diff --git a/.eslintignore b/.eslintignore
index 64f34660d87a8f..673185b1ad3929 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-detect-entry-point.js
+test/es-module/test-require-module-detect-entry-point-aou.js
diff --git a/doc/api/cli.md b/doc/api/cli.md
index bdae4a7e771391..cbc40a906505d5 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -871,6 +871,39 @@ 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), Node.js throws an error
+without executing the module. If `--print-pending-tla` is passed, Node.js
+will evaluate the module, try to locate the top-level awaits, and print
+their location to help users fix them.
+
+With this option alone, the module being `require()`'d should be explicitly
+marked as an ES module either using the `"type": "module"` field in
+`package.json` or the `.mjs` extension. To load implicit ES modules with
+automatic syntax-based module type detection, use
+`--experimental-require-module-with-detection`.
+
+### `--experimental-require-module-with-detection`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active Developement
+
+In addition to what `--experimental-require-module` supports, when the module
+being `require()`'d is not explicitly marked as an ES Module using the
+`"type": "module"` field in `package.json` or the `.mjs` extension, it will
+try to detect module type based on the syntax of the module.
+
 ### `--experimental-sea-config`
 
 <!-- YAML
@@ -2523,6 +2556,8 @@ Node.js options that are allowed are:
 * `--experimental-network-imports`
 * `--experimental-permission`
 * `--experimental-policy`
+* `--experimental-require-module-with-detection`
+* `--experimental-require-module`
 * `--experimental-shadow-realm`
 * `--experimental-specifier-resolution`
 * `--experimental-top-level-await`
diff --git a/doc/api/errors.md b/doc/api/errors.md
index b0b90b4da87dbf..e8156461767196 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -2487,13 +2487,27 @@ Accessing `Object.prototype.__proto__` has been forbidden using
 [`Object.setPrototypeOf`][] should be used to get and set the prototype of an
 object.
 
+<a id="ERR_REQUIRE_ASYNC_MODULE"></a>
+
+### `ERR_REQUIRE_ASYNC_MODULE`
+
+> Stability: 1 - Experimental
+
+When trying to `require()` a [ES Module][] under `--experimental-require-module`,
+the module turns out to be asynchronous. That is, it contains top-level await.
+To see where the top-level await is, use
+`--print-pending-tla` (this would execute the modules before looking for
+the top-level awaits).
+
 <a id="ERR_REQUIRE_ESM"></a>
 
 ### `ERR_REQUIRE_ESM`
 
 > Stability: 1 - Experimental
 
-An attempt was made to `require()` an [ES Module][].
+An attempt was made to `require()` an [ES Module][]. To enable `require()` for
+synchronous module graphs (without top-level await), use
+`--experimental-require-module`.
 
 <a id="ERR_SCRIPT_EXECUTION_INTERRUPTED"></a>
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ef4295f9eaaaef..01f705bdf92d1a 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,12 +1687,16 @@ E('ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS', '%s', TypeError);
 E('ERR_REQUIRE_ESM',
   function(filename, hasEsmSyntax, parentPath = null, packageJsonPath = null) {
     hideInternalStackFrames(this);
+    assert(!getOptionValue('--experimental-require-module'));
     let msg = `require() of ES Module ${filename}${parentPath ? ` from ${
       parentPath}` : ''} not supported.`;
+    const hint = '\nOr use --experimental-require-module if the module is synchronous ' +
+      '(contains no top-level await)';
     if (!packageJsonPath) {
       if (StringPrototypeEndsWith(filename, '.mjs'))
         msg += `\nInstead change the require of ${filename} to a dynamic ` +
             'import() which is available in all CommonJS modules.';
+      msg += hint;
       return msg;
     }
     const path = require('path');
@@ -1700,6 +1705,7 @@ E('ERR_REQUIRE_ESM',
     if (hasEsmSyntax) {
       msg += `\nInstead change the require of ${basename} in ${parentPath} to` +
         ' a dynamic import() which is available in all CommonJS modules.';
+      msg += hint;
       return msg;
     }
     msg += `\n${basename} is treated as an ES module file as it is a .js ` +
@@ -1710,6 +1716,7 @@ E('ERR_REQUIRE_ESM',
       'modules, or change "type": "module" to "type": "commonjs" in ' +
       `${packageJsonPath} to treat all .js files as CommonJS (using .mjs for ` +
       'all ES modules instead).\n';
+    msg += hint;
     return msg;
   }, Error);
 E('ERR_SCRIPT_EXECUTION_INTERRUPTED',
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 0d76fa0613b7a9..9bf2a042a1f543 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,14 @@ const cjsExportsCache = new SafeWeakMap();
 // Set first due to cycle with ESM loader functions.
 module.exports = {
   cjsExportsCache,
-  cjsParseCache,
+  cjsSourceCache,
   initializeCJS,
   Module,
   wrapSafe,
 };
 
+const is_main_symbol = Symbol('is_main_symbol');
+
 const { BuiltinModule } = require('internal/bootstrap/realm');
 const {
   maybeCacheSourceMap,
@@ -98,7 +101,6 @@ const {
   containsModuleSyntax,
   compileFunctionForCJSLoader,
 } = internalBinding('contextify');
-
 const assert = require('internal/assert');
 const fs = require('fs');
 const path = require('path');
@@ -395,6 +397,11 @@ 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')) {
+    emitExperimentalWarning('Support for loading ES Module in require()');
+    Module._extensions['.mjs'] = loadESMFromCJS;
+  }
 }
 
 // Given a module name, and a list of paths to test, returns the first
@@ -600,6 +607,25 @@ function resolveExports(nmPath, request) {
   }
 }
 
+// We don't cache this in case user extends the extensions.
+function getDefaultExtensions() {
+  const result = [];
+  const extensions = ObjectKeys(Module._extensions);
+  for (let i = 0; i < extensions.length; ++i) {
+    const ext = extensions[i];
+    // If the .mjs extension is added by --experimental-require-module,
+    // remove it from the supported default extensions to maintain
+    // compatibility.
+    // TODO(joyeecheung): perhaps we should just support both .cjs
+    // and .mjs as default extensions?
+    if (ext === '.mjs' && Module._extensions['.mjs'] === loadESMFromCJS) {
+      continue;
+    }
+    result.push(ext);
+  }
+  return result;
+}
+
 /**
  * Get the absolute path to a module.
  * @param {string} request Relative or absolute file path
@@ -701,7 +727,7 @@ Module._findPath = function(request, paths, isMain) {
       if (!filename) {
         // Try it with each of the extensions
         if (exts === undefined) {
-          exts = ObjectKeys(Module._extensions);
+          exts = getDefaultExtensions();
         }
         filename = tryExtensions(basePath, exts, isMain);
       }
@@ -710,7 +736,7 @@ Module._findPath = function(request, paths, isMain) {
     if (!filename && rc === 1) {  // Directory.
       // try it with each of the extensions at "index"
       if (exts === undefined) {
-        exts = ObjectKeys(Module._extensions);
+        exts = getDefaultExtensions();
       }
       filename = tryPackage(basePath, exts, isMain, request);
     }
@@ -987,7 +1013,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);
       }
@@ -1009,6 +1035,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);
@@ -1269,36 +1298,42 @@ 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);
+  const result = compileFunctionForCJSLoader(content, filename);
+  // cachedDataRejected is only set for cache coming from SEA.
+  if (codeCache &&
+      result.cachedDataRejected !== false &&
+      internalBinding('sea').isSea()) {
+    process.emitWarning('Code cache data rejected.');
+  }
 
-    // cachedDataRejected is only set for cache coming from SEA.
-    if (codeCache &&
-        result.cachedDataRejected !== false &&
-        internalBinding('sea').isSea()) {
-      process.emitWarning('Code cache data rejected.');
-    }
+  // Cache the source map for the module if present.
+  if (result.sourceMapURL) {
+    maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
+  }
 
-    // Cache the source map for the module if present.
-    if (result.sourceMapURL) {
-      maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
-    }
+  return result;
+}
 
-    return result.function;
-  } catch (err) {
-    if (process.mainModule === cjsModuleInstance) {
-      const { enrichCJSError } = require('internal/modules/esm/translators');
-      enrichCJSError(err, content, filename);
-    }
-    throw err;
-  }
+// Resolve and evaluate as ESM, synchronously.
+function loadESMFromCJS(mod, filename) {
+  const source = getMaybeCachedSource(mod, filename);
+  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
+  const isMain = mod[is_main_symbol];
+  // TODO(joyeecheung): we may want to invent optional special handling for default exports here.
+  mod.exports = cascadedLoader.importSyncForRequire(filename, source, isMain);
 }
 
 /**
@@ -1306,8 +1341,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;
@@ -1317,8 +1353,27 @@ Module.prototype._compile = function(content, filename) {
     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;
+    // If C++ land confirms it looks like ESM and we should retry here (because fallback
+    // detection is enabled), retry.
+    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. Using the
+  // is_main_symbol, or a break_on_start_symbol that gets passed from
+  // higher level instead of doing hacky detection here.
   let inspectorWrapper = null;
   if (getOptionValue('--inspect-brk') && process._eval == null) {
     if (!resolvedArgv) {
@@ -1342,6 +1397,7 @@ Module.prototype._compile = function(content, filename) {
       inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
+
   const dirname = path.dirname(filename);
   const require = makeRequireFunction(this, redirects);
   let result;
@@ -1361,25 +1417,38 @@ 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): we can read a buffer instead to speed up
+    // compilation.
     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;
@@ -1412,7 +1481,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..1d76505fbc6863 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 { isURL, pathToFileURL } = require('internal/url');
+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);
@@ -250,6 +256,110 @@ class ModuleLoader {
     return job;
   }
 
+  /**
+   * Resolve individual module requests and create or get the cached ModuleWraps for
+   * each of them. This is only used to create a module graph being require()'d.
+   * @param {string} specifier Specifier of the the imported module.
+   * @param {string} parentURL Where the import comes from.
+   * @param {object} importAttributes import attributes from the import statement.
+   * @returns {ModuleWrap}
+   */
+  getModuleWrapForRequire(specifier, parentURL, importAttributes) {
+    assert(getOptionValue('--experimental-require-module'));
+
+    const requestKey = this.#resolveCache.serializeKey(specifier, importAttributes);
+    let resolveResult = this.#resolveCache.get(requestKey, parentURL);
+    if (resolveResult == null) {
+      resolveResult = this.defaultResolve(specifier, parentURL, importAttributes);
+      this.#resolveCache.set(requestKey, parentURL, resolveResult);
+    }
+
+    const { url, format } = resolveResult;
+    const resolvedImportAttributes = resolveResult.importAttributes ?? importAttributes;
+    let job = this.loadCache.get(url, resolvedImportAttributes.type);
+
+    if (job !== undefined) {
+      // This module is previously imported before. We will return the module now and check
+      // asynchronicity of the entire graph later, after the graph is instantiated.
+      return job.module;
+    }
+
+    defaultLoadSync ??= require('internal/modules/esm/load').defaultLoadSync;
+    const loadResult = defaultLoadSync(url, { format, importAttributes });
+    const { responseURL, source } = loadResult;
+    let { format: finalFormat } = loadResult;
+    this.validateLoadResult(url, finalFormat);
+    if (finalFormat === 'commonjs') {
+      finalFormat = 'commonjs-sync';
+    } else if (finalFormat === 'wasm') {
+      assert.fail('WASM is currently unsupported by require(esm)');
+    }
+
+    const translator = getTranslators().get(finalFormat);
+    if (!translator) {
+      throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+    }
+
+    const isMain = (parentURL === undefined);
+    const wrap = FunctionPrototypeCall(translator, this, responseURL, source, isMain);
+    assert(wrap instanceof ModuleWrap);  // No asynchronous translators should be called.
+
+    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
+      process.send({ 'watch:import': [url] });
+    }
+
+    const inspectBrk = (isMain && getOptionValue('--inspect-brk'));
+    const { ModuleJobSync } = require('internal/modules/esm/module_job');
+    job = new ModuleJobSync(this, url, importAttributes, wrap, isMain, inspectBrk);
+
+    this.loadCache.set(url, importAttributes.type, job);
+    return job.module;
+  }
+
+  /**
+   * This constructs (creates, instantiates and evaluates) a module graph that
+   * is require()'d.
+   * @param {string} filename Resolved filename of the module being require()'d
+   * @param {string} source Source code. TODO(joyeecheung): pass the raw buffer.
+   * @param {string} isMain Whether this module is a main module.
+   * @returns {ModuleNamespaceObject}
+   */
+  importSyncForRequire(filename, source, isMain) {
+    const url = pathToFileURL(filename).href;
+    let job = this.loadCache.get(url, kImplicitAssertType);
+    // This module is already loaded, check whether it's synchronous and return the
+    // namespace.
+    if (job !== undefined) {
+      return job.module.getNamespaceSync();
+    }
+
+    // TODO(joyeecheung): refactor this so that we pre-parse in C++ and hit the
+    // cache here, or use a carrier object to carry the compiled module script
+    // into the constructor to ensure cache hit.
+    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');
+    // TODO(joyeecheung): refactor so that the default options are shared across
+    // the built-in loaders.
+    registerModule(wrap, {
+      __proto__: null,
+      initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
+      importModuleDynamically: (specifier, wrap, importAttributes) => {
+        return this.import(specifier, url, importAttributes);
+      },
+    });
+
+    const inspectBrk = (isMain && getOptionValue('--inspect-brk'));
+
+    const { ModuleJobSync } = require('internal/modules/esm/module_job');
+    job = new ModuleJobSync(this, url, kEmptyObject, wrap, isMain, inspectBrk);
+    this.loadCache.set(url, kImplicitAssertType, job);
+    return job.runSync().namespace;
+  }
+
   /**
    * Create and cache an object representing a loaded module.
    * @param {string} url The absolute URL that was resolved for this module
@@ -277,8 +387,9 @@ class ModuleLoader {
       (url, isMain) => callTranslator(this.loadSync(url, context), 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 +397,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,
     );
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 108a8138443de0..e53198df08b1c0 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,24 +52,29 @@ 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;
+  }
+}
 
-    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.
+  constructor(loader, url, importAttributes = { __proto__: null },
+              moduleProvider, isMain, inspectBrk, sync = false) {
+    const modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+    super(loader, url, importAttributes, modulePromise, isMain, inspectBrk);
     // Expose the promise to the ModuleWrap directly for linking below.
     // `this.module` is also filled in below.
-    this.modulePromise = ReflectApply(moduleProvider, loader, [url, isMain]);
+    this.modulePromise = modulePromise;
 
     if (sync) {
       this.module = this.modulePromise;
@@ -255,5 +260,37 @@ 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.
+// All the steps are ensured to be synchronous and it throws on instantiating
+// an asynchronous graph.
+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 moduleRequests = this.module.getModuleRequestsSync();
+    for (let i = 0; i < moduleRequests.length; ++i) {
+      const { 0: specifier, 1: attributes } = moduleRequests[i];
+      const wrap = this.loader.getModuleWrapForRequire(specifier, url, attributes);
+      const isLast = i === moduleRequests.length - 1;
+      this.module.cacheResolvedWrapsSync(specifier, PromiseResolve(wrap), isLast);
+    }
+  }
+
+  async run() {
+    assert.fail('ModuleJobSync cannot be run asynchronously');
+  }
+
+  runSync() {
+    assert(this.module instanceof ModuleWrap);
+    this.module.instantiateSync();
+    setHasStartedUserESMExecution();
+    const namespace = this.module.evaluateSync();
+    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/translators.js b/lib/internal/modules/esm/translators.js
index 6772bbffd989d2..4395152056d82f 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,7 +14,6 @@ const {
   StringPrototypeReplaceAll,
   StringPrototypeSlice,
   StringPrototypeStartsWith,
-  SyntaxErrorPrototype,
   globalThis: { WebAssembly },
 } = primordials;
 
@@ -30,7 +28,6 @@ function lazyTypes() {
 }
 
 const {
-  containsModuleSyntax,
   compileFunctionForCJSLoader,
 } = internalBinding('contextify');
 
@@ -44,7 +41,7 @@ const {
 } = require('internal/modules/helpers');
 const {
   Module: CJSModule,
-  cjsParseCache,
+  cjsSourceCache,
   cjsExportsCache,
 } = require('internal/modules/cjs/loader');
 const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
@@ -59,7 +56,6 @@ const {
 const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
 const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
-const { emitWarningSync } = require('internal/process/warning');
 
 // Lazy-loading to avoid circular dependencies.
 let getSourceSync;
@@ -81,7 +77,7 @@ let cjsParse;
  */
 async function initCJSParse() {
   if (typeof WebAssembly === 'undefined') {
-    cjsParse = require('internal/deps/cjs-module-lexer/lexer').parse;
+    initCJSParseSync();
   } else {
     const { parse, init } =
         require('internal/deps/cjs-module-lexer/dist/lexer');
@@ -89,14 +85,21 @@ async function initCJSParse() {
       await init();
       cjsParse = parse;
     } catch {
-      cjsParse = require('internal/deps/cjs-module-lexer/lexer').parse;
+      initCJSParseSync();
     }
   }
 }
 
+function initCJSParseSync() {
+  // 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;
+  }
+}
+
 const translators = new SafeMap();
 exports.translators = translators;
-exports.enrichCJSError = enrichCJSError;
 
 let DECODER = null;
 /**
@@ -162,7 +165,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}`);
@@ -180,25 +183,6 @@ 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.
@@ -210,13 +194,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);
-  } 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);
@@ -323,6 +302,16 @@ function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
 
 }
 
+translators.set('commonjs-sync', function importCommonJS(url, source, isMain) {
+  initCJSParseSync();
+  assert(!isMain);  // This is only used by imported CJS modules.
+
+  return createCJSModuleWrap(url, source, isMain, (module, source, url, filename) => {
+    assert(module === CJSModule._cache[filename]);
+    CJSModule._load(filename, null, false);
+  });
+});
+
 // Handle CommonJS modules referenced by `require` calls.
 // This translator function must be sync, as `require` is sync.
 translators.set('require-commonjs', (url, source, isMain) => {
@@ -343,13 +332,8 @@ translators.set('commonjs', async function commonjsStrategy(url, source,
   // 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;
-    }
+    assert(module === CJSModule._cache[filename]);
+    CJSModule._load(filename);
   } : loadCJSModule;
 
   try {
@@ -371,7 +355,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 };
     }
@@ -395,7 +379,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;
@@ -522,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 25eb79d450c807..a4e8c87506ce2c 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -321,6 +321,61 @@ static Local<Object> createImportAttributesContainer(
   return attributes;
 }
 
+void ModuleWrap::GetModuleRequestsSync(
+    const FunctionCallbackInfo<Value>& args) {
+  Realm* realm = Realm::GetCurrent(args);
+  Isolate* isolate = args.GetIsolate();
+
+  Local<Object> that = args.This();
+
+  ModuleWrap* obj;
+  ASSIGN_OR_RETURN_UNWRAP(&obj, that);
+
+  CHECK(!obj->linked_);
+
+  Local<Module> module = obj->module_.Get(isolate);
+  Local<FixedArray> module_requests = module->GetModuleRequests();
+  const int module_requests_length = module_requests->Length();
+
+  std::vector<Local<Value>> requests;
+  requests.reserve(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<FixedArray> raw_attributes = module_request->GetImportAssertions();
+    std::vector<Local<Value>> request = {
+        module_request->GetSpecifier(),
+        createImportAttributesContainer(realm, isolate, raw_attributes, 3),
+    };
+    requests.push_back(Array::New(isolate, request.data(), request.size()));
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(isolate, requests.data(), requests.size()));
+}
+
+void ModuleWrap::CacheResolvedWrapsSync(
+    const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+
+  CHECK_EQ(args.Length(), 3);
+  CHECK(args[0]->IsString());
+  CHECK(args[1]->IsPromise());
+  CHECK(args[2]->IsBoolean());
+
+  ModuleWrap* dependent;
+  ASSIGN_OR_RETURN_UNWRAP(&dependent, args.This());
+
+  Utf8Value specifier(isolate, args[0]);
+  dependent->resolve_cache_[specifier.ToString()].Reset(isolate,
+                                                        args[1].As<Promise>());
+
+  if (args[1].As<v8::Boolean>()->Value()) {
+    dependent->linked_ = true;
+  }
+}
+
 void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -486,6 +541,125 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result.ToLocalChecked());
 }
 
+void ModuleWrap::InstantiateSync(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) {
+    THROW_ERR_REQUIRE_ASYNC_MODULE(env);
+    return;
+  }
+}
+
+void ModuleWrap::EvaluateSync(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();
+
+  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);
+      }
+    }
+    THROW_ERR_REQUIRE_ASYNC_MODULE(env);
+    return;
+  }
+
+  CHECK_EQ(promise->State(), Promise::PromiseState::kFulfilled);
+
+  args.GetReturnValue().Set(module->GetModuleNamespace());
+}
+
+void ModuleWrap::GetNamespaceSync(const FunctionCallbackInfo<Value>& args) {
+  Realm* realm = Realm::GetCurrent(args);
+  Isolate* isolate = args.GetIsolate();
+  ModuleWrap* obj;
+  ASSIGN_OR_RETURN_UNWRAP(&obj, args.This());
+  Local<Module> module = obj->module_.Get(isolate);
+
+  switch (module->GetStatus()) {
+    case v8::Module::Status::kUninstantiated:
+    case v8::Module::Status::kInstantiating:
+      return realm->env()->ThrowError(
+          "cannot get namespace, module has not been instantiated");
+    case v8::Module::Status::kEvaluating:
+      return realm->env()->ThrowError(
+          "Asynchronous module is not allowed in require(esm)");
+    case v8::Module::Status::kInstantiated:
+    case v8::Module::Status::kEvaluated:
+    case v8::Module::Status::kErrored:
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  if (module->IsGraphAsync()) {
+    return realm->env()->ThrowError(
+        "Asynchronous module is not allowed in require(esm)");
+  }
+  Local<Value> result = module->GetModuleNamespace();
+  args.GetReturnValue().Set(result);
+}
+
 void ModuleWrap::GetNamespace(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -818,6 +992,12 @@ void ModuleWrap::CreatePerIsolateProperties(IsolateData* isolate_data,
       ModuleWrap::kInternalFieldCount);
 
   SetProtoMethod(isolate, tpl, "link", Link);
+  SetProtoMethod(isolate, tpl, "getModuleRequestsSync", GetModuleRequestsSync);
+  SetProtoMethod(
+      isolate, tpl, "cacheResolvedWrapsSync", CacheResolvedWrapsSync);
+  SetProtoMethod(isolate, tpl, "instantiateSync", InstantiateSync);
+  SetProtoMethod(isolate, tpl, "evaluateSync", EvaluateSync);
+  SetProtoMethod(isolate, tpl, "getNamespaceSync", GetNamespaceSync);
   SetProtoMethod(isolate, tpl, "instantiate", Instantiate);
   SetProtoMethod(isolate, tpl, "evaluate", Evaluate);
   SetProtoMethod(isolate, tpl, "setExport", SetSyntheticExport);
@@ -869,6 +1049,11 @@ void ModuleWrap::RegisterExternalReferences(
   registry->Register(New);
 
   registry->Register(Link);
+  registry->Register(GetModuleRequestsSync);
+  registry->Register(CacheResolvedWrapsSync);
+  registry->Register(InstantiateSync);
+  registry->Register(EvaluateSync);
+  registry->Register(GetNamespaceSync);
   registry->Register(Instantiate);
   registry->Register(Evaluate);
   registry->Register(SetSyntheticExport);
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 6f44d722ee0b01..7c40ef08ea00f8 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -79,6 +79,14 @@ class ModuleWrap : public BaseObject {
   ~ModuleWrap() override;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetModuleRequestsSync(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CacheResolvedWrapsSync(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InstantiateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EvaluateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNamespaceSync(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 f39b4ec4c372a3..558f90c58e9fa3 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;
@@ -1409,6 +1411,24 @@ 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 FindMessage(Isolate* isolate,
+                 Local<Message> error_message,
+                 const std::array<std::string_view, 3>& allow_list) {
+  if (error_message.IsEmpty()) {
+    return false;
+  }
+  Utf8Value message_utf8(isolate, error_message->Get());
+  auto message = message_utf8.ToStringView();
+
+  for (const auto& error_message : allow_list) {
+    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);
@@ -1478,25 +1498,34 @@ 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 = FindMessage(
+        env->isolate(), try_catch.Message(), esm_syntax_error_messages);
   }
   args.GetReturnValue().Set(found_error_message_caused_by_module_syntax);
 }
 
+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.";
+
+const char* require_esm_warning_without_detection =
+    "The module being require()d looks like an ES module, but it is not "
+    "explicitly marked with \"type\": \"module\" in the package.json or "
+    "with a .mjs extention. To enable automatic detection of module syntax "
+    "in require(), use --experimental-require-module-with-detection.";
+
+static bool warned_about_require_esm = false;
+static bool warned_about_require_esm_detection = false;
 static void CompileFunctionForCJSLoader(
     const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsString());
   CHECK(args[1]->IsString());
+
   Local<String> code = args[0].As<String>();
   Local<String> filename = args[1].As<String>();
+
   Isolate* isolate = args.GetIsolate();
   Local<Context> context = isolate->GetCurrentContext();
   Environment* env = Environment::GetCurrent(context);
@@ -1532,33 +1561,82 @@ 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 = GetCJSParameters(env->isolate_data());
 
-  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() ||
+            !FindMessage(isolate, message, esm_syntax_error_messages)) {
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        if (!env->options()->require_module) {
+          if (!warned_about_require_esm) {
+            USE(ProcessEmitWarningSync(env, require_esm_warning));
+            warned_about_require_esm = true;
+          }
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        if (!env->options()->require_module_with_detection) {
+          if (!warned_about_require_esm_detection) {
+            USE(ProcessEmitWarningSync(env,
+                                       require_esm_warning_without_detection));
+            warned_about_require_esm_detection = true;
+          }
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        // The file being compiled is likely ESM.
+        retry_as_esm = true;
       }
-      return;
     }
   }
 
+  // TODO(joyeecheung): refactor the ESM compilation so that we can reparse
+  // as ESM here to confirm it's ESM, and pass the compiled module into the
+  // ModuleWrap to save the subsequent compilation.
+
   bool cache_rejected = false;
 #ifndef DISABLE_SINGLE_EXECUTABLE_APPLICATION
   if (used_cache_from_sea) {
@@ -1570,11 +1648,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_errors.h b/src/node_errors.h
index 3a083cdbb706be..8e664921cbd800 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -92,6 +92,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_MODULE_NOT_FOUND, Error)                                               \
   V(ERR_NON_CONTEXT_AWARE_DISABLED, Error)                                     \
   V(ERR_OUT_OF_RANGE, RangeError)                                              \
+  V(ERR_REQUIRE_ASYNC_MODULE, Error)                                           \
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED, Error)                                   \
   V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                       \
   V(ERR_STRING_TOO_LONG, Error)                                                \
@@ -188,6 +189,10 @@ ERRORS_WITH_CODE(V)
     "creating Workers")                                                        \
   V(ERR_NON_CONTEXT_AWARE_DISABLED,                                            \
     "Loading non context-aware native addons has been disabled")               \
+  V(ERR_REQUIRE_ASYNC_MODULE,                                                  \
+    "require() cannot be used on an ESM graph with top-level await. Use "      \
+    "import() instead. To see where the top-level await comes from, use "      \
+    "--print-pending-tla.")                                                    \
   V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
     "Script execution was interrupted by `SIGINT`")                            \
   V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, "Failed to set PSK identity hint")    \
diff --git a/src/node_options.cc b/src/node_options.cc
index bf5265967fb1aa..5976f533def934 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -359,6 +359,18 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "top-level await in the graph",
             &EnvironmentOptions::print_pending_tla,
             kAllowedInEnvvar);
+  AddOption("--experimental-require-module",
+            "Allow loading explicit ES Modules in require().",
+            &EnvironmentOptions::require_module,
+            kAllowedInEnvvar);
+  AddOption("--experimental-require-module-with-detection",
+            "Allow loading ES Modules with syntax-based detection of module "
+            "types for implicit ES modules in require().",
+            &EnvironmentOptions::require_module_with_detection,
+            kAllowedInEnvvar);
+  Implies("--experimental-require-module-with-detection",
+          "--experimental-require-module");
+
   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..76da3446aef09e 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -106,6 +106,8 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> conditions;
   bool detect_module = false;
   bool print_pending_tla = false;
+  bool require_module = false;
+  bool require_module_with_detection = 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..00ff5582c71bda 100644
--- a/test/es-module/test-esm-cjs-load-error-note.mjs
+++ b/test/es-module/test-esm-cjs-load-error-note.mjs
@@ -6,16 +6,16 @@ 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}`,
+  getMessage: (stderr) => `${expectedNote} not found in ${stderr}`,
   includeNote: true,
 };
 const mustNotIncludeMessage = {
-  getMessage: () => (stderr) => `${expectedNote} must not be included in ${stderr}`,
+  getMessage: (stderr) => `${expectedNote} must not be included in ${stderr}`,
   includeNote: false,
 };
 
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-default-extension.js b/test/es-module/test-require-module-default-extension.js
new file mode 100644
index 00000000000000..e7d035d64574a2
--- /dev/null
+++ b/test/es-module/test-require-module-default-extension.js
@@ -0,0 +1,17 @@
+// Flags: --experimental-require-module
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { isModuleNamespaceObject } = require('util/types');
+
+const mod = require('../fixtures/es-modules/package-default-extension/index.mjs');
+assert.deepStrictEqual({ ...mod }, { entry: 'mjs' });
+assert(isModuleNamespaceObject(mod));
+
+assert.throws(() => {
+  const mod = require('../fixtures/es-modules/package-default-extension');
+  console.log(mod);  // In case it succeeds, log the result for debugging.
+}, {
+  message: /Cannot find module.*package-default-extension/
+});
diff --git a/test/es-module/test-require-module-detect-entry-point-aou.js b/test/es-module/test-require-module-detect-entry-point-aou.js
new file mode 100644
index 00000000000000..db300a16c3f740
--- /dev/null
+++ b/test/es-module/test-require-module-detect-entry-point-aou.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module-with-detection --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-detect-entry-point.js b/test/es-module/test-require-module-detect-entry-point.js
new file mode 100644
index 00000000000000..b2aab04fc91558
--- /dev/null
+++ b/test/es-module/test-require-module-detect-entry-point.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module-with-detection
+'use strict';
+
+import { mustCall } from '../common/index.mjs';
+const fn = mustCall(() => {
+  console.log('hello');
+});
+fn();
diff --git a/test/es-module/test-require-module-dont-detect-cjs.js b/test/es-module/test-require-module-dont-detect-cjs.js
new file mode 100644
index 00000000000000..1e6da03a3ba5b6
--- /dev/null
+++ b/test/es-module/test-require-module-dont-detect-cjs.js
@@ -0,0 +1,11 @@
+// Flags: --experimental-require-module-with-detection
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+assert.throws(() => {
+  require('../fixtures/es-modules/es-note-unexpected-export-1.cjs');
+}, {
+  message: /Unexpected token 'export'/
+});
diff --git a/test/es-module/test-require-module-dynamic-import.js b/test/es-module/test-require-module-dynamic-import.js
new file mode 100644
index 00000000000000..1b1830f07ca0da
--- /dev/null
+++ b/test/es-module/test-require-module-dynamic-import.js
@@ -0,0 +1,27 @@
+// Flags: --experimental-require-module
+'use strict';
+
+// Tests that dynamically import()'ed results are reference equal to
+// require()'d results.
+const common = require('../common');
+const assert = require('assert');
+const { pathToFileURL } = require('url');
+const path = require('path');
+
+(async () => {
+  const modules = [
+    '../fixtures/es-module-loaders/module-named-exports.mjs',
+    '../fixtures/es-modules/import-esm.mjs',
+    '../fixtures/es-modules/require-cjs.mjs',
+    '../fixtures/es-modules/cjs-exports.mjs',
+    '../common/index.mjs',
+    '../fixtures/es-modules/package-type-module/index.js',
+  ];
+  for (const id of modules) {
+    const url = pathToFileURL(path.resolve(__dirname, id));
+    const imported = await import(url);
+    const required = require(id);
+    assert.strictEqual(imported, required,
+                       `import()'ed and require()'ed result of ${id} was not reference equal`);
+  }
+})().then(common.mustCall());
diff --git a/test/es-module/test-require-module-preload.js b/test/es-module/test-require-module-preload.js
new file mode 100644
index 00000000000000..5909f3a39c22a2
--- /dev/null
+++ b/test/es-module/test-require-module-preload.js
@@ -0,0 +1,74 @@
+'use strict';
+
+require('../common');
+const { spawnSyncAndExitWithoutError } = require('../common/child_process');
+const fixtures = require('../common/fixtures');
+
+const stderr = /ExperimentalWarning: Support for loading ES Module in require/;
+
+// Test named exports.
+{
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    [ '--experimental-require-module', '-r', fixtures.path('../fixtures/es-module-loaders/module-named-exports.mjs') ],
+    {
+      stderr,
+    }
+  );
+}
+
+// Test ESM that import ESM.
+{
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    [ '--experimental-require-module', '-r', fixtures.path('../fixtures/es-modules/import-esm.mjs') ],
+    {
+      stderr,
+      stdout: 'world',
+      trim: true,
+    }
+  );
+}
+
+// Test ESM that import CJS.
+{
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    [ '--experimental-require-module', '-r', fixtures.path('../fixtures/es-modules/cjs-exports.mjs') ],
+    {
+      stdout: 'ok',
+      stderr,
+      trim: true,
+    }
+  );
+}
+
+// Test ESM that require() CJS.
+// Can't use the common/index.mjs here because that checks the globals, and
+// -r injects a bunch of globals.
+{
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    [ '--experimental-require-module', '-r', fixtures.path('../fixtures/es-modules/require-cjs.mjs') ],
+    {
+      stdout: 'world',
+      stderr,
+      trim: true,
+    }
+  );
+}
+
+// Test "type": "module" and "main" field in package.json.
+{
+  spawnSyncAndExitWithoutError(
+    process.execPath,
+    [ '--experimental-require-module', '-r', fixtures.path('../fixtures/es-modules/package-type-module') ],
+    {
+      stdout: 'package-type-module',
+      stderr,
+      trim: true,
+    }
+  );
+}
+
+// TODO(joyeecheung): test "exports" field
diff --git a/test/es-module/test-require-module-tla.js b/test/es-module/test-require-module-tla.js
new file mode 100644
index 00000000000000..00f02d539d24c1
--- /dev/null
+++ b/test/es-module/test-require-module-tla.js
@@ -0,0 +1,62 @@
+// Flags: --experimental-require-module
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { spawnSyncAndExit } = require('../common/child_process');
+const fixtures = require('../common/fixtures');
+
+const message = /require\(\) cannot be used on an ESM graph with top-level await/;
+// TODO(joyeecheung): assign a code for this error.
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/rejected.mjs');
+}, { message });
+
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/unresolved.mjs');
+}, { message });
+
+
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/resolved.mjs');
+}, { message });
+
+// Test TLA in inner graphs.
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/parent.mjs');
+}, { message });
+
+{
+  spawnSyncAndExit(process.execPath, [
+    '--experimental-require-module',
+    fixtures.path('es-modules/tla/require-execution.js'),
+  ], {
+    signal: null,
+    status: 1,
+    stderr(output) {
+      assert.doesNotMatch(output, /I am executed/);
+      assert.match(output, message);
+      return true;
+    },
+    stdout: ''
+  });
+}
+
+{
+  spawnSyncAndExit(process.execPath, [
+    '--experimental-require-module',
+    '--print-pending-tla',
+    fixtures.path('es-modules/tla/require-execution.js'),
+  ], {
+    signal: null,
+    status: 1,
+    stderr(output) {
+      assert.match(output, /I am executed/);
+      assert.match(output, /Error: unexpected top-level await at.*execution\.mjs:3/);
+      assert.match(output, /await Promise\.resolve\('hi'\)/);
+      assert.match(output, message);
+      return true;
+    },
+    stdout: ''
+  });
+}
diff --git a/test/es-module/test-require-module-with-detection.js b/test/es-module/test-require-module-with-detection.js
new file mode 100644
index 00000000000000..05c8bff4372161
--- /dev/null
+++ b/test/es-module/test-require-module-with-detection.js
@@ -0,0 +1,18 @@
+// Flags: --experimental-require-module-with-detection
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { isModuleNamespaceObject } = require('util/types');
+
+{
+  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));
+}
diff --git a/test/es-module/test-require-module-without-detection.js b/test/es-module/test-require-module-without-detection.js
new file mode 100644
index 00000000000000..4eb037d49ec790
--- /dev/null
+++ b/test/es-module/test-require-module-without-detection.js
@@ -0,0 +1,33 @@
+// Flags: --experimental-require-module
+'use strict';
+
+// Tests that without --experimental-require-module-with-detection, detection
+// doesn't happen.
+const common = require('../common');
+const assert = require('assert');
+
+common.expectWarning(
+  'Warning',
+  'The module being require()d looks like an ES module, but it is not ' +
+  'explicitly marked with "type": "module" in the package.json or with ' +
+  'a .mjs extention. To enable automatic detection of module syntax in ' +
+  'require(), use --experimental-require-module-with-detection.'
+);
+
+common.expectWarning(
+  'ExperimentalWarning',
+  'Support for loading ES Module in require() is an experimental feature ' +
+  'and might change at any time'
+);
+
+assert.throws(() => {
+  require('../fixtures/es-modules/package-without-type/noext-esm');
+}, {
+  message: /Unexpected token 'export'/
+});
+
+assert.throws(() => {
+  require('../fixtures/es-modules/loose.js');
+}, {
+  message: /Unexpected token 'export'/
+});
diff --git a/test/es-module/test-require-module.js b/test/es-module/test-require-module.js
new file mode 100644
index 00000000000000..42eea40d5ef5a1
--- /dev/null
+++ b/test/es-module/test-require-module.js
@@ -0,0 +1,52 @@
+// Flags: --experimental-require-module
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { isModuleNamespaceObject } = require('util/types');
+
+common.expectWarning(
+  'ExperimentalWarning',
+  'Support for loading ES Module in require() is an experimental feature ' +
+  'and might change at any time'
+);
+
+// Test named exports.
+{
+  const mod = require('../fixtures/es-module-loaders/module-named-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, { foo: 'foo', bar: 'bar' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+// Test ESM that import ESM.
+{
+  const mod = require('../fixtures/es-modules/import-esm.mjs');
+  assert.deepStrictEqual({ ...mod }, { hello: 'world' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+// Test ESM that import CJS.
+{
+  const mod = require('../fixtures/es-modules/cjs-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, {});
+  assert(isModuleNamespaceObject(mod));
+}
+
+// Test ESM that require() CJS.
+{
+  const mjs = require('../common/index.mjs');
+  // Only comparing a few properties because the ESM version of test/common doesn't
+  // re-export everything from the CJS version.
+  assert.strictEqual(common.mustCall, mjs.mustCall);
+  assert.strictEqual(common.localIPv6Hosts, mjs.localIPv6Hosts);
+  assert(!isModuleNamespaceObject(common));
+  assert(isModuleNamespaceObject(mjs));
+}
+
+// Test "type": "module" and "main" field in package.json.
+// Also, test default export.
+{
+  const mod = require('../fixtures/es-modules/package-type-module');
+  assert.deepStrictEqual({ ...mod }, { default: 'package-type-module' });
+  assert(isModuleNamespaceObject(mod));
+}
diff --git a/test/fixtures/es-modules/import-esm.mjs b/test/fixtures/es-modules/import-esm.mjs
new file mode 100644
index 00000000000000..d8c0d983dda3d2
--- /dev/null
+++ b/test/fixtures/es-modules/import-esm.mjs
@@ -0,0 +1,3 @@
+import { hello } from './imported-esm.mjs';
+console.log(hello);
+export { hello };
diff --git a/test/fixtures/es-modules/imported-esm.mjs b/test/fixtures/es-modules/imported-esm.mjs
new file mode 100644
index 00000000000000..35f468bf4856d8
--- /dev/null
+++ b/test/fixtures/es-modules/imported-esm.mjs
@@ -0,0 +1 @@
+export const hello = 'world';
diff --git a/test/fixtures/es-modules/package-default-extension/index.cjs b/test/fixtures/es-modules/package-default-extension/index.cjs
new file mode 100644
index 00000000000000..2172e60d945349
--- /dev/null
+++ b/test/fixtures/es-modules/package-default-extension/index.cjs
@@ -0,0 +1 @@
+module.exports = { entry: 'cjs' };
\ No newline at end of file
diff --git a/test/fixtures/es-modules/package-default-extension/index.mjs b/test/fixtures/es-modules/package-default-extension/index.mjs
new file mode 100644
index 00000000000000..aac4141efdb58a
--- /dev/null
+++ b/test/fixtures/es-modules/package-default-extension/index.mjs
@@ -0,0 +1 @@
+export const entry = 'mjs';
diff --git a/test/fixtures/es-modules/require-cjs.mjs b/test/fixtures/es-modules/require-cjs.mjs
new file mode 100644
index 00000000000000..a79a9b004c2237
--- /dev/null
+++ b/test/fixtures/es-modules/require-cjs.mjs
@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const exports = require('./required-cjs');
+console.log(exports.hello);
+export default exports;
diff --git a/test/fixtures/es-modules/required-cjs.js b/test/fixtures/es-modules/required-cjs.js
new file mode 100644
index 00000000000000..68adb0f66ccd36
--- /dev/null
+++ b/test/fixtures/es-modules/required-cjs.js
@@ -0,0 +1,3 @@
+module.exports = {
+  hello: 'world',
+};
\ No newline at end of file
diff --git a/test/fixtures/es-modules/tla/execution.mjs b/test/fixtures/es-modules/tla/execution.mjs
new file mode 100644
index 00000000000000..c060945ba02f21
--- /dev/null
+++ b/test/fixtures/es-modules/tla/execution.mjs
@@ -0,0 +1,3 @@
+import process from 'node:process';
+process._rawDebug('I am executed');
+await Promise.resolve('hi');
diff --git a/test/fixtures/es-modules/tla/require-execution.js b/test/fixtures/es-modules/tla/require-execution.js
new file mode 100644
index 00000000000000..8d3ec9d107a838
--- /dev/null
+++ b/test/fixtures/es-modules/tla/require-execution.js
@@ -0,0 +1 @@
+require('./execution.mjs');
diff --git a/test/fixtures/es-modules/tla/resolved.mjs b/test/fixtures/es-modules/tla/resolved.mjs
new file mode 100644
index 00000000000000..ff717caf5a2e3c
--- /dev/null
+++ b/test/fixtures/es-modules/tla/resolved.mjs
@@ -0,0 +1 @@
+await Promise.resolve('hello');