@temelj/workflow 0.0.0-alpha.1

package/dist/engine/summary/recovery-run-timestamps.d.mts

@@ -0,0 +1,13 @@
+import { RunId } from "../../types/run-id.mjs";
+import "../../types/run.mjs";
+//#region src/engine/summary/recovery-run-timestamps.d.ts
+interface WorkflowRecoveryTimestamp {
+  readonly runId: RunId;
+  readonly timestamp: Temporal.Instant;
+}
+declare function isWorkflowRecoveryRunDueAt(timestamp: Temporal.Instant | undefined, now: Temporal.Instant): boolean;
+declare function earliestWorkflowRecoveryTimestamp(current: WorkflowRecoveryTimestamp | undefined, runId: RunId, timestamp: Temporal.Instant): WorkflowRecoveryTimestamp;
+declare function earliestWorkflowRecoveryInstant(current: Temporal.Instant | undefined, timestamp: Temporal.Instant): Temporal.Instant;
+declare function latestOptionalWorkflowRecoveryInstant(current: Temporal.Instant | undefined, timestamp: Temporal.Instant | undefined): Temporal.Instant | undefined;
+//#endregion
+export { WorkflowRecoveryTimestamp, earliestWorkflowRecoveryInstant, earliestWorkflowRecoveryTimestamp, isWorkflowRecoveryRunDueAt, latestOptionalWorkflowRecoveryInstant };

package/dist/engine/summary/recovery-run-timestamps.mjs

@@ -0,0 +1,18 @@
+//#region src/engine/summary/recovery-run-timestamps.ts
+function isWorkflowRecoveryRunDueAt(timestamp, now) {
+	return timestamp === void 0 || Temporal.Instant.compare(timestamp, now) <= 0;
+}
+function earliestWorkflowRecoveryTimestamp(current, runId, timestamp) {
+	return current === void 0 || Temporal.Instant.compare(timestamp, current.timestamp) < 0 ? {
+		runId,
+		timestamp
+	} : current;
+}
+function earliestWorkflowRecoveryInstant(current, timestamp) {
+	return current === void 0 || Temporal.Instant.compare(timestamp, current) < 0 ? timestamp : current;
+}
+function latestOptionalWorkflowRecoveryInstant(current, timestamp) {
+	return timestamp === void 0 || current !== void 0 && Temporal.Instant.compare(timestamp, current) <= 0 ? current : timestamp;
+}
+//#endregion
+export { earliestWorkflowRecoveryInstant, earliestWorkflowRecoveryTimestamp, isWorkflowRecoveryRunDueAt, latestOptionalWorkflowRecoveryInstant };

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

@@ -0,0 +1,23 @@
+import { WorkflowRecoveryDueSummary, WorkflowRecoveryFailedSummary, WorkflowRecoveryLeaseSummary, WorkflowRecoveryMissingImplementationSummary, WorkflowRecoveryRetrySummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+import { WorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-runs.d.ts
+interface WorkflowRecoveryRunSummaryParts {
+  readonly total: number;
+  readonly recoverableRunIds: readonly string[];
+  readonly due: WorkflowRecoveryDueSummary;
+  readonly lease: WorkflowRecoveryLeaseSummary;
+  readonly retry: WorkflowRecoveryRetrySummary;
+  readonly missingImplementation: WorkflowRecoveryMissingImplementationSummary;
+  readonly failed: WorkflowRecoveryFailedSummary;
+  readonly nextAvailable?: WorkflowRecoveryTimestamp;
+  readonly nextLeaseExpires?: WorkflowRecoveryTimestamp;
+  readonly nextRetry?: WorkflowRecoveryTimestamp;
+}
+interface WorkflowRecoveryRunSummaryReducer {
+  addRun(run: WorkflowRunRecord): void;
+  finish(): WorkflowRecoveryRunSummaryParts;
+}
+declare function createWorkflowRecoveryRunSummaryReducer(now: Temporal.Instant): WorkflowRecoveryRunSummaryReducer;
+//#endregion
+export { WorkflowRecoveryRunSummaryParts, WorkflowRecoveryRunSummaryReducer, createWorkflowRecoveryRunSummaryReducer };

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

@@ -0,0 +1,54 @@
+import { createWorkflowRecoveryDueRunSummaryReducer } from "./recovery-due-runs.mjs";
+import { createWorkflowRecoveryFailedRunSummaryReducer } from "./recovery-failed-runs.mjs";
+import { createWorkflowRecoveryLeaseRunSummaryReducer } from "./recovery-lease-runs.mjs";
+import { createWorkflowRecoveryRetryRunSummaryReducer } from "./recovery-retry-runs.mjs";
+//#region src/engine/summary/recovery-runs.ts
+function createWorkflowRecoveryRunSummaryReducer(now) {
+	const due = createWorkflowRecoveryDueRunSummaryReducer(now);
+	const lease = createWorkflowRecoveryLeaseRunSummaryReducer(now);
+	const retry = createWorkflowRecoveryRetryRunSummaryReducer(now);
+	const failed = createWorkflowRecoveryFailedRunSummaryReducer();
+	let total = 0;
+	return {
+		addRun(run) {
+			total++;
+			due.addRun(run);
+			lease.addRun(run);
+			retry.addRun(run);
+			failed.addRun(run);
+		},
+		finish() {
+			const dueParts = due.finish();
+			const leaseParts = lease.finish();
+			const retryParts = retry.finish();
+			const failedParts = failed.finish();
+			return {
+				total,
+				recoverableRunIds: finishWorkflowRecoveryRecoverableRunIds(dueParts, leaseParts, retryParts, failedParts),
+				due: dueParts.due,
+				lease: leaseParts.lease,
+				retry: retryParts.retry,
+				missingImplementation: retryParts.missingImplementation,
+				failed: failedParts.failed,
+				...finishWorkflowRecoveryNextSummary(dueParts, leaseParts, retryParts)
+			};
+		}
+	};
+}
+function finishWorkflowRecoveryRecoverableRunIds(due, lease, retry, failed) {
+	return [.../* @__PURE__ */ new Set([
+		...due.dueRunIds,
+		...lease.staleRunIds,
+		...retry.dueRetryRunIds,
+		...failed.failedRunIds
+	])].sort();
+}
+function finishWorkflowRecoveryNextSummary(due, lease, retry) {
+	return {
+		...due.nextAvailable === void 0 ? {} : { nextAvailable: due.nextAvailable },
+		...lease.nextLeaseExpires === void 0 ? {} : { nextLeaseExpires: lease.nextLeaseExpires },
+		...retry.nextRetry === void 0 ? {} : { nextRetry: retry.nextRetry }
+	};
+}
+//#endregion
+export { createWorkflowRecoveryRunSummaryReducer };

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

@@ -0,0 +1,10 @@
+import { ScheduleRecord } from "../../types/schedule.mjs";
+import { WorkflowRecoveryScheduleSummary } from "../../types/summary.mjs";
+//#region src/engine/summary/recovery-schedules.d.ts
+interface WorkflowRecoveryScheduleSummaryReducer {
+  addSchedule(schedule: ScheduleRecord): void;
+  finish(): WorkflowRecoveryScheduleSummary;
+}
+declare function createWorkflowRecoveryScheduleSummaryReducer(now: Temporal.Instant): WorkflowRecoveryScheduleSummaryReducer;
+//#endregion
+export { WorkflowRecoveryScheduleSummaryReducer, createWorkflowRecoveryScheduleSummaryReducer };

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

@@ -0,0 +1,46 @@
+//#region src/engine/summary/recovery-schedules.ts
+function createWorkflowRecoveryScheduleSummaryReducer(now) {
+	const schedules = createWorkflowRecoveryScheduleAccumulator();
+	return {
+		addSchedule(schedule) {
+			addWorkflowRecoverySchedule(schedules, schedule, now);
+		},
+		finish() {
+			return finishWorkflowRecoveryScheduleSummary(schedules);
+		}
+	};
+}
+function createWorkflowRecoveryScheduleAccumulator() {
+	return {
+		dueScheduleIds: /* @__PURE__ */ new Set(),
+		invalidNextFireScheduleIds: /* @__PURE__ */ new Set(),
+		scheduleIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRecoverySchedule(schedules, schedule, now) {
+	if (schedule.status !== "active") return;
+	schedules.scheduleIds.add(schedule.id);
+	if (Temporal.Instant.compare(schedule.nextFireAt, now) <= 0) schedules.dueScheduleIds.add(schedule.id);
+	schedules.nextFire = earliestWorkflowRecoveryScheduleFire(schedules.nextFire, schedule.id, schedule.nextFireAt);
+}
+function finishWorkflowRecoveryScheduleSummary(schedules) {
+	return {
+		total: schedules.scheduleIds.size,
+		due: schedules.dueScheduleIds.size,
+		scheduleIds: [...schedules.scheduleIds].sort(),
+		dueScheduleIds: [...schedules.dueScheduleIds].sort(),
+		invalidNextFireScheduleIds: [...schedules.invalidNextFireScheduleIds].sort(),
+		...schedules.nextFire === void 0 ? {} : {
+			nextFireAt: schedules.nextFire.timestamp,
+			nextFireScheduleId: schedules.nextFire.scheduleId
+		}
+	};
+}
+function earliestWorkflowRecoveryScheduleFire(current, scheduleId, timestamp) {
+	return current === void 0 || Temporal.Instant.compare(timestamp, current.timestamp) < 0 ? {
+		scheduleId,
+		timestamp
+	} : current;
+}
+//#endregion
+export { createWorkflowRecoveryScheduleSummaryReducer };

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

@@ -0,0 +1,10 @@
+import { WorkflowRecoverySleepWaitSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+//#region src/engine/summary/recovery-sleep-waits.d.ts
+interface WorkflowRecoverySleepWaitSummaryReducer {
+  addAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  finish(): WorkflowRecoverySleepWaitSummary;
+}
+declare function createWorkflowRecoverySleepWaitSummaryReducer(now: Temporal.Instant): WorkflowRecoverySleepWaitSummaryReducer;
+//#endregion
+export { WorkflowRecoverySleepWaitSummaryReducer, createWorkflowRecoverySleepWaitSummaryReducer };

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

@@ -0,0 +1,53 @@
+import { earliestWorkflowRecoveryTimestamp } from "./recovery-run-timestamps.mjs";
+//#region src/engine/summary/recovery-sleep-waits.ts
+function createWorkflowRecoverySleepWaitSummaryReducer(now) {
+	const sleep = createWorkflowSleepWaitAccumulator();
+	return {
+		addAttempts(attempts) {
+			for (const attempt of attempts) addWorkflowSleepWaitAttempt(sleep, attempt, now);
+		},
+		finish() {
+			return finishWorkflowSleepWaitSummary(sleep);
+		}
+	};
+}
+function createWorkflowSleepWaitAccumulator() {
+	return {
+		runIds: /* @__PURE__ */ new Set(),
+		dueRunIds: /* @__PURE__ */ new Set(),
+		dueStepIds: /* @__PURE__ */ new Set(),
+		invalidUntilRunIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowSleepWaitAttempt(sleep, attempt, now) {
+	if (attempt.status !== "running" || attempt.kind !== "sleep") return;
+	sleep.runIds.add(attempt.runId);
+	if (attempt.until === void 0) {
+		sleep.dueRunIds.add(attempt.runId);
+		sleep.dueStepIds.add(attempt.stepId);
+		sleep.invalidUntilRunIds.add(attempt.runId);
+		return;
+	}
+	if (Temporal.Instant.compare(attempt.until, now) <= 0) {
+		sleep.dueRunIds.add(attempt.runId);
+		sleep.dueStepIds.add(attempt.stepId);
+		return;
+	}
+	sleep.nextWake = earliestWorkflowRecoveryTimestamp(sleep.nextWake, attempt.runId, attempt.until);
+}
+function finishWorkflowSleepWaitSummary(sleep) {
+	return {
+		active: sleep.runIds.size,
+		due: sleep.dueRunIds.size,
+		runIds: [...sleep.runIds].sort(),
+		dueRunIds: [...sleep.dueRunIds].sort(),
+		dueStepIds: [...sleep.dueStepIds].sort(),
+		invalidUntilRunIds: [...sleep.invalidUntilRunIds].sort(),
+		...sleep.nextWake === void 0 ? {} : {
+			nextWakeAt: sleep.nextWake.timestamp,
+			nextWakeRunId: sleep.nextWake.runId
+		}
+	};
+}
+//#endregion
+export { createWorkflowRecoverySleepWaitSummaryReducer };

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

@@ -0,0 +1,21 @@
+import { WorkflowRecoveryWaitSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+import { EventRecord } from "../../types/events.mjs";
+//#region src/engine/summary/recovery-waits.d.ts
+interface WorkflowRecoveryWaitInputs {
+  readonly sleepAttempts?: readonly WorkflowStepAttemptRecord[];
+  readonly messageWaitAttempts?: readonly WorkflowStepAttemptRecord[];
+  readonly childWorkflowAttempts?: readonly WorkflowStepAttemptRecord[];
+  readonly childRuns?: readonly WorkflowRunRecord[];
+  readonly eventsByRunId?: ReadonlyMap<string, readonly EventRecord[]>;
+}
+interface WorkflowRecoveryWaitSummaryReducer {
+  addSleepAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  addMessageWaitAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  addChildWorkflowAttempts(attempts: readonly WorkflowStepAttemptRecord[]): void;
+  finish(): WorkflowRecoveryWaitSummary;
+}
+declare function createWorkflowRecoveryWaitSummaryReducer(inputs: WorkflowRecoveryWaitInputs, now: Temporal.Instant): WorkflowRecoveryWaitSummaryReducer;
+//#endregion
+export { WorkflowRecoveryWaitInputs, WorkflowRecoveryWaitSummaryReducer, createWorkflowRecoveryWaitSummaryReducer };

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

@@ -0,0 +1,29 @@
+import { createWorkflowRecoveryChildWorkflowWaitSummaryReducer } from "./recovery-child-workflow-waits.mjs";
+import { createWorkflowRecoveryMessageWaitSummaryReducer } from "./recovery-message-waits.mjs";
+import { createWorkflowRecoverySleepWaitSummaryReducer } from "./recovery-sleep-waits.mjs";
+//#region src/engine/summary/recovery-waits.ts
+function createWorkflowRecoveryWaitSummaryReducer(inputs, now) {
+	const sleep = createWorkflowRecoverySleepWaitSummaryReducer(now);
+	const message = createWorkflowRecoveryMessageWaitSummaryReducer(inputs.eventsByRunId ?? /* @__PURE__ */ new Map(), now);
+	const childWorkflow = createWorkflowRecoveryChildWorkflowWaitSummaryReducer(inputs.childRuns ?? [], now);
+	return {
+		addSleepAttempts(attempts) {
+			sleep.addAttempts(attempts);
+		},
+		addMessageWaitAttempts(attempts) {
+			message.addAttempts(attempts);
+		},
+		addChildWorkflowAttempts(attempts) {
+			childWorkflow.addAttempts(attempts);
+		},
+		finish() {
+			return {
+				sleep: sleep.finish(),
+				message: message.finish(),
+				childWorkflow: childWorkflow.finish()
+			};
+		}
+	};
+}
+//#endregion
+export { createWorkflowRecoveryWaitSummaryReducer };

package/dist/engine/summary/run-availability.d.mts

@@ -0,0 +1,13 @@
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/run-availability.d.ts
+interface WorkflowRunAvailabilitySummaryFields {
+  readonly nextAvailableAt?: Temporal.Instant;
+  readonly oldestPendingAt?: Temporal.Instant;
+  readonly oldestRunningAt?: Temporal.Instant;
+}
+declare function createWorkflowRunAvailabilitySummaryReducer(): {
+  readonly addRun: (run: WorkflowRunRecord) => void;
+  readonly finish: () => WorkflowRunAvailabilitySummaryFields;
+};
+//#endregion
+export { WorkflowRunAvailabilitySummaryFields, createWorkflowRunAvailabilitySummaryReducer };

package/dist/engine/summary/run-availability.mjs

@@ -0,0 +1,37 @@
+import { isScheduledWorkflowRunStatus } from "../../utility.mjs";
+import { earliestOptionalTimestamp } from "../../temporal.mjs";
+//#region src/engine/summary/run-availability.ts
+function createWorkflowRunAvailabilitySummaryReducer() {
+	const availability = createWorkflowRunAvailabilityAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRunAvailability(availability, run);
+		},
+		finish() {
+			return finishWorkflowRunAvailabilitySummary(availability);
+		}
+	};
+}
+function createWorkflowRunAvailabilityAccumulator() {
+	return {};
+}
+function addWorkflowRunAvailability(availability, run) {
+	if (isScheduledWorkflowRunStatus(run.status)) setWorkflowRunAvailabilityScheduled(availability, run);
+	if (run.status === "running") setWorkflowRunAvailabilityRunning(availability, run);
+}
+function setWorkflowRunAvailabilityScheduled(availability, run) {
+	availability.nextAvailableAt = earliestOptionalTimestamp(availability.nextAvailableAt, run.availableAt);
+	availability.oldestPendingAt = earliestOptionalTimestamp(availability.oldestPendingAt, run.createdAt);
+}
+function setWorkflowRunAvailabilityRunning(availability, run) {
+	availability.oldestRunningAt = earliestOptionalTimestamp(availability.oldestRunningAt, run.startedAt ?? run.createdAt);
+}
+function finishWorkflowRunAvailabilitySummary(availability) {
+	return {
+		...availability.nextAvailableAt === void 0 ? {} : { nextAvailableAt: availability.nextAvailableAt },
+		...availability.oldestPendingAt === void 0 ? {} : { oldestPendingAt: availability.oldestPendingAt },
+		...availability.oldestRunningAt === void 0 ? {} : { oldestRunningAt: availability.oldestRunningAt }
+	};
+}
+//#endregion
+export { createWorkflowRunAvailabilitySummaryReducer };

package/dist/engine/summary/run-cleanup.d.mts

@@ -0,0 +1,14 @@
+import { WorkflowRunCleanupSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/run-cleanup.d.ts
+interface WorkflowRunCleanupSummaryFields {
+  readonly cleanup?: WorkflowRunCleanupSummary;
+}
+interface WorkflowRunCleanupSummaryReducer {
+  readonly addRun: (run: WorkflowRunRecord) => void;
+  readonly finish: () => WorkflowRunCleanupSummaryFields;
+}
+/** Creates an accumulator for terminal-run cleanup eligibility summary fields. */
+declare function createWorkflowRunCleanupSummaryReducer(cutoff: Temporal.Instant | undefined): WorkflowRunCleanupSummaryReducer;
+//#endregion
+export { WorkflowRunCleanupSummaryReducer, createWorkflowRunCleanupSummaryReducer };

package/dist/engine/summary/run-cleanup.mjs

@@ -0,0 +1,44 @@
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+import { createWorkflowTerminalRunStatusCounts, createWorkflowTerminalRunStatusRunIds, sortedWorkflowTerminalRunStatusRunIds } from "./run-metrics.mjs";
+//#region src/engine/summary/run-cleanup.ts
+/** Creates an accumulator for terminal-run cleanup eligibility summary fields. */
+function createWorkflowRunCleanupSummaryReducer(cutoff) {
+	const cleanup = createWorkflowRunCleanupAccumulator();
+	return {
+		addRun(run) {
+			addWorkflowRunCleanupEligibility(cleanup, run, cutoff);
+		},
+		finish() {
+			return finishWorkflowRunCleanupSummary(cleanup, cutoff);
+		}
+	};
+}
+function createWorkflowRunCleanupAccumulator() {
+	return {
+		eligibleRuns: 0,
+		status: createWorkflowTerminalRunStatusCounts(),
+		statusRunIds: createWorkflowTerminalRunStatusRunIds()
+	};
+}
+function addWorkflowRunCleanupEligibility(cleanup, run, cutoff) {
+	if (cutoff === void 0 || run.status !== "completed" && run.status !== "failed" && run.status !== "canceled" || run.finishedAt === void 0 || Temporal.Instant.compare(run.finishedAt, cutoff) >= 0) return;
+	cleanup.eligibleRuns++;
+	cleanup.status[run.status]++;
+	cleanup.statusRunIds[run.status].push(run.id);
+	setWorkflowRunCleanupFinishedRange(cleanup, run);
+}
+function setWorkflowRunCleanupFinishedRange(cleanup, run) {
+	cleanup.oldestFinishedAt = earliestOptionalTimestamp(cleanup.oldestFinishedAt, run.finishedAt);
+	cleanup.newestFinishedAt = latestOptionalTimestamp(cleanup.newestFinishedAt, run.finishedAt);
+}
+function finishWorkflowRunCleanupSummary(cleanup, cutoff) {
+	return cutoff === void 0 ? {} : { cleanup: {
+		eligibleRuns: cleanup.eligibleRuns,
+		status: cleanup.status,
+		statusRunIds: sortedWorkflowTerminalRunStatusRunIds(cleanup.statusRunIds),
+		...cleanup.oldestFinishedAt === void 0 ? {} : { oldestFinishedAt: cleanup.oldestFinishedAt },
+		...cleanup.newestFinishedAt === void 0 ? {} : { newestFinishedAt: cleanup.newestFinishedAt }
+	} };
+}
+//#endregion
+export { createWorkflowRunCleanupSummaryReducer };

package/dist/engine/summary/run-failure.d.mts

@@ -0,0 +1,14 @@
+import { WorkflowRunFailureSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/run-failure.d.ts
+interface WorkflowRunFailureSummaryFields {
+  readonly failure?: WorkflowRunFailureSummary;
+}
+interface WorkflowRunFailureSummaryReducer {
+  readonly addRun: (run: WorkflowRunRecord) => void;
+  readonly finish: () => WorkflowRunFailureSummaryFields;
+}
+/** Creates an accumulator for failed-run summary fields. */
+declare function createWorkflowRunFailureSummaryReducer(): WorkflowRunFailureSummaryReducer;
+//#endregion
+export { WorkflowRunFailureSummaryReducer, createWorkflowRunFailureSummaryReducer };

package/dist/engine/summary/run-failure.mjs

@@ -0,0 +1,62 @@
+import { latestOptionalTimestamp } from "../../temporal.mjs";
+//#region src/engine/summary/run-failure.ts
+/** Creates an accumulator for failed-run summary fields. */
+function createWorkflowRunFailureSummaryReducer() {
+	const failure = createWorkflowRunFailureAccumulator();
+	return {
+		addRun(run) {
+			if (run.status === "failed") addWorkflowRunFailure(failure, run);
+		},
+		finish() {
+			return finishWorkflowRunFailureSummary(failure);
+		}
+	};
+}
+function createWorkflowRunFailureAccumulator() {
+	return {
+		total: 0,
+		failedRunIds: /* @__PURE__ */ new Set(),
+		errors: /* @__PURE__ */ new Map()
+	};
+}
+function addWorkflowRunFailure(failure, run) {
+	failure.total++;
+	failure.failedRunIds.add(run.id);
+	setWorkflowRunFailureLatestFailure(failure, run);
+	addWorkflowRunFailureError(failure, run);
+}
+function setWorkflowRunFailureLatestFailure(failure, run) {
+	failure.latestFailedAt = latestOptionalTimestamp(failure.latestFailedAt, run.finishedAt);
+}
+function addWorkflowRunFailureError(failure, run) {
+	const errorName = run.error?.name ?? "Error";
+	const current = failure.errors.get(errorName) ?? {
+		count: 0,
+		failedRunIds: /* @__PURE__ */ new Set()
+	};
+	current.count++;
+	current.failedRunIds.add(run.id);
+	setWorkflowRunFailureErrorLatestFailure(current, run);
+	failure.errors.set(errorName, current);
+}
+function setWorkflowRunFailureErrorLatestFailure(error, run) {
+	error.latestFailedAt = latestOptionalTimestamp(error.latestFailedAt, run.finishedAt);
+}
+function finishWorkflowRunFailureSummary(failure) {
+	return failure.total === 0 ? {} : { failure: {
+		total: failure.total,
+		failedRunIds: [...failure.failedRunIds].sort(),
+		errors: finishWorkflowRunFailureErrors(failure.errors),
+		...failure.latestFailedAt === void 0 ? {} : { latestFailedAt: failure.latestFailedAt }
+	} };
+}
+function finishWorkflowRunFailureErrors(errors) {
+	return [...errors.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, summary]) => ({
+		name,
+		count: summary.count,
+		failedRunIds: [...summary.failedRunIds].sort(),
+		...summary.latestFailedAt === void 0 ? {} : { latestFailedAt: summary.latestFailedAt }
+	}));
+}
+//#endregion
+export { createWorkflowRunFailureSummaryReducer };

package/dist/engine/summary/run-hooks.d.mts

@@ -0,0 +1,14 @@
+import { RunId } from "../../types/run-id.mjs";
+import { WorkflowRunHookSummary } from "../../types/summary.mjs";
+import "../../types/run.mjs";
+import { ActiveWorkflowHookSummary } from "./active-events.mjs";
+//#region src/engine/summary/run-hooks.d.ts
+interface WorkflowRunHookActivitySummary {
+  readonly hook?: WorkflowRunHookSummary;
+}
+declare function createWorkflowRunHookActivitySummaryReducer(): {
+  readonly addHook: (runId: RunId, hook: ActiveWorkflowHookSummary) => void;
+  readonly finish: () => WorkflowRunHookActivitySummary;
+};
+//#endregion
+export { createWorkflowRunHookActivitySummaryReducer };

package/dist/engine/summary/run-hooks.mjs

@@ -0,0 +1,63 @@
+import { earliestOptionalTimestamp, shouldReplaceWorkflowEarliestDefinedInstant } from "../../temporal.mjs";
+//#region src/engine/summary/run-hooks.ts
+function createWorkflowRunHookActivitySummaryReducer() {
+	const hooks = createWorkflowRunHookActivityAccumulator();
+	return {
+		addHook(runId, hook) {
+			addWorkflowRunHookActivity(hooks, runId, hook);
+		},
+		finish() {
+			return finishWorkflowRunHookActivitySummary(hooks);
+		}
+	};
+}
+function createWorkflowRunHookActivityAccumulator() {
+	return {
+		hookTotal: 0,
+		webhookTotal: 0,
+		hookNames: /* @__PURE__ */ new Set(),
+		messages: /* @__PURE__ */ new Set(),
+		runIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set(),
+		webhookNames: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRunHookActivity(hooks, runId, hook) {
+	if (hook.source === "hook") {
+		hooks.hookTotal++;
+		hooks.hookNames.add(hook.name);
+	} else {
+		hooks.webhookTotal++;
+		hooks.webhookNames.add(hook.name);
+	}
+	hooks.runIds.add(runId);
+	hooks.stepIds.add(hook.stepId);
+	hooks.messages.add(hook.messageId);
+	hooks.oldestStartedAt = earliestOptionalTimestamp(hooks.oldestStartedAt, hook.startedAt);
+	if (shouldReplaceWorkflowEarliestDefinedInstant(hooks.nextTimeoutAt, hook.timeoutAt)) setWorkflowRunHookNextTimeout(hooks, runId, hook);
+}
+function setWorkflowRunHookNextTimeout(hooks, runId, hook) {
+	hooks.nextTimeoutAt = hook.timeoutAt;
+	hooks.nextTimeoutRunId = runId;
+	hooks.nextTimeoutStepId = hook.stepId;
+}
+function finishWorkflowRunHookActivitySummary(hooks) {
+	return hooks.hookTotal + hooks.webhookTotal === 0 ? {} : { hook: {
+		activeHooks: hooks.hookTotal,
+		activeWebhooks: hooks.webhookTotal,
+		activeHookRuns: hooks.runIds.size,
+		hookRunIds: [...hooks.runIds].sort(),
+		hookStepIds: [...hooks.stepIds].sort(),
+		hookNames: [...hooks.hookNames].sort(),
+		webhookNames: [...hooks.webhookNames].sort(),
+		messages: [...hooks.messages].sort(),
+		...hooks.oldestStartedAt === void 0 ? {} : { oldestStartedAt: hooks.oldestStartedAt },
+		...hooks.nextTimeoutAt === void 0 ? {} : {
+			nextTimeoutAt: hooks.nextTimeoutAt,
+			...hooks.nextTimeoutRunId === void 0 ? {} : { nextTimeoutRunId: hooks.nextTimeoutRunId },
+			...hooks.nextTimeoutStepId === void 0 ? {} : { nextTimeoutStepId: hooks.nextTimeoutStepId }
+		}
+	} };
+}
+//#endregion
+export { createWorkflowRunHookActivitySummaryReducer };

package/dist/engine/summary/run-lease.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowRunLeaseSummary } from "../../types/summary.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/run-lease.d.ts
+interface WorkflowRunLeaseSummaryReducer {
+  readonly addRun: (run: WorkflowRunRecord) => void;
+  readonly finish: () => WorkflowRunLeaseSummary;
+}
+/** Creates an accumulator for running-run lease summary fields. */
+declare function createWorkflowRunLeaseSummaryReducer(now: Temporal.Instant): WorkflowRunLeaseSummaryReducer;
+//#endregion
+export { WorkflowRunLeaseSummaryReducer, createWorkflowRunLeaseSummaryReducer };

package/dist/engine/summary/run-lease.mjs

@@ -0,0 +1,64 @@
+import { earliestOptionalTimestamp } from "../../temporal.mjs";
+//#region src/engine/summary/run-lease.ts
+/** Creates an accumulator for running-run lease summary fields. */
+function createWorkflowRunLeaseSummaryReducer(now) {
+	const lease = createWorkflowRunLeaseAccumulator();
+	return {
+		addRun(run) {
+			if (run.status === "running") addWorkflowRunLease(lease, run, now);
+		},
+		finish() {
+			return finishWorkflowRunLeaseSummary(lease);
+		}
+	};
+}
+function createWorkflowRunLeaseAccumulator() {
+	return {
+		total: 0,
+		expired: 0,
+		runIds: /* @__PURE__ */ new Set(),
+		expiredRunIds: /* @__PURE__ */ new Set(),
+		workerIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowRunLease(lease, run, now) {
+	lease.total++;
+	lease.runIds.add(run.id);
+	if (run.workerId !== void 0) lease.workerIds.add(run.workerId);
+	if (run.workerId === void 0 || run.leaseExpiresAt === void 0) {
+		lease.expired++;
+		lease.expiredRunIds.add(run.id);
+		return;
+	}
+	if (Temporal.Instant.compare(run.leaseExpiresAt, now) <= 0) {
+		lease.expired++;
+		lease.expiredRunIds.add(run.id);
+		setWorkflowRunLeaseOldestExpiration(lease, run);
+		return;
+	}
+	setWorkflowRunLeaseNextExpiration(lease, run.id, run.leaseExpiresAt);
+}
+function setWorkflowRunLeaseOldestExpiration(lease, run) {
+	lease.oldestExpiredAt = earliestOptionalTimestamp(lease.oldestExpiredAt, run.leaseExpiresAt);
+}
+function setWorkflowRunLeaseNextExpiration(lease, runId, leaseExpiresAt) {
+	if (lease.nextExpiresAt !== void 0 && Temporal.Instant.compare(leaseExpiresAt, lease.nextExpiresAt) >= 0) return;
+	lease.nextExpiresAt = leaseExpiresAt;
+	lease.nextExpiringRunId = runId;
+}
+function finishWorkflowRunLeaseSummary(lease) {
+	return {
+		total: lease.total,
+		expired: lease.expired,
+		runIds: [...lease.runIds].sort(),
+		expiredRunIds: [...lease.expiredRunIds].sort(),
+		workerIds: [...lease.workerIds].sort(),
+		...lease.nextExpiresAt === void 0 ? {} : {
+			nextExpiresAt: lease.nextExpiresAt,
+			...lease.nextExpiringRunId === void 0 ? {} : { nextExpiringRunId: lease.nextExpiringRunId }
+		},
+		...lease.oldestExpiredAt === void 0 ? {} : { oldestExpiredAt: lease.oldestExpiredAt }
+	};
+}
+//#endregion
+export { createWorkflowRunLeaseSummaryReducer };

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

@@ -0,0 +1,15 @@
+import { RunId } from "../../types/run-id.mjs";
+import { WorkflowRunMessageSummary } from "../../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+import "../../types/run.mjs";
+//#region src/engine/summary/run-message-waits.d.ts
+interface WorkflowRunMessageWaitSummary {
+  readonly messageId?: WorkflowRunMessageSummary;
+}
+declare function createWorkflowRunMessageWaitSummaryReducer(): {
+  readonly addAttempt: (runId: RunId, attempt: WorkflowStepAttemptRecord) => void;
+  readonly addAttempts: (runId: RunId, attempts: readonly WorkflowStepAttemptRecord[]) => void;
+  readonly finish: () => WorkflowRunMessageWaitSummary;
+};
+//#endregion
+export { createWorkflowRunMessageWaitSummaryReducer };