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: #60380Fixes: #59666 Reviewed-By: Geoffrey Booth <[email protected]> Reviewed-By: Jacob Smith <[email protected]>

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.
 
+<aid="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.
+
 <aid="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){
-thrownewERR_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);
 constresponse=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);
+consterror=newERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED();
+error.details={ method, args };
+throwerror;
 }elseif(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));
+constrequest={ specifier,__proto__: null};
+({ url }=loader.resolveSync(parentURL,request));
 returnurl;
 }catch(error){
 switch(error?.code){