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

package/dist/history/{mod.mjs → replay.mjs}

@@ -1,23 +1,22 @@
 import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
-import { makeWorkflowStepAttemptKey } from "./attempt-key.mjs";
 import "../errors/mod.mjs";
-import { createWorkflowStepSequencer } from "./sequencer.mjs";
+import { stepAttemptKey } from "../store-keys.mjs";
+import { createStepSequencer } 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 { activeMessageWaitStepIds, appendReplayProjectionEvents, createReplayProjection, findChildWorkflowLifecycleForAttempt, findLastChildWorkflowStartedForTerminal, findLastIndexedEventAfter, findLastMessageSentById, findLastMessageWaitStartedByNameAndMessageId, findLastMessageWaitStartedForCompleted, findLastMessageWaitTerminalAfterStarted, findLastSleepStartedForCompleted, findMessageSentByIdempotencyKey, findMessageSentByTimestamp, findMessageSentForWait, findStreamEventProjection } from "./replay-projection.mjs";
+import { applyStepAttemptEvent } 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 {
+//#region src/history/replay.ts
+var History = class {
 	#events;
 	#sequencer;
 	#projection;
 	#appendQueue = Promise.resolve();
 	constructor(events) {
 		this.#events = [...events];
-		this.#sequencer = createWorkflowStepSequencer(events);
-		this.#projection = createWorkflowReplayProjection(this.#events);
+		this.#sequencer = createStepSequencer(events);
+		this.#projection = createReplayProjection(this.#events);
 	}
 	get events() {
 		return this.#events;
@@ -57,10 +56,7 @@ var WorkflowHistory = class {
 		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
-		});
+		if (this.#projection.invalidStartedStepAttempt.has(stepId)) WorkflowReplayDivergenceError.atStep(stepId, `recorded run step ${stepId} has an invalid attempt number`);
 		return this.#projection.nextStepAttemptByStepId.get(stepId) ?? 1;
 	}
 	totalStartedStepCount() {
@@ -76,7 +72,7 @@ var WorkflowHistory = class {
 		return this.#projection.completedSleep.get(stepId);
 	}
 	startedSleepForCompleted(completed) {
-		return findLastWorkflowSleepStartedForCompleted(this.#projection, completed);
+		return findLastSleepStartedForCompleted(this.#projection, completed);
 	}
 	startedChildWorkflow(stepId) {
 		return this.#projection.startedChildWorkflow.get(stepId);
@@ -88,10 +84,10 @@ var WorkflowHistory = class {
 		return this.#projection.failedChildWorkflow.get(stepId);
 	}
 	startedChildWorkflowForTerminal(terminal) {
-		return findLastWorkflowChildWorkflowStartedForTerminal(this.#projection, terminal);
+		return findLastChildWorkflowStartedForTerminal(this.#projection, terminal);
 	}
 	childWorkflowLifecycleForAttempt(attempt) {
-		return findWorkflowChildWorkflowLifecycleForAttempt(this.#projection, attempt);
+		return findChildWorkflowLifecycleForAttempt(this.#projection, attempt);
 	}
 	startedMessageWait(stepId) {
 		return this.#projection.startedMessageWait.get(stepId);
@@ -100,10 +96,10 @@ var WorkflowHistory = class {
 		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);
+		return findLastIndexedEventAfter(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);
+		return findLastIndexedEventAfter(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);
@@ -112,22 +108,22 @@ var WorkflowHistory = class {
 		return findLastMessageWaitTerminalAfterStarted(this.#projection, started);
 	}
 	messageForWait(messageId, stepId, timeoutAt) {
-		return findWorkflowMessageSentForWait(this.#projection, messageId, stepId, timeoutAt);
+		return findMessageSentForWait(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);
+		return idempotencyKey === void 0 ? findLastMessageSentById(this.#projection, messageId) : findMessageSentByIdempotencyKey(this.#projection, idempotencyKey);
 	}
 	messageByIdempotencyKey(idempotencyKey) {
-		return findWorkflowMessageSentByIdempotencyKey(this.#projection, idempotencyKey);
+		return findMessageSentByIdempotencyKey(this.#projection, idempotencyKey);
 	}
 	latestMessagesByIdempotencyKey() {
 		return [...this.#projection.latestMessageSentByIdempotencyKey.values()];
 	}
 	messageSentByTimestamp(messageId, timestamp) {
-		return findWorkflowMessageSentByTimestamp(this.#projection, messageId, timestamp);
+		return findMessageSentByTimestamp(this.#projection, messageId, timestamp);
 	}
 	startedMessageSend(stepId) {
 		return this.#projection.startedMessageSend.get(stepId);
@@ -181,15 +177,15 @@ var WorkflowHistory = class {
 		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);
+			appendReplayProjectionEvents(this.#projection, events.slice(previousLength), previousLength);
 			return;
 		}
 		this.#events.splice(0, this.#events.length, ...events);
-		this.#projection = createWorkflowReplayProjection(this.#events);
+		this.#projection = createReplayProjection(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 };
+export { History, applyStepAttemptEvent, createTimeline, stepAttemptKey };

package/dist/history/sequencer.d.mts

@@ -1,16 +1,15 @@
-import { WorkflowStepIdentity, WorkflowStepType } from "../types/run.mjs";
-import { ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendStartedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepStartedEvent, StreamStartedEvent, WorkflowStepStartedEvent } from "../types/events.mjs";
+import { StepIdentity, StepType } from "../types/run.mjs";
+import { ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendStartedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepStartedEvent, StepStartedEvent, StreamStartedEvent } from "../types/events.mjs";
 //#region src/history/sequencer.d.ts
-type WorkflowRecordedStepEvent = WorkflowStepStartedEvent | SleepStartedEvent | ChildWorkflowStartedEvent | MessageSendStartedEvent | MessageWaitStartedEvent | StreamStartedEvent | DeterministicValueRecordedEvent | MetadataSetEvent;
-declare function createWorkflowStepSequencer(events: readonly EventRecord[]): WorkflowStepSequencer;
-declare class WorkflowStepSequencer {
+export type RecordedStepEvent = StepStartedEvent | SleepStartedEvent | ChildWorkflowStartedEvent | MessageSendStartedEvent | MessageWaitStartedEvent | StreamStartedEvent | DeterministicValueRecordedEvent | MetadataSetEvent;
+export declare function createStepSequencer(events: readonly EventRecord[]): StepSequencer;
+export declare class StepSequencer {
   #private;
-  constructor(recordedSteps: readonly WorkflowRecordedStepEvent[]);
-  next<TType extends WorkflowStepType>(type: TType, name: string): WorkflowStepIdentity<TType>;
+  constructor(recordedSteps: readonly RecordedStepEvent[]);
+  next<TType extends StepType>(type: TType, name: string): StepIdentity<TType>;
   requireConsumed(): void;
   isConsumed(): boolean;
 }
-declare function workflowRecordedStepEventType(event: WorkflowRecordedStepEvent): WorkflowStepType;
-declare function isWorkflowRecordedStepEvent(event: EventRecord): event is WorkflowRecordedStepEvent;
-//#endregion
-export { WorkflowRecordedStepEvent, WorkflowStepSequencer, createWorkflowStepSequencer, isWorkflowRecordedStepEvent, workflowRecordedStepEventType };
+export declare function workflowRecordedStepEventType(event: RecordedStepEvent): StepType;
+export declare function isRecordedStepEvent(event: EventRecord): event is RecordedStepEvent;
+//#endregion

package/dist/history/sequencer.mjs

@@ -1,12 +1,13 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
 import "../errors/mod.mjs";
 import { getEventDescriptor, isWorkflowRecordedStepEventKind } from "../events/descriptors.mjs";
 //#region src/history/sequencer.ts
-function createWorkflowStepSequencer(events) {
-	return new WorkflowStepSequencer(distinctRecordedStepEvents(events));
+function createStepSequencer(events) {
+	return new StepSequencer(distinctRecordedStepEvents(events));
 }
-var WorkflowStepSequencer = class {
+var StepSequencer = class {
 	#counts = /* @__PURE__ */ new Map();
 	#recordedSteps;
 	#cursor = 0;
@@ -56,17 +57,20 @@ var WorkflowStepSequencer = class {
 };
 function workflowRecordedStepEventType(event) {
 	const stepType = getEventDescriptor(event.kind).stepType;
-	if (stepType === void 0) WorkflowStateError.unsupportedRecordedStepEventType(event.kind);
+	if (stepType === void 0) throw new WorkflowStateError(`Workflow recorded step event type is not supported: ${event.kind}`, {
+		code: WorkflowErrorCode.STATE_RECORDED_STEP_EVENT_UNSUPPORTED,
+		details: { kind: event.kind }
+	});
 	return stepType;
 }
-function isWorkflowRecordedStepEvent(event) {
+function isRecordedStepEvent(event) {
 	return isWorkflowRecordedStepEventKind(event.kind) && "stepId" in event && "stepName" in event && "count" in event;
 }
 function distinctRecordedStepEvents(events) {
 	const recorded = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const event of events) {
-		if (!isWorkflowRecordedStepEvent(event)) continue;
+		if (!isRecordedStepEvent(event)) continue;
 		const key = `${event.kind}:${event.stepId}:${event.count}`;
 		if (seen.has(key)) continue;
 		seen.add(key);
@@ -75,4 +79,4 @@ function distinctRecordedStepEvents(events) {
 	return recorded;
 }
 //#endregion
-export { WorkflowStepSequencer, createWorkflowStepSequencer, isWorkflowRecordedStepEvent, workflowRecordedStepEventType };
+export { StepSequencer, createStepSequencer, isRecordedStepEvent, workflowRecordedStepEventType };

package/dist/history/step-attempts.d.mts

@@ -1,9 +1,6 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
-import "../types/run.mjs";
+import { RunId } from "../types/ids.mjs";
+import { StepAttemptRecord } from "../types/step-attempts.mjs";
 import { EventRecord } from "../types/events.mjs";
 //#region src/history/step-attempts.d.ts
-/** Creates workflow step attempts. */
-declare function createWorkflowStepAttempts(runId: RunId, events: readonly EventRecord[]): readonly WorkflowStepAttemptRecord[];
-//#endregion
-export { createWorkflowStepAttempts };
+export declare function createStepAttempts(runId: RunId, events: readonly EventRecord[]): readonly StepAttemptRecord[];
+//#endregion

package/dist/history/step-attempts.mjs

@@ -1,26 +1,25 @@
 import { getWorkflowEventStepAttemptKey, isWorkflowTerminalStepAttemptEvent } from "../events/descriptors.mjs";
-import { applyWorkflowStepAttemptEvent } from "./projection.mjs";
+import { applyStepAttemptEvent } from "./projection.mjs";
 //#region src/history/step-attempts.ts
-/** Creates workflow step attempts. */
-function createWorkflowStepAttempts(runId, events) {
+function createStepAttempts(runId, events) {
 	const attempts = /* @__PURE__ */ new Map();
 	for (const event of events) {
-		const key = reconciledWorkflowStepAttemptKeyFromEvent(event);
+		const key = reconciledStepAttemptKeyFromEvent(event);
 		if (key === void 0) continue;
-		const attempt = applyReconciledWorkflowStepAttemptEvent(runId, event, attempts.get(key));
+		const attempt = applyReconciledStepAttemptEvent(runId, event, attempts.get(key));
 		if (attempt === void 0 || isWorkflowTerminalStepAttemptEvent(event) && !attempts.has(key)) continue;
 		attempts.set(key, attempt);
 	}
 	return markSupersededRunningStepAttemptsAsAbandoned([...attempts.values()]).sort(compareStepAttempts);
 }
-function applyReconciledWorkflowStepAttemptEvent(runId, event, current) {
+function applyReconciledStepAttemptEvent(runId, event, current) {
 	try {
-		return applyWorkflowStepAttemptEvent(runId, event, current);
+		return applyStepAttemptEvent(runId, event, current);
 	} catch {
 		return;
 	}
 }
-function reconciledWorkflowStepAttemptKeyFromEvent(event) {
+function reconciledStepAttemptKeyFromEvent(event) {
 	try {
 		return getWorkflowEventStepAttemptKey(event);
 	} catch {
@@ -47,4 +46,4 @@ function compareStepAttempts(left, right) {
 	return stepId === 0 ? left.attempt - right.attempt : stepId;
 }
 //#endregion
-export { createWorkflowStepAttempts };
+export { createStepAttempts };

package/dist/history/timeline.d.mts

@@ -1,16 +1,7 @@
-import { Timeline as Timeline$1, TimelineEntryRecord } from "../types/timeline.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
+import { Timeline } from "../types/timeline.mjs";
 //#region src/history/timeline.d.ts
-/** Creates workflow timeline. */
-declare function createTimeline(run: WorkflowRunRecord, events: readonly EventRecord[]): Timeline$1;
 /** Timeline projection built from a run record and its durable event history. */
-declare class Timeline implements Timeline$1 {
-  /** @inheritdoc */
-  readonly run: WorkflowRunRecord;
-  /** @inheritdoc */
-  readonly entries: readonly TimelineEntryRecord[];
-  constructor(run: WorkflowRunRecord, events: readonly EventRecord[]);
-}
-//#endregion
-export { Timeline, createTimeline };
+export declare function createTimeline(run: RunRecord, events: readonly EventRecord[]): Timeline;
+//#endregion

package/dist/history/timeline.mjs

@@ -1,272 +1,53 @@
+import { parse } from "../schema/common.mjs";
 import { workflowAttributePatchFromEvent } from "../attributes.mjs";
-import { workflowEventRecordListSchema } from "../types/events.mjs";
+import { eventRecordListSchema } from "../schema/events.mjs";
 //#region src/history/timeline.ts
-/** Creates workflow timeline. */
+const CLASSIFICATION = {
+	workflow_started: ["workflow", "started"],
+	workflow_completed: ["workflow", "completed"],
+	workflow_failed: ["workflow", "failed"],
+	step_started: ["step", "started"],
+	step_completed: ["step", "completed"],
+	step_failed: ["step", "failed"],
+	metadata_set: ["metadata", "set"],
+	attributes_set: ["attributes", "set"],
+	deterministic_value_recorded: ["deterministic", "recorded"],
+	sleep_started: ["sleep", "started"],
+	sleep_completed: ["sleep", "completed"],
+	child_workflow_started: ["child_workflow", "started"],
+	child_workflow_completed: ["child_workflow", "completed"],
+	child_workflow_failed: ["child_workflow", "failed"],
+	message_send_started: ["message", "send_started"],
+	message_send_completed: ["message", "send_completed"],
+	message_send_failed: ["message", "send_failed"],
+	message_sent: ["message", "sent"],
+	message_wait_started: ["message", "waiting"],
+	message_wait_completed: ["message", "received"],
+	message_wait_failed: ["message", "failed"],
+	stream_started: ["stream", "started"],
+	stream_chunk: ["stream", "chunk"],
+	stream_closed: ["stream", "closed"],
+	stream_failed: ["stream", "failed"]
+};
+/** Timeline projection built from a run record and its durable event history. */
 function createTimeline(run, events) {
-	return new Timeline(run, events);
+	return {
+		run,
+		entries: parse(eventRecordListSchema, events).map(toTimelineEntry)
+	};
 }
-/** Timeline projection built from a run record and its durable event history. */
-var Timeline = class {
-	/** @inheritdoc */
-	run;
-	/** @inheritdoc */
-	entries;
-	constructor(run, events) {
-		const parsedEvents = workflowEventRecordListSchema.parse(events);
-		this.run = run;
-		this.entries = parsedEvents.map(toTimelineEntry);
-	}
-};
 function toTimelineEntry(event) {
-	switch (event.kind) {
-		case "workflow_started": return {
-			kind: "workflow",
-			status: "started",
-			timestamp: event.timestamp,
-			event
-		};
-		case "workflow_completed": return {
-			kind: "workflow",
-			status: "completed",
-			timestamp: event.timestamp,
-			event
-		};
-		case "workflow_failed": return {
-			kind: "workflow",
-			status: "failed",
-			timestamp: event.timestamp,
-			event
-		};
-		case "step_started": return {
-			kind: "step",
-			status: "started",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			attempt: event.attempt,
-			count: event.count,
-			event
-		};
-		case "step_completed": return {
-			kind: "step",
-			status: "completed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			attempt: event.attempt,
-			result: event.result,
-			event
-		};
-		case "step_failed": return {
-			kind: "step",
-			status: "failed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			attempt: event.attempt,
-			error: event.error,
-			event
-		};
-		case "metadata_set": return {
-			kind: "metadata",
-			status: "set",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			metadata: event.metadata,
-			event
-		};
-		case "attributes_set": return {
-			kind: "attributes",
-			status: "set",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			attributes: workflowAttributePatchFromEvent(event),
-			event
-		};
-		case "deterministic_value_recorded": return {
-			kind: "deterministic",
-			status: "recorded",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			value: event.value,
-			event
-		};
-		case "sleep_started": return {
-			kind: "sleep",
-			status: "started",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			until: event.until,
-			...event.duration === void 0 ? {} : { duration: event.duration },
-			event
-		};
-		case "sleep_completed": return {
-			kind: "sleep",
-			status: "completed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			event
-		};
-		case "child_workflow_started": return {
-			kind: "child_workflow",
-			status: "started",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			childRunId: event.childRunId,
-			workflowName: event.workflowName,
-			...event.workflowVersion === void 0 ? {} : { workflowVersion: event.workflowVersion },
-			...event.input === void 0 ? {} : { input: event.input },
-			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
-			event
-		};
-		case "child_workflow_completed": return {
-			kind: "child_workflow",
-			status: "completed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			childRunId: event.childRunId,
-			result: event.result,
-			event
-		};
-		case "child_workflow_failed": return {
-			kind: "child_workflow",
-			status: "failed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			childRunId: event.childRunId,
-			error: event.error,
-			event
-		};
-		case "message_send_started": return {
-			kind: "message",
-			status: "send_started",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			targetRunId: event.targetRunId,
-			messageId: event.messageId,
-			...event.payload === void 0 ? {} : { payload: event.payload },
-			event
-		};
-		case "message_send_completed": return {
-			kind: "message",
-			status: "send_completed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			targetRunId: event.targetRunId,
-			messageId: event.messageId,
-			event
-		};
-		case "message_send_failed": return {
-			kind: "message",
-			status: "send_failed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			targetRunId: event.targetRunId,
-			messageId: event.messageId,
-			error: event.error,
-			event
-		};
-		case "message_sent": return {
-			kind: "message",
-			status: "sent",
-			timestamp: event.timestamp,
-			messageId: event.messageId,
-			payload: event.payload,
-			waiterStepIds: event.waiterStepIds,
-			event
-		};
-		case "message_wait_started": return {
-			kind: "message",
-			status: "waiting",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			messageId: event.messageId,
-			...event.timeoutAt === void 0 ? {} : { timeoutAt: event.timeoutAt },
-			event
-		};
-		case "message_wait_completed": return {
-			kind: "message",
-			status: "received",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			messageId: event.messageId,
-			payload: event.payload,
-			messageTimestamp: event.messageTimestamp,
-			event
-		};
-		case "message_wait_failed": return {
-			kind: "message",
-			status: "failed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			messageId: event.messageId,
-			error: event.error,
-			event
-		};
-		case "stream_started": return {
-			kind: "stream",
-			status: "started",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			count: event.count,
-			streamId: event.streamId,
-			...event.contentType === void 0 ? {} : { contentType: event.contentType },
-			...event.metadata === void 0 ? {} : { metadata: event.metadata },
-			event
-		};
-		case "stream_chunk": return {
-			kind: "stream",
-			status: "chunk",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			streamId: event.streamId,
-			index: event.index,
-			chunk: event.chunk,
-			event
-		};
-		case "stream_closed": return {
-			kind: "stream",
-			status: "closed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			streamId: event.streamId,
-			event
-		};
-		case "stream_failed": return {
-			kind: "stream",
-			status: "failed",
-			timestamp: event.timestamp,
-			stepId: event.stepId,
-			stepName: event.stepName,
-			streamId: event.streamId,
-			error: event.error,
-			event
-		};
-	}
+	const [kind, status] = CLASSIFICATION[event.kind];
+	const entry = {
+		kind,
+		status,
+		timestamp: event.timestamp,
+		event
+	};
+	return event.kind === "attributes_set" ? {
+		...entry,
+		attributes: workflowAttributePatchFromEvent(event)
+	} : entry;
 }
 //#endregion
-export { Timeline, createTimeline };
+export { createTimeline };

package/dist/history/validator.d.mts

@@ -1,9 +1,7 @@
 import { EventRecord } from "../types/events.mjs";
 //#region src/history/validator.d.ts
-declare function workflowStartedEventMatchesTerminalEvent(started: EventRecord, terminal: EventRecord): boolean;
-declare function workflowHistoryHasStartedEventBeforeTerminalEvent(events: readonly EventRecord[], event: EventRecord): boolean;
-declare function requireWorkflowTerminalEventsHaveStartedEvents(events: readonly EventRecord[]): void;
-declare function requireWorkflowTerminalEventsAreUnique(events: readonly EventRecord[]): void;
-declare function requireWorkflowStartedEventsAreUnique(events: readonly EventRecord[]): void;
-//#endregion
-export { requireWorkflowStartedEventsAreUnique, requireWorkflowTerminalEventsAreUnique, requireWorkflowTerminalEventsHaveStartedEvents, workflowHistoryHasStartedEventBeforeTerminalEvent, workflowStartedEventMatchesTerminalEvent };
+export declare function workflowStartedEventMatchesTerminalEvent(started: EventRecord, terminal: EventRecord): boolean;
+export declare function requireWorkflowTerminalEventsHaveStartedEvents(events: readonly EventRecord[]): void;
+export declare function requireWorkflowTerminalEventsAreUnique(events: readonly EventRecord[]): void;
+export declare function requireWorkflowStartedEventsAreUnique(events: readonly EventRecord[]): void;
+//#endregion