nx 23.3.0-beta.6 → 23.3.0-beta.8

package/dist/src/daemon/server/{io-snapshots-state.js → ultracache-configuration-state.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIoSnapshotsForVersion = getIoSnapshotsForVersion;
-const store_1 = require("../../io-snapshots/store");
+exports.getUltracacheConfigurationsForVersion = getUltracacheConfigurationsForVersion;
+const store_1 = require("../../ultracache/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.
@@ -10,7 +10,7 @@ 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) {
+function getUltracacheConfigurationsForVersion(version) {
     if (!version) {
         return undefined;
     }
@@ -26,7 +26,8 @@ function getIoSnapshotsForVersion(version) {
 }
 function readStored({ commit, fetchedAt, }) {
     try {
-        return (0, store_1.getIoSnapshotStore)().getVersion(commit, fetchedAt) ?? undefined;
+        return ((0, store_1.getUltracacheConfigurationStore)().getVersion(commit, fetchedAt) ??
+            undefined);
     }
     catch {
         // An unusable database hashes natively rather than failing the request.

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

@@ -1,11 +1,11 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
-import type { IoSnapshots } from '../native';
+import type { UltracacheConfigurations } from '../native';
 import type { TaskPlanningContext } from './task-planning-context';
 import { TaskHasher } from './task-hasher';
 /**
- * `ioSnapshots` is this run's set (see `loadIoSnapshotsForRun`); undefined
+ * `ultracacheConfigurations` is this run's set (see `loadUltracacheConfigurationsForRun`); 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;
+export declare function createTaskHasher(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, runnerOptions?: any, ultracacheConfigurations?: UltracacheConfigurations, planningContext?: TaskPlanningContext): TaskHasher;

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

@@ -5,21 +5,21 @@ 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");
 /**
- * `ioSnapshots` is this run's set (see `loadIoSnapshotsForRun`); undefined
+ * `ultracacheConfigurations` is this run's set (see `loadUltracacheConfigurationsForRun`); 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) {
+function createTaskHasher(projectGraph, nxJson, runnerOptions, ultracacheConfigurations, planningContext) {
     if (client_1.daemonClient.enabled()) {
-        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions, ioSnapshots
+        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions, ultracacheConfigurations
             ? {
-                commit: ioSnapshots.commit,
-                fetchedAt: ioSnapshots.resolution.fetchedAt,
+                commit: ultracacheConfigurations.commit,
+                fetchedAt: ultracacheConfigurations.resolution.fetchedAt,
             }
             : undefined);
     }
     else {
         const { rustReferences } = (0, build_project_graph_1.getFileMap)();
-        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions, planningContext, ioSnapshots);
+        return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions, planningContext, ultracacheConfigurations);
     }
 }

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 { type IoSnapshots, TaskDetails } from '../native';
+import { type UltracacheConfigurations, 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, ioSnapshots?: IoSnapshots): Promise<void>;
+export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null, ultracacheConfigurations?: UltracacheConfigurations): 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

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

@@ -23,13 +23,13 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails, ioSnapshots) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails, ultracacheConfigurations) {
     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
+    // An Ultracache configuration 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))
+    const deferredByConfiguration = ultracacheConfigurations
+        ? new Set((0, native_1.getUltracacheDeferredTaskIds)(ultracacheConfigurations, taskGraph))
         : null;
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
@@ -42,7 +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) &&
+        !deferredByConfiguration?.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,7 +1,7 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
-import { ExternalObject, FileData, HasherOptions, HashPlanner, IoSnapshots, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, UltracacheConfigurations, 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';
@@ -22,13 +22,13 @@ export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
         selectivelyHashTsConfig: boolean;
     }, 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[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): 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.
+     * Plans through the native planner. With Ultracache configurations, the
+     * tasks JS resolves as custom-hashed or opted out ride along so the
+     * planner's eligibility walk withholds their entries.
      */
     private plan;
-    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ioSnapshots?: IoSnapshots): Promise<Record<string, PartialHash>>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, PartialHash>>;
 }

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

@@ -6,7 +6,7 @@ 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");
+const overrides_1 = require("../ultracache/overrides");
 class NativeTaskHasherImpl {
     constructor(workspaceRoot, nxJson, projectGraph, externals, options, planningContext) {
         this.projectGraph = projectGraph;
@@ -36,11 +36,11 @@ class NativeTaskHasherImpl {
             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, ioSnapshots) {
-        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs, ioSnapshots);
+    async hashTask(task, taskGraph, env, cwd, collectInputs, ultracacheConfigurations) {
+        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs, ultracacheConfigurations);
         return hashes[0];
     }
-    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
+    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
         const envs = perTaskEnvs;
         const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
         const resolvedCwd = cwd ?? process.cwd();
@@ -49,31 +49,31 @@ class NativeTaskHasherImpl {
         if (this.upfrontPlans &&
             unplanned.some((id) => this.upfrontPlans.taskIds.has(id)) &&
             this.upfrontPlans.fingerprint ===
-                taskGraphFingerprint(taskGraph, ioSnapshots)) {
+                taskGraphFingerprint(taskGraph, ultracacheConfigurations)) {
             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.plan(unplanned, taskGraph, ioSnapshots);
+            const plans = this.plan(unplanned, taskGraph, ultracacheConfigurations);
             Object.assign(hashes, this.hasher.hashPlans(plans, envs, resolvedCwd, shouldCollectInputs));
         }
         return tasks.map((t) => hashes[t.id]);
     }
     /**
-     * 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.
+     * Plans through the native planner. With Ultracache configurations, the
+     * tasks JS resolves as custom-hashed or opted out ride along so the
+     * planner's eligibility walk withholds their entries.
      */
-    plan(taskIds, taskGraph, ioSnapshots) {
-        if (!ioSnapshots) {
+    plan(taskIds, taskGraph, ultracacheConfigurations) {
+        if (!ultracacheConfigurations) {
             return this.planner.getPlansReference(taskIds, taskGraph);
         }
-        return this.planner.getPlansReference(taskIds, taskGraph, ioSnapshots, (0, overrides_1.ioSnapshotEligibilityOptions)(this.projectGraph, taskGraph));
+        return this.planner.getPlansReference(taskIds, taskGraph, ultracacheConfigurations, (0, overrides_1.ultracacheEligibilityOptions)(this.projectGraph, taskGraph));
     }
-    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
-        const plans = this.plan(tasks.map((t) => t.id), taskGraph, ioSnapshots);
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
+        const plans = this.plan(tasks.map((t) => t.id), taskGraph, ultracacheConfigurations);
         this.upfrontPlans = {
-            fingerprint: taskGraphFingerprint(taskGraph, ioSnapshots),
+            fingerprint: taskGraphFingerprint(taskGraph, ultracacheConfigurations),
             taskIds: new Set(tasks.map((t) => t.id)),
             plans,
         };
@@ -84,16 +84,16 @@ class NativeTaskHasherImpl {
 exports.NativeTaskHasherImpl = NativeTaskHasherImpl;
 /**
  * Everything the planner reads from a task graph: each task's target and
- * outputs, and the graph's edges, plus the snapshot set the plans were
+ * outputs, and the graph's edges, plus the Ultracache configurations 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, ioSnapshots) {
+function taskGraphFingerprint(taskGraph, ultracacheConfigurations) {
     const parts = [
-        ioSnapshots
-            ? `${ioSnapshots.commit}@${ioSnapshots.resolution.fetchedAt}`
+        ultracacheConfigurations
+            ? `${ultracacheConfigurations.commit}@${ultracacheConfigurations.resolution.fetchedAt}`
             : '',
     ];
     for (const id of Object.keys(taskGraph.tasks).sort()) {

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

@@ -2,10 +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 type { UltracacheConfigurationVersion } from '../daemon/message-types/ultracache-configuration-version';
 import { InputDefinition } from '../config/workspace-json-project-json';
 import type { TaskPlanningContext } from './task-planning-context';
-import { HashInputs, IoSnapshots, NxWorkspaceFilesExternals } from '../native';
+import { HashInputs, UltracacheConfigurations, NxWorkspaceFilesExternals } from '../native';
 export { HashInputs };
 /**
  * A data structure returned by the default hasher.
@@ -76,16 +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, 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>>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<PartialHash[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<PartialHash>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, PartialHash>>;
 }
 export type Hasher = TaskHasher;
 export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly daemonClient;
     private readonly runnerOptions;
-    private readonly ioSnapshots?;
-    constructor(daemonClient: DaemonClient, runnerOptions: any, ioSnapshots?: IoSnapshotVersion);
+    private readonly ultracacheConfigurationsVersion?;
+    constructor(daemonClient: DaemonClient, runnerOptions: any, ultracacheConfigurationsVersion?: UltracacheConfigurationVersion);
     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>;
@@ -96,15 +96,15 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private readonly externalRustReferences;
     private readonly options;
     private readonly planningContext?;
-    /** This run's snapshot set; the daemon passes one per request instead. */
-    private readonly ioSnapshots?;
+    /** This run's Ultracache configurations; the daemon passes them per request instead. */
+    private readonly ultracacheConfigurations?;
     private taskHasher;
     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>;
+    /** This run's Ultracache configurations; the daemon passes them per request instead. */
+    ultracacheConfigurations?: UltracacheConfigurations);
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<Hash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, Hash>>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean, ultracacheConfigurations?: UltracacheConfigurations): Promise<Hash>;
     private createHashDetails;
     private hashCommand;
 }

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

@@ -44,18 +44,18 @@ function normalizePerTaskEnvs(tasks, arg) {
     return arg;
 }
 class DaemonBasedTaskHasher {
-    constructor(daemonClient, runnerOptions, ioSnapshots) {
+    constructor(daemonClient, runnerOptions, ultracacheConfigurationsVersion) {
         this.daemonClient = daemonClient;
         this.runnerOptions = runnerOptions;
-        this.ioSnapshots = ioSnapshots;
+        this.ultracacheConfigurationsVersion = ultracacheConfigurationsVersion;
     }
     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, this.ioSnapshots);
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs, this.ultracacheConfigurationsVersion);
     }
     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, this.ioSnapshots);
+        return this.daemonClient.hashTasksUpfront(this.runnerOptions, tasks, taskGraph, perTaskEnvs, process.cwd(), collectInputs, this.ultracacheConfigurationsVersion);
     }
     async hashTask(task, taskGraph, env) {
         return (await this.hashTasks([task], taskGraph, {
@@ -66,24 +66,24 @@ class DaemonBasedTaskHasher {
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
 class InProcessTaskHasher {
     constructor(projectGraph, nxJson, externalRustReferences, options, planningContext, 
-    /** This run's snapshot set; the daemon passes one per request instead. */
-    ioSnapshots) {
+    /** This run's Ultracache configurations; the daemon passes them per request instead. */
+    ultracacheConfigurations) {
         this.projectGraph = projectGraph;
         this.nxJson = nxJson;
         this.externalRustReferences = externalRustReferences;
         this.options = options;
         this.planningContext = planningContext;
-        this.ioSnapshots = ioSnapshots;
+        this.ultracacheConfigurations = ultracacheConfigurations;
         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, ioSnapshots) {
-        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs, ioSnapshots ?? this.ioSnapshots);
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs, ultracacheConfigurations ?? this.ultracacheConfigurations);
         return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
-    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
-        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs, ioSnapshots ?? this.ioSnapshots);
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
+        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs, ultracacheConfigurations ?? this.ultracacheConfigurations);
         const result = {};
         for (const task of tasks) {
             if (hashes[task.id]) {
@@ -92,8 +92,8 @@ class InProcessTaskHasher {
         }
         return result;
     }
-    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);
+    async hashTask(task, taskGraph, env, cwd, collectInputs, ultracacheConfigurations) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs, ultracacheConfigurations ?? this.ultracacheConfigurations);
         return this.createHashDetails(task, res);
     }
     createHashDetails(task, res) {

package/dist/src/native/index.d.ts

@@ -97,13 +97,13 @@ export declare class HashPlanInspector {
 export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   /**
-   * `snapshots` is this run's I/O snapshot set; a task with an eligible
-   * entry hashes its observed reads instead of its declared filesets.
+   * `configurations` is this run's Ultracache configurations; a task with an
+   * eligible entry hashes its observed reads instead of its declared filesets.
    * `options` carries the task ids decided in JS, where executors and
    * target configuration are resolved.
    */
-  getPlans(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, string[]>
-  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): ExternalObject<Record<string, Array<HashInstruction>>>
+  getPlans(taskIds: Array<string>, taskGraph: TaskGraph, configurations?: UltracacheConfigurations | undefined | null, options?: UltracacheEligibilityOptions | undefined | null): Record<string, string[]>
+  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph, configurations?: UltracacheConfigurations | undefined | null, options?: UltracacheEligibilityOptions | undefined | null): ExternalObject<Record<string, Array<HashInstruction>>>
 }
 
 export declare class HttpRemoteCache {
@@ -127,43 +127,6 @@ export declare class ImportResult {
   staticImportExpressions: Array<string>
 }
 
-/**
- * One stored version of a commit's snapshot set. Handed to the hash planner as-is.
- * A fresh import holds every entry; a handle reopened from storage reads
- * them per task as they are asked for and remembers them, so it costs the
- * tasks it plans rather than the workspace's whole set.
- */
-export declare class IoSnapshots {
-  get commit(): string
-  get resolution(): IoSnapshotResolution
-}
-
-/**
- * The workspace database's snapshot sets. Each import is its own version,
- * keyed by commit and fetch time, so a run that pinned one keeps reading it
- * while a newer one is imported. Failures throw with a `code` JS maps to a
- * skip reason: `STORE_UNAVAILABLE`, `INVALID_RESPONSE` or `WRITE_FAILED`.
- */
-export declare class IoSnapshotStore {
-  constructor(db: ExternalObject<NxDbConnection>)
-  /**
-   * Stores the set the Nx Cloud client read for `requested_commit` as a new
-   * version, and returns it with every entry in hand.
-   */
-  import(options: IoSnapshotImportOptions): IoSnapshots
-  /**
-   * The newest stored set for `commit`, without touching the network;
-   * `null` when none is stored, its row cannot be read, or it was fetched
-   * more than `max_age_ms` ago. Reads only the version's summary row.
-   */
-  get(commit: string, maxAgeMs?: number | undefined | null): IoSnapshots | null
-  /**
-   * Exactly the version of `commit` fetched at `fetched_at`; `null` when it
-   * is not stored or its row cannot be read.
-   */
-  getVersion(commit: string, fetchedAt: number): IoSnapshots | null
-}
-
 export declare class NxCache {
   cacheDirectory: string
   constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
@@ -325,6 +288,43 @@ export declare class TaskInvocationTracker {
   cleanupStale(): void
 }
 
+/**
+ * One stored version of a commit's Ultracache configurations. Handed to the hash planner as-is.
+ * A fresh import holds every entry; a handle reopened from storage reads
+ * them per task as they are asked for and remembers them, so it costs the
+ * tasks it plans rather than the workspace's whole set.
+ */
+export declare class UltracacheConfigurations {
+  get commit(): string
+  get resolution(): UltracacheConfigurationResolution
+}
+
+/**
+ * The workspace database's Ultracache configurations. Each import is its own version,
+ * keyed by commit and fetch time, so a run that pinned one keeps reading it
+ * while a newer one is imported. Failures throw with a `code` JS maps to a
+ * skip reason: `STORE_UNAVAILABLE`, `INVALID_RESPONSE` or `WRITE_FAILED`.
+ */
+export declare class UltracacheConfigurationStore {
+  constructor(db: ExternalObject<NxDbConnection>)
+  /**
+   * Stores the set the Nx Cloud client read for `requested_commit` as a new
+   * version, and returns it with every entry in hand.
+   */
+  import(options: UltracacheConfigurationImportOptions): UltracacheConfigurations
+  /**
+   * The newest stored set for `commit`, without touching the network;
+   * `null` when none is stored, its row cannot be read, or it was fetched
+   * more than `max_age_ms` ago. Reads only the version's summary row.
+   */
+  get(commit: string, maxAgeMs?: number | undefined | null): UltracacheConfigurations | null
+  /**
+   * Exactly the version of `commit` fetched at `fetched_at`; `null` when it
+   * is not stored or its row cannot be read.
+   */
+  getVersion(commit: string, fetchedAt: number): UltracacheConfigurations | null
+}
+
 export declare class WorkspaceContext {
   workspaceRoot: string
   constructor(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null)
@@ -712,31 +712,26 @@ export declare function getFilesForOutputsBatch(directory: string, entriesBatch:
  */
 export declare function getHardcodedIgnorePatterns(): Array<string>
 
-/**
- * Tasks whose snapshot read another task's outputs: they hash after their
- * producers ran, because those files only exist then. Needs no project graph,
- * so the client can call it before the first hashing wave on the daemon path.
- * Opted-out and custom-hasher tasks are not excluded: deferring a task that
- * ends up hashed natively only delays its hash, it never changes it.
- */
-export declare function getIoSnapshotDeferredTaskIds(snapshots: IoSnapshots, taskGraph: TaskGraph): Array<string>
-
-/** The eligibility report, for the run summary. */
-export declare function getIoSnapshotReport(snapshots: IoSnapshots, taskGraph: TaskGraph, options?: IoSnapshotEligibilityOptions | undefined | null): IoSnapshotReport
-
 /**
  * If `workspace_root` is inside a git worktree, returns the main repo root.
  * Returns `None` when already in the main repo (or not in a git repo at all).
  */
 export declare function getMainWorktreeRoot(workspaceRoot: string): string | null
 
+export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
+
 /**
- * Observed outputs per eligible task, for the runner to union into
- * `task.outputs`.
+ * Tasks whose Ultracache configuration read another task's outputs: they
+ * hash after their producers ran, because those files only exist then. Needs
+ * no project graph, so the client can call it before the first hashing wave
+ * on the daemon path.
+ * Opted-out and custom-hasher tasks are not excluded: deferring a task that
+ * ends up hashed natively only delays its hash, it never changes it.
  */
-export declare function getObservedIoSnapshotOutputs(snapshots: IoSnapshots, taskGraph: TaskGraph, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, Array<string>>
+export declare function getUltracacheDeferredTaskIds(configurations: UltracacheConfigurations, taskGraph: TaskGraph): Array<string>
 
-export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
+/** The eligibility report, for the run summary. */
+export declare function getUltracacheReport(configurations: UltracacheConfigurations, tasks: Record<string, TaskUltracacheSettings | null>, options?: UltracacheEligibilityOptions | undefined | null): UltracacheReport
 
 /**
  * Group information - union of different process group types
@@ -830,46 +825,6 @@ export interface InvocationRecord {
   taskId: string
 }
 
-/**
- * Why a task (or the whole run) hashes natively; `reason` is rendered by the
- * run summary.
- */
-export interface IoSnapshotDiagnostic {
-  reason: string
-  taskId?: string
-  glob?: string
-  message?: string
-}
-
-/** What JS knows about a run's tasks that the eligibility walk needs. */
-export interface IoSnapshotEligibilityOptions {
-  /** Tasks whose executor ships a custom hasher. */
-  customHasherTaskIds?: Array<string>
-}
-
-/** The snapshot set the Nx Cloud client read for HEAD, as JS hands it over. */
-export interface IoSnapshotImportOptions {
-  requestedCommit: string
-  /** `Record<taskId, { commit, inputs, outputs }>` as JSON. */
-  snapshotsJson: string
-}
-
-export interface IoSnapshotReport {
-  /** Task ids hashed from their snapshot. */
-  used: Array<string>
-  /** Subset of `used` whose snapshot also contributes observed outputs. */
-  tasksWithOutputs: Array<string>
-  diagnostics: Array<IoSnapshotDiagnostic>
-  resolution: IoSnapshotResolution
-}
-
-/** What was resolved for a commit; stored beside its entries. */
-export interface IoSnapshotResolution {
-  requestedCommit: string
-  fetchedAt: number
-  tasks: number
-}
-
 export const IS_WASM: boolean
 
 /**
@@ -1134,8 +1089,8 @@ export interface Task {
   parallelism?: boolean
   /** This denotes if the task runs continuously */
   continuous?: boolean
-  /** The target's ultracache configuration, if declared */
-  ultracache?: TaskUltracacheConfiguration
+  /** The target's Ultracache settings, if declared */
+  ultracache?: TaskUltracacheSettings
 }
 
 /** Graph of Tasks to be executed */
@@ -1204,8 +1159,8 @@ export interface TaskTarget {
   configuration?: string
 }
 
-/** Ultracache configuration of a task's target */
-export interface TaskUltracacheConfiguration {
+/** Ultracache settings of a task's target */
+export interface TaskUltracacheSettings {
   /** How this target's tasks participate. Defaults to `on`. */
   mode?: 'on' | 'warn' | 'error' | 'off'
   /**
@@ -1257,8 +1212,39 @@ export interface TuiConfig {
   suppressHints?: boolean
 }
 
+/** The Ultracache configurations the Nx Cloud client read for HEAD, as JS hands them over. */
+export interface UltracacheConfigurationImportOptions {
+  requestedCommit: string
+  /** `Record<taskId, { commit, inputs, outputs }>` as JSON. */
+  configurationsJson: string
+}
+
+/** What was resolved for a commit; stored beside its entries. */
+export interface UltracacheConfigurationResolution {
+  requestedCommit: string
+  fetchedAt: number
+  tasks: number
+}
+
 /**
- * How a target's tasks participate in ultracache. Nx Cloud only: nothing in
+ * Why a task (or the whole run) hashes natively; `reason` is rendered by the
+ * run summary.
+ */
+export interface UltracacheDiagnostic {
+  reason: string
+  taskId?: string
+  glob?: string
+  message?: string
+}
+
+/** What JS knows about a run's tasks that the eligibility walk needs. */
+export interface UltracacheEligibilityOptions {
+  /** Tasks whose executor ships a custom hasher. */
+  customHasherTaskIds?: Array<string>
+}
+
+/**
+ * How a target's tasks participate in Ultracache. Nx Cloud only: nothing in
  * the OSS runner records or applies IO, so every mode behaves as `Off` without
  * it.
  */
@@ -1282,6 +1268,13 @@ export declare const enum UltracacheMode {
   Off = 'off'
 }
 
+export interface UltracacheReport {
+  /** Task ids hashed from their Ultracache configuration. */
+  used: Array<string>
+  diagnostics: Array<UltracacheDiagnostic>
+  resolution: UltracacheConfigurationResolution
+}
+
 export interface UpdatedWorkspaceFiles {
   fileMap: FileMap
   externalReferences: NxWorkspaceFilesExternals