vfs: make package.json reader VFS-aware

The C++ package.json reader reads files via libuv, bypassing VFS
entirely. This means "exports", "imports", and "type" fields in
package.json don't work for VFS packages.

Add toggleable wrappers to package_json_reader.js (same pattern as
helpers.js) for read, getPackageScopeConfig, getPackageType, and
getNearestParentPackageJSON. When VFS is active, module_hooks.js
registers overrides that read from VFS and reimplement upward
directory walks in JS. When VFS is inactive, the fast C++ path is
used unchanged.

Also fix getPackageJSONURL to use the toggleable internalModuleStat
from helpers instead of the captured internalFsBinding, and update
getFormatFromExtension to use the now-VFS-aware getPackageType.

Author: mcollina

lib/internal/modules/package_json_reader.js

@@ -27,7 +27,6 @@ const { kEmptyObject } = require('internal/util');
 const modulesBinding = internalBinding('modules');
 const path = require('path');
 const { validateString } = require('internal/validators');
-const internalFsBinding = internalBinding('fs');
 
 
 /**
@@ -36,6 +35,27 @@ const internalFsBinding = internalBinding('fs');
  * @typedef {import('typings/internalBinding/modules').SerializedPackageConfig} SerializedPackageConfig
  */
 
+let customRead = null;
+let customGetPackageScopeConfig = null;
+let customGetPackageType = null;
+let customGetNearestParentPackageJSON = null;
+
+function setCustomRead(fn) {
+  customRead = fn;
+}
+
+function setCustomGetPackageScopeConfig(fn) {
+  customGetPackageScopeConfig = fn;
+}
+
+function setCustomGetPackageType(fn) {
+  customGetPackageType = fn;
+}
+
+function setCustomGetNearestParentPackageJSON(fn) {
+  customGetNearestParentPackageJSON = fn;
+}
+
 /**
  * @param {URL['pathname']} path
  * @param {SerializedPackageConfig} contents
@@ -116,10 +136,17 @@ const requiresJSONParse = (value) => (value !== undefined && (value[0] === '[' |
  *   base?: URL | string,
  *   specifier?: URL | string,
  *   isESM?: boolean,
- * }} options
+ * }} opts
  * @returns {PackageConfig}
  */
-function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
+function read(jsonPath, opts) {
+  if (customRead !== null) {
+    return customRead(jsonPath, opts, defaultRead);
+  }
+  return defaultRead(jsonPath, opts);
+}
+
+function defaultRead(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(
@@ -165,6 +192,13 @@ const deserializedPackageJSONCache = new SafeMap();
  * @returns {undefined | DeserializedPackageConfig}
  */
 function getNearestParentPackageJSON(checkPath) {
+  if (customGetNearestParentPackageJSON !== null) {
+    return customGetNearestParentPackageJSON(checkPath, defaultGetNearestParentPackageJSON);
+  }
+  return defaultGetNearestParentPackageJSON(checkPath);
+}
+
+function defaultGetNearestParentPackageJSON(checkPath) {
   const parentPackageJSONPath = moduleToParentPackageJSONCache.get(checkPath);
   if (parentPackageJSONPath !== undefined) {
     return deserializedPackageJSONCache.get(parentPackageJSONPath);
@@ -190,6 +224,13 @@ function getNearestParentPackageJSON(checkPath) {
  * @returns {import('typings/internalBinding/modules').PackageConfig} - The package configuration.
  */
 function getPackageScopeConfig(resolved) {
+  if (customGetPackageScopeConfig !== null) {
+    return customGetPackageScopeConfig(resolved, defaultGetPackageScopeConfig);
+  }
+  return defaultGetPackageScopeConfig(resolved);
+}
+
+function defaultGetPackageScopeConfig(resolved) {
   const result = modulesBinding.getPackageScopeConfig(`${resolved}`);
 
   if (ArrayIsArray(result)) {
@@ -219,6 +260,13 @@ function getPackageScopeConfig(resolved) {
  * @returns {string}
  */
 function getPackageType(url) {
+  if (customGetPackageType !== null) {
+    return customGetPackageType(url, defaultGetPackageType);
+  }
+  return defaultGetPackageType(url);
+}
+
+function defaultGetPackageType(url) {
   const type = modulesBinding.getPackageType(`${url}`);
   return type ?? 'none';
 }
@@ -276,11 +324,12 @@ function getPackageJSONURL(specifier, base) {
     }
   }
 
+  const { internalModuleStat } = require('internal/modules/helpers');
   let packageJSONUrl = new URL(`./node_modules/${packageName}/package.json`, base);
   let packageJSONPath = fileURLToPath(packageJSONUrl);
   let lastPath;
   do {
-    const stat = internalFsBinding.internalModuleStat(
+    const stat = internalModuleStat(
       StringPrototypeSlice(packageJSONPath, 0, packageJSONPath.length - 13),
     );
     // Check for !stat.isDirectory()
@@ -360,4 +409,8 @@ module.exports = {
   getPackageType,
   getPackageJSONURL,
   findPackageJSON,
+  setCustomRead,
+  setCustomGetPackageScopeConfig,
+  setCustomGetPackageType,
+  setCustomGetNearestParentPackageJSON,
 };

lib/internal/vfs/module_hooks.js

@@ -5,6 +5,9 @@ const {
   ArrayPrototypePush,
   ArrayPrototypeSplice,
   FunctionPrototypeCall,
+  JSONParse,
+  StringPrototypeEndsWith,
+  StringPrototypeLastIndexOf,
   StringPrototypeStartsWith,
 } = primordials;
 
@@ -336,17 +339,61 @@ function findVFSForWatch(filename) {
   return null;
 }
 
+/**
+ * Checks whether any active VFS could potentially handle the given path.
+ * Used for early exit on non-VFS paths to avoid unnecessary JS walks.
+ * @param {string} filePath The absolute file path to check
+ * @returns {boolean}
+ */
+function anyVFSCouldHandle(filePath) {
+  const normalized = normalizeVFSPath(filePath);
+  for (let i = 0; i < activeVFSList.length; i++) {
+    if (activeVFSList[i].shouldHandle(normalized)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Parse VFS package.json content into the flat PackageConfig format
+ * returned by read() (not the nested DeserializedPackageConfig format).
+ * @param {string} jsonPath Path to the package.json
+ * @param {string|Buffer} content Raw file content
+ * @returns {object} PackageConfig with { name, main, type, exports, imports, exists, pjsonPath }
+ */
+function parseVFSPackageJSON(jsonPath, content) {
+  const str = typeof content === 'string' ? content : content.toString('utf8');
+  const parsed = JSONParse(str);
+  let type = 'none';
+  if (parsed.type === 'commonjs' || parsed.type === 'module') {
+    type = parsed.type;
+  }
+  return {
+    __proto__: null,
+    ...(parsed.name != null && { name: parsed.name }),
+    ...(parsed.main != null && { main: parsed.main }),
+    type,
+    ...(parsed.exports != null && { exports: parsed.exports }),
+    ...(parsed.imports != null && { imports: parsed.imports }),
+    exists: true,
+    pjsonPath: jsonPath,
+  };
+}
+
 /**
  * Determine module format from file extension.
- * Uses the shared extensionFormatMap, falling back to commonjs for .js
- * and unknown extensions since VFS does not check package.json "type".
+ * Uses the shared extensionFormatMap. For .js files, checks the package.json
+ * "type" field via getPackageType (which is now VFS-aware).
  * @param {string} filePath The file path
  * @returns {string} The format ('module', 'commonjs', 'json', etc.)
  */
 function getFormatFromExtension(filePath) {
   const ext = extname(filePath);
   if (ext === '.js') {
-    // TODO: Check package.json "type" field for proper detection
+    const { getPackageType } = require('internal/modules/package_json_reader');
+    const type = getPackageType(pathToFileURL(filePath));
+    if (type === 'module') return 'module';
     return 'commonjs';
   }
   return extensionFormatMap[ext] ?? 'commonjs';
@@ -487,7 +534,16 @@ function installModuleHooks() {
     setCustomToRealPath,
     setCustomReadFileSync,
     setCustomInternalModuleStat,
+    internalModuleStat,
   } = require('internal/modules/helpers');
+  const {
+    read: readPackageJSON,
+    getPackageScopeConfig,
+    setCustomRead,
+    setCustomGetPackageScopeConfig,
+    setCustomGetPackageType,
+    setCustomGetNearestParentPackageJSON,
+  } = require('internal/modules/package_json_reader');
 
   // Save original Module._stat
   originalStat = Module._stat;
@@ -539,6 +595,150 @@ function installModuleHooks() {
     return defaultFn(path);
   });
 
+  // Set VFS-aware package.json read override.
+  // The C++ readPackageJSON binding reads from disk via libuv, bypassing VFS.
+  // This override intercepts package.json reads for paths under VFS mounts.
+  setCustomRead(function vfsAwareRead(jsonPath, opts, defaultFn) {
+    if (!anyVFSCouldHandle(jsonPath)) {
+      return defaultFn(jsonPath, opts);
+    }
+    // Check if the file exists in VFS via stat (avoids ENOENT throw from findVFSForRead)
+    const statResult = findVFSForStat(jsonPath);
+    if (statResult !== null) {
+      if (statResult.result === 0) {
+        // File exists -read and parse it
+        const vfsResult = findVFSForRead(jsonPath, 'utf8');
+        if (vfsResult !== null) {
+          return parseVFSPackageJSON(jsonPath, vfsResult.content);
+        }
+      }
+      // Path is handled by VFS but file doesn't exist -return not-found
+      return {
+        __proto__: null,
+        exists: false,
+        pjsonPath: jsonPath,
+        type: 'none',
+      };
+    }
+    return defaultFn(jsonPath, opts);
+  });
+
+  // Set VFS-aware getPackageScopeConfig override.
+  // The C++ implementation walks upward from a file URL to find the nearest
+  // package.json. This JS reimplementation does the same walk for VFS paths.
+  setCustomGetPackageScopeConfig(function vfsAwareGetPackageScopeConfig(resolved, defaultFn) {
+    let resolvedPath;
+    try {
+      resolvedPath = fileURLToPath(`${resolved}`);
+    } catch {
+      return defaultFn(resolved);
+    }
+
+    if (!anyVFSCouldHandle(resolvedPath)) {
+      return defaultFn(resolved);
+    }
+
+    // Walk upward from the resolved path, checking for package.json at each level.
+    // This mirrors the C++ GetPackageScopeConfig logic.
+    let currentDir = dirname(resolvedPath);
+    let lastDir;
+
+    while (currentDir !== lastDir) {
+      // Stop at node_modules boundaries
+      if (StringPrototypeEndsWith(currentDir, '/node_modules') ||
+          StringPrototypeEndsWith(currentDir, '\\node_modules')) {
+        break;
+      }
+
+      const pjsonPath = resolve(currentDir, 'package.json');
+      const result = readPackageJSON(pjsonPath);
+      if (result.exists) {
+        return result;
+      }
+
+      lastDir = currentDir;
+      currentDir = dirname(currentDir);
+    }
+
+    // No package.json found -return not-found result
+    return {
+      __proto__: null,
+      pjsonPath: resolve(dirname(resolvedPath), 'package.json'),
+      exists: false,
+      type: 'none',
+    };
+  });
+
+  // Set VFS-aware getPackageType override.
+  // Delegates to getPackageScopeConfig (which is already toggled).
+  setCustomGetPackageType(function vfsAwareGetPackageType(url, defaultFn) {
+    let urlPath;
+    try {
+      urlPath = fileURLToPath(`${url}`);
+    } catch {
+      return defaultFn(url);
+    }
+
+    if (!anyVFSCouldHandle(urlPath)) {
+      return defaultFn(url);
+    }
+
+    const config = getPackageScopeConfig(url);
+    return config.type ?? 'none';
+  });
+
+  // Set VFS-aware getNearestParentPackageJSON override.
+  // The C++ TraverseParent walks upward from a file path (not URL) to find
+  // the nearest package.json. Returns DeserializedPackageConfig format:
+  // { data: { name, main, type, exports, imports }, exists, path }.
+  setCustomGetNearestParentPackageJSON(function vfsAwareGetNearestParent(checkPath, defaultFn) {
+    if (!anyVFSCouldHandle(checkPath)) {
+      return defaultFn(checkPath);
+    }
+
+    // Walk upward from dirname(checkPath)
+    let currentDir = dirname(checkPath);
+    let lastDir;
+
+    while (currentDir !== lastDir) {
+      // Stop at node_modules boundaries (matches C++ TraverseParent)
+      const basename = currentDir.substring(
+        StringPrototypeLastIndexOf(currentDir, '/') + 1,
+      );
+      if (basename === 'node_modules') {
+        return undefined;
+      }
+
+      const pjsonPath = resolve(currentDir, 'package.json');
+
+      // Check if the package.json file exists via stat
+      const stat = internalModuleStat(pjsonPath);
+      if (stat === 0) {
+        // File exists -read and parse it
+        const flat = readPackageJSON(pjsonPath);
+        if (flat.exists) {
+          // Convert flat PackageConfig to nested DeserializedPackageConfig
+          const data = { __proto__: null, type: flat.type ?? 'none' };
+          if (flat.name != null) data.name = flat.name;
+          if (flat.main != null) data.main = flat.main;
+          if (flat.exports != null) data.exports = flat.exports;
+          if (flat.imports != null) data.imports = flat.imports;
+
+          return {
+            data,
+            exists: true,
+            path: pjsonPath,
+          };
+        }
+      }
+
+      lastDir = currentDir;
+      currentDir = dirname(currentDir);
+    }
+
+    return undefined;
+  });
+
   // Register ESM hooks using Module.registerHooks
   Module.registerHooks({
     resolve: vfsResolveHook,

test/fixtures/sea/vfs/sea-config.json

@@ -8,6 +8,8 @@
     "modules/math.js": "math.js",
     "modules/calculator.js": "calculator.js",
     "node_modules/test-pkg/package.json": "test-pkg-package.json",
-    "node_modules/test-pkg/index.js": "test-pkg-index.js"
+    "node_modules/test-pkg/index.js": "test-pkg-index.js",
+    "node_modules/test-exports-pkg/package.json": "test-exports-pkg-package.json",
+    "node_modules/test-exports-pkg/lib/entry.js": "test-exports-pkg-entry.js"
   }
 }

test/fixtures/sea/vfs/sea.js

@@ -64,16 +64,17 @@ assert.strictEqual(buf2[0], original, 'buf2 should be unaffected by buf1 mutatio
 assert.strictEqual(buf1[0], 0xFF, 'buf1 mutation should persist');
 console.log('buffer independence test passed');
 
-// TODO(mcollina): The CJS module loader reads package.json via C++ binding
-// (internalBinding('modules').readPackageJSON), which doesn't go through VFS.
-// This means "exports" conditions in package.json won't work for VFS packages.
-// The test below works because "main": "index.js" matches the default fallback.
-// A follow-up PR should make the C++ package.json reader VFS-aware.
-
-// Test node_modules package lookup via VFS
+// Test node_modules package lookup via VFS (resolved through "exports" field)
 const testPkg = require('test-pkg');
 assert.strictEqual(testPkg.name, 'test-pkg', 'package name should match');
 assert.strictEqual(testPkg.greet('World'), 'Hello, World!', 'package function should work');
 console.log('node_modules package lookup test passed');
 
+// Test exports-only package (no "main" field, entry in subdirectory)
+// This proves the package.json reader is VFS-aware — without it,
+// "exports" would not be consulted and resolution would fail.
+const exportsPkg = require('test-exports-pkg');
+assert.strictEqual(exportsPkg.fromExports, true, 'exports-only package should resolve');
+console.log('exports-only package lookup test passed');
+
 console.log('All SEA VFS tests passed!');