@depup/nx 23.2.1-depup.8 → 23.3.0-depup.0

package/dist/src/project-graph/plugins/nx-plugin-capabilities.d.ts

@@ -0,0 +1,6 @@
+import { type CachedPluginCapabilities, NxPluginCapabilities as NxPluginCapabilitiesStore } from '../../native';
+export type NxPluginCapabilities = CachedPluginCapabilities;
+export declare function getNxPluginCapabilitiesStore(): NxPluginCapabilitiesStore | null;
+export declare function noteGraphReadFromCache(computedAt: number | undefined): void;
+/** Null means "load them", never "no plugin registers anything". */
+export declare function capabilitiesOfNxPluginsReadFromCache(): NxPluginCapabilities[] | null;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxPluginCapabilitiesStore = getNxPluginCapabilitiesStore;
+exports.noteGraphReadFromCache = noteGraphReadFromCache;
+exports.capabilitiesOfNxPluginsReadFromCache = capabilitiesOfNxPluginsReadFromCache;
+const native_1 = require("../../native");
+const db_connection_1 = require("../../utils/db-connection");
+let store;
+function getNxPluginCapabilitiesStore() {
+    // The database is not part of the WASM build.
+    if (native_1.IS_WASM) {
+        return null;
+    }
+    // Checkout-local: the rows describe this checkout's graph.
+    store ??= new native_1.NxPluginCapabilities((0, db_connection_1.getLocalDbConnection)());
+    return store;
+}
+let computedAtOfGraphReadFromCache;
+function noteGraphReadFromCache(computedAt) {
+    computedAtOfGraphReadFromCache = computedAt;
+}
+/** Null means "load them", never "no plugin registers anything". */
+function capabilitiesOfNxPluginsReadFromCache() {
+    if (computedAtOfGraphReadFromCache === undefined) {
+        return null;
+    }
+    return (getNxPluginCapabilitiesStore()?.get(computedAtOfGraphReadFromCache) ?? null);
+}

package/dist/src/project-graph/plugins/task-results-stub.d.ts

@@ -0,0 +1,50 @@
+import type { PostTasksExecutionContext } from './public-api';
+/**
+ * A {@link PostTasksExecutionContext} whose terminal outputs have been lifted
+ * out of `taskResults` and into a map of the paths holding them, so it can
+ * cross a process boundary.
+ *
+ * `taskResults` carries every task's full output inline, so the sender copies
+ * every one of those strings into the serialized payload and pushes the whole
+ * thing across the socket, once per boundary. The strings themselves exist
+ * either way: the runner puts them on each result as its task completes, and
+ * the receiver reads them back eagerly. The bytes are
+ * already on disk at `<cacheDir>/terminalOutputs/<hash>`, so transports carry
+ * paths and each receiver reads them back before any plugin sees the context.
+ *
+ * This is no longer a crash fix. The fallback used to be
+ * `v8.serialize(...).toString('binary')`, which put an oversized payload back
+ * through V8's maximum string length after `JSON.stringify` had already hit it,
+ * so both arms threw. `serialize` returns bytes now and the ceiling is gone;
+ * what is left is the cost of moving the payload at all.
+ *
+ * The paths live here rather than in `terminalOutput` so that field never
+ * holds two meanings: a stubbed result carries no `terminalOutput` at all, so
+ * a transport that forgets to rehydrate hands a plugin a missing value rather
+ * than a filename shaped exactly like real output. The map is required, so a
+ * stubbed context cannot typecheck without one.
+ */
+export type StubbedPostTasksExecutionContext = PostTasksExecutionContext & {
+    /**
+     * Path to the terminal output of each stubbed task, keyed by task id. Out of
+     * band because a task can print anything, so no in-band marker is safe from
+     * a task that prints it.
+     */
+    stubbedTerminalOutputs: Record<string, string>;
+};
+export type MaybeStubbedPostTasksExecutionContext = PostTasksExecutionContext | StubbedPostTasksExecutionContext;
+/**
+ * Swaps outputs out for paths ahead of a transport. Idempotent, so a context
+ * already stubbed for the daemon can be passed on to a plugin worker as-is.
+ */
+export declare function stubTerminalOutputs(context: MaybeStubbedPostTasksExecutionContext): MaybeStubbedPostTasksExecutionContext;
+/**
+ * Reads the outputs back. A no-op on a context that was never stubbed, which
+ * is every in-process plugin run without the daemon.
+ *
+ * The reads are issued together rather than awaited one at a time: a run has
+ * one file per task, they are independent, and this sits between the tasks
+ * finishing and the first plugin seeing the results - so serializing it would
+ * add up every file's latency in front of that.
+ */
+export declare function rehydrateTerminalOutputs(context: MaybeStubbedPostTasksExecutionContext): Promise<PostTasksExecutionContext>;

package/dist/src/project-graph/plugins/task-results-stub.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stubTerminalOutputs = stubTerminalOutputs;
+exports.rehydrateTerminalOutputs = rehydrateTerminalOutputs;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const terminal_output_path_1 = require("../../tasks-runner/terminal-output-path");
+const logger_1 = require("../../utils/logger");
+function isStubbed(context) {
+    return !!context.stubbedTerminalOutputs;
+}
+/**
+ * Swaps outputs out for paths ahead of a transport. Idempotent, so a context
+ * already stubbed for the daemon can be passed on to a plugin worker as-is.
+ */
+function stubTerminalOutputs(context) {
+    if (!context.taskResults) {
+        return context;
+    }
+    const stubbedTerminalOutputs = {
+        ...(isStubbed(context) ? context.stubbedTerminalOutputs : {}),
+    };
+    const taskResults = {};
+    let swapped = false;
+    for (const [id, result] of Object.entries(context.taskResults)) {
+        const path = id in stubbedTerminalOutputs ? null : stubbablePath(result);
+        if (path) {
+            const { terminalOutput, ...withoutOutput } = result;
+            stubbedTerminalOutputs[id] = path;
+            taskResults[id] = withoutOutput;
+            swapped = true;
+        }
+        else {
+            taskResults[id] = result;
+        }
+    }
+    // Nothing to swap: hand back the context as it came, so a run with no
+    // outputs on disk sends exactly what it sent before. Covers the
+    // already-stubbed case too, which keeps its own map by staying untouched.
+    if (!swapped) {
+        return context;
+    }
+    return { ...context, taskResults, stubbedTerminalOutputs };
+}
+/**
+ * Reads the outputs back. A no-op on a context that was never stubbed, which
+ * is every in-process plugin run without the daemon.
+ *
+ * The reads are issued together rather than awaited one at a time: a run has
+ * one file per task, they are independent, and this sits between the tasks
+ * finishing and the first plugin seeing the results - so serializing it would
+ * add up every file's latency in front of that.
+ */
+async function rehydrateTerminalOutputs(context) {
+    if (!isStubbed(context)) {
+        return context;
+    }
+    const taskResults = { ...context.taskResults };
+    const reads = Object.entries(context.stubbedTerminalOutputs)
+        // A stub whose result is gone has nothing to attach the bytes to, so it is
+        // dropped before the read rather than after it.
+        .filter(([id]) => taskResults[id])
+        .map(async ([id, path]) => {
+        const terminalOutput = await readTerminalOutput(path);
+        taskResults[id] = { ...taskResults[id], terminalOutput };
+    });
+    await Promise.all(reads);
+    const { stubbedTerminalOutputs, ...rehydrated } = {
+        ...context,
+        taskResults,
+    };
+    return rehydrated;
+}
+/**
+ * The path to swap in, or null to leave the output inline. A task that failed
+ * before it was hashed has no path, and a task that never ran has no file —
+ * both keep whatever they already carry rather than losing it.
+ */
+function stubbablePath(result) {
+    if (result.terminalOutput === undefined) {
+        return null;
+    }
+    const hash = result.task?.hash;
+    if (!hash) {
+        return null;
+    }
+    // `getCustomHasher` lets a plugin return any string, and this one reaches a
+    // read, so the sink is kept inside the cache dir here rather than trusted to
+    // the hasher. A hash that needed stripping resolves to a file that does not
+    // exist, which falls back to sending the output inline.
+    const path = (0, terminal_output_path_1.terminalOutputPathForHash)((0, node_path_1.basename)(hash));
+    return (0, node_fs_1.existsSync)(path) ? path : null;
+}
+/**
+ * A path that no longer resolves means the bytes are gone. Saying so with
+ * `undefined` — already a legal value, skipped tasks have it — beats leaving
+ * the path, which would have plugins treat a filename as the output.
+ */
+async function readTerminalOutput(path) {
+    if (!path) {
+        return undefined;
+    }
+    try {
+        return await (0, promises_1.readFile)(path, 'utf-8');
+    }
+    catch (e) {
+        logger_1.logger.warn(`Nx could not read a task's terminal output from ${path}: ${e.message}`);
+        return undefined;
+    }
+}

package/dist/src/project-graph/plugins/tasks-execution-hooks.d.ts

@@ -1,3 +1,4 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from './public-api';
+import type { PreTasksExecutionContext } from './public-api';
+import { type MaybeStubbedPostTasksExecutionContext } from './task-results-stub';
 export declare function runPreTasksExecution(pluginContext: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
-export declare function runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
+export declare function runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;

package/dist/src/project-graph/plugins/tasks-execution-hooks.js

@@ -7,8 +7,18 @@ const get_plugins_1 = require("./get-plugins");
 const is_on_daemon_1 = require("../../daemon/is-on-daemon");
 const client_1 = require("../../daemon/client/client");
 const workspace_root_1 = require("../../utils/workspace-root");
+const task_results_stub_1 = require("./task-results-stub");
+const nx_plugin_capabilities_1 = require("./nx-plugin-capabilities");
+/** True only when the cached graph's recorded rows show no plugin has `hook`; unknown is false. */
+function knownThatNoPluginRegisters(hook) {
+    const recorded = (0, nx_plugin_capabilities_1.capabilitiesOfNxPluginsReadFromCache)();
+    return !!recorded && !recorded.some((capabilities) => capabilities[hook]);
+}
 async function runPreTasksExecution(pluginContext) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        if (knownThatNoPluginRegisters('hasPreTasksExecution')) {
+            return [];
+        }
         performance.mark(`preTasksExecution:start`);
         const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(pluginContext.workspaceRoot), pluginContext.workspaceRoot);
         const envs = await Promise.all(plugins
@@ -44,6 +54,9 @@ function applyProcessEnvs(envs) {
 }
 async function runPostTasksExecution(context) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        if (knownThatNoPluginRegisters('hasPostTasksExecution')) {
+            return;
+        }
         performance.mark(`postTasksExecution:start`);
         const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot));
         await Promise.all(plugins
@@ -62,6 +75,6 @@ async function runPostTasksExecution(context) {
         performance.measure(`postTasksExecution`, `postTasksExecution:start`, `postTasksExecution:end`);
     }
     else {
-        await client_1.daemonClient.runPostTasksExecution(context);
+        await client_1.daemonClient.runPostTasksExecution((0, task_results_stub_1.stubTerminalOutputs)(context));
     }
 }

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

@@ -26,9 +26,11 @@ const logger_1 = require("../utils/logger");
 const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
+const workspace_context_1 = require("../utils/workspace-context");
 const build_project_graph_1 = require("./build-project-graph");
 const error_types_1 = require("./error-types");
 const nx_deps_cache_1 = require("./nx-deps-cache");
+const nx_plugin_capabilities_1 = require("./plugins/nx-plugin-capabilities");
 const get_plugins_1 = require("./plugins/get-plugins");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const handle_import_1 = require("../utils/handle-import");
@@ -39,16 +41,21 @@ const handle_import_1 = require("../utils/handle-import");
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
 function readCachedProjectGraph(minimumComputedAt) {
-    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
-    if (!projectGraphCache) {
-        const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
-            ? (0, strip_indents_1.stripIndents) `
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    return cached.projectGraph;
+}
+function noCachedProjectGraphError() {
+    const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+        ? (0, strip_indents_1.stripIndents) `
       Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
       The decorated CLI will compute the project graph.
       'ng --help' should say 'Smart Monorepos · Fast Builds'.
       `
-            : '';
-        throw new Error((0, strip_indents_1.stripIndents) `
+        : '';
+    return new Error((0, strip_indents_1.stripIndents) `
       [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
 
       If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
@@ -58,8 +65,6 @@ function readCachedProjectGraph(minimumComputedAt) {
 
       ${angularSpecificError}
     `);
-    }
-    return projectGraphCache;
 }
 function readCachedProjectConfiguration(projectName) {
     const graph = readCachedProjectGraph();
@@ -85,8 +90,11 @@ function readProjectsConfigurationFromProjectGraph(projectGraph) {
 }
 async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     preventRecursionInGraphConstruction();
+    // Answer from the plugins loaded below, not an earlier cached graph's rows.
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(undefined);
     global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
+    (0, workspace_context_1.refreshWorkspaceContext)(workspace_root_1.workspaceRoot);
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
@@ -136,7 +144,12 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(projectGraphError?.errors ?? []),
     ];
     if (cacheEnabled) {
-        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors);
+        const computedAt = Date.now();
+        // Before the graph, so a cached graph never lacks its row.
+        if (errors.length === 0) {
+            (0, nx_plugin_capabilities_1.getNxPluginCapabilitiesStore)()?.record(computedAt, plugins.map((plugin) => plugin.capabilities()));
+        }
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors, computedAt);
     }
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
@@ -149,14 +162,7 @@ function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
         if (e instanceof error_types_1.ProjectGraphError) {
-            let title = e.message;
-            const bodyLines = isVerbose
-                ? [e.stack]
-                : ['Pass --verbose to see the stacktraces.'];
-            output_1.output.error({
-                title,
-                bodyLines: bodyLines,
-            });
+            output_1.output.error((0, error_types_1.formatProjectGraphError)(e, isVerbose));
         }
         else if (typeof e.message === 'string') {
             const lines = e.message.split('\n');
@@ -178,7 +184,12 @@ function handleProjectGraphError(opts, e) {
     }
 }
 async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
-    const graph = readCachedProjectGraph(minimumComputedAt);
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    const graph = cached.projectGraph;
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(cached.computedAt);
     const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
         data.root,
         project,
@@ -260,45 +271,33 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
         const lock = !native_1.IS_WASM
             ? new native_1.FileLock((0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.lock'))
             : null;
-        let locked = lock?.locked;
-        while (locked) {
+        let holdingLock = lock?.tryLock() ?? false;
+        while (lock && !holdingLock) {
             logger_1.logger.verbose('Waiting for graph construction in another process to complete');
             const spinner = new delayed_spinner_1.DelayedSpinner('Waiting for graph construction in another process to complete');
             const start = Date.now();
-            await lock.wait();
-            spinner.cleanup();
-            // Note: This will currently throw if any of the caches are missing...
-            // It would be nice if one of the processes that was waiting for the lock
-            // could pick up the slack and build the graph if it's missing, but
-            // we wouldn't want either of the below to happen:
-            // - All of the waiting processes to build the graph
-            // - Even one of the processes building the graph on a legitimate error
             try {
-                // Ensuring that computedAt was after this process started
-                // waiting for the graph to complete, means that the graph
-                // was computed by the process was already working.
+                await lock.wait();
+                // A graph computed after this process started waiting is the holder's.
                 const graph = await readCachedGraphAndHydrateFileMap(start);
                 const sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
                 if (!sourceMaps) {
                     throw new Error('The project graph was computed in another process, but the source maps are missing.');
                 }
-                return {
-                    projectGraph: graph,
-                    sourceMaps,
-                };
+                return { projectGraph: graph, sourceMaps };
             }
             catch (e) {
-                // If the error is that the cached graph is stale after unlock,
-                // the process that was working on the graph must have been canceled,
-                // so we will fall through to the normal flow to ensure
-                // its created by one of the processes that was waiting
                 if (!(e instanceof error_types_1.StaleProjectGraphCacheError)) {
                     throw e;
                 }
+                // The holder stopped without writing a graph: build it here, or wait for
+                // whoever took the lock first.
+                holdingLock = lock.tryLock();
+            }
+            finally {
+                spinner.cleanup();
             }
-            locked = lock.check();
         }
-        lock?.lock();
         try {
             const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
             perf_hooks_1.performance.measure('createProjectGraphAsync >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
@@ -323,7 +322,9 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
             handleProjectGraphError(opts, e);
         }
         finally {
-            lock?.unlock();
+            if (holdingLock) {
+                lock.unlock();
+            }
         }
     }
     else {

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

@@ -139,6 +139,60 @@ function mergeConfigurationValue(newConfig, baseConfig, projectConfigSourceMap,
     }
     return merged;
 }
+// `ultracache` keeps replace-unless-`'...'` semantics at the object level, but its
+// values still have to be merged per key: neither the wholesale replace nor
+// `mergeObjectWithSpread` recurses, so an `ignoredReads: ['...', 'tmp/**']`
+// would otherwise reach the task graph with `'...'` intact — a glob matching
+// nothing, silently dropping the inherited patterns.
+function mergeUltracache(newUltracache, baseUltracache, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    if (newUltracache === undefined) {
+        return baseUltracache;
+    }
+    const sourceMapContext = projectConfigSourceMap
+        ? {
+            sourceMap: projectConfigSourceMap,
+            key: `${targetIdentifier}.ultracache`,
+            sourceInformation,
+        }
+        : undefined;
+    // Object level first: this settles which keys survive, their order, and
+    // their source-map attribution.
+    const merged = (0, utils_1.getMergeValueResult)(baseUltracache, newUltracache, sourceMapContext, deferSpreadsWithoutBase);
+    if (!merged || typeof merged !== 'object' || Array.isArray(merged)) {
+        return merged;
+    }
+    // Copy before resolving: with no object-level spread `getMergeValueResult`
+    // returns `newUltracache` itself, and writing through it would edit the
+    // caller's target in place, corrupting later merge layers.
+    const resolved = { ...merged };
+    // Keys authored before `'...'` let the base win, exactly as they do at the
+    // target level. Re-resolving those would overwrite the object-level merge's
+    // decision and make authored position meaningless for array keys while
+    // still honouring it for scalar ones.
+    const authoredKeys = Object.keys(newUltracache);
+    const spreadPosition = authoredKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const keysBeforeSpread = spreadPosition >= 0
+        ? new Set(authoredKeys.slice(0, spreadPosition))
+        : new Set();
+    // Then re-resolve any key the target authored as an array, so a nested
+    // `'...'` expands against the inherited value rather than surviving as a
+    // literal element.
+    for (const key of Object.keys(resolved)) {
+        if (!Array.isArray(newUltracache[key]))
+            continue;
+        if (keysBeforeSpread.has(key) && baseUltracache && key in baseUltracache) {
+            continue;
+        }
+        resolved[key] = (0, utils_1.getMergeValueResult)(baseUltracache?.[key], newUltracache[key], projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.ultracache.${key}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return resolved;
+}
 function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
     const mergedConfigurations = {};
     // Keys before '...' let base win for shared names; keys after '...'
@@ -305,6 +359,7 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     const skipForOwnMerge = new Set([
         'options',
         'configurations',
+        'ultracache',
         utils_1.NX_SPREAD_TOKEN,
     ]);
     const processKey = (key) => {
@@ -428,6 +483,18 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
                 sourceInformation;
         }
     }
+    // merge ultracache if either side declares one
+    // as with options, an incompatible target discards the base.
+    // `ultracache` is in `skipForOwnMerge` so the key-by-key pass leaves it to
+    // this block; removing it from that set would change only the key's position
+    // in the result, since this overwrites whatever the generic pass produced.
+    if ('ultracache' in target ||
+        (isCompatible && baseTarget && 'ultracache' in baseTarget)) {
+        const mergedUltracache = mergeUltracache(target.ultracache, isCompatible ? baseTarget?.ultracache : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (mergedUltracache !== undefined) {
+            result.ultracache = mergedUltracache;
+        }
+    }
     if (target.metadata) {
         result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
     }

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

@@ -10,6 +10,7 @@ const output_1 = require("../../../utils/output");
 const to_project_name_1 = require("../../../config/to-project-name");
 const error_types_1 = require("../../error-types");
 const target_merging_1 = require("./target-merging");
+const utils_1 = require("./utils");
 const node_fs_1 = require("node:fs");
 const git_worktrees_1 = require("../../../utils/git-worktrees");
 const path_1 = require("path");
@@ -176,6 +177,87 @@ function warnAboutLegacyCachedTargets(legacyCacheReads) {
         bodyLines,
     });
 }
+/**
+ * Nothing downstream rejects a key it does not know — the Rust hasher drops it,
+ * the Cloud runner reads only the keys it reads, and the Kotlin API decodes with
+ * `ignoreUnknownKeys`. So a typo is silent everywhere else, and this is the only
+ * place a misspelled option can be reported at all. `'...'` is listed because a
+ * spread with no base to resolve against survives merging.
+ */
+const KNOWN_ULTRACACHE_KEYS = new Set([
+    'mode',
+    'ignoredReads',
+    'ignoredWrites',
+    utils_1.NX_SPREAD_TOKEN,
+]);
+const ULTRACACHE_MODES = ['on', 'warn', 'error', 'off'];
+function describeUltracacheValue(value) {
+    if (Array.isArray(value))
+        return 'an array';
+    if (value === null)
+        return 'null';
+    return `a ${typeof value}`;
+}
+/**
+ * Describes every way an `ultracache` violates the shape the schema forbids.
+ *
+ * The schema is editor-only, and everything downstream — the Rust task hasher,
+ * the cloud runner's Go and Kotlin deserializers — is strict. A bad value that
+ * gets this far is reported far from its source, or silently drops the task's
+ * tracking, so it is worth reporting here where the project, target and file
+ * are all still in hand.
+ *
+ * Returns messages rather than throwing: only a WorkspaceValidityError is
+ * collected by `validateAndNormalizeProjectRootMap`, and anything else escapes
+ * as far as the daemon, which exits on an error it cannot classify.
+ */
+function validateTargetUltracache(ultracache, projectName, projectRoot, targetName, sourceMaps) {
+    if (ultracache === undefined) {
+        return [];
+    }
+    const targetSourceMaps = sourceMaps?.[projectRoot];
+    const [file, plugin] = targetSourceMaps?.[`targets.${targetName}.ultracache`] ??
+        targetSourceMaps?.[`targets.${targetName}`] ??
+        [];
+    const origin = file
+        ? ` (defined in ${file})`
+        : plugin
+            ? ` (defined by ${plugin})`
+            : '';
+    const where = `"${targetName}" in project "${projectName}"${origin}`;
+    if (!(0, utils_1.isObject)(ultracache)) {
+        return [
+            `The "ultracache" configuration for target ${where} must be an object, but it is ${describeUltracacheValue(ultracache)}.`,
+        ];
+    }
+    const errors = [];
+    for (const key of Object.keys(ultracache)) {
+        if (!KNOWN_ULTRACACHE_KEYS.has(key)) {
+            errors.push(`"ultracache.${key}" for target ${where} is not an ultracache option. Supported options are "mode", "ignoredReads" and "ignoredWrites".`);
+        }
+    }
+    if (ultracache.mode !== undefined &&
+        !ULTRACACHE_MODES.includes(ultracache.mode)) {
+        const supported = ULTRACACHE_MODES.map((mode) => `"${mode}"`).join(', ');
+        errors.push(`"ultracache.mode" for target ${where} must be one of ${supported}, but it is ${typeof ultracache.mode === 'string'
+            ? `"${ultracache.mode}"`
+            : describeUltracacheValue(ultracache.mode)}.`);
+    }
+    for (const key of ['ignoredReads', 'ignoredWrites']) {
+        const value = ultracache[key];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value)) {
+            errors.push(`"ultracache.${key}" for target ${where} must be an array of glob patterns, but it is ${describeUltracacheValue(value)}.`);
+            continue;
+        }
+        const badIndex = value.findIndex((glob) => typeof glob !== 'string');
+        if (badIndex !== -1) {
+            errors.push(`"ultracache.${key}[${badIndex}]" for target ${where} must be a glob pattern string, but it is ${describeUltracacheValue(value[badIndex])}.`);
+        }
+    }
+    return errors;
+}
 function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
 /**
  * Project configurations keyed by project name
@@ -190,6 +272,7 @@ legacyCacheReads) {
     for (const targetName in project.targets) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
         const target = project.targets[targetName];
+        targetErrorMessage.push(...validateTargetUltracache(target.ultracache, project.name ?? project.root, project.root, targetName, sourceMaps).map((message) => `- ${message}`));
         const targetDefaults = nxJsonConfiguration.targetDefaults;
         if (isLegacyCachedTarget(targetName, targetDefaults, target)) {
             target.cache = true;

package/dist/src/project-graph/utils/project-configuration/utils.d.ts

@@ -35,4 +35,5 @@ type SourceMapContext = {
  * preserved so a later merge layer can expand it.
  */
 export declare function getMergeValueResult<T>(baseValue: unknown, newValue: T | undefined, sourceMapContext?: SourceMapContext, deferSpreadsWithoutBase?: boolean): T | undefined;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
 export {};

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

@@ -4,6 +4,7 @@ exports.IntegerLikeSpreadKeyError = exports.INTEGER_LIKE_KEY_PATTERN = exports.N
 exports.uniqueKeysInObjects = uniqueKeysInObjects;
 exports.assertNoIntegerLikeSpreadKey = assertNoIntegerLikeSpreadKey;
 exports.getMergeValueResult = getMergeValueResult;
+exports.isObject = isObject;
 const source_maps_1 = require("./source-maps");
 exports.NX_SPREAD_TOKEN = '...';
 /**

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

@@ -62,13 +62,28 @@ async function runTasks(executorName, projectGraph, batchTaskGraph, fullTaskGrap
     catch (e) {
         const isVerbose = tasks[0].overrides.verbose;
         console.error(isVerbose ? e : e.message);
+        // `process.exit` does not wait for pipe writes, so the reason this worker
+        // died could otherwise be the one line that never arrives.
+        await flushStdio();
         process.exit(1);
     }
 }
+/**
+ * Waits until everything written to stdout and stderr so far has reached the
+ * pipe. Writes to a pipe are asynchronous, and the parent learns the batch is
+ * over through a separate IPC channel - so without this it can be told the batch
+ * finished, or see the process exit, while the end of its output is still in
+ * memory here. That tail is where a tool reports what went wrong.
+ */
+function flushStdio() {
+    const flush = (stream) => new Promise((resolve) => stream.write('', () => resolve()));
+    return Promise.all([flush(process.stdout), flush(process.stderr)]).then(() => undefined);
+}
 process.on('message', async (message) => {
     switch (message.type) {
         case batch_messages_1.BatchMessageType.RunTasks: {
             const results = await runTasks(message.executorName, message.projectGraph, message.batchTaskGraph, message.fullTaskGraph);
+            await flushStdio();
             process.send({
                 type: batch_messages_1.BatchMessageType.CompleteBatchExecution,
                 results,