nx 23.2.1 → 23.3.0-beta.1

package/dist/src/daemon/server/restart-checks.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeServerProcess = void 0;
+exports.registerDaemonForRestartChecks = registerDaemonForRestartChecks;
+exports.fileNames = fileNames;
+exports.changedPaths = changedPaths;
+exports.restartDaemonIfIgnoreFilesChanged = restartDaemonIfIgnoreFilesChanged;
+exports.stopDaemonIfReplaced = stopDaemonIfReplaced;
+const path_1 = require("path");
+const path_2 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const cache_1 = require("../cache");
+const shutdown_utils_1 = require("./shutdown-utils");
+// Kept apart from server.ts: the recomputation module needs these, and
+// importing server.ts starts a server.
+let daemon;
+function registerDaemonForRestartChecks(server, sockets) {
+    daemon = { server, sockets };
+}
+/**
+ * The daemon's own process file, workspace-relative. It lives under the
+ * hardcoded-ignored .nx/workspace-data, so the watch admits it explicitly;
+ * that is how a daemon learns it has been replaced.
+ */
+exports.relativeServerProcess = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, cache_1.serverProcessJsonPath));
+/** The paths out of a list of files and their hashes. */
+function fileNames(files) {
+    return files.map(({ file }) => file);
+}
+function changedPaths(batch) {
+    return [
+        ...fileNames(batch.createdFiles),
+        ...fileNames(batch.updatedFiles),
+        ...batch.deletedFiles,
+    ];
+}
+// Mirrors the per-directory ignore files create_filter reads (watch_filterer.rs).
+// The sources it honours that cannot trigger a restart from here — because they
+// are never watched — only take effect on the next daemon start: .git/info/exclude
+// (under the hardcoded-ignored .git), the global core.excludesFile (outside the
+// tree), and parent .gitignore files above the workspace root.
+const IGNORE_FILE_NAMES = ['.gitignore', '.nxignore'];
+/**
+ * The watch's ignore rules are fixed when it starts, so an ignore-file edit
+ * needs a daemon restart to take effect. True when it stopped the daemon.
+ */
+function restartDaemonIfIgnoreFilesChanged(paths) {
+    for (const path of paths) {
+        const basename = path.slice(path.lastIndexOf('/') + 1);
+        if (IGNORE_FILE_NAMES.includes(basename)) {
+            stopDaemon('Stopping the daemon the set of ignored files changed (native)');
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Stops this daemon when the events show another process has written the
+ * daemon's process file. True when it stopped the daemon.
+ */
+function stopDaemonIfReplaced(events) {
+    const replaced = events.some((event) => event.path === exports.relativeServerProcess &&
+        (0, cache_1.getDaemonProcessIdSync)() !== process.pid);
+    if (replaced) {
+        stopDaemon('this process is no longer the current daemon (native)');
+    }
+    return replaced;
+}
+function stopDaemon(reason) {
+    if (!daemon)
+        return;
+    (0, shutdown_utils_1.handleServerProcessTermination)({
+        server: daemon.server,
+        reason,
+        sockets: daemon.sockets,
+    });
+}

package/dist/src/daemon/server/server.js

@@ -14,7 +14,6 @@ const native_1 = require("../../native");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
 require("../../utils/perf-logging");
 const versions_1 = require("../../utils/versions");
-const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const cache_1 = require("../cache");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
@@ -38,7 +37,6 @@ const task_history_1 = require("../message-types/task-history");
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const socket_utils_1 = require("../socket-utils");
 const file_change_events_1 = require("./file-watching/file-change-events");
-const route_workspace_changes_1 = require("./file-watching/route-workspace-changes");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const handle_configure_ai_agents_1 = require("./handle-configure-ai-agents");
 const handle_context_file_data_1 = require("./handle-context-file-data");
@@ -62,10 +60,11 @@ const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks")
 const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
 const handle_outputs_changes_1 = require("./handle-outputs-changes");
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const restart_checks_1 = require("./restart-checks");
 const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
 const shutdown_utils_1 = require("./shutdown-utils");
 const sync_generators_1 = require("./sync-generators");
-const watcher_1 = require("./watcher");
+const workspace_context_1 = require("../../utils/workspace-context");
 let workspaceWatcherError;
 global.NX_DAEMON = true;
 process.env.NX_DAEMON_PROCESS = 'true';
@@ -146,6 +145,9 @@ async function handleMessage(socket, data) {
     else if (payload.type === 'HASH_TASKS') {
         await handleResult(socket, 'HASH_TASKS', () => (0, handle_hash_tasks_1.handleHashTasks)(payload), mode);
     }
+    else if (payload.type === 'HASH_TASKS_UPFRONT') {
+        await handleResult(socket, 'HASH_TASKS_UPFRONT', () => (0, handle_hash_tasks_1.handleHashTasksUpfront)(payload), mode);
+    }
     else if (payload.type === 'PROCESS_IN_BACKGROUND') {
         await handleResult(socket, 'PROCESS_IN_BACKGROUND', () => (0, handle_process_in_background_1.handleProcessInBackground)(payload), mode);
     }
@@ -323,7 +325,7 @@ function lockFileHashChanged() {
  * we need to recompute the cached serialized project graph so that it is readily
  * available for the next client request to the server.
  */
-const handleWorkspaceChanges = async (err, changeEvents) => {
+const handleWorkspaceChanges = (err, batch) => {
     if (workspaceWatcherError) {
         logger_1.serverLogger.watcherLog('Skipping handleWorkspaceChanges because of a previously recorded watcher error.');
         return;
@@ -338,8 +340,7 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
             (0, file_watcher_sockets_1.notifyFileWatcherSocketsOfError)(error);
             return;
         }
-        logger_1.serverLogger.watcherLog((0, watcher_1.convertChangeEventsToLogMessage)(changeEvents));
-        (0, route_workspace_changes_1.routeWorkspaceChanges)(changeEvents);
+        (0, project_graph_incremental_recomputation_1.routeAppliedChanges)(batch);
     }
     catch (err) {
         logger_1.serverLogger.watcherLog(`Unexpected workspace error`, err.message);
@@ -349,14 +350,17 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
     }
 };
 async function startServer() {
-    // Watch before scan: a file written during boot must be visible to the
-    // watcher or the scan below. Scan-first left a blind window where such
-    // files stayed invisible to both until an unrelated change arrived.
-    if (!(0, shutdown_utils_1.getWatcherInstance)()) {
-        (0, shutdown_utils_1.storeWatcherInstance)(await (0, watcher_1.watchWorkspace)(server, handleWorkspaceChanges));
+    // The workspace context owns the daemon's one watch and starts it before
+    // it scans, so a file written during boot is visible to one or the other.
+    if (!(0, workspace_context_1.isWatchingWorkspaceContext)()) {
+        (0, restart_checks_1.registerDaemonForRestartChecks)(server, exports.openSockets);
+        (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot, {
+            watch: true,
+            alwaysWatch: [restart_checks_1.relativeServerProcess],
+        });
+        (0, workspace_context_1.subscribeToWorkspaceChanges)(workspace_root_1.workspaceRoot, handleWorkspaceChanges);
         logger_1.serverLogger.watcherLog(`Subscribed to changes within: ${workspace_root_1.workspaceRoot} (native)`);
     }
-    (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
     // Initialize analytics for daemon process
     await (0, analytics_1.startAnalytics)();
     const socketPath = (0, socket_utils_1.getFullOsSocketPath)();
@@ -434,15 +438,21 @@ async function startServer() {
                     }
                     // this triggers the storage of the lock file hash
                     daemonIsOutdated();
-                    if (!(0, shutdown_utils_1.getOutputWatcherInstance)()) {
-                        (0, shutdown_utils_1.storeOutputWatcherInstance)(await (0, watcher_1.watchOutputFiles)(server, handle_outputs_changes_1.handleOutputsChanges));
-                    }
+                    // Every event the watch delivers, gitignored outputs and dotenv
+                    // files included.
+                    (0, workspace_context_1.subscribeToWatchEvents)(workspace_root_1.workspaceRoot, (err, events) => {
+                        if (!err && events && (0, restart_checks_1.stopDaemonIfReplaced)(events)) {
+                            return;
+                        }
+                        if (err || events?.length) {
+                            (0, handle_outputs_changes_1.handleOutputsChanges)(err, events);
+                        }
+                    });
                     // listen for project graph recomputation events to collect and schedule sync generators
                     (0, project_graph_incremental_recomputation_1.registerProjectGraphRecomputationListener)(sync_generators_1.collectAndScheduleSyncGenerators);
                     // register file change listener to invalidate sync generator cache
                     (0, file_change_events_1.registerFileChangeListener)(sync_generators_1.clearSyncGeneratorsCache);
-                    // trigger an initial project graph recomputation
-                    (0, project_graph_incremental_recomputation_1.scheduleProjectGraphRecomputation)([], [], []);
+                    (0, project_graph_incremental_recomputation_1.scheduleInitialProjectGraphComputation)();
                     // Kick off Nx Console check in background to prime the cache
                     (0, handle_nx_console_1.handleGetNxConsoleStatus)().catch(() => {
                         // Ignore errors, this is a background operation
@@ -454,7 +464,7 @@ async function startServer() {
                     return resolve(server);
                 }
                 catch (err) {
-                    await handleWorkspaceChanges(err, []);
+                    await handleWorkspaceChanges(err, null);
                 }
             });
         }

package/dist/src/daemon/server/shutdown-utils.d.ts

@@ -1,10 +1,5 @@
 import type { Server, Socket } from 'net';
-import type { Watcher } from '../../native';
 export declare const SERVER_INACTIVITY_TIMEOUT_MS: 10800000;
-export declare function storeWatcherInstance(instance: Watcher): void;
-export declare function getWatcherInstance(): Watcher;
-export declare function storeOutputWatcherInstance(instance: Watcher): void;
-export declare function getOutputWatcherInstance(): Watcher;
 interface HandleServerProcessTerminationParams {
     server: Server;
     reason: string;

package/dist/src/daemon/server/shutdown-utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_INACTIVITY_TIMEOUT_MS = void 0;
-exports.storeWatcherInstance = storeWatcherInstance;
-exports.getWatcherInstance = getWatcherInstance;
-exports.storeOutputWatcherInstance = storeOutputWatcherInstance;
-exports.getOutputWatcherInstance = getOutputWatcherInstance;
 exports.handleServerProcessTermination = handleServerProcessTermination;
 exports.handleServerProcessTerminationWithRestart = handleServerProcessTerminationWithRestart;
 exports.resetInactivityTimeout = resetInactivityTimeout;
@@ -15,6 +11,7 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const logger_1 = require("../logger");
 const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
+const workspace_context_1 = require("../../utils/workspace-context");
 const error_types_1 = require("../../project-graph/error-types");
 const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
@@ -61,20 +58,6 @@ async function startNewDaemonInBackground() {
     backgroundProcess.unref();
     logger_1.serverLogger.log('Started new daemon process in background');
 }
-let watcherInstance;
-function storeWatcherInstance(instance) {
-    watcherInstance = instance;
-}
-function getWatcherInstance() {
-    return watcherInstance;
-}
-let outputWatcherInstance;
-function storeOutputWatcherInstance(instance) {
-    outputWatcherInstance = instance;
-}
-function getOutputWatcherInstance() {
-    return outputWatcherInstance;
-}
 async function handleServerProcessTermination({ server, reason, sockets, }) {
     await performShutdown(server, reason, sockets);
 }
@@ -95,14 +78,8 @@ async function performShutdown(server, reason, sockets) {
                 socket.destroy();
             }
         });
-        if (watcherInstance) {
-            await watcherInstance.stop();
-            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (sources)`);
-        }
-        if (outputWatcherInstance) {
-            await outputWatcherInstance.stop();
-            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
-        }
+        (0, workspace_context_1.stopWatchingWorkspaceContext)();
+        logger_1.serverLogger.watcherLog(`Stopping the watch for ${workspace_root_1.workspaceRoot}`);
         (0, cache_1.deleteDaemonJsonProcessCache)();
         (0, get_plugins_1.cleanupPlugins)();
         // Clean up shared latest Nx installation

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

@@ -31,29 +31,29 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         const customHasher = (0, utils_1.getCustomHasher)(task, projects);
         return { task, customHasher };
     }));
-    const tasksToHash = tasksWithHashers
-        .filter(({ task, customHasher }) => {
-        // If a task has a custom hasher, it might depend on the outputs of other tasks
-        if (customHasher) {
-            return false;
-        }
-        return !(taskGraph.dependencies[task.id].length > 0 &&
-            (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
-    })
+    // Custom hashers can read other tasks' outputs, so they hash at run time,
+    // and so does a task whose own inputs read them. The hasher still decides
+    // for the rest: outputs also arrive through a dependency's named input or
+    // a continuous server, which only planning reveals.
+    const candidates = tasksWithHashers
+        .filter(({ task, customHasher }) => !customHasher &&
+        !readsDependencyOutputs(task, taskGraph, projectGraph, nxJson))
         .map((t) => t.task);
     const perTaskEnvs = {};
-    for (const task of tasksToHash) {
+    for (const task of candidates) {
         perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, projectGraph);
     }
-    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, perTaskEnvs);
+    const hashes = await hasher.hashTasksUpfront(candidates, taskGraph, perTaskEnvs);
+    const tasksToHash = candidates.filter((task) => task.id in hashes);
     const ioService = (0, task_io_service_1.getTaskIOService)();
     const hasInputSubscribers = ioService.hasTaskInputSubscribers();
-    for (let i = 0; i < tasksToHash.length; i++) {
-        tasksToHash[i].hash = hashes[i].value;
-        tasksToHash[i].hashDetails = hashes[i].details;
+    for (const task of tasksToHash) {
+        const hash = hashes[task.id];
+        task.hash = hash.value;
+        task.hashDetails = hash.details;
         // Notify TaskIOService of hash inputs
-        if (hasInputSubscribers && hashes[i].inputs) {
-            ioService.notifyTaskInputs(tasksToHash[i].id, hashes[i].inputs);
+        if (hasInputSubscribers && hash.inputs) {
+            ioService.notifyTaskInputs(task.id, hash.inputs);
         }
     }
     if (tasksDetails?.recordTaskDetails) {
@@ -67,6 +67,10 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
+function readsDependencyOutputs(task, taskGraph, projectGraph, nxJson) {
+    return (taskGraph.dependencies[task.id]?.length > 0 &&
+        (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
+}
 async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);

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

@@ -2,6 +2,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, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
+import type { IgnoredIndexReader } from '../native';
 import { PartialHash, TaskHasherImpl } from './task-hasher';
 export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     hasher: TaskHasher;
@@ -9,10 +10,17 @@ export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     projectGraphRef: ExternalObject<NativeProjectGraph>;
     allWorkspaceFilesRef: ExternalObject<FileData[]>;
     projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
+    ignoredIndexRef: ExternalObject<IgnoredIndexReader>;
     options: HasherOptions | undefined;
+    /**
+     * Plans of the last up-front batch and the task graph they were built for.
+     * The tasks that batch deferred hash from them later without planning again.
+     */
+    private upfrontPlans;
     constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
         selectivelyHashTsConfig: boolean;
     });
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
 }

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

@@ -8,9 +8,15 @@ const task_io_service_1 = require("../tasks-runner/task-io-service");
 const fileutils_1 = require("../utils/fileutils");
 class NativeTaskHasherImpl {
     constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
+        /**
+         * Plans of the last up-front batch and the task graph they were built for.
+         * The tasks that batch deferred hash from them later without planning again.
+         */
+        this.upfrontPlans = null;
         this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
         this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
         this.projectFileMapRef = externals.projectFiles;
+        this.ignoredIndexRef = externals.ignoredIndex;
         let tsconfig = {};
         let paths = {};
         let rootTsConfigPath = (0, typescript_1.getRootTsConfigPath)();
@@ -22,17 +28,54 @@ class NativeTaskHasherImpl {
             }
         }
         this.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.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options, this.ignoredIndexRef);
     }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {
         const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
         return hashes[0];
     }
     async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const envs = perTaskEnvs;
         const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
-        const hashes = this.hasher.hashPlans(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
+        const resolvedCwd = cwd ?? process.cwd();
+        const hashes = {};
+        let unplanned = tasks.map((t) => t.id);
+        if (this.upfrontPlans &&
+            unplanned.some((id) => this.upfrontPlans.taskIds.has(id)) &&
+            this.upfrontPlans.fingerprint === taskGraphFingerprint(taskGraph)) {
+            Object.assign(hashes, this.hasher.hashPlansFor(this.upfrontPlans.plans, unplanned, envs, resolvedCwd, shouldCollectInputs));
+            unplanned = unplanned.filter((id) => !(id in hashes));
+        }
+        if (unplanned.length > 0) {
+            const plans = this.planner.getPlansReference(unplanned, taskGraph);
+            Object.assign(hashes, this.hasher.hashPlans(plans, envs, resolvedCwd, shouldCollectInputs));
+        }
         return tasks.map((t) => hashes[t.id]);
     }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        this.upfrontPlans = {
+            fingerprint: taskGraphFingerprint(taskGraph),
+            taskIds: new Set(tasks.map((t) => t.id)),
+            plans,
+        };
+        const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
+        return this.hasher.hashPlansUpfront(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
+    }
 }
 exports.NativeTaskHasherImpl = NativeTaskHasherImpl;
+/**
+ * Everything the planner reads from a task graph: each task's target and
+ * outputs, and the graph's edges. The project graph and nx.json are fixed for
+ * the life of a hasher, so equal fingerprints mean equal plans. A run's
+ * results (hash, timings) are left out so hashing one task does not
+ * invalidate the plans of the rest.
+ */
+function taskGraphFingerprint(taskGraph) {
+    const parts = [];
+    for (const id of Object.keys(taskGraph.tasks).sort()) {
+        const task = taskGraph.tasks[id];
+        parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).join(','), (taskGraph.continuousDependencies[id] ?? []).join(','));
+    }
+    return (0, native_1.hashArray)(parts);
+}

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

@@ -60,6 +60,12 @@ export interface TaskHasher {
      * tasks actually differ.
      */
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Hash[]>;
+    /**
+     * Hash the tasks whose hash needs no output of another task, keyed by
+     * task id. A task absent from the result hashes once the tasks it reads
+     * from have run.
+     */
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Record<string, Hash>>;
 }
 export interface TaskHasherImpl {
     /**
@@ -70,6 +76,7 @@ export interface TaskHasherImpl {
      */
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
 }
 export type Hasher = TaskHasher;
 export declare class DaemonBasedTaskHasher implements TaskHasher {
@@ -77,6 +84,7 @@ export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly runnerOptions;
     constructor(daemonClient: DaemonClient, runnerOptions: any);
     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>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
@@ -87,6 +95,7 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private taskHasher;
     constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
     hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
     hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
     private createHashDetails;
     private hashCommand;

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

@@ -52,6 +52,10 @@ class DaemonBasedTaskHasher {
         const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
         return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs);
     }
+    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);
+    }
     async hashTask(task, taskGraph, env) {
         return (await this.hashTasks([task], taskGraph, {
             [task.id]: env ?? process.env,
@@ -73,6 +77,16 @@ class InProcessTaskHasher {
         const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
         return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
     }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        const hashes = await this.taskHasher.hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd ?? process.cwd(), collectInputs);
+        const result = {};
+        for (const task of tasks) {
+            if (hashes[task.id]) {
+                result[task.id] = this.createHashDetails(task, hashes[task.id]);
+            }
+        }
+        return result;
+    }
     async hashTask(task, taskGraph, env, cwd, collectInputs) {
         const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
         return this.createHashDetails(task, res);