nx 23.1.0 → 23.1.1

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/build-project-graph.js

@@ -7,6 +7,7 @@ exports.applyProjectMetadata = applyProjectMetadata;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
+const analytics_1 = require("../analytics");
 const configuration_1 = require("../config/configuration");
 const file_hasher_1 = require("../hasher/file-hasher");
 const typescript_1 = require("../plugins/js/utils/typescript");
@@ -222,7 +223,12 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
         perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, {
             start: `${plugin.name}:createDependencies - start`,
             end: `${plugin.name}:createDependencies - end`,
-            detail: { track: true },
+            detail: {
+                track: true,
+                ...(analytics_1.customDimensions && {
+                    [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
+                }),
+            },
         });
     }));
     perf_hooks_1.performance.mark('createDependencies:end');

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/loaded-nx-plugin.js

@@ -63,6 +63,7 @@ class LoadedNxPlugin {
                             track: true,
                             ...(analytics_1.customDimensions && {
                                 [analytics_1.customDimensions.projectCount]: projectCount,
+                                [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
                             }),
                         },
                     });

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/project-graph.js

@@ -244,6 +244,7 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
                     track: true,
                     ...(analytics_1.customDimensions && {
                         [analytics_1.customDimensions.projectCount]: Object.keys(currentProjectGraph.nodes).length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
                     }),
                 },
             });
@@ -310,6 +311,7 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
                     ...(analytics_1.customDimensions && {
                         [analytics_1.customDimensions.projectCount]: Object.keys(res.projectGraph.nodes)
                             .length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
                     }),
                 },
             });
@@ -333,6 +335,7 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
                     track: true,
                     ...(analytics_1.customDimensions && {
                         [analytics_1.customDimensions.projectCount]: Object.keys(projectGraphAndSourceMaps.projectGraph.nodes).length,
+                        [analytics_1.customDimensions.sampleRate]: analytics_1.PERF_SPAN_SAMPLE_RATE,
                     }),
                 },
             });

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,16 +24,17 @@ 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;
+    private nameHistory;
     constructor(getNameMap?: () => Record<string, ProjectConfiguration>);
     registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
     private processInputs;
@@ -45,6 +43,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,16 +41,19 @@ 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();
+        // name → root for every name a project has ever been identified by, so refs
+        // to a since-renamed name still bind to the right root (see createRef).
+        this.nameHistory = new Map();
         this.getNameMap = getNameMap ?? (() => ({}));
     }
     // Replaces each project-name ref in `inputs`/`dependsOn` with a sentinel.
@@ -82,26 +82,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 +105,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 +116,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 +132,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 +142,26 @@ 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) {
-        const referencedRoot = this.getNameMap()[referencedName]?.root;
+    // Builds a sentinel and registers it. When `referencedName` isn't in the
+    // current name map, fall back to the rename history: a batch may reference a
+    // project by a name that a project earlier in the same batch already renamed
+    // (refs register after the whole batch merges), and the old name still
+    // identifies the same root.
+    createRef(referencedName, targetPart) {
+        const referencedRoot = this.getNameMap()[referencedName]?.root ??
+            this.nameHistory.get(referencedName);
         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) {
@@ -184,6 +176,11 @@ class ProjectNameInNodePropsManager {
     // RootRef by prototype swap. Sentinel identity across spread copies means
     // one promotion updates every array the sentinel reached.
     identifyProjectWithRoot(root, name) {
+        // Every name a root has ever gone by, including pre-rename names. A later
+        // ref to a stale name resolves to the root it identified at the time.
+        // (If two roots use the same name over a graph construction, the later
+        // one wins — matching how the live name map would have resolved it.)
+        this.nameHistory.set(name, root);
         const pending = this.pendingByName.get(name);
         if (!pending)
             return;
@@ -195,24 +192,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();
+        this.nameHistory.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) {
@@ -221,20 +266,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

@@ -28,15 +28,12 @@ export declare class ProjectNodesManager {
     mergeProjectNode(project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation): void;
     /**
      * Inserts project-name sentinels into `inputs` and `dependsOn` on the
-     * merged objects from `mergedRootMap` (defaulting to this manager's
-     * rootMap). Walking the merged entries matters because a spread-produced
-     * array is a fresh instance.
-     *
-     * 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.
+     * merged objects in this manager's rootMap. Walking the merged entries —
+     * not the plugin results — matters because a spread-produced array is a
+     * fresh instance, and because sentinels written into plugin-result arrays
+     * would corrupt them for any later merge that re-reads the results.
      */
-    registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>, mergedRootMap?: Record<string, ProjectConfiguration>): void;
+    registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
     /**
      * Applies all pending name substitutions. Call once after all plugin
      * results have been merged.

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

@@ -129,10 +129,10 @@ deferSpreadsWithoutBase = true) {
             // if augmenting an existing target.
             const target = project.targets?.[targetName];
             if (sourceMap) {
-                // A target default stamping fields onto an existing target must not
-                // steal provenance for the target's existence; real plugins still win
-                // last. Field-level attribution is handled inside
-                // `mergeTargetConfigurations`.
+                // Claims the node key for a newly-created target (or reclaims it from
+                // a weak target-defaults stamp). Whether an *existing* target changes
+                // owners is decided inside `mergeTargetConfigurations`, which knows
+                // whether this merge changed the target's identity.
                 (0, source_maps_1.recordTargetIdentitySourceMapInfo)(sourceMap, (0, source_maps_1.targetSourceMapKey)(targetName), sourceInformation);
             }
             const normalizedTarget = skipTargetNormalization
@@ -257,21 +257,18 @@ class ProjectNodesManager {
     }
     /**
      * Inserts project-name sentinels into `inputs` and `dependsOn` on the
-     * merged objects from `mergedRootMap` (defaulting to this manager's
-     * rootMap). Walking the merged entries matters because a spread-produced
-     * array is a fresh instance.
-     *
-     * 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.
+     * merged objects in this manager's rootMap. Walking the merged entries —
+     * not the plugin results — matters because a spread-produced array is a
+     * fresh instance, and because sentinels written into plugin-result arrays
+     * would corrupt them for any later merge that re-reads the results.
      */
-    registerNameRefs(pluginResultProjects, mergedRootMap = this.rootMap) {
+    registerNameRefs(pluginResultProjects) {
         if (!pluginResultProjects)
             return;
         const scoped = {};
         for (const root in pluginResultProjects) {
-            if (mergedRootMap[root]) {
-                scoped[root] = mergedRootMap[root];
+            if (this.rootMap[root]) {
+                scoped[root] = this.rootMap[root];
             }
         }
         this.nameSubstitutionManager.registerNameRefs(scoped);

package/dist/src/project-graph/utils/project-configuration/source-maps.d.ts

@@ -9,12 +9,19 @@ export type SourceInformation = [file: string | null, plugin: string];
  */
 export declare const TARGET_DEFAULTS_PLUGIN_NAME = "nx/target-defaults";
 /**
- * Write the source for a target's "identity" key (the target node itself, or
- * its executor/command). Real plugins win last; a target-defaults stamp only
- * claims the key when no real plugin already recorded it — target defaults
- * never bring a target into existence, they only layer fields onto one.
+ * Write the source for the target node key (`targets.<name>`). Ownership of a
+ * target follows its identity, not the last writer:
+ *
+ *  - An unowned key goes to whoever writes it first (the creator).
+ *  - A target-defaults stamp is weak — it never authors a target's existence,
+ *    so any real plugin reclaims the key from it, and it can never take the
+ *    key from a real plugin.
+ *  - Between real plugins, the key only changes hands when the merge changed
+ *    the target's identity (executor/command) — a plugin that merely layers
+ *    fields (dependsOn, options, …) onto an existing target does not become
+ *    its owner.
  */
-export declare function recordTargetIdentitySourceMapInfo(sourceMap: Record<string, SourceInformation>, key: string, sourceInfo: SourceInformation): void;
+export declare function recordTargetIdentitySourceMapInfo(sourceMap: Record<string, SourceInformation>, key: string, sourceInfo: SourceInformation, identityChanged?: boolean): void;
 /** Source map per project root. */
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
 export declare function forEachSourceMapKeyForArray(prefixKey: string, array: unknown[], callback: (key: string, index: number) => void, startIndex?: number): void;