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

package/dist/src/executors/run-commands/running-tasks.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SeriallyRunningTasks = exports.ParallelRunningTasks = void 0;
 exports.runSingleCommandWithPseudoTerminal = runSingleCommandWithPseudoTerminal;
+exports.calculateCwd = calculateCwd;
+exports.processEnv = processEnv;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const child_process_1 = require("child_process");
@@ -10,6 +12,7 @@ const path_1 = require("path");
 const native_1 = require("../../native");
 const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
 const task_env_1 = require("../../tasks-runner/task-env");
+const tokens_1 = require("../../tasks-runner/tokens");
 const task_io_service_1 = require("../../tasks-runner/task-io-service");
 const exit_codes_1 = require("../../utils/exit-codes");
 const output_1 = require("../../utils/output");
@@ -38,15 +41,23 @@ function streamChunk(chunk, streamOutput, target = process.stdout) {
 function commandExitedNonZeroWarning(command) {
     return `Warning: command "${command}" exited with non-zero status code`;
 }
+function commandsExitedBeforeReadyWarning(commands, readyWhenStatus) {
+    const exited = commands.length === 1 ? `command "${commands[0].command}"` : 'all commands';
+    const missing = readyWhenStatus
+        .filter(({ found }) => !found)
+        .map(({ stringToMatch }) => `"${stringToMatch}"`)
+        .join(', ');
+    return `Warning: ${exited} exited before printing the readyWhen text ${missing}`;
+}
 class ParallelRunningTasks {
-    constructor(options, context, task) {
+    constructor(options, context, task, baseEnv) {
         this.exitCallbacks = [];
         this.outputCallbacks = [];
         // Memoized exit so late getResults()/onExit() callers don't hang.
         this.exited = false;
         this.exitCode = 0;
         this.exitTerminalOutput = '';
-        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile, task));
+        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile, task, baseEnv));
         this.readyWhenStatus = options.readyWhenStatus;
         this.streamOutput = options.streamOutput;
         this.run();
@@ -91,19 +102,32 @@ class ParallelRunningTasks {
     }
     async run() {
         if (this.readyWhenStatus.length) {
-            let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
-                childProcess.onOutput((terminalOutput) => {
-                    for (const cb of this.outputCallbacks) {
-                        cb(terminalOutput);
-                    }
-                });
-                childProcess.onExit((code, terminalOutput) => {
-                    res({
-                        childProcess,
-                        result: { code, terminalOutput },
+            const settled = await Promise.race([
+                ...this.childProcesses.map((childProcess) => new Promise((res) => {
+                    childProcess.onOutput((terminalOutput) => {
+                        for (const cb of this.outputCallbacks) {
+                            cb(terminalOutput);
+                        }
                     });
-                });
-            })));
+                    childProcess.onExit((code, terminalOutput) => {
+                        res({
+                            childProcess,
+                            result: { code, terminalOutput },
+                        });
+                    });
+                })),
+                Promise.all(this.childProcesses.map((childProcess) => childProcess.outputWhenClosed())).then((outputs) => ({ outputsOfExitedCommands: outputs })),
+            ]);
+            if ('outputsOfExitedCommands' in settled) {
+                const warning = commandsExitedBeforeReadyWarning(this.childProcesses, this.readyWhenStatus);
+                for (const cb of this.outputCallbacks) {
+                    cb(warning);
+                }
+                streamChunk(warning, this.streamOutput, process.stderr);
+                this.emitExit(1, settled.outputsOfExitedCommands.join('\r\n') + warning);
+                return;
+            }
+            let { childProcess, result: { code, terminalOutput }, } = settled;
             if (code !== 0) {
                 const warning = commandExitedNonZeroWarning(childProcess.command);
                 terminalOutput += warning;
@@ -156,9 +180,10 @@ class ParallelRunningTasks {
 }
 exports.ParallelRunningTasks = ParallelRunningTasks;
 class SeriallyRunningTasks {
-    constructor(options, context, tuiEnabled, task) {
+    constructor(options, context, tuiEnabled, task, baseEnv) {
         this.tuiEnabled = tuiEnabled;
         this.task = task;
+        this.baseEnv = baseEnv;
         this.terminalOutputChunks = [];
         this.currentProcess = null;
         this.exitCallbacks = [];
@@ -225,11 +250,11 @@ class SeriallyRunningTasks {
     }
     async run(options, context) {
         for (const c of options.commands) {
-            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, this.task, options.usePty, options.streamOutput, options.tty, options.envFile);
+            const childProcess = await this.createProcess(c, options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, this.task, options.usePty, options.streamOutput, options.tty, options.envFile, this.baseEnv);
             this.currentProcess = childProcess;
-            childProcess.onOutput((output) => {
+            childProcess.onOutput((output, isCommandHeader) => {
                 for (const cb of this.outputCallbacks) {
-                    cb(output);
+                    cb(output, isCommandHeader);
                 }
             });
             let { code, terminalOutput } = await childProcess.getResults();
@@ -244,7 +269,7 @@ class SeriallyRunningTasks {
             }
         }
     }
-    async createProcess(commandConfig, color, cwd, env, task, usePty = true, streamOutput = true, tty, envFile) {
+    async createProcess(commandConfig, color, cwd, env, task, usePty = true, streamOutput = true, tty, envFile, baseEnv) {
         // 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 (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
@@ -253,7 +278,7 @@ class SeriallyRunningTasks {
             pseudo_terminal_1.PseudoTerminal.isSupported()) {
             const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
             registerProcessListener(this, pseudoTerminal);
-            const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
+            const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile, baseEnv);
             // Register process for metrics collection (direct run-commands execution)
             // Skip registration if we're in a forked executor - the fork wrapper already registered
             const pid = pseudoTtyProcess.getPid();
@@ -262,16 +287,55 @@ class SeriallyRunningTasks {
             }
             return pseudoTtyProcess;
         }
-        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, task);
+        return new RunningNodeProcess(commandConfig, color, cwd, env, [], streamOutput, envFile, task, baseEnv);
     }
 }
 exports.SeriallyRunningTasks = SeriallyRunningTasks;
+// Running children share one process listener per event instead of adding one
+// each. The listeners are removed once the last child exits: a signal handler
+// left behind would stop a forked executor from exiting on that signal.
+const runningNodeProcesses = new Set();
+function killRunningNodeProcessesOnExit() {
+    for (const runningNodeProcess of runningNodeProcesses) {
+        runningNodeProcess.killOnExit();
+    }
+}
+function terminateRunningNodeProcesses() {
+    for (const runningNodeProcess of runningNodeProcesses) {
+        runningNodeProcess.kill('SIGTERM');
+    }
+}
+function trackRunningNodeProcess(runningNodeProcess) {
+    if (runningNodeProcesses.size === 0) {
+        process.on('exit', killRunningNodeProcessesOnExit);
+        // In the direct path, detached children don't get OS SIGINT (own process
+        // group via setsid); the orchestrator's cleanup() sends SIGTERM via
+        // killProcessTreeGraceful. Signal handlers here are only needed in the
+        // forked path where there's no orchestrator to dispatch signals.
+        if (process.env.NX_FORKED_TASK_EXECUTOR) {
+            process.on('SIGINT', terminateRunningNodeProcesses);
+            process.on('SIGTERM', terminateRunningNodeProcesses);
+            process.on('SIGHUP', terminateRunningNodeProcesses);
+        }
+    }
+    runningNodeProcesses.add(runningNodeProcess);
+}
+function untrackRunningNodeProcess(runningNodeProcess) {
+    if (!runningNodeProcesses.delete(runningNodeProcess) ||
+        runningNodeProcesses.size > 0) {
+        return;
+    }
+    process.removeListener('exit', killRunningNodeProcessesOnExit);
+    process.removeListener('SIGINT', terminateRunningNodeProcesses);
+    process.removeListener('SIGTERM', terminateRunningNodeProcesses);
+    process.removeListener('SIGHUP', terminateRunningNodeProcesses);
+}
 class RunningNodeProcess {
     /** This class's writes, funnelled through {@link streamChunk}. */
     stream(chunk, target = process.stdout) {
         streamChunk(chunk, this.streamOutput, target);
     }
-    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile, task) {
+    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile, task, baseEnv) {
         this.readyWhenStatus = readyWhenStatus;
         this.streamOutput = streamOutput;
         this.task = task;
@@ -283,7 +347,7 @@ class RunningNodeProcess {
         this.exited = false;
         this.exitCode = 0;
         this.exitTerminalOutput = '';
-        env = processEnv(color, cwd, env, envFile);
+        env = processEnv(color, cwd, env, envFile, baseEnv);
         this.command = commandConfig.command;
         const header = pc.dim('> ') + commandConfig.command + '\r\n\r\n';
         this.terminalOutputChunks.push(header);
@@ -334,6 +398,10 @@ class RunningNodeProcess {
     send(message) {
         this.childProcess.send(message);
     }
+    async outputWhenClosed() {
+        await this.closedPromise;
+        return this.terminalOutputChunks.join('');
+    }
     emitExit(code, terminalOutput) {
         if (this.exited)
             return;
@@ -361,46 +429,30 @@ class RunningNodeProcess {
         ]));
         return this.killPromise;
     }
+    // Last resort on process exit, so it has to be sync. A graceful kill in
+    // progress tracks cleanup subprocesses that this must not interfere with.
+    killOnExit() {
+        if (this.childProcess.pid && !this.killPromise) {
+            (0, native_1.killProcessTree)(this.childProcess.pid);
+        }
+    }
     triggerOutputListeners(output) {
         for (const cb of this.outputCallbacks) {
             cb(output);
         }
     }
     addListeners(commandConfig) {
-        // Named handlers so they can be removed when the child exits.
-        // Otherwise each RunningNodeProcess leaks process listeners; with
-        // many run-commands tasks this triggers MaxListenersExceededWarning.
-        const isForked = !!process.env.NX_FORKED_TASK_EXECUTOR;
-        const onProcessExit = () => {
-            if (this.childProcess.pid && !this.killPromise) {
-                (0, native_1.killProcessTree)(this.childProcess.pid);
-            }
-        };
-        const onSigInt = () => {
-            this.kill('SIGTERM');
-        };
-        const onSigTerm = () => {
-            this.kill('SIGTERM');
-        };
-        const onSigHup = () => {
-            this.kill('SIGTERM');
-        };
-        const removeProcessListeners = () => {
-            process.removeListener('exit', onProcessExit);
-            if (isForked) {
-                process.removeListener('SIGINT', onSigInt);
-                process.removeListener('SIGTERM', onSigTerm);
-                process.removeListener('SIGHUP', onSigHup);
-            }
-        };
         this.childProcess.stdout.setEncoding('utf8');
         this.childProcess.stderr.setEncoding('utf8');
+        // Separate matchers, so a ready string never spans stdout and stderr
+        const stdoutReady = readyWhenMatcher(this.readyWhenStatus);
+        const stderrReady = readyWhenMatcher(this.readyWhenStatus);
         this.childProcess.stdout.on('data', (data) => {
             const output = addColorAndPrefix(data, commandConfig);
             this.terminalOutputChunks.push(output);
             this.triggerOutputListeners(output);
             this.stream(output);
-            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, data)) {
+            if (this.readyWhenStatus.length && stdoutReady(data)) {
                 for (const cb of this.exitCallbacks) {
                     cb(0, this.terminalOutputChunks.join(''));
                 }
@@ -411,9 +463,9 @@ class RunningNodeProcess {
             this.terminalOutputChunks.push(output);
             this.triggerOutputListeners(output);
             this.stream(output, process.stderr);
-            if (this.readyWhenStatus.length && isReady(this.readyWhenStatus, err)) {
+            if (this.readyWhenStatus.length && stderrReady(err)) {
                 for (const cb of this.exitCallbacks) {
-                    cb(1, this.terminalOutputChunks.join(''));
+                    cb(0, this.terminalOutputChunks.join(''));
                 }
             }
         });
@@ -423,44 +475,31 @@ class RunningNodeProcess {
             this.stream(output, process.stderr);
             const terminalOutput = this.terminalOutputChunks.join('');
             this.terminalOutputChunks = [];
-            removeProcessListeners();
+            untrackRunningNodeProcess(this);
             this.emitExit(1, terminalOutput);
         });
         this.childProcess.on('exit', (code, signal) => {
             if (code === null) {
                 code = (0, exit_codes_1.signalToCode)(signal);
             }
-            removeProcessListeners();
+            untrackRunningNodeProcess(this);
+            if (code === 0 &&
+                this.readyWhenStatus.length &&
+                !isReady(this.readyWhenStatus)) {
+                // A parallel companion may still print the readyWhen text. Keep the
+                // output for ParallelRunningTasks, which decides once all have closed.
+                return;
+            }
             const terminalOutput = this.terminalOutputChunks.join('');
             this.terminalOutputChunks = [];
-            if (!this.readyWhenStatus.length || isReady(this.readyWhenStatus)) {
-                this.emitExit(code, terminalOutput);
-            }
-            else if (code !== 0) {
-                // Process crashed before readyWhen matched; surface the failure so
-                // awaiters unblock. A clean exit (code 0) is left as-is — a parallel
-                // companion command may still produce the readyWhen output.
-                this.emitExit(code, terminalOutput);
-            }
+            this.emitExit(code, terminalOutput);
         });
-        // Terminate any task processes on exit (sync, last resort).
-        // Skip if graceful kill is already in progress — it tracks cleanup
-        // subprocesses and we must not interfere with them.
-        process.on('exit', onProcessExit);
-        // In the direct path, detached children don't get OS SIGINT (own process
-        // group via setsid); the orchestrator's cleanup() sends SIGTERM via
-        // killProcessTreeGraceful. Signal handlers here are only needed in the
-        // forked path where there's no orchestrator to dispatch signals.
-        if (isForked) {
-            process.on('SIGINT', onSigInt);
-            process.on('SIGTERM', onSigTerm);
-            process.on('SIGHUP', onSigHup);
-        }
+        trackRunningNodeProcess(this);
     }
 }
-async function runSingleCommandWithPseudoTerminal(normalized, context, task) {
+async function runSingleCommandWithPseudoTerminal(normalized, context, task, baseEnv) {
     const pseudoTerminal = (0, pseudo_terminal_1.createPseudoTerminal)();
-    const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile);
+    const pseudoTtyProcess = await createProcessWithPseudoTty(pseudoTerminal, normalized.commands[0], normalized.color, calculateCwd(normalized.cwd, context), normalized.env, normalized.streamOutput, pseudoTerminal ? normalized.isTTY : false, normalized.envFile, baseEnv);
     // Register process for metrics collection (direct run-commands execution)
     // Skip registration if we're in a forked executor - the fork wrapper already registered
     const pid = pseudoTtyProcess.getPid();
@@ -470,10 +509,10 @@ async function runSingleCommandWithPseudoTerminal(normalized, context, task) {
     registerProcessListener(pseudoTtyProcess, pseudoTerminal);
     return pseudoTtyProcess;
 }
-async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile) {
+async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile, baseEnv) {
     return pseudoTerminal.runCommand(commandConfig.command, {
         cwd,
-        jsEnv: processEnv(color, cwd, env, envFile),
+        jsEnv: processEnv(color, cwd, env, envFile, baseEnv),
         quiet: !streamOutput,
         tty,
     });
@@ -511,15 +550,15 @@ function calculateCwd(cwd, context) {
  * Env variables are processed in the following order:
  * - env option from executor options
  * - env file from envFile option if provided
- * - local env variables
+ * - local env variables, read from `baseEnv`
  */
-function processEnv(color, cwd, envOptionFromExecutor, envFile) {
-    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+function processEnv(color, cwd, envOptionFromExecutor, envFile, baseEnv = process.env) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd(), env: baseEnv });
     localEnv = {
-        ...process.env,
+        ...baseEnv,
         ...localEnv,
     };
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+    if ((0, tokens_1.readEnv)(baseEnv, 'NX_LOAD_DOT_ENV_FILES') !== 'false' && envFile) {
         loadEnvVarsFile(envFile, localEnv);
     }
     let res = {
@@ -539,17 +578,31 @@ function processEnv(color, cwd, envOptionFromExecutor, envFile) {
     delete res.NX_PREFIX_OUTPUT;
     return res;
 }
-function isReady(readyWhenStatus = [], data) {
-    if (data) {
-        for (const readyWhenElement of readyWhenStatus) {
-            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
-                readyWhenElement.found = true;
-                break;
-            }
-        }
-    }
+function isReady(readyWhenStatus) {
     return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
 }
+// The output as printed, kept across chunks, matches strings that hold escape
+// sequences. LogMatcher, absent from the WASM binding, matches text with
+// escapes inside it.
+function readyWhenMatcher(readyWhenStatus) {
+    const matchers = readyWhenStatus.map((status) => ({
+        status,
+        matcher: native_1.IS_WASM ? null : new native_1.LogMatcher([status.stringToMatch]),
+        tail: '',
+    }));
+    return (chunk) => {
+        for (const entry of matchers) {
+            const { status, matcher } = entry;
+            if (status.found)
+                continue;
+            const printed = entry.tail + chunk;
+            status.found =
+                printed.includes(status.stringToMatch) || !!matcher?.feed(chunk);
+            entry.tail = printed.slice(Math.max(0, printed.length - status.stringToMatch.length + 1));
+        }
+        return isReady(readyWhenStatus);
+    };
+}
 function loadEnvVarsFile(path, env = {}) {
     (0, task_env_1.unloadDotEnvFile)(path, env);
     const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
@@ -574,7 +627,7 @@ function registerProcessListener(runningTask, pseudoTerminal) {
         }
     });
     // Terminate any task processes on exit (sync, last resort).
-    // The per-child exit handlers and PseudoTerminal.shutdown() use the
+    // killRunningNodeProcessesOnExit and PseudoTerminal.shutdown() use the
     // sync killProcessTree for this path. We call kill() here as a
     // best-effort fallback — it returns a Promise but on 'exit' only
     // synchronous work runs, so the initial signal is sent but the

package/dist/src/executors/run-commands/schema.json

@@ -123,7 +123,7 @@
             "x-priority": "important"
         },
         "readyWhen": {
-            "description": "String or array of strings to appear in `stdout` or `stderr` that indicate that the task is done. When running multiple commands, this option can only be used when `parallel` is set to `true`. If not specified, the task is done when all the child processes complete.",
+            "description": "String or array of strings to appear in `stdout` or `stderr` that indicate that the task is done. Unless the target is `continuous`, the task fails if every command exits before printing them. When running multiple commands, this option can only be used when `parallel` is set to `true`. If not specified, the task is done when all the child processes complete.",
             "oneOf": [
                 { "type": "string" },
                 { "type": "array", "items": { "type": "string" } }

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

@@ -128,10 +128,7 @@ function getUnresolvedOutputs(taskId, projectGraph) {
             ? targetConfig.configurations?.[configuration]
             : undefined),
     };
-    return (targetConfig.outputs ?? []).filter((output) => [...output.matchAll(/\{options\.([^}]+)\}/g)].some(([, key]) => {
-        const value = key.split('.').reduce((acc, k) => acc?.[k], options);
-        return value === undefined;
-    }));
+    return (targetConfig.outputs ?? []).filter((output) => /{options.*}/.test((0, utils_1.interpolateOutput)(output, projectNode, options)));
 }
 function getTaskGraph(taskId, projectGraph) {
     const cached = taskGraphCache.get(taskId);
@@ -154,14 +151,14 @@ function getDepsOutputs(taskId, { projectGraph, nxJson }) {
 function collectUpstreamTaskIds(taskGraph, rootTaskId, transitive) {
     const direct = taskGraph.dependencies[rootTaskId] ?? [];
     if (!transitive)
-        return [...direct];
+        return direct.map((dep) => dep.id);
     const collected = new Set();
     const walk = (id) => {
         for (const dep of taskGraph.dependencies[id] ?? []) {
-            if (collected.has(dep))
+            if (collected.has(dep.id))
                 continue;
-            collected.add(dep);
-            walk(dep);
+            collected.add(dep.id);
+            walk(dep.id);
         }
     };
     walk(rootTaskId);

package/dist/src/hasher/file-hasher.js

@@ -3,21 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hashArray = hashArray;
 exports.hashObject = hashObject;
 exports.hashFile = hashFile;
+// Loaded on first use; a top-level import breaks unit tests in the Nx repo.
+// Cached because each `require` call re-resolves the module.
+let native;
+function getNative() {
+    return (native ??= require('../native'));
+}
 function hashArray(content) {
-    // Import as needed. There is also an issue running unit tests in Nx repo if this is a top-level import.
-    const { hashArray } = require('../native');
-    return hashArray(content);
+    return getNative().hashArray(content);
 }
 function hashObject(obj) {
-    const { hashArray } = require('../native');
     const parts = [];
     for (const key of Object.keys(obj ?? {}).sort()) {
         parts.push(key);
         parts.push(JSON.stringify(obj[key]));
     }
-    return hashArray(parts);
+    return getNative().hashArray(parts);
 }
 function hashFile(filePath) {
-    const { hashFile } = require('../native');
-    return hashFile(filePath);
+    return getNative().hashFile(filePath);
 }

package/dist/src/hasher/hash-task.js

@@ -9,6 +9,7 @@ const native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
 const task_io_service_1 = require("../tasks-runner/task-io-service");
 const task_env_1 = require("../tasks-runner/task-env");
+// TODO(v25): remove custom hasher support.
 const utils_1 = require("../tasks-runner/utils");
 const db_connection_1 = require("../utils/db-connection");
 const task_hasher_1 = require("./task-hasher");
@@ -32,6 +33,7 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         ? new Set((0, native_1.getUltracacheDeferredTaskIds)(ultracacheConfigurations, taskGraph))
         : null;
     const tasks = Object.values(taskGraph.tasks);
+    // TODO(v25): remove custom hasher support.
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
         const customHasher = (0, utils_1.getCustomHasher)(task, projects);
         return { task, customHasher };
@@ -81,6 +83,7 @@ function readsDependencyOutputs(task, taskGraph, projectGraph, nxJson) {
 async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    // TODO(v25): remove custom hasher support.
     const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
     const { value, details, inputs } = await (customHasher
         ? customHasher(task, {
@@ -126,6 +129,7 @@ async function hashTasks(hasher, projectGraph, taskGraph, perTaskEnvs, taskDetai
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const nxJson = (0, nx_json_1.readNxJson)();
     const tasks = (tasksToHashOverride ?? Object.values(taskGraph.tasks)).filter((task) => !task.hash);
+    // TODO(v25): remove custom hasher support.
     // Separate tasks with custom hashers from those without
     const tasksWithCustomHashers = [];
     const tasksWithoutCustomHashers = [];

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

@@ -98,7 +98,9 @@ function taskGraphFingerprint(taskGraph, ultracacheConfigurations) {
     ];
     for (const id of Object.keys(taskGraph.tasks).sort()) {
         const task = taskGraph.tasks[id];
-        parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).join(','), (taskGraph.continuousDependencies[id] ?? []).join(','));
+        parts.push(id, task.target.project, task.target.target, task.target.configuration ?? '', (task.outputs ?? []).join(','), (taskGraph.dependencies[id] ?? []).map((edge) => edge.id).join(','), (taskGraph.continuousDependencies[id] ?? [])
+            .map((edge) => JSON.stringify([edge.id, edge.inputs === false]))
+            .join(','));
     }
     return (0, native_1.hashArray)(parts);
 }

package/dist/src/hasher/task-hasher.d.ts

@@ -142,6 +142,7 @@ export declare function getInputs(task: Task, projectGraph: ProjectGraph, nxJson
     projectInputs: {
         input: string;
         projects: string[];
+        dependencies?: true;
     }[];
     depsFilesets: {
         fileset: string;
@@ -158,6 +159,7 @@ export declare function splitInputsIntoSelfAndDependencies(inputs: ReadonlyArray
     projectInputs: {
         input: string;
         projects: string[];
+        dependencies?: true;
     }[];
     selfInputs: ExpandedSelfInput[];
     depsOutputs: ExpandedDepsOutput[];

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

@@ -200,7 +200,7 @@ function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
             }
             else if ('input' in d &&
                 !('fileset' in d) &&
-                (('dependencies' in d && d.dependencies) ||
+                (('dependencies' in d && d.dependencies && !('projects' in d)) ||
                     // Todo(@AgentEnder): Remove check in v17
                     ('projects' in d &&
                         typeof d.projects === 'string' &&
@@ -219,6 +219,9 @@ function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
                 projectInputs.push({
                     input: d.input,
                     projects: Array.isArray(d.projects) ? d.projects : [d.projects],
+                    ...('dependencies' in d && d.dependencies
+                        ? { dependencies: true }
+                        : {}),
                 });
             }
             else {

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.d.ts

@@ -6,7 +6,6 @@ import { Tree } from '../../generators/tree';
  * via `cacheableOperations`; Nx 23 removed that derivation and those targets
  * silently stopped being cacheable.
  *
- * Write the intent into the executor key so it no longer depends on the
- * deprecated fallback that restores the old behavior at run time.
+ * Write the intent into the executor key, which is where Nx reads `cache` from.
  */
 export default function update(tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.js

@@ -6,9 +6,6 @@ const format_changed_files_1 = require("../../generators/internal-utils/format-c
 const json_1 = require("../../generators/utils/json");
 const project_configuration_1 = require("../../generators/utils/project-configuration");
 const path_1 = require("../../utils/path");
-// TODO(v24): remove this migration alongside the runtime fallback it exists to
-// retire (`isLegacyCachedTarget` in `target-normalization.ts`), along with its
-// registration in `packages/nx/migrations.json`.
 /**
  * Target defaults resolve to a single key rather than merging, so an executor
  * key hides the target name key entirely. Before Nx 23 a hidden `cache: true`
@@ -16,8 +13,7 @@ const path_1 = require("../../utils/path");
  * via `cacheableOperations`; Nx 23 removed that derivation and those targets
  * silently stopped being cacheable.
  *
- * Write the intent into the executor key so it no longer depends on the
- * deprecated fallback that restores the old behavior at run time.
+ * Write the intent into the executor key, which is where Nx reads `cache` from.
  */
 async function update(tree) {
     const nxJson = (0, project_configuration_1.readNxJson)(tree);
@@ -77,8 +73,8 @@ async function update(tree) {
  * `targets` — including any that is continuous, which makes `nx.json` fail graph
  * construction outright. The key is only safe when every target through it
  * independently wants caching and none of them can be continuous. Anything else
- * is left to the runtime fallback, which decides per target after normalization
- * and can therefore see continuity this migration cannot.
+ * is left unchanged, so those targets stay uncached until someone sets `cache`
+ * on the key by hand.
  */
 function canEnableCache(targetDefaults, key, targets, workspaceRoot, projectsMap) {
     // Targets written with `command` are rewritten to `nx:run-commands` and
@@ -126,9 +122,9 @@ function canEnableCache(targetDefaults, key, targets, workspaceRoot, projectsMap
 }
 /**
  * Whether the target name key declares `cache: true` on an entry that always
- * applies. Mirrors `declaresCacheTrue` in `target-normalization.ts`: a filtered
- * entry declaring `cache` makes the value unknowable without project context,
- * so nothing is claimed. Among unfiltered entries the last wins.
+ * applies. A filtered entry declaring `cache` makes the value unknowable
+ * without project context, so nothing is claimed. Among unfiltered entries the
+ * last wins.
  */
 function declaresCacheTrue(value) {
     if (!value) {
@@ -239,7 +235,6 @@ function executorDeclaresContinuous(executor, workspaceRoot, projectsMap) {
 }
 /**
  * Target names the pre-23 `longRunningTask` guard excluded from caching.
- * Mirrors `isLongRunningTarget` in `target-normalization.ts`.
  */
 function isLongRunningTargetName(targetName) {
     return (targetName.endsWith(':watch') ||