nx 23.2.0-beta.2 → 23.2.0-beta.4

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/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.js

@@ -731,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));
@@ -944,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/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;

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

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBunCatalogDefinitions = readBunCatalogDefinitions;
+exports.updateBunCatalogVersionsInFile = updateBunCatalogVersionsInFile;
+const jsonc_parser_1 = require("jsonc-parser");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../fileutils");
+const json_1 = require("../json");
+const output_1 = require("../output");
+// Extracts catalog definitions from a parsed bun package.json, normalizing the
+// top-level and `workspaces`-nested locations into a single CatalogDefinitions.
+// Bun treats the locations as all-or-nothing: when either catalog field exists
+// under `workspaces`, the top-level fields are ignored entirely rather than
+// merged.
+function normalizeBunCatalogDefinitions(packageJson) {
+    const nested = packageJson.workspaces && !Array.isArray(packageJson.workspaces)
+        ? packageJson.workspaces
+        : undefined;
+    const source = nested?.catalog !== undefined || nested?.catalogs !== undefined
+        ? nested
+        : packageJson;
+    const { catalog, catalogs } = source;
+    if (!catalog && !catalogs) {
+        return null;
+    }
+    return { catalog, catalogs };
+}
+function readBunCatalogConfigFromFs(filename, fullPath) {
+    try {
+        return normalizeBunCatalogDefinitions((0, fileutils_1.readJsonFile)(fullPath));
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function readBunCatalogConfigFromTree(filename, tree) {
+    const content = tree.read(filename, 'utf-8');
+    try {
+        return normalizeBunCatalogDefinitions((0, json_1.parseJson)(content));
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+// Mirror of readCatalogDefinitions for bun's package.json-based catalogs: the
+// fs (string-root) branch is cached per pass, the Tree branch stays live.
+function readBunCatalogDefinitions(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)
+            ? readBunCatalogConfigFromFs(filename, configPath)
+            : null;
+        cache.set(treeOrRoot, defs);
+        return defs;
+    }
+    if (!treeOrRoot.exists(filename)) {
+        return null;
+    }
+    return readBunCatalogConfigFromTree(filename, treeOrRoot);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// Resolves the jsonc path a catalog update should target. Follows the same
+// all-or-nothing routing as the reader: updates land in the `workspaces`
+// location when it holds a catalog field, otherwise at the top level.
+function resolveBunCatalogTargetPath(packageJson, packageName, catalogName) {
+    const nested = packageJson.workspaces && !Array.isArray(packageJson.workspaces)
+        ? packageJson.workspaces
+        : undefined;
+    const nestedIsActive = nested?.catalog !== undefined || nested?.catalogs !== undefined;
+    const prefix = nestedIsActive ? ['workspaces'] : [];
+    return catalogName
+        ? [...prefix, 'catalogs', catalogName, packageName]
+        : [...prefix, 'catalog', packageName];
+}
+// jsonc-parser's `modify` creates missing intermediate objects but throws on
+// null (or other non-object) ones — the JSON counterpart of pnpm's empty
+// `catalog:` placeholder. Walk the target path and, at the first non-object
+// step, replace that node wholesale with the remaining path nested as fresh
+// objects.
+function planBunCatalogEdit(packageJson, targetPath, version) {
+    let node = packageJson;
+    for (let i = 0; i < targetPath.length - 1; i++) {
+        if (!isRecord(node)) {
+            break;
+        }
+        const next = node[targetPath[i]];
+        if (next !== undefined && !isRecord(next)) {
+            const value = targetPath
+                .slice(i + 1)
+                .reduceRight((acc, key) => ({ [key]: acc }), version);
+            return { path: targetPath.slice(0, i + 1), value };
+        }
+        node = next;
+    }
+    return { path: targetPath, value: version };
+}
+function updateBunCatalogVersionsInFile(filename, treeOrRoot, updates) {
+    let checkExists;
+    let readContent;
+    let writeContent;
+    if (typeof treeOrRoot === 'string') {
+        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
+        checkExists = () => (0, node_fs_1.existsSync)(configPath);
+        readContent = () => (0, node_fs_1.readFileSync)(configPath, 'utf-8');
+        writeContent = (content) => (0, node_fs_1.writeFileSync)(configPath, content, 'utf-8');
+    }
+    else {
+        checkExists = () => treeOrRoot.exists(filename);
+        readContent = () => treeOrRoot.read(filename, 'utf-8');
+        writeContent = (content) => treeOrRoot.write(filename, content);
+    }
+    if (!checkExists()) {
+        output_1.output.warn({
+            title: `No ${filename} found`,
+            bodyLines: [
+                `Cannot update catalog versions without a ${filename} file.`,
+                `Create a ${filename} file to use catalogs.`,
+            ],
+        });
+        return;
+    }
+    try {
+        let content = readContent();
+        // parseJson surfaces a genuine syntax error here rather than letting a
+        // broken file be silently rewritten.
+        let packageJson = (0, json_1.parseJson)(content);
+        let hasChanges = false;
+        for (const update of updates) {
+            const { packageName, version, catalogName } = update;
+            const targetPath = resolveBunCatalogTargetPath(packageJson, packageName, catalogName);
+            // `modify` emits an edit even for an identical value, so check first to
+            // keep an already-matching file untouched.
+            const currentValue = targetPath.reduce((node, key) => (isRecord(node) ? node[key] : undefined), packageJson);
+            if (currentValue === version) {
+                continue;
+            }
+            const { path, value } = planBunCatalogEdit(packageJson, targetPath, version);
+            const edits = (0, jsonc_parser_1.modify)(content, path, value, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            });
+            if (edits.length > 0) {
+                content = (0, jsonc_parser_1.applyEdits)(content, edits);
+                // Re-parse so the next update routes against the just-applied edit
+                // (e.g. a null `catalog` placeholder replaced with a fresh map).
+                packageJson = (0, json_1.parseJson)(content);
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            writeContent(content);
+        }
+    }
+    catch (error) {
+        output_1.output.error({
+            title: 'Failed to update catalog versions',
+            bodyLines: [error instanceof Error ? error.message : String(error)],
+        });
+        throw error;
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { Tree } from '../../generators/tree';
+import { type CatalogManager } from './manager';
+import type { CatalogDefinitions, CatalogReference, CatalogReferenceMatch } from './types';
+/**
+ * Bun-specific catalog manager implementation.
+ *
+ * Bun declares catalogs in the root package.json `catalog`/`catalogs` fields,
+ * either at the top level or nested under the object form of `workspaces`.
+ * Unlike pnpm, the name "default" is not special: `catalog:` resolves only
+ * against `catalog`, and `catalog:default` against `catalogs.default`.
+ */
+export declare class BunCatalogManager implements CatalogManager {
+    readonly name = "bun";
+    readonly catalogProtocol = "catalog:";
+    private definitionsByRoot;
+    isCatalogReference(version: string): boolean;
+    parseCatalogReference(version: string): CatalogReference | null;
+    getCatalogDefinitionFilePaths(): string[];
+    getCatalogDefinitions(treeOrRoot: Tree | string): CatalogDefinitions | null;
+    resolveCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): string | null;
+    getCatalogReferencesForPackage(treeOrRoot: Tree | string, packageName: string): CatalogReferenceMatch[];
+    validateCatalogReference(treeOrRoot: Tree | string, packageName: string, version: string): void;
+    updateCatalogVersions(treeOrRoot: Tree | string, updates: Array<{
+        packageName: string;
+        version: string;
+        catalogName?: string;
+    }>): void;
+}