@temelj/workflow 0.0.0-alpha.1

package/dist/engine/create.d.mts

@@ -0,0 +1,106 @@
+import { RunId } from "../types/run-id.mjs";
+import { CleanupMarkerRecord, CleanupRunsOptions, CleanupRunsResult, RetentionPolicyOptions } from "../types/cleanup.mjs";
+import { PageOptions, WorkflowPage } from "../types/pagination.mjs";
+import { ListSchedulesOptions, ListSchedulesPageOptions, ScheduleConfig, ScheduleId, ScheduleRecord, TickSchedulesOptions, TickSchedulesResult } from "../types/schedule.mjs";
+import { WorkflowImplementation, WorkflowStartTarget } from "../types/definition.mjs";
+import { HookInspection, ResumeHookOptions, ResumeWebhookOptions } from "../types/hook.mjs";
+import { AcquireLockOptions, LockRecord, ReleaseLockOptions, ReleaseStaleLockOptions } from "../types/lock.mjs";
+import { WorkflowListRunsOptions, WorkflowListRunsPageOptions, WorkflowListStepAttemptsPageOptions } from "../types/run-list.mjs";
+import { BroadcastMessageChannelOptions, BroadcastMessageInput, BroadcastMessageResult, MessageChannel, SendMessageChannelOptions, SendMessageInput } from "../types/message.mjs";
+import { StreamIdOrName } from "../types/stream-id.mjs";
+import { FollowStreamOptions, ReadStreamOptions, ReadStreamPageOptions, StreamChunk, StreamInfo, StreamPage, StreamState, StreamUpdate, WaitStreamOptions } from "../types/stream.mjs";
+import { WorkflowRecoverySummary, WorkflowRecoverySummaryOptions, WorkflowRunSummary, WorkflowRunSummaryOptions } from "../types/summary.mjs";
+import { WorkflowListStepAttemptsOptions, WorkflowStepAttemptRecord, WorkflowStepAttemptSummary } from "../types/step-attempts.mjs";
+import { ObservationEventHandler, ObservationEventPattern, ObservationUnsubscribe, ScheduleRunCreatedObservationEvent, WorkerOperationObservationEvent } from "../types/observation.mjs";
+import { Timeline } from "../types/timeline.mjs";
+import { ExecutionResult, WorkflowHandle } from "../types/result.mjs";
+import { WorkflowAttributePatch, WorkflowRunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { ScheduleNextOptions, WorkflowBatchStartItem, WorkflowExecutionOptions, WorkflowMarkRunPermanentlyFailedOptions, WorkflowReleaseStaleLeaseOptions, WorkflowRerunOptions, WorkflowRescheduleRunOptions, WorkflowResumeOptions, WorkflowRetryFailedRunOptions, WorkflowStartOptions } from "../types/run-options.mjs";
+import { WorkflowMessageIdempotencyIndex, WorkflowStorage, WorkflowStore } from "../types/store.mjs";
+import { CreateWorkflowEngineOptions } from "../types/engine-options.mjs";
+import { WorkflowEngine as WorkflowEngine$1 } from "../types/engine.mjs";
+import "../mod.mjs";
+//#region src/engine/create.d.ts
+/** Creates workflow engine. */
+declare function createWorkflowEngine(options?: CreateWorkflowEngineOptions): WorkflowEngine$1;
+/** Storage-backed workflow engine implementation used by the default client and runtime. */
+declare class WorkflowEngine implements WorkflowEngine$1 {
+  #private;
+  readonly storage: WorkflowStorage;
+  readonly store: WorkflowStore;
+  constructor(options?: CreateWorkflowEngineOptions);
+  on<Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>): ObservationUnsubscribe;
+  once<Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>): ObservationUnsubscribe;
+  off<Pattern extends ObservationEventPattern>(pattern: Pattern, handler: ObservationEventHandler<Pattern>): void;
+  listeners(): readonly ObservationEventHandler[];
+  listeners<Pattern extends ObservationEventPattern>(pattern: Pattern): readonly ObservationEventHandler<Pattern>[];
+  clearListeners(pattern?: ObservationEventPattern): void;
+  listenerCount(pattern?: ObservationEventPattern): number;
+  close(): Promise<void>;
+  observeWorkerOperation(event: WorkerOperationObservationEvent): void;
+  observeScheduleRunCreated(event: ScheduleRunCreatedObservationEvent): void;
+  startWorkflow<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, input: TRawInput, options?: WorkflowStartOptions): Promise<WorkflowHandle<TOutput>>;
+  startWorkflows<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, items: readonly WorkflowBatchStartItem<TRawInput>[]): Promise<readonly WorkflowHandle<TOutput>[]>;
+  scheduleNextWorkflow<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, input: TRawInput, options: ScheduleNextOptions): Promise<WorkflowHandle<TOutput>>;
+  createSchedule<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, scheduleOptions: ScheduleConfig<TInput, TRawInput>): Promise<ScheduleRecord<TInput>>;
+  upsertSchedule<TInput, TOutput, TRawInput = TInput>(workflow: WorkflowStartTarget<TInput, TOutput, TRawInput>, scheduleOptions: ScheduleConfig<TInput, TRawInput>): Promise<ScheduleRecord<TInput>>;
+  getSchedule(scheduleId: ScheduleId): Promise<ScheduleRecord | undefined>;
+  listSchedules(options?: ListSchedulesOptions): Promise<readonly ScheduleRecord[]>;
+  listSchedulesPage(options?: ListSchedulesPageOptions): Promise<WorkflowPage<ScheduleRecord>>;
+  pauseSchedule(scheduleId: ScheduleId): Promise<ScheduleRecord>;
+  resumeSchedule(scheduleId: ScheduleId): Promise<ScheduleRecord>;
+  archiveSchedule(scheduleId: ScheduleId): Promise<ScheduleRecord>;
+  deleteSchedule(scheduleId: ScheduleId): Promise<ScheduleRecord>;
+  tickSchedules(options?: TickSchedulesOptions): Promise<TickSchedulesResult>;
+  acquireLock(key: string, options: AcquireLockOptions): Promise<LockRecord>;
+  getLock(key: string): Promise<LockRecord | undefined>;
+  listLocks(): Promise<readonly LockRecord[]>;
+  releaseLock(key: string, options: ReleaseLockOptions): Promise<LockRecord>;
+  releaseStaleLock(key: string, options?: ReleaseStaleLockOptions): Promise<LockRecord>;
+  runWorkflow<TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, input: TRawInput, options?: WorkflowExecutionOptions): Promise<WorkflowHandle<TOutput>>;
+  runWorkflowNow<TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, input: TRawInput, options?: WorkflowExecutionOptions): Promise<ExecutionResult<TOutput>>;
+  resumeWorkflow<TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, runId: RunId, options?: WorkflowResumeOptions): Promise<ExecutionResult<TOutput>>;
+  getRun(runId: RunId): Promise<WorkflowRunRecord | undefined>;
+  getEvents(runId: RunId): Promise<readonly EventRecord[]>;
+  listEventsPage(runId: RunId, options?: PageOptions): Promise<WorkflowPage<EventRecord>>;
+  listRuns(options?: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
+  listRunsPage(options?: WorkflowListRunsPageOptions): Promise<WorkflowPage<WorkflowRunRecord>>;
+  countRuns(options?: WorkflowListRunsOptions): Promise<number>;
+  getRunSummary(options?: WorkflowRunSummaryOptions): Promise<WorkflowRunSummary>;
+  getRecoverySummary(options?: WorkflowRecoverySummaryOptions): Promise<WorkflowRecoverySummary>;
+  getTimeline(runId: RunId): Promise<Timeline>;
+  listStepAttempts(runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<readonly WorkflowStepAttemptRecord[]>;
+  listStepAttemptsPage(runId: RunId, options?: WorkflowListStepAttemptsPageOptions): Promise<WorkflowPage<WorkflowStepAttemptRecord>>;
+  countStepAttempts(runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<number>;
+  repairStepAttempts(runId: RunId): Promise<readonly WorkflowStepAttemptRecord[]>;
+  repairMessageIdempotencyIndexes(runId: RunId): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
+  getStepAttemptSummary(runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<WorkflowStepAttemptSummary>;
+  cleanupRuns(options: CleanupRunsOptions): Promise<CleanupRunsResult>;
+  listCleanupMarkers(): Promise<readonly CleanupMarkerRecord[]>;
+  applyRetentionPolicy(retentionOptions: RetentionPolicyOptions): Promise<CleanupRunsResult>;
+  rerunWorkflow(runId: RunId, options?: WorkflowRerunOptions): Promise<WorkflowHandle<unknown>>;
+  rescheduleRun(runId: RunId, options?: WorkflowRescheduleRunOptions): Promise<WorkflowRunRecord>;
+  releaseStaleRunLease(runId: RunId, options?: WorkflowReleaseStaleLeaseOptions): Promise<WorkflowRunRecord>;
+  retryFailedRun(runId: RunId, options?: WorkflowRetryFailedRunOptions): Promise<WorkflowRunRecord>;
+  markRunPermanentlyFailed(runId: RunId, options: WorkflowMarkRunPermanentlyFailedOptions): Promise<WorkflowRunRecord>;
+  updateRunMetadata(runId: RunId, metadata: unknown): Promise<WorkflowRunRecord>;
+  setRunAttributes(runId: RunId, attributes: WorkflowAttributePatch): Promise<WorkflowRunRecord>;
+  cancelRun(runId: RunId): Promise<WorkflowRunRecord>;
+  resumeHook(token: string, options?: ResumeHookOptions): Promise<void>;
+  resumeWebhook(token: string, options?: ResumeWebhookOptions): Promise<void>;
+  disposeHook(token: string): Promise<HookInspection>;
+  disposeWebhook(token: string): Promise<HookInspection>;
+  getHookByToken(token: string): Promise<HookInspection>;
+  getStreamInfo(runId: RunId, streamIdOrName: StreamIdOrName): Promise<StreamInfo>;
+  followStream<TChunk = unknown>(runId: RunId, streamIdOrName: StreamIdOrName, followOptions?: FollowStreamOptions): AsyncIterable<StreamUpdate<TChunk>>;
+  waitForStream(runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+  waitForStreamChunk<TChunk = unknown>(runId: RunId, streamIdOrName: StreamIdOrName, afterIndex: number, waitOptions?: WaitStreamOptions): Promise<StreamChunk<TChunk> | undefined>;
+  waitForStreamTerminal(runId: RunId, streamIdOrName: StreamIdOrName, waitOptions?: WaitStreamOptions): Promise<StreamInfo | undefined>;
+  readStream<TChunk = unknown>(runId: RunId, streamIdOrName: StreamIdOrName, readOptions?: ReadStreamOptions): Promise<StreamState<TChunk>>;
+  readStreamPage<TChunk = unknown>(runId: RunId, streamIdOrName: StreamIdOrName, readOptions?: ReadStreamPageOptions): Promise<StreamPage<TChunk>>;
+  sendMessage<TPayload, TKey = void>(runId: RunId, messageInput: SendMessageInput | MessageChannel<TPayload, TKey>, channelOptions?: SendMessageChannelOptions<TPayload, TKey>): Promise<void>;
+  broadcastMessage<TPayload, TKey = void>(messageInput: BroadcastMessageInput | MessageChannel<TPayload, TKey>, channelOptions?: BroadcastMessageChannelOptions<TPayload, TKey>): Promise<BroadcastMessageResult>;
+}
+//#endregion
+export { WorkflowEngine, createWorkflowEngine };

package/dist/engine/create.mjs

@@ -0,0 +1,402 @@
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { createDefaultRunIdFactory, createDefaultWorkflowRecordedIdFactory } from "../utility.mjs";
+import { defineWorkflowFromTarget } from "../definition.mjs";
+import { readRunResult, retentionCleanupOptions } from "./run-utils.mjs";
+import { cancelWorkflowRun, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rerunWorkflowRun, rescheduleWorkflowRun, retryFailedWorkflowRun, setWorkflowRunAttributes, updateWorkflowRunMetadata } from "./run-service.mjs";
+import { createWorkflowEngineStartApi } from "./start-api.mjs";
+import { createWorkflowStore } from "../store/create.mjs";
+import { instrumentWorkflowStorage } from "../store/instrumentation.mjs";
+import { broadcastWorkflowMessageInput, sendWorkflowMessageInput } from "./message.mjs";
+import { disposeHook, disposeWebhook, getHookByToken, resumeHook, resumeWebhook } from "./hooks.mjs";
+import { acquireLock, releaseLock, releaseStaleLock } from "./lock.mjs";
+import { followStreamForRun, getStreamInfoForRun, readStreamForRun, readStreamPageForRun, waitForStreamChunkForRun, waitForStreamForRun, waitForStreamTerminalForRun } from "./stream.mjs";
+import { createWorkflowEngineExecutionApi } from "./execution-api.mjs";
+import { createWorkflowEngineInspectionApi } from "./inspection-api.mjs";
+import { createWorkflowLifecycleEmitter } from "./lifecycle.mjs";
+import { createObservationEmitter } from "./observation.mjs";
+import { resolveScheduleRecord, tickSchedules, updateScheduleStatus, upsertSchedule } from "./schedule.mjs";
+import { createStorage } from "@temelj/storage";
+import { createNoopLogger } from "@temelj/log";
+//#region src/engine/create.ts
+const MAX_CRYPTO_GET_RANDOM_VALUES_BYTES = 65536;
+function defaultDeterministicRandom() {
+	return Math.random();
+}
+function defaultDeterministicUuid() {
+	return globalThis.crypto.randomUUID();
+}
+function defaultDeterministicBytes(context) {
+	const bytes = new Uint8Array(context.length);
+	for (let offset = 0; offset < bytes.byteLength; offset += MAX_CRYPTO_GET_RANDOM_VALUES_BYTES) {
+		const chunk = bytes.subarray(offset, offset + MAX_CRYPTO_GET_RANDOM_VALUES_BYTES);
+		globalThis.crypto.getRandomValues(chunk);
+	}
+	return bytes;
+}
+/** Creates workflow engine. */
+function createWorkflowEngine(options = {}) {
+	return new WorkflowEngine(options);
+}
+/** Storage-backed workflow engine implementation used by the default client and runtime. */
+var WorkflowEngine = class {
+	storage;
+	store;
+	#now;
+	#limits;
+	#logger;
+	#telemetry;
+	#observation;
+	#startApi;
+	#executionApi;
+	#inspectionApi;
+	#hookService;
+	#messageService;
+	#streamService;
+	#runService;
+	#runLifecycle;
+	constructor(options = {}) {
+		if (options.store !== void 0 && options.storage !== void 0) WorkflowOptionsError.engineStoreAndStorageConflict();
+		const telemetry = options.telemetry === false ? void 0 : options.telemetry;
+		const storage = options.store === void 0 ? instrumentWorkflowStorage(options.storage ?? createStorage(), telemetry) : void 0;
+		this.store = options.store ?? createWorkflowStore({ storage });
+		this.storage = this.store.storage;
+		const now = options.now ?? Temporal.Now.instant;
+		this.#now = now;
+		const createRunId = options.createRunId ?? createDefaultRunIdFactory(now);
+		const createRecordedId = options.createRecordedId ?? createDefaultWorkflowRecordedIdFactory(createRunId);
+		const createDeterministicRandom = options.createDeterministicRandom ?? defaultDeterministicRandom;
+		const createDeterministicUuid = options.createDeterministicUuid ?? defaultDeterministicUuid;
+		const createDeterministicBytes = options.createDeterministicBytes ?? defaultDeterministicBytes;
+		const maximumStepAttemptsPerRun = options.maximumStepAttemptsPerRun ?? 1e3;
+		const limits = {
+			maximumPersistedValueBytes: options.maximumPersistedValueBytes,
+			maximumEventHistoryEvents: options.maximumEventHistoryEvents,
+			maximumStreamChunks: options.maximumStreamChunks
+		};
+		this.#limits = limits;
+		const readCurrentRunResult = async (runId) => await readRunResult(this.store, runId, now());
+		const logger = options.logger === false ? createNoopLogger() : options.logger ?? createNoopLogger();
+		this.#telemetry = telemetry;
+		this.#logger = logger;
+		const observation = createObservationEmitter(telemetry);
+		this.#observation = observation;
+		this.#hookService = {
+			store: this.store,
+			now,
+			limits,
+			emitMessageSent: observation.emitMessageSent,
+			emitHookResumed: observation.emitHookResumed,
+			emitWebhookResumed: observation.emitWebhookResumed,
+			telemetry
+		};
+		this.#messageService = {
+			store: this.store,
+			now,
+			limits,
+			observeMessageSent: observation.emitMessageSent,
+			telemetry
+		};
+		this.#streamService = { store: this.store };
+		this.#runService = {
+			store: this.store,
+			now,
+			limits
+		};
+		const { emitLifecycleEvent, emitResultLifecycleEvent } = createWorkflowLifecycleEmitter(options, observation);
+		this.#runLifecycle = {
+			emitLifecycleEvent,
+			emitRunMetadataUpdated: observation.emitRunMetadataUpdated
+		};
+		this.#inspectionApi = createWorkflowEngineInspectionApi(this.store, now);
+		const executionService = {
+			store: this.store,
+			now,
+			createRecordedId,
+			createDeterministicRandom,
+			createDeterministicUuid,
+			createDeterministicBytes,
+			maximumStepAttemptsPerRun,
+			limits,
+			telemetry,
+			logger,
+			engine: this,
+			readCurrentRunResult,
+			emitResultLifecycleEvent,
+			observeRunEvent: observation.emitRunEvent,
+			observeDurableEventAppended: observation.emitDurableEventAppended,
+			observeMessageSent: observation.emitMessageSent,
+			observeChildWorkflowStarted: (runId, event) => observation.emitChildWorkflowStarted({
+				runId,
+				event
+			})
+		};
+		this.#executionApi = createWorkflowEngineExecutionApi({
+			store: this.store,
+			now,
+			executionService,
+			emitResultLifecycleEvent,
+			starter: this,
+			resumer: this
+		});
+		this.#startApi = createWorkflowEngineStartApi({
+			store: this.store,
+			now,
+			limits,
+			createRunId,
+			telemetry,
+			emitRunEvent: observation.emitRunEvent,
+			starter: this,
+			handleOperations: {
+				getTimeline: async (runId) => await this.getTimeline(runId),
+				setMetadata: async (runId, metadata) => await this.updateRunMetadata(runId, metadata),
+				setAttributes: async (runId, attributes) => await this.setRunAttributes(runId, attributes),
+				cancel: async (runId) => await this.cancelRun(runId)
+			}
+		});
+		try {
+			telemetry?.bindEngine?.(this);
+		} catch {}
+	}
+	on(pattern, handler) {
+		return this.#observation.on(pattern, handler);
+	}
+	once(pattern, handler) {
+		return this.#observation.once(pattern, handler);
+	}
+	off(pattern, handler) {
+		return this.#observation.off(pattern, handler);
+	}
+	listeners(pattern) {
+		return pattern === void 0 ? this.#observation.listeners() : this.#observation.listeners(pattern);
+	}
+	clearListeners(pattern) {
+		return this.#observation.clearListeners(pattern);
+	}
+	listenerCount(pattern) {
+		return this.#observation.listenerCount(pattern);
+	}
+	async close() {
+		const errors = [];
+		try {
+			await this.#logger.close?.();
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			await this.#telemetry?.shutdown?.();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw errors[0];
+	}
+	observeWorkerOperation(event) {
+		this.#observation.emitWorkerOperation(event);
+	}
+	observeScheduleRunCreated(event) {
+		this.#observation.emitScheduleRunCreated(event);
+	}
+	async startWorkflow(workflow, input, options) {
+		return this.#startApi.startWorkflow(workflow, input, options);
+	}
+	async startWorkflows(workflow, items) {
+		return this.#startApi.startWorkflows(workflow, items);
+	}
+	async scheduleNextWorkflow(workflow, input, options) {
+		return this.#startApi.scheduleNextWorkflow(workflow, input, options);
+	}
+	async createSchedule(workflow, scheduleOptions) {
+		const definition = defineWorkflowFromTarget(workflow);
+		const schedule = resolveScheduleRecord(this.store.namespace, definition, scheduleOptions, this.#now(), this.#limits);
+		return this.store.createSchedule(schedule);
+	}
+	async upsertSchedule(workflow, scheduleOptions) {
+		return upsertSchedule(this.store, defineWorkflowFromTarget(workflow), scheduleOptions, this.#now(), this.#limits);
+	}
+	async getSchedule(scheduleId) {
+		return this.store.getSchedule(scheduleId);
+	}
+	async listSchedules(options) {
+		return this.store.listSchedules(options);
+	}
+	async listSchedulesPage(options) {
+		return this.store.listSchedulesPage(options);
+	}
+	async pauseSchedule(scheduleId) {
+		return updateScheduleStatus(this.store, scheduleId, "paused", this.#now());
+	}
+	async resumeSchedule(scheduleId) {
+		return updateScheduleStatus(this.store, scheduleId, "active", this.#now());
+	}
+	async archiveSchedule(scheduleId) {
+		return updateScheduleStatus(this.store, scheduleId, "archived", this.#now());
+	}
+	async deleteSchedule(scheduleId) {
+		return updateScheduleStatus(this.store, scheduleId, "deleted", this.#now());
+	}
+	async tickSchedules(options) {
+		const timestamp = options?.now ?? this.#now();
+		const tickOptions = options === void 0 ? { now: timestamp } : {
+			...options,
+			now: timestamp
+		};
+		const result = await tickSchedules(this.store, this, this.#now, tickOptions);
+		this.#observation.emitScheduleTicked({
+			result,
+			timestamp
+		});
+		return result;
+	}
+	async acquireLock(key, options) {
+		const acquiredAt = options.now === void 0 ? this.#now() : options.now;
+		return acquireLock(this.store, key, options, acquiredAt);
+	}
+	async getLock(key) {
+		return this.store.getLock(key);
+	}
+	async listLocks() {
+		return this.store.listLocks();
+	}
+	async releaseLock(key, options) {
+		const releasedAt = options.now === void 0 ? this.#now() : options.now;
+		return releaseLock(this.store, key, options, releasedAt);
+	}
+	async releaseStaleLock(key, options) {
+		const releasedAt = options?.now === void 0 ? this.#now() : options.now;
+		return releaseStaleLock(this.store, key, releasedAt);
+	}
+	async runWorkflow(implementation, input, options) {
+		return this.#executionApi.runWorkflow(implementation, input, options);
+	}
+	async runWorkflowNow(implementation, input, options) {
+		return this.#executionApi.runWorkflowNow(implementation, input, options);
+	}
+	async resumeWorkflow(implementation, runId, options) {
+		return this.#executionApi.resumeWorkflow(implementation, runId, options);
+	}
+	async getRun(runId) {
+		return this.#inspectionApi.getRun(runId);
+	}
+	async getEvents(runId) {
+		return this.#inspectionApi.getEvents(runId);
+	}
+	async listEventsPage(runId, options) {
+		return this.#inspectionApi.listEventsPage(runId, options);
+	}
+	async listRuns(options) {
+		return this.#inspectionApi.listRuns(options);
+	}
+	async listRunsPage(options) {
+		return this.#inspectionApi.listRunsPage(options);
+	}
+	async countRuns(options) {
+		return this.#inspectionApi.countRuns(options);
+	}
+	async getRunSummary(options) {
+		return this.#inspectionApi.getRunSummary(options);
+	}
+	async getRecoverySummary(options) {
+		return this.#inspectionApi.getRecoverySummary(options);
+	}
+	async getTimeline(runId) {
+		return this.#inspectionApi.getTimeline(runId);
+	}
+	async listStepAttempts(runId, options) {
+		return this.#inspectionApi.listStepAttempts(runId, options);
+	}
+	async listStepAttemptsPage(runId, options) {
+		return this.#inspectionApi.listStepAttemptsPage(runId, options);
+	}
+	async countStepAttempts(runId, options) {
+		return this.#inspectionApi.countStepAttempts(runId, options);
+	}
+	async repairStepAttempts(runId) {
+		return this.#inspectionApi.repairStepAttempts(runId);
+	}
+	async repairMessageIdempotencyIndexes(runId) {
+		return this.#inspectionApi.repairMessageIdempotencyIndexes(runId);
+	}
+	async getStepAttemptSummary(runId, options) {
+		return this.#inspectionApi.getStepAttemptSummary(runId, options);
+	}
+	async cleanupRuns(options) {
+		const result = await this.store.cleanupRuns(options);
+		this.#observation.emitCleanupCompleted(result);
+		return result;
+	}
+	async listCleanupMarkers() {
+		return this.store.listCleanupMarkers();
+	}
+	async applyRetentionPolicy(retentionOptions) {
+		const result = await this.store.cleanupRuns(retentionCleanupOptions(retentionOptions, this.#now));
+		this.#observation.emitRetentionApplied(result);
+		return result;
+	}
+	async rerunWorkflow(runId, options) {
+		return rerunWorkflowRun(this.#runService, async (definition, input, startOptions) => await this.startWorkflow(definition, input, startOptions), runId, options);
+	}
+	async rescheduleRun(runId, options) {
+		return rescheduleWorkflowRun(this.#runService, this.#runLifecycle, runId, options);
+	}
+	async releaseStaleRunLease(runId, options) {
+		return releaseStaleWorkflowRunLease(this.#runService, this.#runLifecycle, runId, options);
+	}
+	async retryFailedRun(runId, options) {
+		return retryFailedWorkflowRun(this.#runService, this.#runLifecycle, runId, options);
+	}
+	async markRunPermanentlyFailed(runId, options) {
+		return markWorkflowRunPermanentlyFailed(this.#runService, this.#runLifecycle, runId, options);
+	}
+	async updateRunMetadata(runId, metadata) {
+		return updateWorkflowRunMetadata(this.#runService, this.#runLifecycle, runId, metadata);
+	}
+	async setRunAttributes(runId, attributes) {
+		return setWorkflowRunAttributes(this.#runService, runId, attributes);
+	}
+	async cancelRun(runId) {
+		return cancelWorkflowRun(this.#runService, this.#runLifecycle, runId);
+	}
+	async resumeHook(token, options) {
+		await resumeHook(token, options, this.#hookService);
+	}
+	async resumeWebhook(token, options) {
+		await resumeWebhook(token, options, this.#hookService);
+	}
+	async disposeHook(token) {
+		return disposeHook(token, this.#hookService);
+	}
+	async disposeWebhook(token) {
+		return disposeWebhook(token, this.#hookService);
+	}
+	async getHookByToken(token) {
+		return getHookByToken(token, this.store, this.#now());
+	}
+	async getStreamInfo(runId, streamIdOrName) {
+		return getStreamInfoForRun(this.#streamService, runId, streamIdOrName);
+	}
+	followStream(runId, streamIdOrName, followOptions) {
+		return followStreamForRun(this.#streamService, runId, streamIdOrName, followOptions);
+	}
+	async waitForStream(runId, streamIdOrName, waitOptions) {
+		return waitForStreamForRun(this.#streamService, runId, streamIdOrName, waitOptions);
+	}
+	async waitForStreamChunk(runId, streamIdOrName, afterIndex, waitOptions) {
+		return waitForStreamChunkForRun(this.#streamService, runId, streamIdOrName, afterIndex, waitOptions);
+	}
+	async waitForStreamTerminal(runId, streamIdOrName, waitOptions) {
+		return waitForStreamTerminalForRun(this.#streamService, runId, streamIdOrName, waitOptions);
+	}
+	async readStream(runId, streamIdOrName, readOptions) {
+		return readStreamForRun(this.#streamService, runId, streamIdOrName, readOptions);
+	}
+	async readStreamPage(runId, streamIdOrName, readOptions) {
+		return readStreamPageForRun(this.#streamService, runId, streamIdOrName, readOptions);
+	}
+	async sendMessage(runId, messageInput, channelOptions) {
+		await sendWorkflowMessageInput(this.#messageService, runId, messageInput, channelOptions);
+	}
+	async broadcastMessage(messageInput, channelOptions) {
+		return broadcastWorkflowMessageInput(this.#messageService, messageInput, channelOptions);
+	}
+};
+//#endregion
+export { WorkflowEngine, createWorkflowEngine };

package/dist/engine/deterministic.d.mts

@@ -0,0 +1,12 @@
+import { StepId } from "../types/step-id.mjs";
+import { WorkflowDeterministicApi, WorkflowStepMetadata } from "../types/step.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+//#region src/engine/deterministic.d.ts
+declare function createWorkflowDeterministicApi(environment: WorkflowExecutionEnvironment): WorkflowDeterministicApi;
+declare function recordWorkflowDeterministicValue<TValue>(environment: WorkflowExecutionEnvironment, name: string, createValue: (identity: WorkflowStepMetadata) => TValue, checkRecorded?: (recorded: {
+  readonly stepId: StepId;
+  readonly timestamp: Temporal.Instant;
+  readonly value: unknown;
+}) => void): Promise<TValue>;
+//#endregion
+export { createWorkflowDeterministicApi, recordWorkflowDeterministicValue };

package/dist/engine/deterministic.mjs

@@ -0,0 +1,102 @@
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
+import { isNonNegativeSafeInteger } from "../utility.mjs";
+import "../errors/mod.mjs";
+import { toPersistedValue } from "./serialization.mjs";
+import { appendEventIfCurrentExecution } from "./state.mjs";
+import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
+//#region src/engine/deterministic.ts
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function createWorkflowDeterministicApi(environment) {
+	const { now, runId } = environment;
+	const api = {
+		async now(commandId = "now") {
+			return await recordWorkflowDeterministicValue(environment, commandId, () => now());
+		},
+		async random(commandId = "random") {
+			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
+				const value = environment.createDeterministicRandom(deterministicValueContext(runId, identity));
+				if (!isDeterministicRandomValue(value)) invalidDeterministicValue(identity.id, "a finite number in [0, 1)");
+				return value;
+			}, (recorded) => {
+				if (!isDeterministicRandomValue(recorded.value)) invalidDeterministicValue(recorded.stepId, "a finite number in [0, 1)");
+			});
+		},
+		async recordedId(commandId = "recorded-id") {
+			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => environment.createRecordedId(deterministicValueContext(runId, identity)));
+		},
+		async id(commandId = "id") {
+			return await api.recordedId(commandId);
+		},
+		async uuid(commandId = "uuid") {
+			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
+				const value = environment.createDeterministicUuid(deterministicValueContext(runId, identity));
+				if (!isDeterministicUuidValue(value)) invalidDeterministicValue(identity.id, "a UUID string");
+				return value;
+			}, (recorded) => {
+				if (!isDeterministicUuidValue(recorded.value)) invalidDeterministicValue(recorded.stepId, "a UUID string");
+			});
+		},
+		async bytes(commandId, length) {
+			if (typeof commandId !== "string") WorkflowOptionsError.string("Workflow deterministic bytes commandId");
+			if (commandId.trim() === "") WorkflowOptionsError.nonBlank("Workflow deterministic bytes commandId");
+			if (!isNonNegativeSafeInteger(length)) WorkflowOptionsError.nonNegativeSafeInteger("Workflow deterministic bytes length");
+			const bytes = await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
+				const value = environment.createDeterministicBytes({
+					...deterministicValueContext(runId, identity),
+					length
+				});
+				if (!isDeterministicBytesValue(value, length)) invalidDeterministicValue(identity.id, `a Uint8Array with length ${length}`);
+				return new Uint8Array(value);
+			}, (recorded) => {
+				if (!isDeterministicBytesValue(recorded.value, length)) invalidDeterministicValue(recorded.stepId, `a Uint8Array with length ${length}`);
+			});
+			return new Uint8Array(bytes);
+		}
+	};
+	return api;
+}
+async function recordWorkflowDeterministicValue(environment, name, createValue, checkRecorded) {
+	const { store, history, now, limits, executionOwner, runId } = environment;
+	const identity = resolveWorkflowCommandIdentity(history, "deterministic", name);
+	const recorded = history.deterministicValue(identity.id);
+	if (recorded !== void 0) {
+		checkRecorded?.(recorded);
+		return recorded.value;
+	}
+	const value = createValue(identity);
+	await appendEventIfCurrentExecution(store, history, {
+		kind: "deterministic_value_recorded",
+		timestamp: now(),
+		stepId: identity.id,
+		stepName: identity.name,
+		count: identity.count,
+		value: toPersistedValue(value, "deterministic value", limits)
+	}, executionOwner, limits, void 0, (event, events) => environment.observeDurableEventAppended?.(runId, event, events));
+	return value;
+}
+function deterministicValueContext(runId, identity) {
+	return {
+		runId,
+		commandId: identity.id,
+		commandName: identity.name,
+		commandCount: identity.count
+	};
+}
+function isDeterministicRandomValue(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value < 1;
+}
+function isDeterministicUuidValue(value) {
+	return typeof value === "string" && UUID_PATTERN.test(value);
+}
+function isDeterministicBytesValue(value, length) {
+	return value instanceof Uint8Array && value.byteLength === length;
+}
+function invalidDeterministicValue(stepId, expected) {
+	WorkflowReplayDivergenceError.diverged(`recorded deterministic value for ${stepId} must be ${expected}`, {
+		expectedStepId: stepId,
+		actualStepId: stepId
+	});
+}
+//#endregion
+export { createWorkflowDeterministicApi, recordWorkflowDeterministicValue };

package/dist/engine/durable-command.d.mts

@@ -0,0 +1,10 @@
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+//#region src/engine/durable-command.d.ts
+type WorkflowDurableStepStartedEvent = Extract<EventRecord, {
+  readonly kind: "step_started" | "sleep_started" | "child_workflow_started" | "message_send_started" | "message_wait_started" | "stream_started";
+}>;
+declare function appendDurableStepStartedEvent(environment: WorkflowExecutionEnvironment, event: WorkflowDurableStepStartedEvent): Promise<void>;
+declare function appendDurableStepTerminalEvent(environment: WorkflowExecutionEnvironment, event: EventRecord): Promise<void>;
+//#endregion
+export { appendDurableStepStartedEvent, appendDurableStepTerminalEvent };

package/dist/engine/durable-command.mjs

@@ -0,0 +1,17 @@
+import { enforceStepAttemptBudget } from "./retry.mjs";
+import { appendEventIfCurrentExecution } from "./state.mjs";
+//#region src/engine/durable-command.ts
+async function appendDurableStepStartedEvent(environment, event) {
+	await appendDurableStepEvent(environment, event, { enforceAttemptBudget: true });
+}
+async function appendDurableStepTerminalEvent(environment, event) {
+	await appendDurableStepEvent(environment, event);
+}
+async function appendDurableStepEvent(environment, event, options = {}) {
+	const { store, runId, history, executionOwner, limits } = environment;
+	await appendEventIfCurrentExecution(store, history, event, executionOwner, limits, options.enforceAttemptBudget === true ? () => {
+		enforceStepAttemptBudget(runId, history, environment.maximumStepAttemptsPerRun);
+	} : void 0, (appendedEvent, events) => environment.observeDurableEventAppended?.(runId, appendedEvent, events));
+}
+//#endregion
+export { appendDurableStepStartedEvent, appendDurableStepTerminalEvent };