From 5a277318035568a4c63d1072aa0017758505ee98 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.
---
 doc/api/cli.md                                |  17 ++
 lib/internal/modules/cjs/loader.js            |  95 +++++++----
 lib/internal/modules/esm/loader.js            |  44 +++--
 lib/internal/modules/esm/module_job.js        |  73 +++++----
 lib/internal/modules/esm/resolve.js           |  12 +-
 lib/internal/modules/esm/translators.js       |  51 ++----
 lib/internal/util/embedding.js                |   2 +-
 src/module_wrap.cc                            | 151 ++++++++++++++++++
 src/module_wrap.h                             |   2 +
 src/node_contextify.cc                        |  66 ++++++--
 src/node_options.cc                           |   5 +
 src/node_options.h                            |   1 +
 .../test-require-module-entry-point.js        |   8 +
 test/es-module/test-require-module.js         |  37 +++++
 14 files changed, 430 insertions(+), 134 deletions(-)
 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/doc/api/cli.md b/doc/api/cli.md
index 2d7e079b685a30..4dfa65b586473d 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/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index cd36233aa9b790..6aaa409e9979ca 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -60,6 +60,7 @@ const {
   StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
+  Symbol,
 } = primordials;
 
 // Map used to store CJS parsing data.
@@ -107,7 +108,6 @@ const { safeGetenv } = internalBinding('credentials');
 const {
   privateSymbols: {
     require_private_symbol,
-    host_defined_option_symbol,
   },
 } = internalBinding('util');
 const {
@@ -161,6 +161,8 @@ let requireDepth = 0;
 let isPreloading = false;
 let statCache = null;
 
+const is_main_symbol = Symbol('is-main-module');
+
 /**
  * Our internal implementation of `require`.
  * @param {Module} module Parent module of what is being required
@@ -271,6 +273,7 @@ function Module(id = '', parent) {
     setOwnProperty(this.__proto__, 'require', makeRequireFunction(this, redirects));
   }
   this[require_private_symbol] = internalRequire;
+  this[is_main_symbol] = false;  // Set to true by the entry point handler.
 }
 
 /** @type {Record<string, Module>} */
@@ -396,6 +399,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
@@ -1010,6 +1017,7 @@ Module._load = function(request, parent, isMain) {
     setOwnProperty(process, 'mainModule', module);
     setOwnProperty(module.require, 'main', process.mainModule);
     module.id = '.';
+    module[is_main_symbol] = true;
   }
 
   reportModuleToWatchMode(filename);
@@ -1270,37 +1278,48 @@ 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 cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
+  // Note that we are still using the CJS's path resolution here.
+  const parent = moduleParentCache.get(mod)?.filename;
+  const base = parent ? pathToFileURL(parent) : parent;
+  // console.log('loadESMFromCJS', mod, filename, base);
+  const specifier = mod[is_main_symbol] ? pathToFileURL(mod.filename) : mod.id;
+  const job = cascadedLoader.getModuleJobSync(specifier, base, kEmptyObject, 'from-cjs-error');
+  const { namespace } = job.runSync();
+  // TODO(joyeecheung): maybe we can do some special handling for default here. Maybe we don't.
+  mod.exports = namespace;
 }
 
 /**
@@ -1308,8 +1327,9 @@ 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;
@@ -1319,8 +1339,21 @@ Module.prototype._compile = function(content, filename) {
     manifest.assertIntegrity(moduleURL, content);
   }
 
-  const compiledWrapper = wrapSafe(filename, content, this);
+  let compiledWrapper;
+  if (!loadAsESM) {
+    const result = wrapSafe(filename, content, this);
+    compiledWrapper = result.function;
+    loadAsESM = result.retryAsESM;
+  }
+
+  if (loadAsESM) {
+    loadESMFromCJS(this);
+    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,6 +1377,7 @@ Module.prototype._compile = function(content, filename) {
       inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
+
   const dirname = path.dirname(filename);
   const require = makeRequireFunction(this, redirects);
   let result;
@@ -1370,6 +1404,7 @@ Module.prototype._compile = function(content, filename) {
  */
 Module._extensions['.js'] = function(module, filename) {
   // If already analyzed the source, then it will be cached.
+  // TODO(joyeecheung): pass as buffer.
   const cached = cjsParseCache.get(module);
   let content;
   if (cached?.source) {
@@ -1378,7 +1413,8 @@ Module._extensions['.js'] = function(module, filename) {
   } else {
     content = fs.readFileSync(filename, 'utf8');
   }
-  if (StringPrototypeEndsWith(filename, '.js')) {
+  if (!getOptionValue('--experimental-require-module') &&
+      StringPrototypeEndsWith(filename, '.js')) {
     const pkg = packageJsonReader.getNearestParentPackageJSON(filename);
     // Function require shouldn't be used in ES modules.
     if (pkg?.data.type === 'module') {
@@ -1414,7 +1450,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 fd4faa3bd4af62..23161b667e9417 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -15,6 +15,7 @@ const {
   hardenRegExp,
 } = primordials;
 
+const assert = require('internal/assert');
 const {
   ERR_REQUIRE_ESM,
   ERR_UNKNOWN_MODULE_FORMAT,
@@ -228,12 +229,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,7 +245,7 @@ class ModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync);
+      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync, requireESMHint);
     }
 
     return job;
@@ -261,7 +262,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,7 +275,7 @@ 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 inspectBrk = (
@@ -358,11 +359,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 +374,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 +382,7 @@ class ModuleLoader {
       conditions: this.#defaultConditions,
       importAttributes,
       parentURL,
+      requireESMHint,
     };
 
     return defaultResolve(originalSpecifier, context);
@@ -398,14 +403,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 05db7f3867efe2..b4bdd2d902c617 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -64,42 +64,51 @@ class ModuleJob {
     this.module = undefined;
     // Expose the promise to the ModuleWrap directly for linking below.
     // `this.module` is also filled in below.
-    this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+    const moduleWrapMaybePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
 
     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();
+
+      // This promise is awaited later anyway, so silence
+      // 'unhandled rejection' warnings.
+      PromisePrototypeThen(this.linked, undefined, noop);
+    }
 
     // instantiated == deep dependency jobs wrappers are instantiated,
     // and module wrapper is instantiated.
@@ -204,13 +213,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() {
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index bbbaed87479289..053abdffefaad5 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,10 +1154,12 @@ 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
     // resolved CommonJS module
+    // TODO(joyeecheung): not needed for --require-module.
     if (error.code === 'ERR_MODULE_NOT_FOUND' ||
         error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
       if (StringPrototypeStartsWith(specifier, 'file://')) {
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 50a315ae68c02a..84601b28e90895 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -19,12 +19,6 @@ const {
   globalThis: { WebAssembly },
 } = primordials;
 
-const {
-  privateSymbols: {
-    host_defined_option_symbol,
-  },
-} = internalBinding('util');
-
 /** @type {import('internal/util/types')} */
 let _TYPES = null;
 /**
@@ -66,9 +60,6 @@ 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');
 // Lazy-loading to avoid circular dependencies.
 let getSourceSync;
 /**
@@ -84,21 +75,12 @@ 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;
-    }
   }
 }
 
@@ -170,7 +152,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}`);
@@ -218,14 +200,8 @@ function enrichCJSError(err, content, filename) {
  * @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;
-  }
+  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);
@@ -335,18 +311,17 @@ 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();
 
+  // TODO(joyeecheung): remove the unnecessary overhead of the ESM facade.
   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) {
-    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
@@ -531,6 +506,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 58ebe7b837af5f..beda8d527bdba2 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -283,6 +283,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();
@@ -448,6 +514,87 @@ 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 = FormatMessage(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();
@@ -780,6 +927,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);
@@ -831,6 +980,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 e17048357feca2..663c07c39f74b1 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -78,6 +78,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..23cde775095435 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,22 @@ 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;
+}
+
 void ContextifyContext::ContainsModuleSyntax(
     const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1473,15 +1491,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);
 }
@@ -1550,13 +1561,35 @@ static void CompileFunctionForCJSLoader(
       v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
 
   Local<Function> fn;
+  bool retry_as_esm = false;
   if (!maybe_fn.ToLocal(&fn)) {
-    if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
-      errors::DecorateErrorStack(env, try_catch);
-      if (!try_catch.HasTerminated()) {
+    if (try_catch.HasTerminated()) {
+      return;
+    }
+    if (try_catch.HasCaught()) {
+      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;
       }
-      return;
+
+      if (!env->options()->require_module) {
+        if (ProcessEmitWarningSync(env,
+                                   "(To load an ES module, set \"type\": "
+                                   "\"module\" in the package.json "
+                                   "or use the .mjs extension.)")
+                .IsJust()) {
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+        }
+        return;
+      }
+
+      // The file being compiled is likely ESM.
+      retry_as_esm = true;
     }
   }
 
@@ -1571,11 +1604,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-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..1e83e0ea5f8340
--- /dev/null
+++ b/test/es-module/test-require-module.js
@@ -0,0 +1,37 @@
+// 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/loose.js');
+  assert.deepStrictEqual({ ...mod }, { default: 'module' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+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\./
+});