@depup/nx 23.2.1-depup.7 → 23.3.0-depup.0

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 { 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): 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,37 +23,43 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails, ultracacheConfigurations) {
     performance.mark('hashMultipleTasks:start');
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    // An Ultracache configuration can make a task depend on producer outputs its declared
+    // inputs never mentioned; those hash after their producers too.
+    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) => {
         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 &&
+        !deferredByConfiguration?.has(task.id) &&
+        !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) {
@@ -66,6 +72,11 @@ 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 &&
+        (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
 }
 async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');

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

@@ -1,18 +1,34 @@
 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 { 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';
 export declare class NativeTaskHasherImpl implements TaskHasherImpl {
+    private readonly projectGraph;
     hasher: TaskHasher;
     planner: HashPlanner;
     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[]>;
+    }, planningContext?: TaskPlanningContext);
+    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 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, ultracacheConfigurations?: UltracacheConfigurations): Promise<Record<string, PartialHash>>;
 }

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

@@ -6,11 +6,22 @@ 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("../ultracache/overrides");
 class NativeTaskHasherImpl {
-    constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
-        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
+    constructor(workspaceRoot, nxJson, projectGraph, externals, options, planningContext) {
+        this.projectGraph = projectGraph;
+        /**
+         * 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;
+        // A shared planner was built over its ref, so the two stay paired.
+        this.projectGraphRef =
+            planningContext?.projectGraphRef ??
+                (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)();
@@ -21,18 +32,73 @@ class NativeTaskHasherImpl {
                 delete tsconfig.compilerOptions.paths;
             }
         }
-        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.planner =
+            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) {
-        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
+    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) {
-        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
+        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, 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, ultracacheConfigurations);
+            Object.assign(hashes, this.hasher.hashPlans(plans, envs, resolvedCwd, shouldCollectInputs));
+        }
         return tasks.map((t) => hashes[t.id]);
     }
+    /**
+     * 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, ultracacheConfigurations) {
+        if (!ultracacheConfigurations) {
+            return this.planner.getPlansReference(taskIds, taskGraph);
+        }
+        return this.planner.getPlansReference(taskIds, taskGraph, ultracacheConfigurations, (0, overrides_1.ultracacheEligibilityOptions)(this.projectGraph, taskGraph));
+    }
+    async hashTasksUpfront(tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurations) {
+        const plans = this.plan(tasks.map((t) => t.id), taskGraph, ultracacheConfigurations);
+        this.upfrontPlans = {
+            fingerprint: taskGraphFingerprint(taskGraph, ultracacheConfigurations),
+            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, 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, ultracacheConfigurations) {
+    const parts = [
+        ultracacheConfigurations
+            ? `${ultracacheConfigurations.commit}@${ultracacheConfigurations.resolution.fetchedAt}`
+            : '',
+    ];
+    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

@@ -2,8 +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 { UltracacheConfigurationVersion } from '../daemon/message-types/ultracache-configuration-version';
 import { InputDefinition } from '../config/workspace-json-project-json';
-import { HashInputs, NxWorkspaceFilesExternals } from '../native';
+import type { TaskPlanningContext } from './task-planning-context';
+import { HashInputs, UltracacheConfigurations, NxWorkspaceFilesExternals } from '../native';
 export { HashInputs };
 /**
  * A data structure returned by the default hasher.
@@ -60,6 +62,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 {
     /**
@@ -68,15 +76,18 @@ 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): Promise<PartialHash[]>;
-    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, 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;
-    constructor(daemonClient: DaemonClient, runnerOptions: any);
+    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>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
@@ -84,10 +95,16 @@ export declare class InProcessTaskHasher implements TaskHasher {
     private readonly nxJson;
     private readonly externalRustReferences;
     private readonly options;
+    private readonly planningContext?;
+    /** 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);
-    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
-    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
+    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any, planningContext?: TaskPlanningContext, 
+    /** 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,13 +44,18 @@ function normalizePerTaskEnvs(tasks, arg) {
     return arg;
 }
 class DaemonBasedTaskHasher {
-    constructor(daemonClient, runnerOptions) {
+    constructor(daemonClient, runnerOptions, ultracacheConfigurationsVersion) {
         this.daemonClient = daemonClient;
         this.runnerOptions = runnerOptions;
+        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);
+        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.ultracacheConfigurationsVersion);
     }
     async hashTask(task, taskGraph, env) {
         return (await this.hashTasks([task], taskGraph, {
@@ -60,21 +65,35 @@ class DaemonBasedTaskHasher {
 }
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
 class InProcessTaskHasher {
-    constructor(projectGraph, nxJson, externalRustReferences, options) {
+    constructor(projectGraph, nxJson, externalRustReferences, options, planningContext, 
+    /** 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.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) {
-        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
+    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 hashTask(task, taskGraph, env, cwd, collectInputs) {
-        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
+    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]) {
+                result[task.id] = this.createHashDetails(task, hashes[task.id]);
+            }
+        }
+        return result;
+    }
+    async hashTask(task, taskGraph, env, cwd, collectInputs, ultracacheConfigurations) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs, ultracacheConfigurations ?? this.ultracacheConfigurations);
         return this.createHashDetails(task, res);
     }
     createHashDetails(task, res) {

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

@@ -0,0 +1,13 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { ExternalObject, HashPlanner, ProjectGraph as NativeProjectGraph } from '../native';
+/**
+ * The graph copied into Rust and the planner built over it, shared by selection
+ * and hashing. The planner remembers its last plans, so the run's hashing reuses
+ * what selection planned.
+ */
+export interface TaskPlanningContext {
+    projectGraphRef: ExternalObject<NativeProjectGraph>;
+    planner: HashPlanner;
+}
+export declare function createTaskPlanningContext(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): TaskPlanningContext;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskPlanningContext = createTaskPlanningContext;
+const native_1 = require("../native");
+const transform_objects_1 = require("../native/transform-objects");
+function createTaskPlanningContext(projectGraph, nxJson) {
+    const projectGraphRef = (0, transform_objects_1.transformProjectGraphForRust)(projectGraph);
+    return {
+        projectGraphRef,
+        planner: new native_1.HashPlanner(nxJson, projectGraphRef),
+    };
+}