vfs: report host paths as readdir parentPath

A recursive `readdirSync()` joined each entry's subdirectory onto the
listed path with `path.posix.join()`, so on Windows `parentPath` mixed
separators (`\.\nul\vfs\0/dir`). The callback and promise `readdir()`
did not rewrite `parentPath` at all, returning the provider-relative
`/`, and left recursive names such as `dir/file.txt` unsplit.

Rewrite the Dirents of all three in one place, joining with the host's
separator for a mounted VFS, as fs does, and keeping POSIX paths for an
unmounted one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: pipobscure

lib/internal/vfs/file_system.js

@@ -4,6 +4,8 @@ const {
   MathRandom,
   ObjectFreeze,
   StringPrototypeIncludes,
+  StringPrototypeLastIndexOf,
+  StringPrototypeSlice,
   StringPrototypeStartsWith,
   Symbol,
   SymbolDispose,
@@ -379,28 +381,36 @@ class VirtualFileSystem {
   readdirSync(dirPath, options) {
     const providerPath = this.#toProviderPath(dirPath);
     const result = this[kProvider].readdirSync(providerPath, options);
+    return this.#toMountedDirents(dirPath, result, options);
+  }
 
-    // Rewrite Dirent parentPath from provider-relative to VFS path.
-    if (options?.withFileTypes === true) {
-      const recursive = options?.recursive === true;
-      for (let i = 0; i < result.length; i++) {
-        const dirent = result[i];
-        if (recursive) {
-          // In recursive mode, name may contain slashes (e.g. 'a/b.txt').
-          const slashIdx = dirent.name.lastIndexOf('/');
-          if (slashIdx !== -1) {
-            const subdir = dirent.name.slice(0, slashIdx);
-            dirent.parentPath = joinPath(dirPath, subdir);
-            dirent.name = dirent.name.slice(slashIdx + 1);
-          } else {
-            dirent.parentPath = dirPath;
-          }
-        } else {
-          dirent.parentPath = dirPath;
+  /**
+   * Rewrites the Dirents of a listing of `dirPath` from provider-relative to
+   * VFS paths, so that each `parentPath` is the directory the entry is in.
+   * @param {string} dirPath The listed directory, as given by the caller
+   * @param {string[]|Dirent[]} result The provider's listing
+   * @param {object} [options] The readdir options
+   * @returns {string[]|Dirent[]}
+   */
+  #toMountedDirents(dirPath, result, options) {
+    if (options?.withFileTypes !== true) return result;
+    const recursive = options?.recursive === true;
+    // A mounted VFS is addressed by host paths, so, like fs, join with the
+    // host's separator; an unmounted one uses POSIX paths throughout.
+    const join = this[kMounted] ? path.join : joinPath;
+    for (let i = 0; i < result.length; i++) {
+      const dirent = result[i];
+      dirent.parentPath = dirPath;
+      if (recursive) {
+        // In recursive mode, name may contain slashes (e.g. 'a/b.txt').
+        const slashIdx = StringPrototypeLastIndexOf(dirent.name, '/');
+        if (slashIdx !== -1) {
+          const subdir = StringPrototypeSlice(dirent.name, 0, slashIdx);
+          dirent.parentPath = join(dirPath, subdir);
+          dirent.name = StringPrototypeSlice(dirent.name, slashIdx + 1);
         }
       }
     }
-
     return result;
   }
 
@@ -813,7 +823,8 @@ class VirtualFileSystem {
     }
 
     this[kProvider].readdir(this.#toProviderPath(dirPath), options)
-      .then((entries) => callback(null, entries), (err) => callback(err));
+      .then((entries) => callback(null, this.#toMountedDirents(dirPath, entries, options)),
+            (err) => callback(err));
   }
 
   /**
@@ -1173,6 +1184,8 @@ class VirtualFileSystem {
     const toProviderPath = (p) => this.#toProviderPath(p);
     const toProviderPrefix = (p) => this.#toProviderPrefix(p);
     const toMountedPath = (p) => this.#toMountedPath(p);
+    const toMountedDirents = (p, result, options) =>
+      this.#toMountedDirents(p, result, options);
 
     return ObjectFreeze({
       async readFile(filePath, options) {
@@ -1202,7 +1215,8 @@ class VirtualFileSystem {
 
       async readdir(dirPath, options) {
         const providerPath = toProviderPath(dirPath);
-        return provider.readdir(providerPath, options);
+        const result = await provider.readdir(providerPath, options);
+        return toMountedDirents(dirPath, result, options);
       },
 
       async mkdir(dirPath, options) {

test/parallel/test-vfs-reserved-root.js

@@ -75,10 +75,20 @@ const linkB = path.join(root, 'b');
   assert.deepStrictEqual(fs.readdirSync(root, { recursive: true }).sort(),
                          expected.sort());
 
-  const dirents = fs.readdirSync(root, { recursive: true, withFileTypes: true });
-  const file = dirents.find((d) => d.name === 'file.txt' &&
-                                   d.parentPath === path.join(mountA, 'dir'));
-  assert.ok(file?.isFile());
+  // Every API names each entry's directory as a host path.
+  const options = { recursive: true, withFileTypes: true };
+  const check = common.mustCall((dirents) => {
+    const file = dirents.find((d) => d.name === 'file.txt' &&
+                                     d.parentPath === path.join(mountA, 'dir'));
+    assert.ok(file?.isFile());
+    const layer = dirents.find((d) => d.name === idA);
+    assert.strictEqual(layer?.parentPath, root);
+  }, 3);
+  check(fs.readdirSync(root, options));
+  fs.readdir(root, options, common.mustSucceed(check));
+  fs.promises.readdir(root, options).then(common.mustCall((dirents) => {
+    check(dirents);
+  }));
 }
 
 // The root is a directory, and a name is a symbolic link to its layer.