nx 23.3.0-beta.4 → 23.3.0-beta.6

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

@@ -8,10 +8,11 @@ const dotenv_1 = require("../utils/dotenv");
 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 outputs_1 = require("../io-snapshots/outputs");
 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");
-async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
+async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots) {
     (0, dotenv_1.loadRootEnvFiles)();
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
@@ -21,7 +22,6 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
         lifeCycle,
     ]);
     const { runnerOptions: options } = (0, run_command_1.getRunner)({}, nxJson);
-    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options);
     const taskGraph = {
         roots: tasks.map((task) => task.id),
         tasks: tasks.reduce((acc, task) => {
@@ -37,6 +37,13 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
             return acc;
         }, {}),
     };
+    // As in run-command, unhashed tasks hash from the caller's set. Applying is
+    // idempotent, so both graphs may share the same Task objects.
+    if (ioSnapshots) {
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, fullTaskGraph, ioSnapshots);
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
+    }
+    const hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ioSnapshots);
     const nxArgs = {
         ...options,
         parallel: tasks.length,
@@ -57,8 +64,10 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
 function logDisposeFailure(e) {
     console.error('Failed to dispose the task orchestrator:', e);
 }
-async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
+async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
     const batchResults = [];
@@ -96,8 +105,10 @@ async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, life
         .catch(logDisposeFailure);
     return results;
 }
-async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle);
+async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
+/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
+ioSnapshots) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
     const runningTasks = tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;

package/dist/src/tasks-runner/run-command.d.ts

@@ -1,17 +1,42 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxJsonConfiguration, TargetDependencies } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
+import { type IoSnapshotOutcome } from '../io-snapshots/store';
+import type { TaskPlanningContext } from '../hasher/task-planning-context';
+/** What a command runs. */
+export interface TaskSelection {
+    taskGraph: TaskGraph;
+    /**
+     * The tasks the command asked for, as opposed to ones pulled in as
+     * dependencies. A graph rebuilt after a sync is built from their projects.
+     */
+    initiatingTaskIds: string[];
+    /**
+     * What a rebuilt graph is pruned to: the selected tasks and everything they
+     * depend on. Unset keeps the whole rebuilt graph.
+     */
+    taskIds?: string[];
+    /** The planner selection used. It remembers those plans, so hashing the run reuses them. */
+    planningContext?: TaskPlanningContext;
+    /** The I/O snapshot set selection planned with; the run hashes with the same one. */
+    ioSnapshotOutcome?: IoSnapshotOutcome | null;
+}
 import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
-export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+/**
+ * `targets` on whole projects, as `run-many` runs them: every task of the
+ * projects' targets and what they depend on, with those tasks initiating.
+ */
+export declare function selectTasksForProjects(projectGraph: ProjectGraph, projectNames: string[], nxArgs: NxArgs, overrides: any, extraTargetDependencies: TargetDependencies, excludeTaskDependencies: boolean): TaskSelection;
+export declare function runCommand(taskSelection: TaskSelection, currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<NodeJS.Process['exitCode']>;
-export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+export declare function runTasksForCommand(taskSelection: TaskSelection, currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
@@ -21,7 +46,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     completed: boolean;
 }>;
 export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
-export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ioSnapshotOutcome: loadedIoSnapshotOutcome, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -31,10 +56,21 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
     initiatingTasks: Task[];
+    planningContext?: TaskPlanningContext;
+    /** Already loaded for this command; `undefined` loads it here. */
+    ioSnapshotOutcome?: IoSnapshotOutcome | null;
 }): Promise<{
     [id: string]: TaskResult;
 }>;
 export declare function constructLifeCycles(lifeCycle: LifeCycle, taskGraph: TaskGraph, nxJson?: NxJsonConfiguration, skipNxCache?: boolean): LifeCycle[];
+/**
+ * What affected task selection reads from the runner options, so it plans as
+ * the run hashes. The snapshot set is loaded once, for selection and the run.
+ */
+export declare function runnerInputsForSelection(nxArgs: NxArgs, nxJson: NxJsonConfiguration): Promise<{
+    ioSnapshotOutcome: IoSnapshotOutcome | null;
+    selectivelyHashTsConfig: boolean;
+}>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTasksForProjects = selectTasksForProjects;
 exports.runCommand = runCommand;
-exports.runCommandForTasks = runCommandForTasks;
+exports.runTasksForCommand = runTasksForCommand;
 exports.setEnvVarsBasedOnArgs = setEnvVarsBasedOnArgs;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.constructLifeCycles = constructLifeCycles;
+exports.runnerInputsForSelection = runnerInputsForSelection;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
 const tslib_1 = require("tslib");
@@ -23,6 +25,10 @@ const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const update_manager_1 = require("../nx-cloud/update-manager");
 const logger_1 = require("../utils/logger");
+const outputs_1 = require("../io-snapshots/outputs");
+const overrides_1 = require("../io-snapshots/overrides");
+const report_1 = require("../io-snapshots/report");
+const store_1 = require("../io-snapshots/store");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
 const configure_ai_agents_disclaimer_1 = require("../ai/configure-ai-agents-disclaimer");
@@ -305,8 +311,22 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         }
     }
 }
-function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies, projectNames, nxArgs, overrides, extraOptions) {
-    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, extraTargetDependencies, projectNames, nxArgs.targets, nxArgs.configuration, overrides, extraOptions.excludeTaskDependencies);
+/**
+ * `targets` on whole projects, as `run-many` runs them: every task of the
+ * projects' targets and what they depend on, with those tasks initiating.
+ */
+function selectTasksForProjects(projectGraph, projectNames, nxArgs, overrides, extraTargetDependencies, excludeTaskDependencies) {
+    const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, extraTargetDependencies, projectNames, nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
+    const projects = new Set(projectNames);
+    return {
+        taskGraph,
+        initiatingTaskIds: Object.values(taskGraph.tasks)
+            .filter((t) => projects.has(t.target.project) &&
+            nxArgs.targets.includes(t.target.target))
+            .map((t) => t.id),
+    };
+}
+function runValidations(projectGraph, taskGraph, nxArgs) {
     (0, task_graph_utils_1.assertTaskGraphDoesNotContainInvalidTargets)(taskGraph);
     const cycle = (0, task_graph_utils_1.findCycle)(taskGraph);
     if (cycle) {
@@ -332,7 +352,7 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
     }
     return taskGraph;
 }
-async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+async function runCommand(taskSelection, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
         const id = (0, native_1.hashArray)([...process.argv, Date.now().toString()]);
         await (0, tasks_execution_hooks_1.runPreTasksExecution)({
@@ -342,7 +362,7 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
             argv: process.argv,
         });
         const startTime = Date.now();
-        const { taskResults, completed } = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, {
+        const { taskResults, completed } = await runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, {
             ...nxArgs,
             skipNxCache: nxArgs.skipNxCache ||
                 process.env.NX_SKIP_NX_CACHE === 'true' ||
@@ -368,17 +388,20 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
     });
     return status;
 }
-async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     // Kick off the license lookup in the background so it overlaps with task
     // execution. The log itself is deferred to the print site below so it
     // never lands in the middle of task output.
     const nxKeyPromise = (0, nx_key_1.getNxKeyInformation)().catch(() => null);
-    const projectNames = projectsToRun.map((t) => t.name);
-    const projectNameSet = new Set(projectNames);
-    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
+    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, nxArgs, overrides, extraTargetDependencies, extraOptions, taskSelection);
     const tasks = Object.values(taskGraph.tasks);
-    const initiatingTasks = tasks.filter((t) => projectNameSet.has(t.target.project) &&
-        nxArgs.targets.includes(t.target.target));
+    // A sync generator can remove a selected task, so absent ids are skipped.
+    const initiatingTasks = taskSelection.initiatingTaskIds
+        .map((id) => taskGraph.tasks[id])
+        .filter(Boolean);
+    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);
     try {
         const taskResults = await invokeTasksRunner({
@@ -391,6 +414,8 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             loadDotEnvFiles: extraOptions.loadDotEnvFiles,
             initiatingProject,
             initiatingTasks,
+            planningContext: taskSelection.planningContext,
+            ioSnapshotOutcome: taskSelection.ioSnapshotOutcome,
         });
         await renderIsDone.finally(() => restoreTerminal?.());
         if (printSummary) {
@@ -447,8 +472,8 @@ function didCommandComplete(tasks, taskResults) {
     // Any stopped task means the run was interrupted
     return !Object.values(taskResults).some((r) => r.status === 'stopped');
 }
-async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
-    let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, nxArgs, overrides, extraTargetDependencies, extraOptions, taskSelection) {
+    let taskGraph = runValidations(projectGraph, taskSelection.taskGraph, nxArgs);
     if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
         return { projectGraph, taskGraph };
     }
@@ -563,9 +588,21 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
             });
             await confirmRunningTasksWithSyncFailures();
         }
-        // Re-create project graph and task graph
+        // Rebuild rather than carry: a sync generator may remove tasks or move inferred
+        // outputs, so the old graph and planning context are stale.
+        taskSelection.planningContext = undefined;
+        const projectNames = [
+            ...new Set(taskSelection.initiatingTaskIds
+                .filter((id) => taskGraph.tasks[id])
+                .map((id) => taskGraph.tasks[id].target.project)),
+        ];
         projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
-        taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+        const rebuilt = selectTasksForProjects(projectGraph, projectNames, nxArgs, overrides, extraTargetDependencies ?? {}, extraOptions.excludeTaskDependencies).taskGraph;
+        taskGraph = runValidations(projectGraph, 
+        // Before validation, so a cycle or atomizer error names what will actually run.
+        taskSelection.taskIds
+            ? (0, utils_1.pruneToSelectedTasks)(rebuilt, taskSelection.taskIds)
+            : rebuilt, nxArgs);
         const successTitle = anySyncGeneratorsFailed
             ? // the identified changes were synced successfully, but the workspace
                 // is still not up to date, which we'll mention next
@@ -669,16 +706,26 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
         process.env.NX_LOAD_DOT_ENV_FILES = 'true';
     }
 }
-async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }) {
+async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ioSnapshotOutcome: loadedIoSnapshotOutcome, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     // this needs to be done before we start to run the tasks
     const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
-    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
+    // Must precede hashing: the set is the snapshot source for task hashes,
+    // and observed outputs join the task outputs the hasher and cache see.
+    const ioSnapshotOutcome = loadedIoSnapshotOutcome !== undefined
+        ? loadedIoSnapshotOutcome
+        : await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions);
+    const ioSnapshots = (0, store_1.snapshotsOf)(ioSnapshotOutcome);
+    if (ioSnapshots) {
+        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
+    }
+    let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions, ioSnapshots, planningContext);
     // 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
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ioSnapshots);
+    reportIoSnapshots(ioSnapshotOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle, taskGraph, nxJson, nxArgs.skipNxCache),
@@ -825,6 +872,25 @@ function loadTasksRunner(modulePath) {
         throw e;
     }
 }
+function reportIoSnapshots(outcome, projectGraph, taskGraph, nxArgs) {
+    if (!outcome || outcome.status === 'skipped')
+        return;
+    if (!nxArgs.verbose && process.env.NX_VERBOSE_LOGGING !== 'true')
+        return;
+    const summary = (0, report_1.formatIoSnapshotSummary)((0, overrides_1.buildIoSnapshotOverrides)(projectGraph, taskGraph, outcome.snapshots), outcome.status);
+    output_1.output.note({ title: summary.line, bodyLines: summary.bodyLines });
+}
+/**
+ * What affected task selection reads from the runner options, so it plans as
+ * the run hashes. The snapshot set is loaded once, for selection and the run.
+ */
+async function runnerInputsForSelection(nxArgs, nxJson) {
+    const { runnerOptions } = getRunner(nxArgs, nxJson);
+    return {
+        ioSnapshotOutcome: await (0, store_1.loadIoSnapshotsForRun)(nxJson, runnerOptions),
+        selectivelyHashTsConfig: runnerOptions?.selectivelyHashTsConfig ?? false,
+    };
+}
 function getRunner(nxArgs, nxJson) {
     let runner = nxArgs.runner;
     runner = runner ?? 'default';

package/dist/src/tasks-runner/task-io-service.d.ts

@@ -1,3 +1,4 @@
+import type { Task } from '../config/task-graph';
 /**
  * Maps taskId -> PID. Note that this only Returns
  * the PID that the main task process is running under,
@@ -89,8 +90,15 @@ export declare function getTaskIOService(): TaskIOService;
 /**
  * Register a task process start with both IO and metrics services.
  * This is the standard way to notify the system that a task process has started.
- * Both services need to be notified together - TaskIOService for external subscribers
- * and ProcessMetricsService for native resource monitoring.
+ *
+ * A target on `ultracache: { mode: 'off' }` reports no PID, which suppresses IO
+ * tracing and therefore its report. Every other mode records — they differ in
+ * what is done with the recording, not in whether it is taken. Metrics are
+ * registered either way: the opt-out covers reporting, not the process
+ * management that cleanup and orphan reaping depend on.
+ *
+ * Narrower than a whole `Task` because `run-commands` can synthesize an id for
+ * a task that is not in any graph.
  */
-export declare function registerTaskProcessStart(taskId: string, pid: number): void;
+export declare function registerTaskProcessStart(task: Pick<Task, 'id' | 'ultracache'>, pid: number): void;
 export {};

package/dist/src/tasks-runner/task-io-service.js

@@ -113,10 +113,19 @@ function getTaskIOService() {
 /**
  * Register a task process start with both IO and metrics services.
  * This is the standard way to notify the system that a task process has started.
- * Both services need to be notified together - TaskIOService for external subscribers
- * and ProcessMetricsService for native resource monitoring.
+ *
+ * A target on `ultracache: { mode: 'off' }` reports no PID, which suppresses IO
+ * tracing and therefore its report. Every other mode records — they differ in
+ * what is done with the recording, not in whether it is taken. Metrics are
+ * registered either way: the opt-out covers reporting, not the process
+ * management that cleanup and orphan reaping depend on.
+ *
+ * Narrower than a whole `Task` because `run-commands` can synthesize an id for
+ * a task that is not in any graph.
  */
-function registerTaskProcessStart(taskId, pid) {
-    getTaskIOService().notifyPidUpdate({ taskId, pid });
-    (0, process_metrics_service_1.getProcessMetricsService)().registerTaskProcess(taskId, pid);
+function registerTaskProcessStart(task, pid) {
+    if (task.ultracache?.mode !== 'off') {
+        getTaskIOService().notifyPidUpdate({ taskId: task.id, pid });
+    }
+    (0, process_metrics_service_1.getProcessMetricsService)().registerTaskProcess(task.id, pid);
 }

package/dist/src/tasks-runner/task-orchestrator.js

@@ -1019,7 +1019,7 @@ class TaskOrchestrator {
                 };
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
-                }, task.id);
+                }, task);
                 this.runningRunCommandsTasks.set(task.id, runningTask);
                 runningTask.onExit(() => {
                     this.runningRunCommandsTasks.delete(task.id);

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

@@ -49,6 +49,11 @@ export declare function getExecutorForTask(task: Task, projects: Record<string,
     isNxExecutor: boolean;
 };
 export declare function getCustomHasher(task: Task, projects: Record<string, ProjectConfiguration>): CustomHasher | null;
+/**
+ * `taskGraph` pruned to `required`, which must already hold its dependencies.
+ * Unknown ids are ignored: a sync generator can remove a task after selection.
+ */
+export declare function pruneToSelectedTasks(taskGraph: TaskGraph, required: Iterable<string>): TaskGraph;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;

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

@@ -17,6 +17,7 @@ exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
+exports.pruneToSelectedTasks = pruneToSelectedTasks;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
@@ -344,6 +345,14 @@ function getCustomHasher(task, projects) {
     const factory = getExecutorForTask(task, projects).hasherFactory;
     return factory ? factory() : null;
 }
+/**
+ * `taskGraph` pruned to `required`, which must already hold its dependencies.
+ * Unknown ids are ignored: a sync generator can remove a task after selection.
+ */
+function pruneToSelectedTasks(taskGraph, required) {
+    const keep = new Set(required);
+    return removeTasksFromTaskGraph(taskGraph, Object.keys(taskGraph.tasks).filter((id) => !keep.has(id)));
+}
 function removeTasksFromTaskGraph(graph, ids) {
     const newGraph = removeIdsFromTaskGraph(graph, ids, graph.tasks);
     return {

package/dist/src/utils/db-connection.d.ts

@@ -1,4 +1,5 @@
 import { ExternalObject } from '../native';
+export declare function sharedWorkspaceDataDirectory(root: string): string;
 export declare function getDbConnection(opts?: {
     directory?: string;
     dbName?: string;

package/dist/src/utils/db-connection.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedWorkspaceDataDirectory = sharedWorkspaceDataDirectory;
 exports.getDbConnection = getDbConnection;
 exports.getLocalDbConnection = getLocalDbConnection;
 const native_1 = require("../native");

package/dist/src/utils/json-diff.d.ts

@@ -13,6 +13,8 @@ export interface JsonChange extends Change {
     };
 }
 export declare function isJsonChange(change: Change): change is JsonChange;
+/**
+ * The changes from `lhs` to `rhs`: every path whose value was deleted or
+ * modified, containers included, then every added path.
+ */
 export declare function jsonDiff(lhs: any, rhs: any): JsonChange[];
-export declare function walkJsonTree(json: any, currPath: string[], visitor: (path: string[], value: any) => boolean): void;
-export declare function deepEquals(a: any, b: any): boolean;

package/dist/src/utils/json-diff.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonDiffType = void 0;
 exports.isJsonChange = isJsonChange;
 exports.jsonDiff = jsonDiff;
-exports.walkJsonTree = walkJsonTree;
-exports.deepEquals = deepEquals;
+const native_1 = require("../native");
 var JsonDiffType;
 (function (JsonDiffType) {
     JsonDiffType["Deleted"] = "JsonPropertyDeleted";
@@ -16,97 +15,10 @@ function isJsonChange(change) {
         change.type === JsonDiffType.Deleted ||
         change.type === JsonDiffType.Modified);
 }
+/**
+ * The changes from `lhs` to `rhs`: every path whose value was deleted or
+ * modified, containers included, then every added path.
+ */
 function jsonDiff(lhs, rhs) {
-    const result = [];
-    const seenInLhs = new Set();
-    walkJsonTree(lhs, [], (path, lhsValue) => {
-        seenInLhs.add(hashArray(path));
-        const rhsValue = getJsonValue(path, rhs);
-        if (rhsValue === undefined) {
-            result.push({
-                type: JsonDiffType.Deleted,
-                path,
-                value: {
-                    lhs: lhsValue,
-                    rhs: undefined,
-                },
-            });
-        }
-        else if (!deepEquals(lhsValue, rhsValue)) {
-            result.push({
-                type: JsonDiffType.Modified,
-                path,
-                value: {
-                    lhs: lhsValue,
-                    rhs: rhsValue,
-                },
-            });
-        }
-        return typeof lhsValue === 'object' || Array.isArray(lhsValue);
-    });
-    walkJsonTree(rhs, [], (path, rhsValue) => {
-        const addedInRhs = !seenInLhs.has(hashArray(path));
-        if (addedInRhs) {
-            result.push({
-                type: JsonDiffType.Added,
-                path,
-                value: {
-                    lhs: undefined,
-                    rhs: rhsValue,
-                },
-            });
-        }
-        return typeof rhsValue === 'object' || Array.isArray(rhsValue);
-    });
-    return result;
-}
-// Depth-first walk down JSON tree.
-function walkJsonTree(json, currPath, visitor) {
-    if (!json || typeof json !== 'object') {
-        return;
-    }
-    Object.keys(json).forEach((key) => {
-        const path = currPath.concat([key]);
-        const shouldContinue = visitor(path, json[key]);
-        if (shouldContinue) {
-            walkJsonTree(json[key], path, visitor);
-        }
-    });
-}
-function hashArray(ary) {
-    return JSON.stringify(ary);
-}
-function getJsonValue(path, json) {
-    let curr = json;
-    for (const k of path) {
-        curr = curr[k];
-        if (curr === undefined) {
-            break;
-        }
-    }
-    return curr;
-}
-function deepEquals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    // Values do not need to be checked for deep equality and the above is false
-    if (
-    // Values are different types
-    typeof a !== typeof b ||
-        // Values are the same type but not an object or array
-        (typeof a !== 'object' && !Array.isArray(a)) ||
-        // Objects are the same type, objects or arrays, but do not have the same number of keys
-        Object.keys(a).length !== Object.keys(b).length) {
-        return false;
-    }
-    // Values need to be checked for deep equality
-    return Object.entries(a).reduce((equal, [key, aValue]) => {
-        // Skip other keys if it is already not equal.
-        if (!equal) {
-            return equal;
-        }
-        // Traverse the object
-        return deepEquals(aValue, b[key]);
-    }, true);
+    return ((0, native_1.diffJson)(JSON.stringify(lhs ?? null), JSON.stringify(rhs ?? null)) ?? []);
 }

package/dist/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,6 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 export declare function isNxCloudDisabled(nxJson: NxJsonConfiguration): boolean;
 export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
+/** Whether nx.json connects the workspace to Nx Cloud, ignoring the env. */
+export declare function isNxCloudConfigured(nxJson: NxJsonConfiguration): boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;

package/dist/src/utils/nx-cloud-utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNxCloudDisabled = isNxCloudDisabled;
 exports.isNxCloudUsed = isNxCloudUsed;
+exports.isNxCloudConfigured = isNxCloudConfigured;
 exports.getNxCloudUrl = getNxCloudUrl;
 function isNxCloudDisabled(nxJson) {
     return process.env.NX_NO_CLOUD === 'true' || nxJson.neverConnectToCloud;
@@ -12,7 +13,11 @@ function isNxCloudUsed(nxJson) {
     }
     return (!!process.env.NX_CLOUD_AUTH_TOKEN ||
         !!process.env.NX_CLOUD_ACCESS_TOKEN ||
-        !!nxJson.nxCloudAccessToken ||
+        isNxCloudConfigured(nxJson));
+}
+/** Whether nx.json connects the workspace to Nx Cloud, ignoring the env. */
+function isNxCloudConfigured(nxJson) {
+    return (!!nxJson.nxCloudAccessToken ||
         !!nxJson.nxCloudId ||
         !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
 }

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

@@ -1,6 +1,8 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import type { ProjectConfiguration } from '../config/workspace-json-project-json';
 export declare function projectHasTarget(project: ProjectGraphProjectNode, target: string): boolean;
+/** The projects that define at least one of `targets`. */
+export declare function runnableForTarget(projects: Record<string, ProjectGraphProjectNode>, targets: string[]): Set<string>;
 export declare function projectHasTargetAndConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string): any;
 export declare function getSourceDirOfDependentProjects(projectName: string, projectGraph?: ProjectGraph): [
     projectDirs: string[],

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectHasTarget = projectHasTarget;
+exports.runnableForTarget = runnableForTarget;
 exports.projectHasTargetAndConfiguration = projectHasTargetAndConfiguration;
 exports.getSourceDirOfDependentProjects = getSourceDirOfDependentProjects;
 exports.findAllProjectNodeDependencies = findAllProjectNodeDependencies;
@@ -13,6 +14,17 @@ function projectHasTarget(project, target) {
         project.data.targets &&
         project.data.targets[target]);
 }
+/** The projects that define at least one of `targets`. */
+function runnableForTarget(projects, targets) {
+    const runnable = new Set();
+    for (const projectName in projects) {
+        const project = projects[projectName];
+        if (targets.some((target) => projectHasTarget(project, target))) {
+            runnable.add(projectName);
+        }
+    }
+    return runnable;
+}
 function projectHasTargetAndConfiguration(project, target, configuration) {
     return (projectHasTarget(project, target) &&
         project.data.targets[target].configurations &&