vfs: use wrapModuleLoad for SEA VFS entry point

Use wrapModuleLoad instead of custom embedderRunCjs code when VFS is
enabled. This gives proper CJS cycle handling and standard module
loading behavior through the registered VFS hooks.

- Restore embedderRunCjs to match upstream (no VFS-specific code)
- Restore embedderRequire to use loadBuiltinModuleForEmbedder
- Add VFS entry path in embedderRunEntryPoint using wrapModuleLoad
  with path.posix.join for cross-platform path construction
- Auto-include main script as VFS asset during blob generation so
  wrapModuleLoad can find it at the VFS mount point
- Expose mainCodePath from SEA binding to construct correct VFS path

Author: mcollina

lib/internal/main/embedding.js

@@ -15,20 +15,16 @@ const {
 const {
   isSea,
   isVfsEnabled: isVfsEnabledFlag,
+  mainCodePath: seaMainCodePath,
   isExperimentalSeaWarningNeeded,
 } = internalBinding('sea');
-const isLoadingSea = isSea();
 const { emitExperimentalWarning } = require('internal/util');
 const { emitWarningSync } = require('internal/process/warning');
-const { Module } = require('internal/modules/cjs/loader');
+const { Module, wrapModuleLoad } = require('internal/modules/cjs/loader');
 const { compileFunctionForCJSLoader } = internalBinding('contextify');
 const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
-const { BuiltinModule } = require('internal/bootstrap/realm');
-const { normalizeRequirableId } = BuiltinModule;
-const { codes: {
-  ERR_UNKNOWN_BUILTIN_MODULE,
-} } = require('internal/errors');
 const { pathToFileURL } = require('internal/url');
+const { loadBuiltinModuleForEmbedder } = require('internal/modules/helpers');
 const { compileSourceTextModule, SourceTextModuleTypes: { kEmbedder } } = require('internal/modules/esm/utils');
 const { moduleFormats } = internalBinding('modules');
 const assert = require('internal/assert');
@@ -38,7 +34,7 @@ const path = require('path');
 // command line (e.g. it could be provided via an API or bundled into the executable).
 prepareMainThreadExecution(false, true);
 
-const isBuiltinWarningNeeded = isLoadingSea && isExperimentalSeaWarningNeeded();
+const isLoadingSea = isSea();
 if (isExperimentalSeaWarningNeeded()) {
   emitExperimentalWarning('Single executable application');
 }
@@ -89,24 +85,9 @@ function embedderRunCjs(content, filename) {
   }
 
   // Patch the module to make it look almost like a regular CJS module
-  // instance. When VFS is active, set the filename to a VFS path so that
-  // relative require('./foo.js') resolves under the VFS mount point,
-  // and use createRequire for a fully-featured require function.
-  let requireFn;
-  if (seaVfsActive && seaVfsMountPoint) {
-    // VFS paths always use POSIX separators regardless of platform.
-    customModule.filename = seaVfsMountPoint + '/' + path.basename(filename);
-    customModule.paths = Module._nodeModulePaths(
-      path.dirname(customModule.filename));
-    // Use createRequire so that require has all standard properties
-    // (resolve, cache, etc.) and builtin loading flows through hooks.
-    requireFn = Module.createRequire(customModule.filename);
-    requireFn.main = customModule;
-  } else {
-    customModule.filename = process.execPath;
-    customModule.paths = Module._nodeModulePaths(process.execPath);
-    requireFn = embedderRequire;
-  }
+  // instance.
+  customModule.filename = process.execPath;
+  customModule.paths = Module._nodeModulePaths(process.execPath);
   embedderRequire.main = customModule;
 
   // This currently returns what the wrapper returns i.e. if the code
@@ -116,27 +97,13 @@ function embedderRunCjs(content, filename) {
   // out parameter.
   return compiledWrapper(
     customModule.exports,  // exports
-    requireFn,             // require
+    embedderRequire,       // require
     customModule,          // module
-    customModule.filename, // __filename
-    path.dirname(customModule.filename),  // __dirname
+    filename,              // __filename
+    customModule.path,     // __dirname
   );
 }
 
-let warnedAboutBuiltins = false;
-function warnNonBuiltinInSEA() {
-  if (isBuiltinWarningNeeded && !warnedAboutBuiltins) {
-    emitWarningSync(
-      'Currently the require() provided to the main script embedded into ' +
-      'single-executable applications only supports loading built-in modules.\n' +
-      'To load a module from disk after the single executable application is ' +
-      'launched, use require("module").createRequire().\n' +
-      'Support for bundled module loading or virtual file systems are under ' +
-      'discussions in https://github.com/nodejs/single-executable');
-    warnedAboutBuiltins = true;
-  }
-}
-
 // Lazy-loaded SEA VFS support
 let seaVfsInitialized = false;
 let seaVfsActive = false;
@@ -148,7 +115,6 @@ function initSeaVfs() {
 
   if (!isLoadingSea || !isVfsEnabledFlag) return;
 
-  // Check if SEA has VFS support
   const { getSeaVfs } = require('internal/vfs/sea');
   const seaVfs = getSeaVfs();
   if (seaVfs) {
@@ -158,15 +124,7 @@ function initSeaVfs() {
 }
 
 function embedderRequire(id) {
-  const normalizedId = normalizeRequirableId(id);
-  if (normalizedId) {
-    return require(normalizedId);
-  }
-
-  // When VFS is not active, only built-in modules are supported.
-  // VFS-enabled SEAs use createRequire instead of embedderRequire.
-  warnNonBuiltinInSEA();
-  throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
+  return loadBuiltinModuleForEmbedder(id).exports;
 }
 
 function embedderRunESM(content, filename) {
@@ -195,6 +153,12 @@ function embedderRunEntryPoint(content, format, filename) {
     initSeaVfs();
   }
 
+  if (seaVfsActive && format === moduleFormats.kCommonJS) {
+    const mainName = seaMainCodePath ? path.basename(seaMainCodePath) : path.basename(filename);
+    const vfsMain = path.posix.join(seaVfsMountPoint, mainName);
+    return wrapModuleLoad(vfsMain, null, true);
+  }
+
   if (format === moduleFormats.kCommonJS) {
     return embedderRunCjs(content, filename);
   } else if (format === moduleFormats.kModule) {

src/node_sea.cc

@@ -752,6 +752,12 @@ ExitCode GenerateSingleExecutableBlob(
   if (!config.assets.empty() && BuildAssets(config.assets, &assets) != 0) {
     return ExitCode::kGenericUserError;
   }
+  // When VFS is enabled, include the main script as an asset so it can be
+  // loaded via wrapModuleLoad from the VFS mount point.
+  if (static_cast<bool>(config.flags & SeaFlags::kEnableVfs) &&
+      !builds_snapshot_from_main) {
+    assets.emplace(config.main_path, main_script);
+  }
   std::unordered_map<std::string_view, std::string_view> assets_view;
   for (auto const& [key, content] : assets) {
     assets_view.emplace(key, content);
@@ -909,6 +915,21 @@ void Initialize(Local<Object> target,
     SeaResource sea_resource = FindSingleExecutableResource();
     is_vfs_enabled =
         static_cast<bool>(sea_resource.flags & SeaFlags::kEnableVfs);
+    // Expose the main code path so VFS can construct the correct entry point.
+    if (is_vfs_enabled) {
+      Local<String> code_path_str;
+      if (String::NewFromUtf8(isolate,
+                              sea_resource.code_path.data(),
+                              NewStringType::kNormal,
+                              sea_resource.code_path.length())
+              .ToLocal(&code_path_str)) {
+        target
+            ->Set(context,
+                  FIXED_ONE_BYTE_STRING(isolate, "mainCodePath"),
+                  code_path_str)
+            .Check();
+      }
+    }
   }
   target
       ->Set(context,