diff --git a/doc/api/module.md b/doc/api/module.md
index 23acde86771dc3..160007121e050a 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -115,6 +115,16 @@ changes:
 Register a module that exports [hooks][] that customize Node.js module
 resolution and loading behavior. See [Customization hooks][].
 
+All hooks, despite of where they were registered (main thread or worker thread),
+are loaded and executed in a single shared thread that only serves hooks. Therefore any
+side effect present will affect all threads that use the same hook.
+
+If global data must be stored in hooks, make sure to scope it using the `thread`
+property that is present in the context of all customization hooks.
+
+All worker thread inherits the parent thread hooks chain when created. All subsequent modifications
+in the parent or worker thread do not affect other chains.
+
 ### `module.syncBuiltinESMExports()`
 
 <!-- YAML
@@ -363,7 +373,7 @@ module resolution and loading process. The exported functions must have specific
 names and signatures, and they must be exported as named exports.
 
 ```mjs
-export async function initialize({ number, port }) {
+export async function initialize({ number, port }, context) {
   // Receives data from `register`.
 }
 
@@ -404,6 +414,8 @@ added:
 > Stability: 1.2 - Release candidate
 
 * `data` {any} The data from `register(loader, import.meta.url, { data })`.
+* `context` {Object}
+  * `threadId` {string} The calling thread ID
 
 The `initialize` hook provides a way to define a custom function that runs in
 the hooks thread when the hooks module is initialized. Initialization happens
@@ -504,6 +516,8 @@ changes:
     attributes for the module to import
   * `parentURL` {string|undefined} The module importing this one, or undefined
     if this is the Node.js entry point
+  * `threadId` {string} The calling thread ID
+  * `data` {any} The data passed to `initialize`
 * `nextResolve` {Function} The subsequent `resolve` hook in the chain, or the
   Node.js default `resolve` hook after the last user-supplied `resolve` hook
   * `specifier` {string}
@@ -599,6 +613,8 @@ changes:
   * `format` {string|null|undefined} The format optionally supplied by the
     `resolve` hook chain
   * `importAttributes` {Object}
+  * `threadId` {string} The calling thread ID
+  * `data` {any} The data passed to `initialize`
 * `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}
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index aa329b9fe04f15..2ecc65ab3fff72 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -95,6 +95,7 @@ port.on('message', (message) => {
       filename,
       hasStdin,
       publicPort,
+      hooksPort,
       workerData,
     } = message;
 
@@ -109,6 +110,7 @@ port.on('message', (message) => {
     }
 
     require('internal/worker').assignEnvironmentData(environmentData);
+    require('internal/worker').hooksPort = hooksPort;
 
     if (SharedArrayBuffer !== undefined) {
       // The counter is only passed to the workers created by the main thread,
@@ -144,7 +146,13 @@ port.on('message', (message) => {
       case 'internal': {
         // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
         internalBinding('module_wrap').callbackMap = new SafeWeakMap();
-        require(filename)(workerData, publicPort);
+        let entrypoint = require(filename);
+
+        if (typeof entrypoint !== 'function') {
+          entrypoint = entrypoint.entrypoint;
+        }
+
+        entrypoint(workerData, publicPort);
         break;
       }
 
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index ba655116a0bb57..16ef4eaed3fe1a 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -12,9 +12,11 @@ const {
   ObjectSetPrototypeOf,
   Promise,
   ReflectSet,
+  SafeMap,
   SafeSet,
   StringPrototypeSlice,
   StringPrototypeToUpperCase,
+  Symbol,
   globalThis,
 } = primordials;
 
@@ -35,7 +37,7 @@ const {
 const { exitCodes: { kUnsettledTopLevelAwait } } = internalBinding('errors');
 const { URL } = require('internal/url');
 const { canParse: URLCanParse } = internalBinding('url');
-const { receiveMessageOnPort } = require('worker_threads');
+const { receiveMessageOnPort, threadId } = require('worker_threads');
 const {
   isAnyArrayBuffer,
   isArrayBufferView,
@@ -47,6 +49,7 @@ const {
 const {
   kEmptyObject,
 } = require('internal/util');
+const { isDeepStrictEqual } = require('internal/util/comparisons');
 
 const {
   defaultResolve,
@@ -61,6 +64,10 @@ const {
   SHARED_MEMORY_BYTE_LENGTH,
   WORKER_TO_MAIN_THREAD_NOTIFICATION,
 } = require('internal/modules/esm/shared_constants');
+
+const currentThreadId = threadId;
+const kDefaultChainId = Symbol('kDefaultChainId');
+
 let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {
   debug = fn;
 });
@@ -68,6 +75,33 @@ let importMetaInitializer;
 
 let importAssertionAlreadyWarned = false;
 
+const defaultChains = {
+  /**
+   * Phase 1 of 2 in ESM loading.
+   * The output of the `resolve` chain of hooks is passed into the `load` chain of hooks.
+   * @private
+   * @property {KeyedHook[]} resolve Last-in-first-out collection of resolve hooks.
+   */
+  resolve: [
+    {
+      fn: defaultResolve,
+      url: 'node:internal/modules/esm/resolve',
+    },
+  ],
+
+  /**
+   * Phase 2 of 2 in ESM loading.
+   * @private
+   * @property {KeyedHook[]} load Last-in-first-out collection of loader hooks.
+   */
+  load: [
+    {
+      fn: require('internal/modules/esm/load').defaultLoad,
+      url: 'node:internal/modules/esm/load',
+    },
+  ],
+};
+
 function emitImportAssertionWarning() {
   if (!importAssertionAlreadyWarned) {
     importAssertionAlreadyWarned = true;
@@ -106,32 +140,7 @@ function defineImportAssertionAlias(context) {
 // [2] `validate...()`s throw the wrong error
 
 class Hooks {
-  #chains = {
-    /**
-     * Phase 1 of 2 in ESM loading.
-     * The output of the `resolve` chain of hooks is passed into the `load` chain of hooks.
-     * @private
-     * @property {KeyedHook[]} resolve Last-in-first-out collection of resolve hooks.
-     */
-    resolve: [
-      {
-        fn: defaultResolve,
-        url: 'node:internal/modules/esm/resolve',
-      },
-    ],
-
-    /**
-     * Phase 2 of 2 in ESM loading.
-     * @private
-     * @property {KeyedHook[]} load Last-in-first-out collection of loader hooks.
-     */
-    load: [
-      {
-        fn: require('internal/modules/esm/load').defaultLoad,
-        url: 'node:internal/modules/esm/load',
-      },
-    ],
-  };
+  #chains = new SafeMap();
 
   // Cache URLs we've already validated to avoid repeated validation
   #validatedUrls = new SafeSet();
@@ -142,43 +151,66 @@ class Hooks {
    * Import and register custom/user-defined module loader hook(s).
    * @param {string} urlOrSpecifier
    * @param {string} parentURL
+   * @param {number} [threadId]
    * @param {any} [data] Arbitrary data to be passed from the custom
+   * @param {boolean} [fromLoader]
    * loader (user-land) to the worker.
    */
-  async register(urlOrSpecifier, parentURL, data) {
+  async register(urlOrSpecifier, parentURL, threadId, data, fromLoader) {
     const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
     const keyedExports = await cascadedLoader.import(
       urlOrSpecifier,
       parentURL,
       kEmptyObject,
     );
-    await this.addCustomLoader(urlOrSpecifier, keyedExports, data);
+
+    await this.addCustomLoader(urlOrSpecifier, keyedExports, threadId, data);
+
+    // If we registered as part of --experimental-loader, make sure we also register
+    // for the hooks thread to influence other loaders
+    if (fromLoader) {
+      await this.addCustomLoader(urlOrSpecifier, keyedExports, currentThreadId, data);
+    }
   }
 
+
   /**
    * Collect custom/user-defined module loader hook(s).
    * @param {string} url Custom loader specifier
    * @param {Record<string, unknown>} exports
-   * @param {any} [data] Arbitrary data to be passed from the custom loader (user-land)
-   * to the worker.
+   * @param {number} [threadId]
+   * @param {any} [data] Arbitrary data to be passed from the custom loader (user-land) to the worker.
    * @returns {any | Promise<any>} User data, ignored unless it's a promise, in which case it will be awaited.
    */
-  addCustomLoader(url, exports, data) {
+  addCustomLoader(url, exports, threadId, data) {
     const {
       initialize,
       resolve,
       load,
     } = pluckHooks(exports);
 
+    const chain = this.getChain(threadId);
+
+    // Do not register the same hook with the same data
+    for (const hook of chain.registered) {
+      if (hook.url === url && (typeof data === 'undefined' || isDeepStrictEqual(hook.data, data))) {
+        return undefined;
+      }
+    }
+
+    ArrayPrototypePush(chain.registered, { url, data });
+
     if (resolve) {
-      const next = this.#chains.resolve[this.#chains.resolve.length - 1];
-      ArrayPrototypePush(this.#chains.resolve, { __proto__: null, fn: resolve, url, next });
+      const next = chain.resolve[chain.resolve.length - 1];
+      ArrayPrototypePush(chain.resolve, { __proto__: null, fn: resolve, url, next, data });
     }
+
     if (load) {
-      const next = this.#chains.load[this.#chains.load.length - 1];
-      ArrayPrototypePush(this.#chains.load, { __proto__: null, fn: load, url, next });
+      const next = chain.load[chain.load.length - 1];
+      ArrayPrototypePush(chain.load, { __proto__: null, fn: load, url, next, data });
     }
-    return initialize?.(data);
+
+    return initialize?.(data, { threadId });
   }
 
   /**
@@ -192,20 +224,24 @@ class Hooks {
    * @param {string} [parentURL] The URL path of the module's parent.
    * @param {ImportAttributes} [importAttributes] Attributes from the import
    *                                              statement or expression.
+   * @param {number} [threadId]
    * @returns {Promise<{ format: string, url: URL['href'] }>}
    */
   async resolve(
     originalSpecifier,
     parentURL,
     importAttributes = { __proto__: null },
+    threadId,
   ) {
     throwIfInvalidParentURL(parentURL);
 
-    const chain = this.#chains.resolve;
+    const chain = this.getChain(threadId).resolve;
+
     const context = {
       conditions: getDefaultConditions(),
       importAttributes,
       parentURL,
+      threadId,
     };
     const meta = {
       chainFinished: null,
@@ -329,10 +365,11 @@ class Hooks {
    * until it reaches the bottom or short-circuits.
    * @param {URL['href']} url The URL/path of the module to be loaded
    * @param {object} context Metadata about the module
+   * @param {number} [threadId]
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
-  async load(url, context = {}) {
-    const chain = this.#chains.load;
+  async load(url, context, threadId) {
+    const chain = this.getChain(threadId).load;
     const meta = {
       chainFinished: null,
       context,
@@ -341,6 +378,9 @@ class Hooks {
       shortCircuited: false,
     };
 
+    context ??= {};
+    context.threadId = threadId;
+
     const validateArgs = (hookErrIdentifier, nextUrl, ctx) => {
       if (typeof nextUrl !== 'string') {
         // Non-strings can be coerced to a URL string
@@ -463,6 +503,45 @@ class Hooks {
     meta = importMetaInitializer(meta, context, loader);
     return meta;
   }
+
+  getChain(id) {
+    // Do not use `if(!id)` here - id is actually a threadId so it might be 0.
+    if (typeof id === 'undefined') {
+      id = kDefaultChainId;
+    }
+
+    if (!this.#chains.has(id)) {
+      this.#chains.set(id, {
+        resolve: [...defaultChains.resolve],
+        load: [...defaultChains.load],
+        registered: [],
+      });
+    }
+
+    return this.#chains.get(id);
+  }
+
+  getChains() {
+    return this.#chains;
+  }
+
+  copyChain(from, to) {
+    if (!this.#chains.has(from)) {
+      this.#chains.set(to, {
+        resolve: [...defaultChains.resolve],
+        load: [...defaultChains.load],
+        registered: [],
+      });
+
+      return;
+    }
+
+    this.#chains.set(to, this.#chains.get(from));
+  }
+
+  deleteChain(id) {
+    this.#chains.delete(id);
+  }
 }
 ObjectSetPrototypeOf(Hooks.prototype, null);
 
@@ -478,10 +557,12 @@ class HooksProxy {
    */
   #lock;
   /**
-   * The InternalWorker instance, which lets us communicate with the loader thread.
+   * The HooksWorker instance, which lets us communicate with the loader thread.
    */
   #worker;
 
+  #portToHooksThread;
+
   /**
    * 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
@@ -499,26 +580,51 @@ class HooksProxy {
   #isReady = false;
 
   constructor() {
-    const { InternalWorker } = require('internal/worker');
-    MessageChannel ??= require('internal/worker/io').MessageChannel;
-
+    const { HooksWorker, hooksPort } = require('internal/worker');
     const lock = new SharedArrayBuffer(SHARED_MEMORY_BYTE_LENGTH);
     this.#lock = new Int32Array(lock);
 
-    this.#worker = new InternalWorker(loaderWorkerId, {
-      stderr: false,
-      stdin: false,
-      stdout: false,
-      trackUnmanagedFds: false,
-      workerData: {
-        lock,
-      },
-    });
-    this.#worker.unref(); // ! Allows the process to eventually exit.
-    this.#worker.on('exit', process.exit);
+    try {
+      // The customization hooks thread is only created once. All other threads reuse
+      // the existing instance. If another thread created it, the constructor will throw
+      // Fallback is to use the existing hooksPort created by the thread that originally
+      // spawned the customization hooks thread.
+      this.#worker = new HooksWorker(loaderWorkerId, {
+        stderr: false,
+        stdin: false,
+        stdout: false,
+        trackUnmanagedFds: false,
+        workerData: {
+          lock,
+        },
+      });
+      this.#worker.unref(); // ! Allows the process to eventually exit.
+      this.#worker.on('exit', process.exit);
+      this.#portToHooksThread = this.#worker;
+
+      // Clear our chain when exiting.
+      process.once('beforeExit', () => {
+        this.makeAsyncRequest('deleteChain', undefined, threadId);
+      });
+    } catch (e) {
+      if (e.code === 'ERR_HOOKS_THREAD_EXISTS') {
+        this.#portToHooksThread = hooksPort;
+      } else {
+        throw e;
+      }
+    }
   }
 
   waitForWorker() {
+    // There is one Hooks instance for each worker thread. But only one of
+    // these Hooks instances has a HooksWorker. That was the Hooks instance
+    // created for the first thread that registers a hook set.
+    // It means for all Hooks instances that are not on that thread => they are
+    // done because they delegate to the single InternalWorker.
+    if (!this.#worker) {
+      return;
+    }
+
     if (!this.#isReady) {
       const { kIsOnline } = require('internal/worker');
       if (!this.#worker[kIsOnline]) {
@@ -535,6 +641,37 @@ class HooksProxy {
     }
   }
 
+  #postMessageToWorker(method, type, transferList, args) {
+    this.waitForWorker();
+
+    MessageChannel ??= require('internal/worker/io').MessageChannel;
+
+    const {
+      port1: fromHooksThread,
+      port2: toHooksThread,
+    } = new MessageChannel();
+
+    // Pass work to the worker.
+    debug(`post ${type} message to worker`, { method, args, transferList });
+    const usedTransferList = [toHooksThread];
+    if (transferList) {
+      ArrayPrototypePushApply(usedTransferList, transferList);
+    }
+
+    this.#portToHooksThread.postMessage(
+      {
+        __proto__: null,
+        args,
+        lock: this.#lock,
+        method,
+        port: toHooksThread,
+      },
+      usedTransferList,
+    );
+
+    return fromHooksThread;
+  }
+
   /**
    * Invoke a remote method asynchronously.
    * @param {string} method Method to invoke
@@ -543,22 +680,13 @@ class HooksProxy {
    * @returns {Promise<any>}
    */
   async makeAsyncRequest(method, transferList, ...args) {
-    this.waitForWorker();
-
-    MessageChannel ??= require('internal/worker/io').MessageChannel;
-    const asyncCommChannel = new MessageChannel();
+    const handleInternalMessage = require('internal/modules/esm/worker').handleInternalMessage;
 
-    // Pass work to the worker.
-    debug('post async message to worker', { method, args, transferList });
-    const finalTransferList = [asyncCommChannel.port2];
-    if (transferList) {
-      ArrayPrototypePushApply(finalTransferList, transferList);
+    if (handleInternalMessage) {
+      return handleInternalMessage({ method, args });
     }
-    this.#worker.postMessage({
-      __proto__: null,
-      method, args,
-      port: asyncCommChannel.port2,
-    }, finalTransferList);
+
+    const fromHooksThread = this.#postMessageToWorker(method, 'Async', transferList, args);
 
     if (this.#numberOfPendingAsyncResponses++ === 0) {
       // On the next lines, the main thread will await a response from the worker thread that might
@@ -567,7 +695,11 @@ class HooksProxy {
       // 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 ref the worker until we get all the
       // responses back.
-      this.#worker.ref();
+      if (this.#worker) {
+        this.#worker.ref();
+      } else {
+        this.#portToHooksThread.ref();
+      }
     }
 
     let response;
@@ -576,18 +708,26 @@ class HooksProxy {
       await AtomicsWaitAsync(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, this.#workerNotificationLastId).value;
       this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
-      response = receiveMessageOnPort(asyncCommChannel.port1);
+      response = receiveMessageOnPort(fromHooksThread);
     } while (response == null);
     debug('got async response from worker', { method, args }, this.#lock);
 
     if (--this.#numberOfPendingAsyncResponses === 0) {
       // We got all the responses from the worker, its job is done (until next time).
-      this.#worker.unref();
+      if (this.#worker) {
+        this.#worker.unref();
+      } else {
+        this.#portToHooksThread.unref();
+      }
     }
 
-    const body = this.#unwrapMessage(response);
-    asyncCommChannel.port1.close();
-    return body;
+    if (response.message.status === 'exit') {
+      process.exit(response.message.body);
+    }
+
+    fromHooksThread.close();
+
+    return this.#unwrapMessage(response);
   }
 
   /**
@@ -598,11 +738,13 @@ class HooksProxy {
    * @returns {any}
    */
   makeSyncRequest(method, transferList, ...args) {
-    this.waitForWorker();
+    const handleInternalMessage = require('internal/modules/esm/worker').handleInternalMessage;
 
-    // Pass work to the worker.
-    debug('post sync message to worker', { method, args, transferList });
-    this.#worker.postMessage({ __proto__: null, method, args }, transferList);
+    if (handleInternalMessage) {
+      return handleInternalMessage({ method, args });
+    }
+
+    const fromHooksThread = this.#postMessageToWorker(method, 'Sync', transferList, args);
 
     let response;
     do {
@@ -611,7 +753,7 @@ class HooksProxy {
       AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, this.#workerNotificationLastId);
       this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
-      response = this.#worker.receiveMessageSync();
+      response = receiveMessageOnPort(fromHooksThread);
     } while (response == null);
     debug('got sync response from worker', { method, args });
     if (response.message.status === 'never-settle') {
@@ -619,6 +761,9 @@ class HooksProxy {
     } else if (response.message.status === 'exit') {
       process.exit(response.message.body);
     }
+
+    fromHooksThread.close();
+
     return this.#unwrapMessage(response);
   }
 
@@ -711,6 +856,7 @@ function nextHookFactory(current, meta, { validateArgs, validateOutput }) {
     fn: hook,
     url: hookFilePath,
     next,
+    data,
   } = current;
 
   // ex 'nextResolve'
@@ -747,7 +893,7 @@ function nextHookFactory(current, meta, { validateArgs, validateOutput }) {
         ObjectAssign(meta.context, context);
       }
 
-      const output = await hook(arg0, meta.context, nextNextHook);
+      const output = await hook(arg0, { ...meta.context, data }, nextNextHook);
       validateOutput(outputErrIdentifier, output);
 
       if (output?.shortCircuit === true) { meta.shortCircuited = true; }
@@ -759,6 +905,7 @@ function nextHookFactory(current, meta, { validateArgs, validateOutput }) {
   );
 }
 
-
-exports.Hooks = Hooks;
-exports.HooksProxy = HooksProxy;
+module.exports = {
+  Hooks,
+  HooksProxy,
+};
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index afb0e9fd9ec1c6..2ed440463fea5c 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -36,11 +36,14 @@ const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
 const { kImplicitTypeAttribute } = require('internal/modules/esm/assert');
+const { HooksProxy } = require('internal/modules/esm/hooks');
 const { canParse } = internalBinding('url');
 const { ModuleWrap, kEvaluating, kEvaluated } = internalBinding('module_wrap');
 const {
   urlToFilename,
 } = require('internal/modules/helpers');
+const { threadId } = require('worker_threads');
+const { hasHooksThread } = require('internal/worker');
 let defaultResolve, defaultLoad, defaultLoadSync, importMetaInitializer;
 
 /**
@@ -206,6 +209,11 @@ class ModuleLoader {
     }
   }
 
+  // This method is only used for internal testing
+  getCustomizations() {
+    return this.#customizations;
+  }
+
   async eval(source, url, isEntryPoint = false) {
     const evalInstance = (url) => {
       return compileSourceTextModule(url, source, this);
@@ -478,7 +486,7 @@ class ModuleLoader {
   /**
    * @see {@link CustomizedModuleLoader.register}
    */
-  register(specifier, parentURL, data, transferList) {
+  register(specifier, parentURL, data, transferList, threadId, fromLoader) {
     if (!this.#customizations) {
       // `CustomizedModuleLoader` is defined at the bottom of this file and
       // available well before this line is ever invoked. This is here in
@@ -486,7 +494,10 @@ class ModuleLoader {
       // eslint-disable-next-line no-use-before-define
       this.setCustomizations(new CustomizedModuleLoader());
     }
-    return this.#customizations.register(`${specifier}`, `${parentURL}`, data, transferList);
+
+    return this.#customizations.register(
+      `${specifier}`, `${parentURL}`, data, transferList, threadId, fromLoader,
+    );
   }
 
   /**
@@ -500,7 +511,7 @@ class ModuleLoader {
    */
   resolve(originalSpecifier, parentURL, importAttributes) {
     if (this.#customizations) {
-      return this.#customizations.resolve(originalSpecifier, parentURL, importAttributes);
+      return this.#customizations.resolve(originalSpecifier, parentURL, importAttributes, threadId);
     }
     const requestKey = this.#resolveCache.serializeKey(originalSpecifier, importAttributes);
     const cachedResult = this.#resolveCache.get(requestKey, parentURL);
@@ -610,7 +621,7 @@ class CustomizedModuleLoader {
   }
 
   /**
-   * Register some loader specifier.
+   * Register a loader specifier.
    * @param {string} originalSpecifier The specified URL path of the loader to
    *                                   be registered.
    * @param {string} parentURL The parent URL from where the loader will be
@@ -618,10 +629,20 @@ class CustomizedModuleLoader {
    * @param {any} [data] Arbitrary data to be passed from the custom loader
    * (user-land) to the worker.
    * @param {any[]} [transferList] Objects in `data` that are changing ownership
-   * @returns {{ format: string, url: URL['href'] }}
+   * @param {number} [threadId]
+   * @param {boolean} [fromLoader]
+   * @returns {{ format: string, url: URL['href'] } | undefined}
    */
-  register(originalSpecifier, parentURL, data, transferList) {
-    return hooksProxy.makeSyncRequest('register', transferList, originalSpecifier, parentURL, data);
+  register(originalSpecifier, parentURL, data, transferList, threadId, fromLoader) {
+    return hooksProxy.makeSyncRequest(
+      'register',
+      transferList,
+      originalSpecifier,
+      parentURL,
+      threadId,
+      data,
+      fromLoader,
+    );
   }
 
   /**
@@ -634,12 +655,26 @@ class CustomizedModuleLoader {
    * @returns {{ format: string, url: URL['href'] }}
    */
   resolve(originalSpecifier, parentURL, importAttributes) {
-    return hooksProxy.makeAsyncRequest('resolve', undefined, originalSpecifier, parentURL, importAttributes);
+    return hooksProxy.makeAsyncRequest(
+      'resolve',
+      undefined,
+      originalSpecifier,
+      parentURL,
+      importAttributes,
+      threadId,
+    );
   }
 
   resolveSync(originalSpecifier, parentURL, importAttributes) {
     // This happens only as a result of `import.meta.resolve` calls, which must be sync per spec.
-    return hooksProxy.makeSyncRequest('resolve', undefined, originalSpecifier, parentURL, importAttributes);
+    return hooksProxy.makeSyncRequest(
+      'resolve',
+      undefined,
+      originalSpecifier,
+      parentURL,
+      importAttributes,
+      threadId,
+    );
   }
 
   /**
@@ -649,10 +684,22 @@ class CustomizedModuleLoader {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   load(url, context) {
-    return hooksProxy.makeAsyncRequest('load', undefined, url, context);
+    return hooksProxy.makeAsyncRequest(
+      'load',
+      undefined,
+      url,
+      context,
+      threadId,
+    );
   }
   loadSync(url, context) {
-    return hooksProxy.makeSyncRequest('load', undefined, url, context);
+    return hooksProxy.makeSyncRequest(
+      'load',
+      undefined,
+      url,
+      context,
+      threadId,
+    );
   }
 
   importMetaInitialize(meta, context, loader) {
@@ -699,6 +746,8 @@ function createModuleLoader() {
         emittedLoaderFlagWarning = true;
       }
       customizations = new CustomizedModuleLoader();
+    } else if (hasHooksThread()) {
+      customizations = new CustomizedModuleLoader();
     }
   }
 
@@ -712,7 +761,6 @@ function createModuleLoader() {
  */
 function getHooksProxy() {
   if (!hooksProxy) {
-    const { HooksProxy } = require('internal/modules/esm/hooks');
     hooksProxy = new HooksProxy();
   }
 
@@ -770,11 +818,13 @@ function register(specifier, parentURL = undefined, options) {
     options = parentURL;
     parentURL = options.parentURL;
   }
+
   getOrInitializeCascadedLoader().register(
     specifier,
     parentURL ?? 'data:',
     options?.data,
     options?.transferList,
+    threadId,
   );
 }
 
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index d393d4336a0c1e..a8cf347d4be088 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -37,7 +37,6 @@ const {
 } = require('internal/process/pre_execution');
 const {
   emitExperimentalWarning,
-  getCWDURL,
 } = require('internal/util');
 const {
   setImportModuleDynamicallyCallback,
@@ -294,8 +293,6 @@ function forceDefaultLoader() {
  * Register module customization hooks.
  */
 async function initializeHooks() {
-  const customLoaderURLs = getOptionValue('--experimental-loader');
-
   const { Hooks } = require('internal/modules/esm/hooks');
   const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
 
@@ -312,14 +309,6 @@ async function initializeHooks() {
   loadPreloadModules();
   initializeFrozenIntrinsics();
 
-  const parentURL = getCWDURL().href;
-  for (let i = 0; i < customLoaderURLs.length; i++) {
-    await hooks.register(
-      customLoaderURLs[i],
-      parentURL,
-    );
-  }
-
   return hooks;
 }
 
diff --git a/lib/internal/modules/esm/worker.js b/lib/internal/modules/esm/worker.js
index 311d77fb099384..ab1fecf4e225fd 100644
--- a/lib/internal/modules/esm/worker.js
+++ b/lib/internal/modules/esm/worker.js
@@ -1,6 +1,8 @@
 'use strict';
 
 const {
+  ArrayPrototypeFilter,
+  ArrayPrototypePush,
   AtomicsAdd,
   AtomicsNotify,
   DataViewPrototypeGetBuffer,
@@ -97,7 +99,21 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     // so it can detect the exit event.
     const { exit } = process;
     process.exit = function(code) {
-      syncCommPort.postMessage(wrapMessage('exit', code ?? process.exitCode));
+      const exitMsg = wrapMessage('exit', code ?? process.exitCode);
+      if (hooks) {
+        for (let i = 0; i < allThreadRegisteredHandlerPorts.length; i++) {
+          const { port: registeredPort } = allThreadRegisteredHandlerPorts[i];
+          registeredPort.postMessage(exitMsg);
+        }
+
+        for (const { port, lock: operationLock } of unsettledResponsePorts) {
+          port.postMessage(exitMsg);
+          // Wake all threads that have pending operations.
+          AtomicsAdd(operationLock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
+          AtomicsNotify(operationLock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
+        }
+      }
+      syncCommPort.postMessage(exitMsg);
       AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
       AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
       return ReflectApply(exit, this, arguments);
@@ -145,8 +161,11 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
   const unsettledResponsePorts = new SafeSet();
 
   process.on('beforeExit', () => {
-    for (const port of unsettledResponsePorts) {
+    for (const { port, lock: operationLock } of unsettledResponsePorts) {
       port.postMessage(wrapMessage('never-settle'));
+      // Wake all threads that have pending operations.
+      AtomicsAdd(operationLock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
+      AtomicsNotify(operationLock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     }
     unsettledResponsePorts.clear();
 
@@ -164,24 +183,63 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     setImmediate(() => {});
   });
 
+  let allThreadRegisteredHandlerPorts = [];
+  /**
+   * @callback registerHandler
+   * @param {MessagePort} toWorkerThread - Upon Worker creation a message channel between the new Worker
+   * and the Hooks thread is being initialized. This is the MessagePort that the Hooks thread will use post
+   * messages to the worker. The other MessagePort is passed to the new Worker itself via LOAD_SCRIPT message
+   */
+  function registerHandler(toWorkerThread, registeredThreadId, parentThreadId) {
+    hooks.copyChain(parentThreadId, registeredThreadId);
+
+    toWorkerThread.on('message', handleMessage);
+    ArrayPrototypePush(allThreadRegisteredHandlerPorts, { port: toWorkerThread, registeredThreadId });
+  }
+
+  /**
+   * @callback registerHandler
+   * @param {number} unregisteredThreadId - the thread id of the worker thread that is being unregistered
+   * from the Hooks Thread
+   */
+  function unregisterHandler(unregisteredThreadId) {
+    hooks.deleteChain(unregisteredThreadId);
+
+    allThreadRegisteredHandlerPorts = ArrayPrototypeFilter(
+      allThreadRegisteredHandlerPorts, (el) => el.registeredThreadId !== unregisteredThreadId);
+  }
+
+  function getMessageHandler(method) {
+    if (method === '#registerWorkerClient') {
+      return registerHandler;
+    }
+    if (method === '#unregisterWorkerClient') {
+      return unregisterHandler;
+    }
+    return hooks[method];
+  }
+
   /**
    * Handles incoming messages from the main thread or other workers.
    * @param {object} options - The options object.
    * @param {string} options.method - The name of the hook.
    * @param {Array} options.args - The arguments to pass to the method.
    * @param {MessagePort} options.port - The message port to use for communication.
+   * @param {Int32Array} options.lock - The shared memory where the caller expects to get awaken.
    */
-  async function handleMessage({ method, args, port }) {
+  async function handleMessage({ method, args, port, lock: msgLock }) {
     // 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');
+    const messageHandler = getMessageHandler(method);
+    assert(typeof messageHandler === '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;
     }
+    const usedLock = msgLock ?? lock;
 
     // 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
@@ -192,17 +250,19 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     clearImmediate(immediate);
     immediate = setImmediate(checkForMessages).unref();
 
-    unsettledResponsePorts.add(port ?? syncCommPort);
+    const unsettledActionData = { port: port ?? syncCommPort, lock: usedLock };
+
+    unsettledResponsePorts.add(unsettledActionData);
 
     let response;
     try {
-      response = await ReflectApply(hooks[method], hooks, args);
+      response = await ReflectApply(messageHandler, hooks, args);
     } catch (exception) {
       hasError = true;
       response = exception;
     }
 
-    unsettledResponsePorts.delete(port ?? syncCommPort);
+    unsettledResponsePorts.delete(unsettledActionData);
 
     // Send the method response (or exception) to the main thread.
     try {
@@ -215,8 +275,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
       (port ?? syncCommPort).postMessage(wrapMessage('error', exception));
     }
 
-    AtomicsAdd(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
-    AtomicsNotify(lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
+    AtomicsAdd(usedLock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 1);
+    AtomicsNotify(usedLock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
     if (shouldRemoveGlobalErrorHandler) {
       process.off('uncaughtException', errorHandler);
     }
@@ -226,6 +286,8 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
     clearImmediate(immediate);
     immediate = setImmediate(checkForMessages).unref();
   }
+
+  module.exports.handleInternalMessage = handleMessage;
 }
 
 /**
@@ -234,7 +296,7 @@ async function customizedModuleWorker(lock, syncCommPort, errorHandler) {
  * @param {{lock: SharedArrayBuffer}} workerData - The lock used to synchronize with the main thread.
  * @param {MessagePort} syncCommPort - The communication port used to communicate with the main thread.
  */
-module.exports = function setupModuleWorker(workerData, syncCommPort) {
+function setupModuleWorker(workerData, syncCommPort) {
   const lock = new Int32Array(workerData.lock);
 
   /**
@@ -262,3 +324,8 @@ module.exports = function setupModuleWorker(workerData, syncCommPort) {
     errorHandler,
   );
 };
+
+module.exports = {
+  entrypoint: setupModuleWorker,
+  handleInternalMessage: undefined,
+};
diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js
index 6c5601ed458b89..bab46f092d10f1 100644
--- a/lib/internal/modules/run_main.js
+++ b/lib/internal/modules/run_main.js
@@ -97,9 +97,21 @@ function shouldUseESMLoader(mainPath) {
 async function asyncRunEntryPointWithESMLoader(callback) {
   const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
   try {
+    const parentURL = getCWDURL().href;
+
+    const experimentalLoaders = getOptionValue('--experimental-loader');
+    if (experimentalLoaders.length > 0) {
+      const { threadId } = require('worker_threads');
+
+      for (let i = 0; i < experimentalLoaders.length; i++) {
+        await cascadedLoader.register(
+          experimentalLoaders[i], parentURL, undefined, undefined, threadId, true,
+        );
+      }
+    }
+
     const userImports = getOptionValue('--import');
     if (userImports.length > 0) {
-      const parentURL = getCWDURL().href;
       for (let i = 0; i < userImports.length; i++) {
         await cascadedLoader.import(userImports[i], parentURL, kEmptyObject);
       }
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 9eefaa97021756..8186741ddd83e5 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -69,6 +69,7 @@ const {
   resourceLimits: resourceLimitsRaw,
   threadId,
   Worker: WorkerImpl,
+  hasHooksThread,
   kMaxYoungGenerationSizeMb,
   kMaxOldGenerationSizeMb,
   kCodeRangeSizeMb,
@@ -132,7 +133,7 @@ class Worker extends EventEmitter {
   constructor(filename, options = kEmptyObject) {
     throwIfBuildingSnapshot('Creating workers');
     super();
-    const isInternal = arguments[2] === kIsInternal;
+    const isInternal = this.#isInternal = arguments[2] === kIsInternal;
     debug(
       `[${threadId}] create new worker`,
       filename,
@@ -258,9 +259,19 @@ class Worker extends EventEmitter {
                          ...new SafeArrayIterator(options.transferList));
 
     this[kPublicPort] = port1;
+    const {
+      port1: toWorkerThread,
+      port2: toHooksThread,
+    } = new MessageChannel();
+    if (!isInternal) {
+      // This is not an internal hooks thread => it needs a channel to the hooks thread:
+      // - send it one side of a channel here
+      ArrayPrototypePush(transferList, toHooksThread);
+    }
     ArrayPrototypeForEach(['message', 'messageerror'], (event) => {
       this[kPublicPort].on(event, (message) => this.emit(event, message));
     });
+
     setupPortReferencing(this[kPublicPort], this, 'message');
     this[kPort].postMessage({
       argv,
@@ -272,8 +283,17 @@ class Worker extends EventEmitter {
       workerData: options.workerData,
       environmentData,
       publicPort: port2,
+      hooksPort: !isInternal ? toHooksThread : undefined,
       hasStdin: !!options.stdin,
     }, transferList);
+
+    if (!isInternal && hasHooksThread()) {
+      // - send the second side of the channel to the hooks thread,
+      // also announce the threadId of the Worker that will use that port.
+      // This is needed for the cleanup stage
+      require('internal/modules/esm/loader').getHooksProxy().makeSyncRequest(
+        '#registerWorkerClient', [toWorkerThread], toWorkerThread, this.threadId, threadId);
+    }
     // Use this to cache the Worker's loopStart value once available.
     this[kLoopStartTime] = -1;
     this[kIsOnline] = false;
@@ -293,6 +313,12 @@ class Worker extends EventEmitter {
 
   [kOnExit](code, customErr, customErrReason) {
     debug(`[${threadId}] hears end event for Worker ${this.threadId}`);
+
+    if (!this.#isInternal && hasHooksThread()) {
+      require('internal/modules/esm/loader').getHooksProxy()?.makeAsyncRequest(
+        '#unregisterWorkerClient', undefined, this.threadId,
+      );
+    }
     drainMessagePort(this[kPublicPort]);
     drainMessagePort(this[kPort]);
     this.removeAllListeners('message');
@@ -435,6 +461,8 @@ class Worker extends EventEmitter {
     return makeResourceLimits(this[kHandle].getResourceLimits());
   }
 
+  #isInternal = false;
+
   getHeapSnapshot(options) {
     const {
       HeapSnapshotStream,
@@ -452,10 +480,10 @@ 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.
+ * A worker which is used to by the customization hooks thread (internal/module/esm/worker).
+ * This bypasses the permission model.
  */
-class InternalWorker extends Worker {
+class HooksWorker extends Worker {
   constructor(filename, options) {
     super(filename, options, kIsInternal);
   }
@@ -532,12 +560,14 @@ module.exports = {
   kIsOnline,
   isMainThread,
   SHARE_ENV,
+  hooksPort: undefined,
+  hasHooksThread,
   resourceLimits:
     !isMainThread ? makeResourceLimits(resourceLimitsRaw) : {},
   setEnvironmentData,
   getEnvironmentData,
   assignEnvironmentData,
   threadId,
-  InternalWorker,
+  HooksWorker,
   Worker,
 };
diff --git a/src/handle_wrap.cc b/src/handle_wrap.cc
index f651b81ca8ce6b..1fbe0178c7a10d 100644
--- a/src/handle_wrap.cc
+++ b/src/handle_wrap.cc
@@ -148,7 +148,8 @@ void HandleWrap::OnClose(uv_handle_t* handle) {
   wrap->OnClose();
   wrap->handle_wrap_queue_.Remove();
 
-  if (!wrap->persistent().IsEmpty() &&
+  if (!env->isolate()->IsExecutionTerminating() &&
+      !wrap->persistent().IsEmpty() &&
       wrap->object()
           ->Has(env->context(), env->handle_onclose_symbol())
           .FromMaybe(false)) {
diff --git a/src/node_errors.h b/src/node_errors.h
index 0a74373cf5d333..9aeb154f7cd8dc 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -70,6 +70,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_DLOPEN_FAILED, Error)                                                  \
   V(ERR_ENCODING_INVALID_ENCODED_DATA, TypeError)                              \
   V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error)                            \
+  V(ERR_HOOKS_THREAD_EXISTS, Error)                                            \
   V(ERR_ILLEGAL_CONSTRUCTOR, Error)                                            \
   V(ERR_INVALID_ADDRESS, Error)                                                \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
diff --git a/src/node_worker.cc b/src/node_worker.cc
index bc43cb42934ba9..6c36e1c767af6d 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -46,6 +46,8 @@ namespace node {
 namespace worker {
 
 constexpr double kMB = 1024 * 1024;
+std::atomic_bool Worker::hooksWorkerExists{false};
+Mutex Worker::instantiationMutex;
 
 Worker::Worker(Environment* env,
                Local<Object> wrap,
@@ -483,6 +485,7 @@ Worker::~Worker() {
 }
 
 void Worker::New(const FunctionCallbackInfo<Value>& args) {
+  Mutex::ScopedLock lock(instantiationMutex);
   Environment* env = Environment::GetCurrent(args);
   auto is_internal = args[5];
   CHECK(is_internal->IsBoolean());
@@ -494,6 +497,16 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
 
   CHECK(args.IsConstructCall());
 
+  if (is_internal->IsTrue()) {
+    if (hooksWorkerExists) {
+      isolate->ThrowException(ERR_HOOKS_THREAD_EXISTS(
+          isolate, "Customization hooks thread already exists"));
+      return;
+    } else {
+      hooksWorkerExists = true;
+    }
+  }
+
   if (env->isolate_data()->platform() == nullptr) {
     THROW_ERR_MISSING_PLATFORM_FOR_WORKER(env);
     return;
@@ -903,6 +916,10 @@ void Worker::LoopStartTime(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(loop_start_time / 1e6);
 }
 
+void Worker::HasHooksThread(const FunctionCallbackInfo<Value>& args) {
+  args.GetReturnValue().Set(Worker::hooksWorkerExists);
+}
+
 namespace {
 
 // Return the MessagePort that is global for this Environment and communicates
@@ -940,6 +957,8 @@ void CreateWorkerPerIsolateProperties(IsolateData* isolate_data,
     SetProtoMethod(isolate, w, "loopStartTime", Worker::LoopStartTime);
 
     SetConstructorFunction(isolate, target, "Worker", w);
+    SetMethodNoSideEffect(
+        isolate, target, "hasHooksThread", Worker::HasHooksThread);
   }
 
   {
@@ -1011,6 +1030,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Worker::TakeHeapSnapshot);
   registry->Register(Worker::LoopIdleTime);
   registry->Register(Worker::LoopStartTime);
+  registry->Register(Worker::HasHooksThread);
 }
 
 }  // anonymous namespace
diff --git a/src/node_worker.h b/src/node_worker.h
index 07fd7b460654e1..e56cffa8808b1d 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <atomic>
 #include <optional>
 #include <unordered_map>
 #include "node_exit_code.h"
@@ -76,6 +77,7 @@ class Worker : public AsyncWrap {
   static void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void LoopIdleTime(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasHooksThread(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  private:
   bool CreateEnvMessagePort(Environment* env);
@@ -102,6 +104,9 @@ class Worker : public AsyncWrap {
   uintptr_t stack_base_ = 0;
   // Optional name used for debugging in inspector and trace events.
   std::string name_;
+  static std::atomic_bool hooksWorkerExists;
+  // this mutex is to synchronize ::New calls
+  static Mutex instantiationMutex;
 
   // Custom resource constraints:
   double resource_limits_[kTotalResourceLimitCount];
diff --git a/test/common/index.mjs b/test/common/index.mjs
index 430527faf8f0ea..6b566a899a35bb 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -51,6 +51,7 @@ const {
   skipIfDumbTerminal,
   skipIfEslintMissing,
   skipIfInspectorDisabled,
+  skipIfWorker,
   spawnPromisified,
 } = common;
 
@@ -106,5 +107,6 @@ export {
   skipIfDumbTerminal,
   skipIfEslintMissing,
   skipIfInspectorDisabled,
+  skipIfWorker,
   spawnPromisified,
 };
diff --git a/test/es-module/test-esm-hooks-chains.mjs b/test/es-module/test-esm-hooks-chains.mjs
new file mode 100644
index 00000000000000..b0be066a133a1a
--- /dev/null
+++ b/test/es-module/test-esm-hooks-chains.mjs
@@ -0,0 +1,135 @@
+import { spawnPromisified } from '../common/index.mjs';
+import { fileURL } from '../common/fixtures.mjs';
+import { Worker } from 'node:worker_threads';
+import { execPath } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { ok, strictEqual, deepStrictEqual } from 'node:assert';
+import { isDeepStrictEqual } from 'node:util';
+
+async function spawn() {
+  new Worker(fileURL('es-modules/test-esm-separate-chains.mjs'), { workerData: { count: 1 } });
+  await import(fileURL('es-modules/test-esm-separate-chains-execute.mjs'));
+  delete globalThis.__testESM;
+}
+
+async function test() {
+  const loader = fileURLToPath(fileURL('es-module-loaders/hooks-log-verbose.mjs'));
+  const { code, stdout, stderr } = await spawnPromisified(execPath, [
+    '--expose-internals',
+    '--import', 'data:text/javascript,globalThis.__testESM=true',
+    // Note that the same loader is imported twice to verify duplication detection
+    '--import', loader,
+    '--import', loader,
+    fileURLToPath(import.meta.url),
+  ]);
+
+  strictEqual(code, 0);
+
+  const executeFileUrl = fileURL('/es-modules/test-esm-separate-chains-execute.mjs').toString();
+
+  // Parse NDJSON output
+  const linesOut = stdout.trim().split('\n').map((line) => JSON.parse(line)).reduce((accu, line) => {
+    accu[line.threadId] ??= [];
+    accu[line.threadId].push(line);
+    return accu;
+  }, {});
+  const linesErr = stderr.trim().split('\n').map((line) => JSON.parse(line));
+
+  // Verify threads behavior - Note that grouping is only inserted for readability
+
+  // Verify the main thread
+  {
+    // A hook is only registered once
+    strictEqual(linesOut[0].filter((line) => line.operation === 'initialize').length, 1);
+    // There is only a chain for the main thread
+    ok(linesOut[0].every((line) => !line.chain || line.chain === '0:1'));
+    // The hook is called for resolve
+    strictEqual(linesOut[0].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl;
+    }).length, 1);
+  }
+
+  // Verify the first worker thread - It just inherits the hooks from the main thread
+  {
+    // Note that the threadId is 2 as the thread 1 is the hooks thread
+    // The hook is copied from the parent thread so it's not reinitialized
+    strictEqual(linesOut[2].filter((line) => line.operation === 'initialize').length, 0);
+    // 6 resolves
+    //  1 (data --import)
+    //  1 (file --import)
+    //  4 worker entrypoint imports
+    // 1 execute
+    strictEqual(linesOut[2].filter((line) => line.threadId === 2).length, 7);
+
+    // The hook is called for resolve
+    strictEqual(linesOut[0].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl;
+    }).length, 1);
+  }
+
+  // Verify the second worker thread - Re-register the same hook but with data attached, so no duplicate
+  {
+    // The hook is copied from the parent thread but it is also reinitialized as there is new data
+    strictEqual(linesOut[3].filter((line) => line.operation === 'initialize').length, 1);
+    // The initialize hook has data only defined once
+    strictEqual(linesOut[3].filter((line) => line.operation === 'initialize' && line.data).length, 1);
+
+    // 1 initialize
+    // 6 resolves
+    //  1 (data --import)
+    //  1 (file --import)
+    //  4 worker entrypoint imports
+    //    1 import has two hooks
+    //    Note that the last worker is not resolve/load again since it is the current entrypoint
+    // 1 execute
+    strictEqual(linesOut[3].filter((line) => line.threadId === 3).length, 9);
+
+    // The hook is called for resolve once per registration
+    strictEqual(linesOut[3].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl && !line.data;
+    }).length, 1);
+    strictEqual(linesOut[3].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl &&
+        isDeepStrictEqual(line.data, { label: 'first' });
+    }).length, 1);
+  }
+
+  // Verify the third worker thread - Re-register the same hook but with data attached, so no duplicate
+  {
+    // The hook is copied from the parent thread but it is also reinitialized as there is new data
+    strictEqual(linesOut[4].filter((line) => line.operation === 'initialize').length, 1);
+    // The initialize hook has data only defined once
+    strictEqual(linesOut[4].filter((line) => line.operation === 'initialize' && line.data).length, 1);
+
+    // 1 initialize
+    // 13 resolves
+    //  2 (data --import, with and without data)
+    //  2 (file --import, with and without data)
+    //  9 (4 worker entrypoint imports, with and without data)
+    //    1 import has three hooks
+    //    Note that the last worker is not resolve/load again since it is the current entrypoint
+    // 1 execute
+    strictEqual(linesOut[4].filter((line) => line.threadId === 4).length, 15);
+
+    // The hook is called for resolve once per registration
+    strictEqual(linesOut[4].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl && !line.data;
+    }).length, 1);
+    strictEqual(linesOut[4].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl &&
+        isDeepStrictEqual(line.data, { label: 'first' });
+    }).length, 1);
+    strictEqual(linesOut[4].filter((line) => {
+      return line.operation === 'resolve' && line.specifier === executeFileUrl &&
+        isDeepStrictEqual(line.data, { label: 'second' });
+    }).length, 1);
+  }
+
+  // Make sure at the the chains are cleared.
+  // The only one remaining are the chain for the thread hooks (1)
+  // and the default chain (whose internal is serialized to null by JSON.stringify)
+  deepStrictEqual(linesErr.at(-1), { operation: 'chains', names: [ 1, null ] });
+}
+
+const runner = globalThis.__testESM ? spawn : test;
+await runner();
diff --git a/test/es-module/test-esm-loader-hooks.mjs b/test/es-module/test-esm-loader-hooks.mjs
index 80dbd885e25819..894d5c3bee05cd 100644
--- a/test/es-module/test-esm-loader-hooks.mjs
+++ b/test/es-module/test-esm-loader-hooks.mjs
@@ -498,7 +498,7 @@ describe('Loader hooks', { concurrency: !process.env.TEST_PARALLEL }, () => {
       ]);
 
       assert.strictEqual(stderr, '');
-      assert.deepStrictEqual(stdout.split('\n'), ['hooks initialize 1', '']);
+      assert.deepStrictEqual(stdout.split('\n'), ['hooks initialize 1', 'hooks initialize 2', '']);
       assert.strictEqual(code, 0);
       assert.strictEqual(signal, null);
     });
@@ -612,7 +612,7 @@ describe('Loader hooks', { concurrency: !process.env.TEST_PARALLEL }, () => {
       ]);
 
       assert.strictEqual(stderr, '');
-      assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', 'resolve passthru', '']);
+      assert.deepStrictEqual(stdout.split('\n'), ['resolve passthru', '']);
       assert.strictEqual(code, 0);
       assert.strictEqual(signal, null);
     });
@@ -654,7 +654,6 @@ describe('Loader hooks', { concurrency: !process.env.TEST_PARALLEL }, () => {
       assert.strictEqual(stderr, '');
       assert.deepStrictEqual(stdout.split('\n'), [ 'hooks initialize 1',
                                                    'result 1 undefined',
-                                                   'hooks initialize 2',
                                                    'result 2 undefined',
                                                    '' ]);
       assert.strictEqual(code, 0);
diff --git a/test/es-module/test-esm-loader-programmatically.mjs b/test/es-module/test-esm-loader-programmatically.mjs
index e117ff454d7889..269046b40bb409 100644
--- a/test/es-module/test-esm-loader-programmatically.mjs
+++ b/test/es-module/test-esm-loader-programmatically.mjs
@@ -163,12 +163,10 @@ describe('ESM: programmatically register loaders', { concurrency: !process.env.T
     const lines = stdout.split('\n');
 
     assert.match(lines[0], /resolve passthru/);
-    assert.match(lines[1], /resolve passthru/);
-    assert.match(lines[2], /load passthru/);
-    assert.match(lines[3], /load passthru/);
-    assert.match(lines[4], /Hello from dynamic import/);
+    assert.match(lines[1], /load passthru/);
+    assert.match(lines[2], /Hello from dynamic import/);
 
-    assert.strictEqual(lines[5], '');
+    assert.strictEqual(lines[3], '');
   });
 
   it('works registering loaders as package name', async () => {
@@ -190,11 +188,10 @@ describe('ESM: programmatically register loaders', { concurrency: !process.env.T
     // Resolve occurs twice because it is first used to resolve the `load` loader
     // _AND THEN_ the `register` module.
     assert.match(lines[0], /resolve passthru/);
-    assert.match(lines[1], /resolve passthru/);
-    assert.match(lines[2], /load passthru/);
-    assert.match(lines[3], /Hello from dynamic import/);
+    assert.match(lines[1], /load passthru/);
+    assert.match(lines[2], /Hello from dynamic import/);
 
-    assert.strictEqual(lines[4], '');
+    assert.strictEqual(lines[3], '');
   });
 
   it('works without a CLI flag', async () => {
diff --git a/test/es-module/test-esm-loader-threads.mjs b/test/es-module/test-esm-loader-threads.mjs
new file mode 100644
index 00000000000000..85d6d7b0353e05
--- /dev/null
+++ b/test/es-module/test-esm-loader-threads.mjs
@@ -0,0 +1,87 @@
+import { spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import { strictEqual } from 'node:assert';
+import { execPath } from 'node:process';
+import { describe, it } from 'node:test';
+
+describe('off-thread hooks', { concurrency: true }, () => {
+  it('uses only one hooks thread to support multiple application threads', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--import',
+      `data:text/javascript,${encodeURIComponent(`
+        import { register } from 'node:module';
+        register(${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-log.mjs'))});
+      `)}`,
+      fixtures.path('es-module-loaders/workers-spawned.mjs'),
+    ]);
+
+
+    strictEqual(stderr, '');
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('initialize')).length, 1);
+    strictEqual(stdout.split('\n').filter((line) => line === 'foo').length, 2);
+    strictEqual(stdout.split('\n').filter((line) => line === 'bar').length, 4);
+
+    //
+    // Calls to resolve/load:
+    //
+    // 1x  test/fixtures/es-module-loaders/workers-spawned.mjs
+    //   1x worker_threads
+    //     2x (1 per each worker spawned in workers-spawned.mjs)
+    //       1x  data:text/javascript
+    //         1x node:module
+    //         1x ./worker-log.mjs
+    //           1x worker_threads
+    //           1x ./module-named-exports.mjs
+    //       Total: 4
+    //     4x (2x per each worker spawned in ./worker-log.mjs)
+    //       1x  data:text/javascript
+    //       1x node:module
+    //         1x ./module-named-exports.mjs
+    //         1x ./worker-log-again.mjs
+    //       Total: 4
+    // --------------------------------------------------------
+    // Sum: 1 + 1 + 2 * 5 + 4 * 4 = 28
+    //
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('hooked resolve')).length, 28);
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('hooked load')).length, 28);
+    strictEqual(code, 0);
+    strictEqual(signal, null);
+  });
+
+  it('propagates the exit code from worker thread import exiting from resolve hook', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--import',
+      `data:text/javascript,${encodeURIComponent(`
+        import { register } from 'node:module';
+        register(${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-exit-worker.mjs'))});
+      `)}`,
+      fixtures.path('es-module-loaders/worker-log-fail-worker-resolve.mjs'),
+    ]);
+
+    strictEqual(stderr, '');
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('resolve process-exit-module-resolve')).length, 1);
+    strictEqual(code, 42);
+    strictEqual(signal, null);
+  });
+
+  it('propagates the exit code from worker thread import exiting from load hook', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--import',
+      `data:text/javascript,${encodeURIComponent(`
+        import { register } from 'node:module';
+        register(${JSON.stringify(fixtures.fileURL('es-module-loaders/hooks-exit-worker.mjs'))});
+      `)}`,
+      fixtures.path('es-module-loaders/worker-log-fail-worker-load.mjs'),
+    ]);
+
+    strictEqual(stderr, '');
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('resolve process-exit-module-load')).length, 1);
+    strictEqual(stdout.split('\n').filter((line) => line.startsWith('load process-exit-on-load:///')).length, 1);
+    strictEqual(code, 43);
+    strictEqual(signal, null);
+  });
+
+});
diff --git a/test/es-module/test-esm-named-exports.js b/test/es-module/test-esm-named-exports.js
index 2c6f67288aa57c..25ce2f794c1165 100644
--- a/test/es-module/test-esm-named-exports.js
+++ b/test/es-module/test-esm-named-exports.js
@@ -2,6 +2,7 @@
 'use strict';
 
 require('../common');
+
 const { readFile, __fromLoader } = require('fs');
 const assert = require('assert');
 
diff --git a/test/es-module/test-esm-virtual-json.mjs b/test/es-module/test-esm-virtual-json.mjs
index a42b037fc1f200..1064a6af5026cf 100644
--- a/test/es-module/test-esm-virtual-json.mjs
+++ b/test/es-module/test-esm-virtual-json.mjs
@@ -1,7 +1,8 @@
-import '../common/index.mjs';
+import { skipIfWorker } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import { register } from 'node:module';
 import assert from 'node:assert';
+skipIfWorker();
 
 async function resolve(referrer, context, next) {
   const result = await next(referrer, context);
diff --git a/test/fixtures/es-module-loaders/assertionless-json-import.mjs b/test/fixtures/es-module-loaders/assertionless-json-import.mjs
index 3ffc4c1148fe69..d81a1f70368cf2 100644
--- a/test/fixtures/es-module-loaders/assertionless-json-import.mjs
+++ b/test/fixtures/es-module-loaders/assertionless-json-import.mjs
@@ -5,7 +5,9 @@ export async function resolve(specifier, context, next) {
   const noAttributesSpecified = context.importAttributes.type == null;
 
   // Mutation from resolve hook should be discarded.
-  context.importAttributes.type = 'whatever';
+  if(!Object.isSealed(context.importAttributes)) {
+    context.importAttributes.type = 'whatever';
+  }
 
   // This fixture assumes that no other resolve hooks in the chain will error on invalid import attributes
   // (as defaultResolve doesn't).
diff --git a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
index fca31c585a6ea9..9dd4fc14d9d016 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports-loader.mjs
@@ -1,15 +1,24 @@
 import module from 'node:module';
 import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 
 /** @type {string} */
 let GET_BUILTIN;
-export function initialize(data) {
+let argv;
+export function initialize(data, context) {
   GET_BUILTIN = data.GET_BUILTIN;
 }
 
 export async function resolve(specifier, context, next) {
   const def = await next(specifier, context);
 
+  const file = fileURLToPath(context.parentURL ?? 'file://');
+
+  // Only apply the hook to the entrypoint includes to avoid cycles
+  if(fileURLToPath(context.parentURL ?? 'file://') !== context.data.entrypoint) {
+    return def;
+  }
+
   if (def.url.startsWith('node:')) {
     return {
       shortCircuit: true,
diff --git a/test/fixtures/es-module-loaders/builtin-named-exports.mjs b/test/fixtures/es-module-loaders/builtin-named-exports.mjs
index 123b12c26bf0c9..68707ee9f6c5d8 100644
--- a/test/fixtures/es-module-loaders/builtin-named-exports.mjs
+++ b/test/fixtures/es-module-loaders/builtin-named-exports.mjs
@@ -3,7 +3,7 @@ import { createRequire, register } from 'node:module';
 
 const require = createRequire(import.meta.url);
 
-const GET_BUILTIN = `$__get_builtin_hole_${Date.now()}`;
+const GET_BUILTIN = `$__get_builtin_hole_${~~(Date.now()/10000)}`;
 Object.defineProperty(globalThis, GET_BUILTIN, {
   value: builtinName => require(builtinName),
   enumerable: false,
@@ -13,5 +13,6 @@ Object.defineProperty(globalThis, GET_BUILTIN, {
 register(fixtures.fileURL('es-module-loaders/builtin-named-exports-loader.mjs'), {
   data: {
     GET_BUILTIN,
+    entrypoint: process.argv.at(-1),
   },
 });
diff --git a/test/fixtures/es-module-loaders/hooks-exit-worker.mjs b/test/fixtures/es-module-loaders/hooks-exit-worker.mjs
new file mode 100644
index 00000000000000..d499a835e6456c
--- /dev/null
+++ b/test/fixtures/es-module-loaders/hooks-exit-worker.mjs
@@ -0,0 +1,21 @@
+import { writeFileSync } from 'node:fs';
+
+export function resolve(specifier, context, next) {
+	writeFileSync(1, `resolve ${specifier}\n`);
+  if (specifier === 'process-exit-module-resolve') {
+    process.exit(42);
+  }
+	
+  if (specifier === 'process-exit-module-load') {
+    return { __proto__: null, shortCircuit: true, url: 'process-exit-on-load:///' }
+  }
+  return next(specifier, context);
+}
+
+export function load(url, context, next) {
+	writeFileSync(1, `load ${url}\n`);
+  if (url === 'process-exit-on-load:///') {
+    process.exit(43);
+  }
+  return next(url, context);
+}
diff --git a/test/fixtures/es-module-loaders/hooks-input.mjs b/test/fixtures/es-module-loaders/hooks-input.mjs
index 1d3759f458224e..43ebf9f91a1a79 100644
--- a/test/fixtures/es-module-loaders/hooks-input.mjs
+++ b/test/fixtures/es-module-loaders/hooks-input.mjs
@@ -37,6 +37,8 @@ export async function resolve(specifier, context, next) {
     'conditions',
     'importAttributes',
     'parentURL',
+    'threadId',
+    'data'
   ]);
   assert.ok(Array.isArray(context.conditions));
   assert.strictEqual(typeof next, 'function');
@@ -74,6 +76,8 @@ export async function load(url, context, next) {
   assert.deepStrictEqual(Object.keys(context), [
     'format',
     'importAttributes',
+    'threadId',
+    'data'
   ]);
   assert.strictEqual(context.format, 'test');
   assert.strictEqual(typeof next, 'function');
diff --git a/test/fixtures/es-module-loaders/hooks-log-verbose-loader.mjs b/test/fixtures/es-module-loaders/hooks-log-verbose-loader.mjs
new file mode 100644
index 00000000000000..cc4219e1a03d59
--- /dev/null
+++ b/test/fixtures/es-module-loaders/hooks-log-verbose-loader.mjs
@@ -0,0 +1,34 @@
+import { threadId } from "worker_threads";
+import esm from "node:internal/modules/esm/loader";
+
+export function initialize(data, context) {
+  process.on('beforeExit', () => {
+    process._rawDebug(JSON.stringify({
+      operation: "chains",
+      names: Array.from(esm.getOrInitializeCascadedLoader().getCustomizations().getChains().keys()),
+    }));
+  })
+
+  console.log(JSON.stringify({
+    operation: "initialize",
+    threadId: context.threadId,
+    data,
+    workerData: context.workerData,
+  }));
+}
+
+export function resolve(specifier, context, next) {
+  if(specifier.startsWith('node:') || specifier.startsWith('../')) {
+    return next(specifier);    
+  }
+  
+  console.log(JSON.stringify({
+    operation: "resolve",
+    specifier,
+    threadId: context.threadId,
+    data: context.data,
+    workerData: context.workerData,
+  }));
+
+  return next(specifier);
+}
\ No newline at end of file
diff --git a/test/fixtures/es-module-loaders/hooks-log-verbose.mjs b/test/fixtures/es-module-loaders/hooks-log-verbose.mjs
new file mode 100644
index 00000000000000..dce72984dd6175
--- /dev/null
+++ b/test/fixtures/es-module-loaders/hooks-log-verbose.mjs
@@ -0,0 +1,4 @@
+import { register } from 'node:module';
+import { fileURL } from '../../common/fixtures.mjs';
+
+register(fileURL('es-module-loaders/hooks-log-verbose-loader.mjs'));
\ No newline at end of file
diff --git a/test/fixtures/es-module-loaders/hooks-log.mjs b/test/fixtures/es-module-loaders/hooks-log.mjs
new file mode 100644
index 00000000000000..416bbad17fd6ac
--- /dev/null
+++ b/test/fixtures/es-module-loaders/hooks-log.mjs
@@ -0,0 +1,19 @@
+import { writeFileSync } from 'node:fs';
+
+let initializeCount = 0;
+let resolveCount = 0;
+let loadCount = 0;
+
+export function initialize() {
+  writeFileSync(1, `initialize ${++initializeCount}\n`);
+}
+
+export function resolve(specifier, context, next) {
+  writeFileSync(1, `hooked resolve ${++resolveCount} ${specifier} \n`);
+  return next(specifier, context);
+}
+
+export function load(url, context, next) {
+  writeFileSync(1, `hooked load ${++loadCount} ${url}\n`);
+  return next(url, context);
+}
diff --git a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
index bf66efbd0810e5..7d53e31df918a7 100644
--- a/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
+++ b/test/fixtures/es-module-loaders/not-found-assert-loader.mjs
@@ -1,16 +1,13 @@
 import assert from 'node:assert';
 
 // A loader that asserts that the defaultResolve will throw "not found"
-// (skipping the top-level main of course, and the built-in ones needed for run-worker).
-let mainLoad = true;
 export async function resolve(specifier, { importAttributes }, next) {
-  if (mainLoad || specifier === 'path' || specifier === 'worker_threads') {
-    mainLoad = false;
-    return next(specifier);
+  if (specifier.startsWith('./not-found')) {
+    await assert.rejects(next(specifier), { code: 'ERR_MODULE_NOT_FOUND' });
+    return {
+      url: 'node:fs',
+      importAttributes,
+    };
   }
-  await assert.rejects(next(specifier), { code: 'ERR_MODULE_NOT_FOUND' });
-  return {
-    url: 'node:fs',
-    importAttributes,
-  };
+  return next(specifier);
 }
diff --git a/test/fixtures/es-module-loaders/worker-fail-on-load.mjs b/test/fixtures/es-module-loaders/worker-fail-on-load.mjs
new file mode 100644
index 00000000000000..46e88664a03c5c
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-fail-on-load.mjs
@@ -0,0 +1 @@
+import 'process-exit-module-load';
diff --git a/test/fixtures/es-module-loaders/worker-fail-on-resolve.mjs b/test/fixtures/es-module-loaders/worker-fail-on-resolve.mjs
new file mode 100644
index 00000000000000..e8e7adde42585f
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-fail-on-resolve.mjs
@@ -0,0 +1 @@
+import 'process-exit-module-resolve';
diff --git a/test/fixtures/es-module-loaders/worker-log-again.mjs b/test/fixtures/es-module-loaders/worker-log-again.mjs
new file mode 100644
index 00000000000000..2969edc8dac382
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-log-again.mjs
@@ -0,0 +1,3 @@
+import { bar } from './module-named-exports.mjs';
+
+console.log(bar);
diff --git a/test/fixtures/es-module-loaders/worker-log-fail-worker-load.mjs b/test/fixtures/es-module-loaders/worker-log-fail-worker-load.mjs
new file mode 100644
index 00000000000000..81797da392cb7a
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-log-fail-worker-load.mjs
@@ -0,0 +1,12 @@
+import { Worker } from 'worker_threads';
+import { foo } from './module-named-exports.mjs';
+
+const workerURLFailOnLoad = new URL('./worker-fail-on-load.mjs', import.meta.url);
+console.log(foo);
+
+// Spawn a worker that will fail to import a dependant module
+new Worker(workerURLFailOnLoad);
+
+process.on('exit', (code) => {
+	console.log(`process exit code: ${code}`)
+});
diff --git a/test/fixtures/es-module-loaders/worker-log-fail-worker-resolve.mjs b/test/fixtures/es-module-loaders/worker-log-fail-worker-resolve.mjs
new file mode 100644
index 00000000000000..b5ff238967f4ef
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-log-fail-worker-resolve.mjs
@@ -0,0 +1,12 @@
+import { Worker } from 'worker_threads';
+import { foo } from './module-named-exports.mjs';
+
+const workerURLFailOnResolve = new URL('./worker-fail-on-resolve.mjs', import.meta.url);
+console.log(foo);
+
+// Spawn a worker that will fail to import a dependant module
+new Worker(workerURLFailOnResolve);
+
+process.on('exit', (code) => {
+	console.log(`process exit code: ${code}`)
+});
diff --git a/test/fixtures/es-module-loaders/worker-log.mjs b/test/fixtures/es-module-loaders/worker-log.mjs
new file mode 100644
index 00000000000000..13290c37d07104
--- /dev/null
+++ b/test/fixtures/es-module-loaders/worker-log.mjs
@@ -0,0 +1,9 @@
+import { Worker } from 'worker_threads';
+import { foo } from './module-named-exports.mjs';
+
+const workerURL = new URL('./worker-log-again.mjs', import.meta.url);
+console.log(foo);
+
+// Spawn two workers
+new Worker(workerURL);
+new Worker(workerURL);
diff --git a/test/fixtures/es-module-loaders/workers-spawned.mjs b/test/fixtures/es-module-loaders/workers-spawned.mjs
new file mode 100644
index 00000000000000..439847656fe13e
--- /dev/null
+++ b/test/fixtures/es-module-loaders/workers-spawned.mjs
@@ -0,0 +1,7 @@
+import { Worker } from 'worker_threads';
+
+const workerURL = new URL('./worker-log.mjs', import.meta.url);
+
+// Spawn two workers
+new Worker(workerURL);
+new Worker(workerURL);
diff --git a/test/fixtures/es-modules/test-esm-separate-chains-execute.mjs b/test/fixtures/es-modules/test-esm-separate-chains-execute.mjs
new file mode 100644
index 00000000000000..74006a97ea701d
--- /dev/null
+++ b/test/fixtures/es-modules/test-esm-separate-chains-execute.mjs
@@ -0,0 +1,3 @@
+import { workerData , threadId} from 'node:worker_threads';
+
+console.log(JSON.stringify({ operation: 'execute', threadId, workerData }));
\ No newline at end of file
diff --git a/test/fixtures/es-modules/test-esm-separate-chains.mjs b/test/fixtures/es-modules/test-esm-separate-chains.mjs
new file mode 100644
index 00000000000000..4c736ce511ea66
--- /dev/null
+++ b/test/fixtures/es-modules/test-esm-separate-chains.mjs
@@ -0,0 +1,33 @@
+import { register } from 'node:module';
+import { Worker, workerData, threadId } from 'node:worker_threads';
+import { fileURL } from '../../common/fixtures.mjs';
+
+if (workerData.port) {
+  workerData.port.postMessage('MESSAGE');
+}
+
+if (workerData.count === 2) {
+  register(fileURL('es-module-loaders/hooks-log-verbose-loader.mjs'), import.meta.url, { data : {  label: 'first' } });
+}
+
+if (workerData.count === 3) {
+  register(fileURL('es-module-loaders/hooks-log-verbose-loader.mjs'), import.meta.url, { data : { label: 'second' } });
+}
+
+if (workerData.count === 1) {
+  const { port1, port2 } = new MessageChannel();
+
+  port1.on('message', message => {
+    process._rawDebug(JSON.stringify({ operation: 'message', message }));
+  }).unref();
+
+  new Worker(
+    fileURL('es-modules/test-esm-separate-chains.mjs'), 
+    { workerData: { count: workerData.count + 1, port: port2 },
+    transferList: [port2],
+  });  
+} else if (workerData.count < 3) {
+  new Worker(fileURL('es-modules/test-esm-separate-chains.mjs'), { workerData: { count: workerData.count + 1 } });
+}
+
+await import(fileURL('es-modules/test-esm-separate-chains-execute.mjs'));
\ No newline at end of file
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 6327fbeb2e7e1b..353901f7c56885 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -216,6 +216,7 @@ if (!common.isMainThread) {
   // When we start adding modules to the worker snapshot, this branch
   // can be removed and  we can just remove the common.isMainThread
   // conditions.
+
   expected.beforePreExec.forEach(expected.atRunTime.add.bind(expected.atRunTime));
   actual.beforePreExec.forEach(actual.atRunTime.add.bind(actual.atRunTime));
 }