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

package/dist/src/project-graph/plugins/get-plugins.d.ts

@@ -1,4 +1,5 @@
 import { NxJsonConfiguration, PluginConfiguration } from '../../config/nx-json';
+import { type NxPluginCapabilities } from './nx-plugin-capabilities';
 import type { LoadedNxPlugin } from './loaded-nx-plugin';
 export interface SeparatedPlugins {
     specifiedPlugins: LoadedNxPlugin[];
@@ -21,7 +22,7 @@ export declare function resetIsolationFallbackForTesting(): void;
  * threw is rethrown, because rerunning it in-process would bury its actual
  * error.
  */
-export declare const loadingMethod: (plugin: PluginConfiguration, root: string, index?: number) => Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;
+export declare const loadingMethod: (plugin: PluginConfiguration, root: string, index?: number) => Promise<LoadedNxPlugin>;
 /**
  * Returns all plugins (specified + default) as a flat list.
  * Specified plugins come first, followed by default plugins.
@@ -48,4 +49,5 @@ export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPl
  */
 export declare function getPluginsIfLoadedOrLoading(): Promise<LoadedNxPlugin[]> | undefined;
 export declare function cleanupPlugins(): void;
+export declare function capabilitiesOfConfiguredPlugins(nxJson: NxJsonConfiguration, root?: string): Promise<NxPluginCapabilities[]>;
 export declare function reasonToError(reason: unknown): Error;

package/dist/src/project-graph/plugins/get-plugins.js

@@ -7,6 +7,7 @@ exports.getPluginsSeparated = getPluginsSeparated;
 exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
 exports.getPluginsIfLoadedOrLoading = getPluginsIfLoadedOrLoading;
 exports.cleanupPlugins = cleanupPlugins;
+exports.capabilitiesOfConfiguredPlugins = capabilitiesOfConfiguredPlugins;
 exports.reasonToError = reasonToError;
 const node_path_1 = require("node:path");
 const angular_json_1 = require("../../adapter/angular-json");
@@ -15,6 +16,9 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const in_process_loader_1 = require("./in-process-loader");
 const isolation_1 = require("./isolation");
 const resolve_plugin_1 = require("./resolve-plugin");
+const is_on_daemon_1 = require("../../daemon/is-on-daemon");
+const client_1 = require("../../daemon/client/client");
+const nx_plugin_capabilities_1 = require("./nx-plugin-capabilities");
 const enabled_1 = require("./isolation/enabled");
 const isolated_plugin_1 = require("./isolation/isolated-plugin");
 const sandbox_socket_hint_1 = require("../../daemon/sandbox-socket-hint");
@@ -26,10 +30,15 @@ const transpiler_1 = require("./transpiler");
  * Stuff for specified NX Plugins.
  */
 let currentPluginsConfigurationHash;
-let loadedPlugins;
 let cachedSeparatedPlugins;
 let pendingPluginsPromise;
-let cleanupSpecifiedPlugins;
+/** Workers aren't disposed here; the next load's `wantPlugins` sweeps the ones it no longer names. */
+function forgetSpecifiedPlugins() {
+    if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+        (0, transpiler_1.cleanupPluginTSTranspiler)();
+    }
+    pendingPluginsPromise = undefined;
+}
 // In-flight separated-plugins load, tagged with its hash. Two roles: a
 // concurrent caller for the same set shares this load instead of racing a
 // second one, and it gates the cache commit — a load writes the cache only if
@@ -74,11 +83,10 @@ const loadingMethod = async (plugin, root, index) => {
     if (!(0, enabled_1.isIsolationEnabled)() || isolationRefusedInThisProcess) {
         return (0, in_process_loader_1.loadNxPlugin)(plugin, root, index);
     }
-    const [isolatedPlugin, cleanup] = await (0, isolation_1.loadIsolatedNxPlugin)(plugin, root, index);
     // Awaited here rather than handed on, because the worker failure surfaces on
     // this promise and the fallback has to happen before the caller sees it.
     try {
-        return [Promise.resolve(await isolatedPlugin), cleanup];
+        return await (0, isolation_1.loadIsolatedNxPlugin)(plugin, root, index);
     }
     catch (e) {
         // Proof, kept separate from policy. The errno the worker saw is what makes
@@ -92,7 +100,6 @@ const loadingMethod = async (plugin, root, index) => {
             !((provenRefusal && (0, native_1.isAiAgent)()) || (0, is_sandbox_1.isSandbox)())) {
             throw e;
         }
-        cleanup();
         // Read and set in one synchronous step. Concurrently loaded plugins each
         // arrive here with their own failure, so testing the latch after setting it
         // is what keeps the advice to one copy.
@@ -152,13 +159,9 @@ async function getPluginsSeparated(nxJson, root = workspace_root_1.workspaceRoot
     if (pendingSeparatedPlugins?.hash === pluginsConfigurationHash) {
         return pendingSeparatedPlugins.promise;
     }
-    // Plugins config changed (e.g. `nx add @nx/maven` updated nx.json). The
-    // cached SeparatedPlugins is invalidated by the early-return above, but
-    // pendingPluginsPromise — the in-flight load — would otherwise be reused
-    // by the `??=` below and serve the previous plugin set forever. Tear
-    // down the old workers and force a fresh load.
-    cleanupSpecifiedPlugins?.();
-    pendingPluginsPromise = undefined;
+    // Plugins config changed (e.g. `nx add @nx/maven`): drop the in-flight load,
+    // or the `??=` below would serve the previous plugin set forever.
+    forgetSpecifiedPlugins();
     const loadPromise = (async () => {
         const results = await Promise.allSettled([
             getOnlyDefaultPlugins(root),
@@ -188,7 +191,6 @@ async function getPluginsSeparated(nxJson, root = workspace_root_1.workspaceRoot
         if (pendingSeparatedPlugins?.promise === loadPromise) {
             cachedSeparatedPlugins = separatedPlugins;
             currentPluginsConfigurationHash = pluginsConfigurationHash;
-            loadedPlugins = specifiedPlugins.concat(defaultPlugins);
         }
         return separatedPlugins;
     })();
@@ -212,7 +214,6 @@ async function getPluginsSeparated(nxJson, root = workspace_root_1.workspaceRoot
  */
 let loadedDefaultPlugins;
 let loadedDefaultPluginsHash;
-let cleanupDefaultPlugins;
 let pendingDefaultPluginPromise;
 async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
     const hash = root;
@@ -220,19 +221,15 @@ async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
     if (loadedDefaultPlugins && hash === loadedDefaultPluginsHash) {
         return loadedDefaultPlugins;
     }
-    // Cleanup current plugins before loading new ones
-    if (cleanupDefaultPlugins) {
-        cleanupDefaultPlugins();
+    const loadPromise = (pendingDefaultPluginPromise ??=
+        loadDefaultNxPlugins(workspace_root_1.workspaceRoot));
+    const result = await loadPromise;
+    // Commit only while this is still the registered load, so a set released while
+    // it was loading is not handed back out as the current one.
+    if (pendingDefaultPluginPromise === loadPromise) {
+        loadedDefaultPlugins = result;
+        loadedDefaultPluginsHash = hash;
     }
-    pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspace_root_1.workspaceRoot);
-    const [result, cleanupFn] = await pendingDefaultPluginPromise;
-    cleanupDefaultPlugins = () => {
-        loadedDefaultPlugins = undefined;
-        pendingDefaultPluginPromise = undefined;
-        cleanupFn();
-    };
-    loadedDefaultPlugins = result;
-    loadedDefaultPluginsHash = hash;
     return result;
 }
 /**
@@ -252,9 +249,9 @@ function getPluginsIfLoadedOrLoading() {
     return Promise.resolve(separated).then(({ specifiedPlugins, defaultPlugins }) => specifiedPlugins.concat(defaultPlugins));
 }
 function cleanupPlugins() {
-    cleanupSpecifiedPlugins?.();
-    cleanupDefaultPlugins?.();
-    pendingPluginsPromise = undefined;
+    (0, isolation_1.disposeIsolatedPlugins)();
+    forgetSpecifiedPlugins();
+    loadedDefaultPlugins = undefined;
     pendingDefaultPluginPromise = undefined;
     cachedSeparatedPlugins = undefined;
     // Drop the in-flight load too: clearing the marker flips its commit gate to
@@ -264,19 +261,38 @@ function cleanupPlugins() {
 /**
  * Stuff for generic loading
  */
+function pluginLabel(plugin) {
+    return typeof plugin === 'string' ? plugin : plugin.plugin;
+}
+async function loadPlugins(loader, pluginConfigurations, root, assignIndexes) {
+    const loads = pluginConfigurations.map((plugin, index) => ({
+        plugin,
+        index: assignIndexes ? index : undefined,
+    }));
+    (0, isolation_1.wantPlugins)(loader, loads, root);
+    return Promise.allSettled(loads.map(async ({ plugin, index }) => {
+        const label = pluginLabel(plugin);
+        performance.mark(`Load Nx Plugin: ${label} - start`);
+        const res = await (0, exports.loadingMethod)(plugin, root, index);
+        performance.mark(`Load Nx Plugin: ${label} - end`);
+        performance.measure(`Load Nx Plugin: ${label}`, `Load Nx Plugin: ${label} - start`, `Load Nx Plugin: ${label} - end`);
+        return res;
+    }));
+}
+async function capabilitiesOfConfiguredPlugins(nxJson, root = workspace_root_1.workspaceRoot) {
+    if (!(0, is_on_daemon_1.isOnDaemon)() && (0, client_1.isDaemonEnabled)()) {
+        return client_1.daemonClient.getPluginCapabilities();
+    }
+    const recorded = (0, nx_plugin_capabilities_1.capabilitiesOfNxPluginsReadFromCache)();
+    if (recorded) {
+        return recorded;
+    }
+    return (await getPlugins(nxJson, root)).map((plugin) => plugin.capabilities());
+}
 async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
     performance.mark('loadDefaultNxPlugins:start');
     const plugins = getDefaultPlugins(root);
-    const cleanupFunctions = [];
-    const results = await Promise.allSettled(plugins.map(async (plugin) => {
-        performance.mark(`Load Nx Plugin: ${plugin} - start`);
-        const [loadedPluginPromise, cleanup] = await (0, exports.loadingMethod)(plugin, root);
-        cleanupFunctions.push(cleanup);
-        const res = await loadedPluginPromise;
-        performance.mark(`Load Nx Plugin: ${plugin} - end`);
-        performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
-        return res;
-    }));
+    const results = await loadPlugins('default', plugins, root, false);
     const defaultPluginResults = [];
     const errors = [];
     for (let i = 0; i < results.length; i++) {
@@ -292,52 +308,25 @@ async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
         }
     }
     if (errors.length > 0) {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
+        // Cleared so the next call retries instead of re-awaiting this rejection.
+        pendingDefaultPluginPromise = undefined;
         const errorMessage = errors
             .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
             .join('\n');
         throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} default Nx plugin(s):\n${errorMessage}`);
     }
-    const ret = [
-        defaultPluginResults,
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                (0, transpiler_1.cleanupPluginTSTranspiler)();
-            }
-        },
-    ];
     performance.mark('loadDefaultNxPlugins:end');
     performance.measure('loadDefaultNxPlugins', 'loadDefaultNxPlugins:start', 'loadDefaultNxPlugins:end');
-    return ret;
+    return defaultPluginResults;
 }
 async function loadSpecifiedNxPlugins(pluginsConfigurations, root = workspace_root_1.workspaceRoot) {
-    // Returning existing plugins is handled by getPlugins,
-    // so, if we are here and there are existing plugins, they are stale
-    if (cleanupSpecifiedPlugins) {
-        cleanupSpecifiedPlugins();
-    }
     performance.mark('loadSpecifiedNxPlugins:start');
     pluginsConfigurations ??= [];
     // Drop the cached workspace-layout snapshot local-plugin resolution uses:
     // in a long-lived daemon it can predate a newly added local plugin and
     // resolve it to the workspace root. Runs only when the plugin set changed.
     (0, resolve_plugin_1.resetResolvePluginCache)();
-    const cleanupFunctions = [];
-    const results = await Promise.allSettled(pluginsConfigurations.map(async (plugin, index) => {
-        const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
-        performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
-        const [loadedPluginPromise, cleanup] = await (0, exports.loadingMethod)(plugin, root, index);
-        cleanupFunctions.push(cleanup);
-        const res = await loadedPluginPromise;
-        performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
-        performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
-        return res;
-    }));
+    const results = await loadPlugins('specified', pluginsConfigurations, root, true);
     performance.mark('loadSpecifiedNxPlugins:end');
     performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
     const plugins = [];
@@ -357,23 +346,12 @@ async function loadSpecifiedNxPlugins(pluginsConfigurations, root = workspace_ro
         }
     }
     if (errors.length > 0) {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
+        // Wants are not retracted: a newer load may own the declaration by now.
         const errorMessage = errors
             .map((e) => `  - ${e.pluginName}: ${e.error.message}`)
             .join('\n');
         throw new AggregateError(errors.map((e) => e.error), `Failed to load ${errors.length} Nx plugin(s):\n${errorMessage}`);
     }
-    cleanupSpecifiedPlugins = () => {
-        for (const fn of cleanupFunctions) {
-            fn();
-        }
-        if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-            (0, transpiler_1.cleanupPluginTSTranspiler)();
-        }
-        pendingPluginsPromise = undefined;
-    };
     return plugins;
 }
 function reasonToError(reason) {

package/dist/src/project-graph/plugins/in-process-loader.d.ts

@@ -6,5 +6,5 @@ export declare function readPluginPackageJson(pluginName: string, projects: Reco
     path: string;
     json: PackageJson;
 };
-export declare function loadNxPlugin(plugin: PluginConfiguration, root: string, index?: number): readonly [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPlugin(plugin: PluginConfiguration, root: string, index?: number): Promise<LoadedNxPlugin>;
 export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string, index?: number): Promise<LoadedNxPlugin>;

package/dist/src/project-graph/plugins/in-process-loader.js

@@ -38,10 +38,7 @@ function readPluginPackageJson(pluginName, projects, paths = (0, installation_di
     }
 }
 function loadNxPlugin(plugin, root, index) {
-    return [
-        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root, index),
-        () => { },
-    ];
+    return loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root, index);
 }
 async function loadNxPluginAsync(pluginConfiguration, paths, root, index) {
     const moduleName = typeof pluginConfiguration === 'string'

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

@@ -1 +1 @@
-export { loadIsolatedNxPlugin } from './load-isolated-plugin';
+export { disposeIsolatedPlugins, loadIsolatedNxPlugin, wantPlugins, } from './load-isolated-plugin';

package/dist/src/project-graph/plugins/isolation/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadIsolatedNxPlugin = void 0;
+exports.wantPlugins = exports.loadIsolatedNxPlugin = exports.disposeIsolatedPlugins = void 0;
 var load_isolated_plugin_1 = require("./load-isolated-plugin");
+Object.defineProperty(exports, "disposeIsolatedPlugins", { enumerable: true, get: function () { return load_isolated_plugin_1.disposeIsolatedPlugins; } });
 Object.defineProperty(exports, "loadIsolatedNxPlugin", { enumerable: true, get: function () { return load_isolated_plugin_1.loadIsolatedNxPlugin; } });
+Object.defineProperty(exports, "wantPlugins", { enumerable: true, get: function () { return load_isolated_plugin_1.wantPlugins; } });

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

@@ -4,6 +4,7 @@ import type { PluginConfiguration } from '../../../config/nx-json';
 import type { ProjectGraph } from '../../../config/project-graph';
 import type { RawProjectGraphDependency } from '../../project-graph-builder';
 import { LoadedNxPlugin } from '../loaded-nx-plugin';
+import type { NxPluginCapabilities } from '../nx-plugin-capabilities';
 import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from '../public-api';
 import type { PluginWorkerLoadResult } from './messaging';
 import { Hook, Phase } from './plugin-lifecycle-manager';
@@ -26,6 +27,7 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
     private worker;
     private socket;
     private _alive;
+    private _released;
     private _connectPromise;
     private txId;
     private pendingCount;
@@ -41,6 +43,7 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
      */
     static load(plugin: PluginConfiguration, root: string, index?: number): Promise<IsolatedPlugin>;
     private constructor();
+    capabilities(): NxPluginCapabilities;
     private spawnAndConnect;
     /**
      * Drops the worker from service without judging why. The next hook call
@@ -66,6 +69,11 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
     private shutdownIfInactive;
     setWorkerEnv(env: Record<string, string>): Promise<void>;
     notifyPhaseAborted(phase: Phase, lastCompletedHook: Hook): void;
+    /**
+     * 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(): void;
     shutdown(): void;
     private registerProcessMetrics;
 }

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;