nx 22.7.10 → 22.7.12

package/dist/src/daemon/socket-utils.js

@@ -4,7 +4,9 @@ exports.getPluginOsSocketPath = exports.getForkedProcessOsSocketPath = exports.g
 exports.getPluginSocketFileName = getPluginSocketFileName;
 exports.killSocketOrPath = killSocketOrPath;
 exports.serializeResult = serializeResult;
+exports.serializeWithFallback = serializeWithFallback;
 exports.serialize = serialize;
+exports.sendMessage = sendMessage;
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -12,6 +14,7 @@ const tmp_dir_1 = require("./tmp-dir");
 const serializable_error_1 = require("../utils/serializable-error");
 const is_v8_serializer_enabled_1 = require("./is-v8-serializer-enabled");
 const v8_1 = require("v8");
+const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
 exports.isWindows = (0, os_1.platform)() === 'win32';
 /**
  * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
@@ -77,41 +80,52 @@ function serializeResult(error, serializedProjectGraph, serializedSourceMaps) {
     // We do not want to repeat work `JSON.stringify`ing an object containing the potentially large project graph so merge as strings
     return `{ "error": ${JSON.stringify(error ? (0, serializable_error_1.createSerializableError)(error) : error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
 }
+function serializeAs(data, format) {
+    return format === 'v8'
+        ? (0, v8_1.serialize)(data)
+        : Buffer.from(JSON.stringify(data), 'utf8');
+}
 /**
- * Helper to serialize data either using v8 serialization or JSON serialization, based on
- * the user's preference and the success of each method. Should only be used by "client" side
- * connections, daemon or other servers should respond based on the type of serialization used
- * by the client it is communicating with.
+ * Serialize using `preferred`, falling back to the other format when it throws.
+ * Neither format subsumes the other: JSON cannot represent a BigInt and hits the
+ * max string length far sooner, while v8 cannot clone a function.
  *
  * @param data Data to serialize
- * @param force Forces one serialization method over the other
- * @returns Serialized data as a string
+ * @param preferred Format to attempt first
+ * @returns Serialized data as bytes ready to be framed onto a socket
  */
-function serialize(data, force) {
-    if (force === 'v8' || (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)()) {
-        try {
-            return (0, v8_1.serialize)(data).toString('binary');
-        }
-        catch (e) {
-            if (force !== 'v8') {
-                console.warn(`Data could not be serialized using v8 serialization: ${e}. Falling back to JSON serialization.`);
-                // Fall back to JSON serialization
-                return JSON.stringify(data);
-            }
-            throw e;
-        }
+function serializeWithFallback(data, preferred) {
+    try {
+        return serializeAs(data, preferred);
     }
-    else {
-        try {
-            return JSON.stringify(data);
-        }
-        catch (e) {
-            if (force !== 'json') {
-                // Fall back to v8 serialization
-                console.warn(`Data could not be serialized using JSON.stringify: ${e}. Falling back to v8 serialization.`);
-                return (0, v8_1.serialize)(data).toString('binary');
-            }
-            throw e;
-        }
+    catch (e) {
+        const fallback = preferred === 'v8' ? 'json' : 'v8';
+        console.warn(`Data could not be serialized using ${preferred} serialization: ${e}. Falling back to ${fallback} serialization.`);
+        return serializeAs(data, fallback);
     }
 }
+/**
+ * Serialize data for IPC using the format the user configured.
+ *
+ * @param data Data to serialize
+ * @param force Use this format without falling back. For callers whose data is
+ *              known to be unrepresentable in the other format, where a fallback
+ *              would only swap one failure for a less obvious one.
+ * @returns Serialized data as bytes ready to be framed onto a socket
+ */
+function serialize(data, force) {
+    return force
+        ? serializeAs(data, force)
+        : serializeWithFallback(data, (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)() ? 'v8' : 'json');
+}
+/**
+ * Serialize `data` and write it as one framed message.
+ *
+ * Lives here rather than in `writeMessage` so the framing stays a byte-level
+ * primitive: `utils/consume-messages-from-socket` is shared by callers that
+ * already hold bytes, and having it reach back into the daemon's serializer
+ * would invert the dependency.
+ */
+function sendMessage(socket, data, force, callback) {
+    (0, consume_messages_from_socket_1.writeMessage)(socket, serialize(data, force), callback);
+}

package/dist/src/hasher/create-task-hasher.js

@@ -9,7 +9,7 @@ function createTaskHasher(projectGraph, nxJson, runnerOptions) {
         return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
     }
     else {
-        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        const { rustReferences } = (0, build_project_graph_1.getFileMap)();
         return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
 }

package/dist/src/project-graph/build-project-graph.d.ts

@@ -2,18 +2,16 @@ import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/proje
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 import { CreateMetadataError } from './error-types';
-import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { CreateMetadataContext } from './plugins';
 import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
 import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
 export declare function getFileMap(): {
     fileMap: FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
-export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
+export declare function hydrateFileMap(fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals): void;
+export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;

package/dist/src/project-graph/build-project-graph.js

@@ -23,13 +23,11 @@ const implicit_project_dependencies_1 = require("./utils/implicit-project-depend
 const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
 const target_merging_1 = require("./utils/project-configuration/target-merging");
 let storedFileMap = null;
-let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
 function getFileMap() {
     if (!!storedFileMap) {
         return {
             fileMap: storedFileMap,
-            allWorkspaceFiles: storedAllWorkspaceFiles,
             rustReferences: storedRustReferences,
         };
     }
@@ -39,19 +37,16 @@ function getFileMap() {
                 nonProjectFiles: [],
                 projectFileMap: {},
             },
-            allWorkspaceFiles: [],
             rustReferences: null,
         };
     }
 }
-function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+function hydrateFileMap(fileMap, rustReferences) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
 }
-async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
     const projects = {};
     for (const root in projectRootMap) {

package/dist/src/project-graph/file-map-utils.d.ts

@@ -1,8 +1,7 @@
-import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
-import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import type { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 export interface WorkspaceFileMap {
-    allWorkspaceFiles: FileData[];
     fileMap: FileMap;
 }
 export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
@@ -10,6 +9,5 @@ export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Pro
 export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
 export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
     fileMap: import("../native").FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals;
 };

package/dist/src/project-graph/file-map-utils.js

@@ -7,7 +7,6 @@ exports.updateFileMap = updateFileMap;
 const workspace_context_1 = require("../utils/workspace-context");
 const workspace_root_1 = require("../utils/workspace-root");
 const project_graph_1 = require("./project-graph");
-const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
 const find_project_for_path_1 = require("./utils/find-project-for-path");
 async function createProjectFileMapUsingProjectGraph(graph) {
     return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
@@ -38,7 +37,6 @@ function createFileMap(projectsConfigurations, allWorkspaceFiles) {
         }
     }
     return {
-        allWorkspaceFiles,
         fileMap: {
             projectFileMap,
             nonProjectFiles,
@@ -49,7 +47,6 @@ function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, del
     const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
     return {
         fileMap: updates.fileMap,
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
         rustReferences: updates.externalReferences,
     };
 }

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -52,7 +52,17 @@ class IsolatedPlugin {
         this.responseHandlers = new Map();
         this.exitHandler = null;
         this.handleSocketData = (raw) => {
-            const message = (0, consume_messages_from_socket_1.parseMessage)(raw);
+            let message;
+            try {
+                message = (0, consume_messages_from_socket_1.parseMessage)(raw);
+            }
+            catch (e) {
+                // Runs inside a synchronous socket 'data' callback, so a throw here
+                // becomes an uncaughtException in the host process rather than a failed
+                // plugin call.
+                logger_2.logger.error(`[plugin-client] "${this.name}" sent a message that could not be parsed: ${e instanceof Error ? e.message : e}\nReceived: ${(0, consume_messages_from_socket_1.describeMessage)(raw)}`);
+                return;
+            }
             if ((0, messaging_1.isPluginWorkerNotification)(message)) {
                 handlePluginWorkerNotification(message);
                 return;
@@ -94,7 +104,13 @@ class IsolatedPlugin {
             this.responseHandlers.clear();
         };
         worker.on('exit', this.exitHandler);
-        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(this.handleSocketData));
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(this.handleSocketData, (err) => {
+            // Nothing else settles the pending hook promises on a framing
+            // failure, so surface it the same way a dead worker would.
+            this.exitHandler?.();
+            socket.destroy();
+            console.error(err.message);
+        }));
         return this.sendLoadMessage();
     }
     /**

package/dist/src/project-graph/plugins/isolation/messaging.js

@@ -6,7 +6,6 @@ exports.isPluginWorkerResult = isPluginWorkerResult;
 exports.consumeMessage = consumeMessage;
 exports.sendMessageOverSocket = sendMessageOverSocket;
 const socket_utils_1 = require("../../../daemon/socket-utils");
-const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const NOTIFICATION_TYPES = [
     'emitLog',
@@ -84,6 +83,5 @@ async function consumeMessage(socket, raw, handlers) {
 function sendMessageOverSocket(socket, message) {
     // Stamped here rather than in each constructor, mirroring the daemon.
     message.workspaceRoot = workspace_root_1.workspaceRoot;
-    socket.write((0, socket_utils_1.serialize)(message));
-    socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+    (0, socket_utils_1.sendMessage)(socket, message);
 }

package/dist/src/project-graph/plugins/isolation/plugin-worker.js

@@ -87,7 +87,8 @@ const server = (0, net_1.createServer)((socket) => {
                         exclude: plugin.exclude,
                         createNodesPattern: plugin.createNodes?.[0],
                         hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
-                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        hasProcessProjectGraph: 'processProjectGraph' in plugin &&
+                            !!plugin.processProjectGraph,
                         hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
                         hasPreTasksExecution: 'preTasksExecution' in plugin && !!plugin.preTasksExecution,
                         hasPostTasksExecution: 'postTasksExecution' in plugin && !!plugin.postTasksExecution,
@@ -118,6 +119,13 @@ const server = (0, net_1.createServer)((socket) => {
                 }
             }),
         });
+    }, (err) => {
+        // The host link cannot resynchronize. Exit so the host's 'exit' handler
+        // rejects the pending hooks instead of waiting on a reply that the
+        // framing failure guarantees will never arrive.
+        console.error(err.message);
+        socket.destroy();
+        process.exit(1);
     }));
     // When the host disconnects, clean up and exit.
     socket.on('end', () => {

package/dist/src/project-graph/project-graph.js

@@ -104,14 +104,14 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
     perf_hooks_1.performance.mark('retrieve-project-configurations:end');
     perf_hooks_1.performance.mark('retrieve-workspace-files:start');
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
     let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
@@ -180,8 +180,8 @@ async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
         data.root,
         project,
     ]));
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
-    (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    (0, build_project_graph_1.hydrateFileMap)(fileMap, rustReferences);
     return graph;
 }
 /**

package/dist/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -3,13 +3,12 @@ import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
 import type { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 /**
- * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: Record<string, import("../../native").FileData[]>;
         nonProjectFiles: import("../../native").FileData[];

package/dist/src/project-graph/utils/retrieve-workspace-files.js

@@ -11,11 +11,10 @@ const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
 const project_configuration_utils_1 = require("./project-configuration-utils");
 const workspace_context_1 = require("../../utils/workspace-context");
-const build_all_workspace_files_1 = require("./build-all-workspace-files");
 const path_1 = require("path");
 const get_plugins_1 = require("../plugins/get-plugins");
 /**
- * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
@@ -29,7 +28,6 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
     perf_hooks_1.performance.mark('get-workspace-files:end');
     perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
     return {
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(projectFileMap, globalFiles),
         fileMap: {
             projectFileMap,
             nonProjectFiles: globalFiles,

package/dist/src/tasks-runner/forked-process-task-runner.d.ts

@@ -11,6 +11,8 @@ export declare class ForkedProcessTaskRunner {
     cliPath: string;
     private readonly verbose;
     private processes;
+    private processMessageHandler;
+    private processExitHandler;
     private finishedProcesses;
     private pseudoTerminals;
     constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
@@ -39,4 +41,5 @@ export declare class ForkedProcessTaskRunner {
     private writeTerminalOutput;
     cleanup(signal?: NodeJS.Signals): void;
     private setupProcessEventListeners;
+    removeProcessEventListeners(): void;
 }

package/dist/src/tasks-runner/forked-process-task-runner.js

@@ -271,7 +271,7 @@ class ForkedProcessTaskRunner {
         this.cleanUpBatchProcesses();
     }
     setupProcessEventListeners() {
-        const messageHandler = (message) => {
+        this.processMessageHandler = (message) => {
             this.pseudoTerminals.forEach((p) => {
                 p.sendMessageToChildren(message);
             });
@@ -281,14 +281,23 @@ class ForkedProcessTaskRunner {
                 }
             });
         };
+        this.processExitHandler = () => {
+            this.cleanup();
+            process.off('message', this.processMessageHandler);
+        };
         // When the nx process gets a message, it will be sent into the task's process
-        process.on('message', messageHandler);
+        process.on('message', this.processMessageHandler);
         // Terminate any task processes on exit
-        process.once('exit', () => {
-            this.cleanup();
-            process.off('message', messageHandler);
-        });
+        process.once('exit', this.processExitHandler);
         // Signal handlers removed - TaskOrchestrator owns signal handling
     }
+    // Long-lived processes (Nx Cloud agents) create a runner per invocation;
+    // without this each instance stays reachable from `process` forever.
+    // Call only after cleanup(): the exit handler is the last-resort child
+    // kill, so it must not be removed while children may still be alive.
+    removeProcessEventListeners() {
+        process.off('message', this.processMessageHandler);
+        process.off('exit', this.processExitHandler);
+    }
 }
 exports.ForkedProcessTaskRunner = ForkedProcessTaskRunner;

package/dist/src/tasks-runner/init-tasks-runner.js

@@ -14,6 +14,7 @@ const life_cycle_1 = require("./life-cycle");
 const task_orchestrator_1 = require("./task-orchestrator");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const client_1 = require("../daemon/client/client");
+const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 /**
  * This function is deprecated. Do not use this
@@ -110,6 +111,11 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
     orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
+// Nothing awaits the dispose chains below, so an unhandled rejection would take
+// down a long-lived agent process.
+function logDisposeFailure(e) {
+    console.error('Failed to dispose the task orchestrator:', e);
+}
 async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
     let groupId = 0;
@@ -138,12 +144,36 @@ async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson
             return [hit];
         return [await orchestrator.runTaskDirectly(true, task, groupId++)];
     });
-    return [...batchResults, ...taskResults];
+    const results = [...batchResults, ...taskResults];
+    // Callers like Nx Cloud agents create an orchestrator per invocation in a
+    // long-lived process; release its process-level listeners once all tasks
+    // settle, otherwise every invocation's orchestrator stays reachable forever.
+    // Not awaited, so callers keep consuming handles as they settle; the forked
+    // runner's exit handler still reaps children until dispose() runs.
+    Promise.allSettled(results)
+        .then(() => orchestrator.dispose())
+        .catch(logDisposeFailure);
+    return results;
 }
 async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
-    return tasks.reduce((current, task, index) => {
+    const runningTasks = tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;
     }, {});
+    // Unlike runDiscreteTasks, this must resolve at task start: callers keep
+    // the RunningTask handles to kill later, so disposal has to be deferred
+    // until every task actually exits.
+    Promise.allSettled(Object.entries(runningTasks).map(async ([taskId, promise]) => {
+        const runningTask = await promise;
+        // A shared task is owned by another nx process; this orchestrator has
+        // no child to protect for it, so disposal does not wait on it.
+        if (runningTask instanceof shared_running_task_1.SharedRunningTask) {
+            return;
+        }
+        await orchestrator.waitForContinuousTaskExit(taskId);
+    }))
+        .then(() => orchestrator.dispose())
+        .catch(logDisposeFailure);
+    return runningTasks;
 }

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -22,6 +22,8 @@ function getTasksHistoryLifeCycle() {
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
+        // Holds no terminalOutput: this singleton outlives every run in the
+        // process, and agents complete thousands of tasks in one process.
         this.pendingResults = new Map();
         this.taskRuns = new Map();
         this.taskHistory = (0, task_history_1.getTaskHistory)();
@@ -36,25 +38,28 @@ class TaskHistoryLifeCycle {
         }
     }
     async endTasks(taskResults) {
-        for (const taskResult of taskResults) {
-            this.pendingResults.set(taskResult.task.id, taskResult);
+        for (const { task, code, status } of taskResults) {
+            this.pendingResults.set(task.id, { task, code, status });
         }
     }
     async endCommand() {
+        const pendingResults = Array.from(this.pendingResults.values());
+        this.pendingResults.clear();
         if (!this.taskHistory) {
             return;
         }
         // Build TaskRun objects now — task.hash is guaranteed to be set by this point
-        for (const [, taskResult] of this.pendingResults) {
-            this.taskRuns.set(taskResult.task.hash, {
-                hash: taskResult.task.hash,
-                target: taskResult.task.target,
-                code: taskResult.code,
-                status: taskResult.status,
-                start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
-                end: taskResult.task.endTime ?? Date.now(),
-                cacheable: taskResult.task.cache === true,
+        for (const { task, code, status } of pendingResults) {
+            this.taskRuns.set(task.hash, {
+                hash: task.hash,
+                target: task.target,
+                code,
+                status,
+                start: task.startTime ?? this.startTimings[task.id],
+                end: task.endTime ?? Date.now(),
+                cacheable: task.cache === true,
             });
+            delete this.startTimings[task.id];
         }
         const runs = [];
         // Only check for flaky tasks among cacheable tasks

package/dist/src/tasks-runner/pseudo-ipc.js

@@ -77,6 +77,14 @@ class PseudoIPCServer {
                     this.childReadyMap.get(childId)();
                 }
             }
+        }, 
+        // Nothing resynchronizes a length-prefixed stream, so report it the
+        // same way a socket error is reported and let the peer see the close.
+        (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+            socket.destroy();
         }));
         socket.on('close', () => {
             for (const childMessage of this.childMessages) {
@@ -91,15 +99,12 @@ class PseudoIPCServer {
     }
     sendMessageToChildren(message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', message }));
-            // send EOT to indicate that the message has been fully written
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', message });
         });
     }
     sendMessageToChild(id, message) {
         this.sockets.forEach((socket) => {
-            socket.write((0, socket_utils_1.serialize)({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
-            socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+            (0, socket_utils_1.sendMessage)(socket, { type: 'TO_CHILDREN_FROM_PARENT', id, message });
         });
     }
     onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
@@ -121,17 +126,13 @@ class PseudoIPCClient {
         this.socket = (0, net_1.connect)(this.path);
     }
     sendMessageToParent(message) {
-        this.socket.write((0, socket_utils_1.serialize)({ type: 'TO_PARENT_FROM_CHILDREN', message }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        (0, socket_utils_1.sendMessage)(this.socket, { type: 'TO_PARENT_FROM_CHILDREN', message });
     }
     notifyChildIsReady(id) {
-        this.socket.write((0, socket_utils_1.serialize)({
+        (0, socket_utils_1.sendMessage)(this.socket, {
             type: 'CHILD_READY',
             message: id,
-        }));
-        // send EOT to indicate that the message has been fully written
-        this.socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
+        });
     }
     onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
         this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
@@ -144,7 +145,7 @@ class PseudoIPCClient {
                     onMessage(message);
                 }
             }
-        }));
+        }, onError));
         this.socket.on('close', onClose);
         this.socket.on('error', onError);
         return this;

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -82,6 +82,9 @@ class BatchProcess {
     onOutput(cb) {
         this.outputCallbacks.push(cb);
     }
+    // Resolves on the CompleteBatchExecution message, not process exit: the
+    // child can outlive its results (open handles keep it alive), so callers
+    // must not treat a settled batch as an exited process.
     async getResults() {
         return Promise.race([
             new Promise((_, rej) => {

package/dist/src/tasks-runner/running-tasks/shared-running-task.d.ts

@@ -3,6 +3,7 @@ import { RunningTasksService } from '../../native';
 export declare class SharedRunningTask implements RunningTask {
     private runningTasksService;
     private exitCallbacks;
+    private detached;
     constructor(runningTasksService: RunningTasksService, taskId: string);
     getResults(): Promise<{
         code: number;

package/dist/src/tasks-runner/running-tasks/shared-running-task.js

@@ -5,7 +5,11 @@ class SharedRunningTask {
     constructor(runningTasksService, taskId) {
         this.runningTasksService = runningTasksService;
         this.exitCallbacks = [];
+        this.detached = false;
         this.waitForTaskToFinish(taskId).then(() => {
+            if (this.detached) {
+                return;
+            }
             // notify exit callbacks
             this.exitCallbacks.forEach((cb) => cb(0));
         });
@@ -13,8 +17,14 @@ class SharedRunningTask {
     async getResults() {
         throw new Error('Results cannot be retrieved from a shared task');
     }
+    // Detaches from the shared task; the owning process keeps running it.
     kill() {
+        if (this.detached) {
+            return;
+        }
+        this.detached = true;
         this.exitCallbacks.forEach((cb) => cb(0));
+        this.exitCallbacks = [];
     }
     onExit(cb) {
         this.exitCallbacks.push(cb);
@@ -24,7 +34,8 @@ class SharedRunningTask {
         // wait for the running task to finish
         do {
             await new Promise((resolve) => setTimeout(resolve, 100));
-        } while (this.runningTasksService.getRunningTasks([taskId]).length);
+        } while (!this.detached &&
+            this.runningTasksService.getRunningTasks([taskId]).length);
     }
 }
 exports.SharedRunningTask = SharedRunningTask;