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

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

@@ -24,7 +24,7 @@ export interface TaskSelection {
     ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
 }
 import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
-import { TasksRunner } from './tasks-runner';
+import { TasksRunner, TaskStatus } from './tasks-runner';
 /**
  * `targets` on whole projects, as `run-many` runs them: every task of the
  * projects' targets and what they depend on, with those tasks initiating.
@@ -43,6 +43,7 @@ export declare function runTasksForCommand(taskSelection: TaskSelection, current
     loadDotEnvFiles: boolean;
 }): Promise<{
     taskResults: TaskResults;
+    taskStatuses?: Record<string, TaskStatus>;
     completed: boolean;
 }>;
 export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
@@ -60,7 +61,10 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     /** Already loaded for this command; `undefined` loads it here. */
     ultracacheConfigurationOutcome?: UltracacheConfigurationOutcome | null;
 }): Promise<{
-    [id: string]: TaskResult;
+    taskResults: {
+        [id: string]: TaskResult;
+    };
+    taskStatuses?: Record<string, TaskStatus>;
 }>;
 export declare function constructLifeCycles(lifeCycle: LifeCycle, taskGraph: TaskGraph, nxJson?: NxJsonConfiguration, skipNxCache?: boolean): LifeCycle[];
 /**

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

@@ -50,9 +50,10 @@ const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle
 const task_telemetry_life_cycle_1 = require("./life-cycles/task-telemetry-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const tui_summary_life_cycle_1 = require("./life-cycles/tui-summary-life-cycle");
+const ready_when_1 = require("./readiness/ready-when");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
-const exit_codes_1 = require("../utils/exit-codes");
+const run_outcome_1 = require("./run-outcome");
 const handle_import_1 = require("../utils/handle-import");
 const pc = tslib_1.__importStar(require("picocolors"));
 const originalStdoutWrite = process.stdout.write.bind(process.stdout);
@@ -80,7 +81,7 @@ const SYNC_SKIPPED_FIX_MESSAGE_LINES = [
     '',
     'Run `nx sync` (no flags) later to sync the workspace.',
 ];
-async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
+async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, projectGraph, nxArgs, nxJson, overrides) {
     const overridesWithoutHidden = { ...overrides };
     delete overridesWithoutHidden['__overrides_unparsed__'];
     const isRunOne = initiatingProject != null;
@@ -133,7 +134,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
             pinnedTasks.push(mainTaskId);
             const mainContinuousDependencies = taskGraph.continuousDependencies[mainTaskId];
             if (mainContinuousDependencies.length > 0) {
-                pinnedTasks.push(mainContinuousDependencies[0]);
+                pinnedTasks.push(mainContinuousDependencies[0].id);
             }
             const [, target] = mainTaskId.split(':');
             titleText = `1 ${target} task`;
@@ -179,7 +180,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const lifeCycles = [tsLifeCycle];
         // Only run the TUI if there are tasks to run
         if (tasks.length > 0) {
-            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, ready_when_1.getReadyDependencies)(taskGraph, projectGraph), (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
             // The native endCommand renders the perf report in the exit popup; the runner
             // sources the payload and CompositeLifeCycle forwards it here.
             lifeCycles.unshift(appLifeCycle);
@@ -361,19 +362,14 @@ async function runCommand(taskSelection, currentProjectGraph, { nxJson }, nxArgs
             argv: process.argv,
         });
         const startTime = Date.now();
-        const { taskResults, completed } = await runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, {
+        const { taskResults, taskStatuses, completed } = await runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }, {
             ...nxArgs,
             skipNxCache: nxArgs.skipNxCache ||
                 process.env.NX_SKIP_NX_CACHE === 'true' ||
                 process.env.NX_DISABLE_NX_CACHE === 'true',
         }, overrides, initiatingProject, extraTargetDependencies, extraOptions);
         const endTime = Date.now();
-        const exitCode = !completed
-            ? (0, exit_codes_1.signalToCode)('SIGINT')
-            : Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' ||
-                taskResult.status === 'skipped')
-                ? 1
-                : 0;
+        const exitCode = (0, run_outcome_1.getRunExitCode)(completed, taskResults, taskStatuses);
         await (0, tasks_execution_hooks_1.runPostTasksExecution)({
             id,
             taskResults,
@@ -401,9 +397,9 @@ async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }
     const projectNames = [
         ...new Set(initiatingTasks.map((t) => t.target.project)),
     ];
-    const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides);
+    const { lifeCycle, renderIsDone, printSummary, restoreTerminal } = await getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, projectGraph, nxArgs, nxJson, overrides);
     try {
-        const taskResults = await invokeTasksRunner({
+        const { taskResults, taskStatuses } = await invokeTasksRunner({
             tasks,
             projectGraph,
             taskGraph,
@@ -426,7 +422,8 @@ async function runTasksForCommand(taskSelection, currentProjectGraph, { nxJson }
             logger_1.logger.log((0, nx_key_1.createNxKeyLicenseeInformation)(nxKey));
         return {
             taskResults,
-            completed: didCommandComplete(tasks, taskResults),
+            taskStatuses,
+            completed: (0, run_outcome_1.didCommandComplete)(tasks, taskResults, taskStatuses),
         };
     }
     catch (e) {
@@ -458,19 +455,6 @@ async function printConfigureAiAgentsDisclaimer() {
         // Silently ignore errors
     }
 }
-function didCommandComplete(tasks, taskResults) {
-    if (tasks.length === 0)
-        return true;
-    for (const task of tasks) {
-        if (!task.continuous) {
-            // Discrete task must have a result (was started and finished)
-            if (!taskResults[task.id])
-                return false;
-        }
-    }
-    // Any stopped task means the run was interrupted
-    return !Object.values(taskResults).some((r) => r.status === 'stopped');
-}
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, nxArgs, overrides, extraTargetDependencies, extraOptions, taskSelection) {
     let taskGraph = runValidations(projectGraph, taskSelection.taskGraph, nxArgs);
     if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {
@@ -719,7 +703,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([
@@ -790,13 +774,19 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
             },
         },
         daemon: client_1.daemonClient,
-        deferredTaskIds,
+        hashingDeferredTaskIds,
     });
     if (promiseOrObservable.subscribe) {
         promiseOrObservable = convertObservableToPromise(promiseOrObservable);
     }
-    await promiseOrObservable;
-    return taskResultsLifecycle.getTaskResults();
+    const taskStatuses = await promiseOrObservable;
+    return {
+        taskResults: taskResultsLifecycle.getTaskResults(),
+        // Custom runners are not guaranteed to resolve to a status map.
+        taskStatuses: taskStatuses && typeof taskStatuses === 'object'
+            ? taskStatuses
+            : undefined,
+    };
 }
 function constructLifeCycles(lifeCycle, taskGraph, nxJson, skipNxCache) {
     const lifeCycles = [];

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

@@ -0,0 +1,16 @@
+import type { Task } from '../config/task-graph';
+import type { TaskResults } from './life-cycle';
+import type { TaskStatus } from './tasks-runner';
+/**
+ * Whether the run got to the end, as opposed to being interrupted.
+ *
+ * A discrete task skipped because a dependency failed has no `TaskResult`,
+ * but the runner still settled it, so it must not make the run look
+ * interrupted.
+ */
+export declare function didCommandComplete(tasks: Task[], taskResults: TaskResults, taskStatuses?: Record<string, TaskStatus>): boolean;
+/**
+ * Exit code for a run: 130 (SIGINT) when it was interrupted, 1 when any task
+ * failed or was skipped, 0 otherwise.
+ */
+export declare function getRunExitCode(completed: boolean, taskResults: TaskResults, taskStatuses?: Record<string, TaskStatus>): number;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.didCommandComplete = didCommandComplete;
+exports.getRunExitCode = getRunExitCode;
+const exit_codes_1 = require("../utils/exit-codes");
+/**
+ * Whether the run got to the end, as opposed to being interrupted.
+ *
+ * A discrete task skipped because a dependency failed has no `TaskResult`,
+ * but the runner still settled it, so it must not make the run look
+ * interrupted.
+ */
+function didCommandComplete(tasks, taskResults, taskStatuses) {
+    if (tasks.length === 0)
+        return true;
+    for (const task of tasks) {
+        if (!task.continuous) {
+            // Discrete task must have been settled by the runner
+            if (!taskResults[task.id] && !taskStatuses?.[task.id])
+                return false;
+        }
+    }
+    // Any stopped task means the run was interrupted
+    return (!Object.values(taskResults).some((r) => r.status === 'stopped') &&
+        !Object.values(taskStatuses ?? {}).some((s) => s === 'stopped'));
+}
+/**
+ * Exit code for a run: 130 (SIGINT) when it was interrupted, 1 when any task
+ * failed or was skipped, 0 otherwise.
+ */
+function getRunExitCode(completed, taskResults, taskStatuses) {
+    if (!completed)
+        return (0, exit_codes_1.signalToCode)('SIGINT');
+    const failedOrSkipped = (status) => status === 'failure' || status === 'skipped';
+    return Object.values(taskResults).some((r) => failedOrSkipped(r.status)) ||
+        Object.values(taskStatuses ?? {}).some(failedOrSkipped)
+        ? 1
+        : 0;
+}

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/running-tasks/node-child-process.js

@@ -14,6 +14,9 @@ class NodeChildProcessWithNonDirectOutput {
         this.terminalOutputChunks = [];
         this.exitCallbacks = [];
         this.outputCallbacks = [];
+        // Decode as a stream so a code point split across chunks stays intact
+        this.childProcess.stdout.setEncoding('utf8');
+        this.childProcess.stderr.setEncoding('utf8');
         if (streamOutput) {
             if (process.env.NX_PREFIX_OUTPUT === 'true') {
                 const color = (0, output_prefix_1.getColor)(prefix);
@@ -54,16 +57,14 @@ class NodeChildProcessWithNonDirectOutput {
                 process.send(message);
             }
         });
-        this.childProcess.stdout.on('data', (chunk) => {
-            const output = chunk.toString();
+        this.childProcess.stdout.on('data', (output) => {
             this.terminalOutputChunks.push(output);
             // Stream output to TUI via callbacks
             for (const cb of this.outputCallbacks) {
                 cb(output);
             }
         });
-        this.childProcess.stderr.on('data', (chunk) => {
-            const output = chunk.toString();
+        this.childProcess.stderr.on('data', (output) => {
             this.terminalOutputChunks.push(output);
             // Stream output to TUI via callbacks
             for (const cb of this.outputCallbacks) {

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

@@ -6,6 +6,6 @@ export declare abstract class RunningTask {
     }>;
     abstract onExit(cb: (code: number) => void): void;
     abstract kill(signal?: NodeJS.Signals): Promise<void> | void;
-    abstract onOutput?(cb: (output: string) => void): void;
+    abstract onOutput?(cb: (output: string, isCommandHeader?: boolean) => void): void;
     abstract send?(message: Serializable): void;
 }

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

@@ -37,6 +37,16 @@ export declare function getTaskSpecificEnv(task: Task, graph: ProjectGraph): Nod
  */
 export declare function getGraphTimeDotEnvForTask(projectRoot: string, target: string, configuration?: string, nonAtomizedTarget?: string, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;
+/**
+ * Pids of the nx processes this one is nested inside, outermost first. Empty
+ * for a root invocation.
+ */
+export declare function getInvocationAncestorPids(): number[];
+/**
+ * Pid of the outermost nx process in this tree, which is this process when it
+ * is the root.
+ */
+export declare function getInvocationRootPid(): number;
 /**
  * This function loads one or more .env files and expands the variables in them.
  * When multiple files are provided, all files are loaded first, then variable

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

@@ -5,9 +5,12 @@ exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
 exports.getTaskSpecificEnv = getTaskSpecificEnv;
 exports.getGraphTimeDotEnvForTask = getGraphTimeDotEnvForTask;
 exports.getEnvVariablesForTask = getEnvVariablesForTask;
+exports.getInvocationAncestorPids = getInvocationAncestorPids;
+exports.getInvocationRootPid = getInvocationRootPid;
 exports.loadAndExpandDotEnvFile = loadAndExpandDotEnvFile;
 exports.unloadDotEnvFile = unloadDotEnvFile;
 exports.getEnvFilesForTask = getEnvFilesForTask;
+const ready_signal_1 = require("./readiness/ready-signal");
 const dotenv_1 = require("dotenv");
 const dotenv_expand_1 = require("dotenv-expand");
 const node_path_1 = require("node:path");
@@ -39,6 +42,11 @@ function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
     };
     // NX_ORIGINAL_FORCE_COLOR is an internal signal and should not leak into child processes
     delete res.NX_ORIGINAL_FORCE_COLOR;
+    // The orchestrator sets these for the one task they are meant for, so an
+    // Nx run inside that task must not pass them on
+    delete res[ready_signal_1.READY_SIGNAL_SOCKET_ENV];
+    delete res[ready_signal_1.READY_SIGNAL_TASK_ENV];
+    delete res[ready_signal_1.READY_URL_ENV];
     return res;
 }
 // The orchestrator now calls this eagerly during the coordinator pre-hash
@@ -121,6 +129,11 @@ function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache,
     // NX_ORIGINAL_FORCE_COLOR is an internal signal used by getForceColorForChild()
     // and should not leak into child processes
     delete res.NX_ORIGINAL_FORCE_COLOR;
+    // The orchestrator sets these for the one task they are meant for, so an
+    // Nx run inside that task must not pass them on
+    delete res[ready_signal_1.READY_SIGNAL_SOCKET_ENV];
+    delete res[ready_signal_1.READY_SIGNAL_TASK_ENV];
+    delete res[ready_signal_1.READY_URL_ENV];
     return res;
 }
 function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
@@ -128,6 +141,10 @@ function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStder
         FORCE_COLOR: forceColor,
         NX_WORKSPACE_ROOT: workspace_root_1.workspaceRoot,
         NX_SKIP_NX_CACHE: skipNxCache ? 'true' : undefined,
+        // pids of the forked process's ancestor nx processes, outermost first.
+        // Only an ancestor re-invoking a task is a loop — sibling nx processes
+        // running the same task are legitimate.
+        NX_INVOCATION_ANCESTOR_PIDS: appendAncestorPid(process.env.NX_INVOCATION_ANCESTOR_PIDS),
     };
     if (outputPath) {
         env.NX_TERMINAL_OUTPUT_PATH = outputPath;
@@ -140,6 +157,26 @@ function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStder
     }
     return env;
 }
+function appendAncestorPid(inherited) {
+    return inherited ? `${inherited},${process.pid}` : String(process.pid);
+}
+/**
+ * Pids of the nx processes this one is nested inside, outermost first. Empty
+ * for a root invocation.
+ */
+function getInvocationAncestorPids() {
+    return (process.env.NX_INVOCATION_ANCESTOR_PIDS ?? '')
+        .split(',')
+        .map((pid) => Number(pid))
+        .filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+/**
+ * Pid of the outermost nx process in this tree, which is this process when it
+ * is the root.
+ */
+function getInvocationRootPid() {
+    return getInvocationAncestorPids()[0] ?? process.pid;
+}
 function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {
     const env = {
         NX_TASK_TARGET_PROJECT: task.target.project,
@@ -153,16 +190,11 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
     if (task.target.target === 'test') {
         env.NX_TERMINAL_CAPTURE_STDERR = 'true';
     }
-    // Pass the root Nx process PID to nested processes for DB-based loop detection.
-    // The root PID is used as a key in the task_invocations table to track which tasks
-    // have been invoked across nested Nx processes.
     return {
         ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
         ...env,
         // Ensure the TUI does not get spawned within the TUI if ever tasks invoke Nx again
         NX_TUI: 'false',
-        // tracks the root PID for child nx tasks, used to verify nx is infinitely recursing through the same tasks
-        NX_INVOCATION_ROOT_PID: process.env.NX_INVOCATION_ROOT_PID ?? String(process.pid),
     };
 }
 /**

package/dist/src/tasks-runner/task-graph-utils.d.ts

@@ -1,24 +1,26 @@
 import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
+import { TaskGraph, TaskGraphEdge } from '../config/task-graph';
+/** Task graph edges, or the project ids of the command graph. */
+type Edge = string | TaskGraphEdge;
 /**
  * This function finds a cycle in the graph.
  * @returns the first cycle found, or null if no cycle is found.
  */
 export declare function findCycle(graph: {
-    dependencies: Record<string, string[]>;
-    continuousDependencies?: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
+    continuousDependencies?: Record<string, Edge[]>;
 }): string[] | null;
 /**
  * This function finds all cycles in the graph.
  * @returns a list of unique task ids in all cycles found, or null if no cycle is found.
  */
 export declare function findCycles(graph: {
-    dependencies: Record<string, string[]>;
-    continuousDependencies?: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
+    continuousDependencies?: Record<string, Edge[]>;
 }): Set<string> | null;
 export declare function makeAcyclic(graph: {
     roots: string[];
-    dependencies: Record<string, string[]>;
+    dependencies: Record<string, Edge[]>;
 }): void;
 export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
 export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;
@@ -28,3 +30,4 @@ export declare function getLeafTasks(taskGraph: TaskGraph): Set<string>;
  * Considers both dependencies and continuousDependencies.
  */
 export declare function walkTaskGraph(taskGraph: TaskGraph, walkFn: (rootTaskIds: string[]) => Promise<void>): Promise<void>;
+export {};

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

@@ -8,6 +8,9 @@ exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotCont
 exports.getLeafTasks = getLeafTasks;
 exports.walkTaskGraph = walkTaskGraph;
 const output_1 = require("../utils/output");
+function edgeId(edge) {
+    return typeof edge === 'string' ? edge : edge.id;
+}
 function _findCycle(graph, id, visited, path) {
     if (visited[id])
         return null;
@@ -15,7 +18,7 @@ function _findCycle(graph, id, visited, path) {
     for (const d of [
         ...graph.dependencies[id],
         ...(graph.continuousDependencies?.[id] ?? []),
-    ]) {
+    ].map(edgeId)) {
         if (path.includes(d))
             return [...path, d];
         const cycle = _findCycle(graph, d, visited, [...path, d]);
@@ -64,13 +67,13 @@ function _makeAcyclic(graph, id, visited, path) {
     visited[id] = true;
     const deps = graph.dependencies[id];
     const continuousDeps = graph.continuousDependencies?.[id] ?? [];
-    for (const d of [...deps, ...continuousDeps]) {
+    for (const d of [...deps, ...continuousDeps].map(edgeId)) {
         if (path.includes(d)) {
-            const depsIdx = deps.indexOf(d);
+            const depsIdx = deps.findIndex((edge) => edgeId(edge) === d);
             if (depsIdx >= 0) {
                 deps.splice(depsIdx, 1);
             }
-            const continuousIdx = continuousDeps.indexOf(d);
+            const continuousIdx = continuousDeps.findIndex((edge) => edgeId(edge) === d);
             if (continuousIdx >= 0) {
                 continuousDeps.splice(continuousIdx, 1);
             }
@@ -131,7 +134,7 @@ function assertTaskGraphDoesNotContainInvalidTargets(taskGraph) {
             taskGraph.continuousDependencies[task.id].length > 0) {
             nonParallelTasksThatDependOnContinuousTasks.push(task);
         }
-        for (const dependency of taskGraph.continuousDependencies[task.id]) {
+        for (const { id: dependency } of taskGraph.continuousDependencies[task.id]) {
             if (taskGraph.tasks[dependency].parallelism === false) {
                 nonParallelContinuousTasksThatAreDependedOn.push(taskGraph.tasks[dependency]);
             }
@@ -148,7 +151,9 @@ class NonParallelTaskDependsOnContinuousTasksError extends Error {
     constructor(invalidTasks, taskGraph) {
         let message = 'The following tasks do not support parallelism but depend on continuous tasks:';
         for (const task of invalidTasks) {
-            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id].join(', ')}`;
+            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id]
+                .map((edge) => edge.id)
+                .join(', ')}`;
         }
         super(message);
         this.invalidTasks = invalidTasks;
@@ -159,7 +164,7 @@ class DependingOnNonParallelContinuousTaskError extends Error {
     constructor(invalidTasks, taskGraph) {
         let message = 'The following continuous tasks do not support parallelism but are depended on:';
         for (const task of invalidTasks) {
-            const dependents = Object.keys(taskGraph.continuousDependencies).filter((parentTaskId) => taskGraph.continuousDependencies[parentTaskId].includes(task.id));
+            const dependents = Object.keys(taskGraph.continuousDependencies).filter((parentTaskId) => taskGraph.continuousDependencies[parentTaskId].some((edge) => edge.id === task.id));
             message += `\n - ${task.id} <- ${dependents.join(', ')}`;
         }
         message +=
@@ -185,13 +190,13 @@ function reverseTaskGraph(taskGraph) {
         dependencies: Object.fromEntries(Object.entries(taskGraph.tasks).map(([taskId]) => [taskId, []])),
     };
     for (const [taskId, dependencies] of Object.entries(taskGraph.dependencies)) {
-        for (const dependency of dependencies) {
-            reversed.dependencies[dependency].push(taskId);
+        for (const { id: dependency } of dependencies) {
+            reversed.dependencies[dependency].push({ id: taskId });
         }
     }
     for (const [taskId, dependencies] of Object.entries(taskGraph.continuousDependencies)) {
-        for (const dependency of dependencies) {
-            reversed.dependencies[dependency].push(taskId);
+        for (const { id: dependency } of dependencies) {
+            reversed.dependencies[dependency].push({ id: taskId });
         }
     }
     return reversed;
@@ -213,7 +218,7 @@ async function walkTaskGraph(taskGraph, walkFn) {
         await walkFn(currentRoots);
         const nextRoots = [];
         for (const id of currentRoots) {
-            for (const depId of reversed.dependencies[id] ?? []) {
+            for (const { id: depId } of reversed.dependencies[id] ?? []) {
                 inDegree[depId]--;
                 if (inDegree[depId] === 0) {
                     nextRoots.push(depId);