@temelj/workflow 0.0.0-alpha.3 → 0.0.0-alpha.5

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

@@ -1,31 +1,28 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowImplementation } from "../types/definition.mjs";
+import { RunId } from "../types/ids.mjs";
+import { WorkflowDefinition, WorkflowImplementation } from "../types/definition.mjs";
 import { ExecutionResult } from "../types/result.mjs";
 import { Telemetry } from "../types/telemetry.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowResumeOptions } from "../types/run-options.mjs";
-import { WorkflowConditionalEventAppender, WorkflowEventReader, WorkflowLockConditionalWriterRepository, WorkflowLockListerRepository, WorkflowMessageIdempotencyIndexLookup, WorkflowRunListerRepository, WorkflowRunReaderRepository, WorkflowRunWriterRepository, WorkflowStepAttemptLookup } from "../types/store.mjs";
-import { WorkflowDeterministicBytesContext, WorkflowDeterministicValueContext, WorkflowExecutionLimits, WorkflowRecordedIdContext } from "../types/engine-options.mjs";
-import { WorkflowChildWorkflowEngine } from "./child-workflow.mjs";
-import { WorkflowStepLockEngine } from "./lock.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import { DeterministicBytesContext, ExecutionLimits, RecordedIdContext } from "../types/engine-options.mjs";
+import { ResumeOptions } from "../types/run-options.mjs";
+import { WorkflowEngine } from "./create.mjs";
 import { Logger } from "@temelj/log";
 //#region src/engine/execution-service.d.ts
-type WorkflowExecutionServiceStore = WorkflowRunReaderRepository & WorkflowRunListerRepository & WorkflowRunWriterRepository & WorkflowMessageIdempotencyIndexLookup & WorkflowConditionalEventAppender & WorkflowEventReader & WorkflowStepAttemptLookup & WorkflowLockListerRepository & WorkflowLockConditionalWriterRepository;
-type WorkflowExecutionStepRuntime = WorkflowChildWorkflowEngine & WorkflowStepLockEngine;
-interface WorkflowExecutionServiceOptions {
-  readonly store: WorkflowExecutionServiceStore;
+export interface ExecutionServiceOptions {
+  readonly store: WorkflowStore;
   readonly now: () => Temporal.Instant;
-  readonly createRecordedId: (context: WorkflowRecordedIdContext) => string;
-  readonly createDeterministicRandom: (context: WorkflowDeterministicValueContext) => number;
-  readonly createDeterministicUuid: (context: WorkflowDeterministicValueContext) => string;
-  readonly createDeterministicBytes: (context: WorkflowDeterministicBytesContext) => Uint8Array;
+  readonly createRecordedId: (context: RecordedIdContext) => string;
+  readonly createDeterministicRandom: (context: RecordedIdContext) => number;
+  readonly createDeterministicUuid: (context: RecordedIdContext) => string;
+  readonly createDeterministicBytes: (context: DeterministicBytesContext) => Uint8Array;
   readonly maximumStepAttemptsPerRun: number;
-  readonly limits: WorkflowExecutionLimits;
-  readonly engine: WorkflowExecutionStepRuntime;
-  readonly readCurrentRunResult: <TOutput>(runId: RunId) => Promise<ExecutionResult<TOutput>>;
-  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previousRun?: WorkflowRunRecord) => Promise<ExecutionResult<TOutput>>;
-  readonly observeRunEvent: (run: WorkflowRunRecord, previousRun?: WorkflowRunRecord) => void;
+  readonly limits: ExecutionLimits;
+  readonly engine: WorkflowEngine;
+  readonly readCurrentRunResult: <TOutput>(definition: WorkflowDefinition<unknown, TOutput, unknown>, runId: RunId) => Promise<ExecutionResult<TOutput>>;
+  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previousRun?: RunRecord) => Promise<ExecutionResult<TOutput>>;
+  readonly observeRunEvent: (run: RunRecord, previousRun?: RunRecord) => void;
   readonly observeDurableEventAppended: (runId: RunId, event: EventRecord, events: readonly EventRecord[]) => void;
   readonly observeMessageSent: (runId: RunId, event: Extract<EventRecord, {
     readonly kind: "message_sent";
@@ -36,6 +33,5 @@ interface WorkflowExecutionServiceOptions {
   readonly telemetry?: Telemetry;
   readonly logger: Logger;
 }
-declare function executeWorkflowRun<TInput, TOutput, TRawInput = TInput>(service: WorkflowExecutionServiceOptions, implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, run: WorkflowRunRecord, executionOptions: WorkflowResumeOptions | undefined): Promise<ExecutionResult<TOutput>>;
-//#endregion
-export { WorkflowExecutionServiceOptions, executeWorkflowRun };
+export declare function executeRun<TInput, TOutput, TRawInput = TInput>(service: ExecutionServiceOptions, implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, run: RunRecord, executionOptions: ResumeOptions | undefined): Promise<ExecutionResult<TOutput>>;
+//#endregion

package/dist/engine/execution-service.mjs

@@ -1,36 +1,40 @@
 import { WorkflowNonRetryableError } from "../errors/failures.mjs";
-import { getRequiredRun, isAbortError, nextRunAttempt } from "../utility.mjs";
-import { WORKFLOW_ATTRIBUTES, WORKFLOW_SYSTEM, withRunTelemetry } from "../telemetry.mjs";
+import { omitUndefined } from "../collection.mjs";
+import { History } from "../history/replay.mjs";
+import { isAbortError } from "../values.mjs";
+import { nextRunAttempt } from "../run-status.mjs";
+import { getRequiredRun } from "../store/query.mjs";
 import { serializeError, toOptionalPersistedValue } from "./serialization.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt } from "./retry.mjs";
+import { enforceEventHistoryNextLimit, nextRetryAt, nextRetryAttempt, resolveRetryConfig, retryClassificationRetryAt, shouldRetryAttempt } from "./retry.mjs";
+import { Suspended } from "./signals.mjs";
+import { failRunForDeadline, isCurrentExecutionOwner, patchCurrentExecutionRun, patchRun, releaseLocksForRun, requireDefinitionMatchesRun, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToRunning, wakeParentRun } from "./state.mjs";
 import { makeCanceledRunResult, makeCompletedRunResult } from "./run-utils.mjs";
-import { WorkflowSuspended, failRunForDeadline, isCurrentExecutionOwner, patchCurrentExecutionRun, patchRun, releaseLocksForRun, requireDefinitionMatchesRun, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToRunning, wakeParentRunForTerminalChild } from "./state.mjs";
-import { createWorkflowDeterministicApi } from "./deterministic.mjs";
+import { WORKFLOW_ATTRIBUTES, WORKFLOW_SYSTEM, withRunTelemetry } from "../telemetry.mjs";
+import { createDeterministicApi } from "./deterministic.mjs";
 import { createStepApi } from "./step-api.mjs";
 //#region src/engine/execution-service.ts
-async function executeWorkflowRun(service, implementation, run, executionOptions) {
-	return await executeWorkflowRunCore(service, implementation, run, executionOptions);
+async function executeRun(service, implementation, run, executionOptions) {
+	return await executeRunCore(service, implementation, run, executionOptions);
 }
-async function executeWorkflowRunCore(service, implementation, run, executionOptions) {
+async function executeRunCore(service, implementation, run, executionOptions) {
 	requireDefinitionMatchesRun(implementation.definition, run);
-	const workflowRetry = resolveWorkflowRetryConfig(implementation.config.retry, {
+	const workflowRetry = resolveRetryConfig(implementation.config.retry, {
 		maximumAttempts: 1,
 		backoffCoefficient: 2
 	}, "Workflow retry");
 	const startedAt = service.now();
 	const isClaimedRun = run.status === "running" && run.workerId !== void 0;
-	enforceWorkflowEventHistoryNextLimit(await service.store.getEvents(run.id), service.limits);
+	enforceEventHistoryNextLimit(await service.store.getEvents(run.id), service.limits);
 	const runningRun = await patchRun(service.store, run, transitionRunToRunning(run, startedAt, isClaimedRun ? run.attempts : nextRunAttempt(run.attempts)));
 	const startedEvents = await service.store.appendEventIfRunCurrent(runningRun, {
 		kind: "workflow_started",
 		timestamp: startedAt
 	});
-	if (startedEvents === void 0) return await service.readCurrentRunResult(run.id);
+	if (startedEvents === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 	if (isClaimedRun) service.observeRunEvent(run);
 	service.observeRunEvent(runningRun, run);
 	service.observeDurableEventAppended(run.id, startedEvents.at(-1), startedEvents);
-	const history = new WorkflowHistory(startedEvents);
+	const history = new History(startedEvents);
 	const replaying = history.hasPriorWorkflowStart();
 	const runLogger = scopedRunLogger(service.logger, runningRun, false);
 	const handlerLogger = replaying ? replayAwareLogger(runLogger, history) : runLogger;
@@ -55,66 +59,64 @@ async function executeWorkflowRunCore(service, implementation, run, executionOpt
 	};
 	const executionAbort = watchRunCancellationWithSignal(service.store, runningRun, executionOptions?.signal ?? new AbortController().signal);
 	const executionSignal = executionAbort.signal;
-	const deterministic = createWorkflowDeterministicApi(environment);
+	const deterministic = createDeterministicApi(environment);
 	const step = createStepApi(environment, service.engine, executionSignal, deterministic);
 	const telemetryContext = {
 		run: runningRun,
-		...run.telemetryContext === void 0 ? {} : { traceContext: run.telemetryContext }
+		traceContext: run.telemetryContext
 	};
 	const executeClaimedRun = async () => {
 		try {
 			history.requireStartedEventsAreUnique();
 			history.requireTerminalEventsHaveStartedEvents();
 			history.requireTerminalEventsAreUnique();
+			const runContext = {
+				id: runningRun.id,
+				workflowName: runningRun.workflowName,
+				workflowVersion: runningRun.workflowVersion,
+				createdAt: runningRun.createdAt
+			};
 			const output = await implementation.handler({
 				input: runningRun.input,
 				step,
-				deterministic,
-				log: handlerLogger,
-				run: {
-					id: runningRun.id,
-					workflowName: runningRun.workflowName,
-					...runningRun.workflowVersion === void 0 ? {} : { workflowVersion: runningRun.workflowVersion },
-					createdAt: runningRun.createdAt
-				},
-				signal: executionSignal,
-				version: runningRun.workflowVersion
+				run: runContext,
+				signal: executionSignal
 			});
 			history.requireReplayConsumed();
 			const latestRun = await getRequiredRun(service.store, run.id);
 			if (latestRun.status === "canceled") return makeCanceledRunResult(latestRun);
-			if (!isCurrentExecutionOwner(latestRun, runningRun)) return await service.readCurrentRunResult(run.id);
+			if (!isCurrentExecutionOwner(latestRun, runningRun)) return await service.readCurrentRunResult(implementation.definition, run.id);
 			const completedAt = service.now();
-			enforceWorkflowEventHistoryNextLimit(history.events, service.limits);
+			enforceEventHistoryNextLimit(history.events, service.limits);
 			const completedRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToCompleted(runningRun, toOptionalPersistedValue(output, "workflow output", service.limits), completedAt));
-			if (completedRun === void 0) return await service.readCurrentRunResult(run.id);
+			if (completedRun === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 			const completedEvents = await service.store.appendEventIfRunCurrent(completedRun, {
 				kind: "workflow_completed",
 				timestamp: completedAt
 			});
-			if (completedEvents === void 0) return await service.readCurrentRunResult(run.id);
+			if (completedEvents === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 			service.observeDurableEventAppended(run.id, completedEvents.at(-1), completedEvents);
 			await releaseLocksForRun(service.store, completedRun.id, completedAt);
-			await wakeParentRunForTerminalChild(service.store, completedRun, completedAt);
-			return await service.emitResultLifecycleEvent(makeCompletedRunResult(completedRun), runningRun);
+			await wakeParentRun(service.store, completedRun, completedAt);
+			return await service.emitResultLifecycleEvent(makeCompletedRunResult(implementation.definition, completedRun), runningRun);
 		} catch (error) {
 			const latestRun = await service.store.getRun(run.id);
 			if (latestRun?.status === "canceled") return makeCanceledRunResult(latestRun);
-			if (latestRun === void 0 || !isCurrentExecutionOwner(latestRun, runningRun)) return await service.readCurrentRunResult(run.id);
+			if (latestRun === void 0 || !isCurrentExecutionOwner(latestRun, runningRun)) return await service.readCurrentRunResult(implementation.definition, run.id);
 			if (executionOptions?.signal?.aborted === true && isAbortError(error)) {
 				const abortedAt = service.now();
 				const waitingRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToExecutionWait(runningRun, abortedAt, abortedAt));
-				if (waitingRun === void 0) return await service.readCurrentRunResult(run.id);
+				if (waitingRun === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 				return await service.emitResultLifecycleEvent({
 					kind: "waiting",
 					run: waitingRun,
 					availableAt: abortedAt
 				}, runningRun);
 			}
-			if (error instanceof WorkflowSuspended) {
+			if (error instanceof Suspended) {
 				const suspendedAt = service.now();
 				const deadlineAt = runningRun.deadlineAt;
-				if (deadlineAt !== void 0 && (error.retryReason !== void 0 ? Temporal.Instant.compare(deadlineAt, error.availableAt) <= 0 : Temporal.Instant.compare(deadlineAt, error.availableAt) < 0)) return await service.emitResultLifecycleEvent(await failRunForDeadline(service.store, runningRun, deadlineAt, suspendedAt, runningRun), runningRun);
+				if (deadlineAt !== void 0 && (error.retryReason !== void 0 ? Temporal.Instant.compare(deadlineAt, error.availableAt) <= 0 : Temporal.Instant.compare(deadlineAt, error.availableAt) < 0)) return await service.emitResultLifecycleEvent(await failRunForDeadline(service.store, implementation.definition, runningRun, deadlineAt, suspendedAt, runningRun), runningRun);
 				const waitingRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToExecutionWait(runningRun, suspendedAt, error.availableAt, {
 					retryAt: error.retryAt,
 					retryReason: error.retryReason,
@@ -122,7 +124,7 @@ async function executeWorkflowRunCore(service, implementation, run, executionOpt
 					retryStepId: error.retryStep?.id,
 					retryStepName: error.retryStep?.name
 				}));
-				if (waitingRun === void 0) return await service.readCurrentRunResult(run.id);
+				if (waitingRun === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 				return await service.emitResultLifecycleEvent({
 					kind: "waiting",
 					run: waitingRun,
@@ -134,39 +136,39 @@ async function executeWorkflowRunCore(service, implementation, run, executionOpt
 			const workflowAttempt = runningRun.attempts ?? 1;
 			const failWorkflowRun = async (errorRecord) => {
 				const failedRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToFailed(runningRun, errorRecord, failedAt, "failed"));
-				if (failedRun === void 0) return await service.readCurrentRunResult(run.id);
+				if (failedRun === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 				const failedEvents = await service.store.appendEventIfRunCurrent(failedRun, {
 					kind: "workflow_failed",
 					timestamp: failedAt
 				});
-				if (failedEvents === void 0) return await service.readCurrentRunResult(run.id);
+				if (failedEvents === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 				service.observeDurableEventAppended(run.id, failedEvents.at(-1), failedEvents);
 				await releaseLocksForRun(service.store, failedRun.id, failedAt);
-				await wakeParentRunForTerminalChild(service.store, failedRun, failedAt);
+				await wakeParentRun(service.store, failedRun, failedAt);
 				return await service.emitResultLifecycleEvent({
 					kind: "failed",
 					run: failedRun,
 					error: errorRecord
 				}, runningRun);
 			};
-			if (!(error instanceof WorkflowNonRetryableError) && shouldRetryWorkflowAttempt(workflowRetry, workflowAttempt)) {
+			if (!(error instanceof WorkflowNonRetryableError) && shouldRetryAttempt(workflowRetry, workflowAttempt)) {
 				let retryAt;
 				let nextAttempt;
 				try {
 					retryAt = retryClassificationRetryAt(failedAt, error, "Workflow retry classification") ?? nextRetryAt(failedAt, workflowRetry, workflowAttempt, "Workflow retry delay") ?? failedAt;
-					nextAttempt = nextWorkflowRetryAttempt(workflowAttempt);
+					nextAttempt = nextRetryAttempt(workflowAttempt);
 				} catch (retryError) {
 					return await failWorkflowRun(serializeError(retryError));
 				}
 				const deadlineAt = runningRun.deadlineAt;
-				if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, retryAt) <= 0) return await service.emitResultLifecycleEvent(await failRunForDeadline(service.store, runningRun, deadlineAt, failedAt, runningRun), runningRun);
+				if (deadlineAt !== void 0 && Temporal.Instant.compare(deadlineAt, retryAt) <= 0) return await service.emitResultLifecycleEvent(await failRunForDeadline(service.store, implementation.definition, runningRun, deadlineAt, failedAt, runningRun), runningRun);
 				const waitingRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToExecutionWait(runningRun, failedAt, retryAt, {
 					retryAt,
 					retryReason: "workflow",
 					retryAttempt: nextAttempt,
 					error: serialized
 				}));
-				if (waitingRun === void 0) return await service.readCurrentRunResult(run.id);
+				if (waitingRun === void 0) return await service.readCurrentRunResult(implementation.definition, run.id);
 				return await service.emitResultLifecycleEvent({
 					kind: "waiting",
 					run: waitingRun,
@@ -202,16 +204,16 @@ async function executeWorkflowRunCore(service, implementation, run, executionOpt
 	}
 }
 function scopedRunLogger(logger, run, replaying) {
-	return logger.child({
+	return logger.child(omitUndefined({
 		[WORKFLOW_ATTRIBUTES.system]: WORKFLOW_SYSTEM,
 		[WORKFLOW_ATTRIBUTES.workflowName]: run.workflowName,
-		...run.workflowVersion === void 0 ? {} : { [WORKFLOW_ATTRIBUTES.workflowVersion]: run.workflowVersion },
+		[WORKFLOW_ATTRIBUTES.workflowVersion]: run.workflowVersion,
 		[WORKFLOW_ATTRIBUTES.runId]: run.id,
 		[WORKFLOW_ATTRIBUTES.namespace]: run.namespace,
 		[WORKFLOW_ATTRIBUTES.runAttempt]: run.attempts,
-		...run.workerId === void 0 ? {} : { [WORKFLOW_ATTRIBUTES.workerId]: run.workerId },
+		[WORKFLOW_ATTRIBUTES.workerId]: run.workerId,
 		[WORKFLOW_ATTRIBUTES.replay]: replaying
-	});
+	}));
 }
 function replayAwareLogger(logger, history) {
 	return new ReplayAwareLogger(logger, history);
@@ -241,11 +243,11 @@ var ReplayAwareLogger = class ReplayAwareLogger {
 	warn(message, attributes) {
 		if (this.#history.isReplayConsumed()) this.#logger.warn(message, attributes);
 	}
-	error(message, attributes) {
-		if (this.#history.isReplayConsumed()) this.#logger.error(message, attributes);
+	error(message, cause, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.error(message, cause, attributes);
 	}
-	fatal(message, attributes) {
-		if (this.#history.isReplayConsumed()) this.#logger.fatal(message, attributes);
+	fatal(message, cause, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.fatal(message, cause, attributes);
 	}
 	async flush() {
 		await this.#logger.flush?.();
@@ -285,4 +287,4 @@ function watchRunCancellationWithSignal(store, executionOwner, parentSignal) {
 	};
 }
 //#endregion
-export { executeWorkflowRun };
+export { executeRun };

package/dist/engine/hooks.d.mts

@@ -1,56 +1,34 @@
-import { MessageId } from "../types/message-id.mjs";
-import { RunId } from "../types/run-id.mjs";
+import { MessageId, RunId } from "../types/ids.mjs";
 import { CreateHookOptions, CreateWebhookOptions, Hook as Hook$1, HookInspection, ResumeHookOptions, Webhook as Webhook$1 } from "../types/hook.mjs";
-import { WorkflowStepHookApi } from "../types/step.mjs";
-import { Telemetry, TelemetryContext } from "../types/telemetry.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowConditionalEventAppender, WorkflowEventReader, WorkflowMessageIdempotencyIndexLookup, WorkflowRunConditionalWriterRepository, WorkflowRunReaderRepository } from "../types/store.mjs";
-import { WorkflowExecutionLimits } from "../types/engine-options.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { StepHookApi } from "../types/step.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import { EngineContext } from "./context.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/engine/hooks.d.ts
-type WorkflowHookStore = WorkflowMessageIdempotencyIndexLookup & WorkflowRunReaderRepository & WorkflowEventReader & WorkflowConditionalEventAppender & WorkflowRunConditionalWriterRepository;
-interface WorkflowHookServiceOptions {
-  readonly store: WorkflowHookStore;
-  readonly now: () => Temporal.Instant;
-  readonly limits: WorkflowExecutionLimits;
-  readonly emitMessageSent: (runId: RunId, event: Extract<EventRecord, {
-    readonly kind: "message_sent";
-  }>) => void;
-  readonly emitHookResumed: (runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined) => void;
-  readonly emitWebhookResumed: (runId: RunId, messageId: MessageId, payload: StorageValue | undefined, traceContext: TelemetryContext | undefined) => void;
-  readonly telemetry?: Telemetry;
-}
-declare function createHook<TPayload>(runId: RunId, options: CreateHookOptions, wait: () => Promise<unknown>): Hook$1<TPayload>;
-declare function createWebhook<TPayload>(runId: RunId, options: CreateWebhookOptions, wait: () => Promise<unknown>): Webhook$1<TPayload>;
-declare function createWorkflowStepHookApi(environment: WorkflowExecutionEnvironment): WorkflowStepHookApi;
-declare class Hook<TPayload> implements Hook$1<TPayload> {
+export declare function createStepHookApi(environment: ExecutionEnvironment): StepHookApi;
+export declare class Hook<TPayload> implements Hook$1<TPayload> {
   #private;
   readonly token: string;
   readonly runId: RunId;
   readonly name: string;
   readonly messageId: MessageId;
-  constructor(runId: RunId, options: CreateHookOptions, wait: () => Promise<unknown>);
+  constructor(runId: RunId, options: Omit<CreateHookOptions, "schema">, wait: () => Promise<TPayload>);
   wait(): Promise<TPayload>;
-  then<TResult1 = TPayload, TResult2 = never>(onfulfilled?: ((value: TPayload) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+  then<TResult1 = TPayload, TResult2 = never>(onfulfilled?: ((value: TPayload) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((cause: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
 }
-declare class Webhook<TPayload> implements Webhook$1<TPayload> {
+export declare class Webhook<TPayload> implements Webhook$1<TPayload> {
   #private;
   readonly token: string;
   readonly runId: RunId;
   readonly name: string;
   readonly messageId: MessageId;
-  readonly metadata?: unknown;
-  constructor(runId: RunId, options: CreateWebhookOptions, wait: () => Promise<unknown>);
+  readonly metadata?: StorageValue;
+  constructor(runId: RunId, options: Omit<CreateWebhookOptions, "schema">, wait: () => Promise<TPayload>);
   wait(): Promise<TPayload>;
-  then<TResult1 = TPayload, TResult2 = never>(onfulfilled?: ((value: TPayload) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+  then<TResult1 = TPayload, TResult2 = never>(onfulfilled?: ((value: TPayload) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((cause: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
 }
-declare function resumeHook(token: string, options: ResumeHookOptions | undefined, service: WorkflowHookServiceOptions): Promise<void>;
-declare function resumeWebhook(token: string, options: ResumeHookOptions | undefined, service: WorkflowHookServiceOptions): Promise<void>;
-declare function disposeHook(token: string, service: WorkflowHookServiceOptions): Promise<HookInspection>;
-declare function disposeWebhook(token: string, service: WorkflowHookServiceOptions): Promise<HookInspection>;
-declare function getHookByToken(token: string, store: WorkflowRunReaderRepository & WorkflowEventReader, now: Temporal.Instant): Promise<HookInspection>;
-declare function inspectHookToken(token: string, run: WorkflowRunRecord | undefined, events: readonly EventRecord[], now: Temporal.Instant): HookInspection;
-//#endregion
-export { Hook, Webhook, createHook, createWebhook, createWorkflowStepHookApi, disposeHook, disposeWebhook, getHookByToken, inspectHookToken, resumeHook, resumeWebhook };
+export declare function resumeHook(token: string, options: ResumeHookOptions | undefined, context: EngineContext): Promise<void>;
+export declare function disposeHook(token: string, context: EngineContext): Promise<HookInspection>;
+export declare function getHookByToken(token: string, store: WorkflowStore, now: Temporal.Instant): Promise<HookInspection>;
+//#endregion