From 3deeccfe12cebfe1ddbbdab1b757608f2055ef76 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 11 May 2023 22:47:32 +0200
Subject: [PATCH 01/32] module: make CJS load from ESM loader

---
 lib/internal/modules/esm/load.js        |  68 ++++++++++++-
 lib/internal/modules/esm/loader.js      |  47 ++++++++-
 lib/internal/modules/esm/module_job.js  |  13 +++
 lib/internal/modules/esm/translators.js | 129 +++++++++++++-----------
 4 files changed, 190 insertions(+), 67 deletions(-)

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index fbd86e2881c0f0..39b2cfc2aebb88 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -69,6 +69,33 @@ 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:') {
+    const { readFileSync } = require('fs');
+    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'];
+    if (experimentalNetworkImports) {
+      ArrayPrototypePush(supportedSchemes, 'http', 'https');
+    }
+    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.
@@ -92,10 +119,7 @@ async function defaultLoad(url, context = kEmptyObject) {
 
   validateAssertions(url, format, importAssertions);
 
-  if (
-    format === 'builtin' ||
-    format === 'commonjs'
-  ) {
+  if (format === 'builtin') {
     source = null;
   } else if (source == null) {
     ({ responseURL, source } = await getSource(urlInstance, context));
@@ -109,6 +133,41 @@ async function defaultLoad(url, context = kEmptyObject) {
   };
 }
 
+/**
+ * Node.js default load hook.
+ * @param {string} url
+ * @param {object} context
+ * @returns {object}
+ */
+function defaultLoadSync(url, context = kEmptyObject) {
+  let responseURL = url;
+  const { importAssertions } = context;
+  let {
+    format,
+    source,
+  } = context;
+
+  if (format == null) {
+    format = defaultGetFormat(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
  * that can be loaded in the default loader
@@ -160,5 +219,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..e7ea1affff0a38 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -18,7 +18,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 +220,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 +236,7 @@ class ModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
+      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format, sync);
     }
 
     return job;
@@ -248,8 +253,25 @@ class ModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
-    const moduleProvider = async (url, isMain) => {
+  #createModuleJob(url, importAssertions, parentURL, format, sync) {
+    const moduleProvider = sync ? (url, isMain) => {
+      const {
+        format: finalFormat,
+        responseURL,
+        source,
+      } = this.loadSync(url, {
+        format,
+        importAssertions,
+      });
+
+      const translator = getTranslators().get(finalFormat);
+
+      if (!translator) {
+        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+      }
+
+      return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
+    } : async (url, isMain) => {
       const {
         format: finalFormat,
         responseURL,
@@ -388,6 +410,15 @@ class ModuleLoader {
     return result;
   }
 
+  loadSync(url, context) {
+    defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
+
+    const result = defaultLoadSync(url, context);
+    result.format = `require-${result?.format}`;
+    this.validateLoadResult(url, result?.format);
+    return result;
+  }
+
   validateLoadResult(url, format) {
     if (format == null) {
       require('internal/modules/esm/load').throwUnknownModuleFormat(url, format);
@@ -473,6 +504,12 @@ class CustomizedModuleLoader {
   forceLoadHooks() {
     hooksProxy.waitForWorker();
   }
+  loadSync(url, context) {
+    const result = hooksProxy.makeSyncRequest('load', url, context);
+    this.validateLoadResult(url, result?.format);
+
+    return result;
+  }
 }
 
 let emittedExperimentalWarning = false;
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 35185c64a7d08f..b6089030a51bb8 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -57,6 +57,8 @@ class ModuleJob {
     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.
@@ -186,6 +188,17 @@ class ModuleJob {
     }
   }
 
+  runSync() {
+    assert(this.modulePromise instanceof ModuleWrap);
+
+    // TODO: better handle errors
+    this.modulePromise.instantiate();
+    const timeout = -1;
+    const breakOnSigint = false;
+    this.modulePromise.evaluate(timeout, breakOnSigint);
+    return { __proto__: null, module: this.modulePromise };
+  }
+
   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..7a7c45e550d12e 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,
+  Function,
   JSONParse,
   ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
   ObjectKeys,
+  ReflectApply,
   SafeArrayIterator,
   SafeMap,
   SafeSet,
@@ -25,7 +25,7 @@ function lazyTypes() {
 }
 
 const { readFileSync } = require('fs');
-const { extname, isAbsolute } = require('path');
+const { dirname, join } = require('path');
 const {
   hasEsmSyntax,
   loadBuiltinModule,
@@ -33,13 +33,12 @@ const {
 } = require('internal/modules/helpers');
 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 } = require('internal/util');
 const {
   ERR_UNKNOWN_BUILTIN_MODULE,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
@@ -140,6 +139,45 @@ function enrichCJSError(err, content, filename) {
   }
 }
 
+const cjsCache = new Map();
+function loadCJS(url, source) {
+  if (cjsCache.has(url)) return cjsCache.get(url).exports;
+
+  debug(`Loading CJSModule ${url}`);
+
+  const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
+
+  // TODO: make module object compatible with CJS Module class
+  const module = { exports: {} };
+  const filename = fileURLToPath(new URL(url));
+  const __dirname = dirname(filename);
+  // TODO: add missing properties on the require function
+  // eslint-disable-next-line func-name-matching,func-style
+  const requireFn = function require(spec) {
+    // TODO: add support for absolute paths
+    if (spec[0] === '.') {
+      spec = pathToFileURL(join(__dirname, spec));
+    }
+    // TODO: add support for JSON imports
+    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, kEmptyObject);
+    job.runSync();
+    return cjsCache.get(job.url).exports;
+  };
+
+  cjsCache.set(url, module);
+  ReflectApply(compiledWrapper, module.exports,
+               [module.exports, requireFn, module, filename, __dirname]);
+
+  return module.exports;
+}
+
+translators.set('require-commonjs', (url, source, isMain) => {
+  return new ModuleWrap(url, undefined, ['default'], function() {
+    const exports = loadCJS(url, source);
+    this.setExport('default', exports);
+  });
+});
+
 // Strategy for loading a node-style CommonJS module
 const isWindows = process.platform === 'win32';
 translators.set('commonjs', async function commonjsStrategy(url, source,
@@ -149,25 +187,12 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
   const filename = fileURLToPath(new URL(url));
 
   if (!cjsParse) await initCJSParse();
-  const { module, exportNames } = cjsPreparseModuleExports(filename);
+  const { exportNames } = cjsPreparseModuleExports(filename);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
   return new ModuleWrap(url, undefined, namesWithDefault, function() {
-    debug(`Loading CJSModule ${url}`);
-
-    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;
-      }
-    }
+    const exports = loadCJS(url, source);
 
     for (const exportName of exportNames) {
       if (!ObjectPrototypeHasOwnProperty(exports, exportName) ||
@@ -187,20 +212,6 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
 });
 
 function cjsPreparseModuleExports(filename) {
-  let module = CJSModule._cache[filename];
-  if (module) {
-    const cached = cjsParseCache.get(module);
-    if (cached)
-      return { module, exportNames: cached.exportNames };
-  }
-  const loaded = Boolean(module);
-  if (!loaded) {
-    module = new CJSModule(filename);
-    module.filename = filename;
-    module.paths = CJSModule._nodeModulePaths(module.path);
-    CJSModule._cache[filename] = module;
-  }
-
   let source;
   try {
     source = readFileSync(filename, 'utf8');
@@ -219,29 +230,30 @@ function cjsPreparseModuleExports(filename) {
   const exportNames = new SafeSet(new SafeArrayIterator(exports));
 
   // Set first for cycles.
-  cjsParseCache.set(module, { source, exportNames, loaded });
-
-  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);
-    }
-  });
-
-  return { module, exportNames };
+  // cjsParseCache.set(module, { source, exportNames });
+
+  // TODO: add back support for reexports
+  // 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);
+  //   }
+  // });
+
+  return { exportNames };
 }
 
 // Strategy for loading a node builtin CommonJS module that isn't
@@ -283,6 +295,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;

From c1b346c5950c69ad2b8e45f809a34af0c6d16541 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 14 May 2023 19:18:16 +0200
Subject: [PATCH 02/32] fixup! module: make CJS load from ESM loader

---
 lib/internal/modules/esm/loader.js     |  1 +
 lib/internal/modules/esm/module_job.js | 19 ++++++++++++++-----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index e7ea1affff0a38..b2296b970e0b47 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -307,6 +307,7 @@ class ModuleLoader {
       moduleProvider,
       parentURL === undefined,
       inspectBrk,
+      sync,
     );
 
     this.loadCache.set(url, importAssertions.type, job);
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index b6089030a51bb8..a269d31cc79074 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -51,7 +51,7 @@ 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;
@@ -64,6 +64,11 @@ class ModuleJob {
     // `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);
+    }
+
     // Wait for the ModuleWrap instance being linked with all dependencies.
     const link = async () => {
       this.module = await this.modulePromise;
@@ -189,14 +194,18 @@ class ModuleJob {
   }
 
   runSync() {
-    assert(this.modulePromise instanceof ModuleWrap);
+    if (this.instantiated !== undefined) {
+      return this.instantiated;
+    }
+    assert(this.module instanceof ModuleWrap);
 
     // TODO: better handle errors
-    this.modulePromise.instantiate();
+    this.module.instantiate();
+    this.instantiated = PromiseResolve();
     const timeout = -1;
     const breakOnSigint = false;
-    this.modulePromise.evaluate(timeout, breakOnSigint);
-    return { __proto__: null, module: this.modulePromise };
+    this.module.evaluate(timeout, breakOnSigint);
+    return { __proto__: null, module: this.module };
   }
 
   async run() {

From df14ab841fec9ea3023b11bb70a034c55dcde50c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 14 May 2023 19:25:41 +0200
Subject: [PATCH 03/32] fixup! module: make CJS load from ESM loader

---
 lib/internal/modules/esm/module_job.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index a269d31cc79074..a37512d37566cb 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -194,10 +194,10 @@ class ModuleJob {
   }
 
   runSync() {
+    assert(this.module instanceof ModuleWrap);
     if (this.instantiated !== undefined) {
-      return this.instantiated;
+      return { __proto__: null, module: this.module };
     }
-    assert(this.module instanceof ModuleWrap);
 
     // TODO: better handle errors
     this.module.instantiate();

From f5fdea1edcc1e6fe4121429dc37400faa8032661 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 23 May 2023 16:59:08 +0200
Subject: [PATCH 04/32] make CJS ModuleWrap instanciation consistent

---
 lib/internal/modules/esm/translators.js | 153 ++++++++++++------------
 1 file changed, 75 insertions(+), 78 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 7a7c45e550d12e..3b2fc6a0efa33e 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -24,8 +24,9 @@ function lazyTypes() {
   return _TYPES = require('internal/util/types');
 }
 
+const assert = require('internal/assert');
 const { readFileSync } = require('fs');
-const { dirname, join } = require('path');
+const { dirname, extname, isAbsolute, join } = require('path');
 const {
   hasEsmSyntax,
   loadBuiltinModule,
@@ -33,6 +34,7 @@ const {
 } = require('internal/modules/helpers');
 const {
   Module: CJSModule,
+  cjsParseCache,
 } = require('internal/modules/cjs/loader');
 const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
@@ -139,61 +141,45 @@ function enrichCJSError(err, content, filename) {
   }
 }
 
-const cjsCache = new Map();
-function loadCJS(url, source) {
-  if (cjsCache.has(url)) return cjsCache.get(url).exports;
-
-  debug(`Loading CJSModule ${url}`);
-
-  const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
-
-  // TODO: make module object compatible with CJS Module class
-  const module = { exports: {} };
-  const filename = fileURLToPath(new URL(url));
-  const __dirname = dirname(filename);
-  // TODO: add missing properties on the require function
-  // eslint-disable-next-line func-name-matching,func-style
-  const requireFn = function require(spec) {
-    // TODO: add support for absolute paths
-    if (spec[0] === '.') {
-      spec = pathToFileURL(join(__dirname, spec));
-    }
-    // TODO: add support for JSON imports
-    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, kEmptyObject);
-    job.runSync();
-    return cjsCache.get(job.url).exports;
-  };
-
-  cjsCache.set(url, module);
-  ReflectApply(compiledWrapper, module.exports,
-               [module.exports, requireFn, module, filename, __dirname]);
-
-  return module.exports;
-}
-
-translators.set('require-commonjs', (url, source, isMain) => {
-  return new ModuleWrap(url, undefined, ['default'], function() {
-    const exports = loadCJS(url, source);
-    this.setExport('default', exports);
-  });
-});
-
-// Strategy for loading a node-style CommonJS module
-const isWindows = process.platform === 'win32';
-translators.set('commonjs', async function commonjsStrategy(url, source,
-                                                            isMain) {
+// TODO: can we use a weak map instead?
+const cjsCache = new SafeMap();
+function createCJSModuleWrap(url, source) {
   debug(`Translating CJSModule ${url}`);
 
   const filename = fileURLToPath(new URL(url));
 
-  if (!cjsParse) await initCJSParse();
-  const { exportNames } = cjsPreparseModuleExports(filename);
+  const { exportNames } = cjsPreparseModuleExports(filename, source);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
   return new ModuleWrap(url, undefined, namesWithDefault, function() {
-    const exports = loadCJS(url, source);
+    if (cjsCache.has(url)) return cjsCache.get(url).exports;
+
+    debug(`Loading CJSModule ${url}`);
 
+    const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
+
+    // TODO: make module object compatible with CJS Module class
+    const module = { exports: {} };
+    const __dirname = dirname(filename);
+    // TODO: add missing properties on the require function
+    // eslint-disable-next-line func-name-matching,func-style
+    const requireFn = function require(spec) {
+      // TODO: add support for absolute paths
+      if (spec[0] === '.') {
+        spec = pathToFileURL(join(__dirname, spec));
+      }
+      // TODO: add support for JSON imports
+      const job = asyncESM.esmLoader.getModuleJob(spec, url, kEmptyObject, true);
+      job.runSync();
+      return cjsCache.get(job.url).exports;
+    };
+
+    cjsCache.set(url, module);
+    ReflectApply(compiledWrapper, module.exports,
+                 [module.exports, requireFn, module, filename, __dirname]);
+
+    const { exports } = module;
     for (const exportName of exportNames) {
       if (!ObjectPrototypeHasOwnProperty(exports, exportName) ||
           exportName === 'default')
@@ -209,16 +195,23 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
     }
     this.setExport('default', exports);
   });
+
+}
+
+translators.set('require-commonjs', (url, source, isMain) => {
+  assert(cjsParse);
+
+  return createCJSModuleWrap(url, source);
 });
 
-function cjsPreparseModuleExports(filename) {
-  let source;
-  try {
-    source = readFileSync(filename, 'utf8');
-  } catch {
-    // Continue regardless of error.
-  }
+// Strategy for loading a node-style CommonJS module
+translators.set('commonjs', async function commonjsStrategy(url, source,
+                                                            isMain) {
+  if (!cjsParse) await initCJSParse();
+  return createCJSModuleWrap(url, source);
+});
 
+function cjsPreparseModuleExports(filename, source) {
   let exports, reexports;
   try {
     ({ exports, reexports } = cjsParse(source || ''));
@@ -230,30 +223,33 @@ function cjsPreparseModuleExports(filename) {
   const exportNames = new SafeSet(new SafeArrayIterator(exports));
 
   // Set first for cycles.
-  // cjsParseCache.set(module, { source, exportNames });
-
-  // TODO: add back support for reexports
-  // 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);
-  //   }
-  // });
-
-  return { exportNames };
+  cjsParseCache.set(module, { source, exportNames });
+
+  if (reexports.length) {
+    module.filename = filename;
+    module.paths = CJSModule._nodeModulePaths(module.path);
+    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.
+        resolved = CJSModule._resolveFilename(reexport, module);
+      } catch {
+        return;
+      }
+      // 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)) {
+        const { exportNames: reexportNames } = cjsPreparseModuleExports(resolved, readFileSync(resolved, 'utf-8'));
+        for (const name of reexportNames)
+          exportNames.add(name);
+      }
+    }
+  }
+
+  return { exportNames, reexports };
 }
 
 // Strategy for loading a node builtin CommonJS module that isn't
@@ -271,6 +267,7 @@ translators.set('builtin', async function builtinStrategy(url) {
 });
 
 // Strategy for loading a JSON file
+const isWindows = process.platform === 'win32';
 translators.set('json', async function jsonStrategy(url, source) {
   emitExperimentalWarning('Importing JSON modules');
   assertBufferSource(source, true, 'load');

From 598d7893b52892729cc67f3144f3bb048b25eac0 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 23 May 2023 17:30:18 +0200
Subject: [PATCH 05/32] fixup! make CJS ModuleWrap instanciation consistent

---
 lib/internal/modules/esm/translators.js | 28 +++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 3b2fc6a0efa33e..9810c7b10b3253 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -2,6 +2,7 @@
 
 const {
   ArrayPrototypeMap,
+  Boolean,
   Function,
   JSONParse,
   ObjectGetPrototypeOf,
@@ -148,7 +149,7 @@ function createCJSModuleWrap(url, source) {
 
   const filename = fileURLToPath(new URL(url));
 
-  const { exportNames } = cjsPreparseModuleExports(filename, source);
+  const { exportNames, module } = cjsPreparseModuleExports(filename, source);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
@@ -159,8 +160,6 @@ function createCJSModuleWrap(url, source) {
 
     const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
 
-    // TODO: make module object compatible with CJS Module class
-    const module = { exports: {} };
     const __dirname = dirname(filename);
     // TODO: add missing properties on the require function
     // eslint-disable-next-line func-name-matching,func-style
@@ -212,9 +211,26 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
 });
 
 function cjsPreparseModuleExports(filename, source) {
+  let module = CJSModule._cache[filename];
+  if (module) {
+    const cached = cjsParseCache.get(module);
+    if (cached)
+      return { module, exportNames: cached.exportNames };
+  }
+  const loaded = Boolean(module);
+  debug(`IsLoaded CJSModule ${filename}? ${loaded}`);
+  if (!loaded) {
+    module = new CJSModule(filename);
+    module.filename = filename;
+    module.paths = CJSModule._nodeModulePaths(module.path);
+    CJSModule._cache[filename] = module;
+  }
+
   let exports, reexports;
   try {
-    ({ exports, reexports } = cjsParse(source || ''));
+    // TODO: use a TextDecoder, or add support for BufferView in `cjsParse`
+    const sourceString = typeof source === 'string' ? source : `${source}`;
+    ({ exports, reexports } = cjsParse(sourceString || ''));
   } catch {
     exports = [];
     reexports = [];
@@ -235,7 +251,7 @@ function cjsPreparseModuleExports(filename, source) {
         // TODO: this should be calling the `resolve` hook chain instead.
         resolved = CJSModule._resolveFilename(reexport, module);
       } catch {
-        return;
+        continue;
       }
       // TODO: this should be calling the `load` hook chain and check if it returns
       // `format: 'commonjs'` instead of relying on file extensions.
@@ -249,7 +265,7 @@ function cjsPreparseModuleExports(filename, source) {
     }
   }
 
-  return { exportNames, reexports };
+  return { module, exportNames };
 }
 
 // Strategy for loading a node builtin CommonJS module that isn't

From afd882a8cbaaa91e2a1596d493de80e5c0bcc73e Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 23 May 2023 17:36:23 +0200
Subject: [PATCH 06/32] add some properties to `require`

---
 lib/internal/modules/esm/translators.js | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 9810c7b10b3253..0fe2963dff81d5 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -41,7 +41,7 @@ const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
-const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject, setOwnProperty } = require('internal/util');
 const {
   ERR_UNKNOWN_BUILTIN_MODULE,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
@@ -147,7 +147,7 @@ const cjsCache = new SafeMap();
 function createCJSModuleWrap(url, source) {
   debug(`Translating CJSModule ${url}`);
 
-  const filename = fileURLToPath(new URL(url));
+  const filename = StringPrototypeStartsWith(url, 'file://') ? fileURLToPath(url) : url;
 
   const { exportNames, module } = cjsPreparseModuleExports(filename, source);
   const namesWithDefault = exportNames.has('default') ?
@@ -173,6 +173,16 @@ function createCJSModuleWrap(url, source) {
       job.runSync();
       return cjsCache.get(job.url).exports;
     };
+    setOwnProperty(require, 'resolve', function resolve(spec) {
+      // TODO: add support for absolute paths
+      if (spec[0] === '.') {
+        spec = pathToFileURL(join(__dirname, spec));
+      }
+      const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
+      return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
+    });
+    setOwnProperty(require, 'cache', CJSModule._cache);
+    setOwnProperty(require, 'main', process.mainModule);
 
     cjsCache.set(url, module);
     ReflectApply(compiledWrapper, module.exports,
@@ -211,6 +221,7 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
 });
 
 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);

From 9958f1f3b27bf250f5df844a05c8d9319e2f529a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 23 May 2023 17:42:32 +0200
Subject: [PATCH 07/32] fixup! add some properties to `require`

---
 lib/internal/modules/esm/translators.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 0fe2963dff81d5..6e42ae48f38fa3 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -173,16 +173,17 @@ function createCJSModuleWrap(url, source) {
       job.runSync();
       return cjsCache.get(job.url).exports;
     };
-    setOwnProperty(require, 'resolve', function resolve(spec) {
+    setOwnProperty(requireFn, 'resolve', function resolve(spec) {
       // TODO: add support for absolute paths
       if (spec[0] === '.') {
         spec = pathToFileURL(join(__dirname, spec));
       }
+      // TODO: make this work for CJSism (e.g. dir import, extensionless imports, etc.)
       const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
       return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
     });
-    setOwnProperty(require, 'cache', CJSModule._cache);
-    setOwnProperty(require, 'main', process.mainModule);
+    setOwnProperty(requireFn, 'cache', CJSModule._cache);
+    setOwnProperty(requireFn, 'main', process.mainModule);
 
     cjsCache.set(url, module);
     ReflectApply(compiledWrapper, module.exports,

From 6d57350be22b43c631510971602c392302c43198 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 25 May 2023 16:40:30 +0200
Subject: [PATCH 08/32] fixes

---
 lib/internal/modules/esm/loader.js      | 10 +++++++---
 lib/internal/modules/esm/module_job.js  |  2 ++
 lib/internal/modules/esm/translators.js | 18 +++++++++---------
 3 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index b2296b970e0b47..b41dc77f58af82 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -414,9 +414,13 @@ class ModuleLoader {
   loadSync(url, context) {
     defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
 
-    const result = defaultLoadSync(url, context);
-    result.format = `require-${result?.format}`;
-    this.validateLoadResult(url, result?.format);
+    let result = defaultLoadSync(url, context);
+    let format = result?.format;
+    if (format === 'commonjs') {
+      format = 'require-commonjs';
+      result = { __proto__: result, format };
+    }
+    this.validateLoadResult(url, format);
     return result;
   }
 
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index a37512d37566cb..9e15ef666e269d 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -67,6 +67,8 @@ class ModuleJob {
     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.
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 6e42ae48f38fa3..9d31b6ae69e8e1 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -161,14 +161,12 @@ function createCJSModuleWrap(url, source) {
     const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
 
     const __dirname = dirname(filename);
-    // TODO: add missing properties on the require function
     // eslint-disable-next-line func-name-matching,func-style
     const requireFn = function require(spec) {
       // TODO: add support for absolute paths
       if (spec[0] === '.') {
-        spec = pathToFileURL(join(__dirname, spec));
+        spec = pathToFileURL(CJSModule._findPath(join(__dirname, spec)));
       }
-      // TODO: add support for JSON imports
       const job = asyncESM.esmLoader.getModuleJob(spec, url, kEmptyObject, true);
       job.runSync();
       return cjsCache.get(job.url).exports;
@@ -176,7 +174,7 @@ function createCJSModuleWrap(url, source) {
     setOwnProperty(requireFn, 'resolve', function resolve(spec) {
       // TODO: add support for absolute paths
       if (spec[0] === '.') {
-        spec = pathToFileURL(join(__dirname, spec));
+        spec = pathToFileURL(CJSModule._findPath(join(__dirname, spec)));
       }
       // TODO: make this work for CJSism (e.g. dir import, extensionless imports, etc.)
       const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
@@ -238,11 +236,11 @@ function cjsPreparseModuleExports(filename, source) {
     CJSModule._cache[filename] = module;
   }
 
+  source = stringify(source);
+
   let exports, reexports;
   try {
-    // TODO: use a TextDecoder, or add support for BufferView in `cjsParse`
-    const sourceString = typeof source === 'string' ? source : `${source}`;
-    ({ exports, reexports } = cjsParse(sourceString || ''));
+    ({ exports, reexports } = cjsParse(source || ''));
   } catch {
     exports = [];
     reexports = [];
@@ -282,11 +280,12 @@ function cjsPreparseModuleExports(filename, source) {
 
 // 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);
   }
@@ -296,7 +295,7 @@ translators.set('builtin', async function builtinStrategy(url) {
 
 // Strategy for loading a JSON file
 const isWindows = process.platform === 'win32';
-translators.set('json', async function jsonStrategy(url, source) {
+translators.set('json', function jsonStrategy(url, source) {
   emitExperimentalWarning('Importing JSON modules');
   assertBufferSource(source, true, 'load');
   debug(`Loading JSONModule ${url}`);
@@ -346,6 +345,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);

From ad7a8ed0bc7c05596bdc58dfc4ad6d61f122a3ed Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 25 May 2023 19:05:59 +0200
Subject: [PATCH 09/32] add support for requiring absolute URLs, JSON files,
 and `.node`

---
 lib/internal/modules/esm/translators.js | 30 +++++++++++++++++--------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 9d31b6ae69e8e1..18da09137d5693 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -27,7 +27,7 @@ function lazyTypes() {
 
 const assert = require('internal/assert');
 const { readFileSync } = require('fs');
-const { dirname, extname, isAbsolute, join } = require('path');
+const { dirname, extname, isAbsolute } = require('path');
 const {
   hasEsmSyntax,
   loadBuiltinModule,
@@ -163,20 +163,32 @@ function createCJSModuleWrap(url, source) {
     const __dirname = dirname(filename);
     // eslint-disable-next-line func-name-matching,func-style
     const requireFn = function require(spec) {
-      // TODO: add support for absolute paths
-      if (spec[0] === '.') {
-        spec = pathToFileURL(CJSModule._findPath(join(__dirname, spec)));
+      let importAttributes = kEmptyObject;
+      if (!StringPrototypeStartsWith(spec, 'node:')) {
+        const path = CJSModule._resolveFilename(spec, module);
+        if (spec !== path) {
+          switch (extname(path)) {
+            case '.json':
+              importAttributes = { __proto__: null, type: 'json' };
+              break;
+            case '.node':
+              return CJSModule._load(spec, module);
+            default:
+          }
+          spec = pathToFileURL(path);
+        }
       }
-      const job = asyncESM.esmLoader.getModuleJob(spec, url, kEmptyObject, true);
+      const job = asyncESM.esmLoader.getModuleJob(spec, url, importAttributes, true);
       job.runSync();
       return cjsCache.get(job.url).exports;
     };
     setOwnProperty(requireFn, 'resolve', function resolve(spec) {
-      // TODO: add support for absolute paths
-      if (spec[0] === '.') {
-        spec = pathToFileURL(CJSModule._findPath(join(__dirname, spec)));
+      if (!StringPrototypeStartsWith(spec, 'node:')) {
+        const path = CJSModule._resolveFilename(spec, module);
+        if (spec !== path) {
+          spec = pathToFileURL(path);
+        }
       }
-      // TODO: make this work for CJSism (e.g. dir import, extensionless imports, etc.)
       const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
       return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
     });

From d0e4abfdd640c78736589e720f9c4d185d4d1a74 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 25 May 2023 19:13:51 +0200
Subject: [PATCH 10/32] fix `CustomizedModuleLoader`

---
 lib/internal/modules/esm/loader.js | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index b41dc77f58af82..ca7f7ac3073b94 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -510,8 +510,13 @@ class CustomizedModuleLoader {
     hooksProxy.waitForWorker();
   }
   loadSync(url, context) {
-    const result = hooksProxy.makeSyncRequest('load', url, context);
-    this.validateLoadResult(url, result?.format);
+    let result = hooksProxy.makeSyncRequest('load', url, context);
+    let format = result?.format;
+    if (format === 'commonjs') {
+      format = 'require-commonjs';
+      result = { __proto__: result, format };
+    }
+    this.validateLoadResult(url, format);
 
     return result;
   }

From 39219be375eb1fc42d4c8bd8f3c7be6706e7f9c9 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 26 May 2023 01:21:38 +0200
Subject: [PATCH 11/32] stringify at the right places, `process.mainModule`

---
 lib/internal/modules/esm/translators.js | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 18da09137d5693..2682296e83fb08 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -144,15 +144,20 @@ function enrichCJSError(err, content, filename) {
 
 // TODO: can we use a weak map instead?
 const cjsCache = new SafeMap();
-function createCJSModuleWrap(url, source) {
+function createCJSModuleWrap(url, source, isMain) {
   debug(`Translating CJSModule ${url}`);
 
   const filename = StringPrototypeStartsWith(url, 'file://') ? fileURLToPath(url) : url;
+  source = stringify(source);
 
   const { exportNames, module } = cjsPreparseModuleExports(filename, source);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
+  if (isMain) {
+    setOwnProperty(process, 'mainModule', module);
+  }
+
   return new ModuleWrap(url, undefined, namesWithDefault, function() {
     if (cjsCache.has(url)) return cjsCache.get(url).exports;
 
@@ -175,7 +180,7 @@ function createCJSModuleWrap(url, source) {
               return CJSModule._load(spec, module);
             default:
           }
-          spec = pathToFileURL(path);
+          spec = `${pathToFileURL(path)}`;
         }
       }
       const job = asyncESM.esmLoader.getModuleJob(spec, url, importAttributes, true);
@@ -186,7 +191,7 @@ function createCJSModuleWrap(url, source) {
       if (!StringPrototypeStartsWith(spec, 'node:')) {
         const path = CJSModule._resolveFilename(spec, module);
         if (spec !== path) {
-          spec = pathToFileURL(path);
+          spec = `${pathToFileURL(path)}`;
         }
       }
       const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
@@ -228,7 +233,7 @@ translators.set('require-commonjs', (url, source, isMain) => {
 translators.set('commonjs', async function commonjsStrategy(url, source,
                                                             isMain) {
   if (!cjsParse) await initCJSParse();
-  return createCJSModuleWrap(url, source);
+  return createCJSModuleWrap(url, source, isMain);
 });
 
 function cjsPreparseModuleExports(filename, source) {
@@ -248,8 +253,6 @@ function cjsPreparseModuleExports(filename, source) {
     CJSModule._cache[filename] = module;
   }
 
-  source = stringify(source);
-
   let exports, reexports;
   try {
     ({ exports, reexports } = cjsParse(source || ''));

From 739dc9e868d6775cf71b33e2b9e51547006c2aa7 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 31 May 2023 16:44:06 +0200
Subject: [PATCH 12/32] add dynamic import in CJS + enriched errors

---
 lib/internal/modules/esm/translators.js | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 2682296e83fb08..32fb9dac4bc4ce 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -51,6 +51,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() {
@@ -163,7 +164,24 @@ function createCJSModuleWrap(url, source, isMain) {
 
     debug(`Loading CJSModule ${url}`);
 
-    const compiledWrapper = Function('exports', 'require', 'module', '__filename', '__dirname', source);
+    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

From 297a63bcdbfee40384ee998ecd68f86be1292e20 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 29 Jul 2023 12:04:06 +0200
Subject: [PATCH 13/32] fix rebase conflict

---
 lib/internal/modules/esm/load.js        | 2 +-
 lib/internal/modules/esm/translators.js | 5 ++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 39b2cfc2aebb88..80a4bbf8eb23c4 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -148,7 +148,7 @@ function defaultLoadSync(url, context = kEmptyObject) {
   } = context;
 
   if (format == null) {
-    format = defaultGetFormat(url, context);
+    format = defaultGetFormat(new URL(url), context);
   }
 
   validateAssertions(url, format, importAssertions);
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 32fb9dac4bc4ce..5794bd07e5ea0a 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -3,7 +3,6 @@
 const {
   ArrayPrototypeMap,
   Boolean,
-  Function,
   JSONParse,
   ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
@@ -201,7 +200,7 @@ function createCJSModuleWrap(url, source, isMain) {
           spec = `${pathToFileURL(path)}`;
         }
       }
-      const job = asyncESM.esmLoader.getModuleJob(spec, url, importAttributes, true);
+      const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
       job.runSync();
       return cjsCache.get(job.url).exports;
     };
@@ -212,7 +211,7 @@ function createCJSModuleWrap(url, source, isMain) {
           spec = `${pathToFileURL(path)}`;
         }
       }
-      const { url: resolvedURL } = asyncESM.esmLoader.resolve(spec, url);
+      const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(spec, url, kEmptyObject);
       return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
     });
     setOwnProperty(requireFn, 'cache', CJSModule._cache);

From 32bf8784a724999fb55368531a08427a40bff859 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 29 Jul 2023 15:05:37 +0200
Subject: [PATCH 14/32] fix cache duplication issues

---
 lib/internal/modules/esm/translators.js | 111 ++++++++++++------------
 1 file changed, 56 insertions(+), 55 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 5794bd07e5ea0a..1a1aa0e85bbb79 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -151,6 +151,7 @@ function createCJSModuleWrap(url, source, isMain) {
   source = stringify(source);
 
   const { exportNames, module } = cjsPreparseModuleExports(filename, source);
+  cjsCache.set(url, module);
   const namesWithDefault = exportNames.has('default') ?
     [...exportNames] : ['default', ...exportNames];
 
@@ -159,67 +160,67 @@ function createCJSModuleWrap(url, source, isMain) {
   }
 
   return new ModuleWrap(url, undefined, namesWithDefault, function() {
-    if (cjsCache.has(url)) return cjsCache.get(url).exports;
-
     debug(`Loading CJSModule ${url}`);
 
-    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;
-    }
+    if (!module.loaded) {
+      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(spec) {
-      let importAttributes = kEmptyObject;
-      if (!StringPrototypeStartsWith(spec, 'node:')) {
-        const path = CJSModule._resolveFilename(spec, module);
-        if (spec !== path) {
-          switch (extname(path)) {
-            case '.json':
-              importAttributes = { __proto__: null, type: 'json' };
-              break;
-            case '.node':
-              return CJSModule._load(spec, module);
-            default:
+      const __dirname = dirname(filename);
+      // eslint-disable-next-line func-name-matching,func-style
+      const requireFn = function require(spec) {
+        let importAttributes = kEmptyObject;
+        if (!StringPrototypeStartsWith(spec, 'node:')) {
+          const path = CJSModule._resolveFilename(spec, module);
+          if (spec !== path) {
+            switch (extname(path)) {
+              case '.json':
+                importAttributes = { __proto__: null, type: 'json' };
+                break;
+              case '.node':
+                return CJSModule._load(spec, module);
+              default:
+            }
+            spec = `${pathToFileURL(path)}`;
           }
-          spec = `${pathToFileURL(path)}`;
         }
-      }
-      const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
-      job.runSync();
-      return cjsCache.get(job.url).exports;
-    };
-    setOwnProperty(requireFn, 'resolve', function resolve(spec) {
-      if (!StringPrototypeStartsWith(spec, 'node:')) {
-        const path = CJSModule._resolveFilename(spec, module);
-        if (spec !== path) {
-          spec = `${pathToFileURL(path)}`;
+        const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
+        job.runSync();
+        return cjsCache.get(job.url).exports;
+      };
+      setOwnProperty(requireFn, 'resolve', function resolve(spec) {
+        if (!StringPrototypeStartsWith(spec, 'node:')) {
+          const path = CJSModule._resolveFilename(spec, module);
+          if (spec !== path) {
+            spec = `${pathToFileURL(path)}`;
+          }
         }
-      }
-      const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(spec, url, kEmptyObject);
-      return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
-    });
-    setOwnProperty(requireFn, 'cache', CJSModule._cache);
-    setOwnProperty(requireFn, 'main', process.mainModule);
-
-    cjsCache.set(url, module);
-    ReflectApply(compiledWrapper, module.exports,
-                 [module.exports, requireFn, module, filename, __dirname]);
+        const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(spec, url, kEmptyObject);
+        return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
+      });
+      setOwnProperty(requireFn, 'cache', CJSModule._cache);
+      setOwnProperty(requireFn, 'main', process.mainModule);
+
+      ReflectApply(compiledWrapper, module.exports,
+                   [module.exports, requireFn, module, filename, __dirname]);
+      setOwnProperty(module, 'loaded', true);
+    }
 
     const { exports } = module;
     for (const exportName of exportNames) {

From 74c93d1d664f8969fe0ad3bcc2d384f083b1a8cf Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 01:18:03 +0200
Subject: [PATCH 15/32] make the change opt-in

---
 lib/internal/modules/esm/load.js        |   5 +-
 lib/internal/modules/esm/translators.js | 156 +++++++++++++++---------
 2 files changed, 100 insertions(+), 61 deletions(-)

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 80a4bbf8eb23c4..f06cdeec7d9f15 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -119,7 +119,10 @@ async function defaultLoad(url, context = kEmptyObject) {
 
   validateAssertions(url, format, importAssertions);
 
-  if (format === 'builtin') {
+  if (
+    format === 'builtin' ||
+    format === 'commonjs'
+  ) {
     source = null;
   } else if (source == null) {
     ({ responseURL, source } = await getSource(urlInstance, context));
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 1a1aa0e85bbb79..ac888b0ba15495 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -142,9 +142,75 @@ function enrichCJSError(err, content, filename) {
   }
 }
 
+/**
+ * Loads a CJS module without using the monkey-patchable CJS loader. Modules
+ * loaded with this method have a special `require` function that calls the ESM
+ * loader.
+ */
+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(spec) {
+    let importAttributes = kEmptyObject;
+    if (!StringPrototypeStartsWith(spec, 'node:')) {
+      // TODO: do not depend on the monkey-patchable CJS loader here.
+      const path = CJSModule._resolveFilename(spec, module);
+      if (spec !== path) {
+        switch (extname(path)) {
+          case '.json':
+            importAttributes = { __proto__: null, type: 'json' };
+            break;
+          case '.node':
+            return CJSModule._load(spec, module);
+          default:
+        }
+        spec = `${pathToFileURL(path)}`;
+      }
+    }
+    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
+    job.runSync();
+    return cjsCache.get(job.url).exports;
+  };
+  setOwnProperty(requireFn, 'resolve', function resolve(spec) {
+    if (!StringPrototypeStartsWith(spec, 'node:')) {
+      const path = CJSModule._resolveFilename(spec, module);
+      if (spec !== path) {
+        spec = `${pathToFileURL(path)}`;
+      }
+    }
+    const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(spec, url, kEmptyObject);
+    return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
+  });
+  setOwnProperty(requireFn, 'cache', CJSModule._cache);
+  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) {
+function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
   debug(`Translating CJSModule ${url}`);
 
   const filename = StringPrototypeStartsWith(url, 'file://') ? fileURLToPath(url) : url;
@@ -163,66 +229,16 @@ function createCJSModuleWrap(url, source, isMain) {
     debug(`Loading CJSModule ${url}`);
 
     if (!module.loaded) {
-      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(spec) {
-        let importAttributes = kEmptyObject;
-        if (!StringPrototypeStartsWith(spec, 'node:')) {
-          const path = CJSModule._resolveFilename(spec, module);
-          if (spec !== path) {
-            switch (extname(path)) {
-              case '.json':
-                importAttributes = { __proto__: null, type: 'json' };
-                break;
-              case '.node':
-                return CJSModule._load(spec, module);
-              default:
-            }
-            spec = `${pathToFileURL(path)}`;
-          }
-        }
-        const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
-        job.runSync();
-        return cjsCache.get(job.url).exports;
-      };
-      setOwnProperty(requireFn, 'resolve', function resolve(spec) {
-        if (!StringPrototypeStartsWith(spec, 'node:')) {
-          const path = CJSModule._resolveFilename(spec, module);
-          if (spec !== path) {
-            spec = `${pathToFileURL(path)}`;
-          }
-        }
-        const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(spec, url, kEmptyObject);
-        return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
-      });
-      setOwnProperty(requireFn, 'cache', CJSModule._cache);
-      setOwnProperty(requireFn, 'main', process.mainModule);
-
-      ReflectApply(compiledWrapper, module.exports,
-                   [module.exports, requireFn, module, filename, __dirname]);
-      setOwnProperty(module, 'loaded', true);
+      loadCJS(module, source, url, filename);
     }
 
-    const { exports } = module;
+    let exports;
+    if (asyncESM.esmLoader.cjsCache.has(module)) {
+      exports = asyncESM.esmLoader.cjsCache.get(module);
+      asyncESM.esmLoader.cjsCache.delete(module);
+    } else {
+      ({ exports } = module);
+    }
     for (const exportName of exportNames) {
       if (!ObjectPrototypeHasOwnProperty(exports, exportName) ||
           exportName === 'default')
@@ -251,7 +267,27 @@ translators.set('require-commonjs', (url, source, isMain) => {
 translators.set('commonjs', async function commonjsStrategy(url, source,
                                                             isMain) {
   if (!cjsParse) await initCJSParse();
-  return createCJSModuleWrap(url, source, isMain);
+
+  // For backward-compatibility, it's possible to return a nullish value for
+  // commonjs 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) {

From 0a6310156d1ef1d2c077c92c2db67b892f539d88 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 01:53:05 +0200
Subject: [PATCH 16/32] fix failing tests

---
 lib/internal/modules/esm/loader.js            | 21 +++++++---------
 .../builtin-named-exports-loader.mjs          |  9 ++++---
 .../not-found-assert-loader.mjs               | 24 +++++++------------
 3 files changed, 22 insertions(+), 32 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index ca7f7ac3073b94..3a52aa65349f5e 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');
@@ -414,11 +415,15 @@ class ModuleLoader {
   loadSync(url, context) {
     defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
 
-    let result = defaultLoadSync(url, context);
+    let result = this.#customizations ?
+      this.#customizations.loadSync(url, context) :
+      defaultLoadSync(url, context);
     let format = result?.format;
     if (format === 'commonjs') {
       format = 'require-commonjs';
       result = { __proto__: result, format };
+    } else if (format === 'module') {
+      throw new ERR_REQUIRE_ESM(url, true);
     }
     this.validateLoadResult(url, format);
     return result;
@@ -501,6 +506,9 @@ class CustomizedModuleLoader {
   load(url, context) {
     return hooksProxy.makeAsyncRequest('load', undefined, url, context);
   }
+  loadSync(url, context) {
+    return hooksProxy.makeSyncRequest('load', url, context);
+  }
 
   importMetaInitialize(meta, context, loader) {
     hooksProxy.importMetaInitialize(meta, context, loader);
@@ -509,17 +517,6 @@ class CustomizedModuleLoader {
   forceLoadHooks() {
     hooksProxy.waitForWorker();
   }
-  loadSync(url, context) {
-    let result = hooksProxy.makeSyncRequest('load', url, context);
-    let format = result?.format;
-    if (format === 'commonjs') {
-      format = 'require-commonjs';
-      result = { __proto__: result, format };
-    }
-    this.validateLoadResult(url, format);
-
-    return result;
-  }
 }
 
 let emittedExperimentalWarning = false;
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..43975b155e569f 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
@@ -32,7 +32,7 @@ export function load(url, context, next) {
     return {
       shortCircuit: true,
       source: generateBuiltinModule(urlObj.pathname),
-      format: 'module',
+      format: 'commonjs',
     };
   }
   return next(url);
@@ -46,13 +46,12 @@ 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;
 
 ${
   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..45e71f8a314bbf 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,
+  };
+}
\ No newline at end of file

From a6f01a30cf12e0b0d1205ea25b248db016ff2029 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 02:13:21 +0200
Subject: [PATCH 17/32] update docs

---
 doc/api/esm.md | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 6d510d0d0b00b5..c6b6030e5cd4dc 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,20 @@ 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. Unless a
+non-nullish `source` is supplied for type `'commonjs'`, it will be fetched using
+the CommonJS module loader. When non-nullish `source` is supplied for type
+`'commonjs'`, `require` calls from inside the loaded module will call the
+`resolve` and `load` hooks.
 
 > **Caveat**: The ESM `load` hook and namespaced exports from CommonJS modules
 > are incompatible. Attempting to use them together will result in an empty

From 3b39ba3aef4a43735465f44030a8c25d9acbed98 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 02:16:26 +0200
Subject: [PATCH 18/32] style

---
 lib/internal/modules/esm/translators.js                     | 1 -
 test/fixtures/es-module-loaders/not-found-assert-loader.mjs | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index ac888b0ba15495..871042c9782253 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -263,7 +263,6 @@ translators.set('require-commonjs', (url, source, isMain) => {
   return createCJSModuleWrap(url, source);
 });
 
-// Strategy for loading a node-style CommonJS module
 translators.set('commonjs', async function commonjsStrategy(url, source,
                                                             isMain) {
   if (!cjsParse) await initCJSParse();
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 45e71f8a314bbf..2486899ea3753f 100644
--- a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
+++ b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
@@ -13,4 +13,4 @@ export async function resolve(specifier, { importAssertions }, next) {
     url: 'node:fs',
     importAssertions,
   };
-}
\ No newline at end of file
+}

From dd2af79a353deeb2bb289ce4722d93aa288f95fb Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 02:19:33 +0200
Subject: [PATCH 19/32] already addressed TODO

---
 lib/internal/modules/esm/module_job.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 9e15ef666e269d..8ac5ff240bdb37 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -201,7 +201,6 @@ class ModuleJob {
       return { __proto__: null, module: this.module };
     }
 
-    // TODO: better handle errors
     this.module.instantiate();
     this.instantiated = PromiseResolve();
     const timeout = -1;

From f6927154b0a0f2ef0c9c256ddcfc7b778151f815 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 11:11:46 +0200
Subject: [PATCH 20/32] Apply suggestions from code review

Co-authored-by: Geoffrey Booth <webadmin@geoffreybooth.com>
---
 lib/internal/modules/esm/load.js        | 18 ++++++++++++------
 lib/internal/modules/esm/translators.js | 13 +++++++------
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index f06cdeec7d9f15..9c206d92943b43 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -69,12 +69,13 @@ async function getSource(url, context) {
   return { __proto__: null, responseURL, source };
 }
 
+let readFileSync;
 function getSourceSync(url, context) {
   const parsed = new URL(url);
   const responseURL = url;
   let source;
   if (parsed.protocol === 'file:') {
-    const { readFileSync } = require('fs');
+    readFileSync ??= require('fs').readFileSync;
     source = readFileSync(parsed);
   } else if (parsed.protocol === 'data:') {
     const match = RegExpPrototypeExec(DATA_URL_PATTERN, parsed.pathname);
@@ -85,9 +86,6 @@ function getSourceSync(url, context) {
     source = BufferFrom(decodeURIComponent(body), base64 ? 'base64' : 'utf8');
   } else {
     const supportedSchemes = ['file', 'data'];
-    if (experimentalNetworkImports) {
-      ArrayPrototypePush(supportedSchemes, 'http', 'https');
-    }
     throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed, supportedSchemes);
   }
   if (policy?.manifest) {
@@ -139,8 +137,16 @@ async function defaultLoad(url, context = kEmptyObject) {
 /**
  * Node.js default load hook.
  * @param {string} url
- * @param {object} context
- * @returns {object}
+ * @param {LoadContext} context
+ * @typedef LoadContext
+ * @property {string} [format] Hint possibly returned by `resolve`
+ * @property {string | Buffer | ArrayBuffer} [source]
+ * @property {Record<string, string>} [importAssertions]
+ * @returns {LoadReturn}
+ * @typedef LoadReturn
+ * @property {string} format
+ * @property {string} responseURL
+ * @property {Buffer} source
  */
 function defaultLoadSync(url, context = kEmptyObject) {
   let responseURL = url;
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 871042c9782253..9e10e4099f047f 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -169,15 +169,15 @@ function loadCJSModule(module, source, url, filename) {
 
   const __dirname = dirname(filename);
   // eslint-disable-next-line func-name-matching,func-style
-  const requireFn = function require(spec) {
-    let importAttributes = kEmptyObject;
+  const requireFn = function require(specifier) {
+    let importAssertions = kEmptyObject;
     if (!StringPrototypeStartsWith(spec, 'node:')) {
       // TODO: do not depend on the monkey-patchable CJS loader here.
       const path = CJSModule._resolveFilename(spec, module);
       if (spec !== path) {
         switch (extname(path)) {
           case '.json':
-            importAttributes = { __proto__: null, type: 'json' };
+            importAssertions = { __proto__: null, type: 'json' };
             break;
           case '.node':
             return CJSModule._load(spec, module);
@@ -186,7 +186,7 @@ function loadCJSModule(module, source, url, filename) {
         spec = `${pathToFileURL(path)}`;
       }
     }
-    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAttributes);
+    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAssertions);
     job.runSync();
     return cjsCache.get(job.url).exports;
   };
@@ -265,7 +265,9 @@ translators.set('require-commonjs', (url, source, isMain) => {
 
 translators.set('commonjs', async function commonjsStrategy(url, source,
                                                             isMain) {
-  if (!cjsParse) await initCJSParse();
+  if (!cjsParse) {
+    await initCJSParse();
+  }
 
   // For backward-compatibility, it's possible to return a nullish value for
   // commonjs source associated with a file: URL. In this case, the source is
@@ -298,7 +300,6 @@ function cjsPreparseModuleExports(filename, source) {
       return { module, exportNames: cached.exportNames };
   }
   const loaded = Boolean(module);
-  debug(`IsLoaded CJSModule ${filename}? ${loaded}`);
   if (!loaded) {
     module = new CJSModule(filename);
     module.filename = filename;

From 850831b79b03fcf6eb0246223fb189ee5ea59da2 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 11:32:14 +0200
Subject: [PATCH 21/32] fixes

---
 lib/internal/modules/esm/load.js              | 27 +++++++-------
 lib/internal/modules/esm/loader.js            | 35 +++++--------------
 lib/internal/modules/esm/translators.js       | 26 +++++++-------
 test/es-module/test-esm-named-exports.js      | 11 ++++++
 .../builtin-named-exports-loader.mjs          |  1 +
 5 files changed, 49 insertions(+), 51 deletions(-)
 create mode 100644 test/es-module/test-esm-named-exports.js

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 9c206d92943b43..e1bc73ce6f8e59 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,13 +70,11 @@ async function getSource(url, context) {
   return { __proto__: null, responseURL, source };
 }
 
-let readFileSync;
 function getSourceSync(url, context) {
   const parsed = new URL(url);
   const responseURL = url;
   let source;
   if (parsed.protocol === 'file:') {
-    readFileSync ??= require('fs').readFileSync;
     source = readFileSync(parsed);
   } else if (parsed.protocol === 'data:') {
     const match = RegExpPrototypeExec(DATA_URL_PATTERN, parsed.pathname);
@@ -133,20 +132,24 @@ async function defaultLoad(url, context = kEmptyObject) {
     source,
   };
 }
-
 /**
- * Node.js default load hook.
- * @param {string} url
- * @param {LoadContext} context
  * @typedef LoadContext
  * @property {string} [format] Hint possibly returned by `resolve`
- * @property {string | Buffer | ArrayBuffer} [source]
- * @property {Record<string, string>} [importAssertions]
- * @returns {LoadReturn}
+ * @property {string | Buffer | ArrayBuffer} [source] source
+ * @property {Record<string, string>} [importAssertions] import attributes
+ */
+
+/**
  * @typedef LoadReturn
- * @property {string} format
- * @property {string} responseURL
- * @property {Buffer} source
+ * @property {string} format format
+ * @property {string} responseURL url
+ * @property {Buffer} source source
+ */
+
+/**
+ * @param {string} url
+ * @param {LoadContext} [context]
+ * @returns {LoadReturn}
  */
 function defaultLoadSync(url, context = kEmptyObject) {
   let responseURL = url;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 3a52aa65349f5e..7887052fb9b768 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -255,16 +255,7 @@ class ModuleLoader {
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
   #createModuleJob(url, importAssertions, parentURL, format, sync) {
-    const moduleProvider = sync ? (url, isMain) => {
-      const {
-        format: finalFormat,
-        responseURL,
-        source,
-      } = this.loadSync(url, {
-        format,
-        importAssertions,
-      });
-
+    const callTranslator = ({ format: finalFormat, responseURL, source }, isMain) => {
       const translator = getTranslators().get(finalFormat);
 
       if (!translator) {
@@ -272,24 +263,16 @@ class ModuleLoader {
       }
 
       return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
-    } : async (url, isMain) => {
-      const {
-        format: finalFormat,
-        responseURL,
-        source,
-      } = await this.load(url, {
+    };
+    const moduleProvider = sync ?
+      (url, isMain) => callTranslator(this.loadSync(url, {
         format,
         importAssertions,
-      });
-
-      const translator = getTranslators().get(finalFormat);
-
-      if (!translator) {
-        throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
-      }
-
-      return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
-    };
+      }), isMain) :
+      async (url, isMain) => callTranslator(await this.load(url, {
+        format,
+        importAssertions,
+      }), isMain);
 
     const inspectBrk = (
       parentURL === undefined &&
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 9e10e4099f047f..13e17e1492d54c 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -171,33 +171,33 @@ function loadCJSModule(module, source, url, filename) {
   // eslint-disable-next-line func-name-matching,func-style
   const requireFn = function require(specifier) {
     let importAssertions = kEmptyObject;
-    if (!StringPrototypeStartsWith(spec, 'node:')) {
+    if (!StringPrototypeStartsWith(specifier, 'node:')) {
       // TODO: do not depend on the monkey-patchable CJS loader here.
-      const path = CJSModule._resolveFilename(spec, module);
-      if (spec !== path) {
+      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(spec, module);
+            return CJSModule._load(specifier, module);
           default:
         }
-        spec = `${pathToFileURL(path)}`;
+        specifier = `${pathToFileURL(path)}`;
       }
     }
-    const job = asyncESM.esmLoader.getModuleJobSync(spec, url, importAssertions);
+    const job = asyncESM.esmLoader.getModuleJobSync(specifier, url, importAssertions);
     job.runSync();
     return cjsCache.get(job.url).exports;
   };
-  setOwnProperty(requireFn, 'resolve', function resolve(spec) {
-    if (!StringPrototypeStartsWith(spec, 'node:')) {
-      const path = CJSModule._resolveFilename(spec, module);
-      if (spec !== path) {
-        spec = `${pathToFileURL(path)}`;
+  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(spec, url, kEmptyObject);
+    const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(specifier, url, kEmptyObject);
     return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
   });
   setOwnProperty(requireFn, 'cache', CJSModule._cache);
@@ -270,7 +270,7 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
   }
 
   // For backward-compatibility, it's possible to return a nullish value for
-  // commonjs source associated with a file: URL. In this case, the source is
+  // 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 {
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 43975b155e569f..31ba0eb1495358 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
@@ -49,6 +49,7 @@ const $builtinInstance = ${GET_BUILTIN}(${JSON.stringify(builtinName)});
 module.exports = $builtinInstance;
 module.exports.__fromLoader = true;
 
+// We need this for CJS-module-lexer can parse the exported names. 
 ${
   builtinExports
     .map(name => `exports.${name} = $builtinInstance.${name};`)

From c7edb23aed2007ed3b6efac032063c50f73385fc Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 13:31:32 +0200
Subject: [PATCH 22/32] add tests

---
 lib/internal/modules/esm/translators.js       |  1 -
 test/es-module/test-esm-loader-hooks.mjs      | 33 +++++++++++++++++++
 .../builtin-named-exports-loader.mjs          |  7 ++++
 test/fixtures/require-resolve.js              | 30 +++++++++--------
 4 files changed, 57 insertions(+), 14 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 13e17e1492d54c..f6bd41e537c6c9 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -200,7 +200,6 @@ function loadCJSModule(module, source, url, filename) {
     const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(specifier, url, kEmptyObject);
     return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
   });
-  setOwnProperty(requireFn, 'cache', CJSModule._cache);
   setOwnProperty(requireFn, 'main', process.mainModule);
 
   ReflectApply(compiledWrapper, module.exports,
diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index ecb429d4593a3a..44c8936e9a4021 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -714,6 +714,39 @@ describe('Loader hooks', { concurrency: true }, () => {
 
     assert.strictEqual(stderr, '');
 
+  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 { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      `data:text/javascript,import{readFile}from"node:fs/promises";export ${async function load(u, c, n) {
+        const r = await n(u, c);
+        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(25));
     assert.strictEqual(code, 0);
     assert.strictEqual(signal, null);
   });
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 31ba0eb1495358..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()}`;
 
@@ -34,6 +35,12 @@ export function load(url, context, next) {
       source: generateBuiltinModule(urlObj.pathname),
       format: 'commonjs',
     };
+  } else if (context.format === 'commonjs') {
+    return {
+      shortCircuit: true,
+      source: readFileSync(new URL(url)),
+      format: 'commonjs',
+    };
   }
   return next(url);
 }
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(

From 2a5521e410e8f0c22258d474ae7902ce472046f1 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 23:19:00 +0200
Subject: [PATCH 23/32] Apply suggestions from code review

Co-authored-by: Geoffrey Booth <webadmin@geoffreybooth.com>
---
 doc/api/esm.md                          | 18 +++++++++++++-----
 lib/internal/modules/esm/loader.js      | 11 +++--------
 lib/internal/modules/esm/translators.js | 10 +++++++---
 3 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index c6b6030e5cd4dc..ee11002c0992e8 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -957,11 +957,19 @@ The final value of `format` must be one of the following:
 | `'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. Unless a
-non-nullish `source` is supplied for type `'commonjs'`, it will be fetched using
-the CommonJS module loader. When non-nullish `source` is supplied for type
-`'commonjs'`, `require` calls from inside the loaded module will call the
-`resolve` and `load` hooks.
+not possible to replace the value of a Node.js builtin (core) module.
+
+For type `'commonjs'`, if `source` is defined, `require` calls from inside the
+loaded module will go through the registered `resolve` and `load` hooks.
+If `source` is undefined or `null`, it will be handled by the CommonJS
+module loader and not processed by any registered hooks. This behavior
+for nullish `source` is temporary; in the future, a `source` value that is
+undefined or `null` will not be supported.
+
+The Node.js internal `defaultLoad`, which is the value of `next` for the last
+loader in the `load` chain, does not return a value for `source`. If one is desired,
+loader authors should load it via a call like `readFile(new URL(url))`. This may
+also change once support for nullish `source` is discontinued.
 
 > **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/loader.js b/lib/internal/modules/esm/loader.js
index 7887052fb9b768..e0c6f7cefe1eb0 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -264,15 +264,10 @@ class ModuleLoader {
 
       return FunctionPrototypeCall(translator, this, responseURL, source, isMain);
     };
+    const context = { format, importAssertions };
     const moduleProvider = sync ?
-      (url, isMain) => callTranslator(this.loadSync(url, {
-        format,
-        importAssertions,
-      }), isMain) :
-      async (url, isMain) => callTranslator(await this.load(url, {
-        format,
-        importAssertions,
-      }), isMain);
+      (url, isMain) => callTranslator(this.loadSync(url, context), isMain) :
+      async (url, isMain) => callTranslator(await this.load(url, context), isMain);
 
     const inspectBrk = (
       parentURL === undefined &&
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index f6bd41e537c6c9..6865f80c37712c 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -143,9 +143,10 @@ function enrichCJSError(err, content, filename) {
 }
 
 /**
- * Loads a CJS module without using the monkey-patchable CJS loader. Modules
- * loaded with this method have a special `require` function that calls the ESM
- * loader.
+ * 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;
@@ -327,6 +328,9 @@ function cjsPreparseModuleExports(filename, source) {
       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, `resolve` hooks will not be run for `require` input.
         resolved = CJSModule._resolveFilename(reexport, module);
       } catch {
         continue;

From 507cd21db594ad520b59ceb0a3da1ec207c4fda5 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 31 Jul 2023 23:46:10 +0200
Subject: [PATCH 24/32] fixes

---
 doc/api/esm.md                          | 19 +++++++++++++++----
 lib/internal/modules/esm/load.js        |  4 ++--
 lib/internal/modules/esm/translators.js | 17 ++++++++++++-----
 3 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index ee11002c0992e8..18db861590001d 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -966,10 +966,21 @@ module loader and not processed by any registered hooks. This behavior
 for nullish `source` is temporary; in the future, a `source` value that is
 undefined or `null` will not be supported.
 
-The Node.js internal `defaultLoad`, which is the value of `next` for the last
-loader in the `load` chain, does not return a value for `source`. If one is desired,
-loader authors should load it via a call like `readFile(new URL(url))`. This may
-also change once support for nullish `source` is discontinued.
+The Node.js own `load` implementation, which is the value of `next` for the last
+loader in the `load` chain, returns `null` for `source` for backward
+compatibility. Here is a example loader that would opt-in to using the behavior:
+
+```js
+import { readFile } from 'node:fs/promises';
+
+export async function load(url, context, nextLoad) {
+  const response = await nextLoad(url, context);
+  if (response.format === 'commonjs') {
+    response.source ??= await readFile(new URL(response.responseURL ?? url));
+  }
+  return response;
+}
+```
 
 > **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 e1bc73ce6f8e59..b25a3865e7a5a8 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -97,8 +97,8 @@ function getSourceSync(url, context) {
 /**
  * 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;
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 6865f80c37712c..5bc25665809605 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -328,9 +328,13 @@ function cjsPreparseModuleExports(filename, source) {
       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, `resolve` hooks will not be run for `require` input.
+        // 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;
@@ -339,8 +343,11 @@ function cjsPreparseModuleExports(filename, source) {
       // `format: 'commonjs'` instead of relying on file extensions.
       const ext = extname(resolved);
       if ((ext === '.js' || ext === '.cjs' || !CJSModule._extensions[ext]) &&
-          isAbsolute(resolved)) {
-        const { exportNames: reexportNames } = cjsPreparseModuleExports(resolved, readFileSync(resolved, 'utf-8'));
+      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);
       }

From ec6d1782a7c68db8b832b5a57bb4b13c1243c803 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 1 Aug 2023 00:41:39 +0200
Subject: [PATCH 25/32] fix typo

---
 doc/api/esm.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 18db861590001d..22c61e678735b7 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -968,7 +968,8 @@ undefined or `null` 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` for backward
-compatibility. Here is a example loader that would opt-in to using the behavior:
+compatibility. Here is an example loader that would opt-in to using the
+non-default behavior:
 
 ```js
 import { readFile } from 'node:fs/promises';

From 279e19d6335478c922e4cd1793553f1eb3f1cb0c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 2 Aug 2023 22:28:59 +0200
Subject: [PATCH 26/32] nits

---
 lib/internal/modules/esm/load.js        | 4 +---
 lib/internal/modules/esm/translators.js | 4 ++++
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index b25a3865e7a5a8..00bf3becfb4426 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -159,9 +159,7 @@ function defaultLoadSync(url, context = kEmptyObject) {
     source,
   } = context;
 
-  if (format == null) {
-    format = defaultGetFormat(new URL(url), context);
-  }
+  format ??= defaultGetFormat(new URL(url), context);
 
   validateAssertions(url, format, importAssertions);
 
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 5bc25665809605..35e840b6ac51c5 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -257,12 +257,16 @@ function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
 
 }
 
+// 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);
 });
 
+// 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) {

From 454985bfde03b165b3d5c035274672386ad11b40 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 3 Aug 2023 09:24:04 +0200
Subject: [PATCH 27/32] fix rebase conflicts

---
 lib/internal/modules/esm/loader.js       | 2 +-
 test/es-module/test-esm-loader-hooks.mjs | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index e0c6f7cefe1eb0..f3d67e9520fdc4 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -485,7 +485,7 @@ class CustomizedModuleLoader {
     return hooksProxy.makeAsyncRequest('load', undefined, url, context);
   }
   loadSync(url, context) {
-    return hooksProxy.makeSyncRequest('load', url, context);
+    return hooksProxy.makeSyncRequest('load', undefined, url, context);
   }
 
   importMetaInitialize(meta, context, loader) {
diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index 44c8936e9a4021..14ea34c6e15a42 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -713,6 +713,9 @@ 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, [

From 2c499bcb2c8605188b9dfb67388e439e56b8e3b8 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 7 Aug 2023 10:55:25 +0200
Subject: [PATCH 28/32] Apply suggestions from code review

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 doc/api/esm.md                          | 20 ++++++++++----------
 lib/internal/modules/esm/load.js        |  6 +++---
 lib/internal/modules/esm/translators.js |  1 +
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 22c61e678735b7..763b43bdf815b7 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -959,12 +959,12 @@ The final value of `format` must be one of the following:
 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.
 
-For type `'commonjs'`, if `source` is defined, `require` calls from inside the
-loaded module will go through the registered `resolve` and `load` hooks.
-If `source` is undefined or `null`, it will be handled by the CommonJS
-module loader and not processed by any registered hooks. This behavior
-for nullish `source` is temporary; in the future, a `source` value that is
-undefined or `null` will not be supported.
+If a `load` hook returns commonjs `source`, that module's `require` calls will
+be processed by ESM loader with registered `resolve` and `load` 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 not processed by 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` for backward
@@ -975,11 +975,11 @@ non-default behavior:
 import { readFile } from 'node:fs/promises';
 
 export async function load(url, context, nextLoad) {
-  const response = await nextLoad(url, context);
-  if (response.format === 'commonjs') {
-    response.source ??= await readFile(new URL(response.responseURL ?? url));
+  const result = await nextLoad(url, context);
+  if (result.format === 'commonjs') {
+    result.source ??= await readFile(new URL(result.responseURL ?? url));
   }
-  return response;
+  return result;
 }
 ```
 
diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 00bf3becfb4426..1998ed1dab67fb 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -134,7 +134,7 @@ async function defaultLoad(url, context = kEmptyObject) {
 }
 /**
  * @typedef LoadContext
- * @property {string} [format] Hint possibly returned by `resolve`
+ * @property {string} [format] A hint (possibly returned from `resolve`)
  * @property {string | Buffer | ArrayBuffer} [source] source
  * @property {Record<string, string>} [importAssertions] import attributes
  */
@@ -142,12 +142,12 @@ async function defaultLoad(url, context = kEmptyObject) {
 /**
  * @typedef LoadReturn
  * @property {string} format format
- * @property {string} responseURL url
+ * @property {URL['href']} responseURL The module's fully resolved URL
  * @property {Buffer} source source
  */
 
 /**
- * @param {string} url
+ * @param {URL['href']} url
  * @param {LoadContext} [context]
  * @returns {LoadReturn}
  */
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 35e840b6ac51c5..c0125cd84c37c0 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -183,6 +183,7 @@ function loadCJSModule(module, source, url, filename) {
           case '.node':
             return CJSModule._load(specifier, module);
           default:
+            // fall through
         }
         specifier = `${pathToFileURL(path)}`;
       }

From 2c5fcfb40f7b4b1101c3ac96dfb37551fcd0e9b2 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 7 Aug 2023 11:06:56 +0200
Subject: [PATCH 29/32] Apply suggestions from code review

---
 doc/api/esm.md | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 763b43bdf815b7..f313195df0055f 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -959,17 +959,20 @@ The final value of `format` must be one of the following:
 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.
 
-If a `load` hook returns commonjs `source`, that module's `require` calls will
-be processed by ESM loader with registered `resolve` and `load` 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 not processed by registered hooks. This behavior for nullish
-`source` is temporary—in the future, nullish `source` will not be supported.
+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` for backward
-compatibility. Here is an example loader that would opt-in to using the
-non-default behavior:
+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';

From 8291086e434317bbe81de625a60057fce9390300 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 7 Aug 2023 11:16:34 +0200
Subject: [PATCH 30/32] Update lib/internal/modules/esm/loader.js

---
 lib/internal/modules/esm/loader.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index f3d67e9520fdc4..5305c1eb8f37d9 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -397,11 +397,12 @@ class ModuleLoader {
       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 };
-    } else if (format === 'module') {
-      throw new ERR_REQUIRE_ESM(url, true);
     }
     this.validateLoadResult(url, format);
     return result;

From 624d933a0286d975752b18802f508a0cd89bb12c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 12 Aug 2023 13:10:35 +0200
Subject: [PATCH 31/32] do not make the test depend on how many require calls
 there is in `common/index.js`

---
 test/es-module/test-esm-loader-hooks.mjs | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index 14ea34c6e15a42..3364765e7b4640 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -733,23 +733,30 @@ describe('Loader hooks', { concurrency: true }, () => {
 
   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";export ${async function load(u, c, n) {
-        const r = await n(u, c);
-        if (c.format === 'commonjs') {
-          r.source = await readFile(new URL(u));
-        }
-        return r;
-      }}`,
+      `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')) {
+          // We don't want the test to start failing when the common file is
+          // modified, so we force it to load with CJS loader:
+            r.source = '"use strict";module.exports=require("node:module").createRequire(' +
+                     `${JSON.stringify(u)})(${JSON.stringify(fileURLToPath(u))})`;
+          } 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(25));
+    assert.strictEqual(stdout, 'resolve passthru\n'.repeat(10));
     assert.strictEqual(code, 0);
     assert.strictEqual(signal, null);
   });

From 5d9cdd03fb5cb0252834f0ad1512bd24723f565c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 13 Aug 2023 03:26:30 +0200
Subject: [PATCH 32/32] fixup! do not make the test depend on how many require
 calls there is in `common/index.js`

---
 test/es-module/test-esm-loader-hooks.mjs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index 3364765e7b4640..d5525f5770b052 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -741,10 +741,8 @@ describe('Loader hooks', { concurrency: true }, () => {
         async function load(u, c, n) {
           const r = await n(u, c);
           if (u.endsWith('/common/index.js')) {
-          // We don't want the test to start failing when the common file is
-          // modified, so we force it to load with CJS loader:
             r.source = '"use strict";module.exports=require("node:module").createRequire(' +
-                     `${JSON.stringify(u)})(${JSON.stringify(fileURLToPath(u))})`;
+                     `${JSON.stringify(u)})(${JSON.stringify(fileURLToPath(u))});\n`;
           } else if (c.format === 'commonjs') {
             r.source = await readFile(new URL(u));
           }