From b4c3f5c23a78339da0ea5781361361d2cf39fa80 Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Tue, 5 Mar 2024 17:19:35 +0100
Subject: [PATCH] module: support require()ing synchronous ESM graphs

This patch adds `require()` support for synchronous ESM graphs under
the flag --experimental-require-module.

This is based on the the following design aspect of ESM:

- The resolution can be synchronous (up to the host)
- The evaluation of a synchronous graph (without top-level await)
  is also synchronous, and, by the time the module graph is
  instantiated (before evaluation starts), this is is already known.

When the module being require()ed has .mjs extension or there are
other explicit indicators that it's an ES module, we load it as an
ES module. If the graph is synchronous, we return the module namespace
as the exports. If the graph contains top-level await, we throw an
error before evaluating the module. If an additional flag
--print-pending-tla is passed, we proceeds to evaluation but do not
run the microtasks, only to find out where the TLA is and print
their location to help users fix them.

If there are not explicit indicators whether a .js file is CJS or ESM,
we parse it as CJS first. If the parse error indicates that it contains
ESM syntax, we parse it again as ESM. If the second parsing succeeds,
we continue to treat it as ESM.
---
 .eslintignore                                 |   2 +
 doc/api/cli.md                                |  17 ++
 lib/internal/errors.js                        |   3 +
 lib/internal/modules/cjs/loader.js            | 150 +++++++++++-----
 lib/internal/modules/esm/loader.js            | 102 ++++++++---
 lib/internal/modules/esm/module_job.js        | 135 +++++++++------
 lib/internal/modules/esm/module_map.js        |   4 +-
 lib/internal/modules/esm/resolve.js           |  11 +-
 lib/internal/modules/esm/translators.js       | 160 +++++++-----------
 lib/internal/util/embedding.js                |   2 +-
 src/module_wrap.cc                            | 150 ++++++++++++++++
 src/module_wrap.h                             |   2 +
 src/node_contextify.cc                        | 110 ++++++++----
 src/node_options.cc                           |   5 +
 src/node_options.h                            |   1 +
 .../test-esm-cjs-load-error-note.mjs          |   6 +-
 test/es-module/test-esm-loader-modulemap.js   |   2 +-
 .../test-require-module-entry-point-aou.js    |   8 +
 .../test-require-module-entry-point.js        |   8 +
 test/es-module/test-require-module.js         |  61 +++++++
 20 files changed, 686 insertions(+), 253 deletions(-)
 create mode 100644 test/es-module/test-require-module-entry-point-aou.js
 create mode 100644 test/es-module/test-require-module-entry-point.js
 create mode 100644 test/es-module/test-require-module.js

diff --git a/.eslintignore b/.eslintignore
index 64f34660d87a8f..f72fbdfd842923 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -13,3 +13,5 @@ doc/changelogs/CHANGELOG_v1*.md
 !doc/changelogs/CHANGELOG_v18.md
 !doc/api_assets/*.js
 !.eslintrc.js
+test/es-module/test-require-module-entry-point.js
+test/es-module/test-require-module-entry-point-aou.js
diff --git a/doc/api/cli.md b/doc/api/cli.md
index bdae4a7e771391..bbfb111e051d4d 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -871,6 +871,22 @@ added: v11.8.0
 
 Use the specified file as a security policy.
 
+### `--experimental-require-module`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active Developement
+
+Supports loading a synchronous ES module graph in `require()`. If the module
+graph is not synchronous (contains top-level await), it throws an error.
+
+By default, a `.js` file will be parsed as a CommonJS module first. If it
+contains ES module syntax, Node.js will try to parse and evaluate the module
+again as an ES module. If it turns out to be synchronous and can be evaluated
+successfully, the module namespace object will be returned by `require()`.
+
 ### `--experimental-sea-config`
 
 <!-- YAML
@@ -2523,6 +2539,7 @@ Node.js options that are allowed are:
 * `--experimental-network-imports`
 * `--experimental-permission`
 * `--experimental-policy`
+* `--experimental-require-module`
 * `--experimental-shadow-realm`
 * `--experimental-specifier-resolution`
 * `--experimental-top-level-await`
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ef4295f9eaaaef..970519d93dab7f 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -210,6 +210,7 @@ class NodeAggregateError extends AggregateError {
 }
 
 const assert = require('internal/assert');
+const { getOptionValue } = require('internal/options');
 
 // Lazily loaded
 let util;
@@ -1686,6 +1687,8 @@ E('ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS', '%s', TypeError);
 E('ERR_REQUIRE_ESM',
   function(filename, hasEsmSyntax, parentPath = null, packageJsonPath = null) {
     hideInternalStackFrames(this);
+    // TODO(joyeecheung): mention --experimental-require-module here.
+    assert(!getOptionValue('--experimental-require-module'));
     let msg = `require() of ES Module ${filename}${parentPath ? ` from ${
       parentPath}` : ''} not supported.`;
     if (!packageJsonPath) {
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index cd36233aa9b790..01940513321ec4 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -60,10 +60,11 @@ const {
   StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
+  Symbol,
 } = primordials;
 
-// Map used to store CJS parsing data.
-const cjsParseCache = new SafeWeakMap();
+// Map used to store CJS parsing data or for ESM loading.
+const cjsSourceCache = new SafeWeakMap();
 /**
  * Map of already-loaded CJS modules to use.
  */
@@ -72,12 +73,15 @@ const cjsExportsCache = new SafeWeakMap();
 // Set first due to cycle with ESM loader functions.
 module.exports = {
   cjsExportsCache,
-  cjsParseCache,
+  cjsSourceCache,
   initializeCJS,
   Module,
   wrapSafe,
+  makeRequireWithPolicy,
 };
 
+const is_main_symbol = Symbol('is_main_symbol');
+
 const { BuiltinModule } = require('internal/bootstrap/realm');
 const {
   maybeCacheSourceMap,
@@ -98,7 +102,6 @@ const {
   containsModuleSyntax,
   compileFunctionForCJSLoader,
 } = internalBinding('contextify');
-
 const assert = require('internal/assert');
 const fs = require('fs');
 const path = require('path');
@@ -107,7 +110,6 @@ const { safeGetenv } = internalBinding('credentials');
 const {
   privateSymbols: {
     require_private_symbol,
-    host_defined_option_symbol,
   },
 } = internalBinding('util');
 const {
@@ -396,6 +398,10 @@ function initializeCJS() {
   // TODO(joyeecheung): deprecate this in favor of a proper hook?
   Module.runMain =
     require('internal/modules/run_main').executeUserEntryPoint;
+
+  if (getOptionValue('--experimental-require-module')) {
+    Module._extensions['.mjs'] = loadESMFromCJS;
+  }
 }
 
 // Given a module name, and a list of paths to test, returns the first
@@ -988,7 +994,7 @@ Module._load = function(request, parent, isMain) {
   if (cachedModule !== undefined) {
     updateChildren(parent, cachedModule, true);
     if (!cachedModule.loaded) {
-      const parseCachedModule = cjsParseCache.get(cachedModule);
+      const parseCachedModule = cjsSourceCache.get(cachedModule);
       if (!parseCachedModule || parseCachedModule.loaded) {
         return getExportsForCircularRequire(cachedModule);
       }
@@ -1010,6 +1016,9 @@ Module._load = function(request, parent, isMain) {
     setOwnProperty(process, 'mainModule', module);
     setOwnProperty(module.require, 'main', process.mainModule);
     module.id = '.';
+    module[is_main_symbol] = true;
+  } else {
+    module[is_main_symbol] = false;
   }
 
   reportModuleToWatchMode(filename);
@@ -1270,37 +1279,60 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache) {
     );
 
     // Cache the source map for the module if present.
-    if (script.sourceMapURL) {
-      maybeCacheSourceMap(filename, content, this, false, undefined, script.sourceMapURL);
+    const { sourceMapURL } = script;
+    if (sourceMapURL) {
+      maybeCacheSourceMap(filename, content, this, false, undefined, sourceMapURL);
     }
 
-    return runScriptInThisContext(script, true, false);
+    return {
+      __proto__: null,
+      function: runScriptInThisContext(script, true, false),
+      sourceMapURL,
+      retryAsESM: false,
+    };
   }
 
-  try {
-    const result = compileFunctionForCJSLoader(content, filename);
-    result.function[host_defined_option_symbol] = hostDefinedOptionId;
-
-    // cachedDataRejected is only set for cache coming from SEA.
-    if (codeCache &&
-        result.cachedDataRejected !== false &&
-        internalBinding('sea').isSea()) {
-      process.emitWarning('Code cache data rejected.');
-    }
+  const result = compileFunctionForCJSLoader(content, filename);
 
-    // Cache the source map for the module if present.
-    if (result.sourceMapURL) {
-      maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
-    }
+  // cachedDataRejected is only set for cache coming from SEA.
+  if (codeCache &&
+      result.cachedDataRejected !== false &&
+      internalBinding('sea').isSea()) {
+    process.emitWarning('Code cache data rejected.');
+  }
 
-    return result.function;
-  } catch (err) {
-    if (process.mainModule === cjsModuleInstance) {
-      const { enrichCJSError } = require('internal/modules/esm/translators');
-      enrichCJSError(err, content, filename);
-    }
-    throw err;
+  // Cache the source map for the module if present.
+  if (result.sourceMapURL) {
+    maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
+  }
+
+  return result;
+}
+
+// Resolve and evaluate as ESM, synchronously.
+function loadESMFromCJS(mod, filename) {
+  const source = getMaybeCachedSource(mod, filename);
+  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
+  // We are still using the CJS's resolution here.
+  const url = pathToFileURL(filename).href;
+  const isMain = mod[is_main_symbol];
+  // TODO(joyeecheung): maybe we can do some special handling for default here. Maybe we don't.
+  mod.exports = cascadedLoader.importSyncForRequire(url, source, isMain);
+}
+
+/**
+ * Create a require function for this module, apply policy if necessary.
+ * @param {Module} module
+ * @param {string} moduleURL
+ * @returns {Function}
+ */
+function makeRequireWithPolicy(module, moduleURL) {
+  const manifest = policy()?.manifest;
+  let redirects;
+  if (manifest) {
+    redirects = manifest.getDependencyMapper(moduleURL);
   }
+  return makeRequireFunction(module, redirects);
 }
 
 /**
@@ -1308,19 +1340,35 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache) {
  * `exports`) to the file. Returns exception, if any.
  * @param {string} content The source code of the module
  * @param {string} filename The file path of the module
+ * @param {boolean} loadAsESM Whether it's known to be ESM - i.e. suffix is .mjs.
  */
-Module.prototype._compile = function(content, filename) {
+Module.prototype._compile = function(content, filename, loadAsESM = false) {
   let moduleURL;
-  let redirects;
   const manifest = policy()?.manifest;
   if (manifest) {
     moduleURL = pathToFileURL(filename);
-    redirects = manifest.getDependencyMapper(moduleURL);
     manifest.assertIntegrity(moduleURL, content);
   }
 
-  const compiledWrapper = wrapSafe(filename, content, this);
+  // TODO(joyeecheung): when the module is the entry point, consider allowing TLA.
+  // Only modules being require()'d really need to avoid TLA.
+  let compiledWrapper;
+  if (!loadAsESM) {
+    const result = wrapSafe(filename, content, this);
+    compiledWrapper = result.function;
+    loadAsESM = result.retryAsESM;
+  }
 
+  if (loadAsESM) {
+    // Pass the source into the .mjs extension handler indirectly through the cache.
+    cjsSourceCache.set(this, content);
+    loadESMFromCJS(this, filename);
+    return;
+  }
+
+  // TODO(joyeecheung): the detection below is unnecessarily complex. Maybe just
+  // use the is_main_symbol, or a break_on_start_symbol that gets passed from
+  // higher level instead of doing hacky detecion here.
   let inspectorWrapper = null;
   if (getOptionValue('--inspect-brk') && process._eval == null) {
     if (!resolvedArgv) {
@@ -1344,8 +1392,9 @@ Module.prototype._compile = function(content, filename) {
       inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
+
   const dirname = path.dirname(filename);
-  const require = makeRequireFunction(this, redirects);
+  const require = makeRequireWithPolicy(this, moduleURL);
   let result;
   const exports = this.exports;
   const thisValue = exports;
@@ -1363,25 +1412,37 @@ Module.prototype._compile = function(content, filename) {
   return result;
 };
 
-/**
- * Native handler for `.js` files.
- * @param {Module} module The module to compile
- * @param {string} filename The file path of the module
- */
-Module._extensions['.js'] = function(module, filename) {
-  // If already analyzed the source, then it will be cached.
-  const cached = cjsParseCache.get(module);
+function getMaybeCachedSource(mod, filename) {
+  const cached = cjsSourceCache.get(mod);
   let content;
   if (cached?.source) {
     content = cached.source;
     cached.source = undefined;
   } else {
+    // TODO(joyeecheung): read a buffer.
     content = fs.readFileSync(filename, 'utf8');
   }
+  return content;
+}
+
+/**
+ * Native handler for `.js` files.
+ * @param {Module} module The module to compile
+ * @param {string} filename The file path of the module
+ */
+Module._extensions['.js'] = function(module, filename) {
+  // If already analyzed the source, then it will be cached.
+  const content = getMaybeCachedSource(module, filename);
+
   if (StringPrototypeEndsWith(filename, '.js')) {
     const pkg = packageJsonReader.getNearestParentPackageJSON(filename);
     // Function require shouldn't be used in ES modules.
     if (pkg?.data.type === 'module') {
+      if (getOptionValue('--experimental-require-module')) {
+        module._compile(content, filename, true);
+        return;
+      }
+
       // This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.
       const parent = moduleParentCache.get(module);
       const parentPath = parent?.filename;
@@ -1414,7 +1475,8 @@ Module._extensions['.js'] = function(module, filename) {
       throw err;
     }
   }
-  module._compile(content, filename);
+
+  module._compile(content, filename, false);
 };
 
 /**
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 1b46caf9c6412d..b32b76fadd22e2 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -15,16 +15,24 @@ const {
   hardenRegExp,
 } = primordials;
 
+const assert = require('internal/assert');
 const {
   ERR_REQUIRE_ESM,
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { isURL } = require('internal/url');
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 const {
+  registerModule,
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+const { kImplicitAssertType } = require('internal/modules/esm/assert');
+const {
+  maybeCacheSourceMap,
+} = require('internal/source_map/source_map_cache');
+
+const { ModuleWrap } = internalBinding('module_wrap');
 let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
 
 /**
@@ -184,8 +192,6 @@ class ModuleLoader {
 
   async eval(source, url, isEntryPoint = false) {
     const evalInstance = (url) => {
-      const { ModuleWrap } = internalBinding('module_wrap');
-      const { registerModule } = require('internal/modules/esm/utils');
       const module = new ModuleWrap(url, undefined, source, 0, 0);
       registerModule(module, {
         __proto__: null,
@@ -197,7 +203,7 @@ class ModuleLoader {
 
       return module;
     };
-    const ModuleJob = require('internal/modules/esm/module_job');
+    const { ModuleJob } = require('internal/modules/esm/module_job');
     const job = new ModuleJob(
       this, url, undefined, evalInstance, false, false);
     this.loadCache.set(url, undefined, job);
@@ -228,12 +234,12 @@ class ModuleLoader {
     return this.getJobFromResolveResult(resolveResult, parentURL, importAttributes);
   }
 
-  getModuleJobSync(specifier, parentURL, importAttributes) {
-    const resolveResult = this.resolveSync(specifier, parentURL, importAttributes);
-    return this.getJobFromResolveResult(resolveResult, parentURL, importAttributes, true);
+  getModuleJobSync(specifier, parentURL, importAttributes, requireESMHint) {
+    const resolveResult = this.resolveSync(specifier, parentURL, importAttributes, requireESMHint);
+    return this.getJobFromResolveResult(resolveResult, parentURL, importAttributes, true, requireESMHint);
   }
 
-  getJobFromResolveResult(resolveResult, parentURL, importAttributes, sync) {
+  getJobFromResolveResult(resolveResult, parentURL, importAttributes, sync, requireESMHint) {
     const { url, format } = resolveResult;
     const resolvedImportAttributes = resolveResult.importAttributes ?? importAttributes;
     let job = this.loadCache.get(url, resolvedImportAttributes.type);
@@ -244,12 +250,46 @@ class ModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync);
+      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync, requireESMHint);
     }
 
     return job;
   }
 
+  importSyncForRequire(url, source, isMain) {
+    let job = this.loadCache.get(url, kImplicitAssertType);
+    if (job !== undefined) {
+      // Module job constructor already finishes the instantiation so it's safe to
+      // return the live namespace now.
+      return job.module.getNamespace();
+    }
+    const wrap = new ModuleWrap(url, undefined, source, 0, 0);
+    // Cache the source map for the module if present.
+    if (wrap.sourceMapURL) {
+      maybeCacheSourceMap(url, source, null, false, undefined, wrap.sourceMapURL);
+    }
+    const { registerModule } = require('internal/modules/esm/utils');
+    registerModule(wrap, {
+      __proto__: null,
+      initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
+      // TODO(joyeecheung): this can just use vm_dynamic_import_default_internal, and
+      // maybe most of other ModuleWraps created by the ESM loader too.
+      importModuleDynamically: (specifier, wrap, importAttributes) => {
+        return this.import(specifier, url, importAttributes);
+      },
+    });
+
+    const inspectBrk = isMain && getOptionValue('--inspect-brk');
+
+    const { ModuleJobSync } = require('internal/modules/esm/module_job');
+    // TODO(joyeecheung): create ModuleJobSync for this.
+    job = new ModuleJobSync(this, url, kEmptyObject, wrap, isMain, inspectBrk, true);
+    this.loadCache.set(url, kImplicitAssertType, job);
+
+    const { namespace } = job.runSync();
+    return namespace;
+  }
+
   /**
    * Create and cache an object representing a loaded module.
    * @param {string} url The absolute URL that was resolved for this module
@@ -261,7 +301,7 @@ class ModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAttributes, parentURL, format, sync) {
+  #createModuleJob(url, importAttributes, parentURL, format, sync, requireESMHint) {
     const callTranslator = ({ format: finalFormat, responseURL, source }, isMain) => {
       const translator = getTranslators().get(finalFormat);
 
@@ -274,11 +314,12 @@ class ModuleLoader {
     const context = { format, importAttributes };
 
     const moduleProvider = sync ?
-      (url, isMain) => callTranslator(this.loadSync(url, context), isMain) :
+      (url, isMain) => callTranslator(this.loadSync(url, context, requireESMHint), isMain) :
       async (url, isMain) => callTranslator(await this.load(url, context), isMain);
 
+    const isMain = parentURL === undefined;
     const inspectBrk = (
-      parentURL === undefined &&
+      isMain &&
       getOptionValue('--inspect-brk')
     );
 
@@ -286,13 +327,13 @@ class ModuleLoader {
       process.send({ 'watch:import': [url] });
     }
 
-    const ModuleJob = require('internal/modules/esm/module_job');
+    const { ModuleJob } = require('internal/modules/esm/module_job');
     const job = new ModuleJob(
       this,
       url,
       importAttributes,
       moduleProvider,
-      parentURL === undefined,
+      isMain,
       inspectBrk,
       sync,
     );
@@ -340,7 +381,7 @@ class ModuleLoader {
    *                                            statement or expression.
    * @returns {{ format: string, url: URL['href'] }}
    */
-  resolve(originalSpecifier, parentURL, importAttributes) {
+  resolve(originalSpecifier, parentURL, importAttributes, requireESMHint) {
     if (this.#customizations) {
       return this.#customizations.resolve(originalSpecifier, parentURL, importAttributes);
     }
@@ -349,7 +390,7 @@ class ModuleLoader {
     if (cachedResult != null) {
       return cachedResult;
     }
-    const result = this.defaultResolve(originalSpecifier, parentURL, importAttributes);
+    const result = this.defaultResolve(originalSpecifier, parentURL, importAttributes, requireESMHint);
     this.#resolveCache.set(requestKey, parentURL, result);
     return result;
   }
@@ -358,11 +399,14 @@ class ModuleLoader {
    * Just like `resolve` except synchronous. This is here specifically to support
    * `import.meta.resolve` which must happen synchronously.
    */
-  resolveSync(originalSpecifier, parentURL, importAttributes) {
-    if (this.#customizations) {
+  resolveSync(originalSpecifier, parentURL, importAttributes, requireESMHint) {
+    // If this comes from the require(esm) fallback, don't apply loader hooks which are on
+    // a separate thread. This is ignored by require(cjs) already anyway.
+    // TODO(joyeecheung): add support in hooks for this?
+    if (this.#customizations && !requireESMHint) {
       return this.#customizations.resolveSync(originalSpecifier, parentURL, importAttributes);
     }
-    return this.defaultResolve(originalSpecifier, parentURL, importAttributes);
+    return this.defaultResolve(originalSpecifier, parentURL, importAttributes, requireESMHint);
   }
 
   /**
@@ -370,7 +414,7 @@ class ModuleLoader {
    * `resolve` and `resolveSync`. This function is here just to avoid
    * repeating the same code block twice in those functions.
    */
-  defaultResolve(originalSpecifier, parentURL, importAttributes) {
+  defaultResolve(originalSpecifier, parentURL, importAttributes, requireESMHint) {
     defaultResolve ??= require('internal/modules/esm/resolve').defaultResolve;
 
     const context = {
@@ -378,6 +422,7 @@ class ModuleLoader {
       conditions: this.#defaultConditions,
       importAttributes,
       parentURL,
+      requireESMHint,
     };
 
     return defaultResolve(originalSpecifier, context);
@@ -398,14 +443,23 @@ class ModuleLoader {
     return result;
   }
 
-  loadSync(url, context) {
+  loadSync(url, context, requireESMHint) {
     defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
-
-    let result = this.#customizations ?
+    const isRequireModuleAllowed = getOptionValue('--experimental-require-module');
+    if (requireESMHint === 'from-cjs-error') {
+      assert(isRequireModuleAllowed);
+      context.format = 'module';
+    }
+    // If this comes from the require(esm) fallback, don't apply loader hooks which are on
+    // a separate thread. This is ignored by require(cjs) already anyway.
+    // TODO(joyeecheung): add support in hooks for this?
+    let result = this.#customizations && !requireESMHint ?
       this.#customizations.loadSync(url, context) :
       defaultLoadSync(url, context);
+
+    // TODO(joyeecheung): we need a better way to detect the format and cache the result.
     let format = result?.format;
-    if (format === 'module') {
+    if (format === 'module' && !isRequireModuleAllowed) {
       throw new ERR_REQUIRE_ESM(url, true);
     }
     if (format === 'commonjs') {
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 108a8138443de0..90c9c78bd0da61 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -8,9 +8,9 @@ const {
   ObjectSetPrototypeOf,
   PromiseResolve,
   PromisePrototypeThen,
-  ReflectApply,
   RegExpPrototypeExec,
   RegExpPrototypeSymbolReplace,
+  ReflectApply,
   SafePromiseAllReturnArrayLike,
   SafePromiseAllReturnVoid,
   SafeSet,
@@ -52,63 +52,76 @@ const isCommonJSGlobalLikeNotDefinedError = (errorMessage) =>
     (globalLike) => errorMessage === `${globalLike} is not defined`,
   );
 
-/* A ModuleJob tracks the loading of a single Module, and the ModuleJobs of
- * its dependencies, over time. */
-class ModuleJob {
-  // `loader` is the Loader instance used for loading dependencies.
-  // `moduleProvider` is a function
-  constructor(loader, url, importAttributes = { __proto__: null },
-              moduleProvider, isMain, inspectBrk, sync = false) {
+class ModuleJobBase {
+  constructor(loader, url, importAttributes, moduleWrapMaybePromise, isMain, inspectBrk) {
     this.loader = loader;
     this.importAttributes = importAttributes;
     this.isMain = isMain;
     this.inspectBrk = inspectBrk;
 
     this.url = url;
+    this.module = moduleWrapMaybePromise;
+    // instantiated == deep dependency jobs wrappers are instantiated,
+    // and module wrapper is instantiated.
+    this.instantiated = undefined;
+  }
+}
 
-    this.module = undefined;
+/* A ModuleJob tracks the loading of a single Module, and the ModuleJobs of
+ * its dependencies, over time. */
+class ModuleJob extends ModuleJobBase {
+  // `loader` is the Loader instance used for loading dependencies.
+  // `moduleProvider` is a function
+  constructor(loader, url, importAttributes = { __proto__: null },
+              moduleProvider, isMain, inspectBrk, sync = false) {
     // Expose the promise to the ModuleWrap directly for linking below.
     // `this.module` is also filled in below.
-    this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+    const moduleWrapMaybePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+    super(loader, url, importAttributes, moduleWrapMaybePromise, isMain, inspectBrk);
 
     if (sync) {
-      this.module = this.modulePromise;
+      this.module = moduleWrapMaybePromise;
+      // TODO(joyeecheung): not needed?
       this.modulePromise = PromiseResolve(this.module);
+      assert(this.module instanceof ModuleWrap);
+      this.linked = this.module.linkSync((specifier, attributes) => {
+        // TODO(joyeecheung): do this entirely in C++.
+        const job = this.loader.getModuleJobSync(specifier, url, attributes, 'from-cjs-fallback');
+        return job.module;
+      });
     } else {
-      this.modulePromise = PromiseResolve(this.modulePromise);
-    }
+      // TODO(joyeecheung): PromiseResolve not needed?
+      this.modulePromise = PromiseResolve(moduleWrapMaybePromise);
+      // Wait for the ModuleWrap instance being linked with all dependencies.
+      const link = async () => {
+        this.module = await this.modulePromise;
+        assert(this.module instanceof ModuleWrap);
 
-    // Wait for the ModuleWrap instance being linked with all dependencies.
-    const link = async () => {
-      this.module = await this.modulePromise;
-      assert(this.module instanceof ModuleWrap);
+        // Explicitly keeping track of dependency jobs is needed in order
+        // to flatten out the dependency graph below in `_instantiate()`,
+        // so that circular dependencies can't cause a deadlock by two of
+        // these `link` callbacks depending on each other.
+        const dependencyJobs = [];
+        const promises = this.module.link(async (specifier, attributes) => {
+          const job = await this.loader.getModuleJob(specifier, url, attributes);
+          ArrayPrototypePush(dependencyJobs, job);
+          return job.modulePromise;
+        });
 
-      // Explicitly keeping track of dependency jobs is needed in order
-      // to flatten out the dependency graph below in `_instantiate()`,
-      // so that circular dependencies can't cause a deadlock by two of
-      // these `link` callbacks depending on each other.
-      const dependencyJobs = [];
-      const promises = this.module.link(async (specifier, attributes) => {
-        const job = await this.loader.getModuleJob(specifier, url, attributes);
-        ArrayPrototypePush(dependencyJobs, job);
-        return job.modulePromise;
-      });
+        if (promises !== undefined) {
+          await SafePromiseAllReturnVoid(promises);
+        }
 
-      if (promises !== undefined) {
-        await SafePromiseAllReturnVoid(promises);
-      }
+        return SafePromiseAllReturnArrayLike(dependencyJobs);
+      };
 
-      return SafePromiseAllReturnArrayLike(dependencyJobs);
-    };
-    // Promise for the list of all dependencyJobs.
-    this.linked = link();
-    // This promise is awaited later anyway, so silence
-    // 'unhandled rejection' warnings.
-    PromisePrototypeThen(this.linked, undefined, noop);
+      // Promise for the list of all dependencyJobs.
+      this.linked = link();
 
-    // instantiated == deep dependency jobs wrappers are instantiated,
-    // and module wrapper is instantiated.
-    this.instantiated = undefined;
+      // This promise is awaited later anyway, so silence
+      // 'unhandled rejection' warnings.
+      PromisePrototypeThen(this.linked, undefined, noop);
+    }
   }
 
   instantiate() {
@@ -209,13 +222,9 @@ class ModuleJob {
       return { __proto__: null, module: this.module };
     }
 
-    this.module.instantiate();
-    this.instantiated = PromiseResolve();
-    const timeout = -1;
-    const breakOnSigint = false;
     setHasStartedUserESMExecution();
-    this.module.evaluate(timeout, breakOnSigint);
-    return { __proto__: null, module: this.module };
+    const namespace = this.module.runSync();
+    return { __proto__: null, module: this.module, namespace };
   }
 
   async run(isEntryPoint = false) {
@@ -255,5 +264,35 @@ class ModuleJob {
     return { __proto__: null, module: this.module };
   }
 }
-ObjectSetPrototypeOf(ModuleJob.prototype, null);
-module.exports = ModuleJob;
+
+// This is a fully synchronous job and does not spawn additional threads in any way, unlike
+// the sync alternative of ModuleJob. Probably a lot more efficient too.
+class ModuleJobSync extends ModuleJobBase {
+  constructor(loader, url, importAttributes, moduleWrap, isMain, inspectBrk) {
+    super(loader, url, importAttributes, moduleWrap, isMain, inspectBrk, true);
+    assert(this.module instanceof ModuleWrap);
+    const requireESMHint = 'from-cjs-fallback';
+    this.linked = this.module.linkSync((specifier, attributes) => {
+      // TODO(joyeecheung): do this entirely in C++ and avoid calling back to JS.
+      const resolved = this.loader.resolve(specifier, url, attributes, requireESMHint);
+      const job = this.loader.getJobFromResolveResult(resolved, url, attributes, true, requireESMHint);
+      return job.module;
+    });
+  }
+
+  runSync() {
+    assert(this.module instanceof ModuleWrap);
+    if (this.instantiated !== undefined) {
+      return { __proto__: null, module: this.module };
+    }
+
+    setHasStartedUserESMExecution();
+    const namespace = this.module.runSync();
+    return { __proto__: null, module: this.module, namespace };
+  }
+}
+
+ObjectSetPrototypeOf(ModuleJobBase.prototype, null);
+module.exports = {
+  ModuleJob, ModuleJobSync, ModuleJobBase,
+};
diff --git a/lib/internal/modules/esm/module_map.js b/lib/internal/modules/esm/module_map.js
index eab00386c413a5..ab1171eaa47b02 100644
--- a/lib/internal/modules/esm/module_map.js
+++ b/lib/internal/modules/esm/module_map.js
@@ -97,8 +97,8 @@ class LoadCache extends SafeMap {
     validateString(url, 'url');
     validateString(type, 'type');
 
-    const ModuleJob = require('internal/modules/esm/module_job');
-    if (job instanceof ModuleJob !== true &&
+    const { ModuleJobBase } = require('internal/modules/esm/module_job');
+    if (job instanceof ModuleJobBase !== true &&
         typeof job !== 'function') {
       throw new ERR_INVALID_ARG_TYPE('job', 'ModuleJob', job);
     }
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index bbbaed87479289..353e712615f635 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -233,7 +233,7 @@ const encodedSepRegEx = /%2F|%5C/i;
  * @throws {ERR_UNSUPPORTED_DIR_IMPORT} - If the resolved pathname is a directory.
  * @throws {ERR_MODULE_NOT_FOUND} - If the resolved pathname is not a file.
  */
-function finalizeResolution(resolved, base, preserveSymlinks) {
+function finalizeResolution(resolved, base, preserveSymlinks, requireESMHint) {
   if (RegExpPrototypeExec(encodedSepRegEx, resolved.pathname) !== null) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
       resolved.pathname, 'must not include encoded "/" or "\\" characters',
@@ -253,6 +253,9 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   const stats = internalModuleStat(toNamespacedPath(StringPrototypeEndsWith(path, '/') ?
     StringPrototypeSlice(path, -1) : path));
 
+  // TODO(joyeecheung): figure out what we should do when require('./dir') resolves to
+  // a directory.
+  // if (!requireESMHint) {
   // Check for stats.isDirectory()
   if (stats === 1) {
     throw new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath(base), String(resolved));
@@ -264,6 +267,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     throw new ERR_MODULE_NOT_FOUND(
       path || resolved.pathname, base && fileURLToPath(base), resolved);
   }
+  // }
 
   if (!preserveSymlinks) {
     const real = realpathSync(path, {
@@ -884,7 +888,7 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
  * @param {Set<string>} conditions - An object containing environment conditions.
  * @param {boolean} preserveSymlinks - Whether to preserve symlinks in the resolved URL.
  */
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+function moduleResolve(specifier, base, conditions, preserveSymlinks, requireESMHint) {
   const protocol = typeof base === 'string' ?
     StringPrototypeSlice(base, 0, StringPrototypeIndexOf(base, ':') + 1) :
     base.protocol;
@@ -921,7 +925,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
   if (resolved.protocol !== 'file:') {
     return resolved;
   }
-  return finalizeResolution(resolved, base, preserveSymlinks);
+  return finalizeResolution(resolved, base, preserveSymlinks, requireESMHint);
 }
 
 /**
@@ -1150,6 +1154,7 @@ function defaultResolve(specifier, context = {}) {
       parentURL,
       conditions,
       isMain ? preserveSymlinksMain : preserveSymlinks,
+      context.requireESMHint,
     );
   } catch (error) {
     // Try to give the user a hint of what would have been the
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 50a315ae68c02a..30dc9525077016 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -4,7 +4,6 @@ const {
   ArrayPrototypeMap,
   Boolean,
   JSONParse,
-  ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
   ObjectKeys,
   ReflectApply,
@@ -15,16 +14,9 @@ const {
   StringPrototypeReplaceAll,
   StringPrototypeSlice,
   StringPrototypeStartsWith,
-  SyntaxErrorPrototype,
   globalThis: { WebAssembly },
 } = primordials;
 
-const {
-  privateSymbols: {
-    host_defined_option_symbol,
-  },
-} = internalBinding('util');
-
 /** @type {import('internal/util/types')} */
 let _TYPES = null;
 /**
@@ -36,7 +28,6 @@ function lazyTypes() {
 }
 
 const {
-  containsModuleSyntax,
   compileFunctionForCJSLoader,
 } = internalBinding('contextify');
 
@@ -50,8 +41,9 @@ const {
 } = require('internal/modules/helpers');
 const {
   Module: CJSModule,
-  cjsParseCache,
+  cjsSourceCache,
   cjsExportsCache,
+  makeRequireWithPolicy,
 } = require('internal/modules/cjs/loader');
 const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
@@ -65,10 +57,8 @@ const {
 const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
 const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
-const { emitWarningSync } = require('internal/process/warning');
-const {
-  vm_dynamic_import_default_internal,
-} = internalBinding('symbols');
+
+const { getOptionValue } = require('internal/options');
 // Lazy-loading to avoid circular dependencies.
 let getSourceSync;
 /**
@@ -84,27 +74,17 @@ function getSource(url) {
 let cjsParse;
 /**
  * Initializes the CommonJS module lexer parser.
- * If WebAssembly is available, it uses the optimized version from the dist folder.
- * Otherwise, it falls back to the JavaScript version from the lexer folder.
  */
-async function initCJSParse() {
-  if (typeof WebAssembly === 'undefined') {
+function initCJSParse() {
+  // TODO(joyeecheung): implement a binding that directly compiles using
+  // v8::WasmModuleObject::Compile() synchronously.
+  if (cjsParse === undefined) {
     cjsParse = require('internal/deps/cjs-module-lexer/lexer').parse;
-  } else {
-    const { parse, init } =
-        require('internal/deps/cjs-module-lexer/dist/lexer');
-    try {
-      await init();
-      cjsParse = parse;
-    } catch {
-      cjsParse = require('internal/deps/cjs-module-lexer/lexer').parse;
-    }
   }
 }
 
 const translators = new SafeMap();
 exports.translators = translators;
-exports.enrichCJSError = enrichCJSError;
 
 let DECODER = null;
 /**
@@ -170,7 +150,7 @@ async function importModuleDynamically(specifier, { url }, attributes) {
 }
 
 // Strategy for loading a standard JavaScript module.
-translators.set('module', async function moduleStrategy(url, source, isMain) {
+translators.set('module', function moduleStrategy(url, source, isMain) {
   assertBufferSource(source, true, 'load');
   source = stringify(source);
   debug(`Translating StandardModule ${url}`);
@@ -188,53 +168,8 @@ translators.set('module', async function moduleStrategy(url, source, isMain) {
   return module;
 });
 
-/**
- * Provide a more informative error for CommonJS imports.
- * @param {Error | any} err
- * @param {string} [content] Content of the file, if known.
- * @param {string} [filename] The filename of the erroring module.
- */
-function enrichCJSError(err, content, filename) {
-  if (err != null && ObjectGetPrototypeOf(err) === SyntaxErrorPrototype &&
-      containsModuleSyntax(content, filename)) {
-    // Emit the warning synchronously because we are in the middle of handling
-    // a SyntaxError that will throw and likely terminate the process before an
-    // asynchronous warning would be emitted.
-    emitWarningSync(
-      'To load an ES module, set "type": "module" in the package.json or use ' +
-      'the .mjs extension.',
-    );
-  }
-}
-
-/**
- * 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.
- * @param {import('internal/modules/cjs/loader').Module} module - The module to load.
- * @param {string} source - The source code of the module.
- * @param {string} url - The URL of the module.
- * @param {string} filename - The filename of the module.
- */
-function loadCJSModule(module, source, url, filename) {
-  let compileResult;
-  try {
-    compileResult = compileFunctionForCJSLoader(source, filename);
-    compileResult.function[host_defined_option_symbol] = vm_dynamic_import_default_internal;
-  } catch (err) {
-    enrichCJSError(err, source, filename);
-    throw err;
-  }
-  // Cache the source map for the cjs module if present.
-  if (compileResult.sourceMapURL) {
-    maybeCacheSourceMap(url, source, null, false, undefined, compileResult.sourceMapURL);
-  }
-
-  const compiledWrapper = compileResult.function;
-
+function makeRequireWithHooks(module, url) {
   const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-  const __dirname = dirname(filename);
   // eslint-disable-next-line func-name-matching,func-style
   const requireFn = function require(specifier) {
     let importAttributes = kEmptyObject;
@@ -267,12 +202,47 @@ function loadCJSModule(module, source, url, filename) {
     return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
   });
   setOwnProperty(requireFn, 'main', process.mainModule);
+  return requireFn;
+}
+
+/**
+ * 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.
+ * @param {import('internal/modules/cjs/loader').Module} module - The module to load.
+ * @param {string} source - The source code of the module.
+ * @param {string} url - The URL of the module.
+ * @param {string} filename - The filename of the module.
+ */
+function loadCJSInternal(module, source, url, filename, isMain) {
+  const compileResult = compileFunctionForCJSLoader(source, filename);
+
+  // Cache the source map for the cjs module if present.
+  if (compileResult.sourceMapURL) {
+    maybeCacheSourceMap(url, source, null, false, undefined, compileResult.sourceMapURL);
+  }
+
+  const compiledWrapper = compileResult.function;
+  const __dirname = dirname(filename);
+
+  // TODO(joyeecheung): figure out how loader hooks should work with
+  // the require(esm) fallback.
+  const requireFn = getOptionValue('--experimental-require-module') ?
+    makeRequireWithPolicy(module, url) :
+    makeRequireWithHooks(module, url);
 
   ReflectApply(compiledWrapper, module.exports,
                [module.exports, requireFn, module, filename, __dirname]);
   setOwnProperty(module, 'loaded', true);
 }
 
+function loadCJSPatchable(module, source, url, filename, isMain) {
+  assert(module === CJSModule._cache[filename]);
+  // Source is indirectly passed from cjsSourceCache.
+  CJSModule._load(filename, undefined, isMain);
+}
+
 // TODO: can we use a weak map instead?
 const cjsCache = new SafeMap();
 /**
@@ -280,10 +250,10 @@ const cjsCache = new SafeMap();
  * @param {string} url - The URL of the module.
  * @param {string} source - The source code of the module.
  * @param {boolean} isMain - Whether the module is the main module.
- * @param {typeof loadCJSModule} [loadCJS=loadCJSModule] - The function to load the CommonJS module.
+ * @param {boolean} patched - Whether the loader is monkey patched.
  * @returns {ModuleWrap} The ModuleWrap object for the CommonJS module.
  */
-function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
+function createCJSModuleWrap(url, source, isMain, patched) {
   debug(`Translating CJSModule ${url}`);
 
   const filename = StringPrototypeStartsWith(url, 'file://') ? fileURLToPath(url) : url;
@@ -303,7 +273,11 @@ function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
     debug(`Loading CJSModule ${url}`);
 
     if (!module.loaded) {
-      loadCJS(module, source, url, filename);
+      if (patched) {
+        loadCJSPatchable(module, source, url, filename, isMain);
+      } else {
+        loadCJSInternal(module, source, url, filename, isMain);
+      }
     }
 
     let exports;
@@ -335,31 +309,21 @@ 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);
+  initCJSParse();
 
-  return createCJSModuleWrap(url, source);
+  return createCJSModuleWrap(url, source, isMain);
 });
 
 // Handle CommonJS modules referenced by `import` statements or expressions,
 // or as the initial entry point when the ESM loader handles a CommonJS entry.
-translators.set('commonjs', async function commonjsStrategy(url, source,
-                                                            isMain) {
-  if (!cjsParse) {
-    await initCJSParse();
-  }
+translators.set('commonjs', /* async */function commonjsStrategy(url, source,
+                                                                 isMain) {
+  initCJSParse();
 
   // For backward-compatibility, it's possible to return a nullish value for
   // CJS source associated with a file: URL. In this case, the source is
   // obtained by calling the monkey-patchable CJS loader.
-  const cjsLoader = source == null ? (module, source, url, filename) => {
-    try {
-      assert(module === CJSModule._cache[filename]);
-      CJSModule._load(filename);
-    } catch (err) {
-      enrichCJSError(err, source, filename);
-      throw err;
-    }
-  } : loadCJSModule;
+  const patched = source == null;
 
   try {
     // We still need to read the FS to detect the exports.
@@ -367,8 +331,8 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
   } catch {
     // Continue regardless of error.
   }
-  return createCJSModuleWrap(url, source, isMain, cjsLoader);
 
+  return createCJSModuleWrap(url, source, isMain, patched);
 });
 
 /**
@@ -380,7 +344,7 @@ 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);
+    const cached = cjsSourceCache.get(module);
     if (cached) {
       return { module, exportNames: cached.exportNames };
     }
@@ -404,7 +368,7 @@ function cjsPreparseModuleExports(filename, source) {
   const exportNames = new SafeSet(new SafeArrayIterator(exports));
 
   // Set first for cycles.
-  cjsParseCache.set(module, { source, exportNames });
+  cjsSourceCache.set(module, { source, exportNames });
 
   if (reexports.length) {
     module.filename = filename;
@@ -531,6 +495,8 @@ translators.set('wasm', async function(url, source) {
 
   let compiled;
   try {
+    // TODO(joyeecheung): implement a binding that directly compiles using
+    // v8::WasmModuleObject::Compile() synchronously.
     compiled = await WebAssembly.compile(source);
   } catch (err) {
     err.message = errPath(url) + ': ' + err.message;
diff --git a/lib/internal/util/embedding.js b/lib/internal/util/embedding.js
index db9162369aae0d..7e4cd565492843 100644
--- a/lib/internal/util/embedding.js
+++ b/lib/internal/util/embedding.js
@@ -16,7 +16,7 @@ const { getCodePath, isSea } = internalBinding('sea');
 
 function embedderRunCjs(contents) {
   const filename = process.execPath;
-  const compiledWrapper = wrapSafe(
+  const { function: compiledWrapper } = wrapSafe(
     isSea() ? getCodePath() : filename,
     contents);
 
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 25eb79d450c807..1aee0a8fbf83d0 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -321,6 +321,72 @@ static Local<Object> createImportAttributesContainer(
   return attributes;
 }
 
+void ModuleWrap::LinkSync(const FunctionCallbackInfo<Value>& args) {
+  Realm* realm = Realm::GetCurrent(args);
+  Isolate* isolate = args.GetIsolate();
+
+  CHECK_EQ(args.Length(), 1);
+  CHECK(args[0]->IsFunction());
+
+  Local<Object> that = args.This();
+
+  ModuleWrap* obj;
+  ASSIGN_OR_RETURN_UNWRAP(&obj, that);
+
+  if (obj->linked_) return;
+  obj->linked_ = true;
+
+  Local<Function> resolver_arg = args[0].As<Function>();
+
+  Local<Context> mod_context = obj->context();
+  Local<Module> module = obj->module_.Get(isolate);
+
+  Local<FixedArray> module_requests = module->GetModuleRequests();
+  const int module_requests_length = module_requests->Length();
+
+  MaybeStackBuffer<Local<Value>, 16> modules(module_requests_length);
+  // call the dependency resolve callbacks
+  for (int i = 0; i < module_requests_length; i++) {
+    Local<ModuleRequest> module_request =
+        module_requests->Get(realm->context(), i).As<ModuleRequest>();
+    Local<String> specifier = module_request->GetSpecifier();
+    Utf8Value specifier_utf8(realm->isolate(), specifier);
+    std::string specifier_std(*specifier_utf8, specifier_utf8.length());
+
+    Local<FixedArray> raw_attributes = module_request->GetImportAssertions();
+    Local<Object> attributes =
+        createImportAttributesContainer(realm, isolate, raw_attributes, 3);
+
+    Local<Value> argv[] = {
+        specifier,
+        attributes,
+    };
+
+    MaybeLocal<Value> maybe_resolve_return_value =
+        resolver_arg->Call(mod_context, that, arraysize(argv), argv);
+    if (maybe_resolve_return_value.IsEmpty()) {
+      return;
+    }
+    Local<Value> resolve_return_value =
+        maybe_resolve_return_value.ToLocalChecked();
+    // TODO(joyeecheung): the resolve cache should not hold on to the wraps
+    // using a Global<Promise>, it's unnecessary and leaky. We should create a
+    // map of ModuleWraps directly instead.
+    Local<Promise::Resolver> resolver;
+    if (!Promise::Resolver::New(mod_context).ToLocal(&resolver)) {
+      return;
+    }
+    if (resolver->Resolve(mod_context, resolve_return_value).IsNothing()) {
+      return;
+    }
+    obj->resolve_cache_[specifier_std].Reset(isolate, resolver->GetPromise());
+    modules[i] = resolve_return_value;
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(isolate, modules.out(), modules.length()));
+}
+
 void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -486,6 +552,86 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result.ToLocalChecked());
 }
 
+void ModuleWrap::RunSync(const FunctionCallbackInfo<Value>& args) {
+  Realm* realm = Realm::GetCurrent(args);
+  Isolate* isolate = args.GetIsolate();
+  ModuleWrap* obj;
+  ASSIGN_OR_RETURN_UNWRAP(&obj, args.This());
+  Local<Context> context = obj->context();
+  Local<Module> module = obj->module_.Get(isolate);
+  Environment* env = realm->env();
+
+  // TODO(joyeecheung): use a separate callback that doesn't use promises
+  // for the cache.
+  {
+    TryCatchScope try_catch(env);
+    USE(module->InstantiateModule(context, ResolveModuleCallback));
+
+    // clear resolve cache on instantiate
+    obj->resolve_cache_.clear();
+
+    if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
+      CHECK(!try_catch.Message().IsEmpty());
+      CHECK(!try_catch.Exception().IsEmpty());
+      AppendExceptionLine(env,
+                          try_catch.Exception(),
+                          try_catch.Message(),
+                          ErrorHandlingMode::MODULE_ERROR);
+      try_catch.ReThrow();
+      return;
+    }
+  }
+
+  // If --print-pending-tla is true, proceeds to evaluation even if it's
+  // async because we want to search for the TLA and help users locate them.
+  if (module->IsGraphAsync() && !env->options()->print_pending_tla) {
+    env->ThrowError("require() cannot be used on an ESM graph with top-level "
+                    "await. Use import() instead.");
+    return;
+  }
+
+  Local<Value> result;
+  {
+    TryCatchScope try_catch(env);
+    if (!module->Evaluate(context).ToLocal(&result)) {
+      if (try_catch.HasCaught()) {
+        if (!try_catch.HasTerminated()) try_catch.ReThrow();
+        return;
+      }
+    }
+  }
+
+  CHECK(result->IsPromise());
+  Local<Promise> promise = result.As<Promise>();
+  if (promise->State() == Promise::PromiseState::kRejected) {
+    isolate->ThrowException(promise->Result());
+    return;
+  }
+
+  if (module->IsGraphAsync()) {
+    CHECK(env->options()->print_pending_tla);
+    auto stalled = module->GetStalledTopLevelAwaitMessage(isolate);
+    if (stalled.size() != 0) {
+      for (auto pair : stalled) {
+        Local<v8::Message> message = std::get<1>(pair);
+
+        std::string reason = "Error: unexpected top-level await at ";
+        std::string info =
+            FormatErrorMessage(isolate, context, "", message, true);
+        reason += info;
+        FPrintF(stderr, "%s\n", reason);
+      }
+    }
+    env->ThrowError("require() cannot be used on an ESM graph with top-level "
+                    "await. Use import() instead.");
+    return;
+  }
+
+  CHECK_EQ(promise->State(), Promise::PromiseState::kFulfilled);
+
+  args.GetReturnValue().Set(module->GetModuleNamespace());
+}
+
 void ModuleWrap::GetNamespace(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -818,6 +964,8 @@ void ModuleWrap::CreatePerIsolateProperties(IsolateData* isolate_data,
       ModuleWrap::kInternalFieldCount);
 
   SetProtoMethod(isolate, tpl, "link", Link);
+  SetProtoMethod(isolate, tpl, "linkSync", LinkSync);
+  SetProtoMethod(isolate, tpl, "runSync", RunSync);
   SetProtoMethod(isolate, tpl, "instantiate", Instantiate);
   SetProtoMethod(isolate, tpl, "evaluate", Evaluate);
   SetProtoMethod(isolate, tpl, "setExport", SetSyntheticExport);
@@ -869,6 +1017,8 @@ void ModuleWrap::RegisterExternalReferences(
   registry->Register(New);
 
   registry->Register(Link);
+  registry->Register(LinkSync);
+  registry->Register(RunSync);
   registry->Register(Instantiate);
   registry->Register(Evaluate);
   registry->Register(SetSyntheticExport);
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 6f44d722ee0b01..659bdc9cb604ed 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -79,6 +79,8 @@ class ModuleWrap : public BaseObject {
   ~ModuleWrap() override;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void LinkSync(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RunSync(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Link(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Instantiate(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Evaluate(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 7d0cfccb37b25d..75ae29064f3101 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -28,6 +28,7 @@
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
+#include "node_process-inl.h"
 #include "node_sea.h"
 #include "node_snapshot_builder.h"
 #include "node_watchdog.h"
@@ -56,6 +57,7 @@ using v8::Maybe;
 using v8::MaybeLocal;
 using v8::MeasureMemoryExecution;
 using v8::MeasureMemoryMode;
+using v8::Message;
 using v8::MicrotaskQueue;
 using v8::MicrotasksPolicy;
 using v8::Name;
@@ -1399,6 +1401,28 @@ constexpr std::array<std::string_view, 3> esm_syntax_error_messages = {
     "Unexpected token 'export'",                     // `export` statements
     "Cannot use 'import.meta' outside a module"};    // `import.meta` references
 
+// TODO(joyeecheung): see if we can upstream an API to V8 for this.
+bool IsESMSyntaxError(Isolate* isolate, Local<Message> error_message) {
+  if (error_message.IsEmpty()) {
+    return false;
+  }
+  Utf8Value message_utf8(isolate, error_message->Get());
+  auto message = message_utf8.ToStringView();
+
+  for (const auto& error_message : esm_syntax_error_messages) {
+    if (message.find(error_message) != std::string_view::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const char* require_esm_warning =
+    "To load an ES module, use --experimental-require-module if you want to"
+    "require() it and it contains no top-level await.\n"
+    "If it's import'ed, set \"type\": \"module\" in the package.json, "
+    "or use the .mjs extension.";
+
 void ContextifyContext::ContainsModuleSyntax(
     const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1473,15 +1497,8 @@ void ContextifyContext::ContainsModuleSyntax(
 
   bool found_error_message_caused_by_module_syntax = false;
   if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
-    Utf8Value message_value(env->isolate(), try_catch.Message()->Get());
-    auto message = message_value.ToStringView();
-
-    for (const auto& error_message : esm_syntax_error_messages) {
-      if (message.find(error_message) != std::string_view::npos) {
-        found_error_message_caused_by_module_syntax = true;
-        break;
-      }
-    }
+    found_error_message_caused_by_module_syntax =
+        IsESMSyntaxError(env->isolate(), try_catch.Message());
   }
   args.GetReturnValue().Set(found_error_message_caused_by_module_syntax);
 }
@@ -1527,8 +1544,6 @@ static void CompileFunctionForCJSLoader(
 #endif
   ScriptCompiler::Source source(code, origin, cached_data);
 
-  TryCatchScope try_catch(env);
-
   // TODO(joyeecheung): make it a per-realm persistent.
   std::vector<Local<String>> params = {
       FIXED_ONE_BYTE_STRING(isolate, "exports"),
@@ -1537,26 +1552,58 @@ static void CompileFunctionForCJSLoader(
       FIXED_ONE_BYTE_STRING(isolate, "__filename"),
       FIXED_ONE_BYTE_STRING(isolate, "__dirname"),
   };
-  MaybeLocal<Function> maybe_fn = ScriptCompiler::CompileFunction(
-      context,
-      &source,
-      params.size(),
-      params.data(),
-      0,       /* context extensions size */
-      nullptr, /* context extensions data */
-      // TODO(joyeecheung): allow optional eager compilation.
-      cached_data == nullptr ? ScriptCompiler::kNoCompileOptions
-                             : ScriptCompiler::kConsumeCodeCache,
-      v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
 
+  bool retry_as_esm = false;
   Local<Function> fn;
-  if (!maybe_fn.ToLocal(&fn)) {
-    if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
-      errors::DecorateErrorStack(env, try_catch);
-      if (!try_catch.HasTerminated()) {
-        try_catch.ReThrow();
+
+  {
+    TryCatchScope try_catch(env);
+    MaybeLocal<Function> maybe_fn;
+    {
+      ShouldNotAbortOnUncaughtScope should_not_abort(env);
+      maybe_fn = ScriptCompiler::CompileFunction(
+          context,
+          &source,
+          params.size(),
+          params.data(),
+          0,       /* context extensions size */
+          nullptr, /* context extensions data */
+          // TODO(joyeecheung): allow optional eager compilation.
+          cached_data == nullptr ? ScriptCompiler::kNoCompileOptions
+                                 : ScriptCompiler::kConsumeCodeCache,
+          v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
+    }
+    if (!maybe_fn.ToLocal(&fn)) {
+      if (try_catch.HasCaught()) {
+        Utf8Value filename_utf8(isolate, filename);
+        size_t flen = filename_utf8.length();
+        if (flen < 4 ||
+            filename_utf8.ToString().substr(flen - 4, flen) == ".cjs") {
+          USE(ProcessEmitWarningSync(env, require_esm_warning));
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        Local<Value> error = try_catch.Exception();
+        Local<Message> message = try_catch.Message();
+        if (!error->IsNativeError() || message.IsEmpty() ||
+            !IsESMSyntaxError(isolate, message)) {
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        if (!env->options()->require_module) {
+          USE(ProcessEmitWarningSync(env, require_esm_warning));
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        // The file being compiled is likely ESM.
+        retry_as_esm = true;
       }
-      return;
     }
   }
 
@@ -1571,11 +1618,14 @@ static void CompileFunctionForCJSLoader(
       env->cached_data_rejected_string(),
       env->source_map_url_string(),
       env->function_string(),
+      FIXED_ONE_BYTE_STRING(isolate, "retryAsESM"),
   };
   std::vector<Local<Value>> values = {
       Boolean::New(isolate, cache_rejected),
-      fn->GetScriptOrigin().SourceMapUrl(),
-      fn,
+      retry_as_esm ? v8::Undefined(isolate).As<Value>()
+                   : fn->GetScriptOrigin().SourceMapUrl(),
+      retry_as_esm ? v8::Undefined(isolate).As<Value>() : fn.As<Value>(),
+      Boolean::New(isolate, retry_as_esm),
   };
   Local<Object> result = Object::New(
       isolate, v8::Null(isolate), names.data(), values.data(), names.size());
diff --git a/src/node_options.cc b/src/node_options.cc
index bf5265967fb1aa..345ff02dc785fb 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -359,6 +359,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "top-level await in the graph",
             &EnvironmentOptions::print_pending_tla,
             kAllowedInEnvvar);
+  AddOption("--experimental-require-module",
+            "Allow loading ES Module in require()",
+            &EnvironmentOptions::require_module,
+            kAllowedInEnvvar);
+
   AddOption("--diagnostic-dir",
             "set dir for all output files"
             " (default: current working directory)",
diff --git a/src/node_options.h b/src/node_options.h
index 97aec1ec8b98d2..608af9eca9dc54 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -106,6 +106,7 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> conditions;
   bool detect_module = false;
   bool print_pending_tla = false;
+  bool require_module = false;
   std::string dns_result_order;
   bool enable_source_maps = false;
   bool experimental_fetch = true;
diff --git a/test/es-module/test-esm-cjs-load-error-note.mjs b/test/es-module/test-esm-cjs-load-error-note.mjs
index 4df9e903eb627a..bfd9bbaacffde3 100644
--- a/test/es-module/test-esm-cjs-load-error-note.mjs
+++ b/test/es-module/test-esm-cjs-load-error-note.mjs
@@ -6,9 +6,9 @@ import { describe, it } from 'node:test';
 
 
 // Expect note to be included in the error output
-const expectedNote = 'To load an ES module, ' +
-'set "type": "module" in the package.json ' +
-'or use the .mjs extension.';
+// Don't match the following sentence because it can change as features are
+// added.
+const expectedNote = 'Warning: To load an ES module';
 
 const mustIncludeMessage = {
   getMessage: () => (stderr) => `${expectedNote} not found in ${stderr}`,
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index 860775df0a2ce8..83125fce738139 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -6,7 +6,7 @@ require('../common');
 const { strictEqual, throws } = require('assert');
 const { createModuleLoader } = require('internal/modules/esm/loader');
 const { LoadCache, ResolveCache } = require('internal/modules/esm/module_map');
-const ModuleJob = require('internal/modules/esm/module_job');
+const { ModuleJob } = require('internal/modules/esm/module_job');
 const createDynamicModule = require(
   'internal/modules/esm/create_dynamic_module');
 
diff --git a/test/es-module/test-require-module-entry-point-aou.js b/test/es-module/test-require-module-entry-point-aou.js
new file mode 100644
index 00000000000000..29ec2478efdc45
--- /dev/null
+++ b/test/es-module/test-require-module-entry-point-aou.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module --abort-on-uncaught-exception
+'use strict';
+
+import { mustCall } from '../common/index.mjs';
+const fn = mustCall(() => {
+  console.log('hello');
+});
+fn();
diff --git a/test/es-module/test-require-module-entry-point.js b/test/es-module/test-require-module-entry-point.js
new file mode 100644
index 00000000000000..408ddf8a11de83
--- /dev/null
+++ b/test/es-module/test-require-module-entry-point.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module
+'use strict';
+
+import { mustCall } from '../common/index.mjs';
+const fn = mustCall(() => {
+  console.log('hello');
+});
+fn();
diff --git a/test/es-module/test-require-module.js b/test/es-module/test-require-module.js
new file mode 100644
index 00000000000000..2c27d59c183779
--- /dev/null
+++ b/test/es-module/test-require-module.js
@@ -0,0 +1,61 @@
+// Flags: --experimental-require-module
+'use strict';
+
+const common = require('../common');  // This is a test too.
+const assert = require('assert');
+const { isModuleNamespaceObject } = require('util/types');
+
+{
+  const mjs = require('../common/index.mjs');
+  // Only comparing a few properties because the ESM version doesn't re-export everything
+  // from the CJS version.
+  assert.strictEqual(common.mustCall, mjs.mustCall);
+  assert(!isModuleNamespaceObject(common));
+  assert(isModuleNamespaceObject(mjs));
+}
+{
+  const mod = require('../fixtures/es-module-loaders/module-named-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, { foo: 'foo', bar: 'bar' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/source-map/esm-basic.mjs');
+  assert.deepStrictEqual({ ...mod }, {});
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/cjs-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, {});
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/loose.js');
+  assert.deepStrictEqual({ ...mod }, { default: 'module' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/package-without-type/noext-esm');
+  assert.deepStrictEqual({ ...mod }, { default: 'module' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+assert.throws(() => {
+  require('../fixtures/es-modules/es-note-unexpected-export-1.cjs');
+}, {
+  message: /Unexpected token 'export'/
+});
+
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/a.mjs');
+}, {
+  message: /require\(\) cannot be used on an ESM graph with top-level await\. Use import\(\) instead\./
+});
+
+// TODO(joyeecheung): test --require
+// TODO(joyeecheung): test import() and import return the same thing
+// TODO(joyeecheung): test "type" field
+// TODO(joyeecheung): test "exports" field