vfs: drop mount() prefix argument and layer- path segment

`mount()` no longer accepts an argument. The user-supplied prefix
served no purpose beyond a cosmetic label - actual layer identity comes
from the per-instance `layerId`, so distinct instances never shared a
mount point even when they passed the same prefix. Removing the
argument eliminates the input validation, the escape check for `..`
segments, and the API-shape doubt about what a "logical prefix" means.

The `layer-` prefix on the layer segment of the mount path is likewise
gone: mount points are now `${os.devNull}/vfs/<id>` (for example
`/dev/null/vfs/0`) instead of `${os.devNull}/vfs/layer-0/<prefix>`.
The parser in `getLayerIdFromPath` simplifies to reading the digit
segment immediately after the VFS root.

Docs, tests and benchmark adapted. The dispatch benchmark still
reports flat per-call latency across 1..10 mounted layers.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

benchmark/vfs/bench-fs-dispatch.js

@@ -35,7 +35,7 @@ function mountLayers(count) {
   const handles = [];
   for (let i = 0; i < count; i++) {
     const v = vfs.create();
-    v.mount('/bench');
+    v.mount();
     handles.push(v);
   }
   return handles;

doc/api/vfs.md

@@ -63,7 +63,7 @@ shape of the [`node:fs`][] API. All paths are POSIX-style and absolute
 
 By default, the file tree is private to the VFS instance. To expose
 it through the global `node:fs` module, `require()`, and `import`,
-call [`vfs.mount(prefix)`][]; call [`vfs.unmount()`][] (or rely on a
+call [`vfs.mount()`][]; call [`vfs.unmount()`][] (or rely on a
 `using` declaration) to detach again.
 
 ## `vfs.create([provider][, options])`
@@ -112,15 +112,12 @@ added: v26.4.0
   * `emitExperimentalWarning` {boolean} Whether to emit the experimental
     warning. **Default:** `true`.
 
-### `vfs.mount([prefix])`
+### `vfs.mount()`
 
 <!-- YAML
 added: REPLACEME
 -->
 
-* `prefix` {string} A logical name for the mount inside the reserved
-  VFS namespace. Interpreted as a relative path; leading separators
-  are ignored. **Default:** `'/'`.
 * Returns: {string} The absolute mount point.
 
 Mounts the virtual file system and returns the resulting mount point.
@@ -129,33 +126,30 @@ After mounting, files in the VFS can be accessed through the
 using paths under the returned mount point.
 
 Mount points always live inside a reserved namespace,
-`${os.devNull}/vfs/layer-<layerId>/`. Because [`os.devNull`][] is a
+`${os.devNull}/vfs/<layerId>`. Because [`os.devNull`][] is a
 character device (POSIX) or a device-namespace path (Windows) that
 cannot have child file system entries, no real file-system path can
 exist under this namespace: virtual paths never conflate with (or
 shadow) real paths, and the layer that owns a path is visible in the
-path itself. The `prefix` argument is a purely logical name inside
-the namespace. It is never resolved against the working directory,
-and a prefix that attempts to escape the namespace (for example with
-`..` segments) throws `ERR_INVALID_ARG_VALUE`.
+path itself.
 
 ```cjs
 const vfs = require('node:vfs');
 const fs = require('node:fs');
 
 const myVfs = vfs.create();
 myVfs.writeFileSync('/data.txt', 'Hello');
-const mountPoint = myVfs.mount('/virtual');
-// e.g. '/dev/null/vfs/layer-0/virtual'
+const mountPoint = myVfs.mount();
+// e.g. '/dev/null/vfs/0'
 
 fs.readFileSync(`${mountPoint}/data.txt`, 'utf8'); // 'Hello'
 ```
 
 Each `VirtualFileSystem` instance may be mounted at most once at a
 time. Attempting to mount an already-mounted instance throws
 `ERR_INVALID_STATE`. Because each instance mounts inside its own
-`layer-<layerId>` namespace, mounts from different instances can
-never overlap, even when they use the same `prefix`.
+per-layer namespace, mounts from different instances can never
+overlap.
 
 The VFS supports the [Explicit Resource Management][] proposal. Use
 a `using` declaration to unmount automatically when leaving scope:
@@ -168,7 +162,7 @@ let mountPoint;
 {
   using myVfs = vfs.create();
   myVfs.writeFileSync('/data.txt', 'Hello');
-  mountPoint = myVfs.mount('/virtual');
+  mountPoint = myVfs.mount();
 
   fs.readFileSync(`${mountPoint}/data.txt`, 'utf8'); // 'Hello'
 } // VFS is automatically unmounted here
@@ -184,8 +178,7 @@ added: REPLACEME
 
 Unmounts the virtual file system. After unmounting, virtual files
 are no longer reachable through `node:fs`, `require()`, or `import`.
-The same instance may be mounted again, at the same or a different
-prefix, by calling `mount()`.
+The same instance may be mounted again by calling `mount()`.
 
 This method is idempotent: calling `unmount()` on a VFS that is not
 currently mounted has no effect.
@@ -209,7 +202,7 @@ added: REPLACEME
 * {string | null}
 
 The current mount point as an absolute string (the value returned by
-the last [`vfs.mount(prefix)`][] call), or `null` when the VFS is not
+the last [`vfs.mount()`][] call), or `null` when the VFS is not
 mounted.
 
 ### `vfs.layerId`
@@ -225,7 +218,7 @@ construction. The id is stable across `mount()` / `unmount()` cycles
 for the lifetime of the instance, and is independent of the order in
 which VFS layers are mounted.
 
-The layer id forms the `layer-<id>` segment of the reserved mount
+The layer id forms the `<id>` segment of the reserved mount
 namespace, so every path served by this instance carries the id, and
 it appears in the `NODE_DEBUG=vfs` output for `register` and
 `deregister` events.
@@ -346,7 +339,7 @@ myVfs.mkdirSync('/lib');
 myVfs.writeFileSync('/lib/greet.js', 'module.exports = () => "hi";');
 myVfs.writeFileSync(
   '/lib/package.json', '{"main": "./greet.js"}');
-const mountPoint = myVfs.mount('/virtual');
+const mountPoint = myVfs.mount();
 
 const greet = require(`${mountPoint}/lib`);
 console.log(greet()); // 'hi'
@@ -364,7 +357,7 @@ import vfs from 'node:vfs';
 
 const myVfs = vfs.create();
 myVfs.writeFileSync('/mod.mjs', 'export const value = 42;');
-const mountPoint = myVfs.mount('/virtual');
+const mountPoint = myVfs.mount();
 
 const { value } = await import(
   pathToFileURL(`${mountPoint}/mod.mjs`).href,
@@ -524,5 +517,5 @@ fields use synthetic but stable values:
 [`fs.Stats`]: fs.md#class-fsstats
 [`node:fs`]: fs.md
 [`os.devNull`]: os.md#osdevnull
-[`vfs.mount(prefix)`]: #vfsmountprefix
+[`vfs.mount()`]: #vfsmount
 [`vfs.unmount()`]: #vfsunmount

lib/internal/vfs/file_system.js

@@ -9,14 +9,13 @@ const {
 
 const {
   codes: {
-    ERR_INVALID_ARG_VALUE,
     ERR_INVALID_STATE,
   },
 } = require('internal/errors');
-const { validateBoolean, validateString } = require('internal/validators');
+const { validateBoolean } = require('internal/validators');
 const { MemoryProvider } = require('internal/vfs/providers/memory');
 const path = require('path');
-const { posix: pathPosix, join: platformJoin, resolve: resolvePath, toNamespacedPath } = path;
+const { posix: pathPosix, resolve: resolvePath, toNamespacedPath } = path;
 const { join: joinPath } = pathPosix;
 const {
   getLayerRoot,
@@ -169,37 +168,22 @@ class VirtualFileSystem {
   // ==================== Mount ====================
 
   /**
-   * Mounts the VFS inside this instance's reserved namespace and
-   * returns the resulting mount point. The mount point always lives
-   * under `${os.devNull}/vfs/layer-<layerId>/` - a location that
-   * cannot exist on the real file system (`os.devNull` is a
-   * character device on POSIX and a device-namespace path on Windows;
-   * neither can have child filesystem entries) - so virtual paths
-   * never conflate with real paths and the owning layer is decidable
-   * from the path alone.
-   * @param {string} [prefix] Logical prefix appended to the reserved
-   *   namespace. Interpreted as a relative path inside the namespace;
-   *   leading separators are ignored.
+   * Mounts the VFS at its reserved mount point and returns that
+   * mount point. The mount point is `${os.devNull}/vfs/<layerId>` -
+   * a location that cannot exist on the real file system (`os.devNull`
+   * is a character device on POSIX and a device-namespace path on
+   * Windows; neither can have child filesystem entries) - so virtual
+   * paths never conflate with real paths, and the owning layer of any
+   * path is decidable from the path alone.
    * @returns {string} The absolute mount point
    */
-  mount(prefix = '/') {
+  mount() {
     if (this[kMounted]) {
       throw new ERR_INVALID_STATE('VFS is already mounted');
     }
-    validateString(prefix, 'prefix');
-    const layerRoot = getLayerRoot(this[kLayerId]);
-    // platformJoin treats an absolute prefix as relative to layerRoot;
-    // resolvePath drops any trailing separator (e.g. for prefix '/').
-    // The containment check rejects '..' segments escaping the
-    // reserved namespace.
-    const mountPoint = resolvePath(platformJoin(layerRoot, prefix));
-    const normalized = normalizeMountedPath(mountPoint);
-    if (!isUnderMountPoint(normalized, normalizeMountedPath(layerRoot))) {
-      throw new ERR_INVALID_ARG_VALUE(
-        'prefix', prefix, 'must not escape the VFS namespace');
-    }
+    const mountPoint = getLayerRoot(this[kLayerId]);
     this[kMountPoint] = mountPoint;
-    this[kNormalizedMountPoint] = normalized;
+    this[kNormalizedMountPoint] = normalizeMountedPath(mountPoint);
     this[kMounted] = true;
     debug('mount %s', mountPoint);
     loadVfsSetup();

lib/internal/vfs/router.js

@@ -9,7 +9,7 @@ const {
 
 const { isAbsolute, relative, resolve, sep, toNamespacedPath } = require('path');
 
-// All VFS mount points live under `${os.devNull}/vfs/layer-<id>/`.
+// All VFS mount points live under `${os.devNull}/vfs/<id>/`.
 // `os.devNull` is a character device on POSIX (`/dev/null`) and a
 // device-namespace path on Windows (`\\.\NUL`); neither can have child
 // filesystem entries, so no real file-system path can exist under this
@@ -32,30 +32,26 @@ function getNormalizedVfsRoot() {
 }
 
 /**
- * Returns the reserved namespace root for a VFS layer:
- * `${os.devNull}/vfs/layer-<id>`.
+ * Returns the reserved mount point for a VFS layer:
+ * `${os.devNull}/vfs/<id>`.
  * @param {number} layerId
  * @returns {string}
  */
 function getLayerRoot(layerId) {
-  return getVfsRoot() + sep + 'layer-' + layerId;
+  return getVfsRoot() + sep + layerId;
 }
 
 /**
  * Extracts the layer id from a normalized path under the VFS root, or
- * returns -1 when the path does not carry a well-formed
- * `.../vfs/layer-<id>` segment. The caller must have verified that
- * `normalizedPath` starts with the normalized VFS root.
+ * returns -1 when the path does not carry a well-formed `.../vfs/<id>`
+ * segment. The caller must have verified that `normalizedPath` starts
+ * with the normalized VFS root plus a separator.
  * @param {string} normalizedPath
  * @returns {number}
  */
 function getLayerIdFromPath(normalizedPath) {
-  // Skip '<root><sep>layer-'.
-  const start = getNormalizedVfsRoot().length + 7;
-  if (!StringPrototypeStartsWith(normalizedPath, sep + 'layer-',
-                                 getNormalizedVfsRoot().length)) {
-    return -1;
-  }
+  // Skip '<root><sep>'.
+  const start = getNormalizedVfsRoot().length + 1;
   let id = 0;
   let i = start;
   const len = normalizedPath.length;
@@ -66,7 +62,7 @@ function getLayerIdFromPath(normalizedPath) {
     if (c < 48 || c > 57) return -1; // not a digit
     id = id * 10 + (c - 48);
   }
-  if (i === start) return -1; // 'layer-' with no digits
+  if (i === start) return -1; // no digits at all
   return id;
 }
 

lib/internal/vfs/setup.js

@@ -87,7 +87,7 @@ function writeFileSyncFd(fd, data, options) {
 }
 
 // Registry of active VFS instances, keyed by layer id. Because every
-// mount point embeds its layer id (`${os.devNull}/vfs/layer-<id>/...`),
+// mount point embeds its layer id (`${os.devNull}/vfs/<id>`),
 // dispatch is a map lookup rather than a scan of mounted layers.
 const activeVFSLayers = new SafeMap();
 
@@ -128,7 +128,7 @@ function deregisterVFS(vfs) {
 /**
  * Resolves a path string to the active VFS that owns it, or null.
  * Ownership is decidable from the path alone: all mount points live
- * under the reserved `${os.devNull}/vfs/layer-<id>/` namespace,
+ * under the reserved `${os.devNull}/vfs/<id>` namespace,
  * so a single prefix comparison rejects every real-file-system path
  * and a map lookup finds the owning layer.
  * @param {string} inputPath

test/parallel/test-vfs-destructuring.js

@@ -24,9 +24,9 @@ myVfs.writeFileSync('/file.txt', 'hello from vfs');
 myVfs.writeFileSync('/sub/nested.txt', 'nested content');
 
 // mount() returns the actual mount point (under os.devNull/vfs/...);
-// '/vfs_destr' is just a logical label. The returned path is already in the
-// platform's native form, so assertion targets are built from it directly.
-const MOUNT = myVfs.mount('/vfs_destr');
+// the returned path is already in the platform's native form, so assertion
+// targets are built from it directly.
+const MOUNT = myVfs.mount();
 const FILE = path.join(MOUNT, 'file.txt');
 
 {

test/parallel/test-vfs-fs-accessSync.js

@@ -12,7 +12,7 @@ const vfs = require('node:vfs');
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-const mountPoint = myVfs.mount('/accessSync');
+const mountPoint = myVfs.mount();
 
 // Existing path succeeds
 fs.accessSync(path.join(mountPoint, 'src/hello.txt'));

test/parallel/test-vfs-fs-callback-error-paths.js

@@ -13,7 +13,7 @@ function mounted() {
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
-  const mountPoint = myVfs.mount('/m');
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 

test/parallel/test-vfs-fs-chmod-callback.js

@@ -12,7 +12,7 @@ const vfs = require('node:vfs');
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-const mountPoint = myVfs.mount('/chmod-cb');
+const mountPoint = myVfs.mount();
 
 const target = path.join(mountPoint, 'src/hello.txt');
 const uid = process.getuid?.() ?? 0;

test/parallel/test-vfs-fs-chmodSync.js

@@ -13,7 +13,7 @@ const vfs = require('node:vfs');
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-const mountPoint = myVfs.mount('/chmodSync');
+const mountPoint = myVfs.mount();
 
 const target = path.join(mountPoint, 'src/hello.txt');
 const uid = process.getuid?.() ?? 0;