test_runner: mock dual-package with conditional exports

When `mock.module()` targets a package whose `exports` field maps
`import` and `require` to different files, the ESM resolver and the
CJS resolver disagree on the resolved path. Only the ESM path was
registered in `mockMap`, so `require()` of the mocked specifier
bypassed the mock and loaded the real CJS module.
Resolve the specifier through `Module._resolveFilename` from the
caller's directory in addition to the existing ESM resolution. When
the two paths differ, register the CJS path as a second key in
`mockMap` and invalidate `Module._cache[cjsPath]`, restoring it on
`restore()`. Single-resolution packages keep their existing behavior.
Fixes: #58231
Signed-off-by: Maruthan G <maruthang4@gmail.com>
PR-URL: #62943
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Jacob Smith <jacob@frende.me>

Author: maruthang

lib/internal/test_runner/mock/mock.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/mock-nm-dual-pkg.js

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/package.json

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/parallel/test-runner-mock-dual-package.js

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

lib/internal/test_runner/mock/mock.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/mock-nm-dual-pkg.js

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/package.json

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/parallel/test-runner-mock-dual-package.js

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

lib/internal/test_runner/mock/mock.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/mock-nm-dual-pkg.js

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/package.json

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/parallel/test-runner-mock-dual-package.js

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

lib/internal/test_runner/mock/mock.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/mock-nm-dual-pkg.js

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.cjs

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/index.js

@@ -20,6 +20,7 @@ const {
  ReflectConstruct,
  ReflectGet,
  SafeMap,
+ StringPrototypeIncludes,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
 }=primordials;
@@ -207,6 +208,7 @@ class MockModuleContext {
  baseURL,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -222,12 +224,25 @@ class MockModuleContext {
 
 sharedState.mockMap.set(baseURL,config);
 sharedState.mockMap.set(fullPath,config);
+// For dual packages (e.g., a package with a "exports" field that exposes
+// both ESM and CJS entry points), the file selected by the ESM resolver
+// (used to compute fullPath) may differ from the one selected by CJS
+// require(). Register the CJS-resolved path so that require() also picks
+// up the mock. See https://github.com/nodejs/node/issues/58231.
+if(cjsPath!==null&&cjsPath!==fullPath){
+sharedState.mockMap.set(cjsPath,config);
+}
 
 this.#sharedState =sharedState;
 this.#restore ={
 __proto__: null,
  baseURL,
 cached: fullPathinModule._cache,
+ cjsPath,
+cjsCached: cjsPath!==null&&cjsPath!==fullPath&&
+cjsPathinModule._cache,
+cjsValue: cjsPath!==null&&cjsPath!==fullPath ?
+Module._cache[cjsPath] : undefined,
  format,
  fullPath,
 value: Module._cache[fullPath],
@@ -257,6 +272,9 @@ class MockModuleContext {
 }
 
 deleteModule._cache[fullPath];
+if(cjsPath!==null&&cjsPath!==fullPath){
+deleteModule._cache[cjsPath];
+}
 sharedState.mockExports.set(baseURL,{
 __proto__: null,
  moduleExports,
@@ -276,6 +294,14 @@ class MockModuleContext {
 Module._cache[this.#restore.fullPath]=this.#restore.value;
 }
 
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+deleteModule._cache[this.#restore.cjsPath];
+if(this.#restore.cjsCached){
+Module._cache[this.#restore.cjsPath]=this.#restore.cjsValue;
+}
+}
+
 constmock=mocks.get(this.#restore.baseURL);
 
 if(mock!==undefined){
@@ -285,6 +311,10 @@ class MockModuleContext {
 
 this.#sharedState.mockMap.delete(this.#restore.baseURL);
 this.#sharedState.mockMap.delete(this.#restore.fullPath);
+if(this.#restore.cjsPath!==null&&
+this.#restore.cjsPath!==this.#restore.fullPath){
+this.#sharedState.mockMap.delete(this.#restore.cjsPath);
+}
 this.#restore =undefined;
 }
 }
@@ -680,11 +710,19 @@ class MockTracker {
 
 constfullPath=StringPrototypeStartsWith(url,'file://') ?
 fileURLToPath(url) : null;
+// For dual packages, the ESM resolver may return a different file than
+// CJS require() would for the same specifier (e.g., when a package's
+// "exports" field points to different files for the "import" and
+// "require" conditions). Compute the CJS-resolved path so that
+// require() of a mocked module also picks up the mock.
+// See https://github.com/nodejs/node/issues/58231.
+constcjsPath=resolveAsCJS(mockSpecifier,caller,fullPath);
 constctx=newMockModuleContext({
 __proto__: null,
 baseURL: baseURL.href,
  cache,
  caller,
+ cjsPath,
  format,
  fullPath,
  moduleExports,
@@ -987,6 +1025,54 @@ function cjsMockModuleLoad(request, parent, isMain) {
 returnmodExports;
 }
 
+// Resolve `specifier` using CJS resolution rules so that mocks for dual
+// packages (e.g., a package whose "exports" field points to different files
+// for the "import" and "require" conditions) also intercept require().
+// Returns an absolute file path on success, or null when the specifier cannot
+// be resolved as CJS (for example, when the package is ESM-only or when it is
+// a non-file URL such as data: or node:).
+functionresolveAsCJS(specifier,callerURL,esmFullPath){
+if(isBuiltin(specifier)||
+StringPrototypeStartsWith(specifier,'node:')||
+StringPrototypeStartsWith(specifier,'data:')){
+returnnull;
+}
+
+letparentPath;
+if(StringPrototypeStartsWith(callerURL,'file://')){
+try{
+parentPath=fileURLToPath(callerURL);
+}catch{
+returnnull;
+}
+}else{
+returnnull;
+}
+
+try{
+consttmpModule=newModule(parentPath,null);
+tmpModule.paths=_nodeModulePaths(parentPath);
+constresolved=_resolveFilename(specifier,tmpModule,false);
+if(typeofresolved!=='string'){
+returnnull;
+}
+// If the resolution matches what the ESM resolver picked, there is
+// nothing additional to register.
+if(resolved===esmFullPath){
+returnesmFullPath;
+}
+// If the resolution returned something that is not a filesystem path
+// (e.g., a builtin id without a slash or backslash), ignore it.
+if(!StringPrototypeIncludes(resolved,'/')&&
+!StringPrototypeIncludes(resolved,'\\')){
+returnnull;
+}
+returnresolved;
+}catch{
+returnnull;
+}
+}
+
 functionvalidateStringOrSymbol(value,name){
 if(typeofvalue!=='string'&&typeofvalue!=='symbol'){
 thrownewERR_INVALID_ARG_TYPE(name,['string','symbol'],value);

test/fixtures/test-runner/node_modules/dual-pkg-with-exports/package.json

@@ -0,0 +1,32 @@
+'use strict';
+constassert=require('node:assert');
+const{ test }=require('node:test');
+constfixture='dual-pkg-with-exports';
+
+test('mock node_modules dual package with conditional exports',async(t)=>{
+constmock=t.mock.module(fixture,{
+namedExports: {add(x,y){return1+x+y;},flavor: 'mocked'},
+});
+
+// CJS require should pick up the mock even though the package's "exports"
+// field maps the "require" condition to a different file than "import".
+constcjsImpl=require(fixture);
+assert.strictEqual(cjsImpl.add(4,5),10);
+assert.strictEqual(cjsImpl.flavor,'mocked');
+
+// ESM dynamic import should also pick up the mock.
+constesmImpl=awaitimport(fixture);
+assert.strictEqual(esmImpl.add(4,5),10);
+assert.strictEqual(esmImpl.flavor,'mocked');
+
+mock.restore();
+
+// After restore, both module systems should see the original exports.
+constrestoredCjs=require(fixture);
+assert.strictEqual(restoredCjs.add(4,5),9);
+assert.strictEqual(restoredCjs.flavor,'cjs');
+
+constrestoredEsm=awaitimport(fixture);
+assert.strictEqual(restoredEsm.add(4,5),9);
+assert.strictEqual(restoredEsm.flavor,'esm');
+});

test/parallel/test-runner-mock-dual-package.js

@@ -0,0 +1,36 @@
+'use strict';
+constcommon=require('../common');
+const{ isMainThread }=require('worker_threads');
+
+if(!isMainThread){
+common.skip('registering customization hooks in Workers does not work');
+}
+
+constfixtures=require('../common/fixtures');
+constassert=require('node:assert');
+const{ test }=require('node:test');
+
+// Regression test for https://github.com/nodejs/node/issues/58231
+// When a dual package exposes both ESM and CJS entry points via the
+// "exports" field with "import"/"require" conditions, the ESM resolver
+// picks one file (e.g. index.js) and CJS require() picks another
+// (e.g. index.cjs). mock.module() must intercept both so that require()
+// of the mocked module does not return the original CJS file.
+test('mock.module intercepts dual package require with conditional exports',
+async()=>{
+constcwd=fixtures.path('test-runner');
+constfixture=fixtures.path('test-runner','mock-nm-dual-pkg.js');
+constargs=['--experimental-test-module-mocks',fixture];
+const{
+ code,
+ stdout,
+ signal,
+}=awaitcommon.spawnPromisified(process.execPath,args,{ cwd });
+
+assert.strictEqual(signal,null);
+assert.strictEqual(code,0,
+'child process exited with non-zero status\n'+
+`stdout:\n${stdout}`);
+assert.match(stdout,/pass1/);
+assert.match(stdout,/fail0/);
+});