nx 23.0.1 → 23.0.2

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

@@ -208,7 +208,6 @@ class ProjectGraphBuilder {
         if (!this.graph.dependencies[source]) {
             this.graph.dependencies[source] = [];
         }
-        const isDuplicate = !!this.graph.dependencies[source].find((d) => d.target === target && d.type === type);
         if (sourceFile) {
             let fileData = getProjectFileData(source, sourceFile, this.projectFileMap);
             const isProjectFileData = !!fileData;
@@ -225,14 +224,17 @@ class ProjectGraphBuilder {
                 fileData.deps.push(dep);
             }
         }
-        else if (!isDuplicate) {
+        else {
             // only add to dependencies section if the source file is not specified
             // and not already added
-            this.graph.dependencies[source].push({
-                source: source,
-                target: target,
-                type,
-            });
+            const isDuplicate = !!this.graph.dependencies[source].find((d) => d.target === target && d.type === type);
+            if (!isDuplicate) {
+                this.graph.dependencies[source].push({
+                    source: source,
+                    target: target,
+                    type,
+                });
+            }
         }
     }
     removeDependenciesWithNode(name) {
@@ -355,11 +357,25 @@ function validateStaticDependency(d, { projects }) {
         throw new Error(`Source project file is required`);
     }
 }
+// Per-project file-name -> FileData index, keyed by the fileMap object so the
+// linear scan (once per source project's file list) is paid once instead of on
+// every addDependency/validateDependency call. Cached against the source's file
+// array reference: a fresh array (new build, or reuse with a swapped list)
+// rebuilds the index.
+const projectFileDataIndex = new WeakMap();
 function getProjectFileData(source, sourceFile, fileMap) {
-    let fileData = (fileMap[source] || []).find((f) => f.file === sourceFile);
-    if (fileData) {
-        return fileData;
+    let byProject = projectFileDataIndex.get(fileMap);
+    if (!byProject) {
+        byProject = new Map();
+        projectFileDataIndex.set(fileMap, byProject);
+    }
+    const files = fileMap[source] || [];
+    let entry = byProject.get(source);
+    if (!entry || entry.files !== files) {
+        entry = { files, byFile: new Map(files.map((f) => [f.file, f])) };
+        byProject.set(source, entry);
     }
+    return entry.byFile.get(sourceFile);
 }
 function getNonProjectFileData(sourceFile, files) {
     const fileData = files.find((f) => f.file === sourceFile);

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

@@ -91,15 +91,32 @@ function buildSyntheticTargetForRoot(targetName, root, specifiedTarget, defaultT
     // matching the default plugin's executor are useful.
     const targetDefaults = readAndPrepareTargetDefaults(targetName, resolvedDefault.executor, root, targetDefaultsConfig);
     if (targetDefaults && (0, target_merging_1.isCompatibleTarget)(resolvedDefault, targetDefaults)) {
-        // Stamp executor/command so the default layer merges cleanly on top.
-        return {
-            ...targetDefaults,
-            executor: resolvedDefault.executor,
-            command: resolvedDefault.command,
-        };
+        // Stamp the default's identity so the default layer merges cleanly on top.
+        const synthetic = { ...targetDefaults };
+        stampTargetIdentity(synthetic, resolvedDefault);
+        return synthetic;
     }
     return undefined;
 }
+// Copies `source`'s identity (executor, command, and — for run-commands — its
+// options.command/commands) onto `target` so the two compare compatible and
+// the synthetic isn't dropped when the default replaces the specified target
+// downstream (#36067). run-commands compatibility keys off
+// options.command/commands, not the top-level command, so both are carried.
+function stampTargetIdentity(target, source) {
+    target.executor = source.executor;
+    target.command = source.command;
+    if (source.executor !== 'nx:run-commands')
+        return;
+    const { command, commands } = source.options ?? {};
+    if (command === undefined && commands === undefined)
+        return;
+    target.options = {
+        ...target.options,
+        ...(command !== undefined ? { command } : {}),
+        ...(commands !== undefined ? { commands } : {}),
+    };
+}
 function readAndPrepareTargetDefaults(targetName, executor, root, targetDefaultsConfig) {
     const rawTargetDefaults = readTargetDefaultsForTarget(targetName, targetDefaultsConfig, executor);
     if (!rawTargetDefaults)

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

@@ -267,31 +267,9 @@ function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfigu
     return { projectRootMap, externalNodes, rootMap, configurationSourceMaps };
 }
 /**
- * Fast matcher for patterns without negations - uses short-circuit evaluation.
- */
-function matchesSimplePatterns(file, patterns) {
-    return patterns.some((pattern) => (0, minimatch_1.minimatch)(file, pattern, { dot: true }));
-}
-/**
- * Full matcher for patterns with negations - processes all patterns sequentially.
- * Patterns starting with '!' are negation patterns that remove files from the match set.
- * Patterns are processed in order, with later patterns overriding earlier ones.
- */
-function matchesNegationPatterns(file, patterns) {
-    // If first pattern is negation, start by matching everything
-    let isMatch = patterns[0].startsWith('!');
-    for (const pattern of patterns) {
-        const isNegation = pattern.startsWith('!');
-        const actualPattern = isNegation ? pattern.substring(1) : pattern;
-        if ((0, minimatch_1.minimatch)(file, actualPattern, { dot: true })) {
-            // Last matching pattern wins
-            isMatch = !isNegation;
-        }
-    }
-    return isMatch;
-}
-/**
- * Creates a matcher function for the given patterns.
+ * Creates a matcher function for the given patterns. Globs are compiled once
+ * here so matching a file list only runs the pre-parsed regex per file, instead
+ * of recompiling every pattern on each call.
  * @param patterns Array of glob patterns (can include negation patterns starting with '!')
  * @param emptyValue Value to return when patterns array is empty
  * @returns A function that checks if a file matches the patterns
@@ -301,9 +279,31 @@ function createMatcher(patterns, emptyValue) {
         return () => emptyValue;
     }
     const hasNegationPattern = patterns.some((p) => p.startsWith('!'));
-    return hasNegationPattern
-        ? (file) => matchesNegationPatterns(file, patterns)
-        : (file) => matchesSimplePatterns(file, patterns);
+    if (hasNegationPattern) {
+        // Patterns are processed in order, with later matches overriding earlier
+        // ones; a leading negation starts from "matches everything".
+        const compiled = patterns.map((pattern) => {
+            const isNegation = pattern.startsWith('!');
+            return {
+                isNegation,
+                matcher: new minimatch_1.Minimatch(isNegation ? pattern.substring(1) : pattern, {
+                    dot: true,
+                }),
+            };
+        });
+        const initialMatch = patterns[0].startsWith('!');
+        return (file) => {
+            let isMatch = initialMatch;
+            for (const { isNegation, matcher } of compiled) {
+                if (matcher.match(file)) {
+                    isMatch = !isNegation;
+                }
+            }
+            return isMatch;
+        };
+    }
+    const compiled = patterns.map((p) => new minimatch_1.Minimatch(p, { dot: true }));
+    return (file) => compiled.some((m) => m.match(file));
 }
 function findMatchingConfigFiles(projectFiles, include, exclude) {
     // projectFiles already comes from multiGlobWithWorkspaceContext for the

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

@@ -7,6 +7,9 @@ const project_graph_1 = require("../../project-graph/project-graph");
 const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("../../command-line/run/executor-utils");
+// Batch workers are inside an Nx run just like task workers (see
+// bin/run-executor.ts) — mark it so nested tooling can detect Nx.
+process.env.NX_CLI_SET = 'true';
 function getBatchExecutor(executorName, projects) {
     const [nodeModule, exportName] = (0, executor_utils_1.parseExecutor)(executorName);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);

package/dist/src/tasks-runner/cache.js

@@ -251,6 +251,12 @@ class DbCache {
                 logger_1.logger.warn('The HTTP remote cache is not yet supported in the wasm build of Nx.');
                 return null;
             }
+            // The cache request runs in Rust (reqwest), which honors
+            // NODE_TLS_REJECT_UNAUTHORIZED but bypasses Node's TLS stack, so Node's own
+            // insecure-TLS warning never fires for it. Re-emit Node's warning here.
+            if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
+                process.emitWarning("Setting the NODE_TLS_REJECT_UNAUTHORIZED environment variable to '0' makes TLS connections and HTTPS requests insecure by disabling certificate verification.");
+            }
             return new native_1.HttpRemoteCache();
         }
         return null;

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

@@ -13,6 +13,7 @@ export declare class PseudoTerminal {
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
     shutdown(code: number): void;
+    private releaseChild;
     runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
         cwd?: string;
         execArgv?: string[];

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

@@ -8,17 +8,18 @@ const socket_utils_1 = require("../daemon/socket-utils");
 const native_1 = require("../native");
 const pseudo_ipc_1 = require("./pseudo-ipc");
 const exit_codes_1 = require("../utils/exit-codes");
-// Register single event listeners for all pseudo-terminal instances
-const pseudoTerminalShutdownCallbacks = [];
+// Kill any children still alive when Nx exits. Terminals remove themselves once
+// their children exit (see releaseChild), so finished runs skip a per-terminal scan.
+const activePseudoTerminals = new Set();
 process.on('exit', (code) => {
-    pseudoTerminalShutdownCallbacks.forEach((cb) => cb(code));
+    activePseudoTerminals.forEach((t) => t.shutdown(code));
 });
 function createPseudoTerminal(skipSupportCheck = false) {
     if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
         throw new Error('Pseudo terminal is not supported on this platform.');
     }
     const pseudoTerminal = new PseudoTerminal(new native_1.RustPseudoTerminal());
-    pseudoTerminalShutdownCallbacks.push(pseudoTerminal.shutdown.bind(pseudoTerminal));
+    activePseudoTerminals.add(pseudoTerminal);
     return pseudoTerminal;
 }
 let id = 0;
@@ -56,9 +57,21 @@ class PseudoTerminal {
             this.pseudoIPC.close();
         }
     }
+    // Once all children have exited, drop the process-exit handler and close IPC.
+    releaseChild(cp) {
+        this.childProcesses.delete(cp);
+        if (this.childProcesses.size === 0) {
+            activePseudoTerminals.delete(this);
+            if (this.initialized) {
+                this.pseudoIPC.close();
+                this.initialized = false;
+            }
+        }
+    }
     runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
         const cp = new PseudoTtyProcess(this.rustPseudoTerminal, this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
         this.childProcesses.add(cp);
+        cp.onExit(() => this.releaseChild(cp));
         return cp;
     }
     async fork(id, script, { cwd, execArgv, jsEnv, quiet, commandLabel, }) {
@@ -67,6 +80,7 @@ class PseudoTerminal {
         }
         const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal, this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet, commandLabel), id, this.pseudoIPC);
         this.childProcesses.add(cp);
+        cp.onExit(() => this.releaseChild(cp));
         await this.pseudoIPC.waitForChildReady(id);
         return cp;
     }

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

@@ -50,6 +50,27 @@ const originalStdoutWrite = process.stdout.write.bind(process.stdout);
 const originalStderrWrite = process.stderr.write.bind(process.stderr);
 const originalConsoleLog = console.log.bind(console);
 const originalConsoleError = console.error.bind(console);
+// Only used in the non-TTY error path. In non-TTY the function `process.exit(1)`s
+// before the `applyChanges` branch can auto-sync, so the auto-sync bullet keeps
+// the "interactive environments" qualifier to avoid suggesting a config change
+// that won't help in CI/agent contexts.
+const SYNC_FIX_MESSAGE_LINES = [
+    'To sync the workspace:',
+    '- Run `nx sync` (no flags) to sync now.',
+    '- Run `nx sync:check` to preview the changes without modifying any files.',
+    '- Set `sync.applyChanges` to `true` in your `nx.json` to sync automatically when running tasks in interactive environments.',
+    '',
+    'For more information, refer to the docs: https://nx.dev/concepts/sync-generators',
+];
+const APPLY_CHANGES_FALSE_FIX_MESSAGE_LINES = [
+    'Your workspace is set to not sync automatically (`sync.applyChanges` is `false` in your `nx.json`).',
+    'Run `nx sync` (no flags) to sync now, or set `sync.applyChanges` to `true` to sync automatically before each task run.',
+];
+const SYNC_SKIPPED_FIX_MESSAGE_LINES = [
+    'This could lead to unexpected results or errors when running tasks.',
+    '',
+    'Run `nx sync` (no flags) later to sync the workspace.',
+];
 async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, projectNames, tasks, taskGraph, nxArgs, nxJson, overrides) {
     const overridesWithoutHidden = { ...overrides };
     delete overridesWithoutHidden['__overrides_unparsed__'];
@@ -414,7 +435,6 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, nxArgs.verbose);
     const outOfSyncTitle = 'The workspace is out of sync';
     const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
-    const fixMessage = 'Make sure to run `nx sync` to apply the identified changes or set `sync.applyChanges` to `true` in your `nx.json` to apply them automatically when running tasks in interactive environments.';
     if (!process.stdout.isTTY) {
         // If the user is running a non-TTY environment we
         // throw an error to stop the execution of the tasks.
@@ -429,7 +449,7 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         else {
             output_1.output.error({
                 title: outOfSyncTitle,
-                bodyLines: [...resultBodyLines, '', fixMessage],
+                bodyLines: [...resultBodyLines, '', ...SYNC_FIX_MESSAGE_LINES],
             });
             if (anySyncGeneratorsFailed) {
                 output_1.output.error({
@@ -463,8 +483,7 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
             bodyLines: [
                 ...resultBodyLines,
                 '',
-                'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
-                fixMessage,
+                ...APPLY_CHANGES_FALSE_FIX_MESSAGE_LINES,
             ],
         });
         if (anySyncGeneratorsFailed) {
@@ -549,10 +568,7 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         else {
             output_1.output.warn({
                 title: 'Syncing the workspace was skipped',
-                bodyLines: [
-                    'This could lead to unexpected results or errors when running tasks.',
-                    fixMessage,
-                ],
+                bodyLines: SYNC_SKIPPED_FIX_MESSAGE_LINES,
             });
         }
     }

package/dist/src/tasks-runner/utils.d.ts

@@ -56,5 +56,6 @@ export declare function getUnparsedOverrideArgs(task: Task): string[];
 export declare function getPrintableCommandArgsForTask(task: Task): string[];
 export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
 export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;
+export declare function isCacheableTask(task: Task): boolean;
 export declare function unparse(options: Object): string[];
 export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;

package/dist/src/tasks-runner/utils.js

@@ -24,6 +24,7 @@ exports.getUnparsedOverrideArgs = getUnparsedOverrideArgs;
 exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
 exports.getSerializedArgsForTask = getSerializedArgsForTask;
 exports.shouldStreamOutput = shouldStreamOutput;
+exports.isCacheableTask = isCacheableTask;
 exports.unparse = unparse;
 exports.createTaskId = createTaskId;
 const minimatch_1 = require("minimatch");
@@ -420,6 +421,9 @@ function shouldStreamOutput(task, initiatingProject) {
         return true;
     return false;
 }
+function isCacheableTask(task) {
+    return task.cache;
+}
 function longRunningTask(task) {
     const t = task.target.target;
     return (task.continuous ||

package/dist/src/utils/ab-testing.d.ts

@@ -2,11 +2,11 @@ export declare const NX_CLOUD_URL = "https://nx.dev/nx-cloud";
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
- * without OSC 8 support just render the bare URL (CLOUD-4642). The medium is
- * per-command because `nx init` and `nx migrate` share a footer but report
- * different mediums.
+ * without OSC 8 support just render the bare URL (CLOUD-4642). The content tag
+ * is per-command because `nx init` and `nx migrate` share a footer but report
+ * different commands.
  */
-export declare function nxCloudHyperlink(utmMedium: string): string;
+export declare function nxCloudHyperlink(utmContent: string): string;
 /**
  * Meta payload types for recordStat telemetry (matches CNW format).
  */

package/dist/src/utils/ab-testing.js

@@ -14,12 +14,12 @@ exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
- * without OSC 8 support just render the bare URL (CLOUD-4642). The medium is
- * per-command because `nx init` and `nx migrate` share a footer but report
- * different mediums.
+ * without OSC 8 support just render the bare URL (CLOUD-4642). The content tag
+ * is per-command because `nx init` and `nx migrate` share a footer but report
+ * different commands.
  */
-function nxCloudHyperlink(utmMedium) {
-    const tracked = `${exports.NX_CLOUD_URL}?utm_source=nx-cli&utm_medium=${utmMedium}`;
+function nxCloudHyperlink(utmContent) {
+    const tracked = `${exports.NX_CLOUD_URL}?utm_source=nx-cli&utm_medium=cli&utm_campaign=nx-cloud-connect&utm_content=${utmContent}`;
     return (0, terminal_link_1.terminalLink)(exports.NX_CLOUD_URL, tracked);
 }
 const messageOptions = {

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

@@ -0,0 +1,9 @@
+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 updateCatalogVersionsInFile(filename: string, treeOrRoot: Tree | string, updates: Array<{
+    packageName: string;
+    version: string;
+    catalogName?: string;
+}>): void;

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

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCatalogConfigFromFs = readCatalogConfigFromFs;
+exports.readCatalogConfigFromTree = readCatalogConfigFromTree;
+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");
+const yaml_1 = require("yaml");
+const fileutils_1 = require("../fileutils");
+const output_1 = require("../output");
+// Walks `path` resolving aliases at every step so structural checks can
+// see through `key: *anchor` references. Neither `doc.getIn` nor
+// `doc.hasIn` traverse aliases on their own. Returns the resolved node, or
+// `undefined` if any ancestor isn't a map.
+function resolveAt(doc, path) {
+    let node = doc.contents;
+    for (let i = 0; i < path.length; i++) {
+        if ((0, yaml_1.isAlias)(node))
+            node = node.resolve(doc);
+        if (!(0, yaml_1.isMap)(node))
+            return undefined;
+        node = node.get(path[i], true);
+    }
+    if ((0, yaml_1.isAlias)(node))
+        node = node.resolve(doc);
+    return node;
+}
+function isMapAt(doc, path) {
+    return (0, yaml_1.isMap)(resolveAt(doc, path));
+}
+function existsAt(doc, path) {
+    return resolveAt(doc, path) !== undefined;
+}
+// `doc.getIn` does not traverse aliases. For aliased paths it returns
+// undefined even when the resolved node has a value. Use the alias-aware
+// walk and unwrap scalar nodes to their JS value.
+function getValueAt(doc, path) {
+    const node = resolveAt(doc, path);
+    return (0, yaml_1.isScalar)(node) ? node.value : node;
+}
+// Walks `targetPath` resolving aliases at every step and mutates the
+// resolved map directly so anchors are preserved. When a step is missing
+// or holds a null placeholder (`key:` with no value), creates a fresh map
+// inside the current parent and carries over the placeholder's comments
+// and anchor so they aren't dropped. A dropped anchor would leave any
+// alias referencing it unresolved and make `String(doc)` throw. Falls back
+// to `doc.setIn` when the current parent isn't a map: an empty-document
+// root gets bootstrapped, while a non-map value where a catalog map was
+// expected makes `setIn` throw, surfacing the malformed config.
+function setThroughAliases(doc, targetPath, value) {
+    let parent = doc.contents;
+    if ((0, yaml_1.isAlias)(parent))
+        parent = parent.resolve(doc);
+    for (let i = 0; i < targetPath.length - 1; i++) {
+        if (!(0, yaml_1.isMap)(parent)) {
+            doc.setIn(targetPath, value);
+            return;
+        }
+        let next = parent.get(targetPath[i], true);
+        const nextWasAlias = (0, yaml_1.isAlias)(next);
+        if ((0, yaml_1.isAlias)(next))
+            next = next.resolve(doc);
+        const placeholder = (0, yaml_1.isScalar)(next) && next.value === null ? next : undefined;
+        if (next === undefined || placeholder) {
+            let cur = parent;
+            for (let j = i; j < targetPath.length - 1; j++) {
+                const fresh = new yaml_1.YAMLMap();
+                if (j === i && placeholder) {
+                    if (placeholder.comment)
+                        fresh.comment = placeholder.comment;
+                    if (placeholder.commentBefore)
+                        fresh.commentBefore = placeholder.commentBefore;
+                    // Copy the anchor only for a directly-held placeholder. When it
+                    // was reached through an alias, the anchor still lives on the
+                    // definition node, so re-emitting it here would duplicate it.
+                    if (!nextWasAlias && placeholder.anchor)
+                        fresh.anchor = placeholder.anchor;
+                }
+                cur.set(targetPath[j], fresh);
+                cur = fresh;
+            }
+            cur.set(targetPath[targetPath.length - 1], value);
+            return;
+        }
+        parent = next;
+    }
+    if (!(0, yaml_1.isMap)(parent)) {
+        doc.setIn(targetPath, value);
+        return;
+    }
+    parent.set(targetPath[targetPath.length - 1], value);
+}
+function readCatalogConfigFromFs(filename, fullPath) {
+    try {
+        return (0, fileutils_1.readYamlFile)(fullPath);
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function readCatalogConfigFromTree(filename, tree) {
+    const content = tree.read(filename, 'utf-8');
+    try {
+        return (0, js_yaml_1.load)(content, { filename });
+    }
+    catch (error) {
+        output_1.output.warn({
+            title: `Unable to parse ${filename}`,
+            bodyLines: [error.toString()],
+        });
+        return null;
+    }
+}
+function updateCatalogVersionsInFile(filename, treeOrRoot, updates) {
+    let checkExists;
+    let readYaml;
+    let writeYaml;
+    if (typeof treeOrRoot === 'string') {
+        const configPath = (0, node_path_1.join)(treeOrRoot, filename);
+        checkExists = () => (0, node_fs_1.existsSync)(configPath);
+        readYaml = () => (0, node_fs_1.readFileSync)(configPath, 'utf-8');
+        writeYaml = (content) => (0, node_fs_1.writeFileSync)(configPath, content, 'utf-8');
+    }
+    else {
+        checkExists = () => treeOrRoot.exists(filename);
+        readYaml = () => treeOrRoot.read(filename, 'utf-8');
+        writeYaml = (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 {
+        // parseDocument keeps comments and anchors so a catalog bump doesn't
+        // rewrite the user's config file.
+        const lineCounter = new yaml_1.LineCounter();
+        const doc = (0, yaml_1.parseDocument)(readYaml(), { lineCounter });
+        // parseDocument collects syntax errors instead of throwing; surface them
+        // now, with their line/column detail, rather than failing later in
+        // `String(doc)` with a generic message or skipping a no-op write on a
+        // malformed file (the previous js-yaml `load()` threw here).
+        if (doc.errors.length > 0) {
+            throw new Error(doc.errors.map((e) => e.message).join('\n'));
+        }
+        // A dangling alias (`*ref` with no matching `&ref`) is not a syntax error,
+        // so parseDocument leaves it out of doc.errors. Surface it here with the
+        // same line/column detail the old js-yaml `load()` reported; otherwise a
+        // broken reference is silently overwritten or written back untouched.
+        const unresolvedAliases = [];
+        (0, yaml_1.visit)(doc, {
+            Alias(_key, node) {
+                if (node.resolve(doc) !== undefined)
+                    return;
+                const pos = node.range ? lineCounter.linePos(node.range[0]) : undefined;
+                unresolvedAliases.push(pos
+                    ? `Unresolved alias "${node.source}" at line ${pos.line}, column ${pos.col}`
+                    : `Unresolved alias "${node.source}"`);
+            },
+        });
+        if (unresolvedAliases.length > 0) {
+            throw new Error(unresolvedAliases.join('\n'));
+        }
+        let hasChanges = false;
+        for (const update of updates) {
+            const { packageName, version, catalogName } = update;
+            const normalizedCatalogName = catalogName === 'default' ? undefined : catalogName;
+            let targetPath;
+            if (!normalizedCatalogName) {
+                // An empty `catalog:` placeholder must not claim the default route
+                // when `catalogs.default` is populated; that would create a
+                // duplicate-default config rejected by pnpm.
+                if (isMapAt(doc, ['catalog'])) {
+                    targetPath = ['catalog', packageName];
+                }
+                else if (existsAt(doc, ['catalogs', 'default'])) {
+                    targetPath = ['catalogs', 'default', packageName];
+                }
+                else {
+                    targetPath = ['catalog', packageName];
+                }
+            }
+            else {
+                targetPath = ['catalogs', normalizedCatalogName, packageName];
+            }
+            if (getValueAt(doc, targetPath) !== version) {
+                setThroughAliases(doc, targetPath, version);
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            writeYaml(String(doc));
+        }
+    }
+    catch (error) {
+        output_1.output.error({
+            title: 'Failed to update catalog versions',
+            bodyLines: [error instanceof Error ? error.message : String(error)],
+        });
+        throw error;
+    }
+}