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

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) {