nx 23.1.0 → 23.2.0-beta.0

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

@@ -25,6 +25,10 @@ function registerPluginTSTranspiler() {
     if (exports.unregisterPluginTSTranspiler !== null) {
         return;
     }
+    // Align Node's runtime resolution with the source-first plugin entry so the
+    // plugin's transitive workspace imports don't fall through to unbuilt `dist`.
+    // A no-op inside a plugin worker/daemon already spawned with `--conditions`.
+    (0, register_1.ensureResolveConditionsInjected)((0, typescript_1.getRootTsConfigResolveExportsConditions)(workspace_root_1.workspaceRoot));
     if ((0, register_1.isNativeStripPreferred)()) {
         // Native strip handles `.ts` syntax but doesn't rewrite NodeNext-style
         // `.js` relative specifiers to their `.ts` sources. Patch the CJS resolver

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

@@ -4,16 +4,13 @@ import { ProjectConfiguration } from '../../../config/workspace-json-project-jso
  * reference. `RootRef` carries the referenced project's root (resolved
  * via nameMap lookup); `UsageRef` carries the raw written name (for
  * forward refs, promoted to `RootRef` in place when the name is
- * identified). `parent` + `key` let the final pass write the resolved
- * name back; `targetPart` preserves the `:target` suffix from
+ * identified). `targetPart` preserves the `:target` suffix from
  * `dependsOn` strings.
  */
 export declare abstract class NameRef {
     value: string;
-    parent: unknown;
-    key: string | undefined;
     targetPart: string | undefined;
-    constructor(value: string, parent: unknown, key: string | undefined, targetPart: string | undefined);
+    constructor(value: string, targetPart: string | undefined);
 }
 export declare class RootRef extends NameRef {
 }
@@ -27,15 +24,15 @@ export declare function isUsageRef(value: unknown): value is UsageRef;
  * then resolves them after all merging is done.
  *
  * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Arrays spread-merge by pushing
- * element references, so sentinel identity survives any downstream
- * merges — the final pass walks a flat registry and writes the resolved
- * name back through each sentinel's `parent` back-reference. Orphaned
- * sentinels (from arrays dropped by a full-replace) write harmlessly.
+ * so each ref becomes a sentinel object. Merges copy sentinels by
+ * reference — one sentinel can end up in many arrays (e.g. a pattern
+ * target's dependsOn applied to every matching target) — so the final
+ * pass sweeps the merged rootMap and resolves every sentinel where it
+ * actually sits. Sentinels in arrays dropped by a full-replace are never
+ * visited and vanish with their array.
  */
 export declare class ProjectNameInNodePropsManager {
     private getNameMap;
-    private allRefs;
     private pendingByName;
     constructor(getNameMap?: () => Record<string, ProjectConfiguration>);
     registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
@@ -45,6 +42,6 @@ export declare class ProjectNameInNodePropsManager {
     private createRef;
     identifyProjectWithRoot(root: string, name: string): void;
     applySubstitutions(rootMap: Record<string, ProjectConfiguration>): void;
+    private substituteInArray;
     private resolveFinalName;
-    private writeReplacement;
 }

package/dist/src/project-graph/utils/project-configuration/name-substitution-manager.js

@@ -11,15 +11,12 @@ const split_target_1 = require("../../../utils/split-target");
  * reference. `RootRef` carries the referenced project's root (resolved
  * via nameMap lookup); `UsageRef` carries the raw written name (for
  * forward refs, promoted to `RootRef` in place when the name is
- * identified). `parent` + `key` let the final pass write the resolved
- * name back; `targetPart` preserves the `:target` suffix from
+ * identified). `targetPart` preserves the `:target` suffix from
  * `dependsOn` strings.
  */
 class NameRef {
-    constructor(value, parent, key, targetPart) {
+    constructor(value, targetPart) {
         this.value = value;
-        this.parent = parent;
-        this.key = key;
         this.targetPart = targetPart;
     }
 }
@@ -44,15 +41,15 @@ function isUsageRef(value) {
  * then resolves them after all merging is done.
  *
  * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Arrays spread-merge by pushing
- * element references, so sentinel identity survives any downstream
- * merges — the final pass walks a flat registry and writes the resolved
- * name back through each sentinel's `parent` back-reference. Orphaned
- * sentinels (from arrays dropped by a full-replace) write harmlessly.
+ * so each ref becomes a sentinel object. Merges copy sentinels by
+ * reference — one sentinel can end up in many arrays (e.g. a pattern
+ * target's dependsOn applied to every matching target) — so the final
+ * pass sweeps the merged rootMap and resolves every sentinel where it
+ * actually sits. Sentinels in arrays dropped by a full-replace are never
+ * visited and vanish with their array.
  */
 class ProjectNameInNodePropsManager {
     constructor(getNameMap) {
-        this.allRefs = new Set();
         this.pendingByName = new Map();
         this.getNameMap = getNameMap ?? (() => ({}));
     }
@@ -82,26 +79,20 @@ class ProjectNameInNodePropsManager {
     processInputs(inputs) {
         for (let i = 0; i < inputs.length; i++) {
             const entry = inputs[i];
-            // Existing sentinel: spread merges may have copied it out of its
-            // original array, so rebind parent to this one.
-            if (isNameRef(entry)) {
-                entry.parent = inputs;
+            if (isNameRef(entry))
                 continue;
-            }
             if (!entry || typeof entry !== 'object')
                 continue;
             if (!('projects' in entry))
                 continue;
             const element = entry;
             const projects = element.projects;
-            if (isNameRef(projects)) {
-                // Object-parent sentinel — element identity is stable across spread.
+            if (isNameRef(projects))
                 continue;
-            }
             if (typeof projects === 'string') {
                 if (projects === 'self' || projects === 'dependencies')
                     continue;
-                element.projects = this.createRef(projects, element, 'projects');
+                element.projects = this.createRef(projects);
             }
             else if (Array.isArray(projects)) {
                 this.processProjectsArray(projects);
@@ -111,12 +102,8 @@ class ProjectNameInNodePropsManager {
     processDependsOn(dependsOn, ownerTargets, ownerName) {
         for (let i = 0; i < dependsOn.length; i++) {
             const dep = dependsOn[i];
-            // Existing sentinel: rebind parent to this array in case a spread
-            // merge copied it out of its original.
-            if (isNameRef(dep)) {
-                dep.parent = dependsOn;
+            if (isNameRef(dep))
                 continue;
-            }
             if (typeof dep === 'string') {
                 // `^target` and same-project targets aren't cross-project refs.
                 if (dep.startsWith('^') || (ownerTargets && dep in ownerTargets)) {
@@ -126,7 +113,7 @@ class ProjectNameInNodePropsManager {
                 if (rest.length === 0)
                     continue;
                 const targetPart = rest.join(':');
-                dependsOn[i] = this.createRef(maybeProject, dependsOn, undefined, targetPart);
+                dependsOn[i] = this.createRef(maybeProject, targetPart);
                 continue;
             }
             if (!dep || typeof dep !== 'object' || !('projects' in dep))
@@ -142,7 +129,7 @@ class ProjectNameInNodePropsManager {
                     projects === 'dependencies') {
                     continue;
                 }
-                element.projects = this.createRef(projects, element, 'projects');
+                element.projects = this.createRef(projects);
             }
             else if (Array.isArray(projects)) {
                 this.processProjectsArray(projects);
@@ -152,24 +139,21 @@ class ProjectNameInNodePropsManager {
     processProjectsArray(projects) {
         for (let j = 0; j < projects.length; j++) {
             const name = projects[j];
-            if (isNameRef(name)) {
-                name.parent = projects;
+            if (isNameRef(name))
                 continue;
-            }
             if (typeof name !== 'string')
                 continue;
             if ((0, globs_1.isGlobPattern)(name))
                 continue;
-            projects[j] = this.createRef(name, projects, undefined);
+            projects[j] = this.createRef(name);
         }
     }
     // Builds a sentinel and registers it.
-    createRef(referencedName, parent, key, targetPart) {
+    createRef(referencedName, targetPart) {
         const referencedRoot = this.getNameMap()[referencedName]?.root;
         const ref = referencedRoot !== undefined
-            ? new RootRef(referencedRoot, parent, key, targetPart)
-            : new UsageRef(referencedName, parent, key, targetPart);
-        this.allRefs.add(ref);
+            ? new RootRef(referencedRoot, targetPart)
+            : new UsageRef(referencedName, targetPart);
         if (ref instanceof UsageRef) {
             let set = this.pendingByName.get(referencedName);
             if (!set) {
@@ -195,25 +179,72 @@ class ProjectNameInNodePropsManager {
             ref.value = root;
         }
     }
-    // Writes each sentinel's current resolved name back into its owning slot.
-    // Called once after all plugin results have been merged.
+    // Resolves every sentinel in the merged rootMap in place. Sweeping the
+    // final config (rather than writing through back-references held by the
+    // sentinels) covers sentinels that merges copied into arrays other than
+    // the one they were created in, e.g. a pattern target's dependsOn applied
+    // to every matching target. Called once after all plugin results have
+    // been merged.
     applySubstitutions(rootMap) {
         const nameByRoot = {};
         for (const root in rootMap) {
             nameByRoot[root] = rootMap[root]?.name;
         }
-        for (const ref of this.allRefs) {
-            const finalName = this.resolveFinalName(ref, nameByRoot);
-            if (finalName === undefined)
-                continue;
-            const replacement = ref.targetPart !== undefined
-                ? `${finalName}:${ref.targetPart}`
-                : finalName;
-            this.writeReplacement(ref, replacement);
+        for (const root in rootMap) {
+            const targets = rootMap[root]?.targets;
+            if (!targets)
+                continue;
+            for (const targetName in targets) {
+                const targetConfig = targets[targetName];
+                if (!targetConfig || typeof targetConfig !== 'object')
+                    continue;
+                if (Array.isArray(targetConfig.inputs)) {
+                    this.substituteInArray(targetConfig.inputs, nameByRoot);
+                }
+                if (Array.isArray(targetConfig.dependsOn)) {
+                    this.substituteInArray(targetConfig.dependsOn, nameByRoot);
+                }
+            }
         }
-        this.allRefs.clear();
         this.pendingByName.clear();
     }
+    substituteInArray(entries, nameByRoot) {
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (isNameRef(entry)) {
+                const finalName = this.resolveFinalName(entry, nameByRoot);
+                if (finalName !== undefined) {
+                    entries[i] =
+                        entry.targetPart !== undefined
+                            ? `${finalName}:${entry.targetPart}`
+                            : finalName;
+                }
+                continue;
+            }
+            if (!entry || typeof entry !== 'object' || !('projects' in entry)) {
+                continue;
+            }
+            const element = entry;
+            if (isNameRef(element.projects)) {
+                const finalName = this.resolveFinalName(element.projects, nameByRoot);
+                if (finalName !== undefined) {
+                    element.projects = finalName;
+                }
+            }
+            else if (Array.isArray(element.projects)) {
+                const projects = element.projects;
+                for (let j = 0; j < projects.length; j++) {
+                    const name = projects[j];
+                    if (!isNameRef(name))
+                        continue;
+                    const finalName = this.resolveFinalName(name, nameByRoot);
+                    if (finalName !== undefined) {
+                        projects[j] = finalName;
+                    }
+                }
+            }
+        }
+    }
     resolveFinalName(ref, nameByRoot) {
         if (ref instanceof RootRef) {
             return nameByRoot[ref.value];
@@ -221,20 +252,5 @@ class ProjectNameInNodePropsManager {
         // Unpromoted forward ref — best effort, fall back to the written name.
         return this.getNameMap()[ref.value]?.name ?? ref.value;
     }
-    writeReplacement(ref, replacement) {
-        const parent = ref.parent;
-        if (Array.isArray(parent)) {
-            // One sentinel may appear at multiple indices (e.g. `[..., ...]`
-            // pushed the same reference twice via spread), so replace all.
-            for (let i = 0; i < parent.length; i++) {
-                if (parent[i] === ref)
-                    parent[i] = replacement;
-            }
-            return;
-        }
-        if (parent && typeof parent === 'object' && ref.key !== undefined) {
-            parent[ref.key] = replacement;
-        }
-    }
 }
 exports.ProjectNameInNodePropsManager = ProjectNameInNodePropsManager;

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

@@ -34,7 +34,7 @@ export declare class ProjectNodesManager {
      *
      * Pass a different `mergedRootMap` for the default-plugin intermediate
      * pass, then call again with `this.rootMap` after it's applied so
-     * sentinel parents rebind onto the final arrays.
+     * name refs introduced by that merge are sentinelized as well.
      */
     registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>, mergedRootMap?: Record<string, ProjectConfiguration>): void;
     /**

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

@@ -263,7 +263,7 @@ class ProjectNodesManager {
      *
      * Pass a different `mergedRootMap` for the default-plugin intermediate
      * pass, then call again with `this.rootMap` after it's applied so
-     * sentinel parents rebind onto the final arrays.
+     * name refs introduced by that merge are sentinelized as well.
      */
     registerNameRefs(pluginResultProjects, mergedRootMap = this.rootMap) {
         if (!pluginResultProjects)

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

@@ -225,12 +225,10 @@ function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfigu
             }));
         }
     }
-    // The intermediate apply may have rebuilt dependsOn / inputs arrays
-    // via spread merges, leaving sentinels inserted against the
-    // intermediate rootMap pointing at now-orphaned arrays. Re-walking
-    // the final merged targets rebinds each encountered sentinel's
-    // `parent` to the current array (see
-    // ProjectNameInNodePropsManager#processInputs / processDependsOn).
+    // 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

package/dist/src/tasks-runner/life-cycles/performance-analysis.d.ts

@@ -60,6 +60,8 @@ export interface PerformanceSummary {
     cacheableCount: number;
     cacheSkipped: boolean;
     remoteCacheEnabled: boolean;
+    /** The workspace opted out of Nx Cloud (`neverConnectToCloud` / NX_NO_CLOUD) — never recommend it. */
+    cloudOptedOut: boolean;
 }
 /** Construction-time inputs for {@link PerformanceLifeCycle}. */
 export interface PerformanceLifeCycleOptions {

package/dist/src/tasks-runner/life-cycles/performance-analysis.js

@@ -18,6 +18,8 @@ const CACHE_HIT_STATUSES = new Set([
 ]);
 /** Gap (ms) still counted as the same pre-dispatch hashing phase; a larger gap means older, unrelated hashing (e.g. a daemon's previous run). */
 const PRE_DISPATCH_HASH_GAP = 1000;
+/** A critical-path task shorter than this fraction of the path is noise, not a speed-up target. */
+const CRITICAL_PATH_TOP_MIN_FRACTION = 0.2;
 /**
  * Pure analysis over one finished run's collected timings — no lifecycle state and no
  * mutation. Built once per run from the {@link PerformanceLifeCycle}'s accumulated
@@ -171,15 +173,17 @@ class PerformanceAnalysis {
      * (their duration is just restore time); no-status tasks (synthetic test runs) are
      * kept.
      */
-    computeCriticalPathTop(criticalPathTasks, durations) {
-        return criticalPathTasks
+    computeCriticalPathTop(criticalPathTasks, durations, criticalPathDuration) {
+        return (criticalPathTasks
             .filter((id) => {
             const status = this.statuses.get(id);
             return !status || !CACHE_HIT_STATUSES.has(status);
         })
             .map((id) => ({ id, duration: durations.get(id) ?? 0 }))
+            // Only tasks that meaningfully shape the path are worth speeding up.
+            .filter((t) => t.duration >= CRITICAL_PATH_TOP_MIN_FRACTION * criticalPathDuration)
             .sort((a, b) => b.duration - a.duration)
-            .slice(0, 3);
+            .slice(0, 3));
     }
     /** Cache outcome: tasks restored (`cacheHits`) and the total with a cache outcome (`cacheableCount` = hits + ran). No-status tasks count for neither. */
     computeCacheStats() {
@@ -244,12 +248,15 @@ class PerformanceAnalysis {
             cores,
             criticalPathDuration,
         });
-        const criticalPathTop = this.computeCriticalPathTop(criticalPathTasks, durations);
+        const criticalPathTop = this.computeCriticalPathTop(criticalPathTasks, durations, criticalPathDuration);
         const { cacheHits, cacheableCount } = this.computeCacheStats();
         // `skipNxCache` already folds in NX_SKIP_NX_CACHE / NX_DISABLE_NX_CACHE
         // (normalized in command-line-utils) — don't re-read those env vars here.
         const cacheSkipped = this.options.skipNxCache === true;
         const remoteCacheEnabled = this.remoteCacheEnabled();
+        const cloudOptedOut = this.options.nxJson
+            ? !!(0, nx_cloud_utils_1.isNxCloudDisabled)(this.options.nxJson)
+            : false;
         // Coordinator-dominated: hashing/scheduling outweighs task work by >3x the
         // critical path, which keeps cold runs critical-path-bound.
         const coordinatorDominated = coordinatorOverhead >= performance_report_1.MEANINGFUL_OVERHEAD &&
@@ -271,14 +278,16 @@ class PerformanceAnalysis {
             parallel,
             cores,
             isCI,
-            // Can only start distributing in CI when not already doing so.
-            canDistribute: isCI && !distributing,
+            // Can only start distributing in CI when not already doing so — and never
+            // suggest Nx Agents to a workspace that opted out of Nx Cloud.
+            canDistribute: isCI && !distributing && !cloudOptedOut,
             distributing,
             coordinatorDominated,
             cacheHits,
             cacheableCount,
             cacheSkipped,
             remoteCacheEnabled,
+            cloudOptedOut,
         };
     }
 }

package/dist/src/tasks-runner/life-cycles/performance-report.d.ts

@@ -25,6 +25,8 @@ interface RecLink {
  * Links are URL-less (the popup re-links them from {@link PerformanceSummaryPayload.links}).
  */
 export declare function recommendationToPayloadString(rec: Recommendation): string;
+/** Below this run duration (ms), the run is already fast — recommend nothing. */
+export declare const MIN_RECOMMENDATION_RUN_DURATION = 30000;
 /** Below this (ms) overhead is noise, not worth a recommendation. */
 export declare const MEANINGFUL_OVERHEAD = 1000;
 /**

package/dist/src/tasks-runner/life-cycles/performance-report.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEANINGFUL_OVERHEAD = void 0;
+exports.MEANINGFUL_OVERHEAD = exports.MIN_RECOMMENDATION_RUN_DURATION = void 0;
 exports.recommendationToPayloadString = recommendationToPayloadString;
 exports.buildRecommendations = buildRecommendations;
 exports.formatReport = formatReport;
@@ -59,6 +59,8 @@ function recommendationLinks(recommendations) {
         .filter(isRecLink)
         .map((part) => ({ text: part.visible, href: part.href })));
 }
+/** Below this run duration (ms), the run is already fast — recommend nothing. */
+exports.MIN_RECOMMENDATION_RUN_DURATION = 30_000;
 /** At/below this hit rate, recommend remote cache (if off); above it caching works. */
 const LOW_CACHE_HIT_RATE = 0.1;
 /** Below this (ms) overhead is noise, not worth a recommendation. */
@@ -136,8 +138,10 @@ const RECOMMENDATIONS = [
     },
     {
         // Barely-used cache with no remote: set up Nx Cloud. Whole-phrase link; the payload
-        // string stays URL-less (the popup re-links the phrase).
+        // string stays URL-less (the popup re-links the phrase). Never pushed at a
+        // workspace that opted out of Nx Cloud.
         isApplicable: (c) => !c.cacheSkipped &&
+            !c.cloudOptedOut &&
             c.cacheableCount > 0 &&
             !c.remoteCacheEnabled &&
             c.cacheHits / c.cacheableCount <= LOW_CACHE_HIT_RATE,
@@ -181,6 +185,10 @@ const RECOMMENDATIONS = [
  * the GitHub-summary Markdown, and the TUI payload.
  */
 function buildRecommendations(s) {
+    // A fast run has nothing worth optimizing — stats only, no advice.
+    if (s.runDuration < exports.MIN_RECOMMENDATION_RUN_DURATION) {
+        return [];
+    }
     const c = {
         recoverableByParallel: s.recoverableByParallel,
         recoverableByMachines: s.recoverableByMachines,
@@ -194,6 +202,7 @@ function buildRecommendations(s) {
         cacheableCount: s.cacheableCount,
         cacheSkipped: s.cacheSkipped,
         remoteCacheEnabled: s.remoteCacheEnabled,
+        cloudOptedOut: s.cloudOptedOut,
     };
     return RECOMMENDATIONS.filter((r) => r.isApplicable(c)).map((r) => r.build(c));
 }

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

@@ -25,6 +25,7 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const logger_1 = require("../utils/logger");
 const nx_key_1 = require("../utils/nx-key");
 const output_1 = require("../utils/output");
+const configure_ai_agents_disclaimer_1 = require("../ai/configure-ai-agents-disclaimer");
 const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
@@ -168,7 +169,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const lifeCycles = [tsLifeCycle];
         // Only run the TUI if there are tasks to run
         if (tasks.length > 0) {
-            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph);
+            appLifeCycle = new AppLifeCycle(tasks, initiatingTasks.map((t) => t.id), isRunOne ? 0 /* RunMode.RunOne */ : 1 /* RunMode.RunMany */, pinnedTasks, nxArgs ?? {}, nxJson.tui ?? {}, titleText, workspace_root_1.workspaceRoot, taskGraph, (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson));
             // The native endCommand renders the perf report in the exit popup; the runner
             // sources the payload and CompositeLifeCycle forwards it here.
             lifeCycles.unshift(appLifeCycle);
@@ -410,9 +411,10 @@ async function printConfigureAiAgentsDisclaimer() {
             return;
         }
         const { outdatedAgents } = await client_1.daemonClient.getConfigureAiAgentsStatus();
-        if (outdatedAgents.length > 0) {
-            output_1.output.logRawLine(output_1.output.dim('Your AI agent configuration is outdated. Run "nx configure-ai-agents" to update.'));
+        if (!(0, configure_ai_agents_disclaimer_1.shouldPrintConfigureAiAgentsDisclaimer)(outdatedAgents, workspace_root_1.workspaceRoot)) {
+            return;
         }
+        output_1.output.logRawLine(output_1.output.dim('Your AI agent configuration is outdated. Run "nx configure-ai-agents" to update.'));
     }
     catch {
         // Silently ignore errors

package/dist/src/utils/acknowledge-build-scripts.d.ts

@@ -0,0 +1,13 @@
+import type { Tree } from '../generators/tree';
+import type { PackageManager } from './package-manager';
+/**
+ * Records build-script decisions for dependencies that are about to be
+ * installed, in whatever form the given package manager understands.
+ *
+ * Only pnpm needs this today: pnpm 11+ refuses to install a dependency whose
+ * build scripts are neither allowed nor denied, so the generator or command
+ * that introduces such a dependency records the decision up front. Other
+ * package managers run build scripts unconditionally, so this is a no-op for
+ * them.
+ */
+export declare function acknowledgeBuildScripts(treeOrRoot: Tree | string, packageManager: PackageManager, entries: Record<string, boolean>): void;

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acknowledgeBuildScripts = acknowledgeBuildScripts;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const yaml_1 = require("yaml");
+const semver_1 = require("semver");
+const package_manager_1 = require("./package-manager");
+const fileutils_1 = require("./fileutils");
+const PNPM_WORKSPACE_FILE = 'pnpm-workspace.yaml';
+/**
+ * Records build-script decisions for dependencies that are about to be
+ * installed, in whatever form the given package manager understands.
+ *
+ * Only pnpm needs this today: pnpm 11+ refuses to install a dependency whose
+ * build scripts are neither allowed nor denied, so the generator or command
+ * that introduces such a dependency records the decision up front. Other
+ * package managers run build scripts unconditionally, so this is a no-op for
+ * them.
+ */
+function acknowledgeBuildScripts(treeOrRoot, packageManager, entries) {
+    if (packageManager !== 'pnpm') {
+        return;
+    }
+    acknowledgePnpmBuildScripts(treeOrRoot, entries);
+}
+/**
+ * Records `allowBuilds` decisions in pnpm-workspace.yaml, creating the file
+ * when missing (mirroring `pnpm approve-builds` in single-package repos).
+ *
+ * Comment-preserving. Existing entries are never overwritten, so user
+ * decisions always win. No-op for pnpm < 11, which warns instead of erroring
+ * and does not read `allowBuilds`.
+ */
+function acknowledgePnpmBuildScripts(treeOrRoot, entries) {
+    const host = createHost(treeOrRoot);
+    const pnpmVersion = getPnpmVersion(host);
+    if (!pnpmVersion || !(0, semver_1.gte)(pnpmVersion, '11.0.0')) {
+        return;
+    }
+    const parsed = (0, yaml_1.parseDocument)(host.exists(PNPM_WORKSPACE_FILE) ? host.read(PNPM_WORKSPACE_FILE) : '');
+    // 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.
+    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);
+            changed = true;
+        }
+    }
+    if (changed) {
+        host.write(PNPM_WORKSPACE_FILE, doc.toString());
+    }
+}
+function createHost(treeOrRoot) {
+    if (typeof treeOrRoot === 'string') {
+        return {
+            root: treeOrRoot,
+            exists: (p) => (0, fs_1.existsSync)((0, path_1.join)(treeOrRoot, p)),
+            read: (p) => (0, fs_1.readFileSync)((0, path_1.join)(treeOrRoot, p), 'utf-8'),
+            write: (p, c) => (0, fs_1.writeFileSync)((0, path_1.join)(treeOrRoot, p), c),
+            readJson: (p) => (0, fileutils_1.readJsonFile)((0, path_1.join)(treeOrRoot, p)),
+        };
+    }
+    return {
+        root: treeOrRoot.root,
+        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')),
+    };
+}
+function getPnpmVersion(host) {
+    // The host's packageManager field wins: during workspace creation the
+    // in-flight package.json only exists in the tree, not on disk.
+    if (host.exists('package.json')) {
+        const { packageManager } = host.readJson('package.json');
+        const version = (0, package_manager_1.parseVersionFromPackageManagerField)('pnpm', typeof packageManager === 'string' ? packageManager : undefined);
+        if (version) {
+            return version;
+        }
+    }
+    try {
+        return (0, package_manager_1.getPackageManagerVersion)('pnpm', host.root);
+    }
+    catch {
+        // The version cannot be probed (e.g. pnpm is not on PATH). Leave the
+        // workspace file untouched; pnpm's own install error remains actionable.
+        return null;
+    }
+}

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

@@ -1,7 +1,6 @@
 import type { Tree } from '../../generators/tree';
 import type { CatalogDefinitions } from './types';
-export declare function readCatalogConfigFromFs(filename: string, fullPath: string): CatalogDefinitions | null;
-export declare function readCatalogConfigFromTree(filename: string, tree: Tree): CatalogDefinitions | null;
+export declare function readCatalogDefinitions(filename: string, treeOrRoot: Tree | string, cache: Map<string, CatalogDefinitions | null>): CatalogDefinitions | null;
 export declare function updateCatalogVersionsInFile(filename: string, treeOrRoot: Tree | string, updates: Array<{
     packageName: string;
     version: string;