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

package/dist/src/core/graph/runtime.js

@@ -1 +1 @@
-(()=>{"use strict";var e,r={},t={};function n(e){var o=t[e];if(void 0!==o)return o.exports;var i=t[e]={exports:{}};return r[e](i,i.exports,n),i.exports}n.m=r,e=[],n.O=(r,t,o,i)=>{if(!t){var a=1/0;for(c=0;c<e.length;c++){for(var[t,o,i]=e[c],l=!0,u=0;u<t.length;u++)(!1&i||a>=i)&&Object.keys(n.O).every(e=>n.O[e](t[u]))?t.splice(u--,1):(l=!1,i<a&&(a=i));if(l){e.splice(c--,1);var f=o();void 0!==f&&(r=f)}}return r}i=i||0;for(var c=e.length;c>0&&e[c-1][2]>i;c--)e[c]=e[c-1];e[c]=[t,o,i]},n.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return n.d(r,{a:r}),r},n.d=(e,r)=>{for(var t in r)n.o(r,t)&&!n.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},n.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),n.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},(()=>{var e={121:0};n.O.j=r=>0===e[r];var r=(r,t)=>{var o,i,[a,l,u]=t,f=0;if(a.some(r=>0!==e[r])){for(o in l)n.o(l,o)&&(n.m[o]=l[o]);if(u)var c=u(n)}for(r&&r(t);f<a.length;f++)i=a[f],n.o(e,i)&&e[i]&&e[i][0](),e[i]=0;return n.O(c)},t=self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[];t.forEach(r.bind(null,0)),t.push=r.bind(null,t.push.bind(t))})()})();
+(()=>{"use strict";var e={};const r={};function t(n){const o=r[n];if(void 0!==o)return o.exports;const i=r[n]={exports:{}};return e[n](i,i.exports,t),i.exports}t.m=e,(()=>{const e=[];t.O=(r,n,o,i)=>{if(n){i=i||0;for(var l=e.length;l>0&&e[l-1][2]>i;l--)e[l]=e[l-1];return void(e[l]=[n,o,i])}let a=1/0;for(l=0;l<e.length;l++){let[n,o,i]=e[l],u=!0;for(var c=0;c<n.length;c++)(!1&i||a>=i)&&Object.keys(t.O).every(e=>t.O[e](n[c]))?n.splice(c--,1):(u=!1,i<a&&(a=i));if(u){e.splice(l--,1);const t=o();void 0!==t&&(r=t)}}return r}})(),t.n=e=>{const r=e&&e.__esModule?()=>e.default:()=>e;return t.d(r,{a:r}),r},t.d=(e,r)=>{if(Array.isArray(r))for(var n=0;n<r.length;){var o=r[n++],i=r[n++];t.o(e,o)?0===i&&n++:0===i?Object.defineProperty(e,o,{enumerable:!0,value:r[n++]}):Object.defineProperty(e,o,{enumerable:!0,get:i})}else for(var o in r)t.o(r,o)&&!t.o(e,o)&&Object.defineProperty(e,o,{enumerable:!0,get:r[o]})},t.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),t.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),t.r=e=>{Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},t.dn=e=>{var r=Object.getOwnPropertyDescriptor(e,"name");(!r||!r.writable&&r.configurable)&&Object.defineProperty(e,"name",{value:"default",configurable:!0})},(()=>{const e={121:0};t.O.j=r=>0===e[r];const r=(r,n)=>{let[o,i,l]=n;var a,c,u=0;if(o.some(r=>0!==e[r])){for(a in i)t.o(i,a)&&(t.m[a]=i[a]);if(l)var f=l(t)}for(r&&r(n);u<o.length;u++)c=o[u],t.o(e,c)&&e[c]&&e[c][0](),e[c]=0;return t.O(f)},n=self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[];n.forEach(r.bind(null,0)),n.push=r.bind(null,n.push.bind(n))})()})();

package/dist/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[]).push([[869],{1296(){}},e=>{var n;n=1296,e(e.s=n)}]);
+"use strict";(self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[]).push([[869],{4091(){}},e=>{var n;n=4091,e(e.s=n)}]);

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

@@ -1,6 +1,7 @@
 import { ChildProcess } from 'child_process';
 import { FileData, ProjectGraph } from '../../config/project-graph';
 import { Task, TaskGraph } from '../../config/task-graph';
+import type { IoSnapshotVersion } from '../message-types/io-snapshot-version';
 import { Hash } from '../../hasher/task-hasher';
 import { NxWorkspaceFiles, TaskRun, TaskTarget } from '../../native';
 import { PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
@@ -8,6 +9,8 @@ import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 import type { FlushSyncGeneratorChangesResult, SyncGeneratorRunResult } from '../../utils/sync-generators';
 import { type ConfigureAiAgentsStatusResponse } from '../message-types/configure-ai-agents';
+import { type SelectAffectedTasksResponse } from '../message-types/select-affected-tasks';
+import type { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
 import type { NxPluginCapabilities } from '../../project-graph/plugins/nx-plugin-capabilities';
 import { type NxConsoleStatusResponse, type SetNxConsolePreferenceAndInstallResponse } from '../message-types/nx-console';
 /** A refused connect: the errno, and the path it was made against. */
@@ -58,8 +61,8 @@ export declare class DaemonClient {
         sourceMaps: ConfigurationSourceMaps;
     }>;
     getAllFileData(): Promise<FileData[]>;
-    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
-    hashTasksUpfront(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
+    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean, ioSnapshots?: IoSnapshotVersion): Promise<Hash[]>;
+    hashTasksUpfront(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean, ioSnapshots?: IoSnapshotVersion): Promise<Record<string, Hash>>;
     registerFileWatcher(config: {
         watchProjects: string[] | 'all';
         includeGlobalWorkspaceFiles?: boolean;
@@ -102,6 +105,8 @@ export declare class DaemonClient {
         taskGenerators: string[];
     }>;
     getPluginCapabilities(): Promise<NxPluginCapabilities[]>;
+    /** Selection runs where hashing does, so the plans it builds are reused. */
+    selectAffectedTasks(request: AffectedTasksRequest): Promise<SelectAffectedTasksResponse>;
     updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     runPreTasksExecution(context: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
     runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;

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

@@ -36,6 +36,7 @@ const get_files_in_directory_1 = require("../message-types/get-files-in-director
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
 const get_plugin_capabilities_1 = require("../message-types/get-plugin-capabilities");
+const select_affected_tasks_1 = require("../message-types/select-affected-tasks");
 const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
 const hash_glob_1 = require("../message-types/hash-glob");
 const nx_console_1 = require("../message-types/nx-console");
@@ -210,7 +211,7 @@ class DaemonClient {
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
-    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
@@ -218,9 +219,12 @@ class DaemonClient {
             ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
+            // An External cannot cross the socket: the version names the stored set
+            // to hash from. Absent means native hashing.
+            ioSnapshots,
         });
     }
-    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS_UPFRONT',
             runnerOptions,
@@ -228,6 +232,7 @@ class DaemonClient {
             ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
+            ioSnapshots,
         });
     }
     async registerFileWatcher(config, callback) {
@@ -725,6 +730,14 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    /** Selection runs where hashing does, so the plans it builds are reused. */
+    selectAffectedTasks(request) {
+        const message = {
+            type: select_affected_tasks_1.SELECT_AFFECTED_TASKS,
+            request,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
         const message = {
             type: update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT,

package/dist/src/daemon/message-types/io-snapshot-version.d.ts

@@ -0,0 +1,5 @@
+/** One stored version of a snapshot set: what crosses the socket in place of the handle. */
+export interface IoSnapshotVersion {
+    commit: string;
+    fetchedAt: number;
+}

package/dist/src/daemon/message-types/io-snapshot-version.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/daemon/message-types/select-affected-tasks.d.ts

@@ -0,0 +1,18 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import type { TaskGraph } from '../../config/task-graph';
+import type { TaskSelection } from '../../tasks-runner/run-command';
+import type { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
+export declare const SELECT_AFFECTED_TASKS: 'SELECT_AFFECTED_TASKS';
+export type HandleSelectAffectedTasksMessage = {
+    type: typeof SELECT_AFFECTED_TASKS;
+    request: AffectedTasksRequest;
+};
+export type SelectAffectedTasksResponse = {
+    /** The graph selection ran against, for the command to run with. */
+    projectGraph: ProjectGraph;
+    affectedTaskIds: string[];
+    taskGraph: TaskGraph;
+    /** Without a planning context: the plans stay in the daemon. */
+    taskSelection: TaskSelection;
+};
+export declare function isHandleSelectAffectedTasksMessage(message: unknown): message is HandleSelectAffectedTasksMessage;

package/dist/src/daemon/message-types/select-affected-tasks.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECT_AFFECTED_TASKS = void 0;
+exports.isHandleSelectAffectedTasksMessage = isHandleSelectAffectedTasksMessage;
+exports.SELECT_AFFECTED_TASKS = 'SELECT_AFFECTED_TASKS';
+function isHandleSelectAffectedTasksMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.SELECT_AFFECTED_TASKS);
+}

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

@@ -1,4 +1,5 @@
 import { Task, TaskGraph } from '../../config/task-graph';
+import type { IoSnapshotVersion } from '../message-types/io-snapshot-version';
 interface HashTasksPayload {
     runnerOptions: any;
     tasks: Task[];
@@ -6,6 +7,7 @@ interface HashTasksPayload {
     perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
     cwd: string;
     collectInputs?: boolean;
+    ioSnapshots?: IoSnapshotVersion;
 }
 export declare function handleHashTasks(payload: HashTasksPayload): Promise<{
     response: import("../../hasher/task-hasher").Hash[];

package/dist/src/daemon/server/handle-hash-tasks.js

@@ -5,6 +5,8 @@ exports.handleHashTasksUpfront = handleHashTasksUpfront;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
+const io_snapshots_state_1 = require("./io-snapshots-state");
+const planning_context_1 = require("./planning-context");
 /**
  * We use this not to recreated hasher for every hash operation
  * TaskHasher has a cache inside, so keeping it around results in faster performance
@@ -19,13 +21,13 @@ async function getHasher(runnerOptions) {
     const nxJson = (0, configuration_1.readNxJson)();
     if (projectGraph !== storedProjectGraph) {
         storedProjectGraph = projectGraph;
-        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
+        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions, (0, planning_context_1.planningContextFor)(projectGraph, nxJson));
     }
     return storedHasher;
 }
 async function handleHashTasks(payload) {
     const hasher = await getHasher(payload.runnerOptions);
-    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, io_snapshots_state_1.getIoSnapshotsForVersion)(payload.ioSnapshots));
     return {
         response,
         description: 'handleHashTasks',
@@ -33,7 +35,7 @@ async function handleHashTasks(payload) {
 }
 async function handleHashTasksUpfront(payload) {
     const hasher = await getHasher(payload.runnerOptions);
-    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, io_snapshots_state_1.getIoSnapshotsForVersion)(payload.ioSnapshots));
     return {
         response,
         description: 'handleHashTasksUpfront',

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSelectAffectedTasks = handleSelectAffectedTasks;
+const configuration_1 = require("../../config/configuration");
+const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
+const io_snapshots_state_1 = require("./io-snapshots-state");
+const planning_context_1 = require("./planning-context");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleSelectAffectedTasks(request) {
+    const { error, projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    if (error) {
+        throw error;
+    }
+    const nxJson = (0, configuration_1.readNxJson)();
+    const selection = await (0, affected_tasks_1.selectAffectedTasks)(projectGraph, nxJson, (0, planning_context_1.planningContextFor)(projectGraph, nxJson), request, { ioSnapshots: (0, io_snapshots_state_1.getIoSnapshotsForVersion)(request.ioSnapshots) });
+    const response = {
+        projectGraph,
+        affectedTaskIds: [...selection.affectedTaskIds],
+        taskGraph: selection.taskGraph,
+        taskSelection: selection.taskSelection,
+    };
+    return { response, description: 'handleSelectAffectedTasks' };
+}

package/dist/src/daemon/server/io-snapshots-state.d.ts

@@ -0,0 +1,7 @@
+import type { IoSnapshots } from '../../native';
+import type { IoSnapshotVersion } from '../message-types/io-snapshot-version';
+/**
+ * Exactly the version the client hashes from, never a newer import for the
+ * same commit. `undefined` when it is not stored, e.g. after `nx reset`.
+ */
+export declare function getIoSnapshotsForVersion(version: IoSnapshotVersion | undefined): IoSnapshots | undefined;

package/dist/src/daemon/server/io-snapshots-state.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIoSnapshotsForVersion = getIoSnapshotsForVersion;
+const store_1 = require("../../io-snapshots/store");
+// One handle at a time: entries read for a request serve the next one while
+// the version holds, and another version replaces it, so nothing accumulates
+// over a long-lived daemon.
+let remembered;
+/**
+ * Exactly the version the client hashes from, never a newer import for the
+ * same commit. `undefined` when it is not stored, e.g. after `nx reset`.
+ */
+function getIoSnapshotsForVersion(version) {
+    if (!version) {
+        return undefined;
+    }
+    if (remembered?.commit === version.commit &&
+        remembered.resolution.fetchedAt === version.fetchedAt) {
+        return remembered;
+    }
+    const stored = readStored(version);
+    if (stored) {
+        remembered = stored;
+    }
+    return stored;
+}
+function readStored({ commit, fetchedAt, }) {
+    try {
+        return (0, store_1.getIoSnapshotStore)().getVersion(commit, fetchedAt) ?? undefined;
+    }
+    catch {
+        // An unusable database hashes natively rather than failing the request.
+        return undefined;
+    }
+}

package/dist/src/daemon/server/planning-context.d.ts

@@ -0,0 +1,8 @@
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { ProjectGraph } from '../../config/project-graph';
+import { TaskPlanningContext } from '../../hasher/task-planning-context';
+/**
+ * One planner per daemon project graph, shared by affected selection and task
+ * hashing, so hashing reuses the plans selection made.
+ */
+export declare function planningContextFor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): TaskPlanningContext;

package/dist/src/daemon/server/planning-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planningContextFor = planningContextFor;
+const task_planning_context_1 = require("../../hasher/task-planning-context");
+let stored = null;
+/**
+ * One planner per daemon project graph, shared by affected selection and task
+ * hashing, so hashing reuses the plans selection made.
+ */
+function planningContextFor(projectGraph, nxJson) {
+    if (stored?.projectGraph !== projectGraph) {
+        stored = {
+            projectGraph,
+            context: (0, task_planning_context_1.createTaskPlanningContext)(projectGraph, nxJson),
+        };
+    }
+    return stored.context;
+}

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

@@ -6,5 +6,6 @@ export type HandlerResult = {
     response?: string | object | boolean;
 };
 export declare const openSockets: Set<Socket>;
+export declare function handleMessage(socket: Socket, data: Buffer): Promise<void>;
 export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>, mode: 'json' | 'v8'): Promise<void>;
 export declare function startServer(): Promise<Server>;

package/dist/src/daemon/server/server.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.openSockets = void 0;
+exports.handleMessage = handleMessage;
 exports.handleResult = handleResult;
 exports.startServer = startServer;
 const fs_1 = require("fs");
@@ -28,6 +29,7 @@ const get_files_in_directory_1 = require("../message-types/get-files-in-director
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
 const get_plugin_capabilities_1 = require("../message-types/get-plugin-capabilities");
+const select_affected_tasks_1 = require("../message-types/select-affected-tasks");
 const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
 const glob_1 = require("../message-types/glob");
 const hash_glob_1 = require("../message-types/hash-glob");
@@ -47,6 +49,7 @@ const handle_client_env_1 = require("./handle-client-env");
 const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
 const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
 const handle_get_plugin_capabilities_1 = require("./handle-get-plugin-capabilities");
+const handle_select_affected_tasks_1 = require("./handle-select-affected-tasks");
 const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
 const handle_glob_1 = require("./handle-glob");
 const handle_hash_glob_1 = require("./handle-hash-glob");
@@ -214,6 +217,9 @@ async function handleMessage(socket, data) {
     else if ((0, get_plugin_capabilities_1.isHandleGetPluginCapabilitiesMessage)(payload)) {
         await handleResult(socket, get_plugin_capabilities_1.GET_PLUGIN_CAPABILITIES, () => (0, handle_get_plugin_capabilities_1.handleGetPluginCapabilities)(), mode);
     }
+    else if ((0, select_affected_tasks_1.isHandleSelectAffectedTasksMessage)(payload)) {
+        await handleResult(socket, select_affected_tasks_1.SELECT_AFFECTED_TASKS, () => (0, handle_select_affected_tasks_1.handleSelectAffectedTasks)(payload.request), mode);
+    }
     else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
         await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles), mode);
     }

package/dist/src/executors/run-commands/run-commands.impl.d.ts

@@ -1,4 +1,5 @@
 import { ExecutorContext } from '../../config/misc-interfaces';
+import type { Task } from '../../config/task-graph';
 import { NoopChildProcess } from '../../tasks-runner/running-tasks/noop-child-process';
 import { ParallelRunningTasks, SeriallyRunningTasks } from './running-tasks';
 export declare const LARGE_BUFFER: number;
@@ -55,5 +56,5 @@ export default function (options: RunCommandsOptions, context: ExecutorContext):
     success: boolean;
     terminalOutput: string;
 }>;
-export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext, taskId?: string): Promise<NoopChildProcess | ParallelRunningTasks | import("../../tasks-runner/pseudo-terminal").PseudoTtyProcess | SeriallyRunningTasks>;
+export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext, task?: Pick<Task, 'id' | 'ultracache'>): Promise<NoopChildProcess | ParallelRunningTasks | import("../../tasks-runner/pseudo-terminal").PseudoTtyProcess | SeriallyRunningTasks>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

package/dist/src/executors/run-commands/run-commands.impl.js

@@ -40,7 +40,7 @@ async function default_1(options, context) {
         success: results.code === 0,
     };
 }
-async function runCommands(options, context, taskId) {
+async function runCommands(options, context, task) {
     const normalized = normalizeOptions(options);
     if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
@@ -62,13 +62,27 @@ async function runCommands(options, context, taskId) {
         normalized.usePty;
     const tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
     try {
-        const resolvedTaskId = taskId ??
+        // The orchestrator's in-process path passes the task with a stub context,
+        // so prefer it. `runExecutor` can name a target the task graph does not
+        // hold, hence the project lookup; `convert-nx-executor` has neither graph,
+        // and only then is the config unknowable, which counts as tracked.
+        const resolvedTaskId = task?.id ??
             (0, utils_1.createTaskId)(context.projectName, context.targetName, context.configurationName);
+        const resolvedTask = task ??
+            context.taskGraph?.tasks?.[resolvedTaskId] ?? {
+            id: resolvedTaskId,
+            // Both graphs are typed as present, but `convert-nx-executor` passes
+            // null for each.
+            ultracache: context.projectName && context.targetName
+                ? context.projectGraph?.nodes?.[context.projectName]?.data
+                    .targets?.[context.targetName]?.ultracache
+                : undefined,
+        };
         const runningTask = isSingleCommandAndCanUsePseudoTerminal
-            ? await (0, running_tasks_1.runSingleCommandWithPseudoTerminal)(normalized, context, resolvedTaskId)
+            ? await (0, running_tasks_1.runSingleCommandWithPseudoTerminal)(normalized, context, resolvedTask)
             : options.parallel
-                ? new running_tasks_1.ParallelRunningTasks(normalized, context, resolvedTaskId)
-                : new running_tasks_1.SeriallyRunningTasks(normalized, context, tuiEnabled, resolvedTaskId);
+                ? new running_tasks_1.ParallelRunningTasks(normalized, context, resolvedTask)
+                : new running_tasks_1.SeriallyRunningTasks(normalized, context, tuiEnabled, resolvedTask);
         return runningTask;
     }
     catch (e) {

package/dist/src/executors/run-commands/running-tasks.d.ts

@@ -2,6 +2,7 @@ import { Serializable } from 'child_process';
 import { ExecutorContext } from '../../config/misc-interfaces';
 import { PseudoTtyProcess } from '../../tasks-runner/pseudo-terminal';
 import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
+import type { Task } from '../../config/task-graph';
 import { NormalizedRunCommandsOptions } from './run-commands.impl';
 export declare class ParallelRunningTasks implements RunningTask {
     private readonly childProcesses;
@@ -12,7 +13,7 @@ export declare class ParallelRunningTasks implements RunningTask {
     private exited;
     private exitCode;
     private exitTerminalOutput;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, taskId: string);
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, task: Pick<Task, 'id' | 'ultracache'>);
     getResults(): Promise<{
         code: number;
         terminalOutput: string;
@@ -27,7 +28,7 @@ export declare class ParallelRunningTasks implements RunningTask {
 }
 export declare class SeriallyRunningTasks implements RunningTask {
     private readonly tuiEnabled;
-    private readonly taskId;
+    private readonly task;
     private terminalOutputChunks;
     private currentProcess;
     private exitCallbacks;
@@ -36,7 +37,7 @@ export declare class SeriallyRunningTasks implements RunningTask {
     private outputCallbacks;
     private exited;
     private exitTerminalOutput;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean, taskId: string);
+    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, tuiEnabled: boolean, task: Pick<Task, 'id' | 'ultracache'>);
     private emitExit;
     getResults(): Promise<{
         code: number;
@@ -49,4 +50,4 @@ export declare class SeriallyRunningTasks implements RunningTask {
     private run;
     private createProcess;
 }
-export declare function runSingleCommandWithPseudoTerminal(normalized: NormalizedRunCommandsOptions, context: ExecutorContext, taskId: string): Promise<PseudoTtyProcess>;
+export declare function runSingleCommandWithPseudoTerminal(normalized: NormalizedRunCommandsOptions, context: ExecutorContext, task: Pick<Task, 'id' | 'ultracache'>): Promise<PseudoTtyProcess>;

package/dist/src/executors/run-commands/running-tasks.js

@@ -39,14 +39,14 @@ function commandExitedNonZeroWarning(command) {
     return `Warning: command "${command}" exited with non-zero status code`;
 }
 class ParallelRunningTasks {
-    constructor(options, context, taskId) {
+    constructor(options, context, task) {
         this.exitCallbacks = [];
         this.outputCallbacks = [];
         // Memoized exit so late getResults()/onExit() callers don't hang.
         this.exited = false;
         this.exitCode = 0;
         this.exitTerminalOutput = '';
-        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile, taskId));
+        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile, task));
         this.readyWhenStatus = options.readyWhenStatus;
         this.streamOutput = options.streamOutput;
         this.run();
@@ -156,9 +156,9 @@ class ParallelRunningTasks {
 }
 exports.ParallelRunningTasks = ParallelRunningTasks;
 class SeriallyRunningTasks {
-    constructor(options, context, tuiEnabled, taskId) {
+    constructor(options, context, tuiEnabled, task) {
         this.tuiEnabled = tuiEnabled;
-        this.taskId = taskId;
+        this.task = task;
         this.terminalOutputChunks = [];
         this.currentProcess = null;
         this.exitCallbacks = [];
@@ -225,7 +225,7 @@ class SeriallyRunningTasks {
     }
     async run(options, context) {
         for (const c of options.commands) {
-            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, this.taskId, options.usePty, options.streamOutput, options.tty, options.envFile);
+            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, this.task, options.usePty, options.streamOutput, options.tty, options.envFile);
             this.currentProcess = childProcess;
             childProcess.onOutput((output) => {
                 for (const cb of this.outputCallbacks) {
@@ -244,7 +244,7 @@ class SeriallyRunningTasks {
             }
         }
     }
-    async createProcess(commandConfig, color, cwd, env, taskId, usePty = true, streamOutput = true, tty, envFile) {
+    async createProcess(commandConfig, color, cwd, env, task, usePty = true, streamOutput = true, tty, envFile) {
         // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
         // currently does not work properly in windows
         if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
@@ -258,11 +258,11 @@ class SeriallyRunningTasks {
             // Skip registration if we're in a forked executor - the fork wrapper already registered
             const pid = pseudoTtyProcess.getPid();
             if (pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
-                (0, task_io_service_1.registerTaskProcessStart)(taskId, pid);
+                (0, task_io_service_1.registerTaskProcessStart)(task, pid);
             }
             return pseudoTtyProcess;
         }
-        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, taskId);
+        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, task);
     }
 }
 exports.SeriallyRunningTasks = SeriallyRunningTasks;
@@ -271,10 +271,10 @@ class RunningNodeProcess {
     stream(chunk, target = process.stdout) {
         streamChunk(chunk, this.streamOutput, target);
     }
-    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile, taskId) {
+    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile, task) {
         this.readyWhenStatus = readyWhenStatus;
         this.streamOutput = streamOutput;
-        this.taskId = taskId;
+        this.task = task;
         this.terminalOutputChunks = [];
         this.exitCallbacks = [];
         this.outputCallbacks = [];
@@ -304,7 +304,7 @@ class RunningNodeProcess {
         // Register process for metrics collection
         // Skip registration if we're in a forked executor - the fork wrapper already registered
         if (this.childProcess.pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
-            (0, task_io_service_1.registerTaskProcessStart)(taskId, this.childProcess.pid);
+            (0, task_io_service_1.registerTaskProcessStart)(this.task, this.childProcess.pid);
         }
         this.addListeners(commandConfig);
     }
@@ -458,14 +458,14 @@ class RunningNodeProcess {
         }
     }
 }
-async function runSingleCommandWithPseudoTerminal(normalized, context, taskId) {
+async function runSingleCommandWithPseudoTerminal(normalized, context, task) {
     const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
     const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile);
     // Register process for metrics collection (direct run-commands execution)
     // Skip registration if we're in a forked executor - the fork wrapper already registered
     const pid = pseudoTtyProcess.getPid();
     if (pid && !process.env.NX_FORKED_TASK_EXECUTOR) {
-        (0, task_io_service_1.registerTaskProcessStart)(taskId, pid);
+        (0, task_io_service_1.registerTaskProcessStart)(task, pid);
     }
     registerProcessListener(pseudoTtyProcess, pseudoTerminal);
     return pseudoTtyProcess;

package/dist/src/hasher/create-task-hasher.d.ts

@@ -1,4 +1,11 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
+import type { IoSnapshots } from '../native';
+import type { TaskPlanningContext } from './task-planning-context';
 import { TaskHasher } from './task-hasher';
-export declare function createTaskHasher(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, runnerOptions?: any): TaskHasher;
+/**
+ * `ioSnapshots` is this run's set (see `loadIoSnapshotsForRun`); undefined
+ * hashes natively. The daemon gets its version, so it hashes from the same
+ * set even after a newer one is imported for the commit.
+ */
+export declare function createTaskHasher(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, runnerOptions?: any, ioSnapshots?: IoSnapshots, planningContext?: TaskPlanningContext): TaskHasher;

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

@@ -4,12 +4,22 @@ exports.createTaskHasher = createTaskHasher;
 const client_1 = require("../daemon/client/client");
 const build_project_graph_1 = require("../project-graph/build-project-graph");
 const task_hasher_1 = require("./task-hasher");
-function createTaskHasher(projectGraph, nxJson, runnerOptions) {
+/**
+ * `ioSnapshots` is this run's set (see `loadIoSnapshotsForRun`); undefined
+ * hashes natively. The daemon gets its version, so it hashes from the same
+ * set even after a newer one is imported for the commit.
+ */
+function createTaskHasher(projectGraph, nxJson, runnerOptions, ioSnapshots, planningContext) {
     if (client_1.daemonClient.enabled()) {
-        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
+        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions, ioSnapshots
+            ? {
+                commit: ioSnapshots.commit,
+                fetchedAt: ioSnapshots.resolution.fetchedAt,
+            }
+            : undefined);
     }
     else {
         const { rustReferences } = (0, build_project_graph_1.getFileMap)();
-        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
+        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions, planningContext, ioSnapshots);
     }
 }

package/dist/src/hasher/hash-plan-inspector.js

@@ -14,7 +14,7 @@ class HashPlanInspector {
         this.projectGraph = projectGraph;
         this.workspaceRootPath = workspaceRootPath;
         this.nxJson = nxJson ?? (0, nx_json_1.readNxJson)(this.workspaceRootPath);
-        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(this.projectGraph));
+        this.projectGraphRef = (0, transform_objects_1.transformProjectGraphForRust)(this.projectGraph);
         this.planner = new native_1.HashPlanner(this.nxJson, this.projectGraphRef);
     }
     async init() {
@@ -44,7 +44,7 @@ class HashPlanInspector {
             configuration: configuration,
             targets: [target],
         }, 'run-one', { printWarnings: false }, this.nxJson);
-        // Create task graph exactly like run-one.ts does via createTaskGraphAndRunValidations
+        // Same task graph run-one builds via `selectTasksForProjects`.
         const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, [project], nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
         // Generate task IDs for ALL tasks in the task graph (including dependencies)
         const taskIds = Object.keys(taskGraph.tasks);

package/dist/src/hasher/hash-task.d.ts

@@ -1,10 +1,10 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
-import { TaskDetails } from '../native';
+import { type IoSnapshots, TaskDetails } from '../native';
 import { TaskHasher } from './task-hasher';
 export declare function getTaskDetails(): TaskDetails | null;
-export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null): Promise<void>;
+export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null, ioSnapshots?: IoSnapshots): Promise<void>;
 export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;
 /**
  * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by