nx 23.1.0-beta.2 → 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;
     /**
@@ -172,6 +173,7 @@ export declare function createFetcher(pmc: PackageManagerCommands): ((pkg: strin
     stats?: MigrateFetchStats;
 };
 export { filterDowngradedUpdates };
+export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
 /**
  * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
  * error code, which npm consistently emits for this class of failure across

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

@@ -6,6 +6,7 @@ exports.resolveCanonicalNxPackage = resolveCanonicalNxPackage;
 exports.resolveInclude = resolveInclude;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.createFetcher = createFetcher;
+exports.generateMigrationsJsonAndUpdatePackageJson = generateMigrationsJsonAndUpdatePackageJson;
 exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.resolveAgenticRunId = resolveAgenticRunId;
 exports.formatSkippedPromptsNextStep = formatSkippedPromptsNextStep;
@@ -191,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]) {
@@ -1347,6 +1369,7 @@ function readNxVersion(packageJson, root) {
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nx/workspace', root, packageJson) ??
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nrwl/workspace', root, packageJson));
 }
+// Exported for testing the optional-include orchestration seam (see NXC-4590).
 async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     let phase = 'fetch_migrations';
@@ -1417,7 +1440,11 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
         const writableUpdates = (0, update_filters_1.filterDowngradedUpdates)(packageUpdates, (0, catalog_1.resolveCatalogSpecifiers)(originalPackageJson), installedPackageVersions);
         const wrotePackageJson = await updatePackageJson(root, writableUpdates);
         const wroteNxJsonInstallation = await updateInstallationDetails(root, writableUpdates);
-        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, packageUpdates[walkedTargetPackage].version);
+        // Under `--include=optional` the target's own entry is filtered out of
+        // `packageUpdates` (it's a required package), so resolve the version
+        // defensively. Also reused by the completion analytics below.
+        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
+        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, resolvedTargetVersion);
         if (migrations.length > 0) {
             await createMigrationsFile(root, [
                 ...addSplitConfigurationMigrationIfAvailable(from, writableUpdates),
@@ -1429,7 +1456,6 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
             : include === 'optional'
                 ? `- Processed optional dependency updates only (skipped required package updates).`
                 : null;
-        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
         // The param expressions below evaluate before the report function is
         // entered; `safeReport` keeps them inside the analytics boundary so a
         // param-building throw can't surface here and convert an already

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/plugins/js/utils/register.d.ts

@@ -35,22 +35,43 @@ export declare function forceRegisterEsmLoader(): void;
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 export declare const NODENEXT_ESM_RESOLVER_SOURCE = "\nconst EXT_FALLBACK = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };\nconst TS_PARENT_RE = /\\.(?:ts|tsx|mts|cts)(?:$|\\?)/;\nexport async function resolve(specifier, context, nextResolve) {\n  try {\n    return await nextResolve(specifier, context);\n  } catch (err) {\n    if (err?.code !== 'ERR_MODULE_NOT_FOUND') throw err;\n    const parent = context.parentURL;\n    if (!parent || !TS_PARENT_RE.test(parent)) throw err;\n    if (!(specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('file:'))) throw err;\n    const m = specifier.match(/(\\.(?:js|mjs|cjs))($|\\?)/);\n    if (!m) throw err;\n    const fallbacks = EXT_FALLBACK[m[1]];\n    if (!fallbacks) throw err;\n    const base = specifier.slice(0, m.index);\n    const suffix = specifier.slice(m.index + m[1].length);\n    for (const ext of fallbacks) {\n      try { return await nextResolve(base + ext + suffix, context); } catch {}\n    }\n    throw err;\n  }\n}\n";
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+export declare function nodeNextEsmResolveHook(specifier: string, context: {
+    parentURL?: string;
+}, nextResolve: (specifier: string, context?: unknown) => {
+    url: string;
+}): {
+    url: string;
+};
+/**
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */

package/dist/src/plugins/js/utils/register.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NODENEXT_ESM_RESOLVER_SOURCE = void 0;
 exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
+exports.nodeNextEsmResolveHook = nodeNextEsmResolveHook;
 exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
 exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
 exports.isNativeStripPreferred = isNativeStripPreferred;
@@ -100,6 +101,10 @@ function ensureEsmLoaderRegistered(opts) {
  * the importing module is itself TypeScript, and the specifier is relative, so
  * it never hijacks resolution that would otherwise succeed.
  *
+ * Used only as the fallback for runtimes without `module.registerHooks()`
+ * (Node < 22.15 / < 23.5); newer runtimes register the in-thread synchronous
+ * twin `nodeNextEsmResolveHook` instead. Keep the two in sync.
+ *
  * Exported so the hook can be exercised directly in unit tests.
  */
 exports.NODENEXT_ESM_RESOLVER_SOURCE = `
@@ -126,20 +131,70 @@ export async function resolve(specifier, context, nextResolve) {
   }
 }
 `;
+const NODENEXT_EXT_FALLBACK = {
+    '.js': ['.ts', '.tsx'],
+    '.mjs': ['.mts'],
+    '.cjs': ['.cts'],
+};
+const NODENEXT_TS_PARENT_RE = /\.(?:ts|tsx|mts|cts)(?:$|\?)/;
+/**
+ * Synchronous in-thread twin of `NODENEXT_ESM_RESOLVER_SOURCE` for
+ * `module.registerHooks()`: `nextResolve` throws synchronously rather than
+ * rejecting, so this uses try/catch instead of `await`. Keep the two in sync.
+ * Exported for unit tests.
+ */
+function nodeNextEsmResolveHook(specifier, context, nextResolve) {
+    try {
+        return nextResolve(specifier, context);
+    }
+    catch (err) {
+        if (err?.code !== 'ERR_MODULE_NOT_FOUND')
+            throw err;
+        const parent = context.parentURL;
+        if (!parent || !NODENEXT_TS_PARENT_RE.test(parent))
+            throw err;
+        if (!(specifier.startsWith('./') ||
+            specifier.startsWith('../') ||
+            specifier.startsWith('file:'))) {
+            throw err;
+        }
+        const m = specifier.match(/(\.(?:js|mjs|cjs))($|\?)/);
+        if (!m)
+            throw err;
+        const fallbacks = NODENEXT_EXT_FALLBACK[m[1]];
+        if (!fallbacks)
+            throw err;
+        const base = specifier.slice(0, m.index);
+        const suffix = specifier.slice(m.index + m[1].length);
+        for (const ext of fallbacks) {
+            try {
+                return nextResolve(base + ext + suffix, context);
+            }
+            catch {
+                // try the next fallback
+            }
+        }
+        throw err;
+    }
+}
 let nodeNextEsmResolverRegistered = false;
 /**
- * Register a self-contained ESM resolution hook (via `Module.register`) that
- * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
- * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
- * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
- * file, but neither native strip nor Node's ESM resolver rewrites the
- * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
- * exists fails with ERR_MODULE_NOT_FOUND without it.
+ * Register an ESM resolution hook that rewrites TypeScript NodeNext-style
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * This is the ESM counterpart to `ensureCjsResolverPatched`: Node's native type
+ * stripping loads the `.ts` file, but neither native strip nor Node's ESM
+ * resolver rewrites the extension, so `import './foo.js'` from a `.ts` source
+ * where only `foo.ts` exists fails with ERR_MODULE_NOT_FOUND without it.
  *
- * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
- * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ * Prefers `module.registerHooks()` (Node 22.15+ / 23.5+), passing the in-thread
+ * `nodeNextEsmResolveHook`. Falls back to `module.register()` with the inlined
+ * `data:` module (`NODENEXT_ESM_RESOLVER_SOURCE`) on older runtimes that lack
+ * `registerHooks` - `module.register()` emits a runtime DeprecationWarning
+ * (DEP0205) on Node 25.9+/26+, so it is only used when nothing better exists.
+ * Either way the hook relies only on Node's default resolver - no
+ * ts-node/swc-node.
  *
- * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * Idempotent and best-effort: a no-op when no registration API is available,
  * when a TypeScript transpiler is already preloaded (see
  * `isTsTranspilerPreloaded`), or if registration fails.
  */
@@ -148,16 +203,16 @@ function ensureNodeNextEsmResolverRegistered() {
         return;
     nodeNextEsmResolverRegistered = true;
     const module = require('node:module');
-    if (typeof module.register !== 'function')
-        return;
     // Skip when a transpiler was preloaded via `--require`/`--import` (e.g.
     // `--require ts-node/register`, which Nx uses only when it runs from `.ts`
-    // source). `module.register()` spins up a loader-hook worker thread on which
-    // Node re-runs those preloads, resolved relative to the *current* working
-    // directory - and Nx plugin workers `chdir()` into the analyzed workspace
-    // first. If that workspace can't resolve the preloaded module, the loader
-    // worker throws and can leave module resolution in a bad state, so we must
-    // avoid the call entirely; catching it is not a clean recovery.
+    // source). The `module.register()` fallback below spins up a loader-hook
+    // worker thread on which Node re-runs those preloads, resolved relative to
+    // the *current* working directory - and Nx plugin workers `chdir()` into the
+    // analyzed workspace first. If that workspace can't resolve the preloaded
+    // module, the loader worker throws and can leave module resolution in a bad
+    // state, so we must avoid the call entirely; catching it is not a clean
+    // recovery. `module.registerHooks()` runs in-thread with no such worker, but
+    // we keep the skip uniform so resolver coverage doesn't vary by Node version.
     //
     // Consequence: in that from-`.ts`-source invocation a `type: module` plugin
     // using NodeNext `.js` specifiers won't get this resolver (a preloaded
@@ -165,6 +220,20 @@ function ensureNodeNextEsmResolverRegistered() {
     // unaffected - its workers run compiled `.js` with no preload.
     if (isTsTranspilerPreloaded())
         return;
+    // Synchronous in-thread hooks (Node 22.15+ / 23.5+). Preferred because
+    // `module.register()` is deprecated (DEP0205) from Node 25.9+/26+.
+    const registerHooks = module.registerHooks;
+    if (typeof registerHooks === 'function') {
+        try {
+            registerHooks.call(module, { resolve: nodeNextEsmResolveHook });
+        }
+        catch {
+            // Best-effort: leave Node's native handling in place rather than failing.
+        }
+        return;
+    }
+    if (typeof module.register !== 'function')
+        return;
     try {
         module.register('data:text/javascript,' + encodeURIComponent(exports.NODENEXT_ESM_RESOLVER_SOURCE));
     }

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