@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

package/dist/builtin/workflows/src/runs/foreground/executor-run-finalizers.ts

@@ -1,144 +0,0 @@
-import type { Store } from "../../shared/store.js";
-import type { RunSnapshot } from "../../shared/store-types.js";
-import type { WorkflowDefinition, WorkflowOutputValues } from "../../shared/types.js";
-import type { WorkflowFailure } from "../../shared/workflow-failures.js";
-import type { ParentWorkflowExitAbortProbe, WorkflowExitSignal } from "./executor-abort.js";
-import { parentWorkflowExitRunReason } from "./executor-abort.js";
-import { appendRunEndWhenRecorded, reconcileTerminalRunResult, runFailureMetadata } from "./executor-lifecycle.js";
-import { assertWorkflowExitOutputs, normalizeWorkflowExitOutput } from "./executor-outputs.js";
-import type { RunOpts, RunResult } from "./executor-types.js";
-
-export interface RunFinalizers {
-	finalizeWorkflowExit(signal: WorkflowExitSignal): Promise<RunResult>;
-	finalizeParentWorkflowExitCancellation(abortReason: ParentWorkflowExitAbortProbe): Promise<RunResult>;
-}
-
-export function createRunFinalizers(input: {
-	readonly def: WorkflowDefinition;
-	readonly runId: string;
-	readonly runSnapshot: RunSnapshot;
-	readonly activeStore: Store;
-	readonly opts: RunOpts;
-	readonly classifyExecutorFailure: (error: unknown) => WorkflowFailure;
-	readonly drainWorkflowExitCleanups: (reason?: string) => Promise<void>;
-}): RunFinalizers {
-	const finalizeWorkflowExitValidationFailure = (err: unknown, exitReason?: string): RunResult => {
-		const failure = input.classifyExecutorFailure(err);
-		const classifiedMetadata = runFailureMetadata(failure, input.runSnapshot.stages);
-		const metadata = {
-			...classifiedMetadata,
-			resumable: false,
-			...(exitReason !== undefined ? { exitReason } : {}),
-		} as const;
-		const recorded = input.activeStore.recordRunEnd(
-			input.runId,
-			"failed",
-			undefined,
-			metadata.errorMessage,
-			metadata,
-		);
-		appendRunEndWhenRecorded(input.opts.persistence, recorded, {
-			runId: input.runId,
-			status: "failed",
-			error: metadata.errorMessage,
-			failureKind: metadata.failureKind,
-			...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
-			...(metadata.failureRecoverability !== undefined
-				? { failureRecoverability: metadata.failureRecoverability }
-				: {}),
-			...(metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {}),
-			failureMessage: metadata.failureMessage,
-			...(metadata.failedStageId !== undefined ? { failedStageId: metadata.failedStageId } : {}),
-			resumable: false,
-			...(metadata.exitReason !== undefined ? { exitReason: metadata.exitReason } : {}),
-			...(metadata.retryAfterMs !== undefined ? { retryAfterMs: metadata.retryAfterMs } : {}),
-			ts: Date.now(),
-		});
-		return reconcileTerminalRunResult(
-			input.runId,
-			input.runSnapshot,
-			input.activeStore,
-			{
-				status: "failed",
-				error: metadata.errorMessage,
-				...(metadata.exitReason !== undefined ? { exitReason: metadata.exitReason } : {}),
-			},
-			input.opts.onRunEnd,
-		);
-	};
-
-	const finalizeWorkflowExit = async (signal: WorkflowExitSignal): Promise<RunResult> => {
-		await input.drainWorkflowExitCleanups(signal.reason);
-		if (signal.validationError !== undefined) {
-			return finalizeWorkflowExitValidationFailure(signal.validationError, signal.reason);
-		}
-
-		let outputs: WorkflowOutputValues | undefined;
-		try {
-			outputs = normalizeWorkflowExitOutput(input.def.name, signal.outputSnapshot);
-			assertWorkflowExitOutputs(input.def.name, outputs, input.def.outputs);
-		} catch (err) {
-			return finalizeWorkflowExitValidationFailure(err, signal.reason);
-		}
-
-		const resumable = signal.status === "failed" && signal.resumable === true;
-		const metadata = {
-			resumable,
-			exited: true,
-			...(signal.reason !== undefined ? { exitReason: signal.reason } : {}),
-		} as const;
-		const recorded = input.activeStore.recordRunEnd(input.runId, signal.status, outputs, undefined, metadata);
-		appendRunEndWhenRecorded(input.opts.persistence, recorded, {
-			runId: input.runId,
-			status: signal.status,
-			result: outputs,
-			exited: true,
-			...(signal.reason !== undefined ? { exitReason: signal.reason } : {}),
-			resumable,
-			ts: Date.now(),
-		});
-		return reconcileTerminalRunResult(
-			input.runId,
-			input.runSnapshot,
-			input.activeStore,
-			{
-				status: signal.status,
-				result: outputs,
-				exited: true,
-				...(signal.reason !== undefined ? { exitReason: signal.reason } : {}),
-			},
-			input.opts.onRunEnd,
-		);
-	};
-
-	const finalizeParentWorkflowExitCancellation = async (
-		abortReason: ParentWorkflowExitAbortProbe,
-	): Promise<RunResult> => {
-		const parentReason = abortReason.workflowExitReason;
-		await input.drainWorkflowExitCleanups(parentReason);
-		const exitReason = parentWorkflowExitRunReason(parentReason);
-		const metadata = { resumable: false, exited: true, exitReason } as const;
-		const recorded = input.activeStore.recordRunEnd(input.runId, "cancelled", undefined, undefined, metadata);
-		appendRunEndWhenRecorded(input.opts.persistence, recorded, {
-			runId: input.runId,
-			status: "cancelled",
-			exited: true,
-			exitReason,
-			resumable: false,
-			ts: Date.now(),
-		});
-		return reconcileTerminalRunResult(
-			input.runId,
-			input.runSnapshot,
-			input.activeStore,
-			{
-				status: "cancelled",
-				exited: true,
-				exitReason,
-			},
-			input.opts.onRunEnd,
-		);
-	};
-
-	return { finalizeWorkflowExit, finalizeParentWorkflowExitCancellation };
-}

package/dist/builtin/workflows/src/runs/foreground/executor-run.ts

@@ -1 +0,0 @@
-export { run } from "../../engine/run.js";

package/dist/builtin/workflows/src/runs/foreground/executor-scheduler.ts

@@ -1,206 +0,0 @@
-import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
-import type { Store } from "../../shared/store.js";
-import type { RunSnapshot, StageSnapshot } from "../../shared/store-types.js";
-import type { StageControlRegistry } from "./stage-control-registry.js";
-
-interface ReleaseBarrier {
-	readonly promise: Promise<void>;
-	readonly resolve: () => void;
-	readonly reject: (reason?: unknown) => void;
-}
-
-export function isTerminalStage(stage: StageSnapshot): boolean {
-	return stage.status === "completed" || stage.status === "failed" || stage.status === "skipped";
-}
-
-export interface StageScheduler {
-	readonly tracker: GraphFrontierTracker;
-	stageById(stageId: string): StageSnapshot | undefined;
-	setStageParentIds(stage: StageSnapshot, parentIds: readonly string[]): void;
-	descendantsOf(stageId: string): StageSnapshot[];
-	blockingAncestorFor(stage: StageSnapshot): string | undefined;
-	blockStageUntilCascadeRelease(stage: StageSnapshot, blockedBy: string): void;
-	blockKnownNonTerminalDescendants(failedStageId: string): void;
-	cascadePauseFrom(pausedStageId: string): Promise<void>;
-	cascadeResumeFrom(resumedStageId: string): Promise<void>;
-	rejectReleaseBarriers(reason: unknown): void;
-	releaseStageBarrier(stageId: string): void;
-	ensureReleaseBarrier(stageId: string): void;
-	waitForStageRelease(stageId: string, onRejected: () => Promise<void>): Promise<void>;
-	markCascadePaused(stageId: string, ownerStageId: string): void;
-	releaseCascadePauseOwner(stageId: string, ownerStageId: string): boolean;
-	hasCascadePauseOwners(stageId: string): boolean;
-}
-
-export function createStageScheduler(input: {
-	readonly runId: string;
-	readonly runSnapshot: RunSnapshot;
-	readonly activeStore: Store;
-	readonly tracker: GraphFrontierTracker;
-	readonly stageRegistry: () => StageControlRegistry;
-}): StageScheduler {
-	const releaseBarriers = new Map<string, ReleaseBarrier>();
-	const cascadePauseOwners = new Map<string, Set<string>>();
-
-	const makeReleaseBarrier = (): ReleaseBarrier => {
-		const resolver = Promise.withResolvers<void>();
-		void resolver.promise.catch(() => {});
-		return { promise: resolver.promise, resolve: resolver.resolve, reject: resolver.reject };
-	};
-
-	const stageById = (stageId: string): StageSnapshot | undefined =>
-		input.runSnapshot.stages.find((stage) => stage.id === stageId);
-
-	const setStageParentIds = (stage: StageSnapshot, parentIds: readonly string[]): void => {
-		// The tracked-stage caller invokes this next to the version-bumping
-		// `recordStageStart` method, with no intervening asynchronous work.
-		stage.parentIds = Object.freeze([...parentIds]);
-	};
-
-	const hasAncestor = (stage: StageSnapshot, ancestorId: string): boolean => {
-		const queue = [...stage.parentIds];
-		const seen = new Set<string>();
-		while (queue.length > 0) {
-			const next = queue.shift();
-			if (next === undefined || seen.has(next)) continue;
-			if (next === ancestorId) return true;
-			seen.add(next);
-			queue.push(...input.tracker.getParents(next));
-		}
-		return false;
-	};
-
-	const descendantsOf = (stageId: string): StageSnapshot[] =>
-		input.runSnapshot.stages.filter((stage) => stage.id !== stageId && hasAncestor(stage, stageId));
-
-	const blockingAncestorFor = (stage: StageSnapshot): string | undefined => {
-		const queue = [...stage.parentIds];
-		const seen = new Set<string>();
-		while (queue.length > 0) {
-			const next = queue.shift();
-			if (next === undefined || seen.has(next)) continue;
-			seen.add(next);
-			const ancestor = stageById(next);
-			if (ancestor?.status === "paused" || ancestor?.status === "blocked") return next;
-			queue.push(...input.tracker.getParents(next));
-		}
-		return undefined;
-	};
-
-	const ensureReleaseBarrier = (stageId: string): void => {
-		if (!releaseBarriers.has(stageId)) releaseBarriers.set(stageId, makeReleaseBarrier());
-	};
-
-	const blockStageUntilCascadeRelease = (stage: StageSnapshot, blockedBy: string): void => {
-		ensureReleaseBarrier(stage.id);
-		input.activeStore.recordStageBlocked(input.runId, stage.id, blockedBy);
-	};
-
-	const blockKnownNonTerminalDescendants = (failedStageId: string): void => {
-		for (const descendant of descendantsOf(failedStageId)) {
-			if (isTerminalStage(descendant) || descendant.status === "paused" || descendant.status === "blocked") continue;
-			blockStageUntilCascadeRelease(descendant, failedStageId);
-		}
-	};
-
-	const markCascadePaused = (stageId: string, ownerStageId: string): void => {
-		let owners = cascadePauseOwners.get(stageId);
-		if (!owners) {
-			owners = new Set<string>();
-			cascadePauseOwners.set(stageId, owners);
-		}
-		owners.add(ownerStageId);
-	};
-
-	const releaseCascadePauseOwner = (stageId: string, ownerStageId: string): boolean => {
-		const owners = cascadePauseOwners.get(stageId);
-		if (!owners) return false;
-		const changed = owners.delete(ownerStageId);
-		if (owners.size === 0) cascadePauseOwners.delete(stageId);
-		return changed;
-	};
-
-	const releaseStageBarrier = (stageId: string): void => {
-		const barrier = releaseBarriers.get(stageId);
-		if (!barrier) return;
-		releaseBarriers.delete(stageId);
-		barrier.resolve();
-	};
-
-	const cascadePauseFrom = async (pausedStageId: string): Promise<void> => {
-		const stageRegistry = input.stageRegistry();
-		for (const descendant of descendantsOf(pausedStageId)) {
-			if (isTerminalStage(descendant) || descendant.status === "paused" || descendant.status === "blocked") continue;
-			const descendantHandle = stageRegistry.get(input.runId, descendant.id);
-			if (descendantHandle?.isStreaming || descendant.status === "running") {
-				if (descendantHandle && (descendantHandle.status === "running" || descendantHandle.status === "pending")) {
-					await descendantHandle.pause();
-					markCascadePaused(descendant.id, pausedStageId);
-				}
-				continue;
-			}
-			blockStageUntilCascadeRelease(descendant, pausedStageId);
-		}
-	};
-
-	const cascadeResumeFrom = async (resumedStageId: string): Promise<void> => {
-		const stageRegistry = input.stageRegistry();
-		for (const descendant of descendantsOf(resumedStageId)) {
-			if (isTerminalStage(descendant)) continue;
-			if (descendant.status === "blocked") {
-				if (blockingAncestorFor(descendant) !== undefined) continue;
-				if (input.activeStore.recordStageUnblocked(input.runId, descendant.id)) releaseStageBarrier(descendant.id);
-				continue;
-			}
-			if (descendant.status === "paused") {
-				const ownedByResumedStage = releaseCascadePauseOwner(descendant.id, resumedStageId);
-				if (!ownedByResumedStage) continue;
-				if (cascadePauseOwners.has(descendant.id)) continue;
-				if (blockingAncestorFor(descendant) !== undefined) continue;
-				const descendantHandle = stageRegistry.get(input.runId, descendant.id);
-				if (descendantHandle?.status === "paused") await descendantHandle.resume();
-			}
-		}
-	};
-
-	const rejectReleaseBarriers = (reason: unknown): void => {
-		cascadePauseOwners.clear();
-		for (const [stageId, barrier] of releaseBarriers) {
-			releaseBarriers.delete(stageId);
-			input.activeStore.recordStageUnblocked(input.runId, stageId);
-			barrier.reject(reason);
-		}
-	};
-
-	const waitForStageRelease = async (stageId: string, onRejected: () => Promise<void>): Promise<void> => {
-		while (true) {
-			const barrier = releaseBarriers.get(stageId);
-			if (!barrier) return;
-			try {
-				await barrier.promise;
-			} catch (err) {
-				await onRejected();
-				throw err;
-			}
-		}
-	};
-
-	return {
-		tracker: input.tracker,
-		stageById,
-		setStageParentIds,
-		descendantsOf,
-		blockingAncestorFor,
-		blockStageUntilCascadeRelease,
-		blockKnownNonTerminalDescendants,
-		cascadePauseFrom,
-		cascadeResumeFrom,
-		rejectReleaseBarriers,
-		releaseStageBarrier,
-		ensureReleaseBarrier,
-		waitForStageRelease,
-		markCascadePaused,
-		releaseCascadePauseOwner,
-		hasCascadePauseOwners: (stageId) => cascadePauseOwners.has(stageId),
-	};
-}