sea: move VFS functions from fs to sea module

Move getSeaVfs() and hasSeaAssets() from the fs module to the sea
module and rename them to getVfs() and hasAssets() since the "Sea"
prefix is redundant when already in the sea namespace.

Also fix circular dependency in internal/vfs/sea.js by using
internalBinding('sea') directly instead of requiring the public
sea module.

Author: mcollina

doc/api/fs.md

@@ -8864,92 +8864,12 @@ const { glob } = require('node:fs/promises');
 })();
 ```
 
-### SEA (Single Executable Application) integration
-
-When running as a Single Executable Application, the VFS can automatically
-provide access to embedded assets through standard file system APIs.
-
-#### `fs.hasSeaAssets()`
-
-<!-- YAML
-added: REPLACEME
--->
-
-* Returns: {boolean}
-
-Returns `true` if running as a SEA with embedded assets, `false` otherwise.
-
-```cjs
-const fs = require('node:fs');
-
-if (fs.hasSeaAssets()) {
-  console.log('Running as SEA with assets');
-}
-```
-
-#### `fs.getSeaVfs([options])`
-
-<!-- YAML
-added: REPLACEME
--->
-
-* `options` {Object}
-  * `prefix` {string} Mount point prefix for SEA assets. **Default:** `'/sea'`.
-  * `moduleHooks` {boolean} Whether to enable require/import hooks.
-    **Default:** `true`.
-* Returns: {VirtualFileSystem|null}
-
-Returns a VFS populated with all SEA embedded assets, mounted at the specified
-prefix. Returns `null` if not running as a SEA or if there are no assets.
-
-The VFS is a singleton - subsequent calls return the same instance (options
-are only used on the first call).
-
-```cjs
-const fs = require('node:fs');
-
-// In a SEA with an embedded 'config.json' asset:
-const seaVfs = fs.getSeaVfs();
-if (seaVfs) {
-  // Access embedded assets via standard fs APIs
-  const config = fs.readFileSync('/sea/config.json', 'utf8');
-  console.log(JSON.parse(config));
-
-  // Or require modules from embedded assets
-  const utils = require('/sea/utils.js');
-}
-```
-
-To use SEA assets, first configure them in your SEA configuration file:
-
-```json
-{
-  "main": "app.js",
-  "output": "app.blob",
-  "assets": {
-    "config.json": "path/to/config.json",
-    "utils.js": "path/to/utils.js"
-  }
-}
-```
-
-Then access them via the VFS:
-
-```cjs
-const fs = require('node:fs');
-const seaVfs = fs.getSeaVfs();
-
-// Assets are accessible at /sea/<asset-key>
-const config = fs.readFileSync('/sea/config.json', 'utf8');
-```
-
 ### Limitations
 
 The current VFS implementation has the following limitations:
 
 * **Read-only**: Files can only be set via `addFile()`. Write operations
   (`writeFile`, `appendFile`, etc.) are not supported.
-* **No symbolic links**: Symbolic links are not supported.
 * **No file watching**: `fs.watch()` and `fs.watchFile()` do not work with
   virtual files.
 * **No real file descriptor**: Virtual file descriptors (10000+) are managed

doc/api/single-executable-applications.md

@@ -251,11 +251,12 @@ To use the VFS with SEA:
 
 ```cjs
 const fs = require('node:fs');
+const sea = require('node:sea');
 
 // Check if SEA assets are available
-if (fs.hasSeaAssets()) {
+if (sea.hasAssets()) {
   // Initialize and mount the SEA VFS
-  const vfs = fs.getSeaVfs();
+  const vfs = sea.getVfs();
 
   // Now you can use standard fs APIs to read bundled assets
   const config = JSON.parse(fs.readFileSync('/sea/config.json', 'utf8'));
@@ -290,11 +291,11 @@ built-in modules. To load JavaScript modules bundled as assets, you must use
 [`module.createRequire()`][]:
 
 ```cjs
-const fs = require('node:fs');
 const { createRequire } = require('node:module');
+const sea = require('node:sea');
 
 // Initialize VFS
-fs.getSeaVfs();
+sea.getVfs();
 
 // Create a require function that works with VFS
 const seaRequire = createRequire('/sea/');
@@ -313,13 +314,16 @@ By default, the VFS is mounted at `/sea`. You can specify a custom prefix
 when initializing the VFS:
 
 ```cjs
-const vfs = fs.getSeaVfs({ prefix: '/app' });
+const fs = require('node:fs');
+const sea = require('node:sea');
+
+const vfs = sea.getSeaVfs({ prefix: '/app' });
 
 // Assets are now accessible under /app
 const config = fs.readFileSync('/app/config.json', 'utf8');
 ```
 
-Note: `fs.getSeaVfs()` returns a singleton. The `prefix` option is only used
+Note: `sea.getVfs()` returns a singleton. The `prefix` option is only used
 on the first call; subsequent calls return the same cached instance.
 
 ### Startup snapshot support

lib/fs.js

@@ -3207,7 +3207,6 @@ function globSync(pattern, options) {
 }
 
 const lazyVfs = getLazy(() => require('internal/vfs/virtual_fs').VirtualFileSystem);
-const lazySeaVfs = getLazy(() => require('internal/vfs/sea'));
 
 /**
  * Creates a new virtual file system instance.
@@ -3221,28 +3220,6 @@ function createVirtual(options) {
   return new VirtualFileSystem(options);
 }
 
-/**
- * Gets the VFS containing SEA (Single Executable Application) assets.
- * Returns null if not running as a SEA or if there are no assets.
- * @param {object} [options] Configuration options
- * @param {string} [options.prefix] Mount point prefix for SEA assets
- * @param {boolean} [options.moduleHooks] Whether to enable require/import hooks
- * @returns {VirtualFileSystem|null}
- */
-function getSeaVfs(options) {
-  const { getSeaVfs: getSeaVfsInternal } = lazySeaVfs();
-  return getSeaVfsInternal(options);
-}
-
-/**
- * Checks if SEA assets are available.
- * @returns {boolean}
- */
-function hasSeaAssets() {
-  const { hasSeaAssets: hasSeaAssetsInternal } = lazySeaVfs();
-  return hasSeaAssetsInternal();
-}
-
 module.exports = fs = {
   appendFile,
   appendFileSync,
@@ -3261,8 +3238,6 @@ module.exports = fs = {
   createReadStream,
   createVirtual,
   createWriteStream,
-  getSeaVfs,
-  hasSeaAssets,
   exists,
   existsSync,
   fchown,

lib/internal/vfs/sea.js

@@ -5,9 +5,19 @@ const {
 } = primordials;
 
 const { Buffer } = require('buffer');
-const { isSea, getAsset, getAssetKeys } = require('sea');
+const { isSea, getAsset: getAssetInternal, getAssetKeys: getAssetKeysInternal } = internalBinding('sea');
 const { kEmptyObject } = require('internal/util');
 
+// Wrapper to get asset as ArrayBuffer (same as public sea.getAsset without encoding)
+function getAsset(key) {
+  return getAssetInternal(key);
+}
+
+// Wrapper to get asset keys
+function getAssetKeys() {
+  return getAssetKeysInternal() || [];
+}
+
 // Lazy-loaded VFS
 let cachedSeaVfs = null;
 

lib/sea.js

@@ -81,10 +81,17 @@ function getAssetKeys() {
   return getAssetKeysInternal() || [];
 }
 
+const {
+  getSeaVfs: getVfs,
+  hasSeaAssets: hasAssets,
+} = require('internal/vfs/sea');
+
 module.exports = {
   isSea,
   getAsset,
   getRawAsset,
   getAssetAsBlob,
   getAssetKeys,
+  getVfs,
+  hasAssets,
 };

test/parallel/test-vfs-sea.js

@@ -5,44 +5,44 @@
 
 require('../common');
 const assert = require('assert');
-const fs = require('fs');
+const sea = require('node:sea');
 
-// Test that SEA functions are exported from fs module
-assert.strictEqual(typeof fs.getSeaVfs, 'function');
-assert.strictEqual(typeof fs.hasSeaAssets, 'function');
+// Test that SEA functions are exported from sea module
+assert.strictEqual(typeof sea.getVfs, 'function');
+assert.strictEqual(typeof sea.hasAssets, 'function');
 
 // Test hasSeaAssets() returns false when not running as SEA
 {
-  const hasAssets = fs.hasSeaAssets();
+  const hasAssets = sea.hasAssets();
   assert.strictEqual(hasAssets, false);
 }
 
 // Test getSeaVfs() returns null when not running as SEA
 {
-  const seaVfs = fs.getSeaVfs();
+  const seaVfs = sea.getVfs();
   assert.strictEqual(seaVfs, null);
 }
 
 // Test getSeaVfs() with options still returns null when not in SEA
 {
-  const seaVfs = fs.getSeaVfs({ prefix: '/custom-sea' });
+  const seaVfs = sea.getVfs({ prefix: '/custom-sea' });
   assert.strictEqual(seaVfs, null);
 }
 
 {
-  const seaVfs = fs.getSeaVfs({ moduleHooks: false });
+  const seaVfs = sea.getVfs({ moduleHooks: false });
   assert.strictEqual(seaVfs, null);
 }
 
 {
-  const seaVfs = fs.getSeaVfs({ prefix: '/my-app', moduleHooks: true });
+  const seaVfs = sea.getVfs({ prefix: '/my-app', moduleHooks: true });
   assert.strictEqual(seaVfs, null);
 }
 
 // Verify that calling getSeaVfs multiple times is safe (caching behavior)
 {
-  const vfs1 = fs.getSeaVfs();
-  const vfs2 = fs.getSeaVfs();
+  const vfs1 = sea.getVfs();
+  const vfs2 = sea.getVfs();
   assert.strictEqual(vfs1, vfs2);
   assert.strictEqual(vfs1, null);
 }

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

@@ -9,7 +9,7 @@ const {
 
 skipIfSingleExecutableIsNotSupported();
 
-// This tests the SEA VFS integration - fs.getSeaVfs() and fs.hasSeaAssets()
+// This tests the SEA VFS integration - sea.getVfs() and sea.hasAssets()
 
 const tmpdir = require('../common/tmpdir');
 const { writeFileSync } = require('fs');
@@ -23,15 +23,16 @@ const outputFile = tmpdir.resolve(process.platform === 'win32' ? 'sea.exe' : 'se
 const seaMain = `
 'use strict';
 const fs = require('fs');
+const sea = require('node:sea');
 const assert = require('assert');
 
 // Test hasSeaAssets() returns true when we have assets
-const hasAssets = fs.hasSeaAssets();
+const hasAssets = sea.hasAssets();
 assert.strictEqual(hasAssets, true, 'hasSeaAssets() should return true');
 console.log('hasSeaAssets:', hasAssets);
 
 // Test getSeaVfs() returns a VFS instance
-const vfs = fs.getSeaVfs();
+const vfs = sea.getVfs();
 assert.ok(vfs !== null, 'getSeaVfs() should not return null');
 console.log('getSeaVfs returned VFS instance');
 
@@ -75,7 +76,7 @@ assert.strictEqual(mathModule.multiply(4, 5), 20, 'math.multiply should work');
 console.log('require from VFS tests passed');
 
 // Test getSeaVfs with custom prefix
-const customVfs = fs.getSeaVfs({ prefix: '/custom' });
+const customVfs = sea.getVfs({ prefix: '/custom' });
 // Note: getSeaVfs is a singleton, so it returns the same instance
 // with the same mount point (/sea) regardless of options passed after first call
 assert.strictEqual(customVfs, vfs, 'Should return the same cached instance');