nx 23.3.0-beta.7 → 23.3.0-beta.8

package/dist/src/native/native-bindings.js

@@ -584,8 +584,6 @@ module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
 module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
-module.exports.IoSnapshots = nativeBinding.IoSnapshots
-module.exports.IoSnapshotStore = nativeBinding.IoSnapshotStore
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
 module.exports.NxPluginCapabilities = nativeBinding.NxPluginCapabilities
@@ -596,6 +594,8 @@ module.exports.RustPseudoTerminal = nativeBinding.RustPseudoTerminal
 module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
 module.exports.TaskInvocationTracker = nativeBinding.TaskInvocationTracker
+module.exports.UltracacheConfigurations = nativeBinding.UltracacheConfigurations
+module.exports.UltracacheConfigurationStore = nativeBinding.UltracacheConfigurationStore
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
 module.exports.affectedTasks = nativeBinding.affectedTasks
 module.exports.BatchStatus = nativeBinding.BatchStatus
@@ -618,11 +618,10 @@ module.exports.getDefaultMaxCacheSize = nativeBinding.getDefaultMaxCacheSize
 module.exports.getEventDimensions = nativeBinding.getEventDimensions
 module.exports.getFilesForOutputsBatch = nativeBinding.getFilesForOutputsBatch
 module.exports.getHardcodedIgnorePatterns = nativeBinding.getHardcodedIgnorePatterns
-module.exports.getIoSnapshotDeferredTaskIds = nativeBinding.getIoSnapshotDeferredTaskIds
-module.exports.getIoSnapshotReport = nativeBinding.getIoSnapshotReport
 module.exports.getMainWorktreeRoot = nativeBinding.getMainWorktreeRoot
-module.exports.getObservedIoSnapshotOutputs = nativeBinding.getObservedIoSnapshotOutputs
 module.exports.getTransformableOutputs = nativeBinding.getTransformableOutputs
+module.exports.getUltracacheDeferredTaskIds = nativeBinding.getUltracacheDeferredTaskIds
+module.exports.getUltracacheReport = nativeBinding.getUltracacheReport
 module.exports.GroupType = nativeBinding.GroupType
 module.exports.hashArray = nativeBinding.hashArray
 module.exports.hashFile = nativeBinding.hashFile

package/dist/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -11,6 +11,7 @@ const url_shorten_1 = require("../../utilities/url-shorten");
 const get_cloud_options_1 = require("../../utilities/get-cloud-options");
 const path_1 = require("path");
 const git_utils_1 = require("../../../utils/git-utils");
+const http_client_1 = require("../../../utils/http-client");
 function printCloudConnectionDisabledMessage() {
     output_1.output.error({
         title: `Connections to Nx Cloud are disabled for this workspace`,
@@ -46,10 +47,13 @@ function getNxInitDate() {
 }
 async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
-    const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
-        workspaceName,
-        installationSource,
-        nxInitDate,
+    const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
+        method: 'POST',
+        data: {
+            workspaceName,
+            installationSource,
+            nxInitDate,
+        },
     });
     if (response.data.message) {
         throw new Error(response.data.message);
@@ -58,10 +62,13 @@ async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxIni
 }
 async function createNxCloudWorkspaceV2(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
-    const response = await require('axios').post(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
-        workspaceName,
-        installationSource,
-        nxInitDate,
+    const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
+        method: 'POST',
+        data: {
+            workspaceName,
+            installationSource,
+            nxInitDate,
+        },
     });
     if (response.data.message) {
         throw new Error(response.data.message);

package/dist/src/nx-cloud/update-manager.d.ts

@@ -1,5 +1,5 @@
 import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
-import type { ReadIoSnapshotsOptions, ReadIoSnapshotsResult } from '../io-snapshots/fetch';
+import type { ReadUltracacheConfigurationsOptions, ReadUltracacheConfigurationsResult } from '../ultracache/fetch';
 import { TasksRunner } from '../tasks-runner/tasks-runner';
 import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
 export declare class NxCloudEnterpriseOutdatedError extends Error {
@@ -13,8 +13,8 @@ export interface NxCloudClient {
     commands: Record<string, () => Promise<void>>;
     nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
     getRemoteCache: () => RemoteCacheV2;
-    /** Clients that expose I/O snapshots; see `fetchIoSnapshots`. */
-    readIoSnapshots?: (options: ReadIoSnapshotsOptions) => Promise<ReadIoSnapshotsResult | null>;
+    /** Clients that expose Ultracache configurations; see `fetchUltracacheConfigurations`. */
+    readUltracacheConfigurations?: (options: ReadUltracacheConfigurationsOptions) => Promise<ReadUltracacheConfigurationsResult | null>;
 }
 export declare function verifyOrUpdateNxCloudClient(options?: {
     url?: string;

package/dist/src/nx-cloud/update-manager.js

@@ -6,9 +6,11 @@ exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const zlib_1 = require("zlib");
+const stream_1 = require("stream");
 const path_1 = require("path");
 const os_1 = require("os");
-const axios_1 = require("./utilities/axios");
+const nx_cloud_http_client_1 = require("./utilities/nx-cloud-http-client");
+const http_client_1 = require("../utils/http-client");
 const debug_logger_1 = require("./debug-logger");
 const tar = tslib_1.__importStar(require("tar-stream"));
 const cache_directory_1 = require("../utils/cache-directory");
@@ -32,14 +34,14 @@ async function verifyOrUpdateNxCloudClient(options) {
     const currentBundle = getLatestInstalledRunnerBundle();
     const apiUrl = process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app';
     if (shouldVerifyInstalledRunnerBundle(currentBundle)) {
-        const axios = (0, axios_1.createApiAxiosInstance)(options);
+        const httpClient = (0, nx_cloud_http_client_1.createApiHttpClient)(options);
         let verifyBundleResponse;
         try {
-            verifyBundleResponse = await verifyCurrentBundle(axios, currentBundle);
+            verifyBundleResponse = await verifyCurrentBundle(httpClient, currentBundle);
         }
         catch (e) {
             // Enterprise image compatibility, to be removed
-            if (e.message === 'Request failed with status code 404' && apiUrl) {
+            if (e instanceof http_client_1.HttpError && e.status === 404 && apiUrl) {
                 throw new NxCloudEnterpriseOutdatedError(apiUrl);
             }
             (0, debug_logger_1.debugLog)('Could not verify bundle. Resetting validation timer and using previously installed or default runner. Error: ', e);
@@ -72,7 +74,7 @@ async function verifyOrUpdateNxCloudClient(options) {
         if (version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
             throw new NxCloudEnterpriseOutdatedError(apiUrl);
         }
-        const fullPath = await downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url);
+        const fullPath = await downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url);
         (0, debug_logger_1.debugLog)('Done: ', fullPath);
         const nxCloudClient = require(fullPath);
         if (nxCloudClient.commands === undefined) {
@@ -157,8 +159,8 @@ function shouldVerifyInstalledRunnerBundle(currentBundle) {
     }
     return true;
 }
-async function verifyCurrentBundle(axios, currentBundle) {
-    return axios.get('/nx-cloud/client/verify', {
+async function verifyCurrentBundle(httpClient, currentBundle) {
+    return httpClient.get('/nx-cloud/client/verify', {
         params: currentBundle
             ? {
                 version: currentBundle.version,
@@ -209,10 +211,10 @@ function hashDirectory(dir) {
     const combinedHashes = hashes.sort().join('');
     return (0, crypto_1.createHash)('sha256').update(combinedHashes).digest('hex');
 }
-async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url) {
+async function downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url) {
     let resp;
     try {
-        resp = await axios.get(url, {
+        resp = await httpClient.get(url, {
             responseType: 'stream',
         });
     }
@@ -238,6 +240,8 @@ async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirector
             else if (headers.type === 'file') {
                 const outputFilePath = (0, path_1.join)(bundleExtractLocation, headers.name);
                 const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
+                // Surface disk errors through the pipeline instead of crashing
+                writeStream.on('error', (e) => extract.destroy(e));
                 stream.pipe(writeStream);
                 // Continue the tar stream after the write stream closes
                 writeStream.on('close', () => {
@@ -246,15 +250,17 @@ async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirector
                 stream.resume();
             }
         });
-        extract.on('error', (e) => {
-            rej(e);
-        });
         extract.on('finish', function () {
             removeOldClientBundles(version);
             writeBundleVerificationLock();
             res(bundleExtractLocation);
         });
-        resp.data.pipe((0, zlib_1.createGunzip)()).pipe(extract);
+        // pipeline propagates download/gunzip errors that .pipe() would leave
+        // uncaught
+        (0, stream_1.pipeline)(resp.data, (0, zlib_1.createGunzip)(), extract, (e) => {
+            if (e)
+                rej(e);
+        });
     });
 }
 function removeOldClientBundles(currentInstallVersion) {

package/dist/src/nx-cloud/utilities/is-workspace-claimed.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isWorkspaceClaimed = isWorkspaceClaimed;
 const get_cloud_options_1 = require("./get-cloud-options");
+const http_client_1 = require("../../utils/http-client");
 async function isWorkspaceClaimed(accessToken) {
     if (!accessToken)
         return false;
@@ -10,7 +11,7 @@ async function isWorkspaceClaimed(accessToken) {
         const requestData = (0, get_cloud_options_1.isNxCloudId)(accessToken)
             ? { nxCloudId: accessToken }
             : { nxCloudAccessToken: accessToken };
-        const response = await require('axios').post(`${apiUrl}/nx-cloud/is-workspace-claimed`, requestData);
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/is-workspace-claimed`, { method: 'POST', data: requestData });
         if (response.data.message) {
             return false;
         }

package/dist/src/nx-cloud/utilities/nx-cloud-http-client.d.ts

@@ -0,0 +1,5 @@
+import { type HttpClient } from '../../utils/http-client';
+export declare function createApiHttpClient(options?: {
+    url?: string;
+    customProxyConfigPath?: string;
+}): HttpClient;

package/dist/src/nx-cloud/utilities/nx-cloud-http-client.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiHttpClient = createApiHttpClient;
+const http_client_1 = require("../../utils/http-client");
+const environment_1 = require("./environment");
+function createApiHttpClient(options) {
+    if (options?.customProxyConfigPath) {
+        const { logger } = require('../../utils/logger');
+        // The client bundle still reads this file for its own requests
+        logger.warn('customProxyConfigPath is not used for downloading the Nx Cloud client. Set HTTP_PROXY/HTTPS_PROXY/NO_PROXY (and NODE_EXTRA_CA_CERTS for custom certificates) instead.');
+    }
+    return (0, http_client_1.createHttpClient)({
+        baseURL: process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app',
+        timeout: environment_1.NX_CLOUD_NO_TIMEOUTS ? environment_1.UNLIMITED_TIMEOUT : 10000,
+    });
+}

package/dist/src/nx-cloud/utilities/url-shorten.js

@@ -5,10 +5,11 @@ exports.getURLifShortenFailed = getURLifShortenFailed;
 const logger_1 = require("../../utils/logger");
 const get_cloud_options_1 = require("./get-cloud-options");
 const git_utils_1 = require("../../utils/git-utils");
+const http_client_1 = require("../../utils/http-client");
 async function createNxCloudOnboardingURL(onboardingSource, accessToken, meta, forceManual = false, forceGithub = false, directory, 
 // Aborting tears down the in-flight request; without it a caller that stops
 // waiting (see prefetchRemoteCacheOnboardingUrl) leaves the socket holding
-// the event loop open, since axios has no default timeout.
+// the event loop open, since these requests have no timeout.
 signal) {
     const remoteInfo = (0, git_utils_1.getVcsRemoteInfo)(directory);
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
@@ -26,14 +27,18 @@ signal) {
     }
     const source = getSource(onboardingSource);
     try {
-        const response = await require('axios').post(`${apiUrl}/nx-cloud/onboarding`, {
-            type: usesGithub ? 'GITHUB' : 'MANUAL',
-            source,
-            accessToken: usesGithub ? null : accessToken,
-            selectedRepositoryName: remoteInfo?.slug ?? null,
-            repositoryDomain: remoteInfo?.domain ?? null,
-            meta,
-        }, { signal });
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/onboarding`, {
+            method: 'POST',
+            data: {
+                type: usesGithub ? 'GITHUB' : 'MANUAL',
+                source,
+                accessToken: usesGithub ? null : accessToken,
+                selectedRepositoryName: remoteInfo?.slug ?? null,
+                repositoryDomain: remoteInfo?.domain ?? null,
+                meta,
+            },
+            signal,
+        });
         if (!response?.data || response.data.message) {
             throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
         }
@@ -69,7 +74,9 @@ function getURLifShortenFailed(usesGithub, githubSlug, apiUrl, source, accessTok
 }
 async function getInstallationSupportsGitHub(apiUrl, signal) {
     try {
-        const response = await require('axios').get(`${apiUrl}/nx-cloud/system/features`, { signal });
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/system/features`, {
+            signal,
+        });
         if (!response?.data || response.data.message) {
             throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
         }

package/dist/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -416,17 +416,16 @@ class TargetProjectLocator {
         const packageJsonPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)((0, node_path_1.join)(packageName, 'package.json'), relativeToDir);
         if (packageJsonPath) {
             if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                return this.packageJsonResolutionCache.get(packageJsonPath);
+                const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                if (cached) {
+                    return cached;
+                }
             }
             const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
             if (parsedPackageJson.name && parsedPackageJson.version) {
                 this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
                 return parsedPackageJson;
             }
-            else {
-                this.packageJsonResolutionCache.set(packageJsonPath, null);
-                return null;
-            }
         }
         try {
             // Resolve the main entry point of the package
@@ -435,22 +434,27 @@ class TargetProjectLocator {
             while (dir !== (0, node_path_1.dirname)(dir)) {
                 const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
                 if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                    return this.packageJsonResolutionCache.get(packageJsonPath);
-                }
-                try {
-                    const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
-                    // Ensure the package.json contains the "name" and "version" fields
-                    if (parsedPackageJson.name && parsedPackageJson.version) {
-                        this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
-                        return parsedPackageJson;
+                    const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                    if (cached) {
+                        return cached;
                     }
-                    else {
+                    // Cached incomplete manifests are traversal points, not terminal misses.
+                }
+                else {
+                    try {
+                        const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+                        // Ensure the package.json contains the "name" and "version" fields
+                        if (parsedPackageJson.name && parsedPackageJson.version) {
+                            this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
+                            return parsedPackageJson;
+                        }
+                        // A module-format stub without name/version: remember it and keep
+                        // traversing towards the real manifest.
                         this.packageJsonResolutionCache.set(packageJsonPath, null);
-                        return null;
                     }
-                }
-                catch {
-                    // Package.json is invalid, keep traversing
+                    catch {
+                        // Package.json is invalid, keep traversing
+                    }
                 }
                 dir = (0, node_path_1.dirname)(dir);
             }

package/dist/src/project-graph/affected/affected-tasks.d.ts

@@ -1,9 +1,9 @@
 import { NxJsonConfiguration, TargetDependencies } from '../../config/nx-json';
 import { ProjectGraph } from '../../config/project-graph';
 import { TaskGraph } from '../../config/task-graph';
-import { type IoSnapshots } from '../../native';
-import { type IoSnapshotOutcome } from '../../io-snapshots/store';
-import type { IoSnapshotVersion } from '../../daemon/message-types/io-snapshot-version';
+import { type UltracacheConfigurations } from '../../native';
+import { type UltracacheConfigurationOutcome } from '../../ultracache/store';
+import type { UltracacheConfigurationVersion } from '../../daemon/message-types/ultracache-configuration-version';
 import { FileChange } from '../file-utils';
 import type { NxArgs } from '../../utils/command-line-utils';
 import { TaskPlanningContext } from '../../hasher/task-planning-context';
@@ -42,8 +42,8 @@ export interface ComputeAffectedTasksOptions {
     /** `--exclude` project patterns. Their tasks leave the selection but still carry a change and run as dependencies. */
     exclude?: string[];
     packageJson?: any;
-    /** This command's I/O snapshot set. Selection plans with it, as the run hashes with it. */
-    ioSnapshotOutcome?: IoSnapshotOutcome | null;
+    /** This command's Ultracache configurations. Selection plans with them, as the run hashes with them. */
+    ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
     selectivelyHashTsConfig?: boolean;
 }
 export type FileChangeArgs = Pick<NxArgs, 'base' | 'head' | 'files'>;
@@ -61,7 +61,7 @@ export interface AffectedTasksRequest {
     extraTargetDependencies: TargetDependencies;
     excludeTaskDependencies: boolean;
     exclude: string[];
-    ioSnapshots?: IoSnapshotVersion;
+    ultracacheConfigurationsVersion?: UltracacheConfigurationVersion;
     /** The runner's `selectivelyHashTsConfig`, which decides what the tsconfig hash reads. */
     selectivelyHashTsConfig?: boolean;
 }
@@ -76,13 +76,14 @@ export interface AffectedTasksRequest {
 export declare function computeAffectedTasks(opts: ComputeAffectedTasksOptions): Promise<AffectedTasksResult>;
 /**
  * Plans the targets' full task graph and matches the changed paths against
- * every plan. No project-level prefilter: under an I/O snapshot a task can read
- * files no affected project owns. Shared by the client and the daemon.
+ * every plan. No project-level prefilter: under Ultracache configurations a
+ * task can read files no affected project owns. Shared by the client and the
+ * daemon.
  */
-export declare function selectAffectedTasks(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, planningContext: TaskPlanningContext, request: AffectedTasksRequest, { touchedFiles, packageJson, ioSnapshots, }?: {
+export declare function selectAffectedTasks(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, planningContext: TaskPlanningContext, request: AffectedTasksRequest, { touchedFiles, packageJson, ultracacheConfigurations, }?: {
     touchedFiles?: FileChange[];
     packageJson?: any;
-    ioSnapshots?: IoSnapshots;
+    ultracacheConfigurations?: UltracacheConfigurations;
 }): Promise<{
     affectedTaskIds: Set<string>;
     taskGraph: TaskGraph;

package/dist/src/project-graph/affected/affected-tasks.js

@@ -4,9 +4,8 @@ exports.selectsAffectedTasks = selectsAffectedTasks;
 exports.computeAffectedTasks = computeAffectedTasks;
 exports.selectAffectedTasks = selectAffectedTasks;
 const native_1 = require("../../native");
-const outputs_1 = require("../../io-snapshots/outputs");
-const overrides_1 = require("../../io-snapshots/overrides");
-const store_1 = require("../../io-snapshots/store");
+const overrides_1 = require("../../ultracache/overrides");
+const store_1 = require("../../ultracache/store");
 const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
 const project_graph_utils_1 = require("../../utils/project-graph-utils");
 const utils_1 = require("../../tasks-runner/utils");
@@ -53,11 +52,11 @@ async function computeAffectedTasks(opts) {
         exclude: opts.exclude ?? [],
         selectivelyHashTsConfig: opts.selectivelyHashTsConfig,
     };
-    const ioSnapshots = (0, store_1.snapshotsOf)(opts.ioSnapshotOutcome ?? null);
-    if (ioSnapshots) {
-        request.ioSnapshots = {
-            commit: ioSnapshots.commit,
-            fetchedAt: ioSnapshots.resolution.fetchedAt,
+    const ultracacheConfigurations = (0, store_1.configurationsOf)(opts.ultracacheConfigurationOutcome ?? null);
+    if (ultracacheConfigurations) {
+        request.ultracacheConfigurationsVersion = {
+            commit: ultracacheConfigurations.commit,
+            fetchedAt: ultracacheConfigurations.resolution.fetchedAt,
         };
     }
     if (!(0, is_on_daemon_1.isOnDaemon)() && client_1.daemonClient.enabled()) {
@@ -68,7 +67,7 @@ async function computeAffectedTasks(opts) {
                 affectedTaskIds: new Set(selection.affectedTaskIds),
                 taskSelection: {
                     ...selection.taskSelection,
-                    ioSnapshotOutcome: opts.ioSnapshotOutcome,
+                    ultracacheConfigurationOutcome: opts.ultracacheConfigurationOutcome,
                 },
             };
         }
@@ -86,7 +85,7 @@ async function computeAffectedTasks(opts) {
     const selection = await selectAffectedTasks(projectGraph, opts.nxJson, planningContext, request, {
         touchedFiles: opts.touchedFiles,
         packageJson: opts.packageJson,
-        ioSnapshots,
+        ultracacheConfigurations,
     });
     return {
         projectGraph,
@@ -96,16 +95,17 @@ async function computeAffectedTasks(opts) {
             ...selection.taskSelection,
             // The planner remembers what selection planned, so the run's hashing reuses it.
             planningContext,
-            ioSnapshotOutcome: opts.ioSnapshotOutcome,
+            ultracacheConfigurationOutcome: opts.ultracacheConfigurationOutcome,
         },
     };
 }
 /**
  * Plans the targets' full task graph and matches the changed paths against
- * every plan. No project-level prefilter: under an I/O snapshot a task can read
- * files no affected project owns. Shared by the client and the daemon.
+ * every plan. No project-level prefilter: under Ultracache configurations a
+ * task can read files no affected project owns. Shared by the client and the
+ * daemon.
  */
-async function selectAffectedTasks(projectGraph, nxJson, planningContext, request, { touchedFiles = (0, file_utils_1.calculateFileChanges)(request.changedFiles, request.fileChangeArgs), packageJson, ioSnapshots, } = {}) {
+async function selectAffectedTasks(projectGraph, nxJson, planningContext, request, { touchedFiles = (0, file_utils_1.calculateFileChanges)(request.changedFiles, request.fileChangeArgs), packageJson, ultracacheConfigurations, } = {}) {
     const { targets } = request;
     // Only projects that have one of the targets: with a single target,
     // createTaskGraph tries to create a task for projects that lack it and
@@ -128,12 +128,8 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
     // Dependencies carry a change even when they won't run; `keep` drops them.
     false);
     const taskIds = Object.keys(taskGraph.tasks);
-    // As the run hashes: observed outputs carry output reads, observed inputs match changes.
-    if (ioSnapshots) {
-        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
-    }
-    const plans = ioSnapshots
-        ? planningContext.planner.getPlansReference(taskIds, taskGraph, ioSnapshots, (0, overrides_1.ioSnapshotEligibilityOptions)(projectGraph, taskGraph))
+    const plans = ultracacheConfigurations
+        ? planningContext.planner.getPlansReference(taskIds, taskGraph, ultracacheConfigurations, (0, overrides_1.ultracacheEligibilityOptions)(projectGraph, taskGraph))
         : planningContext.planner.getPlansReference(taskIds, taskGraph);
     const dependencies = dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson);
     const namedProjects = new Set(dependencies.projects);

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

@@ -1,12 +1,12 @@
 import type { NxJsonConfiguration } from '../config/nx-json';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
-import type { IoSnapshots } from '../native';
+import type { UltracacheConfigurations } from '../native';
 import type { ProjectGraph } from '../config/project-graph';
 import { RunningTask } from './running-tasks/running-task';
 export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
-/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
-ioSnapshots?: IoSnapshots): Promise<Array<Promise<TaskResult[]>>>;
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Array<Promise<TaskResult[]>>>;
 export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle, 
-/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
-ioSnapshots?: IoSnapshots): Promise<Record<string, Promise<RunningTask>>>;
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, Promise<RunningTask>>>;

package/dist/src/tasks-runner/init-tasks-runner.js

@@ -8,11 +8,10 @@ const dotenv_1 = require("../utils/dotenv");
 const life_cycle_1 = require("./life-cycle");
 const task_orchestrator_1 = require("./task-orchestrator");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
-const outputs_1 = require("../io-snapshots/outputs");
 const client_1 = require("../daemon/client/client");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
-async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots) {
+async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
     (0, dotenv_1.loadRootEnvFiles)();
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
@@ -37,13 +36,7 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
             return acc;
         }, {}),
     };
-    // As in run-command, unhashed tasks hash from the caller's set. Applying is
-    // idempotent, so both graphs may share the same Task objects.
-    if (ioSnapshots) {
-        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, fullTaskGraph, ioSnapshots);
-        (0, outputs_1.applyIoSnapshotOutputs)(projectGraph, taskGraph, ioSnapshots);
-    }
-    const hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ioSnapshots);
+    const hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, options, ultracacheConfigurations);
     const nxArgs = {
         ...options,
         parallel: tasks.length,
@@ -65,9 +58,9 @@ function logDisposeFailure(e) {
     console.error('Failed to dispose the task orchestrator:', e);
 }
 async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
-/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
-ioSnapshots) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
     let groupId = 0;
     let nextBatch = orchestrator.nextBatch();
     const batchResults = [];
@@ -106,9 +99,9 @@ ioSnapshots) {
     return results;
 }
 async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
-/** The set to hash from, e.g. from `importIoSnapshots`; omitted hashes natively. */
-ioSnapshots) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ioSnapshots);
+/** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
+ultracacheConfigurations) {
+    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
     const runningTasks = tasks.reduce((current, task, index) => {
         current[task.id] = orchestrator.startContinuousTask(task, index);
         return current;

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

@@ -3,7 +3,7 @@ import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
-import { type IoSnapshotOutcome } from '../io-snapshots/store';
+import { type UltracacheConfigurationOutcome } from '../ultracache/store';
 import type { TaskPlanningContext } from '../hasher/task-planning-context';
 /** What a command runs. */
 export interface TaskSelection {
@@ -20,8 +20,8 @@ export interface TaskSelection {
     taskIds?: string[];
     /** The planner selection used. It remembers those plans, so hashing the run reuses them. */
     planningContext?: TaskPlanningContext;
-    /** The I/O snapshot set selection planned with; the run hashes with the same one. */
-    ioSnapshotOutcome?: IoSnapshotOutcome | null;
+    /** The Ultracache configurations selection planned with; the run hashes with the same ones. */
+    ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
 }
 import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
@@ -46,7 +46,7 @@ export declare function runTasksForCommand(taskSelection: TaskSelection, current
     completed: boolean;
 }>;
 export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
-export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ioSnapshotOutcome: loadedIoSnapshotOutcome, }: {
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, planningContext, ultracacheConfigurationOutcome: loadedUltracacheConfigurationOutcome, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
     taskGraph: TaskGraph;
@@ -58,17 +58,17 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     initiatingTasks: Task[];
     planningContext?: TaskPlanningContext;
     /** Already loaded for this command; `undefined` loads it here. */
-    ioSnapshotOutcome?: IoSnapshotOutcome | null;
+    ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
 }): Promise<{
     [id: string]: TaskResult;
 }>;
 export declare function constructLifeCycles(lifeCycle: LifeCycle, taskGraph: TaskGraph, nxJson?: NxJsonConfiguration, skipNxCache?: boolean): LifeCycle[];
 /**
  * What affected task selection reads from the runner options, so it plans as
- * the run hashes. The snapshot set is loaded once, for selection and the run.
+ * the run hashes. The Ultracache configurations are loaded once, for selection and the run.
  */
 export declare function runnerInputsForSelection(nxArgs: NxArgs, nxJson: NxJsonConfiguration): Promise<{
-    ioSnapshotOutcome: IoSnapshotOutcome | null;
+    ultracacheConfigurationOutcome: UltracacheConfigurationOutcome | null;
     selectivelyHashTsConfig: boolean;
 }>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {