fix(core): resolve name refs copied into pattern-matched target arrays (#36359)

## Current Behavior

Name-ref sentinels (used to keep `dependsOn`/`inputs` project references
correct across renames) are written back through a pointer to the array
they were created in. Merges copy sentinels **by reference** into fresh
arrays — most visibly when a project.json pattern target (e.g.
`e2e-ci--**/**`) with a `"..."` spread is applied to every matching
atomized target. The copies never get resolved, leaving raw internal
objects (`RootRef { value, parent, targetPart }`) in the final project
configuration, and task graph creation crashes with:

```
NX   pattern is not iterable
```

## Expected Behavior

Every name ref resolves to its project name wherever it ends up.
`applySubstitutions` now sweeps the merged rootMap and resolves each
sentinel in place, covering arrays a sentinel was copied into. Since
write-back no longer depends on back-references, the `parent`/`key`
fields, the `allRefs` registry, and the parent-rebinding branches are
removed.

The new integration test reproduces the exact corruption on the previous
implementation (raw `RootRef` objects in the atomized targets'
`dependsOn`) and passes with the sweep.

## Related Issue(s)

Found while using `"..."` in the `dependsOn` of atomized e2e pattern
targets in this repo (see `e2e/gradle/project.json` /
`e2e/maven/project.json`); that cleanup was reverted from #36302 and can
be re-applied once this fix ships.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01Qjm3xvLS2vLRsaxt4vv56d

<!-- polygraph-session-start -->
---
[View session information
↗](https://app.trypolygraph.com/orgs/6a061dcb561c062131116eca/sessions/PR-for-pnpm-11-ERR_PNPM_IGNORED_BUILDS-fix-f71af2eb)
<!-- polygraph-session-end -->

---------

Co-authored-by: Craigory Coppola <craigorycoppola@gmail.com>
(cherry picked from commit 4a05b10)

Author: FrozenPandaz

packages/nx/src/project-graph/utils/project-configuration-utils.spec.ts

@@ -172,8 +172,8 @@ describe('project-configuration-utils', () => {
     });
 
     // Mirror of the dependsOn P2 regression for the inputs path:
-    // processInputs and processDependsOn share writeReplacement /
-    // createRef plumbing, but the top-level walk is separate. Locks in
+    // processInputs and processDependsOn share the createRef plumbing,
+    // but the substitution sweep walks each array separately. Locks in
     // that default-plugin inputs references get sentinel treatment too.
     it('should resolve inputs refs owned by default plugins when the referenced project is renamed during the default apply', () => {
       const specifiedResults: CreateNodesResultEntry[][] = [
@@ -608,6 +608,113 @@ describe('project-configuration-utils', () => {
       expect(buildTarget.inputs).toEqual(['explicit', 'from-defaults']);
     });
 
+    it('should resolve name refs in every pattern-matched target when a project.json pattern target spreads targetDefaults', () => {
+      // Regression: the spread copies the targetDefaults dependsOn entries
+      // (already sentinelized as name refs) by reference into a fresh array
+      // for every target matching the pattern. Write-back through each
+      // sentinel's original array left raw sentinel objects in the copies,
+      // which later crashed task graph creation ("pattern is not iterable").
+      const specifiedResults = [
+        [
+          [
+            'fake-atomizer-plugin',
+            'e2e/maven/jest.config.ts',
+            {
+              projects: {
+                'e2e/maven': {
+                  name: 'e2e-maven',
+                  targets: {
+                    'e2e-ci--src/a.test.ts': { command: 'echo a' },
+                    'e2e-ci--src/b.test.ts': { command: 'echo b' },
+                  },
+                },
+              },
+            },
+          ],
+        ],
+      ] as const;
+
+      const defaultResults = [
+        [
+          [
+            'nx/core/project-json',
+            'project.json',
+            {
+              projects: {
+                '.': {
+                  name: '@nx/nx-source',
+                  root: '.',
+                  targets: {
+                    'populate-storage': { command: 'echo populate' },
+                    'local-registry': { command: 'echo registry' },
+                  },
+                },
+              },
+            },
+          ],
+          [
+            'nx/core/project-json',
+            'e2e/maven/project.json',
+            {
+              projects: {
+                'e2e/maven': {
+                  name: 'e2e-maven',
+                  root: 'e2e/maven',
+                  targets: {
+                    'e2e-ci--**/**': {
+                      dependsOn: ['...', 'maven-plugin:install'],
+                    },
+                  },
+                },
+              },
+            },
+          ],
+          [
+            'nx/core/project-json',
+            'libs/maven-plugin/project.json',
+            {
+              projects: {
+                'libs/maven-plugin': {
+                  name: 'maven-plugin',
+                  root: 'libs/maven-plugin',
+                  targets: {
+                    install: { command: 'echo install' },
+                  },
+                },
+              },
+            },
+          ],
+        ],
+      ] as const;
+
+      const errors = [];
+      const result = mergeCreateNodesResults(
+        specifiedResults as any,
+        defaultResults as any,
+        {
+          targetDefaults: {
+            'e2e-ci--**/**': {
+              dependsOn: [
+                '@nx/nx-source:populate-storage',
+                '@nx/nx-source:local-registry',
+              ],
+            },
+          },
+        },
+        '/tmp/test',
+        errors
+      );
+
+      const targets = result.projectRootMap['e2e/maven'].targets!;
+      const expected = [
+        '@nx/nx-source:populate-storage',
+        '@nx/nx-source:local-registry',
+        'maven-plugin:install',
+      ];
+      expect(targets['e2e-ci--src/a.test.ts'].dependsOn).toEqual(expected);
+      expect(targets['e2e-ci--src/b.test.ts'].dependsOn).toEqual(expected);
+    });
+
     it('should resolve spread tokens from package.json script target augmentation against target defaults', () => {
       // https://github.com/nrwl/nx/issues/36235 — `nx.targets.build` augments
       // the script-derived target inside the package.json reader. The `'...'`

packages/nx/src/project-graph/utils/project-configuration-utils.ts

@@ -432,12 +432,10 @@ export function mergeCreateNodesResults(
     }
   }
 
-  // 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

packages/nx/src/project-graph/utils/project-configuration/name-substitution-manager.spec.ts

@@ -2187,5 +2187,51 @@ describe('ProjectNameInNodePropsManager', () => {
       expect(typeof mergedDependsOn[0]).toBe('string');
       expect(typeof mergedDependsOn[1]).toBe('string');
     });
+
+    // Regression: applying a pattern target (e.g. `e2e-ci--**/**`) copies
+    // its dependsOn entries by reference into a fresh array on every
+    // matching target, and those arrays are never re-registered. Write-back
+    // through the sentinel's original array left the copies holding raw
+    // sentinel objects, which later crashed task graph creation
+    // ("pattern is not iterable").
+    it('should resolve sentinels copied into arrays that are never re-registered', () => {
+      const manager = createManager();
+
+      const projectA = createProject('project-a', 'libs/a', {
+        targets: {
+          'e2e-ci--**/**': {
+            dependsOn: ['project-b:build'],
+          },
+        },
+      });
+      const projectB = createProject('project-b', 'libs/b');
+      const baseResult = createPluginResult([projectA, projectB]);
+      identifyProjects(manager, baseResult);
+      manager.registerNameRefs(baseResult);
+
+      // Simulate pattern-target application: the matching atomized target
+      // gets a fresh dependsOn array holding the same sentinel reference.
+      // Nothing re-registers this array.
+      const templateDependsOn = projectA.targets['e2e-ci--**/**']
+        .dependsOn as unknown[];
+      const atomizedDependsOn: unknown[] = [templateDependsOn[0]];
+      projectA.targets['e2e-ci--src/a.test.ts'] = {
+        dependsOn: atomizedDependsOn,
+      };
+
+      const rootMap = createRootMap([
+        {
+          name: 'project-a',
+          root: 'libs/a',
+          targets: projectA.targets,
+        },
+        { name: 'project-b', root: 'libs/b' },
+      ]);
+
+      manager.applySubstitutions(rootMap);
+
+      expect(atomizedDependsOn[0]).toBe('project-b:build');
+      expect(templateDependsOn[0]).toBe('project-b:build');
+    });
   });
 });