@temelj/workflow 0.0.0-alpha.1

package/dist/history/replay-projection.mjs

@@ -0,0 +1,369 @@
+import { isWorkflowRecordedStepEventKind, isWorkflowTerminalStepAttemptEvent } from "../events/descriptors.mjs";
+import { workflowStartedEventMatchesTerminalEvent } from "./validator.mjs";
+//#region src/history/replay-projection.ts
+function createWorkflowReplayProjection(events) {
+	const projection = {
+		startedEventsByStepId: /* @__PURE__ */ new Map(),
+		startedStep: /* @__PURE__ */ new Map(),
+		completedStep: /* @__PURE__ */ new Map(),
+		failedSteps: /* @__PURE__ */ new Map(),
+		unstartedFailedStep: /* @__PURE__ */ new Map(),
+		metadataSet: /* @__PURE__ */ new Map(),
+		attributesSet: /* @__PURE__ */ new Map(),
+		startedStepAttempts: /* @__PURE__ */ new Map(),
+		nextStepAttemptByStepId: /* @__PURE__ */ new Map(),
+		invalidStartedStepAttempt: /* @__PURE__ */ new Map(),
+		startedSleep: /* @__PURE__ */ new Map(),
+		completedSleep: /* @__PURE__ */ new Map(),
+		startedChildWorkflow: /* @__PURE__ */ new Map(),
+		completedChildWorkflow: /* @__PURE__ */ new Map(),
+		failedChildWorkflow: /* @__PURE__ */ new Map(),
+		childWorkflowStartedByAttemptKey: /* @__PURE__ */ new Map(),
+		childWorkflowStartedByStepId: /* @__PURE__ */ new Map(),
+		childWorkflowCompletedByStepId: /* @__PURE__ */ new Map(),
+		childWorkflowFailedByStepId: /* @__PURE__ */ new Map(),
+		startedMessageWait: /* @__PURE__ */ new Map(),
+		messageWaitStartedByNameAndMessageId: /* @__PURE__ */ new Map(),
+		messageWaitStartedIndex: /* @__PURE__ */ new Map(),
+		latestMessageWaitStartedIndex: /* @__PURE__ */ new Map(),
+		completedMessageWait: /* @__PURE__ */ new Map(),
+		failedMessageWait: /* @__PURE__ */ new Map(),
+		messageSentById: /* @__PURE__ */ new Map(),
+		activeMessageWaitsByMessageId: /* @__PURE__ */ new Map(),
+		messageSentByIdempotencyKey: /* @__PURE__ */ new Map(),
+		latestMessageSentByIdempotencyKey: /* @__PURE__ */ new Map(),
+		startedMessageSend: /* @__PURE__ */ new Map(),
+		completedMessageSend: /* @__PURE__ */ new Map(),
+		failedMessageSend: /* @__PURE__ */ new Map(),
+		startedStream: /* @__PURE__ */ new Map(),
+		streamChunks: /* @__PURE__ */ new Map(),
+		streamChunkByIndex: /* @__PURE__ */ new Map(),
+		streamStartedByIdOrName: /* @__PURE__ */ new Map(),
+		streamChunksByStreamId: /* @__PURE__ */ new Map(),
+		streamClosedByStreamId: /* @__PURE__ */ new Map(),
+		streamFailedByStreamId: /* @__PURE__ */ new Map(),
+		closedStream: /* @__PURE__ */ new Map(),
+		failedStream: /* @__PURE__ */ new Map(),
+		deterministicValue: /* @__PURE__ */ new Map(),
+		terminalStartedBefore: /* @__PURE__ */ new Set(),
+		workflowStartedCount: 0,
+		totalStartedStepCount: 0
+	};
+	for (const [index, event] of events.entries()) appendWorkflowReplayProjectionEvent(projection, event, index);
+	return projection;
+}
+function appendWorkflowReplayProjectionEvents(projection, events, startIndex) {
+	for (const [offset, event] of events.entries()) appendWorkflowReplayProjectionEvent(projection, event, startIndex + offset);
+	return projection;
+}
+function appendWorkflowReplayProjectionEvent(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);
+			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);
+			break;
+		case "step_failed":
+			appendProjectedEvent(projection.failedSteps, event.stepId, event);
+			if (!projection.terminalStartedBefore.has(event)) {
+				const failedSteps = projection.unstartedFailedStep;
+				if (!failedSteps.has(event.stepId)) failedSteps.set(event.stepId, event);
+			}
+			break;
+		case "metadata_set":
+			projection.metadataSet.set(event.stepId, event);
+			break;
+		case "attributes_set":
+			projection.attributesSet.set(event.stepId, event);
+			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);
+			break;
+		case "child_workflow_started": {
+			projection.startedChildWorkflow.set(event.stepId, event);
+			const startedWorkflows = projection.childWorkflowStartedByAttemptKey;
+			const childWorkflowKey = workflowChildWorkflowAttemptKey(event);
+			if (!startedWorkflows.has(childWorkflowKey)) startedWorkflows.set(childWorkflowKey, {
+				index,
+				event
+			});
+			appendProjectedEvent(projection.childWorkflowStartedByStepId, event.stepId, {
+				index,
+				event
+			});
+			appendStartedEvent(projection.startedEventsByStepId, event);
+			incrementTotalStartedStepCount(projection);
+			break;
+		}
+		case "child_workflow_completed":
+			projection.completedChildWorkflow.set(event.stepId, event);
+			appendProjectedEvent(projection.childWorkflowCompletedByStepId, event.stepId, {
+				index,
+				event
+			});
+			break;
+		case "child_workflow_failed":
+			projection.failedChildWorkflow.set(event.stepId, event);
+			appendProjectedEvent(projection.childWorkflowFailedByStepId, event.stepId, {
+				index,
+				event
+			});
+			break;
+		case "message_wait_started":
+			projection.startedMessageWait.set(event.stepId, event);
+			activeMessageWaits(projection, event.messageId).set(event.stepId, event.stepName);
+			appendProjectedEvent(projection.messageWaitStartedByNameAndMessageId, workflowMessageWaitNameMessageKey(event.stepName, event.messageId), {
+				index,
+				event
+			});
+			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);
+			appendProjectedEvent(projection.completedMessageWait, event.stepId, {
+				index,
+				event
+			});
+			break;
+		case "message_wait_failed":
+			deleteActiveMessageWait(projection, event);
+			appendProjectedEvent(projection.failedMessageWait, event.stepId, {
+				index,
+				event
+			});
+			break;
+		case "message_sent":
+			appendProjectedEvent(projection.messageSentById, event.messageId, {
+				index,
+				event
+			});
+			if (event.idempotencyKey !== void 0) {
+				const messages = projection.messageSentByIdempotencyKey;
+				if (!messages.has(event.idempotencyKey)) messages.set(event.idempotencyKey, event);
+				projection.latestMessageSentByIdempotencyKey.set(event.idempotencyKey, event);
+			}
+			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);
+			break;
+		case "message_send_failed":
+			projection.failedMessageSend.set(event.stepId, event);
+			break;
+		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);
+			appendProjectedEvent(projection.streamChunksByStreamId, event.streamId, {
+				index,
+				event
+			});
+			setProjectedStreamChunkByIndex(projection, event);
+			break;
+		case "stream_closed": {
+			projection.closedStream.set(event.stepId, event);
+			const closed = projection.streamClosedByStreamId;
+			if (!closed.has(event.streamId)) closed.set(event.streamId, {
+				index,
+				event
+			});
+			break;
+		}
+		case "stream_failed": {
+			projection.failedStream.set(event.stepId, event);
+			const failed = projection.streamFailedByStreamId;
+			if (!failed.has(event.streamId)) failed.set(event.streamId, {
+				index,
+				event
+			});
+			break;
+		}
+		case "deterministic_value_recorded":
+			projection.deterministicValue.set(event.stepId, event);
+			break;
+	}
+}
+function appendStartedEvent(startedEventsByStepId, event) {
+	if (!isWorkflowRecordedStepEventKind(event.kind) || !("stepId" in event)) return;
+	appendProjectedEvent(startedEventsByStepId, event.stepId, event);
+}
+function recordProjectedStepAttempt(projection, event) {
+	if (!(Number.isSafeInteger(event.attempt) && event.attempt > 0)) {
+		projection.invalidStartedStepAttempt.set(event.stepId, event);
+		return;
+	}
+	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) {
+		projection.streamChunkByIndex.set(event.stepId, /* @__PURE__ */ new Map([[event.index, event]]));
+		return;
+	}
+	if (!chunks.has(event.index)) chunks.set(event.index, event);
+}
+function setProjectedStreamStartedByIdOrName(projection, event, index) {
+	if (!projection.streamStartedByIdOrName.has(event.streamId)) projection.streamStartedByIdOrName.set(event.streamId, {
+		index,
+		event
+	});
+	if (!projection.streamStartedByIdOrName.has(event.stepName)) projection.streamStartedByIdOrName.set(event.stepName, {
+		index,
+		event
+	});
+}
+function activeMessageWaits(projection, messageId) {
+	const waits = projection.activeMessageWaitsByMessageId.get(messageId);
+	if (waits !== void 0) return waits;
+	const nextWaits = /* @__PURE__ */ new Map();
+	projection.activeMessageWaitsByMessageId.set(messageId, nextWaits);
+	return nextWaits;
+}
+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) {
+	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) {
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		const event = entry.event;
+		if (entry.index > afterIndex && predicate(event)) return {
+			index: entry.index,
+			event
+		};
+	}
+}
+function findWorkflowMessageSentForWait(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 findStreamEventProjection(projection, streamIdOrName) {
+	const started = projection.streamStartedByIdOrName.get(streamIdOrName);
+	if (started === void 0) return;
+	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) }
+	};
+}
+function findLastWorkflowSleepStartedForCompleted(projection, completed) {
+	const started = projection.startedSleep.get(completed.stepId);
+	return started?.stepName === completed.stepName ? started : void 0;
+}
+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 findWorkflowChildWorkflowLifecycleForAttempt(projection, attempt) {
+	const started = projection.childWorkflowStartedByAttemptKey.get(workflowChildWorkflowAttemptKey(attempt));
+	if (started === void 0) return { hasTerminalAfterStarted: false };
+	return {
+		started: started.event,
+		hasTerminalAfterStarted: hasWorkflowChildWorkflowTerminalAfterStarted(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 activeMessageWaitStepIds(projection, messageId) {
+	return [...projection.activeMessageWaitsByMessageId.get(messageId)?.keys() ?? []];
+}
+function findLastMessageWaitStartedByNameAndMessageId(projection, stepName, messageId) {
+	return (projection.messageWaitStartedByNameAndMessageId.get(workflowMessageWaitNameMessageKey(stepName, messageId)) ?? []).at(-1)?.event;
+}
+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);
+	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) {
+	return idempotencyKey === void 0 ? void 0 : projection.messageSentByIdempotencyKey.get(idempotencyKey);
+}
+function findLastWorkflowMessageSentById(projection, messageId) {
+	return (projection.messageSentById.get(messageId) ?? []).at(-1)?.event;
+}
+function appendProjectedEvent(map, stepId, event) {
+	const events = map.get(stepId);
+	if (events === void 0) {
+		map.set(stepId, [event]);
+		return;
+	}
+	events.push(event);
+}
+function workflowMessageWaitNameMessageKey(stepName, messageId) {
+	return `${stepName}\u0000${messageId}`;
+}
+function workflowChildWorkflowAttemptKey(event) {
+	return [
+		workflowProjectionKeyPart(event.childRunId),
+		workflowProjectionKeyPart(event.stepId),
+		workflowProjectionKeyPart(event.stepName),
+		workflowProjectionKeyPart(event.attempt),
+		workflowProjectionKeyPart(event.count),
+		workflowProjectionKeyPart(event.workflowName),
+		workflowProjectionKeyPart(event.workflowVersion),
+		workflowProjectionKeyPart(event.cancellation ?? "cascade")
+	].join("\0");
+}
+function workflowProjectionKeyPart(value) {
+	return value === void 0 ? "
" : String(value);
+}
+function workflowChildWorkflowTerminalMatchesStarted(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 };

package/dist/history/sequencer.d.mts

@@ -0,0 +1,16 @@
+import { WorkflowStepIdentity, WorkflowStepType } from "../types/run.mjs";
+import { ChildWorkflowStartedEvent, DeterministicValueRecordedEvent, EventRecord, MessageSendStartedEvent, MessageWaitStartedEvent, MetadataSetEvent, SleepStartedEvent, StreamStartedEvent, WorkflowStepStartedEvent } 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 {
+  #private;
+  constructor(recordedSteps: readonly WorkflowRecordedStepEvent[]);
+  next<TType extends WorkflowStepType>(type: TType, name: string): WorkflowStepIdentity<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 };

package/dist/history/sequencer.mjs

@@ -0,0 +1,78 @@
+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));
+}
+var WorkflowStepSequencer = class {
+	#counts = /* @__PURE__ */ new Map();
+	#recordedSteps;
+	#cursor = 0;
+	constructor(recordedSteps) {
+		this.#recordedSteps = recordedSteps;
+	}
+	next(type, name) {
+		const key = `${type}:${name}`;
+		const count = (this.#counts.get(key) ?? 0) + 1;
+		this.#counts.set(key, count);
+		const identity = {
+			id: count === 1 ? `${type}:${name}` : `${type}:${name}:${count - 1}`,
+			name,
+			count,
+			kind: type
+		};
+		this.#requireNextRecordedStepMatches(identity);
+		this.#cursor++;
+		return identity;
+	}
+	requireConsumed() {
+		const recorded = this.#recordedSteps[this.#cursor];
+		if (recorded === void 0) return;
+		WorkflowReplayDivergenceError.diverged(`recorded step ${recorded.stepId} was not encountered by the workflow handler`, { expectedStepId: recorded.stepId });
+	}
+	isConsumed() {
+		return this.#recordedSteps[this.#cursor] === void 0;
+	}
+	#requireNextRecordedStepMatches(identity) {
+		const recorded = this.#recordedSteps[this.#cursor];
+		if (recorded === void 0) return;
+		const recordedType = workflowRecordedStepEventType(recorded);
+		if (!(recorded.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded ${recordedType} step ${recorded.stepId} has invalid start timestamp: ${String(recorded.timestamp)}`, {
+			expectedStepId: recorded.stepId,
+			actualStepId: identity.id
+		});
+		if (!(Number.isSafeInteger(recorded.count) && recorded.count > 0)) WorkflowReplayDivergenceError.diverged(`recorded ${recordedType} step ${recorded.stepId} has an invalid count`, {
+			expectedStepId: recorded.stepId,
+			actualStepId: identity.id
+		});
+		if (recordedType === identity.kind && recorded.stepId === identity.id && recorded.stepName === identity.name && recorded.count === identity.count) return;
+		WorkflowReplayDivergenceError.diverged(`expected recorded ${recordedType} step ${recorded.stepId}, but encountered ${identity.kind} step ${identity.id}`, {
+			expectedStepId: recorded.stepId,
+			actualStepId: identity.id
+		});
+	}
+};
+function workflowRecordedStepEventType(event) {
+	const stepType = getEventDescriptor(event.kind).stepType;
+	if (stepType === void 0) WorkflowStateError.unsupportedRecordedStepEventType(event.kind);
+	return stepType;
+}
+function isWorkflowRecordedStepEvent(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;
+		const key = `${event.kind}:${event.stepId}:${event.count}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		recorded.push(event);
+	}
+	return recorded;
+}
+//#endregion
+export { WorkflowStepSequencer, createWorkflowStepSequencer, isWorkflowRecordedStepEvent, workflowRecordedStepEventType };

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

@@ -0,0 +1,9 @@
+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/step-attempts.d.ts
+/** Creates workflow step attempts. */
+declare function createWorkflowStepAttempts(runId: RunId, events: readonly EventRecord[]): readonly WorkflowStepAttemptRecord[];
+//#endregion
+export { createWorkflowStepAttempts };

package/dist/history/step-attempts.mjs

@@ -0,0 +1,50 @@
+import { getWorkflowEventStepAttemptKey, isWorkflowTerminalStepAttemptEvent } from "../events/descriptors.mjs";
+import { applyWorkflowStepAttemptEvent } from "./projection.mjs";
+//#region src/history/step-attempts.ts
+/** Creates workflow step attempts. */
+function createWorkflowStepAttempts(runId, events) {
+	const attempts = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = reconciledWorkflowStepAttemptKeyFromEvent(event);
+		if (key === void 0) continue;
+		const attempt = applyReconciledWorkflowStepAttemptEvent(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) {
+	try {
+		return applyWorkflowStepAttemptEvent(runId, event, current);
+	} catch {
+		return;
+	}
+}
+function reconciledWorkflowStepAttemptKeyFromEvent(event) {
+	try {
+		return getWorkflowEventStepAttemptKey(event);
+	} catch {
+		return;
+	}
+}
+function markSupersededRunningStepAttemptsAsAbandoned(attempts) {
+	const latestAttemptByStepId = /* @__PURE__ */ new Map();
+	for (const attempt of attempts) latestAttemptByStepId.set(attempt.stepId, Math.max(latestAttemptByStepId.get(attempt.stepId) ?? 0, attempt.attempt));
+	return attempts.map((attempt) => {
+		if (attempt.status !== "running") return attempt;
+		const latestAttempt = latestAttemptByStepId.get(attempt.stepId) ?? attempt.attempt;
+		if (attempt.attempt >= latestAttempt) return attempt;
+		return {
+			...attempt,
+			status: "abandoned"
+		};
+	});
+}
+function compareStepAttempts(left, right) {
+	const started = Temporal.Instant.compare(left.startedAt, right.startedAt);
+	if (started !== 0) return started;
+	const stepId = left.stepId.localeCompare(right.stepId);
+	return stepId === 0 ? left.attempt - right.attempt : stepId;
+}
+//#endregion
+export { createWorkflowStepAttempts };

package/dist/history/timeline.d.mts

@@ -0,0 +1,16 @@
+import { Timeline as Timeline$1, TimelineEntryRecord } from "../types/timeline.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.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 };