diff --git a/doc/api/esm.md b/doc/api/esm.md
index 6d510d0d0b00b5..f313195df0055f 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -908,6 +908,9 @@ export function resolve(specifier, context, nextResolve) {
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/47999
+    description: Add support for `source` with format `commonjs`.
   - version:
     - v18.6.0
     - v16.17.0
@@ -945,20 +948,43 @@ validating the import assertion.
 
 The final value of `format` must be one of the following:
 
-| `format`     | Description                    | Acceptable types for `source` returned by `load`      |
-| ------------ | ------------------------------ | ----------------------------------------------------- |
-| `'builtin'`  | Load a Node.js builtin module  | Not applicable                                        |
-| `'commonjs'` | Load a Node.js CommonJS module | Not applicable                                        |
-| `'json'`     | Load a JSON file               | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] } |
-| `'module'`   | Load an ES module              | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] } |
-| `'wasm'`     | Load a WebAssembly module      | { [`ArrayBuffer`][], [`TypedArray`][] }               |
+| `format`     | Description                    | Acceptable types for `source` returned by `load`                           |
+| ------------ | ------------------------------ | -------------------------------------------------------------------------- |
+| `'builtin'`  | Load a Node.js builtin module  | Not applicable                                                             |
+| `'commonjs'` | Load a Node.js CommonJS module | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][], `null`, `undefined` } |
+| `'json'`     | Load a JSON file               | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
+| `'module'`   | Load an ES module              | { [`string`][], [`ArrayBuffer`][], [`TypedArray`][] }                      |
+| `'wasm'`     | Load a WebAssembly module      | { [`ArrayBuffer`][], [`TypedArray`][] }                                    |
 
 The value of `source` is ignored for type `'builtin'` because currently it is
-not possible to replace the value of a Node.js builtin (core) module. The value
-of `source` is ignored for type `'commonjs'` because the CommonJS module loader
-does not provide a mechanism for the ES module loader to override the
-[CommonJS module return value](#commonjs-namespaces). This limitation might be
-overcome in the future.
+not possible to replace the value of a Node.js builtin (core) module.
+
+The value of `source` can be omitted for type `'commonjs'`. When a `source` is
+provided, all `require` calls from this module will be processed by the ESM
+loader with registered `resolve` and `load` hooks; all `require.resolve` calls
+from this module will be processed by the ESM loader with registered `resolve`
+hooks; `require.extensions` and monkey-patching on the CommonJS module loader
+will not apply. If `source` is undefined or `null`, it will be handled by the
+CommonJS module loader and `require`/`require.resolve` calls will not go through
+the registered hooks. This behavior for nullish `source` is temporary — in the
+future, nullish `source` will not be supported.
+
+The Node.js own `load` implementation, which is the value of `next` for the last
+loader in the `load` chain, returns `null` for `source` when `format` is
+`'commonjs'` for backward compatibility. Here is an example loader that would
+opt-in to using the non-default behavior:
+
+```js
+import { readFile } from 'node:fs/promises';
+
+export async function load(url, context, nextLoad) {
+  const result = await nextLoad(url, context);
+  if (result.format === 'commonjs') {
+    result.source ??= await readFile(new URL(result.responseURL ?? url));
+  }
+  return result;
+}
+```
 
 > **Caveat**: The ESM `load` hook and namespaced exports from CommonJS modules
 > are incompatible. Attempting to use them together will result in an empty
diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index fbd86e2881c0f0..1998ed1dab67fb 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -10,6 +10,7 @@ const { kEmptyObject } = require('internal/util');
 const { defaultGetFormat } = require('internal/modules/esm/get_format');
 const { validateAssertions } = require('internal/modules/esm/assert');
 const { getOptionValue } = require('internal/options');
+const { readFileSync } = require('fs');
 
 // Do not eagerly grab .manifest, it may be in TDZ
 const policy = getOptionValue('--experimental-policy') ?
@@ -69,12 +70,35 @@ async function getSource(url, context) {
   return { __proto__: null, responseURL, source };
 }
 
+function getSourceSync(url, context) {
+  const parsed = new URL(url);
+  const responseURL = url;
+  let source;
+  if (parsed.protocol === 'file:') {
+    source = readFileSync(parsed);
+  } else if (parsed.protocol === 'data:') {
+    const match = RegExpPrototypeExec(DATA_URL_PATTERN, parsed.pathname);
+    if (!match) {
+      throw new ERR_INVALID_URL(url);
+    }
+    const { 1: base64, 2: body } = match;
+    source = BufferFrom(decodeURIComponent(body), base64 ? 'base64' : 'utf8');
+  } else {
+    const supportedSchemes = ['file', 'data'];
+    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed, supportedSchemes);
+  }
+  if (policy?.manifest) {
+    policy.manifest.assertIntegrity(parsed, source);
+  }
+  return { __proto__: null, responseURL, source };
+}
+
 
 /**
  * Node.js default load hook.
  * @param {string} url
- * @param {object} context
- * @returns {object}
+ * @param {LoadContext} context
+ * @returns {LoadReturn}
  */
 async function defaultLoad(url, context = kEmptyObject) {
   let responseURL = url;
@@ -108,6 +132,51 @@ async function defaultLoad(url, context = kEmptyObject) {
     source,
   };
 }
+/**
+ * @typedef LoadContext
+ * @property {string} [format] A hint (possibly returned from `resolve`)
+ * @property {string | Buffer | ArrayBuffer} [source] source
+ * @property {Record<string, string>} [importAssertions] import attributes
+ */
+
+/**
+ * @typedef LoadReturn
+ * @property {string} format format
+ * @property {URL['href']} responseURL The module's fully resolved URL
+ * @property {Buffer} source source
+ */
+
+/**
+ * @param {URL['href']} url
+ * @param {LoadContext} [context]
+ * @returns {LoadReturn}
+ */
+function defaultLoadSync(url, context = kEmptyObject) {
+  let responseURL = url;
+  const { importAssertions } = context;
+  let {
+    format,
+    source,
+  } = context;
+
+  format ??= defaultGetFormat(new URL(url), context);
+
+  validateAssertions(url, format, importAssertions);
+
+  if (format === 'builtin') {
+    source = null;
+  } else if (source == null) {
+    ({ responseURL, source } = getSourceSync(url, context));
+  }
+
+  return {
+    __proto__: null,
+    format,
+    responseURL,
+    source,
+  };
+}
+
 
 /**
  * throws an error if the protocol is not one of the protocols
@@ -160,5 +229,6 @@ function throwUnknownModuleFormat(url, format) {
 
 module.exports = {
   defaultLoad,
+  defaultLoadSync,
   throwUnknownModuleFormat,
 };
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index f5ee63ddee5d4f..5305c1eb8f37d9 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -10,6 +10,7 @@ const {
 } = primordials;
 
 const {
+  ERR_REQUIRE_ESM,
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
@@ -18,7 +19,7 @@ const { emitExperimentalWarning } = require('internal/util');
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
-let defaultResolve, defaultLoad, importMetaInitializer;
+let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
 
 function newResolveCache() {
   const { ResolveCache } = require('internal/modules/esm/module_map');
@@ -220,7 +221,12 @@ class ModuleLoader {
     return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
   }
 
-  getJobFromResolveResult(resolveResult, parentURL, importAssertions) {
+  getModuleJobSync(specifier, parentURL, importAssertions) {
+    const resolveResult = this.resolveSync(specifier, parentURL, importAssertions);
+    return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions, true);
+  }
+
+  getJobFromResolveResult(resolveResult, parentURL, importAssertions, sync) {
     const { url, format } = resolveResult;
     const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
     let job = this.loadCache.get(url, resolvedImportAssertions.type);
@@ -231,7 +237,7 @@ class ModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
+      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format, sync);
     }
 
     return job;
@@ -248,17 +254,8 @@ class ModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
-    const moduleProvider = async (url, isMain) => {
-      const {
-        format: finalFormat,
-        responseURL,
-        source,
-      } = await this.load(url, {
-        format,
-        importAssertions,
-      });
-
+  #createModuleJob(url, importAssertions, parentURL, format, sync) {
+    const callTranslator = ({ format: finalFormat, responseURL, source }, isMain) => {
       const translator = getTranslators().get(finalFormat);
 
       if (!translator) {
@@ -267,6 +264,10 @@ class ModuleLoader {
 
       return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
     };
+    const context = { format, importAssertions };
+    const moduleProvider = sync ?
+      (url, isMain) => callTranslator(this.loadSync(url, context), isMain) :
+      async (url, isMain) => callTranslator(await this.load(url, context), isMain);
 
     const inspectBrk = (
       parentURL === undefined &&
@@ -285,6 +286,7 @@ class ModuleLoader {
       moduleProvider,
       parentURL === undefined,
       inspectBrk,
+      sync,
     );
 
     this.loadCache.set(url, importAssertions.type, job);
@@ -388,6 +390,24 @@ class ModuleLoader {
     return result;
   }
 
+  loadSync(url, context) {
+    defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
+
+    let result = this.#customizations ?
+      this.#customizations.loadSync(url, context) :
+      defaultLoadSync(url, context);
+    let format = result?.format;
+    if (format === 'module') {
+      throw new ERR_REQUIRE_ESM(url, true);
+    }
+    if (format === 'commonjs') {
+      format = 'require-commonjs';
+      result = { __proto__: result, format };
+    }
+    this.validateLoadResult(url, format);
+    return result;
+  }
+
   validateLoadResult(url, format) {
     if (format == null) {
       require('internal/modules/esm/load').throwUnknownModuleFormat(url, format);
@@ -465,6 +485,9 @@ class CustomizedModuleLoader {
   load(url, context) {
     return hooksProxy.makeAsyncRequest('load', undefined, url, context);
   }
+  loadSync(url, context) {
+    return hooksProxy.makeSyncRequest('load', undefined, url, context);
+  }
 
   importMetaInitialize(meta, context, loader) {
     hooksProxy.importMetaInitialize(meta, context, loader);
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 35185c64a7d08f..8ac5ff240bdb37 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -51,17 +51,26 @@ class ModuleJob {
   // `loader` is the Loader instance used for loading dependencies.
   // `moduleProvider` is a function
   constructor(loader, url, importAssertions = { __proto__: null },
-              moduleProvider, isMain, inspectBrk) {
+              moduleProvider, isMain, inspectBrk, sync = false) {
     this.loader = loader;
     this.importAssertions = importAssertions;
     this.isMain = isMain;
     this.inspectBrk = inspectBrk;
 
+    this.url = url;
+
     this.module = undefined;
     // Expose the promise to the ModuleWrap directly for linking below.
     // `this.module` is also filled in below.
     this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
 
+    if (sync) {
+      this.module = this.modulePromise;
+      this.modulePromise = PromiseResolve(this.module);
+    } else {
+      this.modulePromise = PromiseResolve(this.modulePromise);
+    }
+
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
       this.module = await this.modulePromise;
@@ -186,6 +195,20 @@ class ModuleJob {
     }
   }
 
+  runSync() {
+    assert(this.module instanceof ModuleWrap);
+    if (this.instantiated !== undefined) {
+      return { __proto__: null, module: this.module };
+    }
+
+    this.module.instantiate();
+    this.instantiated = PromiseResolve();
+    const timeout = -1;
+    const breakOnSigint = false;
+    this.module.evaluate(timeout, breakOnSigint);
+    return { __proto__: null, module: this.module };
+  }
+
   async run() {
     await this.instantiate();
     const timeout = -1;
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 267d89f1d44730..c0125cd84c37c0 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -1,13 +1,13 @@
 'use strict';
 
 const {
-  ArrayPrototypeForEach,
   ArrayPrototypeMap,
   Boolean,
   JSONParse,
   ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
   ObjectKeys,
+  ReflectApply,
   SafeArrayIterator,
   SafeMap,
   SafeSet,
@@ -24,8 +24,9 @@ function lazyTypes() {
   return _TYPES = require('internal/util/types');
 }
 
+const assert = require('internal/assert');
 const { readFileSync } = require('fs');
-const { extname, isAbsolute } = require('path');
+const { dirname, extname, isAbsolute } = require('path');
 const {
   hasEsmSyntax,
   loadBuiltinModule,
@@ -35,11 +36,11 @@ const {
   Module: CJSModule,
   cjsParseCache,
 } = require('internal/modules/cjs/loader');
-const { fileURLToPath, URL } = require('internal/url');
+const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject, setOwnProperty } = require('internal/util');
 const {
   ERR_UNKNOWN_BUILTIN_MODULE,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
@@ -49,6 +50,7 @@ const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
 const asyncESM = require('internal/process/esm_loader');
 const { emitWarningSync } = require('internal/process/warning');
+const { internalCompileFunction } = require('internal/vm');
 
 let cjsParse;
 async function initCJSParse() {
@@ -140,35 +142,104 @@ function enrichCJSError(err, content, filename) {
   }
 }
 
-// Strategy for loading a node-style CommonJS module
-const isWindows = process.platform === 'win32';
-translators.set('commonjs', async function commonjsStrategy(url, source,
-                                                            isMain) {
+/**
+ * Loads a CommonJS module via the ESM Loader sync CommonJS translator.
+ * This translator creates its own version of the `require` function passed into CommonJS modules.
+ * Any monkey patches applied to the CommonJS Loader will not affect this module.
+ * Any `require` calls in this module will load all children in the same way.
+ */
+function loadCJSModule(module, source, url, filename) {
+  let compiledWrapper;
+  try {
+    compiledWrapper = internalCompileFunction(source, [
+      'exports',
+      'require',
+      'module',
+      '__filename',
+      '__dirname',
+    ], {
+      filename,
+      importModuleDynamically(specifier, _, importAssertions) {
+        return asyncESM.esmLoader.import(specifier, url, importAssertions);
+      },
+    }).function;
+  } catch (err) {
+    enrichCJSError(err, source, url);
+    throw err;
+  }
+
+  const __dirname = dirname(filename);
+  // eslint-disable-next-line func-name-matching,func-style
+  const requireFn = function require(specifier) {
+    let importAssertions = kEmptyObject;
+    if (!StringPrototypeStartsWith(specifier, 'node:')) {
+      // TODO: do not depend on the monkey-patchable CJS loader here.
+      const path = CJSModule._resolveFilename(specifier, module);
+      if (specifier !== path) {
+        switch (extname(path)) {
+          case '.json':
+            importAssertions = { __proto__: null, type: 'json' };
+            break;
+          case '.node':
+            return CJSModule._load(specifier, module);
+          default:
+            // fall through
+        }
+        specifier = `${pathToFileURL(path)}`;
+      }
+    }
+    const job = asyncESM.esmLoader.getModuleJobSync(specifier, url, importAssertions);
+    job.runSync();
+    return cjsCache.get(job.url).exports;
+  };
+  setOwnProperty(requireFn, 'resolve', function resolve(specifier) {
+    if (!StringPrototypeStartsWith(specifier, 'node:')) {
+      const path = CJSModule._resolveFilename(specifier, module);
+      if (specifier !== path) {
+        specifier = `${pathToFileURL(path)}`;
+      }
+    }
+    const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(specifier, url, kEmptyObject);
+    return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
+  });
+  setOwnProperty(requireFn, 'main', process.mainModule);
+
+  ReflectApply(compiledWrapper, module.exports,
+               [module.exports, requireFn, module, filename, __dirname]);
+  setOwnProperty(module, 'loaded', true);
+}
+
+// TODO: can we use a weak map instead?
+const cjsCache = new SafeMap();
+function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
   debug(`Translating CJSModule ${url}`);
 
-  const filename = fileURLToPath(new URL(url));
+  const filename = StringPrototypeStartsWith(url, 'file://') ? fileURLToPath(url) : url;
+  source = stringify(source);
 
-  if (!cjsParse) await initCJSParse();
-  const { module, exportNames } = cjsPreparseModuleExports(filename);
+  const { exportNames, module } = cjsPreparseModuleExports(filename, source);
+  cjsCache.set(url, module);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
+  if (isMain) {
+    setOwnProperty(process, 'mainModule', module);
+  }
+
   return new ModuleWrap(url, undefined, namesWithDefault, function() {
     debug(`Loading CJSModule ${url}`);
 
+    if (!module.loaded) {
+      loadCJS(module, source, url, filename);
+    }
+
     let exports;
     if (asyncESM.esmLoader.cjsCache.has(module)) {
       exports = asyncESM.esmLoader.cjsCache.get(module);
       asyncESM.esmLoader.cjsCache.delete(module);
     } else {
-      try {
-        exports = CJSModule._load(filename, undefined, isMain);
-      } catch (err) {
-        enrichCJSError(err, undefined, filename);
-        throw err;
-      }
+      ({ exports } = module);
     }
-
     for (const exportName of exportNames) {
       if (!ObjectPrototypeHasOwnProperty(exports, exportName) ||
           exportName === 'default')
@@ -184,9 +255,49 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
     }
     this.setExport('default', exports);
   });
+
+}
+
+// Handle CommonJS modules referenced by `require` calls.
+// This translator function must be sync, as `require` is sync.
+translators.set('require-commonjs', (url, source, isMain) => {
+  assert(cjsParse);
+
+  return createCJSModuleWrap(url, source);
 });
 
-function cjsPreparseModuleExports(filename) {
+// Handle CommonJS modules referenced by `import` statements or expressions,
+// or as the initial entry point when the ESM loader handles a CommonJS entry.
+translators.set('commonjs', async function commonjsStrategy(url, source,
+                                                            isMain) {
+  if (!cjsParse) {
+    await initCJSParse();
+  }
+
+  // For backward-compatibility, it's possible to return a nullish value for
+  // CJS source associated with a file: URL. In this case, the source is
+  // obtained by calling the monkey-patchable CJS loader.
+  const cjsLoader = source == null ? (module, source, url, filename) => {
+    try {
+      module.load(filename);
+    } catch (err) {
+      enrichCJSError(err, source, url);
+      throw err;
+    }
+  } : loadCJSModule;
+
+  try {
+    // We still need to read the FS to detect the exports.
+    source ??= readFileSync(new URL(url), 'utf8');
+  } catch {
+    // Continue regardless of error.
+  }
+  return createCJSModuleWrap(url, source, isMain, cjsLoader);
+
+});
+
+function cjsPreparseModuleExports(filename, source) {
+  // TODO: Do we want to keep hitting the user mutable CJS loader here?
   let module = CJSModule._cache[filename];
   if (module) {
     const cached = cjsParseCache.get(module);
@@ -201,13 +312,6 @@ function cjsPreparseModuleExports(filename) {
     CJSModule._cache[filename] = module;
   }
 
-  let source;
-  try {
-    source = readFileSync(filename, 'utf8');
-  } catch {
-    // Continue regardless of error.
-  }
-
   let exports, reexports;
   try {
     ({ exports, reexports } = cjsParse(source || ''));
@@ -219,38 +323,53 @@ function cjsPreparseModuleExports(filename) {
   const exportNames = new SafeSet(new SafeArrayIterator(exports));
 
   // Set first for cycles.
-  cjsParseCache.set(module, { source, exportNames, loaded });
+  cjsParseCache.set(module, { source, exportNames });
 
   if (reexports.length) {
     module.filename = filename;
     module.paths = CJSModule._nodeModulePaths(module.path);
-  }
-  ArrayPrototypeForEach(reexports, (reexport) => {
-    let resolved;
-    try {
-      resolved = CJSModule._resolveFilename(reexport, module);
-    } catch {
-      return;
-    }
-    const ext = extname(resolved);
-    if ((ext === '.js' || ext === '.cjs' || !CJSModule._extensions[ext]) &&
-        isAbsolute(resolved)) {
-      const { exportNames: reexportNames } = cjsPreparseModuleExports(resolved);
-      for (const name of reexportNames)
-        exportNames.add(name);
+    for (let i = 0; i < reexports.length; i++) {
+      const reexport = reexports[i];
+      let resolved;
+      try {
+        // TODO: this should be calling the `resolve` hook chain instead.
+        // Doing so would mean dropping support for CJS in the loader thread, as
+        // this call needs to be sync from the perspective of the main thread,
+        // which we can do via HooksProxy and Atomics, but we can't do within
+        // the loaders thread. Until this is done, the lexer will use the
+        // monkey-patchable CJS loader to get the path to the module file to
+        // load (which may or may not be aligned with the URL that the `resolve`
+        // hook have returned).
+        resolved = CJSModule._resolveFilename(reexport, module);
+      } catch {
+        continue;
+      }
+      // TODO: this should be calling the `load` hook chain and check if it returns
+      // `format: 'commonjs'` instead of relying on file extensions.
+      const ext = extname(resolved);
+      if ((ext === '.js' || ext === '.cjs' || !CJSModule._extensions[ext]) &&
+      isAbsolute(resolved)) {
+        // TODO: this should be calling the `load` hook chain to get the source
+        // (and fallback to reading the FS only if the source is nullish).
+        const source = readFileSync(resolved, 'utf-8');
+        const { exportNames: reexportNames } = cjsPreparseModuleExports(resolved, source);
+        for (const name of reexportNames)
+          exportNames.add(name);
+      }
     }
-  });
+  }
 
   return { module, exportNames };
 }
 
 // Strategy for loading a node builtin CommonJS module that isn't
 // through normal resolution
-translators.set('builtin', async function builtinStrategy(url) {
+translators.set('builtin', function builtinStrategy(url) {
   debug(`Translating BuiltinModule ${url}`);
   // Slice 'node:' scheme
   const id = StringPrototypeSlice(url, 5);
   const module = loadBuiltinModule(id, url);
+  cjsCache.set(url, module);
   if (!StringPrototypeStartsWith(url, 'node:') || !module) {
     throw new ERR_UNKNOWN_BUILTIN_MODULE(url);
   }
@@ -259,7 +378,8 @@ translators.set('builtin', async function builtinStrategy(url) {
 });
 
 // Strategy for loading a JSON file
-translators.set('json', async function jsonStrategy(url, source) {
+const isWindows = process.platform === 'win32';
+translators.set('json', function jsonStrategy(url, source) {
   emitExperimentalWarning('Importing JSON modules');
   assertBufferSource(source, true, 'load');
   debug(`Loading JSONModule ${url}`);
@@ -283,6 +403,7 @@ translators.set('json', async function jsonStrategy(url, source) {
     // A require call could have been called on the same file during loading and
     // that resolves synchronously. To make sure we always return the identical
     // export, we have to check again if the module already exists or not.
+    // TODO: remove CJS loader from here as well.
     module = CJSModule._cache[modulePath];
     if (module && module.loaded) {
       const exports = module.exports;
@@ -308,6 +429,7 @@ translators.set('json', async function jsonStrategy(url, source) {
   if (pathname) {
     CJSModule._cache[modulePath] = module;
   }
+  cjsCache.set(url, module);
   return new ModuleWrap(url, undefined, ['default'], function() {
     debug(`Parsing JSONModule ${url}`);
     this.setExport('default', module.exports);
diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index ecb429d4593a3a..d5525f5770b052 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -713,7 +713,48 @@ describe('Loader hooks', { concurrency: true }, () => {
     assert.strictEqual(lines[3], 'hooks initialize 2');
 
     assert.strictEqual(stderr, '');
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should use CJS loader to respond to require.resolve calls by default', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      fixtures.fileURL('es-module-loaders/loader-resolve-passthru.mjs'),
+      fixtures.path('require-resolve.js'),
+    ]);
+
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, 'resolve passthru\n');
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should use ESM loader to respond to require.resolve calls when opting in', async () => {
+    const readFile = async () => {};
+    const fileURLToPath = () => {};
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      `data:text/javascript,import{readFile}from"node:fs/promises";import{fileURLToPath}from"node:url";export ${
+        async function load(u, c, n) {
+          const r = await n(u, c);
+          if (u.endsWith('/common/index.js')) {
+            r.source = '"use strict";module.exports=require("node:module").createRequire(' +
+                     `${JSON.stringify(u)})(${JSON.stringify(fileURLToPath(u))});\n`;
+          } else if (c.format === 'commonjs') {
+            r.source = await readFile(new URL(u));
+          }
+          return r;
+        }}`,
+      '--experimental-loader',
+      fixtures.fileURL('es-module-loaders/loader-resolve-passthru.mjs'),
+      fixtures.path('require-resolve.js'),
+    ]);
 
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, 'resolve passthru\n'.repeat(10));
     assert.strictEqual(code, 0);
     assert.strictEqual(signal, null);
   });
diff --git a/test/es-module/test-esm-named-exports.js b/test/es-module/test-esm-named-exports.js
new file mode 100644
index 00000000000000..4e10aaca635539
--- /dev/null
+++ b/test/es-module/test-esm-named-exports.js
@@ -0,0 +1,11 @@
+// Flags: --experimental-loader ./test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+'use strict';
+
+require('../common');
+const { readFile, __fromLoader } = require('fs');
+const assert = require('assert');
+
+assert.throws(() => require('../fixtures/es-modules/test-esm-ok.mjs'), { code: 'ERR_REQUIRE_ESM' });
+
+assert(readFile);
+assert(__fromLoader);
diff --git a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
index 8c317c1b7ce31e..7d462a53ada9d1 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
@@ -1,4 +1,5 @@
 import module from 'module';
+import { readFileSync } from 'node:fs';
 
 const GET_BUILTIN = `$__get_builtin_hole_${Date.now()}`;
 
@@ -32,7 +33,13 @@ export function load(url, context, next) {
     return {
       shortCircuit: true,
       source: generateBuiltinModule(urlObj.pathname),
-      format: 'module',
+      format: 'commonjs',
+    };
+  } else if (context.format === 'commonjs') {
+    return {
+      shortCircuit: true,
+      source: readFileSync(new URL(url)),
+      format: 'commonjs',
     };
   }
   return next(url);
@@ -46,13 +53,13 @@ function generateBuiltinModule(builtinName) {
   return `\
 const $builtinInstance = ${GET_BUILTIN}(${JSON.stringify(builtinName)});
 
-export const __fromLoader = true;
-
-export default $builtinInstance;
+module.exports = $builtinInstance;
+module.exports.__fromLoader = true;
 
+// We need this for CJS-module-lexer can parse the exported names. 
 ${
   builtinExports
-    .map(name => `export const ${name} = $builtinInstance.${name};`)
+    .map(name => `exports.${name} = $builtinInstance.${name};`)
     .join('\n')
 }
 `;
diff --git a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
index ea4c73724298db..2486899ea3753f 100644
--- a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
+++ b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
@@ -1,22 +1,16 @@
 import assert from 'node:assert';
 
-// a loader that asserts that the defaultResolve will throw "not found"
-// (skipping the top-level main of course)
+// A loader that asserts that the defaultResolve will throw "not found"
+// (skipping the top-level main of course, and the built-in ones needed for run-worker).
 let mainLoad = true;
 export async function resolve(specifier, { importAssertions }, next) {
-  if (mainLoad) {
+  if (mainLoad || specifier === 'path' || specifier === 'worker_threads') {
     mainLoad = false;
     return next(specifier);
   }
-  try {
-    await next(specifier);
-  }
-  catch (e) {
-    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
-    return {
-      url: 'node:fs',
-      importAssertions,
-    };
-  }
-  assert.fail(`Module resolution for ${specifier} should be throw ERR_MODULE_NOT_FOUND`);
+  await assert.rejects(next(specifier), { code: 'ERR_MODULE_NOT_FOUND' });
+  return {
+    url: 'node:fs',
+    importAssertions,
+  };
 }
diff --git a/test/fixtures/require-resolve.js b/test/fixtures/require-resolve.js
index 9a7fc3385143aa..ae0609f97c2f27 100644
--- a/test/fixtures/require-resolve.js
+++ b/test/fixtures/require-resolve.js
@@ -12,10 +12,12 @@ assert.strictEqual(
   path.join(nodeModules, 'bar.js')
 );
 
-// Verify that existing paths are removed.
-assert.throws(() => {
-  require.resolve('bar', { paths: [] })
-}, /^Error: Cannot find module 'bar'/);
+if (require.resolve.paths) {
+  // Verify that existing paths are removed.
+  assert.throws(() => {
+    require.resolve('bar', { paths: [] })
+  }, /^Error: Cannot find module 'bar'/);
+}
 
 // Verify that resolution path can be overwritten.
 {
@@ -39,7 +41,7 @@ assert.throws(() => {
 }
 
 // Verify that the default paths can be used and modified.
-{
+if (require.resolve.paths) {
   const paths = require.resolve.paths('bar');
 
   assert.strictEqual(paths[0], nodeModules);
@@ -56,7 +58,7 @@ assert.throws(() => {
 }
 
 // Verify that relative request paths work properly.
-{
+if (require.resolve.paths) {
   const searchIn = './' + path.relative(process.cwd(), nestedIndex);
 
   // Search in relative paths.
@@ -85,13 +87,15 @@ assert.throws(() => {
   }
 }
 
-// Test paths option validation
-assert.throws(() => {
-  require.resolve('.\\three.js', { paths: 'foo' })
-}, {
-  code: 'ERR_INVALID_ARG_VALUE',
-  name: 'TypeError',
-});
+if (require.resolve.paths) {
+  // Test paths option validation
+  assert.throws(() => {
+    require.resolve('.\\three.js', { paths: 'foo' })
+  }, {
+    code: 'ERR_INVALID_ARG_VALUE',
+    name: 'TypeError',
+  });
+}
 
 // Verify that the default require.resolve() is used for empty options.
 assert.strictEqual(