nx 23.2.0-beta.1 → 23.2.0-beta.10

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

@@ -79,11 +79,23 @@ 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();
         this.groups = [];
         this.continuousTasksStarted = 0;
+        /**
+         * How many folds each batch id has rendered. A batch that reports a strict
+         * subset of its tasks is re-run under the same id, so one id can produce more
+         * than one fold and the redirect lines have to point at the right one.
+         */
+        this.batchFoldRenders = new Map();
         this.bailed = false;
         this.resolveStopPromise = null;
         this.stopRequested = false;
@@ -324,9 +336,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 +350,9 @@ class TaskOrchestrator {
             if (cachedResult && this.shouldCacheTaskResult(task, cachedResult.code)) {
                 cacheHits.push({ task, cachedResult });
             }
+            else {
+                this.cacheMissedHashes.add(task.hash);
+            }
         }
         return cacheHits;
     }
@@ -396,14 +414,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);
             }
         }
@@ -559,8 +582,9 @@ class TaskOrchestrator {
     }
     async runBatch(batch, env, groupId) {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
+        let batchProcess;
         try {
-            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
+            batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.fullTaskGraph, env);
             // Stream output from batch process to the batch
             batchProcess.onOutput((output) => {
                 this.options.lifeCycle.appendBatchOutput?.(batch.id, output);
@@ -578,7 +602,12 @@ class TaskOrchestrator {
                 // Skipped tasks didn't run, so they have no terminal output and don't
                 // need a per-task PTY — calling printTaskTerminalOutput would otherwise
                 // allocate one just to write a cursor-hide escape.
-                if (status !== 'skipped') {
+                //
+                // When the batch is being folded, printing is deferred to batch end
+                // (printGroupedBatchOutput), which always renders each task through the
+                // life cycle and adds the worker's whole log as a fold when the run
+                // asked for full output or any task failed or was stopped.
+                if (status !== 'skipped' && !(0, output_1.shouldGroupBatchOutput)()) {
                     this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
                 }
                 task.startTime = result.startTime;
@@ -590,7 +619,7 @@ class TaskOrchestrator {
             });
             const results = await batchProcess.getResults();
             const batchResultEntries = Object.entries(results);
-            return batchResultEntries.map(([taskId, result]) => {
+            const taskResults = batchResultEntries.map(([taskId, result]) => {
                 const task = this.taskGraph.tasks[taskId];
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
@@ -602,10 +631,14 @@ class TaskOrchestrator {
                     terminalOutput: result.terminalOutput,
                 };
             });
+            if ((0, output_1.shouldGroupBatchOutput)()) {
+                this.renderBatchOutputSafely(batch.id, () => this.printGroupedBatchOutput(batch, taskResults, batchProcess.getCapturedOutputPath()));
+            }
+            return taskResults;
         }
         catch (e) {
             const isBatchStopping = this.stopRequested;
-            return Object.keys(batch.taskGraph.tasks).map((taskId) => {
+            const taskResults = Object.keys(batch.taskGraph.tasks).map((taskId) => {
                 const task = this.taskGraph.tasks[taskId];
                 if (isBatchStopping) {
                     task.endTime = Date.now();
@@ -617,12 +650,147 @@ class TaskOrchestrator {
                     terminalOutput: isBatchStopping ? '' : (e.stack ?? e.message ?? ''),
                 };
             });
+            // The worker died without reporting results, so nothing was attributed to
+            // a task and no per-task output ran. Everything it wrote went to
+            // stdout/stderr, held back under log grouping — surface it as one fold.
+            // Outside grouping it already streamed live. This matters just as much
+            // when the batch was stopped: every task is marked stopped whether or not
+            // it finished, so the log is the only record of what got through. Only
+            // the exit-code error is dropped there, since it restates the
+            // cancellation.
+            if ((0, output_1.shouldGroupBatchOutput)()) {
+                const capturedOutputPath = batchProcess?.getCapturedOutputPath();
+                const trailer = isBatchStopping ? undefined : e.message;
+                if (capturedOutputPath || trailer) {
+                    this.renderBatchOutputSafely(batch.id, () => this.printBatchFold(batch, taskResults, {
+                        capturedOutputPath,
+                        trailer,
+                    }));
+                }
+            }
+            return taskResults;
         }
         finally {
+            batchProcess?.discardCapturedOutput();
             const runBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:end');
             perf_hooks_1.performance.measure('TaskOrchestrator-run-batch', runBatchStart.name, runBatchEnd.name);
         }
     }
+    /**
+     * Rendering a batch's output must never change the batch's results. A throw
+     * from the printer would otherwise land in `runBatch`'s own error handling:
+     * on the resolved path it rewrites every task to `failure` with the printer's
+     * stack as its output — reporting a green build red to the life cycles and Nx
+     * Cloud — and on the crash path it escapes `runBatch`, replacing the built
+     * failure results with the printer's error. Both call sites degrade to a
+     * warning here instead.
+     */
+    renderBatchOutputSafely(batchId, render) {
+        try {
+            render();
+        }
+        catch (e) {
+            output_1.output.warn({
+                title: `Could not render output for batch ${batchId}`,
+                bodyLines: [e.message],
+            });
+        }
+    }
+    /**
+     * Prints a completed batch's output once, under log grouping. Live forwarding
+     * was suppressed while grouping, so this is the only copy — which is why the
+     * requested output style has to reach this path rather than stopping at the
+     * life cycle.
+     *
+     * Two things are rendered, and they answer different questions.
+     *
+     * Every task always renders through the life cycle, exactly as in a non-batch
+     * run - failures in full, successes collapsed to a line for run-many, plus the
+     * initiating project in full for run-one. That is what attributes output to a
+     * task, and it is the only place some of it exists: `@nx/jest` synthesizes
+     * each task's `terminalOutput` from an aggregated result and never writes
+     * those per-project summaries to the worker's stdio at all.
+     *
+     * The worker's whole captured log is rendered as a fold above them when the
+     * run asked for full output, or when any task failed or was stopped. A
+     * diagnostic that explains a failure is routinely one no task claimed:
+     * `@nx/maven`'s batch impl writes its exit-code dump and failed-task outputs
+     * to the worker's stderr via `console.error`, and the Maven JVM it spawns
+     * points slf4j at `System.out` because its own stderr carries the result
+     * protocol - two layers, two streams, both captured and neither attributed to
+     * a task - and `@nx/gradle` emits configuration-phase errors before the first
+     * `> Task :x:y` header tells it which task to attribute to. Both catch their
+     * own crash and backfill task results, so the batch resolves and lands here
+     * rather than in the caller's failure path.
+     *
+     * Rendering both duplicates some bytes, deliberately. `@nx/maven` and
+     * `@nx/gradle` tee each task's output into the worker's stdio on the way to
+     * `terminalOutput`, so a failing task's body appears in the fold and again in
+     * its own block. That is bounded on the default style, where successes
+     * collapse to a line each and a crashed batch backfills a short
+     * `e.toString()` rather than a body, so the case with the largest fold
+     * duplicates the least. Under a full-output style it is not bounded: every
+     * task prints in full beside a log that already contains it, which is the
+     * price of that style asking for everything. What it buys either way is
+     * attribution the fold cannot express. The
+     * alternative, letting the fold replace per-task rendering, silently dropped
+     * `@nx/jest`'s summaries and is what this shape exists to avoid.
+     *
+     * A batch that never reported results is handled by the caller instead.
+     */
+    printGroupedBatchOutput(batch, taskResults, capturedOutputPath) {
+        // Read from the same field the streaming decision uses. `this.options` has
+        // its own `outputStyle`, merged from `nx.json`'s tasksRunnerOptions, so the
+        // two disagree whenever a style is configured there but not named on the
+        // command line - and `init-tasks-runner` passes a populated `options` with
+        // no style argument at all, so on that path only `options` can carry one.
+        const printsFullOutput = (0, output_1.printsFullTaskOutput)({
+            verbose: this.options.verbose,
+            outputStyle: this.outputStyle,
+        });
+        const batchOwnsTheDiagnostic = taskResults.some((r) => r.status === 'failure' || r.status === 'stopped');
+        if ((printsFullOutput || batchOwnsTheDiagnostic) && capturedOutputPath) {
+            // No redirect lines: every task renders itself below, so there is nothing
+            // to redirect anyone to.
+            this.printBatchFold(batch, taskResults, { capturedOutputPath }, { redirectLines: false });
+        }
+        for (const { task, status, terminalOutput } of taskResults) {
+            if (status !== 'skipped') {
+                this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput ?? '');
+            }
+        }
+    }
+    /**
+     * Renders a batch's whole output as one fold, plus — unless `redirectLines`
+     * is off — a line per task pointing at it. The fold is labelled with the
+     * executor and a run-unique id (the same
+     * executor can run more than one batch), rather than an arbitrary task. Safe
+     * to write to `output` directly: grouping implies GitHub Actions implies a
+     * non-TTY, static lifecycle.
+     */
+    printBatchFold(batch, taskResults, body, { redirectLines = true } = {}) {
+        // batch.id is already `<executor> <n>`, numbered per executor when the batch
+        // was scheduled. Deriving a second number here would drift from it, since
+        // only batches that render a fold would be counted. The suffix disambiguates
+        // re-runs of the same batch rather than replacing the id, so it cannot.
+        const renders = (this.batchFoldRenders.get(batch.id) ?? 0) + 1;
+        this.batchFoldRenders.set(batch.id, renders);
+        const label = renders === 1 ? `batch ${batch.id}` : `batch ${batch.id}:${renders}`;
+        const worst = taskResults.some((r) => r.status === 'failure')
+            ? 'failure'
+            : taskResults.some((r) => r.status === 'stopped')
+                ? 'stopped'
+                : 'success';
+        output_1.output.logBatchGroup(label, body, worst);
+        if (!redirectLines) {
+            return;
+        }
+        for (const { task, status } of taskResults) {
+            if (status !== 'skipped') {
+                output_1.output.logCommandRedirect((0, utils_1.getPrintableCommandArgsForTask)(task).join(' '), status, `(output in "${label}" above)`);
+            }
+        }
+    }
     // endregion Batch
     // region Single Task
     /**
@@ -710,13 +878,11 @@ class TaskOrchestrator {
         await this.preRunSteps([task], { groupId });
         const pipeOutput = await this.pipeOutputCapture(task);
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = this.outputStyle === 'static'
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
             ? 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));
@@ -790,7 +956,7 @@ class TaskOrchestrator {
                 else if (this.tuiEnabled) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                         // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                         runningTask.onOutput((output) => {
                             this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                         });
@@ -839,7 +1005,7 @@ class TaskOrchestrator {
             if (this.tuiEnabled) {
                 if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                     // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getPtyHandles());
                     runningTask.onOutput((output) => {
                         this.options.lifeCycle.appendTaskOutput(task.id, output, true);
                     });
@@ -923,13 +1089,11 @@ class TaskOrchestrator {
         const pipeOutput = await this.pipeOutputCapture(task);
         // obtain metadata
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = this.outputStyle === 'static'
+        const streamOutput = (0, output_1.isStaticOutputStyle)(this.outputStyle)
             ? 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.js

@@ -7,6 +7,7 @@ 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
@@ -42,23 +43,24 @@ function acknowledgePnpmBuildScripts(treeOrRoot, entries) {
     // 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;
     }
-    const doc = parsed.contents instanceof yaml_1.YAMLMap ? parsed : new yaml_1.Document({});
     let changed = false;
     for (const [pkg, allowed] of Object.entries(entries)) {
         // Only a real boolean is a user decision. pnpm's non-strict installs stub
         // undecided packages with a placeholder string ("set this to true or
         // false"), which would fail the next strict install if left in place.
-        if (typeof doc.getIn(['allowBuilds', pkg]) !== 'boolean') {
-            doc.setIn(['allowBuilds', pkg], allowed);
+        if (typeof parsed.getIn(['allowBuilds', pkg]) !== 'boolean') {
+            parsed.setIn(['allowBuilds', pkg], allowed);
             changed = true;
         }
     }
     if (changed) {
-        host.write(PNPM_WORKSPACE_FILE, doc.toString());
+        host.write(PNPM_WORKSPACE_FILE, parsed.toString());
     }
 }
 function createHost(treeOrRoot) {
@@ -76,7 +78,7 @@ function createHost(treeOrRoot) {
         exists: (p) => treeOrRoot.exists(p),
         read: (p) => treeOrRoot.read(p, 'utf-8'),
         write: (p, c) => treeOrRoot.write(p, c),
-        readJson: (p) => JSON.parse(treeOrRoot.read(p, 'utf-8')),
+        readJson: (p) => (0, json_1.parseJson)(treeOrRoot.read(p, 'utf-8')),
     };
 }
 function getPnpmVersion(host) {

package/dist/src/utils/analytics-enabled.d.ts

@@ -0,0 +1,7 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+/**
+ * Analytics are opt-in: both `"analytics": false` and an unset flag mean no
+ * event is ever sent. Anything enabled for the sake of analytics (network
+ * allowlists, endpoints) gates on this, not on an explicit opt-out alone.
+ */
+export declare function isAnalyticsEnabled(nxJson: NxJsonConfiguration | null): boolean;

package/dist/src/utils/analytics-enabled.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnalyticsEnabled = isAnalyticsEnabled;
+/**
+ * Analytics are opt-in: both `"analytics": false` and an unset flag mean no
+ * event is ever sent. Anything enabled for the sake of analytics (network
+ * allowlists, endpoints) gates on this, not on an explicit opt-out alone.
+ */
+function isAnalyticsEnabled(nxJson) {
+    return nxJson?.analytics === true;
+}

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,11 +2,8 @@
 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 prompt_helpers_1 = require("./prompt-helpers");
 const path_1 = require("path");
 const output_1 = require("./output");
 const is_ci_1 = require("./is-ci");
@@ -50,16 +47,13 @@ async function promptForAnalyticsPreference() {
                 'Learn more: https://cloud.nx.app/privacy',
             ],
         });
-        const { enableAnalytics } = await (0, enquirer_1.prompt)({
-            type: 'confirm',
-            name: 'enableAnalytics',
+        return await (0, prompt_helpers_1.confirmationPrompt)({
             message: 'Share usage data with the Nx team?',
-            initial: true,
+            // Cancelling is a decline, not a failure.
+            onCancel: () => false,
         });
-        return enableAnalytics;
     }
     catch {
-        // User cancelled - default to false
         return false;
     }
 }
@@ -85,51 +79,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/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;