nx 23.1.0 → 23.2.0-beta.1

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

@@ -5,6 +5,7 @@ exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
 exports.nodeNextEsmResolveHook = nodeNextEsmResolveHook;
 exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
 exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
+exports.ensureResolveConditionsInjected = ensureResolveConditionsInjected;
 exports.isNativeStripPreferred = isNativeStripPreferred;
 exports.registerTsProject = registerTsProject;
 exports.getSwcTranspiler = getSwcTranspiler;
@@ -388,6 +389,86 @@ const isInvokedByTsx = (() => {
     return (requireArgs.some((a) => isTsxPath(a)) ||
         importArgs.some((a) => isTsxPath(a)));
 })();
+let resolveConditionsInjected = false;
+/**
+ * Make Node's module resolver honor the given export conditions for the rest of
+ * the process, via `module.registerHooks()`. Used when a local plugin is loaded
+ * from source in-process (no child process to pass `--conditions` to at spawn):
+ * the hook appends the conditions to every resolution so the plugin's transitive
+ * workspace imports resolve to source the same way the plugin entry did.
+ *
+ * No-op when:
+ *   - `conditions` is empty (nothing to inject);
+ *   - every target condition is already active at startup (a spawned plugin
+ *     worker or daemon was launched with the full `--conditions` set, so Node's
+ *     resolver already honors them and the per-resolve hook would be redundant);
+ *   - `module.registerHooks` is unavailable (Node < 22.15 / < 23.5). Those
+ *     runtimes keep the `NODE_OPTIONS=--conditions` escape hatch.
+ *
+ * Idempotent and best-effort.
+ */
+function ensureResolveConditionsInjected(conditions) {
+    if (resolveConditionsInjected)
+        return;
+    resolveConditionsInjected = true;
+    if (!conditions.length)
+        return;
+    // Skip only when Node already honors every target condition (e.g. a worker or
+    // daemon spawned with the full `--conditions` set); a partial overlap still
+    // needs the hook to add the missing ones.
+    const activeConditions = getConditionsActiveAtStartup();
+    if (conditions.every((condition) => activeConditions.has(condition)))
+        return;
+    const module = require('node:module');
+    const registerHooks = module.registerHooks;
+    if (typeof registerHooks !== 'function')
+        return;
+    try {
+        registerHooks.call(module, {
+            resolve(specifier, context, nextResolve) {
+                const merged = context.conditions
+                    ? [...context.conditions, ...conditions]
+                    : conditions;
+                return nextResolve(specifier, { ...context, conditions: merged });
+            },
+        });
+    }
+    catch {
+        // Best-effort: leave Node's native resolution in place rather than failing.
+    }
+}
+/**
+ * Export conditions this process was started with, parsed from `--conditions`
+ * (or its `-C` alias) in `process.execArgv` and `NODE_OPTIONS`. Node's resolver
+ * already honors these, so the injected hook only needs to cover target
+ * conditions not present here.
+ */
+function getConditionsActiveAtStartup() {
+    const active = new Set();
+    const collect = (tokens) => {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token === '--conditions' || token === '-C') {
+                const value = tokens[i + 1];
+                if (value) {
+                    active.add(value);
+                    i++;
+                }
+            }
+            else if (token.startsWith('--conditions=')) {
+                active.add(token.slice('--conditions='.length));
+            }
+            else if (token.startsWith('-C=')) {
+                active.add(token.slice('-C='.length));
+            }
+        }
+    };
+    collect(process.execArgv ?? []);
+    const nodeOptions = process.env.NODE_OPTIONS;
+    if (nodeOptions)
+        collect(nodeOptions.split(/\s+/).filter(Boolean));
+    return active;
+}
 /**
  * Whether the current Node.js runtime exposes native TypeScript type
  * stripping. This is the authoritative gate - it correctly handles every

package/dist/src/plugins/js/utils/typescript.d.ts

@@ -20,4 +20,13 @@ export declare function getRootTsConfigCustomConditions(root?: string): string[]
  * `migrate-development-custom-condition` (21.5).
  */
 export declare function getRootTsConfigResolveExportsConditions(root?: string): string[];
+/**
+ * Node `--conditions <name>` CLI args for spawning a plugin worker or the daemon
+ * with the plugin-resolution conditions active at startup. Mirrors the set Nx
+ * uses to resolve the plugin entry (`getRootTsConfigResolveExportsConditions`)
+ * so the entry and the plugin's transitive workspace imports resolve the same
+ * way; Node's own resolver otherwise ignores TypeScript `customConditions` and a
+ * source-loaded plugin's imports land on their unbuilt `dist`.
+ */
+export declare function getPluginResolveConditionNodeArgs(root?: string): string[];
 export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];

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

@@ -8,6 +8,7 @@ exports.getRootTsConfigFileName = getRootTsConfigFileName;
 exports.getRootTsConfigPath = getRootTsConfigPath;
 exports.getRootTsConfigCustomConditions = getRootTsConfigCustomConditions;
 exports.getRootTsConfigResolveExportsConditions = getRootTsConfigResolveExportsConditions;
+exports.getPluginResolveConditionNodeArgs = getPluginResolveConditionNodeArgs;
 exports.findNodes = findNodes;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const fs_1 = require("fs");
@@ -113,6 +114,20 @@ function getRootTsConfigResolveExportsConditions(root = workspace_root_1.workspa
         ? conditions
         : [...conditions, 'development'];
 }
+/**
+ * Node `--conditions <name>` CLI args for spawning a plugin worker or the daemon
+ * with the plugin-resolution conditions active at startup. Mirrors the set Nx
+ * uses to resolve the plugin entry (`getRootTsConfigResolveExportsConditions`)
+ * so the entry and the plugin's transitive workspace imports resolve the same
+ * way; Node's own resolver otherwise ignores TypeScript `customConditions` and a
+ * source-loaded plugin's imports land on their unbuilt `dist`.
+ */
+function getPluginResolveConditionNodeArgs(root = workspace_root_1.workspaceRoot) {
+    return getRootTsConfigResolveExportsConditions(root).flatMap((c) => [
+        '--conditions',
+        c,
+    ]);
+}
 function findNodes(node, kind, max = Infinity) {
     if (!node || max == 0) {
         return [];

package/dist/src/project-graph/error-types.js

@@ -242,9 +242,48 @@ class AggregateCreateNodesError extends Error {
                 errorTuple.length === 2)) {
             throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
         }
+        // Plugins pass through whatever value they caught, which is not
+        // guaranteed to be an Error. Coerce so formatting can rely on
+        // message and stack being present.
+        for (const errorTuple of errors) {
+            errorTuple[1] = coerceToError(errorTuple[1]);
+        }
     }
 }
 exports.AggregateCreateNodesError = AggregateCreateNodesError;
+function coerceToError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    let message;
+    let stack;
+    if (typeof value === 'object' && value !== null) {
+        const candidate = value;
+        if (typeof candidate.message === 'string') {
+            message = candidate.message;
+            if (typeof candidate.stack === 'string') {
+                stack = candidate.stack;
+            }
+        }
+        else {
+            try {
+                message = JSON.stringify(value);
+            }
+            catch {
+                // Circular structures cannot be stringified.
+                message = String(value);
+            }
+        }
+    }
+    else {
+        message = String(value);
+    }
+    const error = new Error(message);
+    // A synthesized stack would point at this coercion site rather than
+    // the original failure, so prefer the original stack or just the message.
+    error.stack = stack ?? message;
+    return error;
+}
 function formatAggregateCreateNodesError(error, pluginName) {
     const errorCount = error.errors.length > 1 ? `${error.errors.length} errors` : 'An error';
     const pluginLocation = error.pluginIndex
@@ -270,7 +309,8 @@ function formatAggregateCreateNodesError(error, pluginName) {
         }
         for (const e of errors) {
             const messageLines = e.message.split('\n');
-            const stackLines = e.stack.split('\n');
+            // Errors deserialized from a plugin worker may arrive without a stack.
+            const stackLines = (e.stack ?? e.message).split('\n');
             if (file) {
                 errorBodyLines.push(...messageLines.map((line) => `      ${line}`));
                 errorStackLines.push(...stackLines.map((line) => `     ${line}`));

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

@@ -12,6 +12,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
+const git_revision_1 = require("../utils/git-revision");
 const ignore_1 = require("../utils/ignore");
 const json_diff_1 = require("../utils/json-diff");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -116,11 +117,14 @@ function readLockFileAtRevision(file, lockFileName, revision, readFileAtRevision
 }
 exports.TEN_MEGABYTES = 1024 * 10000;
 function defaultReadFileAtRevision(file, revision) {
+    if (revision) {
+        (0, git_revision_1.assertValidGitRevision)(revision);
+    }
     try {
         const filePathInGitRepository = getFilePathInGitRepository(file);
         return !revision
             ? (0, fs_1.readFileSync)(file, 'utf-8')
-            : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
+            : (0, child_process_1.execFileSync)('git', ['show', `${revision}:${filePathInGitRepository}`], {
                 maxBuffer: exports.TEN_MEGABYTES,
                 stdio: ['pipe', 'pipe', 'ignore'],
                 windowsHide: true,
@@ -140,6 +144,7 @@ function defaultReadBunLockFileAtRevision(file, revision) {
             windowsHide: true,
         }).trim();
     }
+    (0, git_revision_1.assertValidGitRevision)(revision);
     const filePathInGitRepository = getFilePathInGitRepository(file);
     const tempDirectory = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'nx-bun-lock-'));
     const tempLockfilePath = (0, path_1.join)(tempDirectory, 'bun.lockb');

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -7,6 +7,7 @@ const path = require("path");
 const logger_1 = require("../../../daemon/logger");
 const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const typescript_1 = require("../../../plugins/js/utils/typescript");
 const installation_directory_1 = require("../../../utils/installation-directory");
 const logger_2 = require("../../../utils/logger");
 const progress_topics_1 = require("../../../utils/progress-topics");
@@ -353,6 +354,9 @@ async function startPluginWorker(name) {
     };
     const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++, performance.now()].join('-'));
     const worker = (0, child_process_1.spawn)(process.execPath, [
+        // Spawn the worker with the same resolve conditions Nx uses for plugin
+        // entries so the plugin's transitive workspace imports resolve to source.
+        ...(0, typescript_1.getPluginResolveConditionNodeArgs)(),
         ...(isWorkerTypescript ? ['--require', 'ts-node/register'] : []),
         workerPath,
         ipcPath,

package/dist/src/project-graph/plugins/transpiler.js

@@ -25,6 +25,10 @@ function registerPluginTSTranspiler() {
     if (exports.unregisterPluginTSTranspiler !== null) {
         return;
     }
+    // Align Node's runtime resolution with the source-first plugin entry so the
+    // plugin's transitive workspace imports don't fall through to unbuilt `dist`.
+    // A no-op inside a plugin worker/daemon already spawned with `--conditions`.
+    (0, register_1.ensureResolveConditionsInjected)((0, typescript_1.getRootTsConfigResolveExportsConditions)(workspace_root_1.workspaceRoot));
     if ((0, register_1.isNativeStripPreferred)()) {
         // Native strip handles `.ts` syntax but doesn't rewrite NodeNext-style
         // `.js` relative specifiers to their `.ts` sources. Patch the CJS resolver

package/dist/src/project-graph/utils/project-configuration/name-substitution-manager.d.ts

@@ -4,16 +4,13 @@ import { ProjectConfiguration } from '../../../config/workspace-json-project-jso
  * reference. `RootRef` carries the referenced project's root (resolved
  * via nameMap lookup); `UsageRef` carries the raw written name (for
  * forward refs, promoted to `RootRef` in place when the name is
- * identified). `parent` + `key` let the final pass write the resolved
- * name back; `targetPart` preserves the `:target` suffix from
+ * identified). `targetPart` preserves the `:target` suffix from
  * `dependsOn` strings.
  */
 export declare abstract class NameRef {
     value: string;
-    parent: unknown;
-    key: string | undefined;
     targetPart: string | undefined;
-    constructor(value: string, parent: unknown, key: string | undefined, targetPart: string | undefined);
+    constructor(value: string, targetPart: string | undefined);
 }
 export declare class RootRef extends NameRef {
 }
@@ -27,15 +24,15 @@ export declare function isUsageRef(value: unknown): value is UsageRef;
  * then resolves them after all merging is done.
  *
  * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Arrays spread-merge by pushing
- * element references, so sentinel identity survives any downstream
- * merges — the final pass walks a flat registry and writes the resolved
- * name back through each sentinel's `parent` back-reference. Orphaned
- * sentinels (from arrays dropped by a full-replace) write harmlessly.
+ * so each ref becomes a sentinel object. Merges copy sentinels by
+ * reference — one sentinel can end up in many arrays (e.g. a pattern
+ * target's dependsOn applied to every matching target) — so the final
+ * pass sweeps the merged rootMap and resolves every sentinel where it
+ * actually sits. Sentinels in arrays dropped by a full-replace are never
+ * visited and vanish with their array.
  */
 export declare class ProjectNameInNodePropsManager {
     private getNameMap;
-    private allRefs;
     private pendingByName;
     constructor(getNameMap?: () => Record<string, ProjectConfiguration>);
     registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
@@ -45,6 +42,6 @@ export declare class ProjectNameInNodePropsManager {
     private createRef;
     identifyProjectWithRoot(root: string, name: string): void;
     applySubstitutions(rootMap: Record<string, ProjectConfiguration>): void;
+    private substituteInArray;
     private resolveFinalName;
-    private writeReplacement;
 }

package/dist/src/project-graph/utils/project-configuration/name-substitution-manager.js

@@ -11,15 +11,12 @@ const split_target_1 = require("../../../utils/split-target");
  * reference. `RootRef` carries the referenced project's root (resolved
  * via nameMap lookup); `UsageRef` carries the raw written name (for
  * forward refs, promoted to `RootRef` in place when the name is
- * identified). `parent` + `key` let the final pass write the resolved
- * name back; `targetPart` preserves the `:target` suffix from
+ * identified). `targetPart` preserves the `:target` suffix from
  * `dependsOn` strings.
  */
 class NameRef {
-    constructor(value, parent, key, targetPart) {
+    constructor(value, targetPart) {
         this.value = value;
-        this.parent = parent;
-        this.key = key;
         this.targetPart = targetPart;
     }
 }
@@ -44,15 +41,15 @@ function isUsageRef(value) {
  * then resolves them after all merging is done.
  *
  * Tracking by array position breaks once `'...'` spreads shuffle indices,
- * so each ref becomes a sentinel object. Arrays spread-merge by pushing
- * element references, so sentinel identity survives any downstream
- * merges — the final pass walks a flat registry and writes the resolved
- * name back through each sentinel's `parent` back-reference. Orphaned
- * sentinels (from arrays dropped by a full-replace) write harmlessly.
+ * so each ref becomes a sentinel object. Merges copy sentinels by
+ * reference — one sentinel can end up in many arrays (e.g. a pattern
+ * target's dependsOn applied to every matching target) — so the final
+ * pass sweeps the merged rootMap and resolves every sentinel where it
+ * actually sits. Sentinels in arrays dropped by a full-replace are never
+ * visited and vanish with their array.
  */
 class ProjectNameInNodePropsManager {
     constructor(getNameMap) {
-        this.allRefs = new Set();
         this.pendingByName = new Map();
         this.getNameMap = getNameMap ?? (() => ({}));
     }
@@ -82,26 +79,20 @@ class ProjectNameInNodePropsManager {
     processInputs(inputs) {
         for (let i = 0; i < inputs.length; i++) {
             const entry = inputs[i];
-            // Existing sentinel: spread merges may have copied it out of its
-            // original array, so rebind parent to this one.
-            if (isNameRef(entry)) {
-                entry.parent = inputs;
+            if (isNameRef(entry))
                 continue;
-            }
             if (!entry || typeof entry !== 'object')
                 continue;
             if (!('projects' in entry))
                 continue;
             const element = entry;
             const projects = element.projects;
-            if (isNameRef(projects)) {
-                // Object-parent sentinel — element identity is stable across spread.
+            if (isNameRef(projects))
                 continue;
-            }
             if (typeof projects === 'string') {
                 if (projects === 'self' || projects === 'dependencies')
                     continue;
-                element.projects = this.createRef(projects, element, 'projects');
+                element.projects = this.createRef(projects);
             }
             else if (Array.isArray(projects)) {
                 this.processProjectsArray(projects);
@@ -111,12 +102,8 @@ class ProjectNameInNodePropsManager {
     processDependsOn(dependsOn, ownerTargets, ownerName) {
         for (let i = 0; i < dependsOn.length; i++) {
             const dep = dependsOn[i];
-            // Existing sentinel: rebind parent to this array in case a spread
-            // merge copied it out of its original.
-            if (isNameRef(dep)) {
-                dep.parent = dependsOn;
+            if (isNameRef(dep))
                 continue;
-            }
             if (typeof dep === 'string') {
                 // `^target` and same-project targets aren't cross-project refs.
                 if (dep.startsWith('^') || (ownerTargets && dep in ownerTargets)) {
@@ -126,7 +113,7 @@ class ProjectNameInNodePropsManager {
                 if (rest.length === 0)
                     continue;
                 const targetPart = rest.join(':');
-                dependsOn[i] = this.createRef(maybeProject, dependsOn, undefined, targetPart);
+                dependsOn[i] = this.createRef(maybeProject, targetPart);
                 continue;
             }
             if (!dep || typeof dep !== 'object' || !('projects' in dep))
@@ -142,7 +129,7 @@ class ProjectNameInNodePropsManager {
                     projects === 'dependencies') {
                     continue;
                 }
-                element.projects = this.createRef(projects, element, 'projects');
+                element.projects = this.createRef(projects);
             }
             else if (Array.isArray(projects)) {
                 this.processProjectsArray(projects);
@@ -152,24 +139,21 @@ class ProjectNameInNodePropsManager {
     processProjectsArray(projects) {
         for (let j = 0; j < projects.length; j++) {
             const name = projects[j];
-            if (isNameRef(name)) {
-                name.parent = projects;
+            if (isNameRef(name))
                 continue;
-            }
             if (typeof name !== 'string')
                 continue;
             if ((0, globs_1.isGlobPattern)(name))
                 continue;
-            projects[j] = this.createRef(name, projects, undefined);
+            projects[j] = this.createRef(name);
         }
     }
     // Builds a sentinel and registers it.
-    createRef(referencedName, parent, key, targetPart) {
+    createRef(referencedName, targetPart) {
         const referencedRoot = this.getNameMap()[referencedName]?.root;
         const ref = referencedRoot !== undefined
-            ? new RootRef(referencedRoot, parent, key, targetPart)
-            : new UsageRef(referencedName, parent, key, targetPart);
-        this.allRefs.add(ref);
+            ? new RootRef(referencedRoot, targetPart)
+            : new UsageRef(referencedName, targetPart);
         if (ref instanceof UsageRef) {
             let set = this.pendingByName.get(referencedName);
             if (!set) {
@@ -195,25 +179,72 @@ class ProjectNameInNodePropsManager {
             ref.value = root;
         }
     }
-    // Writes each sentinel's current resolved name back into its owning slot.
-    // Called once after all plugin results have been merged.
+    // Resolves every sentinel in the merged rootMap in place. Sweeping the
+    // final config (rather than writing through back-references held by the
+    // sentinels) covers sentinels that merges copied into arrays other than
+    // the one they were created in, e.g. a pattern target's dependsOn applied
+    // to every matching target. Called once after all plugin results have
+    // been merged.
     applySubstitutions(rootMap) {
         const nameByRoot = {};
         for (const root in rootMap) {
             nameByRoot[root] = rootMap[root]?.name;
         }
-        for (const ref of this.allRefs) {
-            const finalName = this.resolveFinalName(ref, nameByRoot);
-            if (finalName === undefined)
-                continue;
-            const replacement = ref.targetPart !== undefined
-                ? `${finalName}:${ref.targetPart}`
-                : finalName;
-            this.writeReplacement(ref, replacement);
+        for (const root in rootMap) {
+            const targets = rootMap[root]?.targets;
+            if (!targets)
+                continue;
+            for (const targetName in targets) {
+                const targetConfig = targets[targetName];
+                if (!targetConfig || typeof targetConfig !== 'object')
+                    continue;
+                if (Array.isArray(targetConfig.inputs)) {
+                    this.substituteInArray(targetConfig.inputs, nameByRoot);
+                }
+                if (Array.isArray(targetConfig.dependsOn)) {
+                    this.substituteInArray(targetConfig.dependsOn, nameByRoot);
+                }
+            }
         }
-        this.allRefs.clear();
         this.pendingByName.clear();
     }
+    substituteInArray(entries, nameByRoot) {
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            if (isNameRef(entry)) {
+                const finalName = this.resolveFinalName(entry, nameByRoot);
+                if (finalName !== undefined) {
+                    entries[i] =
+                        entry.targetPart !== undefined
+                            ? `${finalName}:${entry.targetPart}`
+                            : finalName;
+                }
+                continue;
+            }
+            if (!entry || typeof entry !== 'object' || !('projects' in entry)) {
+                continue;
+            }
+            const element = entry;
+            if (isNameRef(element.projects)) {
+                const finalName = this.resolveFinalName(element.projects, nameByRoot);
+                if (finalName !== undefined) {
+                    element.projects = finalName;
+                }
+            }
+            else if (Array.isArray(element.projects)) {
+                const projects = element.projects;
+                for (let j = 0; j < projects.length; j++) {
+                    const name = projects[j];
+                    if (!isNameRef(name))
+                        continue;
+                    const finalName = this.resolveFinalName(name, nameByRoot);
+                    if (finalName !== undefined) {
+                        projects[j] = finalName;
+                    }
+                }
+            }
+        }
+    }
     resolveFinalName(ref, nameByRoot) {
         if (ref instanceof RootRef) {
             return nameByRoot[ref.value];
@@ -221,20 +252,5 @@ class ProjectNameInNodePropsManager {
         // Unpromoted forward ref — best effort, fall back to the written name.
         return this.getNameMap()[ref.value]?.name ?? ref.value;
     }
-    writeReplacement(ref, replacement) {
-        const parent = ref.parent;
-        if (Array.isArray(parent)) {
-            // One sentinel may appear at multiple indices (e.g. `[..., ...]`
-            // pushed the same reference twice via spread), so replace all.
-            for (let i = 0; i < parent.length; i++) {
-                if (parent[i] === ref)
-                    parent[i] = replacement;
-            }
-            return;
-        }
-        if (parent && typeof parent === 'object' && ref.key !== undefined) {
-            parent[ref.key] = replacement;
-        }
-    }
 }
 exports.ProjectNameInNodePropsManager = ProjectNameInNodePropsManager;

package/dist/src/project-graph/utils/project-configuration/project-nodes-manager.d.ts

@@ -34,7 +34,7 @@ export declare class ProjectNodesManager {
      *
      * Pass a different `mergedRootMap` for the default-plugin intermediate
      * pass, then call again with `this.rootMap` after it's applied so
-     * sentinel parents rebind onto the final arrays.
+     * name refs introduced by that merge are sentinelized as well.
      */
     registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>, mergedRootMap?: Record<string, ProjectConfiguration>): void;
     /**

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

@@ -263,7 +263,7 @@ class ProjectNodesManager {
      *
      * Pass a different `mergedRootMap` for the default-plugin intermediate
      * pass, then call again with `this.rootMap` after it's applied so
-     * sentinel parents rebind onto the final arrays.
+     * name refs introduced by that merge are sentinelized as well.
      */
     registerNameRefs(pluginResultProjects, mergedRootMap = this.rootMap) {
         if (!pluginResultProjects)

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

@@ -225,12 +225,10 @@ function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfigu
             }));
         }
     }
-    // The intermediate apply may have rebuilt dependsOn / inputs arrays
-    // via spread merges, leaving sentinels inserted against the
-    // intermediate rootMap pointing at now-orphaned arrays. Re-walking
-    // the final merged targets rebinds each encountered sentinel's
-    // `parent` to the current array (see
-    // ProjectNameInNodePropsManager#processInputs / processDependsOn).
+    // The intermediate apply may have rebuilt dependsOn / inputs arrays via
+    // spread merges, introducing name-ref strings that weren't visible in any
+    // single plugin result. Re-walking the final merged targets sentinelizes
+    // them so the final substitution sweep resolves them too.
     nodesManager.registerNameRefs(intermediateDefaultRootMap);
     // Overlay default-plugin attribution onto the main source maps using
     // "only fill missing" semantics. Any key already present in

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

@@ -29,15 +29,20 @@ export interface Timespan {
     /** `parallelism: false` tasks running during the slice (each one holds every slot). */
     nonParallel: number;
 }
+/**
+ * A task and how long it ran (ms). The unit the report's task lists are built from —
+ * shared with the renderers so the producer and the formatters can't drift.
+ */
+export interface TaskDurationRow {
+    id: string;
+    duration: 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;
-    }>;
+    criticalPathTop: TaskDurationRow[];
     /** Ids of tasks that failed (slowest first), for the GitHub Actions summary's failed-tasks list. Continuous tasks and tasks without a complete window are excluded. */
     failedTasks: string[];
     /** runDuration − criticalPathDuration. */
@@ -60,6 +65,8 @@ export interface PerformanceSummary {
     cacheableCount: number;
     cacheSkipped: boolean;
     remoteCacheEnabled: boolean;
+    /** The workspace opted out of Nx Cloud (`neverConnectToCloud` / NX_NO_CLOUD) — never recommend it. */
+    cloudOptedOut: boolean;
 }
 /** Construction-time inputs for {@link PerformanceLifeCycle}. */
 export interface PerformanceLifeCycleOptions {