nx 23.3.0-beta.0 → 23.3.0-beta.2

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;
@@ -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.js

@@ -14,7 +14,6 @@ const native_1 = require("../../native");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
 require("../../utils/perf-logging");
 const versions_1 = require("../../utils/versions");
-const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const cache_1 = require("../cache");
 const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
@@ -28,6 +27,7 @@ const get_context_file_data_1 = require("../message-types/get-context-file-data"
 const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const get_plugin_capabilities_1 = require("../message-types/get-plugin-capabilities");
 const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
 const glob_1 = require("../message-types/glob");
 const hash_glob_1 = require("../message-types/hash-glob");
@@ -38,7 +38,6 @@ const task_history_1 = require("../message-types/task-history");
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const socket_utils_1 = require("../socket-utils");
 const file_change_events_1 = require("./file-watching/file-change-events");
-const route_workspace_changes_1 = require("./file-watching/route-workspace-changes");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const handle_configure_ai_agents_1 = require("./handle-configure-ai-agents");
 const handle_context_file_data_1 = require("./handle-context-file-data");
@@ -47,6 +46,7 @@ const handle_force_shutdown_1 = require("./handle-force-shutdown");
 const handle_client_env_1 = require("./handle-client-env");
 const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
 const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
+const handle_get_plugin_capabilities_1 = require("./handle-get-plugin-capabilities");
 const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
 const handle_glob_1 = require("./handle-glob");
 const handle_hash_glob_1 = require("./handle-hash-glob");
@@ -62,10 +62,11 @@ const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks")
 const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
 const handle_outputs_changes_1 = require("./handle-outputs-changes");
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const restart_checks_1 = require("./restart-checks");
 const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
 const shutdown_utils_1 = require("./shutdown-utils");
 const sync_generators_1 = require("./sync-generators");
-const watcher_1 = require("./watcher");
+const workspace_context_1 = require("../../utils/workspace-context");
 let workspaceWatcherError;
 global.NX_DAEMON = true;
 process.env.NX_DAEMON_PROCESS = 'true';
@@ -146,6 +147,9 @@ async function handleMessage(socket, data) {
     else if (payload.type === 'HASH_TASKS') {
         await handleResult(socket, 'HASH_TASKS', () => (0, handle_hash_tasks_1.handleHashTasks)(payload), mode);
     }
+    else if (payload.type === 'HASH_TASKS_UPFRONT') {
+        await handleResult(socket, 'HASH_TASKS_UPFRONT', () => (0, handle_hash_tasks_1.handleHashTasksUpfront)(payload), mode);
+    }
     else if (payload.type === 'PROCESS_IN_BACKGROUND') {
         await handleResult(socket, 'PROCESS_IN_BACKGROUND', () => (0, handle_process_in_background_1.handleProcessInBackground)(payload), mode);
     }
@@ -206,6 +210,9 @@ async function handleMessage(socket, data) {
     else if ((0, get_registered_sync_generators_1.isHandleGetRegisteredSyncGeneratorsMessage)(payload)) {
         await handleResult(socket, get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS, () => (0, handle_get_registered_sync_generators_1.handleGetRegisteredSyncGenerators)(), mode);
     }
+    else if ((0, get_plugin_capabilities_1.isHandleGetPluginCapabilitiesMessage)(payload)) {
+        await handleResult(socket, get_plugin_capabilities_1.GET_PLUGIN_CAPABILITIES, () => (0, handle_get_plugin_capabilities_1.handleGetPluginCapabilities)(), mode);
+    }
     else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
         await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles), mode);
     }
@@ -323,7 +330,7 @@ function lockFileHashChanged() {
  * we need to recompute the cached serialized project graph so that it is readily
  * available for the next client request to the server.
  */
-const handleWorkspaceChanges = async (err, changeEvents) => {
+const handleWorkspaceChanges = (err, batch) => {
     if (workspaceWatcherError) {
         logger_1.serverLogger.watcherLog('Skipping handleWorkspaceChanges because of a previously recorded watcher error.');
         return;
@@ -338,8 +345,7 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
             (0, file_watcher_sockets_1.notifyFileWatcherSocketsOfError)(error);
             return;
         }
-        logger_1.serverLogger.watcherLog((0, watcher_1.convertChangeEventsToLogMessage)(changeEvents));
-        (0, route_workspace_changes_1.routeWorkspaceChanges)(changeEvents);
+        (0, project_graph_incremental_recomputation_1.routeAppliedChanges)(batch);
     }
     catch (err) {
         logger_1.serverLogger.watcherLog(`Unexpected workspace error`, err.message);
@@ -349,14 +355,17 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
     }
 };
 async function startServer() {
-    // Watch before scan: a file written during boot must be visible to the
-    // watcher or the scan below. Scan-first left a blind window where such
-    // files stayed invisible to both until an unrelated change arrived.
-    if (!(0, shutdown_utils_1.getWatcherInstance)()) {
-        (0, shutdown_utils_1.storeWatcherInstance)(await (0, watcher_1.watchWorkspace)(server, handleWorkspaceChanges));
+    // The workspace context owns the daemon's one watch and starts it before
+    // it scans, so a file written during boot is visible to one or the other.
+    if (!(0, workspace_context_1.isWatchingWorkspaceContext)()) {
+        (0, restart_checks_1.registerDaemonForRestartChecks)(server, exports.openSockets);
+        (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot, {
+            watch: true,
+            alwaysWatch: [restart_checks_1.relativeServerProcess],
+        });
+        (0, workspace_context_1.subscribeToWorkspaceChanges)(workspace_root_1.workspaceRoot, handleWorkspaceChanges);
         logger_1.serverLogger.watcherLog(`Subscribed to changes within: ${workspace_root_1.workspaceRoot} (native)`);
     }
-    (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
     // Initialize analytics for daemon process
     await (0, analytics_1.startAnalytics)();
     const socketPath = (0, socket_utils_1.getFullOsSocketPath)();
@@ -434,15 +443,21 @@ async function startServer() {
                     }
                     // this triggers the storage of the lock file hash
                     daemonIsOutdated();
-                    if (!(0, shutdown_utils_1.getOutputWatcherInstance)()) {
-                        (0, shutdown_utils_1.storeOutputWatcherInstance)(await (0, watcher_1.watchOutputFiles)(server, handle_outputs_changes_1.handleOutputsChanges));
-                    }
+                    // Every event the watch delivers, gitignored outputs and dotenv
+                    // files included.
+                    (0, workspace_context_1.subscribeToWatchEvents)(workspace_root_1.workspaceRoot, (err, events) => {
+                        if (!err && events && (0, restart_checks_1.stopDaemonIfReplaced)(events)) {
+                            return;
+                        }
+                        if (err || events?.length) {
+                            (0, handle_outputs_changes_1.handleOutputsChanges)(err, events);
+                        }
+                    });
                     // listen for project graph recomputation events to collect and schedule sync generators
                     (0, project_graph_incremental_recomputation_1.registerProjectGraphRecomputationListener)(sync_generators_1.collectAndScheduleSyncGenerators);
                     // register file change listener to invalidate sync generator cache
                     (0, file_change_events_1.registerFileChangeListener)(sync_generators_1.clearSyncGeneratorsCache);
-                    // trigger an initial project graph recomputation
-                    (0, project_graph_incremental_recomputation_1.scheduleProjectGraphRecomputation)([], [], []);
+                    (0, project_graph_incremental_recomputation_1.scheduleInitialProjectGraphComputation)();
                     // Kick off Nx Console check in background to prime the cache
                     (0, handle_nx_console_1.handleGetNxConsoleStatus)().catch(() => {
                         // Ignore errors, this is a background operation
@@ -454,7 +469,7 @@ async function startServer() {
                     return resolve(server);
                 }
                 catch (err) {
-                    await handleWorkspaceChanges(err, []);
+                    await handleWorkspaceChanges(err, null);
                 }
             });
         }

package/dist/src/daemon/server/shutdown-utils.d.ts

@@ -1,10 +1,5 @@
 import type { Server, Socket } from 'net';
-import type { Watcher } from '../../native';
 export declare const SERVER_INACTIVITY_TIMEOUT_MS: 10800000;
-export declare function storeWatcherInstance(instance: Watcher): void;
-export declare function getWatcherInstance(): Watcher;
-export declare function storeOutputWatcherInstance(instance: Watcher): void;
-export declare function getOutputWatcherInstance(): Watcher;
 interface HandleServerProcessTerminationParams {
     server: Server;
     reason: string;

package/dist/src/daemon/server/shutdown-utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_INACTIVITY_TIMEOUT_MS = void 0;
-exports.storeWatcherInstance = storeWatcherInstance;
-exports.getWatcherInstance = getWatcherInstance;
-exports.storeOutputWatcherInstance = storeOutputWatcherInstance;
-exports.getOutputWatcherInstance = getOutputWatcherInstance;
 exports.handleServerProcessTermination = handleServerProcessTermination;
 exports.handleServerProcessTerminationWithRestart = handleServerProcessTerminationWithRestart;
 exports.resetInactivityTimeout = resetInactivityTimeout;
@@ -15,6 +11,7 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const logger_1 = require("../logger");
 const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
+const workspace_context_1 = require("../../utils/workspace-context");
 const error_types_1 = require("../../project-graph/error-types");
 const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
@@ -61,20 +58,6 @@ async function startNewDaemonInBackground() {
     backgroundProcess.unref();
     logger_1.serverLogger.log('Started new daemon process in background');
 }
-let watcherInstance;
-function storeWatcherInstance(instance) {
-    watcherInstance = instance;
-}
-function getWatcherInstance() {
-    return watcherInstance;
-}
-let outputWatcherInstance;
-function storeOutputWatcherInstance(instance) {
-    outputWatcherInstance = instance;
-}
-function getOutputWatcherInstance() {
-    return outputWatcherInstance;
-}
 async function handleServerProcessTermination({ server, reason, sockets, }) {
     await performShutdown(server, reason, sockets);
 }
@@ -95,14 +78,8 @@ async function performShutdown(server, reason, sockets) {
                 socket.destroy();
             }
         });
-        if (watcherInstance) {
-            await watcherInstance.stop();
-            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (sources)`);
-        }
-        if (outputWatcherInstance) {
-            await outputWatcherInstance.stop();
-            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
-        }
+        (0, workspace_context_1.stopWatchingWorkspaceContext)();
+        logger_1.serverLogger.watcherLog(`Stopping the watch for ${workspace_root_1.workspaceRoot}`);
         (0, cache_1.deleteDaemonJsonProcessCache)();
         (0, get_plugins_1.cleanupPlugins)();
         // Clean up shared latest Nx installation

package/dist/src/hasher/hash-task.js

@@ -31,29 +31,29 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         const customHasher = (0, utils_1.getCustomHasher)(task, projects);
         return { task, customHasher };
     }));
-    const tasksToHash = tasksWithHashers
-        .filter(({ task, customHasher }) => {
-        // If a task has a custom hasher, it might depend on the outputs of other tasks
-        if (customHasher) {
-            return false;
-        }
-        return !(taskGraph.dependencies[task.id].length > 0 &&
-            (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
-    })
+    // Custom hashers can read other tasks' outputs, so they hash at run time,
+    // and so does a task whose own inputs read them. The hasher still decides
+    // for the rest: outputs also arrive through a dependency's named input or
+    // a continuous server, which only planning reveals.
+    const candidates = tasksWithHashers
+        .filter(({ task, customHasher }) => !customHasher &&
+        !readsDependencyOutputs(task, taskGraph, projectGraph, nxJson))
         .map((t) => t.task);
     const perTaskEnvs = {};
-    for (const task of tasksToHash) {
+    for (const task of candidates) {
         perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, projectGraph);
     }
-    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, perTaskEnvs);
+    const hashes = await hasher.hashTasksUpfront(candidates, taskGraph, perTaskEnvs);
+    const tasksToHash = candidates.filter((task) => task.id in hashes);
     const ioService = (0, task_io_service_1.getTaskIOService)();
     const hasInputSubscribers = ioService.hasTaskInputSubscribers();
-    for (let i = 0; i < tasksToHash.length; i++) {
-        tasksToHash[i].hash = hashes[i].value;
-        tasksToHash[i].hashDetails = hashes[i].details;
+    for (const task of tasksToHash) {
+        const hash = hashes[task.id];
+        task.hash = hash.value;
+        task.hashDetails = hash.details;
         // Notify TaskIOService of hash inputs
-        if (hasInputSubscribers && hashes[i].inputs) {
-            ioService.notifyTaskInputs(tasksToHash[i].id, hashes[i].inputs);
+        if (hasInputSubscribers && hash.inputs) {
+            ioService.notifyTaskInputs(task.id, hash.inputs);
         }
     }
     if (tasksDetails?.recordTaskDetails) {
@@ -67,6 +67,10 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
+function readsDependencyOutputs(task, taskGraph, projectGraph, nxJson) {
+    return (taskGraph.dependencies[task.id]?.length > 0 &&
+        (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
+}
 async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);

package/dist/src/hasher/native-task-hasher-impl.d.ts

@@ -2,6 +2,7 @@ import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ExternalObject, FileData, HasherOptions, HashPlanner, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
+import type { IgnoredIndexReader } from '../native';
 import { PartialHash, TaskHasherImpl } from './task-hasher';
 export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     hasher: TaskHasher;
@@ -9,10 +10,17 @@ export declare class NativeTaskHasherImpl implements TaskHasherImpl {
     projectGraphRef: ExternalObject<NativeProjectGraph>;
     allWorkspaceFilesRef: ExternalObject<FileData[]>;
     projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
+    ignoredIndexRef: ExternalObject<IgnoredIndexReader>;
     options: HasherOptions | undefined;
+    /**
+     * Plans of the last up-front batch and the task graph they were built for.
+     * The tasks that batch deferred hash from them later without planning again.
+     */
+    private upfrontPlans;
     constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
         selectivelyHashTsConfig: boolean;
     });
     hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
     hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+    hashTasksUpfront(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Record<string, PartialHash>>;
 }