nx 23.3.0-beta.7 → 23.3.0-beta.9

package/dist/src/tasks-runner/task-orchestrator.d.ts

@@ -26,6 +26,8 @@ export declare class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     private readonly resolvedOutputStyle;
     private readonly fullTaskGraph;
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    private readonly deferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -68,7 +70,9 @@ export declare class TaskOrchestrator {
     /** What the user named; undefined means they named nothing. */
     specifiedOutputStyle: OutputStyle | undefined, 
     /** What this run renders with, after defaults. */
-    resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph);
+    resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph, 
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    deferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -128,8 +132,8 @@ export declare class TaskOrchestrator {
      * Hash all batch tasks and resolve cache hits topologically.
      *
      * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks with depsOutputs
-     * whose deps weren't cached are ineligible for cache lookup but still
+     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
+     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
      * receive a preliminary hash — they'll be re-hashed after execution.
      */
     private applyBatchCachedResults;

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

@@ -12,7 +12,6 @@ const project_graph_1 = require("../project-graph/project-graph");
 const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const hash_task_1 = require("../hasher/hash-task");
 const task_graph_utils_1 = require("./task-graph-utils");
-const task_hasher_1 = require("../hasher/task-hasher");
 const native_1 = require("../native");
 const db_connection_1 = require("../utils/db-connection");
 const exit_codes_1 = require("../utils/exit-codes");
@@ -52,7 +51,9 @@ class TaskOrchestrator {
     /** What the user named; undefined means they named nothing. */
     specifiedOutputStyle, 
     /** What this run renders with, after defaults. */
-    resolvedOutputStyle, fullTaskGraph = taskGraph) {
+    resolvedOutputStyle, fullTaskGraph = taskGraph, 
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    deferredTaskIds) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -65,6 +66,7 @@ class TaskOrchestrator {
         this.specifiedOutputStyle = specifiedOutputStyle;
         this.resolvedOutputStyle = resolvedOutputStyle;
         this.fullTaskGraph = fullTaskGraph;
+        this.deferredTaskIds = deferredTaskIds;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
         this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
@@ -477,8 +479,8 @@ class TaskOrchestrator {
      * Hash all batch tasks and resolve cache hits topologically.
      *
      * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks with depsOutputs
-     * whose deps weren't cached are ineligible for cache lookup but still
+     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
+     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
      * receive a preliminary hash — they'll be re-hashed after execution.
      */
     async applyBatchCachedResults(batch, doNotSkipCache, groupId) {
@@ -498,8 +500,7 @@ class TaskOrchestrator {
             for (const task of rootTasks) {
                 const depIds = batch.taskGraph.dependencies[task.id];
                 const hasNonCachedDep = depIds.some((id) => nonCachedTaskIds.has(id));
-                if (hasNonCachedDep &&
-                    (0, task_hasher_1.getInputs)(task, this.projectGraph, this.nxJson).depsOutputs.length > 0) {
+                if (hasNonCachedDep && this.deferredTaskIds?.has(task.id)) {
                     nonCachedTaskIds.add(task.id);
                     needsRehashAfterExecution.add(task.id);
                 }
@@ -555,7 +556,7 @@ class TaskOrchestrator {
             await Promise.all(nonCachedTasks.map((task) => this.options.lifeCycle.scheduleTask(task)));
             await this.preRunSteps(nonCachedTasks, { groupId });
         }
-        // Phase 2: Run non-cached tasks, then re-hash depsOutputs tasks
+        // Phase 2: Run non-cached tasks, then re-hash tasks that read their outputs
         const taskIdsToSkip = cachedResults.map((r) => r.task.id);
         let batchResults = [];
         if (taskIdsToSkip.length < tasks.length) {
@@ -568,7 +569,7 @@ class TaskOrchestrator {
                 executorName: batch.executorName,
                 taskGraph: runGraph,
             }, this.batchEnv, groupId);
-            // Re-hash depsOutputs tasks — their dep outputs are now on disk
+            // Re-hash tasks that read dep outputs — those outputs are now on disk
             const tasksToRehash = batchResults
                 .filter((r) => needsRehashAfterExecution.has(r.task.id) &&
                 (r.status === 'success' || r.status === 'failure'))

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

@@ -19,6 +19,8 @@ export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
     taskGraph?: TaskGraph;
     hasher?: TaskHasher;
     daemon?: DaemonClient;
+    /** Tasks hashed only once the tasks they read outputs from have run. */
+    deferredTaskIds?: ReadonlySet<string>;
 }) => any | Promise<{
     [id: string]: TaskStatus;
 }>;

package/dist/src/ultracache/config.d.ts

@@ -0,0 +1,21 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export interface UltracacheCloudOptions {
+    accessToken?: string;
+    nxCloudId?: string;
+    url?: string;
+    cloud?: boolean;
+}
+export interface UltracacheEnv {
+    NX_CLOUD_USE_ULTRACACHE?: 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_CLOUD_USE_ULTRACACHE=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 isUltracacheConfigurationFetchEnabled(nxJson: NxJsonConfiguration, runnerOptions?: UltracacheCloudOptions, env?: UltracacheEnv): boolean;
+/** The subset of this run's environment the decision reads. */
+export declare function ultracacheEnv(env?: NodeJS.ProcessEnv): UltracacheEnv;

package/dist/src/ultracache/config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUltracacheConfigurationFetchEnabled = isUltracacheConfigurationFetchEnabled;
+exports.ultracacheEnv = ultracacheEnv;
+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_CLOUD_USE_ULTRACACHE=true` in a
+ * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
+ * `env` defaults to this process's.
+ */
+function isUltracacheConfigurationFetchEnabled(nxJson, runnerOptions = {}, env = ultracacheEnv()) {
+    if (env.NX_NO_CLOUD === 'true' ||
+        nxJson.neverConnectToCloud ||
+        runnerOptions.cloud === false ||
+        env.NX_CLOUD_USE_ULTRACACHE !== '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 ultracacheEnv(env = process.env) {
+    return {
+        NX_CLOUD_USE_ULTRACACHE: env.NX_CLOUD_USE_ULTRACACHE,
+        NX_NO_CLOUD: env.NX_NO_CLOUD,
+        hasNxCloudToken: !!(env.NX_CLOUD_ACCESS_TOKEN || env.NX_CLOUD_AUTH_TOKEN),
+    };
+}

package/dist/src/ultracache/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { UltracacheCloudOptions } from './config';
+/** The Nx Cloud client's `readUltracacheConfigurations` contract, as far as nx uses it. */
+export interface ReadUltracacheConfigurationsOptions {
+    workspaceRoot?: string;
+    nxCloudOptions?: UltracacheCloudOptions;
+    timeoutMs?: number;
+}
+export interface ReadUltracacheConfiguration {
+    commit: string;
+    inputs: readonly string[];
+    outputs: readonly string[];
+}
+export interface ReadUltracacheConfigurationsResult {
+    configurations: Readonly<Record<string, ReadUltracacheConfiguration>>;
+}
+/**
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
+ */
+export declare function fetchUltracacheConfigurations(runnerOptions: UltracacheCloudOptions): Promise<ReadUltracacheConfigurationsResult>;

package/dist/src/{io-snapshots → ultracache}/fetch.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchIoSnapshots = fetchIoSnapshots;
+exports.fetchUltracacheConfigurations = fetchUltracacheConfigurations;
 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`.
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
  */
-async function fetchIoSnapshots(runnerOptions) {
+async function fetchUltracacheConfigurations(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');
+    if (typeof client.readUltracacheConfigurations !== 'function') {
+        throw codedError('UNSUPPORTED_CLIENT', 'The installed Nx Cloud client does not expose Ultracache configurations; update nx-cloud');
     }
-    const result = await client.readIoSnapshots({
+    const result = await client.readUltracacheConfigurations({
         workspaceRoot: workspace_root_1.workspaceRoot,
         nxCloudOptions: runnerOptions,
         timeoutMs: READ_TIMEOUT_MS,
@@ -28,7 +28,7 @@ async function fetchIoSnapshots(runnerOptions) {
     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');
+        throw codedError('NO_CONFIGURATIONS', 'Nx Cloud returned no Ultracache configurations');
     }
     return result;
 }

package/dist/src/ultracache/overrides.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import { type UltracacheEligibilityOptions, type UltracacheReport, type UltracacheConfigurations, type TaskUltracacheSettings } from '../native';
+/**
+ * Each task's Ultracache settings: all the native eligibility walk reads
+ * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
+ */
+export declare function getUltracacheSettings(taskGraph: TaskGraph): Record<string, TaskUltracacheSettings | null>;
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+export declare function ultracacheEligibilityOptions(projectGraph: ProjectGraph, taskGraph: TaskGraph): UltracacheEligibilityOptions;
+/**
+ * Reports which tasks in `taskGraph` hash from `configurations` 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 buildUltracacheOverrides(projectGraph: ProjectGraph, taskGraph: TaskGraph, configurations: UltracacheConfigurations): UltracacheReport;

package/dist/src/{io-snapshots → ultracache}/overrides.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUltraCacheConfig = getUltraCacheConfig;
-exports.ioSnapshotEligibilityOptions = ioSnapshotEligibilityOptions;
-exports.buildIoSnapshotOverrides = buildIoSnapshotOverrides;
+exports.getUltracacheSettings = getUltracacheSettings;
+exports.ultracacheEligibilityOptions = ultracacheEligibilityOptions;
+exports.buildUltracacheOverrides = buildUltracacheOverrides;
 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.
+ * Tasks whose executor ships a custom hasher; they are never hashed from
+ * their Ultracache configuration. 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);
@@ -25,7 +26,7 @@ function customHasherTaskIds(projectGraph, taskGraph) {
         }
         catch {
             // An unresolvable executor fails later, at execution; it is not a
-            // reason to withhold a snapshot here.
+            // reason to withhold its configuration here.
             return false;
         }
     })
@@ -34,27 +35,27 @@ function customHasherTaskIds(projectGraph, taskGraph) {
     return ids;
 }
 /**
- * Each task's ultracache configuration: all the native eligibility walk reads
+ * Each task's Ultracache settings: all the native eligibility walk reads
  * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
  */
-function getUltraCacheConfig(taskGraph) {
+function getUltracacheSettings(taskGraph) {
     return Object.fromEntries(Object.entries(taskGraph.tasks).map(([id, task]) => [
         id,
         task.ultracache ?? null,
     ]));
 }
 /** The eligibility walk's view of the run's tasks, as JS resolves it. */
-function ioSnapshotEligibilityOptions(projectGraph, taskGraph) {
+function ultracacheEligibilityOptions(projectGraph, taskGraph) {
     return {
         customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
     };
 }
 /**
- * Reports which tasks in `taskGraph` hash from `snapshots` and why the rest
+ * Reports which tasks in `taskGraph` hash from `configurations` 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, getUltraCacheConfig(taskGraph), ioSnapshotEligibilityOptions(projectGraph, taskGraph));
+function buildUltracacheOverrides(projectGraph, taskGraph, configurations) {
+    return (0, native_1.getUltracacheReport)(configurations, getUltracacheSettings(taskGraph), ultracacheEligibilityOptions(projectGraph, taskGraph));
 }

package/dist/src/ultracache/report.d.ts

@@ -0,0 +1,13 @@
+import type { UltracacheReport } from '../native';
+export interface UltracacheSummary {
+    /** The heading, e.g. "Ultracache: 12 tasks hashed from their configuration, 3 fell back". */
+    line: string;
+    /** Per-reason detail under it. */
+    bodyLines: string[];
+}
+/**
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
+ */
+export declare function formatUltracacheSummary(result: UltracacheReport, status: 'fetched' | 'cached'): UltracacheSummary;

package/dist/src/{io-snapshots → ultracache}/report.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatIoSnapshotSummary = formatIoSnapshotSummary;
+exports.formatUltracacheSummary = formatUltracacheSummary;
 /**
- * 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.
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
  */
-function formatIoSnapshotSummary(result, status) {
+function formatUltracacheSummary(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 withheld = result.diagnostics.filter((d) => d.taskId != null);
     const byReason = countByReason(withheld);
-    const fellBack = new Set(withheld.map((d) => d.taskId)).size;
+    const fellBack = withheld.length;
     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`);
+        ? `Ultracache: none used (unreadable configurations: ${setLevel.message})`
+        : `Ultracache: ${plural(used, 'task')} hashed from their configuration, ${plural(fellBack, 'task')} fell back${fellBack ? ` (${summarizeReasons(byReason)})` : ''}`;
+    const bodyLines = [`configurations: ${status}`];
+    bodyLines.push(`commit ${result.resolution.requestedCommit}, configurations for ${result.resolution.tasks} tasks`);
     for (const d of result.diagnostics) {
         bodyLines.push(describeDiagnostic(d));
     }
@@ -29,7 +25,7 @@ function formatIoSnapshotSummary(result, status) {
 function describeDiagnostic(d) {
     switch (d.reason) {
         case 'unreadable-set':
-            return `unreadable snapshot set: ${d.message}`;
+            return `unreadable Ultracache configurations: ${d.message}`;
         case 'disabled':
             return `${d.taskId}: ultracache.mode is off`;
         case 'autofix-disabled':
@@ -37,13 +33,11 @@ function describeDiagnostic(d) {
         case 'custom-hasher':
             return `${d.taskId}: uses a custom hasher`;
         case 'missing':
-            return `${d.taskId}: no snapshot for this task`;
+            return `${d.taskId}: no Ultracache configuration for this task`;
         case 'invalid-glob':
-            return `${d.taskId}: snapshot glob "${d.glob}" is not a valid files glob`;
+            return `${d.taskId}: configuration 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`;
+            return `${d.taskId}: configuration glob "${d.glob}" escapes the workspace`;
         default:
             return `${d.taskId ? `${d.taskId}: ` : ''}${d.reason}`;
     }

package/dist/src/ultracache/store.d.ts

@@ -0,0 +1,40 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { UltracacheConfigurationStore, type UltracacheConfigurations } from '../native';
+import { type UltracacheCloudOptions, type UltracacheEnv } from './config';
+import { type ReadUltracacheConfigurationsResult } from './fetch';
+/**
+ * What resolving this run's Ultracache configurations came to. Only an
+ * outcome that resolved carries them.
+ */
+export type UltracacheConfigurationOutcome = {
+    status: 'fetched' | 'cached';
+    configurations: UltracacheConfigurations;
+} | {
+    status: 'skipped';
+    reason: string;
+    message: string;
+};
+export declare function skippedUltracacheOutcome(reason: string, message: string): UltracacheConfigurationOutcome;
+/** The configurations an outcome resolved to, if any. */
+export declare function configurationsOf(outcome: UltracacheConfigurationOutcome | null): UltracacheConfigurations | undefined;
+/** The Ultracache configuration store in this process's workspace database. */
+export declare function getUltracacheConfigurationStore(): UltracacheConfigurationStore;
+/**
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+export declare function importUltracacheConfigurations(requestedCommit: string, configurations: ReadUltracacheConfigurationsResult['configurations']): UltracacheConfigurations;
+/**
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+export declare function openUltracacheConfigurations(commit: string, fetchedAt: number): UltracacheConfigurations | null;
+/**
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the stored ones while they are fresh, otherwise what Nx Cloud reads,
+ * imported into the store. Returns `null` when Ultracache is not enabled for
+ * this workspace; never throws.
+ */
+export declare function loadUltracacheConfigurationsForRun(nxJson: NxJsonConfiguration, runnerOptions: UltracacheCloudOptions, env?: UltracacheEnv): Promise<UltracacheConfigurationOutcome | null>;

package/dist/src/{io-snapshots → ultracache}/store.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skippedIoSnapshots = skippedIoSnapshots;
-exports.snapshotsOf = snapshotsOf;
-exports.getIoSnapshotStore = getIoSnapshotStore;
-exports.importIoSnapshots = importIoSnapshots;
-exports.openIoSnapshots = openIoSnapshots;
-exports.loadIoSnapshotsForRun = loadIoSnapshotsForRun;
+exports.skippedUltracacheOutcome = skippedUltracacheOutcome;
+exports.configurationsOf = configurationsOf;
+exports.getUltracacheConfigurationStore = getUltracacheConfigurationStore;
+exports.importUltracacheConfigurations = importUltracacheConfigurations;
+exports.openUltracacheConfigurations = openUltracacheConfigurations;
+exports.loadUltracacheConfigurationsForRun = loadUltracacheConfigurationsForRun;
 const path_1 = require("path");
 const native_1 = require("../native");
 const db_connection_1 = require("../utils/db-connection");
@@ -15,13 +15,13 @@ const output_1 = require("../utils/output");
 const workspace_root_1 = require("../utils/workspace-root");
 const config_1 = require("./config");
 const fetch_1 = require("./fetch");
-function skippedIoSnapshots(reason, message) {
+function skippedUltracacheOutcome(reason, message) {
     return { status: 'skipped', reason, message };
 }
-/** The set an outcome resolved to, if any. */
-function snapshotsOf(outcome) {
+/** The configurations an outcome resolved to, if any. */
+function configurationsOf(outcome) {
     return outcome && outcome.status !== 'skipped'
-        ? outcome.snapshots
+        ? outcome.configurations
         : undefined;
 }
 /**
@@ -30,72 +30,72 @@ function snapshotsOf(outcome) {
  */
 const STORED_SET_MAX_AGE_MS = 60 * 60 * 1000;
 // Reasons that indicate misconfiguration rather than an expected offline
-// state or a client that simply predates snapshots.
+// state or a client that simply predates Ultracache.
 const WARNED_REASONS = new Set([
     'unauthorized',
     'invalid-response',
     'write-failed',
 ]);
-/** The snapshot store in this process's workspace database. */
-function getIoSnapshotStore() {
-    return new native_1.IoSnapshotStore((0, db_connection_1.getDbConnection)());
+/** The Ultracache configuration store in this process's workspace database. */
+function getUltracacheConfigurationStore() {
+    return new native_1.UltracacheConfigurationStore((0, db_connection_1.getDbConnection)());
 }
 /**
- * Stores a set the Nx Cloud client read for `requestedCommit` and returns its
- * handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
  * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
  */
-function importIoSnapshots(requestedCommit, snapshots) {
-    return getIoSnapshotStore().import({
+function importUltracacheConfigurations(requestedCommit, configurations) {
+    return getUltracacheConfigurationStore().import({
         requestedCommit,
-        snapshotsJson: JSON.stringify(snapshots),
+        configurationsJson: JSON.stringify(configurations),
     });
 }
 /**
- * The stored version `importIoSnapshots` returned, reopened by its commit and
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
  * `resolution.fetchedAt`, so other processes hash from it without importing
  * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
  */
-function openIoSnapshots(commit, fetchedAt) {
-    return getIoSnapshotStore().getVersion(commit, fetchedAt);
+function openUltracacheConfigurations(commit, fetchedAt) {
+    return getUltracacheConfigurationStore().getVersion(commit, fetchedAt);
 }
 /**
- * This run's I/O snapshot set for HEAD, in the process that owns the fetch:
- * the stored set while it is fresh, otherwise what Nx Cloud reads, imported
- * into the store. Returns `null` when snapshots are not enabled for this
- * workspace; never throws.
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the stored ones while they are fresh, otherwise what Nx Cloud reads,
+ * imported into the store. Returns `null` when Ultracache is not enabled for
+ * this workspace; never throws.
  */
-async function loadIoSnapshotsForRun(nxJson, runnerOptions, env = (0, config_1.ioSnapshotEnv)()) {
-    if (!(0, config_1.isIoSnapshotFetchEnabled)(nxJson, runnerOptions, env)) {
+async function loadUltracacheConfigurationsForRun(nxJson, runnerOptions, env = (0, config_1.ultracacheEnv)()) {
+    if (!(0, config_1.isUltracacheConfigurationFetchEnabled)(nxJson, runnerOptions, env)) {
         return null;
     }
     const head = (0, git_utils_1.getLatestCommitSha)();
     if (!head) {
-        return reportIoSnapshotResolution(skippedIoSnapshots('not-a-git-repo', 'Could not resolve HEAD'));
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome('not-a-git-repo', 'Could not resolve HEAD'));
     }
     try {
-        const store = getIoSnapshotStore();
+        const store = getUltracacheConfigurationStore();
         const cached = () => {
             const stored = store.get(head, STORED_SET_MAX_AGE_MS);
             return (stored &&
-                reportIoSnapshotResolution({
+                reportUltracacheConfigurationResolution({
                     status: 'cached',
-                    snapshots: stored,
+                    configurations: stored,
                 }));
         };
         return (cached() ??
             // Processes that miss together fetch once: the rest find its set.
-            (await withIoSnapshotFetchLock(async () => {
+            (await withUltracacheConfigurationFetchLock(async () => {
                 const stored = cached();
                 if (stored) {
                     return stored;
                 }
-                const result = await (0, fetch_1.fetchIoSnapshots)(runnerOptions);
-                return reportIoSnapshotResolution({
+                const result = await (0, fetch_1.fetchUltracacheConfigurations)(runnerOptions);
+                return reportUltracacheConfigurationResolution({
                     status: 'fetched',
-                    snapshots: store.import({
+                    configurations: store.import({
                         requestedCommit: head,
-                        snapshotsJson: JSON.stringify(result.snapshots),
+                        configurationsJson: JSON.stringify(result.configurations),
                     }),
                 });
             })));
@@ -103,15 +103,15 @@ async function loadIoSnapshotsForRun(nxJson, runnerOptions, env = (0, config_1.i
     catch (e) {
         // No fallback to an older set for this commit: it would hash from a
         // recording the run could not refresh, and CI can hash natively instead.
-        return reportIoSnapshotResolution(skippedIoSnapshots(reasonFromError(e), errorMessage(e)));
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome(reasonFromError(e), errorMessage(e)));
     }
 }
 /** Runs `fetch` holding a lock beside the workspace database, across processes. */
-async function withIoSnapshotFetchLock(fetch) {
+async function withUltracacheConfigurationFetchLock(fetch) {
     if (native_1.IS_WASM) {
         return fetch();
     }
-    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'io-snapshots.lock'));
+    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'ultracache-configuration.lock'));
     while (!lock.tryLock()) {
         await lock.wait();
     }
@@ -143,20 +143,20 @@ function errorMessage(e) {
     return e instanceof Error ? e.message : String(e);
 }
 /** Warns or logs what a resolution came to. */
-function reportIoSnapshotResolution(outcome) {
+function reportUltracacheConfigurationResolution(outcome) {
     if (outcome.status === 'skipped') {
         if (WARNED_REASONS.has(outcome.reason)) {
             output_1.output.warn({
-                title: `Nx Cloud I/O snapshots are unavailable (${outcome.reason})`,
+                title: `Nx Cloud Ultracache configurations are unavailable (${outcome.reason})`,
                 bodyLines: [outcome.message, 'Tasks will be hashed without them.'],
             });
         }
         else {
-            logger_1.logger.verbose(`Skipping Nx Cloud I/O snapshots (${outcome.reason}): ${outcome.message}`);
+            logger_1.logger.verbose(`Skipping Nx Cloud Ultracache configurations (${outcome.reason}): ${outcome.message}`);
         }
         return outcome;
     }
-    const { resolution } = outcome.snapshots;
-    logger_1.logger.verbose(`Nx Cloud I/O snapshots ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
+    const { resolution } = outcome.configurations;
+    logger_1.logger.verbose(`Nx Cloud Ultracache configurations ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
     return outcome;
 }