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

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

@@ -211,7 +211,7 @@ class DaemonClient {
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
-    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
+    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurationsVersion) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
@@ -221,10 +221,10 @@ class DaemonClient {
             collectInputs,
             // An External cannot cross the socket: the version names the stored set
             // to hash from. Absent means native hashing.
-            ioSnapshots,
+            ultracacheConfigurationsVersion,
         });
     }
-    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ioSnapshots) {
+    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurationsVersion) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS_UPFRONT',
             runnerOptions,
@@ -232,7 +232,7 @@ class DaemonClient {
             ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
-            ioSnapshots,
+            ultracacheConfigurationsVersion,
         });
     }
     async registerFileWatcher(config, callback) {

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

@@ -2,6 +2,7 @@ import type { ProjectGraph } from '../../config/project-graph';
 import type { TaskGraph } from '../../config/task-graph';
 import type { TaskSelection } from '../../tasks-runner/run-command';
 import type { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
+import type { InternedExplanation } from '../../project-graph/affected/affected-reasons';
 export declare const SELECT_AFFECTED_TASKS: 'SELECT_AFFECTED_TASKS';
 export type HandleSelectAffectedTasksMessage = {
     type: typeof SELECT_AFFECTED_TASKS;
@@ -14,5 +15,7 @@ export type SelectAffectedTasksResponse = {
     taskGraph: TaskGraph;
     /** Without a planning context: the plans stay in the daemon. */
     taskSelection: TaskSelection;
+    /** Interned, so it stays small on the wire; the client hydrates it. */
+    explanation?: InternedExplanation;
 };
 export declare function isHandleSelectAffectedTasksMessage(message: unknown): message is HandleSelectAffectedTasksMessage;

package/dist/src/daemon/message-types/ultracache-configuration-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * One stored version of a commit's Ultracache configurations: what crosses
+ * the socket in place of the handle.
+ */
+export interface UltracacheConfigurationVersion {
+    commit: string;
+    fetchedAt: number;
+}

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

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

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

@@ -5,7 +5,7 @@ exports.handleHashTasksUpfront = handleHashTasksUpfront;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
-const io_snapshots_state_1 = require("./io-snapshots-state");
+const ultracache_configuration_state_1 = require("./ultracache-configuration-state");
 const planning_context_1 = require("./planning-context");
 /**
  * We use this not to recreated hasher for every hash operation
@@ -27,7 +27,7 @@ async function getHasher(runnerOptions) {
 }
 async function handleHashTasks(payload) {
     const hasher = await getHasher(payload.runnerOptions);
-    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, io_snapshots_state_1.getIoSnapshotsForVersion)(payload.ioSnapshots));
+    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(payload.ultracacheConfigurationsVersion));
     return {
         response,
         description: 'handleHashTasks',
@@ -35,7 +35,7 @@ async function handleHashTasks(payload) {
 }
 async function handleHashTasksUpfront(payload) {
     const hasher = await getHasher(payload.runnerOptions);
-    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, io_snapshots_state_1.getIoSnapshotsForVersion)(payload.ioSnapshots));
+    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs, (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(payload.ultracacheConfigurationsVersion));
     return {
         response,
         description: 'handleHashTasksUpfront',

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

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

package/dist/src/daemon/server/ultracache-configuration-state.d.ts

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

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/devkit-internals.d.ts

@@ -47,6 +47,8 @@ export { getEnvFilesForTask, getGraphTimeDotEnvForTask, } from './tasks-runner/t
 export { getEnvPathsForTask } from './tasks-runner/task-env-paths';
 export { hashDaemonClientEnv, getDaemonClientEnvGeneration, getAppliedDaemonClientEnv, applyDaemonEnvFromClient, } from './daemon/client/daemon-environment';
 export { isCI } from './utils/is-ci';
+export { createCliOptions } from './utils/create-cli-options';
+export { createOverrides } from './utils/command-line-utils';
 export { isUsingPrettierInTree, prettierConfigFiles, } from './utils/formatters/prettier';
 export { detectFormatter, detectFormatterInTree } from './utils/formatters';
 export type { FormatterType } from './utils/formatters';
@@ -85,7 +87,7 @@ export { getRelativeProjectJsonSchemaPath } from './generators/utils/project-con
 export { hashFile } from './hasher/file-hasher';
 export { filterUsingGlobPatterns, getTargetInputs } from './hasher/task-hasher';
 export type { JsonInput } from './native';
-export { killProcessTreeGraceful } from './native';
+export { isAiAgent, killProcessTreeGraceful } from './native';
 export { killChildOnHostExit } from './utils/kill-child-on-host-exit';
 export { connectToNxCloud } from './nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud';
 export type { NxCloudOnBoardingStatus } from './nx-cloud/models/onboarding-status';

package/dist/src/devkit-internals.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemonClientEnvGeneration = exports.hashDaemonClientEnv = exports.getEnvPathsForTask = exports.getGraphTimeDotEnvForTask = exports.getEnvFilesForTask = exports.interpolate = exports.requireWithTsconfigFallback = exports.isTsEsmNamedExportLinkageError = exports.isRequireInEsmScopeError = exports.forceRegisterEsmLoader = exports.loadTsFile = exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappings = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashMultiGlobWithWorkspaceContext = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.installPackageToTmpAsync = exports.installPackageToTmp = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.confirmationPrompt = exports.textPrompt = exports.multiselectPrompt = exports.selectPrompt = exports.splitTarget = exports.createPrettierIgnoreChecker = exports.createOxfmtIgnoreChecker = exports.createGitIgnoreChecker = exports.readTargetDefaultsForTarget = exports.createTargetDefaultsResults = exports.findMatchingProjects = exports.findMatchingConfigFiles = exports.readProjectConfigurationsFromRootMap = exports.findMatchingTargetNames = exports.resolveCommandSyntacticSugar = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.parseExecutor = exports.getExecutorInformation = exports.parseVersionFromPackageManagerField = exports.createTempNpmDirectory = void 0;
-exports.createNxCloudOnboardingURL = exports.getNxCloudAppOnBoardingUrl = exports.createNxCloudOnboardingURLForWelcomeApp = exports.connectToNxCloud = exports.killChildOnHostExit = exports.killProcessTreeGraceful = exports.getTargetInputs = exports.filterUsingGlobPatterns = exports.hashFile = exports.getRelativeProjectJsonSchemaPath = exports.FsTree = exports.LARGE_BUFFER = exports.daemonClient = exports.isProjectGraphProjectNode = exports.isProjectGraphExternalNode = exports.fileDataDepType = exports.fileDataDepTarget = exports.BatchFunctionRunner = exports.getGeneratorInformation = exports.setupAiAgentsGenerator = exports.toOldFormat = exports.toNewFormat = exports.runCommandsExecutor = exports.acknowledgeBuildScripts = exports.getCatalogDependenciesFromPackageJson = exports.getCatalogManager = exports.checkFilesAreOutputs = exports.checkFilesAreInputs = exports.PromptResolutionError = exports.resolvePrompt = exports.SchemaResolutionError = exports.ImplementationResolutionError = exports.resolveSchema = exports.resolveImplementation = exports.emitPluginWorkerLog = exports.safeWriteFileCache = exports.PluginCache = exports.handleImport = exports.signalToCode = exports.globalSpinner = exports.readYamlFile = exports.oxfmtConfigFiles = exports.formatFilesWithOxfmt = exports.detectFormatterInTree = exports.detectFormatter = exports.prettierConfigFiles = exports.isUsingPrettierInTree = exports.isCI = exports.applyDaemonEnvFromClient = exports.getAppliedDaemonClientEnv = void 0;
-exports.normalizeDependencyConfigDefinition = exports.isCacheableTask = exports.getUnparsedOverrideArgs = exports.getTargetConfigurationForTask = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getOutputs = exports.getExecutorNameForTask = exports.getExecutorForTask = exports.getDependencyConfigs = exports.getCustomHasher = exports.getCliPath = exports.expandWildcardTargetConfiguration = exports.expandInitiatingTasksThroughNoop = exports.expandDependencyConfigSyntaxSugar = exports.createTaskId = exports.calculateReverseDeps = exports.createRunManyDynamicOutputRenderer = exports.CompositeLifeCycle = exports.RemoteCacheV2 = exports.Cache = exports.readCachedProjectConfiguration = exports.preventRecursionInGraphConstruction = exports.handleProjectGraphError = exports.createProjectGraphAndSourceMapsAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.isNpmProject = exports.readFileMapCache = exports.readPackageJson = exports.isWholeFileChange = exports.isLockFileChange = exports.isDeletedFileChange = exports.defaultFileRead = exports.calculateFileChanges = exports.WholeFileChange = exports.TEN_MEGABYTES = exports.LockFileChange = exports.DeletedFileChange = exports.buildPackageJsonWorkspacesMatcher = exports.buildPackageJsonPatterns = exports.getGlobPatternsFromPackageManagerWorkspaces = exports.registerTsConfigPaths = exports.getWorkspacePackagesFromGraph = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.findProjectsNpmDependencies = exports.createPackageJson = exports.getLockFileName = exports.generatePrunedDeployOutput = exports.createLockFile = void 0;
-exports.safeSpawn = exports.safeExecFileSync = exports.workspaceRootInner = exports.setWorkspaceRoot = exports.setupWorkspaceContext = exports.resetWorkspaceContext = exports.globWithWorkspaceContext = exports.getFilesInDirectoryUsingContext = exports.nxVersion = exports.SyncError = exports.quoteShellArg = exports.getSourceDirOfDependentProjects = exports.findAllProjectNodeDependencies = exports.findInstalledPlugins = exports.deriveGroupNameFromTarget = exports.warnUnshippableLocalPathSpec = exports.relocatePrunedLocalPathSpec = exports.movePeerDependencyToDependencies = exports.dropEmptyPeerDependencySections = exports.readNxMigrateConfig = exports.isNxCloudUsed = exports.getNxCloudUrl = exports.orange = exports.NX_PREFIX = exports.getNxRequirePaths = exports.isGlobPattern = exports.combineGlobPatterns = exports.getLatestCommitSha = exports.readFileIfExisting = exports.isRelativePath = exports.fileExists = exports.directoryExists = exports.createDirectory = exports.deduceDefaultBase = exports.codeFrameColumns = exports.runNxSync = exports.workspaceDataDirectory = exports.getLastValueFromAsyncIterableIterator = exports.validateOutputs = exports.unparse = exports.transformLegacyOutputs = exports.shouldStreamOutput = exports.removeTasksFromTaskGraph = exports.readProjectAndTargetFromTargetString = exports.normalizeTargetDependencyWithStringProjects = exports.normalizeDependencyConfigProjects = void 0;
+exports.connectToNxCloud = exports.killChildOnHostExit = exports.killProcessTreeGraceful = exports.isAiAgent = exports.getTargetInputs = exports.filterUsingGlobPatterns = exports.hashFile = exports.getRelativeProjectJsonSchemaPath = exports.FsTree = exports.LARGE_BUFFER = exports.daemonClient = exports.isProjectGraphProjectNode = exports.isProjectGraphExternalNode = exports.fileDataDepType = exports.fileDataDepTarget = exports.BatchFunctionRunner = exports.getGeneratorInformation = exports.setupAiAgentsGenerator = exports.toOldFormat = exports.toNewFormat = exports.runCommandsExecutor = exports.acknowledgeBuildScripts = exports.getCatalogDependenciesFromPackageJson = exports.getCatalogManager = exports.checkFilesAreOutputs = exports.checkFilesAreInputs = exports.PromptResolutionError = exports.resolvePrompt = exports.SchemaResolutionError = exports.ImplementationResolutionError = exports.resolveSchema = exports.resolveImplementation = exports.emitPluginWorkerLog = exports.safeWriteFileCache = exports.PluginCache = exports.handleImport = exports.signalToCode = exports.globalSpinner = exports.readYamlFile = exports.oxfmtConfigFiles = exports.formatFilesWithOxfmt = exports.detectFormatterInTree = exports.detectFormatter = exports.prettierConfigFiles = exports.isUsingPrettierInTree = exports.createOverrides = exports.createCliOptions = exports.isCI = exports.applyDaemonEnvFromClient = exports.getAppliedDaemonClientEnv = void 0;
+exports.getTargetConfigurationForTask = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getOutputs = exports.getExecutorNameForTask = exports.getExecutorForTask = exports.getDependencyConfigs = exports.getCustomHasher = exports.getCliPath = exports.expandWildcardTargetConfiguration = exports.expandInitiatingTasksThroughNoop = exports.expandDependencyConfigSyntaxSugar = exports.createTaskId = exports.calculateReverseDeps = exports.createRunManyDynamicOutputRenderer = exports.CompositeLifeCycle = exports.RemoteCacheV2 = exports.Cache = exports.readCachedProjectConfiguration = exports.preventRecursionInGraphConstruction = exports.handleProjectGraphError = exports.createProjectGraphAndSourceMapsAsync = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.isNpmProject = exports.readFileMapCache = exports.readPackageJson = exports.isWholeFileChange = exports.isLockFileChange = exports.isDeletedFileChange = exports.defaultFileRead = exports.calculateFileChanges = exports.WholeFileChange = exports.TEN_MEGABYTES = exports.LockFileChange = exports.DeletedFileChange = exports.buildPackageJsonWorkspacesMatcher = exports.buildPackageJsonPatterns = exports.getGlobPatternsFromPackageManagerWorkspaces = exports.registerTsConfigPaths = exports.getWorkspacePackagesFromGraph = exports.isBuiltinModuleImport = exports.TargetProjectLocator = exports.findProjectsNpmDependencies = exports.createPackageJson = exports.getLockFileName = exports.generatePrunedDeployOutput = exports.createLockFile = exports.createNxCloudOnboardingURL = exports.getNxCloudAppOnBoardingUrl = exports.createNxCloudOnboardingURLForWelcomeApp = void 0;
+exports.safeSpawn = exports.safeExecFileSync = exports.workspaceRootInner = exports.setWorkspaceRoot = exports.setupWorkspaceContext = exports.resetWorkspaceContext = exports.globWithWorkspaceContext = exports.getFilesInDirectoryUsingContext = exports.nxVersion = exports.SyncError = exports.quoteShellArg = exports.getSourceDirOfDependentProjects = exports.findAllProjectNodeDependencies = exports.findInstalledPlugins = exports.deriveGroupNameFromTarget = exports.warnUnshippableLocalPathSpec = exports.relocatePrunedLocalPathSpec = exports.movePeerDependencyToDependencies = exports.dropEmptyPeerDependencySections = exports.readNxMigrateConfig = exports.isNxCloudUsed = exports.getNxCloudUrl = exports.orange = exports.NX_PREFIX = exports.getNxRequirePaths = exports.isGlobPattern = exports.combineGlobPatterns = exports.getLatestCommitSha = exports.readFileIfExisting = exports.isRelativePath = exports.fileExists = exports.directoryExists = exports.createDirectory = exports.deduceDefaultBase = exports.codeFrameColumns = exports.runNxSync = exports.workspaceDataDirectory = exports.getLastValueFromAsyncIterableIterator = exports.validateOutputs = exports.unparse = exports.transformLegacyOutputs = exports.shouldStreamOutput = exports.removeTasksFromTaskGraph = exports.readProjectAndTargetFromTargetString = exports.normalizeTargetDependencyWithStringProjects = exports.normalizeDependencyConfigProjects = exports.normalizeDependencyConfigDefinition = exports.isCacheableTask = exports.getUnparsedOverrideArgs = void 0;
 const tslib_1 = require("tslib");
 /**
  * Note to developers: STOP! These are nx internals, not part of the public
@@ -112,6 +112,10 @@ Object.defineProperty(exports, "getAppliedDaemonClientEnv", { enumerable: true,
 Object.defineProperty(exports, "applyDaemonEnvFromClient", { enumerable: true, get: function () { return daemon_environment_1.applyDaemonEnvFromClient; } });
 var is_ci_1 = require("./utils/is-ci");
 Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return is_ci_1.isCI; } });
+var create_cli_options_1 = require("./utils/create-cli-options");
+Object.defineProperty(exports, "createCliOptions", { enumerable: true, get: function () { return create_cli_options_1.createCliOptions; } });
+var command_line_utils_1 = require("./utils/command-line-utils");
+Object.defineProperty(exports, "createOverrides", { enumerable: true, get: function () { return command_line_utils_1.createOverrides; } });
 var prettier_1 = require("./utils/formatters/prettier");
 Object.defineProperty(exports, "isUsingPrettierInTree", { enumerable: true, get: function () { return prettier_1.isUsingPrettierInTree; } });
 Object.defineProperty(exports, "prettierConfigFiles", { enumerable: true, get: function () { return prettier_1.prettierConfigFiles; } });
@@ -181,6 +185,7 @@ var task_hasher_1 = require("./hasher/task-hasher");
 Object.defineProperty(exports, "filterUsingGlobPatterns", { enumerable: true, get: function () { return task_hasher_1.filterUsingGlobPatterns; } });
 Object.defineProperty(exports, "getTargetInputs", { enumerable: true, get: function () { return task_hasher_1.getTargetInputs; } });
 var native_1 = require("./native");
+Object.defineProperty(exports, "isAiAgent", { enumerable: true, get: function () { return native_1.isAiAgent; } });
 Object.defineProperty(exports, "killProcessTreeGraceful", { enumerable: true, get: function () { return native_1.killProcessTreeGraceful; } });
 var kill_child_on_host_exit_1 = require("./utils/kill-child-on-host-exit");
 Object.defineProperty(exports, "killChildOnHostExit", { enumerable: true, get: function () { return kill_child_on_host_exit_1.killChildOnHostExit; } });

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<Set<string>>;
 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 = {};
@@ -72,6 +72,7 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     }
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
+    return new Set(tasks.filter((t) => !(t.id in hashes)).map((t) => t.id));
 }
 function readsDependencyOutputs(task, taskGraph, projectGraph, nxJson) {
     return (taskGraph.dependencies[task.id]?.length > 0 &&

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) {