nx 21.0.0-beta.1 → 21.0.0-canary.20250206-8bd0bcd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.0.0-beta.1",
+  "version": "21.0.0-canary.20250206-8bd0bcd",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -63,7 +63,6 @@
     "string-width": "^4.2.3",
     "tar-stream": "~2.2.0",
     "tmp": "~0.2.1",
-    "tree-kill": "^1.2.2",
     "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0",
     "yaml": "^2.6.0",
@@ -83,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.0.0-beta.1",
-    "@nx/nx-darwin-x64": "21.0.0-beta.1",
-    "@nx/nx-freebsd-x64": "21.0.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "21.0.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "21.0.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "21.0.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "21.0.0-beta.1",
-    "@nx/nx-linux-x64-musl": "21.0.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "21.0.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "21.0.0-beta.1"
+    "@nx/nx-darwin-arm64": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-darwin-x64": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-freebsd-x64": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-linux-arm-gnueabihf": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-linux-arm64-gnu": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-linux-arm64-musl": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-linux-x64-gnu": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-linux-x64-musl": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-win32-arm64-msvc": "21.0.0-canary.20250206-8bd0bcd",
+    "@nx/nx-win32-x64-msvc": "21.0.0-canary.20250206-8bd0bcd"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/graph/graph.js

@@ -629,7 +629,6 @@ function getAllTaskGraphsForWorkspace(projectGraph) {
                 taskGraphs[taskId] = {
                     tasks: {},
                     dependencies: {},
-                    continuousDependencies: {},
                     roots: [],
                 };
                 taskGraphErrors[taskId] = err.message;
@@ -645,7 +644,6 @@ function getAllTaskGraphsForWorkspace(projectGraph) {
                         taskGraphs[taskId] = {
                             tasks: {},
                             dependencies: {},
-                            continuousDependencies: {},
                             roots: [],
                         };
                         taskGraphErrors[taskId] = err.message;

package/src/commands-runner/get-command-projects.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCommandProjects = getCommandProjects;
+const utils_1 = require("../tasks-runner/utils");
 const create_command_graph_1 = require("./create-command-graph");
 function getCommandProjects(projectGraph, projects, nxArgs) {
     const commandGraph = (0, create_command_graph_1.createCommandGraph)(projectGraph, projects.map((project) => project.name), nxArgs);
@@ -12,22 +13,6 @@ function getSortedProjects(commandGraph, sortedProjects = []) {
         return sortedProjects;
     }
     sortedProjects.push(...roots);
-    const newGraph = removeIdsFromGraph(commandGraph, roots, commandGraph.dependencies);
+    const newGraph = (0, utils_1.removeIdsFromGraph)(commandGraph, roots, commandGraph.dependencies);
     return getSortedProjects(newGraph, sortedProjects);
 }
-function removeIdsFromGraph(graph, ids, mapWithIds) {
-    const filteredMapWithIds = {};
-    const dependencies = {};
-    const removedSet = new Set(ids);
-    for (let id of Object.keys(mapWithIds)) {
-        if (!removedSet.has(id)) {
-            filteredMapWithIds[id] = mapWithIds[id];
-            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
-        }
-    }
-    return {
-        mapWithIds: filteredMapWithIds,
-        dependencies: dependencies,
-        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
-    };
-}

package/src/config/task-graph.d.ts

@@ -84,10 +84,6 @@ export interface Task {
      * Determines if a given task should be parallelizable.
      */
     parallelism: boolean;
-    /**
-     * This denotes if the task runs continuously
-     */
-    continuous?: boolean;
 }
 /**
  * Graph of Tasks to be executed
@@ -105,5 +101,4 @@ export interface TaskGraph {
      * Map of Task IDs to IDs of tasks which the task depends on
      */
     dependencies: Record<string, string[]>;
-    continuousDependencies: Record<string, string[]>;
 }

package/src/config/workspace-json-project-json.d.ts

@@ -238,10 +238,6 @@ export interface TargetConfiguration<T = any> {
      * Default is true
      */
     parallelism?: boolean;
-    /**
-     * Whether this target runs continuously
-     */
-    continuous?: boolean;
     /**
      * List of generators to run before the target to ensure the workspace
      * is up to date.

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -1,25 +1,23 @@
 import { ExecutorContext } from '../../config/misc-interfaces';
-import { ParallelRunningTasks, SeriallyRunningTasks } from './running-tasks';
 export declare const LARGE_BUFFER: number;
 export type Json = {
     [k: string]: any;
 };
-export interface RunCommandsCommandOptions {
-    command: string;
-    forwardAllArgs?: boolean;
-    /**
-     * description was added to allow users to document their commands inline,
-     * it is not intended to be used as part of the execution of the command.
-     */
-    description?: string;
-    prefix?: string;
-    prefixColor?: string;
-    color?: string;
-    bgColor?: string;
-}
 export interface RunCommandsOptions extends Json {
     command?: string | string[];
-    commands?: Array<RunCommandsCommandOptions | string>;
+    commands?: ({
+        command: string;
+        forwardAllArgs?: boolean;
+        /**
+         * description was added to allow users to document their commands inline,
+         * it is not intended to be used as part of the execution of the command.
+         */
+        description?: string;
+        prefix?: string;
+        prefixColor?: string;
+        color?: string;
+        bgColor?: string;
+    } | string)[];
     color?: boolean;
     parallel?: boolean;
     readyWhen?: string | string[];
@@ -57,5 +55,4 @@ export default function (options: RunCommandsOptions, context: ExecutorContext):
     success: boolean;
     terminalOutput: string;
 }>;
-export declare function runCommands(options: RunCommandsOptions, context: ExecutorContext): Promise<ParallelRunningTasks | SeriallyRunningTasks>;
 export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

package/src/executors/run-commands/run-commands.impl.js

@@ -2,13 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LARGE_BUFFER = void 0;
 exports.default = default_1;
-exports.runCommands = runCommands;
 exports.interpolateArgsIntoCommand = interpolateArgsIntoCommand;
+const child_process_1 = require("child_process");
+const path = require("path");
 const yargsParser = require("yargs-parser");
+const npm_run_path_1 = require("npm-run-path");
+const chalk = require("chalk");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const exit_codes_1 = require("../../utils/exit-codes");
-const running_tasks_1 = require("./running-tasks");
+const task_env_1 = require("../../tasks-runner/task-env");
 exports.LARGE_BUFFER = 1024 * 1000000;
+let pseudoTerminal;
+const childProcesses = new Set();
+function loadEnvVarsFile(path, env = {}) {
+    (0, task_env_1.unloadDotEnvFile)(path, env);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
+    if (result.error) {
+        throw result.error;
+    }
+}
 const propKeys = [
     'command',
     'commands',
@@ -29,14 +41,7 @@ const propKeys = [
     'tty',
 ];
 async function default_1(options, context) {
-    const task = await runCommands(options, context);
-    const results = await task.getResults();
-    return {
-        ...results,
-        success: results.code === 0,
-    };
-}
-async function runCommands(options, context) {
+    registerProcessListener();
     const normalized = normalizeOptions(options);
     if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
@@ -45,15 +50,11 @@ async function runCommands(options, context) {
         !options.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "prefix", "prefixColor", "color" and "bgColor" can only be set when "parallel=true".');
     }
-    const pseudoTerminal = !options.parallel && pseudo_terminal_1.PseudoTerminal.isSupported()
-        ? (0, pseudo_terminal_1.getPseudoTerminal)()
-        : null;
     try {
-        const runningTask = options.parallel
-            ? new running_tasks_1.ParallelRunningTasks(normalized, context)
-            : new running_tasks_1.SeriallyRunningTasks(normalized, context, pseudoTerminal);
-        registerProcessListener(runningTask, pseudoTerminal);
-        return runningTask;
+        const result = options.parallel
+            ? await runInParallel(normalized, context)
+            : await runSerially(normalized, context);
+        return result;
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
@@ -62,6 +63,52 @@ async function runCommands(options, context) {
         throw new Error(`ERROR: Something went wrong in run-commands - ${e.message}`);
     }
 }
+async function runInParallel(options, context) {
+    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhenStatus, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput, options.tty, options.envFile).then((result) => ({
+        result,
+        command: c.command,
+    })));
+    let terminalOutput = '';
+    if (options.readyWhenStatus.length) {
+        const r = await Promise.race(procs);
+        terminalOutput += r.result.terminalOutput;
+        if (!r.result.success) {
+            const output = `Warning: command "${r.command}" exited with non-zero status code`;
+            terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return { success: false, terminalOutput };
+        }
+        else {
+            return { success: true, terminalOutput };
+        }
+    }
+    else {
+        const r = await Promise.all(procs);
+        terminalOutput += r.map((f) => f.result.terminalOutput).join('');
+        const failed = r.filter((v) => !v.result.success);
+        if (failed.length > 0) {
+            const output = failed
+                .map((f) => `Warning: command "${f.command}" exited with non-zero status code`)
+                .join('\r\n');
+            terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return {
+                success: false,
+                terminalOutput,
+            };
+        }
+        else {
+            return {
+                success: true,
+                terminalOutput,
+            };
+        }
+    }
+}
 function normalizeOptions(options) {
     if (options.readyWhen && typeof options.readyWhen === 'string') {
         options.readyWhenStatus = [
@@ -109,6 +156,167 @@ function normalizeOptions(options) {
     });
     return options;
 }
+async function runSerially(options, context) {
+    pseudoTerminal ??= pseudo_terminal_1.PseudoTerminal.isSupported() ? (0, pseudo_terminal_1.getPseudoTerminal)() : null;
+    let terminalOutput = '';
+    for (const c of options.commands) {
+        const result = await createProcess(pseudoTerminal, c, [], options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, false, options.usePty, options.streamOutput, options.tty, options.envFile);
+        terminalOutput += result.terminalOutput;
+        if (!result.success) {
+            const output = `Warning: command "${c.command}" exited with non-zero status code`;
+            result.terminalOutput += output;
+            if (options.streamOutput) {
+                process.stderr.write(output);
+            }
+            return { success: false, terminalOutput };
+        }
+    }
+    return { success: true, terminalOutput };
+}
+async function createProcess(pseudoTerminal, commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty, envFile) {
+    env = processEnv(color, cwd, env, envFile);
+    // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
+    // currently does not work properly in windows
+    if (pseudoTerminal &&
+        process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+        !commandConfig.prefix &&
+        readyWhenStatus.length === 0 &&
+        !isParallel &&
+        usePty) {
+        let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+        if (streamOutput) {
+            process.stdout.write(terminalOutput);
+        }
+        const cp = pseudoTerminal.runCommand(commandConfig.command, {
+            cwd,
+            jsEnv: env,
+            quiet: !streamOutput,
+            tty,
+        });
+        childProcesses.add(cp);
+        return new Promise((res) => {
+            cp.onOutput((output) => {
+                terminalOutput += output;
+            });
+            cp.onExit((code) => {
+                if (code >= 128) {
+                    process.exit(code);
+                }
+                else {
+                    res({ success: code === 0, terminalOutput });
+                }
+            });
+        });
+    }
+    return nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput);
+}
+function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = true) {
+    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+    if (streamOutput) {
+        process.stdout.write(terminalOutput);
+    }
+    return new Promise((res) => {
+        const childProcess = (0, child_process_1.exec)(commandConfig.command, {
+            maxBuffer: exports.LARGE_BUFFER,
+            env,
+            cwd,
+            windowsHide: false,
+        });
+        childProcesses.add(childProcess);
+        childProcess.stdout.on('data', (data) => {
+            const output = addColorAndPrefix(data, commandConfig);
+            terminalOutput += output;
+            if (streamOutput) {
+                process.stdout.write(output);
+            }
+            if (readyWhenStatus.length && isReady(readyWhenStatus, data.toString())) {
+                res({ success: true, terminalOutput });
+            }
+        });
+        childProcess.stderr.on('data', (err) => {
+            const output = addColorAndPrefix(err, commandConfig);
+            terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
+            if (readyWhenStatus.length && isReady(readyWhenStatus, err.toString())) {
+                res({ success: true, terminalOutput });
+            }
+        });
+        childProcess.on('error', (err) => {
+            const ouptput = addColorAndPrefix(err.toString(), commandConfig);
+            terminalOutput += ouptput;
+            if (streamOutput) {
+                process.stderr.write(ouptput);
+            }
+            res({ success: false, terminalOutput });
+        });
+        childProcess.on('exit', (code) => {
+            childProcesses.delete(childProcess);
+            if (!readyWhenStatus.length || isReady(readyWhenStatus)) {
+                res({ success: code === 0, terminalOutput });
+            }
+        });
+    });
+}
+function addColorAndPrefix(out, config) {
+    if (config.prefix) {
+        out = out
+            .split('\n')
+            .map((l) => {
+            let prefixText = config.prefix;
+            if (config.prefixColor && chalk[config.prefixColor]) {
+                prefixText = chalk[config.prefixColor](prefixText);
+            }
+            prefixText = chalk.bold(prefixText);
+            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
+        })
+            .join('\n');
+    }
+    if (config.color && chalk[config.color]) {
+        out = chalk[config.color](out);
+    }
+    if (config.bgColor && chalk[config.bgColor]) {
+        out = chalk[config.bgColor](out);
+    }
+    return out;
+}
+function calculateCwd(cwd, context) {
+    if (!cwd)
+        return context.root;
+    if (path.isAbsolute(cwd))
+        return cwd;
+    return path.join(context.root, cwd);
+}
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
+        ...process.env,
+        ...localEnv,
+    };
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
+    }
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
+    };
+    // need to override PATH to make sure we are using the local node_modules
+    if (localEnv.PATH)
+        res.PATH = localEnv.PATH; // UNIX-like
+    if (localEnv.Path)
+        res.Path = localEnv.Path; // Windows
+    if (color) {
+        res.FORCE_COLOR = `${color}`;
+    }
+    return res;
+}
 function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
     if (command.indexOf('{args.') > -1) {
         const regex = /{args\.([^}]+)}/g;
@@ -196,7 +404,7 @@ function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
     return parsedOptions;
 }
 let registered = false;
-function registerProcessListener(runningTask, pseudoTerminal) {
+function registerProcessListener() {
     if (registered) {
         return;
     }
@@ -207,24 +415,44 @@ function registerProcessListener(runningTask, pseudoTerminal) {
         if (pseudoTerminal) {
             pseudoTerminal.sendMessageToChildren(message);
         }
-        runningTask.send(message);
+        childProcesses.forEach((p) => {
+            if ('connected' in p && p.connected) {
+                p.send(message);
+            }
+        });
     });
     // Terminate any task processes on exit
     process.on('exit', () => {
-        runningTask.kill();
+        childProcesses.forEach((p) => {
+            if ('connected' in p ? p.connected : p.isAlive) {
+                p.kill();
+            }
+        });
     });
     process.on('SIGINT', () => {
-        runningTask.kill('SIGTERM');
+        childProcesses.forEach((p) => {
+            if ('connected' in p ? p.connected : p.isAlive) {
+                p.kill('SIGTERM');
+            }
+        });
         // we exit here because we don't need to write anything to cache.
         process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
     });
     process.on('SIGTERM', () => {
-        runningTask.kill('SIGTERM');
+        childProcesses.forEach((p) => {
+            if ('connected' in p ? p.connected : p.isAlive) {
+                p.kill('SIGTERM');
+            }
+        });
         // no exit here because we expect child processes to terminate which
         // will store results to the cache and will terminate this process
     });
     process.on('SIGHUP', () => {
-        runningTask.kill('SIGTERM');
+        childProcesses.forEach((p) => {
+            if ('connected' in p ? p.connected : p.isAlive) {
+                p.kill('SIGTERM');
+            }
+        });
         // no exit here because we expect child processes to terminate which
         // will store results to the cache and will terminate this process
     });
@@ -246,3 +474,14 @@ function wrapArgIntoQuotesIfNeeded(arg) {
         return arg;
     }
 }
+function isReady(readyWhenStatus = [], data) {
+    if (data) {
+        for (const readyWhenElement of readyWhenStatus) {
+            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
+                readyWhenElement.found = true;
+                break;
+            }
+        }
+    }
+    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
+}

package/src/native/index.d.ts

@@ -11,7 +11,6 @@ export declare class ChildProcess {
   kill(): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
-  cleanup(): void
 }
 
 export declare class FileLock {

package/src/tasks-runner/create-task-graph.d.ts

@@ -11,9 +11,6 @@ export declare class ProcessTasks {
     readonly dependencies: {
         [k: string]: string[];
     };
-    readonly continuousDependencies: {
-        [k: string]: string[];
-    };
     private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
     processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];

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

@@ -17,7 +17,6 @@ class ProcessTasks {
         this.seen = new Set();
         this.tasks = {};
         this.dependencies = {};
-        this.continuousDependencies = {};
         const allTargetNames = new Set();
         for (const projectName in projectGraph.nodes) {
             const project = projectGraph.nodes[projectName];
@@ -37,7 +36,6 @@ class ProcessTasks {
                     const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
                     this.tasks[task.id] = task;
                     this.dependencies[task.id] = [];
-                    this.continuousDependencies[task.id] = [];
                 }
             }
         }
@@ -52,15 +50,11 @@ class ProcessTasks {
                 if (!initialTasks[t]) {
                     delete this.tasks[t];
                     delete this.dependencies[t];
-                    delete this.continuousDependencies[t];
                 }
             }
             for (let d of Object.keys(this.dependencies)) {
                 this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
             }
-            for (let d of Object.keys(this.continuousDependencies)) {
-                this.continuousDependencies[d] = this.continuousDependencies[d].filter((dd) => !!initialTasks[dd]);
-            }
         }
         filterDummyTasks(this.dependencies);
         for (const taskId of Object.keys(this.dependencies)) {
@@ -70,16 +64,7 @@ class ProcessTasks {
                 ];
             }
         }
-        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);
+        return Object.keys(this.dependencies).filter((d) => this.dependencies[d].length === 0);
     }
     processTask(task, projectUsedToDeriveDependencies, configuration, overrides) {
         const seenKey = `${task.id}-${projectUsedToDeriveDependencies}`;
@@ -121,21 +106,15 @@ class ProcessTasks {
         if ((0, project_graph_utils_1.projectHasTarget)(selfProject, dependencyConfig.target)) {
             const resolvedConfiguration = this.resolveConfiguration(selfProject, dependencyConfig.target, configuration);
             const selfTaskId = this.getId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
+            if (task.id !== selfTaskId) {
+                this.dependencies[task.id].push(selfTaskId);
+            }
             if (!this.tasks[selfTaskId]) {
                 const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                 this.tasks[selfTaskId] = newTask;
                 this.dependencies[selfTaskId] = [];
-                this.continuousDependencies[selfTaskId] = [];
                 this.processTask(newTask, newTask.target.project, configuration, overrides);
             }
-            if (task.id !== selfTaskId) {
-                if (this.tasks[selfTaskId].continuous) {
-                    this.continuousDependencies[task.id].push(selfTaskId);
-                }
-                else {
-                    this.dependencies[task.id].push(selfTaskId);
-                }
-            }
         }
     }
     processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides) {
@@ -150,20 +129,13 @@ class ProcessTasks {
             if ((0, project_graph_utils_1.projectHasTarget)(depProject, dependencyConfig.target)) {
                 const resolvedConfiguration = this.resolveConfiguration(depProject, dependencyConfig.target, configuration);
                 const depTargetId = this.getId(depProject.name, dependencyConfig.target, resolvedConfiguration);
-                const depTargetConfiguration = this.projectGraph.nodes[depProject.name].data.targets[dependencyConfig.target];
                 if (task.id !== depTargetId) {
-                    if (depTargetConfiguration.continuous) {
-                        this.continuousDependencies[task.id].push(depTargetId);
-                    }
-                    else {
-                        this.dependencies[task.id].push(depTargetId);
-                    }
+                    this.dependencies[task.id].push(depTargetId);
                 }
                 if (!this.tasks[depTargetId]) {
                     const newTask = this.createTask(depTargetId, depProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
                     this.tasks[depTargetId] = newTask;
                     this.dependencies[depTargetId] = [];
-                    this.continuousDependencies[depTargetId] = [];
                     this.processTask(newTask, newTask.target.project, configuration, overrides);
                 }
             }
@@ -175,7 +147,6 @@ class ProcessTasks {
                     DUMMY_TASK_TARGET, undefined);
                 this.dependencies[task.id].push(dummyId);
                 this.dependencies[dummyId] ??= [];
-                this.continuousDependencies[dummyId] ??= [];
                 const noopTask = this.createDummyTask(dummyId, task);
                 this.processTask(noopTask, depProject.name, configuration, overrides);
             }
@@ -208,7 +179,6 @@ class ProcessTasks {
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
             cache: project.data.targets[target].cache,
             parallelism: project.data.targets[target].parallelism ?? true,
-            continuous: project.data.targets[target].continuous ?? false,
         };
     }
     resolveConfiguration(project, target, configuration) {
@@ -234,7 +204,6 @@ function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, ta
         roots,
         tasks: p.tasks,
         dependencies: p.dependencies,
-        continuousDependencies: p.continuousDependencies,
     };
 }
 function mapTargetDefaultsToDependencies(defaults) {