@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

package/dist/src/project-graph/plugins/loaded-nx-plugin.js

@@ -32,17 +32,13 @@ class LoadedNxPlugin {
                 },
             ];
         }
-        /**
-         * Wraps the plugin-provided createNodes function to provide performance
-         * measurement and error handling.
-         */
         if (this.createNodes) {
             const inner = this.createNodes[1];
             this.createNodes[1] = async (...args) => {
                 performance.mark(`${plugin.name}:createNodes - start`);
                 let projectCount = 0;
                 try {
-                    const result = await inner(...args);
+                    const result = (await inner(...args)).map(([pluginName, file, r]) => [pluginName, file, withoutUndefinedValues(r)]);
                     for (const [, , r] of result) {
                         projectCount += Object.keys(r.projects ?? {}).length;
                     }
@@ -50,7 +46,15 @@ class LoadedNxPlugin {
                 }
                 catch (e) {
                     if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
-                        throw e;
+                        const partialResults = e.partialResults.map(([file, r]) => [file, withoutUndefinedValues(r)]);
+                        if (partialResults.every(([, r], i) => r === e.partialResults[i][1])) {
+                            throw e;
+                        }
+                        // Fresh tuples, as the constructor coerces each error in place.
+                        throw new error_types_1.AggregateCreateNodesError(e.errors.map(([file, error]) => [
+                            file,
+                            error,
+                        ]), partialResults);
                     }
                     // The underlying plugin errored out. We can't know any partial results.
                     throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
@@ -115,3 +119,42 @@ class LoadedNxPlugin {
     }
 }
 exports.LoadedNxPlugin = LoadedNxPlugin;
+/**
+ * Drops `undefined` values (`null` in arrays) like the default JSON transport,
+ * so results from in-process plugins or the v8 serializer can't override an
+ * earlier plugin's value with `undefined`. Copies what it changes instead of
+ * writing to plugin-owned objects.
+ */
+function withoutUndefinedValues(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        let copy;
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            const normalized = item === undefined ? null : withoutUndefinedValues(item);
+            if (!copy && normalized !== item) {
+                copy = value.slice(0, i);
+            }
+            copy?.push(normalized);
+        }
+        return (copy ?? value);
+    }
+    const record = value;
+    const keys = Object.keys(record);
+    let entries;
+    for (let i = 0; i < keys.length; i++) {
+        const item = record[keys[i]];
+        const normalized = item === undefined ? undefined : withoutUndefinedValues(item);
+        if (!entries && (item === undefined || normalized !== item)) {
+            entries = keys.slice(0, i).map((key) => [key, record[key]]);
+        }
+        if (entries && normalized !== undefined) {
+            entries.push([keys[i], normalized]);
+        }
+    }
+    // `Object.fromEntries` defines own properties, so a `__proto__` key stays
+    // a key instead of setting the copy's prototype.
+    return (entries ? Object.fromEntries(entries) : value);
+}

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

@@ -141,7 +141,7 @@ function mergeConfigurationValue(newConfig, baseConfig, projectConfigSourceMap,
 }
 // `ultracache` keeps replace-unless-`'...'` semantics at the object level, but its
 // values still have to be merged per key: neither the wholesale replace nor
-// `mergeObjectWithSpread` recurses, so an `ignoredReads: ['...', 'tmp/**']`
+// `mergeObjectWithSpread` recurses, so an `ignoreReads: ['...', 'tmp/**']`
 // would otherwise reach the task graph with `'...'` intact — a glob matching
 // nothing, silently dropping the inherited patterns.
 function mergeUltracache(newUltracache, baseUltracache, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {

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

@@ -5,8 +5,6 @@ exports.normalizeTarget = normalizeTarget;
 exports.validateAndNormalizeProjectRootMap = validateAndNormalizeProjectRootMap;
 const executor_utils_1 = require("../../../command-line/run/executor-utils");
 const fileutils_1 = require("../../../utils/fileutils");
-const long_running_target_1 = require("../../../utils/long-running-target");
-const output_1 = require("../../../utils/output");
 const to_project_name_1 = require("../../../config/to-project-name");
 const error_types_1 = require("../../error-types");
 const target_merging_1 = require("./target-merging");
@@ -69,114 +67,6 @@ function normalizeTarget(target, project, workspaceRoot, projectsMap, errorMsgKe
     }
     return target;
 }
-// TODO(v24): remove the legacy target-name cache fallback and its warning.
-// Removal needs a second mechanism for plugin-inferred targets, which the
-// accompanying migration cannot reach.
-/**
- * Whether `target` is cacheable only by way of the legacy name-based fallback:
- * the exact target-name key of `targetDefaults` declares `cache: true`, but an
- * executor key won target-default resolution instead, so the merged target never
- * received it.
- *
- * A `true` result means the user's `cache: true` silently lost, so this doubles
- * as the condition for warning them that the name key is being shadowed.
- */
-function isLegacyCachedTarget(targetName, targetDefaults, target) {
-    // Resolution already decided `cache`, so the name key isn't shadowed.
-    if (target.cache !== undefined) {
-        return false;
-    }
-    if (isLongRunningTarget(targetName, target)) {
-        return false;
-    }
-    // Restricted to shadowing, which is narrower than what pre-23 restored: that
-    // derivation matched on target name alone, so a name key dropped as
-    // incompatible (its entry declared a foreign executor) was cacheable too.
-    // Restoring that as well would mean writing `cache` with no key to name in
-    // the warning, and no migration able to retire it. Deliberately not covered.
-    if (!findShadowingTargetDefaultKey(targetDefaults, target)) {
-        return false;
-    }
-    return declaresCacheTrue(targetDefaults?.[targetName]);
-}
-/**
- * Whether the name key declares `cache: true` on an entry that always applies.
- *
- * Filters are deliberately not evaluated. They cannot express a pre-23 config
- * (the filtered array shape postdates the behavior being restored), and a
- * filtered entry declaring `cache` may or may not apply to this project — so
- * rather than guess, a filtered `cache` declares the value unknowable and
- * nothing is restored. Among unfiltered entries the last wins, matching the
- * in-key merge order.
- */
-function declaresCacheTrue(value) {
-    if (!value) {
-        return false;
-    }
-    const entries = Array.isArray(value) ? value : [value];
-    let declared;
-    for (const entry of entries) {
-        // `nx.json` is hand-edited; a null or scalar entry would throw here.
-        if (!entry || typeof entry !== 'object')
-            continue;
-        if (entry.cache === undefined)
-            continue;
-        if (entry.filter)
-            return false;
-        declared = entry.cache;
-    }
-    return declared === true;
-}
-/**
- * The normalization-time half of the pre-23 `longRunningTask` guard, which kept
- * `cacheableOperations` from ever making these cacheable. Its remaining clause
- * — `task.overrides['watch']` — is a runtime invocation override with no target
- * equivalent, so it has no counterpart here.
- */
-function isLongRunningTarget(targetName, target) {
-    return !!target.continuous || (0, long_running_target_1.isLongRunningTargetName)(targetName);
-}
-/**
- * The `targetDefaults` key that beat the target-name key for `target`. Only an
- * executor key can: key precedence puts the exact target name ahead of every
- * glob, so nothing else outranks it. Undefined when the name key lost for
- * another reason (e.g. its entry declared a foreign executor and was dropped as
- * incompatible) — see {@link isLegacyCachedTarget} for why that case is left
- * alone even though pre-23 restored it.
- *
- * `hasOwnProperty` rather than a lookup: an executor named `__proto__` resolves
- * through the prototype chain to a truthy object, which would report a key the
- * user never wrote.
- */
-function findShadowingTargetDefaultKey(targetDefaults, target) {
-    return target.executor &&
-        targetDefaults &&
-        Object.prototype.hasOwnProperty.call(targetDefaults, target.executor)
-        ? target.executor
-        : undefined;
-}
-/**
- * Emits a single grouped warning for every (shadowing key, target-name key)
- * pair that relied on the deprecated fallback. Grouping matters because the
- * same pair recurs in every affected project — a per-target warning would
- * print hundreds of identical lines in a large workspace.
- */
-function warnAboutLegacyCachedTargets(legacyCacheReads) {
-    if (legacyCacheReads.size === 0) {
-        return;
-    }
-    const bodyLines = [];
-    for (const [shadowingKey, targetKeys] of legacyCacheReads) {
-        for (const targetKey of targetKeys) {
-            bodyLines.push(`  - "${shadowingKey}" does not set "cache", so it was read from "${targetKey}"`);
-        }
-    }
-    bodyLines.push('', 'An executor key applies to every target that resolves through it, so exclude any continuous target before setting "cache" on one — a target that is both cacheable and continuous is rejected.', 'Target defaults resolve to a single key rather than merging, so an executor key hides the target name key entirely.', 'Set "cache" on the executor key to keep these targets cacheable — reading it from the target name key is deprecated and will be removed in Nx 24.');
-    output_1.output.warn({
-        title: 'Some targets are only cacheable through a deprecated fallback.',
-        bodyLines,
-    });
-}
 /**
  * Nothing downstream rejects a key it does not know — the Rust hasher drops it,
  * the Cloud runner reads only the keys it reads, and the Kotlin API decodes with
@@ -186,8 +76,9 @@ function warnAboutLegacyCachedTargets(legacyCacheReads) {
  */
 const KNOWN_ULTRACACHE_KEYS = new Set([
     'mode',
-    'ignoredReads',
-    'ignoredWrites',
+    'collectStats',
+    'ignoreReads',
+    'ignoreWrites',
     utils_1.NX_SPREAD_TOKEN,
 ]);
 const ULTRACACHE_MODES = ['on', 'warn', 'error', 'off'];
@@ -233,7 +124,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", "ignoreReads" and "ignoreWrites".`);
         }
     }
     if (ultracache.mode !== undefined &&
@@ -243,7 +134,11 @@ function validateTargetUltracache(ultracache, projectName, projectRoot, targetNa
             ? `"${ultracache.mode}"`
             : describeUltracacheValue(ultracache.mode)}.`);
     }
-    for (const key of ['ignoredReads', 'ignoredWrites']) {
+    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 ['ignoreReads', 'ignoreWrites']) {
         const value = ultracache[key];
         if (value === undefined)
             continue;
@@ -258,30 +153,16 @@ function validateTargetUltracache(ultracache, projectName, projectRoot, targetNa
     }
     return errors;
 }
-function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
+function normalizeTargets(project, sourceMaps, workspaceRoot, 
 /**
  * Project configurations keyed by project name
  */
-projects, 
-/**
- * Shadowing `targetDefaults` key -> target name keys its `cache` was read
- * from. Accumulated across projects so the deprecation warns once per pair.
- */
-legacyCacheReads) {
+projects) {
     const targetErrorMessage = [];
     for (const targetName in project.targets) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
         const target = project.targets[targetName];
         targetErrorMessage.push(...validateTargetUltracache(target.ultracache, project.name ?? project.root, project.root, targetName, sourceMaps).map((message) => `- ${message}`));
-        const targetDefaults = nxJsonConfiguration.targetDefaults;
-        if (isLegacyCachedTarget(targetName, targetDefaults, target)) {
-            target.cache = true;
-            // Always defined: `isLegacyCachedTarget` returns false without it.
-            const shadowingKey = findShadowingTargetDefaultKey(targetDefaults, target);
-            const targetKeys = legacyCacheReads.get(shadowingKey) ?? new Set();
-            targetKeys.add(targetName);
-            legacyCacheReads.set(shadowingKey, targetKeys);
-        }
         if (
         // If the target has no executor or command, it doesn't do anything
         !target.executor &&
@@ -314,7 +195,6 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
     const conflicts = new Map();
     const projectRootsWithNoName = [];
     const validityErrors = [];
-    const legacyCacheReads = new Map();
     for (const root in projectRootMap) {
         const project = projectRootMap[root];
         // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
@@ -364,7 +244,7 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
     for (const root in projectRootMap) {
         const project = projectRootMap[root];
         try {
-            normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects, legacyCacheReads);
+            normalizeTargets(project, sourceMaps, workspaceRoot, projects);
         }
         catch (e) {
             if (e instanceof error_types_1.WorkspaceValidityError) {
@@ -375,7 +255,6 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
             }
         }
     }
-    warnAboutLegacyCachedTargets(legacyCacheReads);
     const errors = [];
     if (conflicts.size > 0) {
         // Only on the way to throwing, so a workspace without duplicates never

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

@@ -316,8 +316,8 @@ function createMatcher(patterns, emptyValue) {
     return (file) => compiled.some((m) => m.match(file));
 }
 function findMatchingConfigFiles(projectFiles, include, exclude) {
-    // projectFiles already comes from multiGlobWithWorkspaceContext for the
-    // plugin's createNodes pattern, so only include/exclude filters remain here.
+    // Callers pass files that already match the plugin's createNodes pattern,
+    // so only include/exclude filters remain here.
     // Empty include means include everything, empty exclude means exclude nothing
     const includes = createMatcher(include, true);
     const excludes = createMatcher(exclude, false);

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,10 +20,10 @@ export declare class ProcessTasks {
         [id: string]: Task;
     };
     readonly dependencies: {
-        [k: string]: string[];
+        [k: string]: TaskGraphEdge[];
     };
     readonly continuousDependencies: {
-        [k: string]: string[];
+        [k: string]: TaskGraphEdge[];
     };
     readonly dependencyOverrides: DependencyOverrides;
     private readonly allTargetNames;
@@ -33,6 +33,7 @@ export declare class ProcessTasks {
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
+    private addContinuousEdge;
     private recordEdge;
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Record<string, unknown>): Task;
@@ -54,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

@@ -59,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);
     }
@@ -132,10 +118,10 @@ class ProcessTasks {
             if (task.id !== selfTaskId) {
                 this.recordEdge(task, selfTaskId, taskOverrides);
                 if (this.tasks[selfTaskId].continuous) {
-                    this.continuousDependencies[task.id].push(selfTaskId);
+                    this.addContinuousEdge(task, selfTaskId, dependencyConfig);
                 }
                 else {
-                    this.dependencies[task.id].push(selfTaskId);
+                    this.dependencies[task.id].push({ id: selfTaskId });
                 }
             }
         }
@@ -156,10 +142,10 @@ class ProcessTasks {
                 if (task.id !== depTargetId) {
                     this.recordEdge(task, depTargetId, taskOverrides);
                     if (depTargetConfiguration.continuous) {
-                        this.continuousDependencies[task.id].push(depTargetId);
+                        this.addContinuousEdge(task, depTargetId, dependencyConfig);
                     }
                     else {
-                        this.dependencies[task.id].push(depTargetId);
+                        this.dependencies[task.id].push({ id: depTargetId });
                     }
                 }
                 if (!this.tasks[depTargetId]) {
@@ -177,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);
@@ -186,6 +172,9 @@ class ProcessTasks {
             }
         }
     }
+    addContinuousEdge(task, dependencyId, dependencyConfig) {
+        this.continuousDependencies[task.id].push(continuousEdge(dependencyId, dependencyConfig));
+    }
     recordEdge(task, dependencyId, overrides) {
         if (!this.recordDependencyOverrides) {
             return;
@@ -228,9 +217,11 @@ class ProcessTasks {
     resolveConfiguration(project, target, configuration) {
         const defaultConfiguration = project.data.targets?.[target]?.defaultConfiguration;
         configuration ??= defaultConfiguration;
-        return (0, project_graph_utils_1.projectHasTargetAndConfiguration)(project, target, configuration)
+        const resolved = (0, project_graph_utils_1.projectHasTargetAndConfiguration)(project, target, configuration)
             ? configuration
             : defaultConfiguration;
+        // `createTaskId` drops an empty configuration, so the target must too.
+        return resolved || undefined;
     }
 }
 exports.ProcessTasks = ProcessTasks;
@@ -298,6 +289,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
@@ -310,7 +332,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)) {
@@ -322,12 +344,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 [];
         }
@@ -339,7 +362,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;