@temelj/workflow 0.0.0-alpha.1

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

@@ -0,0 +1,29 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowImplementation } from "../types/definition.mjs";
+import { ExecutionResult, WorkflowHandle } from "../types/result.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { WorkflowExecutionOptions, WorkflowResumeOptions } from "../types/run-options.mjs";
+import { WorkflowConditionalEventAppender, WorkflowEventReader, WorkflowLockConditionalWriterRepository, WorkflowLockListerRepository, WorkflowRunReaderRepository, WorkflowRunWriterRepository, WorkflowStepAttemptLookup } from "../types/store.mjs";
+import { WorkflowRunStarter } from "../types/engine.mjs";
+import { WorkflowExecutionServiceOptions } from "./execution-service.mjs";
+//#region src/engine/execution-api.d.ts
+interface WorkflowEngineExecutionApi {
+  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>>;
+}
+type WorkflowEngineExecutionApiStore = WorkflowRunReaderRepository & WorkflowRunWriterRepository & WorkflowConditionalEventAppender & WorkflowEventReader & WorkflowStepAttemptLookup & WorkflowLockListerRepository & WorkflowLockConditionalWriterRepository;
+interface WorkflowEngineExecutionResumer {
+  resumeWorkflow<TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>, runId: RunId, options?: WorkflowResumeOptions): Promise<ExecutionResult<TOutput>>;
+}
+interface WorkflowEngineExecutionApiOptions {
+  readonly store: WorkflowEngineExecutionApiStore;
+  readonly now: () => Temporal.Instant;
+  readonly executionService: WorkflowExecutionServiceOptions;
+  readonly emitResultLifecycleEvent: <TOutput>(result: ExecutionResult<TOutput>, previous?: WorkflowRunRecord) => Promise<ExecutionResult<TOutput>>;
+  readonly starter: WorkflowRunStarter;
+  readonly resumer: WorkflowEngineExecutionResumer;
+}
+declare function createWorkflowEngineExecutionApi(service: WorkflowEngineExecutionApiOptions): WorkflowEngineExecutionApi;
+//#endregion
+export { WorkflowEngineExecutionApi, createWorkflowEngineExecutionApi };

package/dist/engine/execution-api.mjs

@@ -0,0 +1,33 @@
+import { getRequiredRun } from "../utility.mjs";
+import { makeCanceledRunResult, makeCompletedRunResult } from "./run-utils.mjs";
+import { failRunForDeadline, requireDefinitionMatchesRun } from "./state.mjs";
+import { executeWorkflowRun } from "./execution-service.mjs";
+//#region src/engine/execution-api.ts
+function createWorkflowEngineExecutionApi(service) {
+	return {
+		async runWorkflow(implementation, input, executionOptions) {
+			return await service.starter.startWorkflow(implementation.definition, input, executionOptions?.start);
+		},
+		async runWorkflowNow(implementation, input, executionOptions) {
+			const handle = await service.starter.startWorkflow(implementation.definition, input, executionOptions?.start);
+			return await service.resumer.resumeWorkflow(implementation, handle.runId, { signal: executionOptions?.signal });
+		},
+		async resumeWorkflow(implementation, runId, resumeOptions) {
+			const run = await getRequiredRun(service.store, runId);
+			requireDefinitionMatchesRun(implementation.definition, run);
+			if (run.status === "completed") return makeCompletedRunResult(run);
+			if (run.status === "canceled") return makeCanceledRunResult(run);
+			const timestamp = service.now();
+			if (run.deadlineAt !== void 0 && Temporal.Instant.compare(run.deadlineAt, timestamp) <= 0) return await service.emitResultLifecycleEvent(await failRunForDeadline(service.store, 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 executeWorkflowRun(service.executionService, implementation, run, resumeOptions);
+		}
+	};
+}
+//#endregion
+export { createWorkflowEngineExecutionApi };

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

@@ -0,0 +1,41 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowImplementation } from "../types/definition.mjs";
+import { ExecutionResult } from "../types/result.mjs";
+import { Telemetry } from "../types/telemetry.mjs";
+import { WorkflowRunRecord } 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 { 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;
+  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 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 observeDurableEventAppended: (runId: RunId, event: EventRecord, events: readonly EventRecord[]) => void;
+  readonly observeMessageSent: (runId: RunId, event: Extract<EventRecord, {
+    readonly kind: "message_sent";
+  }>) => void;
+  readonly observeChildWorkflowStarted: (runId: RunId, event: Extract<EventRecord, {
+    readonly kind: "child_workflow_started";
+  }>) => void;
+  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 };

package/dist/engine/execution-service.mjs

@@ -0,0 +1,288 @@
+import { WorkflowNonRetryableError } from "../errors/failures.mjs";
+import { getRequiredRun, isAbortError, nextRunAttempt } from "../utility.mjs";
+import { WORKFLOW_ATTRIBUTES, WORKFLOW_SYSTEM, withRunTelemetry } from "../telemetry.mjs";
+import { serializeError, toOptionalPersistedValue } from "./serialization.mjs";
+import { WorkflowHistory } from "../history/mod.mjs";
+import { enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt } from "./retry.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 { 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 executeWorkflowRunCore(service, implementation, run, executionOptions) {
+	requireDefinitionMatchesRun(implementation.definition, run);
+	const workflowRetry = resolveWorkflowRetryConfig(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);
+	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 (isClaimedRun) service.observeRunEvent(run);
+	service.observeRunEvent(runningRun, run);
+	service.observeDurableEventAppended(run.id, startedEvents.at(-1), startedEvents);
+	const history = new WorkflowHistory(startedEvents);
+	const replaying = history.hasPriorWorkflowStart();
+	const runLogger = scopedRunLogger(service.logger, runningRun, false);
+	const handlerLogger = replaying ? replayAwareLogger(runLogger, history) : runLogger;
+	const environment = {
+		store: service.store,
+		runId: run.id,
+		history,
+		now: service.now,
+		createRecordedId: service.createRecordedId,
+		createDeterministicRandom: service.createDeterministicRandom,
+		createDeterministicUuid: service.createDeterministicUuid,
+		createDeterministicBytes: service.createDeterministicBytes,
+		maximumStepAttemptsPerRun: service.maximumStepAttemptsPerRun,
+		limits: service.limits,
+		executionOwner: runningRun,
+		telemetry: service.telemetry,
+		logger: handlerLogger,
+		replaying,
+		observeDurableEventAppended: service.observeDurableEventAppended,
+		observeMessageSent: service.observeMessageSent,
+		observeChildWorkflowStarted: service.observeChildWorkflowStarted
+	};
+	const executionAbort = watchRunCancellationWithSignal(service.store, runningRun, executionOptions?.signal ?? new AbortController().signal);
+	const executionSignal = executionAbort.signal;
+	const deterministic = createWorkflowDeterministicApi(environment);
+	const step = createStepApi(environment, service.engine, executionSignal, deterministic);
+	const telemetryContext = {
+		run: runningRun,
+		...run.telemetryContext === void 0 ? {} : { traceContext: run.telemetryContext }
+	};
+	const executeClaimedRun = async () => {
+		try {
+			history.requireStartedEventsAreUnique();
+			history.requireTerminalEventsHaveStartedEvents();
+			history.requireTerminalEventsAreUnique();
+			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
+			});
+			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);
+			const completedAt = service.now();
+			enforceWorkflowEventHistoryNextLimit(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);
+			const completedEvents = await service.store.appendEventIfRunCurrent(completedRun, {
+				kind: "workflow_completed",
+				timestamp: completedAt
+			});
+			if (completedEvents === void 0) return await service.readCurrentRunResult(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);
+		} 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 (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);
+				return await service.emitResultLifecycleEvent({
+					kind: "waiting",
+					run: waitingRun,
+					availableAt: abortedAt
+				}, runningRun);
+			}
+			if (error instanceof WorkflowSuspended) {
+				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);
+				const waitingRun = await patchCurrentExecutionRun(service.store, runningRun, transitionRunToExecutionWait(runningRun, suspendedAt, error.availableAt, {
+					retryAt: error.retryAt,
+					retryReason: error.retryReason,
+					retryAttempt: error.retryAttempt,
+					retryStepId: error.retryStep?.id,
+					retryStepName: error.retryStep?.name
+				}));
+				if (waitingRun === void 0) return await service.readCurrentRunResult(run.id);
+				return await service.emitResultLifecycleEvent({
+					kind: "waiting",
+					run: waitingRun,
+					availableAt: error.availableAt
+				}, runningRun);
+			}
+			const failedAt = service.now();
+			const serialized = serializeError(error);
+			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);
+				const failedEvents = await service.store.appendEventIfRunCurrent(failedRun, {
+					kind: "workflow_failed",
+					timestamp: failedAt
+				});
+				if (failedEvents === void 0) return await service.readCurrentRunResult(run.id);
+				service.observeDurableEventAppended(run.id, failedEvents.at(-1), failedEvents);
+				await releaseLocksForRun(service.store, failedRun.id, failedAt);
+				await wakeParentRunForTerminalChild(service.store, failedRun, failedAt);
+				return await service.emitResultLifecycleEvent({
+					kind: "failed",
+					run: failedRun,
+					error: errorRecord
+				}, runningRun);
+			};
+			if (!(error instanceof WorkflowNonRetryableError) && shouldRetryWorkflowAttempt(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);
+				} 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);
+				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);
+				return await service.emitResultLifecycleEvent({
+					kind: "waiting",
+					run: waitingRun,
+					availableAt: retryAt
+				}, runningRun);
+			}
+			return await failWorkflowRun(serialized);
+		} finally {
+			executionAbort.dispose();
+		}
+	};
+	try {
+		const result = await withRunTelemetry(service.telemetry, telemetryContext, executeClaimedRun);
+		try {
+			service.telemetry?.recordRunExecution?.({
+				...telemetryContext,
+				result
+			});
+		} catch {
+			return result;
+		}
+		return result;
+	} catch (error) {
+		try {
+			service.telemetry?.recordRunExecution?.({
+				...telemetryContext,
+				error
+			});
+		} catch {
+			throw error;
+		}
+		throw error;
+	}
+}
+function scopedRunLogger(logger, run, replaying) {
+	return logger.child({
+		[WORKFLOW_ATTRIBUTES.system]: WORKFLOW_SYSTEM,
+		[WORKFLOW_ATTRIBUTES.workflowName]: run.workflowName,
+		...run.workflowVersion === void 0 ? {} : { [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.replay]: replaying
+	});
+}
+function replayAwareLogger(logger, history) {
+	return new ReplayAwareLogger(logger, history);
+}
+var ReplayAwareLogger = class ReplayAwareLogger {
+	#logger;
+	#history;
+	constructor(logger, history) {
+		this.#logger = logger;
+		this.#history = history;
+	}
+	child(attributes) {
+		return new ReplayAwareLogger(this.#logger.child(attributes), this.#history);
+	}
+	log(level, message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.log(level, message, attributes);
+	}
+	trace(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.trace(message, attributes);
+	}
+	debug(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.debug(message, attributes);
+	}
+	info(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.info(message, attributes);
+	}
+	warn(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.warn(message, attributes);
+	}
+	error(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.error(message, attributes);
+	}
+	fatal(message, attributes) {
+		if (this.#history.isReplayConsumed()) this.#logger.fatal(message, attributes);
+	}
+	async flush() {
+		await this.#logger.flush?.();
+	}
+	async close() {
+		await this.#logger.close?.();
+	}
+};
+function watchRunCancellationWithSignal(store, executionOwner, parentSignal) {
+	const controller = new AbortController();
+	let disposed = false;
+	let polling = false;
+	let interval;
+	const abortFromParent = () => {
+		controller.abort(parentSignal.reason);
+	};
+	if (parentSignal.aborted) abortFromParent();
+	else parentSignal.addEventListener("abort", abortFromParent, { once: true });
+	const poll = () => {
+		if (disposed || polling || controller.signal.aborted) return;
+		polling = true;
+		store.getRun(executionOwner.id).then((run) => {
+			if (!disposed && !controller.signal.aborted && run?.status === "canceled" && run.id === executionOwner.id && run.attempts === executionOwner.attempts) controller.abort(new DOMException("Workflow run canceled", "AbortError"));
+		}).catch(() => {}).finally(() => {
+			polling = false;
+		});
+	};
+	interval = setInterval(poll, 25);
+	poll();
+	return {
+		signal: controller.signal,
+		dispose() {
+			disposed = true;
+			if (interval !== void 0) clearInterval(interval);
+			parentSignal.removeEventListener("abort", abortFromParent);
+		}
+	};
+}
+//#endregion
+export { executeWorkflowRun };

package/dist/engine/hooks.d.mts

@@ -0,0 +1,56 @@
+import { MessageId } from "../types/message-id.mjs";
+import { RunId } from "../types/run-id.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 { 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> {
+  #private;
+  readonly token: string;
+  readonly runId: RunId;
+  readonly name: string;
+  readonly messageId: MessageId;
+  constructor(runId: RunId, options: CreateHookOptions, wait: () => Promise<unknown>);
+  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>;
+}
+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>);
+  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>;
+}
+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 };