@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

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

@@ -7,6 +7,7 @@ import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { TaskResult } from './life-cycle';
+import { NoopChildProcess } from './running-tasks/noop-child-process';
 import { RunningTask } from './running-tasks/running-task';
 import { SharedRunningTask } from './running-tasks/shared-running-task';
 import { TaskStatus } from './tasks-runner';
@@ -27,7 +28,7 @@ export declare class TaskOrchestrator {
     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 readonly hashingDeferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -62,6 +63,13 @@ export declare class TaskOrchestrator {
     private runningDiscreteTasks;
     private discreteTaskExitHandled;
     private continuousTaskExitHandled;
+    private readiness;
+    private readinessFailures;
+    private readinessFailureReasons;
+    private readinessSettled;
+    private readySignal;
+    private readyUrls;
+    private waitingLogged;
     private cleanupPromise;
     private signalHandlers;
     private tasksWithPersistedOutput;
@@ -73,7 +81,7 @@ export declare class TaskOrchestrator {
     /** 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>);
+    hashingDeferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -91,15 +99,24 @@ export declare class TaskOrchestrator {
      */
     private executeCoordinatorLoop;
     private executeContinuousTaskLoop;
+    private hasUnresolvedCacheableTask;
+    private scheduleAfterReadiness;
     private processTask;
     processAllScheduledTasks(): void;
+    processTasks(taskIds: string[]): void;
     /**
-     * Registers a task invocation and checks for loops across nested Nx processes.
-     * Uses the task_invocations DB table keyed by root PID. registerTask() throws
-     * on unique constraint violation when a parent Nx process already registered
-     * this task — indicating an infinite loop.
+     * Registers a task invocation and checks for loops across nested Nx
+     * processes. registerTask() returns the invocation chain only when an
+     * *ancestor* Nx process is already running this task — a genuine loop.
+     * Sibling processes running the same task are legitimate and register
+     * without complaint.
+     *
+     * The overrides hash rides along with the task id so the tracker can tell an
+     * ancestor re-invoking a task with different arguments from one repeating
+     * the same invocation.
      */
     private detectTaskInvocationLoop;
+    private releaseTaskInvocation;
     private applyCachedResults;
     /**
      * Batch cache lookup + filter to successful entries. Handles both
@@ -132,14 +149,18 @@ 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 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.
+     * Walks the task graph level by level. A deferred task (its hash reads
+     * another task's outputs) behind an upstream batch task that still has to
+     * run is never looked up yet:
+     * - behind a non-cacheable task only, it is held back for a later wave,
+     *   where it hashes after that task ran;
+     * - behind a cache miss, it runs in this wave and re-hashes after execution.
+     * Every task run in this wave gets a hash first, for Cloud's startTasks.
      */
     private applyBatchCachedResults;
     private hashBatchTasks;
     applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
+    private runBatchWave;
     private runBatch;
     /**
      * Tells the life cycle where the batch worker's own log is, when something
@@ -176,8 +197,9 @@ export declare class TaskOrchestrator {
      * those per-project summaries to the worker's stdio at all.
      *
      * The worker's whole captured log is rendered as a fold above them when the
-     * run asked for full output, or when any task failed or was stopped. A
-     * diagnostic that explains a failure is routinely one no task claimed:
+     * run asked for full output, or when any task failed, was stopped or was
+     * never reached.
+     * A diagnostic that explains a failure is routinely one no task claimed:
      * `@nx/maven`'s batch impl writes its exit-code dump and failed-task outputs
      * to the worker's stderr via `console.error`, and the Maven JVM it spawns
      * points slf4j at `System.out` because its own stderr carries the result
@@ -220,8 +242,8 @@ export declare class TaskOrchestrator {
      * for running those via {@link runTaskDirectly}.
      *
      * Fires scheduleTask lifecycle for hits that haven't been through
-     * processAllScheduledTasks yet. That's a coordinator gap-filler and
-     * a no-op for callers that pre-process the schedule.
+     * processTasks yet. That's a coordinator gap-filler and a no-op for
+     * callers that process their tasks first.
      *
      * The caller provides `groupId` — cache hits share one slot since they
      * don't actually compete for parallelism.
@@ -244,14 +266,35 @@ export declare class TaskOrchestrator {
      */
     private handleDiscreteWorkerFailure;
     /**
-     * Spawn and wait on a task's child process, unconditionally — no cache
-     * lookup. Callers must have already confirmed the task is a cache miss
-     * (or disabled caching entirely).
+     * Spawn and wait on a task's child process once its ready dependencies are
+     * ready, with no cache lookup. Callers must have already confirmed the task
+     * is a cache miss (or disabled caching entirely).
      */
     runTaskDirectly(doNotSkipCache: boolean, task: Task, groupId: number): Promise<TaskResult>;
     private runTask;
     private runTaskInForkedProcess;
-    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
+    startContinuousTask(task: Task, groupId: number): Promise<NoopChildProcess | RunningTask | SharedRunningTask>;
+    private getReadyWhen;
+    private checkReadyWhenBeforeWait;
+    private getReadyWhenWait;
+    private getReadinessCheck;
+    private warnUncheckedReadiness;
+    private waitForReadyDependencies;
+    private getReadyUrlEnv;
+    private onReadinessHold;
+    private pollReadinessRow;
+    private startReadinessProbe;
+    private failReadiness;
+    private hasReadyWaiter;
+    private skipWaiter;
+    private recordReadiness;
+    private publishReadiness;
+    private readReadyUrl;
+    private readinessOf;
+    private armReadiness;
+    private abortReadiness;
+    private abortAllReadiness;
+    private failTaskBeforeStart;
     private preRunSteps;
     private postRunSteps;
     /**
@@ -297,6 +340,7 @@ export declare class TaskOrchestrator {
      */
     private recordContinuousTerminalOutput;
     private scheduleNextTasksAndReleaseThreads;
+    private releaseThreads;
     private complete;
     /**
      * Unified task completion handler for a set of tasks.