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

package/dist/src/tasks-runner/task-orchestrator.d.ts

@@ -1,3 +1,4 @@
+import type { OutputStyle } from '../command-line/yargs-utils/shared-options';
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
@@ -20,8 +21,13 @@ export declare class TaskOrchestrator {
     private readonly options;
     private readonly bail;
     private readonly daemon;
-    private readonly outputStyle;
+    /** What the user named; undefined means they named nothing. */
+    private readonly specifiedOutputStyle;
+    /** What this run renders with, after defaults. */
+    private readonly resolvedOutputStyle;
     private readonly fullTaskGraph;
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    private readonly deferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -36,6 +42,7 @@ export declare class TaskOrchestrator {
     private initializingTaskIds;
     private processedTasks;
     private cacheMissedHashes;
+    private copiedOutputFiles;
     private completedTasks;
     private waitingForTasks;
     private pendingDiscreteWorkers;
@@ -57,7 +64,16 @@ export declare class TaskOrchestrator {
     private continuousTaskExitHandled;
     private cleanupPromise;
     private signalHandlers;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, fullTaskGraph?: TaskGraph);
+    private tasksWithPersistedOutput;
+    /** Batches whose worker log was handed to the life cycle, so it must survive. */
+    private announcedBatchLogs;
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, 
+    /** What the user named; undefined means they named nothing. */
+    specifiedOutputStyle: OutputStyle | undefined, 
+    /** What this run renders with, after defaults. */
+    resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph, 
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    deferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -117,14 +133,23 @@ export declare class TaskOrchestrator {
      * Hash all batch tasks and resolve cache hits topologically.
      *
      * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks with depsOutputs
-     * whose deps weren't cached are ineligible for cache lookup but still
+     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
+     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
      * receive a preliminary hash — they'll be re-hashed after execution.
      */
     private applyBatchCachedResults;
     private hashBatchTasks;
     applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
     private runBatch;
+    /**
+     * Tells the life cycle where the batch worker's own log is, when something
+     * failed and a style that prints nothing would otherwise leave it unread.
+     *
+     * The path is announced rather than the bytes copied into a task: one worker
+     * produces one log, it explains the batch rather than any single task, and a
+     * task's own output file is read back verbatim on a cache hit.
+     */
+    private announceBatchWorkerLog;
     /**
      * Rendering a batch's output must never change the batch's results. A throw
      * from the printer would otherwise land in `runBatch`'s own error handling:
@@ -229,6 +254,48 @@ export declare class TaskOrchestrator {
     startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
+    /**
+     * The results `cache.put` will write, in the shape it wants them. Pulled out
+     * of postRunSteps so the terminal-output backstop can be told exactly which
+     * tasks the cache is already writing a file for.
+     */
+    private resultsToCache;
+    /**
+     * Guarantee that every task that actually ran leaves its terminal output at
+     * `<cacheDir>/terminalOutputs/<hash>`, whatever its cache setting, output
+     * style, or batch membership. That path is what `--output-style=summary`
+     * addresses each failure by, what the DB cache reads back on a hit
+     * (`build_cached_result`), and what Nx Cloud falls back to reading when a
+     * task's in-memory output is undefined, so a task that reaches a terminal
+     * state without a file there is a dangling reference.
+     *
+     * Batch tasks are why this exists. Their output only ever arrives over IPC,
+     * so the sole thing that ever put it on disk was `cache.put` — leaving a
+     * `cache:false` batch task (the shape CI runs under `NX_BATCH_MODE`) with no
+     * file at all.
+     *
+     * Written exactly once per task: tasks whose runner owns the file are
+     * recorded in `tasksWithPersistedOutput`, and tasks `cache.put` is about to
+     * write are skipped here. Cache hits are skipped by status — their output was
+     * read from this very file — except a replayed cached *failure*, which comes
+     * back as `failure` and is rewritten with the bytes it was just read with.
+     * Skipped tasks never ran, so there is nothing to write.
+     *
+     * Every file written without a cache entry behind it is then registered with
+     * the cache, because `removeOldCacheRecords` only collects hashes it finds in
+     * the database — an unregistered file would never be cleaned up. That covers
+     * files this method wrote AND ones a runner wrote, which are equally
+     * invisible to the GC.
+     */
+    private persistTerminalOutputs;
+    /**
+     * Register a continuous task's terminal output with the cache so the GC can
+     * collect it. Continuous tasks never reach postRunSteps — their file is
+     * written by whichever runner ran them, as the process exits — so this is
+     * the only place their hash gets recorded. Read off disk rather than from a
+     * result, because a continuous task completes without one.
+     */
+    private recordContinuousTerminalOutput;
     private scheduleNextTasksAndReleaseThreads;
     private complete;
     /**