nx 22.7.0 → 23.0.0-beta.0

package/dist/src/config/workspace-json-project-json.d.ts

@@ -260,4 +260,14 @@ export interface TargetConfiguration<T = any> {
      * is up to date.
      */
     syncGenerators?: string[];
+    /**
+     * Spread token used when merging target configurations. When set to `true`,
+     * base (inferred) values take priority over this target's values for any
+     * shared keys — effectively "only add new keys without overwriting inferred
+     * values". Keys that do not exist in the base target are still added.
+     *
+     * The position of `'...'` in the object's key order follows standard
+     * last-write-wins semantics with {@link https://nx.dev/reference/project-configuration#spread-token}.
+     */
+    '...'?: true;
 }

package/dist/src/daemon/server/handle-hash-tasks.js

@@ -11,7 +11,7 @@ const configuration_1 = require("../../config/configuration");
 let storedProjectGraph = null;
 let storedHasher = null;
 async function handleHashTasks(payload) {
-    const { error, projectGraph, allWorkspaceFiles, fileMap, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const { error, projectGraph, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
     if (error) {
         throw error;
     }

package/dist/src/daemon/server/project-graph-incremental-recomputation.d.ts

@@ -1,5 +1,5 @@
 import { Socket } from 'net';
-import { FileData, FileMap, ProjectGraph } from '../../config/project-graph';
+import { FileMap, ProjectGraph } from '../../config/project-graph';
 import { NxWorkspaceFilesExternals } from '../../native';
 import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
@@ -7,8 +7,6 @@ interface SerializedProjectGraph {
     error: Error | null;
     projectGraph: ProjectGraph | null;
     projectFileMapCache: FileMapCache | null;
-    fileMap: FileMap | null;
-    allWorkspaceFiles: FileData[] | null;
     serializedProjectGraph: string | null;
     serializedSourceMaps: string | null;
     sourceMaps: ConfigurationSourceMaps | null;
@@ -16,7 +14,6 @@ interface SerializedProjectGraph {
 }
 export declare let fileMapWithFiles: {
     fileMap: FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals;
 } | undefined;
 export declare let currentProjectFileMapCache: FileMapCache | undefined;

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -54,12 +54,12 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         // reset the wait time
         waitPeriod = 100;
         await resetInternalStateIfNxDepsMissing();
-        const plugins = await (0, get_plugins_1.getPlugins)();
+        const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)();
         const previousPromise = cachedSerializedProjectGraphPromise;
         if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
             if (!cachedSerializedProjectGraphPromise) {
                 cachedSerializedProjectGraphPromise =
-                    processFilesAndCreateAndSerializeProjectGraph(plugins);
+                    processFilesAndCreateAndSerializeProjectGraph(separatedPlugins);
                 logger_1.serverLogger.log('No files changed, but no in-memory cached project graph found. Recomputing it...');
             }
             else {
@@ -69,7 +69,7 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         else {
             logger_1.serverLogger.log(`Recomputing project graph because of ${collectedUpdatedFiles.size} updated and ${collectedDeletedFiles.size} deleted files.`);
             cachedSerializedProjectGraphPromise =
-                processFilesAndCreateAndSerializeProjectGraph(plugins);
+                processFilesAndCreateAndSerializeProjectGraph(separatedPlugins);
         }
         const graphWasRecomputed = cachedSerializedProjectGraphPromise !== previousPromise;
         const result = await cachedSerializedProjectGraphPromise;
@@ -113,8 +113,6 @@ async function getCachedSerializedProjectGraphPromise(socket) {
             sourceMaps: null,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
-            allWorkspaceFiles: null,
             rustReferences: null,
         };
     }
@@ -153,7 +151,7 @@ function addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles) {
                 waitPeriod = waitPeriod * 2;
             }
             cachedSerializedProjectGraphPromise =
-                processFilesAndCreateAndSerializeProjectGraph(await (0, get_plugins_1.getPlugins)());
+                processFilesAndCreateAndSerializeProjectGraph(await (0, get_plugins_1.getPluginsSeparated)());
             const { projectGraph, sourceMaps, error } = await cachedSerializedProjectGraphPromise;
             if (createdFiles.length > 0) {
                 (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, null, null);
@@ -210,7 +208,11 @@ function invalidateGraphCache() {
     // at its own Promise), takes the "reuse" branch, and awaits itself forever.
     cachedSerializedProjectGraphPromise = null;
 }
-async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
+async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
+    const plugins = [
+        ...separatedPlugins.specifiedPlugins,
+        ...separatedPlugins.defaultPlugins,
+    ];
     const myGeneration = ++recomputationGeneration;
     // Helper to check if this recomputation is stale (a newer one has started)
     const isStale = () => myGeneration !== recomputationGeneration;
@@ -231,7 +233,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
         let projectConfigurationsResult;
         let projectConfigurationsError;
         try {
-            projectConfigurationsResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
+            projectConfigurationsResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, workspace_root_1.workspaceRoot, nxJson);
         }
         catch (e) {
             if (e instanceof error_types_1.ProjectConfigurationsError) {
@@ -277,9 +279,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
                     error: g.error,
                     projectGraph: null,
                     projectFileMapCache: null,
-                    fileMap: null,
                     rustReferences: null,
-                    allWorkspaceFiles: null,
                     serializedProjectGraph: null,
                     serializedSourceMaps: null,
                     sourceMaps: null,
@@ -291,9 +291,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
                 error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps),
                 projectGraph: null,
                 projectFileMapCache: null,
-                fileMap: null,
                 rustReferences: null,
-                allWorkspaceFiles: null,
                 serializedProjectGraph: null,
                 serializedSourceMaps: null,
                 sourceMaps: null,
@@ -308,9 +306,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
             error: err,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
             rustReferences: null,
-            allWorkspaceFiles: null,
             serializedProjectGraph: null,
             serializedSourceMaps: null,
             sourceMaps: null,
@@ -334,9 +330,8 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
     try {
         perf_hooks_1.performance.mark('create-project-graph-start');
         const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
-        const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
         const rustReferences = exports.fileMapWithFiles.rustReferences;
-        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)(), sourceMaps);
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)(), sourceMaps);
         exports.currentProjectFileMapCache = projectFileMapCache;
         exports.currentProjectGraph = projectGraph;
         exports.currentSourceMaps = sourceMaps;
@@ -351,8 +346,6 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
             error: null,
             projectGraph,
             projectFileMapCache,
-            fileMap,
-            allWorkspaceFiles,
             serializedProjectGraph,
             serializedSourceMaps,
             sourceMaps,
@@ -365,8 +358,6 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
             error: e,
             projectGraph: null,
             projectFileMapCache: null,
-            fileMap: null,
-            allWorkspaceFiles: null,
             serializedProjectGraph: null,
             serializedSourceMaps: null,
             sourceMaps: null,

package/dist/src/executors/utils/convert-nx-executor.js

@@ -17,10 +17,10 @@ function convertNxExecutor(executor) {
     const builderFunction = (options, builderContext) => {
         const promise = async () => {
             const nxJsonConfiguration = (0, nx_json_1.readNxJson)(builderContext.workspaceRoot);
-            const plugins = await (0, get_plugins_1.getPlugins)();
+            const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)();
             const projectsConfigurations = {
                 version: 2,
-                projects: (0, project_nodes_manager_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
+                projects: (0, project_nodes_manager_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
             };
             const context = {
                 root: builderContext.workspaceRoot,

package/dist/src/hasher/create-task-hasher.js

@@ -9,7 +9,7 @@ function createTaskHasher(projectGraph, nxJson, runnerOptions) {
         return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
     }
     else {
-        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        const { rustReferences } = (0, build_project_graph_1.getFileMap)();
         return new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
 }

package/dist/src/project-graph/build-project-graph.d.ts

@@ -2,18 +2,16 @@ import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/proje
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 import { CreateMetadataError } from './error-types';
-import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { CreateMetadataContext } from './plugins';
 import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
 import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
 export declare function getFileMap(): {
     fileMap: FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
-export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
+export declare function hydrateFileMap(fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals): void;
+export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;

package/dist/src/project-graph/build-project-graph.js

@@ -23,13 +23,11 @@ const implicit_project_dependencies_1 = require("./utils/implicit-project-depend
 const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
 const target_merging_1 = require("./utils/project-configuration/target-merging");
 let storedFileMap = null;
-let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
 function getFileMap() {
     if (!!storedFileMap) {
         return {
             fileMap: storedFileMap,
-            allWorkspaceFiles: storedAllWorkspaceFiles,
             rustReferences: storedRustReferences,
         };
     }
@@ -39,19 +37,16 @@ function getFileMap() {
                 nonProjectFiles: [],
                 projectFileMap: {},
             },
-            allWorkspaceFiles: [],
             rustReferences: null,
         };
     }
 }
-function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+function hydrateFileMap(fileMap, rustReferences) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
 }
-async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;
-    storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
     const projects = {};
     for (const root in projectRootMap) {

package/dist/src/project-graph/file-map-utils.d.ts

@@ -1,8 +1,7 @@
-import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
-import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import type { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
 export interface WorkspaceFileMap {
-    allWorkspaceFiles: FileData[];
     fileMap: FileMap;
 }
 export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
@@ -10,6 +9,5 @@ export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Pro
 export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
 export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
     fileMap: import("../native").FileMap;
-    allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals;
 };

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

@@ -7,7 +7,6 @@ exports.updateFileMap = updateFileMap;
 const workspace_context_1 = require("../utils/workspace-context");
 const workspace_root_1 = require("../utils/workspace-root");
 const project_graph_1 = require("./project-graph");
-const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
 const find_project_for_path_1 = require("./utils/find-project-for-path");
 async function createProjectFileMapUsingProjectGraph(graph) {
     return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
@@ -38,7 +37,6 @@ function createFileMap(projectsConfigurations, allWorkspaceFiles) {
         }
     }
     return {
-        allWorkspaceFiles,
         fileMap: {
             projectFileMap,
             nonProjectFiles,
@@ -49,7 +47,6 @@ function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, del
     const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
     return {
         fileMap: updates.fileMap,
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
         rustReferences: updates.externalReferences,
     };
 }

package/dist/src/project-graph/plugins/get-plugins.d.ts

@@ -1,5 +1,20 @@
 import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export interface SeparatedPlugins {
+    specifiedPlugins: LoadedNxPlugin[];
+    defaultPlugins: LoadedNxPlugin[];
+}
+/**
+ * Returns all plugins (specified + default) as a flat list.
+ * Specified plugins come first, followed by default plugins.
+ */
 export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+/**
+ * Returns specified plugins (from nx.json) and default plugins (project.json,
+ * package.json, etc.) as separate arrays. This separation is needed for
+ * two-phase project configuration processing where target defaults are
+ * applied between specified and default plugin results.
+ */
+export declare function getPluginsSeparated(root?: string): Promise<SeparatedPlugins>;
 export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
 export declare function cleanupPlugins(): void;
 export declare function reasonToError(reason: unknown): Error;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPlugins = getPlugins;
+exports.getPluginsSeparated = getPluginsSeparated;
 exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
 exports.cleanupPlugins = cleanupPlugins;
 exports.reasonToError = reasonToError;
@@ -18,18 +19,33 @@ const transpiler_1 = require("./transpiler");
  */
 let currentPluginsConfigurationHash;
 let loadedPlugins;
+let cachedSeparatedPlugins;
 let pendingPluginsPromise;
 let cleanupSpecifiedPlugins;
 const loadingMethod = (plugin, root, index) => (0, enabled_1.isIsolationEnabled)()
     ? (0, isolation_1.loadIsolatedNxPlugin)(plugin, root, index)
     : (0, in_process_loader_1.loadNxPlugin)(plugin, root, index);
+/**
+ * Returns all plugins (specified + default) as a flat list.
+ * Specified plugins come first, followed by default plugins.
+ */
 async function getPlugins(root = workspace_root_1.workspaceRoot) {
+    const { specifiedPlugins, defaultPlugins } = await getPluginsSeparated(root);
+    return specifiedPlugins.concat(defaultPlugins);
+}
+/**
+ * Returns specified plugins (from nx.json) and default plugins (project.json,
+ * package.json, etc.) as separate arrays. This separation is needed for
+ * two-phase project configuration processing where target defaults are
+ * applied between specified and default plugin results.
+ */
+async function getPluginsSeparated(root = workspace_root_1.workspaceRoot) {
     const pluginsConfiguration = (0, nx_json_1.readNxJson)(root).plugins ?? [];
     const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
     // If the plugins configuration has not changed, reuse the current plugins
-    if (loadedPlugins &&
+    if (cachedSeparatedPlugins &&
         pluginsConfigurationHash === currentPluginsConfigurationHash) {
-        return loadedPlugins;
+        return cachedSeparatedPlugins;
     }
     currentPluginsConfigurationHash = pluginsConfigurationHash;
     const results = await Promise.allSettled([
@@ -51,8 +67,9 @@ async function getPlugins(root = workspace_root_1.workspaceRoot) {
     if (errors.length > 0) {
         throw new AggregateError(errors, errors.map((e) => e.message).join('\n'));
     }
+    cachedSeparatedPlugins = { specifiedPlugins, defaultPlugins };
     loadedPlugins = specifiedPlugins.concat(defaultPlugins);
-    return loadedPlugins;
+    return cachedSeparatedPlugins;
 }
 /**
  * Stuff for default NX Plugins.
@@ -87,6 +104,7 @@ function cleanupPlugins() {
     cleanupDefaultPlugins?.();
     pendingPluginsPromise = undefined;
     pendingDefaultPluginPromise = undefined;
+    cachedSeparatedPlugins = undefined;
 }
 /**
  * Stuff for generic loading

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

@@ -88,9 +88,10 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
-    const plugins = await (0, get_plugins_1.getPlugins)();
+    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)();
+    const plugins = separatedPlugins.specifiedPlugins.concat(separatedPlugins.defaultPlugins);
     try {
-        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(separatedPlugins, workspace_root_1.workspaceRoot, nxJson);
     }
     catch (e) {
         if (e instanceof error_types_1.ProjectConfigurationsError) {
@@ -104,14 +105,14 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
     perf_hooks_1.performance.mark('retrieve-project-configurations:end');
     perf_hooks_1.performance.mark('retrieve-workspace-files:start');
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
     let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
@@ -180,8 +181,8 @@ async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
         data.root,
         project,
     ]));
-    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
-    (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
+    const { fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    (0, build_project_graph_1.hydrateFileMap)(fileMap, rustReferences);
     return graph;
 }
 /**

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

@@ -1,74 +1,50 @@
 import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
 /**
- * Manages deferred project name substitutions across the plugin result
- * merge phase of project graph construction.
- *
- * ### Why this exists
- *
- * When plugins return `createNodes` results, a node `A` may declare a
- * `dependsOn` or `inputs` entry that references another project `B` by
- * name. A *later* plugin is allowed to rename project `B` to `C`. After
- * all plugin results are merged into the root map, node `A` would still
- * hold a stale reference to the now-nonexistent name `B`.
+ * Sentinel placed in `inputs` / `dependsOn` for a pending project-name
+ * 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
+ * `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);
+}
+export declare class RootRef extends NameRef {
+}
+export declare class UsageRef extends NameRef {
+}
+export declare function isNameRef(value: unknown): value is NameRef;
+export declare function isRootRef(value: unknown): value is RootRef;
+export declare function isUsageRef(value: unknown): value is UsageRef;
+/**
+ * Replaces project-name refs in plugin results with in-place sentinels,
+ * then resolves them after all merging is done.
  *
- * This class solves that by:
- * 1. Receiving a live nameMap accessor (maintained by ProjectNodesManager)
- *    for name → root resolution and colon-delimited string parsing.
- * 2. Tracking dirty roots via {@link identifyProjectWithRoot} when a
- *    project name changes at a root.
- * 3. Scanning each plugin's results for project-name references in
- *    `inputs` and `dependsOn` ({@link registerSubstitutorsForNodeResults}).
- * 4. After all results are merged, applying the substitutors for every
- *    renamed project so that references are updated to the final name
- *    ({@link applySubstitutions}).
+ * 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.
  */
 export declare class ProjectNameInNodePropsManager {
-    private substitutorsByReferencedRoot;
-    private substitutorsByArrayKey;
-    private pendingSubstitutorsByName;
-    private dirtyRoots;
     private getNameMap;
+    private allRefs;
+    private pendingByName;
     constructor(getNameMap?: () => Record<string, ProjectConfiguration>);
-    private removeSubstitutorEntry;
-    private clearSubstitutorAtIndex;
-    private clearSubstitutorsFromIndex;
-    private clearSubstitutorsFromSubIndex;
-    private forEachTargetConfig;
-    private registerProjectNameSubstitutor;
-    /**
-     * Scans `pluginResultProjects` for `inputs` and `dependsOn` entries that
-     * reference another project by name, and registers substitutors so those
-     * references are updated if the target project is later renamed.
-     *
-     * **Important**: call {@link identifyProjectWithRoot} for all projects in
-     * this result (and all prior results) before calling this method, so that
-     * referenced project names can be resolved to roots.
-     *
-     * @param pluginResultProjects Projects from a single plugin's createNodes call.
-     */
-    registerSubstitutorsForNodeResults(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
-    private createInputsStringSubstitutor;
-    private createInputsArraySubstitutor;
-    private createDependsOnStringSubstitutor;
-    private createDependsOnArraySubstitutor;
-    private createDependsOnTargetStringSubstitutor;
-    private registerSubstitutorsForInputs;
-    private registerSubstitutorsForDependsOn;
-    /**
-     * Records that a project with `name` exists at the given `root`. Call
-     * this during the merge phase whenever a project's name changes at a
-     * root — **before** calling
-     * {@link registerSubstitutorsForNodeResults} for that result.
-     *
-     * The nameMap (maintained externally by ProjectNodesManager) is always
-     * current — this method only needs to mark the root as dirty and
-     * promote any pending substitutors keyed by name.
-     */
+    registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
+    private processInputs;
+    private processDependsOn;
+    private processProjectsArray;
+    private createRef;
     identifyProjectWithRoot(root: string, name: string): void;
-    /**
-     * Executes all registered substitutors for renamed projects, updating
-     * stale project name references in the final merged `rootMap`. Should be
-     * called once after all plugin results have been merged.
-     */
     applySubstitutions(rootMap: Record<string, ProjectConfiguration>): void;
+    private resolveFinalName;
+    private writeReplacement;
 }