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

package/dist/engine/message.mjs

@@ -1,78 +1,64 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import { WorkflowDurationError, WorkflowReplayDivergenceError } from "../errors/failures.mjs";
-import { getRequiredRun, safeDuration } from "../utility.mjs";
 import { WorkflowMessageDeliveryError, WorkflowMessageIdempotencyConflictError, WorkflowMessageWaitTimeoutError } from "../errors/message.mjs";
-import { resolveBroadcastMessageInput, resolveSendMessageInput, resolveWaitForMessageInput } from "../message-options.mjs";
 import { workflowErrorFromRecord } from "../errors/records.mjs";
-import { captureTelemetryContext } from "../telemetry.mjs";
+import { createMessageWait, resolveBroadcastMessageInput, resolveSendMessageInput } from "../message-options.mjs";
+import { History } from "../history/replay.mjs";
+import { safeDuration } from "../values.mjs";
+import { getRequiredRun } from "../store/query.mjs";
 import { serializeError, toOptionalPersistedValue } from "./serialization.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { enforceWorkflowEventHistoryNextLimit } from "./retry.mjs";
-import { WorkflowSuspended } from "./state.mjs";
-import { resolveWorkflowCommandIdentity, resolveWorkflowCommandIdentityFromCandidates } from "./command-identity.mjs";
-import { appendDurableStepStartedEvent, appendDurableStepTerminalEvent } from "./durable-command.mjs";
-import { requireMessageSendReplayMatches, requireRecordedDurableTerminalStarted } from "./replay.mjs";
+import { enforceEventHistoryNextLimit } from "./retry.mjs";
+import { Suspended } from "./signals.mjs";
+import { resolveCommandIdentity, resolveCommandIdentityFromCandidates } from "./command-identity.mjs";
+import { appendDurableEvent, appendDurableStepStartedEvent } from "./durable-command.mjs";
+import { captureTelemetryContext } from "../telemetry.mjs";
+import { recordedInstant, requireMessageSendReplayMatches, requireRecordedDurableTerminalStarted } from "./replay.mjs";
 import { validateStandardSchema } from "@temelj/standard-schema";
 import { deepEquals } from "@temelj/value";
 //#region src/engine/message.ts
 const MAX_MESSAGE_DELIVERY_APPEND_ATTEMPTS = 16;
-function createWorkflowStepMessageApi(environment) {
+function createStepMessageApi(environment) {
 	const { store, history, now, limits } = environment;
 	return {
 		async send(targetRunId, messageInput, channelOptions) {
 			const options = await resolveSendMessageInput(messageInput, channelOptions);
 			const idempotencyKey = options.idempotencyKey;
-			const identity = resolveWorkflowCommandIdentity(history, "message-send", options.messageId);
+			const identity = resolveCommandIdentity(history, "message-send", options.messageId);
 			const started = history.startedMessageSend(identity.id);
 			const completed = history.completedMessageSend(identity.id);
+			const nextMessageSend = {
+				targetRunId,
+				messageId: options.messageId,
+				payload: toOptionalPersistedValue(options.payload, "message payload", limits),
+				idempotencyKey
+			};
 			if (completed !== void 0) {
 				requireRecordedDurableTerminalStarted(identity, history.hasStartedEventBeforeTerminalEvent(completed));
-				requireMessageSendReplayMatches(identity, started, completed, {
-					targetRunId,
-					messageId: options.messageId,
-					payload: toOptionalPersistedValue(options.payload, "message payload", limits),
-					idempotencyKey
-				});
-				if (!(completed.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded message-send step ${identity.id} has invalid completion timestamp: ` + String(completed.timestamp), {
-					expectedStepId: identity.id,
-					actualStepId: identity.id
-				});
+				requireMessageSendReplayMatches(identity, started, completed, nextMessageSend);
+				recordedInstant("message-send", identity, "completion", completed.timestamp);
 				return;
 			}
 			const failed = history.failedMessageSend(identity.id);
 			if (failed !== void 0) {
 				requireRecordedDurableTerminalStarted(identity, history.hasStartedEventBeforeTerminalEvent(failed));
-				requireMessageSendReplayMatches(identity, started, failed, {
-					targetRunId,
-					messageId: options.messageId,
-					payload: toOptionalPersistedValue(options.payload, "message payload", limits),
-					idempotencyKey
-				});
-				if (!(failed.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded message-send step ${identity.id} has invalid failure timestamp: ` + String(failed.timestamp), {
-					expectedStepId: identity.id,
-					actualStepId: identity.id
-				});
+				requireMessageSendReplayMatches(identity, started, failed, nextMessageSend);
+				recordedInstant("message-send", identity, "failure", failed.timestamp);
 				throw workflowErrorFromRecord(failed.error);
 			}
-			const nextMessageSend = {
-				targetRunId,
-				messageId: options.messageId,
-				payload: toOptionalPersistedValue(options.payload, "message payload", limits),
-				idempotencyKey
-			};
 			if (started === void 0) {
-				const timestamp = now();
-				await appendDurableStepStartedEvent(environment, {
+				const durableEvent = {
 					kind: "message_send_started",
-					timestamp,
+					timestamp: now(),
 					stepId: identity.id,
 					stepName: identity.name,
 					count: identity.count,
 					targetRunId: nextMessageSend.targetRunId,
 					messageId: nextMessageSend.messageId,
 					payload: nextMessageSend.payload,
-					...nextMessageSend.idempotencyKey === void 0 ? {} : { idempotencyKey: nextMessageSend.idempotencyKey }
-				});
+					idempotencyKey: nextMessageSend.idempotencyKey
+				};
+				await appendDurableStepStartedEvent(environment, durableEvent);
 			} else requireMessageSendReplayMatches(identity, started, started, nextMessageSend);
 			try {
 				await sendWorkflowMessage(store, targetRunId, {
@@ -80,7 +66,7 @@ function createWorkflowStepMessageApi(environment) {
 					idempotencyKey
 				}, now, limits, environment.observeMessageSent, environment.telemetry);
 			} catch (error) {
-				await appendDurableStepTerminalEvent(environment, {
+				await appendDurableEvent(environment, {
 					kind: "message_send_failed",
 					timestamp: now(),
 					stepId: identity.id,
@@ -91,7 +77,7 @@ function createWorkflowStepMessageApi(environment) {
 				});
 				throw error;
 			}
-			await appendDurableStepTerminalEvent(environment, {
+			await appendDurableEvent(environment, {
 				kind: "message_send_completed",
 				timestamp: now(),
 				stepId: identity.id,
@@ -100,22 +86,20 @@ function createWorkflowStepMessageApi(environment) {
 				messageId: options.messageId
 			});
 		},
-		async wait(messageInput, channelOptions) {
-			return await waitForWorkflowMessage(environment, resolveWaitForMessageInput(messageInput, channelOptions));
-		}
+		wait: createMessageWait((options) => waitForMessage(environment, options))
 	};
 }
-async function sendWorkflowMessageInput(service, runId, messageInput, channelOptions) {
-	const telemetryContext = captureTelemetryContext(service.telemetry);
+async function sendMessageInput(context, runId, messageInput, channelOptions) {
+	const telemetryContext = captureTelemetryContext(context.telemetry);
 	const messageOptions = await resolveSendMessageInput(messageInput, channelOptions);
-	await sendWorkflowMessage(service.store, runId, messageOptions, service.now, service.limits, service.observeMessageSent, service.telemetry, telemetryContext);
+	await sendWorkflowMessage(context.store, runId, messageOptions, context.now, context.limits, context.observation.emitMessageSent, context.telemetry, telemetryContext);
 }
-async function broadcastWorkflowMessageInput(service, messageInput, channelOptions) {
-	const telemetryContext = captureTelemetryContext(service.telemetry);
+async function broadcastMessageInput(context, messageInput, channelOptions) {
+	const telemetryContext = captureTelemetryContext(context.telemetry);
 	const messageOptions = await resolveBroadcastMessageInput(messageInput, channelOptions);
-	toOptionalPersistedValue(messageOptions.payload, "message payload", service.limits);
-	const targets = await broadcastMessageTargets(service.store, messageOptions.target);
-	for (const target of targets) await sendWorkflowMessage(service.store, target.id, messageOptions, service.now, service.limits, service.observeMessageSent, service.telemetry, telemetryContext);
+	toOptionalPersistedValue(messageOptions.payload, "message payload", context.limits);
+	const targets = await broadcastMessageTargets(context.store, messageOptions.target);
+	for (const target of targets) await sendWorkflowMessage(context.store, target.id, messageOptions, context.now, context.limits, context.observation.emitMessageSent, context.telemetry, telemetryContext);
 	return {
 		messageId: messageOptions.messageId,
 		runIds: targets.map((target) => target.id),
@@ -123,77 +107,81 @@ async function broadcastWorkflowMessageInput(service, messageInput, channelOptio
 	};
 }
 async function sendWorkflowMessage(store, runId, options, now, limits, observeMessageSent, telemetry, traceContext) {
-	const targetRunId = runId;
 	const idempotencyKey = options.idempotencyKey;
 	const telemetryContext = traceContext ?? captureTelemetryContext(telemetry);
-	const run = await getRequiredRun(store, targetRunId);
+	const run = await getRequiredRun(store, runId);
 	const payload = toOptionalPersistedValue(options.payload, "message payload", limits);
 	let timestamp;
 	let appendedEvents;
 	for (let attempt = 0; attempt < MAX_MESSAGE_DELIVERY_APPEND_ATTEMPTS && appendedEvents === void 0; attempt++) {
-		const currentRun = attempt === 0 ? run : await getRequiredRun(store, targetRunId);
-		const currentEvents = await store.getEvents(targetRunId);
-		const currentHistory = new WorkflowHistory(currentEvents);
+		const currentRun = attempt === 0 ? run : await getRequiredRun(store, runId);
+		const currentEvents = await store.getEvents(runId);
+		const currentHistory = new History(currentEvents);
 		if (idempotencyKey !== void 0) {
 			const existingMessage = currentHistory.messageByIdempotencyKey(idempotencyKey);
 			if (existingMessage !== void 0) {
 				if (existingMessage.messageId === options.messageId && deepEquals(existingMessage.payload, payload)) {
-					await wakeRunForMessageEvent(store, targetRunId, existingMessage);
+					await wakeRunForMessageEvent(store, runId, existingMessage);
 					return;
 				}
 				WorkflowMessageIdempotencyConflictError.conflict({
-					runId: targetRunId,
+					runId,
 					messageId: options.messageId,
 					idempotencyKey
 				});
 			}
-			await requireMessageIdempotencyIndexUnclaimed(store, targetRunId, options.messageId, idempotencyKey);
+			await requireMessageIdempotencyIndexUnclaimed(store, runId, options.messageId, idempotencyKey);
 		}
 		if (currentRun.status === "completed" || currentRun.status === "failed" || currentRun.status === "canceled") WorkflowMessageDeliveryError.cannotSend({
-			runId: targetRunId,
+			runId,
 			status: currentRun.status,
 			messageId: options.messageId
 		});
 		const waiterStepIds = currentHistory.activeMessageWaitStepIds(options.messageId);
 		timestamp ??= now();
-		enforceWorkflowEventHistoryNextLimit(currentEvents, limits);
-		appendedEvents = await store.appendEventIfRunCurrent(currentRun, {
+		enforceEventHistoryNextLimit(currentEvents, limits);
+		const durableEvent1 = {
 			kind: "message_sent",
 			timestamp,
 			messageId: options.messageId,
 			payload,
-			...waiterStepIds.length === 0 ? {} : { waiterStepIds },
-			...idempotencyKey === void 0 ? {} : { idempotencyKey },
-			...telemetryContext === void 0 ? {} : { telemetryContext }
-		});
+			waiterStepIds: waiterStepIds.length !== 0 ? waiterStepIds : void 0,
+			idempotencyKey,
+			telemetryContext
+		};
+		appendedEvents = await store.appendEventIfRunCurrent(currentRun, durableEvent1);
 	}
 	if (appendedEvents === void 0) {
-		const currentRun = await getRequiredRun(store, targetRunId);
+		const currentRun = await getRequiredRun(store, runId);
 		if (currentRun.status === "completed" || currentRun.status === "failed" || currentRun.status === "canceled") WorkflowMessageDeliveryError.cannotSend({
-			runId: targetRunId,
+			runId,
 			status: currentRun.status,
 			messageId: options.messageId
 		});
-		WorkflowStateError.failedMessageAppend(targetRunId);
+		throw new WorkflowStateError(`Failed to append workflow message for run ${runId}`, {
+			code: WorkflowErrorCode.STATE_MESSAGE_APPEND_FAILED,
+			details: { runId }
+		});
 	}
-	const appendedHistory = new WorkflowHistory(appendedEvents);
+	const appendedHistory = new History(appendedEvents);
 	if (idempotencyKey !== void 0) {
 		const existingMessage = appendedHistory.messageByIdempotencyKey(idempotencyKey);
 		if (existingMessage !== void 0 && !workflowMessageSendMatches(existingMessage, options, payload)) WorkflowMessageIdempotencyConflictError.conflict({
-			runId: targetRunId,
+			runId,
 			messageId: options.messageId,
 			idempotencyKey
 		});
 	}
-	const messageEvent = appendedHistory.messageForSend(options.messageId, idempotencyKey) ?? {
+	let messageEvent = appendedHistory.messageForSend(options.messageId, idempotencyKey);
+	if (messageEvent === void 0) messageEvent = {
 		kind: "message_sent",
 		timestamp: timestamp ?? now(),
 		messageId: options.messageId,
 		payload,
-		...telemetryContext === void 0 ? {} : { telemetryContext }
+		telemetryContext
 	};
-	observeMessageSent?.(targetRunId, messageEvent);
-	await wakeRunForMessageEvent(store, targetRunId, messageEvent);
+	observeMessageSent?.(runId, messageEvent);
+	await wakeRunForMessageEvent(store, runId, messageEvent);
 }
 async function broadcastMessageTargets(store, target) {
 	return (await store.listRuns(target)).filter((run) => !(run.status === "completed" || run.status === "failed" || run.status === "canceled"));
@@ -208,9 +196,9 @@ async function requireMessageIdempotencyIndexUnclaimed(store, runId, messageId,
 function workflowMessageSendMatches(event, options, payload) {
 	return event.messageId === options.messageId && deepEquals(event.payload, payload);
 }
-async function waitForWorkflowMessage(environment, options) {
-	const { runId, history, now, limits, executionOwner } = environment;
-	const identity = resolveWorkflowCommandIdentityFromCandidates(history, "message-wait", [
+async function waitForMessage(environment, options) {
+	const { runId, history, now, executionOwner } = environment;
+	const identity = resolveCommandIdentityFromCandidates(history, "message-wait", [
 		options.commandId,
 		options.name,
 		options.messageId
@@ -231,28 +219,23 @@ async function waitForWorkflowMessage(environment, options) {
 	if (started !== void 0) requireMessageWaitReplayMatches(identity, started, started, options);
 	const timeoutAt = started?.timeoutAt === void 0 ? options.timeout === void 0 ? void 0 : (() => {
 		const timeout = safeDuration(options.timeout.total({ unit: "millisecond" }), "Workflow messageId timeout");
-		if (timeout <= 0) WorkflowDurationError.signalTimeoutPositive();
+		if (timeout <= 0) throw new WorkflowDurationError("Workflow message timeout must be greater than zero");
 		return now().add(Temporal.Duration.from({ milliseconds: timeout }));
-	})() : (() => {
-		if (!(started.timeoutAt instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} has invalid timeout timestamp: ` + String(started.timeoutAt), {
-			expectedStepId: identity.id,
-			actualStepId: identity.id
-		});
-		return started.timeoutAt;
-	})();
+	})() : recordedInstant("message-wait", identity, "timeout", started.timeoutAt);
 	let waitStartedAt;
 	if (started === void 0) {
 		waitStartedAt = now();
-		await appendDurableStepStartedEvent(environment, {
+		const durableEvent2 = {
 			kind: "message_wait_started",
 			timestamp: waitStartedAt,
 			stepId: identity.id,
 			stepName: identity.name,
 			count: identity.count,
 			messageId: options.messageId,
-			...options.source === void 0 ? {} : { source: options.source },
-			...timeoutAt === void 0 ? {} : { timeoutAt }
-		});
+			source: options.source,
+			timeoutAt
+		};
+		await appendDurableStepStartedEvent(environment, durableEvent2);
 	}
 	const messageId = history.messageForWait(options.messageId, identity.id, timeoutAt);
 	if (messageId !== void 0) {
@@ -260,7 +243,7 @@ async function waitForWorkflowMessage(environment, options) {
 		try {
 			payload = options.schema === void 0 ? messageId.payload : await validateStandardSchema(options.schema, messageId.payload, "Workflow message validation failed");
 		} catch (error) {
-			await appendDurableStepTerminalEvent(environment, {
+			await appendDurableEvent(environment, {
 				kind: "message_wait_failed",
 				timestamp: now(),
 				stepId: identity.id,
@@ -270,28 +253,29 @@ async function waitForWorkflowMessage(environment, options) {
 			});
 			throw error;
 		}
-		const persistedPayload = toOptionalPersistedValue(payload, "messageId payload", limits);
-		await appendDurableStepTerminalEvent(environment, {
+		const persistedPayload = messageId.payload;
+		const durableEvent3 = {
 			kind: "message_wait_completed",
 			timestamp: now(),
 			stepId: identity.id,
 			stepName: identity.name,
 			messageId: options.messageId,
-			...persistedPayload === void 0 ? {} : { payload: persistedPayload },
+			payload: persistedPayload,
 			messageTimestamp: messageId.timestamp,
-			...messageId.telemetryContext === void 0 ? {} : { telemetryContext: messageId.telemetryContext }
-		});
+			telemetryContext: messageId.telemetryContext
+		};
+		await appendDurableEvent(environment, durableEvent3);
 		return payload;
 	}
 	if (timeoutAt !== void 0 && Temporal.Instant.compare(timeoutAt, now()) <= 0) {
-		const error = WorkflowMessageWaitTimeoutError.create({
+		const error = new WorkflowMessageWaitTimeoutError({
 			runId,
 			stepId: identity.id,
 			stepName: identity.name,
 			messageId: options.messageId,
 			timeoutAt
 		});
-		await appendDurableStepTerminalEvent(environment, {
+		await appendDurableEvent(environment, {
 			kind: "message_wait_failed",
 			timestamp: now(),
 			stepId: identity.id,
@@ -301,38 +285,23 @@ async function waitForWorkflowMessage(environment, options) {
 		});
 		throw error;
 	}
-	WorkflowSuspended.until(messageWaitAvailableAt(now, timeoutAt, executionOwner.deadlineAt));
+	Suspended.until(messageWaitAvailableAt(now, timeoutAt, executionOwner.deadlineAt));
 }
 function requireMessageWaitReplayMatches(identity, started, event, options) {
 	const recordedMessage = started?.messageId ?? event.messageId;
-	if (started !== void 0 && !(started.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} has invalid start timestamp: ` + String(started.timestamp), {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
-	if (recordedMessage !== options.messageId) WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} waited for ${recordedMessage}, but replay waited for ${options.messageId}`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	if (started !== void 0) recordedInstant("message-wait", identity, "start", started.timestamp);
+	if (recordedMessage !== options.messageId) WorkflowReplayDivergenceError.atStep(identity.id, `recorded message-wait step ${identity.id} waited for ${recordedMessage}, but replay waited for ${options.messageId}`);
 	if (started !== void 0 && started.source !== options.source) {
 		const recordedSource = started.source ?? "message";
 		const replaySource = options.source ?? "message";
-		WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} was created by ${recordedSource}, but replay used ${replaySource}`, {
-			expectedStepId: identity.id,
-			actualStepId: identity.id
-		});
+		WorkflowReplayDivergenceError.atStep(identity.id, `recorded message-wait step ${identity.id} was created by ${recordedSource}, but replay used ${replaySource}`);
 	}
 	if (started !== void 0 && started.timeoutAt === void 0 !== (options.timeout === void 0)) {
 		const recordedTimeout = started.timeoutAt === void 0 ? "no timeout" : started.timeoutAt;
 		const replayTimeout = options.timeout === void 0 ? "no timeout" : "a timeout";
-		WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} had ${String(recordedTimeout)}, but replay used ${replayTimeout}`, {
-			expectedStepId: identity.id,
-			actualStepId: identity.id
-		});
+		WorkflowReplayDivergenceError.atStep(identity.id, `recorded message-wait step ${identity.id} had ${String(recordedTimeout)}, but replay used ${replayTimeout}`);
 	}
-	if (event.kind === "message_wait_completed" && !(event.messageTimestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded message-wait step ${identity.id} has invalid messageId timestamp: ` + String(event.messageTimestamp), {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	if (event.kind === "message_wait_completed") recordedInstant("message-wait", identity, "messageId", event.messageTimestamp);
 }
 function messageWaitAvailableAt(now, timeoutAt, deadlineAt) {
 	return [timeoutAt, deadlineAt].filter((value) => value !== void 0).sort((left, right) => Temporal.Instant.compare(left, right))[0] ?? now().add(Temporal.Duration.from({ milliseconds: 2 ** 31 - 1 }));
@@ -341,7 +310,7 @@ async function wakeRunForMessageEvent(store, runId, messageEvent) {
 	const run = await store.getRun(runId);
 	if (run === void 0 || run.status !== "waiting") return;
 	const events = await store.getEvents(runId);
-	const activeWaits = new WorkflowHistory(events).activeMessageWaitStepIds(messageEvent.messageId);
+	const activeWaits = new History(events).activeMessageWaitStepIds(messageEvent.messageId);
 	if (!(messageEvent.waiterStepIds === void 0 ? activeWaits.length > 0 : activeWaits.some((stepId) => messageEvent.waiterStepIds?.includes(stepId)))) return;
 	await store.updateRunIfCurrent(run, {
 		...run,
@@ -349,12 +318,10 @@ async function wakeRunForMessageEvent(store, runId, messageEvent) {
 		updatedAt: messageEvent.timestamp,
 		lastTransitionAt: messageEvent.timestamp,
 		lastTransitionReason: "waiting",
-		deadlineAt: run.deadlineAt,
-		retryAt: run.retryAt,
 		error: void 0,
 		output: void 0,
 		finishedAt: void 0
 	});
 }
 //#endregion
-export { broadcastWorkflowMessageInput, createWorkflowStepMessageApi, messageWaitAvailableAt, requireMessageWaitReplayMatches, sendWorkflowMessage, sendWorkflowMessageInput, waitForWorkflowMessage, wakeRunForMessageEvent };
+export { broadcastMessageInput, createStepMessageApi, sendMessageInput, sendWorkflowMessage, waitForMessage };

package/dist/engine/observation.d.mts

@@ -1,14 +1,14 @@
-import { MessageId } from "../types/message-id.mjs";
-import { RunId } from "../types/run-id.mjs";
+import { MessageId, RunId } from "../types/ids.mjs";
 import { CleanupRunsResult } from "../types/cleanup.mjs";
+import { HookKind } from "../types/hook.mjs";
 import { ChildWorkflowStartedObservationEvent, ObservationEmitter as ObservationEmitter$1, ObservationEventHandler, ObservationEventPattern, ScheduleRunCreatedObservationEvent, ScheduleTickObservationEvent, WorkerOperationObservationEvent } from "../types/observation.mjs";
 import { Telemetry, TelemetryContext } from "../types/telemetry.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { EventRecord, MessageSentEvent } from "../types/events.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/engine/observation.d.ts
-declare function createObservationEmitter(telemetry?: Telemetry): ObservationEmitter$1;
-declare class ObservationEmitter implements ObservationEmitter$1 {
+export declare function createObservationEmitter(telemetry?: Telemetry): ObservationEmitter$1;
+export declare class ObservationEmitter implements ObservationEmitter$1 {
   #private;
   constructor(telemetry?: Telemetry);
   on<Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>): () => void;
@@ -18,12 +18,11 @@ declare class ObservationEmitter implements ObservationEmitter$1 {
   listenerCount(pattern?: ObservationEventPattern): number;
   listeners(): readonly ObservationEventHandler[];
   listeners<Pattern extends ObservationEventPattern>(pattern: Pattern): readonly ObservationEventHandler<Pattern>[];
-  emitRunEvent(run: WorkflowRunRecord, previousRun?: WorkflowRunRecord): void;
-  emitRunMetadataUpdated(run: WorkflowRunRecord, previousRun?: WorkflowRunRecord): void;
+  emitRunEvent(run: RunRecord, previousRun?: RunRecord): void;
+  emitRunMetadataUpdated(run: RunRecord, previousRun?: RunRecord): void;
   emitDurableEventAppended(runId: RunId, event: EventRecord, appendedEvents: readonly EventRecord[]): void;
   emitMessageSent(runId: RunId, event: MessageSentEvent): void;
-  emitHookResumed(runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined): void;
-  emitWebhookResumed(runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined): void;
+  emitHookResumed(kind: HookKind, runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined): void;
   emitChildWorkflowStarted(event: ChildWorkflowStartedObservationEvent): void;
   emitCleanupCompleted(result: CleanupRunsResult): void;
   emitRetentionApplied(result: CleanupRunsResult): void;
@@ -31,5 +30,4 @@ declare class ObservationEmitter implements ObservationEmitter$1 {
   emitScheduleTicked(event: ScheduleTickObservationEvent): void;
   emitScheduleRunCreated(event: ScheduleRunCreatedObservationEvent): void;
 }
-//#endregion
-export { ObservationEmitter, createObservationEmitter };
+//#endregion

package/dist/engine/observation.mjs

@@ -1,8 +1,7 @@
-import { makeWorkflowStepAttemptKey } from "../history/attempt-key.mjs";
-import { observeTelemetry } from "../telemetry.mjs";
+import { stepAttemptKey } from "../store-keys.mjs";
 import { getWorkflowEventStepAttemptKey } from "../events/descriptors.mjs";
-import "../history/mod.mjs";
-import { createWorkflowStepAttempts } from "../history/step-attempts.mjs";
+import { createStepAttempts } from "../history/step-attempts.mjs";
+import { observeTelemetry } from "../telemetry.mjs";
 import { createPubSub } from "@temelj/event";
 //#region src/engine/observation.ts
 function createObservationEmitter(telemetry) {
@@ -11,9 +10,9 @@ function createObservationEmitter(telemetry) {
 var ObservationEmitter = class {
 	#events = createPubSub();
 	#telemetry;
-	#emit = (event, payload) => {
-		this.#events.emit(event, payload);
-		observeTelemetry(this.#telemetry, event, payload);
+	#emit = (...event) => {
+		this.#events.emit(event[0], event[1]);
+		observeTelemetry(this.#telemetry, ...event);
 	};
 	constructor(telemetry) {
 		this.#telemetry = telemetry;
@@ -28,7 +27,6 @@ var ObservationEmitter = class {
 		this.emitDurableEventAppended = this.emitDurableEventAppended.bind(this);
 		this.emitMessageSent = this.emitMessageSent.bind(this);
 		this.emitHookResumed = this.emitHookResumed.bind(this);
-		this.emitWebhookResumed = this.emitWebhookResumed.bind(this);
 		this.emitChildWorkflowStarted = this.emitChildWorkflowStarted.bind(this);
 		this.emitCleanupCompleted = this.emitCleanupCompleted.bind(this);
 		this.emitRetentionApplied = this.emitRetentionApplied.bind(this);
@@ -70,28 +68,21 @@ var ObservationEmitter = class {
 		emitStreamUpdated(this.#emit, runId, event);
 	}
 	emitMessageSent(runId, event) {
-		this.#emit("workflow:message-sent", {
+		const observation = {
 			runId,
 			messageId: event.messageId,
 			payload: event.payload,
 			timestamp: event.timestamp,
-			...event.telemetryContext === void 0 ? {} : { traceContext: event.telemetryContext }
-		});
-	}
-	emitHookResumed(runId, messageId, payload, traceContext) {
-		this.#emit("workflow:hook-resumed", {
-			runId,
-			messageId,
-			...payload === void 0 ? {} : { payload },
-			...traceContext === void 0 ? {} : { traceContext }
-		});
+			traceContext: event.telemetryContext
+		};
+		this.#emit("workflow:message-sent", observation);
 	}
-	emitWebhookResumed(runId, messageId, payload, traceContext) {
-		this.#emit("workflow:webhook-resumed", {
+	emitHookResumed(kind, runId, messageId, payload, traceContext) {
+		this.#emit(`workflow:${kind}-resumed`, {
 			runId,
 			messageId,
-			...payload === void 0 ? {} : { payload },
-			...traceContext === void 0 ? {} : { traceContext }
+			payload,
+			traceContext
 		});
 	}
 	emitChildWorkflowStarted(event) {
@@ -121,7 +112,7 @@ function emitStepAttemptUpdated(emit, runId, event, events) {
 		return;
 	}
 	if (key === void 0) return;
-	const attempt = createWorkflowStepAttempts(runId, events).find((current) => makeWorkflowStepAttemptKey(current.stepId, current.attempt) === key);
+	const attempt = createStepAttempts(runId, events).find((current) => stepAttemptKey(current.stepId, current.attempt) === key);
 	if (attempt === void 0) return;
 	emit("workflow:step-attempt-updated", {
 		runId,
@@ -138,8 +129,8 @@ function emitStreamUpdated(emit, runId, event) {
 		timestamp: event.timestamp,
 		stepId: event.stepId,
 		stepName: event.stepName,
-		...event.kind === "stream_chunk" ? { index: event.index } : {},
-		...event.kind === "stream_failed" ? { error: event.error } : {}
+		index: event.kind === "stream_chunk" ? event.index : void 0,
+		error: event.kind === "stream_failed" ? event.error : void 0
 	});
 }
 function emitRunEvent(emit, run, previousRun) {
@@ -192,7 +183,7 @@ function makeRunObservationEvent(run, previousRun) {
 		reason: run.lastTransitionReason,
 		timestamp: run.lastTransitionAt,
 		workflowName: run.workflowName,
-		...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion }
+		workflowVersion: run.workflowVersion
 	};
 }
 //#endregion

package/dist/engine/replay.d.mts

@@ -1,29 +1,28 @@
-import { MessageId } from "../types/message-id.mjs";
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowStepRunConfig } from "../types/step.mjs";
-import { WorkflowAttributePatch, WorkflowStepIdentity } from "../types/run.mjs";
+import { MessageId, RunId } from "../types/ids.mjs";
+import { StepRunConfig } from "../types/step.mjs";
+import { AttributePatch, StepIdentity } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import "../history/mod.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import "../history/replay.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/engine/replay.d.ts
-declare function isRunStepTerminalForStartedAttempt(terminal: Extract<EventRecord, {
+export declare function isRunStepTerminalForStartedAttempt(terminal: Extract<EventRecord, {
   readonly kind: "step_completed" | "step_failed";
 }>, started: Extract<EventRecord, {
   readonly kind: "step_started";
 }>): boolean;
-declare function requireRecordedDurableStepStarted(identity: WorkflowStepIdentity, started: boolean): void;
-declare function requireRecordedDurableTerminalStarted(identity: WorkflowStepIdentity, hasStartedEventBeforeTerminal: boolean): void;
-declare function requireRunStepReplayTimeoutMatches(identity: WorkflowStepIdentity, started: Extract<EventRecord, {
+export declare function requireRecordedDurableStepStarted(identity: StepIdentity, started: boolean): void;
+export declare function requireRecordedDurableTerminalStarted(identity: StepIdentity, hasStartedEventBeforeTerminal: boolean): void;
+export declare function requireRunStepReplayTimeoutMatches(identity: StepIdentity, started: Extract<EventRecord, {
   readonly kind: "step_started";
-}> | undefined, config: WorkflowStepRunConfig): void;
-declare function requireMetadataReplayMatches(identity: WorkflowStepIdentity, recorded: Extract<EventRecord, {
+}> | undefined, config: StepRunConfig): void;
+export declare function requireMetadataReplayMatches(identity: StepIdentity, recorded: Extract<EventRecord, {
   readonly kind: "metadata_set";
 }>, metadata: StorageValue): void;
-declare function requireAttributesReplayMatches(identity: WorkflowStepIdentity, recorded: Extract<EventRecord, {
+export declare function requireAttributesReplayMatches(identity: StepIdentity, recorded: Extract<EventRecord, {
   readonly kind: "attributes_set";
-}>, attributes: WorkflowAttributePatch): void;
-declare function requireMessageSendReplayMatches(identity: WorkflowStepIdentity, started: Extract<EventRecord, {
+}>, attributes: AttributePatch): void;
+export declare function requireMessageSendReplayMatches(identity: StepIdentity, started: Extract<EventRecord, {
   readonly kind: "message_send_started";
 }> | undefined, terminal: Extract<EventRecord, {
   readonly kind: "message_send_started" | "message_send_completed" | "message_send_failed";
@@ -33,9 +32,9 @@ declare function requireMessageSendReplayMatches(identity: WorkflowStepIdentity,
   readonly payload?: StorageValue;
   readonly idempotencyKey?: string;
 }): void;
-declare function sleepUntil(environment: WorkflowExecutionEnvironment, name: string, initialUntil: Temporal.Instant, options: {
+export declare function sleepUntil(environment: ExecutionEnvironment, name: string, initialUntil: Temporal.Instant, options: {
   readonly duration?: Temporal.Duration;
 }): Promise<void>;
-declare function recordedStepCompletionTimestamp(identity: WorkflowStepIdentity, value: Temporal.Instant): Temporal.Instant;
-//#endregion
-export { isRunStepTerminalForStartedAttempt, recordedStepCompletionTimestamp, requireAttributesReplayMatches, requireMessageSendReplayMatches, requireMetadataReplayMatches, requireRecordedDurableStepStarted, requireRecordedDurableTerminalStarted, requireRunStepReplayTimeoutMatches, sleepUntil };
+/** A timestamp read from history; anything else in its place is a replay divergence. */
+export declare function recordedInstant(kind: string, identity: StepIdentity, label: string, value: Temporal.Instant): Temporal.Instant;
+//#endregion