sea: support VFS in embedderRequire

Enable direct require() of modules from VFS in Single Executable
Applications. Previously, SEA's embedderRequire only supported built-in
modules, requiring users to use module.createRequire() for VFS paths.

Now, after calling sea.getVfs(), you can require VFS modules directly:

```js
const sea = require('node:sea');
sea.getVfs(); // Initialize VFS
const myModule = require('/sea/lib/mymodule.js');
```

The implementation:
- Lazily initializes SEA VFS on first non-builtin require
- Checks if the required path exists in VFS
- Uses Module._load to load from VFS via the registered hooks

Author: mcollina

doc/api/single-executable-applications.md

@@ -286,27 +286,23 @@ The VFS supports the following `fs` operations on bundled assets:
 
 #### Loading modules from VFS in SEA
 
-The default `require()` function in a SEA only supports loading Node.js
-built-in modules. To load JavaScript modules bundled as assets, you must use
-[`module.createRequire()`][]:
+Once the VFS is initialized with `sea.getVfs()`, you can use `require()` directly
+with absolute VFS paths:
 
 ```cjs
-const { createRequire } = require('node:module');
 const sea = require('node:sea');
 
-// Initialize VFS
+// Initialize VFS - this must be called first
 sea.getVfs();
 
-// Create a require function that works with VFS
-const seaRequire = createRequire('/sea/');
-
-// Now you can require bundled modules
-const myModule = seaRequire('/sea/lib/mymodule.js');
-const utils = seaRequire('/sea/utils/helpers.js');
+// Now you can require bundled modules directly
+const myModule = require('/sea/lib/mymodule.js');
+const utils = require('/sea/utils/helpers.js');
 ```
 
-This is necessary because SEA uses a special embedder require that doesn't go
-through the standard module resolution hooks that VFS registers.
+The SEA's `require()` function automatically detects VFS paths (paths starting
+with the VFS mount point, e.g., `/sea/`) and loads modules from the virtual
+file system.
 
 #### Custom mount prefix
 
@@ -641,7 +637,6 @@ to help us document them.
 [Mach-O]: https://en.wikipedia.org/wiki/Mach-O
 [PE]: https://en.wikipedia.org/wiki/Portable_Executable
 [Windows SDK]: https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/
-[`module.createRequire()`]: module.md#modulecreaterequirefilename
 [`process.execPath`]: process.md#processexecpath
 [`require()`]: modules.md#requireid
 [`require.main`]: modules.md#accessing-the-main-module

lib/internal/main/embedding.js

@@ -97,22 +97,70 @@ function embedderRunCjs(content) {
 
 let warnedAboutBuiltins = false;
 
+// Lazy-loaded SEA VFS support
+let seaVfsInitialized = false;
+let seaVfs = null;
+let seaVfsMountPoint = null;
+
+function initSeaVfs() {
+  if (seaVfsInitialized) return;
+  seaVfsInitialized = true;
+
+  if (!isLoadingSea) return;
+
+  // Check if SEA has assets (VFS support)
+  const { hasSeaAssets, getSeaVfs } = require('internal/vfs/sea');
+  if (hasSeaAssets()) {
+    seaVfs = getSeaVfs();
+    if (seaVfs) {
+      seaVfsMountPoint = seaVfs.mountPoint;
+    }
+  }
+}
+
 function embedderRequire(id) {
   const normalizedId = normalizeRequirableId(id);
-  if (!normalizedId) {
-    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;
+  if (normalizedId) {
+    // Built-in module
+    return require(normalizedId);
+  }
+
+  // Not a built-in module - check if it's a VFS path in SEA
+  if (isLoadingSea) {
+    initSeaVfs();
+
+    if (seaVfs && seaVfsMountPoint) {
+      // Check if the path is within the VFS mount point
+      // Support both absolute paths (/sea/...) and relative to mount point
+      let modulePath = id;
+      if (id.startsWith(seaVfsMountPoint) || id.startsWith('/')) {
+        // Absolute path - resolve within VFS
+        if (!id.startsWith(seaVfsMountPoint) && id.startsWith('/')) {
+          // Path like '/modules/foo.js' - prepend mount point
+          modulePath = seaVfsMountPoint + id;
+        }
+
+        // Check if the file exists in VFS
+        if (seaVfs.existsSync(modulePath)) {
+          // Use Module._load to load the module, which will use VFS hooks
+          return Module._load(modulePath, embedderRequire.main, false);
+        }
+      }
     }
-    throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
   }
-  return require(normalizedId);
+
+  // No VFS or file not in VFS - show warning and throw
+  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;
+  }
+  throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
 }
 
 return [process, embedderRequire, embedderRunCjs];

test/parallel/test-vfs-chdir.js

@@ -165,8 +165,10 @@ const fs = require('fs');
   const originalCwd = process.cwd();
 
   // Change to a real directory (not under /virtual)
+  // Use realpathSync because /tmp may be a symlink (e.g., /tmp -> /private/tmp on macOS)
+  const tmpDir = fs.realpathSync('/tmp');
   process.chdir('/tmp');
-  assert.strictEqual(process.cwd(), '/tmp');
+  assert.strictEqual(process.cwd(), tmpDir);
   // vfs.cwd() should still be null (not set)
   assert.strictEqual(vfs.cwd(), null);
 

test/sea/test-single-executable-application-vfs.js

@@ -23,7 +23,6 @@ const outputFile = tmpdir.resolve(process.platform === 'win32' ? 'sea.exe' : 'se
 const seaMain = `
 'use strict';
 const fs = require('fs');
-const { createRequire } = require('module');
 const sea = require('node:sea');
 const assert = require('assert');
 
@@ -70,13 +69,12 @@ assert.ok(entries.includes('config.json'), 'Should include config.json');
 assert.ok(entries.includes('data'), 'Should include data directory');
 console.log('readdirSync tests passed, entries:', entries);
 
-// Test requiring a module from SEA VFS using module.createRequire()
-// (SEA's built-in require only supports built-in modules)
-const seaRequire = createRequire('/sea/');
-const mathModule = seaRequire('/sea/modules/math.js');
+// Test requiring a module from SEA VFS using direct require()
+// (SEA's require now supports VFS paths automatically)
+const mathModule = require('/sea/modules/math.js');
 assert.strictEqual(mathModule.add(2, 3), 5, 'math.add should work');
 assert.strictEqual(mathModule.multiply(4, 5), 20, 'math.multiply should work');
-console.log('require from VFS tests passed');
+console.log('direct require from VFS tests passed');
 
 // Test getSeaVfs with custom prefix
 const customVfs = sea.getVfs({ prefix: '/custom' });