fs: fix realpath of namespaced drive paths

The JavaScript realpath implementation probes a namespaced drive root
through the fs binding. Windows path resolution drops the trailing
separator from that probe, so lstat receives C: and reports EISDIR.
Use the regular drive-root spelling only for the probe. Preserve the
namespaced spelling for traversal and returned paths.
Signed-off-by: Jason Zhang <xzha4350@gmail.com>
PR-URL: #65378Fixes: #62446
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Stefan Stojanovic <stefan.stojanovic@janeasystems.com>

Author: jazelly

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});

lib/fs.js

@@ -3272,13 +3272,22 @@ function unwatchFile(filename, listener) {
 
 
 letsplitRoot;
+letgetRealpathRootLstatPath;
 if(isWindows){
 // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
 // slash.
 constsplitRootRe=/^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+constnamespacedDriveRootRe=/^\\\\\?\\([a-zA-Z]:\\)$/;
 splitRoot=functionsplitRoot(str){
 returnSideEffectFreeRegExpPrototypeExec(splitRootRe,str)[0];
 };
+
+// The root probe is the only use of this path. Passing a namespaced drive
+// root to the binding would lose its trailing separator during resolution.
+getRealpathRootLstatPath=functiongetRealpathRootLstatPath(path){
+constmatch=SideEffectFreeRegExpPrototypeExec(namespacedDriveRootRe,path);
+returnmatch===null ? path : match[1];
+};
 }else{
 splitRoot=functionsplitRoot(str){
 for(leti=0;i<str.length;++i){
@@ -3287,6 +3296,7 @@ if (isWindows) {
 }
 returnstr;
 };
+
 }
 
 functionencodeRealpathResult(result,options){
@@ -3368,7 +3378,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3453,7 +3464,8 @@ function realpathSync(p, options) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-constout=binding.lstat(base,false,undefined,true/* throwIfNoEntry */);
+constout=binding.lstat(
+getRealpathRootLstatPath(base),false,undefined,true/* throwIfNoEntry */);
 if(out===undefined){
 return;
 }
@@ -3537,7 +3549,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();
@@ -3626,7 +3638,7 @@ function realpath(p, options, callback) {
 
 // On windows, check that the root exists. On unix there is no need.
 if(isWindows&&!knownHard.has(base)){
-fs.lstat(base,(err)=>{
+fs.lstat(getRealpathRootLstatPath(base),(err)=>{
 if(err)returncallback(err);
 knownHard.add(base);
 LOOP();

test/es-module/test-esm-long-path-win.js

@@ -47,6 +47,24 @@ describe('long path on Windows', () => {
 tmpdir.refresh();
 });
 
+it('runs an extended-length path as the entry point',async()=>{
+// The module loader resolves argv[1] through the JavaScript realpath
+// implementation before executing it.
+tmpdir.refresh();
+constentry=tmpdir.resolve('extended-entry.js');
+fs.writeFileSync(entry,'console.log("hello world");');
+
+const{ code, signal, stderr, stdout }=awaitspawnPromisified(
+execPath,
+[path.toNamespacedPath(entry)],
+);
+
+assert.strictEqual(stderr,'');
+assert.strictEqual(stdout.trim(),'hello world');
+assert.strictEqual(code,0);
+assert.strictEqual(signal,null);
+});
+
 it('check long path in LegacyMainResolve - 1',()=>{
 // Module layout will be the following:
 // package.json

test/parallel/test-fs-realpath-namespaced-drive-win.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.isWindows){
+common.skip('This test is Windows-specific.');
+}
+
+// Verify that the JavaScript realpath implementation accepts namespaced drive
+// paths, including when a junction switches the walk back to a regular drive
+// path, and reports a missing entry instead of treating the drive as a file.
+
+constassert=require('node:assert');
+constfs=require('node:fs');
+constpath=require('node:path');
+const{ test }=require('node:test');
+consttmpdir=require('../common/tmpdir');
+
+tmpdir.refresh();
+
+constentry=tmpdir.resolve('entry.js');
+constnamespacedEntry=path.toNamespacedPath(entry);
+constnamespacedMissing=path.toNamespacedPath(tmpdir.resolve('missing.js'));
+consttargetDir=tmpdir.resolve('target');
+consttargetEntry=path.join(targetDir,'entry.js');
+constjunctionDir=tmpdir.resolve('junction');
+constnamespacedJunctionEntry=path.toNamespacedPath(
+path.join(junctionDir,'entry.js'),
+);
+
+fs.writeFileSync(entry,'');
+fs.mkdirSync(targetDir);
+fs.writeFileSync(targetEntry,'');
+fs.symlinkSync(targetDir,junctionDir,'junction');
+
+functionassertNamespacedRealpath(result){
+assert.strictEqual(path.toNamespacedPath(result),namespacedEntry);
+}
+
+test('fs.realpathSync resolves a namespaced drive path',()=>{
+assertNamespacedRealpath(fs.realpathSync(namespacedEntry));
+});
+
+test('fs.realpathSync reports ENOENT for a missing namespaced drive path',()=>{
+assert.throws(()=>fs.realpathSync(namespacedMissing),{code: 'ENOENT'});
+});
+
+test('fs.realpathSync resolves a namespaced path through a junction',()=>{
+assert.strictEqual(fs.realpathSync(namespacedJunctionEntry),targetEntry);
+});
+
+test('fs.realpath resolves a namespaced drive path',(t,done)=>{
+fs.realpath(namespacedEntry,common.mustSucceed((result)=>{
+assertNamespacedRealpath(result);
+done();
+}));
+});
+
+test('fs.realpath resolves a namespaced path through a junction',(t,done)=>{
+fs.realpath(namespacedJunctionEntry,common.mustSucceed((result)=>{
+assert.strictEqual(result,targetEntry);
+done();
+}));
+});