nx 23.1.0 → 23.2.0-beta.1

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-life-cycle.js

@@ -142,8 +142,9 @@ function flushPerformanceReport() {
         // restore_terminal cooks the terminal back post-TUI, so console.log's plain \n
         // renders fine; it also supplies the single trailing newline formatReport omits.
         console.log((0, performance_report_1.formatReport)(summary));
-        // In GitHub Actions, also append the report (plus a per-task table) to the job
-        // summary page. Independent of the console.log above so neither masks the other.
+        // In GitHub Actions, also append the report to the job summary page — the same stats
+        // as above, led by the run's outcome (a failed-tasks list, or a success line).
+        // Independent of the console.log above so neither masks the other.
         writePerformanceReportToGitHubActions(summary);
     }
     catch (e) {
@@ -157,8 +158,8 @@ function flushPerformanceReport() {
 /**
  * Append the performance report to the GitHub Actions job summary page when running in
  * Actions (`$GITHUB_STEP_SUMMARY` is set there and nowhere else). No-op otherwise. The
- * per-task table is computed lazily so non-CI runs don't pay for it. Best-effort: a
- * write failure must never affect the run.
+ * Markdown is rendered below the guard, so non-CI runs don't pay to format a report
+ * nothing reads. Best-effort: a write failure must never affect the run.
  *
  * Skipped for a nested run (one nx command invoked by another nx task's command), so only
  * the outermost run writes to the summary. Nx sets `NX_TASK_TARGET_PROJECT` on every task's

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

@@ -1,12 +1,16 @@
 import type { PerformanceSummaryPayload } from '../../native';
-import type { PerformanceSummary } from './performance-analysis';
+import type { PerformanceSummary, TaskDurationRow } from './performance-analysis';
 /**
- * A recommendation built from structured parts so the link text comes from the
- * link definition (not a substring scanned out of the assembled report). A part
- * is either literal text or a {@link RecLink}; the renderers below project the
- * same parts to the terminal string, the payload string, and the popup links.
+ * A recommendation built from structured parts so the link text comes from the link
+ * definition (not a substring scanned out of the assembled report). A part is literal
+ * text, a {@link RecLink}, or a {@link RecTaskRows}, projected to each output string by
+ * {@link renderRecommendation}.
+ *
+ * String parts must be single-line — multi-line content needs its own structured part (as
+ * {@link RecTaskRows} is). TS can't enforce this: `string` is already a handled member, so
+ * a multi-line one compiles and then breaks the Markdown nested list.
  */
-type RecPart = string | RecLink;
+type RecPart = string | RecLink | RecTaskRows;
 export type Recommendation = RecPart[];
 /**
  * A docs link inside a recommendation: a sentence is the visible text and the whole of
@@ -15,16 +19,22 @@ export type Recommendation = RecPart[];
  * re-links the phrase from {@link PerformanceSummaryPayload.links}.
  */
 interface RecLink {
-    /** Visible label: the sentence that links. */
     visible: string;
-    /** OSC 8 click target / appended URL: the utm-tagged URL. */
     href: string;
 }
+/**
+ * The critical path's longest tasks as data, so each renderer formats them natively:
+ * the terminal and payload as space-aligned columns, Markdown as a nested list
+ * (HTML collapses space runs, so aligned columns don't survive rendering there).
+ */
+type RecTaskRows = TaskDurationRow[];
 /**
  * The recommendation string the napi payload ships and the Rust popup matches against.
  * 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;
@@ -25,15 +25,49 @@ const NX_DISTRIBUTE_CTA = 'Distribute across machines with Nx Agents';
 function phraseLink(phrase, taggedUrl) {
     return { visible: phrase, href: taggedUrl };
 }
+// Discriminate positively — test for what each part *is*. A `!isRecTaskRows` catch-all
+// would misclassify a future `RecPart` member as a link; TS can't catch that (it never
+// checks a predicate body), so `recommendationLinks`' `.filter(isRecLink)` would ship
+// `{text: undefined, href: undefined}` to the popup.
 function isRecLink(part) {
-    return typeof part !== 'string';
+    return typeof part !== 'string' && 'href' in part;
+}
+function isRecTaskRows(part) {
+    return Array.isArray(part);
+}
+/**
+ * Project a recommendation to a string, formatting each non-text part with the caller's
+ * renderers. The three output targets (payload, terminal, Markdown) share this one dispatch.
+ * After the string and task-rows branches a part is a {@link RecLink}, so `render.link`
+ * takes it directly — and a new {@link RecPart} member that is neither would fail to satisfy
+ * that `RecLink` parameter, turning "forgot to handle it" into a compile error right here.
+ */
+function renderRecommendation(rec, render) {
+    return rec
+        .map((part) => {
+        if (typeof part === 'string') {
+            return part;
+        }
+        if (isRecTaskRows(part)) {
+            return render.taskRows(part);
+        }
+        return render.link(part);
+    })
+        .join('');
 }
 /**
  * The recommendation string the napi payload ships and the Rust popup matches against.
  * Links are URL-less (the popup re-links them from {@link PerformanceSummaryPayload.links}).
  */
 function recommendationToPayloadString(rec) {
-    return rec.map((part) => (!isRecLink(part) ? part : part.visible)).join('');
+    return renderRecommendation(rec, {
+        link: (link) => link.visible,
+        taskRows: taskRowsToText,
+    });
+}
+/** Task rows as the text block the terminal and payload embed: newline-led, space-aligned columns. */
+function taskRowsToText(tasks) {
+    return ['', ...formatTopTaskRows(tasks)].join('\n');
 }
 /**
  * The recommendation as a terminal string. With OSC 8 the phrase becomes a hyperlink
@@ -42,16 +76,12 @@ function recommendationToPayloadString(rec) {
  * are off.
  */
 function recommendationToTerminalString(rec, hyperlinks) {
-    return rec
-        .map((part) => {
-        if (!isRecLink(part)) {
-            return part;
-        }
-        return hyperlinks
-            ? (0, terminal_link_1.terminalLink)(part.visible, part.href)
-            : `${part.visible} → ${part.href}`;
-    })
-        .join('');
+    return renderRecommendation(rec, {
+        link: (link) => hyperlinks
+            ? (0, terminal_link_1.terminalLink)(link.visible, link.href)
+            : `${link.visible} → ${link.href}`,
+        taskRows: taskRowsToText,
+    });
 }
 /** The popup links (phrase + href) for every link in a recommendation list, for OSC 8 re-linking. */
 function recommendationLinks(recommendations) {
@@ -59,6 +89,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. */
@@ -75,7 +107,8 @@ function recoverableTime(s) {
 }
 /** Render the longest critical-path tasks as aligned columns: task (left), duration (right). */
 function formatTopTaskRows(tasks) {
-    // The only caller returns early when empty, so `tasks` is non-empty here.
+    // Non-empty by construction: the only recommendation carrying task rows requires
+    // `criticalPathTop.length > 0` to apply, so no empty array reaches the widths below.
     const idWidth = Math.max(...tasks.map((t) => t.id.length));
     const durations = tasks.map((t) => (0, native_1.formatDuration)(t.duration));
     const durWidth = Math.max(...durations.map((d) => d.length));
@@ -136,8 +169,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,
@@ -168,10 +203,8 @@ const RECOMMENDATIONS = [
         // only multi-line rec). Nothing ran (fully cached) → it doesn't apply.
         isApplicable: (c) => criticalPathBound(c) && c.criticalPathTop.length > 0,
         build: (c) => [
-            [
-                `Speed up or split the longest tasks on the critical path:`,
-                ...formatTopTaskRows(c.criticalPathTop),
-            ].join('\n'),
+            `Speed up or split the longest tasks on the critical path:`,
+            c.criticalPathTop,
         ],
     },
 ];
@@ -181,6 +214,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 +231,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));
 }
@@ -252,18 +290,17 @@ function formatReport(s) {
 }
 /**
  * A recommendation as Markdown: every link becomes `[phrase](href)` (no OSC 8, unlike the
- * terminal renderer) — the whole sentence reads as prose and is the link text. The
- * critical-path rec embeds newline-separated, space-aligned task rows; collapse them to
- * `<br>`-joined lines so they render inside the list item.
+ * terminal renderer) — the whole sentence reads as prose and is the link text. Task rows
+ * become a nested list under the recommendation's bullet (space-aligned columns don't
+ * survive HTML's whitespace collapsing).
  */
 function recommendationToMarkdownString(rec) {
-    return rec
-        .map((part) => !isRecLink(part) ? part : `[${part.visible}](${part.href})`)
-        .join('')
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .join('<br>');
+    return renderRecommendation(rec, {
+        link: (link) => `[${link.visible}](${link.href})`,
+        taskRows: (rows) => rows
+            .map((t) => `\n  - \`${t.id}\` — ${(0, native_1.formatDuration)(t.duration)}`)
+            .join(''),
+    });
 }
 /**
  * The performance report as GitHub-flavored Markdown for the Actions job summary

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;

package/dist/src/utils/catalog/manager-utils.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCatalogConfigFromFs = readCatalogConfigFromFs;
-exports.readCatalogConfigFromTree = readCatalogConfigFromTree;
+exports.readCatalogDefinitions = readCatalogDefinitions;
 exports.updateCatalogVersionsInFile = updateCatalogVersionsInFile;
-// Keep in sync with packages/devkit/src/utils/catalog/manager-utils.ts; the body
-// below the imports is duplicated because @nx/devkit supports a range of nx majors
-// and this logic isn't part of the nx surface it can import across that range.
 const js_yaml_1 = require("@zkochan/js-yaml");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -119,6 +115,27 @@ function readCatalogConfigFromTree(filename, tree) {
         return null;
     }
 }
+// Managers are created per operation (getCatalogManager news one up), so the
+// fs (string-root) branch is cached to read the file once per pass instead of
+// once per catalog reference. The Tree branch stays live since the tree is
+// mutable within a generator.
+function readCatalogDefinitions(filename, treeOrRoot, cache) {
+    if (typeof treeOrRoot === 'string') {
+        if (cache.has(treeOrRoot)) {
+            return cache.get(treeOrRoot);
+        }
+        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
+        const defs = (0, node_fs_1.existsSync)(configPath)
+            ? readCatalogConfigFromFs(filename, configPath)
+            : null;
+        cache.set(treeOrRoot, defs);
+        return defs;
+    }
+    if (!treeOrRoot.exists(filename)) {
+        return null;
+    }
+    return readCatalogConfigFromTree(filename, treeOrRoot);
+}
 function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
     let checkExists;
     let readYaml;

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

@@ -7,6 +7,7 @@ import type { CatalogDefinitions, CatalogReference } from './types';
 export declare class PnpmCatalogManager implements CatalogManager {
     readonly name = "pnpm";
     readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
     isCatalogReference(version: string): boolean;
     parseCatalogReference(version: string): CatalogReference | null;
     getCatalogDefinitionFilePaths(): string[];

package/dist/src/utils/catalog/pnpm-manager.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PnpmCatalogManager = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const PNPM_WORKSPACE_FILENAME = 'pnpm-workspace.yaml';
@@ -13,6 +11,8 @@ class PnpmCatalogManager {
     constructor() {
         this.name = 'pnpm';
         this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
     }
     isCatalogReference(version) {
         return version.startsWith(this.catalogProtocol);
@@ -33,19 +33,7 @@ class PnpmCatalogManager {
         return [PNPM_WORKSPACE_FILENAME];
     }
     getCatalogDefinitions(treeOrRoot) {
-        if (typeof treeOrRoot === 'string') {
-            const configPath = (0, node_path_1.join)(treeOrRoot, PNPM_WORKSPACE_FILENAME);
-            if (!(0, node_fs_1.existsSync)(configPath)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromFs)(PNPM_WORKSPACE_FILENAME, configPath);
-        }
-        else {
-            if (!treeOrRoot.exists(PNPM_WORKSPACE_FILENAME)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromTree)(PNPM_WORKSPACE_FILENAME, treeOrRoot);
-        }
+        return (0, manager_utils_1.readCatalogDefinitions)(PNPM_WORKSPACE_FILENAME, treeOrRoot, this.definitionsByRoot);
     }
     resolveCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);

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

@@ -7,6 +7,7 @@ import type { CatalogDefinitions, CatalogReference } from './types';
 export declare class YarnCatalogManager implements CatalogManager {
     readonly name = "yarn";
     readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
     isCatalogReference(version: string): boolean;
     parseCatalogReference(version: string): CatalogReference | null;
     getCatalogDefinitionFilePaths(): string[];

package/dist/src/utils/catalog/yarn-manager.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YarnCatalogManager = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const manager_1 = require("./manager");
 const manager_utils_1 = require("./manager-utils");
 const YARNRC_FILENAME = '.yarnrc.yml';
@@ -13,6 +11,8 @@ class YarnCatalogManager {
     constructor() {
         this.name = 'yarn';
         this.catalogProtocol = 'catalog:';
+        // Parsed fs-root definitions, cached per pass. See readCatalogDefinitions.
+        this.definitionsByRoot = new Map();
     }
     isCatalogReference(version) {
         return version.startsWith(this.catalogProtocol);
@@ -33,19 +33,7 @@ class YarnCatalogManager {
         return [YARNRC_FILENAME];
     }
     getCatalogDefinitions(treeOrRoot) {
-        if (typeof treeOrRoot === 'string') {
-            const configPath = (0, node_path_1.join)(treeOrRoot, YARNRC_FILENAME);
-            if (!(0, node_fs_1.existsSync)(configPath)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromFs)(YARNRC_FILENAME, configPath);
-        }
-        else {
-            if (!treeOrRoot.exists(YARNRC_FILENAME)) {
-                return null;
-            }
-            return (0, manager_utils_1.readCatalogConfigFromTree)(YARNRC_FILENAME, treeOrRoot);
-        }
+        return (0, manager_utils_1.readCatalogDefinitions)(YARNRC_FILENAME, treeOrRoot, this.definitionsByRoot);
     }
     resolveCatalogReference(treeOrRoot, packageName, version) {
         const catalogRef = this.parseCatalogReference(version);