nx 23.3.0-beta.1 → 23.3.0-beta.2

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

@@ -44,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;
@@ -54,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;
@@ -91,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;
@@ -215,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 = [
@@ -339,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/loaded-nx-plugin.d.ts

@@ -3,6 +3,7 @@ import { type PluginConfiguration } from '../../config/nx-json';
 import type { RawProjectGraphDependency } from '../project-graph-builder';
 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
@@ -39,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

@@ -104,5 +104,14 @@ class LoadedNxPlugin {
             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/tasks-execution-hooks.js

@@ -8,8 +8,17 @@ 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
@@ -45,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