nx 23.2.1 → 23.3.0-beta.1

package/dist/src/native/index.d.ts

@@ -104,6 +104,14 @@ export declare class HttpRemoteCache {
   store(hash: string, cacheDirectory: string, terminalOutput: string, code: number): Promise<boolean>
 }
 
+/**
+ * The hasher's handle on an index: lists only after catching up with the
+ * watch behind it.
+ */
+export declare class IgnoredIndexReader {
+
+}
+
 export declare class ImportResult {
   file: string
   sourceProject: string
@@ -122,6 +130,25 @@ export declare class NxCache {
   getBatch(hashes: Array<string>): Array<CachedResult | undefined | null>
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): Array<string>
   applyRemoteCacheResults(hash: string, result: CachedResult, outputs?: Array<string> | undefined | null): void
+  /**
+   * Register terminal outputs that were written without a cache entry —
+   * uncacheable tasks, and cacheable ones run with `--skip-nx-cache`.
+   *
+   * Without a row the file is invisible to `remove_old_cache_records`,
+   * which only ever walks hashes it finds in the database, so these files
+   * would accumulate forever. The row carries `is_cache_entry = FALSE` so it
+   * can never be served as a cache hit.
+   *
+   * On conflict `accessed_at` always moves: the reads filter these rows out,
+   * so they would otherwise age from the first write and be collected out
+   * from under a task that is still being run daily. `size` moves only while
+   * the row is still output-only (`NOT is_cache_entry`), so a task rerun with
+   * a longer log stops undercounting against `maxCacheSize`. `is_cache_entry`
+   * is never touched, and a row that already has artifacts keeps the size
+   * `put` recorded, so a rewrite can neither demote a real entry nor replace
+   * its whole-entry size with the terminal output's.
+   */
+  recordTerminalOutputs(records: Array<TerminalOutputRecord>): void
   getTaskOutputsPath(hash: string): string
   getCacheSize(): number
   copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): number
@@ -204,7 +231,7 @@ export declare class TaskDetails {
 }
 
 export declare class TaskHasher {
-  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<Record<string, Array<FileData>>>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, rootTsconfigPath?: string | undefined | null, options?: HasherOptions | undefined | null)
+  constructor(workspaceRoot: string, projectGraph: ExternalObject<ProjectGraph>, projectFileMap: ExternalObject<Record<string, Array<FileData>>>, allWorkspaceFiles: ExternalObject<Array<FileData>>, tsConfig: Buffer, tsConfigPaths: Record<string, Array<string>>, rootTsconfigPath: string | undefined | null, options: HasherOptions | undefined | null, ignoredIndex: ExternalObject<IgnoredIndexReader>)
   /**
    * Hash each task's instructions using the env map keyed by `task.id`.
    * Every task in `hash_plans` must have an entry in `per_task_envs` —
@@ -214,6 +241,21 @@ export declare class TaskHasher {
    * every task id.
    */
   hashPlans(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
+  /**
+   * Like `hash_plans`, but only for the plans the planner did not defer
+   * (`HashPlans::deferred`: a task that reads another task's outputs, or a
+   * disk-backed fileset whose directory contains, or sits inside, an
+   * upstream task's output). The rest are left out and hash once those
+   * tasks have run; their ids are absent from the result and need no entry
+   * in `per_task_envs`.
+   */
+  hashPlansUpfront(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
+  /**
+   * Hashes `task_ids` from plans built earlier, so a task the up-front batch
+   * deferred needs no second planning pass. Ids without a plan are absent
+   * from the result.
+   */
+  hashPlansFor(hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, taskIds: Array<string>, perTaskEnvs: Record<string, Record<string, string>>, cwd: string, collectTaskInputs?: boolean | undefined | null): Record<string, HashDetails>
 }
 
 export declare class TaskInvocationTracker {
@@ -228,28 +270,39 @@ export declare class TaskInvocationTracker {
   cleanupStale(): void
 }
 
-export declare class Watcher {
-  origin: string
+export declare class WorkspaceContext {
+  workspaceRoot: string
+  constructor(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null)
   /**
-   * Always applies HARDCODED_IGNORE_PATTERNS plus watcher-specific
-   * patterns (vite/vitest timestamp files), regardless of `use_ignore`.
+   * Loads the files the last walk recorded instead of walking. For a
+   * process whose host already walked, such as a plugin worker.
    */
-  constructor(origin: string, additionalGlobs?: Array<string> | undefined | null, useIgnore?: boolean | undefined | null)
-  watch(callbackTsfn: (err: string | null, events: WatchEvent[]) => void): void
-  stop(): Promise<void>
+  static fromArchive(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null): WorkspaceContext
   /**
-   * Synchronously drains the accumulator. Used by the daemon before
-   * serving a cached project graph so events buffered inside the
-   * IDLE_WINDOW debounce don't go missing. Returns an empty vec if
-   * the watcher hasn't started, the loop has exited, or no events
-   * are buffered.
+   * Bumped once per applied batch that changed anything. Equal values
+   * mean equal files, so a consumer that remembers the value it computed
+   * from can skip recomputing.
    */
-  forceFlushPending(): Array<WatchEvent>
-}
-
-export declare class WorkspaceContext {
-  workspaceRoot: string
-  constructor(workspaceRoot: string, cacheDir: string)
+  changeSeq(): number
+  /**
+   * Walks the workspace again into this context, so it and the archive
+   * include writes made since the last walk. Does nothing while a walk is
+   * in progress. Await `ready()` before reading. What the walk finds
+   * changed goes to the subscriber.
+   *
+   * For a graph built without the daemon, where nothing watches: see
+   * `refreshWorkspaceContext`, called by
+   * `buildProjectGraphAndSourceMapsWithoutDaemon`.
+   */
+  refresh(): boolean
+  /**
+   * Resolves once the files behind this context exist. The readers below
+   * block the calling thread until they do; awaiting this first keeps a
+   * plugin host responsive while its workers are connecting.
+   */
+  ready(): Promise<void>
+  /** On wasm the files are gathered when the context is constructed. */
+  ready(): void
   getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
   glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
   /**
@@ -261,10 +314,60 @@ export declare class WorkspaceContext {
   multiGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<Array<string>>
   hashFilesMatchingGlobs(globGroups: Array<Array<string>>): Array<string>
   hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
-  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
+  /**
+   * Applies changes a caller learned of on its own. Waits through a walk in
+   * progress so the answer reflects them. Returns what really changed; the
+   * batch is not published to subscribers.
+   */
+  incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): ChangeBatch
   updateProjectFiles(projectRootMappings: Record<string, string>, projectFiles: ExternalObject<Record<string, Array<FileData>>>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles
   allFileData(): Array<FileData>
+  /**
+   * Recover from dropped watch events: re-walk, and report what changed
+   * against the files this context was holding. The fresh files are
+   * adopted, so the caller only has to feed the returned changes through
+   * its normal recomputation path; subscribers do not see them.
+   */
+  rescanAndDiff(): ChangeBatch
+  /**
+   * The subset of `paths` the file map holds: what the watch tracks, with
+   * the ignore rules applied. A path it does not hold is gitignored, gone,
+   * or not yet reported. Applies what the watch delivered first, as every
+   * other read of the files does, so a write already reported counts.
+   */
+  trackedFiles(paths: Array<string>): Array<string>
   getFilesInDirectory(directory: string): Array<string>
+  /**
+   * Subscribes to the context's changes: the callback is called whenever
+   * something was applied or delivered, with everything not yet taken by
+   * it or by `settle`. Replaces any earlier subscriber.
+   */
+  onChanges(callback: (err: Error | null, batch: ChangeBatch | null) => void): void
+  /**
+   * Subscribes to every event the watch delivers, whether or not it
+   * concerns the files: writes under ignored directories included, and
+   * the `rescan` marker when the kernel dropped events. Replaces any
+   * earlier subscriber. Batches applied to the files are `onChanges`.
+   */
+  onWatchEvents(callback: (err: Error | null, events: WatchEvent[] | null) => void): void
+  /**
+   * Applies everything the watch has delivered, waiting out the kernel hop,
+   * then takes every change applied and not yet taken, one entry per path
+   * at its latest state. The change subscriber takes from the same place,
+   * so no change is handed out twice.
+   */
+  settle(): ChangeBatch
+  /**
+   * Takes every change applied and not yet taken, without waiting for the
+   * watch: for a caller that just applied changes itself, through
+   * `incrementalUpdate` or `rescanAndDiff`.
+   */
+  takeAppliedChanges(): ChangeBatch
+  /**
+   * Stops the watcher and forgets the subscribers. The files stay as they
+   * were; reads no longer pull anything in.
+   */
+  stopWatching(): void
 }
 
 export interface BatchInfo {
@@ -298,6 +401,20 @@ export declare function canInstallNxConsole(): Promise<boolean>
 
 export declare function canInstallNxConsoleForEditor(editor: SupportedEditor): Promise<boolean>
 
+/**
+ * What one application of changes did to the files. `seq` is the context's
+ * change sequence afterwards; it is unchanged, and the lists empty, when
+ * nothing the batch reported was really different. A path can reach a
+ * consumer in more than one batch (see `settle`): the one with the higher
+ * `seq` holds its later state.
+ */
+export interface ChangeBatch {
+  seq: number
+  createdFiles: Array<FileData>
+  updatedFiles: Array<FileData>
+  deletedFiles: Array<string>
+}
+
 export declare function closeDbConnection(connection: ExternalObject<NxDbConnection>): void
 
 export declare function connectToNxDb(cacheDir: string, dbName?: string | undefined | null): ExternalObject<NxDbConnection>
@@ -357,9 +474,17 @@ export interface EventDimensions {
 export declare const enum EventType {
   delete = 'delete',
   update = 'update',
-  create = 'create'
+  create = 'create',
+  /**
+   * The kernel dropped events (e.g. an inotify queue overflow); per-path
+   * events cannot be trusted complete and consumers must re-walk.
+   */
+  rescan = 'rescan'
 }
 
+/** The files an `includeIgnored` fileset group matches on disk, sorted. */
+export declare function expandFilesInput(workspaceRoot: string, globs: Array<string>): Array<string>
+
 export declare function expandOutputs(directory: string, entries: Array<string>): Array<string>
 
 export interface ExternalDependenciesInput {
@@ -385,6 +510,11 @@ export interface FileMap {
 export interface FileSetInput {
   fileset: string
   dependencies?: boolean
+  /**
+   * Hash the glob straight from disk (so gitignored/generated files count)
+   * instead of the workspace file map.
+   */
+  includeIgnored?: boolean
 }
 
 export declare function findImports(projectFileMap: Record<string, Array<string>>): Array<ImportResult>
@@ -624,6 +754,7 @@ export interface NxWorkspaceFilesExternals {
   projectFiles: ExternalObject<Record<string, Array<FileData>>>
   globalFiles: ExternalObject<Array<FileData>>
   allWorkspaceFiles: ExternalObject<Array<FileData>>
+  ignoredIndex: ExternalObject<IgnoredIndexReader>
 }
 
 export declare function parseTaskStatus(stringStatus: string): TaskStatus
@@ -702,6 +833,31 @@ export declare const enum SupportedEditor {
   Unknown = 5
 }
 
+/**
+ * A free function, not a method: `BatchProcess` writes these logs whichever
+ * cache implementation is active, so the sweep must not be reachable only
+ * through the DB-backed one.
+ *
+ * Deletes batch logs by age, then oldest-first while the directory is over
+ * budget.
+ *
+ * No database rows: nothing looks a batch log up by key, so a row would be
+ * write-only bookkeeping that a hard-killed process could skip, orphaning
+ * the file forever. The filesystem cannot drift from itself, and the file
+ * is appended to for the life of its batch, so a size recorded anywhere
+ * else is wrong until that batch ends.
+ *
+ * The budget is separate from `maxCacheSize` on purpose: these are debug
+ * artifacts, and sharing a budget would let one evict a replayable cache
+ * entry — trading a rebuild for a text file.
+ *
+ * The age sweep deletes at `BATCH_OUTPUT_MAX_AGE`; the eviction skips
+ * anything written within `BATCH_OUTPUT_MIN_EVICTION_AGE`. That is
+ * last-write, not creation, so a batch silent through a long quiet phase is
+ * not protected.
+ */
+export declare function sweepBatchOutputs(cachePath: string): void
+
 /** System information (static system-level data) */
 export interface SystemInfo {
   cpuCores: number
@@ -811,6 +967,15 @@ export interface TaskTarget {
   configuration?: string
 }
 
+export interface TerminalOutputRecord {
+  hash: string
+  /**
+   * Byte length of the terminal output written for this hash, so these
+   * files are counted against `maxCacheSize` like any other cache content.
+   */
+  size: number
+}
+
 export declare function testOnlyTransferFileMap(projectFiles: Record<string, Array<FileData>>, nonProjectFiles: Array<FileData>): NxWorkspaceFilesExternals
 
 /** Track an event using the global telemetry instance */
@@ -851,6 +1016,22 @@ export interface WorkingDirectoryInput {
   workingDirectory: string
 }
 
+export interface WorkspaceContextOptions {
+  /**
+   * Keep the files current from a watcher the context owns. Watching
+   * starts before the scan, so nothing written after construction is
+   * missed. Off by default; ignored on wasm, which has no watcher.
+   */
+  watch?: boolean
+  /**
+   * Paths the watch reports even though a hardcoded ignore covers them,
+   * as the daemon does for its own process file. They reach the event
+   * stream only, never the files: the workspace ignore rules still decide
+   * what enters those.
+   */
+  alwaysWatch?: Array<string>
+}
+
 /** Public NAPI error codes that are for Node */
 export declare const enum WorkspaceErrors {
   ParseError = 'ParseError',

package/dist/src/native/index.js

@@ -210,7 +210,7 @@ Module._load = function (request, parent, isMain) {
 
 const indexModulePath = require.resolve('./native-bindings.js');
 delete require.cache[indexModulePath];
-const indexModule = require('./native-bindings.js');
-
-module.exports = indexModule;
+// A direct re-export: node's CommonJS export lexer follows this form, so ESM
+// importers see the named exports. Assigning via a variable hides them.
+module.exports = require('./native-bindings.js');
 Module._load = originalLoad;

package/dist/src/native/native-bindings.js

@@ -582,6 +582,7 @@ module.exports.FileLock = nativeBinding.FileLock
 module.exports.HashPlanInspector = nativeBinding.HashPlanInspector
 module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
+module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
@@ -592,7 +593,6 @@ module.exports.RustPseudoTerminal = nativeBinding.RustPseudoTerminal
 module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
 module.exports.TaskInvocationTracker = nativeBinding.TaskInvocationTracker
-module.exports.Watcher = nativeBinding.Watcher
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
 module.exports.BatchStatus = nativeBinding.BatchStatus
 module.exports.canInstallNxConsole = nativeBinding.canInstallNxConsole
@@ -602,6 +602,7 @@ module.exports.connectToNxDb = nativeBinding.connectToNxDb
 module.exports.copy = nativeBinding.copy
 module.exports.detectAiAgent = nativeBinding.detectAiAgent
 module.exports.EventType = nativeBinding.EventType
+module.exports.expandFilesInput = nativeBinding.expandFilesInput
 module.exports.expandOutputs = nativeBinding.expandOutputs
 module.exports.findImports = nativeBinding.findImports
 module.exports.flushTelemetry = nativeBinding.flushTelemetry
@@ -633,6 +634,7 @@ module.exports.remove = nativeBinding.remove
 module.exports.restoreTerminal = nativeBinding.restoreTerminal
 module.exports.RunMode = nativeBinding.RunMode
 module.exports.SupportedEditor = nativeBinding.SupportedEditor
+module.exports.sweepBatchOutputs = nativeBinding.sweepBatchOutputs
 module.exports.TaskStatus = nativeBinding.TaskStatus
 module.exports.testOnlyTransferFileMap = nativeBinding.testOnlyTransferFileMap
 module.exports.trackEvent = nativeBinding.trackEvent

package/dist/src/plugins/js/lock-file/pnpm-parser.js

@@ -663,7 +663,7 @@ function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspac
     }
     output.packages = (0, object_sort_1.sortObjectByKeys)(output.packages);
     stripStandaloneLockfileConfig(output);
-    return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
+    return (0, pnpm_normalizer_1.joinPnpmLockfileDocuments)((0, pnpm_normalizer_1.extractEnvLockfileDocument)(rootLockFileContent), (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output));
 }
 /**
  * Removes settings a standalone, pruned lockfile cannot satisfy on its own.

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.d.ts

@@ -15,6 +15,8 @@ export declare function loadPnpmHoistedDepsDefinition(): any;
  */
 export declare function parseAndNormalizePnpmLockfile(content: string): Lockfile;
 export declare function extractMainLockfileDocument(content: string): string;
+export declare function extractEnvLockfileDocument(content: string): string | null;
+export declare function joinPnpmLockfileDocuments(envDocument: string | null, mainDocument: string): string;
 /**
  * Mapping and writing logic from pnpm lockfile `write` function
  */

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.js

@@ -9,6 +9,8 @@ exports.usesLeadingDash = usesLeadingDash;
 exports.loadPnpmHoistedDepsDefinition = loadPnpmHoistedDepsDefinition;
 exports.parseAndNormalizePnpmLockfile = parseAndNormalizePnpmLockfile;
 exports.extractMainLockfileDocument = extractMainLockfileDocument;
+exports.extractEnvLockfileDocument = extractEnvLockfileDocument;
+exports.joinPnpmLockfileDocuments = joinPnpmLockfileDocuments;
 exports.stringifyToPnpmYaml = stringifyToPnpmYaml;
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
@@ -68,6 +70,26 @@ function extractMainLockfileDocument(content) {
     }
     return content.slice(separatorIndex + YAML_DOCUMENT_SEPARATOR.length);
 }
+// The package-manager document (`packageManagerDependencies`) must ship with a
+// pruned lockfile whenever the pruned manifest keeps `packageManager`: pnpm
+// refuses a frozen install when the pin is not recorded in the lockfile.
+function extractEnvLockfileDocument(content) {
+    content = content.replace(/\r\n/g, '\n');
+    if (!content.startsWith(YAML_DOCUMENT_START)) {
+        return null;
+    }
+    const separatorIndex = content.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
+    if (separatorIndex === -1) {
+        return null;
+    }
+    return content.slice(YAML_DOCUMENT_START.length, separatorIndex);
+}
+function joinPnpmLockfileDocuments(envDocument, mainDocument) {
+    if (envDocument === null) {
+        return mainDocument;
+    }
+    return `${YAML_DOCUMENT_START}${envDocument}${YAML_DOCUMENT_SEPARATOR}${mainDocument}`;
+}
 // https://github.com/pnpm/pnpm/blob/50e37072f42bcca6d393a74bed29f7f0e029805d/lockfile/lockfile-file/src/write.ts#L22
 const LOCKFILE_YAML_FORMAT = {
     blankLines: true,

package/dist/src/plugins/js/utils/register.js

@@ -24,6 +24,7 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
 const fs_1 = require("fs");
+const fileutils_1 = require("../../../utils/fileutils");
 const logger_1 = require("../../../utils/logger");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const typescript_1 = require("./typescript");
@@ -1208,7 +1209,7 @@ function resolvePathsBaseUrl(tsconfigPath) {
         const absolute = (0, path_1.resolve)(queue.shift());
         const dir = (0, path_1.dirname)(absolute);
         try {
-            const raw = JSON.parse((0, fs_1.readFileSync)(absolute, 'utf-8'));
+            const raw = (0, fileutils_1.readJsonFile)(absolute);
             chain.push({ dir, raw });
             const exts = raw.extends
                 ? Array.isArray(raw.extends)

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");
@@ -268,7 +269,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;

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,8 @@
 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';
 /**
  * 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 +18,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[];

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,7 +98,10 @@ 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));
         }
     }
 }

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