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

package/dist/src/core/graph/runtime.js

@@ -1 +1 @@
-(()=>{"use strict";var e,r={},t={};function n(e){var o=t[e];if(void 0!==o)return o.exports;var i=t[e]={exports:{}};return r[e](i,i.exports,n),i.exports}n.m=r,e=[],n.O=(r,t,o,i)=>{if(!t){var a=1/0;for(c=0;c<e.length;c++){for(var[t,o,i]=e[c],l=!0,u=0;u<t.length;u++)(!1&i||a>=i)&&Object.keys(n.O).every(e=>n.O[e](t[u]))?t.splice(u--,1):(l=!1,i<a&&(a=i));if(l){e.splice(c--,1);var f=o();void 0!==f&&(r=f)}}return r}i=i||0;for(var c=e.length;c>0&&e[c-1][2]>i;c--)e[c]=e[c-1];e[c]=[t,o,i]},n.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return n.d(r,{a:r}),r},n.d=(e,r)=>{for(var t in r)n.o(r,t)&&!n.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},n.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),n.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},(()=>{var e={121:0};n.O.j=r=>0===e[r];var r=(r,t)=>{var o,i,[a,l,u]=t,f=0;if(a.some(r=>0!==e[r])){for(o in l)n.o(l,o)&&(n.m[o]=l[o]);if(u)var c=u(n)}for(r&&r(t);f<a.length;f++)i=a[f],n.o(e,i)&&e[i]&&e[i][0](),e[i]=0;return n.O(c)},t=self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[];t.forEach(r.bind(null,0)),t.push=r.bind(null,t.push.bind(t))})()})();
+(()=>{"use strict";var e={};const r={};function t(n){const o=r[n];if(void 0!==o)return o.exports;const i=r[n]={exports:{}};return e[n](i,i.exports,t),i.exports}t.m=e,(()=>{const e=[];t.O=(r,n,o,i)=>{if(n){i=i||0;for(var l=e.length;l>0&&e[l-1][2]>i;l--)e[l]=e[l-1];return void(e[l]=[n,o,i])}let a=1/0;for(l=0;l<e.length;l++){let[n,o,i]=e[l],u=!0;for(var c=0;c<n.length;c++)(!1&i||a>=i)&&Object.keys(t.O).every(e=>t.O[e](n[c]))?n.splice(c--,1):(u=!1,i<a&&(a=i));if(u){e.splice(l--,1);const t=o();void 0!==t&&(r=t)}}return r}})(),t.n=e=>{const r=e&&e.__esModule?()=>e.default:()=>e;return t.d(r,{a:r}),r},t.d=(e,r)=>{if(Array.isArray(r))for(var n=0;n<r.length;){var o=r[n++],i=r[n++];t.o(e,o)?0===i&&n++:0===i?Object.defineProperty(e,o,{enumerable:!0,value:r[n++]}):Object.defineProperty(e,o,{enumerable:!0,get:i})}else for(var o in r)t.o(r,o)&&!t.o(e,o)&&Object.defineProperty(e,o,{enumerable:!0,get:r[o]})},t.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),t.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),t.r=e=>{Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},t.dn=e=>{var r=Object.getOwnPropertyDescriptor(e,"name");(!r||!r.writable&&r.configurable)&&Object.defineProperty(e,"name",{value:"default",configurable:!0})},(()=>{const e={121:0};t.O.j=r=>0===e[r];const r=(r,n)=>{let[o,i,l]=n;var a,c,u=0;if(o.some(r=>0!==e[r])){for(a in i)t.o(i,a)&&(t.m[a]=i[a]);if(l)var f=l(t)}for(r&&r(n);u<o.length;u++)c=o[u],t.o(e,c)&&e[c]&&e[c][0](),e[c]=0;return t.O(f)},n=self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[];n.forEach(r.bind(null,0)),n.push=r.bind(null,n.push.bind(n))})()})();

package/dist/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[]).push([[869],{1296(){}},e=>{var n;n=1296,e(e.s=n)}]);
+"use strict";(self.webpackChunk_nx_graph_client=self.webpackChunk_nx_graph_client||[]).push([[869],{4091(){}},e=>{var n;n=4091,e(e.s=n)}]);

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

@@ -1,12 +1,17 @@
 import { ChildProcess } from 'child_process';
 import { FileData, ProjectGraph } from '../../config/project-graph';
 import { Task, TaskGraph } from '../../config/task-graph';
+import type { UltracacheConfigurationVersion } from '../message-types/ultracache-configuration-version';
 import { Hash } from '../../hasher/task-hasher';
-import { NxWorkspaceFiles, TaskRun, TaskTarget } from '../../native';
-import { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import { NxWorkspaceFiles, TaskOutputs, TaskRun, TaskTarget } from '../../native';
+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';
+import { type SelectAffectedTasksResponse } from '../message-types/select-affected-tasks';
+import type { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
+import type { NxPluginCapabilities } from '../../project-graph/plugins/nx-plugin-capabilities';
 import { type NxConsoleStatusResponse, type SetNxConsolePreferenceAndInstallResponse } from '../message-types/nx-console';
 /** A refused connect: the errno, and the path it was made against. */
 type ConnectRefusal = {
@@ -56,7 +61,8 @@ export declare class DaemonClient {
         sourceMaps: ConfigurationSourceMaps;
     }>;
     getAllFileData(): Promise<FileData[]>;
-    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean, ultracacheConfigurationsVersion?: UltracacheConfigurationVersion): Promise<Hash[]>;
+    hashTasksUpfront(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean, ultracacheConfigurationsVersion?: UltracacheConfigurationVersion): Promise<Record<string, Hash>>;
     registerFileWatcher(config: {
         watchProjects: string[] | 'all';
         includeGlobalWorkspaceFiles?: boolean;
@@ -74,10 +80,7 @@ export declare class DaemonClient {
     } | null) => void): Promise<UnregisterCallback>;
     private reconnectProjectGraphListener;
     processInBackground(requirePath: string, data: any): Promise<any>;
-    recordOutputsHashBatch(entries: {
-        outputs: string[];
-        hash: string;
-    }[]): Promise<any>;
+    recordOutputsHashBatch(entries: TaskOutputs[]): Promise<any>;
     outputsHashesMatchBatch(entries: {
         outputs: string[];
         hash: string;
@@ -98,9 +101,12 @@ export declare class DaemonClient {
         globalGenerators: string[];
         taskGenerators: string[];
     }>;
+    getPluginCapabilities(): Promise<NxPluginCapabilities[]>;
+    /** Selection runs where hashing does, so the plans it builds are reused. */
+    selectAffectedTasks(request: AffectedTasksRequest): Promise<SelectAffectedTasksResponse>;
     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");
@@ -34,6 +35,8 @@ 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 select_affected_tasks_1 = require("../message-types/select-affected-tasks");
 const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
 const hash_glob_1 = require("../message-types/hash-glob");
 const nx_console_1 = require("../message-types/nx-console");
@@ -74,6 +77,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
@@ -200,24 +211,28 @@ class DaemonClient {
     async getAllFileData() {
         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;
-        }
+    hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurationsVersion) {
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
             perTaskEnvs,
-            tasks: tasks.map((t) => trimmedTasks[t.id]),
-            taskGraph: { ...taskGraph, tasks: trimmedTasks },
+            ...withoutTaskResults(tasks, taskGraph),
+            cwd,
+            collectInputs,
+            // An External cannot cross the socket: the version names the stored set
+            // to hash from. Absent means native hashing.
+            ultracacheConfigurationsVersion,
+        });
+    }
+    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs, ultracacheConfigurationsVersion) {
+        return this.sendToDaemonViaQueue({
+            type: 'HASH_TASKS_UPFRONT',
+            runnerOptions,
+            perTaskEnvs,
+            ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
+            ultracacheConfigurationsVersion,
         });
     }
     async registerFileWatcher(config, callback) {
@@ -709,6 +724,20 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    getPluginCapabilities() {
+        const message = {
+            type: get_plugin_capabilities_1.GET_PLUGIN_CAPABILITIES,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    /** Selection runs where hashing does, so the plans it builds are reused. */
+    selectAffectedTasks(request) {
+        const message = {
+            type: select_affected_tasks_1.SELECT_AFFECTED_TASKS,
+            request,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
         const message = {
             type: update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT,

package/dist/src/daemon/message-types/get-plugin-capabilities.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_PLUGIN_CAPABILITIES: 'GET_PLUGIN_CAPABILITIES';
+export type HandleGetPluginCapabilitiesMessage = {
+    type: typeof GET_PLUGIN_CAPABILITIES;
+};
+export declare function isHandleGetPluginCapabilitiesMessage(message: unknown): message is HandleGetPluginCapabilitiesMessage;

package/dist/src/daemon/message-types/get-plugin-capabilities.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_PLUGIN_CAPABILITIES = void 0;
+exports.isHandleGetPluginCapabilitiesMessage = isHandleGetPluginCapabilitiesMessage;
+exports.GET_PLUGIN_CAPABILITIES = 'GET_PLUGIN_CAPABILITIES';
+function isHandleGetPluginCapabilitiesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_PLUGIN_CAPABILITIES);
+}

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/message-types/select-affected-tasks.d.ts

@@ -0,0 +1,21 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import type { TaskGraph } from '../../config/task-graph';
+import type { TaskSelection } from '../../tasks-runner/run-command';
+import type { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
+import type { InternedExplanation } from '../../project-graph/affected/affected-reasons';
+export declare const SELECT_AFFECTED_TASKS: 'SELECT_AFFECTED_TASKS';
+export type HandleSelectAffectedTasksMessage = {
+    type: typeof SELECT_AFFECTED_TASKS;
+    request: AffectedTasksRequest;
+};
+export type SelectAffectedTasksResponse = {
+    /** The graph selection ran against, for the command to run with. */
+    projectGraph: ProjectGraph;
+    affectedTaskIds: string[];
+    taskGraph: TaskGraph;
+    /** Without a planning context: the plans stay in the daemon. */
+    taskSelection: TaskSelection;
+    /** Interned, so it stays small on the wire; the client hydrates it. */
+    explanation?: InternedExplanation;
+};
+export declare function isHandleSelectAffectedTasksMessage(message: unknown): message is HandleSelectAffectedTasksMessage;

package/dist/src/daemon/message-types/select-affected-tasks.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECT_AFFECTED_TASKS = void 0;
+exports.isHandleSelectAffectedTasksMessage = isHandleSelectAffectedTasksMessage;
+exports.SELECT_AFFECTED_TASKS = 'SELECT_AFFECTED_TASKS';
+function isHandleSelectAffectedTasksMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.SELECT_AFFECTED_TASKS);
+}

package/dist/src/daemon/message-types/ultracache-configuration-version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * One stored version of a commit's Ultracache configurations: what crosses
+ * the socket in place of the handle.
+ */
+export interface UltracacheConfigurationVersion {
+    commit: string;
+    fetchedAt: number;
+}

package/dist/src/daemon/message-types/ultracache-configuration-version.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/daemon/server/dotenv-graph-changes.d.ts

@@ -16,7 +16,7 @@ export interface DotEnvChangeClassification {
  *
  * Only the workspace root and project roots invalidate: getEnvPathsForTask
  * loads dotenv files from those, never from an arbitrary subdirectory (e.g. one
- * under node_modules), and the outputs watcher spans the whole workspace root.
+ * under node_modules), and the raw-event stream spans the whole workspace root.
  * An unclassified event is not necessarily irrelevant, though: the graph it was
  * classified against can predate the file's project root (none is committed
  * during the initial computation, and a replaced graph lacks a project that

package/dist/src/daemon/server/dotenv-graph-changes.js

@@ -34,7 +34,7 @@ function isDotEnvName(name) {
  *
  * Only the workspace root and project roots invalidate: getEnvPathsForTask
  * loads dotenv files from those, never from an arbitrary subdirectory (e.g. one
- * under node_modules), and the outputs watcher spans the whole workspace root.
+ * under node_modules), and the raw-event stream spans the whole workspace root.
  * An unclassified event is not necessarily irrelevant, though: the graph it was
  * classified against can predate the file's project root (none is committed
  * during the initial computation, and a replaced graph lacks a project that
@@ -138,7 +138,7 @@ function isDotEnvUnderRoot(path, roots) {
 }
 // Paths of dotenv-shaped events whose graph refresh is not provably scheduled:
 // paths under no known root on arrival (the next graph may know the root) and
-// edits to tracked files (the workspace watcher schedules the refresh, but a
+// edits to tracked files (the file-change stream schedules the refresh, but a
 // computation already in flight may have read the file before the edit). Each
 // maps to the recomputation generation current at queue time, so the pre-serve
 // replay can prove whether a computation started before the event arrived.

package/dist/src/daemon/server/handle-get-plugin-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetPluginCapabilities(): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-get-plugin-capabilities.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetPluginCapabilities = handleGetPluginCapabilities;
+const nx_json_1 = require("../../config/nx-json");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleGetPluginCapabilities() {
+    const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot);
+    return {
+        response: plugins.map((plugin) => plugin.capabilities()),
+        description: 'handleGetPluginCapabilities',
+    };
+}

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

@@ -1,12 +1,20 @@
 import { Task, TaskGraph } from '../../config/task-graph';
-export declare function handleHashTasks(payload: {
+import type { UltracacheConfigurationVersion } from '../message-types/ultracache-configuration-version';
+interface HashTasksPayload {
     runnerOptions: any;
     tasks: Task[];
     taskGraph: TaskGraph;
     perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
     cwd: string;
     collectInputs?: boolean;
-}): Promise<{
+    ultracacheConfigurationsVersion?: UltracacheConfigurationVersion;
+}
+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,16 +1,19 @@
 "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");
+const ultracache_configuration_state_1 = require("./ultracache-configuration-state");
+const planning_context_1 = require("./planning-context");
 /**
  * We use this not to recreated hasher for every hash operation
  * TaskHasher has a cache inside, so keeping it around results in faster performance
  */
 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 +21,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, (0, planning_context_1.planningContextFor)(projectGraph, nxJson));
     }
-    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, (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(payload.ultracacheConfigurationsVersion));
     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, (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(payload.ultracacheConfigurationsVersion));
+    return {
+        response,
+        description: 'handleHashTasksUpfront',
+    };
+}

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

@@ -0,0 +1,3 @@
+import { AffectedTasksRequest } from '../../project-graph/affected/affected-tasks';
+import type { HandlerResult } from './server';
+export declare function handleSelectAffectedTasks(request: AffectedTasksRequest): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-select-affected-tasks.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSelectAffectedTasks = handleSelectAffectedTasks;
+const configuration_1 = require("../../config/configuration");
+const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
+const ultracache_configuration_state_1 = require("./ultracache-configuration-state");
+const planning_context_1 = require("./planning-context");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleSelectAffectedTasks(request) {
+    const { error, projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    if (error) {
+        throw error;
+    }
+    const nxJson = (0, configuration_1.readNxJson)();
+    const selection = await (0, affected_tasks_1.selectAffectedTasks)(projectGraph, nxJson, (0, planning_context_1.planningContextFor)(projectGraph, nxJson), request, {
+        ultracacheConfigurations: (0, ultracache_configuration_state_1.getUltracacheConfigurationsForVersion)(request.ultracacheConfigurationsVersion),
+    });
+    const response = {
+        projectGraph,
+        affectedTaskIds: [...selection.affectedTaskIds],
+        taskGraph: selection.taskGraph,
+        taskSelection: selection.taskSelection,
+        explanation: selection.explanation,
+    };
+    return { response, description: 'handleSelectAffectedTasks' };
+}

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/{handle-outputs-changes.d.ts → handle-watch-events.d.ts}

@@ -1,10 +1,10 @@
-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
+ * The error a native watch failure delivered, if one has. Such an
  * error is terminal (the native watch loop exits after delivering it), so the
  * gitignored dotenv edits only that watcher reports stop arriving and a warm
  * graph would go stale silently. The server fails requests closed on it, like
  * a workspace watcher error.
  */
-export declare function getOutputsWatcherTerminalError(): Error | undefined;
-export declare const handleOutputsChanges: FileWatcherCallback;
+export declare function getWatchTerminalError(): Error | undefined;
+export declare const handleWatchEvents: WatchEventsListener;

package/dist/src/daemon/server/{handle-outputs-changes.js → handle-watch-events.js}

@@ -1,31 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleOutputsChanges = void 0;
-exports.getOutputsWatcherTerminalError = getOutputsWatcherTerminalError;
+exports.handleWatchEvents = void 0;
+exports.getWatchTerminalError = getWatchTerminalError;
 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");
-let outputsWatcherError;
-let outputsWatcherTerminalError;
+const workspace_root_1 = require("../../utils/workspace-root");
+const workspace_context_1 = require("../../utils/workspace-context");
+let watchTerminalError;
 /**
- * The error a native outputs watcher failure delivered, if one has. Such an
+ * The error a native watch failure delivered, if one has. Such an
  * error is terminal (the native watch loop exits after delivering it), so the
  * gitignored dotenv edits only that watcher reports stop arriving and a warm
  * graph would go stale silently. The server fails requests closed on it, like
  * a workspace watcher error.
  */
-function getOutputsWatcherTerminalError() {
-    return outputsWatcherTerminalError;
+function getWatchTerminalError() {
+    return watchTerminalError;
 }
-const handleOutputsChanges = async (err, changeEvents) => {
+const handleWatchEvents = async (err, changeEvents) => {
     try {
         if (err || !changeEvents || !changeEvents.length) {
             let error = typeof err === 'string' ? new Error(err) : err;
-            logger_1.serverLogger.watcherLog('Unexpected outputs watcher error', error.message);
+            logger_1.serverLogger.watcherLog('Unexpected watch error', error.message);
             console.error(error);
-            outputsWatcherError = error;
-            (0, outputs_tracking_1.disableOutputsTracking)();
             if (err) {
                 // A native error is terminal: the watch loop has exited, so the
                 // gitignored dotenv edits only this watcher reports stop arriving and
@@ -34,32 +32,40 @@ const handleOutputsChanges = async (err, changeEvents) => {
                 // that silently goes stale. The original error is preserved so an
                 // inotify_add_watch failure still makes the client disable the daemon
                 // and rebuild without it.
-                outputsWatcherTerminalError = error;
+                watchTerminalError = error;
             }
             return;
         }
+        if (changeEvents.some((event) => event.type === 'rescan')) {
+            // Dropped events cannot be classified: any gitignored dotenv file may
+            // have changed unseen. Recorded outputs are compared by stamp, so they
+            // need nothing.
+            logger_1.serverLogger.watcherLog('The watch reported dropped events; invalidating the graph cache.');
+            (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
-        // disabled outputs tracker must not leave the graph stale on a dotenv edit.
-        // A change to a file the workspace watcher tracks already schedules a
-        // recomputation that reads the new content; invalidating for it here too
-        // would discard that recomputation at commit and force a second one. It is
-        // queued instead of dropped: the two watchers deliver independently, so a
+        // createNodes re-resolves config reading process.env. A change to a file
+        // the file-change stream covers already schedules a recomputation that
+        // reads the new content; invalidating for it here too would discard that
+        // recomputation at commit and force a second one. It is
+        // queued instead of dropped: the two streams 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
-        // here cannot trip the outputs-tracking kill switch below, which belongs
-        // to an unrelated subsystem, and it fails safe by invalidating: a stale
+        // 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 fails safe by invalidating: a stale
         // graph on a dotenv edit is the bug this prevents.
         try {
             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)();
@@ -70,17 +76,10 @@ const handleOutputsChanges = async (err, changeEvents) => {
             console.error(e);
             (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
         }
-        if (outputsWatcherError) {
-            return;
-        }
-        logger_1.serverLogger.watcherLog('Processing file changes in outputs');
-        (0, outputs_tracking_1.processFileChangesInOutputs)(changeEvents);
     }
     catch (err) {
-        logger_1.serverLogger.watcherLog(`Unexpected outputs watcher error`, err.message);
+        logger_1.serverLogger.watcherLog(`Unexpected watch error`, err.message);
         console.error(err);
-        outputsWatcherError = err;
-        (0, outputs_tracking_1.disableOutputsTracking)();
     }
 };
-exports.handleOutputsChanges = handleOutputsChanges;
+exports.handleWatchEvents = handleWatchEvents;

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

@@ -1,23 +1,11 @@
-import { WatchEvent } from '../../native';
-export declare function _recordOutputsHash(outputs: string[], hash: string): void;
-export declare function _outputsHashesMatch(outputs: string[], hash: string): boolean;
-export declare function processFileChangesInOutputs(changeEvents: WatchEvent[], now?: number): void;
+import type { TaskOutputs } from '../../native';
 /**
- * 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.
  */
-export declare function outputsHashesMatchBatch(entries: {
-    outputs: string[];
-    hash: string;
-}[]): boolean[];
+export declare function outputsHashesMatchBatch(entries: TaskOutputs[]): boolean[];
 /**
- * Record the hash of each entry's on-disk outputs so future
- * outputsHashesMatchBatch calls can skip redundant cache copies.
- * Uses Rayon-parallel filesystem scanning.
+ * Record each entry's outputs (the files it carries, or else what is on disk)
+ * so future outputsHashesMatchBatch calls can skip redundant cache copies.
  */
-export declare function recordOutputsHashBatch(entries: {
-    outputs: string[];
-    hash: string;
-}[]): void;
-export declare function disableOutputsTracking(): void;
+export declare function recordOutputsHashBatch(entries: TaskOutputs[]): void;