diff --git a/benchmark/vfs/bench-fs-dispatch.js b/benchmark/vfs/bench-fs-dispatch.js
new file mode 100644
index 00000000000000..4dc3a75111b8ae
--- /dev/null
+++ b/benchmark/vfs/bench-fs-dispatch.js
@@ -0,0 +1,56 @@
+'use strict';
+
+// Measures VFS dispatch overhead on fs ops against real-filesystem paths
+// (paths no VFS claims). Layers=0 means the VFS module is never loaded.
+
+const common = require('../common.js');
+const fs = require('fs');
+const path = require('path');
+
+const bench = common.createBenchmark(main, {
+  n: [3e5],
+  op: ['statSync', 'existsSync', 'accessSync', 'readFileSync'],
+  layers: [0, 1, 2, 5, 10],
+}, {
+  flags: ['--experimental-vfs', '--no-warnings'],
+});
+
+function mountLayers(count) {
+  const vfs = require('node:vfs');
+  const handles = [];
+  for (let i = 0; i < count; i++) {
+    const v = vfs.create();
+    v.mount();
+    handles.push(v);
+  }
+  return handles;
+}
+
+function main({ n, op, layers }) {
+  const handles = layers > 0 ? mountLayers(layers) : null;
+
+  const target = layers === 0 ? __filename : path.join(__dirname, path.basename(__filename));
+
+  for (let i = 0; i < 1000; i++) {
+    if (op === 'statSync') fs.statSync(target);
+    else if (op === 'existsSync') fs.existsSync(target);
+    else if (op === 'accessSync') fs.accessSync(target);
+    else fs.readFileSync(target);
+  }
+
+  bench.start();
+  if (op === 'statSync') {
+    for (let i = 0; i < n; i++) fs.statSync(target);
+  } else if (op === 'existsSync') {
+    for (let i = 0; i < n; i++) fs.existsSync(target);
+  } else if (op === 'accessSync') {
+    for (let i = 0; i < n; i++) fs.accessSync(target);
+  } else {
+    for (let i = 0; i < n; i++) fs.readFileSync(target);
+  }
+  bench.end(n);
+
+  if (handles) {
+    for (const v of handles) v.unmount();
+  }
+}
diff --git a/doc/api/vfs.md b/doc/api/vfs.md
index 90b8e9c303125a..b089244f80f0f6 100644
--- a/doc/api/vfs.md
+++ b/doc/api/vfs.md
@@ -61,6 +61,11 @@ callback-based, and promise-based file system methods that mirror the
 shape of the [`node:fs`][] API. All paths are POSIX-style and absolute
 (starting with `/`).
 
+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()`][]; call [`vfs.unmount()`][] (or rely on a
+`using` declaration) to detach again.
+
 ## `vfs.create([provider][, options])`
 
 <!-- YAML
@@ -107,6 +112,99 @@ added: v26.4.0
   * `emitExperimentalWarning` {boolean} Whether to emit the experimental
     warning. **Default:** `true`.
 
+### `vfs.mount()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {string} The absolute mount point.
+
+Mounts the virtual file system and returns the resulting mount point.
+After mounting, files in the VFS can be accessed through the
+`node:fs` module and resolved through `require()` and `import`
+using paths under the returned mount point.
+
+Mount points always live inside a reserved namespace,
+`${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.
+
+```cjs
+const vfs = require('node:vfs');
+const fs = require('node:fs');
+
+const myVfs = vfs.create();
+myVfs.writeFileSync('/data.txt', 'Hello');
+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
+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:
+
+```cjs
+const vfs = require('node:vfs');
+const fs = require('node:fs');
+
+let mountPoint;
+{
+  using myVfs = vfs.create();
+  myVfs.writeFileSync('/data.txt', 'Hello');
+  mountPoint = myVfs.mount();
+
+  fs.readFileSync(`${mountPoint}/data.txt`, 'utf8'); // 'Hello'
+} // VFS is automatically unmounted here
+
+fs.existsSync(`${mountPoint}/data.txt`); // false
+```
+
+### `vfs.unmount()`
+
+<!-- YAML
+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 by calling `mount()`.
+
+This method is idempotent: calling `unmount()` on a VFS that is not
+currently mounted has no effect.
+
+### `vfs.mounted`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+`true` while the VFS is mounted; `false` otherwise.
+
+### `vfs.mountPoint`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string | null}
+
+The current mount point as an absolute string (the value returned by
+the last [`vfs.mount()`][] call), or `null` when the VFS is not
+mounted.
+
 ### `vfs.provider`
 
 <!-- YAML
@@ -195,6 +293,71 @@ The promise namespace mirrors `fs.promises` and includes `readFile`,
 `access`, `rm`, `truncate`, `link`, `mkdtemp`, `chmod`, `chown`, `lchown`,
 `utimes`, `lutimes`, `open`, `lchmod`, and `watch`.
 
+## Module loader integration
+
+Once a `VirtualFileSystem` is mounted, paths under the mount point
+participate in module resolution and loading. Both
+`require()` / `require.resolve()` (CommonJS) and `import` /
+`import.meta.resolve()` (ECMAScript modules) consult the VFS through
+the same toggleable hooks that `node:fs` uses, so files served from
+the VFS are first-class modules: `package.json` is honoured,
+extensionless files are sniffed for Wasm vs. JavaScript, conditional
+`exports` / `imports` work, and so on.
+
+```cjs
+const vfs = require('node:vfs');
+
+const myVfs = vfs.create();
+myVfs.mkdirSync('/lib');
+myVfs.writeFileSync('/lib/greet.js', 'module.exports = () => "hi";');
+myVfs.writeFileSync(
+  '/lib/package.json', '{"main": "./greet.js"}');
+const mountPoint = myVfs.mount();
+
+const greet = require(`${mountPoint}/lib`);
+console.log(greet()); // 'hi'
+
+myVfs.unmount();
+```
+
+For ECMAScript modules, convert mounted paths to `file:` URLs before
+passing them to dynamic `import()`. This keeps VFS imports portable on
+Windows, where mounted paths use Windows path syntax.
+
+```mjs
+import { pathToFileURL } from 'node:url';
+import vfs from 'node:vfs';
+
+const myVfs = vfs.create();
+myVfs.writeFileSync('/mod.mjs', 'export const value = 42;');
+const mountPoint = myVfs.mount();
+
+const { value } = await import(
+  pathToFileURL(`${mountPoint}/mod.mjs`).href,
+);
+console.log(value); // 42
+
+myVfs.unmount();
+```
+
+Module identity follows the path: `__filename` and `module.filename`
+are the plain absolute path of the module under the mount point, and
+`import.meta.url` is the corresponding `file:` URL, with no synthetic
+decorations. Importing the same virtual path repeatedly, including
+through `import.meta.resolve()`, yields the same module instance,
+exactly as for real files.
+
+Calling [`vfs.unmount()`][] invalidates the modules that were loaded
+from the mount point: a subsequent `require()` or `import` of a path
+under a re-created mount re-reads the file from the newly mounted
+VFS rather than returning a stale module. Modules loaded from other
+VFS instances or from the real file system are unaffected.
+
+Mounting and unmounting do not invalidate ESM modules that are
+already executing. As with any other module-system teardown,
+unmounting a VFS while the import graph below it is still loading is
+the caller's responsibility to avoid.
+
 ## Class: `VirtualProvider`
 
 <!-- YAML
@@ -318,6 +481,7 @@ fields use synthetic but stable values:
 * `blocks` is `Math.ceil(size / 512)`.
 * Times default to the moment the entry was created/last modified.
 
+[Explicit Resource Management]: https://github.com/tc39/proposal-explicit-resource-management
 [`MemoryProvider`]: #class-memoryprovider
 [`RealFSProvider`]: #class-realfsprovider
 [`VirtualFileSystem`]: #class-virtualfilesystem
@@ -325,3 +489,6 @@ fields use synthetic but stable values:
 [`fs.BigIntStats`]: fs.md#class-fsbigintstats
 [`fs.Stats`]: fs.md#class-fsstats
 [`node:fs`]: fs.md
+[`os.devNull`]: os.md#osdevnull
+[`vfs.mount()`]: #vfsmount
+[`vfs.unmount()`]: #vfsunmount
diff --git a/lib/fs.js b/lib/fs.js
index 1ea70ff192d6dd..6f584651a07869 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2044,8 +2044,13 @@ function fstatSync(fd, options = { __proto__: null, bigint: false }) {
 function lstatSync(path, options = { __proto__: null, bigint: false, throwIfNoEntry: true }) {
   const h = vfsState.handlers;
   if (h !== null) {
-    const result = h.lstatSync(path, options);
-    if (result !== undefined) return result;
+    try {
+      const result = h.lstatSync(path, options);
+      if (result !== undefined) return result;
+    } catch (err) {
+      if (err?.code === 'ENOENT' && options?.throwIfNoEntry === false) return;
+      throw err;
+    }
   }
   path = getValidatedPath(path);
   if (permission.isEnabled() && !permission.has('fs.read', path)) {
@@ -2078,8 +2083,13 @@ function lstatSync(path, options = { __proto__: null, bigint: false, throwIfNoEn
 function statSync(path, options = { __proto__: null, bigint: false, throwIfNoEntry: true }) {
   const h = vfsState.handlers;
   if (h !== null) {
-    const result = h.statSync(path, options);
-    if (result !== undefined) return result;
+    try {
+      const result = h.statSync(path, options);
+      if (result !== undefined) return result;
+    } catch (err) {
+      if (err?.code === 'ENOENT' && options?.throwIfNoEntry === false) return undefined;
+      throw err;
+    }
   }
   const stats = binding.stat(
     getValidatedPath(path),
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index bb466d0b68d5cb..0a8835547d708d 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -113,6 +113,7 @@ const kFormat = Symbol('kFormat');
 
 // Set first due to cycle with ESM loader functions.
 module.exports = {
+  purgeModuleCachesForPrefix,
   kModuleSource,
   kModuleExport,
   kModuleExportNames,
@@ -155,14 +156,15 @@ const {
 } = internalBinding('contextify');
 
 const assert = require('internal/assert');
-const fs = require('fs');
 const path = require('path');
-const internalFsBinding = internalBinding('fs');
 const { safeGetenv } = internalBinding('credentials');
 const {
+  cleanForVfsPrefix,
   getCjsConditions,
   getCjsConditionsArray,
   initializeCjsConditions,
+  loaderReadFile,
+  loaderStat,
   loadBuiltinModule,
   makeRequireFunction,
   setHasStartedUserCJSExecution,
@@ -278,7 +280,7 @@ function stat(filename) {
     const result = statCache.get(filename);
     if (result !== undefined) { return result; }
   }
-  const result = internalFsBinding.internalModuleStat(filename);
+  const result = loaderStat(filename);
   if (statCache !== null && result >= 0) {
     // Only set cache when `internalModuleStat(filename)` succeeds.
     statCache.set(filename, result);
@@ -286,6 +288,18 @@ function stat(filename) {
   return result;
 }
 
+/**
+ * Drop Module._cache, Module._pathCache and statCache entries under
+ * `mountPoint`. Called when a VFS is unmounted.
+ * @param {string} mountPoint Absolute mount-point path
+ */
+function purgeModuleCachesForPrefix(mountPoint) {
+  cleanForVfsPrefix(Module._cache, mountPoint);
+  // Module._pathCache keys are `request\0parent` tokens; match on value.
+  cleanForVfsPrefix(Module._pathCache, mountPoint, true);
+  if (statCache !== null) { cleanForVfsPrefix(statCache, mountPoint); }
+}
+
 let _stat = stat;
 ObjectDefineProperty(Module, '_stat', {
   __proto__: null,
@@ -1248,7 +1262,7 @@ function defaultLoadImpl(filename, format) {
     case 'module-typescript':
     case 'commonjs-typescript':
     case 'typescript': {
-      return fs.readFileSync(filename, 'utf8');
+      return loaderReadFile(filename, 'utf8');
     }
     case 'builtin':
       return null;
diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js
index 7bc69b3eb5c358..6d5350831fb7ba 100644
--- a/lib/internal/modules/esm/get_format.js
+++ b/lib/internal/modules/esm/get_format.js
@@ -10,7 +10,6 @@ const {
 } = primordials;
 const { getOptionValue } = require('internal/options');
 const { getValidatedPath } = require('internal/fs/utils');
-const fsBindings = internalBinding('fs');
 const { internal: internalConstants } = internalBinding('constants');
 
 const extensionFormatMap = {
@@ -66,7 +65,8 @@ function mimeToFormat(mime) {
  */
 function getFormatOfExtensionlessFile(url) {
   const path = getValidatedPath(url);
-  switch (fsBindings.getFormatOfExtensionlessFile(path)) {
+  const { loaderGetFormatOfExtensionlessFile } = require('internal/modules/helpers');
+  switch (loaderGetFormatOfExtensionlessFile(path)) {
     case internalConstants.EXTENSIONLESS_FORMAT_WASM:
       return 'wasm';
     default:
diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 94879761553e02..65617219dbc0ef 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -9,7 +9,7 @@ const {
 
 const { defaultGetFormat } = require('internal/modules/esm/get_format');
 const { validateAttributes, emitImportAssertionWarning } = require('internal/modules/esm/assert');
-const fs = require('fs');
+const { loaderReadFile } = require('internal/modules/helpers');
 
 const { Buffer: { from: BufferFrom } } = require('buffer');
 
@@ -38,7 +38,7 @@ function getSourceSync(url, context) {
     // behavior - DO NOT depend on the patchability in new code: Node.js
     // internals may stop going through the JavaScript fs module entirely.
     // Prefer module.registerHooks() or other more formal fs hooks released in the future.
-    source = fs.readFileSync(url);
+    source = loaderReadFile(url);
   } else if (protocol === 'data:') {
     const result = dataURLProcessor(url);
     if (result === 'failure') {
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index 3916e79328ed9c..2df36934c7847a 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -9,7 +9,6 @@ const {
   ObjectPrototypeHasOwnProperty,
   RegExpPrototypeExec,
   RegExpPrototypeSymbolReplace,
-  SafeMap,
   SafeSet,
   String,
   StringPrototypeEndsWith,
@@ -23,16 +22,13 @@ const {
   encodeURIComponent,
 } = primordials;
 const assert = require('internal/assert');
-const internalFS = require('internal/fs/utils');
 const { BuiltinModule } = require('internal/bootstrap/realm');
-const fs = require('fs');
 const { getOptionValue } = require('internal/options');
 // Do not eagerly grab .manifest, it may be in TDZ
 const { sep, posix: { relative: relativePosixPath }, resolve, join } = require('path');
 const { URL, pathToFileURL, fileURLToPath, isURL, URLParse } = require('internal/url');
 const { getCWDURL, setOwnProperty, kEmptyObject } = require('internal/util');
 const { canParse: URLCanParse } = internalBinding('url');
-const { legacyMainResolve: FSLegacyMainResolve } = internalBinding('fs');
 const {
   ERR_INPUT_TYPE_NOT_ALLOWED,
   ERR_INVALID_ARG_TYPE,
@@ -49,7 +45,13 @@ const {
 const { defaultGetFormatWithoutErrors } = require('internal/modules/esm/get_format');
 const { getConditionsSet } = require('internal/modules/esm/utils');
 const packageJsonReader = require('internal/modules/package_json_reader');
-const internalFsBinding = internalBinding('fs');
+const {
+  legacyMainResolveExtensions,
+  legacyMainResolveExtensionsIndexes,
+  loaderLegacyMainResolve,
+  loaderStat,
+  toRealPath,
+} = require('internal/modules/helpers');
 
 /**
  * @typedef {import('internal/modules/esm/package_config.js').PackageConfig} PackageConfig
@@ -150,37 +152,6 @@ function emitLegacyIndexDeprecation(url, path, pkgPath, base, main) {
   }
 }
 
-const realpathCache = new SafeMap();
-
-const legacyMainResolveExtensions = [
-  '',
-  '.js',
-  '.json',
-  '.node',
-  '/index.js',
-  '/index.json',
-  '/index.node',
-  './index.js',
-  './index.json',
-  './index.node',
-];
-
-const legacyMainResolveExtensionsIndexes = {
-  // 0-6: when packageConfig.main is defined
-  kResolvedByMain: 0,
-  kResolvedByMainJs: 1,
-  kResolvedByMainJson: 2,
-  kResolvedByMainNode: 3,
-  kResolvedByMainIndexJs: 4,
-  kResolvedByMainIndexJson: 5,
-  kResolvedByMainIndexNode: 6,
-  // 7-9: when packageConfig.main is NOT defined,
-  //      or when the previous case didn't found the file
-  kResolvedByPackageAndJs: 7,
-  kResolvedByPackageAndJson: 8,
-  kResolvedByPackageAndNode: 9,
-};
-
 /**
  * Legacy CommonJS main resolution:
  * 1. let M = pkg_url + (json main field)
@@ -199,7 +170,7 @@ function legacyMainResolve(packageJSONUrl, packageConfig, base) {
 
   const baseStringified = isURL(base) ? base.href : base;
 
-  const resolvedOption = FSLegacyMainResolve(pkgPath, packageConfig.main, baseStringified);
+  const resolvedOption = loaderLegacyMainResolve(pkgPath, packageConfig.main, baseStringified);
 
   const maybeMain = resolvedOption <= legacyMainResolveExtensionsIndexes.kResolvedByMainIndexNode ?
     packageConfig.main || './' : '';
@@ -245,7 +216,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     throw err;
   }
 
-  const stats = internalFsBinding.internalModuleStat(
+  const stats = loaderStat(
     StringPrototypeEndsWith(path, '/') ? StringPrototypeSlice(path, -1) : path,
   );
 
@@ -278,9 +249,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     // behavior - DO NOT depend on the patchability in new code: Node.js
     // internals may stop going through the JavaScript fs module entirely.
     // Prefer module.registerHooks() or other more formal fs hooks released in the future.
-    const real = fs.realpathSync(path, {
-      [internalFS.realpathCacheKey]: realpathCache,
-    });
+    const real = toRealPath(path);
     const { search, hash } = resolved;
     resolved =
         pathToFileURL(real + (StringPrototypeEndsWith(path, sep) ? '/' : ''));
diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js
index 62b8a743942b7a..9fd28713ce22fd 100644
--- a/lib/internal/modules/helpers.js
+++ b/lib/internal/modules/helpers.js
@@ -3,9 +3,13 @@
 const {
   ArrayPrototypeForEach,
   ArrayPrototypePush,
+  MapPrototypeForEach,
+  MapPrototypeGet,
   ObjectDefineProperty,
   ObjectFreeze,
+  ObjectKeys,
   ObjectPrototypeHasOwnProperty,
+  ReflectApply,
   SafeMap,
   SafeSet,
   StringPrototypeCharCodeAt,
@@ -28,7 +32,7 @@ const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
 const assert = require('internal/assert');
 
 const { getOptionValue } = require('internal/options');
-const { setOwnProperty, getLazy } = require('internal/util');
+const { kEmptyObject, setOwnProperty, getLazy } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
 const { emitWarningSync } = require('internal/process/warning');
 const {
@@ -39,13 +43,15 @@ const {
 const lazyTmpdir = getLazy(() => require('os').tmpdir());
 const { join } = path;
 
+const internalFsBinding = internalBinding('fs');
 const { canParse: URLCanParse } = internalBinding('url');
+const modulesBinding = internalBinding('modules');
 const {
   enableCompileCache: _enableCompileCache,
   getCompileCacheDir: _getCompileCacheDir,
   compileCacheStatus: _compileCacheStatus,
   flushCompileCache,
-} = internalBinding('modules');
+} = modulesBinding;
 
 const lazyCJSLoader = getLazy(() => require('internal/modules/cjs/loader'));
 let debug = require('internal/util/debuglog').debuglog('module', (fn) => {
@@ -61,15 +67,121 @@ let debug = require('internal/util/debuglog').debuglog('module', (fn) => {
  * @type {Map<string, string>}
  */
 const realpathCache = new SafeMap();
+
+// Toggleable loader hooks for VFS support. Overrides that return
+// `undefined` fall through to the pinned native implementation.
+const nativeLoaderMethods = {
+  stat: (filename) => internalFsBinding.internalModuleStat(filename),
+  readFile: (filename, options) => fs.readFileSync(filename, options),
+  realpath: (requestPath) => fs.realpathSync(requestPath, {
+    [internalFS.realpathCacheKey]: realpathCache,
+  }),
+  legacyMainResolve: (pkgPath, main, base) =>
+    internalFsBinding.legacyMainResolve(pkgPath, main, base),
+  getFormatOfExtensionlessFile: (filePath) =>
+    internalFsBinding.getFormatOfExtensionlessFile(filePath),
+  readPackageJSON: (jsonPath, isESM, base, specifier) =>
+    modulesBinding.readPackageJSON(jsonPath, isESM, base, specifier),
+  getNearestParentPackageJSON: (checkPath) =>
+    modulesBinding.getNearestParentPackageJSON(checkPath),
+  getPackageScopeConfig: (resolved) =>
+    modulesBinding.getPackageScopeConfig(resolved),
+  getPackageType: (url) => modulesBinding.getPackageType(url),
+};
+const loaderOverrides = new SafeMap();
+let hasLoaderOverrides = false;
+
+function wrapLoaderMethod(originalFn) {
+  return function loaderMethodWrapper(...args) {
+    if (hasLoaderOverrides) {
+      const override = MapPrototypeGet(loaderOverrides, originalFn);
+      if (override !== undefined) {
+        const result = ReflectApply(override, undefined, args);
+        if (result !== undefined) { return result; }
+      }
+    }
+    return ReflectApply(originalFn, undefined, args);
+  };
+}
+
+const loaderStat = wrapLoaderMethod(nativeLoaderMethods.stat);
+const loaderReadFile = wrapLoaderMethod(nativeLoaderMethods.readFile);
+const toRealPath = wrapLoaderMethod(nativeLoaderMethods.realpath);
+const loaderLegacyMainResolve = wrapLoaderMethod(nativeLoaderMethods.legacyMainResolve);
+const loaderGetFormatOfExtensionlessFile =
+  wrapLoaderMethod(nativeLoaderMethods.getFormatOfExtensionlessFile);
+const loaderReadPackageJSON = wrapLoaderMethod(nativeLoaderMethods.readPackageJSON);
+const loaderGetNearestParentPackageJSON =
+  wrapLoaderMethod(nativeLoaderMethods.getNearestParentPackageJSON);
+const loaderGetPackageScopeConfig =
+  wrapLoaderMethod(nativeLoaderMethods.getPackageScopeConfig);
+const loaderGetPackageType = wrapLoaderMethod(nativeLoaderMethods.getPackageType);
+
+function setLoaderOverride(key, override) {
+  const originalFn = nativeLoaderMethods[key];
+  if (override) {
+    loaderOverrides.set(originalFn, override);
+  } else {
+    loaderOverrides.delete(originalFn);
+  }
+  hasLoaderOverrides = loaderOverrides.size > 0;
+}
+
 /**
- * Resolves the path of a given `require` specifier, following symlinks.
- * @param {string} requestPath The `require` specifier
- * @returns {string}
+ * Set override functions for the module loader's fs operations.
+ * @param {{ stat?: Function, readFile?: Function, realpath?: Function,
+ *           legacyMainResolve?: Function, getFormatOfExtensionlessFile?: Function }} overrides
  */
-function toRealPath(requestPath) {
-  return fs.realpathSync(requestPath, {
-    [internalFS.realpathCacheKey]: realpathCache,
-  });
+function setLoaderFsOverrides(overrides = kEmptyObject) {
+  setLoaderOverride('stat', overrides.stat);
+  setLoaderOverride('readFile', overrides.readFile);
+  setLoaderOverride('realpath', overrides.realpath);
+  setLoaderOverride('legacyMainResolve', overrides.legacyMainResolve);
+  setLoaderOverride('getFormatOfExtensionlessFile', overrides.getFormatOfExtensionlessFile);
+}
+
+/**
+ * Set override functions for the module loader's package.json operations.
+ * @param {{
+ *   readPackageJSON?: Function,
+ *   getNearestParentPackageJSON?: Function,
+ *   getPackageScopeConfig?: Function,
+ *   getPackageType?: Function,
+ * }} overrides
+ */
+function setLoaderPackageOverrides(overrides = kEmptyObject) {
+  setLoaderOverride('readPackageJSON', overrides.readPackageJSON);
+  setLoaderOverride('getNearestParentPackageJSON', overrides.getNearestParentPackageJSON);
+  setLoaderOverride('getPackageScopeConfig', overrides.getPackageScopeConfig);
+  setLoaderOverride('getPackageType', overrides.getPackageType);
+}
+
+/**
+ * Delete every entry in `cache` whose owned string is under `mountPoint`.
+ * `byValue: true` tests the entry value instead of the key (used for
+ * Module._pathCache whose keys are `request\0parent` tokens).
+ * @param {object|Map<string, *>} cache
+ * @param {string} mountPoint Absolute mount-point path
+ * @param {boolean} [byValue] Test the entry value instead of the key
+ */
+function cleanForVfsPrefix(cache, mountPoint, byValue = false) {
+  const prefix = mountPoint + path.sep;
+  const owns = (s) =>
+    typeof s === 'string' &&
+    (s === mountPoint || StringPrototypeStartsWith(s, prefix));
+  if (typeof cache.forEach === 'function') {
+    MapPrototypeForEach(cache, (v, k) => {
+      if (owns(byValue ? v : k)) { cache.delete(k); }
+    });
+  } else {
+    ArrayPrototypeForEach(ObjectKeys(cache), (k) => {
+      if (owns(byValue ? cache[k] : k)) { delete cache[k]; }
+    });
+  }
+}
+
+function purgeRealpathCacheForPrefix(mountPoint) {
+  cleanForVfsPrefix(realpathCache, mountPoint);
 }
 
 /** @type {Set<string>} */
@@ -529,9 +641,41 @@ function getRequireStack(parent) {
   return requireStack;
 }
 
+// Suffixes tried by legacy CommonJS `main` resolution; indexes match
+// the values returned by the `legacyMainResolve` C++ binding.
+const legacyMainResolveExtensions = [
+  '',
+  '.js',
+  '.json',
+  '.node',
+  '/index.js',
+  '/index.json',
+  '/index.node',
+  './index.js',
+  './index.json',
+  './index.node',
+];
+
+const legacyMainResolveExtensionsIndexes = {
+  // 0-6: when packageConfig.main is defined
+  kResolvedByMain: 0,
+  kResolvedByMainJs: 1,
+  kResolvedByMainJson: 2,
+  kResolvedByMainNode: 3,
+  kResolvedByMainIndexJs: 4,
+  kResolvedByMainIndexJson: 5,
+  kResolvedByMainIndexNode: 6,
+  // 7-9: when packageConfig.main is not defined
+  kResolvedByPackageAndJs: 7,
+  kResolvedByPackageAndJson: 8,
+  kResolvedByPackageAndNode: 9,
+};
+
 module.exports = {
   addBuiltinLibsToObject,
   assertBufferSource,
+  cleanForVfsPrefix,
+  purgeRealpathCacheForPrefix,
   constants,
   enableCompileCache,
   flushCompileCache,
@@ -540,10 +684,22 @@ module.exports = {
   getCjsConditionsArray,
   getCompileCacheDir,
   initializeCjsConditions,
+  legacyMainResolveExtensions,
+  legacyMainResolveExtensionsIndexes,
+  loaderGetFormatOfExtensionlessFile,
+  loaderGetNearestParentPackageJSON,
+  loaderGetPackageScopeConfig,
+  loaderGetPackageType,
+  loaderLegacyMainResolve,
+  loaderReadFile,
+  loaderReadPackageJSON,
+  loaderStat,
   loadBuiltinModuleForEmbedder,
   loadBuiltinModule,
   makeRequireFunction,
   normalizeReferrerURL,
+  setLoaderFsOverrides,
+  setLoaderPackageOverrides,
   stringify,
   stripBOM,
   toRealPath,
diff --git a/lib/internal/modules/package_json_reader.js b/lib/internal/modules/package_json_reader.js
index 6c6bf0383bc338..bf7a07cbc8b957 100644
--- a/lib/internal/modules/package_json_reader.js
+++ b/lib/internal/modules/package_json_reader.js
@@ -24,10 +24,16 @@ const {
   },
 } = require('internal/errors');
 const { kEmptyObject } = require('internal/util');
-const modulesBinding = internalBinding('modules');
 const path = require('path');
 const { validateString } = require('internal/validators');
-const internalFsBinding = internalBinding('fs');
+const {
+  cleanForVfsPrefix,
+  loaderGetNearestParentPackageJSON,
+  loaderGetPackageScopeConfig,
+  loaderGetPackageType,
+  loaderReadPackageJSON,
+  loaderStat,
+} = require('internal/modules/helpers');
 
 
 /**
@@ -122,7 +128,7 @@ const requiresJSONParse = (value) => (value !== undefined && (value[0] === '[' |
 function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
   // This function will be called by both CJS and ESM, so we need to make sure
   // non-null attributes are converted to strings.
-  const parsed = modulesBinding.readPackageJSON(
+  const parsed = loaderReadPackageJSON(
     jsonPath,
     isESM,
     base == null ? undefined : `${base}`,
@@ -170,7 +176,7 @@ function getNearestParentPackageJSON(checkPath) {
     return deserializedPackageJSONCache.get(parentPackageJSONPath);
   }
 
-  const result = modulesBinding.getNearestParentPackageJSON(checkPath);
+  const result = loaderGetNearestParentPackageJSON(checkPath);
   const packageConfig = deserializePackageJSON(checkPath, result);
 
   moduleToParentPackageJSONCache.set(checkPath, packageConfig.path);
@@ -190,7 +196,7 @@ function getNearestParentPackageJSON(checkPath) {
  * @returns {import('typings/internalBinding/modules').PackageConfig} - The package configuration.
  */
 function getPackageScopeConfig(resolved) {
-  const result = modulesBinding.getPackageScopeConfig(`${resolved}`);
+  const result = loaderGetPackageScopeConfig(`${resolved}`);
 
   if (ArrayIsArray(result)) {
     const { data, exists, path } = deserializePackageJSON(`${resolved}`, result);
@@ -219,7 +225,7 @@ function getPackageScopeConfig(resolved) {
  * @returns {string}
  */
 function getPackageType(url) {
-  const type = modulesBinding.getPackageType(`${url}`);
+  const type = loaderGetPackageType(`${url}`);
   return type ?? 'none';
 }
 
@@ -280,7 +286,7 @@ function getPackageJSONURL(specifier, base) {
   let packageJSONPath = fileURLToPath(packageJSONUrl);
   let lastPath;
   do {
-    const stat = internalFsBinding.internalModuleStat(
+    const stat = loaderStat(
       StringPrototypeSlice(packageJSONPath, 0, packageJSONPath.length - 13),
     );
     // Check for !stat.isDirectory()
@@ -353,6 +359,15 @@ function findPackageJSON(specifier, base = 'data:') {
   return pkg?.path;
 }
 
+/**
+ * Drop package.json-cache entries under an unmounted VFS mount point.
+ * @param {string} mountPoint Absolute mount-point path
+ */
+function purgePackageJSONCacheForPrefix(mountPoint) {
+  cleanForVfsPrefix(moduleToParentPackageJSONCache, mountPoint);
+  cleanForVfsPrefix(deserializedPackageJSONCache, mountPoint);
+}
+
 module.exports = {
   read,
   getNearestParentPackageJSON,
@@ -360,4 +375,5 @@ module.exports = {
   getPackageType,
   getPackageJSONURL,
   findPackageJSON,
+  purgePackageJSONCacheForPrefix,
 };
diff --git a/lib/internal/vfs/file_system.js b/lib/internal/vfs/file_system.js
index ae38639582581b..7c808bb725c34f 100644
--- a/lib/internal/vfs/file_system.js
+++ b/lib/internal/vfs/file_system.js
@@ -3,6 +3,7 @@
 const {
   MathRandom,
   ObjectFreeze,
+  StringPrototypeStartsWith,
   Symbol,
   SymbolDispose,
 } = primordials;
@@ -15,10 +16,10 @@ const {
 const { validateBoolean } = require('internal/validators');
 const { MemoryProvider } = require('internal/vfs/providers/memory');
 const path = require('path');
-const { posix: pathPosix, isAbsolute, resolve: resolvePath } = path;
+const { posix: pathPosix, resolve: resolvePath, sep, toNamespacedPath } = path;
 const { join: joinPath } = pathPosix;
 const {
-  isUnderMountPoint,
+  getLayerRoot,
   getRelativePath,
 } = require('internal/vfs/router');
 const {
@@ -38,13 +39,29 @@ let debug = require('internal/util/debuglog').debuglog('vfs', (fn) => {
   debug = fn;
 });
 
-// Private symbols
 const kProvider = Symbol('kProvider');
 const kMountPoint = Symbol('kMountPoint');
+// Cached normalizeMountedPath(kMountPoint) so the hot dispatch path
+// does not recompute toNamespacedPath(resolve(...)) on every fs call.
+const kNormalizedMountPoint = Symbol('kNormalizedMountPoint');
 const kMounted = Symbol('kMounted');
 const kPromises = Symbol('kPromises');
+const kLayerId = Symbol('kLayerId');
+
+let nextLayerId = 0;
+
+/**
+ * Canonical form used for mount-point comparisons: on Windows,
+ * `path.resolve('/x')` yields `C:\x` while loader internals often pass
+ * namespaced paths like `\\?\C:\x`; normalizing to the namespaced form
+ * routes POSIX-style, drive-absolute, and namespaced paths to the same mount.
+ * @param {string} inputPath
+ * @returns {string}
+ */
+function normalizeMountedPath(inputPath) {
+  return toNamespacedPath(resolvePath(inputPath));
+}
 
-// Lazy-loaded VFS setup
 let registerVFS;
 let deregisterVFS;
 
@@ -56,11 +73,6 @@ function loadVfsSetup() {
   }
 }
 
-/**
- * Virtual File System implementation using Provider architecture.
- * Wraps a Provider and exposes an fs-like API operating on
- * provider-relative paths.
- */
 class VirtualFileSystem {
   /**
    * @param {VirtualProvider|object} [providerOrOptions] The provider to use, or options
@@ -68,15 +80,11 @@ class VirtualFileSystem {
    * @param {boolean} [options.emitExperimentalWarning] Emit the experimental warning (default: true)
    */
   constructor(providerOrOptions, options = kEmptyObject) {
-
-    // Handle case where first arg is options object (no provider)
     let provider = null;
     if (providerOrOptions !== undefined && providerOrOptions !== null) {
       if (typeof providerOrOptions.openSync === 'function') {
-        // It's a provider
         provider = providerOrOptions;
       } else if (typeof providerOrOptions === 'object') {
-        // It's options (no provider specified)
         options = providerOrOptions;
         provider = null;
       }
@@ -92,120 +100,84 @@ class VirtualFileSystem {
 
     this[kProvider] = provider ?? new MemoryProvider();
     this[kMountPoint] = null;
+    this[kNormalizedMountPoint] = null;
     this[kMounted] = false;
-    this[kPromises] = null; // Lazy-initialized
+    this[kPromises] = null;
+    this[kLayerId] = nextLayerId++;
   }
 
-  /**
-   * Gets the underlying provider.
-   * @returns {VirtualProvider}
-   */
   get provider() {
     return this[kProvider];
   }
 
-  /**
-   * Gets the mount point path, or null if not mounted.
-   * @returns {string|null}
-   */
   get mountPoint() {
     return this[kMountPoint];
   }
 
-  /**
-   * Returns true if VFS is mounted.
-   * @returns {boolean}
-   */
   get mounted() {
     return this[kMounted];
   }
 
-  /**
-   * Returns true if the provider is read-only.
-   * @returns {boolean}
-   */
   get readonly() {
     return this[kProvider].readonly;
   }
 
-  // ==================== Mount ====================
-
   /**
-   * Mounts the VFS at a specific path prefix.
-   * @param {string} prefix The mount point path
-   * @returns {VirtualFileSystem} The VFS instance for chaining
+   * Mounts at `${os.devNull}/vfs/<layerId>` - a location that cannot
+   * exist on the real filesystem (os.devNull is a character device on
+   * POSIX and a device-namespace path on Windows; neither can have
+   * children), so path ownership 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');
     }
-    this[kMountPoint] = resolvePath(prefix);
+    const mountPoint = getLayerRoot(this[kLayerId]);
+    this[kMountPoint] = mountPoint;
+    this[kNormalizedMountPoint] = normalizeMountedPath(mountPoint);
     this[kMounted] = true;
-    debug('mount %s', this[kMountPoint]);
+    debug('mount %s', mountPoint);
     loadVfsSetup();
     registerVFS(this);
-    return this;
+    return mountPoint;
   }
 
-  /**
-   * Unmounts the VFS.
-   */
   unmount() {
     debug('unmount %s', this[kMountPoint]);
     loadVfsSetup();
     deregisterVFS(this);
     this[kMountPoint] = null;
+    this[kNormalizedMountPoint] = null;
     this[kMounted] = false;
   }
 
-  /**
-   * Disposes of the VFS by unmounting it.
-   * Supports the Explicit Resource Management proposal (using declaration).
-   */
   [SymbolDispose]() {
     if (this[kMounted]) {
       this.unmount();
     }
   }
 
-  /**
-   * Checks if a path should be handled by this VFS.
-   * @param {string} inputPath The path to check (must be absolute & normalized)
-   * @returns {boolean}
-   */
-  shouldHandle(inputPath) {
-    if (!this[kMounted] || !this[kMountPoint]) {
-      return false;
-    }
-    const normalized = isAbsolute(inputPath) ? inputPath : resolvePath(inputPath);
-    return isUnderMountPoint(normalized, this[kMountPoint]);
+  // Caller must have already passed input through normalizeMountedPath.
+  shouldHandleNormalized(normalizedInput) {
+    const mountPoint = this[kNormalizedMountPoint];
+    if (mountPoint === null) return false;
+    if (normalizedInput === mountPoint) return true;
+    return StringPrototypeStartsWith(normalizedInput, mountPoint + sep);
   }
 
-  // ==================== Path Resolution ====================
-
-  /**
-   * Converts an absolute mounted path to a provider-relative POSIX path.
-   * If not mounted, treats the path as already provider-relative.
-   * @param {string} inputPath The path to convert
-   * @returns {string}
-   */
   #toProviderPath(inputPath) {
-    if (this[kMounted] && this[kMountPoint]) {
-      const resolved = isAbsolute(inputPath) ? inputPath : resolvePath(inputPath);
-      if (!isUnderMountPoint(resolved, this[kMountPoint])) {
+    const mountPoint = this[kNormalizedMountPoint];
+    if (mountPoint !== null) {
+      const resolved = normalizeMountedPath(inputPath);
+      if (!this.shouldHandleNormalized(resolved)) {
         throw createENOENT('open', inputPath);
       }
-      return getRelativePath(resolved, this[kMountPoint]);
+      return getRelativePath(resolved, mountPoint);
     }
     return pathPosix.normalize(inputPath);
   }
 
-  /**
-   * Converts a provider-relative path back to a mounted path.
-   * If not mounted, returns the path as-is.
-   * @param {string} providerPath The provider-relative path
-   * @returns {string} The mounted path
-   */
   #toMountedPath(providerPath) {
     if (this[kMounted] && this[kMountPoint]) {
       return path.join(this[kMountPoint], providerPath);
@@ -213,13 +185,6 @@ class VirtualFileSystem {
     return providerPath;
   }
 
-  // ==================== FS Operations (Sync) ====================
-
-  /**
-   * Checks if a path exists synchronously.
-   * @param {string} filePath The path to check
-   * @returns {boolean}
-   */
   existsSync(filePath) {
     try {
       const providerPath = this.#toProviderPath(filePath);
@@ -229,79 +194,42 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Gets stats for a path synchronously.
-   * @param {string} filePath The path to stat
-   * @param {object} [options] Options
-   * @returns {Stats}
-   */
   statSync(filePath, options) {
     const providerPath = this.#toProviderPath(filePath);
     return this[kProvider].statSync(providerPath, options);
   }
 
-  /**
-   * Gets stats for a path synchronously without following symlinks.
-   * @param {string} filePath The path to stat
-   * @param {object} [options] Options
-   * @returns {Stats}
-   */
   lstatSync(filePath, options) {
     const providerPath = this.#toProviderPath(filePath);
     return this[kProvider].lstatSync(providerPath, options);
   }
 
-  /**
-   * Reads a file synchronously.
-   * @param {string} filePath The path to read
-   * @param {object|string} [options] Options or encoding
-   * @returns {Buffer|string}
-   */
   readFileSync(filePath, options) {
     const providerPath = this.#toProviderPath(filePath);
     return this[kProvider].readFileSync(providerPath, options);
   }
 
-  /**
-   * Writes a file synchronously.
-   * @param {string} filePath The path to write
-   * @param {Buffer|string} data The data to write
-   * @param {object} [options] Options
-   */
   writeFileSync(filePath, data, options) {
     const providerPath = this.#toProviderPath(filePath);
     this[kProvider].writeFileSync(providerPath, data, options);
   }
 
-  /**
-   * Appends to a file synchronously.
-   * @param {string} filePath The path to append to
-   * @param {Buffer|string} data The data to append
-   * @param {object} [options] Options
-   */
   appendFileSync(filePath, data, options) {
     const providerPath = this.#toProviderPath(filePath);
     this[kProvider].appendFileSync(providerPath, data, options);
   }
 
-  /**
-   * Reads directory contents synchronously.
-   * @param {string} dirPath The directory path
-   * @param {object} [options] Options
-   * @returns {string[]|Dirent[]}
-   */
   readdirSync(dirPath, options) {
     const providerPath = this.#toProviderPath(dirPath);
     const result = this[kProvider].readdirSync(providerPath, options);
 
-    // Fix Dirent parentPath from provider-relative to actual VFS path
+    // 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').
-          // Fix to basename only and set correct parentPath.
           const slashIdx = dirent.name.lastIndexOf('/');
           if (slashIdx !== -1) {
             const subdir = dirent.name.slice(0, slashIdx);
@@ -319,109 +247,54 @@ class VirtualFileSystem {
     return result;
   }
 
-  /**
-   * Creates a directory synchronously.
-   * @param {string} dirPath The directory path
-   * @param {object} [options] Options
-   * @returns {string|undefined}
-   */
   mkdirSync(dirPath, options) {
     const providerPath = this.#toProviderPath(dirPath);
     return this[kProvider].mkdirSync(providerPath, options);
   }
 
-  /**
-   * Removes a directory synchronously.
-   * @param {string} dirPath The directory path
-   */
   rmdirSync(dirPath) {
     const providerPath = this.#toProviderPath(dirPath);
     this[kProvider].rmdirSync(providerPath);
   }
 
-  /**
-   * Removes a file synchronously.
-   * @param {string} filePath The file path
-   */
   unlinkSync(filePath) {
     const providerPath = this.#toProviderPath(filePath);
     this[kProvider].unlinkSync(providerPath);
   }
 
-  /**
-   * Renames a file or directory synchronously.
-   * @param {string} oldPath The old path
-   * @param {string} newPath The new path
-   */
   renameSync(oldPath, newPath) {
     const oldProviderPath = this.#toProviderPath(oldPath);
     const newProviderPath = this.#toProviderPath(newPath);
     this[kProvider].renameSync(oldProviderPath, newProviderPath);
   }
 
-  /**
-   * Copies a file synchronously.
-   * @param {string} src Source path
-   * @param {string} dest Destination path
-   * @param {number} [mode] Copy mode flags
-   */
   copyFileSync(src, dest, mode) {
     const srcProviderPath = this.#toProviderPath(src);
     const destProviderPath = this.#toProviderPath(dest);
     this[kProvider].copyFileSync(srcProviderPath, destProviderPath, mode);
   }
 
-  /**
-   * Gets the real path by resolving all symlinks.
-   * @param {string} filePath The path
-   * @param {object} [options] Options
-   * @returns {string}
-   */
   realpathSync(filePath, options) {
     const providerPath = this.#toProviderPath(filePath);
     const realProviderPath = this[kProvider].realpathSync(providerPath, options);
     return this.#toMountedPath(realProviderPath);
   }
 
-  /**
-   * Reads the target of a symbolic link.
-   * @param {string} linkPath The symlink path
-   * @param {object} [options] Options
-   * @returns {string}
-   */
   readlinkSync(linkPath, options) {
     const providerPath = this.#toProviderPath(linkPath);
     return this[kProvider].readlinkSync(providerPath, options);
   }
 
-  /**
-   * Creates a symbolic link.
-   * @param {string} target The symlink target
-   * @param {string} path The symlink path
-   * @param {string} [type] The symlink type
-   */
   symlinkSync(target, path, type) {
     const providerPath = this.#toProviderPath(path);
     this[kProvider].symlinkSync(target, providerPath, type);
   }
 
-  /**
-   * Checks file accessibility synchronously.
-   * @param {string} filePath The path to check
-   * @param {number} [mode] Access mode
-   */
   accessSync(filePath, mode) {
     const providerPath = this.#toProviderPath(filePath);
     this[kProvider].accessSync(providerPath, mode);
   }
 
-  /**
-   * Removes a file or directory synchronously.
-   * @param {string} filePath The path to remove
-   * @param {object} [options] Options
-   * @param {boolean} [options.recursive] If true, remove directories recursively
-   * @param {boolean} [options.force] If true, ignore ENOENT errors
-   */
   rmSync(filePath, options) {
     const recursive = options?.recursive === true;
     const force = options?.force === true;
@@ -454,13 +327,6 @@ class VirtualFileSystem {
     }
   }
 
-  // ==================== Additional Sync Operations ====================
-
-  /**
-   * Truncates a file synchronously.
-   * @param {string} filePath The file path
-   * @param {number} [len] The new length
-   */
   truncateSync(filePath, len = 0) {
     if (len < 0) len = 0;
     const providerPath = this.#toProviderPath(filePath);
@@ -472,11 +338,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Truncates a file descriptor synchronously.
-   * @param {number} fd The file descriptor
-   * @param {number} [len] The new length
-   */
   ftruncateSync(fd, len = 0) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -485,11 +346,6 @@ class VirtualFileSystem {
     vfd.entry.truncateSync(len);
   }
 
-  /**
-   * Creates a hard link synchronously.
-   * @param {string} existingPath The existing file path
-   * @param {string} newPath The new link path
-   */
   linkSync(existingPath, newPath) {
     const existingProviderPath = this.#toProviderPath(existingPath);
     const newProviderPath = this.#toProviderPath(newPath);
@@ -516,14 +372,8 @@ class VirtualFileSystem {
     this[kProvider].lutimesSync(providerPath, atime, mtime);
   }
 
-  /**
-   * Creates a unique temporary directory synchronously.
-   * @param {string} prefix The prefix for the temp directory
-   * @returns {string} The full path of the created directory
-   */
   mkdtempSync(prefix) {
     const providerPrefix = this.#toProviderPath(prefix);
-    // Generate random 6-character suffix like Node does
     const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
     let suffix = '';
     for (let i = 0; i < 6; i++) {
@@ -534,12 +384,6 @@ class VirtualFileSystem {
     return this.#toMountedPath(dirPath);
   }
 
-  /**
-   * Opens a directory synchronously.
-   * @param {string} dirPath The directory path
-   * @param {object} [options] Options
-   * @returns {VirtualDir} A directory handle
-   */
   opendirSync(dirPath, options) {
     const entries = this.readdirSync(dirPath, {
       withFileTypes: true,
@@ -548,12 +392,6 @@ class VirtualFileSystem {
     return new VirtualDir(dirPath, entries);
   }
 
-  /**
-   * Opens a file as a Blob.
-   * @param {string} filePath The file path
-   * @param {object} [options] Options
-   * @returns {Blob} The file content as a Blob
-   */
   openAsBlob(filePath, options) {
     const { Blob } = require('buffer');
     const providerPath = this.#toProviderPath(filePath);
@@ -562,25 +400,12 @@ class VirtualFileSystem {
     return new Blob([content], { type });
   }
 
-  // ==================== File Descriptor Operations ====================
-
-  /**
-   * Opens a file synchronously and returns a file descriptor.
-   * @param {string} filePath The path to open
-   * @param {string} [flags] Open flags
-   * @param {number} [mode] File mode
-   * @returns {number} The file descriptor
-   */
   openSync(filePath, flags = 'r', mode) {
     const providerPath = this.#toProviderPath(filePath);
     const handle = this[kProvider].openSync(providerPath, flags, mode);
     return openVirtualFd(handle);
   }
 
-  /**
-   * Closes a file descriptor synchronously.
-   * @param {number} fd The file descriptor
-   */
   closeSync(fd) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -590,15 +415,6 @@ class VirtualFileSystem {
     closeVirtualFd(fd);
   }
 
-  /**
-   * Reads from a file descriptor synchronously.
-   * @param {number} fd The file descriptor
-   * @param {Buffer} buffer The buffer to read into
-   * @param {number} offset The offset in the buffer
-   * @param {number} length The number of bytes to read
-   * @param {number|null} position The position in the file
-   * @returns {number} The number of bytes read
-   */
   readSync(fd, buffer, offset, length, position) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -607,15 +423,6 @@ class VirtualFileSystem {
     return vfd.entry.readSync(buffer, offset, length, position);
   }
 
-  /**
-   * Writes to a file descriptor synchronously.
-   * @param {number} fd The file descriptor
-   * @param {Buffer} buffer The buffer to write from
-   * @param {number} offset The offset in the buffer
-   * @param {number} length The number of bytes to write
-   * @param {number|null} position The position in the file
-   * @returns {number} The number of bytes written
-   */
   writeSync(fd, buffer, offset, length, position) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -624,12 +431,6 @@ class VirtualFileSystem {
     return vfd.entry.writeSync(buffer, offset, length, position);
   }
 
-  /**
-   * Gets file stats from a file descriptor synchronously.
-   * @param {number} fd The file descriptor
-   * @param {object} [options] Options
-   * @returns {Stats}
-   */
   fstatSync(fd, options) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -638,14 +439,6 @@ class VirtualFileSystem {
     return vfd.entry.statSync(options);
   }
 
-  // ==================== FS Operations (Async with Callbacks) ====================
-
-  /**
-   * Reads a file asynchronously.
-   * @param {string} filePath The path to read
-   * @param {object|string|Function} [options] Options, encoding, or callback
-   * @param {Function} [callback] Callback (err, data)
-   */
   readFile(filePath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -656,13 +449,6 @@ class VirtualFileSystem {
       .then((data) => callback(null, data), (err) => callback(err));
   }
 
-  /**
-   * Writes a file asynchronously.
-   * @param {string} filePath The path to write
-   * @param {Buffer|string} data The data to write
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err)
-   */
   writeFile(filePath, data, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -673,12 +459,6 @@ class VirtualFileSystem {
       .then(() => callback(null), (err) => callback(err));
   }
 
-  /**
-   * Gets stats for a path asynchronously.
-   * @param {string} filePath The path to stat
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, stats)
-   */
   stat(filePath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -689,12 +469,6 @@ class VirtualFileSystem {
       .then((stats) => callback(null, stats), (err) => callback(err));
   }
 
-  /**
-   * Gets stats without following symlinks asynchronously.
-   * @param {string} filePath The path to stat
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, stats)
-   */
   lstat(filePath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -705,12 +479,6 @@ class VirtualFileSystem {
       .then((stats) => callback(null, stats), (err) => callback(err));
   }
 
-  /**
-   * Reads directory contents asynchronously.
-   * @param {string} dirPath The directory path
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, entries)
-   */
   readdir(dirPath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -721,12 +489,6 @@ class VirtualFileSystem {
       .then((entries) => callback(null, entries), (err) => callback(err));
   }
 
-  /**
-   * Gets the real path asynchronously.
-   * @param {string} filePath The path
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, resolvedPath)
-   */
   realpath(filePath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -738,12 +500,6 @@ class VirtualFileSystem {
             (err) => callback(err));
   }
 
-  /**
-   * Reads symlink target asynchronously.
-   * @param {string} linkPath The symlink path
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, target)
-   */
   readlink(linkPath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -754,12 +510,6 @@ class VirtualFileSystem {
       .then((target) => callback(null, target), (err) => callback(err));
   }
 
-  /**
-   * Checks file accessibility asynchronously.
-   * @param {string} filePath The path to check
-   * @param {number|Function} [mode] Access mode or callback
-   * @param {Function} [callback] Callback (err)
-   */
   access(filePath, mode, callback) {
     if (typeof mode === 'function') {
       callback = mode;
@@ -770,13 +520,6 @@ class VirtualFileSystem {
       .then(() => callback(null), (err) => callback(err));
   }
 
-  /**
-   * Opens a file asynchronously.
-   * @param {string} filePath The path to open
-   * @param {string|Function} [flags] Open flags or callback
-   * @param {number|Function} [mode] File mode or callback
-   * @param {Function} [callback] Callback (err, fd)
-   */
   open(filePath, flags, mode, callback) {
     if (typeof flags === 'function') {
       callback = flags;
@@ -795,11 +538,6 @@ class VirtualFileSystem {
       }, (err) => callback(err));
   }
 
-  /**
-   * Closes a file descriptor asynchronously.
-   * @param {number} fd The file descriptor
-   * @param {Function} callback Callback (err)
-   */
   close(fd, callback) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -814,15 +552,6 @@ class VirtualFileSystem {
       }, (err) => callback(err));
   }
 
-  /**
-   * Reads from a file descriptor asynchronously.
-   * @param {number} fd The file descriptor
-   * @param {Buffer} buffer The buffer to read into
-   * @param {number} offset The offset in the buffer
-   * @param {number} length The number of bytes to read
-   * @param {number|null} position The position in the file
-   * @param {Function} callback Callback (err, bytesRead, buffer)
-   */
   read(fd, buffer, offset, length, position, callback) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -834,15 +563,6 @@ class VirtualFileSystem {
       .then(({ bytesRead }) => callback(null, bytesRead, buffer), (err) => callback(err));
   }
 
-  /**
-   * Writes to a file descriptor asynchronously.
-   * @param {number} fd The file descriptor
-   * @param {Buffer} buffer The buffer to write from
-   * @param {number} offset The offset in the buffer
-   * @param {number} length The number of bytes to write
-   * @param {number|null} position The position in the file
-   * @param {Function} callback Callback (err, bytesWritten, buffer)
-   */
   write(fd, buffer, offset, length, position, callback) {
     const vfd = getVirtualFd(fd);
     if (!vfd) {
@@ -854,12 +574,6 @@ class VirtualFileSystem {
       .then(({ bytesWritten }) => callback(null, bytesWritten, buffer), (err) => callback(err));
   }
 
-  /**
-   * Removes a file or directory asynchronously.
-   * @param {string} filePath The path to remove
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err)
-   */
   rm(filePath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -873,12 +587,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Gets file stats from a file descriptor asynchronously.
-   * @param {number} fd The file descriptor
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, stats)
-   */
   fstat(fd, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -895,12 +603,6 @@ class VirtualFileSystem {
       .then((stats) => callback(null, stats), (err) => callback(err));
   }
 
-  /**
-   * Truncates a file asynchronously.
-   * @param {string} filePath The file path
-   * @param {number|Function} [len] The new length or callback
-   * @param {Function} [callback] Callback (err)
-   */
   truncate(filePath, len, callback) {
     if (typeof len === 'function') {
       callback = len;
@@ -914,12 +616,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Truncates a file descriptor asynchronously.
-   * @param {number} fd The file descriptor
-   * @param {number|Function} [len] The new length or callback
-   * @param {Function} [callback] Callback (err)
-   */
   ftruncate(fd, len, callback) {
     if (typeof len === 'function') {
       callback = len;
@@ -933,12 +629,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Creates a hard link asynchronously.
-   * @param {string} existingPath The existing file path
-   * @param {string} newPath The new link path
-   * @param {Function} callback Callback (err)
-   */
   link(existingPath, newPath, callback) {
     try {
       this.linkSync(existingPath, newPath);
@@ -948,12 +638,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Creates a unique temporary directory asynchronously.
-   * @param {string} prefix The prefix for the temp directory
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, dirPath)
-   */
   mkdtemp(prefix, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -967,12 +651,6 @@ class VirtualFileSystem {
     }
   }
 
-  /**
-   * Opens a directory asynchronously.
-   * @param {string} dirPath The directory path
-   * @param {object|Function} [options] Options or callback
-   * @param {Function} [callback] Callback (err, dir)
-   */
   opendir(dirPath, options, callback) {
     if (typeof options === 'function') {
       callback = options;
@@ -986,37 +664,14 @@ class VirtualFileSystem {
     }
   }
 
-  // ==================== Stream Operations ====================
-
-  /**
-   * Creates a readable stream for a virtual file.
-   * @param {string} filePath The path to the file
-   * @param {object} [options] Stream options
-   * @returns {ReadStream}
-   */
   createReadStream(filePath, options) {
     return new VirtualReadStream(this, filePath, options);
   }
 
-  /**
-   * Creates a writable stream for a virtual file.
-   * @param {string} filePath The path to the file
-   * @param {object} [options] Stream options
-   * @returns {WriteStream}
-   */
   createWriteStream(filePath, options) {
     return new VirtualWriteStream(this, filePath, options);
   }
 
-  // ==================== Watch Operations ====================
-
-  /**
-   * Watches a file or directory for changes.
-   * @param {string} filePath The path to watch
-   * @param {object|Function} [options] Watch options or listener
-   * @param {Function} [listener] Change listener
-   * @returns {EventEmitter} A watcher that emits 'change' events
-   */
   watch(filePath, options, listener) {
     if (typeof options === 'function') {
       listener = options;
@@ -1033,13 +688,6 @@ class VirtualFileSystem {
     return watcher;
   }
 
-  /**
-   * Watches a file for changes using stat polling.
-   * @param {string} filePath The path to watch
-   * @param {object|Function} [options] Watch options or listener
-   * @param {Function} [listener] Change listener
-   * @returns {EventEmitter} A stat watcher that emits 'change' events
-   */
   watchFile(filePath, options, listener) {
     if (typeof options === 'function') {
       listener = options;
@@ -1050,22 +698,11 @@ class VirtualFileSystem {
     return this[kProvider].watchFile(providerPath, options, listener);
   }
 
-  /**
-   * Stops watching a file for changes.
-   * @param {string} filePath The path to stop watching
-   * @param {Function} [listener] Optional listener to remove
-   */
   unwatchFile(filePath, listener) {
     const providerPath = this.#toProviderPath(filePath);
     this[kProvider].unwatchFile(providerPath, listener);
   }
 
-  // ==================== Promise API ====================
-
-  /**
-   * Gets the promises API for this VFS instance.
-   * @returns {object} Promise-based fs methods
-   */
   get promises() {
     if (this[kPromises] === null) {
       this[kPromises] = this.#createPromisesAPI();
@@ -1073,14 +710,10 @@ class VirtualFileSystem {
     return this[kPromises];
   }
 
-  /**
-   * Creates the promises API object for this VFS instance.
-   * @returns {object} Promise-based fs methods
-   */
   #createPromisesAPI() {
     const provider = this[kProvider];
 
-    // Use arrow function to capture `this` for private method access
+    // Arrow functions capture `this` for private method access.
     const toProviderPath = (p) => this.#toProviderPath(p);
     const toMountedPath = (p) => this.#toMountedPath(p);
 
@@ -1268,4 +901,6 @@ class VirtualFileSystem {
 
 module.exports = {
   VirtualFileSystem,
+  kLayerId,
+  normalizeMountedPath,
 };
diff --git a/lib/internal/vfs/router.js b/lib/internal/vfs/router.js
index b610b271695a3d..0c5209fb502d72 100644
--- a/lib/internal/vfs/router.js
+++ b/lib/internal/vfs/router.js
@@ -2,45 +2,66 @@
 
 const {
   ArrayPrototypeJoin,
+  StringPrototypeCharCodeAt,
   StringPrototypeSplit,
-  StringPrototypeStartsWith,
 } = primordials;
 
-const { isAbsolute, relative, sep } = require('path');
+const { relative, resolve, sep, toNamespacedPath } = require('path');
 
-// `path.sep` is required here because on Windows `path.resolve('/virtual')`
-// produces 'C:\virtual' and all resolved paths use backslashes - a hardcoded
-// '/' check would never match. The trailing-separator guard handles root
-// mount points like 'C:\' so we don't end up with 'C:\\'.
-function isUnderMountPoint(normalizedPath, mountPoint) {
-  if (normalizedPath === mountPoint) {
-    return true;
-  }
-  if (mountPoint === '/') {
-    return StringPrototypeStartsWith(normalizedPath, '/');
+// 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 children, so no real
+// file-system path can exist under this root and path ownership is
+// decidable from the path alone.
+let vfsRoot;
+let normalizedVfsRoot;
+
+function getVfsRoot() {
+  vfsRoot ??= require('os').devNull + sep + 'vfs';
+  return vfsRoot;
+}
+
+function getNormalizedVfsRoot() {
+  normalizedVfsRoot ??= toNamespacedPath(resolve(getVfsRoot()));
+  return normalizedVfsRoot;
+}
+
+function getLayerRoot(layerId) {
+  return getVfsRoot() + sep + layerId;
+}
+
+// Returns -1 when the path does not carry a well-formed `.../vfs/<id>`
+// segment. Caller must have already verified the VFS-root prefix.
+function getLayerIdFromPath(normalizedPath) {
+  const start = getNormalizedVfsRoot().length + 1;
+  let id = 0;
+  let i = start;
+  const len = normalizedPath.length;
+  if (i >= len) return -1;
+  for (; i < len; i++) {
+    const c = StringPrototypeCharCodeAt(normalizedPath, i);
+    if (c === 47 || c === 92) break; // '/' or '\\'
+    if (c < 48 || c > 57) return -1; // not a digit
+    id = id * 10 + (c - 48);
   }
-  const prefix = mountPoint[mountPoint.length - 1] === sep ?
-    mountPoint : mountPoint + sep;
-  return StringPrototypeStartsWith(normalizedPath, prefix);
+  if (i === start) return -1;
+  return id;
 }
 
-// Returns a POSIX-style relative path the provider can consume. Uses
-// `path.relative()` so Windows backslash paths are handled correctly, then
-// re-joins with forward slashes for the provider's internal POSIX format.
+// POSIX-style relative path for the provider. `path.relative()` handles
+// Windows backslashes; we re-join with forward slashes.
 function getRelativePath(normalizedPath, mountPoint) {
   if (normalizedPath === mountPoint) {
     return '/';
   }
-  if (mountPoint === '/') {
-    return normalizedPath;
-  }
   const rel = relative(mountPoint, normalizedPath);
   const segments = StringPrototypeSplit(rel, sep);
   return '/' + ArrayPrototypeJoin(segments, '/');
 }
 
 module.exports = {
-  isUnderMountPoint,
+  getLayerIdFromPath,
+  getLayerRoot,
+  getNormalizedVfsRoot,
   getRelativePath,
-  isAbsolutePath: isAbsolute,
 };
diff --git a/lib/internal/vfs/setup.js b/lib/internal/vfs/setup.js
index e2e641ad841561..231f91d4c78f6c 100644
--- a/lib/internal/vfs/setup.js
+++ b/lib/internal/vfs/setup.js
@@ -1,30 +1,40 @@
 'use strict';
 
 const {
-  ArrayPrototypeIndexOf,
-  ArrayPrototypePush,
-  ArrayPrototypeSplice,
+  ArrayPrototypeForEach,
+  MapPrototypeForEach,
+  ObjectKeys,
   PromiseResolve,
+  SafeMap,
+  String,
+  StringPrototypeEndsWith,
   StringPrototypeStartsWith,
 } = primordials;
 
 const { Buffer } = require('buffer');
 const { isArrayBufferView } = require('internal/util/types');
-const { resolve, sep } = require('path');
-const { fileURLToPath, URL } = require('internal/url');
+const { dirname, join, sep } = require('path');
+const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
 const { validateObject } = require('internal/validators');
 const {
   codes: {
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_STATE,
+    ERR_MODULE_NOT_FOUND,
   },
 } = require('internal/errors');
 const { createENOENT, createEXDEV } = require('internal/vfs/errors');
+const { kLayerId, normalizeMountedPath } = require('internal/vfs/file_system');
+const {
+  getLayerIdFromPath,
+  getNormalizedVfsRoot,
+} = require('internal/vfs/router');
 const { getVirtualFd, closeVirtualFd } = require('internal/vfs/fd');
-const { assertEncoding, vfsState, setVfsHandlers } = require('internal/fs/utils');
+const { assertEncoding, setVfsHandlers } = require('internal/fs/utils');
 const permission = require('internal/process/permission');
 const { getOptionValue } = require('internal/options');
+const nativeModulesBinding = internalBinding('modules');
 let debug = require('internal/util/debuglog').debuglog('vfs', (fn) => {
   debug = fn;
 });
@@ -72,11 +82,12 @@ function writeFileSyncFd(fd, data, options) {
   return true;
 }
 
-// Registry of active VFS instances.
-const activeVFSList = [];
+const activeVFSLayers = new SafeMap();
 
 let hooksInstalled = false;
 let vfsHandlerObj;
+// Lazy: os.devNull may not be available at snapshot time.
+let normalizedVfsRootPrefix = null;
 
 function registerVFS(vfs) {
   if (permission.isEnabled() && !getOptionValue('--allow-fs-vfs')) {
@@ -85,82 +96,167 @@ function registerVFS(vfs) {
       'Use --allow-fs-vfs to allow it.',
     );
   }
-  if (ArrayPrototypeIndexOf(activeVFSList, vfs) !== -1) return;
-
-  const newMount = vfs.mountPoint;
-  if (newMount != null) {
-    for (let i = 0; i < activeVFSList.length; i++) {
-      const existingMount = activeVFSList[i].mountPoint;
-      if (existingMount == null) continue;
-      // Use path.sep so the trailing-separator guard works on Windows where
-      // mountPoint values are resolved to drive-letter / backslash paths.
-      const newPrefix = newMount === sep ? sep : newMount + sep;
-      const existingPrefix = existingMount === sep ? sep : existingMount + sep;
-      if (newMount === existingMount ||
-          StringPrototypeStartsWith(newMount, existingPrefix) ||
-          StringPrototypeStartsWith(existingMount, newPrefix)) {
-        throw new ERR_INVALID_STATE(
-          `VFS mount '${newMount}' overlaps with existing mount '${existingMount}'`,
-        );
-      }
-    }
-  }
-  ArrayPrototypePush(activeVFSList, vfs);
-  debug('register mount=%s active=%d', newMount, activeVFSList.length);
+  if (activeVFSLayers.has(vfs[kLayerId])) return;
+  activeVFSLayers.set(vfs[kLayerId], vfs);
+  debug('register layer=%d mount=%s active=%d',
+        vfs[kLayerId], vfs.mountPoint, activeVFSLayers.size);
   if (!hooksInstalled) {
-    vfsHandlerObj = createVfsHandlers();
-    setVfsHandlers(vfsHandlerObj);
-    hooksInstalled = true;
-  } else if (vfsState.handlers === null) {
-    setVfsHandlers(vfsHandlerObj);
+    installHooks();
   }
 }
 
 function deregisterVFS(vfs) {
-  const index = ArrayPrototypeIndexOf(activeVFSList, vfs);
-  if (index === -1) return;
-  ArrayPrototypeSplice(activeVFSList, index, 1);
-  debug('deregister active=%d', activeVFSList.length);
-  if (activeVFSList.length === 0) {
-    setVfsHandlers(null);
+  if (!activeVFSLayers.delete(vfs[kLayerId])) return;
+  debug('deregister layer=%d active=%d', vfs[kLayerId], activeVFSLayers.size);
+  purgeLoaderCachesForVFS(vfs);
+  if (activeVFSLayers.size === 0) {
+    uninstallHooks();
   }
 }
 
-function findVFSForExists(filename) {
-  const normalized = resolve(filename);
-  for (let i = 0; i < activeVFSList.length; i++) {
-    const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(normalized)) {
-      return { vfs, exists: vfs.existsSync(normalized) };
+/**
+ * @param {string} inputPath
+ * @returns {{ vfs: object, normalized: string }|null}
+ */
+function findVFS(inputPath) {
+  const normalized = normalizeMountedPath(inputPath);
+  if (!StringPrototypeStartsWith(normalized, normalizedVfsRootPrefix)) {
+    return null;
+  }
+  const layerId = getLayerIdFromPath(normalized);
+  if (layerId === -1) return null;
+  const vfs = activeVFSLayers.get(layerId);
+  if (vfs === undefined || !vfs.shouldHandleNormalized(normalized)) {
+    return null;
+  }
+  return { vfs, normalized };
+}
+
+function purgeLoaderCachesForVFS(vfs) {
+  const mountPoint = vfs.mountPoint;
+
+  const cjsLoader = require('internal/modules/cjs/loader');
+  cjsLoader.purgeModuleCachesForPrefix(mountPoint);
+
+  const helpers = require('internal/modules/helpers');
+  helpers.purgeRealpathCacheForPrefix(mountPoint);
+
+  const pkgReader = require('internal/modules/package_json_reader');
+  pkgReader.purgePackageJSONCacheForPrefix(mountPoint);
+
+  const esmLoader = require('internal/modules/esm/loader');
+  if (esmLoader.isCascadedLoaderInitialized()) {
+    const loader = esmLoader.getOrInitializeCascadedLoader();
+    const loadCache = loader.loadCache;
+    const mountURL = pathToFileURL(mountPoint).href;
+    const mountURLPrefix = mountURL + '/';
+    // Iterate via MapPrototypeForEach (not for-of map.keys()) so a
+    // polluted Map iterator can't break the cleanup path.
+    if (loadCache && typeof loadCache.delete === 'function') {
+      MapPrototypeForEach(loadCache, (variants, url) => {
+        if (typeof url === 'string' &&
+            (url === mountURL ||
+             StringPrototypeStartsWith(url, mountURLPrefix)) &&
+            variants) {
+          ArrayPrototypeForEach(ObjectKeys(variants), (type) => {
+            loadCache.delete(url, type);
+          });
+        }
+      });
     }
   }
-  return null;
 }
 
-function findVFSForPath(filename) {
-  const normalized = resolve(filename);
-  for (let i = 0; i < activeVFSList.length; i++) {
-    const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(normalized)) {
-      return { vfs, normalized };
+// Returns 0 for file, 1 for directory, negative errno for errors.
+function vfsStat(vfs, filePath) {
+  try {
+    const stats = vfs.statSync(filePath);
+    if (stats.isDirectory()) return 1;
+    return 0;
+  } catch (err) {
+    if (typeof err?.errno === 'number') return err.errno;
+    throw err;
+  }
+}
+
+function findVFSForStat(filename) {
+  const r = findVFS(filename);
+  if (r === null) return null;
+  return { vfs: r.vfs, result: vfsStat(r.vfs, filename) };
+}
+
+function findVFSForRead(filename, options) {
+  const r = findVFS(filename);
+  if (r === null) return null;
+  try {
+    return { vfs: r.vfs, content: r.vfs.readFileSync(filename, options) };
+  } catch (e) {
+    const code = e?.code;
+    if (code === 'ENOENT' || code === 'EISDIR') {
+      throw createENOENT('open', filename);
     }
+    throw e;
   }
-  return null;
 }
 
-// Sync read: check exists first, fall through to ENOENT for mounted VFS.
-function findVFSWith(filename, syscall, fn) {
-  const normalized = resolve(filename);
-  for (let i = 0; i < activeVFSList.length; i++) {
-    const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(normalized)) {
-      if (vfs.existsSync(normalized)) {
-        return fn(vfs, normalized);
+// Returns `.tuple` with the C++ binding's shape
+// (`[name, main, type, imports, exports, filePath]`) when found,
+// otherwise `.sentinel` is the last checked path - matches the C++
+// binding's getPackageScopeConfig contract.
+function findVFSPackageJSON(vfs, startPath, normalizedStart) {
+  let currentDir = dirname(startPath);
+  let currentNorm = dirname(normalizedStart);
+  let lastDir;
+  let sentinel = join(currentDir, 'package.json');
+  while (currentDir !== lastDir) {
+    if (StringPrototypeEndsWith(currentDir, '/node_modules') ||
+        StringPrototypeEndsWith(currentDir, '\\node_modules')) {
+      break;
+    }
+    if (!vfs.shouldHandleNormalized(currentNorm)) {
+      break;
+    }
+    const pjsonPath = join(currentDir, 'package.json');
+    sentinel = pjsonPath;
+    if (vfsStat(vfs, pjsonPath) === 0) {
+      let content;
+      try {
+        content = vfs.readFileSync(pjsonPath);
+      } catch {
+        content = null;
+      }
+      if (content !== null) {
+        const tuple = nativeModulesBinding.parsePackageJSON(
+          content, pjsonPath);
+        return { vfs, pjsonPath, tuple, sentinel: pjsonPath };
       }
-      throw createENOENT(syscall, filename);
     }
+    lastDir = currentDir;
+    currentDir = dirname(currentDir);
+    currentNorm = dirname(currentNorm);
   }
-  return undefined;
+  return { sentinel };
+}
+
+function findVFSForExists(filename) {
+  const r = findVFS(filename);
+  if (r === null) return null;
+  return { vfs: r.vfs, exists: r.vfs.existsSync(filename) };
+}
+
+function findVFSForPath(filename) {
+  const r = findVFS(filename);
+  if (r === null) return null;
+  return { vfs: r.vfs, path: filename };
+}
+
+function findVFSWith(filename, syscall, fn) {
+  const r = findVFS(filename);
+  if (r === null) return undefined;
+  if (r.vfs.existsSync(filename)) {
+    return fn(r.vfs, filename);
+  }
+  throw createENOENT(syscall, filename);
 }
 
 function vfsRead(path, syscall, fn) {
@@ -173,7 +269,7 @@ function vfsOp(path, fn) {
   const pathStr = toPathStr(path);
   if (pathStr !== null) {
     const r = findVFSForPath(pathStr);
-    if (r !== null) return fn(r.vfs, r.normalized);
+    if (r !== null) return fn(r.vfs, r.path);
   }
   return undefined;
 }
@@ -182,31 +278,21 @@ function vfsOpVoid(path, fn) {
   const pathStr = toPathStr(path);
   if (pathStr !== null) {
     const r = findVFSForPath(pathStr);
-    if (r !== null) { fn(r.vfs, r.normalized); return true; }
+    if (r !== null) { fn(r.vfs, r.path); return true; }
   }
   return undefined;
 }
 
 function checkSameVFS(srcPath, destPath, syscall, srcVfs) {
-  const destNormalized = resolve(destPath);
-  for (let i = 0; i < activeVFSList.length; i++) {
-    const vfs = activeVFSList[i];
-    if (vfs.shouldHandle(destNormalized)) {
-      if (vfs !== srcVfs) {
-        throw createEXDEV(syscall, srcPath);
-      }
-      return;
-    }
+  if (findVFS(destPath)?.vfs !== srcVfs) {
+    throw createEXDEV(syscall, srcPath);
   }
-  throw createEXDEV(syscall, srcPath);
 }
 
 function createVfsHandlers() {
   return {
     __proto__: null,
 
-    // ==================== Sync path-based read ops ====================
-
     existsSync(path) {
       const pathStr = toPathStr(path);
       if (pathStr === null) return undefined;
@@ -241,27 +327,12 @@ function createVfsHandlers() {
     lstatSync(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr === null) return undefined;
-      const normalized = resolve(pathStr);
-      for (let i = 0; i < activeVFSList.length; i++) {
-        const vfs = activeVFSList[i];
-        if (vfs.shouldHandle(normalized)) {
-          try {
-            return vfs.lstatSync(normalized, options);
-          } catch (e) {
-            if (e?.code === 'ENOENT' && options?.throwIfNoEntry === false) return undefined;
-            throw e;
-          }
-        }
-      }
-      return undefined;
+      const r = findVFS(pathStr);
+      if (r === null) return undefined;
+      return r.vfs.lstatSync(pathStr, options);
     },
     statSync(path, options) {
-      try {
-        return vfsRead(path, 'stat', (vfs, n) => vfs.statSync(n, options));
-      } catch (err) {
-        if (err?.code === 'ENOENT' && options?.throwIfNoEntry === false) return undefined;
-        throw err;
-      }
+      return vfsRead(path, 'stat', (vfs, n) => vfs.statSync(n, options));
     },
     realpathSync(path, options) {
       const result = vfsRead(path, 'realpath', (vfs, n) => vfs.realpathSync(n));
@@ -278,7 +349,7 @@ function createVfsHandlers() {
           if (mode != null && typeof mode !== 'number') {
             throw new ERR_INVALID_ARG_TYPE('mode', 'integer', mode);
           }
-          r.vfs.accessSync(r.normalized, mode);
+          r.vfs.accessSync(r.path, mode);
           return true;
         }
       }
@@ -287,16 +358,11 @@ function createVfsHandlers() {
     readlinkSync(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr === null) return undefined;
-      const normalized = resolve(pathStr);
-      for (let i = 0; i < activeVFSList.length; i++) {
-        const vfs = activeVFSList[i];
-        if (vfs.shouldHandle(normalized)) {
-          const result = vfs.readlinkSync(normalized, options);
-          if (options?.encoding === 'buffer') return Buffer.from(result);
-          return result;
-        }
-      }
-      return undefined;
+      const r = findVFS(pathStr);
+      if (r === null) return undefined;
+      const result = r.vfs.readlinkSync(pathStr, options);
+      if (options?.encoding === 'buffer') return Buffer.from(result);
+      return result;
     },
     statfsSync(path, options) {
       const pathStr = toPathStr(path);
@@ -312,8 +378,6 @@ function createVfsHandlers() {
       return undefined;
     },
 
-    // ==================== Sync path-based write ops ====================
-
     writeFileSync(path, data, options) {
       if (typeof path === 'number') return writeFileSyncFd(path, data, options);
       return vfsOpVoid(path, (vfs, n) => vfs.writeFileSync(n, data, options));
@@ -329,14 +393,16 @@ function createVfsHandlers() {
     unlinkSync: (path) => vfsOpVoid(path, (vfs, n) => vfs.unlinkSync(n)),
     renameSync(oldPath, newPath) {
       return vfsOpVoid(oldPath, (vfs, n) => {
-        checkSameVFS(n, toPathStr(newPath), 'rename', vfs);
-        vfs.renameSync(n, resolve(toPathStr(newPath)));
+        const destStr = toPathStr(newPath);
+        checkSameVFS(n, destStr, 'rename', vfs);
+        vfs.renameSync(n, destStr);
       });
     },
     copyFileSync(src, dest, mode) {
       return vfsOpVoid(src, (vfs, n) => {
-        checkSameVFS(n, toPathStr(dest), 'copyfile', vfs);
-        vfs.copyFileSync(n, resolve(toPathStr(dest)), mode);
+        const destStr = toPathStr(dest);
+        checkSameVFS(n, destStr, 'copyfile', vfs);
+        vfs.copyFileSync(n, destStr, mode);
       });
     },
     symlinkSync: (target, path, type) =>
@@ -351,8 +417,9 @@ function createVfsHandlers() {
     truncateSync: (path, len) => vfsOpVoid(path, (vfs, n) => vfs.truncateSync(n, len)),
     linkSync(existingPath, newPath) {
       return vfsOpVoid(existingPath, (vfs, n) => {
-        checkSameVFS(n, toPathStr(newPath), 'link', vfs);
-        vfs.linkSync(n, resolve(toPathStr(newPath)));
+        const destStr = toPathStr(newPath);
+        checkSameVFS(n, destStr, 'link', vfs);
+        vfs.linkSync(n, destStr);
       });
     },
     mkdtempSync(prefix, options) {
@@ -366,19 +433,14 @@ function createVfsHandlers() {
     openAsBlob(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr !== null) {
-        const normalized = resolve(pathStr);
-        for (let i = 0; i < activeVFSList.length; i++) {
-          const vfs = activeVFSList[i];
-          if (vfs.shouldHandle(normalized) && vfs.existsSync(normalized)) {
-            return vfs.openAsBlob(normalized, options);
-          }
+        const r = findVFS(pathStr);
+        if (r !== null && r.vfs.existsSync(pathStr)) {
+          return r.vfs.openAsBlob(pathStr, options);
         }
       }
       return undefined;
     },
 
-    // ==================== Sync FD-based ops ====================
-
     openSync: (path, flags, mode) => vfsOp(path, (vfs, n) => vfs.openSync(n, flags, mode)),
     closeSync(fd) {
       const vfd = getVirtualFd(fd);
@@ -437,8 +499,6 @@ function createVfsHandlers() {
       return totalWritten;
     },
 
-    // ==================== Async FD-based ops ====================
-
     close(fd) {
       const vfd = getVirtualFd(fd);
       if (!vfd) return undefined;
@@ -472,13 +532,11 @@ function createVfsHandlers() {
     fdatasync: noopFd,
     fsync: noopFd,
 
-    // ==================== Stream ops ====================
-
     createReadStream(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr !== null) {
         const r = findVFSForPath(pathStr);
-        if (r !== null) return r.vfs.createReadStream(r.normalized, options);
+        if (r !== null) return r.vfs.createReadStream(r.path, options);
       }
       return undefined;
     },
@@ -486,13 +544,11 @@ function createVfsHandlers() {
       const pathStr = toPathStr(path);
       if (pathStr !== null) {
         const r = findVFSForPath(pathStr);
-        if (r !== null) return r.vfs.createWriteStream(r.normalized, options);
+        if (r !== null) return r.vfs.createWriteStream(r.path, options);
       }
       return undefined;
     },
 
-    // ==================== Watch ops ====================
-
     watch(filename, options, listener) {
       if (typeof options === 'function') {
         listener = options;
@@ -510,8 +566,6 @@ function createVfsHandlers() {
       return undefined;
     },
 
-    // ==================== Async path-based ops ====================
-
     readdir(path, options) {
       const promise = vfsOp(path, (vfs, n) => vfs.promises.readdir(n, options));
       if (promise !== undefined && options?.encoding === 'buffer' && !options?.withFileTypes) {
@@ -527,14 +581,9 @@ function createVfsHandlers() {
     lstat(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr === null) return undefined;
-      const normalized = resolve(pathStr);
-      for (let i = 0; i < activeVFSList.length; i++) {
-        const vfs = activeVFSList[i];
-        if (vfs.shouldHandle(normalized)) {
-          return vfs.promises.lstat(normalized, options);
-        }
-      }
-      return undefined;
+      const r = findVFS(pathStr);
+      if (r === null) return undefined;
+      return r.vfs.promises.lstat(pathStr, options);
     },
     stat(path, options) {
       const promise = vfsOp(path, (vfs, n) => vfs.promises.stat(n, options));
@@ -578,18 +627,13 @@ function createVfsHandlers() {
     readlink(path, options) {
       const pathStr = toPathStr(path);
       if (pathStr === null) return undefined;
-      const normalized = resolve(pathStr);
-      for (let i = 0; i < activeVFSList.length; i++) {
-        const vfs = activeVFSList[i];
-        if (vfs.shouldHandle(normalized)) {
-          const promise = vfs.promises.readlink(normalized, options);
-          if (options?.encoding === 'buffer') {
-            return promise.then((result) => Buffer.from(result));
-          }
-          return promise;
-        }
+      const r = findVFS(pathStr);
+      if (r === null) return undefined;
+      const promise = r.vfs.promises.readlink(pathStr, options);
+      if (options?.encoding === 'buffer') {
+        return promise.then((result) => Buffer.from(result));
       }
-      return undefined;
+      return promise;
     },
     chown: (path, uid, gid) =>
       vfsOp(path, (vfs, n) => vfs.promises.chown(n, uid, gid).then(() => true)),
@@ -630,14 +674,16 @@ function createVfsHandlers() {
     unlink: (path) => vfsOp(path, (vfs, n) => vfs.promises.unlink(n).then(() => true)),
     rename(oldPath, newPath) {
       return vfsOp(oldPath, (vfs, n) => {
-        checkSameVFS(n, toPathStr(newPath), 'rename', vfs);
-        return vfs.promises.rename(n, resolve(toPathStr(newPath))).then(() => true);
+        const destStr = toPathStr(newPath);
+        checkSameVFS(n, destStr, 'rename', vfs);
+        return vfs.promises.rename(n, destStr).then(() => true);
       });
     },
     copyFile(src, dest, mode) {
       return vfsOp(src, (vfs, n) => {
-        checkSameVFS(n, toPathStr(dest), 'copyfile', vfs);
-        return vfs.promises.copyFile(n, resolve(toPathStr(dest)), mode).then(() => true);
+        const destStr = toPathStr(dest);
+        checkSameVFS(n, destStr, 'copyfile', vfs);
+        return vfs.promises.copyFile(n, destStr, mode).then(() => true);
       });
     },
     symlink(target, path, type) {
@@ -647,8 +693,9 @@ function createVfsHandlers() {
       vfsOp(path, (vfs, n) => vfs.promises.truncate(n, len).then(() => true)),
     link(existingPath, newPath) {
       return vfsOp(existingPath, (vfs, n) => {
-        checkSameVFS(n, toPathStr(newPath), 'link', vfs);
-        return vfs.promises.link(n, resolve(toPathStr(newPath))).then(() => true);
+        const destStr = toPathStr(newPath);
+        checkSameVFS(n, destStr, 'link', vfs);
+        return vfs.promises.link(n, destStr).then(() => true);
       });
     },
     mkdtemp(prefix, options) {
@@ -663,9 +710,8 @@ function createVfsHandlers() {
     utimes: (path, atime, mtime) =>
       vfsOp(path, (vfs, n) => vfs.promises.utimes(n, atime, mtime).then(() => true)),
     open(path, flags, mode) {
-      // openSync is synchronous, so an error thrown by the provider would
-      // escape via fs.open's caller (instead of going through the callback).
-      // Catch it here and surface as a rejected promise.
+      // Wrap openSync in an async fn so provider throws become rejections
+      // instead of escaping past fs.open's callback.
       return vfsOp(path, async (vfs, n) => vfs.openSync(n, flags, mode));
     },
     promisesOpen(path, flags, mode) {
@@ -673,7 +719,7 @@ function createVfsHandlers() {
       if (pathStr !== null) {
         const r = findVFSForPath(pathStr);
         if (r !== null) {
-          const fd = r.vfs.openSync(r.normalized, flags, mode);
+          const fd = r.vfs.openSync(r.path, flags, mode);
           const vfd = getVirtualFd(fd);
           return PromiseResolve(vfd.entry);
         }
@@ -685,6 +731,155 @@ function createVfsHandlers() {
   };
 }
 
+function installModuleLoaderOverrides() {
+  const {
+    legacyMainResolveExtensions,
+    legacyMainResolveExtensionsIndexes,
+    setLoaderFsOverrides,
+    setLoaderPackageOverrides,
+  } = require('internal/modules/helpers');
+  const { kResolvedByMainIndexNode } = legacyMainResolveExtensionsIndexes;
+  const { internal: internalConstants } = internalBinding('constants');
+
+  // Overrides return `undefined` for paths the VFS does not own;
+  // wrapLoaderMethod then falls through to the native binding.
+  setLoaderFsOverrides({
+    stat(filename) {
+      const result = findVFSForStat(filename);
+      return result !== null ? result.result : undefined;
+    },
+    readFile(filename, options) {
+      const pathStr = typeof filename === 'string' ? filename :
+        (filename instanceof URL ? fileURLToPath(filename) : String(filename));
+      const result = findVFSForRead(pathStr, options);
+      return result !== null ? result.content : undefined;
+    },
+    realpath(filename) {
+      return findVFSWith(filename, 'realpath', (vfs, n) => vfs.realpathSync(n));
+    },
+    legacyMainResolve(pkgPath, main, base) {
+      if (findVFS(pkgPath) === null) return undefined;
+
+      for (let i = 0; i < legacyMainResolveExtensions.length; i++) {
+        const byMain = i <= kResolvedByMainIndexNode;
+        if (byMain && !main) continue;
+        const prefix = byMain ? main : '';
+        const candidate = join(pkgPath, prefix + legacyMainResolveExtensions[i]);
+        if (findVFSForStat(candidate)?.result === 0) return i;
+      }
+
+      // Third arg `exactUrl` must be undefined (not a string) so the
+      // message uses the "package" word and err.url is not overwritten.
+      // ERR_MODULE_NOT_FOUND enforces strict arity in getMessage(), so
+      // the undefined has to be passed explicitly.
+      const initial = main ? join(pkgPath, main) : join(pkgPath, 'index.js');
+      throw new ERR_MODULE_NOT_FOUND(initial, base, undefined);
+    },
+    getFormatOfExtensionlessFile(filePath) {
+      let result;
+      try {
+        result = findVFSForRead(filePath, null);
+      } catch {
+        return internalConstants.EXTENSIONLESS_FORMAT_JAVASCRIPT;
+      }
+      if (result === null) return undefined;
+      const content = result.content;
+      // Wasm magic bytes: 0x00 0x61 0x73 0x6d
+      if (content && content.length >= 4 &&
+          content[0] === 0x00 && content[1] === 0x61 &&
+          content[2] === 0x73 && content[3] === 0x6d) {
+        return internalConstants.EXTENSIONLESS_FORMAT_WASM;
+      }
+      return internalConstants.EXTENSIONLESS_FORMAT_JAVASCRIPT;
+    },
+  });
+
+  setLoaderPackageOverrides({
+    readPackageJSON(jsonPath, isESM, base, specifier) {
+      const r = findVFS(jsonPath);
+      if (r === null) return undefined;
+      const { vfs } = r;
+      if (vfsStat(vfs, jsonPath) !== 0) return undefined;
+      let content;
+      try {
+        content = vfs.readFileSync(jsonPath);
+      } catch {
+        return undefined;
+      }
+      // Both CJS and ESM raise ERR_INVALID_PACKAGE_CONFIG since
+      // nodejs/node#48606.
+      return nativeModulesBinding.parsePackageJSON(
+        content, jsonPath, isESM, base, specifier);
+    },
+    getNearestParentPackageJSON(checkPath) {
+      const r = findVFS(checkPath);
+      if (r === null) return undefined;
+      const found = findVFSPackageJSON(r.vfs, checkPath, r.normalized);
+      return found.tuple;
+    },
+    getPackageScopeConfig(resolved) {
+      let filePath;
+      if (StringPrototypeStartsWith(resolved, 'file:')) {
+        try {
+          filePath = fileURLToPath(resolved);
+        } catch {
+          return undefined;
+        }
+      } else {
+        filePath = resolved;
+      }
+      const r = findVFS(filePath);
+      if (r === null) return undefined;
+      const found = findVFSPackageJSON(r.vfs, filePath, r.normalized);
+      if (found.tuple !== undefined) return found.tuple;
+      return found.sentinel;
+    },
+    getPackageType(url) {
+      let filePath;
+      if (StringPrototypeStartsWith(url, 'file:')) {
+        try {
+          filePath = fileURLToPath(url);
+        } catch {
+          return undefined;
+        }
+      } else {
+        filePath = url;
+      }
+      const r = findVFS(filePath);
+      if (r === null) return undefined;
+      const found = findVFSPackageJSON(r.vfs, filePath, r.normalized);
+      if (found.tuple !== undefined) {
+        // Tuple shape: [name, main, type, imports, exports, filePath].
+        const type = found.tuple[2];
+        if (type === 'module' || type === 'commonjs') return type;
+      }
+      return undefined;
+    },
+  });
+}
+
+function installHooks() {
+  if (hooksInstalled) return;
+  debug('install hooks');
+  normalizedVfsRootPrefix = getNormalizedVfsRoot() + sep;
+  installModuleLoaderOverrides();
+  vfsHandlerObj = createVfsHandlers();
+  setVfsHandlers(vfsHandlerObj);
+  hooksInstalled = true;
+}
+
+function uninstallHooks() {
+  if (!hooksInstalled) return;
+  debug('uninstall hooks');
+  const { setLoaderFsOverrides, setLoaderPackageOverrides } =
+    require('internal/modules/helpers');
+  setLoaderFsOverrides();
+  setLoaderPackageOverrides();
+  setVfsHandlers(null);
+  vfsHandlerObj = undefined;
+  hooksInstalled = false;
+}
+
 module.exports = {
   registerVFS,
   deregisterVFS,
diff --git a/src/node_modules.cc b/src/node_modules.cc
index 717d84a4f89aaf..c2d5327c5ac5e9 100644
--- a/src/node_modules.cc
+++ b/src/node_modules.cc
@@ -91,37 +91,16 @@ Local<Array> BindingData::PackageConfig::Serialize(Realm* realm) const {
   return Array::New(isolate, values, 6);
 }
 
-const BindingData::PackageConfig* BindingData::GetPackageJSON(
-    Realm* realm, std::string_view path, ErrorContext* error_context) {
+bool BindingData::ParsePackageJSON(Realm* realm,
+                                   PackageConfig* package_config,
+                                   ErrorContext* error_context) {
   auto binding_data = realm->GetBindingData<BindingData>();
-
-  auto cache_entry = binding_data->package_configs_.find(path.data());
-  if (cache_entry != binding_data->package_configs_.end()) {
-    auto& cache_value = cache_entry->second;
-    if (cache_value) {
-      return &*cache_value;
-    }
-
-    // If we have a cache entry without a value, we've already
-    // attempted to open and read this path and couldn't (it most
-    // likely doesn't exist)
-    return nullptr;
-  }
-
-  PackageConfig package_config{};
-  package_config.file_path = path;
-  // No need to exclude BOM since simdjson will skip it.
-  if (ReadFileSync(&package_config.raw_json, path.data()) < 0) {
-    // Add `nullopt` to the package config cache so that we don't
-    // need to open and attempt to read this path again
-    binding_data->package_configs_.insert({std::string(path), std::nullopt});
-    return nullptr;
-  }
+  const std::string_view path = package_config->file_path;
 
   simdjson::ondemand::document document;
   simdjson::ondemand::object main_object;
   simdjson::error_code error =
-      binding_data->json_parser.iterate(simdjson::pad(package_config.raw_json))
+      binding_data->json_parser.iterate(simdjson::pad(package_config->raw_json))
           .get(document);
 
   const auto throw_invalid_package_config = [error_context, path, realm]() {
@@ -144,7 +123,7 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
           realm->isolate(), "Invalid package config %s.", path.data());
     }
 
-    return nullptr;
+    return false;
   };
 
   if (error || document.get_object().get(main_object)) {
@@ -169,12 +148,12 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
     if (key == "name") {
       // Though there is a key "name" with a corresponding value,
       // the value may not be a string or could be an invalid JSON string
-      if (value.get_string(package_config.name)) {
+      if (value.get_string(package_config->name)) {
         return throw_invalid_package_config();
       }
     } else if (key == "main") {
       // Omit all non-string values
-      USE(value.get_string(package_config.main));
+      USE(value.get_string(package_config->main));
     } else if (key == "exports") {
       if (value.type().get(field_type)) {
         return throw_invalid_package_config();
@@ -185,11 +164,11 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
           if (value.raw_json().get(field_value)) {
             return throw_invalid_package_config();
           }
-          package_config.exports = field_value;
+          package_config->exports = field_value;
           break;
         }
         case simdjson::ondemand::json_type::string: {
-          if (value.get_string(package_config.exports)) {
+          if (value.get_string(package_config->exports)) {
             return throw_invalid_package_config();
           }
           break;
@@ -207,11 +186,11 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
           if (value.raw_json().get(field_value)) {
             return throw_invalid_package_config();
           }
-          package_config.imports = field_value;
+          package_config->imports = field_value;
           break;
         }
         case simdjson::ondemand::json_type::string: {
-          if (value.get_string(package_config.imports)) {
+          if (value.get_string(package_config->imports)) {
             return throw_invalid_package_config();
           }
           break;
@@ -226,7 +205,7 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
       // Only update type if it is "commonjs" or "module"
       // The default value is "none" for backward compatibility.
       if (field_value == "commonjs" || field_value == "module") {
-        package_config.type = field_value;
+        package_config->type = field_value;
       }
     } else if (key == "scripts") {
       if (value.type().get(field_type)) {
@@ -237,7 +216,7 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
           if (value.raw_json().get(field_value)) {
             return throw_invalid_package_config();
           }
-          package_config.scripts = field_value;
+          package_config->scripts = field_value;
           break;
         }
         default:
@@ -245,6 +224,40 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
       }
     }
   }
+  return true;
+}
+
+const BindingData::PackageConfig* BindingData::GetPackageJSON(
+    Realm* realm, std::string_view path, ErrorContext* error_context) {
+  auto binding_data = realm->GetBindingData<BindingData>();
+
+  auto cache_entry = binding_data->package_configs_.find(path.data());
+  if (cache_entry != binding_data->package_configs_.end()) {
+    auto& cache_value = cache_entry->second;
+    if (cache_value) {
+      return &*cache_value;
+    }
+
+    // If we have a cache entry without a value, we've already
+    // attempted to open and read this path and couldn't (it most
+    // likely doesn't exist)
+    return nullptr;
+  }
+
+  PackageConfig package_config{};
+  package_config.file_path = path;
+  // No need to exclude BOM since simdjson will skip it.
+  if (ReadFileSync(&package_config.raw_json, path.data()) < 0) {
+    // Add `nullopt` to the package config cache so that we don't
+    // need to open and attempt to read this path again
+    binding_data->package_configs_.insert({std::string(path), std::nullopt});
+    return nullptr;
+  }
+
+  if (!ParsePackageJSON(realm, &package_config, error_context)) {
+    return nullptr;
+  }
+
   // package_config could be quite large, so we should move it instead of
   // copying it.
   auto cached = binding_data->package_configs_.insert(
@@ -291,6 +304,49 @@ void BindingData::ReadPackageJSON(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(package_json->Serialize(realm));
 }
 
+void BindingData::ParsePackageJSONBinding(
+    const FunctionCallbackInfo<Value>& args) {
+  // parsePackageJSON(source, jsonPath, isESM, base, specifier)
+  CHECK_GE(args.Length(), 2);
+  CHECK(args[0]->IsString() || args[0]->IsArrayBufferView());  // source
+  CHECK(args[1]->IsString());                                  // jsonPath
+
+  Realm* realm = Realm::GetCurrent(args);
+  auto isolate = realm->isolate();
+
+  BufferValue json_path(isolate, args[1]);
+  bool is_esm = args.Length() >= 3 && args[2]->IsTrue();
+  auto error_context = ErrorContext();
+  if (is_esm) {
+    CHECK(args[3]->IsUndefined() || args[3]->IsString());  // base
+    CHECK(args[4]->IsString());                            // specifier
+
+    if (args[3]->IsString()) {
+      Utf8Value base_value(isolate, args[3]);
+      error_context.base = base_value.ToString();
+    }
+    Utf8Value specifier(isolate, args[4]);
+    error_context.specifier = specifier.ToString();
+  }
+
+  PackageConfig package_config{};
+  package_config.file_path = json_path.ToStringView();
+  if (args[0]->IsString()) {
+    Utf8Value source(isolate, args[0]);
+    package_config.raw_json = source.ToString();
+  } else {
+    ArrayBufferViewContents<char> view(args[0]);
+    package_config.raw_json = std::string(view.data(), view.length());
+  }
+
+  if (!ParsePackageJSON(
+          realm, &package_config, is_esm ? &error_context : nullptr)) {
+    return;  // ParsePackageJSON already threw
+  }
+
+  args.GetReturnValue().Set(package_config.Serialize(realm));
+}
+
 const BindingData::PackageConfig* BindingData::TraverseParent(
     Realm* realm, const std::filesystem::path& check_path) {
   std::filesystem::path current_path = check_path;
@@ -612,6 +668,7 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
                                              Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();
   SetMethod(isolate, target, "readPackageJSON", ReadPackageJSON);
+  SetMethod(isolate, target, "parsePackageJSON", ParsePackageJSONBinding);
   SetMethod(isolate,
             target,
             "getNearestParentPackageJSONType",
@@ -690,6 +747,7 @@ void BindingData::CreatePerContextProperties(Local<Object> target,
 void BindingData::RegisterExternalReferences(
     ExternalReferenceRegistry* registry) {
   registry->Register(ReadPackageJSON);
+  registry->Register(ParsePackageJSONBinding);
   registry->Register(GetNearestParentPackageJSONType);
   registry->Register(GetNearestParentPackageJSON);
   registry->Register(GetPackageScopeConfig<false>);
diff --git a/src/node_modules.h b/src/node_modules.h
index d610306a3a3111..54417731265237 100644
--- a/src/node_modules.h
+++ b/src/node_modules.h
@@ -55,6 +55,11 @@ class BindingData : public SnapshotableObject {
   SET_MEMORY_INFO_NAME(BindingData)
 
   static void ReadPackageJSON(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Like ReadPackageJSON but the caller supplies the raw JSON body.
+  // Does not populate the C++ `package_configs_` cache.
+  // Signature: parsePackageJSON(source, jsonPath, isESM, base, specifier)
+  static void ParsePackageJSONBinding(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetNearestParentPackageJSON(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetNearestParentPackageJSONType(
@@ -90,6 +95,12 @@ class BindingData : public SnapshotableObject {
       Realm* realm,
       std::string_view path,
       ErrorContext* error_context = nullptr);
+  // Parses `package_config->raw_json` into `package_config`; caller
+  // must set raw_json and file_path first. Returns false and throws
+  // ERR_INVALID_PACKAGE_CONFIG on a syntactic error.
+  static bool ParsePackageJSON(Realm* realm,
+                               PackageConfig* package_config,
+                               ErrorContext* error_context);
   static const PackageConfig* TraverseParent(
       Realm* realm, const std::filesystem::path& check_path);
 };
diff --git a/test/parallel/test-vfs-destructuring.js b/test/parallel/test-vfs-destructuring.js
index 11422cf4eda89d..e38d15bbb734ac 100644
--- a/test/parallel/test-vfs-destructuring.js
+++ b/test/parallel/test-vfs-destructuring.js
@@ -18,17 +18,13 @@ const {
   realpathSync,
 } = require('fs');
 
-// path.resolve here so the mount point and the assertion targets are in the
-// platform's native form (e.g. 'D:\vfs_destr' on Windows). VirtualFileSystem
-// stores the mount point via path.resolve internally, so we mirror that.
-const MOUNT = path.resolve('/vfs_destr');
-const FILE = path.join(MOUNT, 'file.txt');
-
 const myVfs = vfs.create();
 myVfs.mkdirSync('/sub', { recursive: true });
 myVfs.writeFileSync('/file.txt', 'hello from vfs');
 myVfs.writeFileSync('/sub/nested.txt', 'nested content');
-myVfs.mount(MOUNT);
+
+const MOUNT = myVfs.mount();
+const FILE = path.join(MOUNT, 'file.txt');
 
 {
   const content = readFileSync(FILE, 'utf8');
diff --git a/test/parallel/test-vfs-fs-accessSync.js b/test/parallel/test-vfs-fs-accessSync.js
index a05bfd13282306..9d3469608ecc39 100644
--- a/test/parallel/test-vfs-fs-accessSync.js
+++ b/test/parallel/test-vfs-fs-accessSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-accessSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // Existing path succeeds
 fs.accessSync(path.join(mountPoint, 'src/hello.txt'));
diff --git a/test/parallel/test-vfs-fs-callback-error-paths.js b/test/parallel/test-vfs-fs-callback-error-paths.js
index 8a9bf95980e59a..5cff379eda668a 100644
--- a/test/parallel/test-vfs-fs-callback-error-paths.js
+++ b/test/parallel/test-vfs-fs-callback-error-paths.js
@@ -9,14 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-cb-err-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-chmod-callback.js b/test/parallel/test-vfs-fs-chmod-callback.js
index 72523a3bd7e831..44f86833c397b0 100644
--- a/test/parallel/test-vfs-fs-chmod-callback.js
+++ b/test/parallel/test-vfs-fs-chmod-callback.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-chmod-cb-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const target = path.join(mountPoint, 'src/hello.txt');
 const uid = process.getuid?.() ?? 0;
diff --git a/test/parallel/test-vfs-fs-chmodSync.js b/test/parallel/test-vfs-fs-chmodSync.js
index f4403d3708726c..91a63c36129eb3 100644
--- a/test/parallel/test-vfs-fs-chmodSync.js
+++ b/test/parallel/test-vfs-fs-chmodSync.js
@@ -10,11 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-chmodSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const target = path.join(mountPoint, 'src/hello.txt');
 const uid = process.getuid?.() ?? 0;
diff --git a/test/parallel/test-vfs-fs-copyFileSync.js b/test/parallel/test-vfs-fs-copyFileSync.js
index 9f97421329c541..3383b460862caf 100644
--- a/test/parallel/test-vfs-fs-copyFileSync.js
+++ b/test/parallel/test-vfs-fs-copyFileSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-copyFileSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.copyFileSync(
   path.join(mountPoint, 'src/hello.txt'),
diff --git a/test/parallel/test-vfs-fs-createReadStream.js b/test/parallel/test-vfs-fs-createReadStream.js
index 08303a361e1fb8..357d7db2b92327 100644
--- a/test/parallel/test-vfs-fs-createReadStream.js
+++ b/test/parallel/test-vfs-fs-createReadStream.js
@@ -10,14 +10,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-createReadStream-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-createWriteStream.js b/test/parallel/test-vfs-fs-createWriteStream.js
index 42660acb7f63b7..495d4108db3723 100644
--- a/test/parallel/test-vfs-fs-createWriteStream.js
+++ b/test/parallel/test-vfs-fs-createWriteStream.js
@@ -10,15 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve(
-  '/tmp/vfs-createWriteStream-' + process.pid,
-);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-existsSync.js b/test/parallel/test-vfs-fs-existsSync.js
index 190304a154ca42..5bb6df4c1c2029 100644
--- a/test/parallel/test-vfs-fs-existsSync.js
+++ b/test/parallel/test-vfs-fs-existsSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-existsSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 assert.strictEqual(fs.existsSync(path.join(mountPoint, 'src/hello.txt')), true);
 assert.strictEqual(fs.existsSync(path.join(mountPoint, 'src')), true);
diff --git a/test/parallel/test-vfs-fs-fchmod-callback.js b/test/parallel/test-vfs-fs-fchmod-callback.js
index fa55c934f36f4b..e46fd27af4249b 100644
--- a/test/parallel/test-vfs-fs-fchmod-callback.js
+++ b/test/parallel/test-vfs-fs-fchmod-callback.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-fchmod-cb-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const fd = fs.openSync(path.join(mountPoint, 'src/hello.txt'), 'r+');
 const uid = process.getuid?.() ?? 0;
diff --git a/test/parallel/test-vfs-fs-linkSync.js b/test/parallel/test-vfs-fs-linkSync.js
index f8090b24720d92..e73bcc76df006a 100644
--- a/test/parallel/test-vfs-fs-linkSync.js
+++ b/test/parallel/test-vfs-fs-linkSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-linkSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.linkSync(
   path.join(mountPoint, 'src/hello.txt'),
diff --git a/test/parallel/test-vfs-fs-mkdir-callback.js b/test/parallel/test-vfs-fs-mkdir-callback.js
index e354cc94d01b98..4caccda70f6d25 100644
--- a/test/parallel/test-vfs-fs-mkdir-callback.js
+++ b/test/parallel/test-vfs-fs-mkdir-callback.js
@@ -9,14 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-mkdir-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-mkdirSync.js b/test/parallel/test-vfs-fs-mkdirSync.js
index de3959a06e3b79..83942b8856bed8 100644
--- a/test/parallel/test-vfs-fs-mkdirSync.js
+++ b/test/parallel/test-vfs-fs-mkdirSync.js
@@ -9,10 +9,9 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-mkdirSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // Plain mkdir
 fs.mkdirSync(path.join(mountPoint, 'src/d1'));
diff --git a/test/parallel/test-vfs-fs-mkdtempSync.js b/test/parallel/test-vfs-fs-mkdtempSync.js
index ba837b716cb6ca..2fd1e81d709374 100644
--- a/test/parallel/test-vfs-fs-mkdtempSync.js
+++ b/test/parallel/test-vfs-fs-mkdtempSync.js
@@ -10,10 +10,9 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-mkdtempSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const prefix = path.join(mountPoint, 'src/tmp-');
 
diff --git a/test/parallel/test-vfs-fs-open-callback.js b/test/parallel/test-vfs-fs-open-callback.js
index b1cacb11d921d2..23a4f8ccadb91a 100644
--- a/test/parallel/test-vfs-fs-open-callback.js
+++ b/test/parallel/test-vfs-fs-open-callback.js
@@ -10,14 +10,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-open-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-openAsBlob.js b/test/parallel/test-vfs-fs-openAsBlob.js
index 1c8d175c8f99c4..663472269156a3 100644
--- a/test/parallel/test-vfs-fs-openAsBlob.js
+++ b/test/parallel/test-vfs-fs-openAsBlob.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-openAsBlob-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.openAsBlob(path.join(mountPoint, 'src/hello.txt'))
   .then(async (blob) => {
diff --git a/test/parallel/test-vfs-fs-openSync.js b/test/parallel/test-vfs-fs-openSync.js
index f2c73f0d634469..a6096f6e9a099d 100644
--- a/test/parallel/test-vfs-fs-openSync.js
+++ b/test/parallel/test-vfs-fs-openSync.js
@@ -12,11 +12,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-openSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // openSync + fstatSync + readSync + closeSync
 {
diff --git a/test/parallel/test-vfs-fs-opendir-callback.js b/test/parallel/test-vfs-fs-opendir-callback.js
index 36b8ef81d74ed7..6b1f6fe5f884c8 100644
--- a/test/parallel/test-vfs-fs-opendir-callback.js
+++ b/test/parallel/test-vfs-fs-opendir-callback.js
@@ -10,15 +10,12 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-opendir-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
   myVfs.writeFileSync('/src/data.json', '{}');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-opendirSync.js b/test/parallel/test-vfs-fs-opendirSync.js
index 18ba4c49dd21eb..260b3114d1045f 100644
--- a/test/parallel/test-vfs-fs-opendirSync.js
+++ b/test/parallel/test-vfs-fs-opendirSync.js
@@ -9,12 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-opendirSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src/subdir', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
 myVfs.writeFileSync('/src/data.json', '{}');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const dir = fs.opendirSync(path.join(mountPoint, 'src'));
 const names = [];
diff --git a/test/parallel/test-vfs-fs-promises-buffer-encoding.js b/test/parallel/test-vfs-fs-promises-buffer-encoding.js
index cfb38787ab465c..0c371c9c4587a2 100644
--- a/test/parallel/test-vfs-fs-promises-buffer-encoding.js
+++ b/test/parallel/test-vfs-fs-promises-buffer-encoding.js
@@ -10,14 +10,11 @@ const fsp = require('fs/promises');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-buf-enc-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-promises-stat-no-throw.js b/test/parallel/test-vfs-fs-promises-stat-no-throw.js
index 6bd0c546a02d8c..0b9b28ea10123a 100644
--- a/test/parallel/test-vfs-fs-promises-stat-no-throw.js
+++ b/test/parallel/test-vfs-fs-promises-stat-no-throw.js
@@ -11,11 +11,10 @@ const path = require('path');
 const vfs = require('node:vfs');
 
 (async () => {
-  const mountPoint = path.resolve('/tmp/vfs-stat-no-throw-' + process.pid);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
 
   // Missing file -> undefined
   const missing = await fsp.stat(path.join(mountPoint, 'src/nope'),
diff --git a/test/parallel/test-vfs-fs-promises.js b/test/parallel/test-vfs-fs-promises.js
index d4b151162f2802..d1faaf8b7645bc 100644
--- a/test/parallel/test-vfs-fs-promises.js
+++ b/test/parallel/test-vfs-fs-promises.js
@@ -12,11 +12,10 @@ const path = require('path');
 const vfs = require('node:vfs');
 
 (async () => {
-  const mountPoint = path.resolve('/tmp/vfs-promises-' + process.pid);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   const p = (s) => path.join(mountPoint, s);
 
   // Path-based reads
diff --git a/test/parallel/test-vfs-fs-readFile-callback.js b/test/parallel/test-vfs-fs-readFile-callback.js
index 5902f399b30a9a..653e79e395a277 100644
--- a/test/parallel/test-vfs-fs-readFile-callback.js
+++ b/test/parallel/test-vfs-fs-readFile-callback.js
@@ -10,14 +10,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-readFile-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-readFileSync.js b/test/parallel/test-vfs-fs-readFileSync.js
index 1ca906b2a0577c..297a8855101483 100644
--- a/test/parallel/test-vfs-fs-readFileSync.js
+++ b/test/parallel/test-vfs-fs-readFileSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-readFileSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // Default (buffer) result
 {
@@ -48,15 +47,12 @@ myVfs.unmount();
 // is renamed.
 {
   const root = path.join('/tmp', 'vfs-real-readFileSync-' + process.pid);
-  const realMountPoint = path.join('/tmp', 'vfs-real-readFileSync-mount-' + process.pid);
   fs.rmSync(root, { recursive: true, force: true });
-  fs.rmSync(realMountPoint, { recursive: true, force: true });
   fs.mkdirSync(root, { recursive: true });
-  fs.mkdirSync(realMountPoint, { recursive: true });
 
-  const realVfs = vfs
-    .create(new vfs.RealFSProvider(root), { emitExperimentalWarning: false })
-    .mount(realMountPoint);
+  const realVfs = vfs.create(new vfs.RealFSProvider(root),
+                             { emitExperimentalWarning: false });
+  const realMountPoint = realVfs.mount();
   try {
     fs.writeFileSync(path.join(root, 'a.txt'), 'still readable');
     const fd = fs.openSync(path.join(realMountPoint, 'a.txt'), 'r');
@@ -69,6 +65,5 @@ myVfs.unmount();
   } finally {
     realVfs.unmount();
     fs.rmSync(root, { recursive: true, force: true });
-    fs.rmSync(realMountPoint, { recursive: true, force: true });
   }
 }
diff --git a/test/parallel/test-vfs-fs-readdirSync.js b/test/parallel/test-vfs-fs-readdirSync.js
index 9a795548133914..ee1a1a258b3cfc 100644
--- a/test/parallel/test-vfs-fs-readdirSync.js
+++ b/test/parallel/test-vfs-fs-readdirSync.js
@@ -10,12 +10,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-readdirSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src/subdir', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
 myVfs.writeFileSync('/src/data.json', '{}');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // Default (utf8 string array)
 {
diff --git a/test/parallel/test-vfs-fs-realpathSync.js b/test/parallel/test-vfs-fs-realpathSync.js
index 77d0288776161d..2d87b1e87d3b49 100644
--- a/test/parallel/test-vfs-fs-realpathSync.js
+++ b/test/parallel/test-vfs-fs-realpathSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-realpathSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const p = path.join(mountPoint, 'src/hello.txt');
 
diff --git a/test/parallel/test-vfs-fs-rename-callback.js b/test/parallel/test-vfs-fs-rename-callback.js
index ccf6cccdd56e68..dd426c181e4aa5 100644
--- a/test/parallel/test-vfs-fs-rename-callback.js
+++ b/test/parallel/test-vfs-fs-rename-callback.js
@@ -9,14 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-rename-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-renameSync.js b/test/parallel/test-vfs-fs-renameSync.js
index 88c3f17eef5c83..1f1cbf6b394d5c 100644
--- a/test/parallel/test-vfs-fs-renameSync.js
+++ b/test/parallel/test-vfs-fs-renameSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-renameSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.renameSync(
   path.join(mountPoint, 'src/hello.txt'),
diff --git a/test/parallel/test-vfs-fs-rmSync.js b/test/parallel/test-vfs-fs-rmSync.js
index a6b77a66bc41d7..4f3af281d61a77 100644
--- a/test/parallel/test-vfs-fs-rmSync.js
+++ b/test/parallel/test-vfs-fs-rmSync.js
@@ -9,13 +9,12 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-rmSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src/subdir', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
 myVfs.writeFileSync('/src/subdir/inside.txt', 'inside');
 myVfs.mkdirSync('/empty');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // rmdirSync on an empty directory
 fs.rmdirSync(path.join(mountPoint, 'empty'));
diff --git a/test/parallel/test-vfs-fs-stat-callback.js b/test/parallel/test-vfs-fs-stat-callback.js
index 873d27e14445ef..bd3494b73feccb 100644
--- a/test/parallel/test-vfs-fs-stat-callback.js
+++ b/test/parallel/test-vfs-fs-stat-callback.js
@@ -9,14 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-stat-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-statSync.js b/test/parallel/test-vfs-fs-statSync.js
index e952dfab9ad56c..5a48c4e426fa5a 100644
--- a/test/parallel/test-vfs-fs-statSync.js
+++ b/test/parallel/test-vfs-fs-statSync.js
@@ -10,11 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-statSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 // statSync on a regular file
 {
diff --git a/test/parallel/test-vfs-fs-symlink-callback.js b/test/parallel/test-vfs-fs-symlink-callback.js
index 004745e0fb973c..e35eeb38b980d9 100644
--- a/test/parallel/test-vfs-fs-symlink-callback.js
+++ b/test/parallel/test-vfs-fs-symlink-callback.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-symlink-cb-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.symlink('hello.txt', path.join(mountPoint, 'src/lnk.txt'),
            common.mustSucceed(() => {
diff --git a/test/parallel/test-vfs-fs-symlinkSync.js b/test/parallel/test-vfs-fs-symlinkSync.js
index 6d043c59a98ac7..5a39cc281e0598 100644
--- a/test/parallel/test-vfs-fs-symlinkSync.js
+++ b/test/parallel/test-vfs-fs-symlinkSync.js
@@ -10,11 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-symlinkSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.symlinkSync('hello.txt', path.join(mountPoint, 'src/link.txt'));
 assert.strictEqual(
diff --git a/test/parallel/test-vfs-fs-truncate-callback.js b/test/parallel/test-vfs-fs-truncate-callback.js
index e33ed7e4d61402..1399bf6ed149a0 100644
--- a/test/parallel/test-vfs-fs-truncate-callback.js
+++ b/test/parallel/test-vfs-fs-truncate-callback.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-truncate-cb-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.truncate(path.join(mountPoint, 'src/hello.txt'), 5,
             common.mustSucceed(() => {
diff --git a/test/parallel/test-vfs-fs-truncateSync.js b/test/parallel/test-vfs-fs-truncateSync.js
index 1c15f5647a4716..d4ed16f8fb87dc 100644
--- a/test/parallel/test-vfs-fs-truncateSync.js
+++ b/test/parallel/test-vfs-fs-truncateSync.js
@@ -9,11 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-truncateSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello world');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 fs.truncateSync(path.join(mountPoint, 'src/hello.txt'), 5);
 assert.strictEqual(
diff --git a/test/parallel/test-vfs-fs-watch-dispatch.js b/test/parallel/test-vfs-fs-watch-dispatch.js
index 6d528d6fef7c62..e9952919193bce 100644
--- a/test/parallel/test-vfs-fs-watch-dispatch.js
+++ b/test/parallel/test-vfs-fs-watch-dispatch.js
@@ -10,11 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-watch-dispatch-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
 myVfs.writeFileSync('/src/hello.txt', 'hello');
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const watcher = fs.watch(path.join(mountPoint, 'src/hello.txt'));
 assert.ok(watcher);
diff --git a/test/parallel/test-vfs-fs-writeFile-callback.js b/test/parallel/test-vfs-fs-writeFile-callback.js
index a02dc686b0e0a6..ce22b6b8811ac3 100644
--- a/test/parallel/test-vfs-fs-writeFile-callback.js
+++ b/test/parallel/test-vfs-fs-writeFile-callback.js
@@ -9,13 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseMountPoint = path.resolve('/tmp/vfs-writeFile-cb-' + process.pid);
-let counter = 0;
 function mounted() {
-  const mountPoint = baseMountPoint + '-' + (counter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
diff --git a/test/parallel/test-vfs-fs-writeFileSync.js b/test/parallel/test-vfs-fs-writeFileSync.js
index eeed2a685f08e3..7bde5f6c7b85b7 100644
--- a/test/parallel/test-vfs-fs-writeFileSync.js
+++ b/test/parallel/test-vfs-fs-writeFileSync.js
@@ -9,10 +9,9 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const mountPoint = path.resolve('/tmp/vfs-writeFileSync-' + process.pid);
 const myVfs = vfs.create();
 myVfs.mkdirSync('/src', { recursive: true });
-myVfs.mount(mountPoint);
+const mountPoint = myVfs.mount();
 
 const target = path.join(mountPoint, 'src/new.txt');
 
@@ -58,15 +57,12 @@ myVfs.unmount();
 // after the backing path is renamed.
 {
   const root = path.join('/tmp', 'vfs-real-writeFileSync-' + process.pid);
-  const realMountPoint = path.join('/tmp', 'vfs-real-writeFileSync-mount-' + process.pid);
   fs.rmSync(root, { recursive: true, force: true });
-  fs.rmSync(realMountPoint, { recursive: true, force: true });
   fs.mkdirSync(root, { recursive: true });
-  fs.mkdirSync(realMountPoint, { recursive: true });
 
-  const realVfs = vfs
-    .create(new vfs.RealFSProvider(root), { emitExperimentalWarning: false })
-    .mount(realMountPoint);
+  const realVfs = vfs.create(
+    new vfs.RealFSProvider(root), { emitExperimentalWarning: false });
+  const realMountPoint = realVfs.mount();
   try {
     const mountedFile = path.join(realMountPoint, 'a.txt');
     fs.writeFileSync(path.join(root, 'a.txt'), 'old');
@@ -83,6 +79,5 @@ myVfs.unmount();
   } finally {
     realVfs.unmount();
     fs.rmSync(root, { recursive: true, force: true });
-    fs.rmSync(realMountPoint, { recursive: true, force: true });
   }
 }
diff --git a/test/parallel/test-vfs-import.mjs b/test/parallel/test-vfs-import.mjs
new file mode 100644
index 00000000000000..03e1047c7b79f9
--- /dev/null
+++ b/test/parallel/test-vfs-import.mjs
@@ -0,0 +1,139 @@
+// Flags: --experimental-vfs
+import '../common/index.mjs';
+import assert from 'assert';
+import { pathToFileURL } from 'node:url';
+import vfs from 'node:vfs';
+
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// ESM imports are cached by URL and unmounting does not clear the V8 module
+// cache; each vfs.create() gets its own layer id so mount points are unique.
+
+// Test importing a simple virtual ES module
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/hello.mjs', 'export const message = "hello from vfs";');
+  const mountPoint = myVfs.mount();
+
+  const { message } = await import(vfsImport(`${mountPoint}/hello.mjs`));
+  assert.strictEqual(message, 'hello from vfs');
+
+  myVfs.unmount();
+}
+
+// Test importing a virtual module with default export
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/default.mjs', 'export default { name: "test", value: 42 };');
+  const mountPoint = myVfs.mount();
+
+  const mod = await import(vfsImport(`${mountPoint}/default.mjs`));
+  assert.strictEqual(mod.default.name, 'test');
+  assert.strictEqual(mod.default.value, 42);
+
+  myVfs.unmount();
+}
+
+// Test importing a virtual module that imports another virtual module.
+// Mount first so the embedded absolute specifier can use the mount point.
+{
+  const myVfs = vfs.create();
+  const mountPoint = myVfs.mount();
+  myVfs.writeFileSync(`${mountPoint}/utils.mjs`,
+                      'export function add(a, b) { return a + b; }');
+  myVfs.writeFileSync(`${mountPoint}/main.mjs`, `
+    import { add } from ${JSON.stringify(vfsImport(`${mountPoint}/utils.mjs`))};
+    export const result = add(10, 20);
+  `);
+
+  const { result } = await import(vfsImport(`${mountPoint}/main.mjs`));
+  assert.strictEqual(result, 30);
+
+  myVfs.unmount();
+}
+
+// Test importing with relative paths
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/lib', { recursive: true });
+  myVfs.writeFileSync('/lib/helper.mjs', 'export const helper = () => "helped";');
+  myVfs.writeFileSync('/lib/index.mjs', `
+    import { helper } from './helper.mjs';
+    export const output = helper();
+  `);
+  const mountPoint = myVfs.mount();
+
+  const { output } = await import(vfsImport(`${mountPoint}/lib/index.mjs`));
+  assert.strictEqual(output, 'helped');
+
+  myVfs.unmount();
+}
+
+// Test importing JSON from VFS (with import assertion)
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/data.json', JSON.stringify({ items: [1, 2, 3], enabled: true }));
+  const mountPoint = myVfs.mount();
+
+  const data = await import(vfsImport(`${mountPoint}/data.json`), { with: { type: 'json' } });
+  assert.deepStrictEqual(data.default.items, [1, 2, 3]);
+  assert.strictEqual(data.default.enabled, true);
+
+  myVfs.unmount();
+}
+
+// Test that real modules still work when VFS is mounted
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/test.mjs', 'export const x = 1;');
+  myVfs.mount();
+
+  const assertMod = await import('node:assert');
+  assert.strictEqual(typeof assertMod.strictEqual, 'function');
+
+  myVfs.unmount();
+}
+
+// Test mixed CJS and ESM - ESM importing from VFS while CJS also works
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/esm-module.mjs', 'export const esmValue = "esm";');
+  myVfs.writeFileSync('/cjs-module.js', 'module.exports = { cjsValue: "cjs" };');
+  const mountPoint = myVfs.mount();
+
+  const { esmValue } = await import(vfsImport(`${mountPoint}/esm-module.mjs`));
+  assert.strictEqual(esmValue, 'esm');
+
+  const { createRequire } = await import('module');
+  const require = createRequire(import.meta.url);
+  const { cjsValue } = require(`${mountPoint}/cjs-module.js`);
+  assert.strictEqual(cjsValue, 'cjs');
+
+  myVfs.unmount();
+}
+
+// Test ESM bare specifier resolution from VFS node_modules.
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/my-vfs-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/my-vfs-pkg/package.json', JSON.stringify({
+    name: 'my-vfs-pkg',
+    type: 'module',
+    exports: { '.': './index.mjs' },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/my-vfs-pkg/index.mjs',
+    'export const fromVfs = true;',
+  );
+  // Importing module must live in the VFS mount so node_modules walk stays inside VFS.
+  myVfs.writeFileSync(
+    '/app/entry.mjs',
+    "export { fromVfs } from 'my-vfs-pkg';",
+  );
+  const mountPoint = myVfs.mount();
+
+  const { fromVfs } = await import(vfsImport(`${mountPoint}/app/entry.mjs`));
+  assert.strictEqual(fromVfs, true);
+
+  myVfs.unmount();
+}
diff --git a/test/parallel/test-vfs-invalid-package-json.js b/test/parallel/test-vfs-invalid-package-json.js
new file mode 100644
index 00000000000000..0ac09f5ffce692
--- /dev/null
+++ b/test/parallel/test-vfs-invalid-package-json.js
@@ -0,0 +1,74 @@
+// Flags: --experimental-vfs --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const vfs = require('node:vfs');
+
+// Malformed package.json in VFS throws ERR_INVALID_PACKAGE_CONFIG
+// (matches native CJS behavior after nodejs/node#48606).
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg', { recursive: true });
+  myVfs.writeFileSync('/pkg/package.json', '{ invalid json');
+  myVfs.writeFileSync('/pkg/index.js', 'module.exports = 42;');
+  const mountPoint = myVfs.mount();
+
+  assert.throws(() => require(`${mountPoint}/pkg`),
+                { code: 'ERR_INVALID_PACKAGE_CONFIG' });
+
+  myVfs.unmount();
+}
+
+// Valid package.json still works
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg2', { recursive: true });
+  myVfs.writeFileSync('/pkg2/package.json', '{"main": "lib.js"}');
+  myVfs.writeFileSync('/pkg2/lib.js', 'module.exports = 99;');
+  const mountPoint = myVfs.mount();
+
+  assert.strictEqual(require(`${mountPoint}/pkg2`), 99);
+
+  myVfs.unmount();
+}
+
+// Missing package.json (ENOENT) still falls through to index.js
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg3', { recursive: true });
+  myVfs.writeFileSync('/pkg3/index.js', 'module.exports = 77;');
+  const mountPoint = myVfs.mount();
+
+  assert.strictEqual(require(`${mountPoint}/pkg3`), 77);
+
+  myVfs.unmount();
+}
+
+// A malformed ancestor package.json aborts the scope walk with
+// ERR_INVALID_PACKAGE_CONFIG for both CJS and ESM.
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/outer/inner', { recursive: true });
+  myVfs.writeFileSync('/outer/package.json', '{ bad }');
+  myVfs.writeFileSync('/outer/inner/mod.js', 'module.exports = 1;');
+  const mountPoint = myVfs.mount();
+
+  assert.throws(() => require(`${mountPoint}/outer/inner/mod.js`),
+                { code: 'ERR_INVALID_PACKAGE_CONFIG' });
+
+  myVfs.unmount();
+}
+
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/outer2/inner', { recursive: true });
+  myVfs.writeFileSync('/outer2/package.json', '{ bad }');
+  myVfs.writeFileSync('/outer2/inner/mod.js', 'export const x = 1;');
+  const mountPoint = myVfs.mount();
+
+  await assert.rejects(() => import(`${mountPoint}/outer2/inner/mod.js`),
+                       { code: 'ERR_INVALID_PACKAGE_CONFIG' });
+
+  myVfs.unmount();
+})().then(common.mustCall());
diff --git a/test/parallel/test-vfs-layer-tag-prefix.mjs b/test/parallel/test-vfs-layer-tag-prefix.mjs
new file mode 100644
index 00000000000000..8c751cee73f96c
--- /dev/null
+++ b/test/parallel/test-vfs-layer-tag-prefix.mjs
@@ -0,0 +1,45 @@
+// Flags: --experimental-vfs
+
+// Regression: unmounting a layer whose id is a decimal prefix of another
+// (e.g. layer 1 vs layer 10) must not purge the other's ESM cache entries.
+// Mount points look like `${os.devNull}/vfs/<id>`, so we create instances
+// until the returned mount points exhibit the prefix collision, then
+// verify the survivor's cache lives on.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { pathToFileURL } from 'node:url';
+import vfs from 'node:vfs';
+
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// Layer ids are per-process and increment on every `vfs.create()`, so the
+// second construction lands at id 1 and the eleventh at id 10.
+const instances = [];
+for (let i = 0; i < 11; i++) instances.push(vfs.create());
+const layerOne = instances[1];
+const layerTen = instances[10];
+
+layerOne.writeFileSync('/m.mjs', 'export const tag = "one";');
+const mountOne = layerOne.mount();
+
+layerTen.writeFileSync('/m.mjs', 'export const tag = "ten";');
+const mountTen = layerTen.mount();
+
+assert.notStrictEqual(mountOne, mountTen);
+assert.ok(mountTen.startsWith(mountOne),
+          'test scaffolding: expected layerTen mount to start with layerOne mount');
+
+const oneA = await import(vfsImport(`${mountOne}/m.mjs`));
+const tenA = await import(vfsImport(`${mountTen}/m.mjs`));
+assert.strictEqual(oneA.tag, 'one');
+assert.strictEqual(tenA.tag, 'ten');
+
+layerOne.unmount();
+
+// Layer 10 still mounted: re-import must hit the cache and return the same
+// namespace object. A prefix-based purge would evict it and cause re-eval.
+const tenB = await import(vfsImport(`${mountTen}/m.mjs`));
+assert.strictEqual(tenA, tenB);
+
+layerTen.unmount();
diff --git a/test/parallel/test-vfs-module-hooks-cleanup.js b/test/parallel/test-vfs-module-hooks-cleanup.js
new file mode 100644
index 00000000000000..825957497d1e35
--- /dev/null
+++ b/test/parallel/test-vfs-module-hooks-cleanup.js
@@ -0,0 +1,123 @@
+// Flags: --experimental-vfs
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { pathToFileURL } = require('node:url');
+const vfs = require('node:vfs');
+
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// After a full deregister, a fresh register re-installs hooks cleanly.
+{
+  const a = vfs.create();
+  a.writeFileSync('/m1.js', 'module.exports = "first"');
+  const mountA = a.mount();
+  assert.strictEqual(require(`${mountA}/m1.js`), 'first');
+  a.unmount();
+
+  const b = vfs.create();
+  b.writeFileSync('/m2.js', 'module.exports = "second"');
+  const mountB = b.mount();
+  assert.strictEqual(require(`${mountB}/m2.js`), 'second');
+  b.unmount();
+}
+
+// After the last VFS is removed, real-fs require still works.
+{
+  const v = vfs.create();
+  v.writeFileSync('/x.js', 'module.exports = 1');
+  const mountPoint = v.mount();
+  require(`${mountPoint}/x.js`);
+  v.unmount();
+  const fs = require('fs');
+  assert.strictEqual(typeof fs.readFileSync, 'function');
+}
+
+// Top-level non-object package.json is rejected with ERR_INVALID_PACKAGE_CONFIG
+// (matches the native binding's throw_invalid_package_config path).
+{
+  const v = vfs.create();
+  v.mkdirSync('/pkg');
+  v.writeFileSync('/pkg/package.json', 'null');
+  v.writeFileSync('/pkg/index.js', 'module.exports = 1');
+  const mountPoint = v.mount();
+  assert.throws(
+    () => require(`${mountPoint}/pkg`),
+    { code: 'ERR_INVALID_PACKAGE_CONFIG' },
+  );
+  v.unmount();
+}
+
+// Non-string `main` is silently omitted, matching the native binding
+// (`USE(value.get_string(...))` in src/node_modules.cc).
+{
+  const v = vfs.create();
+  v.mkdirSync('/pkg');
+  v.writeFileSync('/pkg/package.json', '{"main": 42}');
+  v.writeFileSync('/pkg/index.js', 'module.exports = "via-index"');
+  const mountPoint = v.mount();
+  assert.strictEqual(require(`${mountPoint}/pkg`), 'via-index');
+  v.unmount();
+}
+
+// Partial deregister of a multi-mount setup leaves the still-mounted
+// VFS fully functional.
+{
+  const a = vfs.create();
+  a.writeFileSync('/a.js', 'module.exports = "a"');
+  const mountA = a.mount();
+  const b = vfs.create();
+  b.writeFileSync('/b.js', 'module.exports = "b"');
+  const mountB = b.mount();
+
+  assert.strictEqual(require(`${mountA}/a.js`), 'a');
+  assert.strictEqual(require(`${mountB}/b.js`), 'b');
+
+  a.unmount();
+  assert.strictEqual(require(`${mountB}/b.js`), 'b');
+
+  b.unmount();
+}
+
+// ESM legacyMainResolve override produces ERR_MODULE_NOT_FOUND with the
+// resolved candidate path when `main` points at a missing file, and err.url
+// is undefined (regression: previously 'package' leaked into err.url).
+(async () => {
+  const v = vfs.create();
+  v.mkdirSync('/app/node_modules/badpkg', { recursive: true });
+  v.writeFileSync(
+    '/app/node_modules/badpkg/package.json', '{"main": "./nope.js"}');
+  v.writeFileSync('/app/entry.mjs', "import 'badpkg';");
+  const mountPoint = v.mount();
+  await assert.rejects(
+    () => import(vfsImport(`${mountPoint}/app/entry.mjs`)),
+    (err) => {
+      assert.strictEqual(err.code, 'ERR_MODULE_NOT_FOUND');
+      assert.match(err.message, /nope\.js/);
+      assert.match(err.message, /^Cannot find package /);
+      assert.strictEqual(err.url, undefined);
+      return true;
+    },
+  );
+  v.unmount();
+})().then(common.mustCall());
+
+// Symlink inside a VFS: unmount purges cache entries recorded under the
+// resolved realpath too. Remounting the same instance at the same prefix
+// reuses the same mount point, so a stale entry would be revived.
+{
+  const v = vfs.create();
+  v.mkdirSync('/real', { recursive: true });
+  v.writeFileSync('/real/mod.js', 'module.exports = "one"');
+  v.symlinkSync('/real/mod.js', '/link.js');
+  const mountPoint = v.mount();
+  assert.strictEqual(require(`${mountPoint}/link.js`), 'one');
+  v.unmount();
+
+  v.writeFileSync('/real/mod.js', 'module.exports = "two"');
+  const mountPoint2 = v.mount();
+  assert.strictEqual(mountPoint2, mountPoint);
+  assert.strictEqual(require(`${mountPoint2}/link.js`), 'two');
+  v.unmount();
+}
diff --git a/test/parallel/test-vfs-module-hooks.mjs b/test/parallel/test-vfs-module-hooks.mjs
new file mode 100644
index 00000000000000..9629b3bdbaf69d
--- /dev/null
+++ b/test/parallel/test-vfs-module-hooks.mjs
@@ -0,0 +1,657 @@
+// Flags: --experimental-vfs
+import '../common/index.mjs';
+import assert from 'assert';
+import { createRequire } from 'module';
+import { pathToFileURL } from 'node:url';
+import vfs from 'node:vfs';
+
+const require = createRequire(import.meta.url);
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// mount() returns the actual mount point (reserved under os.devNull);
+// each test captures it and uses it for requires/imports.
+
+// Test: CJS bare specifier resolution with exports string shorthand
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/str-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/str-pkg/package.json', JSON.stringify({
+    name: 'str-pkg',
+    exports: './main.js',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/str-pkg/main.js',
+    'module.exports = { strExport: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry.js',
+    "module.exports = require('str-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry.js`);
+  assert.strictEqual(result.strExport, true);
+
+  myVfs.unmount();
+}
+
+// Test: Conditional exports with import/require/default conditions
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/cond-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/cond-pkg/package.json', JSON.stringify({
+    name: 'cond-pkg',
+    exports: {
+      import: './esm.mjs',
+      require: './cjs.js',
+      default: './default.js',
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/cond-pkg/esm.mjs',
+    'export const source = "esm";',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/cond-pkg/cjs.js',
+    'module.exports = { source: "cjs" };',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/cond-pkg/default.js',
+    'module.exports = { source: "default" };',
+  );
+  myVfs.writeFileSync(
+    '/app/esm-entry.mjs',
+    "export { source } from 'cond-pkg';",
+  );
+  myVfs.writeFileSync(
+    '/app/cjs-entry.js',
+    "module.exports = require('cond-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const esmResult = await import(vfsImport(`${mountPoint}/app/esm-entry.mjs`));
+  assert.strictEqual(esmResult.source, 'esm');
+
+  const cjsResult = require(`${mountPoint}/app/cjs-entry.js`);
+  assert.strictEqual(cjsResult.source, 'cjs');
+
+  myVfs.unmount();
+}
+
+// Test: Subpath exports map
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/sub-pkg/lib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/sub-pkg/package.json', JSON.stringify({
+    name: 'sub-pkg',
+    exports: {
+      '.': './lib/index.mjs',
+      './feature': './lib/feature.mjs',
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/sub-pkg/lib/index.mjs',
+    'export const main = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/sub-pkg/lib/feature.mjs',
+    'export const feature = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/entry.mjs',
+    `
+    import { main } from 'sub-pkg';
+    import { feature } from 'sub-pkg/feature';
+    export { main, feature };
+    `,
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/entry.mjs`));
+  assert.strictEqual(result.main, true);
+  assert.strictEqual(result.feature, true);
+
+  myVfs.unmount();
+}
+
+// Test: Subpath exports with conditional object target
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/sub-cond-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/sub-cond-pkg/package.json', JSON.stringify({
+    name: 'sub-cond-pkg',
+    exports: {
+      '.': {
+        import: './esm.mjs',
+        require: './cjs.js',
+      },
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/sub-cond-pkg/esm.mjs',
+    'export const fromSubCond = "esm";',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/sub-cond-pkg/cjs.js',
+    'module.exports = { fromSubCond: "cjs" };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry2.mjs',
+    "export { fromSubCond } from 'sub-cond-pkg';",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/entry2.mjs`));
+  assert.strictEqual(result.fromSubCond, 'esm');
+
+  myVfs.unmount();
+}
+
+// Test: Nested conditional exports (e.g. node -> import/require)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/nested-cond-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/nested-cond-pkg/package.json', JSON.stringify({
+    name: 'nested-cond-pkg',
+    exports: {
+      node: {
+        import: './node-esm.mjs',
+        require: './node-cjs.js',
+      },
+      default: './fallback.js',
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/nested-cond-pkg/node-esm.mjs',
+    'export const nested = "node-esm";',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/nested-cond-pkg/node-cjs.js',
+    'module.exports = { nested: "node-cjs" };',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/nested-cond-pkg/fallback.js',
+    'module.exports = { nested: "fallback" };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry3.mjs',
+    "export { nested } from 'nested-cond-pkg';",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/entry3.mjs`));
+  assert.strictEqual(result.nested, 'node-esm');
+
+  myVfs.unmount();
+}
+
+// Test: Package without exports, using main field
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/main-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/main-pkg/package.json', JSON.stringify({
+    name: 'main-pkg',
+    main: './lib/entry.js',
+  }));
+  myVfs.mkdirSync('/app/node_modules/main-pkg/lib', { recursive: true });
+  myVfs.writeFileSync(
+    '/app/node_modules/main-pkg/lib/entry.js',
+    'module.exports = { fromMain: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry4.js',
+    "module.exports = require('main-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry4.js`);
+  assert.strictEqual(result.fromMain, true);
+
+  myVfs.unmount();
+}
+
+// Test: Package without exports/main, fallback to index.js
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/index-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/index-pkg/package.json', JSON.stringify({
+    name: 'index-pkg',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/index-pkg/index.js',
+    'module.exports = { fromIndex: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry5.js',
+    "module.exports = require('index-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry5.js`);
+  assert.strictEqual(result.fromIndex, true);
+
+  myVfs.unmount();
+}
+
+// Test: Extension resolution (require without file extension)
+{
+  const myVfs = vfs.create();
+  // The embedded specifier must be an absolute mounted path, so mount first.
+  const mountPoint = myVfs.mount();
+  myVfs.mkdirSync(`${mountPoint}/lib`, { recursive: true });
+  myVfs.writeFileSync(`${mountPoint}/lib/utils.js`, 'module.exports = { ext: "js" };');
+  myVfs.writeFileSync(
+    `${mountPoint}/lib/main.js`,
+    `module.exports = require(${JSON.stringify(`${mountPoint}/lib/utils`)});`,
+  );
+
+  const result = require(`${mountPoint}/lib/main.js`);
+  assert.strictEqual(result.ext, 'js');
+
+  myVfs.unmount();
+}
+
+// Test: Extension resolution with .json
+{
+  const myVfs = vfs.create();
+  const mountPoint = myVfs.mount();
+  myVfs.writeFileSync(`${mountPoint}/data.json`, JSON.stringify({ ext: 'json' }));
+  myVfs.writeFileSync(
+    `${mountPoint}/reader.js`,
+    `module.exports = require(${JSON.stringify(`${mountPoint}/data`)});`,
+  );
+
+  const result = require(`${mountPoint}/reader.js`);
+  assert.strictEqual(result.ext, 'json');
+
+  myVfs.unmount();
+}
+
+// Test: Scoped package resolution (@scope/pkg)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/@myorg/mylib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/@myorg/mylib/package.json', JSON.stringify({
+    name: '@myorg/mylib',
+    type: 'module',
+    exports: './index.mjs',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/@myorg/mylib/index.mjs',
+    'export const scoped = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/scoped-entry.mjs',
+    "export { scoped } from '@myorg/mylib';",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/scoped-entry.mjs`));
+  assert.strictEqual(result.scoped, true);
+
+  myVfs.unmount();
+}
+
+// Test: Scoped package with subpath
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/@myorg/utils/lib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/@myorg/utils/package.json', JSON.stringify({
+    name: '@myorg/utils',
+    exports: {
+      '.': './lib/index.mjs',
+      './helpers': './lib/helpers.mjs',
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/@myorg/utils/lib/index.mjs',
+    'export const main = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/node_modules/@myorg/utils/lib/helpers.mjs',
+    'export const helpers = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/scoped-sub-entry.mjs',
+    `
+    import { helpers } from '@myorg/utils/helpers';
+    export { helpers };
+    `,
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/scoped-sub-entry.mjs`));
+  assert.strictEqual(result.helpers, true);
+
+  myVfs.unmount();
+}
+
+// Test: .js file with type: module in package.json -> ESM format
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/package.json', JSON.stringify({ type: 'module' }));
+  myVfs.writeFileSync('/mod.js', 'export const fromModule = true;');
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/mod.js`));
+  assert.strictEqual(result.fromModule, true);
+
+  myVfs.unmount();
+}
+
+// Test: .cjs always treated as CommonJS regardless of package type
+{
+  const myVfs = vfs.create();
+  const mountPoint = myVfs.mount();
+  myVfs.writeFileSync(`${mountPoint}/package.json`, JSON.stringify({ type: 'module' }));
+  myVfs.writeFileSync(`${mountPoint}/helper.cjs`, 'module.exports = { cjsAlways: true };');
+  myVfs.writeFileSync(
+    `${mountPoint}/use-cjs.js`,
+    `
+    import { createRequire } from 'module';
+    const require = createRequire(import.meta.url);
+    const result = require(${JSON.stringify(`${mountPoint}/helper.cjs`)});
+    export const cjsAlways = result.cjsAlways;
+    `,
+  );
+
+  const result = await import(vfsImport(`${mountPoint}/use-cjs.js`));
+  assert.strictEqual(result.cjsAlways, true);
+
+  myVfs.unmount();
+}
+
+// Test: file: URL specifier
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/fileurl.mjs', 'export const fromFileUrl = true;');
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/fileurl.mjs`));
+  assert.strictEqual(result.fromFileUrl, true);
+
+  myVfs.unmount();
+}
+
+// Test: Package with main field requiring extension resolution
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/dir-pkg', { recursive: true });
+  myVfs.writeFileSync('/dir-pkg/package.json', JSON.stringify({
+    name: 'dir-pkg',
+    main: './entry',
+  }));
+  myVfs.writeFileSync(
+    '/dir-pkg/entry.js',
+    'module.exports = { dirPkg: true };',
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/dir-pkg`);
+  assert.strictEqual(result.dirPkg, true);
+
+  myVfs.unmount();
+}
+
+// Test: Bare specifier with package subpath (no exports, direct file)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/direct-pkg/lib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/direct-pkg/package.json', JSON.stringify({
+    name: 'direct-pkg',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/direct-pkg/lib/util.js',
+    'module.exports = { directSub: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-sub.js',
+    "module.exports = require('direct-pkg/lib/util.js');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry-sub.js`);
+  assert.strictEqual(result.directSub, true);
+
+  myVfs.unmount();
+}
+
+// Test: Bare specifier subpath with extension resolution
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/ext-pkg/lib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/ext-pkg/package.json', JSON.stringify({
+    name: 'ext-pkg',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/ext-pkg/lib/util.js',
+    'module.exports = { extSub: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-ext.js',
+    "module.exports = require('ext-pkg/lib/util');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry-ext.js`);
+  assert.strictEqual(result.extSub, true);
+
+  myVfs.unmount();
+}
+
+// Test: Bare specifier main field with extension resolution
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/main-ext-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/main-ext-pkg/package.json', JSON.stringify({
+    name: 'main-ext-pkg',
+    main: './entry',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/main-ext-pkg/entry.js',
+    'module.exports = { mainExt: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-main-ext.js',
+    "module.exports = require('main-ext-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry-main-ext.js`);
+  assert.strictEqual(result.mainExt, true);
+
+  myVfs.unmount();
+}
+
+// Test: exports with array value (fallback array)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/arr-exp-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/arr-exp-pkg/package.json', JSON.stringify({
+    name: 'arr-exp-pkg',
+    exports: {
+      '.': ['./index.js', './fallback.js'],
+    },
+    main: './index.js',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/arr-exp-pkg/index.js',
+    'module.exports = { arrExport: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-arr.js',
+    "module.exports = require('arr-exp-pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry-arr.js`);
+  assert.strictEqual(result.arrExport, true);
+
+  myVfs.unmount();
+}
+
+// Test: Exports with "default" condition
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/default-pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/default-pkg/package.json', JSON.stringify({
+    name: 'default-pkg',
+    exports: {
+      '.': {
+        browser: './browser.js',
+        default: './default.mjs',
+      },
+    },
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/default-pkg/default.mjs',
+    'export const fromDefault = true;',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-default.mjs',
+    "export { fromDefault } from 'default-pkg';",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/app/entry-default.mjs`));
+  assert.strictEqual(result.fromDefault, true);
+
+  myVfs.unmount();
+}
+
+// Test: Package.json type "commonjs" explicitly set for .js
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/package.json', JSON.stringify({ type: 'commonjs' }));
+  myVfs.writeFileSync('/explicit-cjs.js', 'module.exports = { explicitCjs: true };');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/explicit-cjs.js`);
+  assert.strictEqual(result.explicitCjs, true);
+
+  myVfs.unmount();
+}
+
+// Test: .js file with no package.json -> defaults to commonjs
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/no-pkg.js', 'module.exports = { noPkg: true };');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/no-pkg.js`);
+  assert.strictEqual(result.noPkg, true);
+
+  myVfs.unmount();
+}
+
+// Test: Package.json type walk stops at node_modules boundary
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/package.json', JSON.stringify({ type: 'module' }));
+  myVfs.mkdirSync('/node_modules/inner', { recursive: true });
+  myVfs.writeFileSync(
+    '/node_modules/inner/index.js',
+    'module.exports = { inner: true };',
+  );
+  const mountPoint = myVfs.mount();
+
+  // Walk stops at node_modules; type:module from root is not inherited.
+  const result = require(`${mountPoint}/node_modules/inner/index.js`);
+  assert.strictEqual(result.inner, true);
+
+  myVfs.unmount();
+}
+
+// Test: Invalid package.json in directory resolution
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/bad-json-dir', { recursive: true });
+  myVfs.writeFileSync('/bad-json-dir/package.json', '{ invalid json }');
+  myVfs.writeFileSync(
+    '/bad-json-dir/index.js',
+    'module.exports = { fallbackIndex: true };',
+  );
+  const mountPoint = myVfs.mount();
+
+  // Malformed package.json raises ERR_INVALID_PACKAGE_CONFIG after nodejs/node#48606.
+  assert.throws(() => require(`${mountPoint}/bad-json-dir`),
+                { code: 'ERR_INVALID_PACKAGE_CONFIG' });
+
+  myVfs.unmount();
+}
+
+// Test: Invalid package.json in type walk-up
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/package.json', '{ broken json }');
+  myVfs.writeFileSync('/no-type.js', 'module.exports = { noType: true };');
+  const mountPoint = myVfs.mount();
+
+  assert.throws(() => require(`${mountPoint}/no-type.js`),
+                { code: 'ERR_INVALID_PACKAGE_CONFIG' });
+
+  myVfs.unmount();
+}
+
+// Test: Scoped package without slash (just @scope/name)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/@solo/pkg', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/@solo/pkg/package.json', JSON.stringify({
+    name: '@solo/pkg',
+    main: './index.js',
+  }));
+  myVfs.writeFileSync(
+    '/app/node_modules/@solo/pkg/index.js',
+    'module.exports = { solo: true };',
+  );
+  myVfs.writeFileSync(
+    '/app/entry-solo.js',
+    "module.exports = require('@solo/pkg');",
+  );
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/app/entry-solo.js`);
+  assert.strictEqual(result.solo, true);
+
+  myVfs.unmount();
+}
+
+// Test: node: builtin passthrough
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/use-builtin.mjs', `
+    import path from 'node:path';
+    export const sep = path.sep;
+  `);
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/use-builtin.mjs`));
+  assert.strictEqual(typeof result.sep, 'string');
+
+  myVfs.unmount();
+}
+
+// Test: JSON import with type assertion
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/data.json', JSON.stringify({ preformat: true }));
+  const mountPoint = myVfs.mount();
+
+  const result = await import(vfsImport(`${mountPoint}/data.json`), { with: { type: 'json' } });
+  assert.strictEqual(result.default.preformat, true);
+
+  myVfs.unmount();
+}
+
+// Test: File with unknown extension -> defaults to commonjs
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/data.txt', 'module.exports = { txt: true };');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/data.txt`);
+  assert.strictEqual(result.txt, true);
+
+  myVfs.unmount();
+}
diff --git a/test/parallel/test-vfs-mount-errors.js b/test/parallel/test-vfs-mount-errors.js
index 905f1c6d0683ab..dd0fef6064217c 100644
--- a/test/parallel/test-vfs-mount-errors.js
+++ b/test/parallel/test-vfs-mount-errors.js
@@ -3,30 +3,25 @@
 
 // Error paths in the VFS mount layer:
 // - EXDEV when renaming/linking across different VFS instances or VFS<->real
-// - lastunmount handler cleanup (vfsState.handlers becomes null again)
-// - rename of root mount point is rejected as overlapping
+// - last-unmount handler cleanup (vfsState.handlers becomes null again)
+// - namespace isolation between layers
 
 require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const vfs = require('node:vfs');
 const { vfsState } = require('internal/fs/utils');
 
-const baseMountPoint = path.resolve('/tmp/vfs-mount-errors-' + process.pid);
-let mountCounter = 0;
-const nextMount = () => baseMountPoint + '-' + (mountCounter++);
-
 // EXDEV: rename across two different VFS instances
 {
-  const mountA = nextMount();
-  const mountB = nextMount();
   const a = vfs.create();
   const b = vfs.create();
   a.writeFileSync('/file.txt', 'a');
   b.mkdirSync('/x', { recursive: true });
-  a.mount(mountA);
-  b.mount(mountB);
+  const mountA = a.mount();
+  const mountB = b.mount();
 
   assert.throws(
     () => fs.renameSync(path.join(mountA, 'file.txt'),
@@ -39,14 +34,12 @@ const nextMount = () => baseMountPoint + '-' + (mountCounter++);
 
 // EXDEV: copyFileSync across two different VFS instances
 {
-  const mountA = nextMount();
-  const mountB = nextMount();
   const a = vfs.create();
   const b = vfs.create();
   a.writeFileSync('/file.txt', 'a');
   b.mkdirSync('/x', { recursive: true });
-  a.mount(mountA);
-  b.mount(mountB);
+  const mountA = a.mount();
+  const mountB = b.mount();
 
   assert.throws(
     () => fs.copyFileSync(path.join(mountA, 'file.txt'),
@@ -59,14 +52,12 @@ const nextMount = () => baseMountPoint + '-' + (mountCounter++);
 
 // EXDEV: linkSync across two different VFS instances
 {
-  const mountA = nextMount();
-  const mountB = nextMount();
   const a = vfs.create();
   const b = vfs.create();
   a.writeFileSync('/file.txt', 'a');
   b.mkdirSync('/x', { recursive: true });
-  a.mount(mountA);
-  b.mount(mountB);
+  const mountA = a.mount();
+  const mountB = b.mount();
 
   assert.throws(
     () => fs.linkSync(path.join(mountA, 'file.txt'),
@@ -79,10 +70,9 @@ const nextMount = () => baseMountPoint + '-' + (mountCounter++);
 
 // EXDEV: rename from VFS to a real-fs path
 {
-  const mountA = nextMount();
   const a = vfs.create();
   a.writeFileSync('/file.txt', 'a');
-  a.mount(mountA);
+  const mountA = a.mount();
 
   const tmpReal = '/tmp/vfs-mount-real-' + process.pid + '.txt';
   assert.throws(
@@ -96,25 +86,25 @@ const nextMount = () => baseMountPoint + '-' + (mountCounter++);
 {
   assert.strictEqual(vfsState.handlers, null);
   const x = vfs.create();
-  x.mount(nextMount());
+  x.mount();
   assert.notStrictEqual(vfsState.handlers, null);
   x.unmount();
   assert.strictEqual(vfsState.handlers, null);
 
   // And it re-installs on a subsequent mount
   const y = vfs.create();
-  y.mount(nextMount());
+  y.mount();
   assert.notStrictEqual(vfsState.handlers, null);
   y.unmount();
   assert.strictEqual(vfsState.handlers, null);
 }
 
-// Two parallel non-overlapping mounts both register, last-out clears handlers
+// Two parallel mounts both register, last-out clears handlers
 {
   const a = vfs.create();
   const b = vfs.create();
-  a.mount(nextMount());
-  b.mount(nextMount());
+  a.mount();
+  b.mount();
   assert.notStrictEqual(vfsState.handlers, null);
   a.unmount();
   assert.notStrictEqual(vfsState.handlers, null);
@@ -122,38 +112,30 @@ const nextMount = () => baseMountPoint + '-' + (mountCounter++);
   assert.strictEqual(vfsState.handlers, null);
 }
 
-// Overlap detection: nested-under and parent-of both rejected
+// Namespace isolation: a path in an unmounted (or never-mounted) layer
+// namespace is not served by other active layers.
 {
-  const parent = nextMount();
-  const child = path.join(parent, 'child');
   const a = vfs.create();
   const b = vfs.create();
-  a.mount(parent);
-  assert.throws(() => b.mount(child), { code: 'ERR_INVALID_STATE' });
-  a.unmount();
-
-  // Reverse direction: child first, then parent rejected
-  const c = vfs.create();
-  const d = vfs.create();
-  c.mount(child);
-  assert.throws(() => d.mount(parent), { code: 'ERR_INVALID_STATE' });
-  c.unmount();
-}
-
-// Equal mount points: second one rejected
-{
-  const m = nextMount();
-  const a = vfs.create();
-  const b = vfs.create();
-  a.mount(m);
-  assert.throws(() => b.mount(m), { code: 'ERR_INVALID_STATE' });
+  a.writeFileSync('/f.txt', 'a');
+  b.writeFileSync('/f.txt', 'b');
+  const mountA = a.mount();
+  const mountB = b.mount();
+  assert.notStrictEqual(mountA, mountB);
+  b.unmount();
+  // B's namespace is dead even though A is still mounted.
+  assert.strictEqual(fs.existsSync(path.join(mountB, 'f.txt')), false);
+  assert.strictEqual(fs.readFileSync(path.join(mountA, 'f.txt'), 'utf8'), 'a');
+  // A malformed layer segment under the VFS root is not served either.
+  const bogus = path.join(os.devNull, 'vfs', 'not-a-number', 'f.txt');
+  assert.strictEqual(fs.existsSync(bogus), false);
   a.unmount();
 }
 
 // Double-mount of same instance rejected
 {
   const a = vfs.create();
-  a.mount(nextMount());
-  assert.throws(() => a.mount(nextMount()), { code: 'ERR_INVALID_STATE' });
+  a.mount();
+  assert.throws(() => a.mount(), { code: 'ERR_INVALID_STATE' });
   a.unmount();
 }
diff --git a/test/parallel/test-vfs-mount.js b/test/parallel/test-vfs-mount.js
index e59e39eef9713e..2334e7d1e7ec15 100644
--- a/test/parallel/test-vfs-mount.js
+++ b/test/parallel/test-vfs-mount.js
@@ -5,32 +5,37 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const vfs = require('node:vfs');
 
-// Basic mount/unmount API and dispatch through node:vfs from the public fs.
+// Mount points look like `${os.devNull}/vfs/<id>` where `<id>` is a decimal
+// integer segment. This regex captures that structural invariant without
+// tying the tests to a specific id.
+const mountPointShape = new RegExp(
+  `^${os.devNull.replace(/[\\^$.*+?()[\]{}|/\\\\]/g, '\\$&')}` +
+  `\\${path.sep}vfs\\${path.sep}\\d+$`,
+);
 
-const baseMountPoint = path.resolve('/tmp/vfs-mount-' + process.pid);
-let mountCounter = 0;
+// Basic mount/unmount API and dispatch through node:vfs from the public fs.
 
 function createMountedVfs() {
-  const mountPoint = baseMountPoint + '-' + (mountCounter++);
   const myVfs = vfs.create();
   myVfs.mkdirSync('/src', { recursive: true });
   myVfs.writeFileSync('/src/hello.txt', 'hello world');
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   return { myVfs, mountPoint };
 }
 
-// Test: mounted/mountPoint getters
+// Test: mounted/mountPoint getters; mount() returns a path under os.devNull.
 {
   const myVfs = vfs.create();
   assert.strictEqual(myVfs.mounted, false);
   assert.strictEqual(myVfs.mountPoint, null);
 
-  const mountPoint = baseMountPoint + '-' + (mountCounter++);
-  myVfs.mount(mountPoint);
+  const mountPoint = myVfs.mount();
   assert.strictEqual(myVfs.mounted, true);
   assert.strictEqual(myVfs.mountPoint, mountPoint);
+  assert.match(mountPoint, mountPointShape);
 
   myVfs.unmount();
   assert.strictEqual(myVfs.mounted, false);
@@ -40,22 +45,26 @@ function createMountedVfs() {
 // Test: double-mount throws
 {
   const myVfs = vfs.create();
-  const mountPoint = baseMountPoint + '-' + (mountCounter++);
-  myVfs.mount(mountPoint);
-  assert.throws(() => myVfs.mount(mountPoint), { code: 'ERR_INVALID_STATE' });
+  myVfs.mount();
+  assert.throws(() => myVfs.mount(), { code: 'ERR_INVALID_STATE' });
   myVfs.unmount();
 }
 
-// Test: overlapping mounts throw
+// Test: two instances get distinct mount points in their own layer namespace.
 {
   const a = vfs.create();
   const b = vfs.create();
-  const mountPoint = baseMountPoint + '-' + (mountCounter++);
-  a.mount(mountPoint);
-  assert.throws(() => b.mount(mountPoint), { code: 'ERR_INVALID_STATE' });
-  assert.throws(() => b.mount(path.join(mountPoint, 'inner')),
-                { code: 'ERR_INVALID_STATE' });
+  a.writeFileSync('/f.txt', 'A');
+  b.writeFileSync('/f.txt', 'B');
+  const mountA = a.mount();
+  const mountB = b.mount();
+  assert.notStrictEqual(mountA, mountB);
+  assert.match(mountA, mountPointShape);
+  assert.match(mountB, mountPointShape);
+  assert.strictEqual(fs.readFileSync(path.join(mountA, 'f.txt'), 'utf8'), 'A');
+  assert.strictEqual(fs.readFileSync(path.join(mountB, 'f.txt'), 'utf8'), 'B');
   a.unmount();
+  b.unmount();
 }
 
 // Test: fs.readFileSync intercepted
@@ -165,8 +174,7 @@ function createMountedVfs() {
 // Test: Symbol.dispose unmounts
 {
   const myVfs = vfs.create();
-  const mountPoint = baseMountPoint + '-' + (mountCounter++);
-  myVfs.mount(mountPoint);
+  myVfs.mount();
   assert.strictEqual(myVfs.mounted, true);
   myVfs[Symbol.dispose]();
   assert.strictEqual(myVfs.mounted, false);
diff --git a/test/parallel/test-vfs-multi-mount.js b/test/parallel/test-vfs-multi-mount.js
index 879f7cfcbf2b83..7539c0a6f02825 100644
--- a/test/parallel/test-vfs-multi-mount.js
+++ b/test/parallel/test-vfs-multi-mount.js
@@ -1,8 +1,8 @@
 // Flags: --experimental-vfs
 'use strict';
 
-// Two concurrent non-overlapping mounts must each route to its own VFS without
-// interference. Also exercises that the handler registry iterates and routes
+// Two concurrent mounts must each route to its own VFS without
+// interference. Also exercises that the layer registry routes
 // correctly when more than one VFS is active.
 
 require('../common');
@@ -11,9 +11,6 @@ const fs = require('fs');
 const path = require('path');
 const vfs = require('node:vfs');
 
-const baseA = path.resolve('/tmp/vfs-multi-a-' + process.pid);
-const baseB = path.resolve('/tmp/vfs-multi-b-' + process.pid);
-
 const a = vfs.create();
 a.writeFileSync('/file.txt', 'from-a');
 a.mkdirSync('/dir', { recursive: true });
@@ -24,8 +21,8 @@ b.writeFileSync('/file.txt', 'from-b');
 b.mkdirSync('/dir', { recursive: true });
 b.writeFileSync('/dir/inside.txt', 'b-inside');
 
-a.mount(baseA);
-b.mount(baseB);
+const baseA = a.mount();
+const baseB = b.mount();
 
 // Each mount sees its own content
 assert.strictEqual(fs.readFileSync(path.join(baseA, 'file.txt'), 'utf8'),
diff --git a/test/parallel/test-vfs-package-json-cache.js b/test/parallel/test-vfs-package-json-cache.js
new file mode 100644
index 00000000000000..423dad6e73684f
--- /dev/null
+++ b/test/parallel/test-vfs-package-json-cache.js
@@ -0,0 +1,21 @@
+// Flags: --experimental-vfs
+'use strict';
+
+// Package.json caches must be cleared on VFS unmount.
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const vfs = require('node:vfs');
+
+const myVfs = vfs.create();
+myVfs.mkdirSync('/pkg');
+myVfs.writeFileSync('/pkg/package.json', '{"name":"test","type":"module"}');
+myVfs.writeFileSync('/pkg/index.js', 'module.exports = 42');
+const mountPoint = myVfs.mount();
+
+assert.ok(fs.existsSync(`${mountPoint}/pkg/package.json`));
+
+myVfs.unmount();
+
+assert.strictEqual(fs.existsSync(`${mountPoint}/pkg/package.json`), false);
diff --git a/test/parallel/test-vfs-package-json.js b/test/parallel/test-vfs-package-json.js
new file mode 100644
index 00000000000000..9b8dbe8681237c
--- /dev/null
+++ b/test/parallel/test-vfs-package-json.js
@@ -0,0 +1,183 @@
+// Flags: --experimental-vfs --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const path = require('path');
+const vfs = require('node:vfs');
+
+// read() reads package.json from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg', { recursive: true });
+  myVfs.writeFileSync('/pkg/package.json', JSON.stringify({
+    name: 'test-pkg',
+    type: 'module',
+    main: './index.js',
+    exports: { '.': './index.js' },
+  }));
+  const mountPoint = myVfs.mount();
+
+  const packageJsonReader = require('internal/modules/package_json_reader');
+  const result = packageJsonReader.read(
+    path.join(mountPoint, 'pkg', 'package.json'), {},
+  );
+
+  assert.strictEqual(result.exists, true);
+  assert.strictEqual(result.name, 'test-pkg');
+  assert.strictEqual(result.type, 'module');
+  assert.strictEqual(result.main, './index.js');
+  assert.deepStrictEqual(result.exports, { '.': './index.js' });
+  assert.strictEqual(
+    result.pjsonPath,
+    path.join(mountPoint, 'pkg', 'package.json'),
+  );
+
+  // Non-existent package.json returns exists: false
+  const missing = packageJsonReader.read(
+    path.join(mountPoint, 'nope', 'package.json'), {},
+  );
+  assert.strictEqual(missing.exists, false);
+
+  myVfs.unmount();
+}
+
+// getNearestParentPackageJSON() walks up VFS directories
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/src/lib/deep', { recursive: true });
+  myVfs.writeFileSync('/app/package.json', JSON.stringify({
+    name: 'my-app',
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/app/src/lib/deep/module.js', '');
+  const mountPoint = myVfs.mount();
+
+  const packageJsonReader = require('internal/modules/package_json_reader');
+  const result = packageJsonReader.getNearestParentPackageJSON(
+    path.join(mountPoint, 'app', 'src', 'lib', 'deep', 'module.js'),
+  );
+
+  assert.ok(result);
+  assert.strictEqual(result.exists, true);
+  assert.strictEqual(result.data.name, 'my-app');
+  assert.strictEqual(result.data.type, 'module');
+  assert.strictEqual(
+    result.path,
+    path.join(mountPoint, 'app', 'package.json'),
+  );
+
+  myVfs.unmount();
+}
+
+// getPackageScopeConfig() returns correct scope from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/project/src', { recursive: true });
+  myVfs.writeFileSync('/project/package.json', JSON.stringify({
+    name: 'my-project',
+    type: 'commonjs',
+    exports: { '.': './main.js' },
+  }));
+  myVfs.writeFileSync('/project/src/index.js', '');
+  const mountPoint = myVfs.mount();
+
+  const packageJsonReader = require('internal/modules/package_json_reader');
+  const { pathToFileURL } = require('url');
+  const scopeUrl = pathToFileURL(
+    path.join(mountPoint, 'project', 'src', 'index.js'),
+  ).href;
+  const result = packageJsonReader.getPackageScopeConfig(scopeUrl);
+
+  assert.strictEqual(result.exists, true);
+  assert.strictEqual(result.type, 'commonjs');
+  assert.strictEqual(result.name, 'my-project');
+  assert.strictEqual(
+    result.pjsonPath,
+    path.join(mountPoint, 'project', 'package.json'),
+  );
+
+  // Path with no package.json returns exists: false
+  const myVfs2 = vfs.create();
+  myVfs2.mkdirSync('/empty/src', { recursive: true });
+  myVfs2.writeFileSync('/empty/src/file.js', '');
+  const mountPoint2 = myVfs2.mount();
+
+  const emptyUrl = pathToFileURL(
+    path.join(mountPoint2, 'empty', 'src', 'file.js'),
+  ).href;
+  const emptyResult = packageJsonReader.getPackageScopeConfig(emptyUrl);
+  assert.strictEqual(emptyResult.exists, false);
+
+  myVfs2.unmount();
+  myVfs.unmount();
+}
+
+// getPackageType() returns correct type from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/esm-app', { recursive: true });
+  myVfs.writeFileSync('/esm-app/package.json', JSON.stringify({
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/esm-app/index.js', '');
+  const mountPoint = myVfs.mount();
+
+  const packageJsonReader = require('internal/modules/package_json_reader');
+  const { pathToFileURL } = require('url');
+  const typeUrl = pathToFileURL(
+    path.join(mountPoint, 'esm-app', 'index.js'),
+  ).href;
+  const type = packageJsonReader.getPackageType(typeUrl);
+  assert.strictEqual(type, 'module');
+
+  // No package.json => 'none'
+  const myVfs2 = vfs.create();
+  myVfs2.mkdirSync('/bare', { recursive: true });
+  myVfs2.writeFileSync('/bare/file.js', '');
+  const mountPoint2 = myVfs2.mount();
+
+  const noneUrl = pathToFileURL(
+    path.join(mountPoint2, 'bare', 'file.js'),
+  ).href;
+  const noneType = packageJsonReader.getPackageType(noneUrl);
+  assert.strictEqual(noneType, 'none');
+
+  myVfs2.unmount();
+  myVfs.unmount();
+}
+
+// End-to-end CJS require with package.json type detection
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/cjs-app', { recursive: true });
+  myVfs.writeFileSync('/cjs-app/package.json', JSON.stringify({
+    name: 'cjs-app',
+    type: 'commonjs',
+  }));
+  myVfs.writeFileSync('/cjs-app/main.js',
+                      'module.exports = { format: "cjs", ok: true };');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/cjs-app/main.js`);
+  assert.strictEqual(result.format, 'cjs');
+  assert.strictEqual(result.ok, true);
+
+  myVfs.unmount();
+}
+
+// End-to-end ESM import with VFS package type
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/esm', { recursive: true });
+  myVfs.writeFileSync('/esm/package.json', JSON.stringify({
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/esm/mod.mjs', 'export const x = 42;');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/esm/mod.mjs`);
+  assert.strictEqual(mod.x, 42);
+
+  myVfs.unmount();
+}
diff --git a/test/parallel/test-vfs-require.js b/test/parallel/test-vfs-require.js
new file mode 100644
index 00000000000000..3e686967227270
--- /dev/null
+++ b/test/parallel/test-vfs-require.js
@@ -0,0 +1,411 @@
+// Flags: --experimental-vfs
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('node:url');
+const vfs = require('node:vfs');
+
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// Test requiring a simple virtual module
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/hello.js', 'module.exports = "hello from vfs";');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/hello.js`);
+  assert.strictEqual(result, 'hello from vfs');
+
+  myVfs.unmount();
+}
+
+// Test requiring a virtual module that exports an object
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/config.js', `
+    module.exports = {
+      name: 'test-config',
+      version: '1.0.0',
+      getValue: function() { return 42; }
+    };
+  `);
+  const mountPoint = myVfs.mount();
+
+  const config = require(`${mountPoint}/config.js`);
+  assert.strictEqual(config.name, 'test-config');
+  assert.strictEqual(config.version, '1.0.0');
+  assert.strictEqual(config.getValue(), 42);
+
+  myVfs.unmount();
+}
+
+// Test requiring a virtual module that requires another virtual module.
+// Mount first so the embedded absolute specifier can use the mount point.
+{
+  const myVfs = vfs.create();
+  const mountPoint = myVfs.mount();
+  myVfs.writeFileSync(`${mountPoint}/utils.js`, `
+    module.exports = {
+      add: function(a, b) { return a + b; }
+    };
+  `);
+  myVfs.writeFileSync(`${mountPoint}/main.js`, `
+    const utils = require(${JSON.stringify(`${mountPoint}/utils.js`)});
+    module.exports = {
+      sum: utils.add(10, 20)
+    };
+  `);
+
+  const main = require(`${mountPoint}/main.js`);
+  assert.strictEqual(main.sum, 30);
+
+  myVfs.unmount();
+}
+
+// Test requiring a JSON file from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/data.json', JSON.stringify({
+    items: [1, 2, 3],
+    enabled: true,
+  }));
+  const mountPoint = myVfs.mount();
+
+  const data = require(`${mountPoint}/data.json`);
+  assert.deepStrictEqual(data.items, [1, 2, 3]);
+  assert.strictEqual(data.enabled, true);
+
+  myVfs.unmount();
+}
+
+// Test virtual package.json resolution
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/my-package', { recursive: true });
+  myVfs.writeFileSync('/my-package/package.json', JSON.stringify({
+    name: 'my-package',
+    main: 'index.js',
+  }));
+  myVfs.writeFileSync('/my-package/index.js', `
+    module.exports = { loaded: true };
+  `);
+  const mountPoint = myVfs.mount();
+
+  const pkg = require(`${mountPoint}/my-package`);
+  assert.strictEqual(pkg.loaded, true);
+
+  myVfs.unmount();
+}
+
+// Test that real modules still work when VFS is mounted
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/test.js', 'module.exports = 1;');
+  myVfs.mount();
+
+  assert.strictEqual(typeof assert.strictEqual, 'function');
+
+  const commonMod = require('../common');
+  assert.ok(commonMod);
+
+  myVfs.unmount();
+}
+
+// Test require with relative paths inside VFS module
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/lib', { recursive: true });
+  myVfs.writeFileSync('/lib/helper.js', `
+    module.exports = { help: function() { return 'helped'; } };
+  `);
+  myVfs.writeFileSync('/lib/index.js', `
+    const helper = require('./helper.js');
+    module.exports = helper.help();
+  `);
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/lib/index.js`);
+  assert.strictEqual(result, 'helped');
+
+  myVfs.unmount();
+}
+
+// Test fs.readFileSync interception when VFS is active
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/file.txt', 'virtual content');
+  const mountPoint = myVfs.mount();
+
+  const content = fs.readFileSync(`${mountPoint}/file.txt`, 'utf8');
+  assert.strictEqual(content, 'virtual content');
+
+  myVfs.unmount();
+}
+
+// Test requiring an ESM .mjs module from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/esm.mjs', 'export const msg = "hello from esm";');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/esm.mjs`);
+  assert.strictEqual(mod.msg, 'hello from esm');
+
+  myVfs.unmount();
+}
+
+// Test requiring an ESM .mjs module with default export from VFS
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/esm-default.mjs', 'export default function() { return 42; }');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/esm-default.mjs`);
+  assert.strictEqual(mod.default(), 42);
+
+  myVfs.unmount();
+}
+
+// Test require(esm): .js file detected as ESM via VFS package.json type:module
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app', { recursive: true });
+  myVfs.writeFileSync('/app/package.json', JSON.stringify({
+    name: 'esm-app',
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/app/lib.js',
+                      'export const value = 42;' +
+                      ' export function hello() { return "hi"; }');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/app/lib.js`);
+  assert.strictEqual(mod.value, 42);
+  assert.strictEqual(mod.hello(), 'hi');
+
+  myVfs.unmount();
+}
+
+// Test require(esm): nested .js walks up to parent package.json in VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/project/src/utils', { recursive: true });
+  myVfs.writeFileSync('/project/package.json', JSON.stringify({
+    name: 'nested-esm',
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/project/src/utils/math.js',
+                      'export const add = (a, b) => a + b;' +
+                      ' export default 99;');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/project/src/utils/math.js`);
+  assert.strictEqual(mod.add(3, 4), 7);
+  assert.strictEqual(mod.default, 99);
+
+  myVfs.unmount();
+}
+
+// Test require(esm): .js without type field stays CJS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/cjs-app', { recursive: true });
+  myVfs.writeFileSync('/cjs-app/package.json', JSON.stringify({
+    name: 'cjs-app',
+  }));
+  myVfs.writeFileSync('/cjs-app/index.js',
+                      'module.exports = { cjs: true };');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/cjs-app/index.js`);
+  assert.strictEqual(mod.cjs, true);
+
+  myVfs.unmount();
+}
+
+// Test require(esm): ESM .js that imports another ESM .js in VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/multi/src', { recursive: true });
+  myVfs.writeFileSync('/multi/package.json', JSON.stringify({
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/multi/src/dep.js', 'export const X = 100;');
+  myVfs.writeFileSync('/multi/src/main.js',
+                      'import { X } from "./dep.js";' +
+                      ' export const result = X + 1;');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/multi/src/main.js`);
+  assert.strictEqual(mod.result, 101);
+
+  myVfs.unmount();
+}
+
+// Test require(esm): .mjs without any package.json loads as ESM
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/no-pkg.mjs',
+                      'export const x = 1; export default "hello";');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/no-pkg.mjs`);
+  assert.strictEqual(mod.x, 1);
+  assert.strictEqual(mod.default, 'hello');
+
+  myVfs.unmount();
+}
+
+// Test require(esm): .mjs with package.json that has no type field
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app', { recursive: true });
+  myVfs.writeFileSync('/app/package.json',
+                      JSON.stringify({ name: 'no-type' }));
+  myVfs.writeFileSync('/app/lib.mjs', 'export const val = 42;');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/app/lib.mjs`);
+  assert.strictEqual(mod.val, 42);
+
+  myVfs.unmount();
+}
+
+// Test require(esm): .mjs in type:commonjs package still loads as ESM
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/cjs-pkg', { recursive: true });
+  myVfs.writeFileSync('/cjs-pkg/package.json', JSON.stringify({
+    name: 'cjs-pkg',
+    type: 'commonjs',
+  }));
+  myVfs.writeFileSync('/cjs-pkg/esm.mjs', 'export const z = 99;');
+  const mountPoint = myVfs.mount();
+
+  const mod = require(`${mountPoint}/cjs-pkg/esm.mjs`);
+  assert.strictEqual(mod.z, 99);
+
+  myVfs.unmount();
+}
+
+// Test CJS: package with "main" field resolves through VFS
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg/lib', { recursive: true });
+  myVfs.writeFileSync('/pkg/package.json', JSON.stringify({
+    name: 'legacy-main-pkg',
+    main: './lib/entry',
+  }));
+  myVfs.writeFileSync('/pkg/lib/entry.js', 'module.exports = "legacy-main";');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/pkg`);
+  assert.strictEqual(result, 'legacy-main');
+
+  myVfs.unmount();
+}
+
+// Test CJS: package with no "main" field resolves index.js
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/pkg2', { recursive: true });
+  myVfs.writeFileSync('/pkg2/package.json', JSON.stringify({
+    name: 'no-main-pkg',
+  }));
+  myVfs.writeFileSync('/pkg2/index.js', 'module.exports = "index-fallback";');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/pkg2`);
+  assert.strictEqual(result, 'index-fallback');
+
+  myVfs.unmount();
+}
+
+// Test ESM legacyMainResolve: import() a VFS package with "main" (no "exports")
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app/node_modules/esm-legacy-main/lib', { recursive: true });
+  myVfs.writeFileSync('/app/node_modules/esm-legacy-main/package.json', JSON.stringify({
+    name: 'esm-legacy-main',
+    type: 'module',
+    main: './lib/entry.js',
+  }));
+  myVfs.writeFileSync('/app/node_modules/esm-legacy-main/lib/entry.js',
+                      'export const value = "esm-legacy-main";');
+  myVfs.writeFileSync('/app/main.mjs',
+                      'export { value } from "esm-legacy-main";');
+  const mountPoint = myVfs.mount();
+
+  import(vfsImport(`${mountPoint}/app/main.mjs`)).then(common.mustCall((mod) => {
+    assert.strictEqual(mod.value, 'esm-legacy-main');
+    myVfs.unmount();
+  }));
+}
+
+// Test ESM legacyMainResolve: import() a VFS package with no "main" (index.js fallback)
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/app2/node_modules/esm-nomain', { recursive: true });
+  myVfs.writeFileSync('/app2/node_modules/esm-nomain/package.json', JSON.stringify({
+    name: 'esm-nomain',
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/app2/node_modules/esm-nomain/index.js',
+                      'export const value = "esm-index-fallback";');
+  myVfs.writeFileSync('/app2/main.mjs',
+                      'export { value } from "esm-nomain";');
+  const mountPoint = myVfs.mount();
+
+  import(vfsImport(`${mountPoint}/app2/main.mjs`)).then(common.mustCall((mod) => {
+    assert.strictEqual(mod.value, 'esm-index-fallback');
+    myVfs.unmount();
+  }));
+}
+
+// Test getFormatOfExtensionlessFile: extensionless JS file in type:module package
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/esm-pkg', { recursive: true });
+  myVfs.writeFileSync('/esm-pkg/package.json', JSON.stringify({
+    name: 'esm-pkg',
+    type: 'module',
+  }));
+  myVfs.writeFileSync('/esm-pkg/entry', 'export const x = 123;');
+  const mountPoint = myVfs.mount();
+
+  import(vfsImport(`${mountPoint}/esm-pkg/entry`)).then(common.mustCall((mod) => {
+    assert.strictEqual(mod.x, 123);
+    myVfs.unmount();
+  }));
+}
+
+// Test that unmounting stops interception
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/unmount-test.js', 'module.exports = "before unmount";');
+  const mountPoint = myVfs.mount();
+
+  const result = require(`${mountPoint}/unmount-test.js`);
+  assert.strictEqual(result, 'before unmount');
+
+  myVfs.unmount();
+
+  // On Windows, the native loader may surface the NUL-backed former mount
+  // path as ERR_INVALID_PACKAGE_CONFIG while probing for package.json.
+  assert.throws(() => {
+    delete require.cache[path.join(mountPoint, 'unmount-test.js')];
+    require(`${mountPoint}/unmount-test.js`);
+  }, (err) => {
+    if (common.isWindows) {
+      assert.ok(
+        ['ERR_INVALID_PACKAGE_CONFIG', 'MODULE_NOT_FOUND'].includes(err.code),
+      );
+    } else {
+      assert.strictEqual(err.code, 'MODULE_NOT_FOUND');
+    }
+    return true;
+  });
+}
diff --git a/test/parallel/test-vfs-router.js b/test/parallel/test-vfs-router.js
index 864a684f5c2df4..292e33e7379acd 100644
--- a/test/parallel/test-vfs-router.js
+++ b/test/parallel/test-vfs-router.js
@@ -9,38 +9,11 @@
 require('../common');
 const assert = require('assert');
 const path = require('path');
-const { isUnderMountPoint, getRelativePath, isAbsolutePath } =
-  require('internal/vfs/router');
+const { getRelativePath } = require('internal/vfs/router');
 
 const mount = path.resolve('/app');
 const nested = path.join(mount, 'src', 'index.js');
 
-// isUnderMountPoint: equal paths are always considered "under"
-assert.strictEqual(isUnderMountPoint(mount, mount), true);
-
-// isUnderMountPoint: nested paths
-assert.strictEqual(isUnderMountPoint(nested, mount), true);
-
-// isUnderMountPoint: rejects sibling paths that share the prefix string
-assert.strictEqual(
-  isUnderMountPoint(path.resolve('/app2/index.js'), mount), false,
-);
-assert.strictEqual(isUnderMountPoint(path.resolve('/applebrick'), mount),
-                   false);
-
-// isUnderMountPoint: rejects an unrelated absolute path
-assert.strictEqual(isUnderMountPoint(path.resolve('/other'), mount), false);
-
-// isUnderMountPoint: root mount matches any absolute path on POSIX.
-// On Windows the root mount '/' resolves to a drive-letter root, so the
-// special-case in router.js only applies when mountPoint === '/'. Skip the
-// root-mount checks where they would not be representative on Windows.
-if (process.platform !== 'win32') {
-  assert.strictEqual(isUnderMountPoint('/anywhere', '/'), true);
-  assert.strictEqual(isUnderMountPoint('/', '/'), true);
-  assert.strictEqual(isUnderMountPoint('/a/b/c', '/'), true);
-}
-
 // getRelativePath: equal => '/'
 assert.strictEqual(getRelativePath(mount, mount), '/');
 
@@ -48,16 +21,7 @@ assert.strictEqual(getRelativePath(mount, mount), '/');
 // the platform-native input separators.
 assert.strictEqual(getRelativePath(nested, mount), '/src/index.js');
 
-// getRelativePath: root mount returns the original (already absolute) path
-if (process.platform !== 'win32') {
-  assert.strictEqual(getRelativePath('/foo/bar', '/'), '/foo/bar');
-}
-
 // getRelativePath: deeper nesting
 const mountA = path.resolve('/m/a');
 const deep = path.join(mountA, 'b', 'c', 'd');
 assert.strictEqual(getRelativePath(deep, mountA), '/b/c/d');
-
-// isAbsolutePath is re-exported from node:path
-assert.strictEqual(isAbsolutePath(path.resolve('/foo')), true);
-assert.strictEqual(isAbsolutePath('foo'), false);
diff --git a/test/parallel/test-vfs-scoped-cache-purge.js b/test/parallel/test-vfs-scoped-cache-purge.js
new file mode 100644
index 00000000000000..104089cd4a23d3
--- /dev/null
+++ b/test/parallel/test-vfs-scoped-cache-purge.js
@@ -0,0 +1,57 @@
+// Flags: --experimental-vfs
+'use strict';
+
+// Deregistering one VFS must scope-purge loader caches: entries under the
+// unmounted mount point are dropped, entries from other VFSes are kept.
+
+const common = require('../common');
+const assert = require('assert');
+const { pathToFileURL } = require('node:url');
+const vfs = require('node:vfs');
+
+const vfsImport = (path) => pathToFileURL(path).href;
+
+// Multi-mount: deregistering one VFS keeps the other's CJS require.cache warm.
+{
+  const a = vfs.create();
+  a.writeFileSync('/value.js', 'module.exports = "a-cached"');
+  const mountA = a.mount();
+
+  const b = vfs.create();
+  b.writeFileSync('/value.js', 'module.exports = "b-cached"');
+  const mountB = b.mount();
+
+  assert.strictEqual(require(`${mountA}/value.js`), 'a-cached');
+  assert.strictEqual(require(`${mountB}/value.js`), 'b-cached');
+
+  const bKey = require.resolve(`${mountB}/value.js`);
+  assert.ok(bKey in require.cache, 'b should be cached before unmount');
+
+  a.unmount();
+  assert.ok(
+    bKey in require.cache,
+    'unmounting a different VFS must not evict b\'s cache entry',
+  );
+
+  assert.strictEqual(require(`${mountB}/value.js`), 'b-cached');
+
+  b.unmount();
+}
+
+// import.meta.url is the plain file URL under the mount point, and repeated
+// dynamic imports (including via import.meta.resolve) return the same namespace.
+(async () => {
+  const v = vfs.create();
+  v.writeFileSync('/m.mjs',
+                  'export const url = import.meta.url;\n' +
+                  'export const resolved = import.meta.resolve("./m.mjs");');
+  const mountPoint = v.mount();
+
+  const ns = await import(vfsImport(`${mountPoint}/m.mjs`));
+  assert.strictEqual(ns.url, pathToFileURL(`${mountPoint}/m.mjs`).href);
+
+  const nsAgain = await import(ns.resolved);
+  assert.strictEqual(ns, nsAgain);
+
+  v.unmount();
+})().then(common.mustCall());