vfs: fix Windows path handling and remove wrapper functions

Use path.resolve() instead of pathPosix.normalize() for VFS path
normalization so mount points resolve correctly on Windows (e.g.
/virtual -> C:\virtual). Use path.sep and path.relative() in router
for cross-platform mount point matching. Remove normalizeVFSPath and
joinVFSPath wrappers in favor of direct path utility calls. Update
tests to use path.resolve()/path.normalize() for platform-portable
assertions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mcollina

lib/internal/vfs/file_system.js

@@ -14,44 +14,7 @@ const {
 const { validateBoolean } = require('internal/validators');
 const { MemoryProvider } = require('internal/vfs/providers/memory');
 const path = require('path');
-const pathPosix = path.posix;
-const { isAbsolute, resolve: resolvePath } = path;
-
-/**
- * Normalizes a VFS path. Uses POSIX normalization for all paths except
- * Windows drive-letter paths (e.g. C:\), which use platform normalization.
- *
- * On Windows, a bare '/' prefix is treated as a POSIX VFS path, not as the
- * current-drive root.
- * @param {string} inputPath The path to normalize
- * @returns {string} The normalized path
- */
-function normalizeVFSPath(inputPath) {
-  if (inputPath.length >= 3 && inputPath[1] === ':') {
-    // Windows drive-letter path (e.g. C:\app)
-    return path.normalize(inputPath);
-  }
-  return pathPosix.normalize(inputPath);
-}
-
-/**
- * Joins VFS paths. Uses POSIX join for Unix-style base paths and platform
- * join for Windows drive-letter paths (e.g. C:\).
- *
- * On Windows, a bare '/' prefix is treated as a POSIX VFS path, not as the
- * current-drive root.  Only explicit drive-letter paths like 'C:\app' use
- * platform path.join.
- * @param {string} base The base path
- * @param {string} part The path part to join
- * @returns {string} The joined path
- */
-function joinVFSPath(base, part) {
-  if (base.length >= 3 && base[1] === ':') {
-    // Windows drive-letter path (e.g. C:\app)
-    return path.join(base, part);
-  }
-  return pathPosix.join(base, part);
-}
+const { isAbsolute, resolve: resolvePath, join: joinPath } = path;
 const {
   isUnderMountPoint,
   getRelativePath,
@@ -238,13 +201,13 @@ class VirtualFileSystem {
   resolvePath(inputPath) {
     // If path is absolute, return as-is
     if (isAbsolute(inputPath)) {
-      return normalizeVFSPath(inputPath);
+      return resolvePath(inputPath);
     }
 
     // If virtual cwd is enabled and set, resolve relative to it
     if (this[kVirtualCwdEnabled] && this[kVirtualCwd] !== null) {
       const resolved = `${this[kVirtualCwd]}/${inputPath}`;
-      return normalizeVFSPath(resolved);
+      return resolvePath(resolved);
     }
 
     // Fall back to resolving the path (will use real cwd)
@@ -262,7 +225,7 @@ class VirtualFileSystem {
     if (this[kMounted]) {
       throw new ERR_INVALID_STATE('VFS is already mounted');
     }
-    this[kMountPoint] = normalizeVFSPath(prefix);
+    this[kMountPoint] = resolvePath(prefix);
     this[kMounted] = true;
     if (this[kModuleHooks]) {
       loadModuleHooks();
@@ -331,7 +294,7 @@ class VirtualFileSystem {
     process.chdir = function chdir(directory) {
       // Normalize path for VFS comparison (preserves forward slashes for Unix-style paths)
       const normalized = isAbsolute(directory) ?
-        normalizeVFSPath(directory) :
+        resolvePath(directory) :
         resolvePath(directory);
 
       if (vfs.shouldHandle(normalized)) {
@@ -374,16 +337,16 @@ class VirtualFileSystem {
    * @returns {string} The provider-relative path
    */
   #toProviderPath(inputPath) {
-    const resolved = this.resolvePath(inputPath);
-
     if (this[kMounted] && this[kMountPoint]) {
+      const resolved = this.resolvePath(inputPath);
       if (!isUnderMountPoint(resolved, this[kMountPoint])) {
         throw createENOENT('open', inputPath);
       }
       return getRelativePath(resolved, this[kMountPoint]);
     }
 
-    return resolved;
+    // Not mounted: paths are provider-internal, keep POSIX format
+    return path.posix.normalize(inputPath);
   }
 
   /**
@@ -393,7 +356,7 @@ class VirtualFileSystem {
    */
   #toMountedPath(providerPath) {
     if (this[kMounted] && this[kMountPoint]) {
-      return joinVFSPath(this[kMountPoint], providerPath);
+      return joinPath(this[kMountPoint], providerPath);
     }
     return providerPath;
   }
@@ -410,7 +373,7 @@ class VirtualFileSystem {
       return false;
     }
 
-    const normalized = normalizeVFSPath(inputPath);
+    const normalized = resolvePath(inputPath);
     if (!isUnderMountPoint(normalized, this[kMountPoint])) {
       return false;
     }

lib/internal/vfs/module_hooks.js

@@ -17,22 +17,6 @@ const {
 
 const path = require('path');
 const { dirname, extname, isAbsolute, resolve } = path;
-const pathPosix = path.posix;
-
-/**
- * Normalizes a VFS path. Uses POSIX normalization for Unix-style paths (starting with /)
- * and platform normalization for Windows drive letter paths.
- * @param {string} inputPath The path to normalize
- * @returns {string} The normalized path
- */
-function normalizeVFSPath(inputPath) {
-  // If path starts with / (Unix-style), use posix normalization to preserve forward slashes
-  if (inputPath.startsWith('/')) {
-    return pathPosix.normalize(inputPath);
-  }
-  // Otherwise use platform normalization (for Windows drive letters like C:\)
-  return path.normalize(inputPath);
-}
 const { isURL, pathToFileURL, fileURLToPath, toPathIfFileURL, URL } = require('internal/url');
 const { getLazy, kEmptyObject } = require('internal/util');
 const { validateObject } = require('internal/validators');
@@ -125,7 +109,7 @@ function vfsStat(vfs, filePath) {
  * @returns {{ vfs: VirtualFileSystem, result: number }|null}
  */
 function findVFSForStat(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -147,7 +131,7 @@ function findVFSForStat(filename) {
  * @returns {{ vfs: VirtualFileSystem, content: Buffer|string }|null}
  */
 function findVFSForRead(filename, options) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -186,7 +170,7 @@ function findVFSForRead(filename, options) {
  * @returns {{ vfs: VirtualFileSystem, exists: boolean }|null}
  */
 function findVFSForExists(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -207,7 +191,7 @@ function findVFSForExists(filename) {
  * @returns {{ vfs: VirtualFileSystem, realpath: string }|null}
  */
 function findVFSForRealpath(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -234,7 +218,7 @@ function findVFSForRealpath(filename) {
  * @returns {{ vfs: VirtualFileSystem, stats: Stats }|null}
  */
 function findVFSForFsStat(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -262,7 +246,7 @@ function findVFSForFsStat(filename) {
  * @returns {{ vfs: VirtualFileSystem, entries: string[]|Dirent[] }|null}
  */
 function findVFSForReaddir(dirname, options) {
-  const normalized = normalizeVFSPath(dirname);
+  const normalized = resolve(dirname);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -290,7 +274,7 @@ function findVFSForReaddir(dirname, options) {
  * @returns {Promise<{ vfs: VirtualFileSystem, entries: string[]|Dirent[] }|null>}
  */
 async function findVFSForReaddirAsync(dirname, options) {
-  const normalized = normalizeVFSPath(dirname);
+  const normalized = resolve(dirname);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -317,7 +301,7 @@ async function findVFSForReaddirAsync(dirname, options) {
  * @returns {Promise<{ vfs: VirtualFileSystem, stats: Stats }|null>}
  */
 async function findVFSForLstatAsync(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -345,7 +329,7 @@ async function findVFSForLstatAsync(filename) {
  * @returns {{ vfs: VirtualFileSystem }|null}
  */
 function findVFSForWatch(filename) {
-  const normalized = normalizeVFSPath(filename);
+  const normalized = resolve(filename);
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
     if (vfs.shouldHandle(normalized)) {
@@ -394,7 +378,7 @@ function getVFSPackageType(vfs, filePath) {
         StringPrototypeEndsWith(currentDir, '\\node_modules')) {
       break;
     }
-    const pjsonPath = normalizeVFSPath(resolve(currentDir, 'package.json'));
+    const pjsonPath = resolve(currentDir, 'package.json');
     if (vfs.shouldHandle(pjsonPath) && vfsStat(vfs, pjsonPath) === 0) {
       try {
         const content = vfs.readFileSync(pjsonPath, 'utf8');
@@ -454,7 +438,7 @@ function tryExtensions(vfs, basePath) {
 function tryIndexFiles(vfs, dirPath) {
   const indexFiles = ['index.js', 'index.mjs', 'index.cjs', 'index.json'];
   for (let i = 0; i < indexFiles.length; i++) {
-    const candidate = normalizeVFSPath(resolve(dirPath, indexFiles[i]));
+    const candidate = resolve(dirPath, indexFiles[i]);
     if (vfsStat(vfs, candidate) === 0) {
       const url = pathToFileURL(candidate).href;
       const format = getVFSFormat(vfs, candidate);
@@ -479,7 +463,7 @@ function resolveConditions(vfs, pkgDir, condMap, conditions) {
     if (key === 'default' || ArrayPrototypeIndexOf(conditions, key) !== -1) {
       const value = condMap[key];
       if (typeof value === 'string') {
-        const resolved = normalizeVFSPath(resolve(pkgDir, value));
+        const resolved = resolve(pkgDir, value);
         if (vfsStat(vfs, resolved) === 0) {
           const url = pathToFileURL(resolved).href;
           const format = getVFSFormat(vfs, resolved);
@@ -514,7 +498,7 @@ function resolvePackageExports(vfs, pkgDir, packageSubpath, exports, context) {
   // String shorthand: "exports": "./index.js"
   if (typeof exports === 'string') {
     if (packageSubpath === '.') {
-      const resolved = normalizeVFSPath(resolve(pkgDir, exports));
+      const resolved = resolve(pkgDir, exports);
       if (vfsStat(vfs, resolved) === 0) {
         const url = pathToFileURL(resolved).href;
         const format = getVFSFormat(vfs, resolved);
@@ -544,7 +528,7 @@ function resolvePackageExports(vfs, pkgDir, packageSubpath, exports, context) {
   if (target === undefined) return null;
 
   if (typeof target === 'string') {
-    const resolved = normalizeVFSPath(resolve(pkgDir, target));
+    const resolved = resolve(pkgDir, target);
     if (vfsStat(vfs, resolved) === 0) {
       const url = pathToFileURL(resolved).href;
       const format = getVFSFormat(vfs, resolved);
@@ -569,7 +553,7 @@ function resolvePackageExports(vfs, pkgDir, packageSubpath, exports, context) {
  * @returns {object|null} Resolve result or null
  */
 function resolveDirectoryEntry(vfs, dirPath, context) {
-  const pjsonPath = normalizeVFSPath(resolve(dirPath, 'package.json'));
+  const pjsonPath = resolve(dirPath, 'package.json');
   if (vfsStat(vfs, pjsonPath) === 0) {
     try {
       const content = vfs.readFileSync(pjsonPath, 'utf8');
@@ -584,7 +568,7 @@ function resolveDirectoryEntry(vfs, dirPath, context) {
 
       // Try main
       if (parsed.main) {
-        const mainPath = normalizeVFSPath(resolve(dirPath, parsed.main));
+        const mainPath = resolve(dirPath, parsed.main);
         if (vfsStat(vfs, mainPath) === 0) {
           const url = pathToFileURL(mainPath).href;
           const format = getVFSFormat(vfs, mainPath);
@@ -635,7 +619,7 @@ function parsePackageName(specifier) {
  * @returns {object} Resolve result
  */
 function resolveVFSPath(checkPath, context, nextResolve, specifier) {
-  const normalized = normalizeVFSPath(checkPath);
+  const normalized = resolve(checkPath);
 
   for (let i = 0; i < activeVFSList.length; i++) {
     const vfs = activeVFSList[i];
@@ -695,7 +679,7 @@ function resolveBareSpecifier(specifier, context, nextResolve) {
   }
 
   // Find which VFS handles the parent
-  const parentNorm = normalizeVFSPath(parentPath);
+  const parentNorm = resolve(parentPath);
   let parentVfs = null;
   for (let i = 0; i < activeVFSList.length; i++) {
     if (activeVFSList[i].shouldHandle(parentNorm)) {
@@ -715,13 +699,12 @@ function resolveBareSpecifier(specifier, context, nextResolve) {
   let lastDir;
 
   while (currentDir !== lastDir) {
-    const pkgDir = normalizeVFSPath(
-      resolve(currentDir, 'node_modules', packageName));
+    const pkgDir = resolve(currentDir, 'node_modules', packageName);
 
     if (parentVfs.shouldHandle(pkgDir) &&
         vfsStat(parentVfs, pkgDir) === 1) {
       // Found the package directory
-      const pjsonPath = normalizeVFSPath(resolve(pkgDir, 'package.json'));
+      const pjsonPath = resolve(pkgDir, 'package.json');
       if (vfsStat(parentVfs, pjsonPath) === 0) {
         try {
           const content = parentVfs.readFileSync(pjsonPath, 'utf8');
@@ -737,7 +720,7 @@ function resolveBareSpecifier(specifier, context, nextResolve) {
           // No exports, resolve subpath directly
           if (packageSubpath === '.') {
             if (parsed.main) {
-              const mainPath = normalizeVFSPath(resolve(pkgDir, parsed.main));
+              const mainPath = resolve(pkgDir, parsed.main);
               if (vfsStat(parentVfs, mainPath) === 0) {
                 const url = pathToFileURL(mainPath).href;
                 const format = getVFSFormat(parentVfs, mainPath);
@@ -754,8 +737,7 @@ function resolveBareSpecifier(specifier, context, nextResolve) {
             if (indexResult) return indexResult;
           } else {
             // Resolve subpath like './feature'
-            const subResolved = normalizeVFSPath(
-              resolve(pkgDir, packageSubpath));
+            const subResolved = resolve(pkgDir, packageSubpath);
             if (vfsStat(parentVfs, subResolved) === 0) {
               const url = pathToFileURL(subResolved).href;
               const format = getVFSFormat(parentVfs, subResolved);
@@ -812,7 +794,14 @@ function vfsResolveHook(specifier, context, nextResolve) {
   // Convert specifier to an absolute path
   let checkPath;
   if (StringPrototypeStartsWith(specifier, 'file:')) {
-    checkPath = fileURLToPath(specifier);
+    try {
+      checkPath = fileURLToPath(specifier);
+    } catch {
+      // On Windows, file: URLs without a drive letter (e.g. file:///mh1/...)
+      // are invalid. Extract the path and resolve it with a drive letter.
+      const url = new URL(specifier);
+      checkPath = resolve(url.pathname);
+    }
   } else if (isAbsolute(specifier)) {
     checkPath = specifier;
   } else if (specifier[0] === '.') {
@@ -851,7 +840,7 @@ function vfsLoadHook(url, context, nextLoad) {
   }
 
   const filePath = fileURLToPath(url);
-  const normalized = normalizeVFSPath(filePath);
+  const normalized = resolve(filePath);
 
   // Check if any VFS handles this path
   for (let i = 0; i < activeVFSList.length; i++) {