tubeless 0.2.2 → 0.2.3

package/dist/core/pipeline-execute.js

@@ -3,16 +3,18 @@ import { PipelineChildError } from "./child-execution.js";
 import { brandTubelessError } from "../utilities/tubeless-error.js";
 import { createPipelineLifecycleObserver } from "./lifecycle.js";
 import { formatPipelineError } from "./pipeline-diagnostics.js";
-import { createRunId, RUN_MODEL_VERSION } from "./pipeline-ids.js";
+import { createRunId } from "./pipeline-ids.js";
 import { PIPELINE_FINALIZE_STEP_ID, compiledStepGraph, decideStepDisposition, planStepById, stepToPlanStep, } from "./pipeline-plan.js";
+import { PipelineRunState, isCancellationOnly, } from "./pipeline-run-state.js";
+import { evaluateStepSkip, executeStepAttempt, validateStepOutput, } from "./pipeline-step-executor.js";
+import { PipelineBoundaryValidationError, validateStandardSchema } from "./pipeline-validation.js";
 import { createPipelineTraceEmitter } from "../tracing/tracing-internal.js";
-function isCancellationOnly(errors) {
-    return errors.length > 0 && errors.every(({ kind }) => kind === "cancellation");
-}
-function terminalRunStatus(errors) {
-    if (errors.length === 0)
-        return "completed";
-    return isCancellationOnly(errors) ? "cancelled" : "failed";
+const PIPELINE_RUN_ID_OBSERVER = Symbol.for("tubeless.pipeline.runIdObserver");
+/** Observe an execution ID from an internal host without allowing it to be overridden. */
+export function observePipelineRunId(context, observer) {
+    // SAFETY: the internal observer is intentionally hidden from the returned
+    // public type and can observe, but never choose, the generated run ID.
+    return { ...context, [PIPELINE_RUN_ID_OBSERVER]: observer };
 }
 const PIPELINE_LOGGER_BASE = Symbol("pipelineLoggerBase");
 function basePipelineLogger(log) {
@@ -46,46 +48,6 @@ export class PipelineExecutionError extends Error {
         brandTubelessError(this, "pipeline-execution");
     }
 }
-class PipelineBoundaryValidationError extends Error {
-    issues;
-    constructor(message, issues, cause) {
-        super(message, cause === undefined ? undefined : { cause });
-        this.issues = issues;
-        this.name = "PipelineBoundaryValidationError";
-    }
-}
-function normalizeValidationPath(path) {
-    if (!path || path.length === 0)
-        return undefined;
-    return path.map((segment) => {
-        const key = typeof segment === "object" && segment !== null ? segment.key : segment;
-        return typeof key === "number" || typeof key === "string" ? key : String(key);
-    });
-}
-function renderValidationIssue(issue) {
-    const location = issue.path?.map(String).join(".");
-    return location ? `${location}: ${issue.message}` : issue.message;
-}
-async function validateStandardSchema(schema, value, boundary) {
-    let result;
-    try {
-        result = await schema["~standard"].validate(value);
-    }
-    catch (error) {
-        throw new PipelineBoundaryValidationError(`${boundary} schema (${schema["~standard"].vendor}) threw while validating`, [], error);
-    }
-    if (result.issues) {
-        const issues = result.issues.map((issue) => {
-            const path = normalizeValidationPath(issue.path);
-            const normalized = { message: issue.message };
-            if (path)
-                normalized.path = path;
-            return normalized;
-        });
-        throw new PipelineBoundaryValidationError(`${boundary} validation failed: ${issues.map(renderValidationIssue).join("; ")}`, issues);
-    }
-    return result.value;
-}
 const MAX_PIPELINE_CAUSE_DEPTH = 8;
 function readErrorField(value, field) {
     try {
@@ -201,81 +163,29 @@ export function isPipelineCancellation(error, runtime) {
 function isCancelledResult(result) {
     return result.status === "cancelled";
 }
-function errorRunResult(runtime, pipelineId, dryRun, startedAt, errors, identity) {
-    const finishedAtMs = runtime.now();
-    const result = {
-        pipelineId,
-        dryRun,
-        errors,
-        finalized: false,
-        finishedAtMs,
-        runId: identity.runId,
-        startedAtMs: startedAt,
-        status: terminalRunStatus(errors),
-        steps: [],
-        version: RUN_MODEL_VERSION,
-    };
-    if (identity.parentRunId)
-        result.parentRunId = identity.parentRunId;
-    return result;
-}
 function throwIfAborted(runtime) {
     throwIfSignalAborted(runtime.signal, "Pipeline run");
 }
-function recordSkip(step, stepId, reports, reportsByStepId, reason, message, dependencyId, attemptId, startedAtMs, finishedAtMs) {
-    const report = {
-        id: stepId,
-        name: step.name,
-        description: step.description,
-        finishedAtMs,
-        reason,
-        status: "skipped",
-    };
-    if (attemptId)
-        report.attemptId = attemptId;
-    if (startedAtMs !== undefined)
-        report.startedAtMs = startedAtMs;
-    if (dependencyId)
-        report.dependencyId = dependencyId;
-    if (message)
-        report.message = message;
-    reports.push(report);
-    reportsByStepId.set(stepId, report);
-    return report;
-}
-function normalizeStepSkipDecision(decision) {
-    if (decision == null || decision === false)
-        return null;
-    if (typeof decision === "string") {
-        const reason = decision.trim();
-        return reason.length > 0 ? { reason } : null;
-    }
-    if (typeof decision === "object" && typeof decision.reason === "string") {
-        const reason = decision.reason.trim();
-        if (reason.length === 0)
-            return null;
-        return { reason, value: decision.value };
-    }
-    return null;
-}
 export async function executePlannedRun(input) {
     const { compiled, controls, runtime } = input;
-    const optionsSchema = compiled.optionsSchema;
-    const targetIds = compiled.targetIds;
-    // SAFETY: `domainOptions` is the user-supplied options object; if a schema
-    // is present it is re-validated below before assignment to `pipelineOptions`.
-    let pipelineOptions = input.domainOptions;
-    const startedAt = runtime.now();
-    const runId = runtime.runId ?? createRunId(compiled.id);
-    const parentRunId = runtime.parentRunId;
+    const startedAtMs = runtime.now();
+    const runId = createRunId(compiled.id);
+    try {
+        // SAFETY: only internal hosts attach this observation callback. A callback
+        // failure must not change whether the pipeline execution itself can start.
+        runtime[PIPELINE_RUN_ID_OBSERVER]?.(runId);
+    }
+    catch {
+        // Ignore observation failures; execution identity remains package-owned.
+    }
+    const correlationId = runtime.correlationId ?? runtime.runId;
     const identity = { runId };
-    if (parentRunId)
-        identity.parentRunId = parentRunId;
+    if (correlationId !== undefined)
+        identity.correlationId = correlationId;
+    if (runtime.parentRunId)
+        identity.parentRunId = runtime.parentRunId;
     const dryRun = controls.dryRun === true;
-    const trace = createPipelineTraceEmitter(compiled.id, runtime.tracing, basePipelineLogger(runtime.log), {
-        ...identity,
-        itemKey: runtime.tracing?.itemKey,
-    }, runtime.now);
+    const trace = createPipelineTraceEmitter(compiled.id, runtime.tracing, basePipelineLogger(runtime.log), { ...identity, itemKey: runtime.tracing?.itemKey }, runtime.now);
     const lifecycle = createPipelineLifecycleObserver(compiled.id, runtime, trace);
     const tracedLogger = (stepId, attemptId) => {
         if (!trace)
@@ -298,53 +208,18 @@ export async function executePlannedRun(input) {
         log[PIPELINE_LOGGER_BASE] = base;
         return log;
     };
-    let nextAttemptSequence = 0;
-    const beginAttempt = (stepId, startedAtMs = runtime.now()) => ({
-        attemptId: `${runId}:attempt:${(nextAttemptSequence += 1).toString(36)}`,
-        startedAtMs,
-        stepId,
-    });
-    const currentStepStatuses = new Map();
-    const publishStepStatus = (event, traceStatus = true) => {
-        const previous = currentStepStatuses.get(event.step.id);
-        const valid = (previous === undefined && event.status === "planned") ||
-            (previous === "planned" &&
-                (event.status === "running" ||
-                    event.status === "skipped" ||
-                    event.status === "cancelled")) ||
-            (previous === "running" &&
-                (event.status === "running" ||
-                    event.status === "completed" ||
-                    event.status === "skipped" ||
-                    event.status === "cancelled" ||
-                    event.status === "failed"));
-        if (!valid) {
-            throw new Error(`Invalid step status transition for ${event.step.id}: ${previous ?? "unobserved"} -> ${event.status}`);
-        }
-        currentStepStatuses.set(event.step.id, event.status);
-        lifecycle.stepStatus(event, traceStatus);
-    };
-    const publishStepReport = (step, report) => {
-        switch (report.status) {
-            case "cancelled":
-            case "failed":
-            case "skipped":
-            case "completed":
-                publishStepStatus({ ...report, pipelineId: compiled.id, step });
-        }
-    };
-    const runPlan = input.plan;
-    const plannedSteps = planStepById(runPlan);
-    lifecycle.pipelineStart(runPlan, targetIds);
-    if (!runPlan.ok) {
-        const result = errorRunResult(runtime, compiled.id, dryRun, startedAt, runPlan.errors, identity);
-        lifecycle.pipelineComplete(result);
-        await lifecycle.flush();
-        return result;
+    const state = new PipelineRunState(compiled.id, dryRun, startedAtMs, identity, runtime.now, lifecycle);
+    state.start(input.plan, compiled.targetIds);
+    if (!input.plan.ok) {
+        state.recordRunErrors(input.plan.errors);
+        return state.finish();
     }
-    if (optionsSchema) {
+    // SAFETY: `domainOptions` is the user-supplied options object; if a schema
+    // is present it is re-validated below before assignment to `pipelineOptions`.
+    let pipelineOptions = input.domainOptions;
+    if (compiled.optionsSchema) {
         try {
-            const validated = await validateStandardSchema(optionsSchema, input.domainOptions, `Pipeline ${compiled.id} options`);
+            const validated = await validateStandardSchema(compiled.optionsSchema, input.domainOptions, `Pipeline ${compiled.id} options`);
             if (typeof validated !== "object" || validated === null || Array.isArray(validated)) {
                 throw new PipelineBoundaryValidationError(`Pipeline ${compiled.id} options schema returned a non-object value`, [{ message: "Expected the validated options value to be an object" }]);
             }
@@ -353,25 +228,18 @@ export async function executePlannedRun(input) {
             pipelineOptions = validated;
         }
         catch (error) {
-            const pipelineError = toPipelineError(error, {
-                code: "TUBELESS_OPTIONS_VALIDATION_FAILED",
-                kind: "validation",
-                phase: "execution",
-            });
-            const result = errorRunResult(runtime, compiled.id, dryRun, startedAt, [pipelineError], identity);
-            lifecycle.pipelineComplete(result);
-            await lifecycle.flush();
-            return result;
+            state.recordRunErrors([
+                toPipelineError(error, {
+                    code: "TUBELESS_OPTIONS_VALIDATION_FAILED",
+                    kind: "validation",
+                    phase: "execution",
+                }),
+            ]);
+            return state.finish();
         }
     }
-    for (const step of runPlan.steps) {
-        publishStepStatus({ pipelineId: compiled.id, status: "planned", step });
-    }
-    const outputs = new Map();
-    const reports = [];
-    const errors = [];
-    const reportsByStepId = new Map();
-    let completed = true;
+    for (const step of input.plan.steps)
+        state.planStep(step);
     const executionContext = {
         ...runtime,
         dryRun,
@@ -380,50 +248,50 @@ export async function executePlannedRun(input) {
         runId,
         trace: trace?.context,
     };
-    if (parentRunId)
-        executionContext.parentRunId = parentRunId;
+    if (correlationId !== undefined)
+        executionContext.correlationId = correlationId;
+    if (runtime.parentRunId)
+        executionContext.parentRunId = runtime.parentRunId;
+    const plannedSteps = planStepById(input.plan);
     const stepsById = new Map(compiled.orderedSteps.map((step) => [step.id, step]));
-    // `runPlan.steps` is already topologically ordered. Rehydrate from the original step
-    // objects so callers still get the typed `run` functions rather than plan metadata.
+    // `input.plan.steps` is already topologically ordered. Rehydrate from the original step
+    // objects so callers still get the typed handlers rather than plan metadata.
     // SAFETY: every planned step id originates from `compiled.orderedSteps`, so the
     // map lookup always finds the matching `AnyStep<TOptions>`.
-    const orderedSteps = runPlan.steps.map((step) => stepsById.get(step.id));
+    const orderedSteps = input.plan.steps.map((step) => stepsById.get(step.id));
+    const plannedStepFor = (step) => plannedSteps.get(step.id) ??
+        stepToPlanStep(step, true, undefined, undefined, compiledStepGraph(compiled, step));
     const recordRemainingStates = (fromIndex, failedStepId, cancellationError) => {
         for (let index = fromIndex; index < orderedSteps.length; index++) {
             const step = orderedSteps[index];
-            const plannedStep = plannedSteps.get(step.id) ??
-                stepToPlanStep(step, true, undefined, undefined, compiledStepGraph(compiled, step));
+            const plannedStep = plannedStepFor(step);
             if (plannedStep.skipReason) {
                 const dependencyId = plannedStep.skipReason === "unmet-dependency"
                     ? plannedStep.dependencies.find((id) => plannedSteps.get(id)?.skipReason !== undefined)
                     : undefined;
-                const report = recordSkip(step, step.id, reports, reportsByStepId, plannedStep.skipReason, undefined, dependencyId, undefined, undefined, runtime.now());
-                publishStepReport(plannedStep, report);
-                continue;
+                state.skipStep(plannedStep, {
+                    reason: plannedStep.skipReason,
+                    dependencyId,
+                });
             }
-            if (cancellationError) {
-                const report = {
-                    id: step.id,
-                    name: step.name,
-                    description: step.description,
-                    error: { ...cancellationError, stepId: step.id },
-                    finishedAtMs: runtime.now(),
-                    status: "cancelled",
-                };
-                reports.push(report);
-                reportsByStepId.set(step.id, report);
-                publishStepReport(plannedStep, report);
-                continue;
+            else if (cancellationError) {
+                state.cancelStep(plannedStep, { ...cancellationError, stepId: step.id }, false);
+            }
+            else {
+                state.skipStep(plannedStep, {
+                    reason: "fail-fast",
+                    message: failedStepId
+                        ? `Not run because fail-fast stopped after ${failedStepId} failed.`
+                        : "Not run because the pipeline was aborted before this step started.",
+                    dependencyId: failedStepId,
+                });
             }
-            const report = recordSkip(step, step.id, reports, reportsByStepId, "fail-fast", failedStepId
-                ? `Not run because fail-fast stopped after ${failedStepId} failed.`
-                : "Not run because the pipeline was aborted before this step started.", failedStepId, undefined, undefined, runtime.now());
-            publishStepReport(plannedStep, report);
         }
     };
     const cancelBeforeStepStart = (stepId, stepIndex) => {
         try {
             throwIfAborted(runtime);
+            return false;
         }
         catch (error) {
             const pipelineError = toPipelineError(error, {
@@ -432,14 +300,12 @@ export async function executePlannedRun(input) {
                 phase: "execution",
                 stepId,
             });
-            errors.push(pipelineError);
-            completed = false;
+            state.recordRunErrors([pipelineError]);
             recordRemainingStates(stepIndex, undefined, pipelineError);
             return true;
         }
-        return false;
     };
-    const recordStepExecutionFailure = (error, plannedStep, step, stepId, stepIndex, attempt) => {
+    const recordStepExecutionFailure = (error, plannedStep, stepIndex, attempt) => {
         const cancelled = isPipelineCancellation(error, runtime);
         const childFailure = error instanceof PipelineExecutionError || error instanceof PipelineChildError;
         const validationFailure = error instanceof PipelineBoundaryValidationError;
@@ -459,217 +325,109 @@ export async function executePlannedRun(input) {
                         ? "child"
                         : "step",
             phase: "execution",
-            stepId,
+            stepId: plannedStep.id,
         });
-        errors.push(pipelineError);
-        const finishedAtMs = runtime.now();
-        const report = cancelled
-            ? {
-                attemptId: attempt.attemptId,
-                id: stepId,
-                name: step.name,
-                description: step.description,
-                error: pipelineError,
-                finishedAtMs,
-                startedAtMs: attempt.startedAtMs,
-                status: "cancelled",
-            }
-            : {
-                attemptId: attempt.attemptId,
-                id: stepId,
-                name: step.name,
-                description: step.description,
-                error: pipelineError,
-                finishedAtMs,
-                startedAtMs: attempt.startedAtMs,
-                status: "failed",
-            };
-        reports.push(report);
-        reportsByStepId.set(stepId, report);
-        publishStepReport(plannedStep, report);
-        completed = false;
-        if (!controls.continueOnError) {
-            recordRemainingStates(stepIndex + 1, stepId, report.status === "cancelled" ? pipelineError : undefined);
-            return true;
-        }
-        return false;
+        state.failStep(plannedStep, attempt, pipelineError);
+        if (controls.continueOnError)
+            return false;
+        recordRemainingStates(stepIndex + 1, plannedStep.id, cancelled ? pipelineError : undefined);
+        return true;
     };
-    const recordPublishedStepValue = async (args) => {
-        let published = args.value;
-        let attempt = args.attempt;
-        if (args.step.outputSchema) {
-            if (!attempt) {
-                attempt = beginAttempt(args.stepId, runtime.now());
-                publishStepStatus({
-                    attemptId: attempt.attemptId,
-                    pipelineId: compiled.id,
-                    status: "running",
-                    step: args.plannedStep,
-                });
-            }
+    const recordPolicySkip = async (plannedStep, step, stepIndex, reason, value) => {
+        let attempt;
+        let published = value;
+        if (step.outputSchema) {
+            attempt = state.beginAttempt(plannedStep);
             try {
-                published = await validateStandardSchema(args.step.outputSchema, published, `Pipeline ${compiled.id} step ${args.stepId} output`);
+                published = await validateStepOutput(step, value, `Pipeline ${compiled.id} step ${step.id} output`);
             }
             catch (error) {
-                return recordStepExecutionFailure(error, args.plannedStep, args.step, args.stepId, args.stepIndex, attempt);
+                return recordStepExecutionFailure(error, plannedStep, stepIndex, attempt);
             }
         }
-        outputs.set(args.stepId, published);
-        if (args.kind === "complete") {
-            const completeAttempt = attempt;
-            const report = {
-                attemptId: completeAttempt.attemptId,
-                id: args.stepId,
-                name: args.step.name,
-                description: args.step.description,
-                finishedAtMs: runtime.now(),
-                startedAtMs: completeAttempt.startedAtMs,
-                status: "completed",
-            };
-            reports.push(report);
-            reportsByStepId.set(args.stepId, report);
-            publishStepReport(args.plannedStep, report);
-            return false;
-        }
-        const report = recordSkip(args.step, args.stepId, reports, reportsByStepId, "policy", args.skipMessage, undefined, attempt?.attemptId, attempt?.startedAtMs, runtime.now());
-        publishStepReport(args.plannedStep, report);
+        state.skipStep(plannedStep, {
+            attempt,
+            message: reason,
+            output: { value: published },
+            reason: "policy",
+        });
         return false;
     };
     for (const [stepIndex, step] of orderedSteps.entries()) {
-        const stepId = step.id;
-        const graph = compiledStepGraph(compiled, step);
-        const plannedStep = plannedSteps.get(stepId) ?? stepToPlanStep(step, true, undefined, undefined, graph);
-        if (cancelBeforeStepStart(stepId, stepIndex)) {
+        const plannedStep = plannedStepFor(step);
+        if (cancelBeforeStepStart(step.id, stepIndex))
             break;
-        }
+        const graph = compiledStepGraph(compiled, step);
         const disposition = decideStepDisposition({
             dryRun,
             graph,
             planned: plannedStep,
-            reportsByStepId,
+            reportsByStepId: state.reportsByStepId,
             step,
         });
         if (disposition.kind === "skip") {
-            const report = recordSkip(step, stepId, reports, reportsByStepId, disposition.reason, disposition.message, disposition.dependencyId, undefined, undefined, runtime.now());
-            publishStepReport(plannedStep, report);
+            state.skipStep(plannedStep, disposition);
             continue;
         }
         const inputEntries = [];
-        for (const dep of graph.dependsOn) {
-            inputEntries.push([dep.id, outputs.get(dep.id)]);
-        }
+        for (const dep of graph.dependsOn)
+            inputEntries.push([dep.id, state.outputs.get(dep.id)]);
         for (const dep of graph.optionalDependsOn) {
-            if (outputs.has(dep.id)) {
-                inputEntries.push([dep.id, outputs.get(dep.id)]);
-            }
+            if (state.outputs.has(dep.id))
+                inputEntries.push([dep.id, state.outputs.get(dep.id)]);
         }
-        const inputs = Object.fromEntries(inputEntries);
+        const stepInputs = Object.fromEntries(inputEntries);
         if (typeof step.skip === "function") {
             let skipDecision;
             try {
-                skipDecision = normalizeStepSkipDecision(await step.skip(inputs, { ...executionContext, log: tracedLogger(stepId) }));
+                skipDecision = await evaluateStepSkip(step, stepInputs, {
+                    ...executionContext,
+                    log: tracedLogger(step.id),
+                });
             }
             catch (error) {
-                const skipAttempt = beginAttempt(stepId, runtime.now());
-                publishStepStatus({
-                    attemptId: skipAttempt.attemptId,
-                    pipelineId: compiled.id,
-                    status: "running",
-                    step: plannedStep,
-                });
-                if (recordStepExecutionFailure(error, plannedStep, step, stepId, stepIndex, skipAttempt)) {
+                const attempt = state.beginAttempt(plannedStep);
+                if (recordStepExecutionFailure(error, plannedStep, stepIndex, attempt))
                     break;
-                }
                 continue;
             }
-            if (cancelBeforeStepStart(stepId, stepIndex)) {
+            if (cancelBeforeStepStart(step.id, stepIndex))
                 break;
-            }
             if (skipDecision) {
-                if (await recordPublishedStepValue({
-                    kind: "policy-skip",
-                    plannedStep,
-                    skipMessage: skipDecision.reason,
-                    step,
-                    stepId,
-                    stepIndex,
-                    value: skipDecision.value,
-                })) {
+                if (await recordPolicySkip(plannedStep, step, stepIndex, skipDecision.reason, skipDecision.value)) {
                     break;
                 }
                 continue;
             }
         }
-        const stepStartedAt = runtime.now();
-        const attempt = beginAttempt(stepId, stepStartedAt);
-        publishStepStatus({
-            attemptId: attempt.attemptId,
-            pipelineId: compiled.id,
-            status: "running",
-            step: plannedStep,
-        });
+        const attempt = state.beginAttempt(plannedStep);
         try {
-            let acceptsProgress = true;
-            const publishProgress = (progress) => {
-                if (!acceptsProgress)
-                    return;
-                publishStepStatus({
-                    attemptId: attempt.attemptId,
-                    pipelineId: compiled.id,
-                    progress,
-                    status: "running",
-                    step: plannedStep,
-                });
-            };
-            const stepContext = {
-                ...executionContext,
+            const output = await executeStepAttempt({
                 attemptId: attempt.attemptId,
-                log: tracedLogger(stepId, attempt.attemptId),
-                reportAttempt: (attempt, attributes) => {
-                    lifecycle.reportAttempt(stepId, attempt, attributes, stepContext.attemptId);
-                },
-                reportProgress: (progress) => {
-                    publishProgress(progress);
-                },
-            };
-            let output;
-            try {
-                output =
-                    dryRun && typeof step.dryRun === "function"
-                        ? await step.dryRun(inputs, stepContext)
-                        : await step.run(inputs, stepContext);
-            }
-            finally {
-                acceptsProgress = false;
-            }
-            if (await recordPublishedStepValue({
-                attempt,
-                kind: "complete",
-                plannedStep,
+                context: executionContext,
+                dryRun,
+                inputs: stepInputs,
+                log: tracedLogger(step.id, attempt.attemptId),
+                onProgress: (progress) => state.reportProgress(plannedStep, attempt, progress),
+                onReportAttempt: (number, attributes) => lifecycle.reportAttempt(step.id, number, attributes, attempt.attemptId),
+                outputBoundary: `Pipeline ${compiled.id} step ${step.id} output`,
                 step,
-                stepId,
-                stepIndex,
-                value: output,
-            })) {
-                break;
-            }
+            });
+            state.completeStep(plannedStep, attempt, output);
         }
         catch (error) {
-            if (recordStepExecutionFailure(error, plannedStep, step, stepId, stepIndex, attempt)) {
+            if (recordStepExecutionFailure(error, plannedStep, stepIndex, attempt))
                 break;
-            }
         }
     }
-    let value;
-    let finalized = false;
-    if (completed || controls.continueOnError) {
+    if (state.errors.length === 0 || controls.continueOnError) {
         const finalizeStartedAt = runtime.now();
-        lifecycle.finalizeStart();
+        state.beginFinalization();
         try {
             throwIfAborted(runtime);
-            // SAFETY: `outputs` maps step ids to their produced values, which is
+            // SAFETY: `state.outputs` maps step ids to their produced values, which is
             // exactly the shape the finalizer's outputs parameter describes.
-            const finalOutputs = Object.fromEntries(outputs);
+            const finalOutputs = Object.fromEntries(state.outputs);
             const finalizedValue = await compiled.finalize(finalOutputs, {
                 ...executionContext,
                 log: tracedLogger(PIPELINE_FINALIZE_STEP_ID),
@@ -677,11 +435,10 @@ export async function executePlannedRun(input) {
             // SAFETY: with a result schema the value is validated against
             // `TPipelineResult`; without one the finalizer's declared return type
             // is `TPipelineResult`, so the cast only restores that type.
-            value = compiled.resultSchema
+            const value = compiled.resultSchema
                 ? (await validateStandardSchema(compiled.resultSchema, finalizedValue, `Pipeline ${compiled.id} final result`))
                 : finalizedValue;
-            finalized = true;
-            lifecycle.finalizeComplete(runtime.now() - finalizeStartedAt, value);
+            state.completeFinalization(value, runtime.now() - finalizeStartedAt);
         }
         catch (error) {
             const cancelled = isPipelineCancellation(error, runtime);
@@ -696,30 +453,10 @@ export async function executePlannedRun(input) {
                 phase: "finalization",
                 stepId: PIPELINE_FINALIZE_STEP_ID,
             });
-            errors.push(pipelineError);
-            lifecycle.finalizeError(pipelineError, runtime.now() - finalizeStartedAt);
-            completed = false;
+            state.failFinalization(pipelineError, runtime.now() - finalizeStartedAt);
         }
     }
-    const finishedAtMs = runtime.now();
-    const result = {
-        pipelineId: compiled.id,
-        dryRun,
-        errors,
-        finalized,
-        finishedAtMs,
-        runId,
-        startedAtMs: startedAt,
-        status: terminalRunStatus(errors),
-        steps: reports,
-        value,
-        version: RUN_MODEL_VERSION,
-    };
-    if (parentRunId)
-        result.parentRunId = parentRunId;
-    lifecycle.pipelineComplete(result);
-    await lifecycle.flush();
-    return result;
+    return state.finish();
 }
 const fallbackNow = () => Date.now();
 const fallbackSleep = (durationMs, signal) => abortableSleep(durationMs, signal, "Pipeline sleep");