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

package/dist/src/project-graph/plugins/isolation/isolated-plugin.js

@@ -20,6 +20,7 @@ const installation_directory_1 = require("../../../utils/installation-directory"
 const is_sandbox_1 = require("../../../utils/is-sandbox");
 const logger_2 = require("../../../utils/logger");
 const progress_topics_1 = require("../../../utils/progress-topics");
+const task_results_stub_1 = require("../task-results-stub");
 const wait_for_socket_connection_1 = require("../../../utils/wait-for-socket-connection");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const resolve_plugin_1 = require("../resolve-plugin");
@@ -43,9 +44,16 @@ class IsolatedPlugin {
         const moduleName = typeof plugin === 'string' ? plugin : plugin.plugin;
         const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
         const instance = new IsolatedPlugin(plugin, root, name, pluginPath, shouldRegisterTSTranspiler, index);
-        const loadResult = await instance.spawnAndConnect();
-        instance.setupHooks(loadResult);
-        return instance;
+        try {
+            const loadResult = await instance.spawnAndConnect();
+            instance.setupHooks(loadResult);
+            return instance;
+        }
+        catch (e) {
+            // A timed-out worker is still running, and the caller is about to drop this instance.
+            instance.shutdown();
+            throw e;
+        }
     }
     constructor(plugin, root, name, pluginPath, shouldRegisterTSTranspiler, index) {
         this.index = index;
@@ -53,6 +61,7 @@ class IsolatedPlugin {
         this.worker = null;
         this.socket = null;
         this._alive = false;
+        this._released = false;
         this._connectPromise = null;
         this.txId = 0;
         this.pendingCount = 0;
@@ -90,6 +99,15 @@ class IsolatedPlugin {
         this.pluginPath = pluginPath;
         this.shouldRegisterTSTranspiler = shouldRegisterTSTranspiler;
     }
+    capabilities() {
+        return {
+            createNodesPattern: this.createNodes?.[0],
+            hasCreateDependencies: !!this.createDependencies,
+            hasCreateMetadata: !!this.createMetadata,
+            hasPreTasksExecution: !!this.preTasksExecution,
+            hasPostTasksExecution: !!this.postTasksExecution,
+        };
+    }
     async spawnAndConnect() {
         const { worker, socket } = await startPluginWorker(this.name);
         this.worker = worker;
@@ -214,7 +232,15 @@ class IsolatedPlugin {
         const shutdown = (hookName) => this.shutdownIfInactive(hookName);
         const wrap = (hook, hookFn) => this.lifecycle.wrapHook(hook, async (...args) => {
             await this.ensureAlive();
-            return hookFn(...args);
+            try {
+                return await hookFn(...args);
+            }
+            finally {
+                // A released plugin still answers, then shuts its worker straight back down.
+                if (this._released) {
+                    shutdown(hook);
+                }
+            }
         }, () => shutdown(hook));
         if (loadResult.createNodesPattern) {
             this.createNodes = [
@@ -268,7 +294,7 @@ class IsolatedPlugin {
         if (loadResult.hasPostTasksExecution) {
             this.postTasksExecution = wrap('postTasksExecution', async (context) => {
                 const result = await this.sendRequest('postTasksExecution', {
-                    context,
+                    context: (0, task_results_stub_1.stubTerminalOutputs)(context),
                 });
                 if (result.success === false) {
                     throw result.error;
@@ -338,8 +364,18 @@ class IsolatedPlugin {
             this.shutdownIfInactive(lastCompletedHook);
         }
     }
+    /**
+     * Like `shutdown`, but for good: a later hook call still answers, then shuts
+     * the worker back down instead of leaving a respawned one running.
+     */
+    dispose() {
+        this._released = true;
+        this.shutdown();
+    }
     shutdown() {
-        if (!this._alive)
+        // Not `_alive`: that is only set once the worker answers a load, so gating
+        // on it would leave a worker that never got that far running.
+        if (!this.worker && !this.socket)
             return;
         this._alive = false;
         this._connectPromise = null;

package/dist/src/project-graph/plugins/isolation/load-isolated-plugin.d.ts

@@ -1,3 +1,12 @@
 import { PluginConfiguration } from '../../../config/nx-json';
 import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-export declare function loadIsolatedNxPlugin(plugin: PluginConfiguration, root: string, index?: number): Promise<[Promise<LoadedNxPlugin>, () => void]>;
+/**
+ * Declares a loader's plugins and disposes any no loader wants. Call before loading.
+ * Anything that makes a running worker unfit for reuse must be in its cache key.
+ */
+export declare function wantPlugins(loader: string, plugins: Array<{
+    plugin: PluginConfiguration;
+    index?: number;
+}>, root: string): void;
+export declare function disposeIsolatedPlugins(): void;
+export declare function loadIsolatedNxPlugin(plugin: PluginConfiguration, root: string, index?: number): Promise<LoadedNxPlugin>;

package/dist/src/project-graph/plugins/isolation/load-isolated-plugin.js

@@ -1,24 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wantPlugins = wantPlugins;
+exports.disposeIsolatedPlugins = disposeIsolatedPlugins;
 exports.loadIsolatedNxPlugin = loadIsolatedNxPlugin;
 const isolated_plugin_1 = require("./isolated-plugin");
-const isolatedPluginCache = (global['isolatedPluginCache'] ??= new Map());
-async function loadIsolatedNxPlugin(plugin, root, index) {
-    const cacheKey = JSON.stringify({ plugin, root });
-    if (isolatedPluginCache.has(cacheKey)) {
-        return [isolatedPluginCache.get(cacheKey), () => { }];
-    }
-    const pluginPromise = isolated_plugin_1.IsolatedPlugin.load(plugin, root, index).catch((err) => {
-        // Remove failed entries from cache so subsequent calls can retry
-        isolatedPluginCache.delete(cacheKey);
+const loadedPlugins = (global['nxLoadedPlugins'] ??= new Map());
+/**
+ * Keys each loader last asked for; a sweep keeps their union. Global like
+ * `loadedPlugins`, or one copy of Nx would sweep another's workers.
+ */
+const wantedBy = (global['nxWantedPlugins'] ??=
+    new Map());
+/**
+ * Declares a loader's plugins and disposes any no loader wants. Call before loading.
+ * Anything that makes a running worker unfit for reuse must be in its cache key.
+ */
+function wantPlugins(loader, plugins, root) {
+    wantedBy.set(loader, new Set(plugins.map(({ plugin, index }) => getCacheKey(plugin, root, index))));
+    sweep();
+}
+function disposeIsolatedPlugins() {
+    wantedBy.clear();
+    sweep();
+}
+function loadIsolatedNxPlugin(plugin, root, index) {
+    const cacheKey = getCacheKey(plugin, root, index);
+    return (loadedPlugins.get(cacheKey) ??
+        register(cacheKey, isolated_plugin_1.IsolatedPlugin.load(plugin, root, index)));
+}
+function register(cacheKey, loading) {
+    const entry = loading.then((plugin) => {
+        // Swept while loading: nothing names it any more.
+        if (!isWanted(cacheKey)) {
+            plugin.dispose();
+        }
+        return plugin;
+    }, (err) => {
+        forget(cacheKey, entry);
         throw err;
     });
-    isolatedPluginCache.set(cacheKey, pluginPromise);
-    const cleanup = async () => {
-        const instancePromise = isolatedPluginCache.get(cacheKey);
-        isolatedPluginCache.delete(cacheKey);
-        const instance = await instancePromise;
-        instance?.shutdown();
-    };
-    return [pluginPromise, cleanup];
+    if (isWanted(cacheKey)) {
+        loadedPlugins.set(cacheKey, entry);
+    }
+    return entry;
+}
+function sweep() {
+    for (const [cacheKey, entry] of [...loadedPlugins]) {
+        if (isWanted(cacheKey)) {
+            continue;
+        }
+        loadedPlugins.delete(cacheKey);
+        entry.then((plugin) => plugin.dispose(), 
+        // No worker to dispose; the caller reports the rejection.
+        () => { });
+    }
+}
+function isWanted(cacheKey) {
+    for (const keys of wantedBy.values()) {
+        if (keys.has(cacheKey)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Includes the index: a plugin carries its nx.json position, which exclusions and errors point at. */
+function getCacheKey(plugin, root, index) {
+    return JSON.stringify({ plugin, root, index });
+}
+function forget(cacheKey, entry) {
+    if (loadedPlugins.get(cacheKey) === entry) {
+        loadedPlugins.delete(cacheKey);
+    }
 }

package/dist/src/project-graph/plugins/isolation/messaging.d.ts

@@ -3,7 +3,8 @@ import type { Socket } from 'net';
 import type { PluginConfiguration } from '../../../config/nx-json';
 import type { ProjectGraph } from '../../../config/project-graph';
 import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, PostTasksExecutionContext, PreTasksExecutionContext } from '../public-api';
+import type { MaybeStubbedPostTasksExecutionContext } from '../task-results-stub';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, PreTasksExecutionContext } from '../public-api';
 import type { AllMessages, AllResults, DefineMessages, Handlers, ResultOf, WithResult } from './message-types';
 /**
  * All plugin worker message definitions in one place.
@@ -88,7 +89,7 @@ type PluginMessageDefs = DefineMessages<{
     };
     postTasksExecution: {
         payload: {
-            context: PostTasksExecutionContext;
+            context: MaybeStubbedPostTasksExecutionContext;
         };
         result: {
             success: true;

package/dist/src/project-graph/plugins/isolation/plugin-worker.js

@@ -42,6 +42,10 @@ if (!socketPath || !expectedPluginName || !hostWorkspaceRoot) {
     process.exit(1);
 }
 const CONNECT_TIMEOUT_MS = 30_000;
+// Runs in this worker's own loop from the moment it accepts, while the host is
+// loading every plugin at once and may sit in a synchronous workspace walk for
+// over ten seconds. A host that has died closes the socket; 'end' covers that.
+const LOAD_TIMEOUT_MS = 60_000;
 let connectErrorTimeout = setErrorTimeout(CONNECT_TIMEOUT_MS, `The plugin worker for ${expectedPluginName} is exiting as it was not connected to within ${CONNECT_TIMEOUT_MS / 1000} seconds. ` +
     'Plugin workers expect to receive a socket connection from the parent process shortly after being started. ' +
     'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
@@ -55,7 +59,7 @@ const server = (0, net_1.createServer)((socket) => {
     // This handles cases where the host process was killed
     // after the worker connected but before the worker was
     // instructed to load the plugin.
-    let loadErrorTimeout = setErrorTimeout(10_000, `Plugin Worker for ${expectedPluginName} is exiting as it did not receive a load message within 10 seconds of connecting. ` +
+    let loadErrorTimeout = setErrorTimeout(LOAD_TIMEOUT_MS, `Plugin Worker for ${expectedPluginName} is exiting as it did not receive a load message within ${LOAD_TIMEOUT_MS / 1000} seconds of connecting. ` +
         'This likely indicates that the host process was terminated before the worker could be instructed to load the plugin. ' +
         'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
     socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {

package/dist/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -1,7 +1,9 @@
 import type { ProjectGraph } from '../../config/project-graph';
 import { type PluginConfiguration } from '../../config/nx-json';
 import type { RawProjectGraphDependency } from '../project-graph-builder';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, NxPlugin, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, NxPlugin, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+import { type MaybeStubbedPostTasksExecutionContext } from './task-results-stub';
+import type { NxPluginCapabilities } from './nx-plugin-capabilities';
 /**
  * NOTE: Avoid using `import type` with this class. It causes issues with
  * jest's module resolution when running tests in projects that import
@@ -17,7 +19,7 @@ export declare class LoadedNxPlugin {
     readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
     readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
     readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
-    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
+    readonly postTasksExecution?: (context: MaybeStubbedPostTasksExecutionContext) => Promise<void>;
     readonly options?: unknown;
     readonly include?: string[];
     readonly exclude?: string[];
@@ -38,4 +40,5 @@ export declare class LoadedNxPlugin {
      */
     setWorkerEnv?(env: Record<string, string>): Promise<void>;
     constructor(plugin: NxPlugin, pluginDefinition: PluginConfiguration, index?: number);
+    capabilities(): NxPluginCapabilities;
 }

package/dist/src/project-graph/plugins/loaded-nx-plugin.js

@@ -5,6 +5,7 @@ const analytics_1 = require("../../analytics");
 const error_types_1 = require("../error-types");
 const enabled_1 = require("./isolation/enabled");
 const client_1 = require("../../daemon/client/client");
+const task_results_stub_1 = require("./task-results-stub");
 /**
  * NOTE: Avoid using `import type` with this class. It causes issues with
  * jest's module resolution when running tests in projects that import
@@ -97,8 +98,20 @@ class LoadedNxPlugin {
             };
         }
         if (plugin.postTasksExecution) {
-            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
+            // The single rehydration point: every transport hands its context
+            // straight here, so a context bound for an isolated plugin stays stubbed
+            // across that second hop rather than being read and re-stubbed.
+            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, await (0, task_results_stub_1.rehydrateTerminalOutputs)(context));
         }
     }
+    capabilities() {
+        return {
+            createNodesPattern: this.createNodes?.[0],
+            hasCreateDependencies: !!this.createDependencies,
+            hasCreateMetadata: !!this.createMetadata,
+            hasPreTasksExecution: !!this.preTasksExecution,
+            hasPostTasksExecution: !!this.postTasksExecution,
+        };
+    }
 }
 exports.LoadedNxPlugin = LoadedNxPlugin;

package/dist/src/project-graph/plugins/nx-plugin-capabilities.d.ts

@@ -0,0 +1,6 @@
+import { type CachedPluginCapabilities, NxPluginCapabilities as NxPluginCapabilitiesStore } from '../../native';
+export type NxPluginCapabilities = CachedPluginCapabilities;
+export declare function getNxPluginCapabilitiesStore(): NxPluginCapabilitiesStore | null;
+export declare function noteGraphReadFromCache(computedAt: number | undefined): void;
+/** Null means "load them", never "no plugin registers anything". */
+export declare function capabilitiesOfNxPluginsReadFromCache(): NxPluginCapabilities[] | null;

package/dist/src/project-graph/plugins/nx-plugin-capabilities.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxPluginCapabilitiesStore = getNxPluginCapabilitiesStore;
+exports.noteGraphReadFromCache = noteGraphReadFromCache;
+exports.capabilitiesOfNxPluginsReadFromCache = capabilitiesOfNxPluginsReadFromCache;
+const native_1 = require("../../native");
+const db_connection_1 = require("../../utils/db-connection");
+let store;
+function getNxPluginCapabilitiesStore() {
+    // The database is not part of the WASM build.
+    if (native_1.IS_WASM) {
+        return null;
+    }
+    // Checkout-local: the rows describe this checkout's graph.
+    store ??= new native_1.NxPluginCapabilities((0, db_connection_1.getLocalDbConnection)());
+    return store;
+}
+let computedAtOfGraphReadFromCache;
+function noteGraphReadFromCache(computedAt) {
+    computedAtOfGraphReadFromCache = computedAt;
+}
+/** Null means "load them", never "no plugin registers anything". */
+function capabilitiesOfNxPluginsReadFromCache() {
+    if (computedAtOfGraphReadFromCache === undefined) {
+        return null;
+    }
+    return (getNxPluginCapabilitiesStore()?.get(computedAtOfGraphReadFromCache) ?? null);
+}

package/dist/src/project-graph/plugins/task-results-stub.d.ts

@@ -0,0 +1,50 @@
+import type { PostTasksExecutionContext } from './public-api';
+/**
+ * A {@link PostTasksExecutionContext} whose terminal outputs have been lifted
+ * out of `taskResults` and into a map of the paths holding them, so it can
+ * cross a process boundary.
+ *
+ * `taskResults` carries every task's full output inline, so the sender copies
+ * every one of those strings into the serialized payload and pushes the whole
+ * thing across the socket, once per boundary. The strings themselves exist
+ * either way: the runner puts them on each result as its task completes, and
+ * the receiver reads them back eagerly. The bytes are
+ * already on disk at `<cacheDir>/terminalOutputs/<hash>`, so transports carry
+ * paths and each receiver reads them back before any plugin sees the context.
+ *
+ * This is no longer a crash fix. The fallback used to be
+ * `v8.serialize(...).toString('binary')`, which put an oversized payload back
+ * through V8's maximum string length after `JSON.stringify` had already hit it,
+ * so both arms threw. `serialize` returns bytes now and the ceiling is gone;
+ * what is left is the cost of moving the payload at all.
+ *
+ * The paths live here rather than in `terminalOutput` so that field never
+ * holds two meanings: a stubbed result carries no `terminalOutput` at all, so
+ * a transport that forgets to rehydrate hands a plugin a missing value rather
+ * than a filename shaped exactly like real output. The map is required, so a
+ * stubbed context cannot typecheck without one.
+ */
+export type StubbedPostTasksExecutionContext = PostTasksExecutionContext & {
+    /**
+     * Path to the terminal output of each stubbed task, keyed by task id. Out of
+     * band because a task can print anything, so no in-band marker is safe from
+     * a task that prints it.
+     */
+    stubbedTerminalOutputs: Record<string, string>;
+};
+export type MaybeStubbedPostTasksExecutionContext = PostTasksExecutionContext | StubbedPostTasksExecutionContext;
+/**
+ * Swaps outputs out for paths ahead of a transport. Idempotent, so a context
+ * already stubbed for the daemon can be passed on to a plugin worker as-is.
+ */
+export declare function stubTerminalOutputs(context: MaybeStubbedPostTasksExecutionContext): MaybeStubbedPostTasksExecutionContext;
+/**
+ * Reads the outputs back. A no-op on a context that was never stubbed, which
+ * is every in-process plugin run without the daemon.
+ *
+ * The reads are issued together rather than awaited one at a time: a run has
+ * one file per task, they are independent, and this sits between the tasks
+ * finishing and the first plugin seeing the results - so serializing it would
+ * add up every file's latency in front of that.
+ */
+export declare function rehydrateTerminalOutputs(context: MaybeStubbedPostTasksExecutionContext): Promise<PostTasksExecutionContext>;

package/dist/src/project-graph/plugins/task-results-stub.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stubTerminalOutputs = stubTerminalOutputs;
+exports.rehydrateTerminalOutputs = rehydrateTerminalOutputs;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const terminal_output_path_1 = require("../../tasks-runner/terminal-output-path");
+const logger_1 = require("../../utils/logger");
+function isStubbed(context) {
+    return !!context.stubbedTerminalOutputs;
+}
+/**
+ * Swaps outputs out for paths ahead of a transport. Idempotent, so a context
+ * already stubbed for the daemon can be passed on to a plugin worker as-is.
+ */
+function stubTerminalOutputs(context) {
+    if (!context.taskResults) {
+        return context;
+    }
+    const stubbedTerminalOutputs = {
+        ...(isStubbed(context) ? context.stubbedTerminalOutputs : {}),
+    };
+    const taskResults = {};
+    let swapped = false;
+    for (const [id, result] of Object.entries(context.taskResults)) {
+        const path = id in stubbedTerminalOutputs ? null : stubbablePath(result);
+        if (path) {
+            const { terminalOutput, ...withoutOutput } = result;
+            stubbedTerminalOutputs[id] = path;
+            taskResults[id] = withoutOutput;
+            swapped = true;
+        }
+        else {
+            taskResults[id] = result;
+        }
+    }
+    // Nothing to swap: hand back the context as it came, so a run with no
+    // outputs on disk sends exactly what it sent before. Covers the
+    // already-stubbed case too, which keeps its own map by staying untouched.
+    if (!swapped) {
+        return context;
+    }
+    return { ...context, taskResults, stubbedTerminalOutputs };
+}
+/**
+ * Reads the outputs back. A no-op on a context that was never stubbed, which
+ * is every in-process plugin run without the daemon.
+ *
+ * The reads are issued together rather than awaited one at a time: a run has
+ * one file per task, they are independent, and this sits between the tasks
+ * finishing and the first plugin seeing the results - so serializing it would
+ * add up every file's latency in front of that.
+ */
+async function rehydrateTerminalOutputs(context) {
+    if (!isStubbed(context)) {
+        return context;
+    }
+    const taskResults = { ...context.taskResults };
+    const reads = Object.entries(context.stubbedTerminalOutputs)
+        // A stub whose result is gone has nothing to attach the bytes to, so it is
+        // dropped before the read rather than after it.
+        .filter(([id]) => taskResults[id])
+        .map(async ([id, path]) => {
+        const terminalOutput = await readTerminalOutput(path);
+        taskResults[id] = { ...taskResults[id], terminalOutput };
+    });
+    await Promise.all(reads);
+    const { stubbedTerminalOutputs, ...rehydrated } = {
+        ...context,
+        taskResults,
+    };
+    return rehydrated;
+}
+/**
+ * The path to swap in, or null to leave the output inline. A task that failed
+ * before it was hashed has no path, and a task that never ran has no file —
+ * both keep whatever they already carry rather than losing it.
+ */
+function stubbablePath(result) {
+    if (result.terminalOutput === undefined) {
+        return null;
+    }
+    const hash = result.task?.hash;
+    if (!hash) {
+        return null;
+    }
+    // `getCustomHasher` lets a plugin return any string, and this one reaches a
+    // read, so the sink is kept inside the cache dir here rather than trusted to
+    // the hasher. A hash that needed stripping resolves to a file that does not
+    // exist, which falls back to sending the output inline.
+    const path = (0, terminal_output_path_1.terminalOutputPathForHash)((0, node_path_1.basename)(hash));
+    return (0, node_fs_1.existsSync)(path) ? path : null;
+}
+/**
+ * A path that no longer resolves means the bytes are gone. Saying so with
+ * `undefined` — already a legal value, skipped tasks have it — beats leaving
+ * the path, which would have plugins treat a filename as the output.
+ */
+async function readTerminalOutput(path) {
+    if (!path) {
+        return undefined;
+    }
+    try {
+        return await (0, promises_1.readFile)(path, 'utf-8');
+    }
+    catch (e) {
+        logger_1.logger.warn(`Nx could not read a task's terminal output from ${path}: ${e.message}`);
+        return undefined;
+    }
+}

package/dist/src/project-graph/plugins/tasks-execution-hooks.d.ts

@@ -1,3 +1,4 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from './public-api';
+import type { PreTasksExecutionContext } from './public-api';
+import { type MaybeStubbedPostTasksExecutionContext } from './task-results-stub';
 export declare function runPreTasksExecution(pluginContext: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
-export declare function runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
+export declare function runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;

package/dist/src/project-graph/plugins/tasks-execution-hooks.js

@@ -7,8 +7,18 @@ const get_plugins_1 = require("./get-plugins");
 const is_on_daemon_1 = require("../../daemon/is-on-daemon");
 const client_1 = require("../../daemon/client/client");
 const workspace_root_1 = require("../../utils/workspace-root");
+const task_results_stub_1 = require("./task-results-stub");
+const nx_plugin_capabilities_1 = require("./nx-plugin-capabilities");
+/** True only when the cached graph's recorded rows show no plugin has `hook`; unknown is false. */
+function knownThatNoPluginRegisters(hook) {
+    const recorded = (0, nx_plugin_capabilities_1.capabilitiesOfNxPluginsReadFromCache)();
+    return !!recorded && !recorded.some((capabilities) => capabilities[hook]);
+}
 async function runPreTasksExecution(pluginContext) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        if (knownThatNoPluginRegisters('hasPreTasksExecution')) {
+            return [];
+        }
         performance.mark(`preTasksExecution:start`);
         const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(pluginContext.workspaceRoot), pluginContext.workspaceRoot);
         const envs = await Promise.all(plugins
@@ -44,6 +54,9 @@ function applyProcessEnvs(envs) {
 }
 async function runPostTasksExecution(context) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        if (knownThatNoPluginRegisters('hasPostTasksExecution')) {
+            return;
+        }
         performance.mark(`postTasksExecution:start`);
         const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot));
         await Promise.all(plugins
@@ -62,6 +75,6 @@ async function runPostTasksExecution(context) {
         performance.measure(`postTasksExecution`, `postTasksExecution:start`, `postTasksExecution:end`);
     }
     else {
-        await client_1.daemonClient.runPostTasksExecution(context);
+        await client_1.daemonClient.runPostTasksExecution((0, task_results_stub_1.stubTerminalOutputs)(context));
     }
 }