nx 23.1.0 → 23.1.2

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) {
@@ -142,10 +166,13 @@ function getOwnerTargetForTask(task, graph) {
         for (const targets of Object.values(project.data.metadata.targetGroups)) {
             if (targets.includes(task.target.target)) {
                 for (const target of targets) {
-                    if (project.data.targets[target].metadata?.nonAtomizedTarget) {
+                    // a target group can name a target the project does not define —
+                    // inference plugins build the group and the targets separately, so
+                    // the two can disagree. skip the phantom rather than dereferencing it.
+                    if (project.data.targets[target]?.metadata?.nonAtomizedTarget) {
                         return [
                             target,
-                            project.data.targets[target].metadata?.nonAtomizedTarget,
+                            project.data.targets[target]?.metadata?.nonAtomizedTarget,
                         ];
                     }
                 }

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

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

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

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

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

@@ -36,6 +36,7 @@ const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
 const legacy_depends_on_warning_1 = require("./legacy-depends-on-warning");
 const globs_1 = require("../utils/globs");
+const long_running_target_1 = require("../utils/long-running-target");
 const path_1 = require("../utils/path");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
 const split_target_1 = require("../utils/split-target");
@@ -429,14 +430,9 @@ function isCacheableTask(task) {
     return task.cache;
 }
 function longRunningTask(task) {
-    const t = task.target.target;
     return (task.continuous ||
         (!!task.overrides['watch'] && task.overrides['watch'] !== 'false') ||
-        t.endsWith(':watch') ||
-        t.endsWith('-watch') ||
-        t === 'serve' ||
-        t === 'dev' ||
-        t === 'start');
+        (0, long_running_target_1.isLongRunningTargetName)(task.target.target));
 }
 // TODO: vsavkin remove when nx-cloud doesn't depend on it
 function unparse(options) {

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,102 @@
+"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 json_1 = require("./json");
+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.
+    // Empty and comment-only files have no contents at all; setIn creates the
+    // mapping for them while keeping whatever comments they carry.
+    if (parsed.errors.length > 0 ||
+        (parsed.contents != null && !(parsed.contents instanceof yaml_1.YAMLMap))) {
+        return;
+    }
+    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 parsed.getIn(['allowBuilds', pkg]) !== 'boolean') {
+            parsed.setIn(['allowBuilds', pkg], allowed);
+            changed = true;
+        }
+    }
+    if (changed) {
+        host.write(PNPM_WORKSPACE_FILE, parsed.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) => (0, json_1.parseJson)(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/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/assert-workspace-validity.js

@@ -3,7 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertWorkspaceValidity = assertWorkspaceValidity;
 const find_matching_projects_1 = require("./find-matching-projects");
 const output_1 = require("./output");
-const devkit_internals_1 = require("../devkit-internals");
+// Import from the defining module, not the devkit-internals barrel: this file
+// is on the project-graph construction path, and the barrel now eagerly
+// re-exports the project-graph modules, which would create a require cycle back
+// through build-project-graph. (Release modules cross the barrel as erased
+// types only — see the note in packages/devkit/internal.ts.)
+const error_types_1 = require("../project-graph/error-types");
 function assertWorkspaceValidity(projects, nxJson) {
     const projectNames = Object.keys(projects);
     const projectGraphNodes = projectNames.reduce((graph, project) => {
@@ -65,7 +70,7 @@ function assertWorkspaceValidity(projects, nxJson) {
         })
             .join('\n\n');
     }
-    throw new devkit_internals_1.WorkspaceValidityError(message);
+    throw new error_types_1.WorkspaceValidityError(message);
 }
 function detectAndSetInvalidProjectGlobValues(map, sourceName, desiredImplicitDeps, projectConfigurations, projects) {
     const invalidProjectsOrGlobs = desiredImplicitDeps.filter((implicit) => {

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);

package/dist/src/utils/command-line-utils.js

@@ -11,6 +11,7 @@ const yargs_parser_1 = tslib_1.__importDefault(require("yargs-parser"));
 const file_utils_1 = require("../project-graph/file-utils");
 const output_1 = require("./output");
 const child_process_1 = require("child_process");
+const git_revision_1 = require("./git-revision");
 const workspace_root_1 = require("./workspace-root");
 const shared_options_1 = require("../command-line/yargs-utils/shared-options");
 function createOverrides(__overrides_unparsed__ = []) {
@@ -192,30 +193,27 @@ function parseFiles(options) {
     }
 }
 function getUncommittedFiles() {
-    return parseGitOutput(`git diff --name-only --no-renames --relative HEAD .`);
+    return parseGitOutput([
+        'diff',
+        '--name-only',
+        '--no-renames',
+        '--relative',
+        'HEAD',
+        '.',
+    ]);
 }
 function getUntrackedFiles() {
-    return parseGitOutput(`git ls-files --others --exclude-standard`);
+    return parseGitOutput(['ls-files', '--others', '--exclude-standard']);
 }
 function getMergeBase(base, head = 'HEAD') {
+    (0, git_revision_1.assertValidGitRevision)(base);
+    (0, git_revision_1.assertValidGitRevision)(head);
     try {
-        return (0, child_process_1.execSync)(`git merge-base "${base}" "${head}"`, {
-            maxBuffer: file_utils_1.TEN_MEGABYTES,
-            cwd: workspace_root_1.workspaceRoot,
-            stdio: 'pipe',
-            windowsHide: true,
-        })
-            .toString()
-            .trim();
+        return runGit(['merge-base', base, head]).toString().trim();
     }
     catch {
         try {
-            return (0, child_process_1.execSync)(`git merge-base --fork-point "${base}" "${head}"`, {
-                maxBuffer: file_utils_1.TEN_MEGABYTES,
-                cwd: workspace_root_1.workspaceRoot,
-                stdio: 'pipe',
-                windowsHide: true,
-            })
+            return runGit(['merge-base', '--fork-point', base, head])
                 .toString()
                 .trim();
         }
@@ -225,15 +223,27 @@ function getMergeBase(base, head = 'HEAD') {
     }
 }
 function getFilesUsingBaseAndHead(base, head) {
-    return parseGitOutput(`git diff --name-only --no-renames --relative "${base}" "${head}"`);
+    (0, git_revision_1.assertValidGitRevision)(base);
+    (0, git_revision_1.assertValidGitRevision)(head);
+    return parseGitOutput([
+        'diff',
+        '--name-only',
+        '--no-renames',
+        '--relative',
+        base,
+        head,
+    ]);
 }
-function parseGitOutput(command) {
-    return (0, child_process_1.execSync)(command, {
+function runGit(args) {
+    return (0, child_process_1.execFileSync)('git', args, {
         maxBuffer: file_utils_1.TEN_MEGABYTES,
         cwd: workspace_root_1.workspaceRoot,
         stdio: 'pipe',
         windowsHide: true,
-    })
+    });
+}
+function parseGitOutput(args) {
+    return runGit(args)
         .toString('utf-8')
         .split('\n')
         .map((a) => a.trim())

package/dist/src/utils/fileutils.d.ts

@@ -27,6 +27,11 @@ interface YamlReadOptions {
      * Compatibility with JSON.parse behaviour. If true, then duplicate keys in a mapping will override values rather than throwing an error.
      */
     json?: boolean;
+    /**
+     * Resolves only the tags every YAML parser must support, so every scalar stays
+     * a string instead of `true` or `12`.
+     */
+    failsafe?: boolean;
 }
 /**
  * Reads a YAML file and returns the object the YAML content represents.