vfs: add ESM loader intercepts for legacyMainResolve and getFormatOfExtensionlessFile

Both internalBinding('fs') methods bypass VFS fs-level overrides since
they use uv_fs_stat/read directly in C++. Route them through toggleable
wrappers in helpers.js so the VFS can handle paths under active mounts.

Author: mcollina

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 = {
@@ -59,7 +58,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:

lib/internal/modules/esm/resolve.js

@@ -29,7 +29,6 @@ const { sep, posix: { relative: relativePosixPath }, resolve } = require('path')
 const { URL, pathToFileURL, fileURLToPath, isURL, URLParse } = require('internal/url');
 const { getCWDURL, setOwnProperty } = require('internal/util');
 const { canParse: URLCanParse } = internalBinding('url');
-const { legacyMainResolve: FSLegacyMainResolve } = internalBinding('fs');
 const {
   ERR_INPUT_TYPE_NOT_ALLOWED,
   ERR_INVALID_ARG_TYPE,
@@ -46,7 +45,7 @@ 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 { loaderStat, toRealPath } = require('internal/modules/helpers');
+const { loaderLegacyMainResolve, loaderStat, toRealPath } = require('internal/modules/helpers');
 
 /**
  * @typedef {import('internal/modules/esm/package_config.js').PackageConfig} PackageConfig
@@ -193,7 +192,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 || './' : '';

lib/internal/modules/helpers.js

@@ -63,15 +63,20 @@ const realpathCache = new SafeMap();
 let _loaderStat = null;
 let _loaderReadFile = null;
 let _loaderRealpath = null;
+let _loaderLegacyMainResolve = null;
+let _loaderGetFormatOfExtensionlessFile = null;
 
 /**
  * Set override functions for the module loader's fs operations.
- * @param {{ stat?: Function, readFile?: Function, realpath?: Function }} overrides
+ * @param {{ stat?: Function, readFile?: Function, realpath?: Function,
+ *           legacyMainResolve?: Function, getFormatOfExtensionlessFile?: Function }} overrides
  */
-function setLoaderFsOverrides({ stat, readFile, realpath }) {
+function setLoaderFsOverrides({ stat, readFile, realpath, legacyMainResolve, getFormatOfExtensionlessFile }) {
   _loaderStat = stat;
   _loaderReadFile = readFile;
   _loaderRealpath = realpath;
+  _loaderLegacyMainResolve = legacyMainResolve;
+  _loaderGetFormatOfExtensionlessFile = getFormatOfExtensionlessFile;
 }
 
 /**
@@ -113,6 +118,34 @@ function toRealPath(requestPath) {
   });
 }
 
+/**
+ * Wrapper for internalBinding('fs').legacyMainResolve that supports VFS toggle.
+ * @param {string} pkgPath The package directory path
+ * @param {string} main The package main field
+ * @param {string} base The base URL string
+ * @returns {number}
+ */
+function loaderLegacyMainResolve(pkgPath, main, base) {
+  if (_loaderLegacyMainResolve !== null) {
+    const result = _loaderLegacyMainResolve(pkgPath, main, base);
+    if (result !== undefined) { return result; }
+  }
+  return internalFsBinding.legacyMainResolve(pkgPath, main, base);
+}
+
+/**
+ * Wrapper for internalBinding('fs').getFormatOfExtensionlessFile that supports VFS toggle.
+ * @param {string} path The file path
+ * @returns {number}
+ */
+function loaderGetFormatOfExtensionlessFile(path) {
+  if (_loaderGetFormatOfExtensionlessFile !== null) {
+    const result = _loaderGetFormatOfExtensionlessFile(path);
+    if (result !== undefined) { return result; }
+  }
+  return internalFsBinding.getFormatOfExtensionlessFile(path);
+}
+
 // Toggleable overrides for package.json C++ methods (VFS support).
 let _loaderReadPackageJSON = null;
 let _loaderGetNearestParentPackageJSON = null;
@@ -643,9 +676,11 @@ module.exports = {
   getCjsConditionsArray,
   getCompileCacheDir,
   initializeCjsConditions,
+  loaderGetFormatOfExtensionlessFile,
   loaderGetNearestParentPackageJSON,
   loaderGetPackageScopeConfig,
   loaderGetPackageType,
+  loaderLegacyMainResolve,
   loaderReadFile,
   loaderReadPackageJSON,
   loaderStat,

lib/internal/vfs/setup.js

@@ -1360,6 +1360,56 @@ function installModuleLoaderOverrides() {
       const result = findVFSForRealpath(filename);
       return result !== null ? result.realpath : undefined;
     },
+    legacyMainResolve(pkgPath, main, base) {
+      // Check if pkgPath is under any active VFS
+      const normalized = resolve(pkgPath);
+      let handled = false;
+      for (let i = 0; i < activeVFSList.length; i++) {
+        if (activeVFSList[i].shouldHandle(normalized)) {
+          handled = true;
+          break;
+        }
+      }
+      if (!handled) return undefined;
+
+      // Extension index mapping (matches C++ legacyMainResolve):
+      // 0-6: try main + extension, then main + /index.ext
+      // 7-9: try pkgPath + ./index.ext
+      const mainExts = ['', '.js', '.json', '.node',
+                        '/index.js', '/index.json', '/index.node'];
+      const indexExts = ['./index.js', './index.json', './index.node'];
+
+      if (main) {
+        for (let i = 0; i < mainExts.length; i++) {
+          const candidate = resolve(pkgPath, main + mainExts[i]);
+          if (findVFSForStat(candidate)?.result === 0) return i;
+        }
+      }
+      for (let i = 0; i < indexExts.length; i++) {
+        const candidate = resolve(pkgPath, indexExts[i]);
+        if (findVFSForStat(candidate)?.result === 0) return 7 + i;
+      }
+
+      const { ERR_MODULE_NOT_FOUND } = require('internal/errors').codes;
+      throw new ERR_MODULE_NOT_FOUND(
+        pkgPath, base, 'package');
+    },
+    getFormatOfExtensionlessFile(filePath) {
+      try {
+        const result = findVFSForRead(filePath, null);
+        if (result === null) return undefined;
+        const content = result.content;
+        // Check for 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 1; // EXTENSIONLESS_FORMAT_WASM
+        }
+        return 0; // EXTENSIONLESS_FORMAT_JAVASCRIPT
+      } catch {
+        return 0; // EXTENSIONLESS_FORMAT_JAVASCRIPT
+      }
+    },
   });
   const nativeModulesBinding = internalBinding('modules');
   setLoaderPackageOverrides({

test/parallel/test-vfs-require.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
@@ -291,6 +291,58 @@ const vfs = require('node:vfs');
   myVfs.unmount();
 }
 
+// Test legacyMainResolve: 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";');
+  myVfs.mount('/virtual20');
+
+  const result = require('/virtual20/pkg');
+  assert.strictEqual(result, 'legacy-main');
+
+  myVfs.unmount();
+}
+
+// Test legacyMainResolve: 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";');
+  myVfs.mount('/virtual21');
+
+  const result = require('/virtual21/pkg2');
+  assert.strictEqual(result, '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;');
+  myVfs.mount('/virtual22');
+
+  // Use import() to trigger ESM loader path
+  const importPromise = import('/virtual22/esm-pkg/entry');
+  importPromise.then(common.mustCall((mod) => {
+    assert.strictEqual(mod.x, 123);
+    myVfs.unmount();
+  }));
+}
+
 // Test that unmounting stops interception
 {
   const myVfs = vfs.create();