@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

package/dist/src/daemon/client/client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.daemonClient = exports.DaemonClient = exports.WatcherFailedError = void 0;
+exports.daemonClient = exports.DaemonClient = exports.WatcherFailedError = exports.DaemonStatus = void 0;
 exports.isDaemonEnabled = isDaemonEnabled;
 exports.daemonPermissionException = daemonPermissionException;
 exports.daemonProcessException = daemonProcessException;
@@ -55,7 +55,7 @@ var DaemonStatus;
     DaemonStatus[DaemonStatus["CONNECTING"] = 0] = "CONNECTING";
     DaemonStatus[DaemonStatus["DISCONNECTED"] = 1] = "DISCONNECTED";
     DaemonStatus[DaemonStatus["CONNECTED"] = 2] = "CONNECTED";
-})(DaemonStatus || (DaemonStatus = {}));
+})(DaemonStatus || (exports.DaemonStatus = DaemonStatus = {}));
 const WAIT_FOR_SERVER_CONFIG = {
     delayMs: 10,
     maxAttempts: 6000, // 6000 * 10ms = 60 seconds
@@ -95,8 +95,12 @@ class DaemonClient {
         this._daemonStatus = DaemonStatus.DISCONNECTED;
         this._waitForDaemonReady = null;
         this._daemonReady = null;
+        this._daemonReadyFailed = null;
+        // Terminal once set — see `handleConnectionError`.
+        this._pluginWorkerConnectionLost = null;
         this.fileWatcherReconnecting = false;
         this.fileWatcherFramingFailures = 0;
+        this.fileWatcherRegistrations = new Map();
         this.fileWatcherCallbacks = new Map();
         this.fileWatcherConfigs = new Map();
         this.projectGraphListenerReconnecting = false;
@@ -153,6 +157,7 @@ class DaemonClient {
         return this._enabled;
     }
     reset() {
+        this.rejectFileWatcherRegistrations(new Error('Daemon client reset'));
         this.socketMessenger?.close();
         this.socketMessenger = null;
         this.queue = new promised_based_queue_1.PromisedBasedQueue();
@@ -166,7 +171,26 @@ class DaemonClient {
         this.projectGraphListenerMessenger?.close();
         this.projectGraphListenerMessenger = undefined;
         this._daemonStatus = DaemonStatus.DISCONNECTED;
-        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+        this._pluginWorkerConnectionLost = null;
+        this._waitForDaemonReady = this.createReadyPromise();
+    }
+    createReadyPromise() {
+        const promise = new Promise((resolve, reject) => {
+            this._daemonReady = resolve;
+            this._daemonReadyFailed = reject;
+        });
+        // Callers don't always await — swallow the unhandled-rejection warning
+        // so a rejected ready promise that no one observes doesn't crash the
+        // process. Real awaiters still see the rejection.
+        promise.catch(() => { });
+        return promise;
+    }
+    // Move out of CONNECTING and surface an error to every caller parked on
+    // `_waitForDaemonReady`. Without this, a failure while CONNECTING leaves
+    // concurrent callers waiting on a promise that will never settle.
+    failDaemonReady(err) {
+        this._daemonStatus = DaemonStatus.DISCONNECTED;
+        this._daemonReadyFailed?.(err);
     }
     getSocketPath() {
         const daemonProcessJson = (0, cache_1.readDaemonProcessJsonCache)();
@@ -182,12 +206,8 @@ class DaemonClient {
     }
     async getProjectGraphAndSourceMaps() {
         (0, project_graph_1.preventRecursionInGraphConstruction)();
-        let spinner;
-        // If the graph takes a while to load, we want to show a spinner.
-        spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon');
-        this.currentSpinner = spinner;
         try {
-            const response = await this.sendToDaemonViaQueue({
+            const response = await this.sendWithGraphSpinner({
                 type: 'REQUEST_PROJECT_GRAPH',
             });
             return {
@@ -203,10 +223,6 @@ class DaemonClient {
                 throw e;
             }
         }
-        finally {
-            spinner?.cleanup();
-            this.currentSpinner = null;
-        }
     }
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
@@ -249,16 +265,15 @@ class DaemonClient {
         }
         // Generate unique ID for this callback
         const callbackId = Math.random().toString(36).substring(2, 11);
-        // Store callback and config for reconnection
-        this.fileWatcherCallbacks.set(callbackId, callback);
-        this.fileWatcherConfigs.set(callbackId, config);
-        await this.queue.sendToQueue(async () => {
+        await this.queue
+            .sendToQueue(async () => {
+            // Only registrations whose queue entry has started belong to this
+            // connection. A failed earlier entry must not reconnect a queued one.
+            this.fileWatcherCallbacks.set(callbackId, callback);
+            this.fileWatcherConfigs.set(callbackId, config);
             // If we already have a connection, just register the new config
             if (this.fileWatcherMessenger) {
-                this.fileWatcherMessenger.sendMessage({
-                    type: 'REGISTER_FILE_WATCHER',
-                    config,
-                });
+                await this.sendFileWatcherRegistration(callbackId);
                 return;
             }
             await this.startDaemonIfNecessary();
@@ -266,6 +281,8 @@ class DaemonClient {
             this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    if (this.handleFileWatcherRegistration(parsedMessage))
+                        return;
                     // A delivered message means the stream is healthy again.
                     this.fileWatcherFramingFailures = 0;
                     if (parsedMessage?.watcherError) {
@@ -289,6 +306,7 @@ class DaemonClient {
                 // Connection closed - trigger reconnection
                 logger_1.clientLogger.log(`[FileWatcher] Socket closed, triggering reconnection`);
                 this.fileWatcherMessenger = undefined;
+                this.rejectFileWatcherRegistrations(new Error('Daemon disconnected before watcher registration completed'));
                 for (const cb of this.fileWatcherCallbacks.values()) {
                     cb('reconnecting', null);
                 }
@@ -310,10 +328,12 @@ class DaemonClient {
                 // failure would otherwise leave this channel silent forever.
                 this.fileWatcherMessenger?.close();
             });
-            this.fileWatcherMessenger.sendMessage({
-                type: 'REGISTER_FILE_WATCHER',
-                config,
-            });
+            await this.sendFileWatcherRegistration(callbackId);
+        })
+            .catch((error) => {
+            this.fileWatcherCallbacks.delete(callbackId);
+            this.fileWatcherConfigs.delete(callbackId);
+            throw error;
         });
         // Return unregister function
         return () => {
@@ -326,6 +346,52 @@ class DaemonClient {
             }
         };
     }
+    sendFileWatcherRegistration(callbackId) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.fileWatcherRegistrations.delete(callbackId);
+            };
+            const fail = (error) => {
+                cleanup();
+                this.fileWatcherCallbacks.delete(callbackId);
+                this.fileWatcherConfigs.delete(callbackId);
+                reject(error);
+                if (this.fileWatcherCallbacks.size === 0) {
+                    this.fileWatcherMessenger?.close();
+                }
+            };
+            const timeout = setTimeout(() => fail(new Error('Timed out waiting for daemon watcher registration')), WAIT_FOR_SERVER_CONFIG.maxAttempts * WAIT_FOR_SERVER_CONFIG.delayMs);
+            this.fileWatcherRegistrations.set(callbackId, {
+                resolve: () => {
+                    cleanup();
+                    resolve();
+                },
+                reject: fail,
+            });
+            try {
+                this.fileWatcherMessenger.sendMessage({
+                    type: 'REGISTER_FILE_WATCHER',
+                    config: this.fileWatcherConfigs.get(callbackId),
+                    registrationId: callbackId,
+                });
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    }
+    handleFileWatcherRegistration(message) {
+        if (message?.type !== 'FILE_WATCHER_REGISTERED')
+            return false;
+        this.fileWatcherRegistrations.get(message.registrationId)?.resolve();
+        return true;
+    }
+    rejectFileWatcherRegistrations(error) {
+        for (const registration of [...this.fileWatcherRegistrations.values()]) {
+            registration.reject(error);
+        }
+    }
     async reconnectFileWatcher() {
         // Guard against concurrent reconnection attempts
         if (this.fileWatcherReconnecting) {
@@ -380,6 +446,8 @@ class DaemonClient {
             this.fileWatcherMessenger = new daemon_socket_messenger_1.DaemonSocketMessenger((0, net_1.connect)(socketPath)).listen((message) => {
                 try {
                     const parsedMessage = (0, consume_messages_from_socket_1.parseMessage)(message);
+                    if (this.handleFileWatcherRegistration(parsedMessage))
+                        return;
                     // A delivered message means the stream is healthy again.
                     this.fileWatcherFramingFailures = 0;
                     for (const cb of this.fileWatcherCallbacks.values()) {
@@ -394,6 +462,7 @@ class DaemonClient {
             }, () => {
                 // Connection closed - trigger reconnection again
                 this.fileWatcherMessenger = undefined;
+                this.rejectFileWatcherRegistrations(new Error('Daemon disconnected before watcher registration completed'));
                 // Reset reconnection flag before triggering reconnection
                 this.fileWatcherReconnecting = false;
                 for (const cb of this.fileWatcherCallbacks.values()) {
@@ -615,10 +684,7 @@ class DaemonClient {
             type: 'PROCESS_IN_BACKGROUND',
             requirePath,
             data,
-        }, 
-        // This method is sometimes passed data that cannot be serialized with v8
-        // so we force JSON serialization here
-        'json');
+        });
     }
     recordOutputsHashBatch(entries) {
         return this.sendToDaemonViaQueue({
@@ -736,7 +802,7 @@ class DaemonClient {
             type: select_affected_tasks_1.SELECT_AFFECTED_TASKS,
             request,
         };
-        return this.sendToDaemonViaQueue(message);
+        return this.sendWithGraphSpinner(message);
     }
     updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
         const message = {
@@ -821,33 +887,50 @@ class DaemonClient {
         return (await this.probeServer()).available;
     }
     async startDaemonIfNecessary() {
+        if (this._pluginWorkerConnectionLost) {
+            throw this._pluginWorkerConnectionLost;
+        }
         if (this._daemonStatus == DaemonStatus.CONNECTED) {
             return;
         }
         // Ensure daemon is running and socket path is available
         if (this._daemonStatus == DaemonStatus.DISCONNECTED) {
+            // Create a fresh ready promise for any concurrent caller that hits
+            // the CONNECTING branch below before this attempt resolves.
+            this._waitForDaemonReady = this.createReadyPromise();
             this._daemonStatus = DaemonStatus.CONNECTING;
             let daemonPid = null;
-            let probe;
             try {
-                probe = await this.probeServer();
-            }
-            catch (err) {
-                // Version mismatch - treat as server not available, start new one
-                if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
-                    probe = { available: false };
+                let probe;
+                try {
+                    probe = await this.probeServer();
                 }
-                else {
-                    throw err;
+                catch (err) {
+                    // Version mismatch - treat as server not available, start new one
+                    if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
+                        probe = { available: false };
+                    }
+                    else {
+                        throw err;
+                    }
                 }
+                if (!probe.available) {
+                    // Carried as a value so no other caller's probe can substitute for it.
+                    daemonPid = await this.startInBackground(probe.refusal);
+                }
+                this.setUpConnection();
+                this._daemonStatus = DaemonStatus.CONNECTED;
+                this._daemonReady();
             }
-            if (!probe.available) {
-                // Carried as a value so no other caller's probe can substitute for it.
-                daemonPid = await this.startInBackground(probe.refusal);
+            catch (err) {
+                // Reset to DISCONNECTED and reject the ready promise so every
+                // concurrent caller parked on the CONNECTING branch gets the
+                // error instead of hanging forever.
+                this.failDaemonReady(err);
+                throw err;
             }
-            this.setUpConnection();
-            this._daemonStatus = DaemonStatus.CONNECTED;
-            this._daemonReady();
+            // Outside the try: the connection is established by now, and a throw
+            // from here must not undo it.
             daemonPid ??= (0, cache_1.getDaemonProcessIdSync)();
             // Fire-and-forget - don't block daemon connection by waiting for metrics registration
             this.registerDaemonProcessWithMetricsService(daemonPid);
@@ -859,13 +942,27 @@ class DaemonClient {
             this.registerDaemonProcessWithMetricsService(daemonPid);
         }
     }
-    async sendToDaemonViaQueue(messageToDaemon, parser) {
+    /** Shows the daemon's streamed graph and selection progress while waiting. */
+    async sendWithGraphSpinner(messageToDaemon) {
+        const spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon');
+        try {
+            return await this.sendToDaemonViaQueue(messageToDaemon, spinner);
+        }
+        finally {
+            spinner.cleanup();
+        }
+    }
+    async sendToDaemonViaQueue(messageToDaemon, spinner) {
         return this.queue.sendToQueue(async () => {
-            // Set currentSpinner inside the queued function so it's only
-            // active while this specific message is in flight — preventing
-            // concurrent callers from overwriting each other's spinner
-            // reference before their turn arrives.
-            return await this.sendMessageToDaemon(messageToDaemon, parser);
+            // Set inside the queued function so a waiting request cannot take
+            // over the in-flight request's spinner.
+            this.currentSpinner = spinner ?? null;
+            try {
+                return await this.sendMessageToDaemon(messageToDaemon);
+            }
+            finally {
+                this.currentSpinner = null;
+            }
         });
     }
     setUpConnection() {
@@ -927,27 +1024,33 @@ class DaemonClient {
     }
     async handleConnectionError(error) {
         logger_1.clientLogger.log(`[Reconnect] Connection error detected: ${error.message}`);
+        // A plugin worker cannot bring a daemon back — `startInBackground` throws
+        // in one — and it is usually hosted by the daemon that just died, so the
+        // 60s reconnect poll almost always ends in the same failure. Make the loss
+        // terminal instead: the in-flight message and every later one fail fast
+        // with a clear error. The cost is that a CLI-hosted worker no longer
+        // survives a daemon restart, and that command fails.
+        if (global.NX_PLUGIN_WORKER) {
+            const pluginWorkerError = daemonProcessException(`Plugin worker lost its daemon connection and cannot reconnect: ${error.message}`);
+            this._pluginWorkerConnectionLost = pluginWorkerError;
+            if (this.currentReject) {
+                this.currentReject(pluginWorkerError);
+            }
+            this.failDaemonReady(pluginWorkerError);
+            return;
+        }
         // Create a new ready promise for new requests to wait on
-        this._waitForDaemonReady = new Promise((resolve) => (this._daemonReady = resolve));
+        this._waitForDaemonReady = this.createReadyPromise();
         // Set status to CONNECTING so new requests will wait for reconnection
         this._daemonStatus = DaemonStatus.CONNECTING;
-        let serverAvailable;
         try {
-            ({ available: serverAvailable } = await this.waitForServerToBeAvailable({
+            const { available } = await this.waitForServerToBeAvailable({
                 ignoreVersionMismatch: false,
-            }));
-        }
-        catch (err) {
-            if (err instanceof daemon_socket_messenger_1.VersionMismatchError) {
-                // New daemon has different version - reject with error so caller can handle
-                if (this.currentReject) {
-                    this.currentReject(err);
-                }
-                return;
+            });
+            if (!available) {
+                // Out of reconnect attempts, so the error that started this stands.
+                throw error;
             }
-            throw err;
-        }
-        if (serverAvailable) {
             logger_1.clientLogger.log(`[Reconnect] Reconnection successful, re-establishing connection`);
             // Server is back up, establish connection and signal ready
             this.establishConnection();
@@ -962,11 +1065,18 @@ class DaemonClient {
                 this.sendMessageToDaemon(msg).then(res, rej);
             }
         }
-        else {
-            // Failed to reconnect after all attempts, reject the pending request
-            if (this.currentReject) {
-                this.currentReject(error);
+        catch (err) {
+            this.failDaemonReady(err);
+            // A new daemon on a different version and an exhausted reconnect are
+            // both answers for the in-flight caller; anything else is unexpected
+            // and propagates.
+            if (err instanceof daemon_socket_messenger_1.VersionMismatchError || err === error) {
+                if (this.currentReject) {
+                    this.currentReject(err);
+                }
+                return;
             }
+            throw err;
         }
     }
     establishConnection() {
@@ -1026,7 +1136,7 @@ class DaemonClient {
             : `[Client] Server not available after ${WAIT_FOR_SERVER_CONFIG.maxAttempts} attempts`);
         return { available: false, refusal };
     }
-    async sendMessageToDaemon(message, force) {
+    async sendMessageToDaemon(message) {
         // the first message sent to the daemon includes an env prop
         // that updates the process.env values on the daemon.
         if (!this.envReflectionSent && !global.NX_PLUGIN_WORKER) {
@@ -1048,7 +1158,7 @@ class DaemonClient {
             this.currentMessage = message;
             this.currentResolve = resolve;
             this.currentReject = reject;
-            this.socketMessenger.sendMessage(message, force);
+            this.socketMessenger.sendMessage(message);
         }).finally(() => {
             clearTimeout(keepAlive);
         });

package/dist/src/daemon/client/daemon-socket-messenger.d.ts

@@ -6,7 +6,7 @@ export declare class VersionMismatchError extends Error {
 export declare class DaemonSocketMessenger {
     private socket;
     constructor(socket: Socket);
-    sendMessage<T extends DaemonMessage>(messageToDaemon: T, force?: 'v8' | 'json'): void;
+    sendMessage<T extends DaemonMessage>(messageToDaemon: T): void;
     listen(onData: (message: Buffer) => void, onClose?: () => void, onError?: (err: Error) => void): DaemonSocketMessenger;
     close(): void;
 }

package/dist/src/daemon/client/daemon-socket-messenger.js

@@ -18,7 +18,7 @@ class DaemonSocketMessenger {
     constructor(socket) {
         this.socket = socket;
     }
-    sendMessage(messageToDaemon, force) {
+    sendMessage(messageToDaemon) {
         if (!this.socket) {
             throw new Error('Socket not initialized.');
         }
@@ -27,7 +27,7 @@ class DaemonSocketMessenger {
         messageToDaemon.workspaceRoot = workspace_root_1.workspaceRoot;
         logger_1.clientLogger.log('[Messenger] Sending message type:', messageToDaemon.type);
         perf_hooks_1.performance.mark('daemon-message-serialization-start-' + messageToDaemon.type);
-        const serialized = (0, socket_utils_1.serialize)(messageToDaemon, force);
+        const serialized = (0, socket_utils_1.serialize)(messageToDaemon);
         perf_hooks_1.performance.mark('daemon-message-serialization-end-' + messageToDaemon.type);
         perf_hooks_1.performance.measure('daemon-message-serialization-' + messageToDaemon.type, 'daemon-message-serialization-start-' + messageToDaemon.type, 'daemon-message-serialization-end-' + messageToDaemon.type);
         (0, consume_messages_from_socket_1.writeMessage)(this.socket, serialized);

package/dist/src/daemon/server/client-socket-context.js

@@ -50,7 +50,7 @@ function assertOnDaemon(helperName) {
 function writeStreamingMessage(socket, payload, description) {
     try {
         logger_1.serverLogger.log('Streaming message to client:', description);
-        (0, socket_utils_1.sendMessage)(socket, payload, undefined, (err) => {
+        (0, socket_utils_1.sendMessage)(socket, payload, (err) => {
             if (err) {
                 console.log(`Streaming message write error (client likely disconnected): ${err.message}`);
             }

package/dist/src/daemon/server/handle-process-in-background.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleProcessInBackground = handleProcessInBackground;
 const logger_1 = require("../logger");
 const installation_directory_1 = require("../../utils/installation-directory");
+const socket_utils_1 = require("../socket-utils");
+const native_js_loader_1 = require("./native-js-loader");
 async function handleProcessInBackground(payload) {
     let fn;
     try {
-        fn = require(require.resolve(payload.requirePath, {
+        fn = (0, native_js_loader_1.requireWithNativeJsLoader)(require.resolve(payload.requirePath, {
             paths: (0, installation_directory_1.getNxRequirePaths)(),
         })).default;
     }
     catch (e) {
-        return {
-            description: `Unable to require ${payload.requirePath}`,
-            error: new Error(`Unable to require ${payload.requirePath}`),
-        };
+        const description = `Unable to require ${payload.requirePath}`;
+        return { description, error: toTransportableError(e, description) };
     }
     try {
         const response = await fn(payload.data, logger_1.serverLogger);
@@ -24,9 +24,21 @@ async function handleProcessInBackground(payload) {
         };
     }
     catch (e) {
-        return {
-            description: `Error when processing ${payload.type}.`,
-            error: e,
-        };
+        const description = `Error when processing ${payload.type}.`;
+        return { description, error: toTransportableError(e, description) };
+    }
+}
+function toTransportableError(e, fallbackMessage) {
+    if (!(e instanceof Error)) {
+        return new Error(fallbackMessage);
+    }
+    try {
+        (0, socket_utils_1.serializeResult)(e, null, null);
+        return e;
+    }
+    catch {
+        const copy = new Error(e.message);
+        copy.stack = e.stack;
+        return copy;
     }
 }

package/dist/src/daemon/server/handle-select-affected-tasks.d.ts

@@ -1,3 +1,4 @@
+import type { Socket } from 'net';
 import { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
 import type { HandlerResult } from './server';
-export declare function handleSelectAffectedTasks(request: AffectedTasksRequest): Promise<HandlerResult>;
+export declare function handleSelectAffectedTasks(request: AffectedTasksRequest, socket: Socket): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-select-affected-tasks.js

@@ -3,24 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleSelectAffectedTasks = handleSelectAffectedTasks;
 const configuration_1 = require("../../config/configuration");
 const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
+const progress_topics_1 = require("../../utils/progress-topics");
+const client_socket_context_1 = require("./client-socket-context");
 const ultracache_configuration_state_1 = require("./ultracache-configuration-state");
 const planning_context_1 = require("./planning-context");
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
-async function handleSelectAffectedTasks(request) {
-    const { error, projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+async function handleSelectAffectedTasks(request, socket) {
+    const { error, projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)(socket);
     if (error) {
         throw error;
     }
     const nxJson = (0, configuration_1.readNxJson)();
-    const selection = await (0, affected_tasks_1.selectAffectedTasks)(projectGraph, nxJson, (0, planning_context_1.planningContextFor)(projectGraph, nxJson), request, {
-        ultracacheConfigurations: (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(request.ultracacheConfigurationsVersion),
-    });
-    const response = {
-        projectGraph,
-        affectedTaskIds: [...selection.affectedTaskIds],
-        taskGraph: selection.taskGraph,
-        taskSelection: selection.taskSelection,
-        explanation: selection.explanation,
-    };
-    return { response, description: 'handleSelectAffectedTasks' };
+    (0, client_socket_context_1.subscribeClientToTopic)(socket, progress_topics_1.ProgressTopics.AffectedTasks);
+    try {
+        const selection = await (0, affected_tasks_1.selectAffectedTasks)(projectGraph, nxJson, (0, planning_context_1.planningContextFor)(projectGraph, nxJson), request, {
+            ultracacheConfigurations: (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(request.ultracacheConfigurationsVersion),
+        });
+        const response = {
+            projectGraph,
+            affectedTaskIds: [...selection.affectedTaskIds],
+            taskGraph: selection.taskGraph,
+            taskSelection: selection.taskSelection,
+            explanation: selection.explanation,
+        };
+        return { response, description: 'handleSelectAffectedTasks' };
+    }
+    finally {
+        (0, client_socket_context_1.unsubscribeClientFromTopic)(socket, progress_topics_1.ProgressTopics.AffectedTasks);
+    }
 }

package/dist/src/daemon/server/native-js-loader.d.ts

@@ -0,0 +1 @@
+export declare function requireWithNativeJsLoader(path: string): any;

package/dist/src/daemon/server/native-js-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireWithNativeJsLoader = requireWithNativeJsLoader;
+// Captured when the daemon starts, before plugins or sync generators can
+// replace it (e.g. @swc-node/register compiles every .js outside node_modules).
+const nativeJsLoader = require.extensions?.['.js'];
+function requireWithNativeJsLoader(path) {
+    // Undefined when a loader hook (e.g. Yarn PnP's) has Node's ESM loader run
+    // nx's CommonJS. The require nx gets there never runs .js hooks.
+    if (!nativeJsLoader) {
+        return require(path);
+    }
+    const currentJsLoader = require.extensions['.js'];
+    require.extensions['.js'] = nativeJsLoader;
+    try {
+        return require(path);
+    }
+    finally {
+        require.extensions['.js'] = currentJsLoader;
+    }
+}

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -36,7 +36,6 @@ const collectedUpdatedFiles = new Map();
 const collectedDeletedFiles = new Map();
 const projectGraphRecomputationListeners = new Set();
 let storedWorkspaceConfigHash;
-let knownExternalNodes = {};
 let fileChangeCounter = 0;
 let recomputationGeneration = 0;
 // The graph the settled cached promise serves, with the generation its
@@ -341,7 +340,7 @@ function computeWorkspaceConfigHash(projectsConfigurations) {
         .map(([projectName, projectConfig]) => `${projectName}:${JSON.stringify(projectConfig)}`);
     return (0, file_hasher_1.hashArray)(projectConfigurationStrings);
 }
-async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes, projectRootMap }, updatedFileHashes, deletedFiles) {
+async function processCollectedUpdatedAndDeletedFiles({ projects, projectRootMap }, updatedFileHashes, deletedFiles) {
     try {
         const configHash = computeWorkspaceConfigHash(projects);
         // Config changed → can't incrementally update; refetch the file map
@@ -350,7 +349,7 @@ async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes,
         // can't clobber a faster newer one's already-committed state.
         if (configHash !== storedWorkspaceConfigHash) {
             const fresh = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
-            return { fileMap: fresh, configHash, knownExternalNodes: externalNodes };
+            return { fileMap: fresh, configHash };
         }
         // Config unchanged → patch the existing file map in place.
         if (exports.fileMapWithFiles) {
@@ -477,9 +476,6 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // can't clobber a newer compute's write.
         exports.fileMapWithFiles = fileMapUpdate.fileMap;
         storedWorkspaceConfigHash = fileMapUpdate.configHash;
-        if (fileMapUpdate.knownExternalNodes) {
-            knownExternalNodes = fileMapUpdate.knownExternalNodes;
-        }
         // Drain only after committing — a stale compute that returns at the
         // staleness check above must leave its snapshot in `collected*` so the
         // newer compute still sees those files. Removing them earlier would
@@ -604,12 +600,12 @@ function copyFileMap(m) {
     }
     return c;
 }
-async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
+async function createAndSerializeProjectGraph({ projects, externalNodes, sourceMaps, }) {
     try {
         perf_hooks_1.performance.mark('create-project-graph-start');
         const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
         const rustReferences = exports.fileMapWithFiles.rustReferences;
-        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot)), sourceMaps);
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot)), sourceMaps);
         exports.currentProjectFileMapCache = projectFileMapCache;
         exports.currentProjectGraph = projectGraph;
         exports.currentSourceMaps = sourceMaps;

package/dist/src/daemon/server/server.d.ts

@@ -1,5 +1,6 @@
 import { Server, Socket } from 'net';
 import '../../utils/perf-logging';
+import { respondWithErrorAndExit } from './shutdown-utils';
 export type HandlerResult = {
     description: string;
     error?: any;
@@ -7,5 +8,5 @@ export type HandlerResult = {
 };
 export declare const openSockets: Set<Socket>;
 export declare function handleMessage(socket: Socket, data: Buffer): Promise<void>;
-export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>, mode: 'json' | 'v8'): Promise<void>;
+export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>, mode: 'json' | 'v8', respondToError?: typeof respondWithErrorAndExit): Promise<void>;
 export declare function startServer(): Promise<Server>;