@temelj/workflow 0.0.0-alpha.1

package/dist/engine/summary/child-workflow-waits.mjs

@@ -0,0 +1,67 @@
+import { makeWorkflowRunStepAttemptKey } from "../../utility.mjs";
+import { optionalProperty, sortedStringSet } from "../../collection.mjs";
+import { earliestOptionalTimestamp, shouldReplaceWorkflowEarliestDefinedInstant } from "../../temporal.mjs";
+import { summarizeChildWorkflowRuns } from "./child-workflow-runs.mjs";
+//#region src/engine/summary/child-workflow-waits.ts
+/** Creates a reducer for active child workflow waits across workflow runs. */
+function createWorkflowRunChildWorkflowWaitSummaryReducer() {
+	const waits = createWorkflowRunChildWorkflowWaitAccumulator();
+	return {
+		addChildWorkflowAttempts(runId, attempts, childRuns) {
+			for (const attempt of attempts) addWorkflowRunChildWorkflowWaitAttempt(waits, runId, attempt);
+			for (const childRun of childRuns) waits.childRunRecords.set(childRun.id, childRun);
+		},
+		finish() {
+			return finishWorkflowRunChildWorkflowWaitSummary(waits);
+		}
+	};
+}
+function createWorkflowRunChildWorkflowWaitAccumulator() {
+	return {
+		total: 0,
+		attemptKeys: /* @__PURE__ */ new Set(),
+		childRunIds: /* @__PURE__ */ new Set(),
+		childRunRecords: /* @__PURE__ */ new Map(),
+		runIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set(),
+		workflows: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRunChildWorkflowWaitAttempt(waits, runId, attempt) {
+	const attemptKey = makeWorkflowRunStepAttemptKey(runId, attempt);
+	waits.total++;
+	waits.runIds.add(runId);
+	waits.stepIds.add(attempt.stepId);
+	waits.attemptKeys.add(attemptKey);
+	waits.oldestStartedAt = earliestOptionalTimestamp(waits.oldestStartedAt, attempt.startedAt);
+	if (shouldReplaceWorkflowEarliestDefinedInstant(waits.nextTimeoutAt, attempt.timeoutAt)) setWorkflowRunChildWorkflowWaitNextTimeout(waits, runId, attempt, attemptKey);
+	if (attempt.childRunId !== void 0) waits.childRunIds.add(attempt.childRunId);
+	if (attempt.workflowName !== void 0) waits.workflows.add(attempt.workflowVersion === void 0 ? attempt.workflowName : `${attempt.workflowName}@${attempt.workflowVersion}`);
+}
+function setWorkflowRunChildWorkflowWaitNextTimeout(waits, runId, attempt, attemptKey) {
+	waits.nextTimeoutAt = attempt.timeoutAt;
+	waits.nextTimeoutRunId = runId;
+	waits.nextTimeoutStepId = attempt.stepId;
+	waits.nextTimeoutAttemptKey = attemptKey;
+}
+function finishWorkflowRunChildWorkflowWaitSummary(waits) {
+	return waits.total === 0 ? {} : { childWorkflow: {
+		activeWaits: waits.total,
+		activeWaitRuns: waits.runIds.size,
+		waitRunIds: sortedStringSet(waits.runIds),
+		waitStepIds: sortedStringSet(waits.stepIds),
+		waitAttemptKeys: sortedStringSet(waits.attemptKeys),
+		childRunIds: sortedStringSet(waits.childRunIds),
+		workflows: sortedStringSet(waits.workflows),
+		...summarizeChildWorkflowRuns([...waits.childRunRecords.values()]),
+		...optionalProperty("oldestWaitStartedAt", waits.oldestStartedAt),
+		...waits.nextTimeoutAt === void 0 ? {} : {
+			nextWaitTimeoutAt: waits.nextTimeoutAt,
+			...optionalProperty("nextWaitTimeoutRunId", waits.nextTimeoutRunId),
+			...optionalProperty("nextWaitTimeoutStepId", waits.nextTimeoutStepId),
+			...optionalProperty("nextWaitTimeoutAttemptKey", waits.nextTimeoutAttemptKey)
+		}
+	} };
+}
+//#endregion
+export { createWorkflowRunChildWorkflowWaitSummaryReducer };

package/dist/engine/summary/recovery-child-workflow-waits.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowRecoveryChildWorkflowWaitSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/recovery-child-workflow-waits.d.ts
+interface WorkflowRecoveryChildWorkflowWaitSummaryReducer {
+  addAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  finish(): WorkflowRecoveryChildWorkflowWaitSummary;
+}
+declare function createWorkflowRecoveryChildWorkflowWaitSummaryReducer(childRuns: readonly WorkflowRunRecord[], now: Temporal.Instant): WorkflowRecoveryChildWorkflowWaitSummaryReducer;
+//#endregion
+export { WorkflowRecoveryChildWorkflowWaitSummaryReducer, createWorkflowRecoveryChildWorkflowWaitSummaryReducer };

package/dist/engine/summary/recovery-child-workflow-waits.mjs

@@ -0,0 +1,89 @@
+import { earliestWorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-child-workflow-waits.ts
+function createWorkflowRecoveryChildWorkflowWaitSummaryReducer(childRuns, now) {
+	const childWorkflow = createWorkflowChildWorkflowWaitAccumulator();
+	const childByRunId = new Map(childRuns.map((run) => [run.id, run]));
+	return {
+		addAttempts(attempts) {
+			for (const attempt of attempts) addWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, childByRunId, now);
+		},
+		finish() {
+			return finishWorkflowChildWorkflowWaitSummary(childWorkflow);
+		}
+	};
+}
+function createWorkflowChildWorkflowWaitAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		terminalRunIds: /* @__PURE__ */ new Set(),
+		missingRunIds: /* @__PURE__ */ new Set(),
+		timedOutRunIds: /* @__PURE__ */ new Set(),
+		terminalStepIds: /* @__PURE__ */ new Set(),
+		missingStepIds: /* @__PURE__ */ new Set(),
+		timedOutStepIds: /* @__PURE__ */ new Set(),
+		childRunIds: /* @__PURE__ */ new Set(),
+		completedChildRunIds: /* @__PURE__ */ new Set(),
+		failedChildRunIds: /* @__PURE__ */ new Set(),
+		canceledChildRunIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, childByRunId, now) {
+	if (attempt.status !== "running" || attempt.kind !== "workflow") return;
+	childWorkflow.runIds.add(attempt.runId);
+	if (!addResolvedWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, childByRunId)) addTimedOutWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, now);
+}
+function addResolvedWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, childByRunId) {
+	if (attempt.childRunId === void 0) {
+		addMissingWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt);
+		return true;
+	}
+	childWorkflow.childRunIds.add(attempt.childRunId);
+	const child = childByRunId.get(attempt.childRunId);
+	if (child === void 0) {
+		addMissingWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt);
+		return true;
+	}
+	if (child.status !== "completed" && child.status !== "failed" && child.status !== "canceled") return false;
+	childWorkflow.terminalRunIds.add(attempt.runId);
+	childWorkflow.terminalStepIds.add(attempt.stepId);
+	if (child.status === "completed") childWorkflow.completedChildRunIds.add(child.id);
+	else if (child.status === "failed") childWorkflow.failedChildRunIds.add(child.id);
+	else childWorkflow.canceledChildRunIds.add(child.id);
+	return true;
+}
+function addMissingWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt) {
+	childWorkflow.missingRunIds.add(attempt.runId);
+	childWorkflow.missingStepIds.add(attempt.stepId);
+}
+function addTimedOutWorkflowChildWorkflowWaitAttempt(childWorkflow, attempt, now) {
+	if (attempt.timeoutAt === void 0) return;
+	if (Temporal.Instant.compare(attempt.timeoutAt, now) <= 0) {
+		childWorkflow.timedOutRunIds.add(attempt.runId);
+		childWorkflow.timedOutStepIds.add(attempt.stepId);
+		return;
+	}
+	childWorkflow.nextTimeout = earliestWorkflowRecoveryTimestamp(childWorkflow.nextTimeout, attempt.runId, attempt.timeoutAt);
+}
+function finishWorkflowChildWorkflowWaitSummary(childWorkflow) {
+	return {
+		active: childWorkflow.runIds.size,
+		terminal: childWorkflow.terminalRunIds.size,
+		missing: childWorkflow.missingRunIds.size,
+		timedOut: childWorkflow.timedOutRunIds.size,
+		runIds: [...childWorkflow.runIds].sort(),
+		terminalRunIds: [...childWorkflow.terminalRunIds].sort(),
+		missingRunIds: [...childWorkflow.missingRunIds].sort(),
+		timedOutRunIds: [...childWorkflow.timedOutRunIds].sort(),
+		terminalStepIds: [...childWorkflow.terminalStepIds].sort(),
+		missingStepIds: [...childWorkflow.missingStepIds].sort(),
+		timedOutStepIds: [...childWorkflow.timedOutStepIds].sort(),
+		childRunIds: [...childWorkflow.childRunIds].sort(),
+		completedChildRunIds: [...childWorkflow.completedChildRunIds].sort(),
+		failedChildRunIds: [...childWorkflow.failedChildRunIds].sort(),
+		canceledChildRunIds: [...childWorkflow.canceledChildRunIds].sort(),
+		...childWorkflow.nextTimeout === void 0 ? {} : { nextTimeoutAt: childWorkflow.nextTimeout.timestamp },
+		...childWorkflow.nextTimeout === void 0 ? {} : { nextTimeoutRunId: childWorkflow.nextTimeout.runId }
+	};
+}
+//#endregion
+export { createWorkflowRecoveryChildWorkflowWaitSummaryReducer };

package/dist/engine/summary/recovery-due-runs.d.mts

@@ -0,0 +1,16 @@
+import { WorkflowRecoveryDueSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+import { WorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-due-runs.d.ts
+interface WorkflowRecoveryDueRunSummaryParts {
+  readonly due: WorkflowRecoveryDueSummary;
+  readonly dueRunIds: readonly string[];
+  readonly nextAvailable?: WorkflowRecoveryTimestamp;
+}
+interface WorkflowRecoveryDueRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowRecoveryDueRunSummaryParts;
+}
+declare function createWorkflowRecoveryDueRunSummaryReducer(now: Temporal.Instant): WorkflowRecoveryDueRunSummaryReducer;
+//#endregion
+export { WorkflowRecoveryDueRunSummaryParts, WorkflowRecoveryDueRunSummaryReducer, createWorkflowRecoveryDueRunSummaryReducer };

package/dist/engine/summary/recovery-due-runs.mjs

@@ -0,0 +1,52 @@
+import { isScheduledWorkflowRunStatus } from "../../utility.mjs";
+import { earliestWorkflowRecoveryTimestamp, isWorkflowRecoveryRunDueAt } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-due-runs.ts
+function createWorkflowRecoveryDueRunSummaryReducer(now) {
+	const due = createWorkflowRecoveryDueRunAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRecoveryDueRun(due, run, now);
+		},
+		finish() {
+			return {
+				due: finishWorkflowRecoveryDueSummary(due),
+				dueRunIds: [...due.runIds].sort(),
+				...due.nextAvailable === void 0 ? {} : { nextAvailable: due.nextAvailable }
+			};
+		}
+	};
+}
+function createWorkflowRecoveryDueRunAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		pendingRunIds: /* @__PURE__ */ new Set(),
+		waitingRunIds: /* @__PURE__ */ new Set(),
+		invalidScheduleRunIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRecoveryDueRun(due, run, now) {
+	if (!isScheduledWorkflowRunStatus(run.status)) return;
+	const availableAt = run.availableAt;
+	if (isWorkflowRecoveryRunDueAt(availableAt, now)) {
+		due.runIds.add(run.id);
+		if (run.status === "pending") due.pendingRunIds.add(run.id);
+		else due.waitingRunIds.add(run.id);
+		return;
+	}
+	if (availableAt !== void 0) due.nextAvailable = earliestWorkflowRecoveryTimestamp(due.nextAvailable, run.id, availableAt);
+}
+function finishWorkflowRecoveryDueSummary(due) {
+	return {
+		total: due.runIds.size,
+		runIds: [...due.runIds].sort(),
+		pendingRunIds: [...due.pendingRunIds].sort(),
+		waitingRunIds: [...due.waitingRunIds].sort(),
+		invalidScheduleRunIds: [...due.invalidScheduleRunIds].sort(),
+		...due.nextAvailable === void 0 ? {} : {
+			nextAvailableAt: due.nextAvailable.timestamp,
+			nextAvailableRunId: due.nextAvailable.runId
+		}
+	};
+}
+//#endregion
+export { createWorkflowRecoveryDueRunSummaryReducer };

package/dist/engine/summary/recovery-failed-runs.d.mts

@@ -0,0 +1,14 @@
+import { WorkflowRecoveryFailedSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/recovery-failed-runs.d.ts
+interface WorkflowRecoveryFailedRunSummaryParts {
+  readonly failed: WorkflowRecoveryFailedSummary;
+  readonly failedRunIds: readonly string[];
+}
+interface WorkflowRecoveryFailedRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowRecoveryFailedRunSummaryParts;
+}
+declare function createWorkflowRecoveryFailedRunSummaryReducer(): WorkflowRecoveryFailedRunSummaryReducer;
+//#endregion
+export { WorkflowRecoveryFailedRunSummaryParts, WorkflowRecoveryFailedRunSummaryReducer, createWorkflowRecoveryFailedRunSummaryReducer };

package/dist/engine/summary/recovery-failed-runs.mjs

@@ -0,0 +1,33 @@
+import { latestOptionalWorkflowRecoveryInstant } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-failed-runs.ts
+function createWorkflowRecoveryFailedRunSummaryReducer() {
+	const failed = createWorkflowRecoveryFailedRunAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRecoveryFailedRun(failed, run);
+		},
+		finish() {
+			return {
+				failed: finishWorkflowRecoveryFailedSummary(failed),
+				failedRunIds: [...failed.runIds].sort()
+			};
+		}
+	};
+}
+function createWorkflowRecoveryFailedRunAccumulator() {
+	return { runIds: /* @__PURE__ */ new Set() };
+}
+function addWorkflowRecoveryFailedRun(failed, run) {
+	if (run.status !== "failed") return;
+	failed.runIds.add(run.id);
+	failed.latestFailedAt = latestOptionalWorkflowRecoveryInstant(failed.latestFailedAt, run.finishedAt);
+}
+function finishWorkflowRecoveryFailedSummary(failed) {
+	return {
+		total: failed.runIds.size,
+		runIds: [...failed.runIds].sort(),
+		...failed.latestFailedAt === void 0 ? {} : { latestFailedAt: failed.latestFailedAt }
+	};
+}
+//#endregion
+export { createWorkflowRecoveryFailedRunSummaryReducer };

package/dist/engine/summary/recovery-lease-runs.d.mts

@@ -0,0 +1,16 @@
+import { WorkflowRecoveryLeaseSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+import { WorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-lease-runs.d.ts
+interface WorkflowRecoveryLeaseRunSummaryParts {
+  readonly lease: WorkflowRecoveryLeaseSummary;
+  readonly staleRunIds: readonly string[];
+  readonly nextLeaseExpires?: WorkflowRecoveryTimestamp;
+}
+interface WorkflowRecoveryLeaseRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowRecoveryLeaseRunSummaryParts;
+}
+declare function createWorkflowRecoveryLeaseRunSummaryReducer(now: Temporal.Instant): WorkflowRecoveryLeaseRunSummaryReducer;
+//#endregion
+export { WorkflowRecoveryLeaseRunSummaryParts, WorkflowRecoveryLeaseRunSummaryReducer, createWorkflowRecoveryLeaseRunSummaryReducer };

package/dist/engine/summary/recovery-lease-runs.mjs

@@ -0,0 +1,69 @@
+import { earliestWorkflowRecoveryInstant, earliestWorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-lease-runs.ts
+function createWorkflowRecoveryLeaseRunSummaryReducer(now) {
+	const lease = createWorkflowRecoveryLeaseRunAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRecoveryLeaseRun(lease, run, now);
+		},
+		finish() {
+			return {
+				lease: finishWorkflowRecoveryLeaseSummary(lease),
+				staleRunIds: [...lease.staleRunIds].sort(),
+				...lease.nextExpires === void 0 ? {} : { nextLeaseExpires: lease.nextExpires }
+			};
+		}
+	};
+}
+function createWorkflowRecoveryLeaseRunAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		staleRunIds: /* @__PURE__ */ new Set(),
+		ownerlessRunIds: /* @__PURE__ */ new Set(),
+		missingExpiresAtRunIds: /* @__PURE__ */ new Set(),
+		invalidExpiresAtRunIds: /* @__PURE__ */ new Set(),
+		expiredRunIds: /* @__PURE__ */ new Set(),
+		workerIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRecoveryLeaseRun(lease, run, now) {
+	if (run.status !== "running") return;
+	lease.runIds.add(run.id);
+	if (run.workerId !== void 0) lease.workerIds.add(run.workerId);
+	else {
+		lease.staleRunIds.add(run.id);
+		lease.ownerlessRunIds.add(run.id);
+	}
+	if (run.leaseExpiresAt === void 0) {
+		lease.staleRunIds.add(run.id);
+		lease.missingExpiresAtRunIds.add(run.id);
+		return;
+	}
+	if (Temporal.Instant.compare(run.leaseExpiresAt, now) <= 0) {
+		lease.staleRunIds.add(run.id);
+		lease.expiredRunIds.add(run.id);
+		lease.oldestStaleAt = earliestWorkflowRecoveryInstant(lease.oldestStaleAt, run.leaseExpiresAt);
+		return;
+	}
+	if (run.workerId !== void 0) lease.nextExpires = earliestWorkflowRecoveryTimestamp(lease.nextExpires, run.id, run.leaseExpiresAt);
+}
+function finishWorkflowRecoveryLeaseSummary(lease) {
+	return {
+		total: lease.runIds.size,
+		stale: lease.staleRunIds.size,
+		runIds: [...lease.runIds].sort(),
+		staleRunIds: [...lease.staleRunIds].sort(),
+		ownerlessRunIds: [...lease.ownerlessRunIds].sort(),
+		missingExpiresAtRunIds: [...lease.missingExpiresAtRunIds].sort(),
+		invalidExpiresAtRunIds: [...lease.invalidExpiresAtRunIds].sort(),
+		expiredRunIds: [...lease.expiredRunIds].sort(),
+		workerIds: [...lease.workerIds].sort(),
+		...lease.nextExpires === void 0 ? {} : {
+			nextExpiresAt: lease.nextExpires.timestamp,
+			nextExpiringRunId: lease.nextExpires.runId
+		},
+		...lease.oldestStaleAt === void 0 ? {} : { oldestStaleAt: lease.oldestStaleAt }
+	};
+}
+//#endregion
+export { createWorkflowRecoveryLeaseRunSummaryReducer };

package/dist/engine/summary/recovery-locks.d.mts

@@ -0,0 +1,18 @@
+import { LockRecord } from "../../types/lock.mjs";
+import { WorkflowRecoveryLockSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/recovery-locks.d.ts
+interface WorkflowRecoveryLockWaitDetails {
+  readonly key: string;
+  readonly waitDeadlineAt?: Temporal.Instant;
+}
+interface WorkflowRecoveryLockSummaryReducer {
+  addLock(lock: LockRecord): void;
+  addLockWaitAttempt(attempt: WorkflowStepAttemptRecord): void;
+  finish(): WorkflowRecoveryLockSummary;
+}
+declare function createWorkflowRecoveryLockSummaryReducer(runs: readonly WorkflowRunRecord[], now: Temporal.Instant): WorkflowRecoveryLockSummaryReducer;
+declare function workflowRecoveryLockWaitDetails(attempt: WorkflowStepAttemptRecord): WorkflowRecoveryLockWaitDetails | undefined;
+//#endregion
+export { WorkflowRecoveryLockSummaryReducer, WorkflowRecoveryLockWaitDetails, createWorkflowRecoveryLockSummaryReducer, workflowRecoveryLockWaitDetails };

package/dist/engine/summary/recovery-locks.mjs

@@ -0,0 +1,100 @@
+import { WorkflowRetryableError } from "../../errors/failures.mjs";
+import "../../errors/mod.mjs";
+import { earliestWorkflowRecoveryInstant, earliestWorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-locks.ts
+function createWorkflowRecoveryLockSummaryReducer(runs, now) {
+	const locks = createWorkflowRecoveryLockAccumulator();
+	const runById = new Map(runs.map((run) => [run.id, run]));
+	return {
+		addLock(lock) {
+			addWorkflowRecoveryLock(locks, lock, now);
+		},
+		addLockWaitAttempt(attempt) {
+			addWorkflowRecoveryLockWaitAttempt(locks, attempt, runById, now);
+		},
+		finish() {
+			return finishWorkflowRecoveryLockSummary(locks);
+		}
+	};
+}
+function createWorkflowRecoveryLockAccumulator() {
+	return {
+		dueWaitingRunIds: /* @__PURE__ */ new Set(),
+		holderIds: /* @__PURE__ */ new Set(),
+		keys: /* @__PURE__ */ new Set(),
+		staleKeys: /* @__PURE__ */ new Set(),
+		waitingKeys: /* @__PURE__ */ new Set(),
+		waitingRunIds: /* @__PURE__ */ new Set(),
+		waitingStepIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRecoveryLock(locks, lock, now) {
+	if (lock.releasedAt !== void 0) return;
+	locks.keys.add(lock.key);
+	if (lock.holderId !== void 0) locks.holderIds.add(lock.holderId);
+	if (Temporal.Instant.compare(lock.leaseExpiresAt, now) <= 0) {
+		locks.staleKeys.add(lock.key);
+		locks.oldestStaleAt = earliestWorkflowRecoveryInstant(locks.oldestStaleAt, lock.leaseExpiresAt);
+		return;
+	}
+	locks.nextExpires = earliestWorkflowRecoveryLockExpiration(locks.nextExpires, lock.key, lock.leaseExpiresAt);
+}
+function addWorkflowRecoveryLockWaitAttempt(locks, attempt, runById, now) {
+	const details = workflowRecoveryLockWaitDetails(attempt);
+	if (details === void 0) return;
+	const run = runById.get(attempt.runId);
+	if (run === void 0 || run.status !== "waiting" || run.retryReason !== "step") return;
+	locks.waitingRunIds.add(attempt.runId);
+	locks.waitingStepIds.add(attempt.stepId);
+	locks.waitingKeys.add(details.key);
+	if (run.retryAt === void 0 || Temporal.Instant.compare(run.retryAt, now) <= 0) locks.dueWaitingRunIds.add(attempt.runId);
+	if (details.waitDeadlineAt !== void 0 && Temporal.Instant.compare(details.waitDeadlineAt, now) > 0) locks.nextWaitDeadline = earliestWorkflowRecoveryTimestamp(locks.nextWaitDeadline, attempt.runId, details.waitDeadlineAt);
+}
+function finishWorkflowRecoveryLockSummary(locks) {
+	return {
+		total: locks.keys.size,
+		stale: locks.staleKeys.size,
+		keys: [...locks.keys].sort(),
+		staleKeys: [...locks.staleKeys].sort(),
+		holderIds: [...locks.holderIds].sort(),
+		waitingRunIds: [...locks.waitingRunIds].sort(),
+		dueWaitingRunIds: [...locks.dueWaitingRunIds].sort(),
+		waitingStepIds: [...locks.waitingStepIds].sort(),
+		waitingKeys: [...locks.waitingKeys].sort(),
+		...locks.nextExpires === void 0 ? {} : {
+			nextExpiresAt: locks.nextExpires.timestamp,
+			nextExpiringKey: locks.nextExpires.key
+		},
+		...locks.oldestStaleAt === void 0 ? {} : { oldestStaleAt: locks.oldestStaleAt },
+		...locks.nextWaitDeadline === void 0 ? {} : {
+			nextWaitDeadlineAt: locks.nextWaitDeadline.timestamp,
+			nextWaitDeadlineRunId: locks.nextWaitDeadline.runId
+		}
+	};
+}
+function workflowRecoveryLockWaitDetails(attempt) {
+	const error = attempt.error;
+	if (!(attempt.status === "failed" && attempt.kind === "run" && error !== void 0 && WorkflowRetryableError.isLockAlreadyHeld(error) && typeof error.details?.key === "string" && error.details.key.trim() !== "")) return;
+	const waitDeadlineAt = workflowLockWaitDeadline(attempt);
+	return {
+		key: error.details.key,
+		...waitDeadlineAt === void 0 ? {} : { waitDeadlineAt }
+	};
+}
+function workflowLockWaitDeadline(attempt) {
+	const deadline = attempt.error?.details?.waitDeadlineAt;
+	if (!(typeof deadline === "string" && deadline.trim() !== "")) return;
+	try {
+		return Temporal.Instant.from(deadline);
+	} catch {
+		return;
+	}
+}
+function earliestWorkflowRecoveryLockExpiration(current, key, timestamp) {
+	return current === void 0 || Temporal.Instant.compare(timestamp, current.timestamp) < 0 ? {
+		key,
+		timestamp
+	} : current;
+}
+//#endregion
+export { createWorkflowRecoveryLockSummaryReducer, workflowRecoveryLockWaitDetails };

package/dist/engine/summary/recovery-message-waits.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowRecoveryMessageWaitSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { EventRecord } from "../../types/events.mjs";
+//#region src/engine/summary/recovery-message-waits.d.ts
+interface WorkflowRecoveryMessageWaitSummaryReducer {
+  addAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  finish(): WorkflowRecoveryMessageWaitSummary;
+}
+declare function createWorkflowRecoveryMessageWaitSummaryReducer(eventsByRunId: ReadonlyMap<string, readonly EventRecord[]>, now: Temporal.Instant): WorkflowRecoveryMessageWaitSummaryReducer;
+//#endregion
+export { WorkflowRecoveryMessageWaitSummaryReducer, createWorkflowRecoveryMessageWaitSummaryReducer };

package/dist/engine/summary/recovery-message-waits.mjs

@@ -0,0 +1,74 @@
+import { WorkflowHistory } from "../../history/mod.mjs";
+import { earliestWorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-message-waits.ts
+function createWorkflowRecoveryMessageWaitSummaryReducer(eventsByRunId, now) {
+	const message = createMessageWaitAccumulator();
+	const historiesByRunId = workflowHistoriesByRunId(eventsByRunId);
+	return {
+		addAttempts(attempts) {
+			for (const attempt of attempts) addMessageWaitAttempt(message, attempt, historiesByRunId, now);
+		},
+		finish() {
+			return finishMessageWaitSummary(message);
+		}
+	};
+}
+function createMessageWaitAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		readyRunIds: /* @__PURE__ */ new Set(),
+		timedOutRunIds: /* @__PURE__ */ new Set(),
+		readyStepIds: /* @__PURE__ */ new Set(),
+		timedOutStepIds: /* @__PURE__ */ new Set(),
+		messageIds: /* @__PURE__ */ new Set()
+	};
+}
+function addMessageWaitAttempt(message, attempt, historiesByRunId, now) {
+	if (attempt.status !== "running" || attempt.kind !== "message-wait") return;
+	message.runIds.add(attempt.runId);
+	if (!addReadyMessageWaitAttempt(message, attempt, historiesByRunId)) addTimedOutMessageWaitAttempt(message, attempt, now);
+}
+function addReadyMessageWaitAttempt(message, attempt, historiesByRunId) {
+	if (attempt.messageId === void 0) return false;
+	message.messageIds.add(attempt.messageId);
+	if (!messageWasDeliveredForAttempt(historiesByRunId.get(attempt.runId), attempt)) return false;
+	message.readyRunIds.add(attempt.runId);
+	message.readyStepIds.add(attempt.stepId);
+	return true;
+}
+function messageWasDeliveredForAttempt(history, attempt) {
+	return history !== void 0 && attempt.messageId !== void 0 && history.messageForWait(attempt.messageId, attempt.stepId, attempt.timeoutAt) !== void 0;
+}
+function addTimedOutMessageWaitAttempt(message, attempt, now) {
+	if (attempt.timeoutAt === void 0) return;
+	if (Temporal.Instant.compare(attempt.timeoutAt, now) <= 0) {
+		message.timedOutRunIds.add(attempt.runId);
+		message.timedOutStepIds.add(attempt.stepId);
+		return;
+	}
+	message.nextTimeout = earliestWorkflowRecoveryTimestamp(message.nextTimeout, attempt.runId, attempt.timeoutAt);
+}
+function workflowHistoriesByRunId(eventsByRunId) {
+	const histories = /* @__PURE__ */ new Map();
+	for (const [runId, events] of eventsByRunId) histories.set(runId, new WorkflowHistory(events));
+	return histories;
+}
+function finishMessageWaitSummary(message) {
+	return {
+		active: message.runIds.size,
+		ready: message.readyRunIds.size,
+		timedOut: message.timedOutRunIds.size,
+		runIds: [...message.runIds].sort(),
+		readyRunIds: [...message.readyRunIds].sort(),
+		timedOutRunIds: [...message.timedOutRunIds].sort(),
+		readyStepIds: [...message.readyStepIds].sort(),
+		timedOutStepIds: [...message.timedOutStepIds].sort(),
+		messages: [...message.messageIds].sort(),
+		...message.nextTimeout === void 0 ? {} : {
+			nextTimeoutAt: message.nextTimeout.timestamp,
+			nextTimeoutRunId: message.nextTimeout.runId
+		}
+	};
+}
+//#endregion
+export { createWorkflowRecoveryMessageWaitSummaryReducer };

package/dist/engine/summary/recovery-retry-runs.d.mts

@@ -0,0 +1,17 @@
+import { WorkflowRecoveryMissingImplementationSummary, WorkflowRecoveryRetrySummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+import { WorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-retry-runs.d.ts
+interface WorkflowRecoveryRetryRunSummaryParts {
+  readonly retry: WorkflowRecoveryRetrySummary;
+  readonly missingImplementation: WorkflowRecoveryMissingImplementationSummary;
+  readonly dueRetryRunIds: readonly string[];
+  readonly nextRetry?: WorkflowRecoveryTimestamp;
+}
+interface WorkflowRecoveryRetryRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowRecoveryRetryRunSummaryParts;
+}
+declare function createWorkflowRecoveryRetryRunSummaryReducer(now: Temporal.Instant): WorkflowRecoveryRetryRunSummaryReducer;
+//#endregion
+export { WorkflowRecoveryRetryRunSummaryParts, WorkflowRecoveryRetryRunSummaryReducer, createWorkflowRecoveryRetryRunSummaryReducer };

package/dist/engine/summary/recovery-retry-runs.mjs

@@ -0,0 +1,65 @@
+import { isScheduledWorkflowRunStatus } from "../../utility.mjs";
+import { earliestWorkflowRecoveryTimestamp, isWorkflowRecoveryRunDueAt } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-retry-runs.ts
+function createWorkflowRecoveryRetryRunSummaryReducer(now) {
+	const retry = createWorkflowRecoveryRetryRunAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRecoveryRetryRun(retry, run, now);
+		},
+		finish() {
+			return {
+				retry: finishWorkflowRecoveryRetrySummary(retry),
+				missingImplementation: finishWorkflowRecoveryMissingImplementationSummary(retry),
+				dueRetryRunIds: [...retry.dueRunIds].sort(),
+				...retry.next === void 0 ? {} : { nextRetry: retry.next }
+			};
+		}
+	};
+}
+function createWorkflowRecoveryRetryRunAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		dueRunIds: /* @__PURE__ */ new Set(),
+		missingImplementationRunIds: /* @__PURE__ */ new Set(),
+		dueMissingImplementationRunIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRecoveryRetryRun(retry, run, now) {
+	if (!isScheduledWorkflowRunStatus(run.status) || run.retryReason === void 0) return;
+	retry.runIds.add(run.id);
+	const retryAt = run.retryAt;
+	const due = isWorkflowRecoveryRunDueAt(retryAt, now);
+	if (due) retry.dueRunIds.add(run.id);
+	else if (retryAt !== void 0) retry.next = earliestWorkflowRecoveryTimestamp(retry.next, run.id, retryAt);
+	if (run.retryReason !== "missing_implementation") return;
+	retry.missingImplementationRunIds.add(run.id);
+	if (due) retry.dueMissingImplementationRunIds.add(run.id);
+	else if (retryAt !== void 0) retry.nextMissingImplementation = earliestWorkflowRecoveryTimestamp(retry.nextMissingImplementation, run.id, retryAt);
+}
+function finishWorkflowRecoveryRetrySummary(retry) {
+	return {
+		total: retry.runIds.size,
+		due: retry.dueRunIds.size,
+		runIds: [...retry.runIds].sort(),
+		dueRunIds: [...retry.dueRunIds].sort(),
+		...retry.next === void 0 ? {} : {
+			nextRetryAt: retry.next.timestamp,
+			nextRetryRunId: retry.next.runId
+		}
+	};
+}
+function finishWorkflowRecoveryMissingImplementationSummary(retry) {
+	return {
+		total: retry.missingImplementationRunIds.size,
+		due: retry.dueMissingImplementationRunIds.size,
+		runIds: [...retry.missingImplementationRunIds].sort(),
+		dueRunIds: [...retry.dueMissingImplementationRunIds].sort(),
+		...retry.nextMissingImplementation === void 0 ? {} : {
+			nextRetryAt: retry.nextMissingImplementation.timestamp,
+			nextRetryRunId: retry.nextMissingImplementation.runId
+		}
+	};
+}
+//#endregion
+export { createWorkflowRecoveryRetryRunSummaryReducer };