From af0921d877fcf6b572251283da51a24c02854c8e Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Sun, 31 Jul 2022 06:08:02 +0300
Subject: [PATCH] esm: add `--import` flag

PR-URL: https://github.com/nodejs/node/pull/43942
Fixes: https://github.com/nodejs/node/issues/40110
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Jacob Smith <jacob@frende.me>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 doc/api/cli.md                                |  25 ++-
 lib/internal/main/check_syntax.js             |  27 ++-
 lib/internal/main/eval_stdin.js               |   4 +-
 lib/internal/main/eval_string.js              |   4 +-
 lib/internal/modules/run_main.js              |   7 +-
 lib/internal/process/esm_loader.js            |  29 ++-
 lib/internal/process/execution.js             |  61 +++---
 src/node_options.cc                           |   8 +-
 src/node_options.h                            |   4 +-
 test/es-module/test-esm-import-flag.mjs       | 185 ++++++++++++++++++
 .../test-esm-loader-http-imports.mjs          |  38 +++-
 .../es-modules/esm-top-level-await.mjs        |   5 +
 test/fixtures/es-modules/print-3.mjs          |   1 +
 test/message/eval_messages.out                |   4 +
 test/message/stdin_messages.out               |   8 +-
 15 files changed, 346 insertions(+), 64 deletions(-)
 create mode 100644 test/es-module/test-esm-import-flag.mjs
 create mode 100644 test/fixtures/es-modules/esm-top-level-await.mjs
 create mode 100644 test/fixtures/es-modules/print-3.mjs

diff --git a/doc/api/cli.md b/doc/api/cli.md
index b44eb542f8e0e8..f89573f77611c6 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -445,7 +445,8 @@ Only the root context is supported. There is no guarantee that
 `globalThis.Array` is indeed the default intrinsic reference. Code may break
 under this flag.
 
-To allow polyfills to be added, `--require` runs before freezing intrinsics.
+To allow polyfills to be added,
+[`--require`][] and [`--import`][] both run before freezing intrinsics.
 
 ### `--force-node-api-uncaught-exceptions-policy`
 
@@ -594,6 +595,18 @@ added: v0.11.15
 
 Specify ICU data load path. (Overrides `NODE_ICU_DATA`.)
 
+### `--import=module`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Preload the specified module at startup.
+
+Follows [ECMAScript module][] resolution rules.
+Use [`--require`][] to load a [CommonJS module][].
+Modules preloaded with `--require` will run before modules preloaded with `--import`.
+
 ### `--input-type=type`
 
 <!-- YAML
@@ -1527,8 +1540,9 @@ Preload the specified module at startup.
 Follows `require()`'s module resolution
 rules. `module` may be either a path to a file, or a node module name.
 
-Only CommonJS modules are supported. Attempting to preload a
-ES6 Module using `--require` will fail with an error.
+Only CommonJS modules are supported.
+Use [`--import`][] to preload an [ECMAScript module][].
+Modules preloaded with `--require` will run before modules preloaded with `--import`.
 
 ### `-v`, `--version`
 
@@ -1682,6 +1696,7 @@ Node.js options that are allowed are:
 * `--heapsnapshot-signal`
 * `--http-parser`
 * `--icu-data-dir`
+* `--import`
 * `--input-type`
 * `--insecure-http-parser`
 * `--inspect-brk`
@@ -2086,7 +2101,9 @@ done
 [#42511]: https://github.com/nodejs/node/issues/42511
 [Chrome DevTools Protocol]: https://chromedevtools.github.io/devtools-protocol/
 [CommonJS]: modules.md
+[CommonJS module]: modules.md
 [CustomEvent Web API]: https://dom.spec.whatwg.org/#customevent
+[ECMAScript module]: esm.md#modules-ecmascript-modules
 [ECMAScript module loader]: esm.md#loaders
 [Fetch API]: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
 [Modules loaders]: packages.md#modules-loaders
@@ -2103,8 +2120,10 @@ done
 [`--diagnostic-dir`]: #--diagnostic-dirdirectory
 [`--experimental-wasm-modules`]: #--experimental-wasm-modules
 [`--heap-prof-dir`]: #--heap-prof-dir
+[`--import`]: #--importmodule
 [`--openssl-config`]: #--openssl-configfile
 [`--redirect-warnings`]: #--redirect-warningsfile
+[`--require`]: #-r---require-module
 [`Atomics.wait()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait
 [`Buffer`]: buffer.md#class-buffer
 [`CRYPTO_secure_malloc_init`]: https://www.openssl.org/docs/man1.1.0/man3/CRYPTO_secure_malloc_init.html
diff --git a/lib/internal/main/check_syntax.js b/lib/internal/main/check_syntax.js
index 010bef045e4fc8..cf6f15290dcf18 100644
--- a/lib/internal/main/check_syntax.js
+++ b/lib/internal/main/check_syntax.js
@@ -3,6 +3,7 @@
 // If user passed `-c` or `--check` arguments to Node, check its syntax
 // instead of actually running the file.
 
+const { getOptionValue } = require('internal/options');
 const {
   prepareMainThreadExecution
 } = require('internal/bootstrap/pre_execution');
@@ -36,18 +37,29 @@ if (process.argv[1] && process.argv[1] !== '-') {
 
   markBootstrapComplete();
 
-  checkSyntax(source, filename);
+  loadESMIfNeeded(() => checkSyntax(source, filename));
 } else {
   markBootstrapComplete();
 
-  readStdin((code) => {
+  loadESMIfNeeded(() => readStdin((code) => {
     checkSyntax(code, '[stdin]');
-  });
+  }));
 }
 
-async function checkSyntax(source, filename) {
+function loadESMIfNeeded(cb) {
   const { getOptionValue } = require('internal/options');
-  let isModule = false;
+  const hasModulePreImport = getOptionValue('--import').length > 0;
+
+  if (hasModulePreImport) {
+    const { loadESM } = require('internal/process/esm_loader');
+    loadESM(cb);
+    return;
+  }
+  cb();
+}
+
+async function checkSyntax(source, filename) {
+  let isModule = true;
   if (filename === '[stdin]' || filename === '[eval]') {
     isModule = getOptionValue('--input-type') === 'module';
   } else {
@@ -57,11 +69,14 @@ async function checkSyntax(source, filename) {
     const format = await defaultGetFormat(url);
     isModule = format === 'module';
   }
+
   if (isModule) {
     const { ModuleWrap } = internalBinding('module_wrap');
     new ModuleWrap(filename, undefined, source, 0, 0);
     return;
   }
 
-  wrapSafe(filename, source);
+  const { loadESM } = require('internal/process/esm_loader');
+  const { handleMainPromise } = require('internal/modules/run_main');
+  handleMainPromise(loadESM((loader) => wrapSafe(filename, source)));
 }
diff --git a/lib/internal/main/eval_stdin.js b/lib/internal/main/eval_stdin.js
index d97dbece8f0f56..056d394b12703b 100644
--- a/lib/internal/main/eval_stdin.js
+++ b/lib/internal/main/eval_stdin.js
@@ -23,11 +23,13 @@ readStdin((code) => {
   process._eval = code;
 
   const print = getOptionValue('--print');
+  const loadESM = getOptionValue('--import').length > 0;
   if (getOptionValue('--input-type') === 'module')
     evalModule(code, print);
   else
     evalScript('[stdin]',
                code,
                getOptionValue('--inspect-brk'),
-               print);
+               print,
+               loadESM);
 });
diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js
index 2784204f6002e9..64a01fee5e0461 100644
--- a/lib/internal/main/eval_string.js
+++ b/lib/internal/main/eval_string.js
@@ -21,10 +21,12 @@ markBootstrapComplete();
 
 const source = getOptionValue('--eval');
 const print = getOptionValue('--print');
+const loadESM = getOptionValue('--import').length > 0;
 if (getOptionValue('--input-type') === 'module')
   evalModule(source, print);
 else
   evalScript('[eval]',
              source,
              getOptionValue('--inspect-brk'),
-             print);
+             print,
+             loadESM);
diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js
index 5a50d5d6afab6e..daaa153516c424 100644
--- a/lib/internal/modules/run_main.js
+++ b/lib/internal/modules/run_main.js
@@ -33,7 +33,12 @@ function shouldUseESMLoader(mainPath) {
    * (or an empty list when none have been registered).
    */
   const userLoaders = getOptionValue('--experimental-loader');
-  if (userLoaders.length > 0)
+  /**
+   * @type {string[]} userImports A list of preloaded modules registered by the user
+   * (or an empty list when none have been registered).
+   */
+  const userImports = getOptionValue('--import');
+  if (userLoaders.length > 0 || userImports.length > 0)
     return true;
   const esModuleSpecifierResolution =
     getOptionValue('--experimental-specifier-resolution');
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index eeb6ad77a7ec88..473cea48cafe64 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   ObjectCreate,
 } = primordials;
 
@@ -56,8 +57,23 @@ async function initializeLoader() {
 
   const { getOptionValue } = require('internal/options');
   const customLoaders = getOptionValue('--experimental-loader');
+  const preloadModules = getOptionValue('--import');
+  const loaders = await loadModulesInIsolation(customLoaders);
 
-  if (customLoaders.length === 0) return;
+  // Hooks must then be added to external/public loader
+  // (so they're triggered in userland)
+  esmLoader.addCustomLoaders(loaders);
+
+  // Preload after loaders are added so they can be used
+  if (preloadModules?.length) {
+    await loadModulesInIsolation(preloadModules, loaders);
+  }
+
+  isESMInitialized = true;
+}
+
+function loadModulesInIsolation(specifiers, loaders = []) {
+  if (!ArrayIsArray(specifiers) || specifiers.length === 0) { return; }
 
   let cwd;
   try {
@@ -70,19 +86,14 @@ async function initializeLoader() {
   // between internal Node.js and userland. For example, a module with internal
   // state (such as a counter) should be independent.
   const internalEsmLoader = new ESMLoader();
+  internalEsmLoader.addCustomLoaders(loaders);
 
   // Importation must be handled by internal loader to avoid poluting userland
-  const keyedExportsList = await internalEsmLoader.import(
-    customLoaders,
+  return internalEsmLoader.import(
+    specifiers,
     pathToFileURL(cwd).href,
     ObjectCreate(null),
   );
-
-  // Hooks must then be added to external/public loader
-  // (so they're triggered in userland)
-  await esmLoader.addCustomLoaders(keyedExportsList);
-
-  isESMInitialized = true;
 }
 
 exports.loadESM = async function loadESM(callback) {
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 4a8e51f694f7e6..56017a4e497ce3 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -48,7 +48,7 @@ function evalModule(source, print) {
   return handleMainPromise(loadESM((loader) => loader.eval(source)));
 }
 
-function evalScript(name, body, breakFirstLine, print) {
+function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
   const CJSModule = require('internal/modules/cjs/loader').Module;
   const { kVmBreakFirstLineSymbol } = require('internal/util');
   const { pathToFileURL } = require('url');
@@ -60,35 +60,44 @@ function evalScript(name, body, breakFirstLine, print) {
   module.filename = path.join(cwd, name);
   module.paths = CJSModule._nodeModulePaths(cwd);
 
+  const { handleMainPromise } = require('internal/modules/run_main');
   const asyncESM = require('internal/process/esm_loader');
   const baseUrl = pathToFileURL(module.filename).href;
+  const { loadESM } = asyncESM;
+
+  const runScript = () => {
+    // Create wrapper for cache entry
+    const script = `
+      globalThis.module = module;
+      globalThis.exports = exports;
+      globalThis.__dirname = __dirname;
+      globalThis.require = require;
+      return (main) => main();
+    `;
+    globalThis.__filename = name;
+    const result = module._compile(script, `${name}-wrapper`)(() =>
+      require('vm').runInThisContext(body, {
+        filename: name,
+        displayErrors: true,
+        [kVmBreakFirstLineSymbol]: !!breakFirstLine,
+        importModuleDynamically(specifier, _, importAssertions) {
+          const loader = asyncESM.esmLoader;
+          return loader.import(specifier, baseUrl, importAssertions);
+        }
+      }));
+    if (print) {
+      const { log } = require('internal/console/global');
+      log(result);
+    }
 
-  // Create wrapper for cache entry
-  const script = `
-    globalThis.module = module;
-    globalThis.exports = exports;
-    globalThis.__dirname = __dirname;
-    globalThis.require = require;
-    return (main) => main();
-  `;
-  globalThis.__filename = name;
-  const result = module._compile(script, `${name}-wrapper`)(() =>
-    require('vm').runInThisContext(body, {
-      filename: name,
-      displayErrors: true,
-      [kVmBreakFirstLineSymbol]: !!breakFirstLine,
-      importModuleDynamically(specifier, _, importAssertions) {
-        const loader = asyncESM.esmLoader;
-        return loader.import(specifier, baseUrl, importAssertions);
-      }
-    }));
-  if (print) {
-    const { log } = require('internal/console/global');
-    log(result);
-  }
+    if (origModule !== undefined)
+      globalThis.module = origModule;
+  };
 
-  if (origModule !== undefined)
-    globalThis.module = origModule;
+  if (shouldLoadESM) {
+    return handleMainPromise(loadESM(runScript));
+  }
+  return runScript();
 }
 
 const exceptionHandlerState = {
diff --git a/src/node_options.cc b/src/node_options.cc
index 7a41f9bc3b87f6..5189df1ae66ee1 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -608,10 +608,14 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
   AddAlias("-pe", { "--print", "--eval" });
   AddAlias("-p", "--print");
   AddOption("--require",
-            "module to preload (option can be repeated)",
-            &EnvironmentOptions::preload_modules,
+            "CommonJS module to preload (option can be repeated)",
+            &EnvironmentOptions::preload_cjs_modules,
             kAllowedInEnvironment);
   AddAlias("-r", "--require");
+  AddOption("--import",
+            "ES module to preload (option can be repeated)",
+            &EnvironmentOptions::preload_esm_modules,
+            kAllowedInEnvironment);
   AddOption("--interactive",
             "always enter the REPL even if stdin does not appear "
             "to be a terminal",
diff --git a/src/node_options.h b/src/node_options.h
index 827c6298f5ea28..c266ece4b3173e 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -188,7 +188,9 @@ class EnvironmentOptions : public Options {
   bool tls_max_v1_3 = false;
   std::string tls_keylog;
 
-  std::vector<std::string> preload_modules;
+  std::vector<std::string> preload_cjs_modules;
+
+  std::vector<std::string> preload_esm_modules;
 
   std::vector<std::string> user_argv;
 
diff --git a/test/es-module/test-esm-import-flag.mjs b/test/es-module/test-esm-import-flag.mjs
new file mode 100644
index 00000000000000..2f6f4dd48b49a8
--- /dev/null
+++ b/test/es-module/test-esm-import-flag.mjs
@@ -0,0 +1,185 @@
+import { spawnPromisified } from '../common/index.mjs';
+import fixtures from '../common/fixtures.js';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { describe, it } from 'node:test';
+
+const cjsEntry = fixtures.path('es-modules', 'cjs-file.cjs');
+const cjsImport = fixtures.fileURL('es-modules', 'cjs-file.cjs');
+const mjsEntry = fixtures.path('es-modules', 'mjs-file.mjs');
+const mjsImport = fixtures.fileURL('es-modules', 'mjs-file.mjs');
+
+
+describe('import modules using --import', { concurrency: true }, () => {
+  it('should import when using --eval', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--eval', 'console.log("log")',
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\nlog\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import when using --eval and --input-type=module', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--input-type', 'module',
+        '--eval', 'console.log("log")',
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\nlog\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import when main entrypoint is a cjs file', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        cjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\n\.cjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import mjs when entrypoint is a cjs file', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        cjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\n\.cjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import cjs when entrypoint is a mjs file', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', cjsImport,
+        mjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.cjs file\r?\n\.mjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import mjs when entrypoint is a cjs file', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        cjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\n\.cjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should de-duplicate redundant `--import`s', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--import', mjsImport,
+        '--import', mjsImport,
+        cjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\n\.cjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import when running --check', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--check',
+        cjsEntry,
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.mjs file\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import when running --check fails', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--no-warnings',
+        '--check',
+        fixtures.path('es-modules', 'invalid-cjs.js'),
+      ]
+    );
+
+    assert.match(stderr, /SyntaxError: Unexpected token 'export'/);
+    assert.match(stdout, /^\.mjs file\r?\n$/);
+    assert.strictEqual(code, 1);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import --require before --import', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', mjsImport,
+        '--require', cjsEntry,
+        '--eval', 'console.log("log")',
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^\.cjs file\r?\n\.mjs file\r?\nlog\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should import a module with top level await', async () => {
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--import', fixtures.fileURL('es-modules', 'esm-top-level-await.mjs'),
+        fixtures.path('es-modules', 'print-3.mjs'),
+      ]
+    );
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^1\r?\n2\r?\n3\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+});
diff --git a/test/es-module/test-esm-loader-http-imports.mjs b/test/es-module/test-esm-loader-http-imports.mjs
index ad42829f5d1cee..7cf108b9c952f1 100644
--- a/test/es-module/test-esm-loader-http-imports.mjs
+++ b/test/es-module/test-esm-loader-http-imports.mjs
@@ -5,13 +5,18 @@ import http from 'node:http';
 import path from 'node:path';
 import { execPath } from 'node:process';
 import { promisify } from 'node:util';
-import { describe, it } from 'node:test';
+import { describe, it, after } from 'node:test';
 
 
 const files = {
   'main.mjs': 'export * from "./lib.mjs";',
   'lib.mjs': 'export { sum } from "./sum.mjs";',
   'sum.mjs': 'export function sum(a, b) { return a + b }',
+  'console.mjs': `
+    import { sum } from './sum.mjs';
+    globalThis.sum = sum;
+    console.log("loaded over http");
+  `,
 };
 
 const requestListener = ({ url }, rsp) => {
@@ -41,13 +46,26 @@ const {
   port,
 } = server.address();
 
-/**
- * ! If more cases are added to this test, they cannot (yet) be concurrent because there is no
- * ! `afterAll` teardown in which to close the server.
- */
-
-describe('ESM: http import via loader', { concurrency: false }, () => {
-  it('should work', async () => {
+describe('ESM: http import via loader', { concurrency: true }, () => {
+  it('should load using --import flag', async () => {
+    // ! MUST NOT use spawnSync to avoid blocking the event loop
+    const { code, signal, stderr, stdout } = await spawnPromisified(
+      execPath,
+      [
+        '--no-warnings',
+        '--loader',
+        fixtures.fileURL('es-module-loaders', 'http-loader.mjs'),
+        '--import', `http://${host}:${port}/console.mjs`,
+        '--eval',
+        'console.log(sum(1, 2))',
+      ]
+    );
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /loaded over http\r?\n3/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+  it('should load using import inside --eval code', async () => {
     // ! MUST NOT use spawnSync to avoid blocking the event loop
     const { code, signal, stderr, stdout } = await spawnPromisified(
       execPath,
@@ -65,7 +83,7 @@ describe('ESM: http import via loader', { concurrency: false }, () => {
     assert.strictEqual(stdout, '[Module: null prototype] { sum: [Function: sum] }\n');
     assert.strictEqual(code, 0);
     assert.strictEqual(signal, null);
-
-    server.close(); // ! This MUST come after the final test, but inside the async `it` function
   });
+
+  after(() => server.close());
 });
diff --git a/test/fixtures/es-modules/esm-top-level-await.mjs b/test/fixtures/es-modules/esm-top-level-await.mjs
new file mode 100644
index 00000000000000..4a4745afafaaf2
--- /dev/null
+++ b/test/fixtures/es-modules/esm-top-level-await.mjs
@@ -0,0 +1,5 @@
+import { setImmediate } from 'node:timers/promises';
+
+await setImmediate();
+console.log(1);
+console.log(2);
diff --git a/test/fixtures/es-modules/print-3.mjs b/test/fixtures/es-modules/print-3.mjs
new file mode 100644
index 00000000000000..3bd241b50e7c44
--- /dev/null
+++ b/test/fixtures/es-modules/print-3.mjs
@@ -0,0 +1 @@
+console.log(3);
diff --git a/test/message/eval_messages.out b/test/message/eval_messages.out
index d34869586cf6db..3f44332c03a470 100644
--- a/test/message/eval_messages.out
+++ b/test/message/eval_messages.out
@@ -8,6 +8,7 @@ SyntaxError: Strict mode code may not include a with statement
     at Object.runInThisContext (node:vm:*:*)
     at node:internal/process/execution:*:*
     at [eval]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_string:*:*
 
@@ -24,6 +25,7 @@ Error: hello
     at Object.runInThisContext (node:vm:*:*)
     at node:internal/process/execution:*:*
     at [eval]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_string:*:*
 
@@ -39,6 +41,7 @@ Error: hello
     at Object.runInThisContext (node:vm:*:*)
     at node:internal/process/execution:*:*
     at [eval]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_string:*:*
 
@@ -54,6 +57,7 @@ ReferenceError: y is not defined
     at Object.runInThisContext (node:vm:*:*)
     at node:internal/process/execution:*:*
     at [eval]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_string:*:*
 
diff --git a/test/message/stdin_messages.out b/test/message/stdin_messages.out
index eb150d8eaf33f6..3fd047aacb11a2 100644
--- a/test/message/stdin_messages.out
+++ b/test/message/stdin_messages.out
@@ -9,11 +9,11 @@ SyntaxError: Strict mode code may not include a with statement
     at Object.runInThisContext (node:vm:*)
     at node:internal/process/execution:*:*
     at [stdin]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_stdin:*:*
     at Socket.<anonymous> (node:internal/process/execution:*:*)
     at Socket.emit (node:events:*:*)
-    at endReadableNT (node:internal/streams/readable:*:*)
 
 Node.js *
 42
@@ -28,11 +28,11 @@ Error: hello
     at Object.runInThisContext (node:vm:*)
     at node:internal/process/execution:*:*
     at [stdin]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_stdin:*:*
     at Socket.<anonymous> (node:internal/process/execution:*:*)
     at Socket.emit (node:events:*:*)
-    at endReadableNT (node:internal/streams/readable:*:*)
 
 Node.js *
 [stdin]:1
@@ -45,11 +45,11 @@ Error: hello
     at Object.runInThisContext (node:vm:*)
     at node:internal/process/execution:*:*
     at [stdin]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_stdin:*:*
     at Socket.<anonymous> (node:internal/process/execution:*:*)
     at Socket.emit (node:events:*:*)
-    at endReadableNT (node:internal/streams/readable:*:*)
 
 Node.js *
 100
@@ -63,11 +63,11 @@ ReferenceError: y is not defined
     at Object.runInThisContext (node:vm:*)
     at node:internal/process/execution:*:*
     at [stdin]-wrapper:*:*
+    at runScript (node:internal/process/execution:*:*)
     at evalScript (node:internal/process/execution:*:*)
     at node:internal/main/eval_stdin:*:*
     at Socket.<anonymous> (node:internal/process/execution:*:*)
     at Socket.emit (node:events:*:*)
-    at endReadableNT (node:internal/streams/readable:*:*)
 
 Node.js *