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

package/dist/history/projection.mjs

@@ -1,8 +1,9 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import "../errors/mod.mjs";
-import { getEventDescriptor } from "../events/descriptors.mjs";
+import { getEventDescriptor, getEventField } from "../events/descriptors.mjs";
 //#region src/history/projection.ts
-function applyWorkflowStepAttemptEvent(runId, event, current) {
+function applyStepAttemptEvent(runId, event, current) {
 	switch (event.kind) {
 		case "step_started": return {
 			runId,
@@ -12,7 +13,7 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 			status: "running",
 			attempt: event.attempt,
 			count: event.count,
-			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
+			timeoutAt: event.timeoutAt,
 			createdAt: event.timestamp,
 			startedAt: event.timestamp
 		};
@@ -23,7 +24,6 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 				...current,
 				status: "completed",
 				output: event.result,
-				timeoutAt: current?.timeoutAt,
 				finishedAt: event.timestamp
 			};
 		case "step_failed":
@@ -33,7 +33,6 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 				...current,
 				status: "failed",
 				error: event.error,
-				timeoutAt: current?.timeoutAt,
 				finishedAt: event.timestamp
 			};
 		case "sleep_started": return {
@@ -45,7 +44,7 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 			attempt: 1,
 			count: event.count,
 			until: event.until,
-			...event.duration === void 0 ? {} : { duration: event.duration },
+			duration: event.duration,
 			createdAt: event.timestamp,
 			startedAt: event.timestamp
 		};
@@ -55,8 +54,6 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 				...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 {
@@ -69,10 +66,10 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 			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 },
+			workflowVersion: event.workflowVersion,
+			cancellation: event.cancellation,
+			input: event.input,
+			timeoutAt: event.timeoutAt,
 			createdAt: event.timestamp,
 			startedAt: event.timestamp
 		};
@@ -84,9 +81,6 @@ function applyWorkflowStepAttemptEvent(runId, event, 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":
@@ -97,9 +91,6 @@ function applyWorkflowStepAttemptEvent(runId, event, 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 {
@@ -112,7 +103,7 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 			count: event.count,
 			targetRunId: event.targetRunId,
 			messageId: event.messageId,
-			...event.payload === void 0 ? {} : { payload: event.payload },
+			payload: event.payload,
 			createdAt: event.timestamp,
 			startedAt: event.timestamp
 		};
@@ -124,7 +115,6 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 				status: "completed",
 				targetRunId: event.targetRunId,
 				messageId: event.messageId,
-				payload: current?.payload,
 				finishedAt: event.timestamp
 			};
 		case "message_send_failed":
@@ -135,7 +125,6 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 				status: "failed",
 				targetRunId: event.targetRunId,
 				messageId: event.messageId,
-				payload: current?.payload,
 				error: event.error,
 				finishedAt: event.timestamp
 			};
@@ -148,7 +137,7 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 			attempt: 1,
 			count: event.count,
 			messageId: event.messageId,
-			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
+			timeoutAt: event.timeoutAt,
 			createdAt: event.timestamp,
 			startedAt: event.timestamp
 		};
@@ -236,11 +225,18 @@ function applyWorkflowStepAttemptEvent(runId, event, current) {
 function requireCurrentStepAttemptFieldsMatch(event, current) {
 	if (current === void 0) return;
 	const descriptor = getEventDescriptor(event.kind);
+	const currentFields = current;
 	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);
+		const value = getEventField(event, field);
+		if (currentFields[field] === void 0 || currentFields[field] === value) continue;
+		throw new WorkflowStateError(`Workflow step attempt ${event.stepId} ${field} must match started attempt`, {
+			code: WorkflowErrorCode.STATE_STEP_ATTEMPT_FIELD_MISMATCH,
+			details: {
+				stepId: event.stepId,
+				field
+			}
+		});
 	}
 }
 function makeBaseProjectedStepAttempt(runId, stepId, stepName, kind, attempt, timestamp) {
@@ -256,4 +252,4 @@ function makeBaseProjectedStepAttempt(runId, stepId, stepName, kind, attempt, ti
 	};
 }
 //#endregion
-export { applyWorkflowStepAttemptEvent };
+export { applyStepAttemptEvent };

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

@@ -1,44 +1,40 @@
-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";
+import { MessageId, StepId, StreamId, StreamIdOrName } from "../types/ids.mjs";
+import { StepAttemptRecord } from "../types/step-attempts.mjs";
+import { ChildWorkflowCompletedEvent, ChildWorkflowFailedEvent, ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendCompletedEvent, MessageSendFailedEvent, MessageSendStartedEvent, MessageSentEvent, MessageWaitCompletedEvent, MessageWaitFailedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepCompletedEvent, SleepStartedEvent, StepCompletedEvent, StepFailedEvent, StepStartedEvent, StreamChunkEvent, StreamClosedEvent, StreamFailedEvent, StreamStartedEvent } from "../types/events.mjs";
 //#region src/history/replay-projection.d.ts
-interface IndexedWorkflowEvent<TEvent extends EventRecord> {
+interface IndexedEvent<TEvent extends EventRecord> {
   index: number;
   event: TEvent;
 }
-interface WorkflowReplayProjection {
+export interface ReplayProjection {
   startedEventsByStepId: Map<StepId, EventRecord[]>;
-  startedStep: Map<StepId, WorkflowStepStartedEvent>;
-  completedStep: Map<StepId, WorkflowStepCompletedEvent>;
-  failedSteps: Map<StepId, WorkflowStepFailedEvent[]>;
-  unstartedFailedStep: Map<StepId, WorkflowStepFailedEvent>;
+  startedStep: Map<StepId, StepStartedEvent>;
+  completedStep: Map<StepId, StepCompletedEvent>;
+  failedSteps: Map<StepId, StepFailedEvent[]>;
+  unstartedFailedStep: Map<StepId, StepFailedEvent>;
   metadataSet: Map<StepId, MetadataSetEvent>;
   attributesSet: Map<StepId, Extract<EventRecord, {
     kind: "attributes_set";
   }>>;
-  startedStepAttempts: Map<StepId, WorkflowStepStartedEvent[]>;
+  startedStepAttempts: Map<StepId, StepStartedEvent[]>;
   nextStepAttemptByStepId: Map<StepId, number>;
-  invalidStartedStepAttempt: Map<StepId, WorkflowStepStartedEvent>;
+  invalidStartedStepAttempt: Map<StepId, StepStartedEvent>;
   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>[]>;
+  childWorkflowStartedByAttemptKey: Map<string, IndexedEvent<ChildWorkflowStartedEvent>>;
+  childWorkflowStartedByStepId: Map<StepId, IndexedEvent<ChildWorkflowStartedEvent>[]>;
+  childWorkflowCompletedByStepId: Map<StepId, IndexedEvent<ChildWorkflowCompletedEvent>[]>;
+  childWorkflowFailedByStepId: Map<StepId, IndexedEvent<ChildWorkflowFailedEvent>[]>;
   startedMessageWait: Map<StepId, MessageWaitStartedEvent>;
-  messageWaitStartedByNameAndMessageId: Map<string, IndexedWorkflowEvent<MessageWaitStartedEvent>[]>;
+  messageWaitStartedByNameAndMessageId: Map<string, IndexedEvent<MessageWaitStartedEvent>[]>;
   messageWaitStartedIndex: Map<MessageWaitStartedEvent, number>;
   latestMessageWaitStartedIndex: Map<StepId, number>;
-  completedMessageWait: Map<StepId, IndexedWorkflowEvent<MessageWaitCompletedEvent>[]>;
-  failedMessageWait: Map<StepId, IndexedWorkflowEvent<MessageWaitFailedEvent>[]>;
-  messageSentById: Map<MessageId, IndexedWorkflowEvent<MessageSentEvent>[]>;
+  completedMessageWait: Map<StepId, IndexedEvent<MessageWaitCompletedEvent>[]>;
+  failedMessageWait: Map<StepId, IndexedEvent<MessageWaitFailedEvent>[]>;
+  messageSentById: Map<MessageId, IndexedEvent<MessageSentEvent>[]>;
   activeMessageWaitsByMessageId: Map<MessageId, Map<StepId, string>>;
   messageSentByIdempotencyKey: Map<string, MessageSentEvent>;
   latestMessageSentByIdempotencyKey: Map<string, MessageSentEvent>;
@@ -48,10 +44,10 @@ interface WorkflowReplayProjection {
   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>>;
+  streamStartedByIdOrName: Map<string, IndexedEvent<StreamStartedEvent>>;
+  streamChunksByStreamId: Map<StreamId, IndexedEvent<StreamChunkEvent>[]>;
+  streamClosedByStreamId: Map<StreamId, IndexedEvent<StreamClosedEvent>>;
+  streamFailedByStreamId: Map<StreamId, IndexedEvent<StreamFailedEvent>>;
   closedStream: Map<StepId, StreamClosedEvent>;
   failedStream: Map<StepId, StreamFailedEvent>;
   deterministicValue: Map<StepId, DeterministicValueRecordedEvent>;
@@ -59,30 +55,30 @@ interface WorkflowReplayProjection {
   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 {
+export declare function createReplayProjection(events: EventRecord[]): ReplayProjection;
+export declare function appendReplayProjectionEvents(projection: ReplayProjection, events: EventRecord[], startIndex: number): ReplayProjection;
+export declare function findLastIndexedEventAfter<TEvent extends EventRecord, TMatch extends TEvent>(entries: IndexedEvent<TEvent>[], afterIndex: number, predicate: (event: TEvent) => event is TMatch): TMatch | undefined;
+export declare function findMessageSentForWait(projection: ReplayProjection, messageId: MessageId, stepId: StepId, timeoutAt: Temporal.Instant | undefined): MessageSentEvent | undefined;
+export declare function findMessageSentByTimestamp(projection: ReplayProjection, messageId: MessageId, timestamp: Temporal.Instant): MessageSentEvent | undefined;
+export interface StreamEventProjection {
   started: StreamStartedEvent;
-  chunks: IndexedWorkflowEvent<StreamChunkEvent>[];
-  closed?: IndexedWorkflowEvent<StreamClosedEvent>;
-  failed?: IndexedWorkflowEvent<StreamFailedEvent>;
+  chunks: IndexedEvent<StreamChunkEvent>[];
+  closed?: IndexedEvent<StreamClosedEvent>;
+  failed?: IndexedEvent<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 {
+export declare function findStreamEventProjection(projection: ReplayProjection, streamIdOrName: StreamIdOrName): StreamEventProjection | undefined;
+export declare function findLastSleepStartedForCompleted(projection: ReplayProjection, completed: SleepCompletedEvent): SleepStartedEvent | undefined;
+export declare function findLastMessageWaitStartedForCompleted(projection: ReplayProjection, completed: MessageWaitCompletedEvent): MessageWaitStartedEvent | undefined;
+export declare function findLastChildWorkflowStartedForTerminal(projection: ReplayProjection, terminal: ChildWorkflowCompletedEvent | ChildWorkflowFailedEvent): ChildWorkflowStartedEvent | undefined;
+export interface ChildWorkflowLifecycle {
   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;
+export declare function findChildWorkflowLifecycleForAttempt(projection: ReplayProjection, attempt: StepAttemptRecord): ChildWorkflowLifecycle;
+export declare function activeMessageWaitStepIds(projection: ReplayProjection, messageId: MessageId): StepId[];
+export declare function findLastMessageWaitStartedByNameAndMessageId(projection: ReplayProjection, stepName: string, messageId: MessageId): MessageWaitStartedEvent | undefined;
+export declare function findLastMessageWaitTerminalAfterStarted(projection: ReplayProjection, started: MessageWaitStartedEvent): MessageWaitCompletedEvent | MessageWaitFailedEvent | undefined;
+export declare function findMessageSentByIdempotencyKey(projection: ReplayProjection, idempotencyKey: string | undefined): MessageSentEvent | undefined;
+export declare function findLastMessageSentById(projection: ReplayProjection, 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 };
+export {};

package/dist/history/replay-projection.mjs

@@ -1,7 +1,7 @@
 import { isWorkflowRecordedStepEventKind, isWorkflowTerminalStepAttemptEvent } from "../events/descriptors.mjs";
 import { workflowStartedEventMatchesTerminalEvent } from "./validator.mjs";
 //#region src/history/replay-projection.ts
-function createWorkflowReplayProjection(events) {
+function createReplayProjection(events) {
 	const projection = {
 		startedEventsByStepId: /* @__PURE__ */ new Map(),
 		startedStep: /* @__PURE__ */ new Map(),
@@ -49,25 +49,23 @@ function createWorkflowReplayProjection(events) {
 		workflowStartedCount: 0,
 		totalStartedStepCount: 0
 	};
-	for (const [index, event] of events.entries()) appendWorkflowReplayProjectionEvent(projection, event, index);
+	for (const [index, event] of events.entries()) appendReplayProjectionEvent(projection, event, index);
 	return projection;
 }
-function appendWorkflowReplayProjectionEvents(projection, events, startIndex) {
-	for (const [offset, event] of events.entries()) appendWorkflowReplayProjectionEvent(projection, event, startIndex + offset);
+function appendReplayProjectionEvents(projection, events, startIndex) {
+	for (const [offset, event] of events.entries()) appendReplayProjectionEvent(projection, event, startIndex + offset);
 	return projection;
 }
-function appendWorkflowReplayProjectionEvent(projection, event, index) {
+function appendReplayProjectionEvent(projection, event, index) {
 	if (isWorkflowTerminalStepAttemptEvent(event) && (projection.startedEventsByStepId.get(event.stepId) ?? []).some((started) => workflowStartedEventMatchesTerminalEvent(started, event))) projection.terminalStartedBefore.add(event);
 	switch (event.kind) {
 		case "workflow_started":
-			incrementWorkflowStartedCount(projection);
+			projection.workflowStartedCount++;
 			break;
 		case "step_started":
 			projection.startedStep.set(event.stepId, event);
 			appendProjectedEvent(projection.startedStepAttempts, event.stepId, event);
 			recordProjectedStepAttempt(projection, event);
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		case "step_completed":
 			projection.completedStep.set(event.stepId, event);
@@ -87,8 +85,6 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 			break;
 		case "sleep_started":
 			projection.startedSleep.set(event.stepId, event);
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		case "sleep_completed":
 			projection.completedSleep.set(event.stepId, event);
@@ -96,7 +92,7 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 		case "child_workflow_started": {
 			projection.startedChildWorkflow.set(event.stepId, event);
 			const startedWorkflows = projection.childWorkflowStartedByAttemptKey;
-			const childWorkflowKey = workflowChildWorkflowAttemptKey(event);
+			const childWorkflowKey = childWorkflowAttemptKey(event);
 			if (!startedWorkflows.has(childWorkflowKey)) startedWorkflows.set(childWorkflowKey, {
 				index,
 				event
@@ -105,8 +101,6 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 				index,
 				event
 			});
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		}
 		case "child_workflow_completed":
@@ -132,8 +126,6 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 			});
 			projection.messageWaitStartedIndex.set(event, index);
 			projection.latestMessageWaitStartedIndex.set(event.stepId, index);
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		case "message_wait_completed":
 			deleteActiveMessageWait(projection, event);
@@ -162,8 +154,6 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 			break;
 		case "message_send_started":
 			projection.startedMessageSend.set(event.stepId, event);
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		case "message_send_completed":
 			projection.completedMessageSend.set(event.stepId, event);
@@ -174,8 +164,6 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 		case "stream_started":
 			projection.startedStream.set(event.stepId, event);
 			setProjectedStreamStartedByIdOrName(projection, event, index);
-			appendStartedEvent(projection.startedEventsByStepId, event);
-			incrementTotalStartedStepCount(projection);
 			break;
 		case "stream_chunk":
 			appendProjectedEvent(projection.streamChunks, event.stepId, event);
@@ -205,7 +193,19 @@ function appendWorkflowReplayProjectionEvent(projection, event, index) {
 		}
 		case "deterministic_value_recorded": projection.deterministicValue.set(event.stepId, event);
 	}
+	if (STEP_STARTED_KINDS.has(event.kind)) {
+		appendStartedEvent(projection.startedEventsByStepId, event);
+		projection.totalStartedStepCount++;
+	}
 }
+const STEP_STARTED_KINDS = /* @__PURE__ */ new Set([
+	"step_started",
+	"sleep_started",
+	"child_workflow_started",
+	"message_wait_started",
+	"message_send_started",
+	"stream_started"
+]);
 function appendStartedEvent(startedEventsByStepId, event) {
 	if (!isWorkflowRecordedStepEventKind(event.kind) || !("stepId" in event)) return;
 	appendProjectedEvent(startedEventsByStepId, event.stepId, event);
@@ -218,15 +218,6 @@ function recordProjectedStepAttempt(projection, event) {
 	const nextAttempt = event.attempt + 1;
 	projection.nextStepAttemptByStepId.set(event.stepId, Math.max(projection.nextStepAttemptByStepId.get(event.stepId) ?? 1, nextAttempt));
 }
-function incrementTotalStartedStepCount(projection) {
-	asMutableProjection(projection).totalStartedStepCount++;
-}
-function incrementWorkflowStartedCount(projection) {
-	asMutableProjection(projection).workflowStartedCount++;
-}
-function asMutableProjection(projection) {
-	return projection;
-}
 function setProjectedStreamChunkByIndex(projection, event) {
 	const chunks = projection.streamChunkByIndex.get(event.stepId);
 	if (chunks === void 0) {
@@ -256,13 +247,13 @@ function deleteActiveMessageWait(projection, event) {
 	const activeWaits = activeMessageWaits(projection, event.messageId);
 	if (activeWaits.get(event.stepId) === event.stepName) activeWaits.delete(event.stepId);
 }
-function findLastIndexedWorkflowEventAfter(entries, afterIndex, predicate) {
+function findLastIndexedEventAfter(entries, afterIndex, predicate) {
 	for (let index = entries.length - 1; index >= 0; index--) {
 		const entry = entries[index];
 		if (entry.index > afterIndex && predicate(entry.event)) return entry.event;
 	}
 }
-function findLastIndexedWorkflowEventEntryAfter(entries, afterIndex, predicate) {
+function findLastIndexedEventEntryAfter(entries, afterIndex, predicate) {
 	for (let index = entries.length - 1; index >= 0; index--) {
 		const entry = entries[index];
 		const event = entry.event;
@@ -272,14 +263,14 @@ function findLastIndexedWorkflowEventEntryAfter(entries, afterIndex, predicate)
 		};
 	}
 }
-function findWorkflowMessageSentForWait(projection, messageId, stepId, timeoutAt) {
+function findMessageSentForWait(projection, messageId, stepId, timeoutAt) {
 	const waitStartedIndex = projection.latestMessageWaitStartedIndex.get(stepId) ?? -1;
 	return (projection.messageSentById.get(messageId) ?? []).find(({ index, event }) => {
 		return index > waitStartedIndex && (event.waiterStepIds === void 0 || event.waiterStepIds.includes(stepId)) && (timeoutAt === void 0 || Temporal.Instant.compare(event.timestamp, timeoutAt) < 0);
 	})?.event;
 }
-function findWorkflowMessageSentByTimestamp(projection, messageId, timestamp) {
-	return findLastIndexedWorkflowEventAfter(projection.messageSentById.get(messageId) ?? [], -1, (event) => Temporal.Instant.compare(event.timestamp, timestamp) === 0);
+function findMessageSentByTimestamp(projection, messageId, timestamp) {
+	return findLastIndexedEventAfter(projection.messageSentById.get(messageId) ?? [], -1, (event) => Temporal.Instant.compare(event.timestamp, timestamp) === 0);
 }
 function findStreamEventProjection(projection, streamIdOrName) {
 	const started = projection.streamStartedByIdOrName.get(streamIdOrName);
@@ -287,11 +278,11 @@ function findStreamEventProjection(projection, streamIdOrName) {
 	return {
 		started: started.event,
 		chunks: [...projection.streamChunksByStreamId.get(started.event.streamId) ?? []].sort((left, right) => left.event.index - right.event.index),
-		...projection.streamClosedByStreamId.get(started.event.streamId) === void 0 ? {} : { closed: projection.streamClosedByStreamId.get(started.event.streamId) },
-		...projection.streamFailedByStreamId.get(started.event.streamId) === void 0 ? {} : { failed: projection.streamFailedByStreamId.get(started.event.streamId) }
+		closed: projection.streamClosedByStreamId.get(started.event.streamId),
+		failed: projection.streamFailedByStreamId.get(started.event.streamId)
 	};
 }
-function findLastWorkflowSleepStartedForCompleted(projection, completed) {
+function findLastSleepStartedForCompleted(projection, completed) {
 	const started = projection.startedSleep.get(completed.stepId);
 	return started?.stepName === completed.stepName ? started : void 0;
 }
@@ -299,19 +290,19 @@ function findLastMessageWaitStartedForCompleted(projection, completed) {
 	const started = projection.startedMessageWait.get(completed.stepId);
 	return started?.stepName === completed.stepName && started.messageId === completed.messageId ? started : void 0;
 }
-function findLastWorkflowChildWorkflowStartedForTerminal(projection, terminal) {
-	return findLastIndexedWorkflowEventAfter(projection.childWorkflowStartedByStepId.get(terminal.stepId) ?? [], -1, (event) => workflowChildWorkflowTerminalMatchesStarted(terminal, event));
+function findLastChildWorkflowStartedForTerminal(projection, terminal) {
+	return findLastIndexedEventAfter(projection.childWorkflowStartedByStepId.get(terminal.stepId) ?? [], -1, (event) => childWorkflowTerminalMatchesStarted(terminal, event));
 }
-function findWorkflowChildWorkflowLifecycleForAttempt(projection, attempt) {
-	const started = projection.childWorkflowStartedByAttemptKey.get(workflowChildWorkflowAttemptKey(attempt));
+function findChildWorkflowLifecycleForAttempt(projection, attempt) {
+	const started = projection.childWorkflowStartedByAttemptKey.get(childWorkflowAttemptKey(attempt));
 	if (started === void 0) return { hasTerminalAfterStarted: false };
 	return {
 		started: started.event,
-		hasTerminalAfterStarted: hasWorkflowChildWorkflowTerminalAfterStarted(projection, started)
+		hasTerminalAfterStarted: hasChildWorkflowTerminalAfterStarted(projection, started)
 	};
 }
-function hasWorkflowChildWorkflowTerminalAfterStarted(projection, started) {
-	return findLastIndexedWorkflowEventEntryAfter(projection.childWorkflowCompletedByStepId.get(started.event.stepId) ?? [], started.index, (event) => workflowChildWorkflowTerminalMatchesStarted(event, started.event)) !== void 0 || findLastIndexedWorkflowEventEntryAfter(projection.childWorkflowFailedByStepId.get(started.event.stepId) ?? [], started.index, (event) => workflowChildWorkflowTerminalMatchesStarted(event, started.event)) !== void 0;
+function hasChildWorkflowTerminalAfterStarted(projection, started) {
+	return findLastIndexedEventEntryAfter(projection.childWorkflowCompletedByStepId.get(started.event.stepId) ?? [], started.index, (event) => childWorkflowTerminalMatchesStarted(event, started.event)) !== void 0 || findLastIndexedEventEntryAfter(projection.childWorkflowFailedByStepId.get(started.event.stepId) ?? [], started.index, (event) => childWorkflowTerminalMatchesStarted(event, started.event)) !== void 0;
 }
 function activeMessageWaitStepIds(projection, messageId) {
 	return [...projection.activeMessageWaitsByMessageId.get(messageId)?.keys() ?? []];
@@ -322,16 +313,16 @@ function findLastMessageWaitStartedByNameAndMessageId(projection, stepName, mess
 function findLastMessageWaitTerminalAfterStarted(projection, started) {
 	const startedIndex = projection.messageWaitStartedIndex.get(started);
 	if (startedIndex === void 0) return;
-	const completed = findLastIndexedWorkflowEventEntryAfter(projection.completedMessageWait.get(started.stepId) ?? [], startedIndex, (event) => event.stepName === started.stepName && event.messageId === started.messageId);
-	const failed = findLastIndexedWorkflowEventEntryAfter(projection.failedMessageWait.get(started.stepId) ?? [], startedIndex, (event) => event.stepName === started.stepName && event.messageId === started.messageId);
+	const completed = findLastIndexedEventEntryAfter(projection.completedMessageWait.get(started.stepId) ?? [], startedIndex, (event) => event.stepName === started.stepName && event.messageId === started.messageId);
+	const failed = findLastIndexedEventEntryAfter(projection.failedMessageWait.get(started.stepId) ?? [], startedIndex, (event) => event.stepName === started.stepName && event.messageId === started.messageId);
 	if (completed === void 0) return failed?.event;
 	if (failed === void 0) return completed.event;
 	return completed.index > failed.index ? completed.event : failed.event;
 }
-function findWorkflowMessageSentByIdempotencyKey(projection, idempotencyKey) {
+function findMessageSentByIdempotencyKey(projection, idempotencyKey) {
 	return idempotencyKey === void 0 ? void 0 : projection.messageSentByIdempotencyKey.get(idempotencyKey);
 }
-function findLastWorkflowMessageSentById(projection, messageId) {
+function findLastMessageSentById(projection, messageId) {
 	return (projection.messageSentById.get(messageId) ?? []).at(-1)?.event;
 }
 function appendProjectedEvent(map, stepId, event) {
@@ -345,7 +336,7 @@ function appendProjectedEvent(map, stepId, event) {
 function workflowMessageWaitNameMessageKey(stepName, messageId) {
 	return `${stepName}\u0000${messageId}`;
 }
-function workflowChildWorkflowAttemptKey(event) {
+function childWorkflowAttemptKey(event) {
 	return [
 		workflowProjectionKeyPart(event.childRunId),
 		workflowProjectionKeyPart(event.stepId),
@@ -360,8 +351,8 @@ function workflowChildWorkflowAttemptKey(event) {
 function workflowProjectionKeyPart(value) {
 	return value === void 0 ? "
" : String(value);
 }
-function workflowChildWorkflowTerminalMatchesStarted(event, started) {
+function childWorkflowTerminalMatchesStarted(event, started) {
 	return event.stepId === started.stepId && event.stepName === started.stepName && event.childRunId === started.childRunId && event.attempt === started.attempt;
 }
 //#endregion
-export { activeMessageWaitStepIds, appendWorkflowReplayProjectionEvents, createWorkflowReplayProjection, findLastIndexedWorkflowEventAfter, findLastMessageWaitStartedByNameAndMessageId, findLastMessageWaitStartedForCompleted, findLastMessageWaitTerminalAfterStarted, findLastWorkflowChildWorkflowStartedForTerminal, findLastWorkflowMessageSentById, findLastWorkflowSleepStartedForCompleted, findStreamEventProjection, findWorkflowChildWorkflowLifecycleForAttempt, findWorkflowMessageSentByIdempotencyKey, findWorkflowMessageSentByTimestamp, findWorkflowMessageSentForWait };
+export { activeMessageWaitStepIds, appendReplayProjectionEvents, createReplayProjection, findChildWorkflowLifecycleForAttempt, findLastChildWorkflowStartedForTerminal, findLastIndexedEventAfter, findLastMessageSentById, findLastMessageWaitStartedByNameAndMessageId, findLastMessageWaitStartedForCompleted, findLastMessageWaitTerminalAfterStarted, findLastSleepStartedForCompleted, findMessageSentByIdempotencyKey, findMessageSentByTimestamp, findMessageSentForWait, findStreamEventProjection };

package/dist/history/{mod.d.mts → replay.d.mts}

@@ -1,27 +1,22 @@
-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 { MessageId, StepId, StreamIdOrName } from "../types/ids.mjs";
+import { StepAttemptRecord } from "../types/step-attempts.mjs";
+import { StepIdentity, StepType } from "../types/run.mjs";
+import { ChildWorkflowCompletedEvent, ChildWorkflowFailedEvent, ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendCompletedEvent, MessageSendFailedEvent, MessageSendStartedEvent, MessageSentEvent, MessageWaitCompletedEvent, MessageWaitFailedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepCompletedEvent, SleepStartedEvent, StepCompletedEvent, StepFailedEvent, StepStartedEvent, StreamChunkEvent, StreamClosedEvent, StreamFailedEvent, StreamStartedEvent } from "../types/events.mjs";
+import { ChildWorkflowLifecycle, StreamEventProjection } from "./replay-projection.mjs";
+import { applyStepAttemptEvent } 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 {
+import { stepAttemptKey } from "../store-keys.mjs";
+//#region src/history/replay.d.ts
+export declare class History {
   #private;
   constructor(events: readonly EventRecord[]);
   get events(): readonly EventRecord[];
-  nextStep<TType extends WorkflowStepType>(type: TType, name: string): WorkflowStepIdentity<TType>;
+  nextStep<TType extends StepType>(type: TType, name: string): StepIdentity<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;
+  completedStep(stepId: StepId): StepCompletedEvent | undefined;
+  startedStep(stepId: StepId): StepStartedEvent | undefined;
+  failedSteps(stepId: StepId): readonly StepFailedEvent[];
+  unstartedFailedStep(stepId: StepId): StepFailedEvent | undefined;
   metadataSet(stepId: StepId): MetadataSetEvent | undefined;
   attributesSet(stepId: StepId): Extract<EventRecord, {
     readonly kind: "attributes_set";
@@ -37,7 +32,7 @@ declare class WorkflowHistory {
   completedChildWorkflow(stepId: StepId): ChildWorkflowCompletedEvent | undefined;
   failedChildWorkflow(stepId: StepId): ChildWorkflowFailedEvent | undefined;
   startedChildWorkflowForTerminal(terminal: ChildWorkflowCompletedEvent | ChildWorkflowFailedEvent): ChildWorkflowStartedEvent | undefined;
-  childWorkflowLifecycleForAttempt(attempt: WorkflowStepAttemptRecord): WorkflowChildWorkflowLifecycle;
+  childWorkflowLifecycleForAttempt(attempt: StepAttemptRecord): ChildWorkflowLifecycle;
   startedMessageWait(stepId: StepId): MessageWaitStartedEvent | undefined;
   startedMessageWaitForCompleted(completed: MessageWaitCompletedEvent): MessageWaitStartedEvent | undefined;
   completedMessageWait(stepId: StepId): MessageWaitCompletedEvent | undefined;
@@ -68,4 +63,4 @@ declare class WorkflowHistory {
   isReplayConsumed(): boolean;
 }
 //#endregion
-export { type StreamEventProjection, WorkflowHistory, type WorkflowStepIdentity, applyWorkflowStepAttemptEvent, createTimeline, makeWorkflowStepAttemptKey as workflowStepAttemptKey };
+export { type StepIdentity, type StreamEventProjection, applyStepAttemptEvent, createTimeline, stepAttemptKey };