nx 23.2.1 → 23.3.0-beta.1

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

@@ -3,7 +3,8 @@ import { FileData, ProjectGraph } from '../../config/project-graph';
 import { Task, TaskGraph } from '../../config/task-graph';
 import { Hash } from '../../hasher/task-hasher';
 import { NxWorkspaceFiles, TaskRun, TaskTarget } from '../../native';
-import { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import { PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 import type { FlushSyncGeneratorChangesResult, SyncGeneratorRunResult } from '../../utils/sync-generators';
 import { type ConfigureAiAgentsStatusResponse } from '../message-types/configure-ai-agents';
@@ -57,6 +58,7 @@ export declare class DaemonClient {
     }>;
     getAllFileData(): Promise<FileData[]>;
     hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasksUpfront(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
     registerFileWatcher(config: {
         watchProjects: string[] | 'all';
         includeGlobalWorkspaceFiles?: boolean;
@@ -100,7 +102,7 @@ export declare class DaemonClient {
     }>;
     updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     runPreTasksExecution(context: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
-    runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
+    runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;
     getNxConsoleStatus(): Promise<NxConsoleStatusResponse>;
     setNxConsolePreferenceAndInstall(preference: boolean): Promise<SetNxConsolePreferenceAndInstallResponse>;
     getConfigureAiAgentsStatus(): Promise<ConfigureAiAgentsStatusResponse>;

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

@@ -11,6 +11,7 @@ const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const configuration_1 = require("../../config/configuration");
 const nx_json_1 = require("../../config/nx-json");
+const prune_task_graph_1 = require("../../tasks-runner/prune-task-graph");
 const native_1 = require("../../native");
 const error_types_1 = require("../../project-graph/error-types");
 const typescript_1 = require("../../plugins/js/utils/typescript");
@@ -74,6 +75,14 @@ exports.WatcherFailedError = WatcherFailedError;
  * re-dialing once this many land back to back without a message in between.
  */
 const MAX_CONSECUTIVE_FRAMING_FAILURES = 3;
+// Task results get written back onto these task objects as the run
+// progresses — hash/hashDetails/timestamps by hashing and the orchestrator,
+// terminalOutput by the Nx Cloud life cycle (untyped) — so a later message
+// would otherwise re-ship every earlier result.
+function withoutTaskResults(tasks, taskGraph) {
+    const pruned = (0, prune_task_graph_1.pruneTaskGraph)(taskGraph);
+    return { tasks: tasks.map((t) => pruned.tasks[t.id]), taskGraph: pruned };
+}
 class DaemonClient {
     constructor() {
         // Tracks the spinner owned by the in-flight request so streamed
@@ -201,21 +210,21 @@ class DaemonClient {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
     hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        // Task results get written back onto these task objects as the run
-        // progresses — hash/hashDetails/timestamps by hashing and the
-        // orchestrator, terminalOutput by the Nx Cloud life cycle (untyped) —
-        // so a later message would otherwise re-ship every earlier result.
-        const trimmedTasks = {};
-        for (const [id, t] of Object.entries(taskGraph.tasks)) {
-            const { hash, hashDetails, startTime, endTime, terminalOutput, ...strippedTask } = t;
-            trimmedTasks[id] = strippedTask;
-        }
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
             perTaskEnvs,
-            tasks: tasks.map((t) => trimmedTasks[t.id]),
-            taskGraph: { ...taskGraph, tasks: trimmedTasks },
+            ...withoutTaskResults(tasks, taskGraph),
+            cwd,
+            collectInputs,
+        });
+    }
+    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        return this.sendToDaemonViaQueue({
+            type: 'HASH_TASKS_UPFRONT',
+            runnerOptions,
+            perTaskEnvs,
+            ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
         });

package/dist/src/daemon/message-types/run-tasks-execution-hooks.d.ts

@@ -1,4 +1,5 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins';
+import type { PreTasksExecutionContext } from '../../project-graph/plugins';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 export declare const PRE_TASKS_EXECUTION: 'PRE_TASKS_EXECUTION';
 export declare const POST_TASKS_EXECUTION: 'POST_TASKS_EXECUTION';
 export type HandlePreTasksExecutionMessage = {
@@ -7,7 +8,7 @@ export type HandlePreTasksExecutionMessage = {
 };
 export type HandlePostTasksExecutionMessage = {
     type: typeof POST_TASKS_EXECUTION;
-    context: PostTasksExecutionContext;
+    context: MaybeStubbedPostTasksExecutionContext;
 };
 export declare function isHandlePreTasksExecutionMessage(message: unknown): message is HandlePreTasksExecutionMessage;
 export declare function isHandlePostTasksExecutionMessage(message: unknown): message is HandlePostTasksExecutionMessage;

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

@@ -1,12 +1,18 @@
 import { Task, TaskGraph } from '../../config/task-graph';
-export declare function handleHashTasks(payload: {
+interface HashTasksPayload {
     runnerOptions: any;
     tasks: Task[];
     taskGraph: TaskGraph;
     perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
     cwd: string;
     collectInputs?: boolean;
-}): Promise<{
+}
+export declare function handleHashTasks(payload: HashTasksPayload): Promise<{
     response: import("../../hasher/task-hasher").Hash[];
     description: string;
 }>;
+export declare function handleHashTasksUpfront(payload: HashTasksPayload): Promise<{
+    response: Record<string, import("../../hasher/task-hasher").Hash>;
+    description: string;
+}>;
+export {};

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHashTasks = handleHashTasks;
+exports.handleHashTasksUpfront = handleHashTasksUpfront;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
@@ -10,7 +11,7 @@ const configuration_1 = require("../../config/configuration");
  */
 let storedProjectGraph = null;
 let storedHasher = null;
-async function handleHashTasks(payload) {
+async function getHasher(runnerOptions) {
     const { error, projectGraph, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
     if (error) {
         throw error;
@@ -18,11 +19,23 @@ async function handleHashTasks(payload) {
     const nxJson = (0, configuration_1.readNxJson)();
     if (projectGraph !== storedProjectGraph) {
         storedProjectGraph = projectGraph;
-        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, payload.runnerOptions);
+        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
-    const response = await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    return storedHasher;
+}
+async function handleHashTasks(payload) {
+    const hasher = await getHasher(payload.runnerOptions);
+    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
     return {
         response,
         description: 'handleHashTasks',
     };
 }
+async function handleHashTasksUpfront(payload) {
+    const hasher = await getHasher(payload.runnerOptions);
+    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    return {
+        response,
+        description: 'handleHashTasksUpfront',
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { FileWatcherCallback } from './watcher';
+import { type WatchEventsListener } from '../../utils/workspace-context';
 /**
  * The error a native outputs watcher failure delivered, if one has. Such an
  * error is terminal (the native watch loop exits after delivering it), so the
@@ -7,4 +7,4 @@ import type { FileWatcherCallback } from './watcher';
  * a workspace watcher error.
  */
 export declare function getOutputsWatcherTerminalError(): Error | undefined;
-export declare const handleOutputsChanges: FileWatcherCallback;
+export declare const handleOutputsChanges: WatchEventsListener;

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

@@ -6,6 +6,8 @@ const logger_1 = require("../logger");
 const dotenv_graph_changes_1 = require("./dotenv-graph-changes");
 const outputs_tracking_1 = require("./outputs-tracking");
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const workspace_root_1 = require("../../utils/workspace-root");
+const workspace_context_1 = require("../../utils/workspace-context");
 let outputsWatcherError;
 let outputsWatcherTerminalError;
 /**
@@ -38,6 +40,15 @@ const handleOutputsChanges = async (err, changeEvents) => {
             }
             return;
         }
+        if (changeEvents.some((event) => event.type === 'rescan')) {
+            // Dropped events cannot be classified: any recorded output hash and any
+            // gitignored dotenv file may have changed unseen. Start the tracker
+            // over and invalidate the graph rather than trust either.
+            logger_1.serverLogger.watcherLog('The outputs watcher reported dropped events; clearing recorded output hashes and invalidating the graph cache.');
+            (0, outputs_tracking_1.clearRecordedOutputsHashes)();
+            (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+            return;
+        }
         // A dotenv change that a task chain loads must refresh the graph so
         // createNodes re-resolves config reading process.env. This runs above the
         // outputsWatcherError guard: the two concerns are independent, and a
@@ -47,11 +58,11 @@ const handleOutputsChanges = async (err, changeEvents) => {
         // would discard that recomputation at commit and force a second one. It is
         // queued instead of dropped: the two watchers deliver independently, so a
         // computation already in flight may have read the file before the edit,
-        // and only the pre-serve replay can prove that. The committed file map
-        // approximates what the watcher tracks: a file it does not know is either
-        // gitignored (never reaches the workspace watcher, so it needs the
-        // invalidation) or created since the last recompute (the watcher handles
-        // it; the extra invalidation is fail-safe). Its own try/catch so a fault
+        // and only the pre-serve replay can prove that. The context answers from
+        // the files the watch keeps, so a path it does not hold is gitignored,
+        // already deleted, or not yet ingested, and each of those needs the
+        // invalidation. A missing context answers with nothing, which invalidates
+        // too. Its own try/catch so a fault
         // here cannot trip the outputs-tracking kill switch below, which belongs
         // to an unrelated subsystem, and it fails safe by invalidating: a stale
         // graph on a dotenv edit is the bug this prevents.
@@ -59,7 +70,11 @@ const handleOutputsChanges = async (err, changeEvents) => {
             const { invalidating, unclassified } = (0, dotenv_graph_changes_1.classifyDotEnvChanges)(changeEvents, project_graph_incremental_recomputation_1.currentProjectGraph);
             const generation = (0, project_graph_incremental_recomputation_1.getRecomputationGeneration)();
             (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(unclassified.map((event) => event.path), generation);
-            const knownInvalidating = invalidating.filter((path) => (0, project_graph_incremental_recomputation_1.isKnownWorkspaceFile)(path));
+            // Skips the napi call, which takes the files mutex and can wait out a
+            // re-walk, for the common batch that classifies nothing.
+            const knownInvalidating = invalidating.length
+                ? (0, workspace_context_1.trackedFilesInContext)(workspace_root_1.workspaceRoot, invalidating)
+                : [];
             (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(knownInvalidating, generation);
             if (knownInvalidating.length < invalidating.length) {
                 (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();

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

@@ -1,4 +1,5 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 export declare function handleRunPreTasksExecution(context: PreTasksExecutionContext): Promise<{
     response: NodeJS.ProcessEnv[];
     description: string;
@@ -8,7 +9,7 @@ export declare function handleRunPreTasksExecution(context: PreTasksExecutionCon
     error: any;
     description: string;
 }>;
-export declare function handleRunPostTasksExecution(context: PostTasksExecutionContext): Promise<{
+export declare function handleRunPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<{
     error?: undefined;
     response: string;
     description: string;

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

@@ -20,4 +20,10 @@ export declare function recordOutputsHashBatch(entries: {
     outputs: string[];
     hash: string;
 }[]): void;
+/**
+ * One-shot reset for a watcher rescan: recorded hashes may describe outputs
+ * whose change events were dropped, so none can be trusted. Unlike
+ * `disableOutputsTracking` the tracker keeps running; it just starts over.
+ */
+export declare function clearRecordedOutputsHashes(): void;
 export declare function disableOutputsTracking(): void;

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

@@ -5,6 +5,7 @@ exports._outputsHashesMatch = _outputsHashesMatch;
 exports.processFileChangesInOutputs = processFileChangesInOutputs;
 exports.outputsHashesMatchBatch = outputsHashesMatchBatch;
 exports.recordOutputsHashBatch = recordOutputsHashBatch;
+exports.clearRecordedOutputsHashes = clearRecordedOutputsHashes;
 exports.disableOutputsTracking = disableOutputsTracking;
 const path_1 = require("path");
 const native_1 = require("../../native");
@@ -115,6 +116,23 @@ function recordOutputsHashBatch(entries) {
         _recordOutputsHash(expanded, entries[i].hash);
     }
 }
+/**
+ * One-shot reset for a watcher rescan: recorded hashes may describe outputs
+ * whose change events were dropped, so none can be trusted. Unlike
+ * `disableOutputsTracking` the tracker keeps running; it just starts over.
+ */
+function clearRecordedOutputsHashes() {
+    for (const store of [
+        dirsContainingOutputs,
+        recordedHashes,
+        timestamps,
+        numberOfExpandedOutputs,
+    ]) {
+        for (const key of Object.keys(store)) {
+            delete store[key];
+        }
+    }
+}
 function disableOutputsTracking() {
     disabled = true;
 }

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

@@ -1,6 +1,7 @@
 import { Socket } from 'net';
 import { FileMap, ProjectGraph } from '../../config/project-graph';
 import { NxWorkspaceFilesExternals } from '../../native';
+import type { ChangeBatch } from '../../native';
 import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 interface SerializedProjectGraph {
@@ -20,7 +21,28 @@ export declare let currentProjectFileMapCache: FileMapCache | undefined;
 export declare let currentProjectGraph: ProjectGraph | undefined;
 export declare let currentSourceMaps: ConfigurationSourceMaps | undefined;
 export declare function getCachedSerializedProjectGraphPromise(socket?: Socket): Promise<SerializedProjectGraph>;
+/**
+ * Takes in changes the workspace context handed out: restarts the daemon if
+ * an ignore file changed, otherwise schedules the recomputation.
+ */
+export declare function routeAppliedChanges(batch: ChangeBatch): void;
+/**
+ * Applies everything the workspace watcher has seen and routes what changed.
+ * Call before serving a cached project graph, so a change the watcher already
+ * saw is never missed.
+ */
+export declare function flushPendingWorkspaceChanges(): Promise<void>;
+/**
+ * Applies changes a caller learned of on its own to the workspace context,
+ * then schedules the recomputation as for a batch the context applied.
+ *
+ * The caller is a sync generator, whose writes the watch would report anyway;
+ * this makes them visible before the generator returns rather than by the next
+ * settle. Whether that guarantee is still needed is NXC-4996.
+ */
 export declare function scheduleProjectGraphRecomputation(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
+/** Computes the first project graph, unless one is already on its way. */
+export declare function scheduleInitialProjectGraphComputation(): void;
 export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, error: Error | null) => void): void;
 /**
  * Discards the cached graph when a graph input outside the file watcher's view
@@ -37,11 +59,4 @@ export declare function invalidateGraphCache(): void;
  * event arrived.
  */
 export declare function getRecomputationGeneration(): number;
-/**
- * Whether the ignore-filtered workspace file map knows `path`. The workspace
- * watcher applies the same ignore rules, so a change to a known file also
- * reaches scheduleProjectGraphRecomputation; an unknown file is either
- * ignored, or created since the last recompute committed.
- */
-export declare function isKnownWorkspaceFile(path: string): boolean;
 export {};

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

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.currentSourceMaps = exports.currentProjectGraph = exports.currentProjectFileMapCache = exports.fileMapWithFiles = void 0;
 exports.getCachedSerializedProjectGraphPromise = getCachedSerializedProjectGraphPromise;
+exports.routeAppliedChanges = routeAppliedChanges;
+exports.flushPendingWorkspaceChanges = flushPendingWorkspaceChanges;
 exports.scheduleProjectGraphRecomputation = scheduleProjectGraphRecomputation;
+exports.scheduleInitialProjectGraphComputation = scheduleInitialProjectGraphComputation;
 exports.registerProjectGraphRecomputationListener = registerProjectGraphRecomputationListener;
 exports.invalidateGraphCache = invalidateGraphCache;
 exports.getRecomputationGeneration = getRecomputationGeneration;
-exports.isKnownWorkspaceFile = isKnownWorkspaceFile;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -25,7 +27,7 @@ const dotenv_graph_changes_1 = require("./dotenv-graph-changes");
 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 watcher_1 = require("./watcher");
+const restart_checks_1 = require("./restart-checks");
 const logger_1 = require("../logger");
 let cachedSerializedProjectGraphPromise;
 // Maps file path to a version counter that increments on each modification.
@@ -136,7 +138,7 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         // that already arrived in the watcher's accumulator but hasn't
         // flushed past IDLE_WINDOW yet would be invisible to the staleness
         // check below — the daemon would return a stale graph.
-        await (0, watcher_1.flushPendingWorkspaceChanges)();
+        await flushPendingWorkspaceChanges();
         await resetInternalStateIfNxDepsMissing();
         // Yield one macrotask boundary so any TSFN-queued watcher callbacks
         // run before we read collected*. Without this, an event that left
@@ -222,38 +224,96 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         }
     }
 }
+const SUMMARY_CAP = 10;
+function summarize(files) {
+    if (files.length === 0)
+        return '(none)';
+    const listed = files.slice(0, SUMMARY_CAP).map((f) => `  - ${f}`);
+    if (files.length > SUMMARY_CAP) {
+        listed.push(`  ... and ${files.length - SUMMARY_CAP} more`);
+    }
+    return listed.join('\n');
+}
+/**
+ * Takes in changes the workspace context handed out: restarts the daemon if
+ * an ignore file changed, otherwise schedules the recomputation.
+ */
+function routeAppliedChanges(batch) {
+    if (!(0, workspace_context_1.isEmptyBatch)(batch)) {
+        if ((0, restart_checks_1.restartDaemonIfIgnoreFilesChanged)((0, restart_checks_1.changedPaths)(batch))) {
+            return;
+        }
+        logger_1.serverLogger.watcherLog(`File changes detected (seq ${batch.seq}):\n` +
+            `Created:\n${summarize((0, restart_checks_1.fileNames)(batch.createdFiles))}\n` +
+            `Updated:\n${summarize((0, restart_checks_1.fileNames)(batch.updatedFiles))}\n` +
+            `Deleted:\n${summarize(batch.deletedFiles)}`);
+    }
+    scheduleAppliedChanges(batch);
+}
+/**
+ * Applies everything the workspace watcher has seen and routes what changed.
+ * Call before serving a cached project graph, so a change the watcher already
+ * saw is never missed.
+ */
+async function flushPendingWorkspaceChanges() {
+    if (!(0, workspace_context_1.isWatchingWorkspaceContext)())
+        return;
+    const batch = (0, workspace_context_1.settleWorkspaceContext)(workspace_root_1.workspaceRoot);
+    // An empty settle must not reach the routing: it would schedule the first
+    // graph computation here rather than where the request handler reports it.
+    if ((0, workspace_context_1.isEmptyBatch)(batch)) {
+        return;
+    }
+    routeAppliedChanges(batch);
+}
+/**
+ * Applies changes a caller learned of on its own to the workspace context,
+ * then schedules the recomputation as for a batch the context applied.
+ *
+ * The caller is a sync generator, whose writes the watch would report anyway;
+ * this makes them visible before the generator returns rather than by the next
+ * settle. Whether that guarantee is still needed is NXC-4996.
+ */
 function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFiles) {
+    if (!createdFiles.length && !updatedFiles.length && !deletedFiles.length) {
+        return;
+    }
+    // Hashed once here, not inside the recompute, so a stale retry does not see
+    // "no change" after the first pass already updated the context.
+    perf_hooks_1.performance.mark('hash-reported-changes-start');
+    const batch = (0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles);
+    perf_hooks_1.performance.mark('hash-reported-changes-end');
+    perf_hooks_1.performance.measure('hash reported file changes', 'hash-reported-changes-start', 'hash-reported-changes-end');
+    // A watching context hands every applied change out once, from one place.
+    routeAppliedChanges((0, workspace_context_1.isWatchingWorkspaceContext)()
+        ? (0, workspace_context_1.takeAppliedWorkspaceChanges)(workspace_root_1.workspaceRoot)
+        : batch);
+}
+/**
+ * Schedules a recomputation for changes the workspace context has applied:
+ * no-op rewrites are already dropped, deleted directories expanded, and every
+ * created or updated file carries its hash.
+ */
+function scheduleAppliedChanges(batch) {
     ++fileChangeCounter;
-    // Hash the changed files up front and drop no-op rewrites before they can
-    // trigger an expensive recompute. Restoring a cached task output, a
-    // `git checkout` back to the same content, or a formatter that changes
-    // nothing all rewrite a file (new inode) the watcher reports as changed
-    // even though the bytes are identical. updateFilesInContext updates the
-    // workspace context and returns only the files whose content actually
-    // changed. Hashing here — once per watcher batch — rather than inside the
-    // recompute keeps it off the stale-retry path, which would otherwise see
-    // "no change" after the first pass already updated the context hashes.
-    perf_hooks_1.performance.mark('hash-watched-changes-start');
-    const changedFileHashes = createdFiles.length > 0 ||
-        updatedFiles.length > 0 ||
-        deletedFiles.length > 0
-        ? ((0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles) ?? {})
-        : {};
-    perf_hooks_1.performance.mark('hash-watched-changes-end');
-    perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
-    for (const [f, hash] of Object.entries(changedFileHashes)) {
-        collectedDeletedFiles.delete(f);
-        collectedUpdatedFiles.set(f, { version: fileChangeCounter, hash });
+    const { createdFiles, updatedFiles, deletedFiles } = batch;
+    for (const { file, hash } of [...createdFiles, ...updatedFiles]) {
+        collectedDeletedFiles.delete(file);
+        collectedUpdatedFiles.set(file, { version: fileChangeCounter, hash });
     }
-    for (let f of deletedFiles) {
-        collectedUpdatedFiles.delete(f);
-        collectedDeletedFiles.set(f, fileChangeCounter);
+    for (const file of deletedFiles) {
+        collectedUpdatedFiles.delete(file);
+        collectedDeletedFiles.set(file, fileChangeCounter);
     }
-    // The native watcher already coalesces a burst of events into one batch,
-    // so socket + listener notifications dispatch immediately.
-    if (Object.keys(changedFileHashes).length > 0 || deletedFiles.length > 0) {
-        (0, file_change_events_1.notifyFileChangeListeners)({ createdFiles, updatedFiles, deletedFiles });
-        (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, updatedFiles, deletedFiles);
+    if (!(0, workspace_context_1.isEmptyBatch)(batch)) {
+        const createdFileNames = (0, restart_checks_1.fileNames)(createdFiles);
+        const updatedFileNames = (0, restart_checks_1.fileNames)(updatedFiles);
+        (0, file_change_events_1.notifyFileChangeListeners)({
+            createdFiles: createdFileNames,
+            updatedFiles: updatedFileNames,
+            deletedFiles,
+        });
+        (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFileNames, updatedFileNames, deletedFiles);
         // Bump generation synchronously so any in-flight compute fails its
         // next isStale() check and chains to the newer one. kickOffRecompute
         // would also bump on first resume, but only after its first await —
@@ -262,10 +322,14 @@ function scheduleProjectGraphRecomputation(createdFiles, updatedFiles, deletedFi
         kickOffRecompute();
     }
     else {
-        // First call (initial startup) — no events but we still need a graph.
-        if (!cachedSerializedProjectGraphPromise) {
-            kickOffRecompute();
-        }
+        // Nothing changed, but a daemon with no graph yet still needs one.
+        scheduleInitialProjectGraphComputation();
+    }
+}
+/** Computes the first project graph, unless one is already on its way. */
+function scheduleInitialProjectGraphComputation() {
+    if (!cachedSerializedProjectGraphPromise) {
+        kickOffRecompute();
     }
 }
 function registerProjectGraphRecomputationListener(listener) {
@@ -337,36 +401,6 @@ function invalidateGraphCache() {
 function getRecomputationGeneration() {
     return recomputationGeneration;
 }
-// isKnownWorkspaceFile's membership set, derived lazily from the map object it
-// was built from; every `fileMapWithFiles` write clears it, so a replaced map
-// generation is not retained through the memo.
-let knownWorkspaceFiles;
-let knownWorkspaceFilesSource;
-/**
- * Whether the ignore-filtered workspace file map knows `path`. The workspace
- * watcher applies the same ignore rules, so a change to a known file also
- * reaches scheduleProjectGraphRecomputation; an unknown file is either
- * ignored, or created since the last recompute committed.
- */
-function isKnownWorkspaceFile(path) {
-    if (!exports.fileMapWithFiles) {
-        return false;
-    }
-    if (knownWorkspaceFilesSource !== exports.fileMapWithFiles) {
-        const { projectFileMap, nonProjectFiles } = exports.fileMapWithFiles.fileMap;
-        knownWorkspaceFiles = new Set();
-        for (const { file } of nonProjectFiles) {
-            knownWorkspaceFiles.add(file);
-        }
-        for (const files of Object.values(projectFileMap)) {
-            for (const { file } of files) {
-                knownWorkspaceFiles.add(file);
-            }
-        }
-        knownWorkspaceFilesSource = exports.fileMapWithFiles;
-    }
-    return knownWorkspaceFiles.has(path);
-}
 async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
     const plugins = [
         ...separatedPlugins.specifiedPlugins,
@@ -442,8 +476,6 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // chainToLatest above without touching `fileMapWithFiles`, so they
         // can't clobber a newer compute's write.
         exports.fileMapWithFiles = fileMapUpdate.fileMap;
-        knownWorkspaceFiles = undefined;
-        knownWorkspaceFilesSource = undefined;
         storedWorkspaceConfigHash = fileMapUpdate.configHash;
         if (fileMapUpdate.knownExternalNodes) {
             knownExternalNodes = fileMapUpdate.knownExternalNodes;
@@ -616,8 +648,6 @@ async function resetInternalState() {
     servedGraphState = null;
     servedGraphCandidate = null;
     exports.fileMapWithFiles = undefined;
-    knownWorkspaceFiles = undefined;
-    knownWorkspaceFilesSource = undefined;
     exports.currentProjectFileMapCache = undefined;
     exports.currentProjectGraph = undefined;
     exports.currentSourceMaps = undefined;

package/dist/src/daemon/server/restart-checks.d.ts

@@ -0,0 +1,22 @@
+import type { Server, Socket } from 'net';
+import type { ChangeBatch, FileData, WatchEvent } from '../../native';
+export declare function registerDaemonForRestartChecks(server: Server, sockets: Iterable<Socket>): void;
+/**
+ * The daemon's own process file, workspace-relative. It lives under the
+ * hardcoded-ignored .nx/workspace-data, so the watch admits it explicitly;
+ * that is how a daemon learns it has been replaced.
+ */
+export declare const relativeServerProcess: string;
+/** The paths out of a list of files and their hashes. */
+export declare function fileNames(files: FileData[]): string[];
+export declare function changedPaths(batch: ChangeBatch): string[];
+/**
+ * The watch's ignore rules are fixed when it starts, so an ignore-file edit
+ * needs a daemon restart to take effect. True when it stopped the daemon.
+ */
+export declare function restartDaemonIfIgnoreFilesChanged(paths: string[]): boolean;
+/**
+ * Stops this daemon when the events show another process has written the
+ * daemon's process file. True when it stopped the daemon.
+ */
+export declare function stopDaemonIfReplaced(events: WatchEvent[]): boolean;