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

package/dist/engine/hooks.mjs

@@ -1,51 +1,45 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowHookError } from "../errors/hook.mjs";
 import { WorkflowHookDisposedError } from "../errors/message.mjs";
+import { matchesWorkflowError } from "../errors/records.mjs";
 import "../errors/mod.mjs";
-import { captureTelemetryContext } from "../telemetry.mjs";
+import { WORKFLOW_HOOK_TOKEN_PREFIX, parseHookToken } from "../hook-token.mjs";
+import { History } from "../history/replay.mjs";
 import { serializeError, toOptionalPersistedValue, toPersistedValue } from "./serialization.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { enforceWorkflowEventHistoryNextLimit } from "./retry.mjs";
-import { WORKFLOW_HOOK_TOKEN_PREFIX, parseHookToken, parseWebhookToken } from "../types/hook.mjs";
-import { sendWorkflowMessage, waitForWorkflowMessage } from "./message.mjs";
+import { enforceEventHistoryNextLimit } from "./retry.mjs";
+import { captureTelemetryContext } from "../telemetry.mjs";
+import { sendWorkflowMessage, waitForMessage } from "./message.mjs";
 import { encodeBase64UrlString } from "@temelj/string";
 //#region src/engine/hooks.ts
 const MAX_HOOK_DISPOSAL_APPEND_ATTEMPTS = 16;
-function createHook(runId, options, wait) {
-	return new Hook(runId, options, wait);
-}
-function createWebhook(runId, options, wait) {
-	return new Webhook(runId, options, wait);
-}
-function createWorkflowStepHookApi(environment) {
+function createStepHookApi(environment) {
 	const { runId } = environment;
 	const tokens = /* @__PURE__ */ new Set();
+	function create(options) {
+		const hook = new Hook(runId, options, () => waitForMessage(environment, {
+			commandId: options.commandId ?? options.name,
+			messageId: options.messageId ?? options.name,
+			source: "hook",
+			timeout: options.timeout,
+			schema: options.schema
+		}));
+		requireUniqueStepHookToken(tokens, "hook", hook.name, hook.token);
+		return hook;
+	}
+	function createWebhook(options) {
+		const webhook = new Webhook(runId, options, () => waitForMessage(environment, {
+			commandId: options.commandId ?? options.name,
+			messageId: options.messageId ?? options.name,
+			source: "webhook",
+			timeout: options.timeout,
+			schema: options.schema
+		}));
+		requireUniqueStepHookToken(tokens, "webhook", webhook.name, webhook.token);
+		return webhook;
+	}
 	return {
-		create(options) {
-			const hook = createHook(runId, options, async () => {
-				return await waitForWorkflowMessage(environment, {
-					commandId: options.commandId ?? options.name,
-					messageId: options.messageId ?? options.name,
-					source: "hook",
-					...options.timeout === void 0 ? {} : { timeout: options.timeout },
-					...options.schema === void 0 ? {} : { schema: options.schema }
-				});
-			});
-			requireUniqueWorkflowStepHookToken(tokens, "hook", hook.name, hook.token);
-			return hook;
-		},
-		createWebhook(options) {
-			const webhook = createWebhook(runId, options, async () => {
-				return await waitForWorkflowMessage(environment, {
-					commandId: options.commandId ?? options.name,
-					messageId: options.messageId ?? options.name,
-					source: "webhook",
-					...options.timeout === void 0 ? {} : { timeout: options.timeout },
-					...options.schema === void 0 ? {} : { schema: options.schema }
-				});
-			});
-			requireUniqueWorkflowStepHookToken(tokens, "webhook", webhook.name, webhook.token);
-			return webhook;
-		}
+		create,
+		createWebhook
 	};
 }
 var Hook = class {
@@ -59,7 +53,8 @@ var Hook = class {
 		this.token = formatHookToken({
 			runId,
 			name: options.name,
-			messageId
+			messageId,
+			kind: "hook"
 		});
 		this.runId = runId;
 		this.name = options.name;
@@ -73,8 +68,11 @@ var Hook = class {
 		return this.wait().then(onfulfilled, onrejected);
 	}
 };
-function requireUniqueWorkflowStepHookToken(tokens, kind, name, token) {
-	if (tokens.has(token)) WorkflowHookError.tokenNotUnique(kind, name);
+function requireUniqueStepHookToken(tokens, kind, name, token) {
+	if (tokens.has(token)) throw new WorkflowHookError(`Workflow ${kind} token must be unique within a run: ${name}`, WorkflowErrorCode.HOOK_TOKEN_NOT_UNIQUE, {
+		kind,
+		name
+	});
 	tokens.add(token);
 }
 var Webhook = class {
@@ -87,13 +85,14 @@ var Webhook = class {
 	constructor(runId, options, wait) {
 		const messageId = options.messageId ?? options.name;
 		const metadata = options.metadata === void 0 ? void 0 : toPersistedValue(options.metadata, "workflow webhook metadata", {});
-		this.token = formatHookToken({
+		const token = {
 			runId,
 			name: options.name,
 			messageId,
 			kind: "webhook",
-			...metadata === void 0 ? {} : { metadata }
-		});
+			metadata
+		};
+		this.token = formatHookToken(token);
 		this.runId = runId;
 		this.name = options.name;
 		this.messageId = messageId;
@@ -107,56 +106,42 @@ var Webhook = class {
 		return this.wait().then(onfulfilled, onrejected);
 	}
 };
-async function resumeHook(token, options, service) {
+async function resumeHook(token, options, context) {
 	const hook = parseHookToken(token);
-	const payload = toOptionalPersistedValue(options?.payload, "hook payload", service.limits);
-	const telemetryContext = captureTelemetryContext(service.telemetry);
-	await sendWorkflowMessage(service.store, hook.runId, {
+	const payload = toOptionalPersistedValue(options?.payload, `${hook.kind} payload`, context.limits);
+	const telemetryContext = captureTelemetryContext(context.telemetry);
+	await sendWorkflowMessage(context.store, hook.runId, {
 		messageId: hook.messageId,
 		payload,
 		idempotencyKey: options?.idempotencyKey
-	}, service.now, service.limits, service.emitMessageSent, service.telemetry, telemetryContext);
-	service.emitHookResumed(hook.runId, hook.messageId, payload, telemetryContext);
+	}, context.now, context.limits, context.observation.emitMessageSent, context.telemetry, telemetryContext);
+	context.observation.emitHookResumed(hook.kind, hook.runId, hook.messageId, payload, telemetryContext);
 }
-async function resumeWebhook(token, options, service) {
-	const webhook = parseWebhookToken(token);
-	const payload = toOptionalPersistedValue(options?.payload, "webhook payload", service.limits);
-	const telemetryContext = captureTelemetryContext(service.telemetry);
-	await sendWorkflowMessage(service.store, webhook.runId, {
-		messageId: webhook.messageId,
-		payload,
-		idempotencyKey: options?.idempotencyKey
-	}, service.now, service.limits, service.emitMessageSent, service.telemetry, telemetryContext);
-	service.emitWebhookResumed(webhook.runId, webhook.messageId, payload, telemetryContext);
-}
-async function disposeHook(token, service) {
-	return await disposeHookToken(token, parseHookToken(token), service);
-}
-async function disposeWebhook(token, service) {
-	return await disposeHookToken(token, parseWebhookToken(token), service);
+async function disposeHook(token, context) {
+	return await disposeHookToken(token, parseHookToken(token), context);
 }
 async function getHookByToken(token, store, now) {
 	const hook = parseHookToken(token);
 	return inspectHookToken(token, await store.getRun(hook.runId), await store.getEvents(hook.runId), now);
 }
-async function disposeHookToken(token, hook, service) {
+async function disposeHookToken(token, hook, context) {
 	let timestamp;
 	for (let attempt = 0; attempt < MAX_HOOK_DISPOSAL_APPEND_ATTEMPTS; attempt++) {
-		const run = await service.store.getRun(hook.runId);
-		const events = run === void 0 ? [] : await service.store.getEvents(hook.runId);
-		const inspection = inspectHookToken(token, run, events, service.now());
+		const run = await context.store.getRun(hook.runId);
+		const events = run === void 0 ? [] : await context.store.getEvents(hook.runId);
+		const inspection = inspectHookToken(token, run, events, context.now());
 		if (inspection.status !== "waiting") return inspection;
 		if (run === void 0) return inspection;
-		if (inspection.stepId === void 0) WorkflowHookError.waitingStepMissing();
-		timestamp ??= service.now();
-		enforceWorkflowEventHistoryNextLimit(events, service.limits);
-		const appendedEvents = await service.store.appendEventIfRunCurrent(run, {
+		if (inspection.stepId === void 0) throw new WorkflowHookError("Workflow hook inspection is missing a waiting step id", WorkflowErrorCode.HOOK_WAITING_STEP_MISSING, void 0);
+		timestamp ??= context.now();
+		enforceEventHistoryNextLimit(events, context.limits);
+		const appendedEvents = await context.store.appendEventIfRunCurrent(run, {
 			kind: "message_wait_failed",
 			timestamp,
 			stepId: inspection.stepId,
 			stepName: hook.name,
 			messageId: hook.messageId,
-			error: serializeError(WorkflowHookDisposedError.create({
+			error: serializeError(new WorkflowHookDisposedError({
 				runId: hook.runId,
 				stepId: inspection.stepId,
 				stepName: hook.name,
@@ -164,27 +149,25 @@ async function disposeHookToken(token, hook, service) {
 			}))
 		});
 		if (appendedEvents === void 0) continue;
-		if (run.status === "waiting") await service.store.updateRunIfCurrent(run, {
+		if (run.status === "waiting") await context.store.updateRunIfCurrent(run, {
 			...run,
 			availableAt: run.availableAt !== void 0 && Temporal.Instant.compare(run.availableAt, timestamp) <= 0 ? run.availableAt : timestamp,
 			updatedAt: timestamp,
 			lastTransitionAt: timestamp,
 			lastTransitionReason: "waiting",
-			deadlineAt: run.deadlineAt,
-			retryAt: run.retryAt,
 			error: void 0,
 			output: void 0,
 			finishedAt: void 0
 		});
-		return inspectHookToken(token, run, appendedEvents, service.now());
+		return inspectHookToken(token, run, appendedEvents, context.now());
 	}
-	const run = await service.store.getRun(hook.runId);
-	return inspectHookToken(token, run, run === void 0 ? [] : await service.store.getEvents(hook.runId), service.now());
+	const run = await context.store.getRun(hook.runId);
+	return inspectHookToken(token, run, run === void 0 ? [] : await context.store.getEvents(hook.runId), context.now());
 }
 function inspectHookToken(token, run, events, now) {
 	const hook = parseHookToken(token);
 	if (run === void 0) return hookInspection(token, hook, "not-found");
-	const history = new WorkflowHistory(events);
+	const history = new History(events);
 	const started = history.latestMessageWaitStartedByNameAndMessageId(hook.name, hook.messageId);
 	if (started === void 0) return hookInspection(token, hook, "not-found");
 	const terminal = history.latestMessageWaitTerminalAfterStarted(started);
@@ -193,7 +176,7 @@ function inspectHookToken(token, run, events, now) {
 		timeoutAt: started.timeoutAt,
 		payload: terminal.payload
 	});
-	if (terminal?.kind === "message_wait_failed") return hookInspection(token, hook, WorkflowHookDisposedError.isDisposed(terminal.error) ? "disposed" : "failed", {
+	if (terminal?.kind === "message_wait_failed") return hookInspection(token, hook, matchesWorkflowError(terminal.error, WorkflowErrorCode.HOOK_DISPOSED) ? "disposed" : "failed", {
 		stepId: started.stepId,
 		timeoutAt: started.timeoutAt,
 		error: terminal.error
@@ -219,19 +202,15 @@ function hookInspection(token, hook, status, state = {}) {
 		messageId: hook.messageId,
 		kind: hook.kind,
 		status,
-		...hook.metadata === void 0 ? {} : { metadata: hook.metadata },
-		...state.stepId === void 0 ? {} : { stepId: state.stepId },
-		...state.timeoutAt === void 0 ? {} : { timeoutAt: state.timeoutAt },
-		...state.payload === void 0 ? {} : { payload: state.payload },
-		...state.error === void 0 ? {} : { error: state.error }
+		metadata: hook.metadata,
+		stepId: state.stepId,
+		timeoutAt: state.timeoutAt,
+		payload: state.payload,
+		error: state.error
 	};
 }
 function formatHookToken(hook) {
-	const payload = {
-		v: 1,
-		...hook
-	};
-	return `${WORKFLOW_HOOK_TOKEN_PREFIX}v1:${encodeBase64UrlString(JSON.stringify(payload))}`;
+	return `${WORKFLOW_HOOK_TOKEN_PREFIX}v1:${encodeBase64UrlString(JSON.stringify(hook))}`;
 }
 //#endregion
-export { Hook, Webhook, createHook, createWebhook, createWorkflowStepHookApi, disposeHook, disposeWebhook, getHookByToken, inspectHookToken, resumeHook, resumeWebhook };
+export { Hook, Webhook, createStepHookApi, disposeHook, getHookByToken, resumeHook };

package/dist/engine/inspection.d.mts

@@ -1,18 +1,26 @@
-import { WorkflowRecoverySummary, WorkflowRecoverySummaryOptions, WorkflowRunSummary, WorkflowRunSummaryOptions } from "../types/summary.mjs";
-import { WorkflowEventReader, WorkflowLockListerRepository, WorkflowRunListerRepository, WorkflowRunReaderRepository, WorkflowScheduleListerRepository, WorkflowStepAttemptLookup } from "../types/store.mjs";
+import { RunId } from "../types/ids.mjs";
+import { WorkflowPage } from "../types/pagination.mjs";
+import { ListRunsOptions, ListStepAttemptsPageOptions } from "../types/run-list.mjs";
+import { RecoverySummary, RunSummary } from "../types/summary.mjs";
+import { ListStepAttemptsOptions, StepAttemptRecord, StepAttemptSummary } from "../types/step-attempts.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import { EngineContext } from "./context.mjs";
+import { Timeline } from "../types/timeline.mjs";
 //#region src/engine/inspection.d.ts
-type WorkflowSummaryRunStore = WorkflowRunReaderRepository & WorkflowRunListerRepository;
-type WorkflowRunSummaryStore = WorkflowSummaryRunStore & WorkflowEventReader & WorkflowStepAttemptLookup;
-type WorkflowRecoverySummaryStore = WorkflowRunSummaryStore & WorkflowLockListerRepository & WorkflowScheduleListerRepository;
-declare function getWorkflowRunSummary(options: {
-  readonly store: WorkflowRunSummaryStore;
+export declare function getWorkflowRunSummary(options: {
+  readonly store: WorkflowStore;
   readonly now: Temporal.Instant;
-  readonly filters?: WorkflowRunSummaryOptions;
-}): Promise<WorkflowRunSummary>;
-declare function getWorkflowRecoverySummary(options: {
-  readonly store: WorkflowRecoverySummaryStore;
+  readonly filters?: ListRunsOptions;
+}): Promise<RunSummary>;
+export declare function getWorkflowRecoverySummary(options: {
+  readonly store: WorkflowStore;
   readonly now: Temporal.Instant;
-  readonly filters?: WorkflowRecoverySummaryOptions;
-}): Promise<WorkflowRecoverySummary>;
-//#endregion
-export { getWorkflowRecoverySummary, getWorkflowRunSummary };
+  readonly filters?: ListRunsOptions;
+}): Promise<RecoverySummary>;
+/** A page of a run's step attempts. */
+export declare function pageRunStepAttempts({ store }: EngineContext, runId: RunId, options?: ListStepAttemptsPageOptions): Promise<WorkflowPage<StepAttemptRecord>>;
+export declare function countRunStepAttempts({ store }: EngineContext, runId: RunId, options?: ListStepAttemptsOptions): Promise<number>;
+/** A run's step attempts, with the child runs its workflow steps started. */
+export declare function getRunStepAttemptSummary({ store }: EngineContext, runId: RunId, options?: ListStepAttemptsOptions): Promise<StepAttemptSummary>;
+export declare function getRunTimeline({ store }: EngineContext, runId: RunId): Promise<Timeline>;
+//#endregion

package/dist/engine/inspection.mjs

@@ -1,32 +1,39 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowOptionsError } from "../errors/base.mjs";
-import { isActiveWorkflowRunStatus, isWorkflowRunStatus } from "../utility.mjs";
 import "../errors/mod.mjs";
-import { summarizeWorkflowRecovery } from "./recovery.mjs";
-import { getChildRunsForAttempts } from "./summary/child-workflow-runs.mjs";
-import { summarizeWorkflowRuns } from "./summary.mjs";
+import { createTimeline } from "../history/timeline.mjs";
+import "../history/replay.mjs";
+import { isActiveRunStatus, isRunStatus } from "../run-status.mjs";
+import { getRequiredRun } from "../store/query.mjs";
+import { summarizeRecovery } from "./summary/recovery.mjs";
+import { getChildRunsForAttempts, summarizeRuns } from "./summary/runs.mjs";
+import { summarizeStepAttempts } from "./summary/step-attempts.mjs";
 //#region src/engine/inspection.ts
-function isKnownWorkflowRunStatus(run) {
-	return isWorkflowRunStatus(run.status);
+function isKnownRunStatus(run) {
+	return isRunStatus(run.status);
 }
 function workflowRunCanHaveActiveWork(run) {
-	return isActiveWorkflowRunStatus(run.status);
+	return isActiveRunStatus(run.status);
 }
 function workflowSummaryCleanupCutoff(filters) {
 	if (filters?.cleanupFinishedAtBefore === void 0) return;
 	const value = filters.cleanupFinishedAtBefore;
-	if (!(value instanceof Temporal.Instant)) WorkflowOptionsError.temporalInstant("Workflow cleanup finishedAtBefore");
+	if (!(value instanceof Temporal.Instant)) throw new WorkflowOptionsError("Workflow cleanup finishedAtBefore must be a Temporal.Instant", {
+		code: WorkflowErrorCode.OPTIONS_EXPECTED_TEMPORAL_INSTANT,
+		details: { label: "Workflow cleanup finishedAtBefore" }
+	});
 	return value;
 }
-async function listWorkflowRunStepAttempts(store, runId, options) {
+async function listRunStepAttempts(store, runId, options) {
 	return await store.listStepAttempts(runId, options);
 }
-async function listActiveWorkflowRunStepAttempts(store, run, kind) {
-	return workflowRunCanHaveActiveWork(run) ? await listWorkflowRunStepAttempts(store, run.id, {
+async function listActiveRunStepAttempts(store, run, kind) {
+	return workflowRunCanHaveActiveWork(run) ? await listRunStepAttempts(store, run.id, {
 		status: "running",
 		kind
 	}) : [];
 }
-async function getWorkflowRunSummaryActivityInputs(store, runs) {
+async function getRunSummaryActivityInputs(store, runs) {
 	const [runningChildWorkflows, runningSleeps, runningMessageWaits, runningEvents] = await Promise.all([
 		listRunningChildWorkflowWaits(store, runs),
 		listRunningStepWaits(store, runs, "sleep"),
@@ -42,12 +49,12 @@ async function getWorkflowRunSummaryActivityInputs(store, runs) {
 }
 async function listRunningChildWorkflowWaits(store, runs) {
 	return await Promise.all(runs.map(async (run) => {
-		if (!isKnownWorkflowRunStatus(run)) return {
+		if (!isKnownRunStatus(run)) return {
 			runId: run.id,
 			attempts: [],
 			childRuns: []
 		};
-		const attempts = await listWorkflowRunStepAttempts(store, run.id, {
+		const attempts = await listRunStepAttempts(store, run.id, {
 			status: "running",
 			kind: "workflow"
 		});
@@ -62,7 +69,7 @@ async function listRunningStepWaits(store, runs, kind) {
 	return await Promise.all(runs.map(async (run) => {
 		return {
 			runId: run.id,
-			attempts: await listActiveWorkflowRunStepAttempts(store, run, kind)
+			attempts: await listActiveRunStepAttempts(store, run, kind)
 		};
 	}));
 }
@@ -74,8 +81,8 @@ async function listRunningEventActivity(store, runs) {
 		};
 	}));
 }
-async function listWorkflowRunAttemptGroups(store, runs, options) {
-	return await Promise.all(runs.map(async (run) => await listWorkflowRunStepAttempts(store, run.id, options)));
+async function listRunAttemptGroups(store, runs, options) {
+	return await Promise.all(runs.map((run) => listRunStepAttempts(store, run.id, options)));
 }
 async function getWorkflowRunSummary(options) {
 	const { store, now, filters } = options;
@@ -85,9 +92,9 @@ async function getWorkflowRunSummary(options) {
 		runs,
 		now,
 		cleanupCutoff,
-		...await getWorkflowRunSummaryActivityInputs(store, runs)
+		...await getRunSummaryActivityInputs(store, runs)
 	};
-	return summarizeWorkflowRuns(summaryInputs);
+	return summarizeRuns(summaryInputs);
 }
 async function getWorkflowRecoverySummary(options) {
 	const { store, now, filters } = options;
@@ -95,28 +102,28 @@ async function getWorkflowRecoverySummary(options) {
 	const activeRuns = runs.filter((run) => {
 		return workflowRunCanHaveActiveWork(run);
 	});
-	return summarizeWorkflowRecovery({
+	return summarizeRecovery({
 		runs,
 		now,
-		inputs: await getWorkflowRecoverySummaryInputs(store, activeRuns)
+		inputs: await getRecoverySummaryInputs(store, activeRuns)
 	});
 }
-async function getWorkflowRecoverySummaryInputs(store, activeRuns) {
+async function getRecoverySummaryInputs(store, activeRuns) {
 	const [sleepAttemptGroups, messageWaitAttemptGroups, childWorkflowAttemptGroups, lockWaitAttemptGroups, eventsByRunId, locks, schedules] = await Promise.all([
-		listWorkflowRunAttemptGroups(store, activeRuns, {
+		listRunAttemptGroups(store, activeRuns, {
 			status: "running",
 			kind: "sleep"
 		}),
-		listWorkflowRunAttemptGroups(store, activeRuns, {
+		listRunAttemptGroups(store, activeRuns, {
 			status: "running",
 			kind: "message-wait"
 		}),
 		listChildWorkflowAttemptGroups(store, activeRuns),
-		listWorkflowRunAttemptGroups(store, activeRuns, {
+		listRunAttemptGroups(store, activeRuns, {
 			status: "failed",
 			kind: "run"
 		}),
-		getWorkflowRecoveryEventsByRunId(store, activeRuns),
+		getRecoveryEventsByRunId(store, activeRuns),
 		store.listLocks(),
 		store.listSchedules()
 	]);
@@ -133,7 +140,7 @@ async function getWorkflowRecoverySummaryInputs(store, activeRuns) {
 }
 async function listChildWorkflowAttemptGroups(store, activeRuns) {
 	return await Promise.all(activeRuns.map(async (run) => {
-		const attempts = await listWorkflowRunStepAttempts(store, run.id, {
+		const attempts = await listRunStepAttempts(store, run.id, {
 			status: "running",
 			kind: "workflow"
 		});
@@ -144,8 +151,27 @@ async function listChildWorkflowAttemptGroups(store, activeRuns) {
 		};
 	}));
 }
-async function getWorkflowRecoveryEventsByRunId(store, activeRuns) {
+async function getRecoveryEventsByRunId(store, activeRuns) {
 	return new Map(await Promise.all(activeRuns.map(async (run) => [run.id, await store.getEvents(run.id)])));
 }
+/** A page of a run's step attempts. */
+async function pageRunStepAttempts({ store }, runId, options) {
+	await getRequiredRun(store, runId);
+	return await store.listStepAttemptsPage(runId, options);
+}
+async function countRunStepAttempts({ store }, runId, options) {
+	await getRequiredRun(store, runId);
+	return await store.countStepAttempts(runId, options);
+}
+/** A run's step attempts, with the child runs its workflow steps started. */
+async function getRunStepAttemptSummary({ store }, runId, options) {
+	await getRequiredRun(store, runId);
+	const attempts = await store.listStepAttempts(runId, options);
+	return summarizeStepAttempts(attempts, await getChildRunsForAttempts(store, runId, attempts));
+}
+async function getRunTimeline({ store }, runId) {
+	const run = await getRequiredRun(store, runId);
+	return createTimeline(run, await store.getEvents(runId));
+}
 //#endregion
-export { getWorkflowRecoverySummary, getWorkflowRunSummary };
+export { countRunStepAttempts, getRunStepAttemptSummary, getRunTimeline, getWorkflowRecoverySummary, getWorkflowRunSummary, pageRunStepAttempts };

package/dist/engine/lifecycle.d.mts

@@ -1,18 +1,12 @@
 import { ObservationEmitter } from "../types/observation.mjs";
 import { ExecutionResult } from "../types/result.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { CreateWorkflowEngineOptions } from "../types/engine-options.mjs";
 //#region src/engine/lifecycle.d.ts
-declare function createWorkflowLifecycleEmitter(options: CreateWorkflowEngineOptions, observation?: ObservationEmitter): WorkflowLifecycleEmitterContract;
-interface WorkflowLifecycleEmitterContract {
-  readonly emitLifecycleEvent: (run: WorkflowRunRecord, previousRun?: WorkflowRunRecord) => Promise<void>;
-  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previousRun?: WorkflowRunRecord) => Promise<ExecutionResult<TOutput>>;
-}
-declare class WorkflowLifecycleEmitter implements WorkflowLifecycleEmitterContract {
-  #private;
-  constructor(options: CreateWorkflowEngineOptions, observation?: ObservationEmitter);
-  emitLifecycleEvent: (run: WorkflowRunRecord, previousRun?: WorkflowRunRecord) => Promise<void>;
-  emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previousRun?: WorkflowRunRecord) => Promise<ExecutionResult<TOutput>>;
+export declare function createLifecycleEmitter(options: CreateWorkflowEngineOptions, observation?: ObservationEmitter): LifecycleEmitterContract;
+interface LifecycleEmitterContract {
+  readonly emitLifecycleEvent: (run: RunRecord, previousRun?: RunRecord) => Promise<void>;
+  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previousRun?: RunRecord) => Promise<ExecutionResult<TOutput>>;
 }
 //#endregion
-export { WorkflowLifecycleEmitter, createWorkflowLifecycleEmitter };
+export {};

package/dist/engine/lifecycle.mjs

@@ -1,8 +1,8 @@
 //#region src/engine/lifecycle.ts
-function createWorkflowLifecycleEmitter(options, observation) {
-	return new WorkflowLifecycleEmitter(options, observation);
+function createLifecycleEmitter(options, observation) {
+	return new LifecycleEmitter(options, observation);
 }
-var WorkflowLifecycleEmitter = class {
+var LifecycleEmitter = class {
 	#options;
 	#observation;
 	constructor(options, observation) {
@@ -17,7 +17,7 @@ var WorkflowLifecycleEmitter = class {
 			reason: run.lastTransitionReason,
 			timestamp: run.lastTransitionAt,
 			workflowName: run.workflowName,
-			...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion }
+			workflowVersion: run.workflowVersion
 		};
 		this.#observation?.emitRunEvent(run, previousRun);
 		const callbacks = [];
@@ -35,4 +35,4 @@ var WorkflowLifecycleEmitter = class {
 	};
 };
 //#endregion
-export { WorkflowLifecycleEmitter, createWorkflowLifecycleEmitter };
+export { createLifecycleEmitter };

package/dist/engine/lock-replay.d.mts

@@ -1,30 +1,23 @@
-import { RunId } from "../types/run-id.mjs";
-import { StepId } from "../types/step-id.mjs";
-import { LockRecord } from "../types/lock.mjs";
-import "../types/step.mjs";
-import "../types/run.mjs";
+import { RunId } from "../types/ids.mjs";
 import { WorkflowErrorRecord } from "../types/error.mjs";
+import { LockRecord } from "../types/lock.mjs";
+import { DeterministicValueRecordedEvent } from "../types/events.mjs";
 //#region src/engine/lock-replay.d.ts
-declare function requireLockWaitDeadlineReplayMatches(recorded: {
-  readonly stepId: StepId;
-  readonly timestamp: Temporal.Instant;
-  readonly value: unknown;
-}, timeout: number): void;
-declare function requireLockReplayMatches(recorded: LockRecord, expected: {
+export declare function parseLockWaitDeadlineReplay(recorded: DeterministicValueRecordedEvent, timeout: number): Temporal.Instant;
+export declare function requireLockReplayMatches(recorded: LockRecord, expected: {
   readonly key: string;
   readonly holderId: string;
   readonly holderRunId: RunId;
   readonly leaseDuration: number;
 }): void;
-declare function requireLockReleaseReplayMatches(recorded: LockRecord, expected: {
+export declare function requireLockReleaseReplayMatches(recorded: LockRecord, expected: {
   readonly key: string;
   readonly holderId: string;
 }): void;
-declare function requireLockWaitReplayMatches(failedSteps: readonly {
+export declare function requireLockWaitReplayMatches(failedSteps: readonly {
   readonly error: WorkflowErrorRecord;
 }[], expected: {
   readonly key: string;
   readonly wait: boolean;
 }): void;
-//#endregion
-export { requireLockReleaseReplayMatches, requireLockReplayMatches, requireLockWaitDeadlineReplayMatches, requireLockWaitReplayMatches };
+//#endregion

package/dist/engine/lock-replay.mjs

@@ -1,38 +1,25 @@
-import { WorkflowReplayDivergenceError, WorkflowRetryableError } from "../errors/failures.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
+import { matchesWorkflowError } from "../errors/records.mjs";
 import "../errors/mod.mjs";
 //#region src/engine/lock-replay.ts
-function requireLockWaitDeadlineReplayMatches(recorded, timeout) {
-	if (!(recorded.value instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded lock wait deadline ${recorded.stepId} is invalid`, {
-		expectedStepId: recorded.stepId,
-		actualStepId: recorded.stepId
-	});
-	if (recorded.value.since(recorded.timestamp).total({ unit: "millisecond" }) === timeout) return;
-	WorkflowReplayDivergenceError.diverged(`recorded lock wait deadline ${recorded.stepId} does not match replayed waitTimeout`, {
-		expectedStepId: recorded.stepId,
-		actualStepId: recorded.stepId
-	});
+function parseLockWaitDeadlineReplay(recorded, timeout) {
+	if (!(recorded.value instanceof Temporal.Instant)) WorkflowReplayDivergenceError.atStep(recorded.stepId, `recorded lock wait deadline ${recorded.stepId} is invalid`);
+	if (recorded.value.since(recorded.timestamp).total({ unit: "millisecond" }) === timeout) return recorded.value;
+	WorkflowReplayDivergenceError.atStep(recorded.stepId, `recorded lock wait deadline ${recorded.stepId} does not match replayed waitTimeout`);
 }
 function requireLockReplayMatches(recorded, expected) {
 	const recordedLeaseDuration = recorded.leaseExpiresAt.since(recorded.acquiredAt).total({ unit: "millisecond" });
 	if (recorded.key === expected.key && recorded.holderId === expected.holderId && recorded.holderRunId === expected.holderRunId && recordedLeaseDuration === expected.leaseDuration) return;
-	WorkflowReplayDivergenceError.diverged(`recorded lock step ${recorded.holderStepId ?? recorded.key} does not match replayed lock acquisition`, {
-		expectedStepId: recorded.holderStepId,
-		actualStepId: recorded.holderStepId
-	});
+	WorkflowReplayDivergenceError.atStep(recorded.holderStepId, `recorded lock step ${recorded.holderStepId ?? recorded.key} does not match replayed lock acquisition`);
 }
 function requireLockReleaseReplayMatches(recorded, expected) {
 	if (recorded.key === expected.key && recorded.holderId === expected.holderId && recorded.releasedAt !== void 0) return;
-	WorkflowReplayDivergenceError.diverged(`recorded lock step ${recorded.holderStepId ?? recorded.key} does not match replayed lock release`, {
-		expectedStepId: recorded.holderStepId,
-		actualStepId: recorded.holderStepId
-	});
+	WorkflowReplayDivergenceError.atStep(recorded.holderStepId, `recorded lock step ${recorded.holderStepId ?? recorded.key} does not match replayed lock release`);
 }
 function requireLockWaitReplayMatches(failedSteps, expected) {
-	if (!failedSteps.some((failed) => WorkflowRetryableError.isLockAlreadyHeld(failed.error, expected.key)) || expected.wait) return;
-	WorkflowReplayDivergenceError.diverged(`recorded lock ${expected.key} waited but replayed lock acquisition does not allow waiting`, {
-		expectedStepId: `run:${expected.key}`,
-		actualStepId: `run:${expected.key}`
-	});
+	if (!failedSteps.some((failed) => matchesWorkflowError(failed.error, WorkflowErrorCode.LOCK_ALREADY_HELD, { key: expected.key })) || expected.wait) return;
+	WorkflowReplayDivergenceError.atStep(`run:${expected.key}`, `recorded lock ${expected.key} waited but replayed lock acquisition does not allow waiting`);
 }
 //#endregion
-export { requireLockReleaseReplayMatches, requireLockReplayMatches, requireLockWaitDeadlineReplayMatches, requireLockWaitReplayMatches };
+export { parseLockWaitDeadlineReplay, requireLockReleaseReplayMatches, requireLockReplayMatches, requireLockWaitReplayMatches };