vfs: add VFS-aware wrappers for package.json reader methods

Wrap modulesBinding.readPackageJSON(), getNearestParentPackageJSON(),
getPackageScopeConfig(), and getPackageType() with toggleable overrides
so that VFS-mounted package.json files are read from virtual storage
instead of the real filesystem. This fixes syntax detection and error
decoration that re-read package.json bypassing VFS.

The implementation follows the existing loaderStat/loaderReadFile toggle
pattern in helpers.js.

Author: mcollina

lib/internal/modules/helpers.js

@@ -36,12 +36,13 @@ 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) => {
@@ -112,6 +113,79 @@ function toRealPath(requestPath) {
   });
 }
 
+// Toggleable overrides for package.json C++ methods (VFS support).
+let _loaderReadPackageJSON = null;
+let _loaderGetNearestParentPackageJSON = null;
+let _loaderGetPackageScopeConfig = null;
+let _loaderGetPackageType = null;
+
+/**
+ * Set override functions for the module loader's package.json operations.
+ * @param {{
+ *   readPackageJSON?: Function,
+ *   getNearestParentPackageJSON?: Function,
+ *   getPackageScopeConfig?: Function,
+ *   getPackageType?: Function,
+ * }} overrides
+ */
+function setLoaderPackageOverrides(overrides) {
+  _loaderReadPackageJSON = overrides.readPackageJSON;
+  _loaderGetNearestParentPackageJSON = overrides.getNearestParentPackageJSON;
+  _loaderGetPackageScopeConfig = overrides.getPackageScopeConfig;
+  _loaderGetPackageType = overrides.getPackageType;
+}
+
+/**
+ * Wrapper for modulesBinding.readPackageJSON that supports VFS toggle.
+ * @param {string} jsonPath
+ * @param {boolean} isESM
+ * @param {string} base
+ * @param {string} specifier
+ * @returns {SerializedPackageConfig|undefined}
+ */
+function loaderReadPackageJSON(jsonPath, isESM, base, specifier) {
+  if (_loaderReadPackageJSON !== null) {
+    return _loaderReadPackageJSON(jsonPath, isESM, base, specifier);
+  }
+  return modulesBinding.readPackageJSON(jsonPath, isESM, base, specifier);
+}
+
+/**
+ * Wrapper for modulesBinding.getNearestParentPackageJSON that supports VFS toggle.
+ * @param {string} checkPath
+ * @returns {SerializedPackageConfig|undefined}
+ */
+function loaderGetNearestParentPackageJSON(checkPath) {
+  if (_loaderGetNearestParentPackageJSON !== null) {
+    return _loaderGetNearestParentPackageJSON(checkPath);
+  }
+  return modulesBinding.getNearestParentPackageJSON(checkPath);
+}
+
+/**
+ * Wrapper for modulesBinding.getPackageScopeConfig that supports VFS toggle.
+ * @param {string} resolved
+ * @returns {SerializedPackageConfig|string}
+ */
+function loaderGetPackageScopeConfig(resolved) {
+  if (_loaderGetPackageScopeConfig !== null) {
+    return _loaderGetPackageScopeConfig(resolved);
+  }
+  return modulesBinding.getPackageScopeConfig(resolved);
+}
+
+/**
+ * Wrapper for modulesBinding.getPackageType that supports VFS toggle.
+ * @param {string} url
+ * @returns {string|undefined}
+ */
+function loaderGetPackageType(url) {
+  if (_loaderGetPackageType !== null) {
+    return _loaderGetPackageType(url);
+  }
+  return modulesBinding.getPackageType(url);
+}
+
 /** @type {Set<string>} */
 let cjsConditions;
 /** @type {string[]} */
@@ -569,13 +643,18 @@ module.exports = {
   getCjsConditionsArray,
   getCompileCacheDir,
   initializeCjsConditions,
+  loaderGetNearestParentPackageJSON,
+  loaderGetPackageScopeConfig,
+  loaderGetPackageType,
   loaderReadFile,
+  loaderReadPackageJSON,
   loaderStat,
   loadBuiltinModuleForEmbedder,
   loadBuiltinModule,
   makeRequireFunction,
   normalizeReferrerURL,
   setLoaderFsOverrides,
+  setLoaderPackageOverrides,
   stringify,
   stripBOM,
   toRealPath,

lib/internal/modules/package_json_reader.js

@@ -24,10 +24,15 @@ const {
   },
 } = require('internal/errors');
 const { kEmptyObject } = require('internal/util');
-const modulesBinding = internalBinding('modules');
 const path = require('path');
 const { validateString } = require('internal/validators');
-const { loaderStat } = require('internal/modules/helpers');
+const {
+  loaderGetNearestParentPackageJSON,
+  loaderGetPackageScopeConfig,
+  loaderGetPackageType,
+  loaderReadPackageJSON,
+  loaderStat,
+} = require('internal/modules/helpers');
 
 
 /**
@@ -122,7 +127,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 +175,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 +195,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 +224,7 @@ function getPackageScopeConfig(resolved) {
  * @returns {string}
  */
 function getPackageType(url) {
-  const type = modulesBinding.getPackageType(`${url}`);
+  const type = loaderGetPackageType(`${url}`);
   return type ?? 'none';
 }
 

lib/internal/vfs/module_hooks.js

@@ -7,6 +7,7 @@ const {
   ArrayPrototypeSplice,
   FunctionPrototypeCall,
   JSONParse,
+  JSONStringify,
   ObjectGetOwnPropertyNames,
   String,
   StringPrototypeEndsWith,
@@ -870,6 +871,60 @@ function vfsLoadHook(url, context, nextLoad) {
   return nextLoad(url, context);
 }
 
+/**
+ * Serialize a parsed package.json object into the C++ tuple format
+ * expected by deserializePackageJSON: [name, main, type, imports, exports, filePath].
+ * @param {object} parsed The parsed package.json content
+ * @param {string} filePath The path to the package.json file
+ * @returns {Array} Serialized package config tuple
+ */
+function serializePackageJSON(parsed, filePath) {
+  const name = parsed.name;
+  const main = parsed.main;
+  const type = parsed.type ?? 'none';
+  const imports = parsed.imports !== undefined ?
+    (typeof parsed.imports === 'string' ?
+      parsed.imports : JSONStringify(parsed.imports)) :
+    undefined;
+  const exports = parsed.exports !== undefined ?
+    (typeof parsed.exports === 'string' ?
+      parsed.exports : JSONStringify(parsed.exports)) :
+    undefined;
+  return [name, main, type, imports, exports, filePath];
+}
+
+/**
+ * Walk up directories in VFS looking for package.json.
+ * @param {string} startPath Normalized absolute path to start from
+ * @returns {{ vfs: VirtualFileSystem, pjsonPath: string, parsed: object }|null}
+ */
+function findVFSPackageJSON(startPath) {
+  let currentDir = dirname(startPath);
+  let lastDir;
+  while (currentDir !== lastDir) {
+    if (StringPrototypeEndsWith(currentDir, '/node_modules') ||
+        StringPrototypeEndsWith(currentDir, '\\node_modules')) {
+      break;
+    }
+    const pjsonPath = resolve(currentDir, 'package.json');
+    for (let i = 0; i < activeVFSList.length; i++) {
+      const vfs = activeVFSList[i];
+      if (vfs.shouldHandle(pjsonPath) && vfsStat(vfs, pjsonPath) === 0) {
+        try {
+          const content = vfs.readFileSync(pjsonPath, 'utf8');
+          const parsed = JSONParse(content);
+          return { vfs, pjsonPath, parsed };
+        } catch {
+          // Invalid JSON, continue walking
+        }
+      }
+    }
+    lastDir = currentDir;
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+
 /**
  * Install module loading hooks via Module.registerHooks.
  * Both CJS and ESM go through the hooks chain. When both hooks
@@ -1086,7 +1141,10 @@ function installFsPatches() {
  * references to the original fs methods.
  */
 function installModuleLoaderOverrides() {
-  const { setLoaderFsOverrides } = require('internal/modules/helpers');
+  const {
+    setLoaderFsOverrides,
+    setLoaderPackageOverrides,
+  } = require('internal/modules/helpers');
   setLoaderFsOverrides({
     stat(filename) {
       const result = findVFSForStat(filename);
@@ -1104,6 +1162,92 @@ function installModuleLoaderOverrides() {
       return result !== null ? result.realpath : undefined;
     },
   });
+  const nativeModulesBinding = internalBinding('modules');
+  setLoaderPackageOverrides({
+    readPackageJSON(jsonPath, isESM, base, specifier) {
+      const normalized = resolve(jsonPath);
+      for (let i = 0; i < activeVFSList.length; i++) {
+        const vfs = activeVFSList[i];
+        if (!vfs.shouldHandle(normalized)) continue;
+        if (vfsStat(vfs, normalized) !== 0) return undefined;
+        try {
+          const content = vfs.readFileSync(normalized, 'utf8');
+          const parsed = JSONParse(content);
+          return serializePackageJSON(parsed, normalized);
+        } catch {
+          return undefined;
+        }
+      }
+      return nativeModulesBinding.readPackageJSON(
+        jsonPath, isESM, base, specifier);
+    },
+    getNearestParentPackageJSON(checkPath) {
+      const normalized = resolve(checkPath);
+      // Check if this path is within any VFS
+      for (let i = 0; i < activeVFSList.length; i++) {
+        if (activeVFSList[i].shouldHandle(normalized)) {
+          const found = findVFSPackageJSON(normalized);
+          if (found !== null) {
+            return serializePackageJSON(found.parsed, found.pjsonPath);
+          }
+          // Path is in VFS but no package.json found
+          return undefined;
+        }
+      }
+      return nativeModulesBinding.getNearestParentPackageJSON(checkPath);
+    },
+    getPackageScopeConfig(resolved) {
+      // Resolved is a URL string like 'file:///path/to/file.js'
+      let filePath;
+      if (StringPrototypeStartsWith(resolved, 'file:')) {
+        try {
+          filePath = fileURLToPath(resolved);
+        } catch {
+          return nativeModulesBinding.getPackageScopeConfig(resolved);
+        }
+      } else {
+        filePath = resolved;
+      }
+      const normalized = resolve(filePath);
+      for (let i = 0; i < activeVFSList.length; i++) {
+        if (activeVFSList[i].shouldHandle(normalized)) {
+          const found = findVFSPackageJSON(normalized);
+          if (found !== null) {
+            return serializePackageJSON(found.parsed, found.pjsonPath);
+          }
+          // Not found in VFS - return string path (matching C++ behavior)
+          return resolve(dirname(normalized), 'package.json');
+        }
+      }
+      return nativeModulesBinding.getPackageScopeConfig(resolved);
+    },
+    getPackageType(url) {
+      let filePath;
+      if (StringPrototypeStartsWith(url, 'file:')) {
+        try {
+          filePath = fileURLToPath(url);
+        } catch {
+          return nativeModulesBinding.getPackageType(url);
+        }
+      } else {
+        filePath = url;
+      }
+      const normalized = resolve(filePath);
+      for (let i = 0; i < activeVFSList.length; i++) {
+        if (activeVFSList[i].shouldHandle(normalized)) {
+          const found = findVFSPackageJSON(normalized);
+          if (found !== null) {
+            const type = found.parsed.type;
+            if (type === 'module' || type === 'commonjs') {
+              return type;
+            }
+          }
+          return undefined;
+        }
+      }
+      return nativeModulesBinding.getPackageType(url);
+    },
+  });
 }
 
 /**