nx 23.3.0 → 24.0.0-beta.1

package/dist/src/native/nx.wasi-browser.js

@@ -124,6 +124,7 @@ export const installNxConsole = __napiModule.exports.installNxConsole
 export const IS_WASM = __napiModule.exports.IS_WASM
 export const isAiAgent = __napiModule.exports.isAiAgent
 export const logDebug = __napiModule.exports.logDebug
+export const openUrl = __napiModule.exports.openUrl
 export const remove = __napiModule.exports.remove
 export const testOnlyTransferFileMap = __napiModule.exports.testOnlyTransferFileMap
 export const transferProjectGraph = __napiModule.exports.transferProjectGraph

package/dist/src/native/nx.wasi.cjs

@@ -154,6 +154,7 @@ module.exports.installNxConsole = __napiModule.exports.installNxConsole
 module.exports.IS_WASM = __napiModule.exports.IS_WASM
 module.exports.isAiAgent = __napiModule.exports.isAiAgent
 module.exports.logDebug = __napiModule.exports.logDebug
+module.exports.openUrl = __napiModule.exports.openUrl
 module.exports.remove = __napiModule.exports.remove
 module.exports.testOnlyTransferFileMap = __napiModule.exports.testOnlyTransferFileMap
 module.exports.transferProjectGraph = __napiModule.exports.transferProjectGraph

package/dist/src/nx-cloud/update-manager.d.ts

@@ -1,7 +1,12 @@
+import { HttpClient } from '../utils/http-client';
 import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
 import type { ReadUltracacheConfigurationsOptions, ReadUltracacheConfigurationsResult } from '../ultracache/fetch';
 import { TasksRunner } from '../tasks-runner/tasks-runner';
 import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
+interface CloudBundleInstall {
+    version: string;
+    fullPath: string;
+}
 export declare class NxCloudEnterpriseOutdatedError extends Error {
     constructor(url: string);
 }
@@ -24,3 +29,5 @@ export declare function verifyOrUpdateNxCloudClient(options?: {
     version: string;
 } | null>;
 export declare function getBundleInstallDefaultLocation(): string;
+export declare function downloadAndExtractClientBundle(httpClient: HttpClient, version: string, url: string): Promise<CloudBundleInstall>;
+export {};

package/dist/src/nx-cloud/update-manager.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NxCloudClientUnavailableError = exports.NxCloudEnterpriseOutdatedError = void 0;
 exports.verifyOrUpdateNxCloudClient = verifyOrUpdateNxCloudClient;
 exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
+exports.downloadAndExtractClientBundle = downloadAndExtractClientBundle;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const zlib_1 = require("zlib");
@@ -16,6 +17,7 @@ const tar = tslib_1.__importStar(require("tar-stream"));
 const cache_directory_1 = require("../utils/cache-directory");
 const is_ci_1 = require("../utils/is-ci");
 const crypto_1 = require("crypto");
+const native_1 = require("../native");
 const workspace_root_1 = require("../utils/workspace-root");
 class NxCloudEnterpriseOutdatedError extends Error {
     constructor(url) {
@@ -74,13 +76,13 @@ async function verifyOrUpdateNxCloudClient(options) {
         if (version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
             throw new NxCloudEnterpriseOutdatedError(apiUrl);
         }
-        const fullPath = await downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url);
-        (0, debug_logger_1.debugLog)('Done: ', fullPath);
-        const nxCloudClient = require(fullPath);
+        const installedBundle = await downloadAndExtractClientBundle(httpClient, version, url);
+        (0, debug_logger_1.debugLog)('Done: ', installedBundle.fullPath);
+        const nxCloudClient = require(installedBundle.fullPath);
         if (nxCloudClient.commands === undefined) {
             throw new NxCloudEnterpriseOutdatedError(apiUrl);
         }
-        return { version, nxCloudClient };
+        return { version: installedBundle.version, nxCloudClient };
     }
     if (currentBundle === null) {
         throw new NxCloudClientUnavailableError();
@@ -114,6 +116,25 @@ function getBundleInstallDefaultLocation() {
     return (0, path_1.join)((0, is_ci_1.isCI)() ? (0, cache_directory_1.cacheDirectoryForWorkspace)(workspace_root_1.workspaceRoot) : cache_directory_1.cacheDir, 'cloud');
 }
 const runnerBundleInstallDirectory = getBundleInstallDefaultLocation();
+// Control files live outside the install directory. Released nx versions load
+// any directory there as a bundle, so they would `require` a state directory
+// placed inside it.
+const stateDirectory = (0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx.json'))
+    ? (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'nx-cloud')
+    : `${runnerBundleInstallDirectory}-state`;
+function ensureStateDirectory() {
+    (0, fs_1.mkdirSync)(stateDirectory, { recursive: true });
+}
+const downloadLockFilePath = (0, path_1.join)(stateDirectory, 'download.lock');
+// The record lives beside the lockfile rather than inside it. Windows
+// byte-range locks are mandatory and handle-scoped, so writing to a file this
+// process holds an exclusive lock on fails with ERROR_LOCK_VIOLATION. It also
+// matches the convention elsewhere in nx: project-graph.lock and run.json.lock
+// are never written to.
+const downloadRecordFilePath = (0, path_1.join)(stateDirectory, 'download.record');
+// A version names a directory that is created and later deleted, so a value
+// from the server must not be able to escape the install directory.
+const VALID_BUNDLE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function getLatestInstalledRunnerBundle() {
     if (!(0, fs_1.existsSync)(runnerBundleInstallDirectory)) {
         (0, fs_1.mkdirSync)(runnerBundleInstallDirectory, { recursive: true });
@@ -121,7 +142,9 @@ function getLatestInstalledRunnerBundle() {
     try {
         const installedBundles = (0, fs_1.readdirSync)(runnerBundleInstallDirectory)
             .filter((potentialDirectory) => {
-            return (0, fs_1.statSync)((0, path_1.join)(runnerBundleInstallDirectory, potentialDirectory)).isDirectory();
+            // '.tmp-*' directories are in-progress or crashed downloads
+            return (!potentialDirectory.startsWith('.') &&
+                (0, fs_1.statSync)((0, path_1.join)(runnerBundleInstallDirectory, potentialDirectory)).isDirectory());
         })
             .map((fileOrDirectory) => ({
             version: fileOrDirectory,
@@ -131,7 +154,13 @@ function getLatestInstalledRunnerBundle() {
             // No installed bundles
             return null;
         }
-        return installedBundles[0];
+        // A contended install can leave several bundles on disk. The record names
+        // the directory an install last completed in, which is the one to run.
+        // Without a record the directory name is all there is to go on and is read
+        // as the version, which is right for a bundle an older nx installed and
+        // otherwise yields a version the server rejects, costing one more
+        // download.
+        return recordedBundle() ?? installedBundles[0];
     }
     catch (e) {
         console.log('Could not read runner bundle path:', e.message);
@@ -170,7 +199,7 @@ async function verifyCurrentBundle(httpClient, currentBundle) {
     });
 }
 function getLatestBundleVerificationTimestamp() {
-    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    const lockfilePath = (0, path_1.join)(stateDirectory, 'verify.lock');
     if ((0, fs_1.existsSync)(lockfilePath)) {
         const timestampAsString = (0, fs_1.readFileSync)(lockfilePath, 'utf-8');
         let timestampAsNumber;
@@ -185,7 +214,8 @@ function getLatestBundleVerificationTimestamp() {
     return null;
 }
 function writeBundleVerificationLock() {
-    const lockfilePath = (0, path_1.join)(runnerBundleInstallDirectory, 'verify.lock');
+    const lockfilePath = (0, path_1.join)(stateDirectory, 'verify.lock');
+    ensureStateDirectory();
     (0, fs_1.writeFileSync)(lockfilePath, new Date().getTime().toString(), 'utf-8');
 }
 function getBundleContentHash(bundle) {
@@ -211,7 +241,118 @@ function hashDirectory(dir) {
     const combinedHashes = hashes.sort().join('');
     return (0, crypto_1.createHash)('sha256').update(combinedHashes).digest('hex');
 }
-async function downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url) {
+async function downloadAndExtractClientBundle(httpClient, version, url) {
+    // Parallel nx processes race to install bundles, possibly at different
+    // versions. The first to take the lock downloads; the rest wait and adopt
+    // its bundle when an install completed during the wait at the version the
+    // server asked them for. Otherwise they download their own as a contended
+    // install, which publishes its own directory and skips cleanup, so the
+    // holder's bundle stays on disk for the process running from it - at the
+    // same version as well as a different one. The flock is released by the
+    // kernel if the holder dies, so no stale-lock cleanup is needed. Under WASM
+    // the lock is unavailable and downloads run unserialized.
+    if (!VALID_BUNDLE_VERSION.test(version)) {
+        throw new Error(`Invalid Nx Cloud client bundle version: ${version}`);
+    }
+    const recordBeforeContending = readDownloadRecord();
+    const lock = !native_1.IS_WASM ? new native_1.FileLock(downloadLockFilePath) : null;
+    let locked = lock?.locked;
+    let contended = false;
+    while (locked) {
+        (0, debug_logger_1.debugLog)('Another process is downloading the client bundle, waiting for it to complete');
+        await lock.wait();
+        // The holder may be running from a bundle whose record predates this call,
+        // so the wait alone makes the install contended.
+        contended = true;
+        const installedBundle = bundleInstalledSince(recordBeforeContending);
+        if (installedBundle) {
+            if (installedBundle.version === version) {
+                (0, debug_logger_1.debugLog)('Using client bundle downloaded by another process: ', installedBundle.version);
+                return installedBundle;
+            }
+            (0, debug_logger_1.debugLog)('Another process installed a different bundle: ', installedBundle.version);
+        }
+        // The other process failed or installed an older version, so this process
+        // still needs to download.
+        locked = lock.check();
+    }
+    lock?.lock();
+    try {
+        // A process that acquired the lock between the check above and lock() may
+        // have completed an install already.
+        const installedBundle = bundleInstalledSince(recordBeforeContending);
+        if (installedBundle) {
+            if (installedBundle.version === version) {
+                (0, debug_logger_1.debugLog)('Using client bundle downloaded by another process: ', installedBundle.version);
+                return installedBundle;
+            }
+            // A different version means that process is running from a bundle this
+            // one must not delete.
+            contended = true;
+            (0, debug_logger_1.debugLog)('Another process installed a different bundle: ', installedBundle.version);
+        }
+        const fullPath = await downloadAndExtractBundle(httpClient, version, url, contended);
+        return { version, fullPath };
+    }
+    finally {
+        lock?.unlock();
+    }
+}
+// Records "<serverVersion> <directoryName>", written only once an install has
+// COMPLETED. The directory is recorded separately because it cannot be derived
+// from the version - every install publishes its own (see
+// downloadAndExtractBundle), so several directories can carry the same
+// version. That also makes every record distinct, so a waiter can tell "an
+// install finished while I waited" from "this record is left over from a past
+// run" by comparing the record it read before contending. Timestamps cannot
+// answer that: filesystem mtime granularity is coarser than the race window.
+function readDownloadRecord() {
+    try {
+        return (0, fs_1.readFileSync)(downloadRecordFilePath, 'utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function writeDownloadRecord(version, directoryName) {
+    ensureStateDirectory();
+    (0, fs_1.writeFileSync)(downloadRecordFilePath, `${version} ${directoryName}`, 'utf-8');
+}
+/**
+ * The bundle the record names, if it is still on disk. A record whose second
+ * field does not name a live directory resolves to null and leaves selection
+ * on its fallback, which is what a one-field record or anything else
+ * unexpected in the file has to do.
+ */
+function recordedBundle() {
+    const [version, directoryName] = readDownloadRecord().split(' ');
+    if (!version ||
+        !directoryName ||
+        !VALID_BUNDLE_VERSION.test(version) ||
+        !VALID_BUNDLE_VERSION.test(directoryName)) {
+        return null;
+    }
+    const fullPath = (0, path_1.join)(runnerBundleInstallDirectory, directoryName);
+    return (0, fs_1.existsSync)(fullPath) ? { version, fullPath } : null;
+}
+/**
+ * The bundle an install completed during this call, or null. Requires the
+ * record to have changed since `recordBefore` was read: a directory existing
+ * proves only that some earlier run left one there, and an install
+ * interrupted on a released nx leaves exactly that.
+ */
+function bundleInstalledSince(recordBefore) {
+    return readDownloadRecord() === recordBefore ? null : recordedBundle();
+}
+async function downloadAndExtractBundle(httpClient, version, url, contended) {
+    // Every install publishes its own directory. Two processes can be asked for
+    // the same version while one of them is already running from a completed
+    // install of it, so replacing <installDir>/<version> in place would delete
+    // that bundle out from under it - and a holder loading its client in the gap
+    // fails with MODULE_NOT_FOUND, which drops the task runner to running
+    // without Nx Cloud. A directory nothing else has seen cannot be in use.
+    const bundleDirectoryName = `${version}-${(0, crypto_1.randomUUID)()}`;
+    const bundleExtractLocation = (0, path_1.join)(runnerBundleInstallDirectory, bundleDirectoryName);
     let resp;
     try {
         resp = await httpClient.get(url, {
@@ -222,53 +363,99 @@ async function downloadAndExtractClientBundle(httpClient, runnerBundleInstallDir
         console.error('Error while updating Nx Cloud client bundle');
         throw e;
     }
-    const bundleExtractLocation = (0, path_1.join)(runnerBundleInstallDirectory, version);
-    if (!(0, fs_1.existsSync)(bundleExtractLocation)) {
-        (0, fs_1.mkdirSync)(bundleExtractLocation);
-    }
-    return new Promise((res, rej) => {
-        const extract = tar.extract();
-        extract.on('entry', function (headers, stream, next) {
-            if (headers.type === 'directory') {
-                const directoryPath = (0, path_1.join)(bundleExtractLocation, headers.name);
-                if (!(0, fs_1.existsSync)(directoryPath)) {
-                    (0, fs_1.mkdirSync)(directoryPath, { recursive: true });
-                }
-                next();
-                stream.resume();
-            }
-            else if (headers.type === 'file') {
-                const outputFilePath = (0, path_1.join)(bundleExtractLocation, headers.name);
-                const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
-                // Surface disk errors through the pipeline instead of crashing
-                writeStream.on('error', (e) => extract.destroy(e));
-                stream.pipe(writeStream);
-                // Continue the tar stream after the write stream closes
-                writeStream.on('close', () => {
+    // Extract into a temp directory and rename into place afterwards, so a
+    // failed or interrupted download never leaves a partial bundle at the
+    // path other processes require it from.
+    const tempExtractLocation = (0, path_1.join)(runnerBundleInstallDirectory, `.tmp-${version}-${process.pid}`);
+    (0, fs_1.mkdirSync)(tempExtractLocation, { recursive: true });
+    try {
+        await new Promise((res, rej) => {
+            const extract = tar.extract();
+            extract.on('entry', function (headers, stream, next) {
+                if (headers.type === 'directory') {
+                    const directoryPath = (0, path_1.join)(tempExtractLocation, headers.name);
+                    if (!(0, fs_1.existsSync)(directoryPath)) {
+                        (0, fs_1.mkdirSync)(directoryPath, { recursive: true });
+                    }
                     next();
-                });
-                stream.resume();
-            }
-        });
-        extract.on('finish', function () {
-            removeOldClientBundles(version);
-            writeBundleVerificationLock();
-            res(bundleExtractLocation);
-        });
-        // pipeline propagates download/gunzip errors that .pipe() would leave
-        // uncaught
-        (0, stream_1.pipeline)(resp.data, (0, zlib_1.createGunzip)(), extract, (e) => {
-            if (e)
-                rej(e);
+                    stream.resume();
+                }
+                else if (headers.type === 'file') {
+                    const outputFilePath = (0, path_1.join)(tempExtractLocation, headers.name);
+                    const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
+                    // Surface disk errors through the pipeline instead of crashing
+                    writeStream.on('error', (e) => extract.destroy(e));
+                    stream.pipe(writeStream);
+                    // Continue the tar stream after the write stream closes
+                    writeStream.on('close', () => {
+                        next();
+                    });
+                    stream.resume();
+                }
+                else {
+                    // Skipping the entry would publish an incomplete bundle.
+                    extract.destroy(new Error(`Unsupported ${headers.type} entry in Nx Cloud client bundle: ${headers.name}`));
+                }
+            });
+            extract.on('finish', function () {
+                res();
+            });
+            // pipeline propagates download/gunzip errors that .pipe() would leave
+            // uncaught
+            (0, stream_1.pipeline)(resp.data, (0, zlib_1.createGunzip)(), extract, (e) => {
+                if (e)
+                    rej(e);
+            });
         });
-    });
+        (0, fs_1.renameSync)(tempExtractLocation, bundleExtractLocation);
+        // Recorded only now: the record is the signal that a bundle at this
+        // version was installed by this process, which is what lets a waiter
+        // adopt it instead of downloading again, and it carries the directory
+        // that selection has to load from.
+        writeDownloadRecord(version, bundleDirectoryName);
+    }
+    catch (e) {
+        (0, fs_1.rmSync)(tempExtractLocation, { recursive: true, force: true });
+        throw e;
+    }
+    // On a contended install another process may be running from any bundle on
+    // disk, now including one at this same version, so nothing here can be shown
+    // to be unused and collection waits for a later uncontended install. Repeat
+    // contention accumulates directories until one of those runs. Bounding that
+    // means knowing which bundles are still loaded, which nothing on disk
+    // records today.
+    if (!contended) {
+        removeOldClientBundles(bundleDirectoryName);
+    }
+    writeBundleVerificationLock();
+    return bundleExtractLocation;
 }
-function removeOldClientBundles(currentInstallVersion) {
+function removeOldClientBundles(currentInstallDirectoryName) {
     const filesAndFolders = (0, fs_1.readdirSync)(runnerBundleInstallDirectory);
     for (let fileOrFolder of filesAndFolders) {
+        // A '.tmp-*' left by a crashed extract is reclaimed here, which is safe
+        // only because this runs after our own was renamed away and the download
+        // lock means no other process is extracting. Under WASM there is no lock,
+        // so a concurrent extract may still own that directory: leaving it costs
+        // disk, deleting it would fail that process's install.
+        if (fileOrFolder === currentInstallDirectoryName ||
+            (native_1.IS_WASM && fileOrFolder.startsWith('.tmp-'))) {
+            continue;
+        }
         const fileOrFolderPath = (0, path_1.join)(runnerBundleInstallDirectory, fileOrFolder);
-        if (fileOrFolder !== currentInstallVersion) {
-            (0, fs_1.rmSync)(fileOrFolderPath, { recursive: true });
+        // Another process's cleanup can remove an entry between the readdir above
+        // and these calls, so both tolerate it already being gone.
+        let isBundle;
+        try {
+            // Only directories are bundles. Files here, like the verify.lock a
+            // released nx writes, are left alone.
+            isBundle = (0, fs_1.statSync)(fileOrFolderPath).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isBundle) {
+            (0, fs_1.rmSync)(fileOrFolderPath, { recursive: true, force: true });
         }
     }
 }

package/dist/src/project-graph/affected/affected-tasks.js

@@ -148,6 +148,7 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
     const dependencies = dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson);
     const namedProjects = new Set(dependencies.projects);
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    // TODO(v25): remove custom hasher support.
     const customHashed = new Set(taskIds.filter((id) => hasCustomHasher(taskGraph.tasks[id], projects)));
     const options = {
         projectGlobPatterns: await (0, affected_projects_1.getProjectGlobPatterns)(nxJson),

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -351,6 +351,13 @@ class IsolatedPlugin {
         this.shutdown();
     }
     async setWorkerEnv(env) {
+        // A restart may have spawned under the previous client env but not yet
+        // finished loading. Wait for that worker so it receives the update too.
+        // Do not start a stopped worker solely to forward env: its next spawn
+        // will inherit the daemon's already-updated environment.
+        if (!this._alive && this._connectPromise) {
+            await this._connectPromise;
+        }
         if (!this._alive) {
             return;
         }

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;
@@ -298,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
@@ -310,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)) {
@@ -322,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 [];
         }
@@ -339,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/init-tasks-runner.js

@@ -13,6 +13,7 @@ const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
     (0, dotenv_1.loadRootEnvFiles)();
+    fullTaskGraph = withEdgeObjects(fullTaskGraph);
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -52,6 +53,18 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
     orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
+// A client bundle built before edges became objects hands plain task ids
+function withEdgeObjects(taskGraph) {
+    const normalize = (edges) => Object.fromEntries(Object.entries(edges).map(([taskId, taskEdges]) => [
+        taskId,
+        taskEdges.map((edge) => typeof edge === 'string' ? { id: edge } : edge),
+    ]));
+    return {
+        ...taskGraph,
+        dependencies: normalize(taskGraph.dependencies),
+        continuousDependencies: normalize(taskGraph.continuousDependencies),
+    };
+}
 // Nothing awaits the dispose chains below, so an unhandled rejection would take
 // down a long-lived agent process.
 function logDisposeFailure(e) {