nx 23.1.1 → 23.1.2

package/dist/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -8,6 +8,7 @@ const semver_1 = require("semver");
 const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
 const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
+const path_1 = require("../../../../utils/path");
 const workspace_root_1 = require("../../../../utils/workspace-root");
 const packages_1 = require("../../utils/packages");
 const resolve_relative_to_dir_1 = require("../../utils/resolve-relative-to-dir");
@@ -346,6 +347,7 @@ class TargetProjectLocator {
         }));
     }
     findProjectOfResolvedModule(resolvedModule) {
+        resolvedModule = (0, path_1.normalizePath)(resolvedModule);
         if (resolvedModule.startsWith('node_modules/') ||
             resolvedModule.includes('/node_modules/')) {
             return undefined;

package/dist/src/project-graph/affected/affected-project-graph-models.d.ts

@@ -7,5 +7,5 @@ export interface AffectedProjectGraphContext {
     touchedProjects: string[];
 }
 export interface TouchedProjectLocator<T extends Change = Change> {
-    (fileChanges: FileChange<T>[], projectGraphNodes?: Record<string, ProjectGraphProjectNode>, nxJson?: NxJsonConfiguration<any>, packageJson?: any, projectGraph?: ProjectGraph): string[] | Promise<string[]>;
+    (fileChanges: FileChange<T>[], projectGraphNodes?: Record<string, ProjectGraphProjectNode>, nxJson?: NxJsonConfiguration<any>, packageJson?: any, projectGraph?: ProjectGraph, projectDeletionAffectsAllProjects?: boolean): string[] | Promise<string[]>;
 }

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

@@ -1,4 +1,4 @@
 import { FileChange } from '../file-utils';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectGraph } from '../../config/project-graph';
-export declare function filterAffected(graph: ProjectGraph, touchedFiles: FileChange[], nxJson?: NxJsonConfiguration, packageJson?: any): Promise<ProjectGraph>;
+export declare function filterAffected(graph: ProjectGraph, touchedFiles: FileChange[], nxJson?: NxJsonConfiguration, packageJson?: any, projectDeletionAffectsAllProjects?: boolean): Promise<ProjectGraph>;

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

@@ -7,7 +7,7 @@ const touched_projects_1 = require("../../plugins/js/project-graph/affected/touc
 const operators_1 = require("../operators");
 const configuration_1 = require("../../config/configuration");
 const project_glob_changes_1 = require("./locators/project-glob-changes");
-async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.readNxJson)(), packageJson = (0, file_utils_1.readPackageJson)()) {
+async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.readNxJson)(), packageJson = (0, file_utils_1.readPackageJson)(), projectDeletionAffectsAllProjects = true) {
     // Additional affected logic should be in this array.
     const touchedProjectLocators = [
         workspace_projects_1.getTouchedProjects,
@@ -18,7 +18,7 @@ async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.
     const touchedProjects = [];
     for (const locator of touchedProjectLocators) {
         performance.mark(locator.name + ':start');
-        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph);
+        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph, projectDeletionAffectsAllProjects);
         performance.mark(locator.name + ':end');
         performance.measure(locator.name, locator.name + ':start', locator.name + ':end');
         touchedProjects.push(...projects);

package/dist/src/project-graph/affected/locators/project-glob-changes.js

@@ -9,7 +9,7 @@ const fs_1 = require("fs");
 const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files");
 const globs_1 = require("../../../utils/globs");
 const get_plugins_1 = require("../../plugins/get-plugins");
-const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes) => {
+const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes, _nxJson, _packageJson, _projectGraph, projectDeletionAffectsAllProjects = true) => {
     const globPattern = await (async () => {
         // TODO: We need a quicker way to get patterns that should not
         // require starting up plugin workers
@@ -33,7 +33,10 @@ const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGra
             // If the file no longer exists on disk, then it was deleted
             if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, touchedFile.file))) {
                 // If any project has been deleted, we must assume all projects were affected
-                return Object.keys(projectGraphNodes);
+                if (projectDeletionAffectsAllProjects) {
+                    return Object.keys(projectGraphNodes);
+                }
+                continue;
             }
             // Modified project config files are under a project's root, and implicitly
             // mark it as affected. Thus, we don't need to handle it here.

package/dist/src/project-graph/error-types.d.ts

@@ -3,6 +3,7 @@ import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { CreateNodesFunction } from './plugins/public-api';
 import { ConfigurationResult } from './utils/project-configuration-utils';
 import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
+import type { WorktreeConflictAdvice } from '../utils/git-worktrees';
 export type ProjectGraphErrorTypes = AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | WorkspaceValidityError;
 export declare class StaleProjectGraphCacheError extends Error {
     constructor();
@@ -29,7 +30,17 @@ export declare class ProjectGraphError extends Error {
 export declare class MultipleProjectsWithSameNameError extends Error {
     conflicts: Map<string, string[]>;
     projects: Record<string, ProjectConfiguration>;
-    constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
+    /**
+     * Set when some of the duplicates come from git worktrees nested in the
+     * workspace, which is a different fix than renaming them.
+     */
+    worktreeAdvice?: WorktreeConflictAdvice;
+    constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>, 
+    /**
+     * Set when some of the duplicates come from git worktrees nested in the
+     * workspace, which is a different fix than renaming them.
+     */
+    worktreeAdvice?: WorktreeConflictAdvice);
 }
 export declare class ProjectWithExistingNameError extends Error {
     projectName: string;

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

@@ -92,19 +92,44 @@ class ProjectGraphError extends Error {
 exports.ProjectGraphError = ProjectGraphError;
 _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 class MultipleProjectsWithSameNameError extends Error {
-    constructor(conflicts, projects) {
+    constructor(conflicts, projects, 
+    /**
+     * Set when some of the duplicates come from git worktrees nested in the
+     * workspace, which is a different fix than renaming them.
+     */
+    worktreeAdvice) {
         super([
             `The following projects are defined in multiple locations:`,
             ...Array.from(conflicts.entries()).map(([project, roots]) => [`- ${project}: `, ...roots.map((r) => `  - ${r}`)].join('\n')),
             '',
-            "To fix this, set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.",
+            ...(worktreeAdvice?.ignoreTargets.length
+                ? [
+                    'Some of these are inside git worktrees nested in this workspace. A worktree is a full checkout, so every project in it collides with the one it was checked out from.',
+                    '',
+                    // Which `.gitignore` matters: a leading slash anchors to the
+                    // directory holding the file, and these paths are relative to
+                    // the workspace, which is not always the repository root.
+                    'To fix those, add the following to the .gitignore in the workspace root:',
+                    ...worktreeAdvice.ignoreTargets.map((target) => `  ${target}`),
+                    // Ignoring the worktrees settles only the duplicates they
+                    // explain; anything left is an ordinary name collision and still
+                    // needs the ordinary answer.
+                    ...(worktreeAdvice.explainsAllConflicts
+                        ? []
+                        : ['', `The rest are not from worktrees. ${RENAME_ADVICE}`]),
+                ]
+                : [
+                    `To fix this, ${RENAME_ADVICE[0].toLowerCase()}${RENAME_ADVICE.slice(1)}`,
+                ]),
         ].join('\n'));
         this.conflicts = conflicts;
         this.projects = projects;
+        this.worktreeAdvice = worktreeAdvice;
         this.name = this.constructor.name;
     }
 }
 exports.MultipleProjectsWithSameNameError = MultipleProjectsWithSameNameError;
+const RENAME_ADVICE = "Set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.";
 class ProjectWithExistingNameError extends Error {
     constructor(projectName, projectRoot) {
         super(`The project "${projectName}" is defined in multiple locations.`);

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

@@ -60,3 +60,4 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
     shutdown(): void;
     private registerProcessMetrics;
 }
+export declare function getPluginWorkerSocketId(): string;

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsolatedPlugin = void 0;
+exports.getPluginWorkerSocketId = getPluginWorkerSocketId;
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const net_1 = require("net");
 const path = require("path");
 const logger_1 = require("../../../daemon/logger");
@@ -12,6 +14,7 @@ const installation_directory_1 = require("../../../utils/installation-directory"
 const logger_2 = require("../../../utils/logger");
 const progress_topics_1 = require("../../../utils/progress-topics");
 const wait_for_socket_connection_1 = require("../../../utils/wait-for-socket-connection");
+const workspace_root_1 = require("../../../utils/workspace-root");
 const resolve_plugin_1 = require("../resolve-plugin");
 const messaging_1 = require("./messaging");
 const plugin_lifecycle_manager_1 = require("./plugin-lifecycle-manager");
@@ -336,6 +339,10 @@ class IsolatedPlugin {
 exports.IsolatedPlugin = IsolatedPlugin;
 // --- Worker Spawning Utilities ---
 global.nxPluginWorkerCount ??= 0;
+function getPluginWorkerSocketId() {
+    const counter = global.nxPluginWorkerCount++;
+    return `${process.pid}-${counter.toString(36)}-${(0, crypto_1.randomBytes)(4).toString('hex')}`;
+}
 async function startPluginWorker(name) {
     performance.mark(`start-plugin-worker:${name}`);
     const isWorkerTypescript = path.extname(__filename) === '.ts';
@@ -352,7 +359,14 @@ async function startPluginWorker(name) {
             }
             : {}),
     };
-    const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++, performance.now()].join('-'));
+    // Keep the host pid readable for diagnostics, the counter collision-free
+    // within this process, and entropy for a reused pid across process runs. The
+    // suffix is a base36 counter plus four random bytes: eleven characters after
+    // the pid until the counter passes 36, and fixed-length where the
+    // `performance.now()` stamp it replaced varied with process uptime. That
+    // keeps the socket path inside the 95-character budget `assertValidSocketPath`
+    // enforces.
+    const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)(getPluginWorkerSocketId());
     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.
@@ -361,6 +375,9 @@ async function startPluginWorker(name) {
         workerPath,
         ipcPath,
         name,
+        // The host's root. The worker validates against this rather than re-resolving,
+        // so the two agree by construction.
+        workspace_root_1.workspaceRoot,
     ], {
         stdio: ['ignore', 'pipe', 'pipe'],
         env,

package/dist/src/project-graph/plugins/isolation/messaging.d.ts

@@ -107,10 +107,23 @@ type PluginMessageDefs = DefineMessages<{
         };
     };
 }>;
+/**
+ * The sender's workspace root. Only the *worker* asserts on it, for host→worker
+ * messages; results and notifications carry the field but the host does not
+ * check it. The daemon channel is checked in the same one direction — the
+ * server validates inbound client messages and the client does not validate
+ * responses — so the two are alike rather than one being weaker.
+ * Optional and stamped centrally in `sendMessageOverSocket`, so the many
+ * message constructors need not set it; undefined is treated as not foreign,
+ * which is why this detects a shared socket directory rather than an attacker.
+ */
+export type WorkspaceStampedMessage = {
+    workspaceRoot?: string;
+};
 /** Union of all plugin worker message types */
-export type PluginWorkerMessage = AllMessages<PluginMessageDefs>;
+export type PluginWorkerMessage = AllMessages<PluginMessageDefs> & WorkspaceStampedMessage;
 /** Union of all plugin worker result types */
-export type PluginWorkerResult = AllResults<PluginMessageDefs>;
+export type PluginWorkerResult = AllResults<PluginMessageDefs> & WorkspaceStampedMessage;
 /** Result type for the load message */
 export type PluginWorkerLoadResult = ResultOf<PluginMessageDefs, 'load'>;
 /**
@@ -122,7 +135,7 @@ export type PluginWorkerEmitLogNotification = {
     type: 'emitLog';
     level: 'log' | 'warn' | 'error';
     message: string;
-};
+} & WorkspaceStampedMessage;
 export type PluginWorkerNotification = PluginWorkerEmitLogNotification;
 export declare function isPluginWorkerNotification(message: Serializable): message is PluginWorkerNotification;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;

package/dist/src/project-graph/plugins/isolation/messaging.js

@@ -7,6 +7,7 @@ exports.consumeMessage = consumeMessage;
 exports.sendMessageOverSocket = sendMessageOverSocket;
 const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const workspace_root_1 = require("../../../utils/workspace-root");
 const NOTIFICATION_TYPES = [
     'emitLog',
 ];
@@ -81,6 +82,8 @@ async function consumeMessage(socket, raw, handlers) {
  * Sends a message over the socket with proper formatting.
  */
 function sendMessageOverSocket(socket, message) {
+    // Stamped here rather than in each constructor, mirroring the daemon.
+    message.workspaceRoot = workspace_root_1.workspaceRoot;
     socket.write((0, socket_utils_1.serialize)(message));
     socket.write(consume_messages_from_socket_1.MESSAGE_END_SEQ);
 }

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

@@ -354,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/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");
@@ -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);

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

@@ -5,10 +5,13 @@ exports.normalizeTarget = normalizeTarget;
 exports.validateAndNormalizeProjectRootMap = validateAndNormalizeProjectRootMap;
 const executor_utils_1 = require("../../../command-line/run/executor-utils");
 const fileutils_1 = require("../../../utils/fileutils");
+const long_running_target_1 = require("../../../utils/long-running-target");
+const output_1 = require("../../../utils/output");
 const to_project_name_1 = require("../../../config/to-project-name");
 const error_types_1 = require("../../error-types");
 const target_merging_1 = require("./target-merging");
 const node_fs_1 = require("node:fs");
+const git_worktrees_1 = require("../../../utils/git-worktrees");
 const path_1 = require("path");
 function validateProject(project, 
 // name -> project
@@ -65,15 +68,137 @@ function normalizeTarget(target, project, workspaceRoot, projectsMap, errorMsgKe
     }
     return target;
 }
+// TODO(v24): remove the legacy target-name cache fallback and its warning.
+// Removal needs a second mechanism for plugin-inferred targets, which the
+// accompanying migration cannot reach.
+/**
+ * Whether `target` is cacheable only by way of the legacy name-based fallback:
+ * the exact target-name key of `targetDefaults` declares `cache: true`, but an
+ * executor key won target-default resolution instead, so the merged target never
+ * received it.
+ *
+ * A `true` result means the user's `cache: true` silently lost, so this doubles
+ * as the condition for warning them that the name key is being shadowed.
+ */
+function isLegacyCachedTarget(targetName, targetDefaults, target) {
+    // Resolution already decided `cache`, so the name key isn't shadowed.
+    if (target.cache !== undefined) {
+        return false;
+    }
+    if (isLongRunningTarget(targetName, target)) {
+        return false;
+    }
+    // Restricted to shadowing, which is narrower than what pre-23 restored: that
+    // derivation matched on target name alone, so a name key dropped as
+    // incompatible (its entry declared a foreign executor) was cacheable too.
+    // Restoring that as well would mean writing `cache` with no key to name in
+    // the warning, and no migration able to retire it. Deliberately not covered.
+    if (!findShadowingTargetDefaultKey(targetDefaults, target)) {
+        return false;
+    }
+    return declaresCacheTrue(targetDefaults?.[targetName]);
+}
+/**
+ * Whether the name key declares `cache: true` on an entry that always applies.
+ *
+ * Filters are deliberately not evaluated. They cannot express a pre-23 config
+ * (the filtered array shape postdates the behavior being restored), and a
+ * filtered entry declaring `cache` may or may not apply to this project — so
+ * rather than guess, a filtered `cache` declares the value unknowable and
+ * nothing is restored. Among unfiltered entries the last wins, matching the
+ * in-key merge order.
+ */
+function declaresCacheTrue(value) {
+    if (!value) {
+        return false;
+    }
+    const entries = Array.isArray(value) ? value : [value];
+    let declared;
+    for (const entry of entries) {
+        // `nx.json` is hand-edited; a null or scalar entry would throw here.
+        if (!entry || typeof entry !== 'object')
+            continue;
+        if (entry.cache === undefined)
+            continue;
+        if (entry.filter)
+            return false;
+        declared = entry.cache;
+    }
+    return declared === true;
+}
+/**
+ * The normalization-time half of the pre-23 `longRunningTask` guard, which kept
+ * `cacheableOperations` from ever making these cacheable. Its remaining clause
+ * — `task.overrides['watch']` — is a runtime invocation override with no target
+ * equivalent, so it has no counterpart here.
+ */
+function isLongRunningTarget(targetName, target) {
+    return !!target.continuous || (0, long_running_target_1.isLongRunningTargetName)(targetName);
+}
+/**
+ * The `targetDefaults` key that beat the target-name key for `target`. Only an
+ * executor key can: key precedence puts the exact target name ahead of every
+ * glob, so nothing else outranks it. Undefined when the name key lost for
+ * another reason (e.g. its entry declared a foreign executor and was dropped as
+ * incompatible) — see {@link isLegacyCachedTarget} for why that case is left
+ * alone even though pre-23 restored it.
+ *
+ * `hasOwnProperty` rather than a lookup: an executor named `__proto__` resolves
+ * through the prototype chain to a truthy object, which would report a key the
+ * user never wrote.
+ */
+function findShadowingTargetDefaultKey(targetDefaults, target) {
+    return target.executor &&
+        targetDefaults &&
+        Object.prototype.hasOwnProperty.call(targetDefaults, target.executor)
+        ? target.executor
+        : undefined;
+}
+/**
+ * Emits a single grouped warning for every (shadowing key, target-name key)
+ * pair that relied on the deprecated fallback. Grouping matters because the
+ * same pair recurs in every affected project — a per-target warning would
+ * print hundreds of identical lines in a large workspace.
+ */
+function warnAboutLegacyCachedTargets(legacyCacheReads) {
+    if (legacyCacheReads.size === 0) {
+        return;
+    }
+    const bodyLines = [];
+    for (const [shadowingKey, targetKeys] of legacyCacheReads) {
+        for (const targetKey of targetKeys) {
+            bodyLines.push(`  - "${shadowingKey}" does not set "cache", so it was read from "${targetKey}"`);
+        }
+    }
+    bodyLines.push('', 'An executor key applies to every target that resolves through it, so exclude any continuous target before setting "cache" on one — a target that is both cacheable and continuous is rejected.', 'Target defaults resolve to a single key rather than merging, so an executor key hides the target name key entirely.', 'Set "cache" on the executor key to keep these targets cacheable — reading it from the target name key is deprecated and will be removed in Nx 24.');
+    output_1.output.warn({
+        title: 'Some targets are only cacheable through a deprecated fallback.',
+        bodyLines,
+    });
+}
 function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
 /**
  * Project configurations keyed by project name
  */
-projects) {
+projects, 
+/**
+ * Shadowing `targetDefaults` key -> target name keys its `cache` was read
+ * from. Accumulated across projects so the deprecation warns once per pair.
+ */
+legacyCacheReads) {
     const targetErrorMessage = [];
     for (const targetName in project.targets) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
         const target = project.targets[targetName];
+        const targetDefaults = nxJsonConfiguration.targetDefaults;
+        if (isLegacyCachedTarget(targetName, targetDefaults, target)) {
+            target.cache = true;
+            // Always defined: `isLegacyCachedTarget` returns false without it.
+            const shadowingKey = findShadowingTargetDefaultKey(targetDefaults, target);
+            const targetKeys = legacyCacheReads.get(shadowingKey) ?? new Set();
+            targetKeys.add(targetName);
+            legacyCacheReads.set(shadowingKey, targetKeys);
+        }
         if (
         // If the target has no executor or command, it doesn't do anything
         !target.executor &&
@@ -106,6 +231,7 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
     const conflicts = new Map();
     const projectRootsWithNoName = [];
     const validityErrors = [];
+    const legacyCacheReads = new Map();
     for (const root in projectRootMap) {
         const project = projectRootMap[root];
         // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
@@ -155,7 +281,7 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
     for (const root in projectRootMap) {
         const project = projectRootMap[root];
         try {
-            normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects);
+            normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects, legacyCacheReads);
         }
         catch (e) {
             if (e instanceof error_types_1.WorkspaceValidityError) {
@@ -166,9 +292,13 @@ function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJso
             }
         }
     }
+    warnAboutLegacyCachedTargets(legacyCacheReads);
     const errors = [];
     if (conflicts.size > 0) {
-        errors.push(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.
+        const worktreeAdvice = (0, git_worktrees_1.analyzeWorktreeConflicts)(workspaceRoot, conflicts);
+        errors.push(new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects, worktreeAdvice ?? undefined));
     }
     if (projectRootsWithNoName.length > 0) {
         errors.push(new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects));

package/dist/src/tasks-runner/task-env.js

@@ -166,10 +166,13 @@ function getOwnerTargetForTask(task, graph) {
         for (const targets of Object.values(project.data.metadata.targetGroups)) {
             if (targets.includes(task.target.target)) {
                 for (const target of targets) {
-                    if (project.data.targets[target].metadata?.nonAtomizedTarget) {
+                    // a target group can name a target the project does not define —
+                    // inference plugins build the group and the targets separately, so
+                    // the two can disagree. skip the phantom rather than dereferencing it.
+                    if (project.data.targets[target]?.metadata?.nonAtomizedTarget) {
                         return [
                             target,
-                            project.data.targets[target].metadata?.nonAtomizedTarget,
+                            project.data.targets[target]?.metadata?.nonAtomizedTarget,
                         ];
                     }
                 }

package/dist/src/tasks-runner/utils.js

@@ -36,6 +36,7 @@ const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
 const legacy_depends_on_warning_1 = require("./legacy-depends-on-warning");
 const globs_1 = require("../utils/globs");
+const long_running_target_1 = require("../utils/long-running-target");
 const path_1 = require("../utils/path");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
 const split_target_1 = require("../utils/split-target");
@@ -429,14 +430,9 @@ function isCacheableTask(task) {
     return task.cache;
 }
 function longRunningTask(task) {
-    const t = task.target.target;
     return (task.continuous ||
         (!!task.overrides['watch'] && task.overrides['watch'] !== 'false') ||
-        t.endsWith(':watch') ||
-        t.endsWith('-watch') ||
-        t === 'serve' ||
-        t === 'dev' ||
-        t === 'start');
+        (0, long_running_target_1.isLongRunningTargetName)(task.target.target));
 }
 // TODO: vsavkin remove when nx-cloud doesn't depend on it
 function unparse(options) {