@temelj/workflow 0.0.0-alpha.1

package/dist/engine/summary/step-attempt-active-child-workflows.mjs

@@ -0,0 +1,55 @@
+import { sortedStringSet } from "../../collection.mjs";
+import { earliestOptionalTimestamp, shouldReplaceWorkflowEarliestDefinedInstant } from "../../temporal.mjs";
+import { summarizeChildWorkflowRuns } from "./child-workflow-runs.mjs";
+import { finishWorkflowStepAttemptActiveStartedSummary, finishWorkflowStepAttemptActiveTimeoutSummary } from "./step-attempt-active-fields.mjs";
+//#region src/engine/summary/step-attempt-active-child-workflows.ts
+function createWorkflowStepAttemptActiveChildWorkflowSummaryReducer() {
+	const childWorkflow = createWorkflowStepAttemptActiveChildWorkflowAccumulator();
+	return {
+		addAttempt(attempt, attemptKey) {
+			if (attempt.kind === "workflow" && attempt.status === "running") addWorkflowStepAttemptActiveChildWorkflow(childWorkflow, attempt, attemptKey);
+		},
+		finish(childRuns = []) {
+			return finishWorkflowStepAttemptActiveChildWorkflowSummary(childWorkflow, childRuns);
+		}
+	};
+}
+function createWorkflowStepAttemptActiveChildWorkflowAccumulator() {
+	return {
+		total: 0,
+		attemptKeys: /* @__PURE__ */ new Set(),
+		childRunIds: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set(),
+		workflows: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowStepAttemptActiveChildWorkflow(childWorkflow, attempt, attemptKey) {
+	childWorkflow.total++;
+	childWorkflow.stepIds.add(attempt.stepId);
+	childWorkflow.attemptKeys.add(attemptKey);
+	childWorkflow.oldestStartedAt = earliestOptionalTimestamp(childWorkflow.oldestStartedAt, attempt.startedAt);
+	if (shouldReplaceWorkflowEarliestDefinedInstant(childWorkflow.nextTimeoutAt, attempt.timeoutAt)) {
+		childWorkflow.nextTimeoutAt = attempt.timeoutAt;
+		childWorkflow.nextTimeoutStepId = attempt.stepId;
+		childWorkflow.nextTimeoutAttemptKey = attemptKey;
+	}
+	if (attempt.childRunId !== void 0) childWorkflow.childRunIds.add(attempt.childRunId);
+	if (attempt.workflowName !== void 0) childWorkflow.workflows.add(attempt.workflowVersion === void 0 ? attempt.workflowName : `${attempt.workflowName}@${attempt.workflowVersion}`);
+}
+function finishWorkflowStepAttemptActiveChildWorkflowSummary(childWorkflow, childRuns) {
+	return childWorkflow.total === 0 ? {} : { activeChildWorkflows: {
+		total: childWorkflow.total,
+		stepIds: sortedStringSet(childWorkflow.stepIds),
+		attemptKeys: sortedStringSet(childWorkflow.attemptKeys),
+		childRunIds: sortedStringSet(childWorkflow.childRunIds),
+		workflows: sortedStringSet(childWorkflow.workflows),
+		...summarizeChildWorkflowRuns(activeChildWorkflowRuns(childRuns, childWorkflow.childRunIds)),
+		...finishWorkflowStepAttemptActiveStartedSummary(childWorkflow),
+		...finishWorkflowStepAttemptActiveTimeoutSummary(childWorkflow)
+	} };
+}
+function activeChildWorkflowRuns(childRuns, childRunIds) {
+	return childRuns.filter((childRun) => childRunIds.has(childRun.id));
+}
+//#endregion
+export { createWorkflowStepAttemptActiveChildWorkflowSummaryReducer };

package/dist/engine/summary/step-attempt-active-fields.d.mts

@@ -0,0 +1,23 @@
+import { StepId } from "../../types/step-id.mjs";
+import "../../types/step.mjs";
+//#region src/engine/summary/step-attempt-active-fields.d.ts
+interface WorkflowStepAttemptActiveStartedSummaryFields {
+  readonly oldestStartedAt?: Temporal.Instant;
+}
+interface WorkflowStepAttemptActiveTimeoutSummaryFields {
+  readonly nextTimeoutAt?: Temporal.Instant;
+  readonly nextTimeoutStepId?: StepId;
+  readonly nextTimeoutAttemptKey?: string;
+}
+interface WorkflowStepAttemptActiveStartedAccumulator {
+  readonly oldestStartedAt?: Temporal.Instant;
+}
+interface WorkflowStepAttemptActiveTimeoutAccumulator {
+  readonly nextTimeoutAt?: Temporal.Instant;
+  readonly nextTimeoutStepId?: StepId;
+  readonly nextTimeoutAttemptKey?: string;
+}
+declare function finishWorkflowStepAttemptActiveStartedSummary(activeAttempt: WorkflowStepAttemptActiveStartedAccumulator): WorkflowStepAttemptActiveStartedSummaryFields;
+declare function finishWorkflowStepAttemptActiveTimeoutSummary(activeAttempt: WorkflowStepAttemptActiveTimeoutAccumulator): WorkflowStepAttemptActiveTimeoutSummaryFields;
+//#endregion
+export { WorkflowStepAttemptActiveStartedAccumulator, WorkflowStepAttemptActiveStartedSummaryFields, WorkflowStepAttemptActiveTimeoutAccumulator, WorkflowStepAttemptActiveTimeoutSummaryFields, finishWorkflowStepAttemptActiveStartedSummary, finishWorkflowStepAttemptActiveTimeoutSummary };

package/dist/engine/summary/step-attempt-active-fields.mjs

@@ -0,0 +1,14 @@
+import { optionalProperty } from "../../collection.mjs";
+//#region src/engine/summary/step-attempt-active-fields.ts
+function finishWorkflowStepAttemptActiveStartedSummary(activeAttempt) {
+	return optionalProperty("oldestStartedAt", activeAttempt.oldestStartedAt);
+}
+function finishWorkflowStepAttemptActiveTimeoutSummary(activeAttempt) {
+	return activeAttempt.nextTimeoutAt === void 0 ? {} : {
+		nextTimeoutAt: activeAttempt.nextTimeoutAt,
+		...optionalProperty("nextTimeoutStepId", activeAttempt.nextTimeoutStepId),
+		...optionalProperty("nextTimeoutAttemptKey", activeAttempt.nextTimeoutAttemptKey)
+	};
+}
+//#endregion
+export { finishWorkflowStepAttemptActiveStartedSummary, finishWorkflowStepAttemptActiveTimeoutSummary };

package/dist/engine/summary/step-attempt-active-message-waits.d.mts

@@ -0,0 +1,12 @@
+import { WorkflowActiveMessageWaitSummary, WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+//#region src/engine/summary/step-attempt-active-message-waits.d.ts
+interface WorkflowStepAttemptActiveMessageWaitSummaryFields {
+  readonly activeMessageWaits?: WorkflowActiveMessageWaitSummary;
+}
+interface WorkflowStepAttemptActiveMessageWaitSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord, attemptKey: string): void;
+  finish(): WorkflowStepAttemptActiveMessageWaitSummaryFields;
+}
+declare function createWorkflowStepAttemptActiveMessageWaitSummaryReducer(): WorkflowStepAttemptActiveMessageWaitSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptActiveMessageWaitSummaryFields, WorkflowStepAttemptActiveMessageWaitSummaryReducer, createWorkflowStepAttemptActiveMessageWaitSummaryReducer };

package/dist/engine/summary/step-attempt-active-message-waits.mjs

@@ -0,0 +1,47 @@
+import { sortedStringSet } from "../../collection.mjs";
+import { earliestOptionalTimestamp, shouldReplaceWorkflowEarliestDefinedInstant } from "../../temporal.mjs";
+import { finishWorkflowStepAttemptActiveStartedSummary, finishWorkflowStepAttemptActiveTimeoutSummary } from "./step-attempt-active-fields.mjs";
+//#region src/engine/summary/step-attempt-active-message-waits.ts
+function createWorkflowStepAttemptActiveMessageWaitSummaryReducer() {
+	const messageWait = createWorkflowStepAttemptActiveMessageWaitAccumulator();
+	return {
+		addAttempt(attempt, attemptKey) {
+			if (attempt.kind === "message-wait" && attempt.status === "running") addWorkflowStepAttemptActiveMessageWait(messageWait, attempt, attemptKey);
+		},
+		finish() {
+			return finishWorkflowStepAttemptActiveMessageWaitSummary(messageWait);
+		}
+	};
+}
+function createWorkflowStepAttemptActiveMessageWaitAccumulator() {
+	return {
+		total: 0,
+		attemptKeys: /* @__PURE__ */ new Set(),
+		messages: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowStepAttemptActiveMessageWait(messageWait, attempt, attemptKey) {
+	messageWait.total++;
+	messageWait.stepIds.add(attempt.stepId);
+	messageWait.attemptKeys.add(attemptKey);
+	messageWait.oldestStartedAt = earliestOptionalTimestamp(messageWait.oldestStartedAt, attempt.startedAt);
+	if (shouldReplaceWorkflowEarliestDefinedInstant(messageWait.nextTimeoutAt, attempt.timeoutAt)) {
+		messageWait.nextTimeoutAt = attempt.timeoutAt;
+		messageWait.nextTimeoutStepId = attempt.stepId;
+		messageWait.nextTimeoutAttemptKey = attemptKey;
+	}
+	if (attempt.messageId !== void 0) messageWait.messages.add(attempt.messageId);
+}
+function finishWorkflowStepAttemptActiveMessageWaitSummary(messageWait) {
+	return messageWait.total === 0 ? {} : { activeMessageWaits: {
+		total: messageWait.total,
+		stepIds: sortedStringSet(messageWait.stepIds),
+		attemptKeys: sortedStringSet(messageWait.attemptKeys),
+		messages: sortedStringSet(messageWait.messages),
+		...finishWorkflowStepAttemptActiveStartedSummary(messageWait),
+		...finishWorkflowStepAttemptActiveTimeoutSummary(messageWait)
+	} };
+}
+//#endregion
+export { createWorkflowStepAttemptActiveMessageWaitSummaryReducer };

package/dist/engine/summary/step-attempt-active-sleeps.d.mts

@@ -0,0 +1,19 @@
+import { StepId } from "../../types/step-id.mjs";
+import "../../types/step.mjs";
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+//#region src/engine/summary/step-attempt-active-sleeps.d.ts
+interface WorkflowStepAttemptActiveSleepSummaryFields {
+  readonly activeSleepStepIds?: readonly string[];
+  readonly activeSleepAttemptKeys?: readonly string[];
+  readonly nextSleepUntil?: Temporal.Instant;
+  readonly nextSleepStepId?: StepId;
+  readonly nextSleepAttemptKey?: string;
+  readonly nextSleepDuration?: Temporal.Duration;
+}
+interface WorkflowStepAttemptActiveSleepSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord, attemptKey: string): void;
+  finish(): WorkflowStepAttemptActiveSleepSummaryFields;
+}
+declare function createWorkflowStepAttemptActiveSleepSummaryReducer(): WorkflowStepAttemptActiveSleepSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptActiveSleepSummaryFields, WorkflowStepAttemptActiveSleepSummaryReducer, createWorkflowStepAttemptActiveSleepSummaryReducer };

package/dist/engine/summary/step-attempt-active-sleeps.mjs

@@ -0,0 +1,44 @@
+import { optionalProperty, optionalSortedStringSetProperty } from "../../collection.mjs";
+import { shouldReplaceWorkflowEarliestDefinedInstant } from "../../temporal.mjs";
+//#region src/engine/summary/step-attempt-active-sleeps.ts
+function createWorkflowStepAttemptActiveSleepSummaryReducer() {
+	const sleep = createWorkflowStepAttemptActiveSleepAccumulator();
+	return {
+		addAttempt(attempt, attemptKey) {
+			if (attempt.kind === "sleep" && attempt.status === "running") addWorkflowStepAttemptActiveSleep(sleep, attempt, attemptKey);
+		},
+		finish() {
+			return finishWorkflowStepAttemptActiveSleepSummary(sleep);
+		}
+	};
+}
+function createWorkflowStepAttemptActiveSleepAccumulator() {
+	return {
+		attemptKeys: /* @__PURE__ */ new Set(),
+		stepIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowStepAttemptActiveSleep(sleep, attempt, attemptKey) {
+	sleep.stepIds.add(attempt.stepId);
+	sleep.attemptKeys.add(attemptKey);
+	if (shouldReplaceWorkflowEarliestDefinedInstant(sleep.nextUntil, attempt.until)) {
+		sleep.nextUntil = attempt.until;
+		sleep.nextStepId = attempt.stepId;
+		sleep.nextAttemptKey = attemptKey;
+		sleep.nextDuration = attempt.duration instanceof Temporal.Duration ? attempt.duration : void 0;
+	}
+}
+function finishWorkflowStepAttemptActiveSleepSummary(sleep) {
+	return {
+		...optionalSortedStringSetProperty("activeSleepStepIds", sleep.stepIds),
+		...optionalSortedStringSetProperty("activeSleepAttemptKeys", sleep.attemptKeys),
+		...sleep.nextUntil === void 0 ? {} : {
+			nextSleepUntil: sleep.nextUntil,
+			...optionalProperty("nextSleepStepId", sleep.nextStepId),
+			...optionalProperty("nextSleepAttemptKey", sleep.nextAttemptKey),
+			...optionalProperty("nextSleepDuration", sleep.nextDuration)
+		}
+	};
+}
+//#endregion
+export { createWorkflowStepAttemptActiveSleepSummaryReducer };

package/dist/engine/summary/step-attempt-buckets.d.mts

@@ -0,0 +1,22 @@
+import { WorkflowStepAttemptRecord, WorkflowStepAttemptStatus } from "../../types/step-attempts.mjs";
+import { WorkflowMaterializedStepType } from "../../types/run.mjs";
+//#region src/engine/summary/step-attempt-buckets.d.ts
+type WorkflowStepAttemptStatusCounts = Record<WorkflowStepAttemptStatus, number>;
+type WorkflowStepAttemptKindCounts = Record<WorkflowMaterializedStepType, number>;
+interface WorkflowStepAttemptStatusSummaryFields {
+  readonly status: WorkflowStepAttemptStatusCounts;
+  readonly statusStepIds: Record<WorkflowStepAttemptStatus, readonly string[]>;
+  readonly statusAttemptKeys: Record<WorkflowStepAttemptStatus, readonly string[]>;
+}
+interface WorkflowStepAttemptKindSummaryFields {
+  readonly kind: WorkflowStepAttemptKindCounts;
+  readonly kindStepIds: Record<WorkflowMaterializedStepType, readonly string[]>;
+  readonly kindAttemptKeys: Record<WorkflowMaterializedStepType, readonly string[]>;
+}
+interface WorkflowStepAttemptBucketSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord, attemptKey: string): void;
+  finish(): WorkflowStepAttemptStatusSummaryFields & WorkflowStepAttemptKindSummaryFields;
+}
+declare function createWorkflowStepAttemptBucketSummaryReducer(): WorkflowStepAttemptBucketSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptBucketSummaryReducer, WorkflowStepAttemptKindSummaryFields, WorkflowStepAttemptStatusSummaryFields, createWorkflowStepAttemptBucketSummaryReducer };

package/dist/engine/summary/step-attempt-buckets.mjs

@@ -0,0 +1,152 @@
+//#region src/engine/summary/step-attempt-buckets.ts
+function createWorkflowStepAttemptBucketSummaryReducer() {
+	const status = createWorkflowStepAttemptStatusAccumulator();
+	const kind = createWorkflowStepAttemptKindAccumulator();
+	return {
+		addAttempt(attempt, attemptKey) {
+			addWorkflowStepAttemptStatus(status, attempt, attemptKey);
+			addWorkflowStepAttemptKind(kind, attempt, attemptKey);
+		},
+		finish() {
+			return {
+				...finishWorkflowStepAttemptStatusSummary(status),
+				...finishWorkflowStepAttemptKindSummary(kind)
+			};
+		}
+	};
+}
+function createWorkflowStepAttemptStatusAccumulator() {
+	return {
+		attemptKeys: createWorkflowStepAttemptStatusAttemptKeys(),
+		status: createWorkflowStepAttemptStatusCounts(),
+		stepIds: createWorkflowStepAttemptStatusStepIds()
+	};
+}
+function createWorkflowStepAttemptKindAccumulator() {
+	return {
+		attemptKeys: createWorkflowStepAttemptKindAttemptKeys(),
+		kind: createWorkflowStepAttemptKindCounts(),
+		stepIds: createWorkflowStepAttemptKindStepIds()
+	};
+}
+function addWorkflowStepAttemptStatus(status, attempt, attemptKey) {
+	status.status[attempt.status]++;
+	status.stepIds[attempt.status].push(attempt.stepId);
+	status.attemptKeys[attempt.status].push(attemptKey);
+}
+function addWorkflowStepAttemptKind(kind, attempt, attemptKey) {
+	kind.kind[attempt.kind]++;
+	kind.stepIds[attempt.kind].push(attempt.stepId);
+	kind.attemptKeys[attempt.kind].push(attemptKey);
+}
+function finishWorkflowStepAttemptStatusSummary(status) {
+	return {
+		status: status.status,
+		statusStepIds: sortedWorkflowStepAttemptStatusStepIds(status.stepIds),
+		statusAttemptKeys: sortedWorkflowStepAttemptStatusAttemptKeys(status.attemptKeys)
+	};
+}
+function finishWorkflowStepAttemptKindSummary(kind) {
+	return {
+		kind: kind.kind,
+		kindStepIds: sortedWorkflowStepAttemptKindStepIds(kind.stepIds),
+		kindAttemptKeys: sortedWorkflowStepAttemptKindAttemptKeys(kind.attemptKeys)
+	};
+}
+function createWorkflowStepAttemptStatusCounts() {
+	return {
+		running: 0,
+		completed: 0,
+		failed: 0,
+		abandoned: 0
+	};
+}
+function createWorkflowStepAttemptStatusStepIds() {
+	return {
+		running: [],
+		completed: [],
+		failed: [],
+		abandoned: []
+	};
+}
+function sortedWorkflowStepAttemptStatusStepIds(stepIds) {
+	return {
+		running: [...stepIds.running].sort(),
+		completed: [...stepIds.completed].sort(),
+		failed: [...stepIds.failed].sort(),
+		abandoned: [...stepIds.abandoned].sort()
+	};
+}
+function createWorkflowStepAttemptStatusAttemptKeys() {
+	return {
+		running: [],
+		completed: [],
+		failed: [],
+		abandoned: []
+	};
+}
+function sortedWorkflowStepAttemptStatusAttemptKeys(attemptKeys) {
+	return {
+		running: [...attemptKeys.running].sort(),
+		completed: [...attemptKeys.completed].sort(),
+		failed: [...attemptKeys.failed].sort(),
+		abandoned: [...attemptKeys.abandoned].sort()
+	};
+}
+function createWorkflowStepAttemptKindCounts() {
+	return {
+		run: 0,
+		sleep: 0,
+		workflow: 0,
+		"message-send": 0,
+		"message-wait": 0,
+		stream: 0,
+		deterministic: 0
+	};
+}
+function createWorkflowStepAttemptKindStepIds() {
+	return {
+		run: [],
+		sleep: [],
+		workflow: [],
+		"message-send": [],
+		"message-wait": [],
+		stream: [],
+		deterministic: []
+	};
+}
+function createWorkflowStepAttemptKindAttemptKeys() {
+	return {
+		run: [],
+		sleep: [],
+		workflow: [],
+		"message-send": [],
+		"message-wait": [],
+		stream: [],
+		deterministic: []
+	};
+}
+function sortedWorkflowStepAttemptKindAttemptKeys(attemptKeys) {
+	return {
+		run: [...attemptKeys.run].sort(),
+		sleep: [...attemptKeys.sleep].sort(),
+		workflow: [...attemptKeys.workflow].sort(),
+		"message-send": [...attemptKeys["message-send"]].sort(),
+		"message-wait": [...attemptKeys["message-wait"]].sort(),
+		stream: [...attemptKeys.stream].sort(),
+		deterministic: [...attemptKeys.deterministic].sort()
+	};
+}
+function sortedWorkflowStepAttemptKindStepIds(stepIds) {
+	return {
+		run: [...stepIds.run].sort(),
+		sleep: [...stepIds.sleep].sort(),
+		workflow: [...stepIds.workflow].sort(),
+		"message-send": [...stepIds["message-send"]].sort(),
+		"message-wait": [...stepIds["message-wait"]].sort(),
+		stream: [...stepIds.stream].sort(),
+		deterministic: [...stepIds.deterministic].sort()
+	};
+}
+//#endregion
+export { createWorkflowStepAttemptBucketSummaryReducer };

package/dist/engine/summary/step-attempt-failure.d.mts

@@ -0,0 +1,12 @@
+import { WorkflowStepAttemptFailureSummary, WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+//#region src/engine/summary/step-attempt-failure.d.ts
+interface WorkflowStepAttemptFailureSummaryFields {
+  readonly failure?: WorkflowStepAttemptFailureSummary;
+}
+interface WorkflowStepAttemptFailureSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord, attemptKey: string): void;
+  finish(): WorkflowStepAttemptFailureSummaryFields;
+}
+declare function createWorkflowStepAttemptFailureSummaryReducer(): WorkflowStepAttemptFailureSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptFailureSummaryFields, WorkflowStepAttemptFailureSummaryReducer, createWorkflowStepAttemptFailureSummaryReducer };

package/dist/engine/summary/step-attempt-failure.mjs

@@ -0,0 +1,61 @@
+import { latestOptionalTimestamp } from "../../temporal.mjs";
+//#region src/engine/summary/step-attempt-failure.ts
+function createWorkflowStepAttemptFailureSummaryReducer() {
+	const failure = createWorkflowStepAttemptFailureAccumulator();
+	return {
+		addAttempt(attempt, attemptKey) {
+			if (attempt.status === "failed") addWorkflowStepAttemptFailure(failure, attempt, attemptKey);
+		},
+		finish() {
+			return finishWorkflowStepAttemptFailureSummary(failure);
+		}
+	};
+}
+function createWorkflowStepAttemptFailureAccumulator() {
+	return {
+		total: 0,
+		errors: /* @__PURE__ */ new Map(),
+		failedAttemptKeys: /* @__PURE__ */ new Set(),
+		failedStepIds: /* @__PURE__ */ new Set()
+	};
+}
+function addWorkflowStepAttemptFailure(failure, attempt, attemptKey) {
+	failure.total++;
+	failure.failedStepIds.add(attempt.stepId);
+	failure.failedAttemptKeys.add(attemptKey);
+	failure.latestFailedAt = latestOptionalTimestamp(failure.latestFailedAt, attempt.finishedAt);
+	addWorkflowStepAttemptFailureError(failure, attempt, attemptKey);
+}
+function addWorkflowStepAttemptFailureError(failure, attempt, attemptKey) {
+	const errorName = attempt.error?.name ?? "Error";
+	const current = failure.errors.get(errorName) ?? {
+		count: 0,
+		failedAttemptKeys: /* @__PURE__ */ new Set(),
+		failedStepIds: /* @__PURE__ */ new Set()
+	};
+	current.count++;
+	current.failedStepIds.add(attempt.stepId);
+	current.failedAttemptKeys.add(attemptKey);
+	current.latestFailedAt = latestOptionalTimestamp(current.latestFailedAt, attempt.finishedAt);
+	failure.errors.set(errorName, current);
+}
+function finishWorkflowStepAttemptFailureSummary(failure) {
+	return failure.total === 0 ? {} : { failure: {
+		total: failure.total,
+		failedStepIds: [...failure.failedStepIds].sort(),
+		failedAttemptKeys: [...failure.failedAttemptKeys].sort(),
+		errors: finishWorkflowStepAttemptFailureErrors(failure.errors),
+		...failure.latestFailedAt === void 0 ? {} : { latestFailedAt: failure.latestFailedAt }
+	} };
+}
+function finishWorkflowStepAttemptFailureErrors(errors) {
+	return [...errors.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, summary]) => ({
+		name,
+		count: summary.count,
+		failedStepIds: [...summary.failedStepIds].sort(),
+		failedAttemptKeys: [...summary.failedAttemptKeys].sort(),
+		...summary.latestFailedAt === void 0 ? {} : { latestFailedAt: summary.latestFailedAt }
+	}));
+}
+//#endregion
+export { createWorkflowStepAttemptFailureSummaryReducer };

package/dist/engine/summary/step-attempt-lifecycle.d.mts

@@ -0,0 +1,13 @@
+import { WorkflowStepAttemptRecord } from "../../types/step-attempts.mjs";
+//#region src/engine/summary/step-attempt-lifecycle.d.ts
+interface WorkflowStepAttemptLifecycleSummaryFields {
+  readonly oldestRunningAt?: Temporal.Instant;
+  readonly latestFinishedAt?: Temporal.Instant;
+}
+interface WorkflowStepAttemptLifecycleSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord): void;
+  finish(): WorkflowStepAttemptLifecycleSummaryFields;
+}
+declare function createWorkflowStepAttemptLifecycleSummaryReducer(): WorkflowStepAttemptLifecycleSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptLifecycleSummaryFields, WorkflowStepAttemptLifecycleSummaryReducer, createWorkflowStepAttemptLifecycleSummaryReducer };

package/dist/engine/summary/step-attempt-lifecycle.mjs

@@ -0,0 +1,19 @@
+import { earliestOptionalTimestamp, latestOptionalTimestamp } from "../../temporal.mjs";
+//#region src/engine/summary/step-attempt-lifecycle.ts
+function createWorkflowStepAttemptLifecycleSummaryReducer() {
+	const lifecycle = {};
+	return {
+		addAttempt(attempt) {
+			if (attempt.status === "running") lifecycle.oldestRunningAt = earliestOptionalTimestamp(lifecycle.oldestRunningAt, attempt.startedAt);
+			lifecycle.latestFinishedAt = latestOptionalTimestamp(lifecycle.latestFinishedAt, attempt.finishedAt);
+		},
+		finish() {
+			return {
+				...lifecycle.oldestRunningAt === void 0 ? {} : { oldestRunningAt: lifecycle.oldestRunningAt },
+				...lifecycle.latestFinishedAt === void 0 ? {} : { latestFinishedAt: lifecycle.latestFinishedAt }
+			};
+		}
+	};
+}
+//#endregion
+export { createWorkflowStepAttemptLifecycleSummaryReducer };

package/dist/engine/summary/step-attempts.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowStepAttemptRecord, WorkflowStepAttemptSummary } from "../../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../../types/run.mjs";
+//#region src/engine/summary/step-attempts.d.ts
+interface WorkflowStepAttemptSummaryReducer {
+  addAttempt(attempt: WorkflowStepAttemptRecord): void;
+  finish(): WorkflowStepAttemptSummary;
+}
+/** Creates a reducer for materialized step attempts and active child workflow records. */
+declare function createWorkflowStepAttemptSummaryReducer(childRuns?: readonly WorkflowRunRecord[]): WorkflowStepAttemptSummaryReducer;
+//#endregion
+export { WorkflowStepAttemptSummaryReducer, createWorkflowStepAttemptSummaryReducer };

package/dist/engine/summary/step-attempts.mjs

@@ -0,0 +1,43 @@
+import { makeWorkflowStepAttemptKey } from "../../history/attempt-key.mjs";
+import { createWorkflowStepAttemptActiveChildWorkflowSummaryReducer } from "./step-attempt-active-child-workflows.mjs";
+import { createWorkflowStepAttemptActiveMessageWaitSummaryReducer } from "./step-attempt-active-message-waits.mjs";
+import { createWorkflowStepAttemptActiveSleepSummaryReducer } from "./step-attempt-active-sleeps.mjs";
+import { createWorkflowStepAttemptBucketSummaryReducer } from "./step-attempt-buckets.mjs";
+import { createWorkflowStepAttemptFailureSummaryReducer } from "./step-attempt-failure.mjs";
+import { createWorkflowStepAttemptLifecycleSummaryReducer } from "./step-attempt-lifecycle.mjs";
+//#region src/engine/summary/step-attempts.ts
+/** Creates a reducer for materialized step attempts and active child workflow records. */
+function createWorkflowStepAttemptSummaryReducer(childRuns = []) {
+	const buckets = createWorkflowStepAttemptBucketSummaryReducer();
+	const lifecycle = createWorkflowStepAttemptLifecycleSummaryReducer();
+	const failure = createWorkflowStepAttemptFailureSummaryReducer();
+	const sleep = createWorkflowStepAttemptActiveSleepSummaryReducer();
+	const childWorkflow = createWorkflowStepAttemptActiveChildWorkflowSummaryReducer();
+	const messageWait = createWorkflowStepAttemptActiveMessageWaitSummaryReducer();
+	let total = 0;
+	return {
+		addAttempt(attempt) {
+			total++;
+			const attemptKey = makeWorkflowStepAttemptKey(attempt.stepId, attempt.attempt);
+			buckets.addAttempt(attempt, attemptKey);
+			lifecycle.addAttempt(attempt);
+			failure.addAttempt(attempt, attemptKey);
+			sleep.addAttempt(attempt, attemptKey);
+			childWorkflow.addAttempt(attempt, attemptKey);
+			messageWait.addAttempt(attempt, attemptKey);
+		},
+		finish() {
+			return {
+				total,
+				...buckets.finish(),
+				...lifecycle.finish(),
+				...failure.finish(),
+				...sleep.finish(),
+				...childWorkflow.finish(childRuns),
+				...messageWait.finish()
+			};
+		}
+	};
+}
+//#endregion
+export { createWorkflowStepAttemptSummaryReducer };

package/dist/engine/summary.d.mts

@@ -0,0 +1,32 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowRunSummary } from "../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowRunChildWorkflowWaitInput } from "./summary/child-workflow-waits.mjs";
+//#region src/engine/summary.d.ts
+interface WorkflowRunEventActivityInput {
+  readonly runId: RunId;
+  readonly events: readonly EventRecord[];
+}
+interface WorkflowRunSleepWaitInput {
+  readonly runId: RunId;
+  readonly attempts: readonly WorkflowStepAttemptRecord[];
+}
+interface WorkflowRunMessageWaitInput {
+  readonly runId: RunId;
+  readonly attempts: readonly WorkflowStepAttemptRecord[];
+}
+interface WorkflowRunSummaryInputs {
+  readonly runs: readonly WorkflowRunRecord[];
+  readonly now: Temporal.Instant;
+  readonly cleanupCutoff?: Temporal.Instant;
+  readonly runningChildWorkflows?: readonly WorkflowRunChildWorkflowWaitInput[];
+  readonly runningSleeps?: readonly WorkflowRunSleepWaitInput[];
+  readonly runningMessageWaits?: readonly WorkflowRunMessageWaitInput[];
+  readonly runningEvents?: readonly WorkflowRunEventActivityInput[];
+}
+/** Summarizes workflow run records and active wait events for inspection dashboards. */
+declare function summarizeWorkflowRuns(inputs: WorkflowRunSummaryInputs): WorkflowRunSummary;
+//#endregion
+export { WorkflowRunEventActivityInput, WorkflowRunMessageWaitInput, WorkflowRunSleepWaitInput, WorkflowRunSummaryInputs, summarizeWorkflowRuns };

package/dist/engine/summary.mjs

@@ -0,0 +1,37 @@
+import { activeWorkflowEvents } from "./summary/active-events.mjs";
+import { createWorkflowRunChildWorkflowWaitSummaryReducer } from "./summary/child-workflow-waits.mjs";
+import { createWorkflowRunHookActivitySummaryReducer } from "./summary/run-hooks.mjs";
+import { createWorkflowRunMessageWaitSummaryReducer } from "./summary/run-message-waits.mjs";
+import { createWorkflowRunSleepWaitSummaryReducer } from "./summary/run-sleeps.mjs";
+import { createWorkflowRunStateSummaryReducer } from "./summary/run-state.mjs";
+import { createWorkflowRunStreamActivitySummaryReducer } from "./summary/run-streams.mjs";
+//#region src/engine/summary.ts
+/** Summarizes workflow run records and active wait events for inspection dashboards. */
+function summarizeWorkflowRuns(inputs) {
+	const { runs, now, cleanupCutoff, runningChildWorkflows = [], runningSleeps = [], runningMessageWaits = [], runningEvents = [] } = inputs;
+	const runState = createWorkflowRunStateSummaryReducer(now, cleanupCutoff);
+	for (const run of runs) runState.addRun(run);
+	const streams = createWorkflowRunStreamActivitySummaryReducer();
+	const hooks = createWorkflowRunHookActivitySummaryReducer();
+	for (const runEvents of runningEvents) {
+		const activeEvents = activeWorkflowEvents(runEvents.events);
+		for (const stream of activeEvents.streams) streams.addStream(runEvents.runId, stream);
+		for (const hook of activeEvents.hooks) hooks.addHook(runEvents.runId, hook);
+	}
+	const sleeps = createWorkflowRunSleepWaitSummaryReducer();
+	for (const runSleeps of runningSleeps) sleeps.addAttempts(runSleeps.runId, runSleeps.attempts);
+	const messageWaits = createWorkflowRunMessageWaitSummaryReducer();
+	for (const runWaits of runningMessageWaits) messageWaits.addAttempts(runWaits.runId, runWaits.attempts);
+	const childWorkflowWaits = createWorkflowRunChildWorkflowWaitSummaryReducer();
+	for (const childWorkflowWait of runningChildWorkflows) childWorkflowWaits.addChildWorkflowAttempts(childWorkflowWait.runId, childWorkflowWait.attempts, childWorkflowWait.childRuns);
+	return {
+		...runState.finish(),
+		...streams.finish(),
+		...hooks.finish(),
+		...sleeps.finish(),
+		...messageWaits.finish(),
+		...childWorkflowWaits.finish()
+	};
+}
+//#endregion
+export { summarizeWorkflowRuns };

package/dist/engine/task.d.mts

@@ -0,0 +1,6 @@
+import { WorkflowStepTaskApi } from "../types/step.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+//#region src/engine/task.d.ts
+declare function createWorkflowStepTaskApi(environment: WorkflowExecutionEnvironment, executionSignal: AbortSignal): WorkflowStepTaskApi;
+//#endregion
+export { createWorkflowStepTaskApi };