@temelj/workflow 0.0.0-alpha.1

package/dist/history/mod.d.mts

@@ -0,0 +1,71 @@
+import { MessageId } from "../types/message-id.mjs";
+import { StepId } from "../types/step-id.mjs";
+import "../types/message.mjs";
+import { StreamIdOrName } from "../types/stream-id.mjs";
+import "../types/step.mjs";
+import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import { WorkflowStepIdentity, WorkflowStepType } from "../types/run.mjs";
+import { ChildWorkflowCompletedEvent, ChildWorkflowFailedEvent, ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendCompletedEvent, MessageSendFailedEvent, MessageSendStartedEvent, MessageSentEvent, MessageWaitCompletedEvent, MessageWaitFailedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepCompletedEvent, SleepStartedEvent, StreamChunkEvent, StreamClosedEvent, StreamFailedEvent, StreamStartedEvent, WorkflowStepCompletedEvent, WorkflowStepFailedEvent, WorkflowStepStartedEvent } from "../types/events.mjs";
+import { StreamEventProjection, WorkflowChildWorkflowLifecycle } from "./replay-projection.mjs";
+import { applyWorkflowStepAttemptEvent } from "./projection.mjs";
+import { createTimeline } from "./timeline.mjs";
+import { makeWorkflowStepAttemptKey } from "./attempt-key.mjs";
+//#region src/history/mod.d.ts
+/** Runtime class for workflow history. */
+declare class WorkflowHistory {
+  #private;
+  constructor(events: readonly EventRecord[]);
+  get events(): readonly EventRecord[];
+  nextStep<TType extends WorkflowStepType>(type: TType, name: string): WorkflowStepIdentity<TType>;
+  append(appendEvents: () => Promise<readonly EventRecord[]>): Promise<readonly EventRecord[]>;
+  completedStep(stepId: StepId): WorkflowStepCompletedEvent | undefined;
+  startedStep(stepId: StepId): WorkflowStepStartedEvent | undefined;
+  failedSteps(stepId: StepId): readonly WorkflowStepFailedEvent[];
+  unstartedFailedStep(stepId: StepId): WorkflowStepFailedEvent | undefined;
+  metadataSet(stepId: StepId): MetadataSetEvent | undefined;
+  attributesSet(stepId: StepId): Extract<EventRecord, {
+    readonly kind: "attributes_set";
+  }> | undefined;
+  startedStepCount(stepId: StepId): number;
+  nextStepAttempt(stepId: StepId): number;
+  totalStartedStepCount(): number;
+  hasPriorWorkflowStart(): boolean;
+  startedSleep(stepId: StepId): SleepStartedEvent | undefined;
+  completedSleep(stepId: StepId): SleepCompletedEvent | undefined;
+  startedSleepForCompleted(completed: SleepCompletedEvent): SleepStartedEvent | undefined;
+  startedChildWorkflow(stepId: StepId): ChildWorkflowStartedEvent | undefined;
+  completedChildWorkflow(stepId: StepId): ChildWorkflowCompletedEvent | undefined;
+  failedChildWorkflow(stepId: StepId): ChildWorkflowFailedEvent | undefined;
+  startedChildWorkflowForTerminal(terminal: ChildWorkflowCompletedEvent | ChildWorkflowFailedEvent): ChildWorkflowStartedEvent | undefined;
+  childWorkflowLifecycleForAttempt(attempt: WorkflowStepAttemptRecord): WorkflowChildWorkflowLifecycle;
+  startedMessageWait(stepId: StepId): MessageWaitStartedEvent | undefined;
+  startedMessageWaitForCompleted(completed: MessageWaitCompletedEvent): MessageWaitStartedEvent | undefined;
+  completedMessageWait(stepId: StepId): MessageWaitCompletedEvent | undefined;
+  failedMessageWait(stepId: StepId): MessageWaitFailedEvent | undefined;
+  latestMessageWaitStartedByNameAndMessageId(stepName: string, messageId: MessageId): MessageWaitStartedEvent | undefined;
+  latestMessageWaitTerminalAfterStarted(started: MessageWaitStartedEvent): MessageWaitCompletedEvent | MessageWaitFailedEvent | undefined;
+  messageForWait(messageId: MessageId, stepId: StepId, timeoutAt: Temporal.Instant | undefined): MessageSentEvent | undefined;
+  activeMessageWaitStepIds(messageId: MessageId): readonly StepId[];
+  messageForSend(messageId: MessageId, idempotencyKey: string | undefined): MessageSentEvent | undefined;
+  messageByIdempotencyKey(idempotencyKey: string): MessageSentEvent | undefined;
+  latestMessagesByIdempotencyKey(): readonly MessageSentEvent[];
+  messageSentByTimestamp(messageId: MessageId, timestamp: Temporal.Instant): MessageSentEvent | undefined;
+  startedMessageSend(stepId: StepId): MessageSendStartedEvent | undefined;
+  completedMessageSend(stepId: StepId): MessageSendCompletedEvent | undefined;
+  failedMessageSend(stepId: StepId): MessageSendFailedEvent | undefined;
+  startedStream(stepId: StepId): StreamStartedEvent | undefined;
+  streamChunks(stepId: StepId): readonly StreamChunkEvent[];
+  streamChunk(stepId: StepId, index: number): StreamChunkEvent | undefined;
+  closedStream(stepId: StepId): StreamClosedEvent | undefined;
+  failedStream(stepId: StepId): StreamFailedEvent | undefined;
+  streamProjection(streamIdOrName: StreamIdOrName): StreamEventProjection | undefined;
+  deterministicValue(stepId: StepId): DeterministicValueRecordedEvent | undefined;
+  hasStartedEventBeforeTerminalEvent(event: EventRecord): boolean;
+  requireTerminalEventsHaveStartedEvents(): void;
+  requireTerminalEventsAreUnique(): void;
+  requireStartedEventsAreUnique(): void;
+  requireReplayConsumed(): void;
+  isReplayConsumed(): boolean;
+}
+//#endregion
+export { type StreamEventProjection, WorkflowHistory, type WorkflowStepIdentity, applyWorkflowStepAttemptEvent, createTimeline, makeWorkflowStepAttemptKey as workflowStepAttemptKey };

package/dist/history/mod.mjs

@@ -0,0 +1,195 @@
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
+import { makeWorkflowStepAttemptKey } from "./attempt-key.mjs";
+import "../errors/mod.mjs";
+import { createWorkflowStepSequencer } from "./sequencer.mjs";
+import { requireWorkflowStartedEventsAreUnique, requireWorkflowTerminalEventsAreUnique, requireWorkflowTerminalEventsHaveStartedEvents } from "./validator.mjs";
+import { activeMessageWaitStepIds, appendWorkflowReplayProjectionEvents, createWorkflowReplayProjection, findLastIndexedWorkflowEventAfter, findLastMessageWaitStartedByNameAndMessageId, findLastMessageWaitStartedForCompleted, findLastMessageWaitTerminalAfterStarted, findLastWorkflowChildWorkflowStartedForTerminal, findLastWorkflowMessageSentById, findLastWorkflowSleepStartedForCompleted, findStreamEventProjection, findWorkflowChildWorkflowLifecycleForAttempt, findWorkflowMessageSentByIdempotencyKey, findWorkflowMessageSentByTimestamp, findWorkflowMessageSentForWait } from "./replay-projection.mjs";
+import { applyWorkflowStepAttemptEvent } from "./projection.mjs";
+import { createTimeline } from "./timeline.mjs";
+import { deepEquals } from "@temelj/value";
+//#region src/history/mod.ts
+/** Runtime class for workflow history. */
+var WorkflowHistory = class {
+	#events;
+	#sequencer;
+	#projection;
+	#appendQueue = Promise.resolve();
+	constructor(events) {
+		this.#events = [...events];
+		this.#sequencer = createWorkflowStepSequencer(events);
+		this.#projection = createWorkflowReplayProjection(this.#events);
+	}
+	get events() {
+		return this.#events;
+	}
+	nextStep(type, name) {
+		return this.#sequencer.next(type, name);
+	}
+	async append(appendEvents) {
+		let appendedEvents = [];
+		const operation = this.#appendQueue.then(async () => {
+			appendedEvents = await appendEvents();
+			this.#replaceEvents(appendedEvents);
+		});
+		this.#appendQueue = operation.catch(() => {});
+		await operation;
+		return appendedEvents;
+	}
+	completedStep(stepId) {
+		return this.#projection.completedStep.get(stepId);
+	}
+	startedStep(stepId) {
+		return this.#projection.startedStep.get(stepId);
+	}
+	failedSteps(stepId) {
+		return this.#projection.failedSteps.get(stepId) ?? [];
+	}
+	unstartedFailedStep(stepId) {
+		return this.#projection.unstartedFailedStep.get(stepId);
+	}
+	metadataSet(stepId) {
+		return this.#projection.metadataSet.get(stepId);
+	}
+	attributesSet(stepId) {
+		return this.#projection.attributesSet.get(stepId);
+	}
+	startedStepCount(stepId) {
+		return this.#projection.startedStepAttempts.get(stepId)?.length ?? 0;
+	}
+	nextStepAttempt(stepId) {
+		if (this.#projection.invalidStartedStepAttempt.has(stepId)) WorkflowReplayDivergenceError.diverged(`recorded run step ${stepId} has an invalid attempt number`, {
+			expectedStepId: stepId,
+			actualStepId: stepId
+		});
+		return this.#projection.nextStepAttemptByStepId.get(stepId) ?? 1;
+	}
+	totalStartedStepCount() {
+		return this.#projection.totalStartedStepCount;
+	}
+	hasPriorWorkflowStart() {
+		return this.#projection.workflowStartedCount > 1;
+	}
+	startedSleep(stepId) {
+		return this.#projection.startedSleep.get(stepId);
+	}
+	completedSleep(stepId) {
+		return this.#projection.completedSleep.get(stepId);
+	}
+	startedSleepForCompleted(completed) {
+		return findLastWorkflowSleepStartedForCompleted(this.#projection, completed);
+	}
+	startedChildWorkflow(stepId) {
+		return this.#projection.startedChildWorkflow.get(stepId);
+	}
+	completedChildWorkflow(stepId) {
+		return this.#projection.completedChildWorkflow.get(stepId);
+	}
+	failedChildWorkflow(stepId) {
+		return this.#projection.failedChildWorkflow.get(stepId);
+	}
+	startedChildWorkflowForTerminal(terminal) {
+		return findLastWorkflowChildWorkflowStartedForTerminal(this.#projection, terminal);
+	}
+	childWorkflowLifecycleForAttempt(attempt) {
+		return findWorkflowChildWorkflowLifecycleForAttempt(this.#projection, attempt);
+	}
+	startedMessageWait(stepId) {
+		return this.#projection.startedMessageWait.get(stepId);
+	}
+	startedMessageWaitForCompleted(completed) {
+		return findLastMessageWaitStartedForCompleted(this.#projection, completed);
+	}
+	completedMessageWait(stepId) {
+		return findLastIndexedWorkflowEventAfter(this.#projection.completedMessageWait.get(stepId) ?? [], this.#projection.latestMessageWaitStartedIndex.get(stepId) ?? -1, (event) => event.timestamp instanceof Temporal.Instant);
+	}
+	failedMessageWait(stepId) {
+		return findLastIndexedWorkflowEventAfter(this.#projection.failedMessageWait.get(stepId) ?? [], this.#projection.latestMessageWaitStartedIndex.get(stepId) ?? -1, (event) => event.timestamp instanceof Temporal.Instant);
+	}
+	latestMessageWaitStartedByNameAndMessageId(stepName, messageId) {
+		return findLastMessageWaitStartedByNameAndMessageId(this.#projection, stepName, messageId);
+	}
+	latestMessageWaitTerminalAfterStarted(started) {
+		return findLastMessageWaitTerminalAfterStarted(this.#projection, started);
+	}
+	messageForWait(messageId, stepId, timeoutAt) {
+		return findWorkflowMessageSentForWait(this.#projection, messageId, stepId, timeoutAt);
+	}
+	activeMessageWaitStepIds(messageId) {
+		return activeMessageWaitStepIds(this.#projection, messageId);
+	}
+	messageForSend(messageId, idempotencyKey) {
+		return idempotencyKey === void 0 ? findLastWorkflowMessageSentById(this.#projection, messageId) : findWorkflowMessageSentByIdempotencyKey(this.#projection, idempotencyKey);
+	}
+	messageByIdempotencyKey(idempotencyKey) {
+		return findWorkflowMessageSentByIdempotencyKey(this.#projection, idempotencyKey);
+	}
+	latestMessagesByIdempotencyKey() {
+		return [...this.#projection.latestMessageSentByIdempotencyKey.values()];
+	}
+	messageSentByTimestamp(messageId, timestamp) {
+		return findWorkflowMessageSentByTimestamp(this.#projection, messageId, timestamp);
+	}
+	startedMessageSend(stepId) {
+		return this.#projection.startedMessageSend.get(stepId);
+	}
+	completedMessageSend(stepId) {
+		return this.#projection.completedMessageSend.get(stepId);
+	}
+	failedMessageSend(stepId) {
+		return this.#projection.failedMessageSend.get(stepId);
+	}
+	startedStream(stepId) {
+		return this.#projection.startedStream.get(stepId);
+	}
+	streamChunks(stepId) {
+		return this.#projection.streamChunks.get(stepId) ?? [];
+	}
+	streamChunk(stepId, index) {
+		return this.#projection.streamChunkByIndex.get(stepId)?.get(index);
+	}
+	closedStream(stepId) {
+		return this.#projection.closedStream.get(stepId);
+	}
+	failedStream(stepId) {
+		return this.#projection.failedStream.get(stepId);
+	}
+	streamProjection(streamIdOrName) {
+		return findStreamEventProjection(this.#projection, streamIdOrName);
+	}
+	deterministicValue(stepId) {
+		return this.#projection.deterministicValue.get(stepId);
+	}
+	hasStartedEventBeforeTerminalEvent(event) {
+		return this.#projection.terminalStartedBefore.has(event);
+	}
+	requireTerminalEventsHaveStartedEvents() {
+		requireWorkflowTerminalEventsHaveStartedEvents(this.#events);
+	}
+	requireTerminalEventsAreUnique() {
+		requireWorkflowTerminalEventsAreUnique(this.#events);
+	}
+	requireStartedEventsAreUnique() {
+		requireWorkflowStartedEventsAreUnique(this.#events);
+	}
+	requireReplayConsumed() {
+		this.#sequencer.requireConsumed();
+	}
+	isReplayConsumed() {
+		return this.#sequencer.isConsumed();
+	}
+	#replaceEvents(events) {
+		const previousLength = this.#events.length;
+		if (eventsPreservePrefix(this.#events, events, previousLength)) {
+			this.#events.splice(0, this.#events.length, ...events);
+			appendWorkflowReplayProjectionEvents(this.#projection, events.slice(previousLength), previousLength);
+			return;
+		}
+		this.#events.splice(0, this.#events.length, ...events);
+		this.#projection = createWorkflowReplayProjection(this.#events);
+	}
+};
+function eventsPreservePrefix(current, next, prefixLength) {
+	return next.length >= prefixLength && current.every((event, index) => deepEquals(event, next[index]));
+}
+//#endregion
+export { WorkflowHistory, applyWorkflowStepAttemptEvent, createTimeline, makeWorkflowStepAttemptKey as workflowStepAttemptKey };

package/dist/history/projection.d.mts

@@ -0,0 +1,8 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+//#region src/history/projection.d.ts
+declare function applyWorkflowStepAttemptEvent(runId: RunId, event: EventRecord, current: WorkflowStepAttemptRecord | undefined): WorkflowStepAttemptRecord | undefined;
+//#endregion
+export { applyWorkflowStepAttemptEvent };

package/dist/history/projection.mjs

@@ -0,0 +1,259 @@
+import { WorkflowStateError } from "../errors/base.mjs";
+import "../errors/mod.mjs";
+import { getEventDescriptor } from "../events/descriptors.mjs";
+//#region src/history/projection.ts
+function applyWorkflowStepAttemptEvent(runId, event, current) {
+	switch (event.kind) {
+		case "step_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "run",
+			status: "running",
+			attempt: event.attempt,
+			count: event.count,
+			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "step_completed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "run", event.attempt, event.timestamp),
+				...current,
+				status: "completed",
+				output: event.result,
+				timeoutAt: current?.timeoutAt,
+				finishedAt: event.timestamp
+			};
+		case "step_failed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "run", event.attempt, event.timestamp),
+				...current,
+				status: "failed",
+				error: event.error,
+				timeoutAt: current?.timeoutAt,
+				finishedAt: event.timestamp
+			};
+		case "sleep_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "sleep",
+			status: "running",
+			attempt: 1,
+			count: event.count,
+			until: event.until,
+			...event.duration === void 0 ? {} : { duration: event.duration },
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "sleep_completed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "sleep", 1, event.timestamp),
+				...current,
+				status: "completed",
+				until: current?.until,
+				duration: current?.duration,
+				finishedAt: event.timestamp
+			};
+		case "child_workflow_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "workflow",
+			status: "running",
+			attempt: event.attempt,
+			count: event.count,
+			childRunId: event.childRunId,
+			workflowName: event.workflowName,
+			...event.workflowVersion === void 0 ? {} : { workflowVersion: event.workflowVersion },
+			...event.cancellation === void 0 ? {} : { cancellation: event.cancellation },
+			...event.input === void 0 ? {} : { input: event.input },
+			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "child_workflow_completed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "workflow", event.attempt, event.timestamp),
+				...current,
+				status: "completed",
+				output: event.result,
+				childRunId: event.childRunId,
+				input: current?.input,
+				cancellation: current?.cancellation,
+				timeoutAt: current?.timeoutAt,
+				finishedAt: event.timestamp
+			};
+		case "child_workflow_failed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "workflow", event.attempt, event.timestamp),
+				...current,
+				status: "failed",
+				error: event.error,
+				childRunId: event.childRunId,
+				input: current?.input,
+				cancellation: current?.cancellation,
+				timeoutAt: current?.timeoutAt,
+				finishedAt: event.timestamp
+			};
+		case "message_send_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "message-send",
+			status: "running",
+			attempt: 1,
+			count: event.count,
+			targetRunId: event.targetRunId,
+			messageId: event.messageId,
+			...event.payload === void 0 ? {} : { payload: event.payload },
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "message_send_completed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "message-send", 1, event.timestamp),
+				...current,
+				status: "completed",
+				targetRunId: event.targetRunId,
+				messageId: event.messageId,
+				payload: current?.payload,
+				finishedAt: event.timestamp
+			};
+		case "message_send_failed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "message-send", 1, event.timestamp),
+				...current,
+				status: "failed",
+				targetRunId: event.targetRunId,
+				messageId: event.messageId,
+				payload: current?.payload,
+				error: event.error,
+				finishedAt: event.timestamp
+			};
+		case "message_wait_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "message-wait",
+			status: "running",
+			attempt: 1,
+			count: event.count,
+			messageId: event.messageId,
+			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "message_wait_completed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "message-wait", 1, event.timestamp),
+				...current,
+				status: "completed",
+				output: event.payload,
+				messageId: event.messageId,
+				messageTimestamp: event.messageTimestamp,
+				finishedAt: event.timestamp
+			};
+		case "message_wait_failed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				...makeBaseProjectedStepAttempt(runId, event.stepId, event.stepName, "message-wait", 1, event.timestamp),
+				...current,
+				status: "failed",
+				messageId: event.messageId,
+				error: event.error,
+				finishedAt: event.timestamp
+			};
+		case "stream_started": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "stream",
+			status: "running",
+			attempt: 1,
+			count: event.count,
+			createdAt: event.timestamp,
+			startedAt: event.timestamp
+		};
+		case "stream_closed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				runId,
+				stepId: event.stepId,
+				stepName: event.stepName,
+				kind: "stream",
+				status: "completed",
+				attempt: 1,
+				count: current?.count ?? 1,
+				createdAt: current?.createdAt ?? event.timestamp,
+				startedAt: current?.startedAt ?? event.timestamp,
+				finishedAt: event.timestamp
+			};
+		case "stream_failed":
+			requireCurrentStepAttemptFieldsMatch(event, current);
+			return {
+				runId,
+				stepId: event.stepId,
+				stepName: event.stepName,
+				kind: "stream",
+				status: "failed",
+				attempt: 1,
+				count: current?.count ?? 1,
+				error: event.error,
+				createdAt: current?.createdAt ?? event.timestamp,
+				startedAt: current?.startedAt ?? event.timestamp,
+				finishedAt: event.timestamp
+			};
+		case "stream_chunk": return;
+		case "deterministic_value_recorded": return {
+			runId,
+			stepId: event.stepId,
+			stepName: event.stepName,
+			kind: "deterministic",
+			status: "completed",
+			attempt: 1,
+			count: event.count,
+			output: event.value,
+			createdAt: event.timestamp,
+			startedAt: event.timestamp,
+			finishedAt: event.timestamp
+		};
+		case "message_sent": return;
+		case "workflow_started":
+		case "workflow_completed":
+		case "workflow_failed": return;
+	}
+}
+function requireCurrentStepAttemptFieldsMatch(event, current) {
+	if (current === void 0) return;
+	const descriptor = getEventDescriptor(event.kind);
+	for (const field of descriptor.startedEventMatchFields ?? []) {
+		if (field === "stepId") continue;
+		const value = Reflect.get(event, field);
+		if (Reflect.get(current, field) === void 0 || Reflect.get(current, field) === value) continue;
+		WorkflowStateError.stepAttemptFieldMismatch(event.stepId, field);
+	}
+}
+function makeBaseProjectedStepAttempt(runId, stepId, stepName, kind, attempt, timestamp) {
+	return {
+		runId,
+		stepId,
+		stepName,
+		kind,
+		status: "running",
+		attempt,
+		createdAt: timestamp,
+		startedAt: timestamp
+	};
+}
+//#endregion
+export { applyWorkflowStepAttemptEvent };

package/dist/history/replay-projection.d.mts

@@ -0,0 +1,88 @@
+import { MessageId } from "../types/message-id.mjs";
+import { StepId } from "../types/step-id.mjs";
+import "../types/message.mjs";
+import { StreamId, StreamIdOrName } from "../types/stream-id.mjs";
+import "../types/step.mjs";
+import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import { ChildWorkflowCompletedEvent, ChildWorkflowFailedEvent, ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendCompletedEvent, MessageSendFailedEvent, MessageSendStartedEvent, MessageSentEvent, MessageWaitCompletedEvent, MessageWaitFailedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepCompletedEvent, SleepStartedEvent, StreamChunkEvent, StreamClosedEvent, StreamFailedEvent, StreamStartedEvent, WorkflowStepCompletedEvent, WorkflowStepFailedEvent, WorkflowStepStartedEvent } from "../types/events.mjs";
+//#region src/history/replay-projection.d.ts
+interface IndexedWorkflowEvent<TEvent extends EventRecord> {
+  index: number;
+  event: TEvent;
+}
+interface WorkflowReplayProjection {
+  startedEventsByStepId: Map<StepId, EventRecord[]>;
+  startedStep: Map<StepId, WorkflowStepStartedEvent>;
+  completedStep: Map<StepId, WorkflowStepCompletedEvent>;
+  failedSteps: Map<StepId, WorkflowStepFailedEvent[]>;
+  unstartedFailedStep: Map<StepId, WorkflowStepFailedEvent>;
+  metadataSet: Map<StepId, MetadataSetEvent>;
+  attributesSet: Map<StepId, Extract<EventRecord, {
+    kind: "attributes_set";
+  }>>;
+  startedStepAttempts: Map<StepId, WorkflowStepStartedEvent[]>;
+  nextStepAttemptByStepId: Map<StepId, number>;
+  invalidStartedStepAttempt: Map<StepId, WorkflowStepStartedEvent>;
+  startedSleep: Map<StepId, SleepStartedEvent>;
+  completedSleep: Map<StepId, SleepCompletedEvent>;
+  startedChildWorkflow: Map<StepId, ChildWorkflowStartedEvent>;
+  completedChildWorkflow: Map<StepId, ChildWorkflowCompletedEvent>;
+  failedChildWorkflow: Map<StepId, ChildWorkflowFailedEvent>;
+  childWorkflowStartedByAttemptKey: Map<string, IndexedWorkflowEvent<ChildWorkflowStartedEvent>>;
+  childWorkflowStartedByStepId: Map<StepId, IndexedWorkflowEvent<ChildWorkflowStartedEvent>[]>;
+  childWorkflowCompletedByStepId: Map<StepId, IndexedWorkflowEvent<ChildWorkflowCompletedEvent>[]>;
+  childWorkflowFailedByStepId: Map<StepId, IndexedWorkflowEvent<ChildWorkflowFailedEvent>[]>;
+  startedMessageWait: Map<StepId, MessageWaitStartedEvent>;
+  messageWaitStartedByNameAndMessageId: Map<string, IndexedWorkflowEvent<MessageWaitStartedEvent>[]>;
+  messageWaitStartedIndex: Map<MessageWaitStartedEvent, number>;
+  latestMessageWaitStartedIndex: Map<StepId, number>;
+  completedMessageWait: Map<StepId, IndexedWorkflowEvent<MessageWaitCompletedEvent>[]>;
+  failedMessageWait: Map<StepId, IndexedWorkflowEvent<MessageWaitFailedEvent>[]>;
+  messageSentById: Map<MessageId, IndexedWorkflowEvent<MessageSentEvent>[]>;
+  activeMessageWaitsByMessageId: Map<MessageId, Map<StepId, string>>;
+  messageSentByIdempotencyKey: Map<string, MessageSentEvent>;
+  latestMessageSentByIdempotencyKey: Map<string, MessageSentEvent>;
+  startedMessageSend: Map<StepId, MessageSendStartedEvent>;
+  completedMessageSend: Map<StepId, MessageSendCompletedEvent>;
+  failedMessageSend: Map<StepId, MessageSendFailedEvent>;
+  startedStream: Map<StepId, StreamStartedEvent>;
+  streamChunks: Map<StepId, StreamChunkEvent[]>;
+  streamChunkByIndex: Map<StepId, Map<number, StreamChunkEvent>>;
+  streamStartedByIdOrName: Map<string, IndexedWorkflowEvent<StreamStartedEvent>>;
+  streamChunksByStreamId: Map<StreamId, IndexedWorkflowEvent<StreamChunkEvent>[]>;
+  streamClosedByStreamId: Map<StreamId, IndexedWorkflowEvent<StreamClosedEvent>>;
+  streamFailedByStreamId: Map<StreamId, IndexedWorkflowEvent<StreamFailedEvent>>;
+  closedStream: Map<StepId, StreamClosedEvent>;
+  failedStream: Map<StepId, StreamFailedEvent>;
+  deterministicValue: Map<StepId, DeterministicValueRecordedEvent>;
+  terminalStartedBefore: Set<EventRecord>;
+  workflowStartedCount: number;
+  totalStartedStepCount: number;
+}
+declare function createWorkflowReplayProjection(events: EventRecord[]): WorkflowReplayProjection;
+declare function appendWorkflowReplayProjectionEvents(projection: WorkflowReplayProjection, events: EventRecord[], startIndex: number): WorkflowReplayProjection;
+declare function findLastIndexedWorkflowEventAfter<TEvent extends EventRecord, TMatch extends TEvent>(entries: IndexedWorkflowEvent<TEvent>[], afterIndex: number, predicate: (event: TEvent) => event is TMatch): TMatch | undefined;
+declare function findWorkflowMessageSentForWait(projection: WorkflowReplayProjection, messageId: MessageId, stepId: StepId, timeoutAt: Temporal.Instant | undefined): MessageSentEvent | undefined;
+declare function findWorkflowMessageSentByTimestamp(projection: WorkflowReplayProjection, messageId: MessageId, timestamp: Temporal.Instant): MessageSentEvent | undefined;
+interface StreamEventProjection {
+  started: StreamStartedEvent;
+  chunks: IndexedWorkflowEvent<StreamChunkEvent>[];
+  closed?: IndexedWorkflowEvent<StreamClosedEvent>;
+  failed?: IndexedWorkflowEvent<StreamFailedEvent>;
+}
+declare function findStreamEventProjection(projection: WorkflowReplayProjection, streamIdOrName: StreamIdOrName): StreamEventProjection | undefined;
+declare function findLastWorkflowSleepStartedForCompleted(projection: WorkflowReplayProjection, completed: SleepCompletedEvent): SleepStartedEvent | undefined;
+declare function findLastMessageWaitStartedForCompleted(projection: WorkflowReplayProjection, completed: MessageWaitCompletedEvent): MessageWaitStartedEvent | undefined;
+declare function findLastWorkflowChildWorkflowStartedForTerminal(projection: WorkflowReplayProjection, terminal: ChildWorkflowCompletedEvent | ChildWorkflowFailedEvent): ChildWorkflowStartedEvent | undefined;
+interface WorkflowChildWorkflowLifecycle {
+  started?: ChildWorkflowStartedEvent;
+  hasTerminalAfterStarted: boolean;
+}
+declare function findWorkflowChildWorkflowLifecycleForAttempt(projection: WorkflowReplayProjection, attempt: WorkflowStepAttemptRecord): WorkflowChildWorkflowLifecycle;
+declare function activeMessageWaitStepIds(projection: WorkflowReplayProjection, messageId: MessageId): StepId[];
+declare function findLastMessageWaitStartedByNameAndMessageId(projection: WorkflowReplayProjection, stepName: string, messageId: MessageId): MessageWaitStartedEvent | undefined;
+declare function findLastMessageWaitTerminalAfterStarted(projection: WorkflowReplayProjection, started: MessageWaitStartedEvent): MessageWaitCompletedEvent | MessageWaitFailedEvent | undefined;
+declare function findWorkflowMessageSentByIdempotencyKey(projection: WorkflowReplayProjection, idempotencyKey: string | undefined): MessageSentEvent | undefined;
+declare function findLastWorkflowMessageSentById(projection: WorkflowReplayProjection, messageId: MessageId): MessageSentEvent | undefined;
+//#endregion
+export { IndexedWorkflowEvent, StreamEventProjection, WorkflowChildWorkflowLifecycle, WorkflowReplayProjection, activeMessageWaitStepIds, appendWorkflowReplayProjectionEvents, createWorkflowReplayProjection, findLastIndexedWorkflowEventAfter, findLastMessageWaitStartedByNameAndMessageId, findLastMessageWaitStartedForCompleted, findLastMessageWaitTerminalAfterStarted, findLastWorkflowChildWorkflowStartedForTerminal, findLastWorkflowMessageSentById, findLastWorkflowSleepStartedForCompleted, findStreamEventProjection, findWorkflowChildWorkflowLifecycleForAttempt, findWorkflowMessageSentByIdempotencyKey, findWorkflowMessageSentByTimestamp, findWorkflowMessageSentForWait };