nx 23.2.0-beta.1 → 23.2.0-beta.3

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

@@ -13,10 +13,10 @@ const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const plugin_progress_text_1 = require("../../utils/plugin-progress-text");
 const progress_topics_1 = require("../../utils/progress-topics");
 const error_types_1 = require("../error-types");
-const source_maps_1 = require("./project-configuration/source-maps");
 const target_defaults_1 = require("./project-configuration/target-defaults");
 var target_merging_1 = require("./project-configuration/target-merging");
 Object.defineProperty(exports, "mergeTargetConfigurations", { enumerable: true, get: function () { return target_merging_1.mergeTargetConfigurations; } });
+const target_merging_2 = require("./project-configuration/target-merging");
 var target_defaults_2 = require("./project-configuration/target-defaults");
 Object.defineProperty(exports, "readTargetDefaultsForTarget", { enumerable: true, get: function () { return target_defaults_2.readTargetDefaultsForTarget; } });
 /**
@@ -123,14 +123,13 @@ async function createProjectConfigurationsWithPlugins(root = workspace_root_1.wo
  * Runs a single plugin batch through two passes:
  *
  * 1. Every project node in every plugin result is handed to `mergeFn`,
- *    which decides where it lands (the manager's rootMap, an
- *    intermediate rootMap, etc.). Any failure is collected into
- *    `errors`; processing keeps going. External nodes are accumulated
- *    onto the shared `externalNodes` record.
+ *    which merges it into the manager's rootMap. Any failure is
+ *    collected into `errors`; processing keeps going. External nodes
+ *    are accumulated onto the shared `externalNodes` record.
  * 2. After every project in the batch has been merged, name-reference
- *    sentinels for the batch are registered against `nameRefRootMap` —
- *    the rootMap the batch was merged into — so sentinels point at the
- *    target objects that actually received the merges.
+ *    sentinels for the batch are registered against the manager's
+ *    rootMap, so sentinels point at the target objects that actually
+ *    received the merges.
  *
  * The two passes can't be collapsed: a sentinel registered too early
  * would point at the pre-merge object, and a later project in the same
@@ -138,7 +137,11 @@ async function createProjectConfigurationsWithPlugins(root = workspace_root_1.wo
  * the registration into a second pass also lets forward references
  * inside the same batch resolve eagerly.
  */
-function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesManager, nameRefRootMap, externalNodes, errors) {
+function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesManager, externalNodes, errors) {
+    mergeSinglePluginResults(pluginResults, mergeFn, externalNodes, errors);
+    registerNameRefsFromSinglePlugin(pluginResults, nodesManager, errors);
+}
+function mergeSinglePluginResults(pluginResults, mergeFn, externalNodes, errors) {
     for (const result of pluginResults) {
         const [pluginName, file, nodes, pluginIndex] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
@@ -156,11 +159,13 @@ function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesMa
         }
         Object.assign(externalNodes, pluginExternalNodes);
     }
+}
+function registerNameRefsFromSinglePlugin(pluginResults, nodesManager, errors) {
     for (const result of pluginResults) {
         const [pluginName, file, nodes, pluginIndex] = result;
         const { projects: projectNodes } = nodes;
         try {
-            nodesManager.registerNameRefs(projectNodes, nameRefRootMap);
+            nodesManager.registerNameRefs(projectNodes);
         }
         catch (error) {
             errors.push(new error_types_1.MergeNodesError({ file, pluginName, error, pluginIndex }));
@@ -170,108 +175,83 @@ function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesMa
 /**
  * Merges create nodes results into a single rootMap.
  *
- * Specified plugin results are merged once into the manager. Default
- * plugin results are first staged into an intermediate rootMap (with
- * `'...'` spreads deferred) so that synthesis can read each layer's
- * contribution without re-running the merge. The synthetic result from
- * `createTargetDefaultsResults` is then merged into the manager, and
- * the staged intermediate is replayed on top — that replay is where
- * deferred spreads expand against the final (specified + synth) base.
+ * Every layer merges into the manager through the same source-map-aware
+ * merge, in precedence order:
+ *
+ *   specified plugins → synthetic target defaults → default plugins
+ *
+ * so field-level provenance is decided by the merge itself for all three
+ * layers — whichever layer a field's final value came from owns its
+ * attribution, and `'...'` spreads in default-plugin configs resolve against
+ * the accumulated specified + target-defaults base.
  *
- * Synthesis itself doesn't materialize a second rootMap. Per
- * (root, target) it does an on-the-fly merge of the two layered
- * contributions to learn the eventual executor/command, then matches
- * defaults against that merged shape. This keeps specified-plugin
- * merge work to a single pass.
+ * Target-default synthesis needs the *merged* shape of the default layer
+ * (to predict each target's eventual executor/command) before that layer
+ * merges into the manager. To get it, default results are first staged into
+ * a throwaway intermediate rootMap with unresolvable `'...'` spreads
+ * deferred. The staging output feeds only `createTargetDefaultsResults`; the
+ * default plugins then merge into the manager from their original results.
  */
 function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const nodesManager = new project_nodes_manager_1.ProjectNodesManager();
     const externalNodes = {};
     const configurationSourceMaps = {};
-    const intermediateDefaultRootMap = {};
-    // Kept separate so the intermediate merge doesn't clobber
-    // specified/TD attribution on fields the defaults don't touch.
-    const defaultConfigurationSourceMaps = {};
     const mergeToManager = (project, sourceInfo) => nodesManager.mergeProjectNode(project, configurationSourceMaps, sourceInfo);
-    const mergeToIntermediate = (project, sourceInfo) => {
-        (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(intermediateDefaultRootMap, project, defaultConfigurationSourceMaps, sourceInfo);
-    };
     for (const pluginResults of specifiedResults) {
-        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
-    }
-    for (const pluginResults of defaultResults) {
-        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToIntermediate, nodesManager, intermediateDefaultRootMap, externalNodes, errors);
-    }
-    const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration, configurationSourceMaps, defaultConfigurationSourceMaps);
-    if (targetDefaultsResults.length > 0) {
-        mergeCreateNodesResultsFromSinglePlugin(targetDefaultsResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, externalNodes, errors);
     }
-    // Apply the intermediate default rootMap as a single layer. Preserved
-    // spread sentinels resolve here against the real specified + TD base.
-    // Source maps are intentionally not written — TD attribution for
-    // fields that yield to the base (e.g. keys before `...`) stays intact.
-    for (const root in intermediateDefaultRootMap) {
-        const project = intermediateDefaultRootMap[root];
-        try {
-            nodesManager.mergeProjectNode(project, undefined, undefined);
+    // Without target defaults there is nothing to synthesize, and the staging
+    // pass exists only to feed synthesis — skip straight to the default-plugin
+    // merge.
+    if (Object.keys(nxJsonConfiguration.targetDefaults ?? {}).length > 0) {
+        // Throwaway staging area: the default layer's merged shape (unresolvable
+        // `'...'` spreads deferred), read only by target-default synthesis. The
+        // default plugins merge into the manager from their original results, not
+        // from this map. No source maps are kept for it — synthesis attributes
+        // targets without them (a default plugin can never be named by a
+        // `filter.plugin`); the real default merge writes the manager's.
+        const intermediateDefaultRootMap = {};
+        // The rootMap merge adopts input arrays/objects by reference and grows
+        // them in place (e.g. `mergeMetadata`), so staging works on deep clones —
+        // handing it the plugin results themselves would corrupt them before the
+        // real merge below reads them.
+        const mergeToIntermediate = (project, sourceInfo) => {
+            (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(intermediateDefaultRootMap, (0, target_merging_2.deepClone)(project), undefined, sourceInfo, false, true);
+        };
+        // Stage the default layer for synthesis. Merge errors are discarded and
+        // external nodes land in a scratch object — the same results merge into
+        // the manager below, where both surface once with proper plugin context.
+        // The discard is safe because every merge throw is base-independent in
+        // both its condition and its reachability: each throw's condition reads
+        // only the plugin's own config, and the spread-ambiguity throws fire even
+        // when a key is dropped by a base-owns-key shortcut, because those
+        // shortcuts eagerly validate the dropped value (`assertNoIntegerLikeSpreadKey`).
+        // So a given config raises the same error in this pass and the real merge
+        // below despite their bases differing.
+        // Name references are NOT registered here: `applySubstitutions` sweeps only
+        // the manager's `rootMap`, so sentinels registered against this throwaway
+        // rootMap would never be visited and would never resolve.
+        const stagingErrors = [];
+        const stagingExternalNodes = {};
+        for (const pluginResults of defaultResults) {
+            mergeSinglePluginResults(pluginResults, mergeToIntermediate, stagingExternalNodes, stagingErrors);
         }
-        catch (error) {
-            errors.push(new error_types_1.MergeNodesError({
-                file: 'nx.json',
-                pluginName: 'nx/default-plugins',
-                error,
-                pluginIndex: undefined,
-            }));
+        const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration, configurationSourceMaps);
+        if (targetDefaultsResults.length > 0) {
+            mergeCreateNodesResultsFromSinglePlugin(targetDefaultsResults, mergeToManager, nodesManager, externalNodes, errors);
         }
     }
-    // The intermediate apply may have rebuilt dependsOn / inputs arrays via
-    // spread merges, introducing name-ref strings that weren't visible in any
-    // single plugin result. Re-walking the final merged targets sentinelizes
-    // them so the final substitution sweep resolves them too.
-    nodesManager.registerNameRefs(intermediateDefaultRootMap);
-    // Overlay default-plugin attribution onto the main source maps using
-    // "only fill missing" semantics. Any key already present in
-    // configurationSourceMaps was written by a specified plugin or by
-    // target defaults, and that attribution is strictly more correct:
-    //  - For fields the default plugin never shadowed, the existing entry
-    //    already matches what the default plugin would overlay.
-    //  - For fields where a default plugin placed `...` after other keys,
-    //    those keys yielded to the base during the single-layer apply
-    //    above. The stale default-plugin entry in
-    //    `defaultConfigurationSourceMaps` must NOT clobber the base
-    //    attribution that the specified plugin / TD already recorded.
-    const mainRootMap = nodesManager.getRootMap();
-    for (const root in defaultConfigurationSourceMaps) {
-        const existing = (configurationSourceMaps[root] ??= {});
-        const incoming = defaultConfigurationSourceMaps[root];
-        // A default plugin's targets are synthesized into the main rootmap by
-        // target defaults *before* the default layer is applied, so target
-        // defaults wrote the main source map's entry for the target node and its
-        // identity fields first — even though it never authored them (it only
-        // stamps them as a merge guard and cannot bring a target into existence).
-        // The identity fields are the executor/command plus, for run-commands, the
-        // `options.command`/`options.commands` the synthetic copies from the winner
-        // to stay compatible (#36067). For those keys, the real default plugin's
-        // attribution must override the target-defaults stamp.
-        const identityKeys = new Set();
-        for (const targetName in mainRootMap[root]?.targets ?? {}) {
-            const base = (0, source_maps_1.targetSourceMapKey)(targetName);
-            identityKeys.add(base);
-            identityKeys.add(`${base}.executor`);
-            identityKeys.add(`${base}.command`);
-            identityKeys.add(`${base}.options.command`);
-            identityKeys.add(`${base}.options.commands`);
-        }
-        for (const key in incoming) {
-            if (existing[key] === undefined) {
-                existing[key] = incoming[key];
-            }
-            else if (identityKeys.has(key) &&
-                existing[key][1] === source_maps_1.TARGET_DEFAULTS_PLUGIN_NAME) {
-                existing[key] = incoming[key];
-            }
-        }
+    // Merge the default plugins into the manager on top of the specified + TD
+    // base, from their original results. This is the same source-map-aware path
+    // the other layers take, so every field a default plugin wins — including
+    // fields it overrides on a specified/TD target — is attributed to it by the
+    // merge itself, `'...'` spreads resolve against the real base (keys a spread
+    // lets the base win keep their base attribution), and identity provenance
+    // follows the node-ownership rules in `recordTargetIdentitySourceMapInfo` /
+    // `getMergeValueResult`.
+    for (const pluginResults of defaultResults) {
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, externalNodes, errors);
     }
     const projectRootMap = nodesManager.getRootMap();
     try {

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -44,7 +44,7 @@ export interface LifeCycle {
     startTasks?(task: Task[], metadata: TaskMetadata): void | Promise<void>;
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTask?(taskId: string, ptyHandles: ExternalObject<[any, any, any]>): void;
     registerRunningTaskWithEmptyParser?(taskId: string): void;
     appendTaskOutput?(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
@@ -72,7 +72,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     startTasks(tasks: Task[], metadata: TaskMetadata): Promise<void>;
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
-    registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTask(taskId: string, ptyHandles: ExternalObject<[any, any, any]>): void;
     registerRunningTaskWithEmptyParser(taskId: string): void;
     appendTaskOutput(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;

package/dist/src/tasks-runner/life-cycle.js

@@ -67,10 +67,10 @@ class CompositeLifeCycle {
             }
         }
     }
-    registerRunningTask(taskId, parserAndWriter) {
+    registerRunningTask(taskId, ptyHandles) {
         for (let l of this.lifeCycles) {
             if (l.registerRunningTask) {
-                l.registerRunningTask(taskId, parserAndWriter);
+                l.registerRunningTask(taskId, ptyHandles);
             }
         }
     }

package/dist/src/tasks-runner/pseudo-terminal.d.ts

@@ -47,7 +47,7 @@ export declare class PseudoTtyProcess implements RunningTask {
     onOutput(callback: (message: string) => void): void;
     getPid(): number | undefined;
     kill(s?: NodeJS.Signals): Promise<void>;
-    getParserAndWriter(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc]>;
+    getPtyHandles(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc, import("../native").MasterArc]>;
 }
 export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
     rustPseudoTerminal: RustPseudoTerminal;

package/dist/src/tasks-runner/pseudo-terminal.js

@@ -150,8 +150,8 @@ class PseudoTtyProcess {
             }
         }
     }
-    getParserAndWriter() {
-        return this.childProcess.getParserAndWriter();
+    getPtyHandles() {
+        return this.childProcess.getPtyHandles();
     }
 }
 exports.PseudoTtyProcess = PseudoTtyProcess;

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

@@ -1,5 +1,14 @@
 import { ProjectGraph } from '../config/project-graph';
 import { Task } from '../config/task-graph';
+/**
+ * Resolves the FORCE_COLOR value for forked child processes.
+ *
+ * When the user sets FORCE_COLOR=0, bin/nx.ts deletes it from process.env
+ * (workaround for picocolors treating "0" as truthy) and saves the original
+ * value in NX_ORIGINAL_FORCE_COLOR. Without this check, the undefined
+ * FORCE_COLOR would default to 'true', re-enabling colors in all children.
+ */
+export declare function getForceColorForChild(): string;
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task, graph: ProjectGraph): NodeJS.ProcessEnv;
 export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForceColorForChild = getForceColorForChild;
 exports.getEnvVariablesForBatchProcess = getEnvVariablesForBatchProcess;
 exports.getTaskSpecificEnv = getTaskSpecificEnv;
 exports.getEnvVariablesForTask = getEnvVariablesForTask;
@@ -11,13 +12,33 @@ const dotenv_expand_1 = require("dotenv-expand");
 const node_path_1 = require("node:path");
 const workspace_root_1 = require("../utils/workspace-root");
 const task_env_paths_1 = require("./task-env-paths");
+/**
+ * Resolves the FORCE_COLOR value for forked child processes.
+ *
+ * When the user sets FORCE_COLOR=0, bin/nx.ts deletes it from process.env
+ * (workaround for picocolors treating "0" as truthy) and saves the original
+ * value in NX_ORIGINAL_FORCE_COLOR. Without this check, the undefined
+ * FORCE_COLOR would default to 'true', re-enabling colors in all children.
+ */
+function getForceColorForChild() {
+    if (process.env.FORCE_COLOR !== undefined) {
+        return process.env.FORCE_COLOR;
+    }
+    if (process.env.NX_ORIGINAL_FORCE_COLOR === '0') {
+        return '0';
+    }
+    return 'true';
+}
 function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
-    return {
+    const res = {
         // User Process Env Variables override Dotenv Variables
         ...process.env,
         // Nx Env Variables overrides everything
-        ...getNxEnvVariablesForForkedProcess(process.env.FORCE_COLOR === undefined ? 'true' : process.env.FORCE_COLOR, skipNxCache, captureStderr),
+        ...getNxEnvVariablesForForkedProcess(getForceColorForChild(), skipNxCache, captureStderr),
     };
+    // NX_ORIGINAL_FORCE_COLOR is an internal signal and should not leak into child processes
+    delete res.NX_ORIGINAL_FORCE_COLOR;
+    return res;
 }
 // The orchestrator now calls this eagerly during the coordinator pre-hash
 // in addition to processTask (and again in hashBatchTasks), so the same
@@ -58,6 +79,9 @@ function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache,
     }
     // we don't reset NX_BASE or NX_HEAD because those are set by the user and should be preserved
     delete res.NX_SET_CLI;
+    // NX_ORIGINAL_FORCE_COLOR is an internal signal used by getForceColorForChild()
+    // and should not leak into child processes
+    delete res.NX_ORIGINAL_FORCE_COLOR;
     return res;
 }
 function getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput) {

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

@@ -35,6 +35,7 @@ export declare class TaskOrchestrator {
     private reverseTaskDeps;
     private initializingTaskIds;
     private processedTasks;
+    private cacheMissedHashes;
     private completedTasks;
     private waitingForTasks;
     private pendingDiscreteWorkers;
@@ -100,7 +101,9 @@ export declare class TaskOrchestrator {
      * The coordinator relies on this running unconditionally (when cache
      * is enabled): tasks dispatched in step 5 via runTaskDirectly skip
      * their own cache lookup on the assumption that this has already
-     * confirmed them as misses. Don't add length-based bails.
+     * confirmed them as misses. Excluding cacheMissedHashes preserves that
+     * invariant — every dispatched hash was queried exactly once — but
+     * don't add other length-based bails.
      */
     private resolveCachedTasksBulk;
     /**

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

@@ -79,6 +79,12 @@ class TaskOrchestrator {
         // underlying real tasks become the anchors.
         this.initializingTaskIds = (0, utils_1.expandInitiatingTasksThroughNoop)(this.initiatingTasks, this.taskGraph, this.projectGraph);
         this.processedTasks = new Map();
+        // Hashes confirmed absent from the cache this run. A confirmed miss can
+        // only become a hit when the task itself runs — and then it leaves the
+        // schedule — so a missed hash never needs re-querying. Without this, a
+        // miss waiting for a worker slot is re-queried (including the remote
+        // retrieval) on every coordinator cycle.
+        this.cacheMissedHashes = new Set();
         this.completedTasks = new Map();
         this.waitingForTasks = [];
         this.pendingDiscreteWorkers = new Set();
@@ -324,9 +330,12 @@ class TaskOrchestrator {
      * inside DbCache.getBatch.
      */
     async fetchCacheHits(tasks) {
-        const batchResults = await this.cache.getBatch(tasks);
+        const tasksToQuery = tasks.filter((t) => t.hash && !this.cacheMissedHashes.has(t.hash));
+        if (tasksToQuery.length === 0)
+            return [];
+        const batchResults = await this.cache.getBatch(tasksToQuery);
         const cacheHits = [];
-        for (const task of tasks) {
+        for (const task of tasksToQuery) {
             const cachedResult = batchResults.get(task.hash);
             // Replay a cached result only under the same condition it was cached
             // under (shouldCacheTaskResult): successes always, failures only when
@@ -335,6 +344,9 @@ class TaskOrchestrator {
             if (cachedResult && this.shouldCacheTaskResult(task, cachedResult.code)) {
                 cacheHits.push({ task, cachedResult });
             }
+            else {
+                this.cacheMissedHashes.add(task.hash);
+            }
         }
         return cacheHits;
     }
@@ -396,14 +408,19 @@ class TaskOrchestrator {
      * The coordinator relies on this running unconditionally (when cache
      * is enabled): tasks dispatched in step 5 via runTaskDirectly skip
      * their own cache lookup on the assumption that this has already
-     * confirmed them as misses. Don't add length-based bails.
+     * confirmed them as misses. Excluding cacheMissedHashes preserves that
+     * invariant — every dispatched hash was queried exactly once — but
+     * don't add other length-based bails.
      */
     async resolveCachedTasksBulk() {
         const { scheduledTasks } = this.tasksSchedule.getAllScheduledTasks();
         const candidates = [];
         for (const id of scheduledTasks) {
             const task = this.taskGraph.tasks[id];
-            if (task.hash && !task.continuous && task.cache) {
+            if (task.hash &&
+                !this.cacheMissedHashes.has(task.hash) &&
+                !task.continuous &&
+                task.cache) {
                 candidates.push(task);
             }
         }
@@ -714,9 +731,7 @@ class TaskOrchestrator {
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         const env = pipeOutput
-            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
-                ? 'true'
-                : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
+            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, (0, task_env_1.getForceColorForChild)(), this.options.skipNxCache, this.options.captureStderr, null, null)
             : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
         let resolveDiscreteExit;
         const discreteExitHandled = new Promise((r) => (resolveDiscreteExit = r));
@@ -790,7 +805,7 @@ class TaskOrchestrator {
                 else if (this.tuiEnabled) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                         // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                         runningTask.onOutput((output) => {
                             this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                         });
@@ -839,7 +854,7 @@ class TaskOrchestrator {
             if (this.tuiEnabled) {
                 if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                     // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                     runningTask.onOutput((output) => {
                         this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                     });
@@ -927,9 +942,7 @@ class TaskOrchestrator {
             ? false
             : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         let env = pipeOutput
-            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
-                ? 'true'
-                : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
+            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, (0, task_env_1.getForceColorForChild)(), this.options.skipNxCache, this.options.captureStderr, null, null)
             : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
         this.detectTaskInvocationLoop(task);
         const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);

package/dist/src/utils/acknowledge-build-scripts.js

@@ -7,6 +7,7 @@ const yaml_1 = require("yaml");
 const semver_1 = require("semver");
 const package_manager_1 = require("./package-manager");
 const fileutils_1 = require("./fileutils");
+const json_1 = require("./json");
 const PNPM_WORKSPACE_FILE = 'pnpm-workspace.yaml';
 /**
  * Records build-script decisions for dependencies that are about to be
@@ -42,23 +43,24 @@ function acknowledgePnpmBuildScripts(treeOrRoot, entries) {
     // A file that doesn't parse cleanly or whose root isn't a mapping is
     // malformed for pnpm; leave it alone rather than crashing or replacing the
     // user's content. pnpm's own error on the file is the actionable signal.
+    // Empty and comment-only files have no contents at all; setIn creates the
+    // mapping for them while keeping whatever comments they carry.
     if (parsed.errors.length > 0 ||
         (parsed.contents != null && !(parsed.contents instanceof yaml_1.YAMLMap))) {
         return;
     }
-    const doc = parsed.contents instanceof yaml_1.YAMLMap ? parsed : new yaml_1.Document({});
     let changed = false;
     for (const [pkg, allowed] of Object.entries(entries)) {
         // Only a real boolean is a user decision. pnpm's non-strict installs stub
         // undecided packages with a placeholder string ("set this to true or
         // false"), which would fail the next strict install if left in place.
-        if (typeof doc.getIn(['allowBuilds', pkg]) !== 'boolean') {
-            doc.setIn(['allowBuilds', pkg], allowed);
+        if (typeof parsed.getIn(['allowBuilds', pkg]) !== 'boolean') {
+            parsed.setIn(['allowBuilds', pkg], allowed);
             changed = true;
         }
     }
     if (changed) {
-        host.write(PNPM_WORKSPACE_FILE, doc.toString());
+        host.write(PNPM_WORKSPACE_FILE, parsed.toString());
     }
 }
 function createHost(treeOrRoot) {
@@ -76,7 +78,7 @@ function createHost(treeOrRoot) {
         exists: (p) => treeOrRoot.exists(p),
         read: (p) => treeOrRoot.read(p, 'utf-8'),
         write: (p, c) => treeOrRoot.write(p, c),
-        readJson: (p) => JSON.parse(treeOrRoot.read(p, 'utf-8')),
+        readJson: (p) => (0, json_1.parseJson)(treeOrRoot.read(p, 'utf-8')),
     };
 }
 function getPnpmVersion(host) {

package/dist/src/utils/analytics-prompt.d.ts

@@ -7,9 +7,3 @@
  */
 export declare function ensureAnalyticsPreferenceSet(root?: string, interactive?: boolean): Promise<'yes' | 'no' | 'unset'>;
 export declare function promptForAnalyticsPreference(): Promise<boolean>;
-/**
- * Generates a deterministic workspace ID.
- * Priority: nxCloudId > git remote URL (hashed).
- * Returns null if neither is available (no telemetry).
- */
-export declare function generateWorkspaceId(cwd?: string): string | null;

package/dist/src/utils/analytics-prompt.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAnalyticsPreferenceSet = ensureAnalyticsPreferenceSet;
 exports.promptForAnalyticsPreference = promptForAnalyticsPreference;
-exports.generateWorkspaceId = generateWorkspaceId;
-const crypto_1 = require("crypto");
-const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const enquirer_1 = require("enquirer");
 const path_1 = require("path");
@@ -85,51 +82,3 @@ async function saveAnalyticsPreference(root, enabled) {
         // Silently fail - don't block user's command
     }
 }
-/**
- * Generates a deterministic workspace ID.
- * Priority: nxCloudId > git remote URL (hashed).
- * Returns null if neither is available (no telemetry).
- */
-function generateWorkspaceId(cwd) {
-    const root = cwd ?? workspace_root_1.workspaceRoot;
-    // Use nxCloudId if available — most stable identifier
-    const nxJson = (0, nx_json_1.readNxJson)(root);
-    const nxCloudId = nxJson?.nxCloudId ?? nxJson?.nxCloudAccessToken;
-    if (nxCloudId) {
-        return nxCloudId;
-    }
-    // Fall back to git remote URL hash
-    try {
-        const remoteUrl = (0, child_process_1.execSync)('git remote get-url origin', {
-            stdio: 'pipe',
-            cwd: root,
-            windowsHide: true,
-        })
-            .toString()
-            .trim();
-        if (remoteUrl) {
-            return (0, crypto_1.createHash)('sha256').update(remoteUrl).digest('hex').slice(0, 32);
-        }
-    }
-    catch {
-        // No git remote available
-    }
-    // Fall back to first commit SHA — already a hash
-    try {
-        const firstCommit = (0, child_process_1.execSync)('git rev-list --max-parents=0 HEAD', {
-            stdio: 'pipe',
-            cwd: root,
-            windowsHide: true,
-        })
-            .toString()
-            .trim()
-            .split('\n')[0];
-        if (firstCommit) {
-            return firstCommit;
-        }
-    }
-    catch {
-        // Not a git repo
-    }
-    return null;
-}

package/dist/src/utils/catalog/bun-manager-utils.d.ts

@@ -0,0 +1,8 @@
+import type { Tree } from '../../generators/tree';
+import type { CatalogDefinitions } from './types';
+export declare function readBunCatalogDefinitions(filename: string, treeOrRoot: Tree | string, cache: Map<string, CatalogDefinitions | null>): CatalogDefinitions | null;
+export declare function updateBunCatalogVersionsInFile(filename: string, treeOrRoot: Tree | string, updates: Array<{
+    packageName: string;
+    version: string;
+    catalogName?: string;
+}>): void;