@ohos-ports/nx 23.2.1-beta.1 → 23.3.0-beta.1

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));
     }
 }

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

@@ -26,9 +26,11 @@ const logger_1 = require("../utils/logger");
 const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
+const workspace_context_1 = require("../utils/workspace-context");
 const build_project_graph_1 = require("./build-project-graph");
 const error_types_1 = require("./error-types");
 const nx_deps_cache_1 = require("./nx-deps-cache");
+const nx_plugin_capabilities_1 = require("./plugins/nx-plugin-capabilities");
 const get_plugins_1 = require("./plugins/get-plugins");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const handle_import_1 = require("../utils/handle-import");
@@ -39,16 +41,21 @@ const handle_import_1 = require("../utils/handle-import");
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
 function readCachedProjectGraph(minimumComputedAt) {
-    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
-    if (!projectGraphCache) {
-        const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
-            ? (0, strip_indents_1.stripIndents) `
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    return cached.projectGraph;
+}
+function noCachedProjectGraphError() {
+    const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+        ? (0, strip_indents_1.stripIndents) `
       Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
       The decorated CLI will compute the project graph.
       'ng --help' should say 'Smart Monorepos · Fast Builds'.
       `
-            : '';
-        throw new Error((0, strip_indents_1.stripIndents) `
+        : '';
+    return new Error((0, strip_indents_1.stripIndents) `
       [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
 
       If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
@@ -58,8 +65,6 @@ function readCachedProjectGraph(minimumComputedAt) {
 
       ${angularSpecificError}
     `);
-    }
-    return projectGraphCache;
 }
 function readCachedProjectConfiguration(projectName) {
     const graph = readCachedProjectGraph();
@@ -85,8 +90,11 @@ function readProjectsConfigurationFromProjectGraph(projectGraph) {
 }
 async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     preventRecursionInGraphConstruction();
+    // Answer from the plugins loaded below, not an earlier cached graph's rows.
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(undefined);
     global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
+    (0, workspace_context_1.refreshWorkspaceContext)(workspace_root_1.workspaceRoot);
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
@@ -136,7 +144,12 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(projectGraphError?.errors ?? []),
     ];
     if (cacheEnabled) {
-        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors);
+        const computedAt = Date.now();
+        // Before the graph, so a cached graph never lacks its row.
+        if (errors.length === 0) {
+            (0, nx_plugin_capabilities_1.getNxPluginCapabilitiesStore)()?.record(computedAt, plugins.map((plugin) => plugin.capabilities()));
+        }
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors, computedAt);
     }
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
@@ -149,14 +162,7 @@ function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
         if (e instanceof error_types_1.ProjectGraphError) {
-            let title = e.message;
-            const bodyLines = isVerbose
-                ? [e.stack]
-                : ['Pass --verbose to see the stacktraces.'];
-            output_1.output.error({
-                title,
-                bodyLines: bodyLines,
-            });
+            output_1.output.error((0, error_types_1.formatProjectGraphError)(e, isVerbose));
         }
         else if (typeof e.message === 'string') {
             const lines = e.message.split('\n');
@@ -178,7 +184,12 @@ function handleProjectGraphError(opts, e) {
     }
 }
 async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
-    const graph = readCachedProjectGraph(minimumComputedAt);
+    const cached = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
+    if (!cached) {
+        throw noCachedProjectGraphError();
+    }
+    const graph = cached.projectGraph;
+    (0, nx_plugin_capabilities_1.noteGraphReadFromCache)(cached.computedAt);
     const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
         data.root,
         project,
@@ -260,45 +271,33 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
         const lock = !native_1.IS_WASM
             ? new native_1.FileLock((0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.lock'))
             : null;
-        let locked = lock?.locked;
-        while (locked) {
+        let holdingLock = lock?.tryLock() ?? false;
+        while (lock && !holdingLock) {
             logger_1.logger.verbose('Waiting for graph construction in another process to complete');
             const spinner = new delayed_spinner_1.DelayedSpinner('Waiting for graph construction in another process to complete');
             const start = Date.now();
-            await lock.wait();
-            spinner.cleanup();
-            // Note: This will currently throw if any of the caches are missing...
-            // It would be nice if one of the processes that was waiting for the lock
-            // could pick up the slack and build the graph if it's missing, but
-            // we wouldn't want either of the below to happen:
-            // - All of the waiting processes to build the graph
-            // - Even one of the processes building the graph on a legitimate error
             try {
-                // Ensuring that computedAt was after this process started
-                // waiting for the graph to complete, means that the graph
-                // was computed by the process was already working.
+                await lock.wait();
+                // A graph computed after this process started waiting is the holder's.
                 const graph = await readCachedGraphAndHydrateFileMap(start);
                 const sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
                 if (!sourceMaps) {
                     throw new Error('The project graph was computed in another process, but the source maps are missing.');
                 }
-                return {
-                    projectGraph: graph,
-                    sourceMaps,
-                };
+                return { projectGraph: graph, sourceMaps };
             }
             catch (e) {
-                // If the error is that the cached graph is stale after unlock,
-                // the process that was working on the graph must have been canceled,
-                // so we will fall through to the normal flow to ensure
-                // its created by one of the processes that was waiting
                 if (!(e instanceof error_types_1.StaleProjectGraphCacheError)) {
                     throw e;
                 }
+                // The holder stopped without writing a graph: build it here, or wait for
+                // whoever took the lock first.
+                holdingLock = lock.tryLock();
+            }
+            finally {
+                spinner.cleanup();
             }
-            locked = lock.check();
         }
-        lock?.lock();
         try {
             const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
             perf_hooks_1.performance.measure('createProjectGraphAsync >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
@@ -323,7 +322,9 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
             handleProjectGraphError(opts, e);
         }
         finally {
-            lock?.unlock();
+            if (holdingLock) {
+                lock.unlock();
+            }
         }
     }
     else {