diff --git a/.eslintignore b/.eslintignore
index 64f34660d87a8f..f72fbdfd842923 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -13,3 +13,5 @@ doc/changelogs/CHANGELOG_v1*.md
 !doc/changelogs/CHANGELOG_v18.md
 !doc/api_assets/*.js
 !.eslintrc.js
+test/es-module/test-require-module-entry-point.js
+test/es-module/test-require-module-entry-point-aou.js
diff --git a/doc/api/cli.md b/doc/api/cli.md
index bdae4a7e771391..bbfb111e051d4d 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -871,6 +871,22 @@ added: v11.8.0
 
 Use the specified file as a security policy.
 
+### `--experimental-require-module`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active Developement
+
+Supports loading a synchronous ES module graph in `require()`. If the module
+graph is not synchronous (contains top-level await), it throws an error.
+
+By default, a `.js` file will be parsed as a CommonJS module first. If it
+contains ES module syntax, Node.js will try to parse and evaluate the module
+again as an ES module. If it turns out to be synchronous and can be evaluated
+successfully, the module namespace object will be returned by `require()`.
+
 ### `--experimental-sea-config`
 
 <!-- YAML
@@ -2523,6 +2539,7 @@ Node.js options that are allowed are:
 * `--experimental-network-imports`
 * `--experimental-permission`
 * `--experimental-policy`
+* `--experimental-require-module`
 * `--experimental-shadow-realm`
 * `--experimental-specifier-resolution`
 * `--experimental-top-level-await`
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index ef4295f9eaaaef..970519d93dab7f 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -210,6 +210,7 @@ class NodeAggregateError extends AggregateError {
 }
 
 const assert = require('internal/assert');
+const { getOptionValue } = require('internal/options');
 
 // Lazily loaded
 let util;
@@ -1686,6 +1687,8 @@ E('ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS', '%s', TypeError);
 E('ERR_REQUIRE_ESM',
   function(filename, hasEsmSyntax, parentPath = null, packageJsonPath = null) {
     hideInternalStackFrames(this);
+    // TODO(joyeecheung): mention --experimental-require-module here.
+    assert(!getOptionValue('--experimental-require-module'));
     let msg = `require() of ES Module ${filename}${parentPath ? ` from ${
       parentPath}` : ''} not supported.`;
     if (!packageJsonPath) {
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index cd36233aa9b790..97909c70fdf0ac 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');
@@ -107,7 +109,6 @@ const { safeGetenv } = internalBinding('credentials');
 const {
   privateSymbols: {
     require_private_symbol,
-    host_defined_option_symbol,
   },
 } = internalBinding('util');
 const {
@@ -396,6 +397,10 @@ function initializeCJS() {
   // TODO(joyeecheung): deprecate this in favor of a proper hook?
   Module.runMain =
     require('internal/modules/run_main').executeUserEntryPoint;
+
+  if (getOptionValue('--experimental-require-module')) {
+    Module._extensions['.mjs'] = loadESMFromCJS;
+  }
 }
 
 // Given a module name, and a list of paths to test, returns the first
@@ -988,7 +993,7 @@ Module._load = function(request, parent, isMain) {
   if (cachedModule !== undefined) {
     updateChildren(parent, cachedModule, true);
     if (!cachedModule.loaded) {
-      const parseCachedModule = cjsParseCache.get(cachedModule);
+      const parseCachedModule = cjsSourceCache.get(cachedModule);
       if (!parseCachedModule || parseCachedModule.loaded) {
         return getExportsForCircularRequire(cachedModule);
       }
@@ -1010,6 +1015,9 @@ Module._load = function(request, parent, isMain) {
     setOwnProperty(process, 'mainModule', module);
     setOwnProperty(module.require, 'main', process.mainModule);
     module.id = '.';
+    module[is_main_symbol] = true;
+  } else {
+    module[is_main_symbol] = false;
   }
 
   reportModuleToWatchMode(filename);
@@ -1270,37 +1278,45 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache) {
     );
 
     // Cache the source map for the module if present.
-    if (script.sourceMapURL) {
-      maybeCacheSourceMap(filename, content, this, false, undefined, script.sourceMapURL);
+    const { sourceMapURL } = script;
+    if (sourceMapURL) {
+      maybeCacheSourceMap(filename, content, this, false, undefined, sourceMapURL);
     }
 
-    return runScriptInThisContext(script, true, false);
+    return {
+      __proto__: null,
+      function: runScriptInThisContext(script, true, false),
+      sourceMapURL,
+      retryAsESM: false,
+    };
   }
 
-  try {
-    const result = compileFunctionForCJSLoader(content, filename);
-    result.function[host_defined_option_symbol] = hostDefinedOptionId;
-
-    // cachedDataRejected is only set for cache coming from SEA.
-    if (codeCache &&
-        result.cachedDataRejected !== false &&
-        internalBinding('sea').isSea()) {
-      process.emitWarning('Code cache data rejected.');
-    }
+  const result = compileFunctionForCJSLoader(content, filename);
 
-    // Cache the source map for the module if present.
-    if (result.sourceMapURL) {
-      maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
-    }
+  // cachedDataRejected is only set for cache coming from SEA.
+  if (codeCache &&
+      result.cachedDataRejected !== false &&
+      internalBinding('sea').isSea()) {
+    process.emitWarning('Code cache data rejected.');
+  }
 
-    return result.function;
-  } catch (err) {
-    if (process.mainModule === cjsModuleInstance) {
-      const { enrichCJSError } = require('internal/modules/esm/translators');
-      enrichCJSError(err, content, filename);
-    }
-    throw err;
+  // Cache the source map for the module if present.
+  if (result.sourceMapURL) {
+    maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
   }
+
+  return result;
+}
+
+// Resolve and evaluate as ESM, synchronously.
+function loadESMFromCJS(mod, filename) {
+  const source = getMaybeCachedSource(mod, filename);
+  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
+  // We are still using the CJS's resolution here.
+  const url = pathToFileURL(filename).href;
+  const isMain = mod[is_main_symbol];
+  // TODO(joyeecheung): maybe we can do some special handling for default here. Maybe we don't.
+  mod.exports = cascadedLoader.importSyncForRequire(url, source, isMain);
 }
 
 /**
@@ -1308,8 +1324,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 +1336,25 @@ 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;
+    loadAsESM = result.retryAsESM;
+  }
 
+  if (loadAsESM) {
+    // Pass the source into the .mjs extension handler indirectly through the cache.
+    cjsSourceCache.set(this, content);
+    loadESMFromCJS(this, filename);
+    return;
+  }
+
+  // TODO(joyeecheung): the detection below is unnecessarily complex. Maybe just
+  // use the is_main_symbol, or a break_on_start_symbol that gets passed from
+  // higher level instead of doing hacky detecion here.
   let inspectorWrapper = null;
   if (getOptionValue('--inspect-brk') && process._eval == null) {
     if (!resolvedArgv) {
@@ -1344,6 +1378,7 @@ Module.prototype._compile = function(content, filename) {
       inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
+
   const dirname = path.dirname(filename);
   const require = makeRequireFunction(this, redirects);
   let result;
@@ -1363,25 +1398,37 @@ Module.prototype._compile = function(content, filename) {
   return result;
 };
 
-/**
- * Native handler for `.js` files.
- * @param {Module} module The module to compile
- * @param {string} filename The file path of the module
- */
-Module._extensions['.js'] = function(module, filename) {
-  // If already analyzed the source, then it will be cached.
-  const cached = cjsParseCache.get(module);
+function getMaybeCachedSource(mod, filename) {
+  const cached = cjsSourceCache.get(mod);
   let content;
   if (cached?.source) {
     content = cached.source;
     cached.source = undefined;
   } else {
+    // TODO(joyeecheung): read a buffer.
     content = fs.readFileSync(filename, 'utf8');
   }
+  return content;
+}
+
+/**
+ * Native handler for `.js` files.
+ * @param {Module} module The module to compile
+ * @param {string} filename The file path of the module
+ */
+Module._extensions['.js'] = function(module, filename) {
+  // If already analyzed the source, then it will be cached.
+  const content = getMaybeCachedSource(module, filename);
+
   if (StringPrototypeEndsWith(filename, '.js')) {
     const pkg = packageJsonReader.getNearestParentPackageJSON(filename);
     // Function require shouldn't be used in ES modules.
     if (pkg?.data.type === 'module') {
+      if (getOptionValue('--experimental-require-module')) {
+        module._compile(content, filename, true);
+        return;
+      }
+
       // This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.
       const parent = moduleParentCache.get(module);
       const parentPath = parent?.filename;
@@ -1414,7 +1461,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..a3b5c4c4f221e5 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -15,16 +15,24 @@ const {
   hardenRegExp,
 } = primordials;
 
+const assert = require('internal/assert');
 const {
   ERR_REQUIRE_ESM,
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
 const { isURL } = require('internal/url');
-const { emitExperimentalWarning } = require('internal/util');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 const {
+  registerModule,
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+const { kImplicitAssertType } = require('internal/modules/esm/assert');
+const {
+  maybeCacheSourceMap,
+} = require('internal/source_map/source_map_cache');
+
+const { ModuleWrap } = internalBinding('module_wrap');
 let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
 
 /**
@@ -184,8 +192,6 @@ class ModuleLoader {
 
   async eval(source, url, isEntryPoint = false) {
     const evalInstance = (url) => {
-      const { ModuleWrap } = internalBinding('module_wrap');
-      const { registerModule } = require('internal/modules/esm/utils');
       const module = new ModuleWrap(url, undefined, source, 0, 0);
       registerModule(module, {
         __proto__: null,
@@ -197,7 +203,7 @@ class ModuleLoader {
 
       return module;
     };
-    const ModuleJob = require('internal/modules/esm/module_job');
+    const { ModuleJob } = require('internal/modules/esm/module_job');
     const job = new ModuleJob(
       this, url, undefined, evalInstance, false, false);
     this.loadCache.set(url, undefined, job);
@@ -233,7 +239,7 @@ class ModuleLoader {
     return this.getJobFromResolveResult(resolveResult, parentURL, importAttributes, true);
   }
 
-  getJobFromResolveResult(resolveResult, parentURL, importAttributes, sync) {
+  getJobFromResolveResult(resolveResult, parentURL, importAttributes, sync, requireESMHint) {
     const { url, format } = resolveResult;
     const resolvedImportAttributes = resolveResult.importAttributes ?? importAttributes;
     let job = this.loadCache.get(url, resolvedImportAttributes.type);
@@ -244,12 +250,97 @@ class ModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync);
+      job = this.#createModuleJob(url, resolvedImportAttributes, parentURL, format, sync, requireESMHint);
     }
 
     return job;
   }
 
+  getModuleForImportInRequire(specifier, parentURL, importAttributes, requireESMHint) {
+    const requestKey = this.#resolveCache.serializeKey(specifier, importAttributes);
+    let resolveResult = this.#resolveCache.get(requestKey, parentURL);
+    if (resolveResult == null) {
+      resolveResult = this.defaultResolve(specifier, parentURL, importAttributes, requireESMHint);
+      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) {
+      // TODO(joyeecheung): throw if it's async.
+      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';
+    }
+    // TODO(joyeecheung): override translator for commonjs.
+    const translator = getTranslators().get(finalFormat);
+
+    if (!translator) {
+      throw new ERR_UNKNOWN_MODULE_FORMAT(finalFormat, responseURL);
+    }
+
+    const isMain = (parentURL === undefined);
+    const inspectBrk = (isMain && getOptionValue('--inspect-brk'));
+    const wrap = FunctionPrototypeCall(translator, this, responseURL, source, isMain, parentURL);
+    assert(wrap instanceof ModuleWrap);
+    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
+      process.send({ 'watch:import': [url] });
+    }
+
+    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;
+  }
+
+  importSyncForRequire(url, source, isMain) {
+    let job = this.loadCache.get(url, kImplicitAssertType);
+    if (job !== undefined) {
+      // The job has been previously created.
+      const { ModuleJobSync } = require('internal/modules/esm/module_job');
+      if (job instanceof ModuleJobSync) {
+        return job.module.getNamespace();
+      }
+      assert(job.instantiated !== undefined);
+
+      // TODO(joyeecheung): throw if it's async.
+      return job.module.getNamespace();
+    }
+    const wrap = new ModuleWrap(url, undefined, source, 0, 0);
+    // Cache the source map for the module if present.
+    if (wrap.sourceMapURL) {
+      maybeCacheSourceMap(url, source, null, false, undefined, wrap.sourceMapURL);
+    }
+    const { registerModule } = require('internal/modules/esm/utils');
+    registerModule(wrap, {
+      __proto__: null,
+      initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
+      // TODO(joyeecheung): this can just use vm_dynamic_import_default_internal, and
+      // maybe most of other ModuleWraps created by the ESM loader too.
+      importModuleDynamically: (specifier, wrap, importAttributes) => {
+        return this.import(specifier, url, importAttributes);
+      },
+    });
+
+    const inspectBrk = (isMain && getOptionValue('--inspect-brk'));
+
+    const { ModuleJobSync } = require('internal/modules/esm/module_job');
+    job = new ModuleJobSync(this, url, kEmptyObject, wrap, isMain, inspectBrk);
+    this.loadCache.set(url, kImplicitAssertType, job);
+    // TODO(joyeecheung): return the namespace directly.
+    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
@@ -261,7 +352,7 @@ class ModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAttributes, parentURL, format, sync) {
+  #createModuleJob(url, importAttributes, parentURL, format, sync, requireESMHint) {
     const callTranslator = ({ format: finalFormat, responseURL, source }, isMain) => {
       const translator = getTranslators().get(finalFormat);
 
@@ -274,11 +365,12 @@ class ModuleLoader {
     const context = { format, importAttributes };
 
     const moduleProvider = sync ?
-      (url, isMain) => callTranslator(this.loadSync(url, context), isMain) :
+      (url, isMain) => callTranslator(this.loadSync(url, context, requireESMHint), isMain) :
       async (url, isMain) => callTranslator(await this.load(url, context), isMain);
 
+    const isMain = parentURL === undefined;
     const inspectBrk = (
-      parentURL === undefined &&
+      isMain &&
       getOptionValue('--inspect-brk')
     );
 
@@ -286,13 +378,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,
     );
@@ -370,7 +462,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 +470,7 @@ class ModuleLoader {
       conditions: this.#defaultConditions,
       importAttributes,
       parentURL,
+      requireESMHint,
     };
 
     return defaultResolve(originalSpecifier, context);
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 108a8138443de0..1d7298bcad4069 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,30 @@ 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.
+  // `moduleProvider` is a function
+  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 +261,35 @@ class ModuleJob {
     return { __proto__: null, module: this.module };
   }
 }
-ObjectSetPrototypeOf(ModuleJob.prototype, null);
-module.exports = ModuleJob;
+
+// This is a fully synchronous job and does not spawn additional threads in any way, unlike
+// the sync alternative of ModuleJob. Probably a lot more efficient too.
+class ModuleJobSync extends ModuleJobBase {
+  constructor(loader, url, importAttributes, moduleWrap, isMain, inspectBrk) {
+    super(loader, url, importAttributes, moduleWrap, isMain, inspectBrk, true);
+    assert(this.module instanceof ModuleWrap);
+    const requireESMHint = 'from-cjs-fallback';
+    this.linked = this.module.linkSync((specifier, attributes) => {
+      // TODO(joyeecheung): do this entirely in C++ and avoid calling back to JS.
+      return this.loader.getModuleForImportInRequire(specifier, url, attributes, requireESMHint);
+    });
+  }
+
+  async run() {
+    assert.fail('ModuleJobSync cannot be run asynchronously');
+  }
+
+  runSync() {
+    assert(this.module instanceof ModuleWrap);
+    this.module.instantiateSync();
+    this.instantiated = PromiseResolve();
+    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/resolve.js b/lib/internal/modules/esm/resolve.js
index bbbaed87479289..353e712615f635 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -233,7 +233,7 @@ const encodedSepRegEx = /%2F|%5C/i;
  * @throws {ERR_UNSUPPORTED_DIR_IMPORT} - If the resolved pathname is a directory.
  * @throws {ERR_MODULE_NOT_FOUND} - If the resolved pathname is not a file.
  */
-function finalizeResolution(resolved, base, preserveSymlinks) {
+function finalizeResolution(resolved, base, preserveSymlinks, requireESMHint) {
   if (RegExpPrototypeExec(encodedSepRegEx, resolved.pathname) !== null) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
       resolved.pathname, 'must not include encoded "/" or "\\" characters',
@@ -253,6 +253,9 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   const stats = internalModuleStat(toNamespacedPath(StringPrototypeEndsWith(path, '/') ?
     StringPrototypeSlice(path, -1) : path));
 
+  // TODO(joyeecheung): figure out what we should do when require('./dir') resolves to
+  // a directory.
+  // if (!requireESMHint) {
   // Check for stats.isDirectory()
   if (stats === 1) {
     throw new ERR_UNSUPPORTED_DIR_IMPORT(path, fileURLToPath(base), String(resolved));
@@ -264,6 +267,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     throw new ERR_MODULE_NOT_FOUND(
       path || resolved.pathname, base && fileURLToPath(base), resolved);
   }
+  // }
 
   if (!preserveSymlinks) {
     const real = realpathSync(path, {
@@ -884,7 +888,7 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
  * @param {Set<string>} conditions - An object containing environment conditions.
  * @param {boolean} preserveSymlinks - Whether to preserve symlinks in the resolved URL.
  */
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+function moduleResolve(specifier, base, conditions, preserveSymlinks, requireESMHint) {
   const protocol = typeof base === 'string' ?
     StringPrototypeSlice(base, 0, StringPrototypeIndexOf(base, ':') + 1) :
     base.protocol;
@@ -921,7 +925,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
   if (resolved.protocol !== 'file:') {
     return resolved;
   }
-  return finalizeResolution(resolved, base, preserveSymlinks);
+  return finalizeResolution(resolved, base, preserveSymlinks, requireESMHint);
 }
 
 /**
@@ -1150,6 +1154,7 @@ function defaultResolve(specifier, context = {}) {
       parentURL,
       conditions,
       isMain ? preserveSymlinksMain : preserveSymlinks,
+      context.requireESMHint,
     );
   } catch (error) {
     // Try to give the user a hint of what would have been the
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 50a315ae68c02a..ebfae151e7ec9b 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -4,7 +4,6 @@ const {
   ArrayPrototypeMap,
   Boolean,
   JSONParse,
-  ObjectGetPrototypeOf,
   ObjectPrototypeHasOwnProperty,
   ObjectKeys,
   ReflectApply,
@@ -15,16 +14,9 @@ const {
   StringPrototypeReplaceAll,
   StringPrototypeSlice,
   StringPrototypeStartsWith,
-  SyntaxErrorPrototype,
   globalThis: { WebAssembly },
 } = primordials;
 
-const {
-  privateSymbols: {
-    host_defined_option_symbol,
-  },
-} = internalBinding('util');
-
 /** @type {import('internal/util/types')} */
 let _TYPES = null;
 /**
@@ -36,7 +28,6 @@ function lazyTypes() {
 }
 
 const {
-  containsModuleSyntax,
   compileFunctionForCJSLoader,
 } = internalBinding('contextify');
 
@@ -50,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');
@@ -65,10 +56,7 @@ const {
 const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
 const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
-const { emitWarningSync } = require('internal/process/warning');
-const {
-  vm_dynamic_import_default_internal,
-} = internalBinding('symbols');
+
 // Lazy-loading to avoid circular dependencies.
 let getSourceSync;
 /**
@@ -89,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');
@@ -97,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;
 /**
@@ -170,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}`);
@@ -188,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.
@@ -218,14 +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);
-    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);
@@ -332,6 +302,15 @@ function createCJSModuleWrap(url, source, isMain, loadCJS = loadCJSModule) {
 
 }
 
+translators.set('commonjs-sync', (url, source, isMain, parentURL) => {
+  initCJSParseSync();
+  assert(!isMain);
+  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) => {
@@ -352,13 +331,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 {
@@ -380,7 +354,7 @@ function cjsPreparseModuleExports(filename, source) {
   // TODO: Do we want to keep hitting the user mutable CJS loader here?
   let module = CJSModule._cache[filename];
   if (module) {
-    const cached = cjsParseCache.get(module);
+    const cached = cjsSourceCache.get(module);
     if (cached) {
       return { module, exportNames: cached.exportNames };
     }
@@ -404,7 +378,7 @@ function cjsPreparseModuleExports(filename, source) {
   const exportNames = new SafeSet(new SafeArrayIterator(exports));
 
   // Set first for cycles.
-  cjsParseCache.set(module, { source, exportNames });
+  cjsSourceCache.set(module, { source, exportNames });
 
   if (reexports.length) {
     module.filename = filename;
@@ -531,6 +505,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..0acf871680312a 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -321,6 +321,74 @@ 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);
+
+    // TODO(joyeecheung): do it the other way around - create an array with all
+    // the arguments, and let the JS land invoke them.
+    Local<Value> argv[] = {
+        specifier,
+        attributes,
+    };
+
+    MaybeLocal<Value> maybe_resolve_return_value =
+        resolver_arg->Call(mod_context, that, arraysize(argv), argv);
+    if (maybe_resolve_return_value.IsEmpty()) {
+      return;
+    }
+    Local<Value> resolve_return_value =
+        maybe_resolve_return_value.ToLocalChecked();
+    // TODO(joyeecheung): the resolve cache should not hold on to the wraps
+    // using a Global<Promise>, it's unnecessary and leaky. We should create a
+    // map of ModuleWraps directly instead.
+    Local<Promise::Resolver> resolver;
+    if (!Promise::Resolver::New(mod_context).ToLocal(&resolver)) {
+      return;
+    }
+    if (resolver->Resolve(mod_context, resolve_return_value).IsNothing()) {
+      return;
+    }
+    obj->resolve_cache_[specifier_std].Reset(isolate, resolver->GetPromise());
+    modules[i] = resolve_return_value;
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(isolate, modules.out(), modules.length()));
+}
+
 void ModuleWrap::Link(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -486,6 +554,96 @@ 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) {
+    env->ThrowError("require() cannot be used on an ESM graph with top-level "
+                    "await. Use import() instead.");
+    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);
+      }
+    }
+    env->ThrowError("require() cannot be used on an ESM graph with top-level "
+                    "await. Use import() instead.");
+    return;
+  }
+
+  CHECK_EQ(promise->State(), Promise::PromiseState::kFulfilled);
+
+  args.GetReturnValue().Set(module->GetModuleNamespace());
+}
+
 void ModuleWrap::GetNamespace(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   Isolate* isolate = args.GetIsolate();
@@ -818,6 +976,9 @@ void ModuleWrap::CreatePerIsolateProperties(IsolateData* isolate_data,
       ModuleWrap::kInternalFieldCount);
 
   SetProtoMethod(isolate, tpl, "link", Link);
+  SetProtoMethod(isolate, tpl, "linkSync", LinkSync);
+  SetProtoMethod(isolate, tpl, "instantiateSync", InstantiateSync);
+  SetProtoMethod(isolate, tpl, "evaluateSync", EvaluateSync);
   SetProtoMethod(isolate, tpl, "instantiate", Instantiate);
   SetProtoMethod(isolate, tpl, "evaluate", Evaluate);
   SetProtoMethod(isolate, tpl, "setExport", SetSyntheticExport);
@@ -869,6 +1030,9 @@ void ModuleWrap::RegisterExternalReferences(
   registry->Register(New);
 
   registry->Register(Link);
+  registry->Register(LinkSync);
+  registry->Register(InstantiateSync);
+  registry->Register(EvaluateSync);
   registry->Register(Instantiate);
   registry->Register(Evaluate);
   registry->Register(SetSyntheticExport);
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 6f44d722ee0b01..cec219c2598ddb 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -79,6 +79,9 @@ 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 InstantiateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void EvaluateSync(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Link(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Instantiate(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Evaluate(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 7d0cfccb37b25d..75ae29064f3101 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -28,6 +28,7 @@
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
+#include "node_process-inl.h"
 #include "node_sea.h"
 #include "node_snapshot_builder.h"
 #include "node_watchdog.h"
@@ -56,6 +57,7 @@ using v8::Maybe;
 using v8::MaybeLocal;
 using v8::MeasureMemoryExecution;
 using v8::MeasureMemoryMode;
+using v8::Message;
 using v8::MicrotaskQueue;
 using v8::MicrotasksPolicy;
 using v8::Name;
@@ -1399,6 +1401,28 @@ constexpr std::array<std::string_view, 3> esm_syntax_error_messages = {
     "Unexpected token 'export'",                     // `export` statements
     "Cannot use 'import.meta' outside a module"};    // `import.meta` references
 
+// TODO(joyeecheung): see if we can upstream an API to V8 for this.
+bool IsESMSyntaxError(Isolate* isolate, Local<Message> error_message) {
+  if (error_message.IsEmpty()) {
+    return false;
+  }
+  Utf8Value message_utf8(isolate, error_message->Get());
+  auto message = message_utf8.ToStringView();
+
+  for (const auto& error_message : esm_syntax_error_messages) {
+    if (message.find(error_message) != std::string_view::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const char* require_esm_warning =
+    "To load an ES module, use --experimental-require-module if you want to"
+    "require() it and it contains no top-level await.\n"
+    "If it's import'ed, set \"type\": \"module\" in the package.json, "
+    "or use the .mjs extension.";
+
 void ContextifyContext::ContainsModuleSyntax(
     const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -1473,15 +1497,8 @@ void ContextifyContext::ContainsModuleSyntax(
 
   bool found_error_message_caused_by_module_syntax = false;
   if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
-    Utf8Value message_value(env->isolate(), try_catch.Message()->Get());
-    auto message = message_value.ToStringView();
-
-    for (const auto& error_message : esm_syntax_error_messages) {
-      if (message.find(error_message) != std::string_view::npos) {
-        found_error_message_caused_by_module_syntax = true;
-        break;
-      }
-    }
+    found_error_message_caused_by_module_syntax =
+        IsESMSyntaxError(env->isolate(), try_catch.Message());
   }
   args.GetReturnValue().Set(found_error_message_caused_by_module_syntax);
 }
@@ -1527,8 +1544,6 @@ static void CompileFunctionForCJSLoader(
 #endif
   ScriptCompiler::Source source(code, origin, cached_data);
 
-  TryCatchScope try_catch(env);
-
   // TODO(joyeecheung): make it a per-realm persistent.
   std::vector<Local<String>> params = {
       FIXED_ONE_BYTE_STRING(isolate, "exports"),
@@ -1537,26 +1552,58 @@ static void CompileFunctionForCJSLoader(
       FIXED_ONE_BYTE_STRING(isolate, "__filename"),
       FIXED_ONE_BYTE_STRING(isolate, "__dirname"),
   };
-  MaybeLocal<Function> maybe_fn = ScriptCompiler::CompileFunction(
-      context,
-      &source,
-      params.size(),
-      params.data(),
-      0,       /* context extensions size */
-      nullptr, /* context extensions data */
-      // TODO(joyeecheung): allow optional eager compilation.
-      cached_data == nullptr ? ScriptCompiler::kNoCompileOptions
-                             : ScriptCompiler::kConsumeCodeCache,
-      v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
 
+  bool retry_as_esm = false;
   Local<Function> fn;
-  if (!maybe_fn.ToLocal(&fn)) {
-    if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
-      errors::DecorateErrorStack(env, try_catch);
-      if (!try_catch.HasTerminated()) {
-        try_catch.ReThrow();
+
+  {
+    TryCatchScope try_catch(env);
+    MaybeLocal<Function> maybe_fn;
+    {
+      ShouldNotAbortOnUncaughtScope should_not_abort(env);
+      maybe_fn = ScriptCompiler::CompileFunction(
+          context,
+          &source,
+          params.size(),
+          params.data(),
+          0,       /* context extensions size */
+          nullptr, /* context extensions data */
+          // TODO(joyeecheung): allow optional eager compilation.
+          cached_data == nullptr ? ScriptCompiler::kNoCompileOptions
+                                 : ScriptCompiler::kConsumeCodeCache,
+          v8::ScriptCompiler::NoCacheReason::kNoCacheNoReason);
+    }
+    if (!maybe_fn.ToLocal(&fn)) {
+      if (try_catch.HasCaught()) {
+        Utf8Value filename_utf8(isolate, filename);
+        size_t flen = filename_utf8.length();
+        if (flen < 4 ||
+            filename_utf8.ToString().substr(flen - 4, flen) == ".cjs") {
+          USE(ProcessEmitWarningSync(env, require_esm_warning));
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        Local<Value> error = try_catch.Exception();
+        Local<Message> message = try_catch.Message();
+        if (!error->IsNativeError() || message.IsEmpty() ||
+            !IsESMSyntaxError(isolate, message)) {
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        if (!env->options()->require_module) {
+          USE(ProcessEmitWarningSync(env, require_esm_warning));
+          errors::DecorateErrorStack(env, try_catch);
+          try_catch.ReThrow();
+          return;
+        }
+
+        // The file being compiled is likely ESM.
+        retry_as_esm = true;
       }
-      return;
     }
   }
 
@@ -1571,11 +1618,14 @@ static void CompileFunctionForCJSLoader(
       env->cached_data_rejected_string(),
       env->source_map_url_string(),
       env->function_string(),
+      FIXED_ONE_BYTE_STRING(isolate, "retryAsESM"),
   };
   std::vector<Local<Value>> values = {
       Boolean::New(isolate, cache_rejected),
-      fn->GetScriptOrigin().SourceMapUrl(),
-      fn,
+      retry_as_esm ? v8::Undefined(isolate).As<Value>()
+                   : fn->GetScriptOrigin().SourceMapUrl(),
+      retry_as_esm ? v8::Undefined(isolate).As<Value>() : fn.As<Value>(),
+      Boolean::New(isolate, retry_as_esm),
   };
   Local<Object> result = Object::New(
       isolate, v8::Null(isolate), names.data(), values.data(), names.size());
diff --git a/src/node_options.cc b/src/node_options.cc
index bf5265967fb1aa..345ff02dc785fb 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -359,6 +359,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "top-level await in the graph",
             &EnvironmentOptions::print_pending_tla,
             kAllowedInEnvvar);
+  AddOption("--experimental-require-module",
+            "Allow loading ES Module in require()",
+            &EnvironmentOptions::require_module,
+            kAllowedInEnvvar);
+
   AddOption("--diagnostic-dir",
             "set dir for all output files"
             " (default: current working directory)",
diff --git a/src/node_options.h b/src/node_options.h
index 97aec1ec8b98d2..608af9eca9dc54 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -106,6 +106,7 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> conditions;
   bool detect_module = false;
   bool print_pending_tla = false;
+  bool require_module = false;
   std::string dns_result_order;
   bool enable_source_maps = false;
   bool experimental_fetch = true;
diff --git a/test/es-module/test-esm-cjs-load-error-note.mjs b/test/es-module/test-esm-cjs-load-error-note.mjs
index 4df9e903eb627a..bfd9bbaacffde3 100644
--- a/test/es-module/test-esm-cjs-load-error-note.mjs
+++ b/test/es-module/test-esm-cjs-load-error-note.mjs
@@ -6,9 +6,9 @@ import { describe, it } from 'node:test';
 
 
 // Expect note to be included in the error output
-const expectedNote = 'To load an ES module, ' +
-'set "type": "module" in the package.json ' +
-'or use the .mjs extension.';
+// Don't match the following sentence because it can change as features are
+// added.
+const expectedNote = 'Warning: To load an ES module';
 
 const mustIncludeMessage = {
   getMessage: () => (stderr) => `${expectedNote} not found in ${stderr}`,
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index 860775df0a2ce8..83125fce738139 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -6,7 +6,7 @@ require('../common');
 const { strictEqual, throws } = require('assert');
 const { createModuleLoader } = require('internal/modules/esm/loader');
 const { LoadCache, ResolveCache } = require('internal/modules/esm/module_map');
-const ModuleJob = require('internal/modules/esm/module_job');
+const { ModuleJob } = require('internal/modules/esm/module_job');
 const createDynamicModule = require(
   'internal/modules/esm/create_dynamic_module');
 
diff --git a/test/es-module/test-require-module-entry-point-aou.js b/test/es-module/test-require-module-entry-point-aou.js
new file mode 100644
index 00000000000000..29ec2478efdc45
--- /dev/null
+++ b/test/es-module/test-require-module-entry-point-aou.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module --abort-on-uncaught-exception
+'use strict';
+
+import { mustCall } from '../common/index.mjs';
+const fn = mustCall(() => {
+  console.log('hello');
+});
+fn();
diff --git a/test/es-module/test-require-module-entry-point.js b/test/es-module/test-require-module-entry-point.js
new file mode 100644
index 00000000000000..408ddf8a11de83
--- /dev/null
+++ b/test/es-module/test-require-module-entry-point.js
@@ -0,0 +1,8 @@
+// Flags: --experimental-require-module
+'use strict';
+
+import { mustCall } from '../common/index.mjs';
+const fn = mustCall(() => {
+  console.log('hello');
+});
+fn();
diff --git a/test/es-module/test-require-module.js b/test/es-module/test-require-module.js
new file mode 100644
index 00000000000000..2c27d59c183779
--- /dev/null
+++ b/test/es-module/test-require-module.js
@@ -0,0 +1,61 @@
+// Flags: --experimental-require-module
+'use strict';
+
+const common = require('../common');  // This is a test too.
+const assert = require('assert');
+const { isModuleNamespaceObject } = require('util/types');
+
+{
+  const mjs = require('../common/index.mjs');
+  // Only comparing a few properties because the ESM version doesn't re-export everything
+  // from the CJS version.
+  assert.strictEqual(common.mustCall, mjs.mustCall);
+  assert(!isModuleNamespaceObject(common));
+  assert(isModuleNamespaceObject(mjs));
+}
+{
+  const mod = require('../fixtures/es-module-loaders/module-named-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, { foo: 'foo', bar: 'bar' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/source-map/esm-basic.mjs');
+  assert.deepStrictEqual({ ...mod }, {});
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/cjs-exports.mjs');
+  assert.deepStrictEqual({ ...mod }, {});
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/loose.js');
+  assert.deepStrictEqual({ ...mod }, { default: 'module' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+{
+  const mod = require('../fixtures/es-modules/package-without-type/noext-esm');
+  assert.deepStrictEqual({ ...mod }, { default: 'module' });
+  assert(isModuleNamespaceObject(mod));
+}
+
+assert.throws(() => {
+  require('../fixtures/es-modules/es-note-unexpected-export-1.cjs');
+}, {
+  message: /Unexpected token 'export'/
+});
+
+assert.throws(() => {
+  require('../fixtures/es-modules/tla/a.mjs');
+}, {
+  message: /require\(\) cannot be used on an ESM graph with top-level await\. Use import\(\) instead\./
+});
+
+// TODO(joyeecheung): test --require
+// TODO(joyeecheung): test import() and import return the same thing
+// TODO(joyeecheung): test "type" field
+// TODO(joyeecheung): test "exports" field