esm: use sync loading/resolving on non-loader-hook thread

ESM resolution and loading is now always synchronous from a
non-loader-hook thread. If no asynchrnous loader hooks are
registered, the resolution/loading is entirely synchronous.
If asynchronous loader hooks are registered, these would be
synchronous on the non-loader-hook thread, and asynchronous
on the loader hook thread.

This avoids several races caused by async/sync loading sharing
the same cache. In particular, asynchronous loader hooks
now works with `require(esm)` - previously it tends to break
due to races.

In addition, when an asynchronous loader hook
returns a promise that never settles, the main thread no longer
silently exits with exit code 13, leaving the code below
any module loading calls silently ignored without being executed.
Instead, it now throws ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED
which can be caught and handled by the main thread. If the module
request comes from `import()`, the never-settling promise is
now relayed to the result returned by `import()`.

Drive-by: when annotating the error about importing undetectable
named exports from CommonJS, it now no longer reload the source
code of the CommonJS module, and instead reuses format information
cached when the module was loaded for linking.

PR-URL: #60380
Fixes: #59666
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>
Reviewed-By: Jacob Smith <jacob@frende.me>

Author: joyeecheung

doc/api/errors.md

@@ -703,6 +703,13 @@ by the `node:assert` module.
 An attempt was made to register something that is not a function as an
 `AsyncHooks` callback.
 
+<a id="ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED"></a>
+
+### `ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED`
+
+An operation related to module loading is customized by an asynchronous loader
+hook that never settled the promise before the loader thread exits.
+
 <a id="ERR_ASYNC_TYPE"></a>
 
 ### `ERR_ASYNC_TYPE`

lib/internal/errors.js

@@ -1137,6 +1137,8 @@ E('ERR_AMBIGUOUS_ARGUMENT', 'The "%s" argument is ambiguous. %s', TypeError);
 E('ERR_ARG_NOT_ITERABLE', '%s must be iterable', TypeError);
 E('ERR_ASSERTION', '%s', Error);
 E('ERR_ASYNC_CALLBACK', '%s must be a function', TypeError);
+E('ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED',
+  'Async loader request never settled', Error);
 E('ERR_ASYNC_TYPE', 'Invalid name for async "type": %s', TypeError);
 E('ERR_BROTLI_INVALID_PARAM', '%s is not a valid Brotli parameter', RangeError);
 E('ERR_BUFFER_OUT_OF_BOUNDS',

lib/internal/modules/esm/hooks.js

@@ -23,16 +23,15 @@ const {
 } = globalThis;
 
 const {
+  ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED,
   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_METHOD_NOT_IMPLEMENTED,
   ERR_WORKER_UNSERIALIZABLE_ERROR,
 } = require('internal/errors').codes;
-const { exitCodes: { kUnsettledTopLevelAwait } } = internalBinding('errors');
 const { URLParse } = require('internal/url');
 const { canParse: URLCanParse } = internalBinding('url');
 const { receiveMessageOnPort } = require('worker_threads');
@@ -117,15 +116,16 @@ function defineImportAssertionAlias(context) {
  * via `ModuleLoader.#setAsyncLoaderHooks()`.
  * @typedef {object} AsyncLoaderHooks
  * @property {boolean} allowImportMetaResolve Whether to allow the use of `import.meta.resolve`.
+ * @property {boolean} isForAsyncLoaderHookWorker Whether the instance is running on the loader hook worker thread.
  * @property {(url: string, context: object, defaultLoad: Function) => Promise<LoadResult>} load
  *   Calling the asynchronous `load` hook asynchronously.
- * @property {(url: string, context: object, defaultLoad: Function) => LoadResult} loadSync
+ * @property {(url: string, context: object, defaultLoad: Function) => LoadResult} [loadSync]
  *   Calling the asynchronous `load` hook synchronously.
  * @property {(originalSpecifier: string, parentURL: string,
  *             importAttributes: Record<string, string>) => Promise<ResolveResult>} resolve
  *   Calling the asynchronous `resolve` hook asynchronously.
  * @property {(originalSpecifier: string, parentURL: string,
- *            importAttributes: Record<string, string>) => ResolveResult} resolveSync
+ *            importAttributes: Record<string, string>) => ResolveResult} [resolveSync]
  *   Calling the asynchronous `resolve` hook synchronously.
  * @property {(specifier: string, parentURL: string) => any} register Register asynchronous loader hooks
  * @property {() => void} waitForLoaderHookInitialization Force loading of hooks.
@@ -169,6 +169,8 @@ class AsyncLoaderHooksOnLoaderHookWorker {
 
   allowImportMetaResolve = false;
 
+  isForAsyncLoaderHookWorker = true;
+
   /**
    * Import and register custom/user-defined module loader hook(s).
    * @param {string} urlOrSpecifier
@@ -350,10 +352,6 @@ class AsyncLoaderHooksOnLoaderHookWorker {
     };
   }
 
-  resolveSync(_originalSpecifier, _parentURL, _importAttributes) {
-    throw new ERR_METHOD_NOT_IMPLEMENTED('resolveSync()');
-  }
-
   /**
    * Provide source that is understood by one of Node's translators.
    *
@@ -560,7 +558,10 @@ class AsyncLoaderHookWorker {
         debug('wait for signal from worker');
         AtomicsWait(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION, 0);
         const response = this.#worker.receiveMessageSync();
-        if (response == null || response.message.status === 'exit') { return; }
+        if (response == null) { return; }
+        if (response.message.status === 'exit') {
+          process.exit(response.message.body);
+        }
 
         // ! This line catches initialization errors in the worker thread.
         this.#unwrapMessage(response);
@@ -647,10 +648,13 @@ class AsyncLoaderHookWorker {
       this.#workerNotificationLastId = AtomicsLoad(this.#lock, WORKER_TO_MAIN_THREAD_NOTIFICATION);
 
       response = this.#worker.receiveMessageSync();
+      debug('got sync message from worker', { method, args, response });
     } while (response == null);
-    debug('got sync response from worker', { method, args });
+
     if (response.message.status === 'never-settle') {
-      process.exit(kUnsettledTopLevelAwait);
+      const error = new ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED();
+      error.details = { method, args };
+      throw error;
     } else if (response.message.status === 'exit') {
       process.exit(response.message.body);
     }
@@ -819,6 +823,8 @@ class AsyncLoaderHooksProxiedToLoaderHookWorker {
 
   allowImportMetaResolve = true;
 
+  isForAsyncLoaderHookWorker = false;
+
   /**
    * Instantiate a module loader that uses user-provided custom loader hooks.
    */

lib/internal/modules/esm/initialize_import_meta.js

@@ -33,7 +33,8 @@ function createImportMetaResolve(defaultParentURL, loader, allowParentURL) {
     }
 
     try {
-      ({ url } = loader.resolveSync(specifier, parentURL));
+      const request = { specifier, __proto__: null };
+      ({ url } = loader.resolveSync(parentURL, request));
       return url;
     } catch (error) {
       switch (error?.code) {