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

package/dist/engine/replay.mjs

@@ -1,9 +1,9 @@
-import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
 import { workflowAttributePatchFromEvent } from "../attributes.mjs";
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
 import "../errors/mod.mjs";
-import { WorkflowSuspended } from "./state.mjs";
-import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
-import { appendDurableStepStartedEvent, appendDurableStepTerminalEvent } from "./durable-command.mjs";
+import { Suspended } from "./signals.mjs";
+import { resolveCommandIdentity } from "./command-identity.mjs";
+import { appendDurableEvent, appendDurableStepStartedEvent } from "./durable-command.mjs";
 import { deepEquals } from "@temelj/value";
 //#region src/engine/replay.ts
 function isRunStepTerminalForStartedAttempt(terminal, started) {
@@ -11,10 +11,7 @@ function isRunStepTerminalForStartedAttempt(terminal, started) {
 }
 function requireRecordedDurableStepStarted(identity, started) {
 	if (started) return;
-	WorkflowReplayDivergenceError.diverged(`recorded ${identity.kind} step ${identity.id} has a terminal event without a started event`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	WorkflowReplayDivergenceError.atStep(identity.id, `recorded ${identity.kind} step ${identity.id} has a terminal event without a started event`);
 }
 function requireRecordedDurableTerminalStarted(identity, hasStartedEventBeforeTerminal) {
 	requireRecordedDurableStepStarted(identity, hasStartedEventBeforeTerminal);
@@ -23,10 +20,7 @@ function requireRunStepReplayTimeoutMatches(identity, started, config) {
 	if (started === void 0 || started.timeoutAt === void 0 === (config.timeout === void 0)) return;
 	const recordedTimeout = started.timeoutAt === void 0 ? "no timeout" : started.timeoutAt.toString();
 	const replayTimeout = config.timeout === void 0 ? "no timeout" : "a timeout";
-	WorkflowReplayDivergenceError.diverged(`recorded run step ${identity.id} had ${recordedTimeout}, but replay used ${replayTimeout}`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	WorkflowReplayDivergenceError.atStep(identity.id, `recorded run step ${identity.id} had ${recordedTimeout}, but replay used ${replayTimeout}`);
 }
 function requireMetadataReplayMatches(identity, recorded, metadata) {
 	if (deepEquals(recorded.metadata, metadata)) return;
@@ -49,74 +43,56 @@ function requireMessageSendReplayMatches(identity, started, terminal, next) {
 	const recordedIdempotencyKey = started?.idempotencyKey;
 	if (recordedTargetRunId === next.targetRunId && recordedMessage === next.messageId && deepEquals(recordedPayload, next.payload) && recordedIdempotencyKey === next.idempotencyKey) return;
 	const message = recordedTargetRunId === next.targetRunId && recordedMessage === next.messageId ? `recorded message-send step ${identity.id} targeted ${recordedTargetRunId} messageId ${recordedMessage} with different payload or idempotency key` : `recorded message-send step ${identity.id} targeted ${recordedTargetRunId} messageId ${recordedMessage}, but replay targeted ${next.targetRunId} messageId ${next.messageId}`;
-	WorkflowReplayDivergenceError.diverged(message, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	WorkflowReplayDivergenceError.atStep(identity.id, message);
 }
 async function sleepUntil(environment, name, initialUntil, options) {
 	const { history, now } = environment;
-	const identity = resolveWorkflowCommandIdentity(history, "sleep", name);
+	const identity = resolveCommandIdentity(history, "sleep", name);
 	const started = history.startedSleep(identity.id);
 	const completed = history.completedSleep(identity.id);
 	if (completed !== void 0) {
 		requireRecordedDurableStepStarted(identity, history.hasStartedEventBeforeTerminalEvent(completed));
 		requireSleepReplayMatches(identity, started, initialUntil, options);
-		if (!(completed.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} has invalid completion timestamp: ` + String(completed.timestamp), {
-			expectedStepId: identity.id,
-			actualStepId: identity.id
-		});
+		recordedInstant("sleep", identity, "completion", completed.timestamp);
 		return;
 	}
-	const until = started === void 0 ? initialUntil : recordedSleepUntil(identity, started.until);
+	const until = started === void 0 ? initialUntil : recordedInstant("sleep", identity, "wake", started.until);
 	requireSleepReplayMatches(identity, started, initialUntil, options);
-	if (started === void 0) await appendDurableStepStartedEvent(environment, {
-		kind: "sleep_started",
-		timestamp: now(),
-		stepId: identity.id,
-		stepName: identity.name,
-		count: identity.count,
-		until,
-		...options.duration === void 0 ? {} : { duration: options.duration }
-	});
-	if (Temporal.Instant.compare(until, now()) > 0) WorkflowSuspended.until(until);
-	await appendDurableStepTerminalEvent(environment, {
+	if (started === void 0) {
+		const event = {
+			kind: "sleep_started",
+			timestamp: now(),
+			stepId: identity.id,
+			stepName: identity.name,
+			count: identity.count,
+			until,
+			duration: options.duration
+		};
+		await appendDurableStepStartedEvent(environment, event);
+	}
+	if (Temporal.Instant.compare(until, now()) > 0) Suspended.until(until);
+	await appendDurableEvent(environment, {
 		kind: "sleep_completed",
 		timestamp: now(),
 		stepId: identity.id,
 		stepName: identity.name
 	});
 }
-function recordedStepCompletionTimestamp(identity, value) {
-	if (value instanceof Temporal.Instant) return value;
-	WorkflowReplayDivergenceError.diverged(`recorded run step ${identity.id} has invalid completion timestamp: ${String(value)}`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
-}
-function recordedSleepUntil(identity, value) {
-	if (value instanceof Temporal.Instant) return value;
-	WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} has invalid wake timestamp: ${String(value)}`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
-}
 function requireSleepReplayMatches(identity, started, until, options) {
 	if (started === void 0) return;
 	if (started.duration !== void 0 || options.duration !== void 0) {
 		if (started.duration === void 0 || options.duration === void 0) {
 			if (started.duration === options.duration) return;
 		} else if (started.duration.toString() === options.duration.toString()) return;
-		WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} waited for ${String(started.duration)}ms, but replay waited for ${String(options.duration)}ms`, {
-			expectedStepId: identity.id,
-			actualStepId: identity.id
-		});
+		WorkflowReplayDivergenceError.atStep(identity.id, `recorded sleep step ${identity.id} waited for ${String(started.duration)}ms, but replay waited for ${String(options.duration)}ms`);
 	}
 	if (Temporal.Instant.compare(started.until, until) === 0) return;
-	WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} waited until ${started.until.toString()}, but replay waited until ${until.toString()}`, {
-		expectedStepId: identity.id,
-		actualStepId: identity.id
-	});
+	WorkflowReplayDivergenceError.atStep(identity.id, `recorded sleep step ${identity.id} waited until ${started.until.toString()}, but replay waited until ${until.toString()}`);
+}
+/** A timestamp read from history; anything else in its place is a replay divergence. */
+function recordedInstant(kind, identity, label, value) {
+	if (value instanceof Temporal.Instant) return value;
+	WorkflowReplayDivergenceError.atStep(identity.id, `recorded ${kind} step ${identity.id} has invalid ${label} timestamp: ${String(value)}`);
 }
 //#endregion
-export { isRunStepTerminalForStartedAttempt, recordedStepCompletionTimestamp, requireAttributesReplayMatches, requireMessageSendReplayMatches, requireMetadataReplayMatches, requireRecordedDurableStepStarted, requireRecordedDurableTerminalStarted, requireRunStepReplayTimeoutMatches, sleepUntil };
+export { isRunStepTerminalForStartedAttempt, recordedInstant, requireAttributesReplayMatches, requireMessageSendReplayMatches, requireMetadataReplayMatches, requireRecordedDurableStepStarted, requireRecordedDurableTerminalStarted, requireRunStepReplayTimeoutMatches, sleepUntil };

package/dist/engine/resume.d.mts

@@ -0,0 +1,16 @@
+import { RunId } from "../types/ids.mjs";
+import { WorkflowImplementation } from "../types/definition.mjs";
+import { ExecutionResult } from "../types/result.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { ResumeOptions } from "../types/run-options.mjs";
+import { EngineContext } from "./context.mjs";
+import { ExecutionServiceOptions } from "./execution-service.mjs";
+//#region src/engine/resume.d.ts
+export interface ResumeRunServices {
+  readonly context: EngineContext;
+  readonly executionService: ExecutionServiceOptions;
+  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previous?: RunRecord) => Promise<ExecutionResult<TOutput>>;
+}
+/** Runs a stored run until it finishes or waits, unless it is done, past its deadline, or not due. */
+export declare function resumeRun<TInput, TOutput, TRawInput = TInput>(services: ResumeRunServices, implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, runId: RunId, resumeOptions?: ResumeOptions): Promise<ExecutionResult<TOutput>>;
+//#endregion

package/dist/engine/resume.mjs

@@ -0,0 +1,24 @@
+import { getRequiredRun } from "../store/query.mjs";
+import { failRunForDeadline, requireDefinitionMatchesRun } from "./state.mjs";
+import { makeCanceledRunResult, makeCompletedRunResult } from "./run-utils.mjs";
+import { executeRun } from "./execution-service.mjs";
+//#region src/engine/resume.ts
+/** Runs a stored run until it finishes or waits, unless it is done, past its deadline, or not due. */
+async function resumeRun(services, implementation, runId, resumeOptions) {
+	const { context } = services;
+	const run = await getRequiredRun(context.store, runId);
+	requireDefinitionMatchesRun(implementation.definition, run);
+	if (run.status === "completed") return makeCompletedRunResult(implementation.definition, run);
+	if (run.status === "canceled") return makeCanceledRunResult(run);
+	const timestamp = context.now();
+	if (run.deadlineAt !== void 0 && Temporal.Instant.compare(run.deadlineAt, timestamp) <= 0) return await services.emitResultLifecycleEvent(await failRunForDeadline(context.store, implementation.definition, run, run.deadlineAt, timestamp), run);
+	const availableAt = run.availableAt;
+	if (availableAt !== void 0 && Temporal.Instant.compare(availableAt, timestamp) > 0) return {
+		kind: "waiting",
+		run,
+		availableAt
+	};
+	return await executeRun(services.executionService, implementation, run, resumeOptions);
+}
+//#endregion
+export { resumeRun };

package/dist/engine/retry.d.mts

@@ -1,23 +1,19 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowMissingImplementationRetryConfig, WorkflowMissingImplementationRetryDefaults, WorkflowResolvedMissingImplementationRetryConfig, WorkflowResolvedRetryConfig, WorkflowResolvedRetryDefaults, WorkflowResolvedStepRetryConfig, WorkflowRetryConfig } from "../types/retry.mjs";
-import { WorkflowStepRunWorkflowOptions } from "../types/step.mjs";
-import "../types/run.mjs";
+import { RunId } from "../types/ids.mjs";
+import { MissingImplementationRetryConfig, MissingImplementationRetryDefaults, ResolvedMissingImplementationRetryConfig, ResolvedRetryConfig, ResolvedRetryDefaults, RetryConfig } from "../types/retry.mjs";
+import { StepRunWorkflowOptions } from "../types/step.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
+import { ExecutionLimits } from "../types/engine-options.mjs";
+import { History } from "../history/replay.mjs";
 //#region src/engine/retry.d.ts
-interface WorkflowEngineRetryLimits {
-  readonly maximumEventHistoryEvents?: number;
-}
 /** Resolves retry options and merges them with defaults used by workflow or step execution. */
-declare function resolveWorkflowRetryConfig(config: WorkflowRetryConfig | undefined, defaults: WorkflowResolvedRetryDefaults, label: string): WorkflowResolvedRetryConfig;
+export declare function resolveRetryConfig(config: RetryConfig | undefined, defaults: ResolvedRetryDefaults, label: string): ResolvedRetryConfig;
 /** Resolves missing-implementation retry options and merges them with worker defaults. */
-declare function resolveMissingImplementationRetryConfig(config: WorkflowMissingImplementationRetryConfig | undefined, defaults: WorkflowMissingImplementationRetryDefaults, label: string): WorkflowResolvedMissingImplementationRetryConfig;
-declare function resolveChildWorkflowRetryConfig(options: WorkflowStepRunWorkflowOptions | undefined): WorkflowResolvedStepRetryConfig;
-declare function shouldRetryWorkflowAttempt(retry: WorkflowResolvedRetryConfig, failedAttempt: number): boolean;
-declare function nextWorkflowRetryAttempt(failedAttempt: number): number;
-declare function enforceStepAttemptBudget(runId: RunId, history: WorkflowHistory, maximumStepAttemptsPerRun: number): void;
-declare function enforceWorkflowEventHistoryNextLimit(events: readonly EventRecord[], limits: WorkflowEngineRetryLimits): void;
-declare function nextRetryAt(failedAt: Temporal.Instant, retry: WorkflowResolvedRetryConfig, failedAttempt: number, label: string): Temporal.Instant | undefined;
-declare function retryClassificationRetryAt(failedAt: Temporal.Instant, error: unknown, label: string): Temporal.Instant | undefined;
-//#endregion
-export { enforceStepAttemptBudget, enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveChildWorkflowRetryConfig, resolveMissingImplementationRetryConfig, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt };
+export declare function resolveMissingImplementationRetryConfig(config: MissingImplementationRetryConfig | undefined, defaults: MissingImplementationRetryDefaults, label: string): ResolvedMissingImplementationRetryConfig;
+export declare function resolveChildWorkflowRetryConfig(options: StepRunWorkflowOptions | undefined): ResolvedRetryConfig;
+export declare function shouldRetryAttempt(retry: ResolvedRetryConfig, failedAttempt: number): boolean;
+export declare function nextRetryAttempt(failedAttempt: number): number;
+export declare function enforceStepAttemptBudget(runId: RunId, history: History, maximumStepAttemptsPerRun: number): void;
+export declare function enforceEventHistoryNextLimit(events: readonly EventRecord[], limits: ExecutionLimits): void;
+export declare function nextRetryAt(failedAt: Temporal.Instant, retry: ResolvedRetryConfig, failedAttempt: number, label: string): Temporal.Instant | undefined;
+export declare function retryClassificationRetryAt(failedAt: Temporal.Instant, cause: unknown, label: string): Temporal.Instant | undefined;
+//#endregion

package/dist/engine/retry.mjs

@@ -1,22 +1,22 @@
 import { WorkflowOptionsError } from "../errors/base.mjs";
 import { WorkflowDurationError, WorkflowRetryableError, WorkflowSerializationError } from "../errors/failures.mjs";
-import { durationAmount, isPositiveSafeInteger, nextPositiveSafeInteger, resolveSafeRetryDelay } from "../utility.mjs";
 import { WorkflowStepAttemptLimitError } from "../errors/step.mjs";
 import "../errors/mod.mjs";
+import { durationAmount, isPositiveSafeInteger, nextPositiveSafeInteger, resolveSafeRetryDelay } from "../values.mjs";
 //#region src/engine/retry.ts
 const DEFAULT_STEP_RETRY_CONFIG = {
 	maximumAttempts: 10,
 	backoffCoefficient: 2
 };
 /** Resolves retry options and merges them with defaults used by workflow or step execution. */
-function resolveWorkflowRetryConfig(config, defaults, label) {
+function resolveRetryConfig(config, defaults, label) {
 	const input = config ?? {};
 	if (input.initialInterval !== void 0 && input.maximumInterval !== void 0 && Temporal.Duration.compare(input.maximumInterval, input.initialInterval) < 0) WorkflowOptionsError.retryMaximumIntervalTooSmall(label);
 	return {
 		maximumAttempts: input.maximumAttempts ?? defaults.maximumAttempts,
-		...input.initialInterval === void 0 ? {} : { initialInterval: input.initialInterval },
+		initialInterval: input.initialInterval,
 		backoffCoefficient: input.backoffCoefficient ?? defaults.backoffCoefficient,
-		...input.maximumInterval === void 0 ? {} : { maximumInterval: input.maximumInterval }
+		maximumInterval: input.maximumInterval
 	};
 }
 /** Resolves missing-implementation retry options and merges them with worker defaults. */
@@ -29,7 +29,7 @@ function resolveMissingImplementationRetryConfig(config, defaults, label) {
 		initialInterval,
 		backoffCoefficient: input.backoffCoefficient ?? defaults.backoffCoefficient,
 		maximumAttempts: input.maximumAttempts ?? defaults.maximumAttempts,
-		...maximumInterval === void 0 ? {} : { maximumInterval }
+		maximumInterval
 	};
 }
 function resolveChildWorkflowRetryConfig(options) {
@@ -37,12 +37,12 @@ function resolveChildWorkflowRetryConfig(options) {
 		maximumAttempts: 1,
 		backoffCoefficient: DEFAULT_STEP_RETRY_CONFIG.backoffCoefficient
 	};
-	return resolveWorkflowRetryConfig(options.retry, DEFAULT_STEP_RETRY_CONFIG, "Workflow step retry");
+	return resolveRetryConfig(options.retry, DEFAULT_STEP_RETRY_CONFIG, "Workflow step retry");
 }
-function shouldRetryWorkflowAttempt(retry, failedAttempt) {
+function shouldRetryAttempt(retry, failedAttempt) {
 	return retry.maximumAttempts === 0 || failedAttempt < retry.maximumAttempts;
 }
-function nextWorkflowRetryAttempt(failedAttempt) {
+function nextRetryAttempt(failedAttempt) {
 	const nextAttempt = nextPositiveSafeInteger(failedAttempt);
 	if (nextAttempt === void 0) WorkflowOptionsError.positiveSafeInteger("Workflow retry next attempt");
 	return nextAttempt;
@@ -50,7 +50,7 @@ function nextWorkflowRetryAttempt(failedAttempt) {
 function enforceStepAttemptBudget(runId, history, maximumStepAttemptsPerRun) {
 	if (history.totalStartedStepCount() >= maximumStepAttemptsPerRun) WorkflowStepAttemptLimitError.exceeded(runId, maximumStepAttemptsPerRun);
 }
-function enforceWorkflowEventHistoryNextLimit(events, limits) {
+function enforceEventHistoryNextLimit(events, limits) {
 	if (limits.maximumEventHistoryEvents !== void 0 && events.length >= limits.maximumEventHistoryEvents) WorkflowSerializationError.notSerializable("workflow event history", `event count would exceed maximumEventHistoryEvents ${limits.maximumEventHistoryEvents}`);
 }
 function nextRetryAt(failedAt, retry, failedAttempt, label) {
@@ -60,16 +60,16 @@ function nextRetryAt(failedAt, retry, failedAttempt, label) {
 	const cappedDelay = retry.maximumInterval === void 0 ? exponentialDelay : Math.min(exponentialDelay, durationAmount(retry.maximumInterval, label));
 	return failedAt.add(Temporal.Duration.from({ milliseconds: resolveSafeRetryDelay(cappedDelay, label) }));
 }
-function retryClassificationRetryAt(failedAt, error, label) {
-	if (!(error instanceof WorkflowRetryableError)) return;
-	if (error.retryAt !== void 0) {
-		if (!(error.retryAt instanceof Temporal.Instant)) WorkflowDurationError.retryAtInstant(label);
-		return error.retryAt;
+function retryClassificationRetryAt(failedAt, cause, label) {
+	if (!(cause instanceof WorkflowRetryableError)) return;
+	if (cause.retryAt !== void 0) {
+		if (!(cause.retryAt instanceof Temporal.Instant)) throw new WorkflowDurationError(`${label} retryAt must be a Temporal.Instant`);
+		return cause.retryAt;
 	}
-	if (error.retryDelay !== void 0) {
-		const retryDelay = durationAmount(error.retryDelay, label);
+	if (cause.retryDelay !== void 0) {
+		const retryDelay = durationAmount(cause.retryDelay, label);
 		return failedAt.add(Temporal.Duration.from({ milliseconds: resolveSafeRetryDelay(retryDelay, label) }));
 	}
 }
 //#endregion
-export { enforceStepAttemptBudget, enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveChildWorkflowRetryConfig, resolveMissingImplementationRetryConfig, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt };
+export { enforceEventHistoryNextLimit, enforceStepAttemptBudget, nextRetryAt, nextRetryAttempt, resolveChildWorkflowRetryConfig, resolveMissingImplementationRetryConfig, resolveRetryConfig, retryClassificationRetryAt, shouldRetryAttempt };

package/dist/engine/run-data.d.mts

@@ -1,9 +1,5 @@
-import { WorkflowStepRunDataApi } from "../types/step.mjs";
-import { WorkflowAttributePatch } from "../types/run.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { StepRunDataApi } from "../types/step.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/run-data.d.ts
-declare function createWorkflowRunDataApi(environment: WorkflowExecutionEnvironment): WorkflowStepRunDataApi;
-declare function setWorkflowRunMetadata(environment: WorkflowExecutionEnvironment, commandId: string, metadata: unknown): Promise<void>;
-declare function setWorkflowRunAttributes(environment: WorkflowExecutionEnvironment, commandId: string, attributes: WorkflowAttributePatch): Promise<void>;
-//#endregion
-export { createWorkflowRunDataApi, setWorkflowRunAttributes, setWorkflowRunMetadata };
+export declare function createRunDataApi(environment: ExecutionEnvironment): StepRunDataApi;
+//#endregion

package/dist/engine/run-data.mjs

@@ -1,22 +1,24 @@
-import { normalizeWorkflowAttributePatch, workflowAttributeEventPatch, workflowAttributePatchFromEvent } from "../attributes.mjs";
+import { normalizeAttributePatch, workflowAttributeEventPatch, workflowAttributePatchFromEvent } from "../attributes.mjs";
 import { toPersistedValue } from "./serialization.mjs";
-import { WorkflowStaleExecutionError, appendEventIfCurrentExecution, patchCurrentExecutionRun, patchCurrentExecutionRunAttributes } from "./state.mjs";
-import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
+import { StaleExecutionError } from "./signals.mjs";
+import { patchCurrentExecutionRun, patchCurrentExecutionRunAttributes } from "./state.mjs";
+import { resolveCommandIdentity } from "./command-identity.mjs";
+import { appendDurableEvent } from "./durable-command.mjs";
 import { requireAttributesReplayMatches, requireMetadataReplayMatches } from "./replay.mjs";
 //#region src/engine/run-data.ts
-function createWorkflowRunDataApi(environment) {
+function createRunDataApi(environment) {
 	return {
 		async setMetadata(commandId, metadata) {
-			await setWorkflowRunMetadata(environment, commandId, metadata);
+			await setRunMetadata(environment, commandId, metadata);
 		},
 		async setAttributes(commandId, attributes) {
-			await setWorkflowRunAttributes(environment, commandId, attributes);
+			await recordRunAttributes(environment, commandId, attributes);
 		}
 	};
 }
-async function setWorkflowRunMetadata(environment, commandId, metadata) {
-	const { store, runId, history, now, limits, executionOwner } = environment;
-	const identity = resolveWorkflowCommandIdentity(history, "metadata", commandId);
+async function setRunMetadata(environment, commandId, metadata) {
+	const { store, history, now, limits, executionOwner } = environment;
+	const identity = resolveCommandIdentity(history, "metadata", commandId);
 	const persistedMetadata = toPersistedValue(metadata, "workflow run metadata", limits);
 	const recorded = history.metadataSet(identity.id);
 	if (recorded !== void 0) {
@@ -25,51 +27,51 @@ async function setWorkflowRunMetadata(environment, commandId, metadata) {
 			metadata: recorded.metadata,
 			updatedAt: recorded.timestamp
 		});
-		if (updated === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
+		if (updated === void 0) StaleExecutionError.stale(executionOwner.id);
 		Object.assign(executionOwner, updated);
 		return;
 	}
 	const timestamp = now();
-	await appendEventIfCurrentExecution(store, history, {
+	await appendDurableEvent(environment, {
 		kind: "metadata_set",
 		timestamp,
 		stepId: identity.id,
 		stepName: identity.name,
 		count: identity.count,
 		metadata: persistedMetadata
-	}, executionOwner, limits, void 0, (event, events) => environment.observeDurableEventAppended?.(runId, event, events));
+	});
 	const updated = await patchCurrentExecutionRun(store, executionOwner, {
 		metadata: persistedMetadata,
 		updatedAt: timestamp
 	});
-	if (updated === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
+	if (updated === void 0) StaleExecutionError.stale(executionOwner.id);
 	Object.assign(executionOwner, updated);
 }
-async function setWorkflowRunAttributes(environment, commandId, attributes) {
-	const { store, runId, history, now, limits, executionOwner } = environment;
-	const identity = resolveWorkflowCommandIdentity(history, "attributes", commandId);
-	const normalized = normalizeWorkflowAttributePatch(attributes);
+async function recordRunAttributes(environment, commandId, attributes) {
+	const { store, history, now, executionOwner } = environment;
+	const identity = resolveCommandIdentity(history, "attributes", commandId);
+	const normalized = normalizeAttributePatch(attributes);
 	const recorded = history.attributesSet(identity.id);
 	if (recorded !== void 0) {
 		requireAttributesReplayMatches(identity, recorded, normalized);
 		const recordedPatch = workflowAttributePatchFromEvent(recorded);
 		const updated = await patchCurrentExecutionRunAttributes(store, executionOwner, recordedPatch, recorded.timestamp);
-		if (updated === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
+		if (updated === void 0) StaleExecutionError.stale(executionOwner.id);
 		Object.assign(executionOwner, updated);
 		return;
 	}
 	const timestamp = now();
-	await appendEventIfCurrentExecution(store, history, {
+	await appendDurableEvent(environment, {
 		kind: "attributes_set",
 		timestamp,
 		stepId: identity.id,
 		stepName: identity.name,
 		count: identity.count,
 		...workflowAttributeEventPatch(normalized)
-	}, executionOwner, limits, void 0, (event, events) => environment.observeDurableEventAppended?.(runId, event, events));
+	});
 	const updated = await patchCurrentExecutionRunAttributes(store, executionOwner, normalized, timestamp);
-	if (updated === void 0) WorkflowStaleExecutionError.stale(executionOwner.id);
+	if (updated === void 0) StaleExecutionError.stale(executionOwner.id);
 	Object.assign(executionOwner, updated);
 }
 //#endregion
-export { createWorkflowRunDataApi, setWorkflowRunAttributes, setWorkflowRunMetadata };
+export { createRunDataApi };

package/dist/engine/run-service.d.mts

@@ -1,38 +1,29 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.mjs";
+import { CleanupRunsOptions, CleanupRunsResult, RetentionPolicyOptions } from "../types/cleanup.mjs";
 import { WorkflowDefinition } from "../types/definition.mjs";
-import { WorkflowHandle } from "../types/result.mjs";
-import { WorkflowAttributePatch, WorkflowRunRecord, WorkflowRunWorkflowName, WorkflowRunWorkflowVersion } from "../types/run.mjs";
-import { WorkflowMarkRunPermanentlyFailedOptions, WorkflowReleaseStaleLeaseOptions, WorkflowRerunOptions, WorkflowRescheduleRunOptions, WorkflowRetryFailedRunOptions, WorkflowStartOptions } from "../types/run-options.mjs";
-import { WorkflowEventReader, WorkflowLockConditionalWriterRepository, WorkflowLockListerRepository, WorkflowRunReaderRepository, WorkflowRunWriterRepository, WorkflowStepAttemptLookup } from "../types/store.mjs";
+import { AttributePatch, RunRecord } from "../types/run.mjs";
+import { MarkRunPermanentlyFailedOptions, ReleaseStaleLeaseOptions, RerunOptions, RescheduleRunOptions, RetryFailedRunOptions, StartOptions } from "../types/run-options.mjs";
+import { EngineContext } from "./context.mjs";
+import { RunRef } from "./start.mjs";
+import { WorkflowEngine } from "./create.mjs";
+import { StorageValue } from "@temelj/storage";
 //#region src/engine/run-service.d.ts
-type WorkflowRunServiceStore = WorkflowRunReaderRepository & WorkflowRunWriterRepository & WorkflowEventReader & WorkflowStepAttemptLookup & WorkflowLockListerRepository & WorkflowLockConditionalWriterRepository;
-interface WorkflowRunServiceOptions {
-  readonly store: WorkflowRunServiceStore;
-  readonly now: () => Temporal.Instant;
-  readonly limits: {
-    readonly maximumPersistedValueBytes?: number;
-  };
+interface RunLifecycleEmitter {
+  readonly emitLifecycleEvent: (next: RunRecord, previous: RunRecord) => void | Promise<void>;
 }
-interface WorkflowRunLifecycleEmitter {
-  readonly emitLifecycleEvent: (next: WorkflowRunRecord, previous: WorkflowRunRecord) => void | Promise<void>;
+interface RunMetadataUpdateEmitter {
+  readonly emitRunMetadataUpdated: (next: RunRecord, previous: RunRecord) => void;
 }
-interface WorkflowRunMetadataUpdateEmitter {
-  readonly emitRunMetadataUpdated: (next: WorkflowRunRecord, previous: WorkflowRunRecord) => void;
-}
-declare function rerunWorkflowRun(service: WorkflowRunServiceOptions, startWorkflow: <TOutput = unknown>(definition: WorkflowDefinition<unknown, TOutput, unknown>, input: unknown, options?: WorkflowStartOptions) => Promise<WorkflowHandle<TOutput>>, runId: RunId, rerunOptions: WorkflowRerunOptions | undefined): Promise<WorkflowHandle<unknown>>;
-declare function resolveRerunWorkflowDefinition(sourceRun: WorkflowRerunSourceRun, options: WorkflowRerunOptions | undefined): Promise<WorkflowDefinition<unknown, unknown, unknown>>;
-interface WorkflowRerunSourceRun {
-  readonly workflowName: WorkflowRunWorkflowName;
-  readonly workflowVersion?: WorkflowRunWorkflowVersion;
-}
-declare function rescheduleWorkflowRun(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunLifecycleEmitter, runId: RunId, rescheduleOptions: WorkflowRescheduleRunOptions | undefined): Promise<WorkflowRunRecord>;
-declare function releaseStaleWorkflowRunLease(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunLifecycleEmitter, runId: RunId, releaseOptions: WorkflowReleaseStaleLeaseOptions | undefined): Promise<WorkflowRunRecord>;
-declare function retryFailedWorkflowRun(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunLifecycleEmitter, runId: RunId, retryOptions: WorkflowRetryFailedRunOptions | undefined): Promise<WorkflowRunRecord>;
-declare function markWorkflowRunPermanentlyFailed(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunLifecycleEmitter, runId: RunId, permanentFailureOptions: WorkflowMarkRunPermanentlyFailedOptions): Promise<WorkflowRunRecord>;
-declare function updateWorkflowRunMetadata(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunMetadataUpdateEmitter, runId: RunId, metadata: unknown): Promise<WorkflowRunRecord>;
-declare function setWorkflowRunAttributes(service: WorkflowRunServiceOptions, runId: RunId, attributes: WorkflowAttributePatch): Promise<WorkflowRunRecord>;
-declare function cancelWorkflowRun(service: WorkflowRunServiceOptions, lifecycle: WorkflowRunLifecycleEmitter, runId: RunId): Promise<WorkflowRunRecord>;
-declare function resolveWorkflowVersion(workflowName: string, fallbackVersion: string | undefined, resolver: ((workflowName: string, definition: WorkflowDefinition<unknown, unknown, unknown>) => string | undefined | Promise<string | undefined>) | undefined): Promise<string | undefined>;
-declare function resolveWorkflowStartSpec<TInput, TOutput, TRawInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: WorkflowStartOptions | undefined): Promise<WorkflowDefinition<TInput, TOutput, TRawInput>>;
+export declare function rerunRun(context: EngineContext, startWorkflow: WorkflowEngine["startWorkflow"], runId: RunId, rerunOptions: RerunOptions | undefined): Promise<RunRef<unknown>>;
+export declare function rescheduleWorkflowRun(context: EngineContext, lifecycle: RunLifecycleEmitter, runId: RunId, rescheduleOptions: RescheduleRunOptions | undefined): Promise<RunRecord>;
+export declare function releaseStaleWorkflowRunLease(context: EngineContext, lifecycle: RunLifecycleEmitter, runId: RunId, releaseOptions: ReleaseStaleLeaseOptions | undefined): Promise<RunRecord>;
+export declare function retryFailedWorkflowRun(context: EngineContext, lifecycle: RunLifecycleEmitter, runId: RunId, retryOptions: RetryFailedRunOptions | undefined): Promise<RunRecord>;
+export declare function markWorkflowRunPermanentlyFailed(context: EngineContext, lifecycle: RunLifecycleEmitter, runId: RunId, permanentFailureOptions: MarkRunPermanentlyFailedOptions): Promise<RunRecord>;
+export declare function updateWorkflowRunMetadata(context: EngineContext, lifecycle: RunMetadataUpdateEmitter, runId: RunId, metadata: StorageValue): Promise<RunRecord>;
+export declare function setRunAttributes(context: EngineContext, runId: RunId, attributes: AttributePatch): Promise<RunRecord>;
+export declare function cancelWorkflowRun(context: EngineContext, lifecycle: RunLifecycleEmitter, runId: RunId): Promise<RunRecord>;
+export declare function resolveStartSpec<TInput, TOutput, TRawInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: StartOptions | undefined): Promise<WorkflowDefinition<TInput, TOutput, TRawInput>>;
+export declare function cleanupRuns(context: EngineContext, options: CleanupRunsOptions): Promise<CleanupRunsResult>;
+export declare function applyRetentionPolicy(context: EngineContext, options: RetentionPolicyOptions): Promise<CleanupRunsResult>;
 //#endregion
-export { cancelWorkflowRun, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rerunWorkflowRun, rescheduleWorkflowRun, resolveRerunWorkflowDefinition, resolveWorkflowStartSpec, resolveWorkflowVersion, retryFailedWorkflowRun, setWorkflowRunAttributes, updateWorkflowRunMetadata };
+export {};