@temelj/workflow 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/engine/summary/recovery.mjs

@@ -0,0 +1,363 @@
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+import { WorkflowErrorCode } from "../../errors/codes.mjs";
+import { matchesWorkflowError } from "../../errors/records.mjs";
+import "../../errors/mod.mjs";
+import { History } from "../../history/replay.mjs";
+import { isScheduledRunStatus } from "../../run-status.mjs";
+import { Earliest, sorted } from "./tally.mjs";
+import { isString } from "@temelj/value";
+//#region src/engine/summary/recovery.ts
+/**
+* Every run that can make progress now, and when the next sleep, retry, lease, schedule,
+* lock wait, or external wait should be checked again.
+*/
+function summarizeRecovery(options) {
+	const { runs, now, inputs = {} } = options;
+	const due = new RunSet();
+	const pending = /* @__PURE__ */ new Set();
+	const waiting = /* @__PURE__ */ new Set();
+	const lease = new LeaseTally(now);
+	const retry = new RunSet();
+	const missingImplementation = new RunSet();
+	const failed = /* @__PURE__ */ new Set();
+	let latestFailedAt;
+	for (const run of runs) {
+		if (isScheduledRunStatus(run.status)) {
+			if (isDueAt(run.availableAt, now)) {
+				due.add(run.id, true);
+				(run.status === "pending" ? pending : waiting).add(run.id);
+			} else due.next.offer(run.availableAt, { runId: run.id });
+			if (run.retryReason !== void 0) {
+				const retryDue = isDueAt(run.retryAt, now);
+				retry.add(run.id, retryDue, run.retryAt);
+				if (run.retryReason === "missing_implementation") missingImplementation.add(run.id, retryDue, run.retryAt);
+			}
+		}
+		lease.add(run);
+		if (run.status === "failed") {
+			failed.add(run.id);
+			latestFailedAt = latestOptionalTimestamp(latestFailedAt, run.finishedAt);
+		}
+	}
+	const sleep = summarizeSleepWaits(inputs.sleepAttempts ?? [], now);
+	const message = summarizeMessageWaits(inputs.messageWaitAttempts ?? [], inputs.eventsByRunId ?? /* @__PURE__ */ new Map(), now);
+	const childWorkflow = summarizeChildWorkflowWaits(inputs.childWorkflowAttempts ?? [], inputs.childRuns ?? [], now);
+	const lock = summarizeLocks(inputs.locks ?? [], inputs.lockWaitAttempts ?? [], runs, now);
+	const schedule = summarizeSchedules(inputs.schedules ?? [], now);
+	const next = new Earliest();
+	for (const candidate of [
+		due.next.next,
+		lease.next.next,
+		retry.next.next,
+		schedule.next,
+		lock.nextExpiry,
+		lock.nextWaitDeadline,
+		sleep.next,
+		message.next,
+		childWorkflow.next
+	]) next.offer(candidate?.at, {});
+	return {
+		total: runs.length,
+		recoverableRunIds: sorted(/* @__PURE__ */ new Set([
+			...due.dueIds,
+			...lease.staleRunIds,
+			...retry.dueIds,
+			...failed,
+			...sleep.dueRunIds,
+			...message.readyRunIds,
+			...message.timedOutRunIds,
+			...childWorkflow.terminalRunIds,
+			...childWorkflow.missingRunIds,
+			...childWorkflow.timedOutRunIds
+		])),
+		due: {
+			runIds: sorted(due.dueIds),
+			pendingRunIds: sorted(pending),
+			waitingRunIds: sorted(waiting),
+			next: due.next.next
+		},
+		lease: lease.finish(),
+		retry: retry.finish(),
+		missingImplementation: missingImplementation.finish(),
+		failed: {
+			runIds: sorted(failed),
+			latestFailedAt
+		},
+		schedule,
+		lock,
+		wait: {
+			sleep,
+			message,
+			childWorkflow
+		},
+		nextRecoveryAt: next.at
+	};
+}
+/** The lock a failed step attempt was waiting for, when it failed because the lock was held. */
+function lockWaitDetails(attempt) {
+	const error = attempt.error;
+	if (attempt.status !== "failed" || attempt.kind !== "run" || error === void 0 || !matchesWorkflowError(error, WorkflowErrorCode.LOCK_ALREADY_HELD) || !isString(error.details?.key) || error.details.key.trim() === "") return;
+	const deadline = error.details.waitDeadlineAt;
+	return {
+		key: error.details.key,
+		waitDeadlineAt: isString(deadline) && deadline.trim() !== "" ? parseInstant(deadline) : void 0
+	};
+}
+function parseInstant(value) {
+	try {
+		return Temporal.Instant.from(value);
+	} catch {
+		return;
+	}
+}
+function isDueAt(at, now) {
+	return at === void 0 || Temporal.Instant.compare(at, now) <= 0;
+}
+/** Runs of one kind, those that are due, and the earliest that is not yet due. */
+var RunSet = class {
+	ids = /* @__PURE__ */ new Set();
+	dueIds = /* @__PURE__ */ new Set();
+	next = new Earliest();
+	add(id, due, at) {
+		this.ids.add(id);
+		if (due) this.dueIds.add(id);
+		else this.next.offer(at, { runId: id });
+	}
+	finish() {
+		return {
+			runIds: sorted(this.ids),
+			dueRunIds: sorted(this.dueIds),
+			next: this.next.next
+		};
+	}
+};
+var LeaseTally = class {
+	#now;
+	runIds = /* @__PURE__ */ new Set();
+	staleRunIds = /* @__PURE__ */ new Set();
+	#ownerless = /* @__PURE__ */ new Set();
+	#missingExpiresAt = /* @__PURE__ */ new Set();
+	#expired = /* @__PURE__ */ new Set();
+	#workerIds = /* @__PURE__ */ new Set();
+	next = new Earliest();
+	#oldestStaleAt;
+	constructor(now) {
+		this.#now = now;
+	}
+	add(run) {
+		if (run.status !== "running") return;
+		this.runIds.add(run.id);
+		if (run.workerId === void 0) {
+			this.staleRunIds.add(run.id);
+			this.#ownerless.add(run.id);
+		} else this.#workerIds.add(run.workerId);
+		if (run.leaseExpiresAt === void 0) {
+			this.staleRunIds.add(run.id);
+			this.#missingExpiresAt.add(run.id);
+		} else if (Temporal.Instant.compare(run.leaseExpiresAt, this.#now) <= 0) {
+			this.staleRunIds.add(run.id);
+			this.#expired.add(run.id);
+			this.#oldestStaleAt = earliestOptionalTimestamp(this.#oldestStaleAt, run.leaseExpiresAt);
+		} else if (run.workerId !== void 0) this.next.offer(run.leaseExpiresAt, { runId: run.id });
+	}
+	finish() {
+		return {
+			runIds: sorted(this.runIds),
+			staleRunIds: sorted(this.staleRunIds),
+			ownerlessRunIds: sorted(this.#ownerless),
+			missingExpiresAtRunIds: sorted(this.#missingExpiresAt),
+			expiredRunIds: sorted(this.#expired),
+			workerIds: sorted(this.#workerIds),
+			next: this.next.next,
+			oldestStaleAt: this.#oldestStaleAt
+		};
+	}
+};
+function summarizeSleepWaits(attempts, now) {
+	const runIds = /* @__PURE__ */ new Set();
+	const dueRunIds = /* @__PURE__ */ new Set();
+	const dueStepIds = /* @__PURE__ */ new Set();
+	const invalidUntilRunIds = /* @__PURE__ */ new Set();
+	const next = new Earliest();
+	for (const attempt of attempts) {
+		if (attempt.status !== "running" || attempt.kind !== "sleep") continue;
+		runIds.add(attempt.runId);
+		if (attempt.until === void 0) invalidUntilRunIds.add(attempt.runId);
+		if (isDueAt(attempt.until, now)) {
+			dueRunIds.add(attempt.runId);
+			dueStepIds.add(attempt.stepId);
+		} else next.offer(attempt.until, { runId: attempt.runId });
+	}
+	return {
+		runIds: sorted(runIds),
+		dueRunIds: sorted(dueRunIds),
+		dueStepIds: sorted(dueStepIds),
+		invalidUntilRunIds: sorted(invalidUntilRunIds),
+		next: next.next
+	};
+}
+function summarizeMessageWaits(attempts, eventsByRunId, now) {
+	const histories = /* @__PURE__ */ new Map();
+	const runIds = /* @__PURE__ */ new Set();
+	const readyRunIds = /* @__PURE__ */ new Set();
+	const readyStepIds = /* @__PURE__ */ new Set();
+	const timedOutRunIds = /* @__PURE__ */ new Set();
+	const timedOutStepIds = /* @__PURE__ */ new Set();
+	const messages = /* @__PURE__ */ new Set();
+	const next = new Earliest();
+	for (const attempt of attempts) {
+		if (attempt.status !== "running" || attempt.kind !== "message-wait") continue;
+		runIds.add(attempt.runId);
+		if (attempt.messageId !== void 0) {
+			messages.add(attempt.messageId);
+			const events = eventsByRunId.get(attempt.runId);
+			if (events !== void 0) {
+				let history = histories.get(attempt.runId);
+				if (history === void 0) {
+					history = new History(events);
+					histories.set(attempt.runId, history);
+				}
+				if (history.messageForWait(attempt.messageId, attempt.stepId, attempt.timeoutAt)) {
+					readyRunIds.add(attempt.runId);
+					readyStepIds.add(attempt.stepId);
+					continue;
+				}
+			}
+		}
+		if (attempt.timeoutAt === void 0) continue;
+		if (Temporal.Instant.compare(attempt.timeoutAt, now) <= 0) {
+			timedOutRunIds.add(attempt.runId);
+			timedOutStepIds.add(attempt.stepId);
+		} else next.offer(attempt.timeoutAt, { runId: attempt.runId });
+	}
+	return {
+		runIds: sorted(runIds),
+		readyRunIds: sorted(readyRunIds),
+		timedOutRunIds: sorted(timedOutRunIds),
+		readyStepIds: sorted(readyStepIds),
+		timedOutStepIds: sorted(timedOutStepIds),
+		messages: sorted(messages),
+		next: next.next
+	};
+}
+function summarizeChildWorkflowWaits(attempts, childRuns, now) {
+	const childById = new Map(childRuns.map((run) => [run.id, run]));
+	const runIds = /* @__PURE__ */ new Set();
+	const terminal = {
+		runIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set()
+	};
+	const missing = {
+		runIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set()
+	};
+	const timedOut = {
+		runIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set()
+	};
+	const childRunIds = /* @__PURE__ */ new Set();
+	const completed = /* @__PURE__ */ new Set();
+	const failed = /* @__PURE__ */ new Set();
+	const canceled = /* @__PURE__ */ new Set();
+	const next = new Earliest();
+	for (const attempt of attempts) {
+		if (attempt.status !== "running" || attempt.kind !== "workflow") continue;
+		runIds.add(attempt.runId);
+		if (attempt.childRunId !== void 0) childRunIds.add(attempt.childRunId);
+		const child = attempt.childRunId === void 0 ? void 0 : childById.get(attempt.childRunId);
+		if (child === void 0) {
+			missing.runIds.add(attempt.runId);
+			missing.stepIds.add(attempt.stepId);
+			continue;
+		}
+		if (child.status === "completed" || child.status === "failed" || child.status === "canceled") {
+			terminal.runIds.add(attempt.runId);
+			terminal.stepIds.add(attempt.stepId);
+			if (child.status === "completed") completed.add(child.id);
+			else if (child.status === "failed") failed.add(child.id);
+			else canceled.add(child.id);
+			continue;
+		}
+		if (attempt.timeoutAt === void 0) continue;
+		if (Temporal.Instant.compare(attempt.timeoutAt, now) <= 0) {
+			timedOut.runIds.add(attempt.runId);
+			timedOut.stepIds.add(attempt.stepId);
+		} else next.offer(attempt.timeoutAt, { runId: attempt.runId });
+	}
+	return {
+		runIds: sorted(runIds),
+		terminalRunIds: sorted(terminal.runIds),
+		missingRunIds: sorted(missing.runIds),
+		timedOutRunIds: sorted(timedOut.runIds),
+		terminalStepIds: sorted(terminal.stepIds),
+		missingStepIds: sorted(missing.stepIds),
+		timedOutStepIds: sorted(timedOut.stepIds),
+		childRunIds: sorted(childRunIds),
+		completedChildRunIds: sorted(completed),
+		failedChildRunIds: sorted(failed),
+		canceledChildRunIds: sorted(canceled),
+		next: next.next
+	};
+}
+function summarizeLocks(locks, waitAttempts, runs, now) {
+	const keys = /* @__PURE__ */ new Set();
+	const staleKeys = /* @__PURE__ */ new Set();
+	const holderIds = /* @__PURE__ */ new Set();
+	const nextExpiry = new Earliest();
+	let oldestStaleAt;
+	for (const lock of locks) {
+		if (lock.releasedAt !== void 0) continue;
+		keys.add(lock.key);
+		if (lock.holderId !== void 0) holderIds.add(lock.holderId);
+		if (Temporal.Instant.compare(lock.leaseExpiresAt, now) <= 0) {
+			staleKeys.add(lock.key);
+			oldestStaleAt = earliestOptionalTimestamp(oldestStaleAt, lock.leaseExpiresAt);
+		} else nextExpiry.offer(lock.leaseExpiresAt, { key: lock.key });
+	}
+	const runById = new Map(runs.map((run) => [run.id, run]));
+	const waitingRunIds = /* @__PURE__ */ new Set();
+	const dueWaitingRunIds = /* @__PURE__ */ new Set();
+	const waitingStepIds = /* @__PURE__ */ new Set();
+	const waitingKeys = /* @__PURE__ */ new Set();
+	const nextWaitDeadline = new Earliest();
+	for (const attempt of waitAttempts) {
+		const details = lockWaitDetails(attempt);
+		const run = runById.get(attempt.runId);
+		if (details === void 0 || run === void 0 || run.status !== "waiting" || run.retryReason !== "step") continue;
+		waitingRunIds.add(attempt.runId);
+		waitingStepIds.add(attempt.stepId);
+		waitingKeys.add(details.key);
+		if (isDueAt(run.retryAt, now)) dueWaitingRunIds.add(attempt.runId);
+		if (details.waitDeadlineAt !== void 0 && Temporal.Instant.compare(details.waitDeadlineAt, now) > 0) nextWaitDeadline.offer(details.waitDeadlineAt, { runId: attempt.runId });
+	}
+	return {
+		keys: sorted(keys),
+		staleKeys: sorted(staleKeys),
+		holderIds: sorted(holderIds),
+		waitingRunIds: sorted(waitingRunIds),
+		dueWaitingRunIds: sorted(dueWaitingRunIds),
+		waitingStepIds: sorted(waitingStepIds),
+		waitingKeys: sorted(waitingKeys),
+		oldestStaleAt,
+		nextExpiry: nextExpiry.next,
+		nextWaitDeadline: nextWaitDeadline.next
+	};
+}
+function summarizeSchedules(schedules, now) {
+	const ids = /* @__PURE__ */ new Set();
+	const dueIds = /* @__PURE__ */ new Set();
+	const next = new Earliest();
+	for (const schedule of schedules) {
+		if (schedule.status !== "active") continue;
+		ids.add(schedule.id);
+		if (Temporal.Instant.compare(schedule.nextFireAt, now) <= 0) dueIds.add(schedule.id);
+		next.offer(schedule.nextFireAt, { scheduleId: schedule.id });
+	}
+	return {
+		scheduleIds: sorted(ids),
+		dueScheduleIds: sorted(dueIds),
+		next: next.next
+	};
+}
+//#endregion
+export { lockWaitDetails, summarizeRecovery };

package/dist/engine/summary/runs.d.mts

@@ -0,0 +1,43 @@
+import { RunId } from "../../types/ids.mjs";
+import { RunFailureSummary, RunRetrySummary, RunSummary } from "../../types/summary.mjs";
+import { StepAttemptRecord } from "../../types/step-attempts.mjs";
+import { RunRecord, RunStatus } from "../../types/run.mjs";
+import { EventRecord } from "../../types/events.mjs";
+import { WorkflowStore } from "../../types/store.mjs";
+//#region src/engine/summary/runs.d.ts
+export interface RunAttemptsInput {
+  readonly runId: RunId;
+  readonly attempts: readonly StepAttemptRecord[];
+}
+export interface RunChildWorkflowWaitInput extends RunAttemptsInput {
+  readonly childRuns: readonly RunRecord[];
+}
+export interface RunEventActivityInput {
+  readonly runId: RunId;
+  readonly events: readonly EventRecord[];
+}
+export interface RunSummaryInputs {
+  readonly runs: readonly RunRecord[];
+  readonly now: Temporal.Instant;
+  readonly cleanupCutoff?: Temporal.Instant;
+  readonly runningChildWorkflows?: readonly RunChildWorkflowWaitInput[];
+  readonly runningSleeps?: readonly RunAttemptsInput[];
+  readonly runningMessageWaits?: readonly RunAttemptsInput[];
+  readonly runningEvents?: readonly RunEventActivityInput[];
+}
+/** Summarizes run records and their active waits for inspection dashboards. */
+export declare function summarizeRuns(inputs: RunSummaryInputs): RunSummary;
+/** Child runs that belong to the given child-workflow step attempts of a parent run. */
+export declare function getChildRunsForAttempts(store: WorkflowStore, parentRunId: RunId, attempts: readonly StepAttemptRecord[]): Promise<readonly RunRecord[]>;
+interface ChildRunsSummary {
+  readonly childStatus: Record<RunStatus, number>;
+  readonly retryChildRunIds?: readonly string[];
+  readonly failedChildRunIds?: readonly string[];
+  readonly canceledChildRunIds?: readonly string[];
+  readonly childRetry?: RunRetrySummary;
+  readonly childFailure?: RunFailureSummary;
+}
+/** The state of the child runs that active child-workflow waits point at. */
+export declare function summarizeChildRuns(runs: readonly RunRecord[]): ChildRunsSummary;
+//#endregion
+export {};

package/dist/engine/summary/runs.mjs

@@ -0,0 +1,294 @@
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+import { runStepAttemptKey } from "../../store-keys.mjs";
+import { isRunStatus, isScheduledRunStatus } from "../../run-status.mjs";
+import { Earliest, FailureTally, RUN_STATUSES, RUN_TRANSITION_REASONS, RetryTally, TERMINAL_RUN_STATUSES, WaitTally, counts, sorted, sortedOrUndefined } from "./tally.mjs";
+//#region src/engine/summary/runs.ts
+/** Summarizes run records and their active waits for inspection dashboards. */
+function summarizeRuns(inputs) {
+	const states = new RunStateTally(inputs.now, inputs.cleanupCutoff);
+	for (const run of inputs.runs) states.add(run);
+	const streams = new WaitTally();
+	const streamNames = /* @__PURE__ */ new Set();
+	let chunkCount = 0;
+	const hooks = new WaitTally();
+	const hookNames = /* @__PURE__ */ new Set();
+	const webhookNames = /* @__PURE__ */ new Set();
+	const hookMessages = /* @__PURE__ */ new Set();
+	let webhooks = 0;
+	for (const { runId, events } of inputs.runningEvents ?? []) {
+		const active = activeEvents(events);
+		for (const stream of active.streams) {
+			streams.add(stream.stepId, void 0, stream.startedAt);
+			streamNames.add(stream.stepName);
+			chunkCount += stream.chunkCount;
+		}
+		for (const hook of active.hooks) {
+			hooks.add(hook.stepId, void 0, hook.startedAt);
+			hooks.next.offer(hook.timeoutAt, {
+				runId,
+				stepId: hook.stepId
+			});
+			hookMessages.add(hook.messageId);
+			if (hook.source === "hook") hookNames.add(hook.name);
+			else {
+				webhooks++;
+				webhookNames.add(hook.name);
+			}
+		}
+	}
+	const sleeps = new WaitTally();
+	for (const { runId, attempts } of inputs.runningSleeps ?? []) for (const attempt of attempts) {
+		sleeps.add(attempt.stepId, void 0, attempt.startedAt);
+		sleeps.next.offer(attempt.until, {
+			runId,
+			stepId: attempt.stepId,
+			attemptKey: runStepAttemptKey(runId, attempt),
+			duration: attempt.duration instanceof Temporal.Duration ? attempt.duration : void 0
+		});
+	}
+	const messageWaits = new WaitTally();
+	const messages = /* @__PURE__ */ new Set();
+	for (const { runId, attempts } of inputs.runningMessageWaits ?? []) for (const attempt of attempts) {
+		messageWaits.add(attempt.stepId, void 0, attempt.startedAt);
+		messageWaits.next.offer(attempt.timeoutAt, {
+			runId,
+			stepId: attempt.stepId,
+			attemptKey: runStepAttemptKey(runId, attempt)
+		});
+		if (attempt.messageId !== void 0) messages.add(attempt.messageId);
+	}
+	return {
+		...states.finish(),
+		stream: streams.total === 0 ? void 0 : {
+			...waitSummary(streams),
+			names: sorted(streamNames),
+			chunkCount
+		},
+		hook: hooks.total === 0 ? void 0 : {
+			...waitSummary(hooks),
+			webhooks,
+			hookNames: sorted(hookNames),
+			webhookNames: sorted(webhookNames),
+			messages: sorted(hookMessages),
+			next: hooks.next.next
+		},
+		sleep: sleeps.total === 0 ? void 0 : {
+			...waitSummary(sleeps),
+			next: sleeps.next.next
+		},
+		message: messageWaits.total === 0 ? void 0 : {
+			...waitSummary(messageWaits),
+			messages: sorted(messages),
+			next: messageWaits.next.next
+		},
+		childWorkflow: summarizeChildWorkflowWaits(inputs.runningChildWorkflows ?? [])
+	};
+}
+/** Child runs that belong to the given child-workflow step attempts of a parent run. */
+async function getChildRunsForAttempts(store, parentRunId, attempts) {
+	const childRunIds = new Set(attempts.flatMap((attempt) => attempt.childRunId ?? []));
+	return (await Promise.all([...childRunIds].map((runId) => store.getRun(runId)))).filter((run) => run !== void 0 && attempts.some((attempt) => run.parentRunId === parentRunId && run.parentStepId === attempt.stepId && run.parentStepName === attempt.stepName && run.parentStepAttempt === attempt.attempt && attempt.childRunId === run.id && attempt.workflowName === run.workflowName && attempt.workflowVersion === run.workflowVersion));
+}
+function waitSummary(waits) {
+	return {
+		count: waits.total,
+		oldestStartedAt: waits.oldestStartedAt
+	};
+}
+/** Everything a summary reads from the run records themselves. */
+var RunStateTally = class {
+	#now;
+	#cleanupCutoff;
+	#total = 0;
+	#status = counts(RUN_STATUSES);
+	#workflows = /* @__PURE__ */ new Map();
+	#transitionReason = counts(RUN_TRANSITION_REASONS);
+	#latestTransitionAt;
+	#retry = new RetryTally();
+	#failure = new FailureTally();
+	#lease = {
+		count: 0,
+		expired: 0,
+		workerIds: /* @__PURE__ */ new Set(),
+		next: new Earliest()
+	};
+	#cleanup = { status: counts(TERMINAL_RUN_STATUSES) };
+	#nextAvailableAt;
+	#oldestPendingAt;
+	#oldestRunningAt;
+	constructor(now, cleanupCutoff) {
+		this.#now = now;
+		this.#cleanupCutoff = cleanupCutoff;
+	}
+	add(run) {
+		if (!isRunStatus(run.status)) return;
+		this.#total++;
+		this.#status[run.status]++;
+		this.#addWorkflow(run);
+		this.#transitionReason[run.lastTransitionReason]++;
+		this.#latestTransitionAt = latestOptionalTimestamp(this.#latestTransitionAt, run.lastTransitionAt);
+		this.#retry.add(run);
+		this.#failure.add(run);
+		this.#addLease(run);
+		this.#addCleanup(run, run.status);
+		if (isScheduledRunStatus(run.status)) {
+			this.#nextAvailableAt = earliestOptionalTimestamp(this.#nextAvailableAt, run.availableAt);
+			this.#oldestPendingAt = earliestOptionalTimestamp(this.#oldestPendingAt, run.createdAt);
+		}
+		if (run.status === "running") this.#oldestRunningAt = earliestOptionalTimestamp(this.#oldestRunningAt, run.startedAt ?? run.createdAt);
+	}
+	finish() {
+		const lease = this.#lease;
+		const cleanup = this.#cleanup;
+		return {
+			total: this.#total,
+			status: this.#status,
+			workflows: [...this.#workflows.values()].sort((left, right) => left.name.localeCompare(right.name) || (left.version ?? "").localeCompare(right.version ?? "")),
+			transition: {
+				reason: this.#transitionReason,
+				latestTransitionAt: this.#latestTransitionAt
+			},
+			retry: this.#retry.finish(),
+			failure: this.#failure.total === 0 ? void 0 : this.#failure.finish(),
+			lease: {
+				count: lease.count,
+				expired: lease.expired,
+				workerIds: sorted(lease.workerIds),
+				oldestExpiredAt: lease.oldestExpiredAt,
+				next: lease.next.next
+			},
+			cleanup: this.#cleanupCutoff === void 0 ? void 0 : {
+				status: cleanup.status,
+				oldestFinishedAt: cleanup.oldestFinishedAt,
+				newestFinishedAt: cleanup.newestFinishedAt
+			},
+			nextAvailableAt: this.#nextAvailableAt,
+			oldestPendingAt: this.#oldestPendingAt,
+			oldestRunningAt: this.#oldestRunningAt
+		};
+	}
+	#addWorkflow(run) {
+		const key = run.workflowVersion === void 0 ? run.workflowName : `${run.workflowName}\0${run.workflowVersion}`;
+		const entry = this.#workflows.get(key);
+		this.#workflows.set(key, {
+			name: run.workflowName,
+			version: run.workflowVersion,
+			count: (entry?.count ?? 0) + 1
+		});
+	}
+	#addLease(run) {
+		if (run.status !== "running") return;
+		const lease = this.#lease;
+		lease.count++;
+		if (run.workerId !== void 0) lease.workerIds.add(run.workerId);
+		if (run.workerId === void 0 || run.leaseExpiresAt === void 0) lease.expired++;
+		else if (Temporal.Instant.compare(run.leaseExpiresAt, this.#now) <= 0) {
+			lease.expired++;
+			lease.oldestExpiredAt = earliestOptionalTimestamp(lease.oldestExpiredAt, run.leaseExpiresAt);
+		} else lease.next.offer(run.leaseExpiresAt, { runId: run.id });
+	}
+	#addCleanup(run, status) {
+		const cutoff = this.#cleanupCutoff;
+		if (cutoff === void 0 || status !== "completed" && status !== "failed" && status !== "canceled" || run.finishedAt === void 0 || Temporal.Instant.compare(run.finishedAt, cutoff) >= 0) return;
+		const cleanup = this.#cleanup;
+		cleanup.status[status]++;
+		cleanup.oldestFinishedAt = earliestOptionalTimestamp(cleanup.oldestFinishedAt, run.finishedAt);
+		cleanup.newestFinishedAt = latestOptionalTimestamp(cleanup.newestFinishedAt, run.finishedAt);
+	}
+};
+function summarizeChildWorkflowWaits(inputs) {
+	const waits = new WaitTally();
+	const workflows = /* @__PURE__ */ new Set();
+	const childRuns = /* @__PURE__ */ new Map();
+	for (const { runId, attempts, childRuns: runs } of inputs) {
+		for (const attempt of attempts) {
+			waits.add(attempt.stepId, void 0, attempt.startedAt);
+			waits.next.offer(attempt.timeoutAt, {
+				runId,
+				stepId: attempt.stepId,
+				attemptKey: runStepAttemptKey(runId, attempt)
+			});
+			if (attempt.workflowName !== void 0) workflows.add(attempt.workflowVersion === void 0 ? attempt.workflowName : `${attempt.workflowName}@${attempt.workflowVersion}`);
+		}
+		for (const run of runs) childRuns.set(run.id, run);
+	}
+	if (waits.total === 0) return;
+	const { childStatus, childRetry, childFailure } = summarizeChildRuns([...childRuns.values()]);
+	return {
+		...waitSummary(waits),
+		workflows: sorted(workflows),
+		childStatus,
+		childRetry,
+		childFailure,
+		next: waits.next.next
+	};
+}
+/** The state of the child runs that active child-workflow waits point at. */
+function summarizeChildRuns(runs) {
+	const childStatus = counts(RUN_STATUSES);
+	const retry = new RetryTally();
+	const failure = new FailureTally();
+	const failedChildRunIds = /* @__PURE__ */ new Set();
+	const canceledChildRunIds = /* @__PURE__ */ new Set();
+	for (const run of runs) {
+		if (!isRunStatus(run.status)) continue;
+		childStatus[run.status]++;
+		retry.add(run);
+		failure.add(run);
+		if (run.status === "failed") failedChildRunIds.add(run.id);
+		else if (run.status === "canceled") canceledChildRunIds.add(run.id);
+	}
+	return {
+		childStatus,
+		retryChildRunIds: retry.runIds(),
+		failedChildRunIds: sortedOrUndefined(failedChildRunIds),
+		canceledChildRunIds: sortedOrUndefined(canceledChildRunIds),
+		childRetry: retry.total === 0 ? void 0 : retry.finish(),
+		childFailure: failure.total === 0 ? void 0 : failure.finish()
+	};
+}
+/** Streams and hooks of one run that have started and not yet ended. */
+function activeEvents(events) {
+	const streams = /* @__PURE__ */ new Map();
+	const hooks = /* @__PURE__ */ new Map();
+	const ended = /* @__PURE__ */ new Set();
+	for (const event of events) switch (event.kind) {
+		case "stream_started":
+			streams.set(event.stepId, {
+				stepId: event.stepId,
+				stepName: event.stepName,
+				streamId: event.streamId,
+				startedAt: event.timestamp,
+				chunkCount: 0
+			});
+			break;
+		case "stream_chunk": {
+			const stream = streams.get(event.stepId);
+			if (stream !== void 0) streams.set(event.stepId, {
+				...stream,
+				chunkCount: stream.chunkCount + 1
+			});
+			break;
+		}
+		case "message_wait_started":
+			if (event.source === "hook" || event.source === "webhook") hooks.set(event.stepId, {
+				stepId: event.stepId,
+				name: event.stepName,
+				messageId: event.messageId,
+				source: event.source,
+				startedAt: event.timestamp,
+				timeoutAt: event.timeoutAt
+			});
+			break;
+		case "stream_closed":
+		case "stream_failed":
+		case "message_wait_completed":
+		case "message_wait_failed": ended.add(`${event.kind.startsWith("stream") ? "stream" : "hook"}:${event.stepId}`);
+	}
+	return {
+		streams: [...streams.values()].filter((stream) => !ended.has(`stream:${stream.stepId}`)),
+		hooks: [...hooks.values()].filter((hook) => !ended.has(`hook:${hook.stepId}`))
+	};
+}
+//#endregion
+export { getChildRunsForAttempts, summarizeChildRuns, summarizeRuns };