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

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

@@ -23,9 +23,14 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails, ioSnapshots) {
     performance.mark('hashMultipleTasks:start');
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    // A snapshot can make a task depend on producer outputs its declared
+    // inputs never mentioned; those hash after their producers too.
+    const deferredBySnapshot = ioSnapshots
+        ? new Set((0, native_1.getIoSnapshotDeferredTaskIds)(ioSnapshots, taskGraph))
+        : null;
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
         const customHasher = (0, utils_1.getCustomHasher)(task, projects);
@@ -37,6 +42,7 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     // a continuous server, which only planning reveals.
     const candidates = tasksWithHashers
         .filter(({ task, customHasher }) => !customHasher &&
+        !deferredBySnapshot?.has(task.id) &&
         !readsDependencyOutputs(task, taskGraph, projectGraph, nxJson))
         .map((t) => t.task);
     const perTaskEnvs = {};

package/dist/src/hasher/native-task-hasher-impl.d.ts

@@ -1,10 +1,12 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
-import { ExternalObject, FileData, HasherOptions, HashPlanner, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, IoSnapshots, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
 import type { IgnoredIndexReader } from '../native';
+import type { TaskPlanningContext } from './task-planning-context';
 import { PartialHash, TaskHasherImpl } from './task-hasher';
 export declare class NativeTaskHasherImpl implements TaskHasherImpl {
+    private readonly projectGraph;
     hasher: TaskHasher;
     planner: HashPlanner;
     projectGraphRef: ExternalObject<NativeProjectGraph>;
@@ -19,8 +21,14 @@ export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     private upfrontPlans;
     constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
         selectivelyHashTsConfig: boolean;
-    });
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
-    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
+    }, planningContext?: TaskPlanningContext);
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<PartialHash[]>;
+    /**
+     * Plans through the native planner. With a snapshot set, the tasks JS resolves as
+     * custom-hashed or opted out ride along so the planner's eligibility walk
+     * withholds their snapshots.
+     */
+    private plan;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Record<string, PartialHash>>;
 }

package/dist/src/hasher/native-task-hasher-impl.js

@@ -6,14 +6,19 @@ const transform_objects_1 = require("../native/transform-objects");
 const typescript_1 = require("../plugins/js/utils/typescript");
 const task_io_service_1 = require("../tasks-runner/task-io-service");
 const fileutils_1 = require("../utils/fileutils");
+const overrides_1 = require("../io-snapshots/overrides");
 class NativeTaskHasherImpl {
-    constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
+    constructor(workspaceRoot, nxJson, projectGraph, externals, options, planningContext) {
+        this.projectGraph = projectGraph;
         /**
          * Plans of the last up-front batch and the task graph they were built for.
          * The tasks that batch deferred hash from them later without planning again.
          */
         this.upfrontPlans = null;
-        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
+        // A shared planner was built over its ref, so the two stay paired.
+        this.projectGraphRef =
+            planningContext?.projectGraphRef ??
+                (0, transform_objects_1.transformProjectGraphForRust)(projectGraph);
         this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
         this.projectFileMapRef = externals.projectFiles;
         this.ignoredIndexRef = externals.ignoredIndex;
@@ -27,14 +32,15 @@ class NativeTaskHasherImpl {
                 delete tsconfig.compilerOptions.paths;
             }
         }
-        this.planner = new native_1.HashPlanner(nxJson, this.projectGraphRef);
+        this.planner =
+            planningContext?.planner ?? new native_1.HashPlanner(nxJson, this.projectGraphRef);
         this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options, this.ignoredIndexRef);
     }
-    async hashTask(task, taskGraph, env, cwd, collectInputs) {
-        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
+    async hashTask(task, taskGraph, env, cwd, collectInputs, ioSnapshots) {
+        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs, ioSnapshots);
         return hashes[0];
     }
-    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
         const envs = perTaskEnvs;
         const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
         const resolvedCwd = cwd ?? process.cwd();
@@ -42,20 +48,32 @@ class NativeTaskHasherImpl {
         let unplanned = tasks.map((t) => t.id);
         if (this.upfrontPlans &&
             unplanned.some((id) => this.upfrontPlans.taskIds.has(id)) &&
-            this.upfrontPlans.fingerprint === taskGraphFingerprint(taskGraph)) {
+            this.upfrontPlans.fingerprint ===
+                taskGraphFingerprint(taskGraph, ioSnapshots)) {
             Object.assign(hashes, this.hasher.hashPlansFor(this.upfrontPlans.plans, unplanned, envs, resolvedCwd, shouldCollectInputs));
             unplanned = unplanned.filter((id) => !(id in hashes));
         }
         if (unplanned.length > 0) {
-            const plans = this.planner.getPlansReference(unplanned, taskGraph);
+            const plans = this.plan(unplanned, taskGraph, ioSnapshots);
             Object.assign(hashes, this.hasher.hashPlans(plans, envs, resolvedCwd, shouldCollectInputs));
         }
         return tasks.map((t) => hashes[t.id]);
     }
-    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+    /**
+     * Plans through the native planner. With a snapshot set, the tasks JS resolves as
+     * custom-hashed or opted out ride along so the planner's eligibility walk
+     * withholds their snapshots.
+     */
+    plan(taskIds, taskGraph, ioSnapshots) {
+        if (!ioSnapshots) {
+            return this.planner.getPlansReference(taskIds, taskGraph);
+        }
+        return this.planner.getPlansReference(taskIds, taskGraph, ioSnapshots, (0, overrides_1.ioSnapshotEligibilityOptions)(this.projectGraph, taskGraph));
+    }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
+        const plans = this.plan(tasks.map((t) => t.id), taskGraph, ioSnapshots);
         this.upfrontPlans = {
-            fingerprint: taskGraphFingerprint(taskGraph),
+            fingerprint: taskGraphFingerprint(taskGraph, ioSnapshots),
             taskIds: new Set(tasks.map((t) => t.id)),
             plans,
         };
@@ -66,13 +84,18 @@ class NativeTaskHasherImpl {
 exports.NativeTaskHasherImpl = NativeTaskHasherImpl;
 /**
  * Everything the planner reads from a task graph: each task's target and
- * outputs, and the graph's edges. The project graph and nx.json are fixed for
- * the life of a hasher, so equal fingerprints mean equal plans. A run's
+ * outputs, and the graph's edges, plus the snapshot set the plans were
+ * built against. The project graph and nx.json are fixed for the life of a
+ * hasher, so equal fingerprints mean equal plans. A run's
  * results (hash, timings) are left out so hashing one task does not
  * invalidate the plans of the rest.
  */
-function taskGraphFingerprint(taskGraph) {
-    const parts = [];
+function taskGraphFingerprint(taskGraph, ioSnapshots) {
+    const parts = [
+        ioSnapshots
+            ? `${ioSnapshots.commit}@${ioSnapshots.resolution.fetchedAt}`
+            : '',
+    ];
     for (const id of Object.keys(taskGraph.tasks).sort()) {
         const task = taskGraph.tasks[id];
         parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).join(','), (taskGraph.continuousDependencies[id] ?? []).join(','));

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

@@ -2,8 +2,10 @@ import { FileData, ProjectGraph, ProjectGraphProjectNode } from '../config/proje
 import { NxJsonConfiguration } from '../config/nx-json';
 import { Task, TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
+import type { IoSnapshotVersion } from '../daemon/message-types/io-snapshot-version';
 import { InputDefinition } from '../config/workspace-json-project-json';
-import { HashInputs, NxWorkspaceFilesExternals } from '../native';
+import type { TaskPlanningContext } from './task-planning-context';
+import { HashInputs, IoSnapshots, NxWorkspaceFilesExternals } from '../native';
 export { HashInputs };
 /**
  * A data structure returned by the default hasher.
@@ -74,15 +76,16 @@ export interface TaskHasherImpl {
      * single shared env should construct `{ [task.id]: env }` for every
      * task.
      */
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
-    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
-    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<PartialHash[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<PartialHash>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Record<string, PartialHash>>;
 }
 export type Hasher = TaskHasher;
 export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly daemonClient;
     private readonly runnerOptions;
-    constructor(daemonClient: DaemonClient, runnerOptions: any);
+    private readonly ioSnapshots?;
+    constructor(daemonClient: DaemonClient, runnerOptions: any, ioSnapshots?: IoSnapshotVersion);
     hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>): Promise<Hash[]>;
     hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>): Promise<Record<string, Hash>>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
@@ -92,11 +95,16 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private readonly nxJson;
     private readonly externalRustReferences;
     private readonly options;
+    private readonly planningContext?;
+    /** This run's snapshot set; the daemon passes one per request instead. */
+    private readonly ioSnapshots?;
     private taskHasher;
-    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
-    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
-    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
+    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any, planningContext?: TaskPlanningContext, 
+    /** This run's snapshot set; the daemon passes one per request instead. */
+    ioSnapshots?: IoSnapshots);
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Hash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Record<string, Hash>>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Hash>;
     private createHashDetails;
     private hashCommand;
 }

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

@@ -44,17 +44,18 @@ function normalizePerTaskEnvs(tasks, arg) {
     return arg;
 }
 class DaemonBasedTaskHasher {
-    constructor(daemonClient, runnerOptions) {
+    constructor(daemonClient, runnerOptions, ioSnapshots) {
         this.daemonClient = daemonClient;
         this.runnerOptions = runnerOptions;
+        this.ioSnapshots = ioSnapshots;
     }
     async hashTasks(tasks, taskGraph, envOrPerTaskEnvs) {
         const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs);
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs, this.ioSnapshots);
     }
     async hashTasksUpfront(tasks, taskGraph, perTaskEnvs) {
         const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        return this.daemonClient.hashTasksUpfront(this.runnerOptions, tasks, taskGraph, perTaskEnvs, process.cwd(), collectInputs);
+        return this.daemonClient.hashTasksUpfront(this.runnerOptions, tasks, taskGraph, perTaskEnvs, process.cwd(), collectInputs, this.ioSnapshots);
     }
     async hashTask(task, taskGraph, env) {
         return (await this.hashTasks([task], taskGraph, {
@@ -64,21 +65,25 @@ class DaemonBasedTaskHasher {
 }
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
 class InProcessTaskHasher {
-    constructor(projectGraph, nxJson, externalRustReferences, options) {
+    constructor(projectGraph, nxJson, externalRustReferences, options, planningContext, 
+    /** This run's snapshot set; the daemon passes one per request instead. */
+    ioSnapshots) {
         this.projectGraph = projectGraph;
         this.nxJson = nxJson;
         this.externalRustReferences = externalRustReferences;
         this.options = options;
+        this.planningContext = planningContext;
+        this.ioSnapshots = ioSnapshots;
         this.taskHasher = new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, this.nxJson, this.projectGraph, this.externalRustReferences, {
             selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
-        });
+        }, this.planningContext);
     }
-    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs, cwd, collectInputs) {
-        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs, cwd, collectInputs, ioSnapshots) {
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs, ioSnapshots ?? this.ioSnapshots);
         return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
-    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs);
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
+        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs, ioSnapshots ?? this.ioSnapshots);
         const result = {};
         for (const task of tasks) {
             if (hashes[task.id]) {
@@ -87,8 +92,8 @@ class InProcessTaskHasher {
         }
         return result;
     }
-    async hashTask(task, taskGraph, env, cwd, collectInputs) {
-        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
+    async hashTask(task, taskGraph, env, cwd, collectInputs, ioSnapshots) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs, ioSnapshots ?? this.ioSnapshots);
         return this.createHashDetails(task, res);
     }
     createHashDetails(task, res) {

package/dist/src/hasher/task-planning-context.d.ts

@@ -0,0 +1,13 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { ExternalObject, HashPlanner, ProjectGraph as NativeProjectGraph } from '../native';
+/**
+ * The graph copied into Rust and the planner built over it, shared by selection
+ * and hashing. The planner remembers its last plans, so the run's hashing reuses
+ * what selection planned.
+ */
+export interface TaskPlanningContext {
+    projectGraphRef: ExternalObject<NativeProjectGraph>;
+    planner: HashPlanner;
+}
+export declare function createTaskPlanningContext(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): TaskPlanningContext;

package/dist/src/hasher/task-planning-context.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskPlanningContext = createTaskPlanningContext;
+const native_1 = require("../native");
+const transform_objects_1 = require("../native/transform-objects");
+function createTaskPlanningContext(projectGraph, nxJson) {
+    const projectGraphRef = (0, transform_objects_1.transformProjectGraphForRust)(projectGraph);
+    return {
+        projectGraphRef,
+        planner: new native_1.HashPlanner(nxJson, projectGraphRef),
+    };
+}

package/dist/src/io-snapshots/config.d.ts

@@ -0,0 +1,23 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export interface IoSnapshotCloudOptions {
+    accessToken?: string;
+    nxCloudId?: string;
+    url?: string;
+    cloud?: boolean;
+}
+export interface IoSnapshotEnv {
+    NX_IO_SNAPSHOTS?: string;
+    NX_CLOUD_USE_IO_SNAPSHOTS?: string;
+    NX_NO_CLOUD?: string;
+    /** Whether the run's env holds an Nx Cloud token. */
+    hasNxCloudToken?: boolean;
+}
+/**
+ * Off unless a CI run opts in with `NX_IO_SNAPSHOTS=true`, or the Nx Cloud
+ * client's `NX_CLOUD_USE_IO_SNAPSHOTS=true`, in a workspace that uses Nx Cloud,
+ * since there is nothing to fetch from otherwise. `env` defaults to this
+ * process's.
+ */
+export declare function isIoSnapshotFetchEnabled(nxJson: NxJsonConfiguration, runnerOptions?: IoSnapshotCloudOptions, env?: IoSnapshotEnv): boolean;
+/** The subset of this run's environment the decision reads. */
+export declare function ioSnapshotEnv(env?: NodeJS.ProcessEnv): IoSnapshotEnv;

package/dist/src/io-snapshots/config.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIoSnapshotFetchEnabled = isIoSnapshotFetchEnabled;
+exports.ioSnapshotEnv = ioSnapshotEnv;
+const is_ci_1 = require("../utils/is-ci");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+/**
+ * Off unless a CI run opts in with `NX_IO_SNAPSHOTS=true`, or the Nx Cloud
+ * client's `NX_CLOUD_USE_IO_SNAPSHOTS=true`, in a workspace that uses Nx Cloud,
+ * since there is nothing to fetch from otherwise. `env` defaults to this
+ * process's.
+ */
+function isIoSnapshotFetchEnabled(nxJson, runnerOptions = {}, env = ioSnapshotEnv()) {
+    if (env.NX_NO_CLOUD === 'true' ||
+        nxJson.neverConnectToCloud ||
+        runnerOptions.cloud === false ||
+        (env.NX_IO_SNAPSHOTS !== 'true' &&
+            env.NX_CLOUD_USE_IO_SNAPSHOTS !== 'true') ||
+        !(0, is_ci_1.isCI)()) {
+        return false;
+    }
+    return !!env.hasNxCloudToken || (0, nx_cloud_utils_1.isNxCloudConfigured)(nxJson);
+}
+/** The subset of this run's environment the decision reads. */
+function ioSnapshotEnv(env = process.env) {
+    return {
+        NX_IO_SNAPSHOTS: env.NX_IO_SNAPSHOTS,
+        NX_CLOUD_USE_IO_SNAPSHOTS: env.NX_CLOUD_USE_IO_SNAPSHOTS,
+        NX_NO_CLOUD: env.NX_NO_CLOUD,
+        hasNxCloudToken: !!(env.NX_CLOUD_ACCESS_TOKEN || env.NX_CLOUD_AUTH_TOKEN),
+    };
+}

package/dist/src/io-snapshots/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { IoSnapshotCloudOptions } from './config';
+/** The Nx Cloud client's `readIoSnapshots` contract, as far as nx uses it. */
+export interface ReadIoSnapshotsOptions {
+    workspaceRoot?: string;
+    nxCloudOptions?: IoSnapshotCloudOptions;
+    timeoutMs?: number;
+}
+export interface ReadIoSnapshot {
+    commit: string;
+    inputs: readonly string[];
+    outputs: readonly string[];
+}
+export interface ReadIoSnapshotsResult {
+    snapshots: Readonly<Record<string, ReadIoSnapshot>>;
+}
+/**
+ * Reads HEAD's snapshot set from Nx Cloud. Throws with a `code` saying why it
+ * could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_SNAPSHOTS`.
+ */
+export declare function fetchIoSnapshots(runnerOptions: IoSnapshotCloudOptions): Promise<ReadIoSnapshotsResult>;

package/dist/src/io-snapshots/fetch.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchIoSnapshots = fetchIoSnapshots;
+const resolution_helpers_1 = require("../nx-cloud/resolution-helpers");
+const update_manager_1 = require("../nx-cloud/update-manager");
+const workspace_root_1 = require("../utils/workspace-root");
+const READ_TIMEOUT_MS = 10_000;
+/**
+ * Reads HEAD's snapshot set from Nx Cloud. Throws with a `code` saying why it
+ * could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_SNAPSHOTS`.
+ */
+async function fetchIoSnapshots(runnerOptions) {
+    const client = await loadCloudClient(runnerOptions).catch((e) => {
+        throw codedError('NO_CLOUD_CLIENT', e instanceof Error ? e.message : String(e));
+    });
+    if (!client) {
+        throw codedError('NO_CLOUD_CLIENT', 'The Nx Cloud client could not be loaded');
+    }
+    if (typeof client.readIoSnapshots !== 'function') {
+        throw codedError('UNSUPPORTED_CLIENT', 'The installed Nx Cloud client does not expose I/O snapshots; update nx-cloud');
+    }
+    const result = await client.readIoSnapshots({
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        nxCloudOptions: runnerOptions,
+        timeoutMs: READ_TIMEOUT_MS,
+    });
+    if (!result) {
+        // The client returns `null` only for a `knownUpdatedAt` match, which nx
+        // never sends; treat it as nothing to serve rather than a broken reply.
+        throw codedError('NO_SNAPSHOTS', 'Nx Cloud returned no I/O snapshot set');
+    }
+    return result;
+}
+async function loadCloudClient(runnerOptions) {
+    const client = (await (0, update_manager_1.verifyOrUpdateNxCloudClient)(runnerOptions))
+        ?.nxCloudClient;
+    client?.configureLightClientRequire()((0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []));
+    return client;
+}
+function codedError(code, message) {
+    return Object.assign(new Error(message), { code });
+}

package/dist/src/io-snapshots/outputs.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import { type IoSnapshots } from '../native';
+/**
+ * Extends each eligible task's outputs in place to `declared ∪ observed`,
+ * declared first, as a set of exact strings. Ineligible tasks keep their
+ * declared outputs untouched. Idempotent. Runs before hashing so the task
+ * graph the hasher, the cache, and the deferral check see carries the union.
+ * A graph already extended from `snapshots` is skipped: DTE workers pass the
+ * same graph for every task they run.
+ */
+export declare function applyIoSnapshotOutputs(projectGraph: ProjectGraph, taskGraph: TaskGraph, snapshots: IoSnapshots): void;

package/dist/src/io-snapshots/outputs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyIoSnapshotOutputs = applyIoSnapshotOutputs;
+const native_1 = require("../native");
+const overrides_1 = require("./overrides");
+/** The sets already applied to each task graph object. */
+const applied = new WeakMap();
+/**
+ * Extends each eligible task's outputs in place to `declared ∪ observed`,
+ * declared first, as a set of exact strings. Ineligible tasks keep their
+ * declared outputs untouched. Idempotent. Runs before hashing so the task
+ * graph the hasher, the cache, and the deferral check see carries the union.
+ * A graph already extended from `snapshots` is skipped: DTE workers pass the
+ * same graph for every task they run.
+ */
+function applyIoSnapshotOutputs(projectGraph, taskGraph, snapshots) {
+    if (applied.get(taskGraph)?.has(snapshots)) {
+        return;
+    }
+    // Same walk as hashing, already confined to the workspace and outside
+    // node_modules/.nx/.git; ineligible tasks are absent.
+    const observed = (0, native_1.getObservedIoSnapshotOutputs)(snapshots, taskGraph, (0, overrides_1.ioSnapshotEligibilityOptions)(projectGraph, taskGraph));
+    for (const [taskId, outputs] of Object.entries(observed)) {
+        const task = taskGraph.tasks[taskId];
+        if (task) {
+            task.outputs = [...new Set([...task.outputs, ...outputs])];
+        }
+    }
+    // Marked only once applied, so a call that threw is retried.
+    const sets = applied.get(taskGraph) ?? new WeakSet();
+    sets.add(snapshots);
+    applied.set(taskGraph, sets);
+}

package/dist/src/io-snapshots/overrides.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import { type IoSnapshotEligibilityOptions, type IoSnapshotReport, type IoSnapshots } from '../native';
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+export declare function ioSnapshotEligibilityOptions(projectGraph: ProjectGraph, taskGraph: TaskGraph): IoSnapshotEligibilityOptions;
+/**
+ * Reports which tasks in `taskGraph` hash from `snapshots` and why the rest
+ * do not, with the same eligibility walk the planner uses, without building a
+ * planner (no project-graph transfer). Never fetches, never throws. Feeds
+ * the `--verbose` run summary.
+ */
+export declare function buildIoSnapshotOverrides(projectGraph: ProjectGraph, taskGraph: TaskGraph, snapshots: IoSnapshots): IoSnapshotReport;

package/dist/src/io-snapshots/overrides.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ioSnapshotEligibilityOptions = ioSnapshotEligibilityOptions;
+exports.buildIoSnapshotOverrides = buildIoSnapshotOverrides;
+const native_1 = require("../native");
+const project_graph_1 = require("../project-graph/project-graph");
+const utils_1 = require("../tasks-runner/utils");
+const customHasherMemo = new WeakMap();
+/**
+ * Tasks whose executor ships a custom hasher; they are never hashed from a
+ * snapshot. Detected here because executors are resolved in JS, by the
+ * factory's presence only — invoking it would load user modules.
+ */
+function customHasherTaskIds(projectGraph, taskGraph) {
+    const memoized = customHasherMemo.get(taskGraph);
+    if (memoized) {
+        return memoized;
+    }
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    const ids = Object.values(taskGraph.tasks)
+        .filter((task) => {
+        try {
+            return !!(0, utils_1.getExecutorForTask)(task, projects).hasherFactory;
+        }
+        catch {
+            // An unresolvable executor fails later, at execution; it is not a
+            // reason to withhold a snapshot here.
+            return false;
+        }
+    })
+        .map((task) => task.id);
+    customHasherMemo.set(taskGraph, ids);
+    return ids;
+}
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+function ioSnapshotEligibilityOptions(projectGraph, taskGraph) {
+    return {
+        customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
+    };
+}
+/**
+ * Reports which tasks in `taskGraph` hash from `snapshots` and why the rest
+ * do not, with the same eligibility walk the planner uses, without building a
+ * planner (no project-graph transfer). Never fetches, never throws. Feeds
+ * the `--verbose` run summary.
+ */
+function buildIoSnapshotOverrides(projectGraph, taskGraph, snapshots) {
+    return (0, native_1.getIoSnapshotReport)(snapshots, taskGraph, ioSnapshotEligibilityOptions(projectGraph, taskGraph));
+}

package/dist/src/io-snapshots/report.d.ts

@@ -0,0 +1,13 @@
+import type { IoSnapshotReport } from '../native';
+export interface IoSnapshotSummary {
+    /** The heading, e.g. "I/O snapshots: 12 tasks hashed from snapshot, 3 fell back". */
+    line: string;
+    /** Per-reason detail under it. */
+    bodyLines: string[];
+}
+/**
+ * Formats the once-per-run verbose summary of a run that resolved a set:
+ * `result` is what hashing used, `status` whether the set was fetched or
+ * already stored.
+ */
+export declare function formatIoSnapshotSummary(result: IoSnapshotReport, status: 'fetched' | 'cached'): IoSnapshotSummary;

package/dist/src/io-snapshots/report.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatIoSnapshotSummary = formatIoSnapshotSummary;
+/**
+ * Formats the once-per-run verbose summary of a run that resolved a set:
+ * `result` is what hashing used, `status` whether the set was fetched or
+ * already stored.
+ */
+function formatIoSnapshotSummary(result, status) {
+    const used = result.used.length;
+    // `unusable-output` is raised on used tasks, possibly several per task:
+    // count withheld tasks, not diagnostics.
+    const usedTasks = new Set(result.used);
+    const withheld = result.diagnostics.filter((d) => d.taskId != null && !usedTasks.has(d.taskId));
+    const byReason = countByReason(withheld);
+    const fellBack = new Set(withheld.map((d) => d.taskId)).size;
+    const setLevel = result.diagnostics.find((d) => d.taskId == null);
+    const withOutputs = result.tasksWithOutputs?.length ?? 0;
+    const line = setLevel
+        ? `I/O snapshots: none used (unreadable set: ${setLevel.message})`
+        : `I/O snapshots: ${plural(used, 'task')} hashed from snapshot${withOutputs ? ` (${withOutputs} with observed outputs)` : ''}, ${plural(fellBack, 'task')} fell back${fellBack ? ` (${summarizeReasons(byReason)})` : ''}`;
+    const bodyLines = [`set: ${status}`];
+    bodyLines.push(`commit ${result.resolution.requestedCommit}, ${result.resolution.tasks} tasks in set`);
+    for (const d of result.diagnostics) {
+        bodyLines.push(describeDiagnostic(d));
+    }
+    return { line, bodyLines };
+}
+function describeDiagnostic(d) {
+    switch (d.reason) {
+        case 'unreadable-set':
+            return `unreadable snapshot set: ${d.message}`;
+        case 'disabled':
+            return `${d.taskId}: ultracache.mode is off`;
+        case 'autofix-disabled':
+            return `${d.taskId}: ultracache.mode is not on`;
+        case 'custom-hasher':
+            return `${d.taskId}: uses a custom hasher`;
+        case 'missing':
+            return `${d.taskId}: no snapshot for this task`;
+        case 'invalid-glob':
+            return `${d.taskId}: snapshot glob "${d.glob}" is not a valid files glob`;
+        case 'escapes-workspace':
+            return `${d.taskId}: snapshot glob "${d.glob}" escapes the workspace`;
+        case 'unusable-output':
+            return `${d.taskId}: observed write "${d.glob}" is not usable as an output, so it is not cached`;
+        default:
+            return `${d.taskId ? `${d.taskId}: ` : ''}${d.reason}`;
+    }
+}
+function countByReason(diagnostics) {
+    const counts = new Map();
+    for (const d of diagnostics) {
+        if (d.taskId != null) {
+            counts.set(d.reason, (counts.get(d.reason) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function summarizeReasons(counts) {
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([reason, n]) => `${n} ${reason}`)
+        .join(', ');
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}