@depup/nx 23.2.1-depup.8 → 23.3.0-depup.0

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

@@ -1,120 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
-const collapse_expanded_outputs_1 = require("../../utils/collapse-expanded-outputs");
+const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
-let disabled = false;
-const dirsContainingOutputs = {};
-const recordedHashes = {};
-const timestamps = {};
-const numberOfExpandedOutputs = {};
-function _recordOutputsHash(outputs, hash) {
-    numberOfExpandedOutputs[hash] = outputs.length;
-    for (const output of outputs) {
-        recordedHashes[output] = hash;
-        timestamps[output] = new Date().getTime();
-        let current = output;
-        while (current != (0, path_1.dirname)(current)) {
-            if (!dirsContainingOutputs[current]) {
-                dirsContainingOutputs[current] = new Set();
-            }
-            dirsContainingOutputs[current].add(output);
-            current = (0, path_1.dirname)(current);
-        }
-    }
-}
-function _outputsHashesMatch(outputs, hash) {
-    if (outputs.length !== numberOfExpandedOutputs[hash]) {
-        return false;
-    }
-    else {
-        for (const output of outputs) {
-            if (recordedHashes[output] !== hash) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-function processFileChangesInOutputs(changeEvents, now = undefined) {
-    if (!now) {
-        now = new Date().getTime();
-    }
-    for (let e of changeEvents) {
-        let current = e.path;
-        // the path is either an output itself or a parent
-        if (dirsContainingOutputs[current]) {
-            dirsContainingOutputs[current].forEach((output) => {
-                if (now - timestamps[output] > 2000) {
-                    recordedHashes[output] = undefined;
-                }
-            });
-            continue;
-        }
-        // the path is a child of some output or unrelated
-        while (current != (0, path_1.dirname)(current)) {
-            if (recordedHashes[current] && now - timestamps[current] > 2000) {
-                recordedHashes[current] = undefined;
-                break;
-            }
-            current = (0, path_1.dirname)(current);
-        }
-    }
-}
 /**
- * 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.
+ * Whether the on-disk outputs of each entry are still what the daemon
+ * recorded for its hash, so the cache copy can be skipped.
  */
 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;
+    return (0, workspace_context_1.outputsUnchangedInContext)(workspace_root_1.workspaceRoot, entries);
 }
 /**
- * Record the hash of each entry's on-disk outputs so future
- * outputsHashesMatchBatch calls can skip redundant cache copies.
- * Uses Rayon-parallel filesystem scanning.
+ * Record each entry's outputs (the files it carries, or else what is on disk)
+ * so future outputsHashesMatchBatch calls can skip redundant cache copies.
  */
 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;
+    (0, workspace_context_1.recordOutputsInContext)(workspace_root_1.workspaceRoot, entries);
 }

package/dist/src/daemon/server/planning-context.d.ts

@@ -0,0 +1,8 @@
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { ProjectGraph } from '../../config/project-graph';
+import { TaskPlanningContext } from '../../hasher/task-planning-context';
+/**
+ * One planner per daemon project graph, shared by affected selection and task
+ * hashing, so hashing reuses the plans selection made.
+ */
+export declare function planningContextFor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): TaskPlanningContext;

package/dist/src/daemon/server/planning-context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planningContextFor = planningContextFor;
+const task_planning_context_1 = require("../../hasher/task-planning-context");
+let stored = null;
+/**
+ * One planner per daemon project graph, shared by affected selection and task
+ * hashing, so hashing reuses the plans selection made.
+ */
+function planningContextFor(projectGraph, nxJson) {
+    if (stored?.projectGraph !== projectGraph) {
+        stored = {
+            projectGraph,
+            context: (0, task_planning_context_1.createTaskPlanningContext)(projectGraph, nxJson),
+        };
+    }
+    return stored.context;
+}

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 file-change stream 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
@@ -146,8 +148,8 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         // separates them.
         await new Promise(setImmediate);
         // The queue can hold evidence against the settled cached graph itself: a
-        // tracked dotenv edit only the outputs watcher has delivered yet queues
-        // without invalidating, and the workspace watcher's recomputation may lag
+        // tracked dotenv edit only the raw-event stream has delivered yet queues
+        // without invalidating, and the file-change stream's recomputation may lag
         // this request. Classified against the exact graph the cache serves; an
         // in-flight computation needs no check here because its own pre-serve
         // replay consumes the queue. Content hashes are dropped before the
@@ -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 file-change stream 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;
@@ -508,8 +540,8 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // against the graph about to be served. Runs after the last staleness
         // gate so a stale compute leaves the queue for its successor, and only
         // on the success path: an error result is never notified or persisted.
-        // Queue evidence is decisive here even for files the workspace watcher
-        // tracks: the two watchers deliver independently, so tracking alone does
+        // Queue evidence is decisive here even for files the file-change stream
+        // covers: the two streams deliver independently, so tracking alone does
         // not prove that watcher's recomputation was already scheduled.
         let staleDotEnv;
         try {
@@ -556,7 +588,7 @@ function persistProjectGraphToDisk(result) {
         !result.sourceMaps) {
         return;
     }
-    (0, nx_deps_cache_1.writeCache)(result.projectFileMapCache, result.projectGraph, result.sourceMaps, extractErrors(result.error));
+    (0, nx_deps_cache_1.writeCache)(result.projectFileMapCache, result.projectGraph, result.sourceMaps, extractErrors(result.error), Date.now());
     cacheHasBeenPersisted = true;
 }
 function copyFileData(d) {
@@ -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;

package/dist/src/daemon/server/restart-checks.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeServerProcess = void 0;
+exports.registerDaemonForRestartChecks = registerDaemonForRestartChecks;
+exports.fileNames = fileNames;
+exports.changedPaths = changedPaths;
+exports.restartDaemonIfIgnoreFilesChanged = restartDaemonIfIgnoreFilesChanged;
+exports.stopDaemonIfReplaced = stopDaemonIfReplaced;
+const path_1 = require("path");
+const path_2 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const cache_1 = require("../cache");
+const shutdown_utils_1 = require("./shutdown-utils");
+// Kept apart from server.ts: the recomputation module needs these, and
+// importing server.ts starts a server.
+let daemon;
+function registerDaemonForRestartChecks(server, sockets) {
+    daemon = { server, sockets };
+}
+/**
+ * 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.
+ */
+exports.relativeServerProcess = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, cache_1.serverProcessJsonPath));
+/** The paths out of a list of files and their hashes. */
+function fileNames(files) {
+    return files.map(({ file }) => file);
+}
+function changedPaths(batch) {
+    return [
+        ...fileNames(batch.createdFiles),
+        ...fileNames(batch.updatedFiles),
+        ...batch.deletedFiles,
+    ];
+}
+// Mirrors the per-directory ignore files create_filter reads (watch_filterer.rs).
+// The sources it honours that cannot trigger a restart from here — because they
+// are never watched — only take effect on the next daemon start: .git/info/exclude
+// (under the hardcoded-ignored .git), the global core.excludesFile (outside the
+// tree), and parent .gitignore files above the workspace root.
+const IGNORE_FILE_NAMES = ['.gitignore', '.nxignore'];
+/**
+ * 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.
+ */
+function restartDaemonIfIgnoreFilesChanged(paths) {
+    for (const path of paths) {
+        const basename = path.slice(path.lastIndexOf('/') + 1);
+        if (IGNORE_FILE_NAMES.includes(basename)) {
+            stopDaemon('Stopping the daemon the set of ignored files changed (native)');
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Stops this daemon when the events show another process has written the
+ * daemon's process file. True when it stopped the daemon.
+ */
+function stopDaemonIfReplaced(events) {
+    const replaced = events.some((event) => event.path === exports.relativeServerProcess &&
+        (0, cache_1.getDaemonProcessIdSync)() !== process.pid);
+    if (replaced) {
+        stopDaemon('this process is no longer the current daemon (native)');
+    }
+    return replaced;
+}
+function stopDaemon(reason) {
+    if (!daemon)
+        return;
+    (0, shutdown_utils_1.handleServerProcessTermination)({
+        server: daemon.server,
+        reason,
+        sockets: daemon.sockets,
+    });
+}

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

@@ -6,5 +6,6 @@ export type HandlerResult = {
     response?: string | object | boolean;
 };
 export declare const openSockets: Set<Socket>;
+export declare function handleMessage(socket: Socket, data: Buffer): Promise<void>;
 export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>, mode: 'json' | 'v8'): Promise<void>;
 export declare function startServer(): Promise<Server>;