nx 24.0.0-beta.1 → 24.0.0-beta.2

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

@@ -142,6 +142,7 @@ export declare function getInputs(task: Task, projectGraph: ProjectGraph, nxJson
     projectInputs: {
         input: string;
         projects: string[];
+        dependencies?: true;
     }[];
     depsFilesets: {
         fileset: string;
@@ -158,6 +159,7 @@ export declare function splitInputsIntoSelfAndDependencies(inputs: ReadonlyArray
     projectInputs: {
         input: string;
         projects: string[];
+        dependencies?: true;
     }[];
     selfInputs: ExpandedSelfInput[];
     depsOutputs: ExpandedDepsOutput[];

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

@@ -200,7 +200,7 @@ function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
             }
             else if ('input' in d &&
                 !('fileset' in d) &&
-                (('dependencies' in d && d.dependencies) ||
+                (('dependencies' in d && d.dependencies && !('projects' in d)) ||
                     // Todo(@AgentEnder): Remove check in v17
                     ('projects' in d &&
                         typeof d.projects === 'string' &&
@@ -219,6 +219,9 @@ function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
                 projectInputs.push({
                     input: d.input,
                     projects: Array.isArray(d.projects) ? d.projects : [d.projects],
+                    ...('dependencies' in d && d.dependencies
+                        ? { dependencies: true }
+                        : {}),
                 });
             }
             else {

package/dist/src/native/index.d.ts

@@ -99,7 +99,8 @@ export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   /**
    * `configurations` is this run's Ultracache configurations; a task with an
-   * eligible entry hashes its observed reads instead of its declared filesets.
+   * eligible entry hashes its observed reads instead of its declared
+   * filesets, except `always` ones.
    * `options` carries the task ids decided in JS, where executors and
    * target configuration are resolved.
    */
@@ -732,8 +733,12 @@ export declare const enum EventType {
   rescan = 'rescan'
 }
 
-/** The files an `includeIgnored` fileset group matches on disk, sorted. */
-export declare function expandFilesInput(workspaceRoot: string, globs: Array<string>): Array<string>
+/**
+ * The files an `includeIgnored` fileset group matches on disk, sorted.
+ * Given the workspace's project roots, an entry skips projects nested below
+ * the one it reads from, as hashing does.
+ */
+export declare function expandFilesInput(workspaceRoot: string, globs: Array<string>, projectRoots?: Array<string> | undefined | null): Array<string>
 
 export declare function expandOutputs(directory: string, entries: Array<string>): Array<string>
 
@@ -779,6 +784,11 @@ export interface FileSetInput {
    * instead of the workspace file map.
    */
   includeIgnored?: boolean
+  /**
+   * Keep the matched files in the hash even when the task is hashed from
+   * its ultracache recording.
+   */
+  always?: boolean
 }
 
 export declare function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
@@ -937,8 +947,17 @@ export interface InputMatch {
 
 export interface InputsInput {
   input: string
+  /**
+   * With `projects`: the selected projects' dependencies' `input`, as `^input`
+   * resolves for each, instead of the projects' own files.
+   */
   dependencies?: boolean
   projects?: string | Array<string>
+  /**
+   * Keep the files this input resolves to in the hash even when the task
+   * is hashed from its ultracache recording.
+   */
+  always?: boolean
 }
 
 export declare function installNxConsole(): Promise<boolean>
@@ -978,6 +997,11 @@ export interface JsonInput {
   json: string
   fields?: Array<string>
   excludeFields?: Array<string>
+  /**
+   * Keep the file in the hash even when the task is hashed from its
+   * ultracache recording.
+   */
+  always?: boolean
 }
 
 /**
@@ -1435,6 +1459,11 @@ export interface TaskTarget {
 export interface TaskUltracacheSettings {
   /** How this target's tasks participate. Defaults to `on`. */
   mode?: 'on' | 'warn' | 'error' | 'off'
+  /**
+   * Collect successful stat metadata accesses as inputs. Defaults to `false`.
+   * Missing-path probes are tracked independently of this setting.
+   */
+  collectStats?: boolean
   /**
    * Workspace-relative glob patterns for reads that should be excluded
    * from ultracache reports. The first path segment cannot contain `*`,

package/dist/src/project-graph/utils/project-configuration/target-normalization.js

@@ -186,6 +186,7 @@ function warnAboutLegacyCachedTargets(legacyCacheReads) {
  */
 const KNOWN_ULTRACACHE_KEYS = new Set([
     'mode',
+    'collectStats',
     'ignoredReads',
     'ignoredWrites',
     utils_1.NX_SPREAD_TOKEN,
@@ -233,7 +234,7 @@ function validateTargetUltracache(ultracache, projectName, projectRoot, targetNa
     const errors = [];
     for (const key of Object.keys(ultracache)) {
         if (!KNOWN_ULTRACACHE_KEYS.has(key)) {
-            errors.push(`"ultracache.${key}" for target ${where} is not an ultracache option. Supported options are "mode", "ignoredReads" and "ignoredWrites".`);
+            errors.push(`"ultracache.${key}" for target ${where} is not an ultracache option. Supported options are "mode", "collectStats", "ignoredReads" and "ignoredWrites".`);
         }
     }
     if (ultracache.mode !== undefined &&
@@ -243,6 +244,10 @@ function validateTargetUltracache(ultracache, projectName, projectRoot, targetNa
             ? `"${ultracache.mode}"`
             : describeUltracacheValue(ultracache.mode)}.`);
     }
+    if (ultracache.collectStats !== undefined &&
+        typeof ultracache.collectStats !== 'boolean') {
+        errors.push(`"ultracache.collectStats" for target ${where} must be a boolean, but it is ${describeUltracacheValue(ultracache.collectStats)}.`);
+    }
     for (const key of ['ignoredReads', 'ignoredWrites']) {
         const value = ultracache[key];
         if (value === undefined)

package/dist/src/project-graph/utils/retrieve-workspace-files.js

@@ -12,6 +12,7 @@ const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
 const project_configuration_utils_1 = require("./project-configuration-utils");
 const workspace_context_1 = require("../../utils/workspace-context");
+const minimatch_1 = require("minimatch");
 const path_1 = require("path");
 const get_plugins_1 = require("../plugins/get-plugins");
 /**
@@ -45,11 +46,9 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
 async function retrieveProjectConfigurations(separatedPlugins, workspaceRoot, nxJson) {
     const specifiedWithCreateNodes = separatedPlugins.specifiedPlugins.filter((p) => !!p.createNodes);
     const defaultWithCreateNodes = separatedPlugins.defaultPlugins.filter((p) => !!p.createNodes);
-    const specifiedGlobPatterns = getGlobPatternsOfPlugins(specifiedWithCreateNodes);
-    const defaultGlobPatterns = getGlobPatternsOfPlugins(defaultWithCreateNodes);
     const [specifiedPluginFiles, defaultPluginFiles] = await Promise.all([
-        (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, specifiedGlobPatterns),
-        (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, defaultGlobPatterns),
+        globPluginFiles(workspaceRoot, specifiedWithCreateNodes),
+        globPluginFiles(workspaceRoot, defaultWithCreateNodes),
     ]);
     return (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(workspaceRoot, nxJson, {
         specifiedPluginFiles: specifiedPluginFiles ?? [],
@@ -71,8 +70,7 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
     return res;
 }
 async function retrieveProjectConfigurationPaths(root, plugins) {
-    const projectGlobPatterns = getGlobPatternsOfPlugins(plugins);
-    const pluginConfigFiles = await (0, workspace_context_1.multiGlobWithWorkspaceContext)(root, projectGlobPatterns);
+    const pluginConfigFiles = await globPluginFiles(root, plugins);
     return pluginConfigFiles.flat();
 }
 const projectsWithoutPluginCache = new Map();
@@ -105,6 +103,29 @@ async function retrieveProjectConfigurationsWithoutPluginInference(root) {
 function clearProjectsWithoutPluginInferenceCache() {
     projectsWithoutPluginCache.clear();
 }
+/**
+ * Files each plugin's createNodes pattern matches, in plugin order. A plugin
+ * scoped by `include` globs only those patterns natively, so a broad pattern
+ * (every `.ts` file, say) is never matched against the whole workspace in JS.
+ */
+async function globPluginFiles(root, plugins) {
+    const unscoped = plugins.filter((p) => !canGlobInclude(p));
+    const unscopedFiles = (await (0, workspace_context_1.multiGlobWithWorkspaceContext)(root, unscoped.map((p) => p.createNodes[0]))) ?? [];
+    return Promise.all(plugins.map(async (plugin) => {
+        if (!canGlobInclude(plugin)) {
+            return unscopedFiles[unscoped.indexOf(plugin)] ?? [];
+        }
+        const pattern = new minimatch_1.Minimatch(plugin.createNodes[0], { dot: true });
+        const included = await (0, workspace_context_1.globWithWorkspaceContext)(root, plugin.include);
+        return included.filter((file) => pattern.match(file));
+    }));
+}
+// Only narrow includes: a `**` scope can return more files than the plugin
+// pattern does. Negations and extglobs keep the JS matcher's semantics.
+function canGlobInclude(plugin) {
+    return (plugin.include?.length > 0 &&
+        plugin.include.every((pattern) => !pattern.includes('**') && !/[!()]/.test(pattern)));
+}
 function getGlobPatternsOfPlugins(plugins) {
     return plugins.map((p) => p.createNodes[0]);
 }

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

@@ -68,7 +68,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.specifiedOutputStyle, context.nxArgs?.resolvedOutputStyle ?? 'static-failures-only', context.taskGraph, context.deferredTaskIds);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.specifiedOutputStyle, context.nxArgs?.resolvedOutputStyle ?? 'static-failures-only', context.taskGraph, context.hashingDeferredTaskIds);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

package/dist/src/tasks-runner/run-command.js

@@ -720,7 +720,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    const deferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
+    const hashingDeferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
     reportUltracacheConfigurations(ultracacheConfigurationOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -791,7 +791,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
             },
         },
         daemon: client_1.daemonClient,
-        deferredTaskIds,
+        hashingDeferredTaskIds,
     });
     if (promiseOrObservable.subscribe) {
         promiseOrObservable = convertObservableToPromise(promiseOrObservable);

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -80,6 +80,12 @@ class BatchProcess {
                     for (const cb of this.batchResultsCallbacks) {
                         cb(message.results);
                     }
+                    // The worker runs a single batch. Its IPC channel would otherwise
+                    // keep it alive until cleanup kills it, which waits out the grace
+                    // period on Windows, where SIGTERM is a no-op.
+                    if (this.childProcess.connected) {
+                        this.childProcess.disconnect();
+                    }
                     break;
                 }
                 case batch_messages_1.BatchMessageType.RunTasks: {

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

@@ -28,7 +28,7 @@ export declare class TaskOrchestrator {
     private readonly resolvedOutputStyle;
     private readonly fullTaskGraph;
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    private readonly deferredTaskIds?;
+    private readonly hashingDeferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -79,7 +79,7 @@ export declare class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph, 
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    deferredTaskIds?: ReadonlySet<string>);
+    hashingDeferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -146,14 +146,18 @@ export declare class TaskOrchestrator {
     /**
      * Hash all batch tasks and resolve cache hits topologically.
      *
-     * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
-     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
-     * receive a preliminary hash — they'll be re-hashed after execution.
+     * Walks the task graph level by level. A deferred task (its hash reads
+     * another task's outputs) behind an upstream batch task that still has to
+     * run is never looked up yet:
+     * - behind a non-cacheable task only, it is held back for a later wave,
+     *   where it hashes after that task ran;
+     * - behind a cache miss, it runs in this wave and re-hashes after execution.
+     * Every task run in this wave gets a hash first, for Cloud's startTasks.
      */
     private applyBatchCachedResults;
     private hashBatchTasks;
     applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
+    private runBatchWave;
     private runBatch;
     /**
      * Tells the life cycle where the batch worker's own log is, when something

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

@@ -80,7 +80,7 @@ class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     resolvedOutputStyle, fullTaskGraph = taskGraph, 
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    deferredTaskIds) {
+    hashingDeferredTaskIds) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -93,7 +93,7 @@ class TaskOrchestrator {
         this.specifiedOutputStyle = specifiedOutputStyle;
         this.resolvedOutputStyle = resolvedOutputStyle;
         this.fullTaskGraph = fullTaskGraph;
-        this.deferredTaskIds = deferredTaskIds;
+        this.hashingDeferredTaskIds = hashingDeferredTaskIds;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
         this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
@@ -573,37 +573,63 @@ class TaskOrchestrator {
     /**
      * Hash all batch tasks and resolve cache hits topologically.
      *
-     * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
-     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
-     * receive a preliminary hash — they'll be re-hashed after execution.
+     * Walks the task graph level by level. A deferred task (its hash reads
+     * another task's outputs) behind an upstream batch task that still has to
+     * run is never looked up yet:
+     * - behind a non-cacheable task only, it is held back for a later wave,
+     *   where it hashes after that task ran;
+     * - behind a cache miss, it runs in this wave and re-hashes after execution.
+     * Every task run in this wave gets a hash first, for Cloud's startTasks.
      */
     async applyBatchCachedResults(batch, doNotSkipCache, groupId) {
         const cachedResults = [];
-        const needsRehashAfterExecution = new Set();
+        const rehashAfterRun = new Set();
         const tasks = Object.values(batch.taskGraph.tasks);
         if (!doNotSkipCache) {
             // Cache skipped — just hash so startTasks has valid hashes
             await this.hashBatchTasks(tasks);
-            return { cachedResults, needsRehashAfterExecution };
-        }
-        const nonCachedTaskIds = new Set();
-        await (0, task_graph_utils_1.walkTaskGraph)(batch.taskGraph, async (rootTaskIds) => {
-            const rootTasks = rootTaskIds.map((id) => batch.taskGraph.tasks[id]);
-            await this.hashBatchTasks(rootTasks);
-            const eligible = [];
-            for (const task of rootTasks) {
-                const hasNonCachedDep = batch.taskGraph.dependencies[task.id].some(({ id }) => nonCachedTaskIds.has(id));
-                if (hasNonCachedDep && this.deferredTaskIds?.has(task.id)) {
-                    nonCachedTaskIds.add(task.id);
-                    needsRehashAfterExecution.add(task.id);
+            return { cachedResults, tasksToRun: tasks, rehashAfterRun };
+        }
+        const toRun = new Map();
+        // Neither restored nor run in this wave; a later wave picks them up.
+        const heldBack = new Set();
+        // Tasks with a cache miss / a non-cacheable task upstream that still has
+        // to run in this wave.
+        const behindMiss = new Set();
+        const behindUncacheable = new Set();
+        const pending = (id, cacheable) => toRun.has(id) && !!toRun.get(id).cache === cacheable;
+        await (0, task_graph_utils_1.walkTaskGraph)(batch.taskGraph, async (levelIds) => {
+            const runNow = [];
+            const lookUp = [];
+            for (const id of levelIds) {
+                const task = batch.taskGraph.tasks[id];
+                const deps = batch.taskGraph.dependencies[id].map((dep) => dep.id);
+                if (deps.some((dep) => heldBack.has(dep))) {
+                    heldBack.add(id);
+                    continue;
+                }
+                const afterMiss = deps.some((dep) => behindMiss.has(dep) || pending(dep, true));
+                const afterUncacheable = deps.some((dep) => behindUncacheable.has(dep) || pending(dep, false));
+                if (afterMiss)
+                    behindMiss.add(id);
+                if (afterUncacheable)
+                    behindUncacheable.add(id);
+                const deferred = this.hashingDeferredTaskIds?.has(id);
+                if (deferred && afterMiss) {
+                    runNow.push(task);
+                    toRun.set(id, task);
+                    rehashAfterRun.add(id);
+                }
+                else if (deferred && afterUncacheable) {
+                    heldBack.add(id);
                 }
                 else {
-                    eligible.push(task);
+                    lookUp.push(task);
                 }
             }
-            if (eligible.length > 0) {
-                const cacheResults = await this.applyCachedResults(eligible);
+            await this.hashBatchTasks([...runNow, ...lookUp]);
+            if (lookUp.length > 0) {
+                const cacheResults = await this.applyCachedResults(lookUp);
                 const cachedIds = new Set(cacheResults.map((r) => r.task.id));
                 cachedResults.push(...cacheResults);
                 if (cacheResults.length > 0) {
@@ -613,14 +639,14 @@ class TaskOrchestrator {
                     // Replayed from the cache — don't write the results back.
                     await this.postRunSteps(cacheResults, false, groupId);
                 }
-                for (const task of eligible) {
+                for (const task of lookUp) {
                     if (!cachedIds.has(task.id)) {
-                        nonCachedTaskIds.add(task.id);
+                        toRun.set(task.id, task);
                     }
                 }
             }
         });
-        return { cachedResults, needsRehashAfterExecution };
+        return { cachedResults, tasksToRun: [...toRun.values()], rehashAfterRun };
     }
     async hashBatchTasks(tasks) {
         // Batch executors run every task in the same forked process, but
@@ -634,29 +660,52 @@ class TaskOrchestrator {
         await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.fullTaskGraph, perTaskEnvs, this.taskDetails, tasks);
     }
     async applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId) {
+        if (this.bailed || this.stopRequested) {
+            return [];
+        }
         const applyFromCacheOrRunBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:start');
-        const taskEntries = Object.entries(batch.taskGraph.tasks);
-        const tasks = taskEntries.map(([, task]) => task);
+        const taskIds = Object.keys(batch.taskGraph.tasks);
         this.options.lifeCycle.registerRunningBatch?.(batch.id, {
             executorName: batch.executorName,
-            taskIds: Object.keys(batch.taskGraph.tasks),
+            taskIds,
+        });
+        // Each wave restores or runs what it can; tasks held back for a later
+        // wave (or left out by the executor) stay incomplete and go again.
+        const results = [];
+        let taskGraph = batch.taskGraph;
+        while (Object.keys(taskGraph.tasks).length > 0 &&
+            !this.bailed &&
+            !this.stopRequested) {
+            results.push(...(await this.runBatchWave(doNotSkipCache, { ...batch, taskGraph }, groupId)));
+            this.forkedProcessTaskRunner.cleanUpBatchProcesses();
+            taskGraph = (0, utils_1.removeTasksFromTaskGraph)(taskGraph, Object.keys(taskGraph.tasks).filter((id) => this.completedTasks.has(id)));
+        }
+        // Once, after every wave: an earlier status would end the batch in the TUI.
+        const hasFailures = taskIds.some((taskId) => {
+            const status = this.completedTasks.get(taskId);
+            return status === 'failure' || status === 'skipped';
         });
-        const { cachedResults, needsRehashAfterExecution } = await this.applyBatchCachedResults(batch, doNotSkipCache, groupId);
+        this.options.lifeCycle.setBatchStatus?.(batch.id, hasFailures ? "Failure" /* BatchStatus.Failure */ : "Success" /* BatchStatus.Success */);
+        const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
+        perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
+        return results;
+    }
+    async runBatchWave(doNotSkipCache, batch, groupId) {
+        const tasks = Object.values(batch.taskGraph.tasks);
+        const { cachedResults, tasksToRun: wave, rehashAfterRun, } = await this.applyBatchCachedResults(batch, doNotSkipCache, groupId);
         // Cached tasks were started and completed inside applyBatchCachedResults;
         // a member skipped meanwhile (a dependency failed) must not run either
-        const nonCachedTasks = tasks.filter((t) => !this.completedTasks.has(t.id));
-        if (nonCachedTasks.length > 0) {
-            await Promise.all(nonCachedTasks.map((task) => this.options.lifeCycle.scheduleTask(task)));
-            await this.preRunSteps(nonCachedTasks, { groupId });
+        const tasksToRun = wave.filter((t) => !this.completedTasks.has(t.id));
+        if (tasksToRun.length > 0) {
+            await Promise.all(tasksToRun.map((task) => this.options.lifeCycle.scheduleTask(task)));
+            await this.preRunSteps(tasksToRun, { groupId });
         }
-        // Phase 2: Run non-cached tasks, then re-hash tasks that read their outputs
+        // Phase 2: Run this wave's tasks, then re-hash those run without a lookup
         let batchResults = [];
         // Read again: a member can be skipped while the hooks above ran
-        const taskIdsToSkip = tasks
-            .filter((t) => this.completedTasks.has(t.id))
-            .map((t) => t.id);
-        if (taskIdsToSkip.length < tasks.length) {
-            const runGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, taskIdsToSkip);
+        const runIds = new Set(tasksToRun.filter((t) => !this.completedTasks.has(t.id)).map((t) => t.id));
+        if (runIds.size > 0) {
+            const runGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasks.filter((t) => !runIds.has(t.id)).map((t) => t.id));
             for (const task of Object.values(runGraph.tasks)) {
                 this.detectTaskInvocationLoop(task);
             }
@@ -667,7 +716,7 @@ class TaskOrchestrator {
             }, this.batchEnv, groupId);
             // Re-hash tasks that read dep outputs — those outputs are now on disk
             const tasksToRehash = batchResults
-                .filter((r) => needsRehashAfterExecution.has(r.task.id) &&
+                .filter((r) => rehashAfterRun.has(r.task.id) &&
                 (r.status === 'success' || r.status === 'failure'))
                 .map((r) => r.task);
             if (tasksToRehash.length > 0) {
@@ -683,25 +732,6 @@ class TaskOrchestrator {
         if (batchResults.length > 0) {
             await this.postRunSteps(batchResults, doNotSkipCache, groupId);
         }
-        // Update batch status based on all task results
-        const hasFailures = taskEntries.some(([taskId]) => {
-            const status = this.completedTasks.get(taskId);
-            return status === 'failure' || status === 'skipped';
-        });
-        this.options.lifeCycle.setBatchStatus?.(batch.id, hasFailures ? "Failure" /* BatchStatus.Failure */ : "Success" /* BatchStatus.Success */);
-        this.forkedProcessTaskRunner.cleanUpBatchProcesses();
-        const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks.has(taskId));
-        // Batch is still not done, run it again
-        if (tasksCompleted.length !== taskEntries.length) {
-            await this.applyFromCacheOrRunBatch(doNotSkipCache, {
-                id: batch.id,
-                executorName: batch.executorName,
-                taskGraph: (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasksCompleted.map(([taskId]) => taskId)),
-            }, groupId);
-        }
-        // Batch is done, mark it as completed
-        const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
-        perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
         return [...cachedResults, ...batchResults];
     }
     async runBatch(batch, env, groupId) {

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

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

package/dist/src/utils/plugins/core-plugins.js

@@ -82,6 +82,10 @@ exports.CORE_PLUGINS = [
         name: '@nx/remix',
         capabilities: 'generators',
     },
+    {
+        name: '@nx/rolldown',
+        capabilities: 'generators',
+    },
     {
         name: '@nx/rollup',
         capabilities: 'executors,generators',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "24.0.0-beta.1",
+  "version": "24.0.0-beta.2",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -150,16 +150,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "24.0.0-beta.1",
-    "@nx/nx-darwin-x64": "24.0.0-beta.1",
-    "@nx/nx-freebsd-x64": "24.0.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "24.0.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "24.0.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "24.0.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "24.0.0-beta.1",
-    "@nx/nx-linux-x64-musl": "24.0.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "24.0.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "24.0.0-beta.1"
+    "@nx/nx-darwin-arm64": "24.0.0-beta.2",
+    "@nx/nx-darwin-x64": "24.0.0-beta.2",
+    "@nx/nx-freebsd-x64": "24.0.0-beta.2",
+    "@nx/nx-linux-arm-gnueabihf": "24.0.0-beta.2",
+    "@nx/nx-linux-arm64-gnu": "24.0.0-beta.2",
+    "@nx/nx-linux-arm64-musl": "24.0.0-beta.2",
+    "@nx/nx-linux-x64-gnu": "24.0.0-beta.2",
+    "@nx/nx-linux-x64-musl": "24.0.0-beta.2",
+    "@nx/nx-win32-arm64-msvc": "24.0.0-beta.2",
+    "@nx/nx-win32-x64-msvc": "24.0.0-beta.2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -192,6 +192,7 @@
       "@nx/plugin",
       "@nx/react",
       "@nx/react-native",
+      "@nx/rolldown",
       "@nx/rollup",
       "@nx/remix",
       "@nx/rspack",