nx 24.0.0-beta.0 → 24.0.0-beta.2

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

@@ -13,6 +13,7 @@ const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
     (0, dotenv_1.loadRootEnvFiles)();
+    fullTaskGraph = withEdgeObjects(fullTaskGraph);
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -52,6 +53,18 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
     orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
+// A client bundle built before edges became objects hands plain task ids
+function withEdgeObjects(taskGraph) {
+    const normalize = (edges) => Object.fromEntries(Object.entries(edges).map(([taskId, taskEdges]) => [
+        taskId,
+        taskEdges.map((edge) => typeof edge === 'string' ? { id: edge } : edge),
+    ]));
+    return {
+        ...taskGraph,
+        dependencies: normalize(taskGraph.dependencies),
+        continuousDependencies: normalize(taskGraph.continuousDependencies),
+    };
+}
 // Nothing awaits the dispose chains below, so an unhandled rejection would take
 // down a long-lived agent process.
 function logDisposeFailure(e) {

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
+import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskReadiness, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
 import { TaskStatus } from './tasks-runner';
 /**
  * The result of a completed {@link Task}.
@@ -48,6 +48,8 @@ export interface LifeCycle {
     registerRunningTaskWithEmptyParser?(taskId: string): void;
     appendTaskOutput?(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    /** Only continuous tasks that declare a `readyWhen` report readiness. */
+    setTaskReadiness?(taskId: string, readiness: TaskReadiness): void;
     setTaskTiming?(taskId: string, startTime: number, endTime: number): void;
     registerForcedShutdownCallback?(callback: () => void): void;
     setEstimatedTaskTimings?(timings: Record<string, number>): void;
@@ -82,6 +84,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     registerRunningTaskWithEmptyParser(taskId: string): void;
     appendTaskOutput(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    setTaskReadiness(taskId: string, readiness: TaskReadiness): void;
     setTaskTiming(taskId: string, startTime: number, endTime: number): void;
     registerForcedShutdownCallback(callback: () => void): void;
     setEstimatedTaskTimings(timings: Record<string, number>): void;

package/dist/src/tasks-runner/life-cycle.js

@@ -95,6 +95,13 @@ class CompositeLifeCycle {
             }
         }
     }
+    setTaskReadiness(taskId, readiness) {
+        for (let l of this.lifeCycles) {
+            if (l.setTaskReadiness) {
+                l.setTaskReadiness(taskId, readiness);
+            }
+        }
+    }
     setTaskTiming(taskId, startTime, endTime) {
         for (let l of this.lifeCycles) {
             if (l.setTaskTiming) {

package/dist/src/tasks-runner/life-cycles/performance-analysis.d.ts

@@ -4,6 +4,8 @@ import { TaskResult } from '../life-cycle';
 export interface TaskTiming {
     startTime?: number;
     endTime?: number;
+    /** When a continuous task passed its `readyWhen` check. */
+    readyTime?: number;
     continuous: boolean;
 }
 /** A discrete task that ran, with its window and whether it monopolizes the pool (`parallelism: false`). */
@@ -122,8 +124,9 @@ export declare class PerformanceAnalysis {
     private finishEstimate;
     /**
      * Earliest this task became eligible, independent of slots: the latest of run
-     * start, dependency ends, any continuous dependency's *start* (an ordering
-     * constraint, not contention), and any earlier batch sibling's end.
+     * start, dependency ends, any continuous dependency's *start*, or its
+     * readiness when the edge waits for it (an ordering constraint, not
+     * contention), and any earlier batch sibling's end.
      */
     private readyTime;
     /**

package/dist/src/tasks-runner/life-cycles/performance-analysis.js

@@ -101,7 +101,9 @@ class PerformanceAnalysis {
      */
     predecessorsFor(id, durations) {
         const start = this.timings.get(id)?.startTime ?? Infinity;
-        const deps = (this.taskGraph.dependencies[id] ?? []).filter((d) => durations.has(d));
+        const deps = (this.taskGraph.dependencies[id] ?? [])
+            .map((d) => d.id)
+            .filter((d) => durations.has(d));
         const siblings = (this.batchSiblings.get(id) ?? []).filter((s) => {
             const sEnd = this.timings.get(s)?.endTime;
             return durations.has(s) && sEnd != null && sEnd <= start;
@@ -142,22 +144,26 @@ class PerformanceAnalysis {
     }
     /**
      * Earliest this task became eligible, independent of slots: the latest of run
-     * start, dependency ends, any continuous dependency's *start* (an ordering
-     * constraint, not contention), and any earlier batch sibling's end.
+     * start, dependency ends, any continuous dependency's *start*, or its
+     * readiness when the edge waits for it (an ordering constraint, not
+     * contention), and any earlier batch sibling's end.
      */
     readyTime(id, runStart) {
         const start = this.timings.get(id)?.startTime;
         let result = runStart;
         for (const dep of this.taskGraph.dependencies[id] ?? []) {
-            const end = this.timings.get(dep)?.endTime;
+            const end = this.timings.get(dep.id)?.endTime;
             if (end != null) {
                 result = Math.max(result, end);
             }
         }
         for (const cdep of this.taskGraph.continuousDependencies?.[id] ?? []) {
-            const cStart = this.timings.get(cdep)?.startTime;
-            if (cStart != null) {
-                result = Math.max(result, cStart);
+            const producer = this.timings.get(cdep.id);
+            const usable = cdep.waitFor === 'ready'
+                ? (producer?.readyTime ?? producer?.startTime)
+                : producer?.startTime;
+            if (usable != null) {
+                result = Math.max(result, usable);
             }
         }
         for (const sibling of this.batchSiblings.get(id) ?? []) {

package/dist/src/tasks-runner/life-cycles/performance-life-cycle.d.ts

@@ -1,4 +1,4 @@
-import type { BatchInfo, PerformanceSummaryPayload } from '../../native';
+import { TaskReadiness, type BatchInfo, type PerformanceSummaryPayload } from '../../native';
 import { TaskGraph } from '../../config/task-graph';
 import { LifeCycle, TaskResult } from '../life-cycle';
 import { type PerformanceLifeCycleOptions, type PerformanceSummary } from './performance-analysis';
@@ -14,8 +14,8 @@ import { type PerformanceLifeCycleOptions, type PerformanceSummary } from './per
  * coordinator time (hashing, scheduling, continuous-dep waits).
  *
  * Scope: discrete tasks only. Continuous tasks (no end time) are excluded; a
- * discrete task's wait for a continuous dependency to start is eligibility, not
- * contention.
+ * discrete task's wait for a continuous dependency to start, or to be ready, is
+ * eligibility, not contention.
  */
 export declare class PerformanceLifeCycle implements LifeCycle {
     private readonly taskGraph;
@@ -34,6 +34,7 @@ export declare class PerformanceLifeCycle implements LifeCycle {
      */
     startCommand(_threadCount?: number, parallel?: number): void;
     registerRunningBatch(_batchId: string, batchInfo: BatchInfo): void;
+    setTaskReadiness(taskId: string, readiness: TaskReadiness): void;
     endTasks(taskResults: TaskResult[]): void;
     private entry;
     /** Analyze the collected timings into a structured summary, or `null` when no discrete task timings were recorded. */

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

@@ -20,8 +20,8 @@ const performance_analysis_1 = require("./performance-analysis");
  * coordinator time (hashing, scheduling, continuous-dep waits).
  *
  * Scope: discrete tasks only. Continuous tasks (no end time) are excluded; a
- * discrete task's wait for a continuous dependency to start is eligibility, not
- * contention.
+ * discrete task's wait for a continuous dependency to start, or to be ready, is
+ * eligibility, not contention.
  */
 class PerformanceLifeCycle {
     constructor(taskGraph, options = {}) {
@@ -51,6 +51,13 @@ class PerformanceLifeCycle {
             this.batchSiblings.set(id, batchInfo.taskIds.filter((other) => other !== id));
         }
     }
+    setTaskReadiness(taskId, readiness) {
+        const entry = this.entry(taskId);
+        // Each waiter polling a shared producer reports Ready; the first one counts.
+        if (readiness === 1 /* TaskReadiness.Ready */ && entry.readyTime == null) {
+            entry.readyTime = Date.now();
+        }
+    }
     endTasks(taskResults) {
         // Called incrementally (per group/batch); accumulate so the last call sees every timing.
         for (const { task, status } of taskResults) {

package/dist/src/tasks-runner/readiness/probes.d.ts

@@ -0,0 +1,9 @@
+import type { RunningTask } from '../running-tasks/running-task';
+import { type NormalizedReadyWhen } from './ready-when';
+export interface ReadinessProbeContext {
+    taskId: string;
+    runningTask: RunningTask;
+    cwd: string;
+    signal: AbortSignal;
+}
+export declare function waitForReadiness(readyWhen: NormalizedReadyWhen, context: ReadinessProbeContext): Promise<void>;

package/dist/src/tasks-runner/readiness/probes.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForReadiness = waitForReadiness;
+const native_1 = require("../../native");
+const ready_when_1 = require("./ready-when");
+// Never rejects for a transient probe error: every failure is retried until
+// the deadline.
+async function waitForReadiness(readyWhen, context) {
+    if (native_1.IS_WASM) {
+        throw new Error(`The WASM build of Nx does not support "readyWhen", so "${context.taskId}" cannot be probed for readiness.`);
+    }
+    if (readyWhen.kind === 'logMatches') {
+        return waitForLogMatch(readyWhen, context);
+    }
+    const probe = new native_1.ReadinessProbe({
+        timeout: readyWhen.timeout,
+        interval: readyWhen.interval,
+        ...(readyWhen.kind === 'url'
+            ? { url: readyWhen.url }
+            : readyWhen.kind === 'port'
+                ? { port: readyWhen.port, host: readyWhen.host }
+                : { command: readyWhen.command }),
+    }, context.cwd);
+    const cancel = () => probe.cancel();
+    context.signal.addEventListener('abort', cancel);
+    if (context.signal.aborted) {
+        probe.cancel();
+    }
+    let ready;
+    try {
+        ready = await probe.wait();
+    }
+    finally {
+        context.signal.removeEventListener('abort', cancel);
+    }
+    if (!ready) {
+        throw context.signal.aborted
+            ? (0, ready_when_1.notReadyError)(context.taskId, 'exited')
+            : (0, ready_when_1.readinessTimeoutError)(context.taskId, readyWhen);
+    }
+}
+function waitForLogMatch(readyWhen, context) {
+    return new Promise((resolve, reject) => {
+        const matcher = new native_1.LogMatcher(readyWhen.logMatches);
+        let settled = false;
+        const settle = (error) => {
+            settled = true;
+            clearTimeout(timer);
+            context.signal.removeEventListener('abort', onAbort);
+            error ? reject(error) : resolve();
+        };
+        const onAbort = () => settle((0, ready_when_1.notReadyError)(context.taskId, 'exited'));
+        const timer = setTimeout(() => settle((0, ready_when_1.readinessTimeoutError)(context.taskId, readyWhen)), readyWhen.timeout);
+        timer.unref();
+        context.signal.addEventListener('abort', onAbort);
+        context.runningTask.onOutput((chunk) => {
+            if (!settled && matcher.feed(chunk)) {
+                settle();
+            }
+        });
+    });
+}

package/dist/src/tasks-runner/readiness/ready-when.d.ts

@@ -0,0 +1,38 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import type { Task, TaskGraph } from '../../config/task-graph';
+import type { ProjectConfiguration, ReadyWhen } from '../../config/workspace-json-project-json';
+export type NormalizedReadyWhen = {
+    timeout: number;
+    interval?: number;
+} & ({
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'port';
+    port: number;
+    host?: string;
+} | {
+    kind: 'command';
+    command: string;
+} | {
+    kind: 'logMatches';
+    logMatches: string[];
+});
+export interface ReadyWhenData {
+    workspaceRoot: string;
+    projectRoot: string;
+    projectName: string;
+    options: Record<string, unknown>;
+}
+export declare function normalizeReadyWhen(readyWhen: ReadyWhen, taskId: string, data: ReadyWhenData): NormalizedReadyWhen;
+export declare function readinessTimeoutError(taskId: string, readyWhen: NormalizedReadyWhen): Error;
+export declare class ProducerFailedError extends Error {
+    constructor(taskId: string);
+}
+export declare class NotReadyError extends Error {
+}
+export declare function notReadyError(taskId: string, reason: 'exited' | 'was stopped' | 'failed'): Error;
+export declare function getReadyWhenConfig(task: Task, projectGraph: ProjectGraph): ReadyWhen | undefined;
+export declare function getReadyWhen(task: Task, projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, workspaceRoot: string): NormalizedReadyWhen | null;
+export declare function getReadyProducerIds(task: Task, taskGraph: TaskGraph): string[];
+export declare function getReadyDependencies(taskGraph: TaskGraph, projectGraph: ProjectGraph): Record<string, string[]>;

package/dist/src/tasks-runner/readiness/ready-when.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotReadyError = exports.ProducerFailedError = void 0;
+exports.normalizeReadyWhen = normalizeReadyWhen;
+exports.readinessTimeoutError = readinessTimeoutError;
+exports.notReadyError = notReadyError;
+exports.getReadyWhenConfig = getReadyWhenConfig;
+exports.getReadyWhen = getReadyWhen;
+exports.getReadyProducerIds = getReadyProducerIds;
+exports.getReadyDependencies = getReadyDependencies;
+const path_1 = require("path");
+const params_1 = require("../../utils/params");
+const utils_1 = require("../utils");
+const DEFAULT_READY_TIMEOUT = 60_000;
+// Node timers take at most a signed 32-bit count of milliseconds
+const MAX_DURATION = 2_147_483_647;
+const PROBE_KEYS = ['url', 'port', 'command', 'logMatches'];
+// The placeholders `outputs` resolve, matched by name so that braces a shell
+// command needs (`{{.State.Health.Status}}`, `${VAR}`, `{a,b}`) stay literal
+const PLACEHOLDER = /{(workspaceRoot|projectRoot|projectName|options\.[^}]+)}/g;
+function normalizeReadyWhen(readyWhen, taskId, data) {
+    const invalid = (reason) => new Error(`Task "${taskId}" has an invalid "readyWhen": ${reason}.`);
+    if (typeof readyWhen !== 'object' || readyWhen === null) {
+        throw invalid('expected an object');
+    }
+    const config = readyWhen;
+    const resolve = (value) => typeof value === 'string'
+        ? value.replace(PLACEHOLDER, (match, name) => {
+            let resolved = data;
+            for (const key of name.split('.')) {
+                resolved = resolved?.[key];
+            }
+            if (resolved == null) {
+                throw invalid(`"${match}" has no value`);
+            }
+            if (!['string', 'number', 'boolean'].includes(typeof resolved)) {
+                throw invalid(`"${match}" is not a string or a number`);
+            }
+            return String(resolved);
+        })
+        : value;
+    // Braces are never valid in a host or port once resolved, so a leftover is
+    // a typo. A url keeps them: they are legal in its path and query.
+    const resolveWithoutBraces = (key) => {
+        const value = resolve(config[key]);
+        if (typeof value === 'string' && /[{}]/.test(value)) {
+            throw invalid(`"${key}" contains an unknown placeholder`);
+        }
+        return value;
+    };
+    const present = PROBE_KEYS.filter((key) => config[key] != null);
+    if (present.length !== 1) {
+        throw invalid(`expected exactly one of ${PROBE_KEYS.map((k) => `"${k}"`).join(', ')}`);
+    }
+    const timeout = config.timeout ?? DEFAULT_READY_TIMEOUT;
+    if (!isDuration(timeout)) {
+        throw invalid(`"timeout" must be an integer from 1 to ${MAX_DURATION}`);
+    }
+    const shared = { timeout };
+    if (config.interval != null) {
+        if (!isDuration(config.interval)) {
+            throw invalid(`"interval" must be an integer from 1 to ${MAX_DURATION}`);
+        }
+        shared.interval = config.interval;
+    }
+    switch (present[0]) {
+        case 'url': {
+            const url = resolve(config.url);
+            if (typeof url !== 'string' || !isHttpUrl(url)) {
+                throw invalid('"url" must be an http or https URL');
+            }
+            return { kind: 'url', url, ...shared };
+        }
+        case 'port': {
+            let port = resolveWithoutBraces('port');
+            if (typeof port === 'string' && /^\d+$/.test(port)) {
+                port = Number(port);
+            }
+            if (!isPositiveInteger(port) || port > 65535) {
+                throw invalid('"port" must be an integer from 1 to 65535');
+            }
+            const host = resolveWithoutBraces('host');
+            if (host == null) {
+                return { kind: 'port', port, ...shared };
+            }
+            if (typeof host !== 'string' || !host) {
+                throw invalid('"host" must be a non-empty string');
+            }
+            return { kind: 'port', port, host, ...shared };
+        }
+        case 'command': {
+            const command = resolve(config.command);
+            if (typeof command !== 'string' || !command) {
+                throw invalid('"command" must be a non-empty string');
+            }
+            return { kind: 'command', command, ...shared };
+        }
+        case 'logMatches': {
+            const logMatches = (Array.isArray(config.logMatches)
+                ? config.logMatches
+                : [config.logMatches]).map(resolve);
+            if (logMatches.length === 0 ||
+                !logMatches.every((m) => typeof m === 'string' && !!m)) {
+                throw invalid('"logMatches" must be a non-empty string or an array of them');
+            }
+            return { kind: 'logMatches', logMatches, ...shared };
+        }
+    }
+}
+function readinessTimeoutError(taskId, readyWhen) {
+    return new Error(`Task "${taskId}" did not become ready within ${readyWhen.timeout}ms (readyWhen: ${describeReadyWhen(readyWhen)}).`);
+}
+// The row carries only the status; the owner reports the reason
+class ProducerFailedError extends Error {
+    constructor(taskId) {
+        super(`Task "${taskId}" failed its readiness check in the process that started it.`);
+    }
+}
+exports.ProducerFailedError = ProducerFailedError;
+// An exit or a stop is completed by its own handler, not as a verdict
+class NotReadyError extends Error {
+}
+exports.NotReadyError = NotReadyError;
+function notReadyError(taskId, reason) {
+    return new NotReadyError(`Task "${taskId}" ${reason} before it became ready.`);
+}
+function describeReadyWhen(readyWhen) {
+    switch (readyWhen.kind) {
+        case 'url':
+            return `url ${readyWhen.url}`;
+        case 'port':
+            return readyWhen.host
+                ? `port ${readyWhen.host}:${readyWhen.port}`
+                : `port ${readyWhen.port}`;
+        case 'command':
+            return `command "${readyWhen.command}"`;
+        case 'logMatches':
+            return `logMatches ${readyWhen.logMatches.map((m) => `"${m}"`).join(', ')}`;
+    }
+}
+// Raw config: scheduling must not throw on an invalid value, the producer's
+// own start reports that
+function getReadyWhenConfig(task, projectGraph) {
+    if (!task.continuous) {
+        return undefined;
+    }
+    return projectGraph.nodes[task.target.project]?.data?.targets?.[task.target.target]?.readyWhen;
+}
+// Placeholders resolve against the options the executor receives: aliases,
+// schema defaults and the spelling of command-line overrides applied
+function getReadyWhen(task, projectGraph, projects, workspaceRoot) {
+    const readyWhen = getReadyWhenConfig(task, projectGraph);
+    if (readyWhen == null) {
+        return null;
+    }
+    const node = projectGraph.nodes[task.target.project];
+    const target = node.data.targets[task.target.target];
+    const { schema } = (0, utils_1.getExecutorForTask)(task, projects);
+    return normalizeReadyWhen(readyWhen, task.id, {
+        workspaceRoot,
+        projectRoot: node.data.root,
+        projectName: node.name,
+        options: (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? target.defaultConfiguration, target, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true'),
+    });
+}
+function getReadyProducerIds(task, taskGraph) {
+    return (taskGraph.continuousDependencies[task.id] ?? [])
+        .filter((edge) => edge.waitFor === 'ready')
+        .map((edge) => edge.id);
+}
+// Producers with a probe that each task waits on; tasks with none are left out
+function getReadyDependencies(taskGraph, projectGraph) {
+    const readyDependencies = {};
+    for (const task of Object.values(taskGraph.tasks)) {
+        const producerIds = getReadyProducerIds(task, taskGraph).filter((id) => getReadyWhenConfig(taskGraph.tasks[id], projectGraph) != null);
+        if (producerIds.length > 0) {
+            readyDependencies[task.id] = producerIds;
+        }
+    }
+    return readyDependencies;
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function isDuration(value) {
+    return isPositiveInteger(value) && value <= MAX_DURATION;
+}
+function isHttpUrl(value) {
+    return (URL.canParse(value) && ['http:', 'https:'].includes(new URL(value).protocol));
+}

package/dist/src/tasks-runner/run-command.js

@@ -50,6 +50,7 @@ const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle
 const task_telemetry_life_cycle_1 = require("./life-cycles/task-telemetry-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const tui_summary_life_cycle_1 = require("./life-cycles/tui-summary-life-cycle");
+const ready_when_1 = require("./readiness/ready-when");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const exit_codes_1 = require("../utils/exit-codes");
@@ -80,7 +81,7 @@ const SYNC_SKIPPED_FIX_MESSAGE_LINES = [
     '',
     'Run `nx sync` (no flags) later to sync the workspace.',
 ];
-async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
+async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, projectGraph, nxArgs, nxJson, overrides) {
     const overridesWithoutHidden = { ...overrides };
     delete overridesWithoutHidden['__overrides_unparsed__'];
     const isRunOne = initiatingProject != null;
@@ -133,7 +134,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
             pinnedTasks.push(mainTaskId);
             const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
             if (mainContinuousDependencies.length > 0) {
-                pinnedTasks.push(mainContinuousDependencies[0]);
+                pinnedTasks.push(mainContinuousDependencies[0].id);
             }
             const [, target] = mainTaskId.split(':');
             titleText = `1 ${target} task`;
@@ -179,7 +180,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const lifeCycles = [tsLifeCycle];
         // Only run the TUI if there are tasks to run
         if (tasks.length > 0) {
-            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, ready_when_1.getReadyDependencies)(taskGraph, projectGraph), (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
             // The native endCommand renders the perf report in the exit popup; the runner
             // sources the payload and CompositeLifeCycle forwards it here.
             lifeCycles.unshift(appLifeCycle);
@@ -401,7 +402,7 @@ async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }
     const projectNames = [
         ...new Set(initiatingTasks.map((t) => t.target.project)),
     ];
-    const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
+    const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, projectGraph, nxArgs, nxJson, overrides);
     try {
         const taskResults = await invokeTasksRunner({
             tasks,
@@ -719,7 +720,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    const deferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
+    const hashingDeferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
     reportUltracacheConfigurations(ultracacheConfigurationOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -790,7 +791,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
             },
         },
         daemon: client_1.daemonClient,
-        deferredTaskIds,
+        hashingDeferredTaskIds,
     });
     if (promiseOrObservable.subscribe) {
         promiseOrObservable = convertObservableToPromise(promiseOrObservable);

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

@@ -80,6 +80,12 @@ class BatchProcess {
                     for (const cb of this.batchResultsCallbacks) {
                         cb(message.results);
                     }
+                    // The worker runs a single batch. Its IPC channel would otherwise
+                    // keep it alive until cleanup kills it, which waits out the grace
+                    // period on Windows, where SIGTERM is a no-op.
+                    if (this.childProcess.connected) {
+                        this.childProcess.disconnect();
+                    }
                     break;
                 }
                 case batch_messages_1.BatchMessageType.RunTasks: {

package/dist/src/tasks-runner/running-tasks/node-child-process.js

@@ -14,6 +14,9 @@ class NodeChildProcessWithNonDirectOutput {
         this.terminalOutputChunks = [];
         this.exitCallbacks = [];
         this.outputCallbacks = [];
+        // Decode as a stream so a code point split across chunks stays intact
+        this.childProcess.stdout.setEncoding('utf8');
+        this.childProcess.stderr.setEncoding('utf8');
         if (streamOutput) {
             if (process.env.NX_PREFIX_OUTPUT === 'true') {
                 const color = (0, output_prefix_1.getColor)(prefix);
@@ -54,16 +57,14 @@ class NodeChildProcessWithNonDirectOutput {
                 process.send(message);
             }
         });
-        this.childProcess.stdout.on('data', (chunk) => {
-            const output = chunk.toString();
+        this.childProcess.stdout.on('data', (output) => {
             this.terminalOutputChunks.push(output);
             // Stream output to TUI via callbacks
             for (const cb of this.outputCallbacks) {
                 cb(output);
             }
         });
-        this.childProcess.stderr.on('data', (chunk) => {
-            const output = chunk.toString();
+        this.childProcess.stderr.on('data', (output) => {
             this.terminalOutputChunks.push(output);
             // Stream output to TUI via callbacks
             for (const cb of this.outputCallbacks) {

package/dist/src/tasks-runner/task-graph-utils.d.ts

@@ -1,24 +1,26 @@
 import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
+import { TaskGraph, TaskGraphEdge } from '../config/task-graph';
+/** Task graph edges, or the project ids of the command graph. */
+type Edge = string | TaskGraphEdge;
 /**
  * This function finds a cycle in the graph.
  * @returns the first cycle found, or null if no cycle is found.
  */
 export declare function findCycle(graph: {
-    dependencies: Record<string, string[]>;
-    continuousDependencies?: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
+    continuousDependencies?: Record<string, Edge[]>;
 }): string[] | null;
 /**
  * This function finds all cycles in the graph.
  * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
  */
 export declare function findCycles(graph: {
-    dependencies: Record<string, string[]>;
-    continuousDependencies?: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
+    continuousDependencies?: Record<string, Edge[]>;
 }): Set<string> | null;
 export declare function makeAcyclic(graph: {
     roots: string[];
-    dependencies: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
 }): void;
 export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
 export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;
@@ -28,3 +30,4 @@ export declare function getLeafTasks(taskGraph: TaskGraph): Set<string>;
  * Considers both dependencies and continuousDependencies.
  */
 export declare function walkTaskGraph(taskGraph: TaskGraph, walkFn: (rootTaskIds: string[]) => Promise<void>): Promise<void>;
+export {};