nx 23.1.1 → 23.1.3

package/dist/src/plugins/js/project-graph/affected/npm-packages.js

@@ -13,6 +13,7 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
     let touched = [];
     const changes = packageJsonChange.getChanges();
     const npmPackages = Object.values(projectGraph.externalNodes);
+    let packagesByName;
     const missingTouchedNpmPackages = [];
     for (const c of changes) {
         if ((0, json_diff_1.isJsonChange)(c) &&
@@ -53,26 +54,20 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
             (c.path[0] === 'overrides' ||
                 c.path[0] === 'resolutions' ||
                 (c.path[0] === 'pnpm' && c.path[1] === 'overrides'))) {
-            // Changes to overrides, resolutions, or pnpm.overrides
-            // Find which package was changed and mark projects that depend on it as affected
-            const packageName = c.path[0] === 'pnpm' ? c.path[2] : c.path[1];
-            if (packageName) {
-                // Look for the npm package in external nodes
-                let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === packageName);
-                if (npmPackage) {
-                    touched.push(npmPackage.name);
-                    // If it's a global package, all projects are affected
-                    if ('packageName' in npmPackage.data &&
-                        globalPackages.has(npmPackage.data.packageName)) {
-                        return Object.keys(projectGraph.nodes);
-                    }
-                }
-                else {
-                    // If the package isn't found in external nodes, it might affect all projects
-                    // since overrides can affect transitive dependencies
-                    return Object.keys(projectGraph.nodes);
-                }
+            const packageSelector = getPackageSelector(c);
+            if (!packageSelector)
+                continue;
+            packagesByName ??= groupPackagesByName(npmPackages);
+            const matchingNpmPackages = findPackagesForSelector(packageSelector, packagesByName, c.path[0] === 'pnpm');
+            // An unresolved selector can still target a transitive dependency,
+            // so fall back to marking every project affected.
+            if (!matchingNpmPackages.length) {
+                return Object.keys(projectGraph.nodes);
             }
+            if (matchingNpmPackages.some((pkg) => globalPackages.has(pkg.data.packageName))) {
+                return Object.keys(projectGraph.nodes);
+            }
+            touched.push(...matchingNpmPackages.map((pkg) => pkg.name));
         }
         else if ((0, file_utils_1.isWholeFileChange)(c)) {
             // Whole file was touched, so all npm packages are touched.
@@ -83,9 +78,45 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
     if (missingTouchedNpmPackages.length) {
         logger_1.logger.warn(`The affected projects might have not been identified properly. The package(s) ${missingTouchedNpmPackages.join(', ')} were not found. Please open an issue in GitHub including the package.json file.`);
     }
-    return touched;
+    return [...new Set(touched)];
 };
 exports.getTouchedNpmPackages = getTouchedNpmPackages;
+function getPackageSelector(change) {
+    if (typeof change.value.lhs !== 'string' &&
+        typeof change.value.rhs !== 'string') {
+        return;
+    }
+    const selectorIndex = change.path[0] === 'pnpm' ? 2 : change.path.length - 1;
+    const selector = change.path[selectorIndex];
+    return selector === '.' ? change.path[selectorIndex - 1] : selector;
+}
+function groupPackagesByName(npmPackages) {
+    const packagesByName = new Map();
+    for (const pkg of npmPackages) {
+        const packageName = pkg.data.packageName;
+        if (!packageName)
+            continue;
+        const packages = packagesByName.get(packageName);
+        if (packages) {
+            packages.push(pkg);
+        }
+        else {
+            packagesByName.set(packageName, [pkg]);
+        }
+    }
+    return packagesByName;
+}
+function findPackagesForSelector(selector, packagesByName, isPnpmOverride) {
+    if (isPnpmOverride) {
+        // Pnpm does not treat `>` as a parent delimiter when it starts a range.
+        const parentDelimiterIndex = selector.search(/[^ |@]>/);
+        if (parentDelimiterIndex !== -1) {
+            selector = selector.slice(parentDelimiterIndex + 2);
+        }
+    }
+    const packageName = selector.match(/(?:^|\/)(@[^/@>\s]+\/[^/@>\s]+|[^/@>\s]+)(?:@[^/]*)?$/)?.[1];
+    return packageName ? (packagesByName.get(packageName) ?? []) : [];
+}
 function getGlobalPackages(plugins) {
     return (plugins ?? [])
         .map((p) => (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(typeof p === 'string' ? p : p.plugin))

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);