nx 23.1.0-beta.3 → 23.1.0-beta.4

package/dist/src/command-line/migrate/migrate.d.ts

@@ -85,6 +85,7 @@ export declare class Migrator {
     }>;
     private createMigrateJson;
     private buildPackageJsonUpdates;
+    private resolveVersionForCascade;
     private populatePackageJsonUpdatesAndGetPackagesToCheck;
     private getPackageJsonUpdatesFromMigrationConfig;
     /**

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

@@ -192,16 +192,37 @@ class Migrator {
                     !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
                     (!this.interactive ||
                         (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
-                    Object.entries(packageUpdate.packages).forEach(([name, update]) => {
+                    const updateEntries = Object.entries(packageUpdate.packages);
+                    // Validate all up front so invalid metadata fails fast, before any
+                    // resolution does I/O.
+                    for (const [name, update] of updateEntries) {
                         this.validatePackageUpdateVersion(packageToCheck.package, name, update);
-                        filteredUpdates[name] = update;
-                        this.packageUpdates[name] = update;
-                    });
+                    }
+                    // Resolve serially: resolution can prompt (pnpm strict cooldown) and
+                    // append to minimumReleaseAgeExclude, so a serial loop avoids
+                    // overlapping prompts and keeps packageUpdates ordering stable.
+                    for (const [name, update] of updateEntries) {
+                        const resolvedUpdate = {
+                            ...update,
+                            version: await this.resolveVersionForCascade(name, update.version),
+                        };
+                        filteredUpdates[name] = resolvedUpdate;
+                        this.packageUpdates[name] = resolvedUpdate;
+                    }
                 }
             }
             await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
         }
     }
+    async resolveVersionForCascade(packageName, version) {
+        // Already a fully-qualified semver (incl. prereleases) - nothing to resolve.
+        if ((0, semver_1.valid)(version)) {
+            return version;
+        }
+        // Otherwise resolve the spec (range/tag) through the min-release-age policy,
+        // which also honors any configured minimumReleaseAgeExclude entries.
+        return (0, resolve_package_version_1.resolvePackageVersionRespectingMinReleaseAge)(packageName, version);
+    }
     async populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target) {
         let targetVersion = target.version;
         if (this.to[targetPackage]) {

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -178,9 +178,26 @@ async function getCachedSerializedProjectGraphPromise(socket) {
 }
 function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFiles) {
     ++fileChangeCounter;
-    for (let f of [...createdFiles, ...updatedFiles]) {
+    // Hash the changed files up front and drop no-op rewrites before they can
+    // trigger an expensive recompute. Restoring a cached task output, a
+    // `git checkout` back to the same content, or a formatter that changes
+    // nothing all rewrite a file (new inode) the watcher reports as changed
+    // even though the bytes are identical. updateFilesInContext updates the
+    // workspace context and returns only the files whose content actually
+    // changed. Hashing here — once per watcher batch — rather than inside the
+    // recompute keeps it off the stale-retry path, which would otherwise see
+    // "no change" after the first pass already updated the context hashes.
+    perf_hooks_1.performance.mark('hash-watched-changes-start');
+    const changedFileHashes = createdFiles.length > 0 ||
+        updatedFiles.length > 0 ||
+        deletedFiles.length > 0
+        ? ((0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles) ?? {})
+        : {};
+    perf_hooks_1.performance.mark('hash-watched-changes-end');
+    perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
+    for (const [f, hash] of Object.entries(changedFileHashes)) {
         collectedDeletedFiles.delete(f);
-        collectedUpdatedFiles.set(f, fileChangeCounter);
+        collectedUpdatedFiles.set(f, { version: fileChangeCounter, hash });
     }
     for (let f of deletedFiles) {
         collectedUpdatedFiles.delete(f);
@@ -188,9 +205,7 @@ function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFi
     }
     // The native watcher already coalesces a burst of events into one batch,
     // so socket + listener notifications dispatch immediately.
-    if (createdFiles.length > 0 ||
-        updatedFiles.length > 0 ||
-        deletedFiles.length > 0) {
+    if (Object.keys(changedFileHashes).length > 0 || deletedFiles.length > 0) {
         (0, file_change_events_1.notifyFileChangeListeners)({ createdFiles, updatedFiles, deletedFiles });
         (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, updatedFiles, deletedFiles);
         // Bump generation synchronously so any in-flight compute fails its
@@ -284,14 +299,18 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         return cachedSerializedProjectGraphPromise;
     };
     try {
-        perf_hooks_1.performance.mark('hash-watched-changes-start');
         const updatedFilesSnapshot = new Map(collectedUpdatedFiles);
         const deletedFilesSnapshot = new Map(collectedDeletedFiles);
         const updatedFiles = [...updatedFilesSnapshot.keys()];
         const deletedFiles = [...deletedFilesSnapshot.keys()];
-        let updatedFileHashes = (0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, updatedFiles, deletedFiles);
-        perf_hooks_1.performance.mark('hash-watched-changes-end');
-        perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
+        // Hashes were already computed (and the workspace context updated) in
+        // scheduleProjectGraphRecomputation, which also dropped no-op rewrites.
+        // Reuse them so the context isn't re-hashed on every (possibly stale)
+        // recompute attempt.
+        const updatedFileHashes = {};
+        for (const [f, { hash }] of updatedFilesSnapshot) {
+            updatedFileHashes[f] = hash;
+        }
         logger_1.serverLogger.requestLog(`Updated workspace context based on watched changes, recomputing project graph...`);
         logger_1.serverLogger.requestLog(updatedFiles);
         logger_1.serverLogger.requestLog(deletedFiles);
@@ -333,8 +352,8 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // from the daemon's view (project graph misses recently added files).
         // Match version-stamps so a file modified mid-flight (higher version)
         // stays in the queue for reprocessing.
-        for (const [f, version] of updatedFilesSnapshot) {
-            if (collectedUpdatedFiles.get(f) === version) {
+        for (const [f, { version }] of updatedFilesSnapshot) {
+            if (collectedUpdatedFiles.get(f)?.version === version) {
                 collectedUpdatedFiles.delete(f);
             }
         }

package/dist/src/native/index.d.ts

@@ -34,7 +34,7 @@ export declare class AppLifeCycle {
   startTasks(tasks: Array<Task>, metadata: object): void
   printTaskTerminalOutput(task: Task, status: string, output: string): void
   endTasks(taskResults: Array<TaskResult>, metadata: object): void
-  endCommand(): void
+  endCommand(summary?: PerformanceSummaryPayload | undefined | null): void
   __init(doneCallback: (() => unknown)): void
   registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[ParserArc, WriterArc]>): void
   registerRunningTaskWithEmptyParser(taskId: string): void
@@ -275,6 +275,15 @@ export interface CachedResult {
   size?: number
 }
 
+/**
+ * Cache hits vs total; present only when there was a cache outcome. A bypassed
+ * cache is signalled separately by `cache_skipped`.
+ */
+export interface CacheStat {
+  hits: number
+  total: number
+}
+
 export declare function canInstallNxConsole(): Promise<boolean>
 
 export declare function canInstallNxConsoleForEditor(editor: SupportedEditor): Promise<boolean>
@@ -375,6 +384,13 @@ export declare function findImports(projectFileMap: Record<string, Array<string>
  */
 export declare function flushTelemetry(): void
 
+/**
+ * The single duration formatter — used by the task list, terminal report, and TUI
+ * popup. Exposed to JS as `formatDuration` so all three share one implementation.
+ * 0 (or sub-millisecond) → "<1ms", then "470ms", "13.4s", "1m 30s".
+ */
+export declare function formatDuration(ms: number): string
+
 export declare function getBinaryTarget(): string
 
 export declare function getDefaultMaxCacheSize(cachePath: string): number
@@ -524,6 +540,15 @@ export declare function killProcessTree(rootPid: number, signal?: string | numbe
  */
 export declare function killProcessTreeGraceful(rootPid: number, signal?: string | number | undefined | null, gracePeriodMs?: number | undefined | null): Promise<void>
 
+/**
+ * A docs link rendered as an OSC 8 hyperlink. Both fields come from TS so the
+ * popup never hardcodes a URL.
+ */
+export interface Link {
+  text: string
+  href: string
+}
+
 export declare function logDebug(message: string): void
 
 /** Combined metadata for groups and processes */
@@ -564,6 +589,28 @@ export interface NxWorkspaceFilesExternals {
 
 export declare function parseTaskStatus(stringStatus: string): TaskStatus
 
+/**
+ * Structured run report shown in the exit-countdown popup. The TUI builds the
+ * visual from these numbers rather than receiving a pre-formatted string.
+ */
+export interface PerformanceSummaryPayload {
+  runDurationMs: number
+  criticalPathMs: number
+  criticalPathTaskCount: number
+  recoverableMs: number
+  cache?: CacheStat
+  cacheSkipped: boolean
+  /** Already in display order; a multi-line entry embeds a task list. */
+  recommendations: Array<string>
+  /** The docs footer link, rendered as a bullet and hyperlinked. */
+  footer: Link
+  /**
+   * Phrases already in `recommendations` to hyperlink in place (e.g. the
+   * remote-cache CTA); empty when none apply.
+   */
+  links: Array<Link>
+}
+
 /** Process metadata (static, doesn't change during process lifetime) */
 export interface ProcessMetadata {
   ppid: number

package/dist/src/native/native-bindings.js

@@ -605,6 +605,7 @@ module.exports.EventType = nativeBinding.EventType
 module.exports.expandOutputs = nativeBinding.expandOutputs
 module.exports.findImports = nativeBinding.findImports
 module.exports.flushTelemetry = nativeBinding.flushTelemetry
+module.exports.formatDuration = nativeBinding.formatDuration
 module.exports.getBinaryTarget = nativeBinding.getBinaryTarget
 module.exports.getDefaultMaxCacheSize = nativeBinding.getDefaultMaxCacheSize
 module.exports.getEventDimensions = nativeBinding.getEventDimensions

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTasksRunner = exports.RemoteCacheV2 = void 0;
 const task_orchestrator_1 = require("./task-orchestrator");
+const performance_life_cycle_1 = require("./life-cycles/performance-life-cycle");
 const cache_directory_1 = require("../utils/cache-directory");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
@@ -54,13 +55,15 @@ class RemoteCacheV2 {
 }
 exports.RemoteCacheV2 = RemoteCacheV2;
 const defaultTasksRunner = async (tasks, options, context) => {
-    const { total: threadCount } = (0, task_orchestrator_1.getThreadPoolSize)(options, context.taskGraph);
-    await options.lifeCycle.startCommand(threadCount);
+    const { total: threadCount, discrete } = (0, task_orchestrator_1.getThreadPoolSize)(options, context.taskGraph);
+    // Total thread count drives the TUI; the discrete `--parallel` feeds the perf report.
+    await options.lifeCycle.startCommand(threadCount, discrete);
     try {
         return await runAllTasks(options, context);
     }
     finally {
-        await options.lifeCycle.endCommand();
+        // Hand the TUI exit popup the perf report (multi-task TUI runs); other modes flush it.
+        await options.lifeCycle.endCommand((0, performance_life_cycle_1.getPerformanceReport)(tasks.length));
     }
 };
 exports.defaultTasksRunner = defaultTasksRunner;

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

@@ -15,7 +15,7 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
-        ...(0, run_command_1.constructLifeCycles)(invokeRunnerTerminalLifecycle),
+        ...(0, run_command_1.constructLifeCycles)(invokeRunnerTerminalLifecycle, fullTaskGraph, nxJson),
         taskResultsLifecycle,
         lifeCycle,
     ]);

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
+import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
 import { TaskStatus } from './tasks-runner';
 /**
  * The result of a completed {@link Task}.
@@ -21,8 +21,13 @@ export interface TaskMetadata {
     groupId: number;
 }
 export interface LifeCycle {
-    startCommand?(parallel?: number): void | Promise<void>;
-    endCommand?(): void | Promise<void>;
+    /**
+     * @param threadCount total thread-pool size (drives the TUI display)
+     * @param parallel resolved `--parallel` (discrete slots), for the performance report
+     */
+    startCommand?(threadCount?: number, parallel?: number): void | Promise<void>;
+    /** @param summary performance report payload for the TUI exit popup (TUI runs only) */
+    endCommand?(summary?: PerformanceSummaryPayload): void | Promise<void>;
     scheduleTask?(task: Task): void | Promise<void>;
     /**
      * @deprecated use startTasks
@@ -53,8 +58,8 @@ export interface LifeCycle {
 export declare class CompositeLifeCycle implements LifeCycle {
     private readonly lifeCycles;
     constructor(lifeCycles: LifeCycle[]);
-    startCommand(parallel?: number): Promise<void>;
-    endCommand(): Promise<void>;
+    startCommand(threadCount?: number, parallel?: number): Promise<void>;
+    endCommand(summary?: PerformanceSummaryPayload): Promise<void>;
     scheduleTask(task: Task): Promise<void>;
     startTask(task: Task): void;
     endTask(task: Task, code: number): void;

package/dist/src/tasks-runner/life-cycle.js

@@ -5,17 +5,17 @@ class CompositeLifeCycle {
     constructor(lifeCycles) {
         this.lifeCycles = lifeCycles;
     }
-    async startCommand(parallel) {
+    async startCommand(threadCount, parallel) {
         for (let l of this.lifeCycles) {
             if (l.startCommand) {
-                await l.startCommand(parallel);
+                await l.startCommand(threadCount, parallel);
             }
         }
     }
-    async endCommand() {
+    async endCommand(summary) {
         for (let l of this.lifeCycles) {
             if (l.endCommand) {
-                await l.endCommand();
+                await l.endCommand(summary);
             }
         }
     }

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

@@ -0,0 +1,156 @@
+import { TaskGraph } from '../../config/task-graph';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { type Recommendation } from './performance-report';
+import { TaskResult } from '../life-cycle';
+export interface TaskTiming {
+    startTime?: number;
+    endTime?: number;
+    continuous: boolean;
+}
+/** A discrete task that ran, with its window and whether it monopolizes the pool (`parallelism: false`). */
+export interface TimedTask {
+    id: string;
+    start: number;
+    end: number;
+    nonParallel: boolean;
+}
+/**
+ * One [start, end) slice of the run where the counts below hold steady — the gap between
+ * two adjacent sweep boundaries (see {@link buildTimespans}). Because nothing changes
+ * within the slice, the analysis treats it as a flat rectangle of `end - start` ms.
+ */
+export interface Timespan {
+    /** Slice bounds (epoch ms); occ/waiting/nonParallel are constant across [start, end). */
+    start: number;
+    end: number;
+    /** Slots busy for the whole slice (a `parallelism: false` task counts as the entire pool). */
+    occ: number;
+    /** Tasks eligible to run but still queued for a free slot. */
+    waiting: number;
+    /** `parallelism: false` tasks running during the slice (each one holds every slot). */
+    nonParallel: number;
+}
+export interface PerformanceSummary {
+    runDuration: number;
+    criticalPathDuration: number;
+    criticalPathTaskCount: number;
+    /** Longest critical-path tasks that ran (desc, capped at a few), cache hits excluded; empty when the path was fully cached. */
+    criticalPathTop: Array<{
+        id: string;
+        duration: number;
+    }>;
+    /** runDuration − criticalPathDuration. */
+    overhead: number;
+    /** Overhead split by lever; these + coordinatorOverhead sum to `overhead`. Their sum is the slot-contention time (derived, never stored, so the halves can't drift). */
+    recoverableByParallel: number;
+    recoverableByMachines: number;
+    coordinatorOverhead: number;
+    parallel: number;
+    cores: number;
+    isCI: boolean;
+    /** One structured rec per lever (with link parts); drives the report + payload renderers. */
+    structuredRecommendations: Recommendation[];
+    /** Coordinator overhead outweighs task work, so the longest tasks aren't the lever (typical cached run). */
+    coordinatorDominated: boolean;
+    cacheHits: number;
+    /** Tasks with any cache outcome (hits + tasks that ran). */
+    cacheableCount: number;
+    cacheSkipped: boolean;
+    remoteCacheEnabled: boolean;
+}
+/** Construction-time inputs for {@link PerformanceLifeCycle}. */
+export interface PerformanceLifeCycleOptions {
+    /** Whether `--skip-nx-cache` was passed (feeds the cache-skipped check). */
+    skipNxCache?: boolean;
+    /** Passed in at construction so the lifecycle doesn't re-read nx.json. */
+    nxJson?: NxJsonConfiguration;
+}
+/**
+ * Pure analysis over one finished run's collected timings — no lifecycle state and no
+ * mutation. Built once per run from the {@link PerformanceLifeCycle}'s accumulated
+ * maps; everything here is a function of that snapshot plus the environment it reads.
+ */
+export declare class PerformanceAnalysis {
+    private readonly timings;
+    private readonly statuses;
+    private readonly taskGraph;
+    private readonly batchSiblings;
+    /** Resolved `--parallel` (getThreadPoolSize's `discrete`), set on the lifecycle by the runner; falls back to 1. */
+    private readonly parallel;
+    private readonly options;
+    constructor(timings: Map<string, TaskTiming>, statuses: Map<string, TaskResult['status']>, taskGraph: TaskGraph, batchSiblings: Map<string, string[]>, 
+    /** Resolved `--parallel` (getThreadPoolSize's `discrete`), set on the lifecycle by the runner; falls back to 1. */
+    parallel: number, options: PerformanceLifeCycleOptions);
+    /**
+     * Whether a remote (Nx Cloud) cache is active, from the nx.json handed in at
+     * construction. Assumes no remote cache when it wasn't provided rather than
+     * re-reading nx.json from disk — the CLI path always provides it.
+     */
+    private remoteCacheEnabled;
+    /** Discrete tasks that ran and have a start + end timestamp. */
+    private timedTasks;
+    /**
+     * Longest-duration chain through the dependency DAG — the floor with unlimited
+     * slots. `finishEstimate(t) = duration[t] + max(finishEstimate(p) for predecessors
+     * p)`. Predecessors are real dependencies *plus* earlier batch siblings (a batch runs
+     * sequentially in one process, so that ordering is part of the floor too). On equal
+     * finish estimates keep the longer-running predecessor.
+     */
+    private criticalPath;
+    /**
+     * Real predecessors of `id`: dependencies plus any earlier batch sibling that FINISHED
+     * before `id` started. A batch runs sequentially in one process, so that ordering is
+     * part of the floor; concurrent batch executors aren't, and chaining them would inflate
+     * it. (Matches readyTime.)
+     */
+    private predecessorsFor;
+    /**
+     * Longest finish time of any chain reaching `id` — its duration plus the best
+     * predecessor's finish estimate — memoized in `ctx`. `ctx.visiting` guards a cycle in
+     * a malformed graph (the back-edge contributes nothing).
+     */
+    private finishEstimate;
+    /**
+     * Earliest this task became eligible, independent of slots: the latest of run
+     * start, dependency ends, any continuous dependency's *start* (an ordering
+     * constraint, not contention), and any earlier batch sibling's end.
+     */
+    private readyTime;
+    /**
+     * Longest critical-path tasks that RAN (desc, capped at 3). Cache hits are excluded
+     * (their duration is just restore time); no-status tasks (synthetic test runs) are
+     * kept.
+     */
+    private computeCriticalPathTop;
+    /** Cache outcome: tasks restored (`cacheHits`) and the total with a cache outcome (`cacheableCount` = hits + ran). No-status tasks count for neither. */
+    private computeCacheStats;
+    /** The structured performance summary, or `null` when no discrete task timings were recorded. */
+    summary(): PerformanceSummary | null;
+}
+/**
+ * Union a set of `[start, end]` intervals into an ordered, non-overlapping set, e.g.
+ * `[[1, 3], [2, 5]]` → `[[1, 5]]`. Sort by start, then sweep once: each interval
+ * either extends the previous merged one (if it overlaps or touches it) or begins a
+ * new one.
+ */
+export declare function mergeIntervals(intervals: Array<[number, number]>): Array<[number, number]>;
+/** Total time [a, b] overlaps the given (unsorted, possibly overlapping) intervals. */
+export declare function overlap(a: number, b: number, intervals: Array<[number, number]>): number;
+/**
+ * Coordinator hashing wall-clock that ran *before* the first task started — the run
+ * window (first task start → last task end) would otherwise miss it. Matters on a
+ * cached run where hashing dominates but the tasks restore in milliseconds.
+ *
+ * `hashWindows` are absolute `[start, end]` spans from nx's `hash*` perf measures.
+ */
+export declare function preDispatchHashTime(firstTaskStart: number, hashWindows: Array<[number, number]>): number;
+/**
+ * The occupancy timeline (contiguous {@link Timespan}s) — single source of truth for
+ * slot contention. A `parallelism: false` task occupies the whole pool. Integrates
+ * over time rather than sampling one instant, so it's robust to when tasks hand off.
+ *
+ * Builds it via a delta sweep: each task bumps a counter up at its start and down at
+ * its end, then we walk the sorted boundaries accumulating the running totals into one
+ * timespan per gap.
+ */
+export declare function buildTimespans(timed: TimedTask[], eligible: Map<string, number>, parallel: number): Timespan[];