fix(core): reject pending promises directly when plugin worker exits unexpectedly (#34588)

When a plugin worker process exits unexpectedly, the exit handler
previously sent synthetic `loadResult` messages to all pending response
handlers. If any handler was waiting for a different result type (e.g.
`createNodesResult`), the type validation would reject with a confusing
"Expected createNodesResult, got loadResult" error instead of surfacing
the actual cause.

Split response handlers into `onMessage` / `onError` callbacks so the
exit handler can reject each pending promise directly with a clear
"Plugin worker exited unexpectedly" error.

Also use unique transaction IDs for `load` messages (via `generateTxId`)
to avoid potential handler overwrites during worker restarts.

Fixes #34564

(cherry picked from commit 1ecf0fb)

Author: AgentEnder

packages/nx/src/project-graph/plugins/isolation/isolated-plugin.ts

@@ -89,7 +89,10 @@ export class IsolatedPlugin implements LoadedNxPlugin {
   // Typed response handlers keyed by transaction ID
   private responseHandlers = new Map<
     string,
-    (msg: PluginWorkerResult) => void
+    {
+      onMessage: (msg: PluginWorkerResult) => void;
+      onError: (error: Error) => void;
+    }
   >();
 
   // Configuration for restart
@@ -159,15 +162,11 @@ export class IsolatedPlugin implements LoadedNxPlugin {
         this.worker.stderr.unpipe(process.stderr);
       }
       // Reject all pending requests
-      for (const handler of this.responseHandlers.values()) {
-        handler({
-          type: 'loadResult',
-          tx: '',
-          payload: {
-            success: false,
-            error: new Error(`Plugin worker ${this.name} exited unexpectedly.`),
-          },
-        } as PluginWorkerResult);
+      const error = new Error(
+        `Plugin worker "${this.name}" exited unexpectedly.`
+      );
+      for (const { onError } of this.responseHandlers.values()) {
+        onError(error);
       }
       this.responseHandlers.clear();
     };
@@ -204,16 +203,16 @@ export class IsolatedPlugin implements LoadedNxPlugin {
     if (!isPluginWorkerResult(message)) {
       return;
     }
-    const handler = this.responseHandlers.get(message.tx);
-    if (handler) {
+    const pending = this.responseHandlers.get(message.tx);
+    if (pending) {
       this.responseHandlers.delete(message.tx);
-      handler(message);
+      pending.onMessage(message);
     }
   };
 
   private sendLoadMessage(): Promise<LoadResultPayload> {
     return new Promise((resolve, reject) => {
-      const tx = 'load';
+      const tx = this.generateTxId('load');
 
       const timeout = setTimeout(() => {
         this.responseHandlers.delete(tx);
@@ -226,19 +225,25 @@ export class IsolatedPlugin implements LoadedNxPlugin {
         );
       }, MAX_MESSAGE_WAIT);
 
-      this.responseHandlers.set(tx, (msg) => {
-        clearTimeout(timeout);
-        if (msg.type !== 'loadResult') {
-          reject(new Error(`Expected loadResult, got ${msg.type}`));
-          return;
-        }
-        const payload = msg.payload as PluginWorkerLoadResult['payload'];
-        if (payload.success === false) {
-          reject(payload.error);
-        } else {
-          this._alive = true;
-          resolve(payload);
-        }
+      this.responseHandlers.set(tx, {
+        onMessage: (msg) => {
+          clearTimeout(timeout);
+          if (msg.type !== 'loadResult') {
+            reject(new Error(`Expected loadResult, got ${msg.type}`));
+            return;
+          }
+          const payload = msg.payload as PluginWorkerLoadResult['payload'];
+          if (payload.success === false) {
+            reject(payload.error);
+          } else {
+            this._alive = true;
+            resolve(payload);
+          }
+        },
+        onError: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        },
       });
 
       sendMessageOverSocket(this.socket, {
@@ -387,16 +392,25 @@ export class IsolatedPlugin implements LoadedNxPlugin {
         );
       }, MAX_MESSAGE_WAIT);
 
-      this.responseHandlers.set(tx, (msg) => {
-        clearTimeout(timeout);
-        this.pendingCount--;
+      this.responseHandlers.set(tx, {
+        onMessage: (msg) => {
+          clearTimeout(timeout);
+          this.pendingCount--;
 
-        if (msg.type !== expectedResultType) {
-          reject(new Error(`Expected ${expectedResultType}, got ${msg.type}`));
-          return;
-        }
+          if (msg.type !== expectedResultType) {
+            reject(
+              new Error(`Expected ${expectedResultType}, got ${msg.type}`)
+            );
+            return;
+          }
 
-        resolve(msg.payload as MessageResult<TType>['payload']);
+          resolve(msg.payload as MessageResult<TType>['payload']);
+        },
+        onError: (error) => {
+          clearTimeout(timeout);
+          this.pendingCount--;
+          reject(error);
+        },
       });
 
       sendMessageOverSocket(this.socket, {