nx 23.1.0 → 23.1.2

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

@@ -7,6 +7,7 @@ node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading --
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const logger_1 = require("../../../utils/logger");
 const serializable_error_1 = require("../../../utils/serializable-error");
+const daemon_message_1 = require("../../../daemon/message-types/daemon-message");
 const messaging_1 = require("./messaging");
 const worker_streaming_1 = require("./worker-streaming");
 const fs_1 = require("fs");
@@ -23,6 +24,19 @@ global.NX_PLUGIN_WORKER = true;
 let plugin;
 const socketPath = process.argv[2];
 const expectedPluginName = process.argv[3];
+// The host's root, passed explicitly rather than re-resolved: a host that set
+// its root at runtime would resolve a different one here and drop every
+// legitimate message as foreign.
+const hostWorkspaceRoot = process.argv[4];
+// Positional, so inserting an argument host-side shifts all of them — and the
+// symptom is silent and total: an undefined hostWorkspaceRoot makes every
+// message look foreign while the host waits out its plugin timeout.
+if (!socketPath || !expectedPluginName || !hostWorkspaceRoot) {
+    console.error(`[plugin-worker] started with an incomplete argument list ` +
+        `(socketPath=${socketPath}, pluginName=${expectedPluginName}, hostWorkspaceRoot=${hostWorkspaceRoot}). ` +
+        `This is an Nx bug — please report it at https://github.com/nrwl/nx/issues.`);
+    process.exit(1);
+}
 const CONNECT_TIMEOUT_MS = 30_000;
 let connectErrorTimeout = setErrorTimeout(CONNECT_TIMEOUT_MS, `The plugin worker for ${expectedPluginName} is exiting as it was not connected to within ${CONNECT_TIMEOUT_MS / 1000} seconds. ` +
     'Plugin workers expect to receive a socket connection from the parent process shortly after being started. ' +
@@ -45,6 +59,16 @@ const server = (0, net_1.createServer)((socket) => {
         if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
             return;
         }
+        // Same check the daemon applies to its own socket. Dropped rather than thrown:
+        // a stray foreign message must not kill a worker serving its host. The daemon
+        // has a response channel and surfaces it to the client instead.
+        try {
+            (0, daemon_message_1.assertNotForeignWorkspaceMessage)(message, hostWorkspaceRoot, `The Nx plugin worker "${expectedPluginName}" (pid: ${process.pid})`);
+        }
+        catch (e) {
+            logger_1.logger.verbose(`[plugin-worker] ignored a "${message.type}" message: ${e instanceof Error ? e.message : e}`);
+            return;
+        }
         return (0, messaging_1.consumeMessage)(socket, message, {
             load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
                 loadErrorTimeout?.clear();
@@ -104,8 +128,24 @@ const server = (0, net_1.createServer)((socket) => {
         process.exit(0);
     });
 });
-server.listen(socketPath);
-logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) listening on ${socketPath}`);
+server.on('error', (err) => {
+    // Without this the host only sees "exited before the connection was
+    // established"; the errno distinguishes a denied bind from EADDRINUSE.
+    console.error(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) failed to listen on ${socketPath}: ${err.message}`);
+    process.exit(1);
+});
+// A worker killed without its 'end' handler leaves the socket behind. Colliding
+// takes a recycled host pid landing on the same counter *and* the same 4 random
+// bytes; the random component is what this unlink rests on, and on Windows it is
+// the only barrier, since the endpoint is a namespace object and the mode never
+// applies. A failed bind surfaces through the error handler above.
+try {
+    (0, fs_1.unlinkSync)(socketPath);
+}
+catch { }
+server.listen(socketPath, () => {
+    logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) listening on ${socketPath}`);
+});
 async function withErrorHandling(cb) {
     try {
         const result = await cb();
@@ -136,15 +176,25 @@ function setErrorTimeout(timeoutMs, errorMessage) {
         },
     };
 }
-const exitHandler = (exitCode) => () => {
+const cleanup = () => {
     server.close();
     try {
         (0, fs_1.unlinkSync)(socketPath);
     }
     catch (e) { }
-    process.exit(exitCode);
 };
-const events = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'exit'];
-events.forEach((event) => process.once(event, exitHandler(0)));
-process.once('uncaughtException', exitHandler(1));
-process.once('unhandledRejection', exitHandler(1));
+const events = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
+events.forEach((event) => process.once(event, () => {
+    cleanup();
+    process.exit(0);
+}));
+// Cleanup only: process.exit() here would override the real exit code.
+process.once('exit', cleanup);
+const fatalHandler = (error) => {
+    // Registering this handler suppresses Node's default reporting.
+    console.error(error);
+    cleanup();
+    process.exit(1);
+};
+process.once('uncaughtException', fatalHandler);
+process.once('unhandledRejection', fatalHandler);

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,
                     }),
                 },
             });
@@ -351,6 +354,26 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
                 (0, tmp_dir_1.markDaemonAsDisabled)(e.message);
                 return buildProjectGraphAndSourceMapsWithoutDaemon();
             }
+            if (e.daemonPermissionError) {
+                // Deliberately not disabled: unlike the inotify limit above, a socket
+                // owned by someone else stops being there when it is removed or the
+                // machine reboots, and disabling until `nx reset` would outlive the
+                // cause and hide the fix from anyone who followed the advice.
+                // The first line carries the errno, and it is the one token that tells
+                // the two causes apart: EACCES is a socket owned by someone else (delete
+                // it), EPERM is a sandbox refusing the connect syscall (allow unix
+                // sockets under the Nx socket root). The message hedges between exactly
+                // those two because it cannot tell them apart, and this branch does not
+                // call writeDaemonLogs, so dropping the line loses the errno for good.
+                const [summary, ...details] = e.message.split('\n');
+                output_1.output.note({
+                    title: `${summary} Continuing without the daemon.`,
+                    // The blank line after the summary separates paragraphs when the
+                    // message is printed as one blob; as bodyLines it is a leading gap.
+                    bodyLines: details[0] === '' ? details.slice(1) : details,
+                });
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
             if (e.internalDaemonError) {
                 const errorLogFile = (0, tmp_dir_1.writeDaemonLogs)(e.message);
                 output_1.output.warn({

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

@@ -7,6 +7,8 @@ exports.createRootMap = createRootMap;
 const error_types_1 = require("../../error-types");
 const target_merging_1 = require("./target-merging");
 const target_normalization_1 = require("./target-normalization");
+const git_worktrees_1 = require("../../../utils/git-worktrees");
+const workspace_root_1 = require("../../../utils/workspace-root");
 const name_substitution_manager_1 = require("./name-substitution-manager");
 const source_maps_1 = require("./source-maps");
 const minimatch_1 = require("minimatch");
@@ -129,10 +131,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
@@ -194,7 +196,9 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
         }
     }
     if (conflicts.size > 0) {
-        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
+        // Only on the way to throwing, so a workspace without duplicates never
+        // pays for reading git's worktree registry.
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects, (0, git_worktrees_1.analyzeWorktreeConflicts)(workspace_root_1.workspaceRoot, conflicts) ?? undefined);
     }
     if (projectRootsWithNoName.length > 0) {
         throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
@@ -257,21 +261,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;

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

@@ -21,14 +21,28 @@ exports.targetConfigurationsSourceMapKey = targetConfigurationsSourceMapKey;
  */
 exports.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.
  */
-function recordTargetIdentitySourceMapInfo(sourceMap, key, sourceInfo) {
-    if (sourceInfo[1] !== exports.TARGET_DEFAULTS_PLUGIN_NAME ||
-        sourceMap[key] === undefined) {
+function recordTargetIdentitySourceMapInfo(sourceMap, key, sourceInfo, identityChanged = false) {
+    const existing = sourceMap[key];
+    if (existing === undefined) {
+        sourceMap[key] = sourceInfo;
+        return;
+    }
+    if (sourceInfo[1] === exports.TARGET_DEFAULTS_PLUGIN_NAME) {
+        return;
+    }
+    if (existing[1] === exports.TARGET_DEFAULTS_PLUGIN_NAME || identityChanged) {
         sourceMap[key] = sourceInfo;
     }
 }

package/dist/src/project-graph/utils/project-configuration/target-defaults.d.ts

@@ -19,7 +19,7 @@ type CreateNodesResultEntry = readonly [
  * fly. That's all the matcher needs; the full target merge happens
  * downstream in the real merge.
  */
-export declare function createTargetDefaultsResults(specifiedPluginRootMap: Record<string, ProjectConfiguration>, defaultPluginRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration, specifiedSourceMaps?: ConfigurationSourceMaps, defaultSourceMaps?: ConfigurationSourceMaps): CreateNodesResultEntry[];
+export declare function createTargetDefaultsResults(specifiedPluginRootMap: Record<string, ProjectConfiguration>, defaultPluginRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration, specifiedSourceMaps?: ConfigurationSourceMaps): CreateNodesResultEntry[];
 /**
  * Public reader that resolves the target defaults applying to a given
  * target. Accepts the nested map shape (a value is either a plain config