nx 24.0.0-beta.0 → 24.0.0-beta.2

package/dist/src/devkit-exports.d.ts

@@ -21,7 +21,7 @@ export { createNodesFromFiles } from './project-graph/plugins';
 /**
  * @category Tasks
  */
-export type { Task, TaskGraph } from './config/task-graph';
+export type { Task, TaskGraph, TaskGraphEdge } from './config/task-graph';
 /**
  * @category Tasks
  */

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

@@ -154,14 +154,14 @@ function getDepsOutputs(taskId, { projectGraph, nxJson }) {
 function collectUpstreamTaskIds(taskGraph, rootTaskId, transitive) {
     const direct = taskGraph.dependencies[rootTaskId] ?? [];
     if (!transitive)
-        return [...direct];
+        return direct.map((dep) => dep.id);
     const collected = new Set();
     const walk = (id) => {
         for (const dep of taskGraph.dependencies[id] ?? []) {
-            if (collected.has(dep))
+            if (collected.has(dep.id))
                 continue;
-            collected.add(dep);
-            walk(dep);
+            collected.add(dep.id);
+            walk(dep.id);
         }
     };
     walk(rootTaskId);

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

@@ -98,7 +98,9 @@ function taskGraphFingerprint(taskGraph, ultracacheConfigurations) {
     ];
     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(','), (taskGraph.continuousDependenciesWithoutInputs?.[id] ?? []).join(','));
+        parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).map((edge) => edge.id).join(','), (taskGraph.continuousDependencies[id] ?? [])
+            .map((edge) => JSON.stringify([edge.id, edge.inputs === false]))
+            .join(','));
     }
     return (0, native_1.hashArray)(parts);
 }

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

@@ -32,7 +32,7 @@ export declare class ExternalObject<T> {
   }
 }
 export declare class AppLifeCycle {
-  constructor(tasks: Array<Task>, initiatingTasks: Array<string>, runMode: RunMode, pinnedTasks: Array<string>, tuiCliArgs: TuiCliArgs, tuiConfig: TuiConfig, titleText: string, workspaceRoot: string, taskGraph: TaskGraph, isCloudEnabled?: boolean | undefined | null)
+  constructor(tasks: Array<Task>, initiatingTasks: Array<string>, runMode: RunMode, pinnedTasks: Array<string>, tuiCliArgs: TuiCliArgs, tuiConfig: TuiConfig, titleText: string, workspaceRoot: string, taskGraph: TaskGraph, readyDependencies: Record<string, Array<string>>, isCloudEnabled?: boolean | undefined | null)
   startCommand(threadCount?: number | undefined | null): void
   scheduleTask(task: Task): void
   startTasks(tasks: Array<Task>, metadata: object): void
@@ -44,6 +44,7 @@ export declare class AppLifeCycle {
   registerRunningTaskWithEmptyParser(taskId: string): void
   appendTaskOutput(taskId: string, output: string, isPtyOutput: boolean): void
   setTaskStatus(taskId: string, status: TaskStatus): void
+  setTaskReadiness(taskId: string, readiness: TaskReadiness): void
   setTaskTiming(taskId: string, startTime: number, endTime: number): void
   registerForcedShutdownCallback(forcedShutdownCallback: (() => unknown)): void
   __setCloudMessage(message: string): Promise<void>
@@ -98,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.
    */
@@ -127,6 +129,15 @@ export declare class ImportResult {
   staticImportExpressions: Array<string>
 }
 
+/**
+ * Done once every pattern has appeared in the fed output, in any order, even
+ * split across chunks or interleaved with terminal control sequences.
+ */
+export declare class LogMatcher {
+  constructor(patterns: Array<string>)
+  feed(chunk: string): boolean
+}
+
 export declare class NxCache {
   cacheDirectory: string
   constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
@@ -232,15 +243,33 @@ export declare class ProcessMetricsCollector {
   subscribe(callback: (err: Error | null, event: MetricsUpdate) => void): void
 }
 
+/**
+ * Retries a probe until it passes, the timeout elapses or `cancel` is called.
+ * A failing attempt is never an error.
+ */
+export declare class ReadinessProbe {
+  constructor(config: ReadinessProbeConfig, cwd: string)
+  /** False once the timeout elapses or `cancel` is called. */
+  wait(): Promise<boolean>
+  cancel(): void
+}
+
 export declare class RunningTasksService {
   constructor(db: ExternalObject<NxDbConnection>)
   getRunningTasks(ids: Array<string>): Array<string>
   addRunningTask(taskId: string): void
   /**
-   * Release this process's claim on a task. A row another process has since
-   * taken over is left in place.
+   * Release this process's claim on a task and its readiness. A row another
+   * process has since taken over is left in place.
    */
   removeRunningTask(taskId: string): void
+  /**
+   * No-op unless this process holds the task's claim, so a late or displaced
+   * probe result cannot overwrite the current owner's verdict.
+   */
+  setTaskReadiness(taskId: string, status: TaskReadiness): void
+  /** `None` when the task is not running. */
+  getTaskReadiness(taskId: string): TaskReadiness | null
 }
 
 export declare class RustPseudoTerminal {
@@ -704,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>
 
@@ -751,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>
@@ -909,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>
@@ -950,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
 }
 
 /**
@@ -1116,6 +1168,16 @@ export interface ProjectGraph {
   externalNodes: Record<string, ExternalNode>
 }
 
+/** Exactly one of `url`, `port` or `command` is set. `interval` absent means backoff. */
+export interface ReadinessProbeConfig {
+  url?: string
+  port?: number
+  host?: string
+  command?: string
+  timeout: number
+  interval?: number
+}
+
 export declare function remove(src: string): void
 
 /**
@@ -1287,14 +1349,19 @@ export interface TaskGraph {
   roots: Array<string>
   /** Map of Task IDs to Tasks */
   tasks: Record<string, Task>
-  /** Map of Task IDs to IDs of tasks which the task depends on */
-  dependencies: Record<string, Array<string>>
-  continuousDependencies: Record<string, Array<string>>
-  /**
-   * The subset of `continuous_dependencies` from `dependsOn` entries with
-   * `inputs: false`: still run, but their inputs are not hashed into the task.
-   */
-  continuousDependenciesWithoutInputs?: Record<string, Array<string>>
+  /** Map of Task IDs to the edges to tasks which the task depends on */
+  dependencies: Record<string, Array<TaskGraphEdge>>
+  continuousDependencies: Record<string, Array<TaskGraphEdge>>
+}
+
+/** An edge from a task to one of the tasks it depends on */
+export interface TaskGraphEdge {
+  /** ID of the task depended on */
+  id: string
+  /** What the dependent waits for on a continuous dependency. Defaults to `started`. */
+  waitFor?: 'started' | 'ready'
+  /** `false` on a continuous dependency whose inputs the dependent does not hash */
+  inputs?: false
 }
 
 /** Details about the composition of a task's hash */
@@ -1339,6 +1406,12 @@ export interface TaskOutputs {
   files?: Array<OutputFile>
 }
 
+export declare const enum TaskReadiness {
+  Pending = 0,
+  Ready = 1,
+  Failed = 2
+}
+
 /**
  * The result of a completed Task.
  *
@@ -1386,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/native/native-bindings.js

@@ -584,11 +584,13 @@ module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
 module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
+module.exports.LogMatcher = nativeBinding.LogMatcher
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
 module.exports.NxPluginCapabilities = nativeBinding.NxPluginCapabilities
 module.exports.NxTaskHistory = nativeBinding.NxTaskHistory
 module.exports.ProcessMetricsCollector = nativeBinding.ProcessMetricsCollector
+module.exports.ReadinessProbe = nativeBinding.ReadinessProbe
 module.exports.RunningTasksService = nativeBinding.RunningTasksService
 module.exports.RustPseudoTerminal = nativeBinding.RustPseudoTerminal
 module.exports.TaskDetails = nativeBinding.TaskDetails
@@ -649,6 +651,7 @@ module.exports.restoreTerminal = nativeBinding.restoreTerminal
 module.exports.RunMode = nativeBinding.RunMode
 module.exports.SupportedEditor = nativeBinding.SupportedEditor
 module.exports.sweepBatchOutputs = nativeBinding.sweepBatchOutputs
+module.exports.TaskReadiness = nativeBinding.TaskReadiness
 module.exports.TaskStatus = nativeBinding.TaskStatus
 module.exports.testOnlyTransferFileMap = nativeBinding.testOnlyTransferFileMap
 module.exports.trackEvent = nativeBinding.trackEvent

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/create-task-graph.d.ts

@@ -1,5 +1,5 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { Task, TaskGraph } from '../config/task-graph';
+import { Task, TaskGraph, TaskGraphEdge } from '../config/task-graph';
 import { TargetDependencies } from '../config/nx-json';
 /**
  * For each task, the overrides every `dependsOn` edge into it would give it,
@@ -20,13 +20,11 @@ export declare class ProcessTasks {
         [id: string]: Task;
     };
     readonly dependencies: {
-        [k: string]: string[];
+        [k: string]: TaskGraphEdge[];
     };
     readonly continuousDependencies: {
-        [k: string]: string[];
+        [k: string]: TaskGraphEdge[];
     };
-    private readonly continuousEdgesWithoutInputs;
-    private readonly continuousEdgesWithInputs;
     readonly dependencyOverrides: DependencyOverrides;
     private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph, recordDependencyOverrides?: boolean);
@@ -36,13 +34,6 @@ export declare class ProcessTasks {
     private processTasksForSingleProject;
     private processTasksForDependencies;
     private addContinuousEdge;
-    /**
-     * Continuous edges every `dependsOn` path into which has `inputs: false`.
-     * Undefined when there are none, so graphs without the option are unchanged.
-     */
-    continuousDependenciesWithoutInputs(): {
-        [k: string]: string[];
-    } | undefined;
     private recordEdge;
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
@@ -64,11 +55,11 @@ export declare function filterTaskGraphToSelection(projectGraph: ProjectGraph, t
  * It will manipulate the dependencies object in place
  */
 export declare function filterDummyTasks(dependencies: {
-    [k: string]: string[];
+    [k: string]: TaskGraphEdge[];
 }): void;
 /**
  * this function is used to get the non dummy dependencies of a task recursively
  */
-export declare function getNonDummyDeps(currentTask: string, dependencies: {
-    [k: string]: string[];
-}, cycles?: Set<string>, seen?: Set<string>): string[];
+export declare function getNonDummyDeps(currentEdge: TaskGraphEdge, dependencies: {
+    [k: string]: TaskGraphEdge[];
+}, cycles?: Set<string>, seen?: Set<string>): TaskGraphEdge[];

package/dist/src/tasks-runner/create-task-graph.js

@@ -20,11 +20,6 @@ class ProcessTasks {
         this.tasks = {};
         this.dependencies = {};
         this.continuousDependencies = {};
-        // `from\0to` continuous edges by whether their `dependsOn` entry has
-        // `inputs: false`. Keyed from the creator's target, like `recordEdge`, so
-        // an edge through a dummy task names the real task.
-        this.continuousEdgesWithoutInputs = new Set();
-        this.continuousEdgesWithInputs = new Set();
         this.dependencyOverrides = {};
         const allTargetNames = new Set();
         for (const projectName in projectGraph.nodes) {
@@ -64,28 +59,14 @@ class ProcessTasks {
                 }
             }
             for (let d of Object.keys(this.dependencies)) {
-                this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
+                this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd.id]);
             }
             for (let d of Object.keys(this.continuousDependencies)) {
-                this.continuousDependencies[d] = this.continuousDependencies[d].filter((dd) => !!initialTasks[dd]);
+                this.continuousDependencies[d] = this.continuousDependencies[d].filter((dd) => !!initialTasks[dd.id]);
             }
         }
         filterDummyTasks(this.dependencies);
-        for (const taskId of Object.keys(this.dependencies)) {
-            if (this.dependencies[taskId].length > 0) {
-                this.dependencies[taskId] = [
-                    ...new Set(this.dependencies[taskId].filter((d) => d !== taskId)).values(),
-                ];
-            }
-        }
         filterDummyTasks(this.continuousDependencies);
-        for (const taskId of Object.keys(this.continuousDependencies)) {
-            if (this.continuousDependencies[taskId].length > 0) {
-                this.continuousDependencies[taskId] = [
-                    ...new Set(this.continuousDependencies[taskId].filter((d) => d !== taskId)).values(),
-                ];
-            }
-        }
         return Object.keys(this.tasks).filter((d) => this.dependencies[d].length === 0 &&
             this.continuousDependencies[d].length === 0);
     }
@@ -140,7 +121,7 @@ class ProcessTasks {
                     this.addContinuousEdge(task, selfTaskId, dependencyConfig);
                 }
                 else {
-                    this.dependencies[task.id].push(selfTaskId);
+                    this.dependencies[task.id].push({ id: selfTaskId });
                 }
             }
         }
@@ -164,7 +145,7 @@ class ProcessTasks {
                         this.addContinuousEdge(task, depTargetId, dependencyConfig);
                     }
                     else {
-                        this.dependencies[task.id].push(depTargetId);
+                        this.dependencies[task.id].push({ id: depTargetId });
                     }
                 }
                 if (!this.tasks[depTargetId]) {
@@ -182,8 +163,8 @@ class ProcessTasks {
                     '__' +
                     dependencyConfig.target +
                     DUMMY_TASK_TARGET, undefined);
-                this.dependencies[task.id].push(dummyId);
-                this.continuousDependencies[task.id].push(dummyId);
+                this.dependencies[task.id].push({ id: dummyId });
+                this.continuousDependencies[task.id].push({ id: dummyId });
                 this.dependencies[dummyId] ??= [];
                 this.continuousDependencies[dummyId] ??= [];
                 const noopTask = this.createDummyTask(dummyId, task);
@@ -192,30 +173,7 @@ class ProcessTasks {
         }
     }
     addContinuousEdge(task, dependencyId, dependencyConfig) {
-        this.continuousDependencies[task.id].push(dependencyId);
-        const { project, target, configuration } = task.target;
-        const edge = `${(0, utils_1.createTaskId)(project, target, configuration)}\0${dependencyId}`;
-        (dependencyConfig.inputs === false
-            ? this.continuousEdgesWithoutInputs
-            : this.continuousEdgesWithInputs).add(edge);
-    }
-    /**
-     * Continuous edges every `dependsOn` path into which has `inputs: false`.
-     * Undefined when there are none, so graphs without the option are unchanged.
-     */
-    continuousDependenciesWithoutInputs() {
-        let without;
-        for (const [taskId, deps] of Object.entries(this.continuousDependencies)) {
-            const excluded = deps.filter((dep) => {
-                const edge = `${taskId}\0${dep}`;
-                return (this.continuousEdgesWithoutInputs.has(edge) &&
-                    !this.continuousEdgesWithInputs.has(edge));
-            });
-            if (excluded.length > 0) {
-                (without ??= {})[taskId] = excluded;
-            }
-        }
-        return without;
+        this.continuousDependencies[task.id].push(continuousEdge(dependencyId, dependencyConfig));
     }
     recordEdge(task, dependencyId, overrides) {
         if (!this.recordDependencyOverrides) {
@@ -307,15 +265,11 @@ function filterTaskGraphToSelection(projectGraph, taskGraph, dependencyOverrides
 }
 function buildTaskGraph(p, projectNames, targets, configuration, overrides, excludeTaskDependencies) {
     const roots = p.processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies);
-    const continuousDependenciesWithoutInputs = p.continuousDependenciesWithoutInputs();
     return {
         roots,
         tasks: p.tasks,
         dependencies: p.dependencies,
         continuousDependencies: p.continuousDependencies,
-        ...(continuousDependenciesWithoutInputs
-            ? { continuousDependenciesWithoutInputs }
-            : {}),
     };
 }
 function interpolateOverrides(args, projectName, project) {
@@ -333,6 +287,37 @@ function interpolateOverrides(args, projectName, project) {
     });
     return interpolatedArgs;
 }
+function continuousEdge(id, dependencyConfig) {
+    const edge = { id };
+    if (dependencyConfig.waitFor === 'ready') {
+        edge.waitFor = 'ready';
+    }
+    if (dependencyConfig.inputs === false) {
+        edge.inputs = false;
+    }
+    return edge;
+}
+// A task reached by several edges waits for ready when any of them does, and
+// keeps its inputs unless all of them opt out
+function mergeEdges(edges) {
+    const byId = new Map();
+    for (const edge of edges) {
+        const seen = byId.get(edge.id);
+        if (!seen) {
+            byId.set(edge.id, edge);
+            continue;
+        }
+        const merged = { id: edge.id };
+        if (seen.waitFor === 'ready' || edge.waitFor === 'ready') {
+            merged.waitFor = 'ready';
+        }
+        if (seen.inputs === false && edge.inputs === false) {
+            merged.inputs = false;
+        }
+        byId.set(edge.id, merged);
+    }
+    return [...byId.values()];
+}
 /**
  * This function is used to filter out the dummy tasks from the dependencies
  * It will manipulate the dependencies object in place
@@ -345,7 +330,7 @@ function filterDummyTasks(dependencies) {
             for (const dep of deps) {
                 normalizedDeps.push(...getNonDummyDeps(dep, dependencies, cycles, new Set([key])));
             }
-            dependencies[key] = normalizedDeps;
+            dependencies[key] = mergeEdges(normalizedDeps);
         }
     }
     for (const key of Object.keys(dependencies)) {
@@ -357,12 +342,13 @@ function filterDummyTasks(dependencies) {
 /**
  * this function is used to get the non dummy dependencies of a task recursively
  */
-function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
+function getNonDummyDeps(currentEdge, dependencies, cycles, seen = new Set()) {
+    const currentTask = currentEdge.id;
     if (seen.has(currentTask)) {
         return [];
     }
-    seen.add(currentTask);
     if (currentTask.endsWith(DUMMY_TASK_TARGET)) {
+        seen.add(currentTask);
         if (cycles?.has(currentTask)) {
             return [];
         }
@@ -374,7 +360,7 @@ function getNonDummyDeps(currentTask, dependencies, cycles, seen = new Set()) {
         return deps.flatMap((dep) => getNonDummyDeps(dep, dependencies, cycles, seen));
     }
     else {
-        return [currentTask];
+        return [currentEdge];
     }
 }
 function createTaskOverrides(dependencyConfig, cliOverrides, sourceTask, projectGraph) {

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;