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

package/dist/src/tasks-runner/init-tasks-runner.js

@@ -11,8 +11,9 @@ const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const client_1 = require("../daemon/client/client");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
-async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
+function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations) {
     (0, dotenv_1.loadRootEnvFiles)();
+    fullTaskGraph = withEdgeObjects(fullTaskGraph);
     const invokeRunnerTerminalLifecycle = new invoke_runner_terminal_output_life_cycle_1.InvokeRunnerTerminalOutputLifeCycle(tasks);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -43,82 +44,138 @@ async function createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, li
         lifeCycle: compositedLifeCycle,
     };
     (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, 
+    return new task_orchestrator_1.TaskOrchestrator(hasher, null, tasks, projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, 
     // No argv on this path, so the output-style middleware never ran and both
     // fields are unset - this always renders `static-failures-only`. `nx.json`'s
     // `outputStyle` does not reach them; it merges under its own name.
     nxArgs.specifiedOutputStyle, nxArgs.resolvedOutputStyle ?? 'static-failures-only', fullTaskGraph);
-    await orchestrator.init();
-    orchestrator.processAllScheduledTasks();
-    return orchestrator;
+}
+// A client bundle built before edges became objects hands plain task ids
+function withEdgeObjects(taskGraph) {
+    const normalize = (edges) => Object.fromEntries(Object.entries(edges).map(([taskId, taskEdges]) => [
+        taskId,
+        taskEdges.map((edge) => typeof edge === 'string' ? { id: edge } : edge),
+    ]));
+    return {
+        ...taskGraph,
+        dependencies: normalize(taskGraph.dependencies),
+        continuousDependencies: normalize(taskGraph.continuousDependencies),
+    };
 }
 // Nothing awaits the dispose chains below, so an unhandled rejection would take
 // down a long-lived agent process.
 function logDisposeFailure(e) {
     console.error('Failed to dispose the task orchestrator:', e);
 }
+// Agents never call `TaskOrchestrator.run()`, which sizes these limits for a CLI
+// run. A call starts all its tasks at once while other calls' orchestrators stay
+// alive, so each adds room for its tasks and its own orchestrator until disposed.
+function reserveProcessListeners(tasks) {
+    const room = tasks.length + 1;
+    const adjust = (delta) => {
+        for (const emitter of [process, process.stdout, process.stderr]) {
+            const limit = emitter.getMaxListeners();
+            // 0 is unlimited
+            if (limit !== 0) {
+                emitter.setMaxListeners(limit + delta);
+            }
+        }
+    };
+    adjust(room);
+    return () => adjust(-room);
+}
 async function runDiscreteTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
 /** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
 ultracacheConfigurations) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
-    let groupId = 0;
-    let nextBatch = orchestrator.nextBatch();
+    const orchestrator = createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
+    const releaseProcessListeners = reserveProcessListeners(tasks);
     const batchResults = [];
-    /**
-     * Set of task ids that were part of batches
-     */
-    const batchTasks = new Set();
-    while (nextBatch) {
-        for (const task in nextBatch.taskGraph.tasks) {
-            batchTasks.add(task);
+    try {
+        await orchestrator.init();
+        let groupId = 0;
+        let nextBatch = orchestrator.nextBatch();
+        /**
+         * Set of task ids that were part of batches
+         */
+        const batchTasks = new Set();
+        while (nextBatch) {
+            for (const task in nextBatch.taskGraph.tasks) {
+                batchTasks.add(task);
+            }
+            batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
+            nextBatch = orchestrator.nextBatch();
         }
-        batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
-        nextBatch = orchestrator.nextBatch();
+        const discreteTasks = tasks.filter((task) => !batchTasks.has(task.id));
+        // Every task here starts directly, but the schedule hashes only the tasks it admits
+        orchestrator.processTasks(discreteTasks.map((task) => task.id));
+        // Bulk-resolve every discrete task's cache state in one shot —
+        // single SQL call plus parallel remote retrievals. Batches kicked
+        // off above continue running concurrently while we await this.
+        const cacheHits = await orchestrator.resolveCachedTasks(true, discreteTasks, groupId++);
+        const cacheHitsById = new Map(cacheHits.map((h) => [h.task.id, h]));
+        const taskResults = discreteTasks.map(async (task) => {
+            const hit = cacheHitsById.get(task.id);
+            if (hit)
+                return [hit];
+            return [await orchestrator.runTaskDirectly(true, task, groupId++)];
+        });
+        const results = [...batchResults, ...taskResults];
+        // Callers like Nx Cloud agents create an orchestrator per invocation in a
+        // long-lived process; release its process-level listeners once all tasks
+        // settle, otherwise every invocation's orchestrator stays reachable forever.
+        // Not awaited, so callers keep consuming handles as they settle; the forked
+        // runner's exit handler still reaps children until dispose() runs.
+        Promise.allSettled(results)
+            .then(() => orchestrator.dispose())
+            .finally(releaseProcessListeners)
+            .catch(logDisposeFailure);
+        return results;
+    }
+    catch (e) {
+        // A batch started before the failure can still fork a child, which only
+        // the orchestrator's exit handler reaps, so dispose once batches settle
+        Promise.allSettled(batchResults)
+            .then(() => orchestrator.dispose())
+            .finally(releaseProcessListeners)
+            .catch(logDisposeFailure);
+        throw e;
     }
-    const discreteTasks = tasks.filter((task) => !batchTasks.has(task.id));
-    // Bulk-resolve every discrete task's cache state in one shot —
-    // single SQL call plus parallel remote retrievals. Batches kicked
-    // off above continue running concurrently while we await this.
-    const cacheHits = await orchestrator.resolveCachedTasks(true, discreteTasks, groupId++);
-    const cacheHitsById = new Map(cacheHits.map((h) => [h.task.id, h]));
-    const taskResults = discreteTasks.map(async (task) => {
-        const hit = cacheHitsById.get(task.id);
-        if (hit)
-            return [hit];
-        return [await orchestrator.runTaskDirectly(true, task, groupId++)];
-    });
-    const results = [...batchResults, ...taskResults];
-    // Callers like Nx Cloud agents create an orchestrator per invocation in a
-    // long-lived process; release its process-level listeners once all tasks
-    // settle, otherwise every invocation's orchestrator stays reachable forever.
-    // Not awaited, so callers keep consuming handles as they settle; the forked
-    // runner's exit handler still reaps children until dispose() runs.
-    Promise.allSettled(results)
-        .then(() => orchestrator.dispose())
-        .catch(logDisposeFailure);
-    return results;
 }
 async function runContinuousTasks(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, 
 /** The set to hash from, e.g. from `importUltracacheConfigurations`; omitted hashes natively. */
 ultracacheConfigurations) {
-    const orchestrator = await createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
-    const runningTasks = tasks.reduce((current, task, index) => {
-        current[task.id] = orchestrator.startContinuousTask(task, index);
-        return current;
-    }, {});
-    // Unlike runDiscreteTasks, this must resolve at task start: callers keep
-    // the RunningTask handles to kill later, so disposal has to be deferred
-    // until every task actually exits.
-    Promise.allSettled(Object.entries(runningTasks).map(async ([taskId, promise]) => {
-        const runningTask = await promise;
-        // A shared task is owned by another nx process; this orchestrator has
-        // no child to protect for it, so disposal does not wait on it.
-        if (runningTask instanceof shared_running_task_1.SharedRunningTask) {
-            return;
-        }
-        await orchestrator.waitForContinuousTaskExit(taskId);
-    }))
-        .then(() => orchestrator.dispose())
-        .catch(logDisposeFailure);
-    return runningTasks;
+    const orchestrator = createOrchestrator(tasks, projectGraph, fullTaskGraph, nxJson, lifeCycle, ultracacheConfigurations);
+    const releaseProcessListeners = reserveProcessListeners(tasks);
+    try {
+        await orchestrator.init();
+        orchestrator.processTasks(tasks.map((task) => task.id));
+        const runningTasks = tasks.reduce((current, task, index) => {
+            current[task.id] = orchestrator.startContinuousTask(task, index);
+            return current;
+        }, {});
+        // Unlike runDiscreteTasks, this must resolve at task start: callers keep
+        // the RunningTask handles to kill later, so disposal has to be deferred
+        // until every task actually exits.
+        Promise.allSettled(Object.entries(runningTasks).map(async ([taskId, promise]) => {
+            const runningTask = await promise;
+            // A shared task is owned by another nx process; this orchestrator has
+            // no child to protect for it, so disposal does not wait on it.
+            if (runningTask instanceof shared_running_task_1.SharedRunningTask) {
+                return;
+            }
+            await orchestrator.waitForContinuousTaskExit(taskId);
+        }))
+            .then(() => orchestrator.dispose())
+            .finally(releaseProcessListeners)
+            .catch(logDisposeFailure);
+        return runningTasks;
+    }
+    catch (e) {
+        // A failure before the disposal chain above never reaches it
+        orchestrator
+            .dispose()
+            .finally(releaseProcessListeners)
+            .catch(logDisposeFailure);
+        throw e;
+    }
 }

package/dist/src/tasks-runner/life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { Task } from '../config/task-graph';
-import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
+import { BatchInfo, BatchStatus, ExternalObject, PerformanceSummaryPayload, TaskReadiness, TaskResult, TaskStatus as NativeTaskStatus } from '../native';
 import { TaskStatus } from './tasks-runner';
 /**
  * The result of a completed {@link Task}.
@@ -48,6 +48,8 @@ export interface LifeCycle {
     registerRunningTaskWithEmptyParser?(taskId: string): void;
     appendTaskOutput?(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
+    /** Only continuous tasks that declare a `readyWhen` report readiness. */
+    setTaskReadiness?(taskId: string, readiness: TaskReadiness): void;
     setTaskTiming?(taskId: string, startTime: number, endTime: number): void;
     registerForcedShutdownCallback?(callback: () => void): void;
     setEstimatedTaskTimings?(timings: Record<string, number>): void;
@@ -82,6 +84,7 @@ export declare class CompositeLifeCycle implements LifeCycle {
     registerRunningTaskWithEmptyParser(taskId: string): void;
     appendTaskOutput(taskId: string, output: string, isPtyTask: boolean): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
+    setTaskReadiness(taskId: string, readiness: TaskReadiness): void;
     setTaskTiming(taskId: string, startTime: number, endTime: number): void;
     registerForcedShutdownCallback(callback: () => void): void;
     setEstimatedTaskTimings(timings: Record<string, number>): void;

package/dist/src/tasks-runner/life-cycle.js

@@ -95,6 +95,13 @@ class CompositeLifeCycle {
             }
         }
     }
+    setTaskReadiness(taskId, readiness) {
+        for (let l of this.lifeCycles) {
+            if (l.setTaskReadiness) {
+                l.setTaskReadiness(taskId, readiness);
+            }
+        }
+    }
     setTaskTiming(taskId, startTime, endTime) {
         for (let l of this.lifeCycles) {
             if (l.setTaskTiming) {

package/dist/src/tasks-runner/life-cycles/performance-analysis.d.ts

@@ -4,6 +4,8 @@ import { TaskResult } from '../life-cycle';
 export interface TaskTiming {
     startTime?: number;
     endTime?: number;
+    /** When a continuous task passed its `readyWhen` check. */
+    readyTime?: number;
     continuous: boolean;
 }
 /** A discrete task that ran, with its window and whether it monopolizes the pool (`parallelism: false`). */
@@ -122,8 +124,9 @@ export declare class PerformanceAnalysis {
     private finishEstimate;
     /**
      * Earliest this task became eligible, independent of slots: the latest of run
-     * start, dependency ends, any continuous dependency's *start* (an ordering
-     * constraint, not contention), and any earlier batch sibling's end.
+     * start, dependency ends, any continuous dependency's *start*, or its
+     * readiness when the edge waits for it (an ordering constraint, not
+     * contention), and any earlier batch sibling's end.
      */
     private readyTime;
     /**

package/dist/src/tasks-runner/life-cycles/performance-analysis.js

@@ -101,7 +101,9 @@ class PerformanceAnalysis {
      */
     predecessorsFor(id, durations) {
         const start = this.timings.get(id)?.startTime ?? Infinity;
-        const deps = (this.taskGraph.dependencies[id] ?? []).filter((d) => durations.has(d));
+        const deps = (this.taskGraph.dependencies[id] ?? [])
+            .map((d) => d.id)
+            .filter((d) => durations.has(d));
         const siblings = (this.batchSiblings.get(id) ?? []).filter((s) => {
             const sEnd = this.timings.get(s)?.endTime;
             return durations.has(s) && sEnd != null && sEnd <= start;
@@ -142,22 +144,26 @@ class PerformanceAnalysis {
     }
     /**
      * Earliest this task became eligible, independent of slots: the latest of run
-     * start, dependency ends, any continuous dependency's *start* (an ordering
-     * constraint, not contention), and any earlier batch sibling's end.
+     * start, dependency ends, any continuous dependency's *start*, or its
+     * readiness when the edge waits for it (an ordering constraint, not
+     * contention), and any earlier batch sibling's end.
      */
     readyTime(id, runStart) {
         const start = this.timings.get(id)?.startTime;
         let result = runStart;
         for (const dep of this.taskGraph.dependencies[id] ?? []) {
-            const end = this.timings.get(dep)?.endTime;
+            const end = this.timings.get(dep.id)?.endTime;
             if (end != null) {
                 result = Math.max(result, end);
             }
         }
         for (const cdep of this.taskGraph.continuousDependencies?.[id] ?? []) {
-            const cStart = this.timings.get(cdep)?.startTime;
-            if (cStart != null) {
-                result = Math.max(result, cStart);
+            const producer = this.timings.get(cdep.id);
+            const usable = cdep.waitFor === 'ready'
+                ? (producer?.readyTime ?? producer?.startTime)
+                : producer?.startTime;
+            if (usable != null) {
+                result = Math.max(result, usable);
             }
         }
         for (const sibling of this.batchSiblings.get(id) ?? []) {

package/dist/src/tasks-runner/life-cycles/performance-life-cycle.d.ts

@@ -1,4 +1,4 @@
-import type { BatchInfo, PerformanceSummaryPayload } from '../../native';
+import { TaskReadiness, type BatchInfo, type PerformanceSummaryPayload } from '../../native';
 import { TaskGraph } from '../../config/task-graph';
 import { LifeCycle, TaskResult } from '../life-cycle';
 import { type PerformanceLifeCycleOptions, type PerformanceSummary } from './performance-analysis';
@@ -14,8 +14,8 @@ import { type PerformanceLifeCycleOptions, type PerformanceSummary } from './per
  * coordinator time (hashing, scheduling, continuous-dep waits).
  *
  * Scope: discrete tasks only. Continuous tasks (no end time) are excluded; a
- * discrete task's wait for a continuous dependency to start is eligibility, not
- * contention.
+ * discrete task's wait for a continuous dependency to start, or to be ready, is
+ * eligibility, not contention.
  */
 export declare class PerformanceLifeCycle implements LifeCycle {
     private readonly taskGraph;
@@ -34,6 +34,7 @@ export declare class PerformanceLifeCycle implements LifeCycle {
      */
     startCommand(_threadCount?: number, parallel?: number): void;
     registerRunningBatch(_batchId: string, batchInfo: BatchInfo): void;
+    setTaskReadiness(taskId: string, readiness: TaskReadiness): void;
     endTasks(taskResults: TaskResult[]): void;
     private entry;
     /** Analyze the collected timings into a structured summary, or `null` when no discrete task timings were recorded. */

package/dist/src/tasks-runner/life-cycles/performance-life-cycle.js

@@ -20,8 +20,8 @@ const performance_analysis_1 = require("./performance-analysis");
  * coordinator time (hashing, scheduling, continuous-dep waits).
  *
  * Scope: discrete tasks only. Continuous tasks (no end time) are excluded; a
- * discrete task's wait for a continuous dependency to start is eligibility, not
- * contention.
+ * discrete task's wait for a continuous dependency to start, or to be ready, is
+ * eligibility, not contention.
  */
 class PerformanceLifeCycle {
     constructor(taskGraph, options = {}) {
@@ -51,6 +51,13 @@ class PerformanceLifeCycle {
             this.batchSiblings.set(id, batchInfo.taskIds.filter((other) => other !== id));
         }
     }
+    setTaskReadiness(taskId, readiness) {
+        const entry = this.entry(taskId);
+        // Each waiter polling a shared producer reports Ready; the first one counts.
+        if (readiness === 1 /* TaskReadiness.Ready */ && entry.readyTime == null) {
+            entry.readyTime = Date.now();
+        }
+    }
     endTasks(taskResults) {
         // Called incrementally (per group/batch); accumulate so the last call sees every timing.
         for (const { task, status } of taskResults) {

package/dist/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -61,8 +61,11 @@ class StaticRunManyTerminalOutputLifeCycle {
         }
         // A stopped task was killed mid-flight, so the run did not complete even
         // though nothing outright failed. `didCommandComplete` already treats it
-        // that way; reporting "Successfully ran" here would contradict it.
-        if (this.failedTasks.length === 0 && this.stoppedTasks.length === 0) {
+        // that way; reporting "Successfully ran" here would contradict it. A
+        // discrete task that never reported was skipped, which fails the run too.
+        if (this.failedTasks.length === 0 &&
+            this.stoppedTasks.length === 0 &&
+            !this.skippedTasks().some((t) => !t.continuous)) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0
                 ? [

package/dist/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.js

@@ -71,7 +71,10 @@ class StaticRunOneTerminalOutputLifeCycle {
         output_1.output.addNewline();
         // A stopped task was killed mid-flight, so the run did not complete even
         // though nothing outright failed — matching run-many and didCommandComplete.
-        if (this.failedTasks.length === 0 && this.stoppedTasks.length === 0) {
+        // A discrete task that never reported was skipped, which fails the run too.
+        if (this.failedTasks.length === 0 &&
+            this.stoppedTasks.length === 0 &&
+            !this.skippedTasks().some((t) => !t.continuous)) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0
                 ? [

package/dist/src/tasks-runner/life-cycles/summary-terminal-output-life-cycle.js

@@ -100,7 +100,11 @@ class SummaryTerminalOutputLifeCycle {
         }
         bodyLines.push('', output_1.output.dim('Re-run with --output-style=static to inline logs.'));
         const title = this.countsLine(skipped);
-        if (this.failed.length > 0 || this.stopped.length > 0) {
+        // A discrete task that never reported was skipped, which fails the run; a
+        // continuous one nothing needed is never started
+        if (this.failed.length > 0 ||
+            this.stopped.length > 0 ||
+            this.tasks.some((t) => !t.continuous && !this.completed.has(t.id))) {
             output_1.output.error({ title, bodyLines });
         }
         else {

package/dist/src/tasks-runner/pseudo-ipc.d.ts

@@ -44,5 +44,6 @@ export declare class PseudoIPCClient {
     sendMessageToParent(message: Serializable): void;
     notifyChildIsReady(id: string): void;
     onMessageFromParent(forkId: string, onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    unref(): this;
     close(): void;
 }

package/dist/src/tasks-runner/pseudo-ipc.js

@@ -150,6 +150,10 @@ class PseudoIPCClient {
         this.socket.on('error', onError);
         return this;
     }
+    unref() {
+        this.socket?.unref();
+        return this;
+    }
     close() {
         this.socket?.destroy();
     }

package/dist/src/tasks-runner/pseudo-terminal.d.ts

@@ -58,7 +58,7 @@ export declare class PseudoTtyProcess implements RunningTask {
         terminalOutput: string;
     }>;
     onExit(callback: (code: number, terminalOutput: string) => void): void;
-    onOutput(callback: (message: string) => void): void;
+    onOutput(callback: (message: string, isCommandHeader: boolean) => void): void;
     getPid(): number | undefined;
     kill(s?: NodeJS.Signals): Promise<void>;
     getPtyHandles(): import("../native").ExternalObject<[import("../native").ParserArc, import("../native").WriterArc, import("../native").MasterArc]>;

package/dist/src/tasks-runner/pseudo-terminal.js

@@ -109,12 +109,12 @@ class PseudoTtyProcess {
         this.exitCallbacks = [];
         this.outputCallbacks = [];
         this.terminalOutputChunks = [];
-        childProcess.onOutput((chunk) => {
+        childProcess.onOutput((chunk, isCommandHeader) => {
             if (!this.quiet) {
                 output_1.output.noteExternalWrite(chunk);
             }
             this.terminalOutputChunks.push(chunk);
-            this.outputCallbacks.forEach((cb) => cb(chunk));
+            this.outputCallbacks.forEach((cb) => cb(chunk, isCommandHeader));
         });
         childProcess.onExit((message) => {
             this.isAlive = false;

package/dist/src/tasks-runner/readiness/executor-ready-signal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Passes the executor's results through unchanged and signals the task ready
+ * at the `baseUrl` of the first successful result that has one.
+ */
+export declare function signalReadyAtBaseUrl<T extends {
+    success: boolean;
+}>(results: AsyncIterableIterator<T>): AsyncIterableIterator<T>;

package/dist/src/tasks-runner/readiness/executor-ready-signal.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalReadyAtBaseUrl = signalReadyAtBaseUrl;
+const ready_signal_1 = require("./ready-signal");
+/**
+ * Passes the executor's results through unchanged and signals the task ready
+ * at the `baseUrl` of the first successful result that has one.
+ */
+async function* signalReadyAtBaseUrl(results) {
+    const iterator = results[Symbol.asyncIterator]();
+    let signalled = false;
+    while (true) {
+        const result = await iterator.next();
+        if (result.done) {
+            return result.value;
+        }
+        if (!signalled) {
+            const url = getReadySignalUrl(result.value);
+            if (url) {
+                signalled = true;
+                (0, ready_signal_1.emitReadySignal)(url);
+            }
+        }
+        yield result.value;
+    }
+}
+function getReadySignalUrl(result) {
+    const { baseUrl } = result;
+    if (result.success !== true ||
+        typeof baseUrl !== 'string' ||
+        !URL.canParse(baseUrl)) {
+        return undefined;
+    }
+    const url = new URL(baseUrl);
+    // `localhost:4200` parses too, with `localhost:` as its protocol
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return undefined;
+    }
+    if (url.hostname === '0.0.0.0' || url.hostname === '[::]') {
+        url.hostname = 'localhost';
+    }
+    return url.href;
+}

package/dist/src/tasks-runner/readiness/probes.d.ts

@@ -0,0 +1,14 @@
+import type { RunningTask } from '../running-tasks/running-task';
+import type { ReadySignalServer } from './ready-signal-server';
+import { type NormalizedReadyWhen } from './ready-when';
+export interface ReadinessProbeContext {
+    taskId: string;
+    runningTask: RunningTask;
+    cwd: string;
+    signal: AbortSignal;
+    readySignal?: ReadySignalServer;
+}
+export interface Readiness {
+    url?: string;
+}
+export declare function waitForReadiness(readyWhen: NormalizedReadyWhen, context: ReadinessProbeContext): Promise<Readiness>;

package/dist/src/tasks-runner/readiness/probes.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForReadiness = waitForReadiness;
+const native_1 = require("../../native");
+const startup_host_1 = require("./startup-host");
+const ready_when_1 = require("./ready-when");
+// Never rejects for a transient probe error: every failure is retried until
+// the deadline.
+async function waitForReadiness(readyWhen, context) {
+    if (readyWhen.kind === 'signal') {
+        return waitForSignal(readyWhen, context);
+    }
+    await waitForCheck(readyWhen, context);
+    return {};
+}
+async function waitForCheck(readyWhen, context) {
+    if (native_1.IS_WASM) {
+        throw new Error(`The WASM build of Nx does not support "readyWhen", so "${context.taskId}" cannot be probed for readiness.`);
+    }
+    if (readyWhen.kind === 'logMatches') {
+        return waitForLogMatch(readyWhen, context);
+    }
+    const probe = new native_1.ReadinessProbe({
+        timeout: readyWhen.timeout,
+        interval: readyWhen.interval,
+        ...(readyWhen.kind === 'url'
+            ? { url: readyWhen.url }
+            : readyWhen.kind === 'port'
+                ? { port: readyWhen.port, host: (0, startup_host_1.resolveStartupHost)(readyWhen.host) }
+                : { command: readyWhen.command, env: readyWhen.env }),
+    }, context.cwd);
+    const cancel = () => probe.cancel();
+    context.signal.addEventListener('abort', cancel);
+    if (context.signal.aborted) {
+        probe.cancel();
+    }
+    let ready;
+    try {
+        ready = await probe.wait();
+    }
+    finally {
+        context.signal.removeEventListener('abort', cancel);
+    }
+    if (!ready) {
+        throw context.signal.aborted
+            ? (0, ready_when_1.notReadyError)(context.taskId, 'exited')
+            : (0, ready_when_1.readinessTimeoutError)(context.taskId, readyWhen);
+    }
+}
+// Ready on the producer's `ready` message, which a message sent before the
+// check started counts as
+function waitForSignal(readyWhen, context) {
+    return new Promise((resolve, reject) => {
+        let unsubscribe = () => { };
+        let settled = false;
+        const settle = (error, readiness) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            unsubscribe();
+            context.signal.removeEventListener('abort', onAbort);
+            error ? reject(error) : resolve(readiness);
+        };
+        const onAbort = () => settle((0, ready_when_1.notReadyError)(context.taskId, 'exited'));
+        const timer = setTimeout(() => settle((0, ready_when_1.readinessTimeoutError)(context.taskId, readyWhen)), readyWhen.timeout);
+        timer.unref();
+        context.signal.addEventListener('abort', onAbort);
+        if (context.signal.aborted) {
+            onAbort();
+            return;
+        }
+        const stop = context.readySignal?.subscribe(context.taskId, (message) => settle(null, message.url ? { url: message.url } : {}));
+        if (settled) {
+            stop?.();
+            return;
+        }
+        unsubscribe = stop ?? unsubscribe;
+    });
+}
+function waitForLogMatch(readyWhen, context) {
+    return new Promise((resolve, reject) => {
+        const matcher = new native_1.LogMatcher(readyWhen.logMatches);
+        let settled = false;
+        const settle = (error) => {
+            settled = true;
+            clearTimeout(timer);
+            context.signal.removeEventListener('abort', onAbort);
+            error ? reject(error) : resolve();
+        };
+        const onAbort = () => settle((0, ready_when_1.notReadyError)(context.taskId, 'exited'));
+        const timer = setTimeout(() => settle((0, ready_when_1.readinessTimeoutError)(context.taskId, readyWhen)), readyWhen.timeout);
+        timer.unref();
+        context.signal.addEventListener('abort', onAbort);
+        context.runningTask.onOutput((chunk, isCommandHeader) => {
+            if (!settled && !isCommandHeader && matcher.feed(chunk)) {
+                settle();
+            }
+        });
+    });
+}

package/dist/src/tasks-runner/readiness/ready-signal-server.d.ts

@@ -0,0 +1,18 @@
+import { type ReadySignalMessage } from './ready-signal';
+export type ReadySignalListener = (message: ReadySignalMessage) => void;
+/**
+ * Receives the readiness signals of the producers this process starts. It
+ * does not depend on the pseudo terminal, which Windows and non-TTY runs lack.
+ */
+export declare class ReadySignalServer {
+    private readonly path;
+    private readonly server;
+    private started;
+    private listeners;
+    private early;
+    private issued;
+    env(taskId: string): Promise<NodeJS.ProcessEnv>;
+    subscribe(taskId: string, listener: ReadySignalListener): () => void;
+    close(): void;
+    private dispatch;
+}