From 03f6bb4fbeb8359fbb259e22a78920c846527cfa Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Mon, 19 Dec 2022 21:16:22 +0100
Subject: [PATCH 001/126] esm: move hook execution to separate thread
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
Co-authored-by: Geoffrey Booth <webadmin@geoffreybooth.com>
Co-authored-by: Michaël Zasso <targos@protonmail.com>
---
 lib/internal/modules/esm/loader.js | 105 ++++++++++++++++++++++++-----
 lib/internal/modules/esm/worker.js |  72 ++++++++++++++++++++
 lib/internal/process/esm_loader.js |  10 +--
 lib/internal/worker.js             |  24 ++++++-
 src/env-inl.h                      |   3 +-
 5 files changed, 189 insertions(+), 25 deletions(-)
 create mode 100644 lib/internal/modules/esm/worker.js

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 1fc25512b2c69c..96e816adc0433f 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -19,6 +19,10 @@ const { getOptionValue } = require('internal/options');
 const { pathToFileURL } = require('internal/url');
 const { emitExperimentalWarning } = require('internal/util');
 
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
+
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
@@ -33,6 +37,76 @@ function getTranslators() {
   return translators;
 }
 
+class HooksProxy {
+  /**
+   * The communication vehicle constituting all memory shared between the main and the worker.
+   */
+  #commsChannel = new SharedArrayBuffer(2048); // maybe use buffer.constants.MAX_LENGTH ?
+  /**
+   * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
+   * segment is used to tell the main to sleep when the worker is processing, and vice versa
+   * (for the worker to sleep whilst the main thread is processing).
+   * 0 -> main sleeps
+   * 1 -> worker sleeps
+   */
+  #lock = new Int32Array(this.#commsChannel, 0, 4);
+  /**
+   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
+   * requests & responses into a format supported by the comms channel) reads and writes with
+   * Uint8Array.
+   */
+  #requestResponseData = new Uint8Array(this.#commsChannel, 4, 2044);
+
+  #isReady = false;
+
+  constructor() {
+    const { InternalWorker } = require('internal/worker');
+    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
+      stderr: false,
+      stdin: false,
+      stdout: false,
+      trackUnmanagedFds: false,
+      workerData: { commsChannel: this.#commsChannel },
+    });
+    worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
+  }
+
+  makeRequest(type, ...args) {
+    if (!this.#isReady) {
+      const { kIsOnline } = require('internal/worker');
+      if (!this.worker[kIsOnline]) {
+        debug('blocking main thread until the loader thread is ready');
+        Atomics.wait(this.#lock, 0, 0); // ! Block this module until the worker is ready.
+      }
+
+      this.#isReady = true;
+    }
+
+    const { deserialize, serialize } = require('v8');
+
+    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
+
+    const request = serialize({ type, args });
+    debug(`sending ${type} request to worker (and then sleeping) with args`, ...args);
+    TypedArrayPrototypeSet(this.#requestResponseData, request);
+
+    Atomics.store(this.#lock, 0, 0); // Send request to worker
+    Atomics.notify(this.#lock, 0); // Notify worker of new request
+    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
+
+    debug(`received response from worker for ${type} request`, this.#requestResponseData);
+    return deserialize(this.#requestResponseData);
+  }
+}
+ObjectSetPrototypeOf(HooksProxy.prototype, null);
+
+/**
+ * Multiple instances of ESMLoader exist for various, specific reasons (see code comments at site).
+ * In order to maintain consitency, we use a single worker (sandbox), which must sit apart of an
+ * individual ESMLoader instance.
+ */
+let hookProxy;
+
 /**
  * @typedef {object} ExportedHooks
  * @property {Function} globalPreload Global preload hook.
@@ -66,7 +140,6 @@ function getTranslators() {
  */
 
 class ESMLoader {
-  #hooks;
   #defaultResolve;
   #defaultLoad;
   #importMetaInitializer;
@@ -105,13 +178,12 @@ class ESMLoader {
     }
   }
 
-  addCustomLoaders(userLoaders) {
-    const { Hooks } = require('internal/modules/esm/hooks');
-    this.#hooks = new Hooks(userLoaders);
+  addCustomLoaders() {
+    hookProxy ??= new HooksProxy(); // The worker adds custom hooks as part of its startup.
   }
 
   preload() {
-    this.#hooks?.preload();
+    hookProxy?.makeRequest('preload');
   }
 
   async eval(
@@ -160,7 +232,7 @@ class ESMLoader {
 
     // We can skip cloning if there are no user-provided loaders because
     // the Node.js default resolve hook does not use import assertions.
-    if (this.#hooks?.hasCustomResolveOrLoadHooks) {
+    if (hookProxy) { // This exists only when there are custom hooks.
       // This method of cloning only works so long as import assertions cannot contain objects as values,
       // which they currently cannot per spec.
       importAssertionsForResolve = {
@@ -307,6 +379,7 @@ class ESMLoader {
     if (this.#hooks) {
       return this.#hooks.resolve(originalSpecifier, parentURL, importAssertions);
     }
+
     if (!this.#defaultResolve) {
       this.#defaultResolve = require('internal/modules/esm/resolve').defaultResolve;
     }
@@ -316,8 +389,8 @@ class ESMLoader {
       importAssertions,
       parentURL,
     };
-    return this.#defaultResolve(originalSpecifier, context);
 
+    return this.#defaultResolve(originalSpecifier, context);
   }
 
   /**
@@ -329,8 +402,8 @@ class ESMLoader {
    */
   async load(url, context) {
     let loadResult;
-    if (this.#hooks) {
-      loadResult = await this.#hooks.load(url, context);
+    if (hookProxy) {
+      loadResult = await hookProxy.makeRequest('load', url, context);
     } else {
       if (!this.#defaultLoad) {
         this.#defaultLoad = require('internal/modules/esm/load').defaultLoad;
@@ -347,14 +420,14 @@ class ESMLoader {
   }
 
   importMetaInitialize(meta, context) {
-    if (this.#hooks) {
-      this.#hooks.importMetaInitialize(meta, context);
-    } else {
-      if (!this.#importMetaInitializer) {
-        this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-      }
-      this.#importMetaInitializer(meta, context);
+    if (hookProxy) {
+      return hookProxy.makeRequest('importMetaInitialize', meta, context);
+    }
+
+    if (!this.#importMetaInitializer) {
+      this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
     }
+    this.#importMetaInitializer(meta, context);
   }
 }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
new file mode 100644
index 00000000000000..70381af0926ab4
--- /dev/null
+++ b/lib/internal/modules/esm/worker.js
@@ -0,0 +1,72 @@
+'use strict';
+
+const { appendFileSync, writeFileSync } = require('fs');
+const { inspect } = require('util');
+
+function debug(...args) {
+  appendFileSync('./__debug.log', args.map((arg) => inspect(arg)).join(' ') + '\n');
+}
+writeFileSync('./__debug.log', 'worker for public ESM running\n');
+
+// let debug = require('internal/util/debuglog').debuglog('esm_worker', (fn) => {
+//   debug = fn;
+// });
+
+const {
+  ReflectApply,
+  SafeWeakMap,
+} = primordials;
+
+// Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
+internalBinding('module_wrap').callbackMap = new SafeWeakMap();
+
+const { triggerUncaughtException } = internalBinding('errors');
+const { Hooks } = require('internal/modules/esm/hooks');
+const { workerData } = require('worker_threads');
+const { deserialize, serialize } = require('v8');
+
+const { commsChannel } = workerData;
+// lock = 0 -> main sleeps
+// lock = 1 -> worker sleeps
+const lock = new Int32Array(commsChannel, 0, 4); // Required by Atomics
+const requestResponseData = new Uint8Array(commsChannel, 4, 2044); // For v8.serialize/deserialize
+
+const hooks = new Hooks();
+
+function releaseLock() {
+  Atomics.store(lock, 0, 1); // Send response to main
+  Atomics.notify(lock, 0); // Notify main of new response
+}
+
+releaseLock(); // Send 'ready' signal to main
+
+(async function setupESMWorker() {
+  const customLoaders = getOptionValue('--experimental-loader');
+  hooks.addCustomLoaders(customLoaders);
+
+  while (true) {
+    debug('blocking worker thread until main thread is ready');
+
+    Atomics.wait(lock, 0, 1); // This pauses the while loop
+
+    debug('worker awakened');
+
+    let type, args;
+    try {
+      ({ type, args } = deserialize(requestResponseData));
+    } catch(err) {
+      debug('deserialising request failed');
+      throw err;
+    }
+debug('worker request', { type, args })
+    const response = await ReflectApply(hooks[type], publicESMLoader, args);
+    requestResponseData.fill(0);
+debug('worker response', response)
+    requestResponseData.set(serialize(response));
+    releaseLock();
+  }
+})().catch((err) => {
+  releaseLock();
+  debug('worker failed to handle request', err);
+  triggerUncaughtException(err);
+});
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 9a04e094e001c4..de2b8c20529a1f 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -12,8 +12,8 @@ const {
 const { pathToFileURL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
 
-const esmLoader = new ESMLoader();
-exports.esmLoader = esmLoader;
+const publicESMLoader = new ESMLoader();
+exports.esmLoader = publicESMLoader;
 
 // Module.runMain() causes loadESM() to re-run (which it should do); however, this should NOT cause
 // ESM to be re-initialized; doing so causes duplicate custom loaders to be added to the public
@@ -59,8 +59,8 @@ async function initializeLoader() {
 
   // Hooks must then be added to external/public loader
   // (so they're triggered in userland)
-  esmLoader.addCustomLoaders(allLoaders);
-  esmLoader.preload();
+  publicESMLoader.addCustomLoaders(allLoaders);
+  publicESMLoader.preload();
 
   // Preload after loaders are added so they can be used
   if (preloadModules?.length) {
@@ -91,7 +91,7 @@ function loadModulesInIsolation(parentURL, specifiers, loaders = []) {
 exports.loadESM = async function loadESM(callback) {
   try {
     await initializeLoader();
-    await callback(esmLoader);
+    await callback(publicESMLoader);
   } catch (err) {
     if (hasUncaughtExceptionCaptureCallback()) {
       process._fatalException(err);
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 3b4b2f6ffaf0dc..47921179913bed 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -128,7 +128,13 @@ function assignEnvironmentData(data) {
 class Worker extends EventEmitter {
   constructor(filename, options = kEmptyObject) {
     super();
-    debug(`[${threadId}] create new worker`, filename, options);
+    const isInternal = this instanceof InternalWorker;
+    debug(
+      `[${threadId}] create new worker`,
+      filename,
+      options,
+      `isInternal: ${isInternal}`,
+    );
     if (options.execArgv)
       validateArray(options.execArgv, 'options.execArgv');
 
@@ -139,7 +145,10 @@ class Worker extends EventEmitter {
     }
 
     let url, doEval;
-    if (options.eval) {
+    if (isInternal) {
+      doEval = 'internal';
+      url = `node:${filename}`;
+    } else if (options.eval) {
       if (typeof filename !== 'string') {
         throw new ERR_INVALID_ARG_VALUE(
           'options.eval',
@@ -195,6 +204,7 @@ class Worker extends EventEmitter {
       name = StringPrototypeTrim(options.name);
     }
 
+    debug('instantiating Worker.', `url: ${url}`, `doEval: ${doEval}`);
     // Set up the C++ handle for the worker, as well as some internal wiring.
     this[kHandle] = new WorkerImpl(url,
                                    env === process.env ? null : env,
@@ -252,6 +262,7 @@ class Worker extends EventEmitter {
       type: messageTypes.LOAD_SCRIPT,
       filename,
       doEval,
+      isInternal,
       cwdCounter: cwdCounter || workerIo.sharedCwdCounter,
       workerData: options.workerData,
       environmentData,
@@ -441,6 +452,13 @@ class Worker extends EventEmitter {
   }
 }
 
+class InternalWorker extends Worker {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(filename, options) {
+    super(filename, options);
+  }
+}
+
 function pipeWithoutWarning(source, dest) {
   const sourceMaxListeners = source._maxListeners;
   const destMaxListeners = dest._maxListeners;
@@ -505,6 +523,7 @@ function eventLoopUtilization(util1, util2) {
 
 module.exports = {
   ownsProcessState,
+  kIsOnline,
   isMainThread,
   SHARE_ENV,
   resourceLimits:
@@ -513,5 +532,6 @@ module.exports = {
   getEnvironmentData,
   assignEnvironmentData,
   threadId,
+  InternalWorker,
   Worker,
 };
diff --git a/src/env-inl.h b/src/env-inl.h
index 7b135c7b83293a..f3192f19f551f6 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -636,8 +636,7 @@ inline bool Environment::owns_inspector() const {
 }
 
 inline bool Environment::should_create_inspector() const {
-  return (flags_ & EnvironmentFlags::kNoCreateInspector) == 0 &&
-         !options_->test_runner && !options_->watch_mode;
+  return (flags_ & EnvironmentFlags::kNoCreateInspector) == 0; // ! FIXME: do not merge
 }
 
 inline bool Environment::tracks_unmanaged_fds() const {

From a0bb205304bb96aa781a655c616e4d0628ebb2c7 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Mon, 9 Jan 2023 17:09:40 -0800
Subject: [PATCH 002/126] esm: resolve optionally returns import assertions

---
 doc/api/esm.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 6293779131e4e0..481f8cbc43bcb2 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -752,7 +752,7 @@ changes:
 > signature may change. Do not rely on the API described below.
 
 * `specifier` {string}
-* `context` {Object}
+* `context` {object}
   * `conditions` {string\[]} Export conditions of the relevant `package.json`
   * `importAssertions` {Object} An object whose key-value pairs represent the
     assertions for the module to import
@@ -846,16 +846,16 @@ changes:
 > deprecated, hooks (`getFormat`, `getSource`, and `transformSource`).
 
 * `url` {string} The URL returned by the `resolve` chain
-* `context` {Object}
+* `context` {object}
   * `conditions` {string\[]} Export conditions of the relevant `package.json`
   * `format` {string|null|undefined} The format optionally supplied by the
     `resolve` hook chain
-  * `importAssertions` {Object}
+  * `importAssertions` {object}
 * `nextLoad` {Function} The subsequent `load` hook in the chain, or the
   Node.js default `load` hook after the last user-supplied `load` hook
   * `specifier` {string}
-  * `context` {Object}
-* Returns: {Object}
+  * `context` {object}
+* Returns: {object}
   * `format` {string}
   * `shortCircuit` {undefined|boolean} A signal that this hook intends to
     terminate the chain of `resolve` hooks. **Default:** `false`
@@ -943,7 +943,7 @@ changes:
 > In a previous version of this API, this hook was named
 > `getGlobalPreloadCode`.
 
-* `context` {Object} Information to assist the preload code
+* `context` {object} Information to assist the preload code
   * `port` {MessagePort}
 * Returns: {string} Code to run before application startup
 

From cd16ccdf852c61869078e381f08dbaa22aca58f6 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Tue, 20 Dec 2022 23:28:55 +0100
Subject: [PATCH 003/126] port updates to `worker_thread`

---
 lib/internal/main/worker_thread.js | 78 ++++++++++++++++++------------
 1 file changed, 47 insertions(+), 31 deletions(-)

diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 2ebfb849663eb6..e5489ce9908daf 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -89,17 +89,19 @@ port.on('message', (message) => {
     const {
       argv,
       cwdCounter,
-      filename,
       doEval,
-      workerData,
       environmentData,
-      publicPort,
+      filename,
+      hasStdin,
       manifestSrc,
       manifestURL,
-      hasStdin,
+      publicPort,
+      workerData,
     } = message;
 
-    if (argv !== undefined) {
+    debug(`LOAD_SCRIPT (${doEval}): ${filename}`);
+
+    if (doEval !== 'internal' && argv !== undefined) {
       ArrayPrototypePushApply(process.argv, argv);
     }
 
@@ -130,7 +132,7 @@ port.on('message', (message) => {
     if (manifestSrc) {
       require('internal/process/policy').setup(manifestSrc, manifestURL);
     }
-    setupUserModules();
+    if (doEval !== 'internal') setupUserModules();
 
     if (!hasStdin)
       process.stdin.push(null);
@@ -138,31 +140,45 @@ port.on('message', (message) => {
     debug(`[${threadId}] starts worker script ${filename} ` +
           `(eval = ${doEval}) at cwd = ${process.cwd()}`);
     port.postMessage({ type: UP_AND_RUNNING });
-    if (doEval === 'classic') {
-      const { evalScript } = require('internal/process/execution');
-      const name = '[worker eval]';
-      // This is necessary for CJS module compilation.
-      // TODO: pass this with something really internal.
-      ObjectDefineProperty(process, '_eval', {
-        __proto__: null,
-        configurable: true,
-        enumerable: true,
-        value: filename,
-      });
-      ArrayPrototypeSplice(process.argv, 1, 0, name);
-      evalScript(name, filename);
-    } else if (doEval === 'module') {
-      const { evalModule } = require('internal/process/execution');
-      PromisePrototypeThen(evalModule(filename), undefined, (e) => {
-        workerOnGlobalUncaughtException(e, true);
-      });
-    } else {
-      // script filename
-      // runMain here might be monkey-patched by users in --require.
-      // XXX: the monkey-patchability here should probably be deprecated.
-      ArrayPrototypeSplice(process.argv, 1, 0, filename);
-      const CJSLoader = require('internal/modules/cjs/loader');
-      CJSLoader.Module.runMain(filename);
+    switch (doEval) {
+      case 'internal': {
+        require(filename);
+        break;
+      }
+
+      case 'classic': {
+        const { evalScript } = require('internal/process/execution');
+        const name = '[worker eval]';
+        // This is necessary for CJS module compilation.
+        // TODO: pass this with something really internal.
+        ObjectDefineProperty(process, '_eval', {
+          __proto__: null,
+          configurable: true,
+          enumerable: true,
+          value: filename,
+        });
+        ArrayPrototypeSplice(process.argv, 1, 0, name);
+        evalScript(name, filename);
+        break;
+      }
+
+      case 'module': {
+        const { evalModule } = require('internal/process/execution');
+        PromisePrototypeThen(evalModule(filename), undefined, (e) => {
+          workerOnGlobalUncaughtException(e, true);
+        });
+        break;
+      }
+
+      default: {
+        // script filename
+        // runMain here might be monkey-patched by users in --require.
+        // XXX: the monkey-patchability here should probably be deprecated.
+        ArrayPrototypeSplice(process.argv, 1, 0, filename);
+        const CJSLoader = require('internal/modules/cjs/loader');
+        CJSLoader.Module.runMain(filename);
+        break;
+      }
     }
   } else if (message.type === STDIO_PAYLOAD) {
     const { stream, chunks } = message;

From 01f1191ef8d8271f3b3a232b180bed43d2c7dc02 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Tue, 20 Dec 2022 23:33:12 +0100
Subject: [PATCH 004/126] move `HooksProxy` to `hooks.js`

---
 lib/internal/modules/esm/hooks.js  | 89 ++++++++++++++++++++++++++++--
 lib/internal/modules/esm/loader.js | 86 +++++------------------------
 2 files changed, 97 insertions(+), 78 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 513204bb9d7e48..268ba4cd1811e6 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -1,5 +1,16 @@
 'use strict';
 
+// let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+//   debug = fn;
+// });
+const { appendFileSync } = require('fs');
+const { inspect } = require('util');
+function debug(...args) {
+  appendFileSync('/dev/fd/1',
+    'Hooks: ' + args.map((arg) => inspect(arg)).join(' ') + '\n'
+  );
+}
+
 const {
   ArrayPrototypeJoin,
   ArrayPrototypePush,
@@ -10,6 +21,8 @@ const {
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
+  TypedArrayPrototypeFill,
+  TypedArrayPrototypeSet,
   globalThis,
 } = primordials;
 
@@ -83,15 +96,13 @@ class Hooks {
     ],
   };
 
-  // Enable an optimization in ESMLoader.getModuleJob
-  hasCustomResolveOrLoadHooks = false;
-
   // Cache URLs we've already validated to avoid repeated validation
   #validatedUrls = new SafeSet();
 
   #importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
 
   constructor(userLoaders) {
+    debug('initialising');
     this.#addCustomLoaders(userLoaders);
   }
 
@@ -104,6 +115,7 @@ class Hooks {
   #addCustomLoaders(
     customLoaders = [],
   ) {
+    debug('adding custom loaders')
     for (let i = 0; i < customLoaders.length; i++) {
       const {
         exports,
@@ -135,7 +147,6 @@ class Hooks {
         );
       }
       if (load) {
-        this.hasCustomResolveOrLoadHooks = true;
         ArrayPrototypePush(
           this.#hooks.load,
           {
@@ -515,9 +526,76 @@ class Hooks {
     };
   }
 }
-
 ObjectSetPrototypeOf(Hooks.prototype, null);
 
+class HooksProxy {
+  /**
+   * The communication vehicle constituting all memory shared between the main and the worker.
+   */
+  #commsChannel = new SharedArrayBuffer(2048); // maybe use buffer.constants.MAX_LENGTH ?
+  /**
+   * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
+   * segment is used to tell the main to sleep when the worker is processing, and vice versa
+   * (for the worker to sleep whilst the main thread is processing).
+   * 0 -> main sleeps
+   * 1 -> worker sleeps
+   */
+  #lock = new Int32Array(this.#commsChannel, 0, 4);
+  /**
+   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
+   * requests & responses into a format supported by the comms channel) reads and writes with
+   * Uint8Array.
+   */
+  #requestResponseData = new Uint8Array(this.#commsChannel, 4, 2044);
+
+  #isReady = false;
+
+  constructor() {
+    const { InternalWorker } = require('internal/worker');
+    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
+      stderr: false,
+      stdin: false,
+      stdout: false,
+      trackUnmanagedFds: false,
+      workerData: { commsChannel: this.#commsChannel },
+    });
+    worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
+  }
+
+  makeRequest(type, ...args) {
+    if (!this.#isReady) {
+      const { kIsOnline } = require('internal/worker');
+      if (!this.worker[kIsOnline]) {
+        debug('blocking main thread until the loader thread is ready');
+        Atomics.wait(this.#lock, 0, 0); // ! Block this module until the worker is ready.
+        debug('main thread awakened');
+      }
+
+      this.#isReady = true;
+    }
+
+    const { deserialize, serialize } = require('v8');
+
+    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
+
+    const request = serialize({ type, args });
+    debug(
+      `sending ${type} request to worker (and then sleeping) with`,
+      ...(args.length ? args : ['no args']),
+    );
+    TypedArrayPrototypeSet(this.#requestResponseData, request);
+
+    Atomics.store(this.#lock, 0, 0); // Send request to worker
+    Atomics.notify(this.#lock, 0); // Notify worker of new request
+    debug('notified worker of request; sleeping main.')
+    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
+
+    debug(`received response from worker for ${type} request`, this.#requestResponseData);
+    return deserialize(this.#requestResponseData);
+  }
+}
+ObjectSetPrototypeOf(HooksProxy.prototype, null);
+
 
 /**
  * A utility function to pluck the hooks from a user-defined loader.
@@ -665,3 +743,4 @@ function nextHookFactory(chain, meta, { validateArgs, validateOutput }) {
 
 
 exports.Hooks = Hooks;
+exports.HooksProxy = HooksProxy;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 96e816adc0433f..e24bafd23baec7 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -37,75 +37,12 @@ function getTranslators() {
   return translators;
 }
 
-class HooksProxy {
-  /**
-   * The communication vehicle constituting all memory shared between the main and the worker.
-   */
-  #commsChannel = new SharedArrayBuffer(2048); // maybe use buffer.constants.MAX_LENGTH ?
-  /**
-   * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
-   * segment is used to tell the main to sleep when the worker is processing, and vice versa
-   * (for the worker to sleep whilst the main thread is processing).
-   * 0 -> main sleeps
-   * 1 -> worker sleeps
-   */
-  #lock = new Int32Array(this.#commsChannel, 0, 4);
-  /**
-   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
-   * requests & responses into a format supported by the comms channel) reads and writes with
-   * Uint8Array.
-   */
-  #requestResponseData = new Uint8Array(this.#commsChannel, 4, 2044);
-
-  #isReady = false;
-
-  constructor() {
-    const { InternalWorker } = require('internal/worker');
-    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
-      stderr: false,
-      stdin: false,
-      stdout: false,
-      trackUnmanagedFds: false,
-      workerData: { commsChannel: this.#commsChannel },
-    });
-    worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
-  }
-
-  makeRequest(type, ...args) {
-    if (!this.#isReady) {
-      const { kIsOnline } = require('internal/worker');
-      if (!this.worker[kIsOnline]) {
-        debug('blocking main thread until the loader thread is ready');
-        Atomics.wait(this.#lock, 0, 0); // ! Block this module until the worker is ready.
-      }
-
-      this.#isReady = true;
-    }
-
-    const { deserialize, serialize } = require('v8');
-
-    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
-
-    const request = serialize({ type, args });
-    debug(`sending ${type} request to worker (and then sleeping) with args`, ...args);
-    TypedArrayPrototypeSet(this.#requestResponseData, request);
-
-    Atomics.store(this.#lock, 0, 0); // Send request to worker
-    Atomics.notify(this.#lock, 0); // Notify worker of new request
-    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
-
-    debug(`received response from worker for ${type} request`, this.#requestResponseData);
-    return deserialize(this.#requestResponseData);
-  }
-}
-ObjectSetPrototypeOf(HooksProxy.prototype, null);
-
 /**
  * Multiple instances of ESMLoader exist for various, specific reasons (see code comments at site).
  * In order to maintain consitency, we use a single worker (sandbox), which must sit apart of an
  * individual ESMLoader instance.
  */
-let hookProxy;
+let hooksProxy;
 
 /**
  * @typedef {object} ExportedHooks
@@ -179,11 +116,14 @@ class ESMLoader {
   }
 
   addCustomLoaders() {
-    hookProxy ??= new HooksProxy(); // The worker adds custom hooks as part of its startup.
+    if (hooksProxy) { return; }
+
+    const { HooksProxy } = require('internal/modules/esm/hooks');
+    hooksProxy = new HooksProxy(); // The worker adds custom hooks as part of its startup.
   }
 
   preload() {
-    hookProxy?.makeRequest('preload');
+    hooksProxy?.makeRequest('preload');
   }
 
   async eval(
@@ -232,7 +172,7 @@ class ESMLoader {
 
     // We can skip cloning if there are no user-provided loaders because
     // the Node.js default resolve hook does not use import assertions.
-    if (hookProxy) { // This exists only when there are custom hooks.
+    if (hooksProxy) { // This exists only when there are custom hooks.
       // This method of cloning only works so long as import assertions cannot contain objects as values,
       // which they currently cannot per spec.
       importAssertionsForResolve = {
@@ -376,8 +316,8 @@ class ESMLoader {
    * @returns {Promise<{ format: string, url: URL['href'] }>}
    */
   async resolve(originalSpecifier, parentURL, importAssertions) {
-    if (this.#hooks) {
-      return this.#hooks.resolve(originalSpecifier, parentURL, importAssertions);
+    if (hooksProxy) {
+      return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
     }
 
     if (!this.#defaultResolve) {
@@ -402,8 +342,8 @@ class ESMLoader {
    */
   async load(url, context) {
     let loadResult;
-    if (hookProxy) {
-      loadResult = await hookProxy.makeRequest('load', url, context);
+    if (hooksProxy) {
+      loadResult = await hooksProxy.makeRequest('load', url, context);
     } else {
       if (!this.#defaultLoad) {
         this.#defaultLoad = require('internal/modules/esm/load').defaultLoad;
@@ -420,8 +360,8 @@ class ESMLoader {
   }
 
   importMetaInitialize(meta, context) {
-    if (hookProxy) {
-      return hookProxy.makeRequest('importMetaInitialize', meta, context);
+    if (hooksProxy) {
+      return hooksProxy.makeRequest('importMetaInitialize', meta, context);
     }
 
     if (!this.#importMetaInitializer) {

From 5f0229735a83da47da043a085a030ad4dfd134e9 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Tue, 20 Dec 2022 23:34:32 +0100
Subject: [PATCH 005/126] =?UTF-8?q?`ESMLoader::addCustomLoaders`=20?=
 =?UTF-8?q?=E2=86=92=20`ESMLoader::registerCustomLoaders`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/internal/modules/esm/loader.js | 2 +-
 lib/internal/process/esm_loader.js | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index e24bafd23baec7..8f35dc1be1e676 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -115,7 +115,7 @@ class ESMLoader {
     }
   }
 
-  addCustomLoaders() {
+  registerCustomLoaders() {
     if (hooksProxy) { return; }
 
     const { HooksProxy } = require('internal/modules/esm/hooks');
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index de2b8c20529a1f..6b4f4f41d6b7b5 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -43,6 +43,7 @@ async function initializeLoader() {
 
   const parentURL = pathToFileURL(cwd).href;
 
+  // TODO: move this to worker
   for (let i = 0; i < customLoaders.length; i++) {
     const customLoader = customLoaders[i];
 
@@ -53,13 +54,13 @@ async function initializeLoader() {
       kEmptyObject,
     );
 
-    internalEsmLoader.addCustomLoaders(keyedExportsSublist);
+    internalEsmLoader.registerCustomLoaders(keyedExportsSublist);
     ArrayPrototypePushApply(allLoaders, keyedExportsSublist);
   }
 
   // Hooks must then be added to external/public loader
   // (so they're triggered in userland)
-  publicESMLoader.addCustomLoaders(allLoaders);
+  publicESMLoader.registerCustomLoaders(allLoaders);
   publicESMLoader.preload();
 
   // Preload after loaders are added so they can be used
@@ -77,7 +78,7 @@ function loadModulesInIsolation(parentURL, specifiers, loaders = []) {
   // 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);
+  internalEsmLoader.registerCustomLoaders(loaders);
   internalEsmLoader.preload();
 
   // Importation must be handled by internal loader to avoid polluting userland

From 820aa5560446062d0b695ae5ae90442ed597d400 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Tue, 20 Dec 2022 23:37:51 +0100
Subject: [PATCH 006/126] fix startup issues in hooks worker

Hooks initialisation has a cart-before-the-horse issue (see fixme in worker)
---
 lib/internal/modules/esm/worker.js | 46 +++++++++++++++++++-----------
 1 file changed, 29 insertions(+), 17 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 70381af0926ab4..d3b16545be7fd2 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,16 +1,17 @@
 'use strict';
 
-const { appendFileSync, writeFileSync } = require('fs');
+const { appendFileSync } = require('fs');
 const { inspect } = require('util');
 
-function debug(...args) {
-  appendFileSync('./__debug.log', args.map((arg) => inspect(arg)).join(' ') + '\n');
-}
-writeFileSync('./__debug.log', 'worker for public ESM running\n');
-
 // let debug = require('internal/util/debuglog').debuglog('esm_worker', (fn) => {
 //   debug = fn;
 // });
+function debug(...args) {
+  appendFileSync('/dev/fd/1',
+    'esm_worker: ' + args.map((arg) => inspect(arg)).join(' ') + '\n'
+  );
+}
+debug('worker running');
 
 const {
   ReflectApply,
@@ -20,29 +21,39 @@ const {
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
-const { triggerUncaughtException } = internalBinding('errors');
-const { Hooks } = require('internal/modules/esm/hooks');
-const { workerData } = require('worker_threads');
-const { deserialize, serialize } = require('v8');
+const { workerData: { commsChannel } } = require('worker_threads');
 
-const { commsChannel } = workerData;
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(commsChannel, 0, 4); // Required by Atomics
-const requestResponseData = new Uint8Array(commsChannel, 4, 2044); // For v8.serialize/deserialize
-
-const hooks = new Hooks();
+const requestResponseData = new Uint8Array(commsChannel, 4, 2044); // For v8.deserialize/serialize
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
   Atomics.notify(lock, 0); // Notify main of new response
 }
 
-releaseLock(); // Send 'ready' signal to main
-
+/**
+ * ! Put everything possible within this function so errors get reported.
+ */
 (async function setupESMWorker() {
+  debug('starting sandbox setup');
+  const { initializeESM } = require('internal/modules/esm/utils');
+  debug('initialising ESM');
+  initializeESM();
+
+  const { getOptionValue } = require('internal/options');
   const customLoaders = getOptionValue('--experimental-loader');
-  hooks.addCustomLoaders(customLoaders);
+  const { Hooks } = require('internal/modules/esm/hooks');
+  // FIXME: custom loaders need to already be import()'d. handle main-side and pass as a request?
+  const hooks = new Hooks(customLoaders);
+  debug('hooks inititalised');
+
+  // ! Put as little above this line as possible
+  releaseLock(); // Send 'ready' signal to main
+  debug('lock released; main notified worker is up.');
+
+  const { deserialize, serialize } = require('v8');
 
   while (true) {
     debug('blocking worker thread until main thread is ready');
@@ -66,6 +77,7 @@ debug('worker response', response)
     releaseLock();
   }
 })().catch((err) => {
+  const { triggerUncaughtException } = internalBinding('errors');
   releaseLock();
   debug('worker failed to handle request', err);
   triggerUncaughtException(err);

From 231b9644b6a10684653d7aa43b4b6081e0ca410b Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Wed, 21 Dec 2022 00:01:35 +0100
Subject: [PATCH 007/126] WIP: move importing custom loaders back to main
 thread

---
 lib/internal/modules/esm/hooks.js  | 38 ++++++++++++++++++++----------
 lib/internal/modules/esm/loader.js |  4 ++--
 lib/internal/process/esm_loader.js |  1 -
 3 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 268ba4cd1811e6..cb2f8e87683ba7 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -550,7 +550,11 @@ class HooksProxy {
 
   #isReady = false;
 
-  constructor() {
+  /**
+   * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
+   *  (as returned by `ESMLoader.import()`).
+   */
+  constructor(customLoaders) {
     const { InternalWorker } = require('internal/worker');
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
@@ -560,6 +564,22 @@ class HooksProxy {
       workerData: { commsChannel: this.#commsChannel },
     });
     worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
+
+    debug('setting initial data for worker', customLoaders);
+    this.#setRequest('init', customLoaders);
+  }
+
+  #setRequest(type, ...args) {
+    const { serialize } = require('v8');
+
+    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
+
+    const request = serialize({ type, args });
+    debug(
+      `sending ${type} request to worker (and then sleeping) with`,
+      ...(args.length ? args : ['no args']),
+    );
+    TypedArrayPrototypeSet(this.#requestResponseData, request);
   }
 
   makeRequest(type, ...args) {
@@ -574,22 +594,16 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    const { deserialize, serialize } = require('v8');
-
-    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
-
-    const request = serialize({ type, args });
-    debug(
-      `sending ${type} request to worker (and then sleeping) with`,
-      ...(args.length ? args : ['no args']),
-    );
-    TypedArrayPrototypeSet(this.#requestResponseData, request);
+    this.#setRequest(type, ...args);
 
     Atomics.store(this.#lock, 0, 0); // Send request to worker
     Atomics.notify(this.#lock, 0); // Notify worker of new request
-    debug('notified worker of request; sleeping main.')
+    debug('notified worker of request; sleeping main.');
+
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
 
+    const { deserialize } = require('v8');
+
     debug(`received response from worker for ${type} request`, this.#requestResponseData);
     return deserialize(this.#requestResponseData);
   }
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 8f35dc1be1e676..a97f7fa334b369 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -115,11 +115,11 @@ class ESMLoader {
     }
   }
 
-  registerCustomLoaders() {
+  registerCustomLoaders(customLoaders) {
     if (hooksProxy) { return; }
 
     const { HooksProxy } = require('internal/modules/esm/hooks');
-    hooksProxy = new HooksProxy(); // The worker adds custom hooks as part of its startup.
+    hooksProxy = new HooksProxy(customLoaders); // The worker adds custom hooks as part of its startup.
   }
 
   preload() {
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 6b4f4f41d6b7b5..335e98d70c7416 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -43,7 +43,6 @@ async function initializeLoader() {
 
   const parentURL = pathToFileURL(cwd).href;
 
-  // TODO: move this to worker
   for (let i = 0; i < customLoaders.length; i++) {
     const customLoader = customLoaders[i];
 

From ed412d5502c90fff770a46fd0f26db3e546646c5 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Thu, 22 Dec 2022 21:07:21 +0100
Subject: [PATCH 008/126] =?UTF-8?q?=F0=9F=8E=89=20`/test-esm-example-loade?=
 =?UTF-8?q?r.mjs`=20is=20passing!!?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/internal/main/worker_thread.js |  2 -
 lib/internal/modules/esm/hooks.js  | 45 ++++---------------
 lib/internal/modules/esm/loader.js | 17 +++----
 lib/internal/modules/esm/utils.js  | 55 ++++++++++++++++++++++-
 lib/internal/modules/esm/worker.js | 37 ++--------------
 lib/internal/process/esm_loader.js | 71 ++----------------------------
 6 files changed, 75 insertions(+), 152 deletions(-)

diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index e5489ce9908daf..428a326c60b9a4 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -99,8 +99,6 @@ port.on('message', (message) => {
       workerData,
     } = message;
 
-    debug(`LOAD_SCRIPT (${doEval}): ${filename}`);
-
     if (doEval !== 'internal' && argv !== undefined) {
       ArrayPrototypePushApply(process.argv, argv);
     }
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index cb2f8e87683ba7..3c6fb45dfdf101 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -1,16 +1,5 @@
 'use strict';
 
-// let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
-//   debug = fn;
-// });
-const { appendFileSync } = require('fs');
-const { inspect } = require('util');
-function debug(...args) {
-  appendFileSync('/dev/fd/1',
-    'Hooks: ' + args.map((arg) => inspect(arg)).join(' ') + '\n'
-  );
-}
-
 const {
   ArrayPrototypeJoin,
   ArrayPrototypePush,
@@ -102,7 +91,6 @@ class Hooks {
   #importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
 
   constructor(userLoaders) {
-    debug('initialising');
     this.#addCustomLoaders(userLoaders);
   }
 
@@ -115,7 +103,6 @@ class Hooks {
   #addCustomLoaders(
     customLoaders = [],
   ) {
-    debug('adding custom loaders')
     for (let i = 0; i < customLoaders.length; i++) {
       const {
         exports,
@@ -554,7 +541,7 @@ class HooksProxy {
    * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
    *  (as returned by `ESMLoader.import()`).
    */
-  constructor(customLoaders) {
+  constructor() {
     const { InternalWorker } = require('internal/worker');
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
@@ -564,47 +551,31 @@ class HooksProxy {
       workerData: { commsChannel: this.#commsChannel },
     });
     worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
-
-    debug('setting initial data for worker', customLoaders);
-    this.#setRequest('init', customLoaders);
-  }
-
-  #setRequest(type, ...args) {
-    const { serialize } = require('v8');
-
-    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
-
-    const request = serialize({ type, args });
-    debug(
-      `sending ${type} request to worker (and then sleeping) with`,
-      ...(args.length ? args : ['no args']),
-    );
-    TypedArrayPrototypeSet(this.#requestResponseData, request);
   }
 
   makeRequest(type, ...args) {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
-        debug('blocking main thread until the loader thread is ready');
-        Atomics.wait(this.#lock, 0, 0); // ! Block this module until the worker is ready.
-        debug('main thread awakened');
+        Atomics.wait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
       }
 
       this.#isReady = true;
     }
 
-    this.#setRequest(type, ...args);
+    const { serialize } = require('v8');
+
+    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
+
+    const request = serialize({ type, args });
+    TypedArrayPrototypeSet(this.#requestResponseData, request);
 
     Atomics.store(this.#lock, 0, 0); // Send request to worker
     Atomics.notify(this.#lock, 0); // Notify worker of new request
-    debug('notified worker of request; sleeping main.');
-
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
 
     const { deserialize } = require('v8');
 
-    debug(`received response from worker for ${type} request`, this.#requestResponseData);
     return deserialize(this.#requestResponseData);
   }
 }
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index a97f7fa334b369..4edb5d68e969a5 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -18,11 +18,6 @@ const {
 const { getOptionValue } = require('internal/options');
 const { pathToFileURL } = require('internal/url');
 const { emitExperimentalWarning } = require('internal/util');
-
-let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
-  debug = fn;
-});
-
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
@@ -115,15 +110,15 @@ class ESMLoader {
     }
   }
 
-  registerCustomLoaders(customLoaders) {
+  registerCustomLoaders() {
     if (hooksProxy) { return; }
 
-    const { HooksProxy } = require('internal/modules/esm/hooks');
-    hooksProxy = new HooksProxy(customLoaders); // The worker adds custom hooks as part of its startup.
-  }
+    const customLoaders = getOptionValue('--experimental-loader');
+
+    if (!customLoaders.length) { return; } // Nothing to do.
 
-  preload() {
-    hooksProxy?.makeRequest('preload');
+    const { HooksProxy } = require('internal/modules/esm/hooks');
+    hooksProxy = new HooksProxy(); // The worker adds custom hooks as part of its startup.
   }
 
   async eval(
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index bf3edc86518b4c..f0d9d6a7d38e11 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -1,6 +1,8 @@
 'use strict';
+
 const {
   ArrayIsArray,
+  ArrayPrototypePushApply,
   SafeSet,
   SafeWeakMap,
   ObjectFreeze,
@@ -10,9 +12,9 @@ const {
   ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,
   ERR_INVALID_ARG_VALUE,
 } = require('internal/errors').codes;
-
 const { getOptionValue } = require('internal/options');
-
+const { pathToFileURL } = require('internal/url');
+const { kEmptyObject } = require('internal/util');
 const {
   setImportModuleDynamicallyCallback,
   setInitializeImportMetaObjectCallback,
@@ -97,9 +99,58 @@ function initializeESM() {
   setImportModuleDynamicallyCallback(importModuleDynamicallyCallback);
 }
 
+async function initializeHooks() {
+  const customLoaderPaths = getOptionValue('--experimental-loader');
+
+  let cwd;
+  try {
+    cwd = process.cwd() + '/';
+  } catch {
+    cwd = '/';
+  }
+
+  const { ESMLoader } = require('internal/modules/esm/loader');
+  const internalEsmLoader = new ESMLoader();
+  const importedCustomLoaders = [];
+
+  const parentURL = pathToFileURL(cwd).href;
+
+  for (let i = 0; i < customLoaderPaths.length; i++) {
+    const customLoaderPath = customLoaderPaths[i];
+
+    // Importation must be handled by internal loader to avoid polluting user-land
+    const keyedExportsSublist = await internalEsmLoader.import(
+      [customLoaderPath], // Import can handle multiple paths, but custom loaders must be sequential
+      parentURL,
+      kEmptyObject,
+    );
+
+    ArrayPrototypePushApply(importedCustomLoaders, keyedExportsSublist);
+  }
+
+  const { Hooks } = require('internal/modules/esm/hooks');
+  const hooks = new Hooks(importedCustomLoaders);
+
+  hooks.preload();
+
+  // Preload after loaders are added so they can be used
+  const preloadModules = getOptionValue('--import');
+
+  if (preloadModules) {
+    await internalEsmLoader.import(
+      preloadModules,
+      parentURL,
+      kEmptyObject,
+    );
+  }
+
+  return hooks;
+}
+
 module.exports = {
   setCallbackForWrap,
   initializeESM,
+  initializeHooks,
   getDefaultConditions,
   getConditionsSet,
 };
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index d3b16545be7fd2..c49134b5d7e5c1 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,18 +1,5 @@
 'use strict';
 
-const { appendFileSync } = require('fs');
-const { inspect } = require('util');
-
-// let debug = require('internal/util/debuglog').debuglog('esm_worker', (fn) => {
-//   debug = fn;
-// });
-function debug(...args) {
-  appendFileSync('/dev/fd/1',
-    'esm_worker: ' + args.map((arg) => inspect(arg)).join(' ') + '\n'
-  );
-}
-debug('worker running');
-
 const {
   ReflectApply,
   SafeWeakMap,
@@ -34,51 +21,35 @@ function releaseLock() {
 }
 
 /**
- * ! Put everything possible within this function so errors get reported.
+ * ! Run everything possible within this function so errors get reported.
  */
 (async function setupESMWorker() {
-  debug('starting sandbox setup');
-  const { initializeESM } = require('internal/modules/esm/utils');
-  debug('initialising ESM');
+  const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
   initializeESM();
 
-  const { getOptionValue } = require('internal/options');
-  const customLoaders = getOptionValue('--experimental-loader');
-  const { Hooks } = require('internal/modules/esm/hooks');
-  // FIXME: custom loaders need to already be import()'d. handle main-side and pass as a request?
-  const hooks = new Hooks(customLoaders);
-  debug('hooks inititalised');
+  const hooks = await initializeHooks();
 
   // ! Put as little above this line as possible
   releaseLock(); // Send 'ready' signal to main
-  debug('lock released; main notified worker is up.');
 
   const { deserialize, serialize } = require('v8');
 
   while (true) {
-    debug('blocking worker thread until main thread is ready');
-
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
-    debug('worker awakened');
-
     let type, args;
     try {
       ({ type, args } = deserialize(requestResponseData));
     } catch(err) {
-      debug('deserialising request failed');
       throw err;
     }
-debug('worker request', { type, args })
-    const response = await ReflectApply(hooks[type], publicESMLoader, args);
+    const response = await ReflectApply(hooks[type], hooks, args);
     requestResponseData.fill(0);
-debug('worker response', response)
     requestResponseData.set(serialize(response));
     releaseLock();
   }
 })().catch((err) => {
   const { triggerUncaughtException } = internalBinding('errors');
   releaseLock();
-  debug('worker failed to handle request', err);
   triggerUncaughtException(err);
 });
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 335e98d70c7416..21c83c463626a0 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,19 +1,12 @@
 'use strict';
 
-const {
-  ArrayIsArray,
-  ArrayPrototypePushApply,
-} = primordials;
-
 const { ESMLoader } = require('internal/modules/esm/loader');
 const {
   hasUncaughtExceptionCaptureCallback,
 } = require('internal/process/execution');
-const { pathToFileURL } = require('internal/url');
-const { kEmptyObject } = require('internal/util');
 
-const publicESMLoader = new ESMLoader();
-exports.esmLoader = publicESMLoader;
+const esmLoader = new ESMLoader();
+exports.esmLoader = esmLoader;
 
 // Module.runMain() causes loadESM() to re-run (which it should do); however, this should NOT cause
 // ESM to be re-initialized; doing so causes duplicate custom loaders to be added to the public
@@ -27,71 +20,15 @@ let isESMInitialized = false;
 async function initializeLoader() {
   if (isESMInitialized) { return; }
 
-  const { getOptionValue } = require('internal/options');
-  const customLoaders = getOptionValue('--experimental-loader');
-  const preloadModules = getOptionValue('--import');
-
-  let cwd;
-  try {
-    cwd = process.cwd() + '/';
-  } catch {
-    cwd = '/';
-  }
-
-  const internalEsmLoader = new ESMLoader();
-  const allLoaders = [];
-
-  const parentURL = pathToFileURL(cwd).href;
-
-  for (let i = 0; i < customLoaders.length; i++) {
-    const customLoader = customLoaders[i];
-
-    // Importation must be handled by internal loader to avoid polluting user-land
-    const keyedExportsSublist = await internalEsmLoader.import(
-      [customLoader],
-      parentURL,
-      kEmptyObject,
-    );
-
-    internalEsmLoader.registerCustomLoaders(keyedExportsSublist);
-    ArrayPrototypePushApply(allLoaders, keyedExportsSublist);
-  }
-
-  // Hooks must then be added to external/public loader
-  // (so they're triggered in userland)
-  publicESMLoader.registerCustomLoaders(allLoaders);
-  publicESMLoader.preload();
-
-  // Preload after loaders are added so they can be used
-  if (preloadModules?.length) {
-    await loadModulesInIsolation(parentURL, preloadModules, allLoaders);
-  }
+  esmLoader.registerCustomLoaders();
 
   isESMInitialized = true;
 }
 
-function loadModulesInIsolation(parentURL, specifiers, loaders = []) {
-  if (!ArrayIsArray(specifiers) || specifiers.length === 0) { return; }
-
-  // A separate loader instance is necessary to avoid cross-contamination
-  // 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.registerCustomLoaders(loaders);
-  internalEsmLoader.preload();
-
-  // Importation must be handled by internal loader to avoid polluting userland
-  return internalEsmLoader.import(
-    specifiers,
-    parentURL,
-    kEmptyObject,
-  );
-}
-
 exports.loadESM = async function loadESM(callback) {
   try {
     await initializeLoader();
-    await callback(publicESMLoader);
+    await callback(esmLoader);
   } catch (err) {
     if (hasUncaughtExceptionCaptureCallback()) {
       process._fatalException(err);

From 4776a6d664ec4146f9d33c7dadad1f3b098ee381 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Thu, 22 Dec 2022 22:02:02 -0800
Subject: [PATCH 009/126] Fix tests that are loading modules/esm/worker.js on
 the main thread

---
 lib/internal/modules/esm/worker.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index c49134b5d7e5c1..d12a0c99001f73 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -8,7 +8,9 @@ const {
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
-const { workerData: { commsChannel } } = require('worker_threads');
+const { isMainThread, workerData } = require('worker_threads');
+if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
+const { commsChannel } = workerData;
 
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps

From 2aed49a1e4fba890ba451a7d0a53d025315aab69 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Sat, 24 Dec 2022 00:09:27 +0100
Subject: [PATCH 010/126] WIP: convert resolve to sync

---
 doc/api/esm.md                                | 29 +++++---
 lib/internal/modules/esm/hooks.js             | 17 ++---
 .../modules/esm/initialize_import_meta.js     | 29 ++++----
 lib/internal/modules/esm/loader.js            | 18 ++---
 lib/internal/modules/esm/module_job.js        |  7 +-
 lib/internal/modules/esm/resolve.js           |  6 +-
 lib/internal/modules/esm/translators.js       |  7 +-
 lib/internal/modules/esm/worker.js            | 19 +++---
 lib/internal/process/esm_loader.js            |  6 +-
 .../test-esm-import-meta-resolve.mjs          | 68 +++++++++++--------
 test/es-module/test-esm-loader-search.js      |  2 +-
 test/es-module/test-esm-resolve-type.mjs      | 20 +++---
 12 files changed, 131 insertions(+), 97 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 481f8cbc43bcb2..28c05f173ed22b 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -7,6 +7,9 @@
 <!-- YAML
 added: v8.5.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/44710
+    description: Convert from asynchronous to synchronous.
   - version:
     - v18.6.0
     - v16.17.0
@@ -340,15 +343,19 @@ command flag enabled.
 * `specifier` {string} The module specifier to resolve relative to `parent`.
 * `parent` {string|URL} The absolute parent module URL to resolve from. If none
   is specified, the value of `import.meta.url` is used as the default.
-* Returns: {Promise}
+* Returns: {string}
 
 Provides a module-relative resolution function scoped to each module, returning
-the URL string.
+the URL string. In alignment with browser behavior, this now returns
+synchronously.
+
+> **Caveat** This can result in synchronous file-system operations, which
+> can impact performance similarly to `require.resolve`.
 
 <!-- eslint-skip -->
 
 ```js
-const dependencyAsset = await import.meta.resolve('component-lib/asset.css');
+const dependencyAsset = import.meta.resolve('component-lib/asset.css');
 ```
 
 `import.meta.resolve` also accepts a second argument which is the parent module
@@ -357,11 +364,11 @@ from which to resolve from:
 <!-- eslint-skip -->
 
 ```js
-await import.meta.resolve('./dep', import.meta.url);
+import.meta.resolve('./dep', import.meta.url);
 ```
 
-This function is asynchronous because the ES module resolver in Node.js is
-allowed to be asynchronous.
+This function is synchronous because the ES module resolver in Node.js is
+synchronous.
 
 ## Interoperability with CommonJS
 
@@ -734,6 +741,9 @@ prevent unintentional breaks in the chain.
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/44710
+    description: Convert hook from asynchronous to synchronous.
   - version:
     - v18.6.0
     - v16.17.0
@@ -772,6 +782,9 @@ changes:
     terminate the chain of `resolve` hooks. **Default:** `false`
   * `url` {string} The absolute URL to which this input resolves
 
+> **Caveat** A resolve hook can contain synchronous file-system operations
+> (as `defaultResolveHook()` does), which can impact performance.
+
 The `resolve` hook chain is responsible for telling Node.js where to find and
 how to cache a given `import` statement or expression. It can optionally return
 its format (such as `'module'`) as a hint to the `load` hook. If a format is
@@ -797,7 +810,7 @@ Node.js module specifier resolution behavior_ when calling `defaultResolve`, the
 `context.conditions` array originally passed into the `resolve` hook.
 
 ```js
-export async function resolve(specifier, context, nextResolve) {
+export function resolve(specifier, context, nextResolve) {
   const { parentURL = null } = context;
 
   if (Math.random() > 0.5) { // Some condition.
@@ -1100,7 +1113,7 @@ const baseURL = pathToFileURL(`${cwd()}/`).href;
 // CoffeeScript files end in .coffee, .litcoffee, or .coffee.md.
 const extensionsRegex = /\.coffee$|\.litcoffee$|\.coffee\.md$/;
 
-export async function resolve(specifier, context, nextResolve) {
+export function resolve(specifier, context, nextResolve) {
   if (extensionsRegex.test(specifier)) {
     const { parentURL = baseURL } = context;
 
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 3c6fb45dfdf101..c4c52272ae66fa 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -28,6 +28,10 @@ const {
   isAnyArrayBuffer,
   isArrayBufferView,
 } = require('internal/util/types');
+const {
+  deserialize,
+  serialize,
+} = require('v8');
 const {
   validateObject,
   validateString,
@@ -100,9 +104,7 @@ class Hooks {
    * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
    *  (as returned by `ESMLoader.import()`).
    */
-  #addCustomLoaders(
-    customLoaders = [],
-  ) {
+  #addCustomLoaders(customLoaders = []) {
     for (let i = 0; i < customLoaders.length; i++) {
       const {
         exports,
@@ -509,7 +511,7 @@ class Hooks {
       __proto__: null,
       format,
       responseURL,
-      source,
+      source: ''+source,
     };
   }
 }
@@ -563,8 +565,6 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    const { serialize } = require('v8');
-
     TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
 
     const request = serialize({ type, args });
@@ -574,9 +574,10 @@ class HooksProxy {
     Atomics.notify(this.#lock, 0); // Notify worker of new request
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
 
-    const { deserialize } = require('v8');
 
-    return deserialize(this.#requestResponseData);
+    const response = deserialize(this.#requestResponseData);
+
+    return response;
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index fe5ba4a3cc1248..f8a8fef03f90a8 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -1,23 +1,24 @@
 'use strict';
 
 const { getOptionValue } = require('internal/options');
-const experimentalImportMetaResolve =
-  getOptionValue('--experimental-import-meta-resolve');
-const {
-  PromisePrototypeThen,
-  PromiseReject,
-} = primordials;
+const experimentalImportMetaResolve = getOptionValue('--experimental-import-meta-resolve');
 const asyncESM = require('internal/process/esm_loader');
 
 function createImportMetaResolve(defaultParentUrl) {
-  return async function resolve(specifier, parentUrl = defaultParentUrl) {
-    return PromisePrototypeThen(
-      asyncESM.esmLoader.resolve(specifier, parentUrl),
-      ({ url }) => url,
-      (error) => (
-        error.code === 'ERR_UNSUPPORTED_DIR_IMPORT' ?
-          error.url : PromiseReject(error)),
-    );
+  return function resolve(specifier, parentUrl = defaultParentUrl) {
+    let url;
+
+    try {
+      ({ url } = asyncESM.esmLoader.resolve(specifier, parentUrl));
+    } catch (error) {
+      if (error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
+        ({ url } = error);
+      } else {
+        throw error;
+      }
+    }
+
+    return url;
   };
 }
 
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 4edb5d68e969a5..064e1f8c04998a 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -110,11 +110,9 @@ class ESMLoader {
     }
   }
 
-  registerCustomLoaders() {
+  registerCustomLoaders(customLoaders) {
     if (hooksProxy) { return; }
 
-    const customLoaders = getOptionValue('--experimental-loader');
-
     if (!customLoaders.length) { return; } // Nothing to do.
 
     const { HooksProxy } = require('internal/modules/esm/hooks');
@@ -162,7 +160,7 @@ class ESMLoader {
    *                                                  module import.
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  async getModuleJob(specifier, parentURL, importAssertions) {
+  getModuleJob(specifier, parentURL, importAssertions) {
     let importAssertionsForResolve;
 
     // We can skip cloning if there are no user-provided loaders because
@@ -176,7 +174,7 @@ class ESMLoader {
       };
     }
 
-    const resolveResult = await this.resolve(specifier, parentURL, importAssertionsForResolve);
+    const resolveResult = this.resolve(specifier, parentURL, importAssertionsForResolve);
     const { url, format } = resolveResult;
     const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
 
@@ -280,8 +278,9 @@ class ESMLoader {
     const jobs = new Array(count);
 
     for (let i = 0; i < count; i++) {
-      jobs[i] = this.getModuleJob(specifiers[i], parentURL, importAssertions)
-        .then((job) => job.run())
+      jobs[i] = this
+        .getModuleJob(specifiers[i], parentURL, importAssertions)
+        .run()
         .then(({ module }) => module.getNamespace());
     }
 
@@ -308,9 +307,9 @@ class ESMLoader {
    * @param {string} [parentURL] The URL path of the module's parent.
    * @param {ImportAssertions} importAssertions Assertions from the import
    *                                              statement or expression.
-   * @returns {Promise<{ format: string, url: URL['href'] }>}
+   * @returns {{ format: string, url: URL['href'] }}
    */
-  async resolve(originalSpecifier, parentURL, importAssertions) {
+  resolve(originalSpecifier, parentURL, importAssertions) {
     if (hooksProxy) {
       return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
     }
@@ -318,6 +317,7 @@ class ESMLoader {
     if (!this.#defaultResolve) {
       this.#defaultResolve = require('internal/modules/esm/resolve').defaultResolve;
     }
+
     const context = {
       __proto__: null,
       conditions: this.#defaultConditions,
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 2a0208dfc5cf8f..2cf2813a6dcf7f 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -72,10 +72,9 @@ class ModuleJob {
       // so that circular dependencies can't cause a deadlock by two of
       // these `link` callbacks depending on each other.
       const dependencyJobs = [];
-      const promises = this.module.link(async (specifier, assertions) => {
-        const jobPromise = this.loader.getModuleJob(specifier, url, assertions);
-        ArrayPrototypePush(dependencyJobs, jobPromise);
-        const job = await jobPromise;
+      const promises = this.module.link((specifier, assertions) => {
+        const job = this.loader.getModuleJob(specifier, url, assertions);
+        ArrayPrototypePush(dependencyJobs, job);
         return job.modulePromise;
       });
 
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index 5212e2ce17758d..113ebf37906058 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -963,7 +963,7 @@ function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports) {
   }
 }
 
-async function defaultResolve(specifier, context = {}) {
+function defaultResolve(specifier, context = {}) {
   let { parentURL, conditions } = context;
   if (parentURL && policy?.manifest) {
     const redirects = policy.manifest.getDependencyMapper(parentURL);
@@ -1109,11 +1109,11 @@ const {
 
 if (policy) {
   const $defaultResolve = defaultResolve;
-  module.exports.defaultResolve = async function defaultResolve(
+  module.exports.defaultResolve = function defaultResolve(
     specifier,
     context,
   ) {
-    const ret = await $defaultResolve(specifier, context);
+    const ret = $defaultResolve(specifier, context);
     // This is a preflight check to avoid data exfiltration by query params etc.
     policy.manifest.mightAllow(ret.url, () =>
       new ERR_MANIFEST_DEPENDENCY_MISSING(
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 267d89f1d44730..1fb560f6a02193 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -113,7 +113,12 @@ translators.set('module', async function moduleStrategy(url, source, isMain) {
   source = stringify(source);
   maybeCacheSourceMap(url, source);
   debug(`Translating StandardModule ${url}`);
-  const module = new ModuleWrap(url, undefined, source, 0, 0);
+  let module;
+  try {
+    module = new ModuleWrap(url, undefined, source, 0, 0);
+  } catch(e) {
+    console.error(e, { url, source});
+  }
   const { setCallbackForWrap } = require('internal/modules/esm/utils');
   setCallbackForWrap(module, {
     initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index d12a0c99001f73..d70bdf3ed3ce91 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,8 +1,15 @@
 'use strict';
 
 const {
+  Int32Array,
   ReflectApply,
   SafeWeakMap,
+  TypedArrayPrototypeFill,
+  TypedArrayPrototypeSet,
+  Uint8Array,
+  globalThis: {
+    Atomics,
+  },
 } = primordials;
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
@@ -39,15 +46,11 @@ function releaseLock() {
   while (true) {
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
-    let type, args;
-    try {
-      ({ type, args } = deserialize(requestResponseData));
-    } catch(err) {
-      throw err;
-    }
+    const { type, args } = deserialize(requestResponseData);
+    TypedArrayPrototypeFill(requestResponseData, 0);
+
     const response = await ReflectApply(hooks[type], hooks, args);
-    requestResponseData.fill(0);
-    requestResponseData.set(serialize(response));
+    TypedArrayPrototypeSet(requestResponseData, serialize(response));
     releaseLock();
   }
 })().catch((err) => {
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 21c83c463626a0..c8cb4150d9bc7a 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -20,7 +20,11 @@ let isESMInitialized = false;
 async function initializeLoader() {
   if (isESMInitialized) { return; }
 
-  esmLoader.registerCustomLoaders();
+  const { getOptionValue } = require('internal/options');
+
+  const customLoaders = getOptionValue('--experimental-loader');
+
+  esmLoader.registerCustomLoaders(customLoaders);
 
   isESMInitialized = true;
 }
diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index dc45610b460280..3430fa31e1f0e8 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -1,36 +1,44 @@
 // Flags: --experimental-import-meta-resolve
-import { mustCall } from '../common/index.mjs';
+import '../common/index.mjs';
 import assert from 'assert';
 
 const dirname = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
 const fixtures = dirname.slice(0, dirname.lastIndexOf('/', dirname.length - 2) + 1) + 'fixtures/';
 
-(async () => {
-  assert.strictEqual(await import.meta.resolve('./test-esm-import-meta.mjs'),
-                     dirname + 'test-esm-import-meta.mjs');
-  try {
-    await import.meta.resolve('./notfound.mjs');
-    assert.fail();
-  } catch (e) {
-    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
-  }
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/empty-with-bom.txt'),
-    fixtures + 'empty-with-bom.txt');
-  assert.strictEqual(await import.meta.resolve('../fixtures/'), fixtures);
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/', import.meta.url),
-    fixtures);
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/', new URL(import.meta.url)),
-    fixtures);
-  await Promise.all(
-    [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
-      assert.rejects(import.meta.resolve('../fixtures/', arg), {
-        code: 'ERR_INVALID_ARG_TYPE',
-      })
-    )
-  );
-  assert.strictEqual(await import.meta.resolve('baz/', fixtures),
-                     fixtures + 'node_modules/baz/');
-})().then(mustCall());
+assert.strictEqual(
+  import.meta.resolve('./test-esm-import-meta.mjs'),
+  dirname + 'test-esm-import-meta.mjs',
+);
+try {
+  import.meta.resolve('./notfound.mjs');
+  assert.fail();
+} catch (e) {
+  assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
+}
+assert.strictEqual(
+  import.meta.resolve('../fixtures/empty-with-bom.txt'),
+  fixtures + 'empty-with-bom.txt',
+);
+assert.strictEqual(
+  import.meta.resolve('../fixtures/'),
+  fixtures,
+);
+assert.strictEqual(
+  import.meta.resolve('../fixtures/', import.meta.url),
+  fixtures,
+);
+assert.strictEqual(
+  import.meta.resolve('../fixtures/', new URL(import.meta.url)),
+  fixtures,
+);
+Promise.all(
+  [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
+    assert.rejects(import.meta.resolve('../fixtures/', arg), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    })
+  )
+);
+assert.strictEqual(
+  import.meta.resolve('baz/', fixtures),
+  fixtures + 'node_modules/baz/',
+);
diff --git a/test/es-module/test-esm-loader-search.js b/test/es-module/test-esm-loader-search.js
index 0440d3d7775cff..068cadbb879404 100644
--- a/test/es-module/test-esm-loader-search.js
+++ b/test/es-module/test-esm-loader-search.js
@@ -10,7 +10,7 @@ const {
   defaultResolve: resolve
 } = require('internal/modules/esm/resolve');
 
-assert.rejects(
+assert.throws(
   resolve('target'),
   {
     code: 'ERR_MODULE_NOT_FOUND',
diff --git a/test/es-module/test-esm-resolve-type.mjs b/test/es-module/test-esm-resolve-type.mjs
index f594e56cf18510..539d2230c7d78b 100644
--- a/test/es-module/test-esm-resolve-type.mjs
+++ b/test/es-module/test-esm-resolve-type.mjs
@@ -37,16 +37,16 @@ try {
    * ensure that resolving by full path does not return the format
    * with the defaultResolver
    */
-  await Promise.all([
+  [
     [ '/es-modules/package-type-module/index.js', 'module' ],
     [ '/es-modules/package-type-commonjs/index.js', 'commonjs' ],
     [ '/es-modules/package-without-type/index.js', 'commonjs' ],
     [ '/es-modules/package-without-pjson/index.js', 'commonjs' ],
-  ].map(async ([ testScript, expectedType ]) => {
+  ].map(([ testScript, expectedType ]) => {
     const resolvedPath = path.resolve(fixtures.path(testScript));
-    const resolveResult = await resolve(url.pathToFileURL(resolvedPath));
+    const resolveResult = resolve(url.pathToFileURL(resolvedPath));
     assert.strictEqual(resolveResult.format, expectedType);
-  }));
+  });
 
   /**
    * create a test module and try to resolve it by module name.
@@ -85,7 +85,7 @@ try {
     fs.writeFileSync(script,
                      'export function esm-resolve-tester() {return 42}');
 
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedType);
 
     fs.rmSync(nmDir, { recursive: true, force: true });
@@ -168,14 +168,14 @@ try {
     );
 
     // test the resolve
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, 'module');
     assert.ok(resolveResult.url.includes('my-dual-package/es/index.js'));
   }
 
   // TestParameters are ModuleName, mainRequireScript, mainImportScript,
   // mainPackageType, subdirPkgJsonType, expectedResolvedFormat, mainSuffix
-  await Promise.all([
+  [
     [ 'mjs-mod-mod', 'index.js', 'index.mjs', 'module', 'module', 'module'],
     [ 'mjs-com-com', 'idx.js', 'idx.mjs', 'commonjs', 'commonjs', 'module'],
     [ 'mjs-mod-com', 'index.js', 'imp.mjs', 'module', 'commonjs', 'module'],
@@ -186,7 +186,7 @@ try {
     [ 'hmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '#Key'],
     [ 'qhmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '?k=v#h'],
     [ 'ts-mod-com', 'index.js', 'imp.ts', 'module', 'commonjs', undefined],
-  ].map(async (testVariant) => {
+  ].map((testVariant) => {
     const [
       moduleName,
       mainRequireScript,
@@ -234,10 +234,10 @@ try {
     );
 
     // test the resolve
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedFormat);
     assert.ok(resolveResult.url.endsWith(`${moduleName}/subdir/${mainImportScript}${mainSuffix}`));
-  }));
+  });
 
 } finally {
   process.chdir(previousCwd);

From 78a28891cb8aefd5da30713f42cb777afbd11e0f Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sun, 25 Dec 2022 22:29:39 -0800
Subject: [PATCH 011/126] Fix test

---
 test/es-module/test-esm-loader-search.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/es-module/test-esm-loader-search.js b/test/es-module/test-esm-loader-search.js
index 068cadbb879404..3c451409b356db 100644
--- a/test/es-module/test-esm-loader-search.js
+++ b/test/es-module/test-esm-loader-search.js
@@ -11,7 +11,7 @@ const {
 } = require('internal/modules/esm/resolve');
 
 assert.throws(
-  resolve('target'),
+  () => resolve('target'),
   {
     code: 'ERR_MODULE_NOT_FOUND',
     name: 'Error',

From 5746d178035d1a8fbd0ef3bee1a477ebdb073cb9 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sat, 24 Dec 2022 22:21:47 -0800
Subject: [PATCH 012/126] Restore parentURL validation to defaultResolve (and
 therefore also to import.meta.resolve)

---
 lib/internal/modules/esm/hooks.js             | 21 +++++--------------
 lib/internal/modules/esm/resolve.js           | 14 ++++++++++++-
 .../test-esm-import-meta-resolve.mjs          | 10 ++++-----
 3 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index c4c52272ae66fa..ae18b230058c20 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -23,7 +23,7 @@ const {
   ERR_INVALID_RETURN_PROPERTY_VALUE,
   ERR_INVALID_RETURN_VALUE,
 } = require('internal/errors').codes;
-const { isURL, URL } = require('internal/url');
+const { URL } = require('internal/url');
 const {
   isAnyArrayBuffer,
   isArrayBufferView,
@@ -38,7 +38,7 @@ const {
 } = require('internal/validators');
 
 const {
-  defaultResolve,
+  defaultResolve, throwIfInvalidParentURL,
 } = require('internal/modules/esm/resolve');
 const {
   getDefaultConditions,
@@ -257,19 +257,8 @@ class Hooks {
     parentURL,
     importAssertions = { __proto__: null },
   ) {
-    const isMain = parentURL === undefined;
+    throwIfInvalidParentURL(parentURL);
 
-    if (
-      !isMain &&
-      typeof parentURL !== 'string' &&
-      !isURL(parentURL)
-    ) {
-      throw new ERR_INVALID_ARG_TYPE(
-        'parentURL',
-        ['string', 'URL'],
-        parentURL,
-      );
-    }
     const chain = this.#hooks.resolve;
     const context = {
       conditions: getDefaultConditions(),
@@ -511,7 +500,7 @@ class Hooks {
       __proto__: null,
       format,
       responseURL,
-      source: ''+source,
+      source: '' + source,
     };
   }
 }
@@ -521,7 +510,7 @@ class HooksProxy {
   /**
    * The communication vehicle constituting all memory shared between the main and the worker.
    */
-  #commsChannel = new SharedArrayBuffer(2048); // maybe use buffer.constants.MAX_LENGTH ?
+  #commsChannel = new SharedArrayBuffer(2048); // Maybe use buffer.constants.MAX_LENGTH ?
   /**
    * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
    * segment is used to tell the main to sleep when the worker is processing, and vice versa
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index 113ebf37906058..249c550cc93b91 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -41,9 +41,10 @@ const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
 const experimentalNetworkImports =
   getOptionValue('--experimental-network-imports');
 const typeFlag = getOptionValue('--input-type');
-const { URL, pathToFileURL, fileURLToPath } = require('internal/url');
+const { URL, pathToFileURL, fileURLToPath, isURL } = require('internal/url');
 const {
   ERR_INPUT_TYPE_NOT_ALLOWED,
+  ERR_INVALID_ARG_TYPE,
   ERR_INVALID_MODULE_SPECIFIER,
   ERR_INVALID_PACKAGE_CONFIG,
   ERR_INVALID_PACKAGE_TARGET,
@@ -935,6 +936,15 @@ function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
   }
 }
 
+function throwIfInvalidParentURL(parentURL) {
+  if (parentURL === undefined) {
+    return; // Main entry point, so no parent
+  }
+  if (typeof parentURL !== 'string' && !isURL(parentURL)) {
+    throw new ERR_INVALID_ARG_TYPE('parentURL', ['string', 'URL'], parentURL);
+  }
+}
+
 function throwIfUnsupportedURLProtocol(url) {
   if (url.protocol !== 'file:' && url.protocol !== 'data:' &&
       url.protocol !== 'node:') {
@@ -965,6 +975,7 @@ function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports) {
 
 function defaultResolve(specifier, context = {}) {
   let { parentURL, conditions } = context;
+  throwIfInvalidParentURL(parentURL);
   if (parentURL && policy?.manifest) {
     const redirects = policy.manifest.getDependencyMapper(parentURL);
     if (redirects) {
@@ -1100,6 +1111,7 @@ module.exports = {
   getPackageType,
   packageExportsResolve,
   packageImportsResolve,
+  throwIfInvalidParentURL,
 };
 
 // cycle
diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index 3430fa31e1f0e8..e852a82393cc54 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -31,12 +31,10 @@ assert.strictEqual(
   import.meta.resolve('../fixtures/', new URL(import.meta.url)),
   fixtures,
 );
-Promise.all(
-  [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
-    assert.rejects(import.meta.resolve('../fixtures/', arg), {
-      code: 'ERR_INVALID_ARG_TYPE',
-    })
-  )
+[[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
+  assert.throws(() => {
+    import.meta.resolve('../fixtures/', arg)
+  }, { code: 'ERR_INVALID_ARG_TYPE' })
 );
 assert.strictEqual(
   import.meta.resolve('baz/', fixtures),

From c1afb3d9cbaf98a8feffc984ddc34dfa9e0ff9c3 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Mon, 26 Dec 2022 10:11:18 -0800
Subject: [PATCH 013/126] Improve deserialization error (sometimes)

---
 lib/internal/modules/esm/hooks.js | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index ae18b230058c20..f8cd099414a0cc 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -563,10 +563,15 @@ class HooksProxy {
     Atomics.notify(this.#lock, 0); // Notify worker of new request
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
 
-
-    const response = deserialize(this.#requestResponseData);
-
-    return response;
+    try {
+      return deserialize(this.#requestResponseData);
+    } catch (exception) {
+      if (this.#requestResponseData.every((byte) => byte === 0)) {
+        throw new ERR_INVALID_RETURN_VALUE('an object', type, undefined);
+      } else {
+        throw exception;
+      }
+    }
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);

From 666ee105fa34f319fcd973f7256e31716a51d0c3 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Mon, 26 Dec 2022 11:21:22 -0800
Subject: [PATCH 014/126] Rename #hooks to #chains

---
 lib/internal/modules/esm/hooks.js | 35 +++++++------------------------
 1 file changed, 8 insertions(+), 27 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index f8cd099414a0cc..a4d554c769b03e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -55,7 +55,7 @@ const {
 
 
 class Hooks {
-  #hooks = {
+  #chains = {
     /**
      * Prior to ESM loading. These are called once before any modules are started.
      * @private
@@ -117,32 +117,13 @@ class Hooks {
       } = pluckHooks(exports);
 
       if (globalPreload) {
-        ArrayPrototypePush(
-          this.#hooks.globalPreload,
-          {
-            fn: globalPreload,
-            url,
-          },
-        );
+        ArrayPrototypePush(this.#chains.globalPreload, { fn: globalPreload, url });
       }
       if (resolve) {
-        this.hasCustomResolveOrLoadHooks = true;
-        ArrayPrototypePush(
-          this.#hooks.resolve,
-          {
-            fn: resolve,
-            url,
-          },
-        );
+        ArrayPrototypePush(this.#chains.resolve, { fn: resolve, url });
       }
       if (load) {
-        ArrayPrototypePush(
-          this.#hooks.load,
-          {
-            fn: load,
-            url,
-          },
-        );
+        ArrayPrototypePush(this.#chains.load, { fn: load, url });
       }
     }
   }
@@ -151,7 +132,7 @@ class Hooks {
    * Initialize `globalPreload` hooks.
    */
   preload() {
-    for (let i = this.#hooks.globalPreload.length - 1; i >= 0; i--) {
+    for (let i = this.#chains.globalPreload.length - 1; i >= 0; i--) {
       const { MessageChannel } = require('internal/worker/io');
       const channel = new MessageChannel();
       const {
@@ -165,7 +146,7 @@ class Hooks {
       const {
         fn: preload,
         url: specifier,
-      } = this.#hooks.globalPreload[i];
+      } = this.#chains.globalPreload[i];
 
       const preloaded = preload({
         port: insideLoader,
@@ -259,7 +240,7 @@ class Hooks {
   ) {
     throwIfInvalidParentURL(parentURL);
 
-    const chain = this.#hooks.resolve;
+    const chain = this.#chains.resolve;
     const context = {
       conditions: getDefaultConditions(),
       importAssertions,
@@ -381,7 +362,7 @@ class Hooks {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context = {}) {
-    const chain = this.#hooks.load;
+    const chain = this.#chains.load;
     const meta = {
       chainFinished: null,
       context,

From 8198a1346f3ce3a3f2cbe3aeabbe0c98e47212ab Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Mon, 26 Dec 2022 14:40:36 -0800
Subject: [PATCH 015/126] Subclass customized module loader

---
 lib/internal/modules/esm/hooks.js             |   4 +-
 lib/internal/modules/esm/loader.js            | 147 +++++++++++-------
 lib/internal/modules/esm/utils.js             |   8 +-
 lib/internal/process/esm_loader.js            |  26 +---
 test/es-module/test-esm-loader-modulemap.js   |   4 +-
 ...oader-this-value-inside-hook-functions.mjs |   6 +-
 6 files changed, 105 insertions(+), 90 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index a4d554c769b03e..26ab698167fa0e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -102,7 +102,7 @@ class Hooks {
    * Collect custom/user-defined module loader hook(s).
    * After all hooks have been collected, the global preload hook(s) must be initialized.
    * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
-   *  (as returned by `ESMLoader.import()`).
+   *  (as returned by `ModuleLoader.import()`).
    */
   #addCustomLoaders(customLoaders = []) {
     for (let i = 0; i < customLoaders.length; i++) {
@@ -511,7 +511,7 @@ class HooksProxy {
 
   /**
    * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
-   *  (as returned by `ESMLoader.import()`).
+   *  (as returned by `ModuleLoader.import()`).
    */
   constructor() {
     const { InternalWorker } = require('internal/worker');
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 064e1f8c04998a..5557af23eb81dd 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -33,9 +33,9 @@ function getTranslators() {
 }
 
 /**
- * Multiple instances of ESMLoader exist for various, specific reasons (see code comments at site).
- * In order to maintain consitency, we use a single worker (sandbox), which must sit apart of an
- * individual ESMLoader instance.
+ * Multiple loader instances exist for various, specific reasons (see code comments at site).
+ * In order to maintain consistency, we use a single worker (sandbox), which must sit apart of an
+ * individual loader instance.
  */
 let hooksProxy;
 
@@ -66,12 +66,10 @@ let hooksProxy;
 
 
 /**
- * An ESMLoader instance is used as the main entry point for loading ES modules.
- * Currently, this is a singleton -- there is only one used for loading
- * the main module and everything in its dependency graph.
+ * This class covers the default case of an module loader instance where no custom user loaders are used.
+ * The below CustomizedModuleLoader class extends this one to support custom user loader hooks.
  */
-
-class ESMLoader {
+class DefaultModuleLoader {
   #defaultResolve;
   #defaultLoad;
   #importMetaInitializer;
@@ -102,23 +100,11 @@ class ESMLoader {
   translators = getTranslators();
 
   constructor() {
-    if (getOptionValue('--experimental-loader').length > 0) {
-      emitExperimentalWarning('Custom ESM Loaders');
-    }
     if (getOptionValue('--experimental-network-imports')) {
       emitExperimentalWarning('Network Imports');
     }
   }
 
-  registerCustomLoaders(customLoaders) {
-    if (hooksProxy) { return; }
-
-    if (!customLoaders.length) { return; } // Nothing to do.
-
-    const { HooksProxy } = require('internal/modules/esm/hooks');
-    hooksProxy = new HooksProxy(); // The worker adds custom hooks as part of its startup.
-  }
-
   async eval(
     source,
     url = pathToFileURL(`${process.cwd()}/[eval${++this.evalIndex}]`).href,
@@ -161,20 +147,7 @@ class ESMLoader {
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
   getModuleJob(specifier, parentURL, importAssertions) {
-    let importAssertionsForResolve;
-
-    // We can skip cloning if there are no user-provided loaders because
-    // the Node.js default resolve hook does not use import assertions.
-    if (hooksProxy) { // This exists only when there are custom hooks.
-      // This method of cloning only works so long as import assertions cannot contain objects as values,
-      // which they currently cannot per spec.
-      importAssertionsForResolve = {
-        __proto__: null,
-        ...importAssertions,
-      };
-    }
-
-    const resolveResult = this.resolve(specifier, parentURL, importAssertionsForResolve);
+    const resolveResult = this.resolve(specifier, parentURL, importAssertions);
     const { url, format } = resolveResult;
     const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
 
@@ -310,10 +283,6 @@ class ESMLoader {
    * @returns {{ format: string, url: URL['href'] }}
    */
   resolve(originalSpecifier, parentURL, importAssertions) {
-    if (hooksProxy) {
-      return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
-    }
-
     if (!this.#defaultResolve) {
       this.#defaultResolve = require('internal/modules/esm/resolve').defaultResolve;
     }
@@ -336,36 +305,104 @@ class ESMLoader {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context) {
-    let loadResult;
-    if (hooksProxy) {
-      loadResult = await hooksProxy.makeRequest('load', url, context);
-    } else {
-      if (!this.#defaultLoad) {
-        this.#defaultLoad = require('internal/modules/esm/load').defaultLoad;
-      }
-      loadResult = await this.#defaultLoad(url, context);
+    if (!this.#defaultLoad) {
+      this.#defaultLoad = require('internal/modules/esm/load').defaultLoad;
     }
 
-    const { format } = loadResult;
+    const result = await this.#defaultLoad(url, context);
+    this.validateLoadResult(url, result?.format);
+    return result;
+  }
+
+  validateLoadResult(url, format) {
     if (format == null) {
       require('internal/modules/esm/load').throwUnknownModuleFormat(url, format);
     }
-
-    return loadResult;
   }
 
   importMetaInitialize(meta, context) {
-    if (hooksProxy) {
-      return hooksProxy.makeRequest('importMetaInitialize', meta, context);
-    }
-
     if (!this.#importMetaInitializer) {
       this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
     }
     this.#importMetaInitializer(meta, context);
   }
 }
+ObjectSetPrototypeOf(DefaultModuleLoader.prototype, null);
+
+
+class CustomizedModuleLoader extends DefaultModuleLoader {
+  /**
+   * Instantiate a module loader that uses user-provided custom loader hooks.
+   */
+  constructor() {
+    super();
+
+    if (hooksProxy) {
+      // The worker proxy is shared across all instances, so don't recreate it if it already exists.
+      return;
+    }
+
+    const { HooksProxy } = require('internal/modules/esm/hooks');
+    hooksProxy = new HooksProxy(); // The user's custom hooks are loaded within the worker as part of its startup.
+  }
+
+  /**
+   * Resolve the location of the module.
+   *
+   * @param {string} originalSpecifier The specified URL path of the module to
+   *                                   be resolved.
+   * @param {string} [parentURL] The URL path of the module's parent.
+   * @param {ImportAssertions} [importAssertions] Assertions from the import
+   *                                              statement or expression.
+   * @returns {{ format: string, url: URL['href'] }}
+   */
+  resolve(originalSpecifier, parentURL, importAssertions = { __proto__: null },
+  ) {
+    return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
+  }
+
+  /**
+   * Provide source that is understood by one of Node's translators.
+   *
+   * @param {URL['href']} url The URL/path of the module to be loaded
+   * @param {object} [context] Metadata about the module
+   * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
+   */
+  async load(url, context) {
+    const result = await hooksProxy.makeRequest('load', url, context);
+    this.validateLoadResult(url, result?.format);
+    return result;
+  }
+
+  importMetaInitialize(meta, context) {
+    return hooksProxy.makeRequest('importMetaInitialize', meta, context);
+  }
+}
+
 
-ObjectSetPrototypeOf(ESMLoader.prototype, null);
+/**
+ * A loader instance is used as the main entry point for loading ES modules. Currently, this is a singleton; there is
+ * only one used for loading the main module and everything in its dependency graph, though separate instances of this
+ * class might be instantiated as part of bootstrap for other purposes.
+ */
+class ModuleLoader {
+  /**
+   *
+   * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
+   * @returns {instanceof BaseModuleLoader | instanceof CustomizedModuleLoader}
+   */
+  constructor(useCustomLoadersIfPresent = true) {
+    if (useCustomLoadersIfPresent) {
+      const userLoaderPaths = getOptionValue('--experimental-loader');
+      if (userLoaderPaths.length > 0) {
+        emitExperimentalWarning('Custom ESM Loaders');
+        return new CustomizedModuleLoader(userLoaderPaths);
+      }
+    }
+
+    return new DefaultModuleLoader();
+  }
+}
+ObjectSetPrototypeOf(ModuleLoader.prototype, null);
 
-exports.ESMLoader = ESMLoader;
+exports.ModuleLoader = ModuleLoader;
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index f0d9d6a7d38e11..7871e7c8e05d51 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -109,8 +109,8 @@ async function initializeHooks() {
     cwd = '/';
   }
 
-  const { ESMLoader } = require('internal/modules/esm/loader');
-  const internalEsmLoader = new ESMLoader();
+  const { ModuleLoader } = require('internal/modules/esm/loader');
+  const privateModuleLoader = new ModuleLoader(false);
   const importedCustomLoaders = [];
 
   const parentURL = pathToFileURL(cwd).href;
@@ -119,7 +119,7 @@ async function initializeHooks() {
     const customLoaderPath = customLoaderPaths[i];
 
     // Importation must be handled by internal loader to avoid polluting user-land
-    const keyedExportsSublist = await internalEsmLoader.import(
+    const keyedExportsSublist = await privateModuleLoader.import(
       [customLoaderPath], // Import can handle multiple paths, but custom loaders must be sequential
       parentURL,
       kEmptyObject,
@@ -137,7 +137,7 @@ async function initializeHooks() {
   const preloadModules = getOptionValue('--import');
 
   if (preloadModules) {
-    await internalEsmLoader.import(
+    await privateModuleLoader.import(
       preloadModules,
       parentURL,
       kEmptyObject,
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index c8cb4150d9bc7a..77ee73d92970eb 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,37 +1,15 @@
 'use strict';
 
-const { ESMLoader } = require('internal/modules/esm/loader');
+const { ModuleLoader } = require('internal/modules/esm/loader');
 const {
   hasUncaughtExceptionCaptureCallback,
 } = require('internal/process/execution');
 
-const esmLoader = new ESMLoader();
+const esmLoader = new ModuleLoader(true);
 exports.esmLoader = esmLoader;
 
-// Module.runMain() causes loadESM() to re-run (which it should do); however, this should NOT cause
-// ESM to be re-initialized; doing so causes duplicate custom loaders to be added to the public
-// esmLoader.
-let isESMInitialized = false;
-
-/**
- * Causes side-effects: user-defined loader hooks are added to esmLoader.
- * @returns {void}
- */
-async function initializeLoader() {
-  if (isESMInitialized) { return; }
-
-  const { getOptionValue } = require('internal/options');
-
-  const customLoaders = getOptionValue('--experimental-loader');
-
-  esmLoader.registerCustomLoaders(customLoaders);
-
-  isESMInitialized = true;
-}
-
 exports.loadESM = async function loadESM(callback) {
   try {
-    await initializeLoader();
     await callback(esmLoader);
   } catch (err) {
     if (hasUncaughtExceptionCaptureCallback()) {
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index 190676ec725cd2..a1d035fbf01938 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -4,7 +4,7 @@
 require('../common');
 
 const { strictEqual, throws } = require('assert');
-const { ESMLoader } = require('internal/modules/esm/loader');
+const { ModuleLoader } = require('internal/modules/esm/loader');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 const createDynamicModule = require(
@@ -16,7 +16,7 @@ const jsonModuleDataUrl = 'data:application/json,""';
 const stubJsModule = createDynamicModule([], ['default'], jsModuleDataUrl);
 const stubJsonModule = createDynamicModule([], ['default'], jsonModuleDataUrl);
 
-const loader = new ESMLoader();
+const loader = new ModuleLoader(false);
 const jsModuleJob = new ModuleJob(loader, stubJsModule.module, undefined,
                                   () => new Promise(() => {}));
 const jsonModuleJob = new ModuleJob(loader, stubJsonModule.module,
diff --git a/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs b/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
index c1c80622feea66..b4b1750508a402 100644
--- a/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
+++ b/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
@@ -1,14 +1,14 @@
 export function resolve(url, _, next) {
-  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
   return next(url);
 }
 
 export function load(url, _, next) {
-  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
   return next(url);
 }
 
 export function globalPreload() {
-  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
   return "";
 }

From 2d39e1388151ac20503a43babd95ab3d0b44f502 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Tue, 27 Dec 2022 15:12:02 -0800
Subject: [PATCH 016/126] Fix import.meta being undefined (WIP)

---
 lib/internal/modules/esm/hooks.js             |  2 +-
 .../modules/esm/initialize_import_meta.js     | 20 ++++++++++++++-----
 lib/internal/modules/esm/loader.js            |  7 ++-----
 lib/internal/modules/esm/utils.js             |  2 +-
 4 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 26ab698167fa0e..6456ccf6f0d383 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -216,7 +216,7 @@ class Hooks {
   }
 
   importMetaInitialize(meta, context) {
-    this.#importMetaInitializer(meta, context);
+    this.#importMetaInitializer(meta, context, this.resolve);
   }
 
   /**
diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index f8a8fef03f90a8..0bbaa9cc4caf33 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -2,14 +2,19 @@
 
 const { getOptionValue } = require('internal/options');
 const experimentalImportMetaResolve = getOptionValue('--experimental-import-meta-resolve');
-const asyncESM = require('internal/process/esm_loader');
 
-function createImportMetaResolve(defaultParentUrl) {
+/**
+ * Generate a function to be used as import.meta.resolve for a particular module.
+ * @param {string} defaultParentUrl The default base to use for resolution
+ * @param {Function} resolveMethod Reference to the resolve method for the current module loader
+ * @returns {(specifier: string, parentUrl?: string) => string} Function to assign to import.meta.resolve
+ */
+function createImportMetaResolve(defaultParentUrl, resolveMethod) {
   return function resolve(specifier, parentUrl = defaultParentUrl) {
     let url;
 
     try {
-      ({ url } = asyncESM.esmLoader.resolve(specifier, parentUrl));
+      ({ url } = resolveMethod(specifier, parentUrl));
     } catch (error) {
       if (error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
         ({ url } = error);
@@ -23,18 +28,23 @@ function createImportMetaResolve(defaultParentUrl) {
 }
 
 /**
+ * Create the import.meta object for a module.
  * @param {object} meta
  * @param {{url: string}} context
+ * @param {Function} resolveMethod Reference to the resolve method for the current module loader
+ * @returns {{url: string, resolve?: Function}}
  */
-function initializeImportMeta(meta, context) {
+function initializeImportMeta(meta, context, resolveMethod) {
   const { url } = context;
 
   // Alphabetical
   if (experimentalImportMetaResolve) {
-    meta.resolve = createImportMetaResolve(url);
+    meta.resolve = createImportMetaResolve(url, resolveMethod);
   }
 
   meta.url = url;
+
+  return meta;
 }
 
 module.exports = {
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 5557af23eb81dd..6b8232b6f5d74f 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -324,7 +324,8 @@ class DefaultModuleLoader {
     if (!this.#importMetaInitializer) {
       this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
     }
-    this.#importMetaInitializer(meta, context);
+    meta = this.#importMetaInitializer(meta, context, this.resolve);
+    return meta;
   }
 }
 ObjectSetPrototypeOf(DefaultModuleLoader.prototype, null);
@@ -373,10 +374,6 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
     this.validateLoadResult(url, result?.format);
     return result;
   }
-
-  importMetaInitialize(meta, context) {
-    return hooksProxy.makeRequest('importMetaInitialize', meta, context);
-  }
 }
 
 
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 7871e7c8e05d51..738aff3ae5e120 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -75,7 +75,7 @@ function initializeImportMetaObject(wrap, meta) {
   if (callbackMap.has(wrap)) {
     const { initializeImportMeta } = callbackMap.get(wrap);
     if (initializeImportMeta !== undefined) {
-      initializeImportMeta(meta, getModuleFromWrap(wrap) || wrap);
+      meta = initializeImportMeta(meta, getModuleFromWrap(wrap) || wrap);
     }
   }
 }

From dd6a5d387bde6ce03d1db0d4ab327dd0020c80bb Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Tue, 27 Dec 2022 16:10:03 -0800
Subject: [PATCH 017/126] Remove undocumented globalPreload
 setImportMetaCallback (WIP)

---
 lib/internal/modules/esm/hooks.js | 34 +++----------------------------
 lib/internal/modules/esm/utils.js |  2 +-
 2 files changed, 4 insertions(+), 32 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 6456ccf6f0d383..fbc2f6d7b35d07 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -131,7 +131,7 @@ class Hooks {
   /**
    * Initialize `globalPreload` hooks.
    */
-  preload() {
+  initializeGlobalPreload() {
     for (let i = this.#chains.globalPreload.length - 1; i >= 0; i--) {
       const { MessageChannel } = require('internal/worker/io');
       const channel = new MessageChannel();
@@ -166,20 +166,12 @@ class Hooks {
       const { compileFunction } = require('vm');
       const preloadInit = compileFunction(
         preloaded,
-        ['getBuiltin', 'port', 'setImportMetaCallback'],
+        ['getBuiltin', 'port'],
         {
           filename: '<preload>',
         },
       );
       const { BuiltinModule } = require('internal/bootstrap/realm');
-      // We only allow replacing the importMetaInitializer during preload;
-      // after preload is finished, we disable the ability to replace it.
-      //
-      // This exposes accidentally setting the initializer too late by throwing an error.
-      let finished = false;
-      let replacedImportMetaInitializer = false;
-      let next = this.#importMetaInitializer;
-      try {
         // Calls the compiled preload source text gotten from the hook
         // Since the parameters are named we use positional parameters
         // see compileFunction above to cross reference the names
@@ -195,30 +187,10 @@ class Hooks {
           },
           // Param port
           insidePreload,
-          // Param setImportMetaCallback
-          (fn) => {
-            if (finished || typeof fn !== 'function') {
-              throw new ERR_INVALID_ARG_TYPE('fn', fn);
-            }
-            replacedImportMetaInitializer = true;
-            const parent = next;
-            next = (meta, context) => {
-              return fn(meta, context, parent);
-            };
-          });
-      } finally {
-        finished = true;
-        if (replacedImportMetaInitializer) {
-          this.#importMetaInitializer = next;
-        }
-      }
+        );
     }
   }
 
-  importMetaInitialize(meta, context) {
-    this.#importMetaInitializer(meta, context, this.resolve);
-  }
-
   /**
    * Resolve the location of the module.
    *
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 738aff3ae5e120..6efad5a23008bd 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -131,7 +131,7 @@ async function initializeHooks() {
   const { Hooks } = require('internal/modules/esm/hooks');
   const hooks = new Hooks(importedCustomLoaders);
 
-  hooks.preload();
+  hooks.initializeGlobalPreload();
 
   // Preload after loaders are added so they can be used
   const preloadModules = getOptionValue('--import');

From 1415d6e4f8158b4ee4e431ded149c03a5e48b552 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 28 Dec 2022 13:22:43 -0800
Subject: [PATCH 018/126] fs.write(1, message) works at least in Mac and
 Windows for printing from inside a worker

---
 .../es-module-loaders/loader-load-passthru.mjs     |  4 +++-
 .../loader-load-receiving-modified-context.mjs     |  4 +++-
 .../fixtures/es-module-loaders/loader-log-args.mjs | 14 ++++++++------
 .../es-module-loaders/loader-resolve-42.mjs        |  6 ++++--
 .../es-module-loaders/loader-resolve-foo.mjs       |  4 +++-
 .../es-module-loaders/loader-resolve-passthru.mjs  |  4 +++-
 .../loader-resolve-receiving-modified-context.mjs  |  4 +++-
 .../es-module-loaders/loader-resolve-strip-xxx.mjs |  4 +++-
 .../es-module-loaders/loader-resolve-strip-yyy.mjs |  4 +++-
 9 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index 1c2f2ea4487cdf..f3925984fddb09 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -1,3 +1,5 @@
+import { writeSync } from 'fs';
+
 export async function load(url, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +9,6 @@ export async function load(url, context, next) {
     return next(url);
   }
 
-  console.log('load passthru'); // This log is deliberate
+  writeSync(1, 'load passthru\n'); // This log is deliberate
   return next(url);
 }
diff --git a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
index 2d7bc350bd8775..2fc16eb8b08a0f 100644
--- a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
@@ -1,4 +1,6 @@
+import { writeSync } from 'fs';
+
 export async function load(url, context, next) {
-  console.log(context.foo); // This log is deliberate
+  writeSync(1, `${context.foo}\n`); // This log is deliberate
   return next(url, context);
 }
diff --git a/test/fixtures/es-module-loaders/loader-log-args.mjs b/test/fixtures/es-module-loaders/loader-log-args.mjs
index 84ed373d6b4de4..587251326f58c7 100644
--- a/test/fixtures/es-module-loaders/loader-log-args.mjs
+++ b/test/fixtures/es-module-loaders/loader-log-args.mjs
@@ -1,10 +1,12 @@
+import { writeSync } from 'fs';
+
 export async function resolve(...args) {
-  console.log(`resolve arg count: ${args.length}`);
-  console.log({
+  writeSync(1, `resolve arg count: ${args.length}\n`);
+  writeSync(1, `${JSON.stringify({
     specifier: args[0],
     context: args[1],
     next: args[2],
-  });
+  })}\n`);
 
   return {
     shortCircuit: true,
@@ -13,12 +15,12 @@ export async function resolve(...args) {
 }
 
 export async function load(...args) {
-  console.log(`load arg count: ${args.length}`);
-  console.log({
+  writeSync(1, `load arg count: ${args.length}`);
+  writeSync(1, `${JSON.stringify({
     url: args[0],
     context: args[1],
     next: args[2],
-  });
+  })}\n`);
 
   return {
     format: 'module',
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index 05ef2f68390bd1..20338b307e8bff 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -1,3 +1,5 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,8 +9,8 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve 42'); // This log is deliberate
-  console.log('next<HookName>:', next.name); // This log is deliberate
+  writeSync(1, 'resolve 42\n'); // This log is deliberate
+  writeSync(1, `next<HookName>:${next.name}\n`); // This log is deliberate
 
   return next('file:///42.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index 09d30e952a2a92..74261c160a8142 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -1,3 +1,5 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +9,6 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve foo'); // This log is deliberate
+  writeSync(1, 'resolve foo\n'); // This log is deliberate
   return next('file:///foo.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index d4845acc9f5f71..6c0096e7f10b38 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -1,3 +1,5 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +9,6 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve passthru'); // This log is deliberate
+  writeSync(1, 'resolve passthru\n'); // This log is deliberate
   return next(specifier);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
index 83aa83104e96e4..4661bae9a0d3c0 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
@@ -1,4 +1,6 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, next) {
-  console.log(context.foo); // This log is deliberate
+  writeSync(1, `${context.foo}\n`); // This log is deliberate
   return next(specifier, context);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
index 58d7a1107994fe..81766a08105c48 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
@@ -1,4 +1,6 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, nextResolve) {
-  console.log(`loader-a`, {specifier});
+  writeSync(1, `loader-a ${specifier}\n`);
   return nextResolve(specifier.replace(/^xxx\//, `./`));
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
index 3615926143c4c7..efa74aa6ff7511 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
@@ -1,4 +1,6 @@
+import { writeSync } from 'fs';
+
 export async function resolve(specifier, context, nextResolve) {
-  console.log(`loader-b`, {specifier});
+  writeSync(1, `loader-b ${specifier}\n`);
   return nextResolve(specifier.replace(/^yyy\//, `./`));
 }

From a374bd1c514c7d800884e07225a7eb208d8f0458 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 28 Dec 2022 15:18:15 -0800
Subject: [PATCH 019/126] Standardize names, fix lint

---
 lib/internal/modules/esm/hooks.js | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index fbc2f6d7b35d07..e2b42adbc9fde7 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -92,8 +92,6 @@ class Hooks {
   // Cache URLs we've already validated to avoid repeated validation
   #validatedUrls = new SafeSet();
 
-  #importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-
   constructor(userLoaders) {
     this.#addCustomLoaders(userLoaders);
   }
@@ -247,12 +245,12 @@ class Hooks {
 
     const nextResolve = nextHookFactory(chain, meta, { validateArgs, validateOutput });
 
-    const resolution = await nextResolve(originalSpecifier, context);
+    const result = await nextResolve(originalSpecifier, context);
     const { hookErrIdentifier } = meta; // Retrieve the value after all settled
 
-    validateOutput(hookErrIdentifier, resolution);
+    validateOutput(hookErrIdentifier, result);
 
-    if (resolution?.shortCircuit === true) { meta.shortCircuited = true; }
+    if (result?.shortCircuit === true) { meta.shortCircuited = true; }
 
     if (!meta.chainFinished && !meta.shortCircuited) {
       throw new ERR_LOADER_CHAIN_INCOMPLETE(hookErrIdentifier);
@@ -262,7 +260,7 @@ class Hooks {
       format,
       importAssertions: resolvedImportAssertions,
       url,
-    } = resolution;
+    } = result;
 
     if (typeof url !== 'string') {
       // non-strings can be coerced to a URL string
@@ -383,12 +381,12 @@ class Hooks {
 
     const nextLoad = nextHookFactory(chain, meta, { validateArgs, validateOutput });
 
-    const loaded = await nextLoad(url, context);
+    const result = await nextLoad(url, context);
     const { hookErrIdentifier } = meta; // Retrieve the value after all settled
 
-    validateOutput(hookErrIdentifier, loaded);
+    validateOutput(hookErrIdentifier, result);
 
-    if (loaded?.shortCircuit === true) { meta.shortCircuited = true; }
+    if (result?.shortCircuit === true) { meta.shortCircuited = true; }
 
     if (!meta.chainFinished && !meta.shortCircuited) {
       throw new ERR_LOADER_CHAIN_INCOMPLETE(hookErrIdentifier);
@@ -397,8 +395,8 @@ class Hooks {
     const {
       format,
       source,
-    } = loaded;
-    let responseURL = loaded.responseURL;
+    } = result;
+    let responseURL = result.responseURL;
 
     if (responseURL === undefined) {
       responseURL = url;

From 98b55127ac886d8227fe9f11960eb8efc5f4264d Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 28 Dec 2022 15:18:56 -0800
Subject: [PATCH 020/126] Exceptions thrown inside loader hooks should be
 returned to the main thread and rethrown there so that they're printed in
 stdout

---
 lib/internal/modules/esm/hooks.js  | 8 +++++++-
 lib/internal/modules/esm/worker.js | 8 +++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index e2b42adbc9fde7..0004b31a883547 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -514,8 +514,9 @@ class HooksProxy {
     Atomics.notify(this.#lock, 0); // Notify worker of new request
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
 
+    let response;
     try {
-      return deserialize(this.#requestResponseData);
+      response = deserialize(this.#requestResponseData);
     } catch (exception) {
       if (this.#requestResponseData.every((byte) => byte === 0)) {
         throw new ERR_INVALID_RETURN_VALUE('an object', type, undefined);
@@ -523,6 +524,11 @@ class HooksProxy {
         throw exception;
       }
     }
+    if (response instanceof Error) {
+      throw response;
+    } else {
+      return response;
+    }
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index d70bdf3ed3ce91..32ff07696afce7 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -49,7 +49,13 @@ function releaseLock() {
     const { type, args } = deserialize(requestResponseData);
     TypedArrayPrototypeFill(requestResponseData, 0);
 
-    const response = await ReflectApply(hooks[type], hooks, args);
+    let response;
+    try {
+      response = await ReflectApply(hooks[type], hooks, args);
+    } catch (exception) {
+      // Send the exception to the main thread where it can be thrown and printed
+      response = exception;
+    }
     TypedArrayPrototypeSet(requestResponseData, serialize(response));
     releaseLock();
   }

From 7be92f3797468baf091f848b250d49ecbcaa6146 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 28 Dec 2022 22:39:25 -0800
Subject: [PATCH 021/126] Rewrite test-esm-loader-hooks test to spawn child
 process and inspect stdout

---
 test/fixtures/es-module-loaders/hooks-input.mjs | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/test/fixtures/es-module-loaders/hooks-input.mjs b/test/fixtures/es-module-loaders/hooks-input.mjs
index 6859cfc07d9b6a..6b3777526e547a 100644
--- a/test/fixtures/es-module-loaders/hooks-input.mjs
+++ b/test/fixtures/es-module-loaders/hooks-input.mjs
@@ -2,6 +2,7 @@
 // node --loader ./test/fixtures/es-module-loaders/hooks-input.mjs ./test/fixtures/es-modules/json-modules.mjs
 
 import assert from 'assert';
+import { writeSync } from 'fs';
 import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 
@@ -17,15 +18,12 @@ export async function resolve(specifier, context, next) {
     url = new URL(specifier).href;
     assert.match(specifier, /json-modules\.mjs$/);
     assert.strictEqual(context.parentURL, undefined);
-    assert.deepStrictEqual(context.importAssertions, {
-      __proto__: null,
-    });
+    assert.deepStrictEqual(context.importAssertions, {});
   } else if (resolveCalls === 2) {
     url = new URL(specifier, context.parentURL).href;
     assert.match(specifier, /experimental\.json$/);
     assert.match(context.parentURL, /json-modules\.mjs$/);
     assert.deepStrictEqual(context.importAssertions, {
-      __proto__: null,
       type: 'json',
     });
   }
@@ -45,7 +43,7 @@ export async function resolve(specifier, context, next) {
     shortCircuit: true,
   }
 
-  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
+  writeSync(1, `${JSON.stringify(returnValue)}\n`); // For the test to validate when it parses stdout
 
   return returnValue;
 }
@@ -57,14 +55,11 @@ export async function load(url, context, next) {
 
   if (loadCalls === 1) {
     assert.match(url, /json-modules\.mjs$/);
-    assert.deepStrictEqual(context.importAssertions, {
-      __proto__: null,
-    });
+    assert.deepStrictEqual(context.importAssertions, {});
     format = 'module';
   } else if (loadCalls === 2) {
     assert.match(url, /experimental\.json$/);
     assert.deepStrictEqual(context.importAssertions, {
-      __proto__: null,
       type: 'json',
     });
     format = 'json';
@@ -85,7 +80,7 @@ export async function load(url, context, next) {
     shortCircuit: true,
   };
 
-  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
+  writeSync(1, `${JSON.stringify(returnValue)}\n`); // For the test to validate when it parses stdout
 
   return returnValue;
 }

From 382753aaae9365c548a0b30272158fa9a7b35da1 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Thu, 29 Dec 2022 17:09:57 -0800
Subject: [PATCH 022/126] Send loader initialization errors up to the main
 thread so they can be thrown and printed

---
 lib/internal/modules/esm/worker.js | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 32ff07696afce7..d9dadee33289f9 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -34,9 +34,16 @@ function releaseLock() {
  */
 (async function setupESMWorker() {
   const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
-  initializeESM();
+  let initializationError, hooks;
 
-  const hooks = await initializeHooks();
+  try {
+    initializeESM();
+    hooks = await initializeHooks();
+  } catch (exception) {
+    // If there was an error while parsing and executing a user loader, for example if because a loader contained a syntax error,
+    // then we need to send the error to the main thread so it can be thrown and printed.
+    initializationError = exception;
+  }
 
   // ! Put as little above this line as possible
   releaseLock(); // Send 'ready' signal to main
@@ -50,11 +57,15 @@ function releaseLock() {
     TypedArrayPrototypeFill(requestResponseData, 0);
 
     let response;
-    try {
-      response = await ReflectApply(hooks[type], hooks, args);
-    } catch (exception) {
-      // Send the exception to the main thread where it can be thrown and printed
-      response = exception;
+    if (initializationError) {
+      response = initializationError;
+    } else {
+      try {
+        response = await ReflectApply(hooks[type], hooks, args);
+      } catch (exception) {
+        // Send the exception to the main thread where it can be thrown and printed
+        response = exception;
+      }
     }
     TypedArrayPrototypeSet(requestResponseData, serialize(response));
     releaseLock();

From 2b3e6a5410084f4efd53f57a1c9188bb4bb3c9af Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Thu, 29 Dec 2022 17:32:16 -0800
Subject: [PATCH 023/126] Remove debugging code (fixes 3 tests!)

---
 lib/internal/modules/esm/translators.js | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 1fb560f6a02193..267d89f1d44730 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -113,12 +113,7 @@ translators.set('module', async function moduleStrategy(url, source, isMain) {
   source = stringify(source);
   maybeCacheSourceMap(url, source);
   debug(`Translating StandardModule ${url}`);
-  let module;
-  try {
-    module = new ModuleWrap(url, undefined, source, 0, 0);
-  } catch(e) {
-    console.error(e, { url, source});
-  }
+  const module = new ModuleWrap(url, undefined, source, 0, 0);
   const { setCallbackForWrap } = require('internal/modules/esm/utils');
   setCallbackForWrap(module, {
     initializeImportMeta: (meta, wrap) => this.importMetaInitialize(meta, { url }),

From c73001f010a6bd3abd144587dfdb902dccd0be4d Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Thu, 29 Dec 2022 21:47:25 -0800
Subject: [PATCH 024/126] Catch another worker thread exception so that the
 process doesn't hang

---
 lib/internal/modules/esm/worker.js | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index d9dadee33289f9..6839c17bad0fad 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -67,10 +67,21 @@ function releaseLock() {
         response = exception;
       }
     }
-    TypedArrayPrototypeSet(requestResponseData, serialize(response));
+    // This next line needs to be outside of the previous try/catch block in order to return any above errors to the main thread;
+    // but since this call itself might throw an exception, we need to repeat the pattern to send any exceptions from this call
+    // to the main thread in the same way.
+    try {
+      TypedArrayPrototypeSet(requestResponseData, serialize(response));
+    } catch (exception) {
+      // Send the exception to the main thread where it can be thrown and printed
+      TypedArrayPrototypeSet(requestResponseData, serialize(exception));
+    }
     releaseLock();
   }
 })().catch((err) => {
+  // The triggerUncaughtException call below does not terminate the process or surface errors to the user;
+  // putting process._rawDebug here as a temporary workaround to ensure that the error is printed.
+  process._rawDebug('Uncaught exception in setupESMWorker:', err);
   const { triggerUncaughtException } = internalBinding('errors');
   releaseLock();
   triggerUncaughtException(err);

From b4cccd48a70ad87388d164d7c7c5080abe747d56 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Thu, 29 Dec 2022 22:12:23 -0800
Subject: [PATCH 025/126] Add error handling around hooks method responses
 being undefined or hooks method responses being too large when serialized

---
 lib/internal/modules/esm/hooks.js  |  6 ++---
 lib/internal/modules/esm/worker.js | 36 +++++++++++++++++++++---------
 2 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 0004b31a883547..03f084984d4c7a 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -495,7 +495,7 @@ class HooksProxy {
     worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
   }
 
-  makeRequest(type, ...args) {
+  makeRequest(method, ...args) {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
@@ -507,7 +507,7 @@ class HooksProxy {
 
     TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
 
-    const request = serialize({ type, args });
+    const request = serialize({ method, args });
     TypedArrayPrototypeSet(this.#requestResponseData, request);
 
     Atomics.store(this.#lock, 0, 0); // Send request to worker
@@ -519,7 +519,7 @@ class HooksProxy {
       response = deserialize(this.#requestResponseData);
     } catch (exception) {
       if (this.#requestResponseData.every((byte) => byte === 0)) {
-        throw new ERR_INVALID_RETURN_VALUE('an object', type, undefined);
+        throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
       } else {
         throw exception;
       }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 6839c17bad0fad..ff78d900fad19d 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -11,6 +11,10 @@ const {
     Atomics,
   },
 } = primordials;
+const {
+  ERR_INVALID_RETURN_VALUE,
+  ERR_OUT_OF_RANGE,
+} = require('internal/errors').codes;
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
@@ -22,7 +26,8 @@ const { commsChannel } = workerData;
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(commsChannel, 0, 4); // Required by Atomics
-const requestResponseData = new Uint8Array(commsChannel, 4, 2044); // For v8.deserialize/serialize
+const requestResponseDataSize = 2044;
+const requestResponseData = new Uint8Array(commsChannel, 4, requestResponseDataSize); // For v8.deserialize/serialize
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
@@ -53,27 +58,38 @@ function releaseLock() {
   while (true) {
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
-    const { type, args } = deserialize(requestResponseData);
+    const { method, args } = deserialize(requestResponseData);
     TypedArrayPrototypeFill(requestResponseData, 0);
 
-    let response;
+    // Each potential exception needs to be caught individually so that the correct error is sent to the main thread
+    let response, serializedResponse;
     if (initializationError) {
       response = initializationError;
     } else {
       try {
-        response = await ReflectApply(hooks[type], hooks, args);
+        response = await ReflectApply(hooks[method], hooks, args);
+        if (!response) {
+          throw new ERR_INVALID_RETURN_VALUE('object', method, response)
+        }
       } catch (exception) {
-        // Send the exception to the main thread where it can be thrown and printed
         response = exception;
       }
     }
-    // This next line needs to be outside of the previous try/catch block in order to return any above errors to the main thread;
-    // but since this call itself might throw an exception, we need to repeat the pattern to send any exceptions from this call
-    // to the main thread in the same way.
+
+    try {
+      serializedResponse = serialize(response);
+      if (serializedResponse.byteLength > requestResponseDataSize) {
+        throw new ERR_OUT_OF_RANGE('serializedResponse.byteLength', `<= ${requestResponseDataSize}`, serializedResponse.byteLength);
+      }
+    } catch (exception) {
+      serializedResponse = serialize(exception);
+    }
+
+    // Send the method response (or exception) to the main thread
     try {
-      TypedArrayPrototypeSet(requestResponseData, serialize(response));
+      TypedArrayPrototypeSet(requestResponseData, serializedResponse);
     } catch (exception) {
-      // Send the exception to the main thread where it can be thrown and printed
+      // Or send the exception thrown when trying to send the response
       TypedArrayPrototypeSet(requestResponseData, serialize(exception));
     }
     releaseLock();

From b272d31b2a4bbcb24838ffb7c031330238540f41 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Sat, 31 Dec 2022 11:38:28 -0500
Subject: [PATCH 026/126] separate worker `data` & `lock` buffers

---
 lib/internal/modules/esm/hooks.js  | 64 ++++++++++++++++--------------
 lib/internal/modules/esm/worker.js | 18 ++++-----
 2 files changed, 43 insertions(+), 39 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 03f084984d4c7a..6df69204b10413 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -170,22 +170,22 @@ class Hooks {
         },
       );
       const { BuiltinModule } = require('internal/bootstrap/realm');
-        // Calls the compiled preload source text gotten from the hook
-        // Since the parameters are named we use positional parameters
-        // see compileFunction above to cross reference the names
-        FunctionPrototypeCall(
-          preloadInit,
-          globalThis,
-          // Param getBuiltin
-          (builtinName) => {
-            if (BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
-              return require(builtinName);
-            }
-            throw new ERR_INVALID_ARG_VALUE('builtinName', builtinName);
-          },
-          // Param port
-          insidePreload,
-        );
+      // Calls the compiled preload source text gotten from the hook
+      // Since the parameters are named we use positional parameters
+      // see compileFunction above to cross reference the names
+      FunctionPrototypeCall(
+        preloadInit,
+        globalThis,
+        // Param getBuiltin
+        (builtinName) => {
+          if (BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
+            return require(builtinName);
+          }
+          throw new ERR_INVALID_ARG_VALUE('builtinName', builtinName);
+        },
+        // Param port
+        insidePreload,
+      );
     }
   }
 
@@ -459,9 +459,12 @@ ObjectSetPrototypeOf(Hooks.prototype, null);
 
 class HooksProxy {
   /**
-   * The communication vehicle constituting all memory shared between the main and the worker.
+   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
+   * requests & responses into a format supported by the comms channel) reads and writes with
+   * Uint8Array.
    */
   #commsChannel = new SharedArrayBuffer(2048); // Maybe use buffer.constants.MAX_LENGTH ?
+  #data;
   /**
    * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
    * segment is used to tell the main to sleep when the worker is processing, and vice versa
@@ -469,13 +472,7 @@ class HooksProxy {
    * 0 -> main sleeps
    * 1 -> worker sleeps
    */
-  #lock = new Int32Array(this.#commsChannel, 0, 4);
-  /**
-   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
-   * requests & responses into a format supported by the comms channel) reads and writes with
-   * Uint8Array.
-   */
-  #requestResponseData = new Uint8Array(this.#commsChannel, 4, 2044);
+  #lock;
 
   #isReady = false;
 
@@ -485,12 +482,21 @@ class HooksProxy {
    */
   constructor() {
     const { InternalWorker } = require('internal/worker');
+
+    const data = new SharedArrayBuffer(2048);
+    const lock = new SharedArrayBuffer(4);
+    this.#data = new Uint8Array(data);
+    this.#lock = new Int32Array(lock);
+
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
       stdin: false,
       stdout: false,
       trackUnmanagedFds: false,
-      workerData: { commsChannel: this.#commsChannel },
+      workerData: {
+        data,
+        lock,
+      },
     });
     worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
   }
@@ -505,10 +511,10 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    TypedArrayPrototypeFill(this.#requestResponseData, 0); // Erase handled request/response data
+    TypedArrayPrototypeFill(this.#data, 0); // Erase handled request/response data
 
     const request = serialize({ method, args });
-    TypedArrayPrototypeSet(this.#requestResponseData, request);
+    TypedArrayPrototypeSet(this.#data, request);
 
     Atomics.store(this.#lock, 0, 0); // Send request to worker
     Atomics.notify(this.#lock, 0); // Notify worker of new request
@@ -516,9 +522,9 @@ class HooksProxy {
 
     let response;
     try {
-      response = deserialize(this.#requestResponseData);
+      response = deserialize(this.#data);
     } catch (exception) {
-      if (this.#requestResponseData.every((byte) => byte === 0)) {
+      if (this.#data.every((byte) => byte === 0)) {
         throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
       } else {
         throw exception;
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index ff78d900fad19d..f917c5c1276948 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -21,13 +21,11 @@ internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
 const { isMainThread, workerData } = require('worker_threads');
 if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
-const { commsChannel } = workerData;
 
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
-const lock = new Int32Array(commsChannel, 0, 4); // Required by Atomics
-const requestResponseDataSize = 2044;
-const requestResponseData = new Uint8Array(commsChannel, 4, requestResponseDataSize); // For v8.deserialize/serialize
+const lock = new Int32Array(workerData.lock); // Required by Atomics
+const data = new Uint8Array(workerData.data); // For v8.deserialize/serialize
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
@@ -58,8 +56,8 @@ function releaseLock() {
   while (true) {
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
-    const { method, args } = deserialize(requestResponseData);
-    TypedArrayPrototypeFill(requestResponseData, 0);
+    const { method, args } = deserialize(data);
+    TypedArrayPrototypeFill(data, 0);
 
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread
     let response, serializedResponse;
@@ -78,8 +76,8 @@ function releaseLock() {
 
     try {
       serializedResponse = serialize(response);
-      if (serializedResponse.byteLength > requestResponseDataSize) {
-        throw new ERR_OUT_OF_RANGE('serializedResponse.byteLength', `<= ${requestResponseDataSize}`, serializedResponse.byteLength);
+      if (serializedResponse.byteLength > data.length) {
+        throw new ERR_OUT_OF_RANGE('serializedResponse.byteLength', `<= ${data.length}`, serializedResponse.byteLength);
       }
     } catch (exception) {
       serializedResponse = serialize(exception);
@@ -87,10 +85,10 @@ function releaseLock() {
 
     // Send the method response (or exception) to the main thread
     try {
-      TypedArrayPrototypeSet(requestResponseData, serializedResponse);
+      TypedArrayPrototypeSet(data, serializedResponse);
     } catch (exception) {
       // Or send the exception thrown when trying to send the response
-      TypedArrayPrototypeSet(requestResponseData, serialize(exception));
+      TypedArrayPrototypeSet(data, serialize(exception));
     }
     releaseLock();
   }

From 0ec518ae4bd85c66f0d7e4687b49c6baf738b809 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Thu, 5 Jan 2023 00:31:35 +0100
Subject: [PATCH 027/126] chunks working?? (code is very rough!)

---
 lib/internal/modules/esm/hooks.js  | 37 ++++++++++++++-----------
 lib/internal/modules/esm/worker.js | 43 ++++++++++++++++++------------
 2 files changed, 48 insertions(+), 32 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 6df69204b10413..38ade915f9392b 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -483,7 +483,7 @@ class HooksProxy {
   constructor() {
     const { InternalWorker } = require('internal/worker');
 
-    const data = new SharedArrayBuffer(2048);
+    const data = new SharedArrayBuffer(204_800);
     const lock = new SharedArrayBuffer(4);
     this.#data = new Uint8Array(data);
     this.#lock = new Int32Array(lock);
@@ -511,30 +511,37 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    TypedArrayPrototypeFill(this.#data, 0); // Erase handled request/response data
-
+    TypedArrayPrototypeFill(this.#data, undefined); // Erase handled request/response data
     const request = serialize({ method, args });
     TypedArrayPrototypeSet(this.#data, request);
 
-    Atomics.store(this.#lock, 0, 0); // Send request to worker
-    Atomics.notify(this.#lock, 0); // Notify worker of new request
-    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
-
-    let response;
+    const chunks = [];
+    let done = false;
     try {
-      response = deserialize(this.#data);
+      while (done === false) {
+        this.#awaitResponse();
+
+        const chunk = deserialize(this.#data);
+        if (chunk instanceof Error) { throw chunk; }
+        ({ done } = chunk);
+        chunks.push(chunk.value);
+      }
     } catch (exception) {
-      if (this.#data.every((byte) => byte === 0)) {
+      if (this.#data[0] === 0) { // Response should not be empty
         throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
       } else {
         throw exception;
       }
     }
-    if (response instanceof Error) {
-      throw response;
-    } else {
-      return response;
-    }
+
+    const response = Buffer.concat(chunks);
+    return response;
+  }
+
+  #awaitResponse() {
+    Atomics.store(this.#lock, 0, 0); // Send request to worker
+    Atomics.notify(this.#lock, 0); // Notify worker of new request
+    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index f917c5c1276948..4c1796661e9111 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -13,7 +13,6 @@ const {
 } = primordials;
 const {
   ERR_INVALID_RETURN_VALUE,
-  ERR_OUT_OF_RANGE,
 } = require('internal/errors').codes;
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
@@ -26,6 +25,7 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(workerData.lock); // Required by Atomics
 const data = new Uint8Array(workerData.data); // For v8.deserialize/serialize
+const CHUNK_THRESHOLD = data.length - 26; // `{ done: true/false, value: … }` adds 26 bytes
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
@@ -53,14 +53,14 @@ function releaseLock() {
 
   const { deserialize, serialize } = require('v8');
 
-  while (true) {
+  while (true) { // The loop is needed in order to cycle through requests
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
     const { method, args } = deserialize(data);
-    TypedArrayPrototypeFill(data, 0);
+    TypedArrayPrototypeFill(data, undefined);
 
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread
-    let response, serializedResponse;
+    let response;
     if (initializationError) {
       response = initializationError;
     } else {
@@ -70,27 +70,29 @@ function releaseLock() {
           throw new ERR_INVALID_RETURN_VALUE('object', method, response)
         }
       } catch (exception) {
-        response = exception;
+        TypedArrayPrototypeSet(data, serialize(exception));
+        releaseLock();
       }
     }
 
     try {
-      serializedResponse = serialize(response);
-      if (serializedResponse.byteLength > data.length) {
-        throw new ERR_OUT_OF_RANGE('serializedResponse.byteLength', `<= ${data.length}`, serializedResponse.byteLength);
+      const serializedResponseValue = serialize(response);
+      const chunkCount = Math.ceil(serializedResponseValue.byteLength / CHUNK_THRESHOLD);
+      for (let i = 0; i < chunkCount; i++) {
+        const chunk = {
+          __proto__: null,
+          done: i === chunkCount - 1,
+          value: serializedResponseValue.slice(i),
+        };
+        const serializedChunk = serialize(chunk);
+        // Send the method response (or exception) to the main thread
+        TypedArrayPrototypeSet(data, serializedChunk);
+        releaseLock();
       }
     } catch (exception) {
-      serializedResponse = serialize(exception);
-    }
-
-    // Send the method response (or exception) to the main thread
-    try {
-      TypedArrayPrototypeSet(data, serializedResponse);
-    } catch (exception) {
-      // Or send the exception thrown when trying to send the response
       TypedArrayPrototypeSet(data, serialize(exception));
+      releaseLock();
     }
-    releaseLock();
   }
 })().catch((err) => {
   // The triggerUncaughtException call below does not terminate the process or surface errors to the user;
@@ -100,3 +102,10 @@ function releaseLock() {
   releaseLock();
   triggerUncaughtException(err);
 });
+
+process.on('uncaughtException', (err) => {
+  process._rawDebug('process uncaughtException:', new Error().stack);
+  const { triggerUncaughtException } = internalBinding('errors');
+  releaseLock();
+  triggerUncaughtException(err);
+});

From 11c1471de5f1341d2ad8532bfc726d402eee2f99 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sat, 7 Jan 2023 14:04:05 -0800
Subject: [PATCH 028/126] Fix import.meta.resolve

---
 lib/internal/modules/esm/initialize_import_meta.js | 12 ++++++------
 lib/internal/modules/esm/loader.js                 |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index 0bbaa9cc4caf33..d0bf7a324cb6aa 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -6,15 +6,15 @@ const experimentalImportMetaResolve = getOptionValue('--experimental-import-meta
 /**
  * Generate a function to be used as import.meta.resolve for a particular module.
  * @param {string} defaultParentUrl The default base to use for resolution
- * @param {Function} resolveMethod Reference to the resolve method for the current module loader
+ * @param {typeof import('./loader.js').ModuleLoader} loader Reference to the current module loader
  * @returns {(specifier: string, parentUrl?: string) => string} Function to assign to import.meta.resolve
  */
-function createImportMetaResolve(defaultParentUrl, resolveMethod) {
+function createImportMetaResolve(defaultParentUrl, loader) {
   return function resolve(specifier, parentUrl = defaultParentUrl) {
     let url;
 
     try {
-      ({ url } = resolveMethod(specifier, parentUrl));
+      ({ url } = loader.resolve(specifier, parentUrl));
     } catch (error) {
       if (error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
         ({ url } = error);
@@ -31,15 +31,15 @@ function createImportMetaResolve(defaultParentUrl, resolveMethod) {
  * Create the import.meta object for a module.
  * @param {object} meta
  * @param {{url: string}} context
- * @param {Function} resolveMethod Reference to the resolve method for the current module loader
+ * @param {typeof import('./loader.js').ModuleLoader} loader Reference to the current module loader
  * @returns {{url: string, resolve?: Function}}
  */
-function initializeImportMeta(meta, context, resolveMethod) {
+function initializeImportMeta(meta, context, loader) {
   const { url } = context;
 
   // Alphabetical
   if (experimentalImportMetaResolve) {
-    meta.resolve = createImportMetaResolve(url, resolveMethod);
+    meta.resolve = createImportMetaResolve(url, loader);
   }
 
   meta.url = url;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 6b8232b6f5d74f..2a1725f48db43f 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -324,7 +324,7 @@ class DefaultModuleLoader {
     if (!this.#importMetaInitializer) {
       this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
     }
-    meta = this.#importMetaInitializer(meta, context, this.resolve);
+    meta = this.#importMetaInitializer(meta, context, this);
     return meta;
   }
 }

From 0dd5114948c3dafb3c24eb9b43d4d2fe1566ca00 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sat, 7 Jan 2023 17:52:24 -0800
Subject: [PATCH 029/126] More carefully pass errors back to the main thread

---
 lib/internal/modules/esm/hooks.js  | 14 +++++++-------
 lib/internal/modules/esm/worker.js |  6 +++++-
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 38ade915f9392b..26d7662ff4b08e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -520,11 +520,11 @@ class HooksProxy {
     try {
       while (done === false) {
         this.#awaitResponse();
-
-        const chunk = deserialize(this.#data);
-        if (chunk instanceof Error) { throw chunk; }
-        ({ done } = chunk);
-        chunks.push(chunk.value);
+        const chunkContainer = deserialize(this.#data);
+        ({ done } = chunkContainer);
+        const { value } = chunkContainer;
+        if (value instanceof Error) { throw value; }
+        chunks.push(value);
       }
     } catch (exception) {
       if (this.#data[0] === 0) { // Response should not be empty
@@ -533,8 +533,8 @@ class HooksProxy {
         throw exception;
       }
     }
-
-    const response = Buffer.concat(chunks);
+    const reassembledChunks = Buffer.concat(chunks);
+    const response = deserialize(reassembledChunks);
     return response;
   }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 4c1796661e9111..5bce6becf1e850 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -70,7 +70,11 @@ function releaseLock() {
           throw new ERR_INVALID_RETURN_VALUE('object', method, response)
         }
       } catch (exception) {
-        TypedArrayPrototypeSet(data, serialize(exception));
+        TypedArrayPrototypeSet(data, serialize({
+          __proto__: null,
+          done: i === chunkCount - 1,
+          value: serialize(exception),
+        }));
         releaseLock();
       }
     }

From d15b42589ab1c831d611f584dd7e3e56ef146a4c Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sat, 7 Jan 2023 18:29:48 -0800
Subject: [PATCH 030/126] Some errors span multiple chunks, apparently

---
 lib/internal/modules/esm/hooks.js  | 10 ++++++++--
 lib/internal/modules/esm/worker.js |  2 +-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 26d7662ff4b08e..93c2777911b95c 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -521,10 +521,12 @@ class HooksProxy {
       while (done === false) {
         this.#awaitResponse();
         const chunkContainer = deserialize(this.#data);
+        // `deserialize` might return an error, such as a `RangeError`, rather than throw it
+        if (chunkContainer instanceof Error) { throw chunkContainer; }
         ({ done } = chunkContainer);
         const { value } = chunkContainer;
-        if (value instanceof Error) { throw value; }
-        chunks.push(value);
+        if (!value) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
+        ArrayPrototypePush(chunks, value);
       }
     } catch (exception) {
       if (this.#data[0] === 0) { // Response should not be empty
@@ -533,8 +535,12 @@ class HooksProxy {
         throw exception;
       }
     }
+    if (chunks.length === 0) { // Response should not be empty
+      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
+    }
     const reassembledChunks = Buffer.concat(chunks);
     const response = deserialize(reassembledChunks);
+    if (response instanceof Error) { throw response; }
     return response;
   }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 5bce6becf1e850..b9ddde691c6bef 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -86,7 +86,7 @@ function releaseLock() {
         const chunk = {
           __proto__: null,
           done: i === chunkCount - 1,
-          value: serializedResponseValue.slice(i),
+          value: serializedResponseValue.slice(i, i + CHUNK_THRESHOLD),
         };
         const serializedChunk = serialize(chunk);
         // Send the method response (or exception) to the main thread

From b796c0286aa1b2b9a92c7d47605a725761c08b73 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Sun, 8 Jan 2023 19:10:29 -0800
Subject: [PATCH 031/126] Fix chunking by separating metadata into separate
 buffers; fix error handling

---
 lib/internal/modules/esm/hooks.js  |  73 ++++++++++++---------
 lib/internal/modules/esm/worker.js | 101 +++++++++++++----------------
 2 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 93c2777911b95c..1f4ec1a1339008 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -10,8 +10,8 @@ const {
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
-  TypedArrayPrototypeFill,
   TypedArrayPrototypeSet,
+  TypedArrayPrototypeSlice,
   globalThis,
 } = primordials;
 
@@ -458,13 +458,6 @@ class Hooks {
 ObjectSetPrototypeOf(Hooks.prototype, null);
 
 class HooksProxy {
-  /**
-   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
-   * requests & responses into a format supported by the comms channel) reads and writes with
-   * Uint8Array.
-   */
-  #commsChannel = new SharedArrayBuffer(2048); // Maybe use buffer.constants.MAX_LENGTH ?
-  #data;
   /**
    * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
    * segment is used to tell the main to sleep when the worker is processing, and vice versa
@@ -474,6 +467,16 @@ class HooksProxy {
    */
   #lock;
 
+  #done;
+  #chunkLength;
+
+  /**
+   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
+   * requests & responses into a format supported by the comms channel) reads and writes with
+   * Uint8Array.
+   */
+  #data;
+
   #isReady = false;
 
   /**
@@ -483,20 +486,21 @@ class HooksProxy {
   constructor() {
     const { InternalWorker } = require('internal/worker');
 
-    const data = new SharedArrayBuffer(204_800);
-    const lock = new SharedArrayBuffer(4);
-    this.#data = new Uint8Array(data);
+    const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
+    const done = new SharedArrayBuffer(1); // For chunking, to know whether the last chunk has been sent
+    const chunkLength = new SharedArrayBuffer(32); // For chunking, to know the length of the current chunk
+    const data = new SharedArrayBuffer(2048); // The data for the request and response
     this.#lock = new Int32Array(lock);
+    this.#done = new Uint8Array(done);
+    this.#chunkLength = new Uint8Array(chunkLength);
+    this.#data = new Uint8Array(data);
 
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
       stdin: false,
       stdout: false,
       trackUnmanagedFds: false,
-      workerData: {
-        data,
-        lock,
-      },
+      workerData: { lock, done, chunkLength, data },
     });
     worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
   }
@@ -511,36 +515,41 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    TypedArrayPrototypeFill(this.#data, undefined); // Erase handled request/response data
     const request = serialize({ method, args });
     TypedArrayPrototypeSet(this.#data, request);
+    TypedArrayPrototypeSet(this.#chunkLength, serialize(request.byteLength));
+    TypedArrayPrototypeSet(this.#done, [1]);
 
     const chunks = [];
     let done = false;
-    try {
-      while (done === false) {
-        this.#awaitResponse();
-        const chunkContainer = deserialize(this.#data);
-        // `deserialize` might return an error, such as a `RangeError`, rather than throw it
-        if (chunkContainer instanceof Error) { throw chunkContainer; }
-        ({ done } = chunkContainer);
-        const { value } = chunkContainer;
-        if (!value) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
-        ArrayPrototypePush(chunks, value);
-      }
-    } catch (exception) {
-      if (this.#data[0] === 0) { // Response should not be empty
+    while (done === false) {
+      this.#awaitResponse();
+
+      try {
+        var chunkLength = deserialize(this.#chunkLength);
+      } catch (err) {
         throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
-      } else {
-        throw exception;
       }
+      if (!chunkLength) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
+
+      const chunk = TypedArrayPrototypeSlice(this.#data, 0, chunkLength);
+      if (!chunk) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
+
+      ArrayPrototypePush(chunks, chunk);
+      if (this.#done[0] === 1) { done = true; }
     }
     if (chunks.length === 0) { // Response should not be empty
       throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
     }
     const reassembledChunks = Buffer.concat(chunks);
     const response = deserialize(reassembledChunks);
-    if (response instanceof Error) { throw response; }
+
+    if (response instanceof Error) {
+      // An exception was thrown in the worker thread; re-throw to crash the process
+      const { triggerUncaughtException } = internalBinding('errors');
+      triggerUncaughtException(response);
+    }
+
     return response;
   }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index b9ddde691c6bef..8fb13904da5c29 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -4,16 +4,18 @@ const {
   Int32Array,
   ReflectApply,
   SafeWeakMap,
-  TypedArrayPrototypeFill,
   TypedArrayPrototypeSet,
+  TypedArrayPrototypeSlice,
   Uint8Array,
   globalThis: {
     Atomics,
   },
 } = primordials;
 const {
+  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_RETURN_VALUE,
 } = require('internal/errors').codes;
+const { deserialize, serialize } = require('v8');
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
@@ -24,8 +26,9 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(workerData.lock); // Required by Atomics
-const data = new Uint8Array(workerData.data); // For v8.deserialize/serialize
-const CHUNK_THRESHOLD = data.length - 26; // `{ done: true/false, value: … }` adds 26 bytes
+const done = new Uint8Array(workerData.done); // Coordinate chunks between main and worker
+const chunkLength = new Uint8Array(workerData.chunkLength); // Coordinate chunks between main and worker
+const data = new Uint8Array(workerData.data); // Chunks content
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
@@ -35,7 +38,7 @@ function releaseLock() {
 /**
  * ! Run everything possible within this function so errors get reported.
  */
-(async function setupESMWorker() {
+(async function customizedModuleWorker() {
   const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
   let initializationError, hooks;
 
@@ -51,65 +54,53 @@ function releaseLock() {
   // ! Put as little above this line as possible
   releaseLock(); // Send 'ready' signal to main
 
-  const { deserialize, serialize } = require('v8');
-
+  // Preserve state across iterations of the loop so that we can return responses in chunks
+  let serializedResponse, chunksCount, chunksSent = 0;
   while (true) { // The loop is needed in order to cycle through requests
     Atomics.wait(lock, 0, 1); // This pauses the while loop
 
-    const { method, args } = deserialize(data);
-    TypedArrayPrototypeFill(data, undefined);
-
-    // Each potential exception needs to be caught individually so that the correct error is sent to the main thread
-    let response;
     if (initializationError) {
-      response = initializationError;
-    } else {
-      try {
-        response = await ReflectApply(hooks[method], hooks, args);
-        if (!response) {
-          throw new ERR_INVALID_RETURN_VALUE('object', method, response)
-        }
-      } catch (exception) {
-        TypedArrayPrototypeSet(data, serialize({
-          __proto__: null,
-          done: i === chunkCount - 1,
-          value: serialize(exception),
-        }));
-        releaseLock();
+      serializedResponse = serialize(initializationError);
+      chunksCount = 1;
+    } else if (done[0] !== 0) { // Not currently sending chunks to main thread; process new request
+      const requestLength = deserialize(chunkLength);
+      const { method, args } = deserialize(data.slice(0, requestLength));
+      if (!hooks[method]) {
+        throw new ERR_INVALID_ARG_VALUE('method', method);
       }
-    }
 
-    try {
-      const serializedResponseValue = serialize(response);
-      const chunkCount = Math.ceil(serializedResponseValue.byteLength / CHUNK_THRESHOLD);
-      for (let i = 0; i < chunkCount; i++) {
-        const chunk = {
-          __proto__: null,
-          done: i === chunkCount - 1,
-          value: serializedResponseValue.slice(i, i + CHUNK_THRESHOLD),
-        };
-        const serializedChunk = serialize(chunk);
-        // Send the method response (or exception) to the main thread
-        TypedArrayPrototypeSet(data, serializedChunk);
-        releaseLock();
+      const response = await ReflectApply(hooks[method], hooks, args);
+      if (!response) {
+        throw new ERR_INVALID_RETURN_VALUE('object', method, response)
       }
-    } catch (exception) {
-      TypedArrayPrototypeSet(data, serialize(exception));
-      releaseLock();
+
+      serializedResponse = serialize(response);
+      chunksCount = Math.ceil(serializedResponse.byteLength / data.length);
+      chunksSent = 0;
     }
-  }
-})().catch((err) => {
-  // The triggerUncaughtException call below does not terminate the process or surface errors to the user;
-  // putting process._rawDebug here as a temporary workaround to ensure that the error is printed.
-  process._rawDebug('Uncaught exception in setupESMWorker:', err);
-  const { triggerUncaughtException } = internalBinding('errors');
-  releaseLock();
-  triggerUncaughtException(err);
-});
 
-process.on('uncaughtException', (err) => {
-  process._rawDebug('process uncaughtException:', new Error().stack);
-  const { triggerUncaughtException } = internalBinding('errors');
+    const startIndex = chunksSent * data.length;
+    const endIndex = startIndex + data.length;
+    const chunk = TypedArrayPrototypeSlice(serializedResponse, startIndex, endIndex);
+    const isLastChunk = chunksSent === chunksCount - 1;
+    TypedArrayPrototypeSet(data, chunk);
+    TypedArrayPrototypeSet(chunkLength, serialize(chunk.byteLength));
+    TypedArrayPrototypeSet(done, isLastChunk ? [1] : [0]);
+    if (isLastChunk) {
+      serializedResponse = undefined;
+      chunksCount = undefined;
+      chunksSent = 0;
+    } else {
+      chunksSent++;
+    }
+    releaseLock();
+  }
+})().catch((exception) => {
+  // Send the exception up to the main thread so it can throw it and crash the process
+  process._rawDebug('exception in worker:', exception)
+  const chunk = serialize(exception);
+  TypedArrayPrototypeSet(data, chunk);
+  TypedArrayPrototypeSet(chunkLength, serialize(chunk.byteLength));
+  TypedArrayPrototypeSet(done, [1]);
   releaseLock();
-  triggerUncaughtException(err);
 });

From 599a6165b0b3eb589ec267dd5ed2ebf399f7616f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Mon, 2 Jan 2023 09:45:51 +0100
Subject: [PATCH 032/126] unlock worker thread

use postMessage from the main thread instead of atomics to signal the worker
---
 lib/internal/modules/esm/hooks.js  | 31 ++++++++++++++++++++++--------
 lib/internal/modules/esm/worker.js |  7 ++++---
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 1f4ec1a1339008..c8131c3fd8da3a 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -460,12 +460,15 @@ ObjectSetPrototypeOf(Hooks.prototype, null);
 class HooksProxy {
   /**
    * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
-   * segment is used to tell the main to sleep when the worker is processing, and vice versa
-   * (for the worker to sleep whilst the main thread is processing).
+   * segment is used to tell the main to sleep when the worker is processing.
    * 0 -> main sleeps
-   * 1 -> worker sleeps
+   * 1 -> main wakes up
    */
   #lock;
+  /**
+   * A MessagePort used to synchronously communicate with the worker.
+   */
+  #syncCommPort;
 
   #done;
   #chunkLength;
@@ -485,6 +488,7 @@ class HooksProxy {
    */
   constructor() {
     const { InternalWorker } = require('internal/worker');
+    const { MessageChannel } = require('internal/worker/io');
 
     const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
     const done = new SharedArrayBuffer(1); // For chunking, to know whether the last chunk has been sent
@@ -494,15 +498,24 @@ class HooksProxy {
     this.#done = new Uint8Array(done);
     this.#chunkLength = new Uint8Array(chunkLength);
     this.#data = new Uint8Array(data);
+    const syncCommChannel = new MessageChannel();
+    this.#syncCommPort = syncCommChannel.port1;
 
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
       stdin: false,
       stdout: false,
       trackUnmanagedFds: false,
-      workerData: { lock, done, chunkLength, data },
+      workerData: {
+        lock,
+        done,
+        chunkLength,
+        data,
+        syncCommPort: syncCommChannel.port2,
+      },
+      transferList: [syncCommChannel.port2],
     });
-    worker.unref(); // ! Allows the process to eventually exit when worker is in its final sleep.
+    worker.unref(); // ! Allows the process to eventually exit.
   }
 
   makeRequest(method, ...args) {
@@ -554,9 +567,11 @@ class HooksProxy {
   }
 
   #awaitResponse() {
-    Atomics.store(this.#lock, 0, 0); // Send request to worker
-    Atomics.notify(this.#lock, 0); // Notify worker of new request
-    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds
+    // Signal the worker that there is work to do.
+    this.#syncCommPort.postMessage(true);
+
+    Atomics.store(this.#lock, 0, 0); // Reset lock.
+    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds.
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 8fb13904da5c29..565163a10b3ac6 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -29,6 +29,7 @@ const lock = new Int32Array(workerData.lock); // Required by Atomics
 const done = new Uint8Array(workerData.done); // Coordinate chunks between main and worker
 const chunkLength = new Uint8Array(workerData.chunkLength); // Coordinate chunks between main and worker
 const data = new Uint8Array(workerData.data); // Chunks content
+const { syncCommPort } = workerData; // To receive work signals.
 
 function releaseLock() {
   Atomics.store(lock, 0, 1); // Send response to main
@@ -51,14 +52,14 @@ function releaseLock() {
     initializationError = exception;
   }
 
+  syncCommPort.on('message', handleSyncMessage);
+
   // ! Put as little above this line as possible
   releaseLock(); // Send 'ready' signal to main
 
   // Preserve state across iterations of the loop so that we can return responses in chunks
   let serializedResponse, chunksCount, chunksSent = 0;
-  while (true) { // The loop is needed in order to cycle through requests
-    Atomics.wait(lock, 0, 1); // This pauses the while loop
-
+  async function handleSyncMessage() {
     if (initializationError) {
       serializedResponse = serialize(initializationError);
       chunksCount = 1;

From 42d485e249dff900e09c0210638a3a96bb3748ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Mon, 2 Jan 2023 11:23:05 +0100
Subject: [PATCH 033/126] use syncCommPort to exchange data too

---
 lib/internal/modules/esm/hooks.js  | 72 +++++-------------------------
 lib/internal/modules/esm/worker.js | 72 +++++++++++++-----------------
 2 files changed, 40 insertions(+), 104 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index c8131c3fd8da3a..4bff6d738e0efa 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -10,8 +10,6 @@ const {
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
-  TypedArrayPrototypeSet,
-  TypedArrayPrototypeSlice,
   globalThis,
 } = primordials;
 
@@ -24,14 +22,11 @@ const {
   ERR_INVALID_RETURN_VALUE,
 } = require('internal/errors').codes;
 const { URL } = require('internal/url');
+const { receiveMessageOnPort } = require('worker_threads');
 const {
   isAnyArrayBuffer,
   isArrayBufferView,
 } = require('internal/util/types');
-const {
-  deserialize,
-  serialize,
-} = require('v8');
 const {
   validateObject,
   validateString,
@@ -470,16 +465,6 @@ class HooksProxy {
    */
   #syncCommPort;
 
-  #done;
-  #chunkLength;
-
-  /**
-   * The request & response segment of the shared memory. TextEncoder/Decoder (needed to convert
-   * requests & responses into a format supported by the comms channel) reads and writes with
-   * Uint8Array.
-   */
-  #data;
-
   #isReady = false;
 
   /**
@@ -491,13 +476,7 @@ class HooksProxy {
     const { MessageChannel } = require('internal/worker/io');
 
     const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
-    const done = new SharedArrayBuffer(1); // For chunking, to know whether the last chunk has been sent
-    const chunkLength = new SharedArrayBuffer(32); // For chunking, to know the length of the current chunk
-    const data = new SharedArrayBuffer(2048); // The data for the request and response
     this.#lock = new Int32Array(lock);
-    this.#done = new Uint8Array(done);
-    this.#chunkLength = new Uint8Array(chunkLength);
-    this.#data = new Uint8Array(data);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
 
@@ -508,9 +487,6 @@ class HooksProxy {
       trackUnmanagedFds: false,
       workerData: {
         lock,
-        done,
-        chunkLength,
-        data,
         syncCommPort: syncCommChannel.port2,
       },
       transferList: [syncCommChannel.port2],
@@ -528,50 +504,22 @@ class HooksProxy {
       this.#isReady = true;
     }
 
-    const request = serialize({ method, args });
-    TypedArrayPrototypeSet(this.#data, request);
-    TypedArrayPrototypeSet(this.#chunkLength, serialize(request.byteLength));
-    TypedArrayPrototypeSet(this.#done, [1]);
-
-    const chunks = [];
-    let done = false;
-    while (done === false) {
-      this.#awaitResponse();
+    // Pass work to the worker.
+    this.#syncCommPort.postMessage({ method, args });
 
-      try {
-        var chunkLength = deserialize(this.#chunkLength);
-      } catch (err) {
-        throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
-      }
-      if (!chunkLength) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
-
-      const chunk = TypedArrayPrototypeSlice(this.#data, 0, chunkLength);
-      if (!chunk) { throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined); }
-
-      ArrayPrototypePush(chunks, chunk);
-      if (this.#done[0] === 1) { done = true; }
-    }
-    if (chunks.length === 0) { // Response should not be empty
-      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
-    }
-    const reassembledChunks = Buffer.concat(chunks);
-    const response = deserialize(reassembledChunks);
+    Atomics.store(this.#lock, 0, 0); // Reset lock.
+    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds.
 
+    const response = receiveMessageOnPort(this.#syncCommPort).message;
     if (response instanceof Error) {
       // An exception was thrown in the worker thread; re-throw to crash the process
       const { triggerUncaughtException } = internalBinding('errors');
       triggerUncaughtException(response);
+    } else if (!response) {
+      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
+    } else {
+      return response;
     }
-
-    return response;
-  }
-
-  #awaitResponse() {
-    // Signal the worker that there is work to do.
-    this.#syncCommPort.postMessage(true);
-
-    Atomics.store(this.#lock, 0, 0); // Reset lock.
-    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds.
   }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 565163a10b3ac6..905df88b2fd75b 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -4,9 +4,6 @@ const {
   Int32Array,
   ReflectApply,
   SafeWeakMap,
-  TypedArrayPrototypeSet,
-  TypedArrayPrototypeSlice,
-  Uint8Array,
   globalThis: {
     Atomics,
   },
@@ -26,9 +23,6 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(workerData.lock); // Required by Atomics
-const done = new Uint8Array(workerData.done); // Coordinate chunks between main and worker
-const chunkLength = new Uint8Array(workerData.chunkLength); // Coordinate chunks between main and worker
-const data = new Uint8Array(workerData.data); // Chunks content
 const { syncCommPort } = workerData; // To receive work signals.
 
 function releaseLock() {
@@ -54,54 +48,48 @@ function releaseLock() {
 
   syncCommPort.on('message', handleSyncMessage);
 
-  // ! Put as little above this line as possible
-  releaseLock(); // Send 'ready' signal to main
+  // ! Put as little above this line as possible.
+  releaseLock(); // Send 'ready' signal to main.
 
-  // Preserve state across iterations of the loop so that we can return responses in chunks
-  let serializedResponse, chunksCount, chunksSent = 0;
-  async function handleSyncMessage() {
+  async function handleSyncMessage({ method, args }) {
+    // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
+    let response;
     if (initializationError) {
-      serializedResponse = serialize(initializationError);
-      chunksCount = 1;
-    } else if (done[0] !== 0) { // Not currently sending chunks to main thread; process new request
-      const requestLength = deserialize(chunkLength);
-      const { method, args } = deserialize(data.slice(0, requestLength));
+      response = initializationError;
+    } else {
       if (!hooks[method]) {
         throw new ERR_INVALID_ARG_VALUE('method', method);
       }
 
-      const response = await ReflectApply(hooks[method], hooks, args);
-      if (!response) {
-        throw new ERR_INVALID_RETURN_VALUE('object', method, response)
+      try {
+        response = await ReflectApply(hooks[method], hooks, args);
+        if (!response) {
+          throw new ERR_INVALID_RETURN_VALUE('object', method, response);
+        }
+      } catch (exception) {
+        response = exception;
       }
-
-      serializedResponse = serialize(response);
-      chunksCount = Math.ceil(serializedResponse.byteLength / data.length);
-      chunksSent = 0;
     }
 
-    const startIndex = chunksSent * data.length;
-    const endIndex = startIndex + data.length;
-    const chunk = TypedArrayPrototypeSlice(serializedResponse, startIndex, endIndex);
-    const isLastChunk = chunksSent === chunksCount - 1;
-    TypedArrayPrototypeSet(data, chunk);
-    TypedArrayPrototypeSet(chunkLength, serialize(chunk.byteLength));
-    TypedArrayPrototypeSet(done, isLastChunk ? [1] : [0]);
-    if (isLastChunk) {
-      serializedResponse = undefined;
-      chunksCount = undefined;
-      chunksSent = 0;
-    } else {
-      chunksSent++;
+    // Send the method response (or exception) to the main thread.
+    try {
+      syncCommPort.postMessage(response);
+    } catch (exception) {
+      // Or send the exception thrown when trying to send the response.
+      syncCommPort.postMessage(exception);
     }
     releaseLock();
   }
-})().catch((exception) => {
+})().catch(exception => {
   // Send the exception up to the main thread so it can throw it and crash the process
-  process._rawDebug('exception in worker:', exception)
-  const chunk = serialize(exception);
-  TypedArrayPrototypeSet(data, chunk);
-  TypedArrayPrototypeSet(chunkLength, serialize(chunk.byteLength));
-  TypedArrayPrototypeSet(done, [1]);
+  process._rawDebug('exception in worker:', exception) // TODO: Remove this once exception handling is reliable
+  syncCommPort.postMessage(exception);
+  releaseLock();
+});
+
+process.on('uncaughtException', (err) => {
+  process._rawDebug('process uncaughtException:', err);
+  const { triggerUncaughtException } = internalBinding('errors');
   releaseLock();
+  triggerUncaughtException(err);
 });

From 8e3e0c6cce8108f7cfa1320f878e957b0c80c9e6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Sun, 8 Jan 2023 21:13:59 -0800
Subject: [PATCH 034/126] fix --import

---
 lib/internal/modules/esm/utils.js  | 11 -----------
 lib/internal/process/esm_loader.js | 18 ++++++++++++++++++
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 6efad5a23008bd..c79b21d3cda9d2 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -133,17 +133,6 @@ async function initializeHooks() {
 
   hooks.initializeGlobalPreload();
 
-  // Preload after loaders are added so they can be used
-  const preloadModules = getOptionValue('--import');
-
-  if (preloadModules) {
-    await privateModuleLoader.import(
-      preloadModules,
-      parentURL,
-      kEmptyObject,
-    );
-  }
-
   return hooks;
 }
 
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 77ee73d92970eb..36d6e15eb223dd 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,15 +1,33 @@
 'use strict';
 
 const { ModuleLoader } = require('internal/modules/esm/loader');
+const { getOptionValue } = require('internal/options');
 const {
   hasUncaughtExceptionCaptureCallback,
 } = require('internal/process/execution');
+const { pathToFileURL } = require('internal/url');
+const { kEmptyObject } = require('internal/util');
 
 const esmLoader = new ModuleLoader(true);
 exports.esmLoader = esmLoader;
 
 exports.loadESM = async function loadESM(callback) {
   try {
+    const userImports = getOptionValue('--import');
+    if (userImports.length > 0) {
+      let cwd;
+      try {
+        cwd = process.cwd() + '/';
+      } catch {
+        cwd = '/';
+      }
+      const parentURL = pathToFileURL(cwd).href;
+      await esmLoader.import(
+        userImports,
+        parentURL,
+        kEmptyObject,
+      );
+    }
     await callback(esmLoader);
   } catch (err) {
     if (hasUncaughtExceptionCaptureCallback()) {

From 76e23d859fa9dcdcd97dfe6d1165d0eb45827c84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 10 Jan 2023 08:26:44 +0000
Subject: [PATCH 035/126] fix doclint

---
 doc/api/esm.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 28c05f173ed22b..179aac352230ea 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -762,7 +762,7 @@ changes:
 > signature may change. Do not rely on the API described below.
 
 * `specifier` {string}
-* `context` {object}
+* `context` {Object}
   * `conditions` {string\[]} Export conditions of the relevant `package.json`
   * `importAssertions` {Object} An object whose key-value pairs represent the
     assertions for the module to import
@@ -859,16 +859,16 @@ changes:
 > deprecated, hooks (`getFormat`, `getSource`, and `transformSource`).
 
 * `url` {string} The URL returned by the `resolve` chain
-* `context` {object}
+* `context` {Object}
   * `conditions` {string\[]} Export conditions of the relevant `package.json`
   * `format` {string|null|undefined} The format optionally supplied by the
     `resolve` hook chain
-  * `importAssertions` {object}
+  * `importAssertions` {Object}
 * `nextLoad` {Function} The subsequent `load` hook in the chain, or the
   Node.js default `load` hook after the last user-supplied `load` hook
   * `specifier` {string}
-  * `context` {object}
-* Returns: {object}
+  * `context` {Object}
+* Returns: {Object}
   * `format` {string}
   * `shortCircuit` {undefined|boolean} A signal that this hook intends to
     terminate the chain of `resolve` hooks. **Default:** `false`
@@ -956,7 +956,7 @@ changes:
 > In a previous version of this API, this hook was named
 > `getGlobalPreloadCode`.
 
-* `context` {object} Information to assist the preload code
+* `context` {Object} Information to assist the preload code
   * `port` {MessagePort}
 * Returns: {string} Code to run before application startup
 

From 75fe62bd47f8b878b623a1a62cdb4c2d68e13f59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 10 Jan 2023 08:27:34 +0000
Subject: [PATCH 036/126] remove internal check

---
 lib/internal/main/worker_thread.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 428a326c60b9a4..4797e9760148fa 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -130,7 +130,7 @@ port.on('message', (message) => {
     if (manifestSrc) {
       require('internal/process/policy').setup(manifestSrc, manifestURL);
     }
-    if (doEval !== 'internal') setupUserModules();
+    setupUserModules();
 
     if (!hasStdin)
       process.stdin.push(null);

From 350351ff9d6a167587f8af1c618e0129dc9031d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 10 Jan 2023 09:02:14 +0000
Subject: [PATCH 037/126] refactor worker exception handling

It's possible to throw/reject with anything (not only instances of Error)
---
 lib/internal/modules/esm/hooks.js  | 15 ++++++++----
 lib/internal/modules/esm/worker.js | 37 ++++++++++++++++++++----------
 2 files changed, 36 insertions(+), 16 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 4bff6d738e0efa..d1ca1f79a96c09 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -499,6 +499,12 @@ class HooksProxy {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
         Atomics.wait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
+        const response = receiveMessageOnPort(this.#syncCommPort).message;
+        if (response.type === 'error') {
+          const { triggerUncaughtException } = internalBinding('errors');
+          triggerUncaughtException(response.value);
+          throw response.value
+        }
       }
 
       this.#isReady = true;
@@ -511,14 +517,15 @@ class HooksProxy {
     Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds.
 
     const response = receiveMessageOnPort(this.#syncCommPort).message;
-    if (response instanceof Error) {
+    if (response.type === 'error') {
       // An exception was thrown in the worker thread; re-throw to crash the process
       const { triggerUncaughtException } = internalBinding('errors');
-      triggerUncaughtException(response);
-    } else if (!response) {
+      triggerUncaughtException(response.value);
+      throw response.value;
+    } else if (!response.value) {
       throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
     } else {
-      return response;
+      return response.value;
     }
   }
 }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 905df88b2fd75b..0b9321a14702c4 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -12,7 +12,6 @@ const {
   ERR_INVALID_ARG_VALUE,
   ERR_INVALID_RETURN_VALUE,
 } = require('internal/errors').codes;
-const { deserialize, serialize } = require('v8');
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
@@ -35,7 +34,9 @@ function releaseLock() {
  */
 (async function customizedModuleWorker() {
   const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
-  let initializationError, hooks;
+  let hooks;
+  let hasInitializationError = false;
+  let initializationError;
 
   try {
     initializeESM();
@@ -43,47 +44,59 @@ function releaseLock() {
   } catch (exception) {
     // If there was an error while parsing and executing a user loader, for example if because a loader contained a syntax error,
     // then we need to send the error to the main thread so it can be thrown and printed.
+    hasInitializationError = true;
     initializationError = exception;
   }
 
   syncCommPort.on('message', handleSyncMessage);
 
-  // ! Put as little above this line as possible.
+  syncCommPort.postMessage({
+    type: hasInitializationError ? 'error' : 'success',
+    value: initializationError,
+  })
   releaseLock(); // Send 'ready' signal to main.
 
   async function handleSyncMessage({ method, args }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
+    let hasError = false;
     let response;
-    if (initializationError) {
-      response = initializationError;
+    if (!hooks[method]) {
+      hasError = true;
+      response = new ERR_INVALID_ARG_VALUE('method', method);
     } else {
-      if (!hooks[method]) {
-        throw new ERR_INVALID_ARG_VALUE('method', method);
-      }
-
       try {
         response = await ReflectApply(hooks[method], hooks, args);
         if (!response) {
           throw new ERR_INVALID_RETURN_VALUE('object', method, response);
         }
       } catch (exception) {
+        hasError = true;
         response = exception;
       }
     }
 
     // Send the method response (or exception) to the main thread.
     try {
-      syncCommPort.postMessage(response);
+      syncCommPort.postMessage({
+        type: hasError ? 'error' : 'success',
+        value: response,
+      });
     } catch (exception) {
       // Or send the exception thrown when trying to send the response.
-      syncCommPort.postMessage(exception);
+      syncCommPort.postMessage({
+        type: 'error',
+        value: exception,
+      });
     }
     releaseLock();
   }
 })().catch(exception => {
   // Send the exception up to the main thread so it can throw it and crash the process
   process._rawDebug('exception in worker:', exception) // TODO: Remove this once exception handling is reliable
-  syncCommPort.postMessage(exception);
+  syncCommPort.postMessage({
+    type: 'error',
+    value: exception,
+  });
   releaseLock();
 });
 

From f3b2ed985b4bf634851fa0eec5000df0adc80f13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 10 Jan 2023 09:24:55 +0000
Subject: [PATCH 038/126] errors during load should just be rethrown

---
 lib/internal/modules/esm/hooks.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index d1ca1f79a96c09..0f10f180c642b2 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -501,6 +501,7 @@ class HooksProxy {
         Atomics.wait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
         const response = receiveMessageOnPort(this.#syncCommPort).message;
         if (response.type === 'error') {
+          // An exception was thrown during initialization of the worker thread; re-throw to crash the process.
           const { triggerUncaughtException } = internalBinding('errors');
           triggerUncaughtException(response.value);
           throw response.value
@@ -518,9 +519,6 @@ class HooksProxy {
 
     const response = receiveMessageOnPort(this.#syncCommPort).message;
     if (response.type === 'error') {
-      // An exception was thrown in the worker thread; re-throw to crash the process
-      const { triggerUncaughtException } = internalBinding('errors');
-      triggerUncaughtException(response.value);
       throw response.value;
     } else if (!response.value) {
       throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);

From 7e79b2f73b3b04cf0b9f99ea27f248fbd239dffe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Wed, 11 Jan 2023 14:47:29 +0000
Subject: [PATCH 039/126] run global preload scripts in the main thread

---
 lib/internal/modules/esm/hooks.js  | 71 ++++++++++++++++++------------
 lib/internal/modules/esm/utils.js  |  4 +-
 lib/internal/modules/esm/worker.js | 21 ++++++---
 3 files changed, 61 insertions(+), 35 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 0f10f180c642b2..9987b4f458c13e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -125,6 +125,7 @@ class Hooks {
    * Initialize `globalPreload` hooks.
    */
   initializeGlobalPreload() {
+    const preloadScripts = [];
     for (let i = this.#chains.globalPreload.length - 1; i >= 0; i--) {
       const { MessageChannel } = require('internal/worker/io');
       const channel = new MessageChannel();
@@ -147,41 +148,21 @@ class Hooks {
 
       if (preloaded == null) { return; }
 
-      const hookErrIdentifier = `${specifier} globalPreload`;
-
       if (typeof preloaded !== 'string') { // [2]
+        const hookErrIdentifier = `${specifier} globalPreload`;
         throw new ERR_INVALID_RETURN_VALUE(
           'a string',
           hookErrIdentifier,
           preload,
         );
       }
-      const { compileFunction } = require('vm');
-      const preloadInit = compileFunction(
-        preloaded,
-        ['getBuiltin', 'port'],
-        {
-          filename: '<preload>',
-        },
-      );
-      const { BuiltinModule } = require('internal/bootstrap/realm');
-      // Calls the compiled preload source text gotten from the hook
-      // Since the parameters are named we use positional parameters
-      // see compileFunction above to cross reference the names
-      FunctionPrototypeCall(
-        preloadInit,
-        globalThis,
-        // Param getBuiltin
-        (builtinName) => {
-          if (BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
-            return require(builtinName);
-          }
-          throw new ERR_INVALID_ARG_VALUE('builtinName', builtinName);
-        },
-        // Param port
-        insidePreload,
-      );
+
+      preloadScripts.push({
+        code: preloaded,
+        port: insidePreload,
+      });
     }
+    return preloadScripts;
   }
 
   /**
@@ -504,7 +485,10 @@ class HooksProxy {
           // An exception was thrown during initialization of the worker thread; re-throw to crash the process.
           const { triggerUncaughtException } = internalBinding('errors');
           triggerUncaughtException(response.value);
-          throw response.value
+          throw response.value;
+        } else {
+          const { preloadScripts } = response.value;
+          this.#executePreloadScripts(preloadScripts);
         }
       }
 
@@ -526,6 +510,37 @@ class HooksProxy {
       return response.value;
     }
   }
+
+  #executePreloadScripts(preloadScripts) {
+    for (const { code, port } of preloadScripts) {
+      const { compileFunction } = require('vm');
+      const preloadInit = compileFunction(
+        code,
+        ['getBuiltin', 'port'],
+        {
+          filename: '<preload>',
+        },
+      );
+      const { BuiltinModule } = require('internal/bootstrap/realm');
+      // Calls the compiled preload source text gotten from the hook
+      // Since the parameters are named we use positional parameters
+      // see compileFunction above to cross reference the names
+      FunctionPrototypeCall(
+        preloadInit,
+        globalThis,
+        // Param getBuiltin
+        (builtinName) => {
+          if (BuiltinModule.canBeRequiredByUsers(builtinName) &&
+              BuiltinModule.canBeRequiredWithoutScheme(builtinName)) {
+            return require(builtinName);
+          }
+          throw new ERR_INVALID_ARG_VALUE('builtinName', builtinName);
+        },
+        // Param port
+        port,
+      );
+    }
+  }
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
 
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index c79b21d3cda9d2..8196027c18faac 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -131,9 +131,9 @@ async function initializeHooks() {
   const { Hooks } = require('internal/modules/esm/hooks');
   const hooks = new Hooks(importedCustomLoaders);
 
-  hooks.initializeGlobalPreload();
+  const preloadScripts = hooks.initializeGlobalPreload();
 
-  return hooks;
+  return { hooks, preloadScripts };
 }
 
 module.exports = {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 0b9321a14702c4..765b9c1210f0b3 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -35,12 +35,15 @@ function releaseLock() {
 (async function customizedModuleWorker() {
   const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
   let hooks;
+  let preloadScripts;
   let hasInitializationError = false;
   let initializationError;
 
   try {
     initializeESM();
-    hooks = await initializeHooks();
+    const initResult = await initializeHooks();
+    hooks = initResult.hooks;
+    preloadScripts = initResult.preloadScripts;
   } catch (exception) {
     // If there was an error while parsing and executing a user loader, for example if because a loader contained a syntax error,
     // then we need to send the error to the main thread so it can be thrown and printed.
@@ -50,10 +53,18 @@ function releaseLock() {
 
   syncCommPort.on('message', handleSyncMessage);
 
-  syncCommPort.postMessage({
-    type: hasInitializationError ? 'error' : 'success',
-    value: initializationError,
-  })
+  if (hasInitializationError) {
+    syncCommPort.postMessage({
+      type: 'error',
+      value: initializationError,
+    });
+  } else {
+    syncCommPort.postMessage({
+      type: 'success',
+      value: { preloadScripts },
+    }, preloadScripts.map(({ port }) => port));
+  }
+
   releaseLock(); // Send 'ready' signal to main.
 
   async function handleSyncMessage({ method, args }) {

From c0142d64f70d8b33cce036eb5d21230402148aad Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 11 Jan 2023 12:31:26 +0100
Subject: [PATCH 040/126] nits

---
 lib/internal/modules/esm/loader.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 2a1725f48db43f..79acf45d95bc7d 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -33,6 +33,7 @@ function getTranslators() {
 }
 
 /**
+ * @type {HooksProxy}
  * Multiple loader instances exist for various, specific reasons (see code comments at site).
  * In order to maintain consistency, we use a single worker (sandbox), which must sit apart of an
  * individual loader instance.
@@ -279,7 +280,7 @@ class DefaultModuleLoader {
    *                                   be resolved.
    * @param {string} [parentURL] The URL path of the module's parent.
    * @param {ImportAssertions} importAssertions Assertions from the import
-   *                                              statement or expression.
+   *                                            statement or expression.
    * @returns {{ format: string, url: URL['href'] }}
    */
   resolve(originalSpecifier, parentURL, importAssertions) {
@@ -353,12 +354,11 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
    * @param {string} originalSpecifier The specified URL path of the module to
    *                                   be resolved.
    * @param {string} [parentURL] The URL path of the module's parent.
-   * @param {ImportAssertions} [importAssertions] Assertions from the import
-   *                                              statement or expression.
+   * @param {ImportAssertions} importAssertions Assertions from the import
+   *                                            statement or expression.
    * @returns {{ format: string, url: URL['href'] }}
    */
-  resolve(originalSpecifier, parentURL, importAssertions = { __proto__: null },
-  ) {
+  resolve(originalSpecifier, parentURL, importAssertions) {
     return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
   }
 

From 5d7e3b46df9012f31c0efbc154c850e9d71f311e Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 11 Jan 2023 13:07:06 +0100
Subject: [PATCH 041/126] nits

---
 lib/internal/modules/esm/loader.js | 23 +++++++----------------
 1 file changed, 7 insertions(+), 16 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 79acf45d95bc7d..6799e9f0e778bf 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -21,6 +21,7 @@ const { emitExperimentalWarning } = require('internal/util');
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+let defaultResolve, defaultLoad, importMetaInitializer;
 
 function newModuleMap() {
   const ModuleMap = require('internal/modules/esm/module_map');
@@ -71,10 +72,6 @@ let hooksProxy;
  * The below CustomizedModuleLoader class extends this one to support custom user loader hooks.
  */
 class DefaultModuleLoader {
-  #defaultResolve;
-  #defaultLoad;
-  #importMetaInitializer;
-
   /**
    * The conditions for resolving packages if `--conditions` is not used.
    */
@@ -284,9 +281,7 @@ class DefaultModuleLoader {
    * @returns {{ format: string, url: URL['href'] }}
    */
   resolve(originalSpecifier, parentURL, importAssertions) {
-    if (!this.#defaultResolve) {
-      this.#defaultResolve = require('internal/modules/esm/resolve').defaultResolve;
-    }
+    defaultResolve ??= require('internal/modules/esm/resolve').defaultResolve;
 
     const context = {
       __proto__: null,
@@ -295,7 +290,7 @@ class DefaultModuleLoader {
       parentURL,
     };
 
-    return this.#defaultResolve(originalSpecifier, context);
+    return defaultResolve(originalSpecifier, context);
   }
 
   /**
@@ -306,11 +301,9 @@ class DefaultModuleLoader {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context) {
-    if (!this.#defaultLoad) {
-      this.#defaultLoad = require('internal/modules/esm/load').defaultLoad;
-    }
+    defaultLoad ??= require('internal/modules/esm/load').defaultLoad;
 
-    const result = await this.#defaultLoad(url, context);
+    const result = await defaultLoad(url, context);
     this.validateLoadResult(url, result?.format);
     return result;
   }
@@ -322,10 +315,8 @@ class DefaultModuleLoader {
   }
 
   importMetaInitialize(meta, context) {
-    if (!this.#importMetaInitializer) {
-      this.#importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-    }
-    meta = this.#importMetaInitializer(meta, context, this);
+    importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
+    meta = importMetaInitializer(meta, context, this);
     return meta;
   }
 }

From 685590c057e65dbea1bdeec5ac5510b6c9556524 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 11 Jan 2023 13:19:23 +0100
Subject: [PATCH 042/126] fix linter errors

---
 lib/internal/modules/esm/hooks.js             | 19 ++++++++------
 lib/internal/modules/esm/loader.js            | 25 ++++++++-----------
 lib/internal/modules/esm/worker.js            | 18 +++++++------
 lib/internal/worker.js                        |  7 +++---
 .../test-esm-import-meta-resolve.mjs          |  2 +-
 test/es-module/test-esm-resolve-type.mjs      |  4 +--
 6 files changed, 40 insertions(+), 35 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 9987b4f458c13e..75cf2ca9bceca4 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -4,6 +4,7 @@ const {
   ArrayPrototypeJoin,
   ArrayPrototypePush,
   FunctionPrototypeCall,
+  Int32Array,
   ObjectAssign,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
@@ -13,6 +14,14 @@ const {
   globalThis,
 } = primordials;
 
+const {
+  Atomics: {
+    store: AtomicsStore,
+    wait: AtomicsWait,
+  },
+  SharedArrayBuffer,
+} = globalThis;
+
 const {
   ERR_LOADER_CHAIN_INCOMPLETE,
   ERR_INTERNAL_ASSERTION,
@@ -448,10 +457,6 @@ class HooksProxy {
 
   #isReady = false;
 
-  /**
-   * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
-   *  (as returned by `ModuleLoader.import()`).
-   */
   constructor() {
     const { InternalWorker } = require('internal/worker');
     const { MessageChannel } = require('internal/worker/io');
@@ -479,7 +484,7 @@ class HooksProxy {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
-        Atomics.wait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
+        AtomicsWait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
         const response = receiveMessageOnPort(this.#syncCommPort).message;
         if (response.type === 'error') {
           // An exception was thrown during initialization of the worker thread; re-throw to crash the process.
@@ -498,8 +503,8 @@ class HooksProxy {
     // Pass work to the worker.
     this.#syncCommPort.postMessage({ method, args });
 
-    Atomics.store(this.#lock, 0, 0); // Reset lock.
-    Atomics.wait(this.#lock, 0, 0); // Sleep until worker responds.
+    AtomicsStore(this.#lock, 0, 0); // Reset lock.
+    AtomicsWait(this.#lock, 0, 0); // Sleep until worker responds.
 
     const response = receiveMessageOnPort(this.#syncCommPort).message;
     if (response.type === 'error') {
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 6799e9f0e778bf..13fc5f517f3c69 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -372,24 +372,19 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
  * A loader instance is used as the main entry point for loading ES modules. Currently, this is a singleton; there is
  * only one used for loading the main module and everything in its dependency graph, though separate instances of this
  * class might be instantiated as part of bootstrap for other purposes.
+ * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
+ * @returns {instanceof BaseModuleLoader | instanceof CustomizedModuleLoader}
  */
-class ModuleLoader {
-  /**
-   *
-   * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
-   * @returns {instanceof BaseModuleLoader | instanceof CustomizedModuleLoader}
-   */
-  constructor(useCustomLoadersIfPresent = true) {
-    if (useCustomLoadersIfPresent) {
-      const userLoaderPaths = getOptionValue('--experimental-loader');
-      if (userLoaderPaths.length > 0) {
-        emitExperimentalWarning('Custom ESM Loaders');
-        return new CustomizedModuleLoader(userLoaderPaths);
-      }
+function ModuleLoader(useCustomLoadersIfPresent = true) {
+  if (useCustomLoadersIfPresent) {
+    const userLoaderPaths = getOptionValue('--experimental-loader');
+    if (userLoaderPaths.length > 0) {
+      emitExperimentalWarning('Custom ESM Loaders');
+      return new CustomizedModuleLoader(userLoaderPaths);
     }
-
-    return new DefaultModuleLoader();
   }
+
+  return new DefaultModuleLoader();
 }
 ObjectSetPrototypeOf(ModuleLoader.prototype, null);
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 765b9c1210f0b3..00f03702d077c4 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -5,7 +5,10 @@ const {
   ReflectApply,
   SafeWeakMap,
   globalThis: {
-    Atomics,
+    Atomics: {
+      notify: AtomicsNotify,
+      store: AtomicsStore,
+    },
   },
 } = primordials;
 const {
@@ -25,8 +28,8 @@ const lock = new Int32Array(workerData.lock); // Required by Atomics
 const { syncCommPort } = workerData; // To receive work signals.
 
 function releaseLock() {
-  Atomics.store(lock, 0, 1); // Send response to main
-  Atomics.notify(lock, 0); // Notify main of new response
+  AtomicsStore(lock, 0, 1); // Send response to main
+  AtomicsNotify(lock, 0); // Notify main of new response
 }
 
 /**
@@ -45,8 +48,9 @@ function releaseLock() {
     hooks = initResult.hooks;
     preloadScripts = initResult.preloadScripts;
   } catch (exception) {
-    // If there was an error while parsing and executing a user loader, for example if because a loader contained a syntax error,
-    // then we need to send the error to the main thread so it can be thrown and printed.
+    // If there was an error while parsing and executing a user loader, for
+    // example if because a loader contained a syntax error, then we need to
+    // send the error to the main thread so it can be thrown and printed.
     hasInitializationError = true;
     initializationError = exception;
   }
@@ -101,9 +105,9 @@ function releaseLock() {
     }
     releaseLock();
   }
-})().catch(exception => {
+})().catch((exception) => {
   // Send the exception up to the main thread so it can throw it and crash the process
-  process._rawDebug('exception in worker:', exception) // TODO: Remove this once exception handling is reliable
+  process._rawDebug('exception in worker:', exception); // TODO: Remove this once exception handling is reliable
   syncCommPort.postMessage({
     type: 'error',
     value: exception,
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 47921179913bed..a78795e08011ed 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -82,6 +82,7 @@ const kOnCouldNotSerializeErr = Symbol('kOnCouldNotSerializeErr');
 const kOnErrorMessage = Symbol('kOnErrorMessage');
 const kParentSideStdio = Symbol('kParentSideStdio');
 const kLoopStartTime = Symbol('kLoopStartTime');
+const kIsInternal = Symbol('kIsInternal');
 const kIsOnline = Symbol('kIsOnline');
 
 const SHARE_ENV = SymbolFor('nodejs.worker_threads.SHARE_ENV');
@@ -128,7 +129,7 @@ function assignEnvironmentData(data) {
 class Worker extends EventEmitter {
   constructor(filename, options = kEmptyObject) {
     super();
-    const isInternal = this instanceof InternalWorker;
+    const isInternal = arguments[2] === kIsInternal;
     debug(
       `[${threadId}] create new worker`,
       filename,
@@ -453,9 +454,9 @@ class Worker extends EventEmitter {
 }
 
 class InternalWorker extends Worker {
-  // eslint-disable-next-line no-useless-constructor
+
   constructor(filename, options) {
-    super(filename, options);
+    super(filename, options, kIsInternal);
   }
 }
 
diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index e852a82393cc54..a38abe1636bd89 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -33,7 +33,7 @@ assert.strictEqual(
 );
 [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
   assert.throws(() => {
-    import.meta.resolve('../fixtures/', arg)
+    import.meta.resolve('../fixtures/', arg);
   }, { code: 'ERR_INVALID_ARG_TYPE' })
 );
 assert.strictEqual(
diff --git a/test/es-module/test-esm-resolve-type.mjs b/test/es-module/test-esm-resolve-type.mjs
index 539d2230c7d78b..7a0527ff59e554 100644
--- a/test/es-module/test-esm-resolve-type.mjs
+++ b/test/es-module/test-esm-resolve-type.mjs
@@ -42,7 +42,7 @@ try {
     [ '/es-modules/package-type-commonjs/index.js', 'commonjs' ],
     [ '/es-modules/package-without-type/index.js', 'commonjs' ],
     [ '/es-modules/package-without-pjson/index.js', 'commonjs' ],
-  ].map(([ testScript, expectedType ]) => {
+  ].forEach(([ testScript, expectedType ]) => {
     const resolvedPath = path.resolve(fixtures.path(testScript));
     const resolveResult = resolve(url.pathToFileURL(resolvedPath));
     assert.strictEqual(resolveResult.format, expectedType);
@@ -186,7 +186,7 @@ try {
     [ 'hmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '#Key'],
     [ 'qhmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '?k=v#h'],
     [ 'ts-mod-com', 'index.js', 'imp.ts', 'module', 'commonjs', undefined],
-  ].map((testVariant) => {
+  ].forEach((testVariant) => {
     const [
       moduleName,
       mainRequireScript,

From 49a408834d2fa78c5f22ad3125602b1ef389f0dd Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 11 Jan 2023 16:25:15 +0100
Subject: [PATCH 043/126] Add `HookProxy.prototype.makeAsyncRequest`

---
 lib/internal/modules/esm/hooks.js  | 48 ++++++++++++++++++++++++++----
 lib/internal/modules/esm/loader.js |  4 +--
 lib/internal/modules/esm/worker.js |  8 ++---
 3 files changed, 49 insertions(+), 11 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 75cf2ca9bceca4..06fbac101a425a 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -18,6 +18,7 @@ const {
   Atomics: {
     store: AtomicsStore,
     wait: AtomicsWait,
+    waitAsync: AtomicsWaitAsync,
   },
   SharedArrayBuffer,
 } = globalThis;
@@ -442,6 +443,7 @@ class Hooks {
 }
 ObjectSetPrototypeOf(Hooks.prototype, null);
 
+let MessageChannel;
 class HooksProxy {
   /**
    * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
@@ -459,7 +461,7 @@ class HooksProxy {
 
   constructor() {
     const { InternalWorker } = require('internal/worker');
-    const { MessageChannel } = require('internal/worker/io');
+    MessageChannel ??= require('internal/worker/io').MessageChannel;
 
     const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
@@ -480,7 +482,7 @@ class HooksProxy {
     worker.unref(); // ! Allows the process to eventually exit.
   }
 
-  makeRequest(method, ...args) {
+  #waitForWorker() {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
@@ -499,14 +501,50 @@ class HooksProxy {
 
       this.#isReady = true;
     }
+  }
+
+  async makeAsyncRequest(method, ...args) {
+    this.#waitForWorker();
+
+    MessageChannel ??= require('internal/worker/io').MessageChannel;
+    const asyncCommChannel = new MessageChannel();
+
+    // Pass work to the worker.
+    this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
+
+    let response;
+    while (response == null) {
+      AtomicsStore(this.#lock, 0, 0); // Reset lock.
+      await AtomicsWaitAsync(this.#lock, 0, 0);
+
+      response = receiveMessageOnPort(asyncCommChannel.port1);
+    }
+    response = response.message;
+    asyncCommChannel.port1.close();
+
+    if (response.type === 'error') {
+      throw response.value;
+    } else if (!response.value) {
+      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
+    } else {
+      return response.value;
+    }
+  }
+
+  makeSyncRequest(method, ...args) {
+    this.#waitForWorker();
 
     // Pass work to the worker.
     this.#syncCommPort.postMessage({ method, args });
 
-    AtomicsStore(this.#lock, 0, 0); // Reset lock.
-    AtomicsWait(this.#lock, 0, 0); // Sleep until worker responds.
+    let response;
+    while (response == null) {
+      AtomicsStore(this.#lock, 0, 0); // Reset lock.
+      AtomicsWait(this.#lock, 0, 0); // Sleep until worker responds.
 
-    const response = receiveMessageOnPort(this.#syncCommPort).message;
+      response = receiveMessageOnPort(this.#syncCommPort);
+    }
+    response = response.message;
     if (response.type === 'error') {
       throw response.value;
     } else if (!response.value) {
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 13fc5f517f3c69..92bc4d02948112 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -350,7 +350,7 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
    * @returns {{ format: string, url: URL['href'] }}
    */
   resolve(originalSpecifier, parentURL, importAssertions) {
-    return hooksProxy.makeRequest('resolve', originalSpecifier, parentURL, importAssertions);
+    return hooksProxy.makeSyncRequest('resolve', originalSpecifier, parentURL, importAssertions);
   }
 
   /**
@@ -361,7 +361,7 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context) {
-    const result = await hooksProxy.makeRequest('load', url, context);
+    const result = await hooksProxy.makeAsyncRequest('load', url, context);
     this.validateLoadResult(url, result?.format);
     return result;
   }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 00f03702d077c4..3e3c1bb7d5e144 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -55,7 +55,7 @@ function releaseLock() {
     initializationError = exception;
   }
 
-  syncCommPort.on('message', handleSyncMessage);
+  syncCommPort.on('message', handleMessage);
 
   if (hasInitializationError) {
     syncCommPort.postMessage({
@@ -71,7 +71,7 @@ function releaseLock() {
 
   releaseLock(); // Send 'ready' signal to main.
 
-  async function handleSyncMessage({ method, args }) {
+  async function handleMessage({ method, args, port }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
     let response;
@@ -92,13 +92,13 @@ function releaseLock() {
 
     // Send the method response (or exception) to the main thread.
     try {
-      syncCommPort.postMessage({
+      (port ?? syncCommPort).postMessage({
         type: hasError ? 'error' : 'success',
         value: response,
       });
     } catch (exception) {
       // Or send the exception thrown when trying to send the response.
-      syncCommPort.postMessage({
+      (port ?? syncCommPort).postMessage({
         type: 'error',
         value: exception,
       });

From d40834d48fad8e943cb668e105188a92c9f171f6 Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 11 Jan 2023 21:46:35 -0800
Subject: [PATCH 044/126] Wrap messages passed from worker to main thread so
 that we can carry along and restore the extra properties of Error objects

---
 lib/internal/modules/esm/hooks.js  | 41 ++++++++++++----------------
 lib/internal/modules/esm/worker.js | 44 ++++++++++++++++--------------
 2 files changed, 41 insertions(+), 44 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 06fbac101a425a..50428047d1bf6b 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -487,16 +487,9 @@ class HooksProxy {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
         AtomicsWait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
-        const response = receiveMessageOnPort(this.#syncCommPort).message;
-        if (response.type === 'error') {
-          // An exception was thrown during initialization of the worker thread; re-throw to crash the process.
-          const { triggerUncaughtException } = internalBinding('errors');
-          triggerUncaughtException(response.value);
-          throw response.value;
-        } else {
-          const { preloadScripts } = response.value;
-          this.#executePreloadScripts(preloadScripts);
-        }
+        const response = receiveMessageOnPort(this.#syncCommPort);
+        const { preloadScripts } = this.#unwrapMessage(response);
+        this.#executePreloadScripts(preloadScripts);
       }
 
       this.#isReady = true;
@@ -519,16 +512,9 @@ class HooksProxy {
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
-    response = response.message;
+    const body = this.#unwrapMessage(response)
     asyncCommChannel.port1.close();
-
-    if (response.type === 'error') {
-      throw response.value;
-    } else if (!response.value) {
-      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
-    } else {
-      return response.value;
-    }
+    return body;
   }
 
   makeSyncRequest(method, ...args) {
@@ -544,13 +530,20 @@ class HooksProxy {
 
       response = receiveMessageOnPort(this.#syncCommPort);
     }
-    response = response.message;
-    if (response.type === 'error') {
-      throw response.value;
-    } else if (!response.value) {
+    return(this.#unwrapMessage(response))
+  }
+
+  #unwrapMessage(response) {
+    if (!response || !response.message || !response.message.body) {
       throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
+    } else if (response.message.status === 'error') {
+      const exception = response.message.body.error;
+      exception.stack = response.message.body.stack;
+      exception.code = response.message.body.code;
+      exception.cause = response.message.body.cause;
+      throw exception;
     } else {
-      return response.value;
+      return response.message.body;
     }
   }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 3e3c1bb7d5e144..4e6a869bf1dce5 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -58,15 +58,9 @@ function releaseLock() {
   syncCommPort.on('message', handleMessage);
 
   if (hasInitializationError) {
-    syncCommPort.postMessage({
-      type: 'error',
-      value: initializationError,
-    });
+    syncCommPort.postMessage(wrapMessage('error', initializationError));
   } else {
-    syncCommPort.postMessage({
-      type: 'success',
-      value: { preloadScripts },
-    }, preloadScripts.map(({ port }) => port));
+    syncCommPort.postMessage(wrapMessage('success', { preloadScripts }), preloadScripts.map(({ port }) => port));
   }
 
   releaseLock(); // Send 'ready' signal to main.
@@ -92,29 +86,39 @@ function releaseLock() {
 
     // Send the method response (or exception) to the main thread.
     try {
-      (port ?? syncCommPort).postMessage({
-        type: hasError ? 'error' : 'success',
-        value: response,
-      });
+      (port ?? syncCommPort).postMessage(wrapMessage(hasError ? 'error' : 'success', response));
     } catch (exception) {
       // Or send the exception thrown when trying to send the response.
-      (port ?? syncCommPort).postMessage({
-        type: 'error',
-        value: exception,
-      });
+      (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
     releaseLock();
   }
 })().catch((exception) => {
   // Send the exception up to the main thread so it can throw it and crash the process
   process._rawDebug('exception in worker:', exception); // TODO: Remove this once exception handling is reliable
-  syncCommPort.postMessage({
-    type: 'error',
-    value: exception,
-  });
+  syncCommPort.postMessage(wrapMessage('error', exception));
   releaseLock();
 });
 
+function wrapMessage(status, body) {
+  if (status === 'success') {
+    return { status, body }
+  } else {
+    // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on) through `postMessage` will strip
+    // it of many of its properties such as `code`. `v8.serialize` does too. Therefore, we save these properties alongside it.
+    // TODO(@GeoffreyBooth): Use https://github.com/sindresorhus/serialize-error for this?
+    return {
+      status,
+      body: {
+        error: body,
+        stack: body.stack,
+        code: body.code,
+        cause: body.cause,
+      }
+    }
+  }
+}
+
 process.on('uncaughtException', (err) => {
   process._rawDebug('process uncaughtException:', err);
   const { triggerUncaughtException } = internalBinding('errors');

From 47bd0bf5a5b607b33975d4cd3a58db96cacb4d4e Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 11 Jan 2023 22:01:26 -0800
Subject: [PATCH 045/126] Emit experimental warning only once

---
 lib/internal/modules/esm/loader.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 92bc4d02948112..97803057db78dc 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -368,6 +368,7 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
 }
 
 
+let emittedExperimentalWarning = false;
 /**
  * A loader instance is used as the main entry point for loading ES modules. Currently, this is a singleton; there is
  * only one used for loading the main module and everything in its dependency graph, though separate instances of this
@@ -379,7 +380,10 @@ function ModuleLoader(useCustomLoadersIfPresent = true) {
   if (useCustomLoadersIfPresent) {
     const userLoaderPaths = getOptionValue('--experimental-loader');
     if (userLoaderPaths.length > 0) {
-      emitExperimentalWarning('Custom ESM Loaders');
+      if (!emittedExperimentalWarning) {
+        emitExperimentalWarning('Custom ESM Loaders');
+        emittedExperimentalWarning = true;
+      }
       return new CustomizedModuleLoader(userLoaderPaths);
     }
   }

From 17ff52432dde7ac92663eb5ac34a9ee22b82c7fa Mon Sep 17 00:00:00 2001
From: Geoffrey Booth <webadmin@geoffreybooth.com>
Date: Wed, 11 Jan 2023 22:28:49 -0800
Subject: [PATCH 046/126] Don't re-throw uncaught exceptions and then re-catch
 them ad infinitum

---
 lib/internal/modules/esm/worker.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 4e6a869bf1dce5..ab76b6ecae8b9c 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -119,9 +119,8 @@ function wrapMessage(status, body) {
   }
 }
 
-process.on('uncaughtException', (err) => {
-  process._rawDebug('process uncaughtException:', err);
-  const { triggerUncaughtException } = internalBinding('errors');
+process.on('uncaughtException', (exception) => {
+  process._rawDebug('process uncaughtException:', exception);
+  syncCommPort.postMessage(wrapMessage('error', exception));
   releaseLock();
-  triggerUncaughtException(err);
 });

From 206522281410ec89986d3fe262a37561e467775a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 11:19:26 +0100
Subject: [PATCH 047/126] fix linter errors

---
 lib/internal/modules/esm/hooks.js  | 10 +++++-----
 lib/internal/modules/esm/utils.js  |  2 +-
 lib/internal/modules/esm/worker.js | 29 +++++++++++++++--------------
 3 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 50428047d1bf6b..cd5cc1e1b214cd 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -48,6 +48,7 @@ const {
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+const assert = require('internal/assert');
 
 
 /**
@@ -512,7 +513,7 @@ class HooksProxy {
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
-    const body = this.#unwrapMessage(response)
+    const body = this.#unwrapMessage(response);
     asyncCommChannel.port1.close();
     return body;
   }
@@ -530,13 +531,12 @@ class HooksProxy {
 
       response = receiveMessageOnPort(this.#syncCommPort);
     }
-    return(this.#unwrapMessage(response))
+    return (this.#unwrapMessage(response));
   }
 
   #unwrapMessage(response) {
-    if (!response || !response.message || !response.message.body) {
-      throw new ERR_INVALID_RETURN_VALUE('an object', method, undefined);
-    } else if (response.message.status === 'error') {
+    assert(response?.message?.body);
+    if (response.message.status === 'error') {
       const exception = response.message.body.error;
       exception.stack = response.message.body.stack;
       exception.code = response.message.body.code;
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 8196027c18faac..bc02f9dba8ad39 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -133,7 +133,7 @@ async function initializeHooks() {
 
   const preloadScripts = hooks.initializeGlobalPreload();
 
-  return { hooks, preloadScripts };
+  return { __proto__: null, hooks, preloadScripts };
 }
 
 module.exports = {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index ab76b6ecae8b9c..4cc291da8148b7 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -102,21 +102,22 @@ function releaseLock() {
 
 function wrapMessage(status, body) {
   if (status === 'success') {
-    return { status, body }
-  } else {
-    // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on) through `postMessage` will strip
-    // it of many of its properties such as `code`. `v8.serialize` does too. Therefore, we save these properties alongside it.
-    // TODO(@GeoffreyBooth): Use https://github.com/sindresorhus/serialize-error for this?
-    return {
-      status,
-      body: {
-        error: body,
-        stack: body.stack,
-        code: body.code,
-        cause: body.cause,
-      }
-    }
+    return { status, body };
   }
+  // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on)
+  // through `postMessage` will strip it of many of its properties such as `code`. `v8.serialize`
+  // does too. Therefore, we save these properties alongside it.
+  // TODO(@GeoffreyBooth): Use https://github.com/sindresorhus/serialize-error for this?
+  return {
+    status,
+    body: {
+      error: body,
+      stack: body?.stack,
+      code: body?.code,
+      cause: body?.cause,
+    }
+  };
+
 }
 
 process.on('uncaughtException', (exception) => {

From b0cc21fc783ffc4e0c7cfd80d84dcab1e0405324 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 11:42:24 +0100
Subject: [PATCH 048/126] transfer `ArrayBuffer`s

---
 lib/internal/modules/esm/hooks.js  |  2 +-
 lib/internal/modules/esm/worker.js | 21 ++++++++++++++++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index cd5cc1e1b214cd..bffff7b2f95b3e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -438,7 +438,7 @@ class Hooks {
       __proto__: null,
       format,
       responseURL,
-      source: '' + source,
+      source,
     };
   }
 }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 4cc291da8148b7..47d8f05863f9d0 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,9 +1,11 @@
 'use strict';
 
 const {
+  DataViewPrototypeGetBuffer,
   Int32Array,
   ReflectApply,
   SafeWeakMap,
+  TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
       notify: AtomicsNotify,
@@ -15,6 +17,12 @@ const {
   ERR_INVALID_ARG_VALUE,
   ERR_INVALID_RETURN_VALUE,
 } = require('internal/errors').codes;
+const {
+  isArrayBuffer,
+  isArrayBufferView,
+  isDataView,
+  isTypedArray,
+} = require('util/types');
 
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
@@ -27,6 +35,12 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 const lock = new Int32Array(workerData.lock); // Required by Atomics
 const { syncCommPort } = workerData; // To receive work signals.
 
+function getArrayBuffer(bufferView) {
+  if (isTypedArray(bufferView)) return TypedArrayPrototypeGetBuffer(bufferView);
+  if (isDataView(bufferView)) return DataViewPrototypeGetBuffer(bufferView);
+  return bufferView;
+}
+
 function releaseLock() {
   AtomicsStore(lock, 0, 1); // Send response to main
   AtomicsNotify(lock, 0); // Notify main of new response
@@ -86,7 +100,12 @@ function releaseLock() {
 
     // Send the method response (or exception) to the main thread.
     try {
-      (port ?? syncCommPort).postMessage(wrapMessage(hasError ? 'error' : 'success', response));
+      (port ?? syncCommPort).postMessage(
+        wrapMessage(hasError ? 'error' : 'success', response),
+        !hasError && (isArrayBuffer(response?.source) || isArrayBufferView(response?.source)) ?
+          [getArrayBuffer(response.source)] :
+          undefined
+      );
     } catch (exception) {
       // Or send the exception thrown when trying to send the response.
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));

From 29d019ff9d279c0282c9d6d02ef8bfb7d528c32a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 12:23:20 +0100
Subject: [PATCH 049/126] improve exception serialization

---
 lib/internal/modules/esm/hooks.js  | 56 ++++++++++++++++++++++++++----
 lib/internal/modules/esm/worker.js | 46 +++++++++++++-----------
 2 files changed, 75 insertions(+), 27 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index bffff7b2f95b3e..34feadbb8f0c7d 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -1,16 +1,25 @@
 'use strict';
 
 const {
+  AggregateError,
   ArrayPrototypeJoin,
   ArrayPrototypePush,
+  Error,
+  EvalError,
   FunctionPrototypeCall,
   Int32Array,
   ObjectAssign,
+  ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  RangeError,
+  ReferenceError,
+  ReflectConstruct,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
+  SyntaxError,
+  TypeError,
   globalThis,
 } = primordials;
 
@@ -48,7 +57,6 @@ const {
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
-const assert = require('internal/assert');
 
 
 /**
@@ -535,12 +543,48 @@ class HooksProxy {
   }
 
   #unwrapMessage(response) {
-    assert(response?.message?.body);
     if (response.message.status === 'error') {
-      const exception = response.message.body.error;
-      exception.stack = response.message.body.stack;
-      exception.code = response.message.body.code;
-      exception.cause = response.message.body.cause;
+      if (!response.message.body?.isSerializedError) throw response.message.body;
+
+      let exceptionConstructor;
+      switch (response.message.body.errorType) {
+        case 'AggregateError':
+          exceptionConstructor = AggregateError;
+          break;
+        case 'EvalError':
+          exceptionConstructor = EvalError;
+          break;
+        case 'RangeError':
+          exceptionConstructor = RangeError;
+          break;
+        case 'ReferenceError':
+          exceptionConstructor = ReferenceError;
+          break;
+        case 'SyntaxError':
+          exceptionConstructor = SyntaxError;
+          break;
+        case 'TypeError':
+          exceptionConstructor = TypeError;
+          break;
+        default:
+          exceptionConstructor = Error;
+      }
+      const exception = ReflectConstruct(exceptionConstructor, response.message.body.errorConstructorArguments);
+      if (exception != null) {
+        const descriptors = { __proto__: null };
+        const { ownProperties, values, enumerable } = response.message.body;
+        for (let i = 0; i < ownProperties.length; i++) {
+          const key = ownProperties[i];
+          descriptors[key] = {
+            __proto__: null,
+            configurable: true,
+            enumerable: enumerable[i],
+            writable: true,
+            value: values[i],
+          };
+        }
+        ObjectDefineProperties(exception, descriptors);
+      }
       throw exception;
     } else {
       return response.message.body;
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 47d8f05863f9d0..7a1c3f69adb88d 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,10 +1,14 @@
 'use strict';
 
 const {
+  ArrayPrototypeMap,
   DataViewPrototypeGetBuffer,
   Int32Array,
+  ObjectGetOwnPropertyNames,
   ReflectApply,
+  ReflectGetOwnPropertyDescriptor,
   SafeWeakMap,
+  String,
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
@@ -13,10 +17,7 @@ const {
     },
   },
 } = primordials;
-const {
-  ERR_INVALID_ARG_VALUE,
-  ERR_INVALID_RETURN_VALUE,
-} = require('internal/errors').codes;
+const assert = require('internal/assert');
 const {
   isArrayBuffer,
   isArrayBufferView,
@@ -82,20 +83,13 @@ function releaseLock() {
   async function handleMessage({ method, args, port }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
+    assert(typeof hooks[method] === 'function');
     let response;
-    if (!hooks[method]) {
+    try {
+      response = await ReflectApply(hooks[method], hooks, args);
+    } catch (exception) {
       hasError = true;
-      response = new ERR_INVALID_ARG_VALUE('method', method);
-    } else {
-      try {
-        response = await ReflectApply(hooks[method], hooks, args);
-        if (!response) {
-          throw new ERR_INVALID_RETURN_VALUE('object', method, response);
-        }
-      } catch (exception) {
-        hasError = true;
-        response = exception;
-      }
+      response = exception;
     }
 
     // Send the method response (or exception) to the main thread.
@@ -120,20 +114,30 @@ function releaseLock() {
 });
 
 function wrapMessage(status, body) {
-  if (status === 'success') {
+  if (status === 'success' || body === null || typeof body !== 'object') {
     return { status, body };
   }
   // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on)
   // through `postMessage` will strip it of many of its properties such as `code`. `v8.serialize`
   // does too. Therefore, we save these properties alongside it.
   // TODO(@GeoffreyBooth): Use https://github.com/sindresorhus/serialize-error for this?
+  const ownProperties = ObjectGetOwnPropertyNames(body);
   return {
     status,
     body: {
-      error: body,
-      stack: body?.stack,
-      code: body?.code,
-      cause: body?.cause,
+      isSerializedError: true,
+      errorType: body.constructor?.name,
+      errorConstructorArguments: [body.message],
+      ownProperties,
+      values: ArrayPrototypeMap(ownProperties, (key) => {
+        try {
+          return String(body[key]);
+        } catch {
+          return undefined;
+        }
+      }),
+      enumerable: ArrayPrototypeMap(
+        ownProperties, (key) => ReflectGetOwnPropertyDescriptor(body, key).enumerable),
     }
   };
 

From 8706cbd6ada10af7fd77d97529a8ae87fcc3b75c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 13:15:15 +0100
Subject: [PATCH 050/126] chaining loader hooks

---
 lib/internal/modules/esm/hooks.js             |  4 +-
 lib/internal/modules/esm/loader.js            | 11 +++--
 lib/internal/modules/esm/utils.js             | 47 ++++++++++++++++---
 .../loader-load-passthru.mjs                  |  2 +-
 ...loader-load-receiving-modified-context.mjs |  2 +-
 .../es-module-loaders/loader-log-args.mjs     |  2 +-
 .../es-module-loaders/loader-resolve-42.mjs   |  2 +-
 .../es-module-loaders/loader-resolve-foo.mjs  |  2 +-
 .../loader-resolve-passthru.mjs               |  2 +-
 ...der-resolve-receiving-modified-context.mjs |  2 +-
 .../loader-resolve-strip-xxx.mjs              |  2 +-
 .../loader-resolve-strip-yyy.mjs              |  2 +-
 12 files changed, 58 insertions(+), 22 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 34feadbb8f0c7d..261407a7010a62 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -107,7 +107,7 @@ class Hooks {
   #validatedUrls = new SafeSet();
 
   constructor(userLoaders) {
-    this.#addCustomLoaders(userLoaders);
+    this.addCustomLoaders(userLoaders);
   }
 
   /**
@@ -116,7 +116,7 @@ class Hooks {
    * @param {import('./loader.js).KeyedExports} customLoaders Exports from user-defined loaders
    *  (as returned by `ModuleLoader.import()`).
    */
-  #addCustomLoaders(customLoaders = []) {
+  addCustomLoaders(customLoaders = []) {
     for (let i = 0; i < customLoaders.length; i++) {
       const {
         exports,
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 97803057db78dc..00b2fd9b7ef455 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -142,7 +142,7 @@ class DefaultModuleLoader {
    *                                     point.
    * @param {Record<string, string>} importAssertions Validations for the
    *                                                  module import.
-   * @returns {Promise<ModuleJob>} The (possibly pending) module job
+   * @returns {ModuleJob} The (possibly pending) module job
    */
   getModuleJob(specifier, parentURL, importAssertions) {
     const resolveResult = this.resolve(specifier, parentURL, importAssertions);
@@ -157,7 +157,7 @@ class DefaultModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
+      job = this.createModuleJob(url, resolvedImportAssertions, parentURL, format);
     }
 
     return job;
@@ -174,7 +174,7 @@ class DefaultModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  #createModuleJob(url, importAssertions, parentURL, format) {
+  createModuleJob(url, importAssertions, parentURL, format) {
     const moduleProvider = async (url, isMain) => {
       const {
         format: finalFormat,
@@ -392,4 +392,7 @@ function ModuleLoader(useCustomLoadersIfPresent = true) {
 }
 ObjectSetPrototypeOf(ModuleLoader.prototype, null);
 
-exports.ModuleLoader = ModuleLoader;
+module.exports = {
+  DefaultModuleLoader,
+  ModuleLoader,
+};
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index bc02f9dba8ad39..5e142b5b5e60b2 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -2,7 +2,7 @@
 
 const {
   ArrayIsArray,
-  ArrayPrototypePushApply,
+  PromisePrototypeThen,
   SafeSet,
   SafeWeakMap,
   ObjectFreeze,
@@ -109,9 +109,45 @@ async function initializeHooks() {
     cwd = '/';
   }
 
-  const { ModuleLoader } = require('internal/modules/esm/loader');
+
+  const { Hooks } = require('internal/modules/esm/hooks');
+  const hooks = new Hooks();
+
+  const { DefaultModuleLoader } = require('internal/modules/esm/loader');
+  class ModuleLoader extends DefaultModuleLoader {
+    async asyncGetModuleJob(specifier, parentURL, importAssertions) {
+      const resolveResult = await hooks.resolve(specifier, parentURL, importAssertions);
+      const { url, format } = resolveResult;
+      const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
+
+      let job = this.moduleMap.get(url, resolvedImportAssertions.type);
+
+      // CommonJS will set functions for lazy job evaluation.
+      if (typeof job === 'function') {
+        this.moduleMap.set(url, undefined, job = job());
+      }
+
+      if (job === undefined) {
+        job = this.createModuleJob(url, resolvedImportAssertions, parentURL, format);
+      }
+
+      return job;
+    }
+    getModuleJob(specifier, parentURL, importAssertions) {
+      const jobPromise = this.asyncGetModuleJob(specifier, parentURL, importAssertions);
+      return {
+        async run() { return (await jobPromise).run(); },
+        get modulePromise() {
+          return PromisePrototypeThen(jobPromise, (job) => job.modulePromise);
+        },
+        get linked() {
+          return PromisePrototypeThen(jobPromise, (job) => job.linked);
+        }
+      };
+    }
+    load(url, context) { return hooks.load(url, context); }
+  }
   const privateModuleLoader = new ModuleLoader(false);
-  const importedCustomLoaders = [];
 
   const parentURL = pathToFileURL(cwd).href;
 
@@ -125,12 +161,9 @@ async function initializeHooks() {
       kEmptyObject,
     );
 
-    ArrayPrototypePushApply(importedCustomLoaders, keyedExportsSublist);
+    hooks.addCustomLoaders(keyedExportsSublist);
   }
 
-  const { Hooks } = require('internal/modules/esm/hooks');
-  const hooks = new Hooks(importedCustomLoaders);
-
   const preloadScripts = hooks.initializeGlobalPreload();
 
   return { __proto__: null, hooks, preloadScripts };
diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index f3925984fddb09..c6dea0d7e012b4 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function load(url, context, next) {
   // This check is needed to make sure that we don't prevent the
diff --git a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
index 2fc16eb8b08a0f..df9d45782674ff 100644
--- a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function load(url, context, next) {
   writeSync(1, `${context.foo}\n`); // This log is deliberate
diff --git a/test/fixtures/es-module-loaders/loader-log-args.mjs b/test/fixtures/es-module-loaders/loader-log-args.mjs
index 587251326f58c7..ce03811284d7c8 100644
--- a/test/fixtures/es-module-loaders/loader-log-args.mjs
+++ b/test/fixtures/es-module-loaders/loader-log-args.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(...args) {
   writeSync(1, `resolve arg count: ${args.length}\n`);
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index 20338b307e8bff..e7ea66352d9cf8 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index 74261c160a8142..66373493d04cd5 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index 6c0096e7f10b38..4ba4dce68eb6a1 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
diff --git a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
index 4661bae9a0d3c0..a50f12b7d5a874 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   writeSync(1, `${context.foo}\n`); // This log is deliberate
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
index 81766a08105c48..fe0928eebd202d 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, nextResolve) {
   writeSync(1, `loader-a ${specifier}\n`);
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
index efa74aa6ff7511..d1263c1fed076a 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
@@ -1,4 +1,4 @@
-import { writeSync } from 'fs';
+import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, nextResolve) {
   writeSync(1, `loader-b ${specifier}\n`);

From 04ebc5cfac788a48f3ff2c36e363114328ae4bbc Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 14:13:35 +0100
Subject: [PATCH 051/126] make things more consistent

---
 lib/internal/modules/esm/utils.js | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 5e142b5b5e60b2..1889bb09b8c3e9 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -115,7 +115,7 @@ async function initializeHooks() {
 
   const { DefaultModuleLoader } = require('internal/modules/esm/loader');
   class ModuleLoader extends DefaultModuleLoader {
-    async asyncGetModuleJob(specifier, parentURL, importAssertions) {
+    async #getModuleJob(specifier, parentURL, importAssertions) {
       const resolveResult = await hooks.resolve(specifier, parentURL, importAssertions);
       const { url, format } = resolveResult;
       const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
@@ -134,9 +134,11 @@ async function initializeHooks() {
       return job;
     }
     getModuleJob(specifier, parentURL, importAssertions) {
-      const jobPromise = this.asyncGetModuleJob(specifier, parentURL, importAssertions);
+      const jobPromise = this.#getModuleJob(specifier, parentURL, importAssertions);
       return {
-        async run() { return (await jobPromise).run(); },
+        run() {
+          return PromisePrototypeThen(jobPromise, (job) => job.run());
+        },
         get modulePromise() {
           return PromisePrototypeThen(jobPromise, (job) => job.modulePromise);
         },

From 8aae17ead48f61dc30c7d99f3c54a4d0469f2de3 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 14:44:15 +0100
Subject: [PATCH 052/126] remove unnecessary parenthesis

---
 lib/internal/modules/esm/hooks.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 261407a7010a62..fd432f6959bb61 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -539,7 +539,7 @@ class HooksProxy {
 
       response = receiveMessageOnPort(this.#syncCommPort);
     }
-    return (this.#unwrapMessage(response));
+    return this.#unwrapMessage(response);
   }
 
   #unwrapMessage(response) {

From b74dcaa328f6f10a75e7680e6ea370ee2b9cd35a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 16:40:00 +0100
Subject: [PATCH 053/126] simplify error cloning

---
 lib/internal/modules/esm/hooks.js  | 63 ++++++++----------------------
 lib/internal/modules/esm/worker.js | 26 ++++++------
 2 files changed, 29 insertions(+), 60 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index fd432f6959bb61..001af3f608515e 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -1,25 +1,17 @@
 'use strict';
 
 const {
-  AggregateError,
   ArrayPrototypeJoin,
   ArrayPrototypePush,
-  Error,
-  EvalError,
   FunctionPrototypeCall,
   Int32Array,
   ObjectAssign,
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
-  RangeError,
-  ReferenceError,
-  ReflectConstruct,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
-  SyntaxError,
-  TypeError,
   globalThis,
 } = primordials;
 
@@ -544,47 +536,24 @@ class HooksProxy {
 
   #unwrapMessage(response) {
     if (response.message.status === 'error') {
-      if (!response.message.body?.isSerializedError) throw response.message.body;
-
-      let exceptionConstructor;
-      switch (response.message.body.errorType) {
-        case 'AggregateError':
-          exceptionConstructor = AggregateError;
-          break;
-        case 'EvalError':
-          exceptionConstructor = EvalError;
-          break;
-        case 'RangeError':
-          exceptionConstructor = RangeError;
-          break;
-        case 'ReferenceError':
-          exceptionConstructor = ReferenceError;
-          break;
-        case 'SyntaxError':
-          exceptionConstructor = SyntaxError;
-          break;
-        case 'TypeError':
-          exceptionConstructor = TypeError;
-          break;
-        default:
-          exceptionConstructor = Error;
+      if (typeof response.message.body !== 'object' || response.message.body === null) {
+        throw response.message.body;
       }
-      const exception = ReflectConstruct(exceptionConstructor, response.message.body.errorConstructorArguments);
-      if (exception != null) {
-        const descriptors = { __proto__: null };
-        const { ownProperties, values, enumerable } = response.message.body;
-        for (let i = 0; i < ownProperties.length; i++) {
-          const key = ownProperties[i];
-          descriptors[key] = {
-            __proto__: null,
-            configurable: true,
-            enumerable: enumerable[i],
-            writable: true,
-            value: values[i],
-          };
-        }
-        ObjectDefineProperties(exception, descriptors);
+
+      const { exception } = response.message.body;
+      const descriptors = { __proto__: null };
+      const { ownProperties, values, enumerable } = response.message.body;
+      for (let i = 0; i < ownProperties.length; i++) {
+        const key = ownProperties[i];
+        descriptors[key] = {
+          __proto__: null,
+          configurable: true,
+          enumerable: enumerable[i],
+          writable: true,
+          value: values[i],
+        };
       }
+      ObjectDefineProperties(exception, descriptors);
       throw exception;
     } else {
       return response.message.body;
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 7a1c3f69adb88d..86a481d0bb053d 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayPrototypeFilter,
   ArrayPrototypeMap,
   DataViewPrototypeGetBuffer,
   Int32Array,
@@ -8,7 +9,6 @@ const {
   ReflectApply,
   ReflectGetOwnPropertyDescriptor,
   SafeWeakMap,
-  String,
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
@@ -18,6 +18,7 @@ const {
   },
 } = primordials;
 const assert = require('internal/assert');
+const { structuredClone } = require('internal/structured_clone');
 const {
   isArrayBuffer,
   isArrayBufferView,
@@ -120,22 +121,21 @@ function wrapMessage(status, body) {
   // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on)
   // through `postMessage` will strip it of many of its properties such as `code`. `v8.serialize`
   // does too. Therefore, we save these properties alongside it.
-  // TODO(@GeoffreyBooth): Use https://github.com/sindresorhus/serialize-error for this?
-  const ownProperties = ObjectGetOwnPropertyNames(body);
+  const ownProperties = ArrayPrototypeFilter(ObjectGetOwnPropertyNames(body), (key) => {
+    try {
+      // Filter only the clonable properties.
+      structuredClone(body[key]);
+    } catch {
+      return false;
+    }
+    return true;
+  });
   return {
     status,
     body: {
-      isSerializedError: true,
-      errorType: body.constructor?.name,
-      errorConstructorArguments: [body.message],
+      exception: body,
       ownProperties,
-      values: ArrayPrototypeMap(ownProperties, (key) => {
-        try {
-          return String(body[key]);
-        } catch {
-          return undefined;
-        }
-      }),
+      values: ArrayPrototypeMap(ownProperties, (key) => body[key]),
       enumerable: ArrayPrototypeMap(
         ownProperties, (key) => ReflectGetOwnPropertyDescriptor(body, key).enumerable),
     }

From 3312b1ceec29b367b7a50dcaa0f3cd75a8e0598f Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 19:08:09 +0100
Subject: [PATCH 054/126] small optimisation: read error properties only once
 when cloning

---
 lib/internal/modules/esm/worker.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 86a481d0bb053d..4d08464ba46de1 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -3,6 +3,7 @@
 const {
   ArrayPrototypeFilter,
   ArrayPrototypeMap,
+  ArrayPrototypePush,
   DataViewPrototypeGetBuffer,
   Int32Array,
   ObjectGetOwnPropertyNames,
@@ -121,13 +122,18 @@ function wrapMessage(status, body) {
   // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on)
   // through `postMessage` will strip it of many of its properties such as `code`. `v8.serialize`
   // does too. Therefore, we save these properties alongside it.
+  const values = [];
   const ownProperties = ArrayPrototypeFilter(ObjectGetOwnPropertyNames(body), (key) => {
+    let value;
     try {
+      // Accessing in a try/catch in case it's a getter that throws.
+      value = body[key];
       // Filter only the clonable properties.
-      structuredClone(body[key]);
+      structuredClone(value);
     } catch {
       return false;
     }
+    ArrayPrototypePush(values, value);
     return true;
   });
   return {
@@ -135,7 +141,7 @@ function wrapMessage(status, body) {
     body: {
       exception: body,
       ownProperties,
-      values: ArrayPrototypeMap(ownProperties, (key) => body[key]),
+      values,
       enumerable: ArrayPrototypeMap(
         ownProperties, (key) => ReflectGetOwnPropertyDescriptor(body, key).enumerable),
     }

From 7e8be7c022f198fd62c3157f438450993dd9e6d9 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 12 Jan 2023 19:25:00 +0100
Subject: [PATCH 055/126] skip already cloned properties

---
 lib/internal/modules/esm/worker.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 4d08464ba46de1..fe01557fa384ea 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -124,6 +124,9 @@ function wrapMessage(status, body) {
   // does too. Therefore, we save these properties alongside it.
   const values = [];
   const ownProperties = ArrayPrototypeFilter(ObjectGetOwnPropertyNames(body), (key) => {
+    // Those properties are already taken care of by the structured clone algorithm:
+    if (key === 'stack' || key === 'message' || key === 'cause') return false;
+
     let value;
     try {
       // Accessing in a try/catch in case it's a getter that throws.

From 7b7e5bec3461bd755caea69ea16b5837b53c073b Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 01:26:52 +0100
Subject: [PATCH 056/126] DRY

---
 lib/internal/modules/esm/loader.js |  8 ++++++--
 lib/internal/modules/esm/utils.js  | 16 +---------------
 2 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 00b2fd9b7ef455..2c373e0f1c15c8 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -146,6 +146,10 @@ class DefaultModuleLoader {
    */
   getModuleJob(specifier, parentURL, importAssertions) {
     const resolveResult = this.resolve(specifier, parentURL, importAssertions);
+    return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
+  }
+
+  getJobFromResolveResult(resolveResult, parentURL, importAssertions) {
     const { url, format } = resolveResult;
     const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
 
@@ -157,7 +161,7 @@ class DefaultModuleLoader {
     }
 
     if (job === undefined) {
-      job = this.createModuleJob(url, resolvedImportAssertions, parentURL, format);
+      job = this.#createModuleJob(url, resolvedImportAssertions, parentURL, format);
     }
 
     return job;
@@ -174,7 +178,7 @@ class DefaultModuleLoader {
    *                          `resolve` hook
    * @returns {Promise<ModuleJob>} The (possibly pending) module job
    */
-  createModuleJob(url, importAssertions, parentURL, format) {
+  #createModuleJob(url, importAssertions, parentURL, format) {
     const moduleProvider = async (url, isMain) => {
       const {
         format: finalFormat,
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 1889bb09b8c3e9..104804c4d79419 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -117,21 +117,7 @@ async function initializeHooks() {
   class ModuleLoader extends DefaultModuleLoader {
     async #getModuleJob(specifier, parentURL, importAssertions) {
       const resolveResult = await hooks.resolve(specifier, parentURL, importAssertions);
-      const { url, format } = resolveResult;
-      const resolvedImportAssertions = resolveResult.importAssertions ?? importAssertions;
-
-      let job = this.moduleMap.get(url, resolvedImportAssertions.type);
-
-      // CommonJS will set functions for lazy job evaluation.
-      if (typeof job === 'function') {
-        this.moduleMap.set(url, undefined, job = job());
-      }
-
-      if (job === undefined) {
-        job = this.createModuleJob(url, resolvedImportAssertions, parentURL, format);
-      }
-
-      return job;
+      return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
     }
     getModuleJob(specifier, parentURL, importAssertions) {
       const jobPromise = this.#getModuleJob(specifier, parentURL, importAssertions);

From 3f4c9bf1a378720f5b06fb11f9ec0a4c6330492b Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 17:54:50 +0100
Subject: [PATCH 057/126] fix `test-esm-loader-chaining`

---
 test/fixtures/es-module-loaders/loader-load-passthru.mjs | 7 ++++---
 test/fixtures/es-module-loaders/loader-log-args.mjs      | 7 ++++---
 test/fixtures/es-module-loaders/loader-resolve-42.mjs    | 9 +++++----
 test/fixtures/es-module-loaders/loader-resolve-foo.mjs   | 7 ++++---
 .../es-module-loaders/loader-resolve-incomplete.mjs      | 7 ++++---
 .../es-module-loaders/loader-resolve-passthru.mjs        | 7 ++++---
 6 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index c6dea0d7e012b4..da1e952b4b8eb7 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -2,11 +2,12 @@ import { writeSync } from 'node:fs';
 
 export async function load(url, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders. It wouldn't be a problem
+  // resolution from follow-up loaders, or `'node:fs'` that we
+  // use instead of `console.log`. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader')) {
-    return next(url);
+  if (url.includes('loader') || url === 'node:fs') {
+    return next(url, context);
   }
 
   writeSync(1, 'load passthru\n'); // This log is deliberate
diff --git a/test/fixtures/es-module-loaders/loader-log-args.mjs b/test/fixtures/es-module-loaders/loader-log-args.mjs
index ce03811284d7c8..e8c515669f03fe 100644
--- a/test/fixtures/es-module-loaders/loader-log-args.mjs
+++ b/test/fixtures/es-module-loaders/loader-log-args.mjs
@@ -1,8 +1,9 @@
 import { writeSync } from 'node:fs';
+import { format } from 'node:util';
 
 export async function resolve(...args) {
   writeSync(1, `resolve arg count: ${args.length}\n`);
-  writeSync(1, `${JSON.stringify({
+  writeSync(1, `${format({
     specifier: args[0],
     context: args[1],
     next: args[2],
@@ -15,8 +16,8 @@ export async function resolve(...args) {
 }
 
 export async function load(...args) {
-  writeSync(1, `load arg count: ${args.length}`);
-  writeSync(1, `${JSON.stringify({
+  writeSync(1, `load arg count: ${args.length}\n`);
+  writeSync(1, `${format({
     url: args[0],
     context: args[1],
     next: args[2],
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index e7ea66352d9cf8..616d3209f31149 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -2,15 +2,16 @@ import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders. It wouldn't be a problem
+  // resolution from follow-up loaders, or `'node:fs'` that we
+  // use instead of `console.log`. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
-    return next(specifier);
+  if (specifier.includes('loader') || specifier === 'node:fs') {
+    return next(specifier, context);
   }
 
   writeSync(1, 'resolve 42\n'); // This log is deliberate
-  writeSync(1, `next<HookName>:${next.name}\n`); // This log is deliberate
+  writeSync(1, `next<HookName>: ${next.name}\n`); // This log is deliberate
 
   return next('file:///42.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index 66373493d04cd5..53856c6edc8698 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -2,11 +2,12 @@ import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders. It wouldn't be a problem
+  // resolution from follow-up loaders, or `'node:fs'` that we
+  // use instead of `console.log`. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
-    return next(specifier);
+  if (specifier.includes('loader') || specifier === 'node:fs') {
+    return next(specifier, context);
   }
 
   writeSync(1, 'resolve foo\n'); // This log is deliberate
diff --git a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
index d00b8fc50134e1..2fc4fd29f79f5d 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
@@ -1,10 +1,11 @@
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders. It wouldn't be a problem
+  // resolution from follow-up loaders, or `'node:fs'` that we
+  // use instead of `console.log`. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
-    return next(specifier);
+  if (specifier.includes('loader') || specifier === 'node:fs') {
+    return next(specifier, context);
   }
 
   return {
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index 4ba4dce68eb6a1..1ac7c86decc65c 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -2,11 +2,12 @@ import { writeSync } from 'node:fs';
 
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders. It wouldn't be a problem
+  // resolution from follow-up loaders, or `'node:fs'` that we
+  // use instead of `console.log`. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
-    return next(specifier);
+  if (specifier.includes('loader') || specifier === 'node:fs') {
+    return next(specifier, context);
   }
 
   writeSync(1, 'resolve passthru\n'); // This log is deliberate

From 140c03b3679c0f872f733449bdac5c9cd75e538f Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 18:31:58 +0100
Subject: [PATCH 058/126] update docs

---
 doc/api/esm.md | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 179aac352230ea..39876faa4bd8c0 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -9,7 +9,7 @@ added: v8.5.0
 changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/44710
-    description: Convert from asynchronous to synchronous.
+    description: User hooks are executed off thread.
   - version:
     - v18.6.0
     - v16.17.0
@@ -328,6 +328,9 @@ added:
   - v13.9.0
   - v12.16.2
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/44710
+    description: This API now returns a string synchronously instead of a Promise.
   - version:
       - v16.2.0
       - v14.18.0
@@ -352,8 +355,6 @@ synchronously.
 > **Caveat** This can result in synchronous file-system operations, which
 > can impact performance similarly to `require.resolve`.
 
-<!-- eslint-skip -->
-
 ```js
 const dependencyAsset = import.meta.resolve('component-lib/asset.css');
 ```
@@ -361,15 +362,10 @@ const dependencyAsset = import.meta.resolve('component-lib/asset.css');
 `import.meta.resolve` also accepts a second argument which is the parent module
 from which to resolve from:
 
-<!-- eslint-skip -->
-
 ```js
 import.meta.resolve('./dep', import.meta.url);
 ```
 
-This function is synchronous because the ES module resolver in Node.js is
-synchronous.
-
 ## Interoperability with CommonJS
 
 ### `import` statements
@@ -741,9 +737,6 @@ prevent unintentional breaks in the chain.
 
 <!-- YAML
 changes:
-  - version: REPLACEME
-    pr-url: https://github.com/nodejs/node/pull/44710
-    description: Convert hook from asynchronous to synchronous.
   - version:
     - v18.6.0
     - v16.17.0
@@ -772,7 +765,7 @@ changes:
   Node.js default `resolve` hook after the last user-supplied `resolve` hook
   * `specifier` {string}
   * `context` {Object}
-* Returns: {Object}
+* Returns: {Object|Promise}
   * `format` {string|null|undefined} A hint to the load hook (it might be
     ignored)
     `'builtin' | 'commonjs' | 'json' | 'module' | 'wasm'`
@@ -782,8 +775,8 @@ changes:
     terminate the chain of `resolve` hooks. **Default:** `false`
   * `url` {string} The absolute URL to which this input resolves
 
-> **Caveat** A resolve hook can contain synchronous file-system operations
-> (as `defaultResolveHook()` does), which can impact performance.
+> **Caveat** Despite support for returning promises, calls to `resolve` will
+> block the main thread which can impact performance.
 
 The `resolve` hook chain is responsible for telling Node.js where to find and
 how to cache a given `import` statement or expression. It can optionally return

From 020b9d7ab9ad4287a6abb6d1d97a268b4698ea85 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 18:51:55 +0100
Subject: [PATCH 059/126] fix `waitAsync` usage

---
 lib/internal/modules/esm/hooks.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 001af3f608515e..31be97bcbfeca6 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -509,7 +509,9 @@ class HooksProxy {
     let response;
     while (response == null) {
       AtomicsStore(this.#lock, 0, 0); // Reset lock.
-      await AtomicsWaitAsync(this.#lock, 0, 0);
+      this.worker.ref();
+      await AtomicsWaitAsync(this.#lock, 0, 0).value;
+      this.worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }

From 68992032998cdc65fdc1ff2871973cd07d5e588a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 19:18:54 +0100
Subject: [PATCH 060/126] simplify `ArrayBuffer` transfer

---
 lib/internal/modules/esm/worker.js | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index fe01557fa384ea..1265693388c899 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -22,7 +22,6 @@ const assert = require('internal/assert');
 const { structuredClone } = require('internal/structured_clone');
 const {
   isArrayBuffer,
-  isArrayBufferView,
   isDataView,
   isTypedArray,
 } = require('util/types');
@@ -38,10 +37,11 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 const lock = new Int32Array(workerData.lock); // Required by Atomics
 const { syncCommPort } = workerData; // To receive work signals.
 
-function getArrayBuffer(bufferView) {
-  if (isTypedArray(bufferView)) return TypedArrayPrototypeGetBuffer(bufferView);
-  if (isDataView(bufferView)) return DataViewPrototypeGetBuffer(bufferView);
-  return bufferView;
+function transferArrayBuffer(hasError, source) {
+  if (hasError || source == null) return;
+  if (isArrayBuffer(source)) return [source];
+  if (isTypedArray(source)) return [TypedArrayPrototypeGetBuffer(source)];
+  if (isDataView(source)) return [DataViewPrototypeGetBuffer(source)];
 }
 
 function releaseLock() {
@@ -98,9 +98,7 @@ function releaseLock() {
     try {
       (port ?? syncCommPort).postMessage(
         wrapMessage(hasError ? 'error' : 'success', response),
-        !hasError && (isArrayBuffer(response?.source) || isArrayBufferView(response?.source)) ?
-          [getArrayBuffer(response.source)] :
-          undefined
+        transferArrayBuffer(hasError, response?.source),
       );
     } catch (exception) {
       // Or send the exception thrown when trying to send the response.

From 9d392efc55aaa47189e6d19384ce49144acb5e03 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 20:46:53 +0100
Subject: [PATCH 061/126] do not die waiting on worker to respond,

---
 lib/internal/modules/esm/hooks.js  | 11 ++++++++++-
 lib/internal/modules/esm/worker.js | 18 ++++++++----------
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 31be97bcbfeca6..8050ed5346881f 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -9,6 +9,7 @@ const {
   ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  PromisePrototypeThen,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
@@ -49,6 +50,9 @@ const {
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+const {
+  onGlobalUncaughtException,
+} = require('internal/process/execution');
 
 
 /**
@@ -464,7 +468,7 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
+    const lock = new SharedArrayBuffer(8); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
@@ -481,6 +485,11 @@ class HooksProxy {
       transferList: [syncCommChannel.port2],
     });
     worker.unref(); // ! Allows the process to eventually exit.
+
+    PromisePrototypeThen(AtomicsWaitAsync(this.#lock, 1, 0).value, () => {
+      const { message: { exception, origin } } = receiveMessageOnPort(this.#syncCommPort);
+      onGlobalUncaughtException(exception, origin === 'unhandledRejection');
+    });
   }
 
   #waitForWorker() {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 1265693388c899..4eb5619560bf78 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -44,9 +44,9 @@ function transferArrayBuffer(hasError, source) {
   if (isDataView(source)) return [DataViewPrototypeGetBuffer(source)];
 }
 
-function releaseLock() {
-  AtomicsStore(lock, 0, 1); // Send response to main
-  AtomicsNotify(lock, 0); // Notify main of new response
+function releaseLock(index = 0) {
+  AtomicsStore(lock, index, 1); // Send response to main
+  AtomicsNotify(lock, index); // Notify main of new response
 }
 
 /**
@@ -108,9 +108,8 @@ function releaseLock() {
   }
 })().catch((exception) => {
   // Send the exception up to the main thread so it can throw it and crash the process
-  process._rawDebug('exception in worker:', exception); // TODO: Remove this once exception handling is reliable
-  syncCommPort.postMessage(wrapMessage('error', exception));
-  releaseLock();
+  syncCommPort.postMessage({ exception, origin: 'unhandledRejection' });
+  releaseLock(1);
 });
 
 function wrapMessage(status, body) {
@@ -150,8 +149,7 @@ function wrapMessage(status, body) {
 
 }
 
-process.on('uncaughtException', (exception) => {
-  process._rawDebug('process uncaughtException:', exception);
-  syncCommPort.postMessage(wrapMessage('error', exception));
-  releaseLock();
+process.on('uncaughtException', (exception, origin) => {
+  syncCommPort.postMessage({ exception, origin });
+  releaseLock(1);
 });

From 1c7dd716f636af1025561e6246e4564a6d893117 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 20:48:16 +0100
Subject: [PATCH 062/126] `import()` should not block the main thread, even for
 the resolve step

---
 doc/api/esm.md                     |  4 ++--
 lib/internal/modules/esm/loader.js | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 39876faa4bd8c0..22ee47b11fb6df 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -775,8 +775,8 @@ changes:
     terminate the chain of `resolve` hooks. **Default:** `false`
   * `url` {string} The absolute URL to which this input resolves
 
-> **Caveat** Despite support for returning promises, calls to `resolve` will
-> block the main thread which can impact performance.
+> **Caveat** Despite support for returning promises and async function, calls to
+> `resolve` may block the main thread which can impact performance.
 
 The `resolve` hook chain is responsible for telling Node.js where to find and
 how to cache a given `import` statement or expression. It can optionally return
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 2c373e0f1c15c8..912f81e1da5fa1 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -8,6 +8,7 @@ const {
   ArrayIsArray,
   FunctionPrototypeCall,
   ObjectSetPrototypeOf,
+  PromisePrototypeThen,
   SafePromiseAllReturnArrayLike,
   SafeWeakMap,
 } = primordials;
@@ -357,6 +358,25 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
     return hooksProxy.makeSyncRequest('resolve', originalSpecifier, parentURL, importAssertions);
   }
 
+  async #getModuleJob(specifier, parentURL, importAssertions) {
+    const resolveResult = await hooksProxy.makeAsyncRequest('resolve', specifier, parentURL, importAssertions);
+    return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
+  }
+  getModuleJob(specifier, parentURL, importAssertions) {
+    const jobPromise = this.#getModuleJob(specifier, parentURL, importAssertions);
+    return {
+      run() {
+        return PromisePrototypeThen(jobPromise, (job) => job.run());
+      },
+      get modulePromise() {
+        return PromisePrototypeThen(jobPromise, (job) => job.modulePromise);
+      },
+      get linked() {
+        return PromisePrototypeThen(jobPromise, (job) => job.linked);
+      }
+    };
+  }
+
   /**
    * Provide source that is understood by one of Node's translators.
    *

From acfa8d9102b36e4f5eb7991de07f0fc72014ee75 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 20:49:52 +0100
Subject: [PATCH 063/126] rework docs

---
 doc/api/esm.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 22ee47b11fb6df..4ab0a4c392c49d 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -9,7 +9,7 @@ added: v8.5.0
 changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/44710
-    description: User hooks are executed off thread.
+    description: User hooks are executed off the main thread.
   - version:
     - v18.6.0
     - v16.17.0

From 182130190506d358d8a6c69fd59a14ac862375d2 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 13 Jan 2023 21:37:50 +0100
Subject: [PATCH 064/126] do not keep the worker alive when awaiting hooks to
 resolve

---
 lib/internal/modules/esm/hooks.js  |  6 +++--
 lib/internal/modules/esm/worker.js | 38 ++++++++++++++++++++++++++----
 2 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 8050ed5346881f..b66140adb4dbbf 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -471,6 +471,7 @@ class HooksProxy {
     const lock = new SharedArrayBuffer(8); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
+    const errorCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
 
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
@@ -481,13 +482,14 @@ class HooksProxy {
       workerData: {
         lock,
         syncCommPort: syncCommChannel.port2,
+        errorCommPort: errorCommChannel.port2,
       },
-      transferList: [syncCommChannel.port2],
+      transferList: [syncCommChannel.port2, errorCommChannel.port2],
     });
     worker.unref(); // ! Allows the process to eventually exit.
 
     PromisePrototypeThen(AtomicsWaitAsync(this.#lock, 1, 0).value, () => {
-      const { message: { exception, origin } } = receiveMessageOnPort(this.#syncCommPort);
+      const { message: { exception, origin } } = receiveMessageOnPort(errorCommChannel.port1);
       onGlobalUncaughtException(exception, origin === 'unhandledRejection');
     });
   }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 4eb5619560bf78..2817b444303c10 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -20,6 +20,7 @@ const {
 } = primordials;
 const assert = require('internal/assert');
 const { structuredClone } = require('internal/structured_clone');
+const { clearImmediate, setImmediate } = require('timers');
 const {
   isArrayBuffer,
   isDataView,
@@ -29,13 +30,13 @@ const {
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
-const { isMainThread, workerData } = require('worker_threads');
+const { isMainThread, workerData, receiveMessageOnPort } = require('worker_threads');
 if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
 
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(workerData.lock); // Required by Atomics
-const { syncCommPort } = workerData; // To receive work signals.
+const { syncCommPort, errorCommPort } = workerData; // To receive work signals.
 
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
@@ -82,13 +83,32 @@ function releaseLock(index = 0) {
 
   releaseLock(); // Send 'ready' signal to main.
 
+  let immediate;
+  let immediateCount = 0;
+  function checkForMessages() {
+    const response = receiveMessageOnPort(syncCommPort);
+
+    if (response !== undefined) {
+      handleMessage(response.message);
+    }
+    immediate = setImmediate(checkForMessages).unref();
+  }
+
   async function handleMessage({ method, args, port }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
     assert(typeof hooks[method] === 'function');
     let response;
     try {
+      if (immediateCount++ === 0) {
+        immediate = setImmediate(checkForMessages).unref();
+        syncCommPort.off('message', handleMessage);
+      }
       response = await ReflectApply(hooks[method], hooks, args);
+      if (--immediateCount === 0) {
+        clearImmediate(immediate);
+        syncCommPort.on('message', handleMessage);
+      }
     } catch (exception) {
       hasError = true;
       response = exception;
@@ -108,7 +128,12 @@ function releaseLock(index = 0) {
   }
 })().catch((exception) => {
   // Send the exception up to the main thread so it can throw it and crash the process
-  syncCommPort.postMessage({ exception, origin: 'unhandledRejection' });
+  try {
+    errorCommPort.postMessage({ exception, origin: 'unhandledRejection' });
+  } catch {
+    // If the exception is not serializable, still inform the main thread.
+    errorCommPort.postMessage({ origin: 'unhandledRejection' });
+  }
   releaseLock(1);
 });
 
@@ -150,6 +175,11 @@ function wrapMessage(status, body) {
 }
 
 process.on('uncaughtException', (exception, origin) => {
-  syncCommPort.postMessage({ exception, origin });
+  try {
+    errorCommPort.postMessage({ exception, origin });
+  } catch {
+    // If the exception is not serializable, still inform the main thread.
+    errorCommPort.postMessage({ origin });
+  }
   releaseLock(1);
 });

From b1dcccc64952ff9225056489afcc5aa21b85ba0c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 10:59:48 +0100
Subject: [PATCH 065/126] keep the worker thread alive longer

---
 lib/internal/modules/esm/hooks.js  | 20 +++++++++++++++++--
 lib/internal/modules/esm/worker.js | 32 +++++++++++++++++++-----------
 2 files changed, 38 insertions(+), 14 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index b66140adb4dbbf..1594023ae14b31 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -53,6 +53,9 @@ const {
 const {
   onGlobalUncaughtException,
 } = require('internal/process/execution');
+let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
+  debug = fn;
+});
 
 
 /**
@@ -462,6 +465,8 @@ class HooksProxy {
    */
   #syncCommPort;
 
+  #pendingAsyncMessages = 0;
+
   #isReady = false;
 
   constructor() {
@@ -489,6 +494,7 @@ class HooksProxy {
     worker.unref(); // ! Allows the process to eventually exit.
 
     PromisePrototypeThen(AtomicsWaitAsync(this.#lock, 1, 0).value, () => {
+      debug('uncaughtExceptionFromWorker');
       const { message: { exception, origin } } = receiveMessageOnPort(errorCommChannel.port1);
       onGlobalUncaughtException(exception, origin === 'unhandledRejection');
     });
@@ -498,6 +504,7 @@ class HooksProxy {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
+        debug('wait for signal from worker');
         AtomicsWait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
         const response = receiveMessageOnPort(this.#syncCommPort);
         const { preloadScripts } = this.#unwrapMessage(response);
@@ -515,17 +522,23 @@ class HooksProxy {
     const asyncCommChannel = new MessageChannel();
 
     // Pass work to the worker.
+    debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
 
+    if (this.#pendingAsyncMessages++ === 0) this.worker.ref();
+
     let response;
+    debug('start waiting for async response from worker', { method, args });
     while (response == null) {
       AtomicsStore(this.#lock, 0, 0); // Reset lock.
-      this.worker.ref();
       await AtomicsWaitAsync(this.#lock, 0, 0).value;
-      this.worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
+    debug('got async response from worker', { method, args });
+
+    if (--this.#pendingAsyncMessages === 0) this.worker.unref();
+
     const body = this.#unwrapMessage(response);
     asyncCommChannel.port1.close();
     return body;
@@ -535,15 +548,18 @@ class HooksProxy {
     this.#waitForWorker();
 
     // Pass work to the worker.
+    debug('post sync message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args });
 
     let response;
+    debug('start waiting for sync response from worker', { method, args });
     while (response == null) {
       AtomicsStore(this.#lock, 0, 0); // Reset lock.
       AtomicsWait(this.#lock, 0, 0); // Sleep until worker responds.
 
       response = receiveMessageOnPort(this.#syncCommPort);
     }
+    debug('got sync response from worker', { method, args });
     return this.#unwrapMessage(response);
   }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 2817b444303c10..8f7f5026a8db8b 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -7,6 +7,7 @@ const {
   DataViewPrototypeGetBuffer,
   Int32Array,
   ObjectGetOwnPropertyNames,
+  PromisePrototypeThen,
   ReflectApply,
   ReflectGetOwnPropertyDescriptor,
   SafeWeakMap,
@@ -50,6 +51,17 @@ function releaseLock(index = 0) {
   AtomicsNotify(lock, index); // Notify main of new response
 }
 
+function errorHandler(exception) {
+  // Send the exception up to the main thread so it can throw it and crash the process
+  try {
+    errorCommPort.postMessage({ exception, origin: 'unhandledRejection' });
+  } catch {
+    // If the exception is not serializable, still inform the main thread.
+    errorCommPort.postMessage({ origin: 'unhandledRejection' });
+  }
+  releaseLock(1);
+}
+
 /**
  * ! Run everything possible within this function so errors get reported.
  */
@@ -85,13 +97,18 @@ function releaseLock(index = 0) {
 
   let immediate;
   let immediateCount = 0;
+  let tickCount = 0;
   function checkForMessages() {
+    immediate = setImmediate(checkForMessages);
+    // We need to let the event loop tick a few times to give the main thread a
+    // chance to send follow-up messages.
+    if (tickCount++ === 9) immediate.unref();
     const response = receiveMessageOnPort(syncCommPort);
 
     if (response !== undefined) {
-      handleMessage(response.message);
+      tickCount = 0;
+      PromisePrototypeThen(handleMessage(response.message), undefined, errorHandler);
     }
-    immediate = setImmediate(checkForMessages).unref();
   }
 
   async function handleMessage({ method, args, port }) {
@@ -126,16 +143,7 @@ function releaseLock(index = 0) {
     }
     releaseLock();
   }
-})().catch((exception) => {
-  // Send the exception up to the main thread so it can throw it and crash the process
-  try {
-    errorCommPort.postMessage({ exception, origin: 'unhandledRejection' });
-  } catch {
-    // If the exception is not serializable, still inform the main thread.
-    errorCommPort.postMessage({ origin: 'unhandledRejection' });
-  }
-  releaseLock(1);
-});
+})().catch(errorHandler);
 
 function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {

From 0cfc683643ace3f024ad741c5f6f2f8cd3e4aa00 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 12:04:31 +0100
Subject: [PATCH 066/126] let uncatcught exceptinnon be uncaught exceptions

---
 lib/internal/modules/esm/hooks.js  | 12 ++--------
 lib/internal/modules/esm/worker.js | 38 +++++++++++++++---------------
 2 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 1594023ae14b31..b9220e909d2345 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -473,10 +473,9 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(8); // Signal to tell the other thread to sleep or wake
+    const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
-    const errorCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
 
     const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
@@ -487,17 +486,10 @@ class HooksProxy {
       workerData: {
         lock,
         syncCommPort: syncCommChannel.port2,
-        errorCommPort: errorCommChannel.port2,
       },
-      transferList: [syncCommChannel.port2, errorCommChannel.port2],
+      transferList: [syncCommChannel.port2],
     });
     worker.unref(); // ! Allows the process to eventually exit.
-
-    PromisePrototypeThen(AtomicsWaitAsync(this.#lock, 1, 0).value, () => {
-      debug('uncaughtExceptionFromWorker');
-      const { message: { exception, origin } } = receiveMessageOnPort(errorCommChannel.port1);
-      onGlobalUncaughtException(exception, origin === 'unhandledRejection');
-    });
   }
 
   #waitForWorker() {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 8f7f5026a8db8b..8e4652f0d1a531 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -22,6 +22,9 @@ const {
 const assert = require('internal/assert');
 const { structuredClone } = require('internal/structured_clone');
 const { clearImmediate, setImmediate } = require('timers');
+const {
+  hasUncaughtExceptionCaptureCallback,
+} = require('internal/process/execution');
 const {
   isArrayBuffer,
   isDataView,
@@ -37,7 +40,7 @@ if (isMainThread) { return; } // Needed to pass some tests that happen to load t
 // lock = 0 -> main sleeps
 // lock = 1 -> worker sleeps
 const lock = new Int32Array(workerData.lock); // Required by Atomics
-const { syncCommPort, errorCommPort } = workerData; // To receive work signals.
+const { syncCommPort } = workerData; // To receive work signals.
 
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
@@ -51,15 +54,17 @@ function releaseLock(index = 0) {
   AtomicsNotify(lock, index); // Notify main of new response
 }
 
-function errorHandler(exception) {
-  // Send the exception up to the main thread so it can throw it and crash the process
-  try {
-    errorCommPort.postMessage({ exception, origin: 'unhandledRejection' });
-  } catch {
-    // If the exception is not serializable, still inform the main thread.
-    errorCommPort.postMessage({ origin: 'unhandledRejection' });
+function errorHandler(err, origin = 'unhandledRejection') {
+  releaseLock();
+  process.off('uncaughtException', errorHandler);
+  if (hasUncaughtExceptionCaptureCallback()) {
+    process._fatalException(err);
+    return;
   }
-  releaseLock(1);
+  internalBinding('errors').triggerUncaughtException(
+    err,
+    origin === 'unhandledRejection'
+  );
 }
 
 /**
@@ -115,6 +120,10 @@ function errorHandler(exception) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
     assert(typeof hooks[method] === 'function');
+    if (port == null && !hasUncaughtExceptionCaptureCallback()) {
+      // When receiving sync messages, we want to unlock the main thread when there's an exception.
+      process.on('uncaughtException', errorHandler);
+    }
     let response;
     try {
       if (immediateCount++ === 0) {
@@ -142,6 +151,7 @@ function errorHandler(exception) {
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
     releaseLock();
+    process.off('uncaughtException', errorHandler);
   }
 })().catch(errorHandler);
 
@@ -181,13 +191,3 @@ function wrapMessage(status, body) {
   };
 
 }
-
-process.on('uncaughtException', (exception, origin) => {
-  try {
-    errorCommPort.postMessage({ exception, origin });
-  } catch {
-    // If the exception is not serializable, still inform the main thread.
-    errorCommPort.postMessage({ origin });
-  }
-  releaseLock(1);
-});

From 7fd6fa1617c330ae0300c55c6eb174ea24345203 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 12:25:43 +0100
Subject: [PATCH 067/126] use `serializeError` instead of custom logic

---
 lib/internal/modules/esm/hooks.js  | 27 +++++---------------
 lib/internal/modules/esm/worker.js | 41 ++++++++----------------------
 2 files changed, 17 insertions(+), 51 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index b9220e909d2345..793606b4556de1 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -6,10 +6,8 @@ const {
   FunctionPrototypeCall,
   Int32Array,
   ObjectAssign,
-  ObjectDefineProperties,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
-  PromisePrototypeThen,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
@@ -26,12 +24,13 @@ const {
 } = globalThis;
 
 const {
-  ERR_LOADER_CHAIN_INCOMPLETE,
   ERR_INTERNAL_ASSERTION,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
   ERR_INVALID_RETURN_PROPERTY_VALUE,
   ERR_INVALID_RETURN_VALUE,
+  ERR_LOADER_CHAIN_INCOMPLETE,
+  ERR_WORKER_UNSERIALIZABLE_ERROR,
 } = require('internal/errors').codes;
 const { URL } = require('internal/url');
 const { receiveMessageOnPort } = require('worker_threads');
@@ -53,6 +52,7 @@ const {
 const {
   onGlobalUncaughtException,
 } = require('internal/process/execution');
+const { deserializeError } = require('internal/error_serdes');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
@@ -557,25 +557,12 @@ class HooksProxy {
 
   #unwrapMessage(response) {
     if (response.message.status === 'error') {
-      if (typeof response.message.body !== 'object' || response.message.body === null) {
-        throw response.message.body;
+      if (!response.nessage.body?.serializationFailed) {
+        throw ERR_WORKER_UNSERIALIZABLE_ERROR();
       }
 
-      const { exception } = response.message.body;
-      const descriptors = { __proto__: null };
-      const { ownProperties, values, enumerable } = response.message.body;
-      for (let i = 0; i < ownProperties.length; i++) {
-        const key = ownProperties[i];
-        descriptors[key] = {
-          __proto__: null,
-          configurable: true,
-          enumerable: enumerable[i],
-          writable: true,
-          value: values[i],
-        };
-      }
-      ObjectDefineProperties(exception, descriptors);
-      throw exception;
+      const error = deserializeError(response.message.body.serialized);
+      throw error;
     } else {
       return response.message.body;
     }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 8e4652f0d1a531..3a41f00f6fcfaa 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,15 +1,10 @@
 'use strict';
 
 const {
-  ArrayPrototypeFilter,
-  ArrayPrototypeMap,
-  ArrayPrototypePush,
   DataViewPrototypeGetBuffer,
   Int32Array,
-  ObjectGetOwnPropertyNames,
   PromisePrototypeThen,
   ReflectApply,
-  ReflectGetOwnPropertyDescriptor,
   SafeWeakMap,
   TypedArrayPrototypeGetBuffer,
   globalThis: {
@@ -20,7 +15,6 @@ const {
   },
 } = primordials;
 const assert = require('internal/assert');
-const { structuredClone } = require('internal/structured_clone');
 const { clearImmediate, setImmediate } = require('timers');
 const {
   hasUncaughtExceptionCaptureCallback,
@@ -159,34 +153,19 @@ function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {
     return { status, body };
   }
-  // Sending an `Error` object (or its derivatives like `TypeError`, `RangeError` and so on)
-  // through `postMessage` will strip it of many of its properties such as `code`. `v8.serialize`
-  // does too. Therefore, we save these properties alongside it.
-  const values = [];
-  const ownProperties = ArrayPrototypeFilter(ObjectGetOwnPropertyNames(body), (key) => {
-    // Those properties are already taken care of by the structured clone algorithm:
-    if (key === 'stack' || key === 'message' || key === 'cause') return false;
-
-    let value;
-    try {
-      // Accessing in a try/catch in case it's a getter that throws.
-      value = body[key];
-      // Filter only the clonable properties.
-      structuredClone(value);
-    } catch {
-      return false;
-    }
-    ArrayPrototypePush(values, value);
-    return true;
-  });
+  let serialized;
+  let serializationFailed = false;
+  try {
+    const { serializeError } = require('internal/error_serdes');
+    serialized = serializeError(body);
+  } catch {
+    serializationFailed = true;
+  }
   return {
     status,
     body: {
-      exception: body,
-      ownProperties,
-      values,
-      enumerable: ArrayPrototypeMap(
-        ownProperties, (key) => ReflectGetOwnPropertyDescriptor(body, key).enumerable),
+      serialized,
+      serializationFailed,
     }
   };
 

From a3982eec075ae703ad51e3e2f3228ee28cebb92e Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 13:24:25 +0100
Subject: [PATCH 068/126] fix unserializable errors handling

---
 lib/internal/modules/esm/hooks.js                    | 3 ++-
 lib/internal/modules/esm/worker.js                   | 5 ++++-
 test/es-module/test-esm-loader-with-syntax-error.mjs | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 793606b4556de1..a5d7aa259674b0 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -557,7 +557,8 @@ class HooksProxy {
 
   #unwrapMessage(response) {
     if (response.message.status === 'error') {
-      if (!response.nessage.body?.serializationFailed) {
+      if (response.message.body == null) throw response.message.body;
+      if (response.message.body.serializationFailed || response.message.body.serialized == null) {
         throw ERR_WORKER_UNSERIALIZABLE_ERROR();
       }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 3a41f00f6fcfaa..cdbc2051fabfba 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -153,8 +153,11 @@ function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {
     return { status, body };
   }
+  if (body == null) {
+    return { status, body };
+  }
   let serialized;
-  let serializationFailed = false;
+  let serializationFailed;
   try {
     const { serializeError } = require('internal/error_serdes');
     serialized = serializeError(body);
diff --git a/test/es-module/test-esm-loader-with-syntax-error.mjs b/test/es-module/test-esm-loader-with-syntax-error.mjs
index 0ed995ad510ee7..02a96b5b9470a8 100644
--- a/test/es-module/test-esm-loader-with-syntax-error.mjs
+++ b/test/es-module/test-esm-loader-with-syntax-error.mjs
@@ -13,7 +13,7 @@ describe('ESM: loader with syntax error', { concurrency: true }, () => {
       path('print-error-message.js'),
     ]);
 
-    match(stderr, /SyntaxError:/);
+    match(stderr, /SyntaxError \[Error\]:/);
     ok(!stderr.includes('Bad command or file name'));
     notStrictEqual(code, 0);
   });

From 47b4d83f9bb330a720dd242326d8bee3e90324fb Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 17:57:28 +0100
Subject: [PATCH 069/126] only count async messages

---
 lib/internal/modules/esm/worker.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index cdbc2051fabfba..1413570c2b8c4e 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -120,12 +120,12 @@ function errorHandler(err, origin = 'unhandledRejection') {
     }
     let response;
     try {
-      if (immediateCount++ === 0) {
+      if (port != null && immediateCount++ === 0) {
         immediate = setImmediate(checkForMessages).unref();
         syncCommPort.off('message', handleMessage);
       }
       response = await ReflectApply(hooks[method], hooks, args);
-      if (--immediateCount === 0) {
+      if (port != null && --immediateCount === 0) {
         clearImmediate(immediate);
         syncCommPort.on('message', handleMessage);
       }

From d518e53fdee6f9172b166944f440d6aeab9861e4 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 18:00:41 +0100
Subject: [PATCH 070/126] remove global error handler only at the end of the
 sync messages

---
 lib/internal/modules/esm/worker.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 1413570c2b8c4e..ce5fcb02d5feaf 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -113,10 +113,12 @@ function errorHandler(err, origin = 'unhandledRejection') {
   async function handleMessage({ method, args, port }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
+    let shouldRemoveGlobalErrorHandler = false;
     assert(typeof hooks[method] === 'function');
     if (port == null && !hasUncaughtExceptionCaptureCallback()) {
       // When receiving sync messages, we want to unlock the main thread when there's an exception.
       process.on('uncaughtException', errorHandler);
+      shouldRemoveGlobalErrorHandler = true;
     }
     let response;
     try {
@@ -145,7 +147,9 @@ function errorHandler(err, origin = 'unhandledRejection') {
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
     releaseLock();
-    process.off('uncaughtException', errorHandler);
+    if (shouldRemoveGlobalErrorHandler) {
+      process.off('uncaughtException', errorHandler);
+    }
   }
 })().catch(errorHandler);
 

From 531c9a3ca4f46d4bfcf27f23aeb2c2725b5fe1c8 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 14 Jan 2023 20:32:59 +0100
Subject: [PATCH 071/126] use `'beforeExit'` event to detect when threads are
 ready to die

---
 lib/internal/modules/esm/hooks.js  | 47 ++++++++++++++++++++++++++++--
 lib/internal/modules/esm/worker.js | 29 +++++++++++++++++-
 2 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index a5d7aa259674b0..ac28aaea879bd9 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -16,6 +16,8 @@ const {
 
 const {
   Atomics: {
+    notify: AtomicsNotify,
+    or: AtomicsOr,
     store: AtomicsStore,
     wait: AtomicsWait,
     waitAsync: AtomicsWaitAsync,
@@ -53,6 +55,7 @@ const {
   onGlobalUncaughtException,
 } = require('internal/process/execution');
 const { deserializeError } = require('internal/error_serdes');
+const { setImmediate } = require('timers');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
@@ -473,7 +476,7 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(4); // Signal to tell the other thread to sleep or wake
+    const lock = new SharedArrayBuffer(8); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
@@ -507,6 +510,24 @@ class HooksProxy {
     }
   }
 
+  #beforeExitTellMyChildILoveHer = () => {
+    switch (AtomicsOr(this.#lock, 1, 0b10)) {
+      case 0b00:
+      case 0b10:
+        // The worker is still in good health, and we just told it it's the
+        // only thing keeping us alive.
+        this.worker.ref();
+        break;
+
+      case 0b01:
+      case 0b11:
+        // The worker has already reported waiting for us to die together.
+        this.worker.unref();
+        AtomicsNotify(this.#lock, 1); // Wake up worker so it can die.
+        break;
+    }
+  };
+
   async makeAsyncRequest(method, ...args) {
     this.#waitForWorker();
 
@@ -517,7 +538,16 @@ class HooksProxy {
     debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
 
-    if (this.#pendingAsyncMessages++ === 0) this.worker.ref();
+    if (this.#pendingAsyncMessages++ === 0) {
+      AtomicsStore(this.#lock, 1, 0); // Reset signal
+      process.on('beforeExit', this.#beforeExitTellMyChildILoveHer);
+    } else if (this.#lock[1] & 0b01) {
+      // The worker locked itself waiting for a message from us, let's unlock it
+      // so it can process the message just sent.
+      AtomicsStore(this.#lock, 1, 0); // Reset signal
+      debug('wake up worker');
+      AtomicsNotify(this.#lock, 1);
+    }
 
     let response;
     debug('start waiting for async response from worker', { method, args });
@@ -529,7 +559,10 @@ class HooksProxy {
     }
     debug('got async response from worker', { method, args });
 
-    if (--this.#pendingAsyncMessages === 0) this.worker.unref();
+    if (--this.#pendingAsyncMessages === 0) {
+      this.worker.unref();
+      process.off('beforeExit', this.#beforeExitTellMyChildILoveHer);
+    }
 
     const body = this.#unwrapMessage(response);
     asyncCommChannel.port1.close();
@@ -543,6 +576,14 @@ class HooksProxy {
     debug('post sync message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args });
 
+    if (this.#lock[1] & 0b01) {
+      // The worker locked itself waiting for a message from us, let's unlock it
+      // so it can process the message just sent.
+      AtomicsStore(this.#lock, 1, 0); // Reset signal
+      debug('wake up worker');
+      AtomicsNotify(this.#lock, 1);
+    }
+
     let response;
     debug('start waiting for sync response from worker', { method, args });
     while (response == null) {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index ce5fcb02d5feaf..af805655cf5dca 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -10,7 +10,9 @@ const {
   globalThis: {
     Atomics: {
       notify: AtomicsNotify,
+      or: AtomicsOr,
       store: AtomicsStore,
+      wait: AtomicsWait,
     },
   },
 } = primordials;
@@ -110,6 +112,30 @@ function errorHandler(err, origin = 'unhandledRejection') {
     }
   }
 
+  function beforeExitTellMyMomILoveHer() {
+    switch (AtomicsOr(lock, 1, 0b01)) {
+      case 0b00:
+      case 0b01:
+        // The main thread is still in good health, let's pause the worker
+        // thread until a new message comes in.
+        if (AtomicsWait(lock, 1, 0) === 'ok') {
+          // If the value is 0, it means the main thread just sent a message for
+          // us to process.
+          // Any other value means the main thread is also dying.
+          tickCount = 0;
+          checkForMessages();
+        }
+        break;
+
+      case 0b10:
+      case 0b11:
+        // The main thread has already reported waiting for us to die together.
+        syncCommPort.off('message', handleMessage);
+        break;
+    }
+  }
+  process.on('beforeExit', beforeExitTellMyMomILoveHer);
+
   async function handleMessage({ method, args, port }) {
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
@@ -123,13 +149,14 @@ function errorHandler(err, origin = 'unhandledRejection') {
     let response;
     try {
       if (port != null && immediateCount++ === 0) {
-        immediate = setImmediate(checkForMessages).unref();
+        immediate = setImmediate(checkForMessages);
         syncCommPort.off('message', handleMessage);
       }
       response = await ReflectApply(hooks[method], hooks, args);
       if (port != null && --immediateCount === 0) {
         clearImmediate(immediate);
         syncCommPort.on('message', handleMessage);
+        AtomicsStore(lock, 1, 0); // Reset signal
       }
     } catch (exception) {
       hasError = true;

From 3bcf18c3b8fe36b01617a06624241f8e67baae7b Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 15 Jan 2023 01:21:50 +0100
Subject: [PATCH 072/126] ensure there are no pending messages before letting
 worker die

---
 lib/internal/modules/esm/hooks.js  | 55 +++++++++++++-----------------
 lib/internal/modules/esm/worker.js | 42 +++++++++++------------
 2 files changed, 43 insertions(+), 54 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index ac28aaea879bd9..05373668c9fef3 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -16,6 +16,8 @@ const {
 
 const {
   Atomics: {
+    add: AtomicsAdd,
+    and: AtomicsAnd,
     notify: AtomicsNotify,
     or: AtomicsOr,
     store: AtomicsStore,
@@ -468,7 +470,7 @@ class HooksProxy {
    */
   #syncCommPort;
 
-  #pendingAsyncMessages = 0;
+  #pendingAsyncMessageResponses = 0;
 
   #isReady = false;
 
@@ -476,7 +478,7 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(8); // Signal to tell the other thread to sleep or wake
+    const lock = new SharedArrayBuffer(12); // Signal to tell the other thread to sleep or wake
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
@@ -511,20 +513,15 @@ class HooksProxy {
   }
 
   #beforeExitTellMyChildILoveHer = () => {
-    switch (AtomicsOr(this.#lock, 1, 0b10)) {
-      case 0b00:
-      case 0b10:
-        // The worker is still in good health, and we just told it it's the
-        // only thing keeping us alive.
-        this.worker.ref();
-        break;
-
-      case 0b01:
-      case 0b11:
-        // The worker has already reported waiting for us to die together.
-        this.worker.unref();
-        AtomicsNotify(this.#lock, 1); // Wake up worker so it can die.
-        break;
+    const value = AtomicsOr(this.#lock, 1, 0b010);
+    debug('beforeExit main thread', value, this.#lock);
+    if (value & 0b001 && this.#lock[2] === 0) {
+      // The worker has already reported waiting for us to die together.
+      this.worker.terminate();
+    } else {
+      // The worker is still in good health, and we just told it it's the
+      // only thing keeping us alive.
+      this.worker.ref();
     }
   };
 
@@ -537,16 +534,12 @@ class HooksProxy {
     // Pass work to the worker.
     debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
+    // In case the worker was bored, it might lock itself waiting for a signal.
+    AtomicsAdd(this.#lock, 2, 1);
+    AtomicsNotify(this.#lock, 2);
 
-    if (this.#pendingAsyncMessages++ === 0) {
-      AtomicsStore(this.#lock, 1, 0); // Reset signal
+    if (this.#pendingAsyncMessageResponses++ === 0) {
       process.on('beforeExit', this.#beforeExitTellMyChildILoveHer);
-    } else if (this.#lock[1] & 0b01) {
-      // The worker locked itself waiting for a message from us, let's unlock it
-      // so it can process the message just sent.
-      AtomicsStore(this.#lock, 1, 0); // Reset signal
-      debug('wake up worker');
-      AtomicsNotify(this.#lock, 1);
     }
 
     let response;
@@ -559,7 +552,9 @@ class HooksProxy {
     }
     debug('got async response from worker', { method, args });
 
-    if (--this.#pendingAsyncMessages === 0) {
+    AtomicsAnd(this.#lock, 1, ~0b10); // If the main thread was bored before, it's no longer the case.
+    if (--this.#pendingAsyncMessageResponses === 0) {
+      // We got all the responses from the worker, its job is done (until next time).
       this.worker.unref();
       process.off('beforeExit', this.#beforeExitTellMyChildILoveHer);
     }
@@ -576,13 +571,9 @@ class HooksProxy {
     debug('post sync message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args });
 
-    if (this.#lock[1] & 0b01) {
-      // The worker locked itself waiting for a message from us, let's unlock it
-      // so it can process the message just sent.
-      AtomicsStore(this.#lock, 1, 0); // Reset signal
-      debug('wake up worker');
-      AtomicsNotify(this.#lock, 1);
-    }
+    // In case the worker was bored, it might lock itself waiting for a signal.
+    AtomicsAdd(this.#lock, 2, 1);
+    AtomicsNotify(this.#lock, 2);
 
     let response;
     debug('start waiting for sync response from worker', { method, args });
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index af805655cf5dca..0731c17087f4dc 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -9,9 +9,11 @@ const {
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
+      and: AtomicsAnd,
       notify: AtomicsNotify,
       or: AtomicsOr,
       store: AtomicsStore,
+      sub: AtomicsSub,
       wait: AtomicsWait,
     },
   },
@@ -107,36 +109,34 @@ function errorHandler(err, origin = 'unhandledRejection') {
     const response = receiveMessageOnPort(syncCommPort);
 
     if (response !== undefined) {
-      tickCount = 0;
+      tickCount = 9;
       PromisePrototypeThen(handleMessage(response.message), undefined, errorHandler);
     }
   }
 
+  const WORKER_THREAD_IS_BORED = 0b01;
+  const MAIN_THREAD_IS_BORED = 0b10;
   function beforeExitTellMyMomILoveHer() {
-    switch (AtomicsOr(lock, 1, 0b01)) {
-      case 0b00:
-      case 0b01:
-        // The main thread is still in good health, let's pause the worker
-        // thread until a new message comes in.
-        if (AtomicsWait(lock, 1, 0) === 'ok') {
-          // If the value is 0, it means the main thread just sent a message for
-          // us to process.
-          // Any other value means the main thread is also dying.
-          tickCount = 0;
-          checkForMessages();
-        }
-        break;
-
-      case 0b10:
-      case 0b11:
-        // The main thread has already reported waiting for us to die together.
-        syncCommPort.off('message', handleMessage);
-        break;
+    const value = AtomicsOr(lock, 1, WORKER_THREAD_IS_BORED);
+
+    if (value & MAIN_THREAD_IS_BORED && lock[2] === 0) {
+      // Main thread has no work schedule, we can die together
+      return;
     }
+
+    // Let's pause the worker thread until a new message comes in.
+    AtomicsWait(lock, 2, 0);
+    // If the value is 0, it means the main thread woke us up only to die together.
+    AtomicsAnd(lock, 1, ~WORKER_THREAD_IS_BORED);
+    tickCount = 0;
+    clearImmediate(immediate);
+    checkForMessages();
   }
   process.on('beforeExit', beforeExitTellMyMomILoveHer);
 
   async function handleMessage({ method, args, port }) {
+    AtomicsSub(lock, 2, 1);
+
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;
     let shouldRemoveGlobalErrorHandler = false;
@@ -149,14 +149,12 @@ function errorHandler(err, origin = 'unhandledRejection') {
     let response;
     try {
       if (port != null && immediateCount++ === 0) {
-        immediate = setImmediate(checkForMessages);
         syncCommPort.off('message', handleMessage);
       }
       response = await ReflectApply(hooks[method], hooks, args);
       if (port != null && --immediateCount === 0) {
         clearImmediate(immediate);
         syncCommPort.on('message', handleMessage);
-        AtomicsStore(lock, 1, 0); // Reset signal
       }
     } catch (exception) {
       hasError = true;

From b071a89b00b3ba6383fd421f65df1f818361d905 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 15 Jan 2023 23:13:15 +0100
Subject: [PATCH 073/126] linter fixes

---
 lib/internal/modules/esm/hooks.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 05373668c9fef3..376f061dd340ac 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -53,11 +53,7 @@ const {
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
-const {
-  onGlobalUncaughtException,
-} = require('internal/process/execution');
 const { deserializeError } = require('internal/error_serdes');
-const { setImmediate } = require('timers');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });

From 0911d152ce70da0115cc22ef42d110d2d92afef5 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 15 Jan 2023 23:21:14 +0100
Subject: [PATCH 074/126] get rid of the tick counter timeout

---
 lib/internal/modules/esm/worker.js | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 0731c17087f4dc..5ba3158de03292 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -100,16 +100,13 @@ function errorHandler(err, origin = 'unhandledRejection') {
 
   let immediate;
   let immediateCount = 0;
-  let tickCount = 0;
   function checkForMessages() {
-    immediate = setImmediate(checkForMessages);
+    immediate = setImmediate(checkForMessages).unref();
     // We need to let the event loop tick a few times to give the main thread a
     // chance to send follow-up messages.
-    if (tickCount++ === 9) immediate.unref();
     const response = receiveMessageOnPort(syncCommPort);
 
     if (response !== undefined) {
-      tickCount = 9;
       PromisePrototypeThen(handleMessage(response.message), undefined, errorHandler);
     }
   }
@@ -126,11 +123,12 @@ function errorHandler(err, origin = 'unhandledRejection') {
 
     // Let's pause the worker thread until a new message comes in.
     AtomicsWait(lock, 2, 0);
-    // If the value is 0, it means the main thread woke us up only to die together.
-    AtomicsAnd(lock, 1, ~WORKER_THREAD_IS_BORED);
-    tickCount = 0;
-    clearImmediate(immediate);
+    AtomicsAnd(lock, 1, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
+    // The pending messages won't come back at this point, we can reset the counter.
+    immediateCount = 0;
     checkForMessages();
+    clearImmediate(immediate);
+    syncCommPort.on('message', handleMessage);
   }
   process.on('beforeExit', beforeExitTellMyMomILoveHer);
 
@@ -149,6 +147,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
     let response;
     try {
       if (port != null && immediateCount++ === 0) {
+        immediate = setImmediate(checkForMessages).unref();
         syncCommPort.off('message', handleMessage);
       }
       response = await ReflectApply(hooks[method], hooks, args);

From 0b1c22b4bd509c32cc5d0ce75d56e2197309332e Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 17 Jan 2023 16:28:50 +0100
Subject: [PATCH 075/126] Use `Atomics.load` for better results

---
 lib/internal/modules/esm/hooks.js  | 6 ++++--
 lib/internal/modules/esm/worker.js | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 376f061dd340ac..a1cc65faecd346 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -18,6 +18,7 @@ const {
   Atomics: {
     add: AtomicsAdd,
     and: AtomicsAnd,
+    load: AtomicsLoad,
     notify: AtomicsNotify,
     or: AtomicsOr,
     store: AtomicsStore,
@@ -509,9 +510,10 @@ class HooksProxy {
   }
 
   #beforeExitTellMyChildILoveHer = () => {
-    const value = AtomicsOr(this.#lock, 1, 0b010);
+    const value = AtomicsOr(this.#lock, 1, 0b10);
     debug('beforeExit main thread', value, this.#lock);
-    if (value & 0b001 && this.#lock[2] === 0) {
+    if (value & 0b01 && AtomicsLoad(this.#lock, 2) === 0) {
+      debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
       this.worker.terminate();
     } else {
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 5ba3158de03292..daec5aa0d98e63 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -10,6 +10,7 @@ const {
   globalThis: {
     Atomics: {
       and: AtomicsAnd,
+      load: AtomicsLoad,
       notify: AtomicsNotify,
       or: AtomicsOr,
       store: AtomicsStore,
@@ -116,7 +117,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
   function beforeExitTellMyMomILoveHer() {
     const value = AtomicsOr(lock, 1, WORKER_THREAD_IS_BORED);
 
-    if (value & MAIN_THREAD_IS_BORED && lock[2] === 0) {
+    if (value & MAIN_THREAD_IS_BORED && AtomicsLoad(lock, 2) === 0) {
       // Main thread has no work schedule, we can die together
       return;
     }

From 88686f53f930fd954077d231f2c7cd9be6ff80cd Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 18 Jan 2023 17:00:14 +0100
Subject: [PATCH 076/126] add `shared_constants` internal module to make code
 clearer

---
 lib/internal/modules/esm/hooks.js            | 39 ++++++++++++--------
 lib/internal/modules/esm/shared_constants.js | 14 +++++++
 lib/internal/modules/esm/worker.js           | 30 ++++++++-------
 3 files changed, 54 insertions(+), 29 deletions(-)
 create mode 100644 lib/internal/modules/esm/shared_constants.js

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index a1cc65faecd346..793477f50747d9 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -55,6 +55,13 @@ const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
 const { deserializeError } = require('internal/error_serdes');
+const {
+  BOREDOM_OF_THREADS,
+  MAIN_THREAD_IS_BORED,
+  NUMBER_OF_INCOMING_MESSAGES,
+  WORKER_THREAD_IS_BORED,
+  WORKER_TO_MAIN_THREAD_NOTIFICATION,
+} = require('internal/modules/esm/shared_constants');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
@@ -475,7 +482,7 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(12); // Signal to tell the other thread to sleep or wake
+    const lock = new SharedArrayBuffer(3 * 4);
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
@@ -499,7 +506,7 @@ class HooksProxy {
       const { kIsOnline } = require('internal/worker');
       if (!this.worker[kIsOnline]) {
         debug('wait for signal from worker');
-        AtomicsWait(this.#lock, 0, 0); // ! Block the main thread until the worker is ready.
+        AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0);
         const response = receiveMessageOnPort(this.#syncCommPort);
         const { preloadScripts } = this.#unwrapMessage(response);
         this.#executePreloadScripts(preloadScripts);
@@ -509,10 +516,10 @@ class HooksProxy {
     }
   }
 
-  #beforeExitTellMyChildILoveHer = () => {
-    const value = AtomicsOr(this.#lock, 1, 0b10);
+  #beforeExitHandler = () => {
+    const value = AtomicsOr(this.#lock, BOREDOM_OF_THREADS, MAIN_THREAD_IS_BORED);
     debug('beforeExit main thread', value, this.#lock);
-    if (value & 0b01 && AtomicsLoad(this.#lock, 2) === 0) {
+    if (value & WORKER_THREAD_IS_BORED && AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
       debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
       this.worker.terminate();
@@ -533,28 +540,28 @@ class HooksProxy {
     debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsAdd(this.#lock, 2, 1);
-    AtomicsNotify(this.#lock, 2);
+    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
+    AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
     if (this.#pendingAsyncMessageResponses++ === 0) {
-      process.on('beforeExit', this.#beforeExitTellMyChildILoveHer);
+      process.on('beforeExit', this.#beforeExitHandler);
     }
 
     let response;
     debug('start waiting for async response from worker', { method, args });
     while (response == null) {
-      AtomicsStore(this.#lock, 0, 0); // Reset lock.
-      await AtomicsWaitAsync(this.#lock, 0, 0).value;
+      AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
+      await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
     debug('got async response from worker', { method, args });
 
-    AtomicsAnd(this.#lock, 1, ~0b10); // If the main thread was bored before, it's no longer the case.
+    AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
     if (--this.#pendingAsyncMessageResponses === 0) {
       // We got all the responses from the worker, its job is done (until next time).
       this.worker.unref();
-      process.off('beforeExit', this.#beforeExitTellMyChildILoveHer);
+      process.off('beforeExit', this.#beforeExitHandler);
     }
 
     const body = this.#unwrapMessage(response);
@@ -570,14 +577,14 @@ class HooksProxy {
     this.#syncCommPort.postMessage({ method, args });
 
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsAdd(this.#lock, 2, 1);
-    AtomicsNotify(this.#lock, 2);
+    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
+    AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
     let response;
     debug('start waiting for sync response from worker', { method, args });
     while (response == null) {
-      AtomicsStore(this.#lock, 0, 0); // Reset lock.
-      AtomicsWait(this.#lock, 0, 0); // Sleep until worker responds.
+      AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
+      AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Sleep until worker responds.
 
       response = receiveMessageOnPort(this.#syncCommPort);
     }
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
new file mode 100644
index 00000000000000..0408bec47f7d4b
--- /dev/null
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -0,0 +1,14 @@
+// This file contains the definition for the constant values that must be
+// available to both the main thread and the loader thread.
+
+'use strict';
+
+module.exports = {
+  WORKER_TO_MAIN_THREAD_NOTIFICATION: 0,
+
+  BOREDOM_OF_THREADS: 1,
+  WORKER_THREAD_IS_BORED: 0b01,
+  MAIN_THREAD_IS_BORED: 0b10,
+
+  NUMBER_OF_INCOMING_MESSAGES: 2,
+};
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index daec5aa0d98e63..5477f1d9b40fef 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -34,6 +34,13 @@ const {
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
 const { isMainThread, workerData, receiveMessageOnPort } = require('worker_threads');
+const {
+  BOREDOM_OF_THREADS,
+  MAIN_THREAD_IS_BORED,
+  NUMBER_OF_INCOMING_MESSAGES,
+  WORKER_THREAD_IS_BORED,
+  WORKER_TO_MAIN_THREAD_NOTIFICATION,
+} = require('internal/modules/esm/shared_constants');
 if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
 
 // lock = 0 -> main sleeps
@@ -48,9 +55,9 @@ function transferArrayBuffer(hasError, source) {
   if (isDataView(source)) return [DataViewPrototypeGetBuffer(source)];
 }
 
-function releaseLock(index = 0) {
-  AtomicsStore(lock, index, 1); // Send response to main
-  AtomicsNotify(lock, index); // Notify main of new response
+function releaseLock() {
+  AtomicsStore(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1); // Send response to main
+  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION); // Notify main of new response
 }
 
 function errorHandler(err, origin = 'unhandledRejection') {
@@ -112,29 +119,26 @@ function errorHandler(err, origin = 'unhandledRejection') {
     }
   }
 
-  const WORKER_THREAD_IS_BORED = 0b01;
-  const MAIN_THREAD_IS_BORED = 0b10;
-  function beforeExitTellMyMomILoveHer() {
-    const value = AtomicsOr(lock, 1, WORKER_THREAD_IS_BORED);
+  process.on('beforeExit', () => {
+    const value = AtomicsOr(lock, BOREDOM_OF_THREADS, WORKER_THREAD_IS_BORED);
 
-    if (value & MAIN_THREAD_IS_BORED && AtomicsLoad(lock, 2) === 0) {
+    if (value & MAIN_THREAD_IS_BORED && AtomicsLoad(lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
       // Main thread has no work schedule, we can die together
       return;
     }
 
     // Let's pause the worker thread until a new message comes in.
-    AtomicsWait(lock, 2, 0);
-    AtomicsAnd(lock, 1, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
+    AtomicsWait(lock, NUMBER_OF_INCOMING_MESSAGES, 0);
+    AtomicsAnd(lock, BOREDOM_OF_THREADS, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
     // The pending messages won't come back at this point, we can reset the counter.
     immediateCount = 0;
     checkForMessages();
     clearImmediate(immediate);
     syncCommPort.on('message', handleMessage);
-  }
-  process.on('beforeExit', beforeExitTellMyMomILoveHer);
+  });
 
   async function handleMessage({ method, args, port }) {
-    AtomicsSub(lock, 2, 1);
+    AtomicsSub(lock, NUMBER_OF_INCOMING_MESSAGES, 1);
 
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;

From 1b1583e3afd7c69d4eeb136bd5fbb8cbaf263b9b Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 18 Jan 2023 17:12:33 +0100
Subject: [PATCH 077/126] rename `ModuleLoader` -> `createModuleLoader`

---
 lib/internal/modules/esm/loader.js          | 5 ++---
 lib/internal/process/esm_loader.js          | 4 ++--
 test/es-module/test-esm-loader-modulemap.js | 4 ++--
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 912f81e1da5fa1..6f46696b1a15f5 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -400,7 +400,7 @@ let emittedExperimentalWarning = false;
  * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
  * @returns {instanceof BaseModuleLoader | instanceof CustomizedModuleLoader}
  */
-function ModuleLoader(useCustomLoadersIfPresent = true) {
+function createModuleLoader(useCustomLoadersIfPresent = true) {
   if (useCustomLoadersIfPresent) {
     const userLoaderPaths = getOptionValue('--experimental-loader');
     if (userLoaderPaths.length > 0) {
@@ -414,9 +414,8 @@ function ModuleLoader(useCustomLoadersIfPresent = true) {
 
   return new DefaultModuleLoader();
 }
-ObjectSetPrototypeOf(ModuleLoader.prototype, null);
 
 module.exports = {
   DefaultModuleLoader,
-  ModuleLoader,
+  createModuleLoader,
 };
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 36d6e15eb223dd..b19d4e61ea063f 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const { ModuleLoader } = require('internal/modules/esm/loader');
+const { createModuleLoader } = require('internal/modules/esm/loader');
 const { getOptionValue } = require('internal/options');
 const {
   hasUncaughtExceptionCaptureCallback,
@@ -8,7 +8,7 @@ const {
 const { pathToFileURL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
 
-const esmLoader = new ModuleLoader(true);
+const esmLoader = createModuleLoader(true);
 exports.esmLoader = esmLoader;
 
 exports.loadESM = async function loadESM(callback) {
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index a1d035fbf01938..093a4f6b3ef162 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -4,7 +4,7 @@
 require('../common');
 
 const { strictEqual, throws } = require('assert');
-const { ModuleLoader } = require('internal/modules/esm/loader');
+const { createModuleLoader } = require('internal/modules/esm/loader');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 const createDynamicModule = require(
@@ -16,7 +16,7 @@ const jsonModuleDataUrl = 'data:application/json,""';
 const stubJsModule = createDynamicModule([], ['default'], jsModuleDataUrl);
 const stubJsonModule = createDynamicModule([], ['default'], jsonModuleDataUrl);
 
-const loader = new ModuleLoader(false);
+const loader = createModuleLoader(false);
 const jsModuleJob = new ModuleJob(loader, stubJsModule.module, undefined,
                                   () => new Promise(() => {}));
 const jsonModuleJob = new ModuleJob(loader, stubJsonModule.module,

From 3f4934aef5b731caee98d9ed62e10e9089afcd06 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 19 Jan 2023 00:14:55 +0100
Subject: [PATCH 078/126] lazy load esmLoader

---
 lib/internal/process/esm_loader.js | 59 ++++++++++++++++--------------
 1 file changed, 32 insertions(+), 27 deletions(-)

diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index b19d4e61ea063f..d64d35f4f10e85 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -8,35 +8,40 @@ const {
 const { pathToFileURL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
 
-const esmLoader = createModuleLoader(true);
-exports.esmLoader = esmLoader;
+let esmLoader;
 
-exports.loadESM = async function loadESM(callback) {
-  try {
-    const userImports = getOptionValue('--import');
-    if (userImports.length > 0) {
-      let cwd;
-      try {
-        cwd = process.cwd() + '/';
-      } catch {
-        cwd = '/';
+module.exports = {
+  get esmLoader() {
+    return esmLoader ??= createModuleLoader(true);
+  },
+  async loadESM(callback) {
+    esmLoader ??= createModuleLoader(true);
+    try {
+      const userImports = getOptionValue('--import');
+      if (userImports.length > 0) {
+        let cwd;
+        try {
+          cwd = process.cwd() + '/';
+        } catch {
+          cwd = '/';
+        }
+        const parentURL = pathToFileURL(cwd).href;
+        await esmLoader.import(
+          userImports,
+          parentURL,
+          kEmptyObject,
+        );
       }
-      const parentURL = pathToFileURL(cwd).href;
-      await esmLoader.import(
-        userImports,
-        parentURL,
-        kEmptyObject,
+      await callback(esmLoader);
+    } catch (err) {
+      if (hasUncaughtExceptionCaptureCallback()) {
+        process._fatalException(err);
+        return;
+      }
+      internalBinding('errors').triggerUncaughtException(
+        err,
+        true, /* fromPromise */
       );
     }
-    await callback(esmLoader);
-  } catch (err) {
-    if (hasUncaughtExceptionCaptureCallback()) {
-      process._fatalException(err);
-      return;
-    }
-    internalBinding('errors').triggerUncaughtException(
-      err,
-      true, /* fromPromise */
-    );
-  }
+  },
 };

From 800d1515842067dc92210f0d9ccb317bb8a03201 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 19 Jan 2023 01:15:22 +0100
Subject: [PATCH 079/126] nits

---
 lib/internal/modules/esm/hooks.js  | 12 ++++++++----
 lib/internal/modules/esm/worker.js |  6 ++++--
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 793477f50747d9..3d8753ce0ecf41 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -531,6 +531,7 @@ class HooksProxy {
   };
 
   async makeAsyncRequest(method, ...args) {
+    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
     this.#waitForWorker();
 
     MessageChannel ??= require('internal/worker/io').MessageChannel;
@@ -540,7 +541,6 @@ class HooksProxy {
     debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
     AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
     if (this.#pendingAsyncMessageResponses++ === 0) {
@@ -552,12 +552,12 @@ class HooksProxy {
     while (response == null) {
       AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
+      AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
-    debug('got async response from worker', { method, args });
+    debug('got async response from worker', { method, args }, this.#lock);
 
-    AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
     if (--this.#pendingAsyncMessageResponses === 0) {
       // We got all the responses from the worker, its job is done (until next time).
       this.worker.unref();
@@ -570,6 +570,7 @@ class HooksProxy {
   }
 
   makeSyncRequest(method, ...args) {
+    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
     this.#waitForWorker();
 
     // Pass work to the worker.
@@ -577,7 +578,6 @@ class HooksProxy {
     this.#syncCommPort.postMessage({ method, args });
 
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
     AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
     let response;
@@ -587,6 +587,10 @@ class HooksProxy {
       AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Sleep until worker responds.
 
       response = receiveMessageOnPort(this.#syncCommPort);
+
+      if (response == null && AtomicsLoad(this.#lock, BOREDOM_OF_THREADS) & WORKER_THREAD_IS_BORED) {
+        // TODO(aduh95): handle never-settling promises in sync responses.
+      }
     }
     debug('got sync response from worker', { method, args });
     return this.#unwrapMessage(response);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 5477f1d9b40fef..a159218ae477ac 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -123,18 +123,20 @@ function errorHandler(err, origin = 'unhandledRejection') {
     const value = AtomicsOr(lock, BOREDOM_OF_THREADS, WORKER_THREAD_IS_BORED);
 
     if (value & MAIN_THREAD_IS_BORED && AtomicsLoad(lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
-      // Main thread has no work schedule, we can die together
+      // Main thread is also out of work, there's nothing left to do.
       return;
     }
 
+    releaseLock(); // In case the main thread was waiting for a sync response.
     // Let's pause the worker thread until a new message comes in.
     AtomicsWait(lock, NUMBER_OF_INCOMING_MESSAGES, 0);
+
     AtomicsAnd(lock, BOREDOM_OF_THREADS, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
     // The pending messages won't come back at this point, we can reset the counter.
     immediateCount = 0;
+    syncCommPort.on('message', handleMessage);
     checkForMessages();
     clearImmediate(immediate);
-    syncCommPort.on('message', handleMessage);
   });
 
   async function handleMessage({ method, args, port }) {

From a5a798be45bbfe166341f2cac39eadbdb607f047 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Feb 2023 22:48:26 +0100
Subject: [PATCH 080/126] fix test-esm-loader

---
 lib/internal/modules/esm/worker.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index a159218ae477ac..e55f6db8b22390 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -158,13 +158,14 @@ function errorHandler(err, origin = 'unhandledRejection') {
         syncCommPort.off('message', handleMessage);
       }
       response = await ReflectApply(hooks[method], hooks, args);
+    } catch (exception) {
+      hasError = true;
+      response = exception;
+    } finally {
       if (port != null && --immediateCount === 0) {
         clearImmediate(immediate);
         syncCommPort.on('message', handleMessage);
       }
-    } catch (exception) {
-      hasError = true;
-      response = exception;
     }
 
     // Send the method response (or exception) to the main thread.

From f9371ae5f2862549f1bac298f1fd05be964a7d70 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Feb 2023 23:23:43 +0100
Subject: [PATCH 081/126] unref worker more often

---
 lib/internal/modules/esm/hooks.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 3d8753ce0ecf41..2d6a697a3f7876 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -553,6 +553,7 @@ class HooksProxy {
       AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
       AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
+      this.worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
@@ -560,7 +561,6 @@ class HooksProxy {
 
     if (--this.#pendingAsyncMessageResponses === 0) {
       // We got all the responses from the worker, its job is done (until next time).
-      this.worker.unref();
       process.off('beforeExit', this.#beforeExitHandler);
     }
 

From 0b79809c0afcdca29723e790746dff06ce69dbba Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Feb 2023 23:28:14 +0100
Subject: [PATCH 082/126] add more comments

---
 lib/internal/modules/esm/worker.js | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index e55f6db8b22390..de82afd8e188a0 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -151,21 +151,28 @@ function errorHandler(err, origin = 'unhandledRejection') {
       process.on('uncaughtException', errorHandler);
       shouldRemoveGlobalErrorHandler = true;
     }
+
+    if (port != null && immediateCount++ === 0) {
+      // We are about to yield the execution with the await ReflectApply below.
+      // In case the code following the await never runs, we remove the message
+      // handler so the `beforeExit` event can be triggered.
+      syncCommPort.off('message', handleMessage);
+      // We keep checking for new messages to not miss any.
+      immediate = setImmediate(checkForMessages).unref();
+    }
+
     let response;
     try {
-      if (port != null && immediateCount++ === 0) {
-        immediate = setImmediate(checkForMessages).unref();
-        syncCommPort.off('message', handleMessage);
-      }
       response = await ReflectApply(hooks[method], hooks, args);
     } catch (exception) {
       hasError = true;
       response = exception;
-    } finally {
-      if (port != null && --immediateCount === 0) {
-        clearImmediate(immediate);
-        syncCommPort.on('message', handleMessage);
-      }
+    }
+
+    if (port != null && --immediateCount === 0) {
+      // All the messages have been handled before the event loop died, we can go back to the initial setup.
+      syncCommPort.on('message', handleMessage);
+      clearImmediate(immediate);
     }
 
     // Send the method response (or exception) to the main thread.

From 0cfec426b194177da9fb888b925efa3fb11c0ff0 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 12 Feb 2023 23:10:51 +0100
Subject: [PATCH 083/126] fix main thread refusing to die waiting on a response
 that will never come

---
 lib/internal/modules/esm/hooks.js            | 10 +++++-----
 lib/internal/modules/esm/shared_constants.js |  1 +
 lib/internal/modules/esm/worker.js           | 15 +++++++++++----
 3 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 2d6a697a3f7876..1280215bbbb6e1 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -22,6 +22,7 @@ const {
     notify: AtomicsNotify,
     or: AtomicsOr,
     store: AtomicsStore,
+    sub: AtomicsSub,
     wait: AtomicsWait,
     waitAsync: AtomicsWaitAsync,
   },
@@ -58,6 +59,7 @@ const { deserializeError } = require('internal/error_serdes');
 const {
   BOREDOM_OF_THREADS,
   MAIN_THREAD_IS_BORED,
+  NUMBER_OF_INCOMING_ASYNC_RESPONSES,
   NUMBER_OF_INCOMING_MESSAGES,
   WORKER_THREAD_IS_BORED,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
@@ -474,15 +476,13 @@ class HooksProxy {
    */
   #syncCommPort;
 
-  #pendingAsyncMessageResponses = 0;
-
   #isReady = false;
 
   constructor() {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(3 * 4);
+    const lock = new SharedArrayBuffer(4 * 4);
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
@@ -543,7 +543,7 @@ class HooksProxy {
     // In case the worker was bored, it might lock itself waiting for a signal.
     AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
-    if (this.#pendingAsyncMessageResponses++ === 0) {
+    if (AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) === 0) {
       process.on('beforeExit', this.#beforeExitHandler);
     }
 
@@ -559,7 +559,7 @@ class HooksProxy {
     }
     debug('got async response from worker', { method, args }, this.#lock);
 
-    if (--this.#pendingAsyncMessageResponses === 0) {
+    if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
       // We got all the responses from the worker, its job is done (until next time).
       process.off('beforeExit', this.#beforeExitHandler);
     }
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 0408bec47f7d4b..1c236ca36d27ca 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -11,4 +11,5 @@ module.exports = {
   MAIN_THREAD_IS_BORED: 0b10,
 
   NUMBER_OF_INCOMING_MESSAGES: 2,
+  NUMBER_OF_INCOMING_ASYNC_RESPONSES: 3,
 };
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index de82afd8e188a0..fb35664ddc97c4 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -37,6 +37,7 @@ const { isMainThread, workerData, receiveMessageOnPort } = require('worker_threa
 const {
   BOREDOM_OF_THREADS,
   MAIN_THREAD_IS_BORED,
+  NUMBER_OF_INCOMING_ASYNC_RESPONSES,
   NUMBER_OF_INCOMING_MESSAGES,
   WORKER_THREAD_IS_BORED,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
@@ -107,7 +108,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
   releaseLock(); // Send 'ready' signal to main.
 
   let immediate;
-  let immediateCount = 0;
+  let pendingAsyncResponses = 0;
   function checkForMessages() {
     immediate = setImmediate(checkForMessages).unref();
     // We need to let the event loop tick a few times to give the main thread a
@@ -132,10 +133,16 @@ function errorHandler(err, origin = 'unhandledRejection') {
     AtomicsWait(lock, NUMBER_OF_INCOMING_MESSAGES, 0);
 
     AtomicsAnd(lock, BOREDOM_OF_THREADS, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
+
     // The pending messages won't come back at this point, we can reset the counter.
-    immediateCount = 0;
+    AtomicsSub(lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, pendingAsyncResponses);
+    pendingAsyncResponses = 0;
+
+    // Let's attach back the event handler.
     syncCommPort.on('message', handleMessage);
+    // Let's also check synchronously for a message, in case it's already there.
     checkForMessages();
+    // We don't need the sync check after this tick, as we already have added the event handler.
     clearImmediate(immediate);
   });
 
@@ -152,7 +159,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
       shouldRemoveGlobalErrorHandler = true;
     }
 
-    if (port != null && immediateCount++ === 0) {
+    if (port != null && pendingAsyncResponses++ === 0) {
       // We are about to yield the execution with the await ReflectApply below.
       // In case the code following the await never runs, we remove the message
       // handler so the `beforeExit` event can be triggered.
@@ -169,7 +176,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
       response = exception;
     }
 
-    if (port != null && --immediateCount === 0) {
+    if (port != null && --pendingAsyncResponses === 0) {
       // All the messages have been handled before the event loop died, we can go back to the initial setup.
       syncCommPort.on('message', handleMessage);
       clearImmediate(immediate);

From 281e943bfe6950f29899f4ca8607e62a1fb18e80 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 12 Feb 2023 23:18:37 +0100
Subject: [PATCH 084/126] remove unrelated/unnecessary changes in `test/`

---
 .../test-esm-import-meta-resolve.mjs          | 66 +++++++++----------
 test/es-module/test-esm-resolve-type.mjs      | 20 +++---
 .../loader-load-passthru.mjs                  | 11 ++--
 ...loader-load-receiving-modified-context.mjs |  4 +-
 .../es-module-loaders/loader-log-args.mjs     | 15 ++---
 .../es-module-loaders/loader-resolve-42.mjs   | 13 ++--
 .../es-module-loaders/loader-resolve-foo.mjs  | 11 ++--
 .../loader-resolve-incomplete.mjs             |  7 +-
 .../loader-resolve-passthru.mjs               | 11 ++--
 ...der-resolve-receiving-modified-context.mjs |  4 +-
 .../loader-resolve-strip-xxx.mjs              |  4 +-
 .../loader-resolve-strip-yyy.mjs              |  4 +-
 ...oader-this-value-inside-hook-functions.mjs |  6 +-
 13 files changed, 73 insertions(+), 103 deletions(-)

diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index a38abe1636bd89..41452b945e8421 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -1,42 +1,36 @@
 // Flags: --experimental-import-meta-resolve
-import '../common/index.mjs';
+import { mustCall } from '../common/index.mjs';
 import assert from 'assert';
 
 const dirname = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
 const fixtures = dirname.slice(0, dirname.lastIndexOf('/', dirname.length - 2) + 1) + 'fixtures/';
 
-assert.strictEqual(
-  import.meta.resolve('./test-esm-import-meta.mjs'),
-  dirname + 'test-esm-import-meta.mjs',
-);
-try {
-  import.meta.resolve('./notfound.mjs');
-  assert.fail();
-} catch (e) {
-  assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
-}
-assert.strictEqual(
-  import.meta.resolve('../fixtures/empty-with-bom.txt'),
-  fixtures + 'empty-with-bom.txt',
-);
-assert.strictEqual(
-  import.meta.resolve('../fixtures/'),
-  fixtures,
-);
-assert.strictEqual(
-  import.meta.resolve('../fixtures/', import.meta.url),
-  fixtures,
-);
-assert.strictEqual(
-  import.meta.resolve('../fixtures/', new URL(import.meta.url)),
-  fixtures,
-);
-[[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
-  assert.throws(() => {
-    import.meta.resolve('../fixtures/', arg);
-  }, { code: 'ERR_INVALID_ARG_TYPE' })
-);
-assert.strictEqual(
-  import.meta.resolve('baz/', fixtures),
-  fixtures + 'node_modules/baz/',
-);
+(async () => {
+  assert.strictEqual(await import.meta.resolve('./test-esm-import-meta.mjs'),
+                     dirname + 'test-esm-import-meta.mjs');
+  try {
+    await import.meta.resolve('./notfound.mjs');
+    assert.fail();
+  } catch (e) {
+    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
+  }
+  assert.strictEqual(
+    await import.meta.resolve('../fixtures/empty-with-bom.txt'),
+    fixtures + 'empty-with-bom.txt');
+  assert.strictEqual(await import.meta.resolve('../fixtures/'), fixtures);
+  assert.strictEqual(
+    await import.meta.resolve('../fixtures/', import.meta.url),
+    fixtures);
+  assert.strictEqual(
+    await import.meta.resolve('../fixtures/', new URL(import.meta.url)),
+    fixtures);
+  await Promise.all(
+    [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
+      assert.throws(() => import.meta.resolve('../fixtures/', arg), {
+        code: 'ERR_INVALID_ARG_TYPE',
+      })
+    )
+  );
+  assert.strictEqual(await import.meta.resolve('baz/', fixtures),
+                     fixtures + 'node_modules/baz/');
+})().then(mustCall());
diff --git a/test/es-module/test-esm-resolve-type.mjs b/test/es-module/test-esm-resolve-type.mjs
index 7a0527ff59e554..f594e56cf18510 100644
--- a/test/es-module/test-esm-resolve-type.mjs
+++ b/test/es-module/test-esm-resolve-type.mjs
@@ -37,16 +37,16 @@ try {
    * ensure that resolving by full path does not return the format
    * with the defaultResolver
    */
-  [
+  await Promise.all([
     [ '/es-modules/package-type-module/index.js', 'module' ],
     [ '/es-modules/package-type-commonjs/index.js', 'commonjs' ],
     [ '/es-modules/package-without-type/index.js', 'commonjs' ],
     [ '/es-modules/package-without-pjson/index.js', 'commonjs' ],
-  ].forEach(([ testScript, expectedType ]) => {
+  ].map(async ([ testScript, expectedType ]) => {
     const resolvedPath = path.resolve(fixtures.path(testScript));
-    const resolveResult = resolve(url.pathToFileURL(resolvedPath));
+    const resolveResult = await resolve(url.pathToFileURL(resolvedPath));
     assert.strictEqual(resolveResult.format, expectedType);
-  });
+  }));
 
   /**
    * create a test module and try to resolve it by module name.
@@ -85,7 +85,7 @@ try {
     fs.writeFileSync(script,
                      'export function esm-resolve-tester() {return 42}');
 
-    const resolveResult = resolve(`${moduleName}`);
+    const resolveResult = await resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedType);
 
     fs.rmSync(nmDir, { recursive: true, force: true });
@@ -168,14 +168,14 @@ try {
     );
 
     // test the resolve
-    const resolveResult = resolve(`${moduleName}`);
+    const resolveResult = await resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, 'module');
     assert.ok(resolveResult.url.includes('my-dual-package/es/index.js'));
   }
 
   // TestParameters are ModuleName, mainRequireScript, mainImportScript,
   // mainPackageType, subdirPkgJsonType, expectedResolvedFormat, mainSuffix
-  [
+  await Promise.all([
     [ 'mjs-mod-mod', 'index.js', 'index.mjs', 'module', 'module', 'module'],
     [ 'mjs-com-com', 'idx.js', 'idx.mjs', 'commonjs', 'commonjs', 'module'],
     [ 'mjs-mod-com', 'index.js', 'imp.mjs', 'module', 'commonjs', 'module'],
@@ -186,7 +186,7 @@ try {
     [ 'hmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '#Key'],
     [ 'qhmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '?k=v#h'],
     [ 'ts-mod-com', 'index.js', 'imp.ts', 'module', 'commonjs', undefined],
-  ].forEach((testVariant) => {
+  ].map(async (testVariant) => {
     const [
       moduleName,
       mainRequireScript,
@@ -234,10 +234,10 @@ try {
     );
 
     // test the resolve
-    const resolveResult = resolve(`${moduleName}`);
+    const resolveResult = await resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedFormat);
     assert.ok(resolveResult.url.endsWith(`${moduleName}/subdir/${mainImportScript}${mainSuffix}`));
-  });
+  }));
 
 } finally {
   process.chdir(previousCwd);
diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index da1e952b4b8eb7..1c2f2ea4487cdf 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -1,15 +1,12 @@
-import { writeSync } from 'node:fs';
-
 export async function load(url, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders, or `'node:fs'` that we
-  // use instead of `console.log`. It wouldn't be a problem
+  // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader') || url === 'node:fs') {
-    return next(url, context);
+  if (url.includes('loader')) {
+    return next(url);
   }
 
-  writeSync(1, 'load passthru\n'); // This log is deliberate
+  console.log('load passthru'); // This log is deliberate
   return next(url);
 }
diff --git a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
index df9d45782674ff..2d7bc350bd8775 100644
--- a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
@@ -1,6 +1,4 @@
-import { writeSync } from 'node:fs';
-
 export async function load(url, context, next) {
-  writeSync(1, `${context.foo}\n`); // This log is deliberate
+  console.log(context.foo); // This log is deliberate
   return next(url, context);
 }
diff --git a/test/fixtures/es-module-loaders/loader-log-args.mjs b/test/fixtures/es-module-loaders/loader-log-args.mjs
index e8c515669f03fe..84ed373d6b4de4 100644
--- a/test/fixtures/es-module-loaders/loader-log-args.mjs
+++ b/test/fixtures/es-module-loaders/loader-log-args.mjs
@@ -1,13 +1,10 @@
-import { writeSync } from 'node:fs';
-import { format } from 'node:util';
-
 export async function resolve(...args) {
-  writeSync(1, `resolve arg count: ${args.length}\n`);
-  writeSync(1, `${format({
+  console.log(`resolve arg count: ${args.length}`);
+  console.log({
     specifier: args[0],
     context: args[1],
     next: args[2],
-  })}\n`);
+  });
 
   return {
     shortCircuit: true,
@@ -16,12 +13,12 @@ export async function resolve(...args) {
 }
 
 export async function load(...args) {
-  writeSync(1, `load arg count: ${args.length}\n`);
-  writeSync(1, `${format({
+  console.log(`load arg count: ${args.length}`);
+  console.log({
     url: args[0],
     context: args[1],
     next: args[2],
-  })}\n`);
+  });
 
   return {
     format: 'module',
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index 616d3209f31149..05ef2f68390bd1 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -1,17 +1,14 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders, or `'node:fs'` that we
-  // use instead of `console.log`. It wouldn't be a problem
+  // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader') || specifier === 'node:fs') {
-    return next(specifier, context);
+  if (specifier.includes('loader')) {
+    return next(specifier);
   }
 
-  writeSync(1, 'resolve 42\n'); // This log is deliberate
-  writeSync(1, `next<HookName>: ${next.name}\n`); // This log is deliberate
+  console.log('resolve 42'); // This log is deliberate
+  console.log('next<HookName>:', next.name); // This log is deliberate
 
   return next('file:///42.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index 53856c6edc8698..09d30e952a2a92 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -1,15 +1,12 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders, or `'node:fs'` that we
-  // use instead of `console.log`. It wouldn't be a problem
+  // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader') || specifier === 'node:fs') {
-    return next(specifier, context);
+  if (specifier.includes('loader')) {
+    return next(specifier);
   }
 
-  writeSync(1, 'resolve foo\n'); // This log is deliberate
+  console.log('resolve foo'); // This log is deliberate
   return next('file:///foo.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
index 2fc4fd29f79f5d..d00b8fc50134e1 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
@@ -1,11 +1,10 @@
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders, or `'node:fs'` that we
-  // use instead of `console.log`. It wouldn't be a problem
+  // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader') || specifier === 'node:fs') {
-    return next(specifier, context);
+  if (specifier.includes('loader')) {
+    return next(specifier);
   }
 
   return {
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index 1ac7c86decc65c..d4845acc9f5f71 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -1,15 +1,12 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
-  // resolution from follow-up loaders, or `'node:fs'` that we
-  // use instead of `console.log`. It wouldn't be a problem
+  // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader') || specifier === 'node:fs') {
-    return next(specifier, context);
+  if (specifier.includes('loader')) {
+    return next(specifier);
   }
 
-  writeSync(1, 'resolve passthru\n'); // This log is deliberate
+  console.log('resolve passthru'); // This log is deliberate
   return next(specifier);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
index a50f12b7d5a874..83aa83104e96e4 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
@@ -1,6 +1,4 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, next) {
-  writeSync(1, `${context.foo}\n`); // This log is deliberate
+  console.log(context.foo); // This log is deliberate
   return next(specifier, context);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
index fe0928eebd202d..58d7a1107994fe 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
@@ -1,6 +1,4 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, nextResolve) {
-  writeSync(1, `loader-a ${specifier}\n`);
+  console.log(`loader-a`, {specifier});
   return nextResolve(specifier.replace(/^xxx\//, `./`));
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
index d1263c1fed076a..3615926143c4c7 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
@@ -1,6 +1,4 @@
-import { writeSync } from 'node:fs';
-
 export async function resolve(specifier, context, nextResolve) {
-  writeSync(1, `loader-b ${specifier}\n`);
+  console.log(`loader-b`, {specifier});
   return nextResolve(specifier.replace(/^yyy\//, `./`));
 }
diff --git a/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs b/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
index b4b1750508a402..c1c80622feea66 100644
--- a/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
+++ b/test/fixtures/es-module-loaders/loader-this-value-inside-hook-functions.mjs
@@ -1,14 +1,14 @@
 export function resolve(url, _, next) {
-  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
   return next(url);
 }
 
 export function load(url, _, next) {
-  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
   return next(url);
 }
 
 export function globalPreload() {
-  if (this != null) throw new Error('hook function must not be bound to ModuleLoader instance');
+  if (this != null) throw new Error('hook function must not be bound to ESMLoader instance');
   return "";
 }

From 3e31a1c87913b5068c457ab458f215545bd46f4d Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 12 Feb 2023 23:39:06 +0100
Subject: [PATCH 085/126] remove unrelated change in `src/`

---
 src/env-inl.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/env-inl.h b/src/env-inl.h
index f3192f19f551f6..7b135c7b83293a 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -636,7 +636,8 @@ inline bool Environment::owns_inspector() const {
 }
 
 inline bool Environment::should_create_inspector() const {
-  return (flags_ & EnvironmentFlags::kNoCreateInspector) == 0; // ! FIXME: do not merge
+  return (flags_ & EnvironmentFlags::kNoCreateInspector) == 0 &&
+         !options_->test_runner && !options_->watch_mode;
 }
 
 inline bool Environment::tracks_unmanaged_fds() const {

From 595a95f3e57196640e55e0c268ec1f661f3f077c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 12 Feb 2023 23:48:56 +0100
Subject: [PATCH 086/126] restore changes related to sync resolve

---
 test/es-module/test-esm-resolve-type.mjs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/test/es-module/test-esm-resolve-type.mjs b/test/es-module/test-esm-resolve-type.mjs
index f594e56cf18510..7a0527ff59e554 100644
--- a/test/es-module/test-esm-resolve-type.mjs
+++ b/test/es-module/test-esm-resolve-type.mjs
@@ -37,16 +37,16 @@ try {
    * ensure that resolving by full path does not return the format
    * with the defaultResolver
    */
-  await Promise.all([
+  [
     [ '/es-modules/package-type-module/index.js', 'module' ],
     [ '/es-modules/package-type-commonjs/index.js', 'commonjs' ],
     [ '/es-modules/package-without-type/index.js', 'commonjs' ],
     [ '/es-modules/package-without-pjson/index.js', 'commonjs' ],
-  ].map(async ([ testScript, expectedType ]) => {
+  ].forEach(([ testScript, expectedType ]) => {
     const resolvedPath = path.resolve(fixtures.path(testScript));
-    const resolveResult = await resolve(url.pathToFileURL(resolvedPath));
+    const resolveResult = resolve(url.pathToFileURL(resolvedPath));
     assert.strictEqual(resolveResult.format, expectedType);
-  }));
+  });
 
   /**
    * create a test module and try to resolve it by module name.
@@ -85,7 +85,7 @@ try {
     fs.writeFileSync(script,
                      'export function esm-resolve-tester() {return 42}');
 
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedType);
 
     fs.rmSync(nmDir, { recursive: true, force: true });
@@ -168,14 +168,14 @@ try {
     );
 
     // test the resolve
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, 'module');
     assert.ok(resolveResult.url.includes('my-dual-package/es/index.js'));
   }
 
   // TestParameters are ModuleName, mainRequireScript, mainImportScript,
   // mainPackageType, subdirPkgJsonType, expectedResolvedFormat, mainSuffix
-  await Promise.all([
+  [
     [ 'mjs-mod-mod', 'index.js', 'index.mjs', 'module', 'module', 'module'],
     [ 'mjs-com-com', 'idx.js', 'idx.mjs', 'commonjs', 'commonjs', 'module'],
     [ 'mjs-mod-com', 'index.js', 'imp.mjs', 'module', 'commonjs', 'module'],
@@ -186,7 +186,7 @@ try {
     [ 'hmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '#Key'],
     [ 'qhmod', 'index.js', 'imp.js', 'commonjs', 'module', 'module', '?k=v#h'],
     [ 'ts-mod-com', 'index.js', 'imp.ts', 'module', 'commonjs', undefined],
-  ].map(async (testVariant) => {
+  ].forEach((testVariant) => {
     const [
       moduleName,
       mainRequireScript,
@@ -234,10 +234,10 @@ try {
     );
 
     // test the resolve
-    const resolveResult = await resolve(`${moduleName}`);
+    const resolveResult = resolve(`${moduleName}`);
     assert.strictEqual(resolveResult.format, expectedResolvedFormat);
     assert.ok(resolveResult.url.endsWith(`${moduleName}/subdir/${mainImportScript}${mainSuffix}`));
-  }));
+  });
 
 } finally {
   process.chdir(previousCwd);

From 10bf7b8f765815584c9b636c75fcd54573eb2283 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 12 Feb 2023 23:49:35 +0100
Subject: [PATCH 087/126] Revert "unref worker more often"

This reverts commit 93d01bec634d45be09b504942fbbd336d4847897.
---
 lib/internal/modules/esm/hooks.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 1280215bbbb6e1..a9ed2ed8bc3e14 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -553,7 +553,6 @@ class HooksProxy {
       AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
       AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
-      this.worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
@@ -561,6 +560,7 @@ class HooksProxy {
 
     if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
       // We got all the responses from the worker, its job is done (until next time).
+      this.worker.unref();
       process.off('beforeExit', this.#beforeExitHandler);
     }
 

From 106b40008a9cb23b1e1752ea6cf4ea49121dd3e2 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 13 Feb 2023 00:38:48 +0100
Subject: [PATCH 088/126] nits

---
 lib/internal/modules/esm/hooks.js  | 24 ++++++++++++------------
 lib/internal/modules/esm/utils.js  |  2 +-
 lib/internal/modules/esm/worker.js | 13 ++++++-------
 3 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index a9ed2ed8bc3e14..511f080e3a0bcb 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -50,7 +50,8 @@ const {
 } = require('internal/validators');
 
 const {
-  defaultResolve, throwIfInvalidParentURL,
+  defaultResolve,
+  throwIfInvalidParentURL,
 } = require('internal/modules/esm/resolve');
 const {
   getDefaultConditions,
@@ -178,10 +179,9 @@ class Hooks {
       if (preloaded == null) { return; }
 
       if (typeof preloaded !== 'string') { // [2]
-        const hookErrIdentifier = `${specifier} globalPreload`;
         throw new ERR_INVALID_RETURN_VALUE(
           'a string',
-          hookErrIdentifier,
+          `${specifier} globalPreload`,
           preload,
         );
       }
@@ -250,12 +250,12 @@ class Hooks {
 
     const nextResolve = nextHookFactory(chain, meta, { validateArgs, validateOutput });
 
-    const result = await nextResolve(originalSpecifier, context);
+    const resolution = await nextResolve(originalSpecifier, context);
     const { hookErrIdentifier } = meta; // Retrieve the value after all settled
 
-    validateOutput(hookErrIdentifier, result);
+    validateOutput(hookErrIdentifier, resolution);
 
-    if (result?.shortCircuit === true) { meta.shortCircuited = true; }
+    if (resolution?.shortCircuit === true) { meta.shortCircuited = true; }
 
     if (!meta.chainFinished && !meta.shortCircuited) {
       throw new ERR_LOADER_CHAIN_INCOMPLETE(hookErrIdentifier);
@@ -265,7 +265,7 @@ class Hooks {
       format,
       importAssertions: resolvedImportAssertions,
       url,
-    } = result;
+    } = resolution;
 
     if (typeof url !== 'string') {
       // non-strings can be coerced to a URL string
@@ -386,12 +386,12 @@ class Hooks {
 
     const nextLoad = nextHookFactory(chain, meta, { validateArgs, validateOutput });
 
-    const result = await nextLoad(url, context);
+    const loaded = await nextLoad(url, context);
     const { hookErrIdentifier } = meta; // Retrieve the value after all settled
 
-    validateOutput(hookErrIdentifier, result);
+    validateOutput(hookErrIdentifier, loaded);
 
-    if (result?.shortCircuit === true) { meta.shortCircuited = true; }
+    if (loaded?.shortCircuit === true) { meta.shortCircuited = true; }
 
     if (!meta.chainFinished && !meta.shortCircuited) {
       throw new ERR_LOADER_CHAIN_INCOMPLETE(hookErrIdentifier);
@@ -400,8 +400,8 @@ class Hooks {
     const {
       format,
       source,
-    } = result;
-    let responseURL = result.responseURL;
+    } = loaded;
+    let responseURL = loaded.responseURL;
 
     if (responseURL === undefined) {
       responseURL = url;
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 104804c4d79419..c5e8c6e2aa0a3d 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -135,7 +135,7 @@ async function initializeHooks() {
     }
     load(url, context) { return hooks.load(url, context); }
   }
-  const privateModuleLoader = new ModuleLoader(false);
+  const privateModuleLoader = new ModuleLoader();
 
   const parentURL = pathToFileURL(cwd).href;
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index fb35664ddc97c4..35bd1e8b0f90f0 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -42,12 +42,11 @@ const {
   WORKER_THREAD_IS_BORED,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
+
 if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
 
-// lock = 0 -> main sleeps
-// lock = 1 -> worker sleeps
-const lock = new Int32Array(workerData.lock); // Required by Atomics
-const { syncCommPort } = workerData; // To receive work signals.
+const lock = new Int32Array(workerData.lock);
+const { syncCommPort } = workerData;
 
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
@@ -57,8 +56,8 @@ function transferArrayBuffer(hasError, source) {
 }
 
 function releaseLock() {
-  AtomicsStore(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1); // Send response to main
-  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION); // Notify main of new response
+  AtomicsStore(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
+  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 }
 
 function errorHandler(err, origin = 'unhandledRejection') {
@@ -134,7 +133,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
 
     AtomicsAnd(lock, BOREDOM_OF_THREADS, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
 
-    // The pending messages won't come back at this point, we can reset the counter.
+    // The pending messages won't come back at this point, we can reset the counters.
     AtomicsSub(lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, pendingAsyncResponses);
     pendingAsyncResponses = 0;
 

From cc9373a9ccd1ef7936f2adc8ac7f800c4a7a5895 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 13 Feb 2023 10:01:09 +0100
Subject: [PATCH 089/126] use `console.log` instead `fs.writeSync`

---
 test/fixtures/es-module-loaders/hooks-input.mjs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/fixtures/es-module-loaders/hooks-input.mjs b/test/fixtures/es-module-loaders/hooks-input.mjs
index 6b3777526e547a..dba540d2046c7d 100644
--- a/test/fixtures/es-module-loaders/hooks-input.mjs
+++ b/test/fixtures/es-module-loaders/hooks-input.mjs
@@ -2,7 +2,6 @@
 // node --loader ./test/fixtures/es-module-loaders/hooks-input.mjs ./test/fixtures/es-modules/json-modules.mjs
 
 import assert from 'assert';
-import { writeSync } from 'fs';
 import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 
@@ -43,7 +42,7 @@ export async function resolve(specifier, context, next) {
     shortCircuit: true,
   }
 
-  writeSync(1, `${JSON.stringify(returnValue)}\n`); // For the test to validate when it parses stdout
+  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
 
   return returnValue;
 }
@@ -80,7 +79,7 @@ export async function load(url, context, next) {
     shortCircuit: true,
   };
 
-  writeSync(1, `${JSON.stringify(returnValue)}\n`); // For the test to validate when it parses stdout
+  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
 
   return returnValue;
 }

From a67af11569514e7f914c9551f1038127d28c236c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 16 Feb 2023 02:17:57 +0100
Subject: [PATCH 090/126] fix lint

---
 lib/internal/modules/esm/loader.js | 2 +-
 lib/internal/modules/esm/utils.js  | 2 +-
 lib/internal/modules/esm/worker.js | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 6f46696b1a15f5..fff192f05258fa 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -373,7 +373,7 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
       },
       get linked() {
         return PromisePrototypeThen(jobPromise, (job) => job.linked);
-      }
+      },
     };
   }
 
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index c5e8c6e2aa0a3d..5589d5d0d6b42e 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -130,7 +130,7 @@ async function initializeHooks() {
         },
         get linked() {
           return PromisePrototypeThen(jobPromise, (job) => job.linked);
-        }
+        },
       };
     }
     load(url, context) { return hooks.load(url, context); }
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 35bd1e8b0f90f0..3427ddc330e466 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -69,7 +69,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
   }
   internalBinding('errors').triggerUncaughtException(
     err,
-    origin === 'unhandledRejection'
+    origin === 'unhandledRejection',
   );
 }
 
@@ -218,7 +218,7 @@ function wrapMessage(status, body) {
     body: {
       serialized,
       serializationFailed,
-    }
+    },
   };
 
 }

From aab57d7fb0bff60e2c6582d3a31e223a52bd4e98 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 18 Feb 2023 01:36:41 +0100
Subject: [PATCH 091/126] add comment to describe the shared memory
 organisation

---
 lib/internal/modules/esm/shared_constants.js | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 1c236ca36d27ca..626259bf76ab5a 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -3,6 +3,40 @@
 
 'use strict';
 
+/*
+The shared memory area is divided in 4 32-bit long sections. It has to be 32-bit
+long as `Atomics.notify` only works with `Int32Array` objects.
+
+--32-bits-- --32-bits-- --32-bits-- --32-bits--
+    ^           ^           ^           ^
+    |           |           |           |
+    |           |           | NUMBER_OF_INCOMING_ASYNC_RESPONSES
+    |           |           |
+    |           | NUMBER_OF_INCOMING_MESSAGES
+    |           |
+    |   BOREDOM_OF_THREADS
+    |
+WORKER_TO_MAIN_THREAD_NOTIFICATION
+
+WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value is never used.
+
+BOREDOM_OF_THREADS does not represent a number, but an array of booleans.
+Currently, only two flags are used: WORKER_THREAD_IS_BORED, and MAIN_THREAD_IS_BORED
+
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_BORED is false, and MAIN_THREAD_IS_BORED is false.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_BORED is true, and MAIN_THREAD_IS_BORED is false.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_BORED is false, and MAIN_THREAD_IS_BORED is true.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_BORED is true, and MAIN_THREAD_IS_BORED is true.
+
+NUMBER_OF_INCOMING_MESSAGES is used to communicate the number of messages sent
+by the main thread and not yet handled by the worker thread. It is also used to
+wake up the worker thread when it locks itself.
+
+NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to let the main thread keep count of
+how many async responses to expect.
+
+*/
+
 module.exports = {
   WORKER_TO_MAIN_THREAD_NOTIFICATION: 0,
 

From 638b4975d075170fea37d00d8fbcaa0a7b36a59d Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 18 Feb 2023 10:50:13 +0100
Subject: [PATCH 092/126] Remove unnecessary `Atomics.store` calls

---
 lib/internal/modules/esm/hooks.js            | 3 ---
 lib/internal/modules/esm/shared_constants.js | 2 +-
 lib/internal/modules/esm/worker.js           | 2 --
 3 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 511f080e3a0bcb..0701e5abd5704b 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -21,7 +21,6 @@ const {
     load: AtomicsLoad,
     notify: AtomicsNotify,
     or: AtomicsOr,
-    store: AtomicsStore,
     sub: AtomicsSub,
     wait: AtomicsWait,
     waitAsync: AtomicsWaitAsync,
@@ -550,7 +549,6 @@ class HooksProxy {
     let response;
     debug('start waiting for async response from worker', { method, args });
     while (response == null) {
-      AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
       AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
 
@@ -583,7 +581,6 @@ class HooksProxy {
     let response;
     debug('start waiting for sync response from worker', { method, args });
     while (response == null) {
-      AtomicsStore(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Reset lock.
       AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Sleep until worker responds.
 
       response = receiveMessageOnPort(this.#syncCommPort);
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 626259bf76ab5a..2ee3f84739c440 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -18,7 +18,7 @@ long as `Atomics.notify` only works with `Int32Array` objects.
     |
 WORKER_TO_MAIN_THREAD_NOTIFICATION
 
-WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value is never used.
+WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value should always be 0.
 
 BOREDOM_OF_THREADS does not represent a number, but an array of booleans.
 Currently, only two flags are used: WORKER_THREAD_IS_BORED, and MAIN_THREAD_IS_BORED
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 3427ddc330e466..890f8c8186e710 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -13,7 +13,6 @@ const {
       load: AtomicsLoad,
       notify: AtomicsNotify,
       or: AtomicsOr,
-      store: AtomicsStore,
       sub: AtomicsSub,
       wait: AtomicsWait,
     },
@@ -56,7 +55,6 @@ function transferArrayBuffer(hasError, source) {
 }
 
 function releaseLock() {
-  AtomicsStore(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
   AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 }
 

From e340d241ba61aac2119f5d183672525f7ffda350 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 18 Feb 2023 10:52:10 +0100
Subject: [PATCH 093/126] s/BORED/IDLE/

---
 lib/internal/modules/esm/hooks.js            | 14 +++++++-------
 lib/internal/modules/esm/shared_constants.js | 20 ++++++++++----------
 lib/internal/modules/esm/worker.js           | 12 ++++++------
 3 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 0701e5abd5704b..94484f22c49c86 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -57,11 +57,11 @@ const {
 } = require('internal/modules/esm/utils');
 const { deserializeError } = require('internal/error_serdes');
 const {
-  BOREDOM_OF_THREADS,
-  MAIN_THREAD_IS_BORED,
+  IDLENESS_OF_THREADS,
+  MAIN_THREAD_IS_IDLE,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES,
   NUMBER_OF_INCOMING_MESSAGES,
-  WORKER_THREAD_IS_BORED,
+  WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
@@ -516,9 +516,9 @@ class HooksProxy {
   }
 
   #beforeExitHandler = () => {
-    const value = AtomicsOr(this.#lock, BOREDOM_OF_THREADS, MAIN_THREAD_IS_BORED);
+    const value = AtomicsOr(this.#lock, IDLENESS_OF_THREADS, MAIN_THREAD_IS_IDLE);
     debug('beforeExit main thread', value, this.#lock);
-    if (value & WORKER_THREAD_IS_BORED && AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
+    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
       debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
       this.worker.terminate();
@@ -550,7 +550,7 @@ class HooksProxy {
     debug('start waiting for async response from worker', { method, args });
     while (response == null) {
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
-      AtomicsAnd(this.#lock, BOREDOM_OF_THREADS, ~MAIN_THREAD_IS_BORED); // We are no longer bored.
+      AtomicsAnd(this.#lock, IDLENESS_OF_THREADS, ~MAIN_THREAD_IS_IDLE); // We are no longer bored.
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
@@ -585,7 +585,7 @@ class HooksProxy {
 
       response = receiveMessageOnPort(this.#syncCommPort);
 
-      if (response == null && AtomicsLoad(this.#lock, BOREDOM_OF_THREADS) & WORKER_THREAD_IS_BORED) {
+      if (response == null && AtomicsLoad(this.#lock, IDLENESS_OF_THREADS) & WORKER_THREAD_IS_IDLE) {
         // TODO(aduh95): handle never-settling promises in sync responses.
       }
     }
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 2ee3f84739c440..3f2330c20f27ca 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -14,19 +14,19 @@ long as `Atomics.notify` only works with `Int32Array` objects.
     |           |           |
     |           | NUMBER_OF_INCOMING_MESSAGES
     |           |
-    |   BOREDOM_OF_THREADS
+    |  IDLENESS_OF_THREADS
     |
 WORKER_TO_MAIN_THREAD_NOTIFICATION
 
 WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value should always be 0.
 
-BOREDOM_OF_THREADS does not represent a number, but an array of booleans.
-Currently, only two flags are used: WORKER_THREAD_IS_BORED, and MAIN_THREAD_IS_BORED
+IDLENESS_OF_THREADS does not represent a number, but an array of booleans.
+Currently, only two flags are used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE
 
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_BORED is false, and MAIN_THREAD_IS_BORED is false.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_BORED is true, and MAIN_THREAD_IS_BORED is false.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_BORED is false, and MAIN_THREAD_IS_BORED is true.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_BORED is true, and MAIN_THREAD_IS_BORED is true.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is false.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is false.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is true.
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is true.
 
 NUMBER_OF_INCOMING_MESSAGES is used to communicate the number of messages sent
 by the main thread and not yet handled by the worker thread. It is also used to
@@ -40,9 +40,9 @@ how many async responses to expect.
 module.exports = {
   WORKER_TO_MAIN_THREAD_NOTIFICATION: 0,
 
-  BOREDOM_OF_THREADS: 1,
-  WORKER_THREAD_IS_BORED: 0b01,
-  MAIN_THREAD_IS_BORED: 0b10,
+  IDLENESS_OF_THREADS: 1,
+  WORKER_THREAD_IS_IDLE: 0b01,
+  MAIN_THREAD_IS_IDLE: 0b10,
 
   NUMBER_OF_INCOMING_MESSAGES: 2,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES: 3,
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 890f8c8186e710..c54b8a0db0071e 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -34,11 +34,11 @@ internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
 const { isMainThread, workerData, receiveMessageOnPort } = require('worker_threads');
 const {
-  BOREDOM_OF_THREADS,
-  MAIN_THREAD_IS_BORED,
+  IDLENESS_OF_THREADS,
+  MAIN_THREAD_IS_IDLE,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES,
   NUMBER_OF_INCOMING_MESSAGES,
-  WORKER_THREAD_IS_BORED,
+  WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
 
@@ -118,9 +118,9 @@ function errorHandler(err, origin = 'unhandledRejection') {
   }
 
   process.on('beforeExit', () => {
-    const value = AtomicsOr(lock, BOREDOM_OF_THREADS, WORKER_THREAD_IS_BORED);
+    const value = AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
 
-    if (value & MAIN_THREAD_IS_BORED && AtomicsLoad(lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
+    if (value & MAIN_THREAD_IS_IDLE && AtomicsLoad(lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
       // Main thread is also out of work, there's nothing left to do.
       return;
     }
@@ -129,7 +129,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
     // Let's pause the worker thread until a new message comes in.
     AtomicsWait(lock, NUMBER_OF_INCOMING_MESSAGES, 0);
 
-    AtomicsAnd(lock, BOREDOM_OF_THREADS, ~WORKER_THREAD_IS_BORED); // We are no longer bored.
+    AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
 
     // The pending messages won't come back at this point, we can reset the counters.
     AtomicsSub(lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, pendingAsyncResponses);

From 018ab18e606781e7f06b3b8b8918d31170d2961c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 18 Feb 2023 10:57:41 +0100
Subject: [PATCH 094/126] add `SHARED_MEMORY_BYTE_LENGTH` to shared_constants

---
 lib/internal/modules/esm/hooks.js            | 3 ++-
 lib/internal/modules/esm/shared_constants.js | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 94484f22c49c86..63afb403d03ec1 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -61,6 +61,7 @@ const {
   MAIN_THREAD_IS_IDLE,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES,
   NUMBER_OF_INCOMING_MESSAGES,
+  SHARED_MEMORY_BYTE_LENGTH,
   WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
@@ -481,7 +482,7 @@ class HooksProxy {
     const { InternalWorker } = require('internal/worker');
     MessageChannel ??= require('internal/worker/io').MessageChannel;
 
-    const lock = new SharedArrayBuffer(4 * 4);
+    const lock = new SharedArrayBuffer(SHARED_MEMORY_BYTE_LENGTH);
     this.#lock = new Int32Array(lock);
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 3f2330c20f27ca..dacd83fa3296c2 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -46,4 +46,6 @@ module.exports = {
 
   NUMBER_OF_INCOMING_MESSAGES: 2,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES: 3,
+
+  SHARED_MEMORY_BYTE_LENGTH: 4 * 4,
 };

From 80cd74cb5d9ee5d7d775a837d771b5adb6b9828f Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 18 Feb 2023 11:09:09 +0100
Subject: [PATCH 095/126] add definition for idleness

---
 lib/internal/modules/esm/shared_constants.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index dacd83fa3296c2..7dd3628e77195d 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -21,7 +21,11 @@ WORKER_TO_MAIN_THREAD_NOTIFICATION
 WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value should always be 0.
 
 IDLENESS_OF_THREADS does not represent a number, but an array of booleans.
-Currently, only two flags are used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE
+Currently, two flags are used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE.
+For our use case, a thread is considered IDLE if it has nothing left on its
+event loop and is waiting for the other thread to either terminate the process
+or send it more work.
+If we represent this memory area as a binary number, here's how to interpret its value:
 
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is false.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is false.

From 817d0e880cfebfc5ea32748c975a4d03e622c7bc Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 1 Mar 2023 18:30:16 +0100
Subject: [PATCH 096/126] Update doc/api/esm.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Michaël Zasso <targos@protonmail.com>
---
 doc/api/esm.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 4ab0a4c392c49d..d43907bbc2efc8 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -9,7 +9,7 @@ added: v8.5.0
 changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/44710
-    description: User hooks are executed off the main thread.
+    description: Loader hooks are executed off the main thread.
   - version:
     - v18.6.0
     - v16.17.0

From 0590df4519017e6211701079f9a3740d2462be7a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 6 Mar 2023 10:33:05 +0100
Subject: [PATCH 097/126] Update lib/internal/modules/esm/shared_constants.js

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 lib/internal/modules/esm/shared_constants.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 7dd3628e77195d..d6713d27c6f15a 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -36,8 +36,8 @@ NUMBER_OF_INCOMING_MESSAGES is used to communicate the number of messages sent
 by the main thread and not yet handled by the worker thread. It is also used to
 wake up the worker thread when it locks itself.
 
-NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to let the main thread keep count of
-how many async responses to expect.
+NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to track how many async responses
+the main thread should expect.
 
 */
 

From cee03fabbd4803d3ec1628ddc4e426c3098bf6c8 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 6 Mar 2023 11:12:43 +0100
Subject: [PATCH 098/126] add/fix comments + nits

---
 lib/internal/modules/esm/hooks.js  | 17 +++++++++++++----
 lib/internal/modules/esm/loader.js |  4 ++--
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 63afb403d03ec1..bb7da2625dec7c 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -465,10 +465,8 @@ ObjectSetPrototypeOf(Hooks.prototype, null);
 let MessageChannel;
 class HooksProxy {
   /**
-   * The lock/unlock segment of the shared memory. Atomics require this to be a Int32Array. This
-   * segment is used to tell the main to sleep when the worker is processing.
-   * 0 -> main sleeps
-   * 1 -> main wakes up
+   * Shared memory. Always use Atomics method to read or write to it.
+   * @type {Int32Array}
    */
   #lock;
   /**
@@ -544,6 +542,17 @@ class HooksProxy {
     AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
 
     if (AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) === 0) {
+      // On the next lines, the main thread will await a response from the
+      // worker thread that might come after the last task in the event
+      // loop has run its course and there would be nothing left keeping the
+      // thread alive (and once the main thread dies, the whole process stops).
+      // However we want to keep the process alive until the worker thread
+      // responds (or until the event loop of the worker thread is also empty).
+      // So we add the beforeExit handler whose mission is to lock the main
+      // thread until we hear back from the worker thread.
+      // The if condition is there so we only add the event handler once (if
+      // there are already pending async responses, the previous calls have
+      // added the event listener).
       process.on('beforeExit', this.#beforeExitHandler);
     }
 
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index fff192f05258fa..63ce8d98c80fb0 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -398,7 +398,7 @@ let emittedExperimentalWarning = false;
  * only one used for loading the main module and everything in its dependency graph, though separate instances of this
  * class might be instantiated as part of bootstrap for other purposes.
  * @param {boolean} useCustomLoadersIfPresent If the user has provided loaders via the --loader flag, use them.
- * @returns {instanceof BaseModuleLoader | instanceof CustomizedModuleLoader}
+ * @returns {DefaultModuleLoader | CustomizedModuleLoader}
  */
 function createModuleLoader(useCustomLoadersIfPresent = true) {
   if (useCustomLoadersIfPresent) {
@@ -408,7 +408,7 @@ function createModuleLoader(useCustomLoadersIfPresent = true) {
         emitExperimentalWarning('Custom ESM Loaders');
         emittedExperimentalWarning = true;
       }
-      return new CustomizedModuleLoader(userLoaderPaths);
+      return new CustomizedModuleLoader();
     }
   }
 

From 258cf8a8514c625a6a1a41ccc76af9b4be28a0e1 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 6 Mar 2023 11:15:16 +0100
Subject: [PATCH 099/126] for..of -> classic for

---
 lib/internal/modules/esm/hooks.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index bb7da2625dec7c..31d28b6345fa5f 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -618,7 +618,8 @@ class HooksProxy {
   }
 
   #executePreloadScripts(preloadScripts) {
-    for (const { code, port } of preloadScripts) {
+    for (let i = 0; i < preloadScripts.length; i++) {
+      const { code, port } = preloadScripts[i];
       const { compileFunction } = require('vm');
       const preloadInit = compileFunction(
         code,

From 8863cb9a6c5479cbac9e2602a8c59f1fb27138d3 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 8 Mar 2023 22:36:33 +0100
Subject: [PATCH 100/126] 
 s/NUMBER_OF_INCOMING_MESSAGES/NUMBER_OF_MESSAGES_IN_TRANSIT/

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 lib/internal/modules/esm/hooks.js            | 12 ++++++------
 lib/internal/modules/esm/shared_constants.js | 10 +++++-----
 lib/internal/modules/esm/worker.js           |  8 ++++----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 31d28b6345fa5f..64500cf29a6e8c 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -60,7 +60,7 @@ const {
   IDLENESS_OF_THREADS,
   MAIN_THREAD_IS_IDLE,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES,
-  NUMBER_OF_INCOMING_MESSAGES,
+  NUMBER_OF_MESSAGES_IN_TRANSIT,
   SHARED_MEMORY_BYTE_LENGTH,
   WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
@@ -517,7 +517,7 @@ class HooksProxy {
   #beforeExitHandler = () => {
     const value = AtomicsOr(this.#lock, IDLENESS_OF_THREADS, MAIN_THREAD_IS_IDLE);
     debug('beforeExit main thread', value, this.#lock);
-    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
+    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
       debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
       this.worker.terminate();
@@ -529,7 +529,7 @@ class HooksProxy {
   };
 
   async makeAsyncRequest(method, ...args) {
-    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
+    AtomicsAdd(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
     this.#waitForWorker();
 
     MessageChannel ??= require('internal/worker/io').MessageChannel;
@@ -539,7 +539,7 @@ class HooksProxy {
     debug('post async message to worker', { method, args });
     this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
+    AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
 
     if (AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) === 0) {
       // On the next lines, the main thread will await a response from the
@@ -578,7 +578,7 @@ class HooksProxy {
   }
 
   makeSyncRequest(method, ...args) {
-    AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_MESSAGES, 1);
+    AtomicsAdd(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
     this.#waitForWorker();
 
     // Pass work to the worker.
@@ -586,7 +586,7 @@ class HooksProxy {
     this.#syncCommPort.postMessage({ method, args });
 
     // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsNotify(this.#lock, NUMBER_OF_INCOMING_MESSAGES);
+    AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
 
     let response;
     debug('start waiting for sync response from worker', { method, args });
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index d6713d27c6f15a..00533b3f8fca3d 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -12,7 +12,7 @@ long as `Atomics.notify` only works with `Int32Array` objects.
     |           |           |           |
     |           |           | NUMBER_OF_INCOMING_ASYNC_RESPONSES
     |           |           |
-    |           | NUMBER_OF_INCOMING_MESSAGES
+    |           | NUMBER_OF_MESSAGES_IN_TRANSIT
     |           |
     |  IDLENESS_OF_THREADS
     |
@@ -32,9 +32,9 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is true.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is true.
 
-NUMBER_OF_INCOMING_MESSAGES is used to communicate the number of messages sent
-by the main thread and not yet handled by the worker thread. It is also used to
-wake up the worker thread when it locks itself.
+NUMBER_OF_MESSAGES_IN_TRANSIT is used to communicate the number of messages
+sent by the main thread and not yet acknowledged by the worker thread. It is
+also used to wake up the worker thread when it locks itself.
 
 NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to track how many async responses
 the main thread should expect.
@@ -48,7 +48,7 @@ module.exports = {
   WORKER_THREAD_IS_IDLE: 0b01,
   MAIN_THREAD_IS_IDLE: 0b10,
 
-  NUMBER_OF_INCOMING_MESSAGES: 2,
+  NUMBER_OF_MESSAGES_IN_TRANSIT: 2,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES: 3,
 
   SHARED_MEMORY_BYTE_LENGTH: 4 * 4,
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index c54b8a0db0071e..965b7f83a9564c 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -37,7 +37,7 @@ const {
   IDLENESS_OF_THREADS,
   MAIN_THREAD_IS_IDLE,
   NUMBER_OF_INCOMING_ASYNC_RESPONSES,
-  NUMBER_OF_INCOMING_MESSAGES,
+  NUMBER_OF_MESSAGES_IN_TRANSIT,
   WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
@@ -120,14 +120,14 @@ function errorHandler(err, origin = 'unhandledRejection') {
   process.on('beforeExit', () => {
     const value = AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
 
-    if (value & MAIN_THREAD_IS_IDLE && AtomicsLoad(lock, NUMBER_OF_INCOMING_MESSAGES) === 0) {
+    if (value & MAIN_THREAD_IS_IDLE && AtomicsLoad(lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
       // Main thread is also out of work, there's nothing left to do.
       return;
     }
 
     releaseLock(); // In case the main thread was waiting for a sync response.
     // Let's pause the worker thread until a new message comes in.
-    AtomicsWait(lock, NUMBER_OF_INCOMING_MESSAGES, 0);
+    AtomicsWait(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 0);
 
     AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
 
@@ -144,7 +144,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
   });
 
   async function handleMessage({ method, args, port }) {
-    AtomicsSub(lock, NUMBER_OF_INCOMING_MESSAGES, 1);
+    AtomicsSub(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
 
     // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
     let hasError = false;

From 13f3d8d139615563fef64ead255f07ef057f15a7 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Thu, 9 Mar 2023 03:36:49 -0500
Subject: [PATCH 101/126] add explanation for how `process.cwd()` can fail

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/modules/esm/utils.js  | 1 +
 lib/internal/process/esm_loader.js | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index 5589d5d0d6b42e..ed87dc1d451d4c 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -104,6 +104,7 @@ async function initializeHooks() {
 
   let cwd;
   try {
+    // `process.cwd()` can fail if the parent directory is deleted while the process runs.
     cwd = process.cwd() + '/';
   } catch {
     cwd = '/';
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index d64d35f4f10e85..e7d70ebbca1ca4 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -21,6 +21,7 @@ module.exports = {
       if (userImports.length > 0) {
         let cwd;
         try {
+          // `process.cwd()` can fail if the parent directory is deleted while the process runs.
           cwd = process.cwd() + '/';
         } catch {
           cwd = '/';

From 473136298496e203c0fbf1b4449c36ab49bbeae8 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 9 Mar 2023 14:02:25 +0100
Subject: [PATCH 102/126] Apply suggestions from code review

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 lib/internal/modules/esm/resolve.js | 3 +++
 lib/internal/modules/esm/worker.js  | 8 ++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index 249c550cc93b91..0dc7a9ae1d6690 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -936,6 +936,9 @@ function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
   }
 }
 
+/**
+ * Validate user-input in `context` supplied by a custom loader.
+ */
 function throwIfInvalidParentURL(parentURL) {
   if (parentURL === undefined) {
     return; // Main entry point, so no parent
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 965b7f83a9564c..62a77fc7f65875 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -126,12 +126,12 @@ function errorHandler(err, origin = 'unhandledRejection') {
     }
 
     releaseLock(); // In case the main thread was waiting for a sync response.
-    // Let's pause the worker thread until a new message comes in.
+    // Pause the worker thread until a new message comes in.
     AtomicsWait(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 0);
 
     AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
 
-    // The pending messages won't come back at this point, we can reset the counters.
+    // The pending messages won't come back at this point, so we can reset the counters.
     AtomicsSub(lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, pendingAsyncResponses);
     pendingAsyncResponses = 0;
 
@@ -157,8 +157,8 @@ function errorHandler(err, origin = 'unhandledRejection') {
     }
 
     if (port != null && pendingAsyncResponses++ === 0) {
-      // We are about to yield the execution with the await ReflectApply below.
-      // In case the code following the await never runs, we remove the message
+      // We are about to yield the execution with `await ReflectApply` below.
+      // In case the code following the `await` never runs, we remove the message
       // handler so the `beforeExit` event can be triggered.
       syncCommPort.off('message', handleMessage);
       // We keep checking for new messages to not miss any.

From 12717f7be907a773a3266e9f9e7bdd3cd2ab66f1 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 9 Mar 2023 14:33:56 +0100
Subject: [PATCH 103/126] fix worker permissions for internal workers

---
 lib/internal/worker.js |  1 +
 src/node_worker.cc     | 12 ++++++++----
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index a78795e08011ed..5ea21cd6d03084 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -212,6 +212,7 @@ class Worker extends EventEmitter {
                                    options.execArgv,
                                    parseResourceLimits(options.resourceLimits),
                                    !!(options.trackUnmanagedFds ?? true),
+                                   isInternal,
                                    name);
     if (this[kHandle].invalidExecArgv) {
       throw new ERR_WORKER_INVALID_EXEC_ARGV(this[kHandle].invalidExecArgv);
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 5aa8a06b9cfbea..7be78dcdb93d1d 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -459,8 +459,12 @@ Worker::~Worker() {
 
 void Worker::New(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  THROW_IF_INSUFFICIENT_PERMISSIONS(
-      env, permission::PermissionScope::kWorkerThreads, "");
+  auto is_internal = args[5];
+  CHECK(is_internal->IsBoolean());
+  if (is_internal->IsFalse()) {
+    THROW_IF_INSUFFICIENT_PERMISSIONS(
+        env, permission::PermissionScope::kWorkerThreads, "");
+  }
   Isolate* isolate = args.GetIsolate();
 
   CHECK(args.IsConstructCall());
@@ -484,9 +488,9 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
     url.append(value.out(), value.length());
   }
 
-  if (!args[5]->IsNullOrUndefined()) {
+  if (!args[6]->IsNullOrUndefined()) {
     Utf8Value value(
-        isolate, args[5]->ToString(env->context()).FromMaybe(Local<String>()));
+        isolate, args[6]->ToString(env->context()).FromMaybe(Local<String>()));
     name.append(value.out(), value.length());
   }
 

From 61ad2a51920411ca0305690b09d1ac432fe55903 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 9 Mar 2023 15:15:00 +0100
Subject: [PATCH 104/126] fix dead lock

---
 lib/internal/modules/esm/hooks.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 64500cf29a6e8c..d0d1364bb90575 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -566,9 +566,9 @@ class HooksProxy {
     }
     debug('got async response from worker', { method, args }, this.#lock);
 
+    this.worker.unref(); // We unref the worker here so the beforeExit handler can be called.
     if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
       // We got all the responses from the worker, its job is done (until next time).
-      this.worker.unref();
       process.off('beforeExit', this.#beforeExitHandler);
     }
 

From fa29a703ccb777f70e6df7b8d3c9ad1d9840cc58 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 9 Mar 2023 21:45:38 +0100
Subject: [PATCH 105/126] Apply suggestions from code review

Co-authored-by: Jordan Harband <ljharb@gmail.com>
---
 lib/internal/modules/esm/hooks.js                  |  6 ++----
 lib/internal/modules/esm/initialize_import_meta.js |  2 +-
 lib/internal/modules/esm/loader.js                 | 10 ++++++----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index d0d1364bb90575..c8c70ebf0953f6 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -186,7 +186,7 @@ class Hooks {
         );
       }
 
-      preloadScripts.push({
+      ArrayPrototypePush(preloadScripts, {
         code: preloaded,
         port: insidePreload,
       });
@@ -610,8 +610,7 @@ class HooksProxy {
         throw ERR_WORKER_UNSERIALIZABLE_ERROR();
       }
 
-      const error = deserializeError(response.message.body.serialized);
-      throw error;
+      throw deserializeError(response.message.body.serialized);
     } else {
       return response.message.body;
     }
@@ -651,7 +650,6 @@ class HooksProxy {
 }
 ObjectSetPrototypeOf(HooksProxy.prototype, null);
 
-
 /**
  * A utility function to pluck the hooks from a user-defined loader.
  * @param {import('./loader.js).ModuleExports} exports
diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index d0bf7a324cb6aa..adaf0fe52a0f61 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -16,7 +16,7 @@ function createImportMetaResolve(defaultParentUrl, loader) {
     try {
       ({ url } = loader.resolve(specifier, parentUrl));
     } catch (error) {
-      if (error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
+      if (error?.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
         ({ url } = error);
       } else {
         throw error;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 63ce8d98c80fb0..0c704e9286f4bd 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -254,10 +254,12 @@ class DefaultModuleLoader {
     const jobs = new Array(count);
 
     for (let i = 0; i < count; i++) {
-      jobs[i] = this
-        .getModuleJob(specifiers[i], parentURL, importAssertions)
-        .run()
-        .then(({ module }) => module.getNamespace());
+      jobs[i] = PromisePrototypeThen(
+        this
+          .getModuleJob(specifiers[i], parentURL, importAssertions)
+          .run(),
+        ({ module }) => module.getNamespace()
+      );
     }
 
     const namespaces = await SafePromiseAllReturnArrayLike(jobs);

From 159ca6fbeb995819d10277180520f10b403ae16a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 9 Mar 2023 21:54:43 +0100
Subject: [PATCH 106/126] Apply suggestions from code review

---
 lib/internal/modules/esm/hooks.js  | 1 +
 lib/internal/modules/esm/loader.js | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index c8c70ebf0953f6..8cdb35da3822d4 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -610,6 +610,7 @@ class HooksProxy {
         throw ERR_WORKER_UNSERIALIZABLE_ERROR();
       }
 
+      // eslint-disable-next-line no-restricted-syntax
       throw deserializeError(response.message.body.serialized);
     } else {
       return response.message.body;
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 0c704e9286f4bd..3ed430bfb02a24 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -258,7 +258,7 @@ class DefaultModuleLoader {
         this
           .getModuleJob(specifiers[i], parentURL, importAssertions)
           .run(),
-        ({ module }) => module.getNamespace()
+        ({ module }) => module.getNamespace(),
       );
     }
 

From b4a8a2f0c685e4bab24139fbce1c54e373db0012 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Mar 2023 11:44:43 +0100
Subject: [PATCH 107/126] `git mv lib/internal/modules/esm/worker.js
 lib/internal/main/loader_thread.js`

---
 lib/internal/{modules/esm/worker.js => main/loader_thread.js} | 4 +---
 lib/internal/modules/esm/hooks.js                             | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)
 rename lib/internal/{modules/esm/worker.js => main/loader_thread.js} (97%)

diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/main/loader_thread.js
similarity index 97%
rename from lib/internal/modules/esm/worker.js
rename to lib/internal/main/loader_thread.js
index 62a77fc7f65875..2f31091085f3c8 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/main/loader_thread.js
@@ -32,7 +32,7 @@ const {
 // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
 internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
-const { isMainThread, workerData, receiveMessageOnPort } = require('worker_threads');
+const { workerData, receiveMessageOnPort } = require('worker_threads');
 const {
   IDLENESS_OF_THREADS,
   MAIN_THREAD_IS_IDLE,
@@ -42,8 +42,6 @@ const {
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
 
-if (isMainThread) { return; } // Needed to pass some tests that happen to load this file on the main thread
-
 const lock = new Int32Array(workerData.lock);
 const { syncCommPort } = workerData;
 
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 8cdb35da3822d4..85d595c1d5dd89 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -485,7 +485,7 @@ class HooksProxy {
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
 
-    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
+    const worker = this.worker = new InternalWorker('internal/main/loader_thread', {
       stderr: false,
       stdin: false,
       stdout: false,

From 6177afa9c8e5d26aba1e84365862e10514aedc37 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Mar 2023 11:46:19 +0100
Subject: [PATCH 108/126] add comment

---
 lib/internal/main/loader_thread.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/internal/main/loader_thread.js b/lib/internal/main/loader_thread.js
index 2f31091085f3c8..ea50902d526c17 100644
--- a/lib/internal/main/loader_thread.js
+++ b/lib/internal/main/loader_thread.js
@@ -192,7 +192,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
       process.off('uncaughtException', errorHandler);
     }
   }
-})().catch(errorHandler);
+})().catch(errorHandler); // This is executed before any user code on that thread, prototype pollution is not a concern.
 
 function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {

From a85288dcc65842b49ef3e9d0998c0a4ac8a38272 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Mar 2023 13:36:03 +0100
Subject: [PATCH 109/126] revert `git mv lib/internal/modules/esm/worker.js
 lib/internal/main/loader_thread.js`

---
 lib/internal/main/worker_thread.js            |  13 ++-
 lib/internal/modules/esm/hooks.js             |   2 +-
 .../esm/worker.js}                            | 106 +++++++++---------
 3 files changed, 60 insertions(+), 61 deletions(-)
 rename lib/internal/{main/loader_thread.js => modules/esm/worker.js} (83%)

diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 4797e9760148fa..6941bd79afa7a5 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -10,6 +10,7 @@ const {
   ObjectDefineProperty,
   PromisePrototypeThen,
   RegExpPrototypeExec,
+  SafeWeakMap,
   globalThis: {
     Atomics,
     SharedArrayBuffer,
@@ -103,9 +104,11 @@ port.on('message', (message) => {
       ArrayPrototypePushApply(process.argv, argv);
     }
 
-    const publicWorker = require('worker_threads');
-    publicWorker.parentPort = publicPort;
-    publicWorker.workerData = workerData;
+    if (doEval !== 'internal') {
+      const publicWorker = require('worker_threads');
+      publicWorker.parentPort = publicPort;
+      publicWorker.workerData = workerData;
+    }
 
     require('internal/worker').assignEnvironmentData(environmentData);
 
@@ -140,7 +143,9 @@ port.on('message', (message) => {
     port.postMessage({ type: UP_AND_RUNNING });
     switch (doEval) {
       case 'internal': {
-        require(filename);
+        // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
+        internalBinding('module_wrap').callbackMap = new SafeWeakMap();
+        require(filename)(workerData, publicPort);
         break;
       }
 
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 85d595c1d5dd89..8cdb35da3822d4 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -485,7 +485,7 @@ class HooksProxy {
     const syncCommChannel = new MessageChannel();
     this.#syncCommPort = syncCommChannel.port1;
 
-    const worker = this.worker = new InternalWorker('internal/main/loader_thread', {
+    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
       stdin: false,
       stdout: false,
diff --git a/lib/internal/main/loader_thread.js b/lib/internal/modules/esm/worker.js
similarity index 83%
rename from lib/internal/main/loader_thread.js
rename to lib/internal/modules/esm/worker.js
index ea50902d526c17..f033d210030d8e 100644
--- a/lib/internal/main/loader_thread.js
+++ b/lib/internal/modules/esm/worker.js
@@ -5,7 +5,6 @@ const {
   Int32Array,
   PromisePrototypeThen,
   ReflectApply,
-  SafeWeakMap,
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
@@ -29,10 +28,7 @@ const {
   isTypedArray,
 } = require('util/types');
 
-// Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
-internalBinding('module_wrap').callbackMap = new SafeWeakMap();
-
-const { workerData, receiveMessageOnPort } = require('worker_threads');
+const { receiveMessageOnPort } = require('internal/worker/io');
 const {
   IDLENESS_OF_THREADS,
   MAIN_THREAD_IS_IDLE,
@@ -41,9 +37,7 @@ const {
   WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
-
-const lock = new Int32Array(workerData.lock);
-const { syncCommPort } = workerData;
+const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
 
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
@@ -52,32 +46,33 @@ function transferArrayBuffer(hasError, source) {
   if (isDataView(source)) return [DataViewPrototypeGetBuffer(source)];
 }
 
-function releaseLock() {
-  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
-}
-
-function errorHandler(err, origin = 'unhandledRejection') {
-  releaseLock();
-  process.off('uncaughtException', errorHandler);
-  if (hasUncaughtExceptionCaptureCallback()) {
-    process._fatalException(err);
-    return;
+function wrapMessage(status, body) {
+  if (status === 'success' || body === null || typeof body !== 'object') {
+    return { status, body };
+  }
+  if (body == null) {
+    return { status, body };
+  }
+  let serialized;
+  let serializationFailed;
+  try {
+    const { serializeError } = require('internal/error_serdes');
+    serialized = serializeError(body);
+  } catch {
+    serializationFailed = true;
   }
-  internalBinding('errors').triggerUncaughtException(
-    err,
-    origin === 'unhandledRejection',
-  );
+  return {
+    status,
+    body: {
+      serialized,
+      serializationFailed,
+    },
+  };
 }
 
-/**
- * ! Run everything possible within this function so errors get reported.
- */
-(async function customizedModuleWorker() {
-  const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
-  let hooks;
-  let preloadScripts;
+async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
+  let hooks, preloadScripts, initializationError;
   let hasInitializationError = false;
-  let initializationError;
 
   try {
     initializeESM();
@@ -100,7 +95,7 @@ function errorHandler(err, origin = 'unhandledRejection') {
     syncCommPort.postMessage(wrapMessage('success', { preloadScripts }), preloadScripts.map(({ port }) => port));
   }
 
-  releaseLock(); // Send 'ready' signal to main.
+  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION); // Unlock the main thread now that we are ready.
 
   let immediate;
   let pendingAsyncResponses = 0;
@@ -123,7 +118,8 @@ function errorHandler(err, origin = 'unhandledRejection') {
       return;
     }
 
-    releaseLock(); // In case the main thread was waiting for a sync response.
+    // In case the main thread was waiting for a sync response.
+    AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     // Pause the worker thread until a new message comes in.
     AtomicsWait(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 0);
 
@@ -187,34 +183,32 @@ function errorHandler(err, origin = 'unhandledRejection') {
       // Or send the exception thrown when trying to send the response.
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
-    releaseLock();
+    AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
     }
   }
-})().catch(errorHandler); // This is executed before any user code on that thread, prototype pollution is not a concern.
+}
 
-function wrapMessage(status, body) {
-  if (status === 'success' || body === null || typeof body !== 'object') {
-    return { status, body };
-  }
-  if (body == null) {
-    return { status, body };
-  }
-  let serialized;
-  let serializationFailed;
-  try {
-    const { serializeError } = require('internal/error_serdes');
-    serialized = serializeError(body);
-  } catch {
-    serializationFailed = true;
+/**
+ * ! Run everything possible within this function so errors get reported.
+ */
+module.exports = function(workerData) {
+  const lock = new Int32Array(workerData.lock);
+  const { syncCommPort } = workerData;
+
+  function errorHandler(err, origin = 'unhandledRejection') {
+    AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
+    process.off('uncaughtException', errorHandler);
+    if (hasUncaughtExceptionCaptureCallback()) {
+      process._fatalException(err);
+      return;
+    }
+    internalBinding('errors').triggerUncaughtException(
+      err,
+      origin === 'unhandledRejection',
+    );
   }
-  return {
-    status,
-    body: {
-      serialized,
-      serializationFailed,
-    },
-  };
 
-}
+  return PromisePrototypeThen(customizedModuleWorker(lock, syncCommPort, errorHandler), undefined, errorHandler);
+};

From be8090ef88196a317f1b2eef7e092da6ec53bacb Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Mar 2023 13:38:17 +0100
Subject: [PATCH 110/126] never-settling `import.meta.resolve`

---
 lib/internal/modules/esm/hooks.js                             | 3 ++-
 lib/internal/modules/esm/worker.js                            | 4 ++--
 .../never-settling-resolve-step/import.meta.never-resolve.mjs | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 8cdb35da3822d4..9d835275fb9398 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -37,6 +37,7 @@ const {
   ERR_LOADER_CHAIN_INCOMPLETE,
   ERR_WORKER_UNSERIALIZABLE_ERROR,
 } = require('internal/errors').codes;
+const { exitCodes: { kUnfinishedTopLevelAwait } } = internalBinding('errors');
 const { URL } = require('internal/url');
 const { receiveMessageOnPort } = require('worker_threads');
 const {
@@ -596,7 +597,7 @@ class HooksProxy {
       response = receiveMessageOnPort(this.#syncCommPort);
 
       if (response == null && AtomicsLoad(this.#lock, IDLENESS_OF_THREADS) & WORKER_THREAD_IS_IDLE) {
-        // TODO(aduh95): handle never-settling promises in sync responses.
+        process.exit(kUnfinishedTopLevelAwait);
       }
     }
     debug('got sync response from worker', { method, args });
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index f033d210030d8e..65af1a2297050a 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -150,7 +150,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       shouldRemoveGlobalErrorHandler = true;
     }
 
-    if (port != null && pendingAsyncResponses++ === 0) {
+    if ((port == null ? pendingAsyncResponses : pendingAsyncResponses++) === 0) {
       // We are about to yield the execution with `await ReflectApply` below.
       // In case the code following the `await` never runs, we remove the message
       // handler so the `beforeExit` event can be triggered.
@@ -167,7 +167,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       response = exception;
     }
 
-    if (port != null && --pendingAsyncResponses === 0) {
+    if ((port == null ? pendingAsyncResponses : --pendingAsyncResponses) === 0) {
       // All the messages have been handled before the event loop died, we can go back to the initial setup.
       syncCommPort.on('message', handleMessage);
       clearImmediate(immediate);
diff --git a/test/fixtures/es-module-loaders/never-settling-resolve-step/import.meta.never-resolve.mjs b/test/fixtures/es-module-loaders/never-settling-resolve-step/import.meta.never-resolve.mjs
index 51205a9475889c..fc3a077abe6ddc 100644
--- a/test/fixtures/es-module-loaders/never-settling-resolve-step/import.meta.never-resolve.mjs
+++ b/test/fixtures/es-module-loaders/never-settling-resolve-step/import.meta.never-resolve.mjs
@@ -1,5 +1,5 @@
 console.log('should be output');
 
-await import.meta.resolve('never-settle-resolve');
+import.meta.resolve('never-settle-resolve');
 
 console.log('should not be output');

From f6679bc0d7f4e76c3d274b3b8d7118a6640755a3 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 10 Mar 2023 14:40:02 +0100
Subject: [PATCH 111/126] reuse the public port instead of creating an
 additional communication channel

---
 lib/internal/modules/esm/hooks.js  | 32 ++++++++++++++----------------
 lib/internal/modules/esm/worker.js |  3 +--
 lib/internal/worker.js             |  6 +++++-
 3 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 9d835275fb9398..e4aeed8cd9fe92 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -471,9 +471,9 @@ class HooksProxy {
    */
   #lock;
   /**
-   * A MessagePort used to synchronously communicate with the worker.
+   * The InternalWorker instance, which let us communicate with the loader thread.
    */
-  #syncCommPort;
+  #worker;
 
   #isReady = false;
 
@@ -483,30 +483,26 @@ class HooksProxy {
 
     const lock = new SharedArrayBuffer(SHARED_MEMORY_BYTE_LENGTH);
     this.#lock = new Int32Array(lock);
-    const syncCommChannel = new MessageChannel();
-    this.#syncCommPort = syncCommChannel.port1;
 
-    const worker = this.worker = new InternalWorker('internal/modules/esm/worker', {
+    this.#worker = new InternalWorker('internal/modules/esm/worker', {
       stderr: false,
       stdin: false,
       stdout: false,
       trackUnmanagedFds: false,
       workerData: {
         lock,
-        syncCommPort: syncCommChannel.port2,
       },
-      transferList: [syncCommChannel.port2],
     });
-    worker.unref(); // ! Allows the process to eventually exit.
+    this.#worker.unref(); // ! Allows the process to eventually exit.
   }
 
   #waitForWorker() {
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
-      if (!this.worker[kIsOnline]) {
+      if (!this.#worker[kIsOnline]) {
         debug('wait for signal from worker');
         AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0);
-        const response = receiveMessageOnPort(this.#syncCommPort);
+        const response = this.#worker.receiveMessageSync();
         const { preloadScripts } = this.#unwrapMessage(response);
         this.#executePreloadScripts(preloadScripts);
       }
@@ -521,11 +517,11 @@ class HooksProxy {
     if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
       debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
-      this.worker.terminate();
+      this.#worker.terminate();
     } else {
       // The worker is still in good health, and we just told it it's the
       // only thing keeping us alive.
-      this.worker.ref();
+      this.#worker.ref();
     }
   };
 
@@ -538,7 +534,7 @@ class HooksProxy {
 
     // Pass work to the worker.
     debug('post async message to worker', { method, args });
-    this.#syncCommPort.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
+    this.#worker.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
     // In case the worker was bored, it might lock itself waiting for a signal.
     AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
 
@@ -561,13 +557,15 @@ class HooksProxy {
     debug('start waiting for async response from worker', { method, args });
     while (response == null) {
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
-      AtomicsAnd(this.#lock, IDLENESS_OF_THREADS, ~MAIN_THREAD_IS_IDLE); // We are no longer bored.
+
+      // In case the beforeExit handler was called during the await, we revert its actions.
+      AtomicsAnd(this.#lock, IDLENESS_OF_THREADS, ~MAIN_THREAD_IS_IDLE);
+      this.#worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     }
     debug('got async response from worker', { method, args }, this.#lock);
 
-    this.worker.unref(); // We unref the worker here so the beforeExit handler can be called.
     if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
       // We got all the responses from the worker, its job is done (until next time).
       process.off('beforeExit', this.#beforeExitHandler);
@@ -584,7 +582,7 @@ class HooksProxy {
 
     // Pass work to the worker.
     debug('post sync message to worker', { method, args });
-    this.#syncCommPort.postMessage({ method, args });
+    this.#worker.postMessage({ method, args });
 
     // In case the worker was bored, it might lock itself waiting for a signal.
     AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
@@ -594,7 +592,7 @@ class HooksProxy {
     while (response == null) {
       AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Sleep until worker responds.
 
-      response = receiveMessageOnPort(this.#syncCommPort);
+      response = this.#worker.receiveMessageSync();
 
       if (response == null && AtomicsLoad(this.#lock, IDLENESS_OF_THREADS) & WORKER_THREAD_IS_IDLE) {
         process.exit(kUnfinishedTopLevelAwait);
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 65af1a2297050a..2a6bb636cf98fe 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -193,9 +193,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
 /**
  * ! Run everything possible within this function so errors get reported.
  */
-module.exports = function(workerData) {
+module.exports = function(workerData, syncCommPort) {
   const lock = new Int32Array(workerData.lock);
-  const { syncCommPort } = workerData;
 
   function errorHandler(err, origin = 'unhandledRejection') {
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 5ea21cd6d03084..0c1f60db136e61 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -45,6 +45,7 @@ const { getOptionValue } = require('internal/options');
 const workerIo = require('internal/worker/io');
 const {
   drainMessagePort,
+  receiveMessageOnPort,
   MessageChannel,
   messageTypes,
   kPort,
@@ -455,10 +456,13 @@ class Worker extends EventEmitter {
 }
 
 class InternalWorker extends Worker {
-
   constructor(filename, options) {
     super(filename, options, kIsInternal);
   }
+
+  receiveMessageSync() {
+    return receiveMessageOnPort(this[kPublicPort]);
+  }
 }
 
 function pipeWithoutWarning(source, dest) {

From 722fd0ed690844a38cf2ba8263ea53a88c8aebef Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Mon, 13 Mar 2023 22:48:36 +0100
Subject: [PATCH 112/126] fix: disable test's case concurrency to avoid
 deadlock ~1/10 times

---
 test/es-module/test-esm-loader-chaining.mjs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/es-module/test-esm-loader-chaining.mjs b/test/es-module/test-esm-loader-chaining.mjs
index 0f67d71ece0aa4..120d0a1ef8efd9 100644
--- a/test/es-module/test-esm-loader-chaining.mjs
+++ b/test/es-module/test-esm-loader-chaining.mjs
@@ -15,7 +15,11 @@ const commonArgs = [
   commonInput,
 ];
 
-describe('ESM: loader chaining', { concurrency: true }, () => {
+describe('ESM: loader chaining', {
+  // FIXME(JakobJingleheimer): Enabling test runner concurrency causes the CustomizedModuleLoader to
+  // hang ~1/10 times. Disabling it is a significant hit to test execution time: 0.650s -> 1.823s
+  concurrency: false
+}, () => {
   it('should load unadulterated source when there are no loaders', async () => {
     const { code, stderr, stdout } = await spawnPromisified(
       execPath,

From 544bf89e1a41ae518f3c92dcb120eb0cf1191888 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Tue, 14 Mar 2023 23:18:34 +0100
Subject: [PATCH 113/126] fix rare deadlock

---
 lib/internal/modules/esm/hooks.js            | 27 +++++++++----
 lib/internal/modules/esm/shared_constants.js | 28 +++++++-------
 lib/internal/modules/esm/worker.js           | 40 ++++++++++++++------
 test/es-module/test-esm-loader-chaining.mjs  |  6 +--
 4 files changed, 62 insertions(+), 39 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index e4aeed8cd9fe92..9260f71c7b3b9d 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -475,6 +475,14 @@ class HooksProxy {
    */
   #worker;
 
+  /**
+   * The last notification ID received from the worker. This is used to detect
+   * if the worker has already sent a notification before putting the main
+   * thread to sleep, to avoid a race condition.
+   * @type {number}
+   */
+  #workerNotificationLastId = 0;
+
   #isReady = false;
 
   constructor() {
@@ -554,16 +562,17 @@ class HooksProxy {
     }
 
     let response;
-    debug('start waiting for async response from worker', { method, args });
-    while (response == null) {
-      await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0).value;
+    do {
+      debug('wait for async response from worker', { method, args });
+      await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, this.#workerNotificationLastId).value;
+      this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
       // In case the beforeExit handler was called during the await, we revert its actions.
       AtomicsAnd(this.#lock, IDLENESS_OF_THREADS, ~MAIN_THREAD_IS_IDLE);
       this.#worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
-    }
+    } while (response == null);
     debug('got async response from worker', { method, args }, this.#lock);
 
     if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
@@ -588,16 +597,18 @@ class HooksProxy {
     AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
 
     let response;
-    debug('start waiting for sync response from worker', { method, args });
-    while (response == null) {
-      AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0); // Sleep until worker responds.
+    do {
+      debug('wait for sync response from worker', { method, args });
+      // Sleep until worker responds.
+      AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, this.#workerNotificationLastId);
+      this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
       response = this.#worker.receiveMessageSync();
 
       if (response == null && AtomicsLoad(this.#lock, IDLENESS_OF_THREADS) & WORKER_THREAD_IS_IDLE) {
         process.exit(kUnfinishedTopLevelAwait);
       }
-    }
+    } while (response == null);
     debug('got sync response from worker', { method, args });
     return this.#unwrapMessage(response);
   }
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 00533b3f8fca3d..2ae6b6c1c6f01a 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -4,8 +4,8 @@
 'use strict';
 
 /*
-The shared memory area is divided in 4 32-bit long sections. It has to be 32-bit
-long as `Atomics.notify` only works with `Int32Array` objects.
+The shared memory area is divided in 4 32-bit long sections. It has to be 32-bit long as
+`Atomics.notify` only works with `Int32Array` objects.
 
 --32-bits-- --32-bits-- --32-bits-- --32-bits--
     ^           ^           ^           ^
@@ -18,26 +18,26 @@ long as `Atomics.notify` only works with `Int32Array` objects.
     |
 WORKER_TO_MAIN_THREAD_NOTIFICATION
 
-WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value should always be 0.
+WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value is going to
+increase every time the worker sends a notification to the main thread.
 
-IDLENESS_OF_THREADS does not represent a number, but an array of booleans.
-Currently, two flags are used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE.
-For our use case, a thread is considered IDLE if it has nothing left on its
-event loop and is waiting for the other thread to either terminate the process
-or send it more work.
-If we represent this memory area as a binary number, here's how to interpret its value:
+IDLENESS_OF_THREADS does not represent a number, but an array of booleans. Currently, two flags are
+used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE. For our use case, a thread is considered IDLE
+if it has nothing left on its event loop and is waiting for the other thread to either terminate the
+process or send it more work. If we represent this memory area as a binary number, here's how to
+interpret its value:
 
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is false.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is false.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is true.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is true.
 
-NUMBER_OF_MESSAGES_IN_TRANSIT is used to communicate the number of messages
-sent by the main thread and not yet acknowledged by the worker thread. It is
-also used to wake up the worker thread when it locks itself.
+NUMBER_OF_MESSAGES_IN_TRANSIT is used to communicate the number of messages sent by the main thread
+and not yet acknowledged by the worker thread. It is also used to wake up the worker thread when it
+locks itself.
 
-NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to track how many async responses
-the main thread should expect.
+NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to track how many async responses the main thread should
+expect.
 
 */
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 2a6bb636cf98fe..133106a73ca265 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -8,6 +8,7 @@ const {
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
+      add: AtomicsAdd,
       and: AtomicsAnd,
       load: AtomicsLoad,
       notify: AtomicsNotify,
@@ -39,6 +40,7 @@ const {
 } = require('internal/modules/esm/shared_constants');
 const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
 
+
 function transferArrayBuffer(hasError, source) {
   if (hasError || source == null) return;
   if (isArrayBuffer(source)) return [source];
@@ -80,9 +82,9 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     hooks = initResult.hooks;
     preloadScripts = initResult.preloadScripts;
   } catch (exception) {
-    // If there was an error while parsing and executing a user loader, for
-    // example if because a loader contained a syntax error, then we need to
-    // send the error to the main thread so it can be thrown and printed.
+    // If there was an error while parsing and executing a user loader, for example if because a
+    // loader contained a syntax error, then we need to send the error to the main thread so it can
+    // be thrown and printed.
     hasInitializationError = true;
     initializationError = exception;
   }
@@ -95,14 +97,16 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     syncCommPort.postMessage(wrapMessage('success', { preloadScripts }), preloadScripts.map(({ port }) => port));
   }
 
-  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION); // Unlock the main thread now that we are ready.
+  // We're ready, so unlock the main thread.
+  AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
+  AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
   let immediate;
   let pendingAsyncResponses = 0;
   function checkForMessages() {
     immediate = setImmediate(checkForMessages).unref();
-    // We need to let the event loop tick a few times to give the main thread a
-    // chance to send follow-up messages.
+    // We need to let the event loop tick a few times to give the main thread a chance to send
+    // follow-up messages.
     const response = receiveMessageOnPort(syncCommPort);
 
     if (response !== undefined) {
@@ -119,7 +123,9 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     }
 
     // In case the main thread was waiting for a sync response.
+    AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
+
     // Pause the worker thread until a new message comes in.
     AtomicsWait(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 0);
 
@@ -140,7 +146,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   async function handleMessage({ method, args, port }) {
     AtomicsSub(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
 
-    // Each potential exception needs to be caught individually so that the correct error is sent to the main thread.
+    // Each potential exception needs to be caught individually so that the correct error is sent to
+    // the main thread.
     let hasError = false;
     let shouldRemoveGlobalErrorHandler = false;
     assert(typeof hooks[method] === 'function');
@@ -151,10 +158,11 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     }
 
     if ((port == null ? pendingAsyncResponses : pendingAsyncResponses++) === 0) {
-      // We are about to yield the execution with `await ReflectApply` below.
-      // In case the code following the `await` never runs, we remove the message
-      // handler so the `beforeExit` event can be triggered.
+      // We are about to yield the execution with `await ReflectApply` below. In case the code
+      // following the `await` never runs, we remove the message handler so the `beforeExit` event
+      // can be triggered.
       syncCommPort.off('message', handleMessage);
+
       // We keep checking for new messages to not miss any.
       immediate = setImmediate(checkForMessages).unref();
     }
@@ -168,7 +176,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     }
 
     if ((port == null ? pendingAsyncResponses : --pendingAsyncResponses) === 0) {
-      // All the messages have been handled before the event loop died, we can go back to the initial setup.
+      // All the messages have been handled before the event loop died, we can go back to the
+      // initial setup.
       syncCommPort.on('message', handleMessage);
       clearImmediate(immediate);
     }
@@ -183,6 +192,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       // Or send the exception thrown when trying to send the response.
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
+
+    AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
@@ -197,6 +208,7 @@ module.exports = function(workerData, syncCommPort) {
   const lock = new Int32Array(workerData.lock);
 
   function errorHandler(err, origin = 'unhandledRejection') {
+    AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     process.off('uncaughtException', errorHandler);
     if (hasUncaughtExceptionCaptureCallback()) {
@@ -209,5 +221,9 @@ module.exports = function(workerData, syncCommPort) {
     );
   }
 
-  return PromisePrototypeThen(customizedModuleWorker(lock, syncCommPort, errorHandler), undefined, errorHandler);
+  return PromisePrototypeThen(
+    customizedModuleWorker(lock, syncCommPort, errorHandler),
+    undefined,
+    errorHandler,
+  );
 };
diff --git a/test/es-module/test-esm-loader-chaining.mjs b/test/es-module/test-esm-loader-chaining.mjs
index 120d0a1ef8efd9..0f67d71ece0aa4 100644
--- a/test/es-module/test-esm-loader-chaining.mjs
+++ b/test/es-module/test-esm-loader-chaining.mjs
@@ -15,11 +15,7 @@ const commonArgs = [
   commonInput,
 ];
 
-describe('ESM: loader chaining', {
-  // FIXME(JakobJingleheimer): Enabling test runner concurrency causes the CustomizedModuleLoader to
-  // hang ~1/10 times. Disabling it is a significant hit to test execution time: 0.650s -> 1.823s
-  concurrency: false
-}, () => {
+describe('ESM: loader chaining', { concurrency: true }, () => {
   it('should load unadulterated source when there are no loaders', async () => {
     const { code, stderr, stdout } = await spawnPromisified(
       execPath,

From 88f90426039d78130b0b0f0bdfdf1b1988313dd7 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Mon, 20 Mar 2023 22:17:44 +0100
Subject: [PATCH 114/126] update Hooks entry in to note use of threads and
 caveat for async ops

---
 doc/api/esm.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index d43907bbc2efc8..a2a6bbb43bacaa 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -733,6 +733,10 @@ A hook that returns without calling `next<hookName>()` _and_ without returning
 `shortCircuit: true` also triggers an exception. These errors are to help
 prevent unintentional breaks in the chain.
 
+Hooks are run in a separate thread, isolated from the main. That means it is a different
+[realm](https://tc39.es/ecma262/#realm). The hooks thread may be terminated by
+the main thread at any time, so do not depend on asynchronous operations to complete.
+
 #### `resolve(specifier, context, nextResolve)`
 
 <!-- YAML

From 6d8bfc69d8a4333925d6d3b652e12fdc7b6a8d8f Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Mon, 20 Mar 2023 22:42:16 +0100
Subject: [PATCH 115/126] chore: de-lint md

---
 doc/api/esm.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index a2a6bbb43bacaa..298ac4245eb702 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -733,9 +733,10 @@ A hook that returns without calling `next<hookName>()` _and_ without returning
 `shortCircuit: true` also triggers an exception. These errors are to help
 prevent unintentional breaks in the chain.
 
-Hooks are run in a separate thread, isolated from the main. That means it is a different
-[realm](https://tc39.es/ecma262/#realm). The hooks thread may be terminated by
-the main thread at any time, so do not depend on asynchronous operations to complete.
+Hooks are run in a separate thread, isolated from the main. That means it is a
+different [realm](https://tc39.es/ecma262/#realm). The hooks thread may be
+terminated by the main thread at any time, so do not depend on asynchronous
+operations to complete.
 
 #### `resolve(specifier, context, nextResolve)`
 

From 31e7d5d1c46e7e030962d033a6fb670d9e2d6594 Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Thu, 23 Mar 2023 22:22:59 +0100
Subject: [PATCH 116/126] =?UTF-8?q?switch=20test=20fixtures=20from=20`cons?=
 =?UTF-8?q?ole.log`=20=E2=86=92=20`writeSync(1,=20=E2=80=A6)`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 test/fixtures/es-module-loaders/loader-load-passthru.mjs   | 5 ++++-
 .../loader-load-receiving-modified-context.mjs             | 5 ++++-
 test/fixtures/es-module-loaders/loader-resolve-42.mjs      | 7 +++++--
 test/fixtures/es-module-loaders/loader-resolve-foo.mjs     | 5 ++++-
 .../fixtures/es-module-loaders/loader-resolve-passthru.mjs | 5 ++++-
 .../loader-resolve-receiving-modified-context.mjs          | 5 ++++-
 6 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index 1c2f2ea4487cdf..cf7cdf2d806cc4 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -1,3 +1,6 @@
+import { writeSync } from 'node:fs';
+
+
 export async function load(url, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +10,6 @@ export async function load(url, context, next) {
     return next(url);
   }
 
-  console.log('load passthru'); // This log is deliberate
+  writeSync(1, 'load passthru' + '\n'); // Signal that this specific hook ran
   return next(url);
 }
diff --git a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
index 2d7bc350bd8775..6e5a1ee7193652 100644
--- a/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-receiving-modified-context.mjs
@@ -1,4 +1,7 @@
+import { writeSync } from 'node:fs';
+
+
 export async function load(url, context, next) {
-  console.log(context.foo); // This log is deliberate
+  writeSync(1, context.foo + '\n'); // Expose actual value the hook was called with
   return next(url, context);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index 05ef2f68390bd1..eb1ca09ba19dcf 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -1,3 +1,6 @@
+import { writeSync } from 'node:fs';
+
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,8 +10,8 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve 42'); // This log is deliberate
-  console.log('next<HookName>:', next.name); // This log is deliberate
+  writeSync(1, 'resolve 42' + '\n'); // Signal that this specific hook ran
+  writeSync(1, `next<HookName>: ${next.name}\n`); // Expose actual value the hook was called with
 
   return next('file:///42.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index 09d30e952a2a92..d18855552ccf10 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -1,3 +1,6 @@
+import { writeSync } from 'node:fs';
+
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +10,6 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve foo'); // This log is deliberate
+  writeSync(1, 'resolve foo' + '\n'); // Signal that this specific hook ran
   return next('file:///foo.mjs');
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index d4845acc9f5f71..896c0b7902f887 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -1,3 +1,6 @@
+import { writeSync } from 'node:fs';
+
+
 export async function resolve(specifier, context, next) {
   // This check is needed to make sure that we don't prevent the
   // resolution from follow-up loaders. It wouldn't be a problem
@@ -7,6 +10,6 @@ export async function resolve(specifier, context, next) {
     return next(specifier);
   }
 
-  console.log('resolve passthru'); // This log is deliberate
+  writeSync(1, 'resolve passthru' + '\n'); // Signal that this specific hook ran
   return next(specifier);
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
index 83aa83104e96e4..f6a8fdad53ece3 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-receiving-modified-context.mjs
@@ -1,4 +1,7 @@
+import { writeSync } from 'node:fs';
+
+
 export async function resolve(specifier, context, next) {
-  console.log(context.foo); // This log is deliberate
+  writeSync(1, context.foo + '\n'); // Expose actual value the hook was called with
   return next(specifier, context);
 }

From 372065eb7d4c7572831f3d487d010c327fb845ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Mon, 27 Mar 2023 07:40:15 +0200
Subject: [PATCH 117/126] fix loaders with node:fs

---
 test/fixtures/es-module-loaders/loader-load-foo-or-42.mjs       | 2 +-
 test/fixtures/es-module-loaders/loader-load-incomplete.mjs      | 2 +-
 test/fixtures/es-module-loaders/loader-load-passthru.mjs        | 2 +-
 test/fixtures/es-module-loaders/loader-resolve-42.mjs           | 2 +-
 test/fixtures/es-module-loaders/loader-resolve-foo.mjs          | 2 +-
 test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs   | 2 +-
 .../fixtures/es-module-loaders/loader-resolve-next-modified.mjs | 2 +-
 test/fixtures/es-module-loaders/loader-resolve-passthru.mjs     | 2 +-
 test/fixtures/es-module-loaders/loader-resolve-shortcircuit.mjs | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/fixtures/es-module-loaders/loader-load-foo-or-42.mjs b/test/fixtures/es-module-loaders/loader-load-foo-or-42.mjs
index 8f850e82bef54b..285b81a910ef5d 100644
--- a/test/fixtures/es-module-loaders/loader-load-foo-or-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-foo-or-42.mjs
@@ -3,7 +3,7 @@ export async function load(url, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader')) {
+  if (url === 'node:fs' || url.includes('loader')) {
     return next(url);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-load-incomplete.mjs b/test/fixtures/es-module-loaders/loader-load-incomplete.mjs
index a4bf3531f3d225..bf6d5ea254dcc6 100644
--- a/test/fixtures/es-module-loaders/loader-load-incomplete.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-incomplete.mjs
@@ -3,7 +3,7 @@ export async function load(url, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader')) {
+  if (url === 'node:fs' || url.includes('loader')) {
     return next(url);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-load-passthru.mjs b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
index cf7cdf2d806cc4..22fd7b0413aac8 100644
--- a/test/fixtures/es-module-loaders/loader-load-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-load-passthru.mjs
@@ -6,7 +6,7 @@ export async function load(url, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader')) {
+  if (url === 'node:fs' || url.includes('loader')) {
     return next(url);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-42.mjs b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
index eb1ca09ba19dcf..b571a27a9787e9 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-42.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-42.mjs
@@ -6,7 +6,7 @@ export async function resolve(specifier, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
+  if (specifier === 'node:fs' || specifier.includes('loader')) {
     return next(specifier);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
index d18855552ccf10..b5e5a419b99d45 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-foo.mjs
@@ -6,7 +6,7 @@ export async function resolve(specifier, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
+  if (specifier === 'node:fs' || specifier.includes('loader')) {
     return next(specifier);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
index d00b8fc50134e1..cb37a43527186c 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-incomplete.mjs
@@ -3,7 +3,7 @@ export async function resolve(specifier, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
+  if (specifier === 'node:fs' || specifier.includes('loader')) {
     return next(specifier);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-next-modified.mjs b/test/fixtures/es-module-loaders/loader-resolve-next-modified.mjs
index ac5ad5b1fe020d..a6b8e85455d31c 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-next-modified.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-next-modified.mjs
@@ -3,7 +3,7 @@ export async function resolve(url, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (url.includes('loader')) {
+  if (url === 'node:fs' || url.includes('loader')) {
     return next(url);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
index 896c0b7902f887..3a313611eb3e83 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-passthru.mjs
@@ -6,7 +6,7 @@ export async function resolve(specifier, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
+  if (specifier === 'node:fs' || specifier.includes('loader')) {
     return next(specifier);
   }
 
diff --git a/test/fixtures/es-module-loaders/loader-resolve-shortcircuit.mjs b/test/fixtures/es-module-loaders/loader-resolve-shortcircuit.mjs
index e1a357b4ab48f9..00c18e75e2c7c5 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-shortcircuit.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-shortcircuit.mjs
@@ -3,7 +3,7 @@ export async function resolve(specifier, context, next) {
   // resolution from follow-up loaders. It wouldn't be a problem
   // in real life because loaders aren't supposed to break the
   // resolution, but the ones used in our tests do, for convenience.
-  if (specifier.includes('loader')) {
+  if (specifier === 'node:fs' || specifier.includes('loader')) {
     return next(specifier);
   }
 

From 244f916f6e3c1e1347483b03b0f945c00b60507b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 28 Mar 2023 11:20:11 +0200
Subject: [PATCH 118/126] use more writeSync

---
 test/fixtures/es-module-loaders/hooks-input.mjs   |  5 +++--
 .../es-module-loaders/loader-log-args.mjs         | 15 +++++++++------
 .../loader-resolve-strip-xxx.mjs                  |  8 +++++++-
 .../loader-resolve-strip-yyy.mjs                  |  5 ++++-
 4 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/test/fixtures/es-module-loaders/hooks-input.mjs b/test/fixtures/es-module-loaders/hooks-input.mjs
index dba540d2046c7d..5f61f679515040 100644
--- a/test/fixtures/es-module-loaders/hooks-input.mjs
+++ b/test/fixtures/es-module-loaders/hooks-input.mjs
@@ -2,6 +2,7 @@
 // node --loader ./test/fixtures/es-module-loaders/hooks-input.mjs ./test/fixtures/es-modules/json-modules.mjs
 
 import assert from 'assert';
+import { writeSync } from 'fs';
 import { readFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 
@@ -42,7 +43,7 @@ export async function resolve(specifier, context, next) {
     shortCircuit: true,
   }
 
-  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
+  writeSync(1, JSON.stringify(returnValue) + '\n'); // For the test to validate when it parses stdout
 
   return returnValue;
 }
@@ -79,7 +80,7 @@ export async function load(url, context, next) {
     shortCircuit: true,
   };
 
-  console.log(JSON.stringify(returnValue)); // For the test to validate when it parses stdout
+  writeSync(1, JSON.stringify(returnValue) + '\n'); // For the test to validate when it parses stdout
 
   return returnValue;
 }
diff --git a/test/fixtures/es-module-loaders/loader-log-args.mjs b/test/fixtures/es-module-loaders/loader-log-args.mjs
index 84ed373d6b4de4..b56fddbce5854d 100644
--- a/test/fixtures/es-module-loaders/loader-log-args.mjs
+++ b/test/fixtures/es-module-loaders/loader-log-args.mjs
@@ -1,10 +1,13 @@
+import { writeSync } from 'node:fs';
+import { inspect } from 'node:util'
+
 export async function resolve(...args) {
-  console.log(`resolve arg count: ${args.length}`);
-  console.log({
+  writeSync(1, `resolve arg count: ${args.length}\n`);
+  writeSync(1, inspect({
     specifier: args[0],
     context: args[1],
     next: args[2],
-  });
+  }) + '\n');
 
   return {
     shortCircuit: true,
@@ -13,12 +16,12 @@ export async function resolve(...args) {
 }
 
 export async function load(...args) {
-  console.log(`load arg count: ${args.length}`);
-  console.log({
+  writeSync(1, `load arg count: ${args.length}\n`);
+  writeSync(1, inspect({
     url: args[0],
     context: args[1],
     next: args[2],
-  });
+  }) + '\n');
 
   return {
     format: 'module',
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
index 58d7a1107994fe..996dfd041c0df6 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-xxx.mjs
@@ -1,4 +1,10 @@
+import { writeSync } from 'node:fs';
+import { inspect } from 'node:util';
+
 export async function resolve(specifier, context, nextResolve) {
-  console.log(`loader-a`, {specifier});
+  if (specifier.startsWith('node:')) {
+    return nextResolve(specifier);
+  }
+  writeSync(1, `loader-a ${inspect({specifier})}\n`);
   return nextResolve(specifier.replace(/^xxx\//, `./`));
 }
diff --git a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
index 3615926143c4c7..7746469bf817eb 100644
--- a/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
+++ b/test/fixtures/es-module-loaders/loader-resolve-strip-yyy.mjs
@@ -1,4 +1,7 @@
+import { writeSync } from 'node:fs';
+import { inspect } from 'node:util';
+
 export async function resolve(specifier, context, nextResolve) {
-  console.log(`loader-b`, {specifier});
+  writeSync(1, `loader-b ${inspect({specifier})}\n`);
   return nextResolve(specifier.replace(/^yyy\//, `./`));
 }

From bc8e97027d82be27b98aa0ba04a7dc71c233fc81 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 2 Apr 2023 20:52:52 +0200
Subject: [PATCH 119/126] remove remaining `await` in front of
 `import.meta.resolve`

---
 .../test-esm-import-meta-resolve.mjs          | 56 +++++++++----------
 .../es-modules/import-resolve-exports.mjs     | 10 +---
 test/fixtures/es-modules/runmain.mjs          |  4 +-
 3 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/test/es-module/test-esm-import-meta-resolve.mjs b/test/es-module/test-esm-import-meta-resolve.mjs
index 41452b945e8421..843ca6d747140a 100644
--- a/test/es-module/test-esm-import-meta-resolve.mjs
+++ b/test/es-module/test-esm-import-meta-resolve.mjs
@@ -1,36 +1,32 @@
 // Flags: --experimental-import-meta-resolve
-import { mustCall } from '../common/index.mjs';
+import '../common/index.mjs';
 import assert from 'assert';
 
 const dirname = import.meta.url.slice(0, import.meta.url.lastIndexOf('/') + 1);
 const fixtures = dirname.slice(0, dirname.lastIndexOf('/', dirname.length - 2) + 1) + 'fixtures/';
 
-(async () => {
-  assert.strictEqual(await import.meta.resolve('./test-esm-import-meta.mjs'),
-                     dirname + 'test-esm-import-meta.mjs');
-  try {
-    await import.meta.resolve('./notfound.mjs');
-    assert.fail();
-  } catch (e) {
-    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
-  }
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/empty-with-bom.txt'),
-    fixtures + 'empty-with-bom.txt');
-  assert.strictEqual(await import.meta.resolve('../fixtures/'), fixtures);
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/', import.meta.url),
-    fixtures);
-  assert.strictEqual(
-    await import.meta.resolve('../fixtures/', new URL(import.meta.url)),
-    fixtures);
-  await Promise.all(
-    [[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
-      assert.throws(() => import.meta.resolve('../fixtures/', arg), {
-        code: 'ERR_INVALID_ARG_TYPE',
-      })
-    )
-  );
-  assert.strictEqual(await import.meta.resolve('baz/', fixtures),
-                     fixtures + 'node_modules/baz/');
-})().then(mustCall());
+assert.strictEqual(import.meta.resolve('./test-esm-import-meta.mjs'),
+                   dirname + 'test-esm-import-meta.mjs');
+try {
+  import.meta.resolve('./notfound.mjs');
+  assert.fail();
+} catch (e) {
+  assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
+}
+assert.strictEqual(
+  import.meta.resolve('../fixtures/empty-with-bom.txt'),
+  fixtures + 'empty-with-bom.txt');
+assert.strictEqual(import.meta.resolve('../fixtures/'), fixtures);
+assert.strictEqual(
+  import.meta.resolve('../fixtures/', import.meta.url),
+  fixtures);
+assert.strictEqual(
+  import.meta.resolve('../fixtures/', new URL(import.meta.url)),
+  fixtures);
+[[], {}, Symbol(), 0, 1, 1n, 1.1, () => {}, true, false].map((arg) =>
+  assert.throws(() => import.meta.resolve('../fixtures/', arg), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  })
+);
+assert.strictEqual(import.meta.resolve('baz/', fixtures),
+                   fixtures + 'node_modules/baz/');
diff --git a/test/fixtures/es-modules/import-resolve-exports.mjs b/test/fixtures/es-modules/import-resolve-exports.mjs
index 0bbce4fbc5efc0..e6a840ec996d96 100644
--- a/test/fixtures/es-modules/import-resolve-exports.mjs
+++ b/test/fixtures/es-modules/import-resolve-exports.mjs
@@ -1,10 +1,4 @@
 import { strictEqual } from 'assert';
 
-(async () => {
-  const resolved = await import.meta.resolve('pkgexports-sugar');
-  strictEqual(typeof resolved, 'string');
-})()
-.catch((e) => {
-  console.error(e);
-  process.exit(1);
-});
+const resolved = import.meta.resolve('pkgexports-sugar');
+strictEqual(typeof resolved, 'string');
diff --git a/test/fixtures/es-modules/runmain.mjs b/test/fixtures/es-modules/runmain.mjs
index 5ceb86b66c76ce..ee71ff42a81368 100644
--- a/test/fixtures/es-modules/runmain.mjs
+++ b/test/fixtures/es-modules/runmain.mjs
@@ -1,7 +1,7 @@
 import { runMain } from 'node:module';
 
-try { await import.meta.resolve('doesnt-matter.mjs') } catch {}
+try { import.meta.resolve('doesnt-matter.mjs') } catch {}
 
 runMain();
 
-try { await import.meta.resolve('doesnt-matter.mjs') } catch {}
+try { import.meta.resolve('doesnt-matter.mjs') } catch {}

From f44a24686c37319f5c508d842eea8b5273bae142 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 2 Apr 2023 21:05:22 +0200
Subject: [PATCH 120/126] resolve TODOs for edge cases

---
 lib/internal/modules/esm/initialize_import_meta.js    | 2 +-
 lib/internal/modules/esm/loader.js                    | 6 ++++++
 lib/internal/modules/esm/utils.js                     | 1 +
 test/fixtures/es-module-loaders/loader-edge-cases.mjs | 6 ++----
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index adaf0fe52a0f61..1d86b9c8a2e0d0 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -38,7 +38,7 @@ function initializeImportMeta(meta, context, loader) {
   const { url } = context;
 
   // Alphabetical
-  if (experimentalImportMetaResolve) {
+  if (experimentalImportMetaResolve && loader.loaderType !== 'internal') {
     meta.resolve = createImportMetaResolve(url, loader);
   }
 
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 3ed430bfb02a24..a6014dbc03d7c8 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -98,6 +98,12 @@ class DefaultModuleLoader {
    */
   translators = getTranslators();
 
+  /**
+   * Type of loader.
+   * @type {'default' | 'internal'}
+   */
+  loaderType = 'default';
+
   constructor() {
     if (getOptionValue('--experimental-network-imports')) {
       emitExperimentalWarning('Network Imports');
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index ed87dc1d451d4c..1c01dd13b3ab21 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -116,6 +116,7 @@ async function initializeHooks() {
 
   const { DefaultModuleLoader } = require('internal/modules/esm/loader');
   class ModuleLoader extends DefaultModuleLoader {
+    loaderType = 'internal';
     async #getModuleJob(specifier, parentURL, importAssertions) {
       const resolveResult = await hooks.resolve(specifier, parentURL, importAssertions);
       return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
diff --git a/test/fixtures/es-module-loaders/loader-edge-cases.mjs b/test/fixtures/es-module-loaders/loader-edge-cases.mjs
index f50df0988194e4..19af0e2bc078c0 100644
--- a/test/fixtures/es-module-loaders/loader-edge-cases.mjs
+++ b/test/fixtures/es-module-loaders/loader-edge-cases.mjs
@@ -1,15 +1,13 @@
 import { strictEqual } from "node:assert";
 import { isMainThread, workerData, parentPort } from "node:worker_threads";
 
-// TODO(aduh95): switch this to `false` when loader hooks are run on a separate thread.
-strictEqual(isMainThread, true);
+strictEqual(isMainThread, false);
 
 // We want to make sure that internals are not leaked on the public module:
 strictEqual(workerData, null);
 strictEqual(parentPort, null);
 
-// TODO(aduh95): switch to `"undefined"` when loader hooks are run on a separate thread.
 // We don't want `import.meta.resolve` being available from loaders
 // as the sync implementation is not compatible with calling async
 // functions on the same thread.
-strictEqual(typeof import.meta.resolve, 'function');
+strictEqual(typeof import.meta.resolve, 'undefined');

From 221f2e2218d6ddded07d144a96530d863193f22c Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Tue, 4 Apr 2023 11:05:37 +0200
Subject: [PATCH 121/126] fix race condition that could cause a dead lock when
 dealing with never settling hooks

---
 lib/internal/modules/esm/hooks.js            | 3 ++-
 lib/internal/modules/esm/shared_constants.js | 6 ++++--
 lib/internal/modules/esm/worker.js           | 8 ++++++++
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 9260f71c7b3b9d..0ba6130eb135ff 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -522,7 +522,8 @@ class HooksProxy {
   #beforeExitHandler = () => {
     const value = AtomicsOr(this.#lock, IDLENESS_OF_THREADS, MAIN_THREAD_IS_IDLE);
     debug('beforeExit main thread', value, this.#lock);
-    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
+    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0 &&
+        AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES) === 0) {
       debug('send terminate order to worker');
       // The worker has already reported waiting for us to die together.
       this.#worker.terminate();
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index 2ae6b6c1c6f01a..bd802243ec8203 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -24,8 +24,10 @@ increase every time the worker sends a notification to the main thread.
 IDLENESS_OF_THREADS does not represent a number, but an array of booleans. Currently, two flags are
 used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE. For our use case, a thread is considered IDLE
 if it has nothing left on its event loop and is waiting for the other thread to either terminate the
-process or send it more work. If we represent this memory area as a binary number, here's how to
-interpret its value:
+process or send it more work. In addition to that, the worker will declare itself idle when it's
+handled all the messages sent to it, even if it might still be doing other work, we disregard work
+done by the worker that doesn't involve responding to the main thread messages. If we represent this
+memory area as a binary number, here's how to interpret its value:
 
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is false.
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is false.
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 133106a73ca265..de10e98382c55f 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -90,6 +90,9 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   }
 
   syncCommPort.on('message', handleMessage);
+  // We just added an event listener that will keep the process alive. Let's
+  // notify the main thread that we don't have anything to do.
+  AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
 
   if (hasInitializationError) {
     syncCommPort.postMessage(wrapMessage('error', initializationError));
@@ -144,6 +147,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   });
 
   async function handleMessage({ method, args, port }) {
+    AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
     AtomicsSub(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
 
     // Each potential exception needs to be caught individually so that the correct error is sent to
@@ -198,6 +202,10 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
     }
+    if (pendingAsyncResponses === 0 && AtomicsLoad(lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
+      // Let's let the main thread know that we don't have anything to do.
+      AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
+    }
   }
 }
 

From 9436c973978ed65bd3b303c6d5c38fd3c174f50f Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 12 Apr 2023 00:22:43 +0200
Subject: [PATCH 122/126] reduce the size of the sab and introduce a
 `never-setlle` message status

---
 lib/internal/modules/esm/hooks.js            | 48 +++++---------
 lib/internal/modules/esm/shared_constants.js | 42 ++----------
 lib/internal/modules/esm/worker.js           | 68 +++++---------------
 3 files changed, 38 insertions(+), 120 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 0ba6130eb135ff..ef537f06e491b7 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -8,6 +8,7 @@ const {
   ObjectAssign,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
+  Promise,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
@@ -16,12 +17,8 @@ const {
 
 const {
   Atomics: {
-    add: AtomicsAdd,
     and: AtomicsAnd,
     load: AtomicsLoad,
-    notify: AtomicsNotify,
-    or: AtomicsOr,
-    sub: AtomicsSub,
     wait: AtomicsWait,
     waitAsync: AtomicsWaitAsync,
   },
@@ -58,12 +55,7 @@ const {
 } = require('internal/modules/esm/utils');
 const { deserializeError } = require('internal/error_serdes');
 const {
-  IDLENESS_OF_THREADS,
-  MAIN_THREAD_IS_IDLE,
-  NUMBER_OF_INCOMING_ASYNC_RESPONSES,
-  NUMBER_OF_MESSAGES_IN_TRANSIT,
   SHARED_MEMORY_BYTE_LENGTH,
-  WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
@@ -483,6 +475,12 @@ class HooksProxy {
    */
   #workerNotificationLastId = 0;
 
+  /**
+   * Track how many async responses the main thread should expect.
+   * @type {number}
+   */
+  #numberOfPendingAsyncResponses = 0;
+
   #isReady = false;
 
   constructor() {
@@ -520,14 +518,8 @@ class HooksProxy {
   }
 
   #beforeExitHandler = () => {
-    const value = AtomicsOr(this.#lock, IDLENESS_OF_THREADS, MAIN_THREAD_IS_IDLE);
-    debug('beforeExit main thread', value, this.#lock);
-    if (value & WORKER_THREAD_IS_IDLE && AtomicsLoad(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0 &&
-        AtomicsLoad(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES) === 0) {
-      debug('send terminate order to worker');
-      // The worker has already reported waiting for us to die together.
-      this.#worker.terminate();
-    } else {
+    debug('beforeExit main thread', this.#lock);
+    if (this.#numberOfPendingAsyncResponses !== 0) {
       // The worker is still in good health, and we just told it it's the
       // only thing keeping us alive.
       this.#worker.ref();
@@ -535,7 +527,6 @@ class HooksProxy {
   };
 
   async makeAsyncRequest(method, ...args) {
-    AtomicsAdd(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
     this.#waitForWorker();
 
     MessageChannel ??= require('internal/worker/io').MessageChannel;
@@ -544,10 +535,8 @@ class HooksProxy {
     // Pass work to the worker.
     debug('post async message to worker', { method, args });
     this.#worker.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
-    // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
 
-    if (AtomicsAdd(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) === 0) {
+    if (this.#numberOfPendingAsyncResponses++ === 0) {
       // On the next lines, the main thread will await a response from the
       // worker thread that might come after the last task in the event
       // loop has run its course and there would be nothing left keeping the
@@ -569,14 +558,13 @@ class HooksProxy {
       this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
       // In case the beforeExit handler was called during the await, we revert its actions.
-      AtomicsAnd(this.#lock, IDLENESS_OF_THREADS, ~MAIN_THREAD_IS_IDLE);
       this.#worker.unref();
 
       response = receiveMessageOnPort(asyncCommChannel.port1);
     } while (response == null);
     debug('got async response from worker', { method, args }, this.#lock);
 
-    if (AtomicsSub(this.#lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, 1) <= 1) {
+    if (--this.#numberOfPendingAsyncResponses === 0) {
       // We got all the responses from the worker, its job is done (until next time).
       process.off('beforeExit', this.#beforeExitHandler);
     }
@@ -587,16 +575,12 @@ class HooksProxy {
   }
 
   makeSyncRequest(method, ...args) {
-    AtomicsAdd(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
     this.#waitForWorker();
 
     // Pass work to the worker.
     debug('post sync message to worker', { method, args });
     this.#worker.postMessage({ method, args });
 
-    // In case the worker was bored, it might lock itself waiting for a signal.
-    AtomicsNotify(this.#lock, NUMBER_OF_MESSAGES_IN_TRANSIT);
-
     let response;
     do {
       debug('wait for sync response from worker', { method, args });
@@ -605,16 +589,18 @@ class HooksProxy {
       this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
       response = this.#worker.receiveMessageSync();
-
-      if (response == null && AtomicsLoad(this.#lock, IDLENESS_OF_THREADS) & WORKER_THREAD_IS_IDLE) {
-        process.exit(kUnfinishedTopLevelAwait);
-      }
     } while (response == null);
     debug('got sync response from worker', { method, args });
+    if (response.message.status === 'never-settle') {
+      process.exit(kUnfinishedTopLevelAwait);
+    }
     return this.#unwrapMessage(response);
   }
 
   #unwrapMessage(response) {
+    if (response.message.status === 'never-settle') {
+      return new Promise(() => {});
+    }
     if (response.message.status === 'error') {
       if (response.message.body == null) throw response.message.body;
       if (response.message.body.serializationFailed || response.message.body.serialized == null) {
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index bd802243ec8203..c9c9f8dd9552c5 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -4,54 +4,22 @@
 'use strict';
 
 /*
-The shared memory area is divided in 4 32-bit long sections. It has to be 32-bit long as
+The shared memory area is divided in 1 32-bit long sections. It has to be 32-bit long as
 `Atomics.notify` only works with `Int32Array` objects.
 
---32-bits-- --32-bits-- --32-bits-- --32-bits--
-    ^           ^           ^           ^
-    |           |           |           |
-    |           |           | NUMBER_OF_INCOMING_ASYNC_RESPONSES
-    |           |           |
-    |           | NUMBER_OF_MESSAGES_IN_TRANSIT
-    |           |
-    |  IDLENESS_OF_THREADS
+--32-bits--
+    ^
+    |
     |
 WORKER_TO_MAIN_THREAD_NOTIFICATION
 
 WORKER_TO_MAIN_THREAD_NOTIFICATION is only used to send notifications, its value is going to
 increase every time the worker sends a notification to the main thread.
 
-IDLENESS_OF_THREADS does not represent a number, but an array of booleans. Currently, two flags are
-used: WORKER_THREAD_IS_IDLE, and MAIN_THREAD_IS_IDLE. For our use case, a thread is considered IDLE
-if it has nothing left on its event loop and is waiting for the other thread to either terminate the
-process or send it more work. In addition to that, the worker will declare itself idle when it's
-handled all the messages sent to it, even if it might still be doing other work, we disregard work
-done by the worker that doesn't involve responding to the main thread messages. If we represent this
-memory area as a binary number, here's how to interpret its value:
-
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx00: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is false.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is false.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx10: WORKER_THREAD_IS_IDLE is false, and MAIN_THREAD_IS_IDLE is true.
-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx11: WORKER_THREAD_IS_IDLE is true, and MAIN_THREAD_IS_IDLE is true.
-
-NUMBER_OF_MESSAGES_IN_TRANSIT is used to communicate the number of messages sent by the main thread
-and not yet acknowledged by the worker thread. It is also used to wake up the worker thread when it
-locks itself.
-
-NUMBER_OF_INCOMING_ASYNC_RESPONSES is used to track how many async responses the main thread should
-expect.
-
 */
 
 module.exports = {
   WORKER_TO_MAIN_THREAD_NOTIFICATION: 0,
 
-  IDLENESS_OF_THREADS: 1,
-  WORKER_THREAD_IS_IDLE: 0b01,
-  MAIN_THREAD_IS_IDLE: 0b10,
-
-  NUMBER_OF_MESSAGES_IN_TRANSIT: 2,
-  NUMBER_OF_INCOMING_ASYNC_RESPONSES: 3,
-
-  SHARED_MEMORY_BYTE_LENGTH: 4 * 4,
+  SHARED_MEMORY_BYTE_LENGTH: 1 * 4,
 };
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index de10e98382c55f..a2f1591f05df93 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -5,16 +5,13 @@ const {
   Int32Array,
   PromisePrototypeThen,
   ReflectApply,
+  SafeSet,
   TypedArrayPrototypeGetBuffer,
   globalThis: {
     Atomics: {
       add: AtomicsAdd,
-      and: AtomicsAnd,
-      load: AtomicsLoad,
       notify: AtomicsNotify,
-      or: AtomicsOr,
       sub: AtomicsSub,
-      wait: AtomicsWait,
     },
   },
 } = primordials;
@@ -31,11 +28,6 @@ const {
 
 const { receiveMessageOnPort } = require('internal/worker/io');
 const {
-  IDLENESS_OF_THREADS,
-  MAIN_THREAD_IS_IDLE,
-  NUMBER_OF_INCOMING_ASYNC_RESPONSES,
-  NUMBER_OF_MESSAGES_IN_TRANSIT,
-  WORKER_THREAD_IS_IDLE,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
 const { initializeESM, initializeHooks } = require('internal/modules/esm/utils');
@@ -52,9 +44,6 @@ function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {
     return { status, body };
   }
-  if (body == null) {
-    return { status, body };
-  }
   let serialized;
   let serializationFailed;
   try {
@@ -90,9 +79,6 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   }
 
   syncCommPort.on('message', handleMessage);
-  // We just added an event listener that will keep the process alive. Let's
-  // notify the main thread that we don't have anything to do.
-  AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
 
   if (hasInitializationError) {
     syncCommPort.postMessage(wrapMessage('error', initializationError));
@@ -105,7 +91,6 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
   let immediate;
-  let pendingAsyncResponses = 0;
   function checkForMessages() {
     immediate = setImmediate(checkForMessages).unref();
     // We need to let the event loop tick a few times to give the main thread a chance to send
@@ -117,27 +102,17 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     }
   }
 
-  process.on('beforeExit', () => {
-    const value = AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
+  const unsettledResponsePorts = new SafeSet();
 
-    if (value & MAIN_THREAD_IS_IDLE && AtomicsLoad(lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
-      // Main thread is also out of work, there's nothing left to do.
-      return;
+  process.on('beforeExit', () => {
+    for (const port of unsettledResponsePorts) {
+      port.postMessage(wrapMessage('never-settle'));
     }
+    unsettledResponsePorts.clear();
 
-    // In case the main thread was waiting for a sync response.
     AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
-    // Pause the worker thread until a new message comes in.
-    AtomicsWait(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 0);
-
-    AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
-
-    // The pending messages won't come back at this point, so we can reset the counters.
-    AtomicsSub(lock, NUMBER_OF_INCOMING_ASYNC_RESPONSES, pendingAsyncResponses);
-    pendingAsyncResponses = 0;
-
     // Let's attach back the event handler.
     syncCommPort.on('message', handleMessage);
     // Let's also check synchronously for a message, in case it's already there.
@@ -147,9 +122,6 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   });
 
   async function handleMessage({ method, args, port }) {
-    AtomicsAnd(lock, IDLENESS_OF_THREADS, ~WORKER_THREAD_IS_IDLE); // We are no longer bored.
-    AtomicsSub(lock, NUMBER_OF_MESSAGES_IN_TRANSIT, 1);
-
     // Each potential exception needs to be caught individually so that the correct error is sent to
     // the main thread.
     let hasError = false;
@@ -161,15 +133,16 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       shouldRemoveGlobalErrorHandler = true;
     }
 
-    if ((port == null ? pendingAsyncResponses : pendingAsyncResponses++) === 0) {
-      // We are about to yield the execution with `await ReflectApply` below. In case the code
-      // following the `await` never runs, we remove the message handler so the `beforeExit` event
-      // can be triggered.
-      syncCommPort.off('message', handleMessage);
+    // We are about to yield the execution with `await ReflectApply` below. In case the code
+    // following the `await` never runs, we remove the message handler so the `beforeExit` event
+    // can be triggered.
+    syncCommPort.off('message', handleMessage);
 
-      // We keep checking for new messages to not miss any.
-      immediate = setImmediate(checkForMessages).unref();
-    }
+    // We keep checking for new messages to not miss any.
+    clearImmediate(immediate);
+    immediate = setImmediate(checkForMessages).unref();
+
+    unsettledResponsePorts.add(port ?? syncCommPort);
 
     let response;
     try {
@@ -179,12 +152,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       response = exception;
     }
 
-    if ((port == null ? pendingAsyncResponses : --pendingAsyncResponses) === 0) {
-      // All the messages have been handled before the event loop died, we can go back to the
-      // initial setup.
-      syncCommPort.on('message', handleMessage);
-      clearImmediate(immediate);
-    }
+    unsettledResponsePorts.delete(port ?? syncCommPort);
 
     // Send the method response (or exception) to the main thread.
     try {
@@ -202,10 +170,6 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
     }
-    if (pendingAsyncResponses === 0 && AtomicsLoad(lock, NUMBER_OF_MESSAGES_IN_TRANSIT) === 0) {
-      // Let's let the main thread know that we don't have anything to do.
-      AtomicsOr(lock, IDLENESS_OF_THREADS, WORKER_THREAD_IS_IDLE);
-    }
   }
 }
 

From ad73db66e8798362ffa39a6421e1fe202e81ad49 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Wed, 12 Apr 2023 16:41:58 +0200
Subject: [PATCH 123/126] fix race condition?

---
 lib/internal/modules/esm/hooks.js  | 6 ++----
 lib/internal/modules/esm/worker.js | 9 ++++++++-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index ef537f06e491b7..ee036cab09c2e6 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -17,7 +17,6 @@ const {
 
 const {
   Atomics: {
-    and: AtomicsAnd,
     load: AtomicsLoad,
     wait: AtomicsWait,
     waitAsync: AtomicsWaitAsync,
@@ -518,10 +517,9 @@ class HooksProxy {
   }
 
   #beforeExitHandler = () => {
-    debug('beforeExit main thread', this.#lock);
+    debug('beforeExit main thread', this.#lock, this.#numberOfPendingAsyncResponses);
     if (this.#numberOfPendingAsyncResponses !== 0) {
-      // The worker is still in good health, and we just told it it's the
-      // only thing keeping us alive.
+      // The worker still has some work to do, let's wait for it before terminating the process.
       this.#worker.ref();
     }
   };
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index a2f1591f05df93..18c4e88452539d 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -11,7 +11,6 @@ const {
     Atomics: {
       add: AtomicsAdd,
       notify: AtomicsNotify,
-      sub: AtomicsSub,
     },
   },
 } = primordials;
@@ -116,9 +115,12 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     // Let's attach back the event handler.
     syncCommPort.on('message', handleMessage);
     // Let's also check synchronously for a message, in case it's already there.
+    clearImmediate(immediate);
     checkForMessages();
     // We don't need the sync check after this tick, as we already have added the event handler.
     clearImmediate(immediate);
+    // Let's add some work for next tick so the worker cannot exit.
+    setImmediate(() => {});
   });
 
   async function handleMessage({ method, args, port }) {
@@ -170,6 +172,11 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
     }
+
+    syncCommPort.off('message', handleMessage);
+    // We keep checking for new messages to not miss any.
+    clearImmediate(immediate);
+    immediate = setImmediate(checkForMessages).unref();
   }
 }
 

From 95052c6b6c857d9620288bf85ecf61e41176c36e Mon Sep 17 00:00:00 2001
From: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
Date: Thu, 13 Apr 2023 00:00:08 +0200
Subject: [PATCH 124/126] tidy code, comments, and docs

---
 doc/api/esm.md                                |  8 +++---
 lib/internal/main/worker_thread.js            |  8 +++---
 lib/internal/modules/esm/hooks.js             | 25 ++++++++++---------
 .../modules/esm/initialize_import_meta.js     |  2 +-
 lib/internal/modules/esm/loader.js            |  4 ++-
 lib/internal/modules/esm/shared_constants.js  |  2 +-
 lib/internal/modules/esm/worker.js            | 10 +++++---
 lib/internal/worker.js                        |  4 +++
 8 files changed, 36 insertions(+), 27 deletions(-)

diff --git a/doc/api/esm.md b/doc/api/esm.md
index 298ac4245eb702..884c3e83c9e684 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -360,7 +360,7 @@ const dependencyAsset = import.meta.resolve('component-lib/asset.css');
 ```
 
 `import.meta.resolve` also accepts a second argument which is the parent module
-from which to resolve from:
+from which to resolve:
 
 ```js
 import.meta.resolve('./dep', import.meta.url);
@@ -736,7 +736,7 @@ prevent unintentional breaks in the chain.
 Hooks are run in a separate thread, isolated from the main. That means it is a
 different [realm](https://tc39.es/ecma262/#realm). The hooks thread may be
 terminated by the main thread at any time, so do not depend on asynchronous
-operations to complete.
+operations to (like `console.log`) complete.
 
 #### `resolve(specifier, context, nextResolve)`
 
@@ -780,8 +780,8 @@ changes:
     terminate the chain of `resolve` hooks. **Default:** `false`
   * `url` {string} The absolute URL to which this input resolves
 
-> **Caveat** Despite support for returning promises and async function, calls to
-> `resolve` may block the main thread which can impact performance.
+> **Caveat** Despite support for returning promises and async functions, calls
+> to `resolve` may block the main thread which can impact performance.
 
 The `resolve` hook chain is responsible for telling Node.js where to find and
 how to cache a given `import` statement or expression. It can optionally return
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 6941bd79afa7a5..4d8938e58bdf33 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -100,11 +100,11 @@ port.on('message', (message) => {
       workerData,
     } = message;
 
-    if (doEval !== 'internal' && argv !== undefined) {
-      ArrayPrototypePushApply(process.argv, argv);
-    }
-
     if (doEval !== 'internal') {
+      if (argv !== undefined) {
+        ArrayPrototypePushApply(process.argv, argv);
+      }
+
       const publicWorker = require('worker_threads');
       publicWorker.parentPort = publicPort;
       publicWorker.workerData = workerData;
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index ee036cab09c2e6..7df6672582c50d 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -454,6 +454,10 @@ class Hooks {
 }
 ObjectSetPrototypeOf(Hooks.prototype, null);
 
+/**
+ * There may be multiple instances of Hooks/HooksProxy, but there is only 1 Internal worker, so
+ * there is only 1 MessageChannel.
+ */
 let MessageChannel;
 class HooksProxy {
   /**
@@ -462,7 +466,7 @@ class HooksProxy {
    */
   #lock;
   /**
-   * The InternalWorker instance, which let us communicate with the loader thread.
+   * The InternalWorker instance, which lets us communicate with the loader thread.
    */
   #worker;
 
@@ -535,17 +539,14 @@ class HooksProxy {
     this.#worker.postMessage({ method, args, port: asyncCommChannel.port2 }, [asyncCommChannel.port2]);
 
     if (this.#numberOfPendingAsyncResponses++ === 0) {
-      // On the next lines, the main thread will await a response from the
-      // worker thread that might come after the last task in the event
-      // loop has run its course and there would be nothing left keeping the
-      // thread alive (and once the main thread dies, the whole process stops).
-      // However we want to keep the process alive until the worker thread
-      // responds (or until the event loop of the worker thread is also empty).
-      // So we add the beforeExit handler whose mission is to lock the main
-      // thread until we hear back from the worker thread.
-      // The if condition is there so we only add the event handler once (if
-      // there are already pending async responses, the previous calls have
-      // added the event listener).
+      // On the next lines, the main thread will await a response from the worker thread that might
+      // come AFTER the last task in the event loop has run its course and there would be nothing
+      // left keeping the thread alive (and once the main thread dies, the whole process stops).
+      // However we want to keep the process alive until the worker thread responds (or until the
+      // event loop of the worker thread is also empty). So we add the beforeExit handler whose
+      // mission is to lock the main thread until we hear back from the worker thread. The `if`
+      // condition is there so we only add the event handler once (if there are already pending
+      // async responses, the previous calls have added the event listener).
       process.on('beforeExit', this.#beforeExitHandler);
     }
 
diff --git a/lib/internal/modules/esm/initialize_import_meta.js b/lib/internal/modules/esm/initialize_import_meta.js
index 1d86b9c8a2e0d0..c548f71bef837a 100644
--- a/lib/internal/modules/esm/initialize_import_meta.js
+++ b/lib/internal/modules/esm/initialize_import_meta.js
@@ -28,7 +28,7 @@ function createImportMetaResolve(defaultParentUrl, loader) {
 }
 
 /**
- * Create the import.meta object for a module.
+ * Create the `import.meta` object for a module.
  * @param {object} meta
  * @param {{url: string}} context
  * @param {typeof import('./loader.js').ModuleLoader} loader Reference to the current module loader
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index a6014dbc03d7c8..a42319dba892c8 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -347,7 +347,6 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
       // The worker proxy is shared across all instances, so don't recreate it if it already exists.
       return;
     }
-
     const { HooksProxy } = require('internal/modules/esm/hooks');
     hooksProxy = new HooksProxy(); // The user's custom hooks are loaded within the worker as part of its startup.
   }
@@ -368,10 +367,12 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
 
   async #getModuleJob(specifier, parentURL, importAssertions) {
     const resolveResult = await hooksProxy.makeAsyncRequest('resolve', specifier, parentURL, importAssertions);
+
     return this.getJobFromResolveResult(resolveResult, parentURL, importAssertions);
   }
   getModuleJob(specifier, parentURL, importAssertions) {
     const jobPromise = this.#getModuleJob(specifier, parentURL, importAssertions);
+
     return {
       run() {
         return PromisePrototypeThen(jobPromise, (job) => job.run());
@@ -395,6 +396,7 @@ class CustomizedModuleLoader extends DefaultModuleLoader {
   async load(url, context) {
     const result = await hooksProxy.makeAsyncRequest('load', url, context);
     this.validateLoadResult(url, result?.format);
+
     return result;
   }
 }
diff --git a/lib/internal/modules/esm/shared_constants.js b/lib/internal/modules/esm/shared_constants.js
index c9c9f8dd9552c5..4200bc87367d14 100644
--- a/lib/internal/modules/esm/shared_constants.js
+++ b/lib/internal/modules/esm/shared_constants.js
@@ -4,7 +4,7 @@
 'use strict';
 
 /*
-The shared memory area is divided in 1 32-bit long sections. It has to be 32-bit long as
+The shared memory area is divided in 1 32-bit long section. It has to be 32-bit long as
 `Atomics.notify` only works with `Int32Array` objects.
 
 --32-bits--
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 18c4e88452539d..8a1ef9add7060f 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -43,6 +43,7 @@ function wrapMessage(status, body) {
   if (status === 'success' || body === null || typeof body !== 'object') {
     return { status, body };
   }
+
   let serialized;
   let serializationFailed;
   try {
@@ -51,6 +52,7 @@ function wrapMessage(status, body) {
   } catch {
     serializationFailed = true;
   }
+
   return {
     status,
     body: {
@@ -112,14 +114,14 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
     AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
-    // Let's attach back the event handler.
+    // Attach back the event handler.
     syncCommPort.on('message', handleMessage);
-    // Let's also check synchronously for a message, in case it's already there.
+    // Also check synchronously for a message, in case it's already there.
     clearImmediate(immediate);
     checkForMessages();
     // We don't need the sync check after this tick, as we already have added the event handler.
     clearImmediate(immediate);
-    // Let's add some work for next tick so the worker cannot exit.
+    // Add some work for next tick so the worker cannot exit.
     setImmediate(() => {});
   });
 
@@ -183,7 +185,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
 /**
  * ! Run everything possible within this function so errors get reported.
  */
-module.exports = function(workerData, syncCommPort) {
+module.exports = function setupModuleWorker(workerData, syncCommPort) {
   const lock = new Int32Array(workerData.lock);
 
   function errorHandler(err, origin = 'unhandledRejection') {
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 0c1f60db136e61..d68149ea65ca6c 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -455,6 +455,10 @@ class Worker extends EventEmitter {
   }
 }
 
+/**
+ * A worker to be used internally by node (ex module/esm/worker). This functions as a siganal to
+ * handle its setup and script in a particular way.
+ */
 class InternalWorker extends Worker {
   constructor(filename, options) {
     super(filename, options, kIsInternal);

From acc09009156c2b33f2a2b35d1e8b669998c71ab0 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 13 Apr 2023 00:08:11 +0200
Subject: [PATCH 125/126] Update lib/internal/worker.js

---
 lib/internal/worker.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index d68149ea65ca6c..fee691419d9152 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -456,8 +456,7 @@ class Worker extends EventEmitter {
 }
 
 /**
- * A worker to be used internally by node (ex module/esm/worker). This functions as a siganal to
- * handle its setup and script in a particular way.
+ * A worker which has an internal module for entry point (e.g. internal/module/esm/worker).
  */
 class InternalWorker extends Worker {
   constructor(filename, options) {

From f02012f0ff023c97ac6b52f74c62712f958db025 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Thu, 13 Apr 2023 00:18:54 +0200
Subject: [PATCH 126/126] Update lib/internal/worker.js

---
 lib/internal/worker.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index fee691419d9152..eda9dbcdeb5c04 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -457,6 +457,7 @@ class Worker extends EventEmitter {
 
 /**
  * A worker which has an internal module for entry point (e.g. internal/module/esm/worker).
+ * Internal workers bypass the permission model.
  */
 class InternalWorker extends Worker {
   constructor(filename, options) {