vfs: fix module loader paths on Windows

Author: mcollina

lib/internal/modules/esm/resolve.js

@@ -19,6 +19,7 @@ const {
   StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
+  decodeURIComponent,
   encodeURIComponent,
 } = primordials;
 const assert = require('internal/assert');
@@ -239,9 +240,17 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   try {
     path = fileURLToPath(resolved);
   } catch (err) {
-    setOwnProperty(err, 'input', `${resolved}`);
-    setOwnProperty(err, 'module', `${base}`);
-    throw err;
+    // Windows rejects drive-less file URLs such as file:///mnt/app.js before
+    // loader hooks can see them. If a mounted VFS owns the URL pathname, use
+    // that pathname as the virtual absolute path; otherwise preserve the
+    // native file URL validation error.
+    const pathname = decodeURIComponent(resolved.pathname);
+    if (loaderGetLayerForPath(pathname) === undefined) {
+      setOwnProperty(err, 'input', `${resolved}`);
+      setOwnProperty(err, 'module', `${base}`);
+      throw err;
+    }
+    path = pathname;
   }
 
   const stats = loaderStat(

lib/internal/vfs/file_system.js

@@ -15,7 +15,7 @@ const {
 const { validateBoolean } = require('internal/validators');
 const { MemoryProvider } = require('internal/vfs/providers/memory');
 const path = require('path');
-const { posix: pathPosix, isAbsolute, resolve: resolvePath } = path;
+const { posix: pathPosix, resolve: resolvePath, toNamespacedPath } = path;
 const { join: joinPath } = pathPosix;
 const {
   isUnderMountPoint,
@@ -51,6 +51,19 @@ const kLayerId = Symbol('kLayerId');
 // messages.
 let nextLayerId = 0;
 
+/**
+ * Normalizes paths for mount-point comparisons. On Windows, `path.resolve('/x')`
+ * yields `C:\x`, while loader internals often pass namespaced paths like
+ * `\\?\C:\x`. Compare using a single canonical representation so POSIX-style
+ * rooted test paths, drive-absolute paths, and namespaced paths all route to the
+ * same VFS mount.
+ * @param {string} inputPath
+ * @returns {string}
+ */
+function normalizeMountedPath(inputPath) {
+  return toNamespacedPath(resolvePath(inputPath));
+}
+
 // Lazy-loaded VFS setup
 let registerVFS;
 let deregisterVFS;
@@ -195,8 +208,9 @@ class VirtualFileSystem {
     if (!this[kMounted] || !this[kMountPoint]) {
       return false;
     }
-    const normalized = isAbsolute(inputPath) ? inputPath : resolvePath(inputPath);
-    return isUnderMountPoint(normalized, this[kMountPoint]);
+    const normalized = normalizeMountedPath(inputPath);
+    const mountPoint = normalizeMountedPath(this[kMountPoint]);
+    return isUnderMountPoint(normalized, mountPoint);
   }
 
   // ==================== Path Resolution ====================
@@ -209,11 +223,12 @@ class VirtualFileSystem {
    */
   #toProviderPath(inputPath) {
     if (this[kMounted] && this[kMountPoint]) {
-      const resolved = isAbsolute(inputPath) ? inputPath : resolvePath(inputPath);
-      if (!isUnderMountPoint(resolved, this[kMountPoint])) {
+      const resolved = normalizeMountedPath(inputPath);
+      const mountPoint = normalizeMountedPath(this[kMountPoint]);
+      if (!isUnderMountPoint(resolved, mountPoint)) {
         throw createENOENT('open', inputPath);
       }
-      return getRelativePath(resolved, this[kMountPoint]);
+      return getRelativePath(resolved, mountPoint);
     }
     return pathPosix.normalize(inputPath);
   }