vfs: replace custom path helpers with standard path module

Remove normalizePath and joinMountPath from router.js in favor of
path.normalize, path.resolve, and path.join. Remove unused VFS_FD_BASE
export from fd.js.

Author: mcollina

lib/internal/vfs/fd.js

@@ -79,7 +79,6 @@ function closeVirtualFd(fd) {
 
 module.exports = {
   VirtualFD,
-  VFS_FD_BASE,
   openVirtualFd,
   getVirtualFd,
   closeVirtualFd,

lib/internal/vfs/file_system.js

@@ -13,12 +13,10 @@ const {
 } = require('internal/errors');
 const { validateBoolean } = require('internal/validators');
 const { MemoryProvider } = require('internal/vfs/providers/memory');
+const { normalize, resolve, join, isAbsolute } = require('path');
 const {
-  normalizePath,
   isUnderMountPoint,
   getRelativePath,
-  joinMountPath,
-  isAbsolutePath,
 } = require('internal/vfs/router');
 const {
   openVirtualFd,
@@ -201,18 +199,18 @@ class VirtualFileSystem {
    */
   resolvePath(inputPath) {
     // If path is absolute, return as-is
-    if (isAbsolutePath(inputPath)) {
-      return normalizePath(inputPath);
+    if (isAbsolute(inputPath)) {
+      return normalize(inputPath);
     }
 
     // If virtual cwd is enabled and set, resolve relative to it
     if (this[kVirtualCwdEnabled] && this[kVirtualCwd] !== null) {
       const resolved = `${this[kVirtualCwd]}/${inputPath}`;
-      return normalizePath(resolved);
+      return normalize(resolved);
     }
 
-    // Fall back to normalizing the path (will use real cwd)
-    return normalizePath(inputPath);
+    // Fall back to resolving the path (will use real cwd)
+    return resolve(inputPath);
   }
 
   // ==================== Mount ====================
@@ -226,7 +224,7 @@ class VirtualFileSystem {
     if (this[kMounted]) {
       throw new ERR_INVALID_STATE('VFS is already mounted');
     }
-    this[kMountPoint] = normalizePath(prefix);
+    this[kMountPoint] = normalize(prefix);
     this[kMounted] = true;
     if (this[kModuleHooks]) {
       loadModuleHooks();
@@ -277,7 +275,7 @@ class VirtualFileSystem {
     this[kOriginalCwd] = process.cwd;
 
     process.chdir = function chdir(directory) {
-      const normalized = normalizePath(directory);
+      const normalized = resolve(directory);
 
       if (vfs.shouldHandle(normalized)) {
         vfs.chdir(normalized);
@@ -341,7 +339,7 @@ class VirtualFileSystem {
    */
   _toMountedPath(providerPath) {
     if (this[kMounted] && this[kMountPoint]) {
-      return joinMountPath(this[kMountPoint], providerPath);
+      return join(this[kMountPoint], providerPath);
     }
     return providerPath;
   }
@@ -358,7 +356,7 @@ class VirtualFileSystem {
       return false;
     }
 
-    const normalized = normalizePath(inputPath);
+    const normalized = normalize(inputPath);
     if (!isUnderMountPoint(normalized, this[kMountPoint])) {
       return false;
     }

lib/internal/vfs/module_hooks.js

@@ -9,8 +9,7 @@ const {
   StringPrototypeStartsWith,
 } = primordials;
 
-const { dirname, isAbsolute, resolve } = require('path');
-const { normalizePath } = require('internal/vfs/router');
+const { dirname, isAbsolute, normalize, resolve } = require('path');
 const { isURL, pathToFileURL, fileURLToPath, toPathIfFileURL, URL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
 const { validateObject } = require('internal/validators');
@@ -80,7 +79,7 @@ function unregisterVFS(vfs) {
  * @returns {{ vfs: VirtualFileSystem, result: number }|null}
  */
 function findVFSForStat(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -102,7 +101,7 @@ function findVFSForStat(filename) {
  * @returns {{ vfs: VirtualFileSystem, content: Buffer|string }|null}
  */
 function findVFSForRead(filename, options) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -141,7 +140,7 @@ function findVFSForRead(filename, options) {
  * @returns {{ vfs: VirtualFileSystem, exists: boolean }|null}
  */
 function findVFSForExists(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -162,7 +161,7 @@ function findVFSForExists(filename) {
  * @returns {{ vfs: VirtualFileSystem, realpath: string }|null}
  */
 function findVFSForRealpath(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -189,7 +188,7 @@ function findVFSForRealpath(filename) {
  * @returns {{ vfs: VirtualFileSystem, stats: Stats }|null}
  */
 function findVFSForFsStat(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -217,7 +216,7 @@ function findVFSForFsStat(filename) {
  * @returns {{ vfs: VirtualFileSystem, entries: string[]|Dirent[] }|null}
  */
 function findVFSForReaddir(dirname, options) {
-  const normalized = normalizePath(dirname);
+  const normalized = normalize(dirname);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -245,7 +244,7 @@ function findVFSForReaddir(dirname, options) {
  * @returns {Promise<{ vfs: VirtualFileSystem, entries: string[]|Dirent[] }|null>}
  */
 async function findVFSForReaddirAsync(dirname, options) {
-  const normalized = normalizePath(dirname);
+  const normalized = normalize(dirname);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -272,7 +271,7 @@ async function findVFSForReaddirAsync(dirname, options) {
  * @returns {Promise<{ vfs: VirtualFileSystem, stats: Stats }|null>}
  */
 async function findVFSForLstatAsync(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -300,7 +299,7 @@ async function findVFSForLstatAsync(filename) {
  * @returns {{ vfs: VirtualFileSystem }|null}
  */
 function findVFSForWatch(filename) {
-  const normalized = normalizePath(filename);
+  const normalized = normalize(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -387,7 +386,7 @@ function vfsResolveHook(specifier, context, nextResolve) {
   }
 
   // Check if any VFS handles this path
-  const normalized = normalizePath(checkPath);
+  const normalized = normalize(checkPath);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized) && vfs.existsSync(normalized)) {
@@ -431,7 +430,7 @@ function vfsLoadHook(url, context, nextLoad) {
   }
 
   const filePath = fileURLToPath(url);
-  const normalized = normalizePath(filePath);
+  const normalized = normalize(filePath);
 
   // Check if any VFS handles this path
   for (let i = 0; i < activeVFSList.length; i++) {

lib/internal/vfs/router.js

@@ -1,39 +1,12 @@
 'use strict';
 
 const {
-  StringPrototypeEndsWith,
-  StringPrototypeReplaceAll,
   StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
 } = primordials;
 
-const { isAbsolute, posix: pathPosix, resolve, sep } = require('path');
-
-/**
- * Normalizes a path for VFS lookup.
- * - Resolves to absolute path
- * - Removes trailing slashes (except for root)
- * - Normalizes separators to forward slashes (VFS uses '/' internally)
- * @param {string} inputPath The path to normalize
- * @returns {string} The normalized path
- */
-function normalizePath(inputPath) {
-  let normalized = resolve(inputPath);
-
-  // On Windows, convert backslashes to forward slashes for consistent VFS lookup.
-  // VFS uses forward slashes internally regardless of platform.
-  if (sep === '\\') {
-    normalized = StringPrototypeReplaceAll(normalized, '\\', '/');
-  }
-
-  // Remove trailing slash (except for root)
-  if (normalized.length > 1 && StringPrototypeEndsWith(normalized, '/')) {
-    normalized = StringPrototypeSlice(normalized, 0, -1);
-  }
-
-  return normalized;
-}
+const { isAbsolute, posix: pathPosix } = require('path');
 
 /**
  * Splits a path into segments.
@@ -110,32 +83,11 @@ function getRelativePath(normalizedPath, mountPoint) {
   return StringPrototypeSlice(normalizedPath, mountPoint.length);
 }
 
-/**
- * Joins a mount point with a relative path.
- * Note: We don't use path.join here because VFS relative paths start with /
- * and path.join would treat them as absolute paths.
- * @param {string} mountPoint A normalized mount point path
- * @param {string} relativePath A relative path (starting with /)
- * @returns {string} The joined absolute path
- */
-function joinMountPath(mountPoint, relativePath) {
-  if (relativePath === '/') {
-    return mountPoint;
-  }
-  // Special case: root mount point - the relative path is already the full path
-  if (mountPoint === '/') {
-    return relativePath;
-  }
-  return mountPoint + relativePath;
-}
-
 module.exports = {
-  normalizePath,
   splitPath,
   getParentPath,
   getBaseName,
   isUnderMountPoint,
   getRelativePath,
-  joinMountPath,
   isAbsolutePath: isAbsolute,
 };