vfs: add Windows path compatibility

- Use path.isAbsolute() for cross-platform absolute path detection
  instead of checking for '/' prefix only
- Use path.posix.join() in createScopedVFS to ensure forward slashes
  on all platforms since VFS uses '/' internally
- Fix ESM module hook to recognize Windows absolute paths (C:\)
- Fix symlink target resolution for Windows paths

This enables VFS to work correctly on Windows where absolute paths
use drive letters (e.g., C:\path) instead of Unix-style forward
slashes.

Author: mcollina

lib/internal/vfs/entries.js

@@ -12,7 +12,8 @@ const {
     ERR_INVALID_STATE,
   },
 } = require('internal/errors');
-const { join } = require('path');
+// Use path.posix.join for cross-platform consistency - VFS uses forward slashes internally
+const { posix: { join } } = require('path');
 const { createFileStats, createDirectoryStats, createSymlinkStats } = require('internal/vfs/stats');
 
 // Symbols for private properties

lib/internal/vfs/module_hooks.js

@@ -8,7 +8,7 @@ const {
   StringPrototypeStartsWith,
 } = primordials;
 
-const { dirname, resolve } = require('path');
+const { dirname, isAbsolute, resolve } = require('path');
 const { normalizePath } = require('internal/vfs/router');
 const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
 const { createENOENT } = require('internal/vfs/errors');
@@ -331,8 +331,8 @@ function vfsResolveHook(specifier, context, nextResolve) {
   let checkPath;
   if (StringPrototypeStartsWith(specifier, 'file:')) {
     checkPath = fileURLToPath(specifier);
-  } else if (specifier[0] === '/') {
-    // Absolute path
+  } else if (isAbsolute(specifier)) {
+    // Absolute path (Unix / or Windows C:\)
     checkPath = specifier;
   } else if (specifier[0] === '.') {
     // Relative path - need to resolve against parent

lib/internal/vfs/router.js

@@ -9,7 +9,7 @@ const {
   StringPrototypeStartsWith,
 } = primordials;
 
-const { basename, resolve, sep } = require('path');
+const { basename, isAbsolute, resolve, sep } = require('path');
 
 /**
  * Normalizes a path for VFS lookup.
@@ -131,4 +131,5 @@ module.exports = {
   isUnderMountPoint,
   getRelativePath,
   joinMountPath,
+  isAbsolutePath: isAbsolute,
 };

lib/internal/vfs/virtual_fs.js

@@ -25,6 +25,7 @@ const {
   getBaseName,
   isUnderMountPoint,
   getRelativePath,
+  isAbsolutePath,
 } = require('internal/vfs/router');
 const {
   createENOENT,
@@ -182,8 +183,8 @@ class VirtualFileSystem {
    * @returns {string} The resolved path
    */
   resolvePath(inputPath) {
-    // If path is absolute, return as-is
-    if (inputPath.startsWith('/')) {
+    // If path is absolute, return as-is (works for both Unix / and Windows C:\)
+    if (isAbsolutePath(inputPath)) {
       return normalizePath(inputPath);
     }
 
@@ -471,13 +472,21 @@ class VirtualFileSystem {
     const target = symlink.target;
     let targetPath;
 
-    if (target.startsWith('/')) {
+    if (isAbsolutePath(target)) {
       // Absolute symlink target - interpret as VFS-internal path
       // If mounted, prepend the mount point to get the actual filesystem path
+      // Normalize first to handle Windows paths (convert \ to /)
+      const normalizedTarget = normalizePath(target);
       if (this[kMounted] && this[kMountPoint]) {
-        targetPath = this[kMountPoint] + target;
+        // For VFS-internal absolute paths starting with /, prepend mount point
+        // For external absolute paths (like C:/...), use as-is
+        if (target.startsWith('/')) {
+          targetPath = this[kMountPoint] + normalizedTarget;
+        } else {
+          targetPath = normalizedTarget;
+        }
       } else {
-        targetPath = target;
+        targetPath = normalizedTarget;
       }
     } else {
       // Relative symlink target - resolve relative to symlink's parent directory
@@ -527,7 +536,6 @@ class VirtualFileSystem {
 
     for (let i = 0; i < segments.length; i++) {
       const segment = segments[i];
-      const isLastSegment = i === segments.length - 1;
 
       // Follow symlinks for intermediate path components
       if (current.isSymbolicLink() && followSymlinks) {
@@ -571,7 +579,7 @@ class VirtualFileSystem {
    * Resolves a path to its VFS entry, if it exists.
    * Follows symlinks by default.
    * @param {string} inputPath The path to resolve
-   * @param {boolean} [followSymlinks=true] Whether to follow symlinks
+   * @param {boolean} [followSymlinks] Whether to follow symlinks
    * @returns {VirtualEntry|null}
    * @private
    */
@@ -584,7 +592,7 @@ class VirtualFileSystem {
    * Resolves a path and throws ELOOP if symlink loop detected.
    * @param {string} inputPath The path to resolve
    * @param {string} syscall The syscall name for error
-   * @param {boolean} [followSymlinks=true] Whether to follow symlinks
+   * @param {boolean} [followSymlinks] Whether to follow symlinks
    * @returns {VirtualEntry}
    * @throws {Error} ENOENT if path doesn't exist, ELOOP if symlink loop
    * @private

test/parallel/test-vfs-symlinks.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
@@ -60,7 +60,7 @@ const fs = require('fs');
 
   const lstat = vfs.lstatSync('/virtual/link.txt');
 
-  // lstat should show it's a symlink
+  // Lstat should show it's a symlink
   assert.strictEqual(lstat.isSymbolicLink(), true);
   assert.strictEqual(lstat.isFile(), false);
 
@@ -126,7 +126,7 @@ const fs = require('fs');
   const content = vfs.readFileSync('/virtual/dir/link.txt', 'utf8');
   assert.strictEqual(content, 'content');
 
-  // readlink should return the relative target as-is
+  // Readlink should return the relative target as-is
   const target = vfs.readlinkSync('/virtual/dir/link.txt');
   assert.strictEqual(target, 'file.txt');
 
@@ -229,11 +229,10 @@ const fs = require('fs');
   vfs.addSymlink('/link', '/target');
   vfs.mount('/virtual');
 
-  vfs.readlink('/virtual/link', (err, target) => {
-    assert.ifError(err);
+  vfs.readlink('/virtual/link', common.mustSucceed((target) => {
     assert.strictEqual(target, '/target');
     vfs.unmount();
-  });
+  }));
 }
 
 // Test async realpath with symlinks
@@ -243,11 +242,10 @@ const fs = require('fs');
   vfs.addSymlink('/link', '/real');
   vfs.mount('/virtual');
 
-  vfs.realpath('/virtual/link/file.txt', (err, resolvedPath) => {
-    assert.ifError(err);
+  vfs.realpath('/virtual/link/file.txt', common.mustSucceed((resolvedPath) => {
     assert.strictEqual(resolvedPath, '/virtual/real/file.txt');
     vfs.unmount();
-  });
+  }));
 }
 
 // Test promises API - stat follows symlinks
@@ -262,7 +260,7 @@ const fs = require('fs');
     assert.strictEqual(stat.isFile(), true);
     assert.strictEqual(stat.size, 50);
     vfs.unmount();
-  })();
+  })().then(common.mustCall());
 }
 
 // Test promises API - lstat does not follow symlinks
@@ -276,7 +274,7 @@ const fs = require('fs');
     const lstat = await vfs.promises.lstat('/virtual/link.txt');
     assert.strictEqual(lstat.isSymbolicLink(), true);
     vfs.unmount();
-  })();
+  })().then(common.mustCall());
 }
 
 // Test promises API - readlink
@@ -290,7 +288,7 @@ const fs = require('fs');
     const target = await vfs.promises.readlink('/virtual/link');
     assert.strictEqual(target, '/target');
     vfs.unmount();
-  })();
+  })().then(common.mustCall());
 }
 
 // Test promises API - realpath resolves symlinks
@@ -304,7 +302,7 @@ const fs = require('fs');
     const resolved = await vfs.promises.realpath('/virtual/link/file.txt');
     assert.strictEqual(resolved, '/virtual/real/file.txt');
     vfs.unmount();
-  })();
+  })().then(common.mustCall());
 }
 
 // Test broken symlink (target doesn't exist)