vfs: fix lint errors across implementation and tests

- Use primordials correctly (MathMin, Promise, Error)
- Alphabetize primordials imports
- Fix JSDoc types (function -> Function)
- Fix function name matching for fs overrides
- Fix use-before-define issues by restructuring code
- Add null-prototype to async function returns
- Remove unused imports and variables
- Use proper error codes from internal/errors
- Add URL import from internal/url
- Fix test files: remove unused variables, use node: prefix

Author: mcollina

doc/api/fs.md

@@ -8294,7 +8294,7 @@ added: REPLACEME
 > Stability: 1 - Experimental
 
 The virtual file system (VFS) allows creating in-memory file system overlays
-that integrate seamlessly with Node.js's `fs` module and module loader. Virtual
+that integrate seamlessly with the Node.js `fs` module and module loader. Virtual
 files and directories can be accessed using standard `fs` operations and can be
 `require()`d or `import`ed like regular files.
 
@@ -8384,6 +8384,7 @@ added: REPLACEME
   returns the content.
 
 Adds a virtual file. The `content` can be:
+
 * A `string` or `Buffer` for static content
 * A synchronous function `() => string|Buffer` for dynamic content
 * An async function `async () => string|Buffer` for async dynamic content
@@ -8628,6 +8629,7 @@ stream.on('end', () => console.log('Done'));
 ```
 
 The readable stream supports the following options:
+
 * `encoding` {string} Character encoding for string output.
 * `start` {integer} Byte position to start reading from.
 * `end` {integer} Byte position to stop reading at (inclusive).
@@ -8637,7 +8639,7 @@ The readable stream supports the following options:
 ### Module loading from VFS
 
 Virtual files can be loaded as modules using `require()` or `import`. The VFS
-integrates with Node.js's module loaders automatically when mounted or in
+integrates with the Node.js module loaders automatically when mounted or in
 overlay mode.
 
 ```cjs
@@ -8711,10 +8713,12 @@ fs.glob('/virtual/src/*.js', (err, matches) => {
 });
 
 // Async glob with promises (returns async iterator)
-const { glob } = require('fs/promises');
-for await (const file of glob('/virtual/src/**/*.js')) {
-  console.log(file);
-}
+const { glob } = require('node:fs/promises');
+(async () => {
+  for await (const file of glob('/virtual/src/**/*.js')) {
+    console.log(file);
+  }
+})();
 ```
 
 ### SEA (Single Executable Application) integration

lib/fs.js

@@ -3212,8 +3212,8 @@ const lazySeaVfs = getLazy(() => require('internal/vfs/sea'));
 /**
  * Creates a new virtual file system instance.
  * @param {object} [options] Configuration options
- * @param {boolean} [options.fallthrough=true] Whether to fall through to real fs on miss
- * @param {boolean} [options.moduleHooks=true] Whether to enable require/import hooks
+ * @param {boolean} [options.fallthrough] Whether to fall through to real fs on miss
+ * @param {boolean} [options.moduleHooks] Whether to enable require/import hooks
  * @returns {VirtualFileSystem}
  */
 function createVirtual(options) {
@@ -3225,8 +3225,8 @@ function createVirtual(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='/sea'] Mount point prefix for SEA assets
- * @param {boolean} [options.moduleHooks=true] Whether to enable require/import hooks
+ * @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) {

lib/internal/test_runner/mock/mock.js

@@ -795,7 +795,7 @@ class MockTracker {
   /**
    * Creates a mock file system using VFS.
    * @param {object} [options] - Options for the mock file system.
-   * @param {string} [options.prefix='/mock'] - The mount prefix for the VFS.
+   * @param {string} [options.prefix] - The mount prefix for the VFS.
    * @param {object} [options.files] - Initial files to add (path: content pairs).
    * @returns {MockFSContext} The mock file system context.
    */
@@ -807,7 +807,7 @@ class MockTracker {
     }
 
     const { VirtualFileSystem } = require('internal/vfs/virtual_fs');
-    const vfs = new VirtualFileSystem({ moduleHooks: true });
+    const vfs = new VirtualFileSystem({ __proto__: null, moduleHooks: true });
 
     // Add initial files if provided
     if (files) {

lib/internal/vfs/entries.js

@@ -1,12 +1,17 @@
 'use strict';
 
 const {
-  DateNow,
+  Promise,
   SafeMap,
   Symbol,
 } = primordials;
 
 const { Buffer } = require('buffer');
+const {
+  codes: {
+    ERR_INVALID_STATE,
+  },
+} = require('internal/errors');
 const { createFileStats, createDirectoryStats } = require('internal/vfs/stats');
 
 // Symbols for private properties
@@ -69,7 +74,7 @@ class VirtualEntry {
 class VirtualFile extends VirtualEntry {
   /**
    * @param {string} path The absolute path of this file
-   * @param {Buffer|string|function} content The file content or content provider
+   * @param {Buffer|string|Function} content The file content or content provider
    * @param {object} [options] Optional configuration
    * @param {number} [options.mode] File mode (default: 0o644)
    */
@@ -113,7 +118,7 @@ class VirtualFile extends VirtualEntry {
     if (this[kContentProvider] !== null) {
       const result = this[kContentProvider]();
       if (result instanceof Promise) {
-        throw new Error('Cannot use sync API with async content provider');
+        throw new ERR_INVALID_STATE('cannot use sync API with async content provider');
       }
       const buffer = typeof result === 'string' ? Buffer.from(result) : result;
       // Update stats with actual size
@@ -147,52 +152,13 @@ class VirtualFile extends VirtualEntry {
   }
 }
 
-/**
- * Scoped VFS interface passed to dynamic directory populate callbacks.
- * Allows adding files and directories relative to the parent directory.
- */
-class ScopedVFS {
-  /**
-   * @param {VirtualDirectory} directory The parent directory
-   * @param {function} addEntry Callback to add an entry
-   */
-  constructor(directory, addEntry) {
-    this._directory = directory;
-    this._addEntry = addEntry;
-  }
-
-  /**
-   * Adds a file to this directory.
-   * @param {string} name The file name (not a path)
-   * @param {Buffer|string|function} content The file content or content provider
-   * @param {object} [options] Optional configuration
-   */
-  addFile(name, content, options) {
-    const path = this._directory.path + '/' + name;
-    const file = new VirtualFile(path, content, options);
-    this._addEntry(name, file);
-  }
-
-  /**
-   * Adds a subdirectory to this directory.
-   * @param {string} name The directory name (not a path)
-   * @param {function} [populate] Optional callback to populate the directory
-   * @param {object} [options] Optional configuration
-   */
-  addDirectory(name, populate, options) {
-    const path = this._directory.path + '/' + name;
-    const dir = new VirtualDirectory(path, populate, options);
-    this._addEntry(name, dir);
-  }
-}
-
 /**
  * Represents a virtual directory with static or dynamic entries.
  */
 class VirtualDirectory extends VirtualEntry {
   /**
    * @param {string} path The absolute path of this directory
-   * @param {function} [populate] Optional callback to populate directory contents
+   * @param {Function} [populate] Optional callback to populate directory contents
    * @param {object} [options] Optional configuration
    * @param {number} [options.mode] Directory mode (default: 0o755)
    */
@@ -233,7 +199,7 @@ class VirtualDirectory extends VirtualEntry {
    */
   ensurePopulated() {
     if (!this[kPopulated] && this[kPopulate] !== null) {
-      const scopedVfs = new ScopedVFS(this, (name, entry) => {
+      const scopedVfs = createScopedVFS(this, (name, entry) => {
         this[kEntries].set(name, entry);
       });
       this[kPopulate](scopedVfs);
@@ -298,11 +264,33 @@ class VirtualDirectory extends VirtualEntry {
   }
 }
 
+/**
+ * Creates a scoped VFS interface for dynamic directory populate callbacks.
+ * @param {VirtualDirectory} directory The parent directory
+ * @param {Function} addEntry Callback to add an entry
+ * @returns {object} Scoped VFS interface
+ */
+function createScopedVFS(directory, addEntry) {
+  return {
+    __proto__: null,
+    addFile(name, content, options) {
+      const path = directory.path + '/' + name;
+      const file = new VirtualFile(path, content, options);
+      addEntry(name, file);
+    },
+    addDirectory(name, populate, options) {
+      const path = directory.path + '/' + name;
+      const dir = new VirtualDirectory(path, populate, options);
+      addEntry(name, dir);
+    },
+  };
+}
+
 module.exports = {
   VirtualEntry,
   VirtualFile,
   VirtualDirectory,
-  ScopedVFS,
+  createScopedVFS,
   kContent,
   kContentProvider,
   kPopulate,

lib/internal/vfs/module_hooks.js

@@ -1,15 +1,15 @@
 'use strict';
 
 const {
-  ArrayPrototypePush,
   ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
   ArrayPrototypeSplice,
   StringPrototypeEndsWith,
   StringPrototypeStartsWith,
 } = primordials;
 
 const { normalizePath } = require('internal/vfs/router');
-const { pathToFileURL, fileURLToPath } = require('internal/url');
+const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
 const { createENOENT } = require('internal/vfs/errors');
 
 // Registry of active VFS instances
@@ -35,8 +35,6 @@ let originalPromisesReaddir = null;
 let originalPromisesLstat = null;
 // Track if hooks are installed
 let hooksInstalled = false;
-// ESM hooks instance (for potential cleanup)
-let esmHooksInstance = null;
 
 /**
  * Registers a VFS instance to be checked for CJS module loading.
@@ -242,7 +240,7 @@ async function findVFSForReaddirAsync(dirname, options) {
       if (vfs.existsSync(normalized)) {
         try {
           const entries = await vfs.promises.readdir(normalized, options);
-          return { vfs, entries };
+          return { __proto__: null, vfs, entries };
         } catch (e) {
           if (vfs.isMounted) {
             throw e;
@@ -269,7 +267,7 @@ async function findVFSForLstatAsync(filename) {
       if (vfs.existsSync(normalized)) {
         try {
           const stats = await vfs.promises.lstat(normalized);
-          return { vfs, stats };
+          return { __proto__: null, vfs, stats };
         } catch (e) {
           if (vfs.isMounted) {
             throw e;
@@ -319,7 +317,7 @@ function urlToPath(urlOrPath) {
  * ESM resolve hook for VFS.
  * @param {string} specifier The module specifier
  * @param {object} context The resolve context
- * @param {function} nextResolve The next resolve function in the chain
+ * @param {Function} nextResolve The next resolve function in the chain
  * @returns {object} The resolve result
  */
 function vfsResolveHook(specifier, context, nextResolve) {
@@ -380,7 +378,7 @@ function vfsResolveHook(specifier, context, nextResolve) {
  * ESM load hook for VFS.
  * @param {string} url The module URL
  * @param {object} context The load context
- * @param {function} nextLoad The next load function in the chain
+ * @param {Function} nextLoad The next load function in the chain
  * @returns {object} The load result
  */
 function vfsLoadHook(url, context, nextLoad) {
@@ -450,7 +448,7 @@ function installHooks() {
   // Override Module._stat
   // This uses the setter which emits an experimental warning, but that's acceptable
   // for now since VFS integration IS experimental.
-  Module._stat = function vfsStat(filename) {
+  Module._stat = function _stat(filename) {
     const vfsResult = findVFSForStat(filename);
     if (vfsResult !== null) {
       return vfsResult.result;
@@ -460,7 +458,7 @@ function installHooks() {
 
   // Override fs.readFileSync
   // We need to be careful to only intercept when VFS should handle the path
-  fs.readFileSync = function vfsReadFileSync(path, options) {
+  fs.readFileSync = function readFileSync(path, options) {
     // Only intercept string paths (not file descriptors)
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
@@ -473,7 +471,7 @@ function installHooks() {
   };
 
   // Override fs.realpathSync
-  fs.realpathSync = function vfsRealpathSync(path, options) {
+  fs.realpathSync = function realpathSync(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = findVFSForRealpath(pathStr);
@@ -487,7 +485,7 @@ function installHooks() {
   fs.realpathSync.native = originalRealpathSync.native;
 
   // Override fs.lstatSync
-  fs.lstatSync = function vfsLstatSync(path, options) {
+  fs.lstatSync = function lstatSync(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = findVFSForFsStat(pathStr);
@@ -499,7 +497,7 @@ function installHooks() {
   };
 
   // Override fs.statSync
-  fs.statSync = function vfsStatSync(path, options) {
+  fs.statSync = function statSync(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = findVFSForFsStat(pathStr);
@@ -512,7 +510,7 @@ function installHooks() {
 
   // Override fs.readdirSync (needed for glob support)
   originalReaddirSync = fs.readdirSync;
-  fs.readdirSync = function vfsReaddirSync(path, options) {
+  fs.readdirSync = function readdirSync(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = findVFSForReaddir(pathStr, options);
@@ -525,7 +523,7 @@ function installHooks() {
 
   // Override fs.existsSync
   originalExistsSync = fs.existsSync;
-  fs.existsSync = function vfsExistsSync(path) {
+  fs.existsSync = function existsSync(path) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = findVFSForExists(pathStr);
@@ -541,7 +539,7 @@ function installHooks() {
 
   // Override fs/promises.readdir (needed for async glob support)
   originalPromisesReaddir = fsPromises.readdir;
-  fsPromises.readdir = async function vfsPromisesReaddir(path, options) {
+  fsPromises.readdir = async function readdir(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = await findVFSForReaddirAsync(pathStr, options);
@@ -554,7 +552,7 @@ function installHooks() {
 
   // Override fs/promises.lstat (needed for async glob support)
   originalPromisesLstat = fsPromises.lstat;
-  fsPromises.lstat = async function vfsPromisesLstat(path, options) {
+  fsPromises.lstat = async function lstat(path, options) {
     if (typeof path === 'string' || path instanceof URL) {
       const pathStr = typeof path === 'string' ? path : path.pathname;
       const vfsResult = await findVFSForLstatAsync(pathStr);
@@ -566,7 +564,7 @@ function installHooks() {
   };
 
   // Register ESM hooks using Module.registerHooks
-  esmHooksInstance = Module.registerHooks({
+  Module.registerHooks({
     resolve: vfsResolveHook,
     load: vfsLoadHook,
   });

lib/internal/vfs/router.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const {
-  StringPrototypeStartsWith,
-  StringPrototypeSlice,
   StringPrototypeEndsWith,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
 } = primordials;
 
 const path = require('path');