nx 22.7.0-beta.12 → 22.7.0-beta.13

package/dist/src/daemon/client/client.d.ts

@@ -44,7 +44,7 @@ export declare class DaemonClient {
         sourceMaps: ConfigurationSourceMaps;
     }>;
     getAllFileData(): Promise<FileData[]>;
-    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
     registerFileWatcher(config: {
         watchProjects: string[] | 'all';
         includeGlobalWorkspaceFiles?: boolean;
@@ -62,8 +62,14 @@ export declare class DaemonClient {
     } | null) => void): Promise<UnregisterCallback>;
     private reconnectProjectGraphListener;
     processInBackground(requirePath: string, data: any): Promise<any>;
-    recordOutputsHash(outputs: string[], hash: string): Promise<any>;
-    outputsHashesMatch(outputs: string[], hash: string): Promise<any>;
+    recordOutputsHashBatch(entries: {
+        outputs: string[];
+        hash: string;
+    }[]): Promise<any>;
+    outputsHashesMatchBatch(entries: {
+        outputs: string[];
+        hash: string;
+    }[]): Promise<boolean[]>;
     glob(globs: string[], exclude?: string[]): Promise<string[]>;
     multiGlob(globs: string[], exclude?: string[]): Promise<string[][]>;
     getWorkspaceContextFileData(): Promise<FileData[]>;
@@ -100,6 +106,7 @@ export declare class DaemonClient {
      * Used for reconnection - throws VersionMismatchError if daemon version differs.
      */
     private waitForServerToBeAvailable;
+    private envReflectionSent;
     private sendMessageToDaemon;
     private registerDaemonProcessWithMetricsService;
     private handleMessage;

package/dist/src/daemon/client/client.js

@@ -15,13 +15,13 @@ const native_1 = require("../../native");
 const error_types_1 = require("../../project-graph/error-types");
 const project_graph_1 = require("../../project-graph/project-graph");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
-const wait_for_socket_connection_1 = require("../../utils/wait-for-socket-connection");
 const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const handle_import_1 = require("../../utils/handle-import");
 const is_ci_1 = require("../../utils/is-ci");
 const is_sandbox_1 = require("../../utils/is-sandbox");
 const output_1 = require("../../utils/output");
 const promised_based_queue_1 = require("../../utils/promised-based-queue");
+const wait_for_socket_connection_1 = require("../../utils/wait-for-socket-connection");
 const workspace_root_1 = require("../../utils/workspace-root");
 const cache_1 = require("../cache");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
@@ -41,15 +41,7 @@ const task_history_1 = require("../message-types/task-history");
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const tmp_dir_1 = require("../tmp-dir");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
-const DAEMON_ENV_REQUIRED_SETTINGS = {
-    NX_PROJECT_GLOB_CACHE: 'false',
-    NX_CACHE_PROJECTS_CONFIG: 'false',
-};
-const DAEMON_ENV_OVERRIDABLE_SETTINGS = {
-    NX_VERBOSE_LOGGING: 'true',
-    NX_PERF_LOGGING: 'true',
-    NX_NATIVE_LOGGING: 'nx=debug',
-};
+const daemon_environment_1 = require("./daemon-environment");
 var DaemonStatus;
 (function (DaemonStatus) {
     DaemonStatus[DaemonStatus["CONNECTING"] = 0] = "CONNECTING";
@@ -72,6 +64,7 @@ class DaemonClient {
         this.fileWatcherConfigs = new Map();
         this.projectGraphListenerReconnecting = false;
         this.projectGraphListenerCallbacks = new Map();
+        this.envReflectionSent = false;
         try {
             this.nxJson = (0, configuration_1.readNxJson)();
         }
@@ -187,13 +180,11 @@ class DaemonClient {
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
-    hashTasks(runnerOptions, tasks, taskGraph, env, cwd, collectInputs) {
+    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
-            env: process.env.NX_USE_V8_SERIALIZER !== 'false'
-                ? structuredClone(process.env)
-                : env,
+            perTaskEnvs,
             tasks,
             taskGraph,
             cwd,
@@ -525,22 +516,16 @@ class DaemonClient {
             // so we force JSON serialization here
         }, 'json');
     }
-    recordOutputsHash(outputs, hash) {
+    recordOutputsHashBatch(entries) {
         return this.sendToDaemonViaQueue({
-            type: 'RECORD_OUTPUTS_HASH',
-            data: {
-                outputs,
-                hash,
-            },
+            type: 'RECORD_OUTPUTS_HASH_BATCH',
+            data: entries,
         });
     }
-    outputsHashesMatch(outputs, hash) {
+    outputsHashesMatchBatch(entries) {
         return this.sendToDaemonViaQueue({
-            type: 'OUTPUTS_HASHES_MATCH',
-            data: {
-                outputs,
-                hash,
-            },
+            type: 'OUTPUTS_HASHES_MATCH_BATCH',
+            data: entries,
         });
     }
     glob(globs, exclude) {
@@ -868,6 +853,12 @@ class DaemonClient {
         return false;
     }
     async sendMessageToDaemon(message, force) {
+        // the first message sent to the daemon includes an env prop
+        // that updates the process.env values on the daemon.
+        if (!this.envReflectionSent && !global.NX_PLUGIN_WORKER) {
+            message.env = (0, daemon_environment_1.getDaemonEnv)();
+            this.envReflectionSent = true;
+        }
         await this.startDaemonIfNecessary();
         let keepAlive;
         return new Promise((resolve, reject) => {
@@ -947,12 +938,11 @@ class DaemonClient {
             detached: true,
             windowsHide: true,
             shell: false,
-            env: {
-                ...DAEMON_ENV_OVERRIDABLE_SETTINGS,
-                ...process.env,
-                ...DAEMON_ENV_REQUIRED_SETTINGS,
-            },
+            env: (0, daemon_environment_1.getDaemonEnv)(),
         });
+        // if this process is the process that spawned the daemon,
+        // the daemon env is already up to date
+        this.envReflectionSent = true;
         backgroundProcess.unref();
         /**
          * Ensure the server is actually available to connect to via IPC before resolving

package/dist/src/daemon/client/daemon-environment.d.ts

@@ -0,0 +1,4 @@
+export declare function getDaemonEnv(): NodeJS.ProcessEnv & {
+    NX_PROJECT_GLOB_CACHE: string;
+    NX_CACHE_PROJECTS_CONFIG: string;
+};

package/dist/src/daemon/client/daemon-environment.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDaemonEnv = getDaemonEnv;
+const DAEMON_ENV_REQUIRED_SETTINGS = {
+    NX_PROJECT_GLOB_CACHE: 'false',
+    NX_CACHE_PROJECTS_CONFIG: 'false',
+};
+const DAEMON_ENV_OVERRIDABLE_SETTINGS = {
+    NX_VERBOSE_LOGGING: 'true',
+    NX_PERF_LOGGING: 'true',
+    NX_NATIVE_LOGGING: 'nx=debug',
+};
+/**
+ * Env vars that should NOT be sent to the daemon because they cannot affect
+ * the project graph. Only vars that can actually affect the project graph
+ * (e.g. PATH, JAVA_HOME, GRADLE_HOME) should be allowed through.
+ */
+const DAEMON_ENV_VARS_EXCLUSIONS = new Set([
+    // Nx task-scoped vars
+    'NX_TASK_TARGET_CONFIGURATION',
+    'NX_TASK_TARGET_PROJECT',
+    'NX_TASK_TARGET_TARGET',
+    'NX_TASK_HASH',
+    'NX_TERMINAL_OUTPUT_PATH',
+    'NX_TERMINAL_CAPTURE_STDERR',
+    'NX_STREAM_OUTPUT',
+    'NX_PREFIX_OUTPUT',
+    'NX_FORKED_TASK_EXECUTOR',
+    'NX_SET_CLI',
+    'NX_INVOKED_BY_RUNNER',
+    'NX_LOAD_DOT_ENV_FILES',
+    'NX_SKIP_NX_CACHE',
+    'NX_CACHE_FAILURES',
+    'NX_REJECT_UNKNOWN_LOCAL_CACHE',
+    'NX_IGNORE_CYCLES',
+    'NX_BATCH_MODE',
+    'NX_CI_EXECUTION_ID',
+    'NX_DAEMON_PROCESS',
+    // Nx UI/logging vars (don't affect graph structure)
+    'NX_TUI',
+    'NX_TUI_AUTO_EXIT',
+    'NX_TUI_SKIP_CAPABILITY_CHECK',
+    'NX_VERBOSE_LOGGING',
+    'NX_PERF_LOGGING',
+    'NX_NATIVE_LOGGING',
+    'NX_PROFILE',
+    'NX_DAEMON_VERBOSE_LOGGING',
+    // AI agent detection vars (the daemon itself is not an AI agent)
+    'CLAUDECODE',
+    'CLAUDE_CODE',
+    'REPL_ID',
+    'CURSOR_TRACE_ID',
+    'COMPOSER_NO_INTERACTION',
+    'OPENCODE',
+    'GEMINI_CLI',
+    // Shell mechanics
+    '_',
+    'SHLVL',
+    'OLDPWD',
+    'SHELL_SESSION_ID',
+    'TERM_SESSION_ID',
+    'SECURITYSESSIONID',
+    'COMMAND_MODE',
+    'WINDOWID',
+    'COLUMNS',
+    'LINES',
+    'TMPDIR',
+    // Session / auth
+    'SSH_AUTH_SOCK',
+    'SSH_AGENT_PID',
+    'XDG_SESSION_ID',
+    'DBUS_SESSION_BUS_ADDRESS',
+    'DISPLAY',
+    // macOS internals
+    '__CF_USER_TEXT_ENCODING',
+    '__CFBundleIdentifier',
+]);
+/**
+ * Env var prefixes that should never be sent to the daemon.
+ * These cover CI platforms, package managers, editors, and terminals.
+ */
+const DAEMON_ENV_PREFIX_EXCLUSIONS = [
+    // CI platforms
+    'GITHUB_',
+    'RUNNER_',
+    'CI_JOB_',
+    'CI_PIPELINE_',
+    'CIRCLE_',
+    'JENKINS_',
+    'BUILD_',
+    'AGENT_',
+    'SYSTEM_TASK',
+    // Package managers (process-scoped)
+    'npm_',
+    'pnpm_',
+    // Editors / IDEs
+    'VSCODE_',
+    'JETBRAINS_',
+    // Terminal emulators
+    'ITERM_',
+    'KITTY_',
+    'WEZTERM_',
+    'ALACRITTY_',
+    'KONSOLE_',
+    'TMUX',
+];
+function isExcludedEnvVar(key) {
+    return (DAEMON_ENV_VARS_EXCLUSIONS.has(key) ||
+        DAEMON_ENV_PREFIX_EXCLUSIONS.some((prefix) => key.startsWith(prefix)));
+}
+function getDaemonEnv() {
+    const env = { ...DAEMON_ENV_OVERRIDABLE_SETTINGS };
+    for (const key in process.env) {
+        if (!isExcludedEnvVar(key)) {
+            env[key] = process.env[key];
+        }
+    }
+    return Object.assign(env, DAEMON_ENV_REQUIRED_SETTINGS);
+}

package/dist/src/daemon/client/daemon-socket-messenger.d.ts

@@ -1,15 +1,12 @@
 import { Socket } from 'net';
-export interface Message extends Record<string, any> {
-    type: string;
-    data?: any;
-}
+import { DaemonMessage } from '../message-types/daemon-message';
 export declare class VersionMismatchError extends Error {
     constructor();
 }
 export declare class DaemonSocketMessenger {
     private socket;
     constructor(socket: Socket);
-    sendMessage(messageToDaemon: Message, force?: 'v8' | 'json'): void;
+    sendMessage<T extends DaemonMessage>(messageToDaemon: T, force?: 'v8' | 'json'): void;
     listen(onData: (message: string) => void, onClose?: () => void, onError?: (err: Error) => void): DaemonSocketMessenger;
     close(): void;
 }

package/dist/src/daemon/client/daemon-socket-messenger.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DaemonSocketMessenger = exports.VersionMismatchError = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
-const socket_utils_1 = require("../socket-utils");
 const logger_1 = require("../logger");
+const socket_utils_1 = require("../socket-utils");
 class VersionMismatchError extends Error {
     constructor() {
         super('Version mismatch with daemon server');

package/dist/src/daemon/message-types/daemon-message.d.ts

@@ -0,0 +1,6 @@
+export type DaemonMessage = {
+    type: string;
+    env?: Record<string, string>;
+    data?: any;
+};
+export declare function isDaemonMessage(msg: unknown): msg is DaemonMessage;

package/dist/src/daemon/message-types/daemon-message.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDaemonMessage = isDaemonMessage;
+function isDaemonMessage(msg) {
+    return typeof msg === 'object' && msg && 'type' in msg;
+}

package/dist/src/daemon/server/handle-hash-tasks.d.ts

@@ -1,9 +1,9 @@
 import { Task, TaskGraph } from '../../config/task-graph';
 export declare function handleHashTasks(payload: {
     runnerOptions: any;
-    env: any;
     tasks: Task[];
     taskGraph: TaskGraph;
+    perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
     cwd: string;
     collectInputs?: boolean;
 }): Promise<{

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

@@ -20,7 +20,7 @@ async function handleHashTasks(payload) {
         storedProjectGraph = projectGraph;
         storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, payload.runnerOptions);
     }
-    const response = await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.env, payload.cwd, payload.collectInputs);
+    const response = await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
     return {
         response,
         description: 'handleHashTasks',

package/dist/src/daemon/server/handle-outputs-tracking.d.ts

@@ -1,15 +1,15 @@
 import { HandlerResult } from './server';
-export declare function handleRecordOutputsHash(payload: {
+export declare function handleRecordOutputsHashBatch(payload: {
     type: string;
     data: {
         outputs: string[];
         hash: string;
-    };
+    }[];
 }): Promise<HandlerResult>;
-export declare function handleOutputsHashesMatch(payload: {
+export declare function handleOutputsHashesMatchBatch(payload: {
     type: string;
     data: {
         outputs: string[];
         hash: string;
-    };
+    }[];
 }): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-outputs-tracking.js

@@ -1,34 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRecordOutputsHash = handleRecordOutputsHash;
-exports.handleOutputsHashesMatch = handleOutputsHashesMatch;
+exports.handleRecordOutputsHashBatch = handleRecordOutputsHashBatch;
+exports.handleOutputsHashesMatchBatch = handleOutputsHashesMatchBatch;
 const outputs_tracking_1 = require("./outputs-tracking");
-async function handleRecordOutputsHash(payload) {
+async function handleRecordOutputsHashBatch(payload) {
     try {
-        await (0, outputs_tracking_1.recordOutputsHash)(payload.data.outputs, payload.data.hash);
+        (0, outputs_tracking_1.recordOutputsHashBatch)(payload.data);
         return {
-            description: 'recordOutputsHash',
+            description: 'recordOutputsHashBatch',
             response: '{}',
         };
     }
     catch (e) {
         return {
-            description: 'recordOutputsHash failed',
+            description: 'recordOutputsHashBatch failed',
             error: new Error(`Critical error when recording metadata about outputs: '${e.message}'.`),
         };
     }
 }
-async function handleOutputsHashesMatch(payload) {
+async function handleOutputsHashesMatchBatch(payload) {
     try {
-        const res = await (0, outputs_tracking_1.outputsHashesMatch)(payload.data.outputs, payload.data.hash);
+        const results = (0, outputs_tracking_1.outputsHashesMatchBatch)(payload.data);
         return {
-            response: res,
-            description: 'outputsHashesMatch',
+            response: results,
+            description: 'outputsHashesMatchBatch',
         };
     }
     catch (e) {
         return {
-            description: 'outputsHashesMatch failed',
+            description: 'outputsHashesMatchBatch failed',
             error: new Error(`Critical error when verifying the contents of the outputs haven't changed: '${e.message}'.`),
         };
     }

package/dist/src/daemon/server/outputs-tracking.d.ts

@@ -1,8 +1,23 @@
 import { WatchEvent } from '../../native';
 export declare function _recordOutputsHash(outputs: string[], hash: string): void;
 export declare function _outputsHashesMatch(outputs: string[], hash: string): boolean;
-export declare function recordedHash(output: string): string;
-export declare function recordOutputsHash(_outputs: string[], hash: string): Promise<void>;
-export declare function outputsHashesMatch(_outputs: string[], hash: string): Promise<boolean>;
 export declare function processFileChangesInOutputs(changeEvents: WatchEvent[], now?: number): void;
+/**
+ * Check whether the on-disk outputs of each entry still match the hash
+ * the daemon recorded for them. Uses Rayon-parallel filesystem scanning
+ * for uncached entries.
+ */
+export declare function outputsHashesMatchBatch(entries: {
+    outputs: string[];
+    hash: string;
+}[]): boolean[];
+/**
+ * Record the hash of each entry's on-disk outputs so future
+ * outputsHashesMatchBatch calls can skip redundant cache copies.
+ * Uses Rayon-parallel filesystem scanning.
+ */
+export declare function recordOutputsHashBatch(entries: {
+    outputs: string[];
+    hash: string;
+}[]): void;
 export declare function disableOutputsTracking(): void;

package/dist/src/daemon/server/outputs-tracking.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._recordOutputsHash = _recordOutputsHash;
 exports._outputsHashesMatch = _outputsHashesMatch;
-exports.recordedHash = recordedHash;
-exports.recordOutputsHash = recordOutputsHash;
-exports.outputsHashesMatch = outputsHashesMatch;
 exports.processFileChangesInOutputs = processFileChangesInOutputs;
+exports.outputsHashesMatchBatch = outputsHashesMatchBatch;
+exports.recordOutputsHashBatch = recordOutputsHashBatch;
 exports.disableOutputsTracking = disableOutputsTracking;
 const path_1 = require("path");
 const native_1 = require("../../native");
@@ -44,25 +43,6 @@ function _outputsHashesMatch(outputs, hash) {
     }
     return true;
 }
-function recordedHash(output) {
-    return recordedHashes[output];
-}
-async function recordOutputsHash(_outputs, hash) {
-    const outputs = await normalizeOutputs(_outputs);
-    if (disabled)
-        return;
-    _recordOutputsHash(outputs, hash);
-}
-async function outputsHashesMatch(_outputs, hash) {
-    const outputs = await normalizeOutputs(_outputs);
-    if (disabled)
-        return false;
-    return _outputsHashesMatch(outputs, hash);
-}
-async function normalizeOutputs(outputs) {
-    let expandedOutputs = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)((0, native_1.getFilesForOutputs)(workspace_root_1.workspaceRoot, outputs));
-    return expandedOutputs;
-}
 function processFileChangesInOutputs(changeEvents, now = undefined) {
     if (!now) {
         now = new Date().getTime();
@@ -88,6 +68,53 @@ function processFileChangesInOutputs(changeEvents, now = undefined) {
         }
     }
 }
+/**
+ * Check whether the on-disk outputs of each entry still match the hash
+ * the daemon recorded for them. Uses Rayon-parallel filesystem scanning
+ * for uncached entries.
+ */
+function outputsHashesMatchBatch(entries) {
+    if (disabled)
+        return entries.map(() => false);
+    // Fast path: skip filesystem scan for entries with no recorded hash.
+    // _outputsHashesMatch will return false immediately if the hash isn't
+    // in numberOfExpandedOutputs, so scanning the filesystem is wasted work.
+    const needsScan = [];
+    const results = new Array(entries.length);
+    for (let i = 0; i < entries.length; i++) {
+        if (numberOfExpandedOutputs[entries[i].hash] === undefined) {
+            results[i] = false;
+        }
+        else {
+            needsScan.push(i);
+        }
+    }
+    if (needsScan.length > 0) {
+        // Only scan outputs for entries that have recorded hashes
+        const outputsBatch = needsScan.map((i) => entries[i].outputs);
+        const expandedBatch = (0, native_1.getFilesForOutputsBatch)(workspace_root_1.workspaceRoot, outputsBatch);
+        for (let j = 0; j < needsScan.length; j++) {
+            const expanded = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)(expandedBatch[j]);
+            results[needsScan[j]] = _outputsHashesMatch(expanded, entries[needsScan[j]].hash);
+        }
+    }
+    return results;
+}
+/**
+ * Record the hash of each entry's on-disk outputs so future
+ * outputsHashesMatchBatch calls can skip redundant cache copies.
+ * Uses Rayon-parallel filesystem scanning.
+ */
+function recordOutputsHashBatch(entries) {
+    if (disabled)
+        return;
+    const outputsBatch = entries.map((e) => e.outputs);
+    const expandedBatch = (0, native_1.getFilesForOutputsBatch)(workspace_root_1.workspaceRoot, outputsBatch);
+    for (let i = 0; i < entries.length; i++) {
+        const expanded = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)(expandedBatch[i]);
+        _recordOutputsHash(expanded, entries[i].hash);
+    }
+}
 function disableOutputsTracking() {
     disabled = true;
 }

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

@@ -1,6 +1,6 @@
 import { FileData, FileMap, ProjectGraph } from '../../config/project-graph';
-import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { NxWorkspaceFilesExternals } from '../../native';
+import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 interface SerializedProjectGraph {
     error: Error | null;
@@ -24,4 +24,5 @@ export declare let currentSourceMaps: ConfigurationSourceMaps | undefined;
 export declare function getCachedSerializedProjectGraphPromise(): Promise<SerializedProjectGraph>;
 export declare function addUpdatedAndDeletedFiles(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
 export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, error: Error | null) => void): void;
+export declare function invalidateGraphCache(): void;
 export {};

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

@@ -4,22 +4,23 @@ exports.currentSourceMaps = exports.currentProjectGraph = exports.currentProject
 exports.getCachedSerializedProjectGraphPromise = getCachedSerializedProjectGraphPromise;
 exports.addUpdatedAndDeletedFiles = addUpdatedAndDeletedFiles;
 exports.registerProjectGraphRecomputationListener = registerProjectGraphRecomputationListener;
+exports.invalidateGraphCache = invalidateGraphCache;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
 const build_project_graph_1 = require("../../project-graph/build-project-graph");
+const error_types_1 = require("../../project-graph/error-types");
 const file_map_utils_1 = require("../../project-graph/file-map-utils");
 const nx_deps_cache_1 = require("../../project-graph/nx-deps-cache");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
-const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
+const logger_1 = require("../logger");
 const file_change_events_1 = require("./file-watching/file-change-events");
+const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
-const logger_1 = require("../logger");
-const error_types_1 = require("../../project-graph/error-types");
-const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 let cachedSerializedProjectGraphPromise;
 // Maps file path to a version counter that increments on each modification.
 // This lets us detect mid-flight re-modifications when clearing processed files.
@@ -86,9 +87,16 @@ async function getCachedSerializedProjectGraphPromise() {
             const writeFn = graphWasRecomputed ? nx_deps_cache_1.writeCache : nx_deps_cache_1.writeCacheIfStale;
             writeFn(result.projectFileMapCache, result.projectGraph, result.sourceMaps, errors);
         }
+        if (errors?.length) {
+            cachedSerializedProjectGraphPromise = null;
+        }
         return result;
     }
     catch (e) {
+        // We return the project graph, but we don't want to persist the cache to
+        // serve the same state, as it could cause issues if the error is caused by something
+        // transient
+        cachedSerializedProjectGraphPromise = null;
         return {
             error: e,
             serializedProjectGraph: null,
@@ -180,6 +188,14 @@ async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes,
         throw e;
     }
 }
+function invalidateGraphCache() {
+    // Clear the cached promise so the next request triggers a fresh computation.
+    // We intentionally do NOT call getCachedSerializedProjectGraphPromise() here
+    // because assigning its return Promise to the module-level variable causes a
+    // deadlock: the async function resumes, sees the variable is non-null (pointing
+    // at its own Promise), takes the "reuse" branch, and awaits itself forever.
+    cachedSerializedProjectGraphPromise = null;
+}
 async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
     const myGeneration = ++recomputationGeneration;
     // Helper to check if this recomputation is stale (a newer one has started)