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

package/dist/engine/serialization.d.mts

@@ -1,9 +1,12 @@
 import { WorkflowErrorRecord } from "../types/error.mjs";
-import { WorkflowEngineSerializationLimits } from "../types/engine-options.mjs";
+import { WorkflowDefinition } from "../types/definition.mjs";
+import { ExecutionLimits } from "../types/engine-options.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/engine/serialization.d.ts
-declare function serializeError(error: unknown): WorkflowErrorRecord;
-declare function toPersistedValue(value: unknown, path: string, limits?: WorkflowEngineSerializationLimits): StorageValue;
-declare function toOptionalPersistedValue(value: unknown, path: string, limits?: WorkflowEngineSerializationLimits): StorageValue | undefined;
-//#endregion
-export { serializeError, toOptionalPersistedValue, toPersistedValue };
+export declare function serializeError(cause: unknown): WorkflowErrorRecord;
+/** Validates workflow input and returns the value admitted to durable storage. */
+export declare function parseInput(definition: WorkflowDefinition, input: unknown): Promise<StorageValue | undefined>;
+export declare function toPersistedValue(value: unknown, path: string, limits?: ExecutionLimits): StorageValue;
+export declare function toOptionalPersistedValue(value: unknown, path: string, limits?: ExecutionLimits): StorageValue | undefined;
+export declare function enforceStorageValueSize(value: StorageValue | undefined, path: string, limits: ExecutionLimits | undefined): void;
+//#endregion

package/dist/engine/serialization.mjs

@@ -1,37 +1,39 @@
 import { WorkflowError } from "../errors/base.mjs";
 import { WorkflowSerializationError } from "../errors/failures.mjs";
-import { sanitizedWorkflowErrorDetails } from "../types/error.mjs";
-import { persistedValueIssue } from "../types/run.mjs";
 import { WorkflowStepExecutionError } from "../errors/step.mjs";
+import { sanitizedErrorDetails } from "../errors/records.mjs";
 import "../errors/mod.mjs";
+import { persistedValueIssue } from "../schema/persisted-value.mjs";
+import { validateStandardSchema } from "@temelj/standard-schema";
+import { isString } from "@temelj/value";
 import { createSuperJsonStorageCodec } from "@temelj/storage";
 //#region src/engine/serialization.ts
 const PERSISTED_VALUE_CODEC = createSuperJsonStorageCodec({ format: "bytes" });
-function serializeError(error) {
-	if (error instanceof Error) {
-		const name = typeof error.name === "string" && error.name.trim() !== "" ? error.name : "Error";
-		const message = typeof error.message === "string" && error.message.trim() !== "" ? error.message : name;
-		const stack = typeof error.stack === "string" && error.stack.trim() !== "" ? error.stack : void 0;
+function serializeError(cause) {
+	if (cause instanceof Error) {
+		const name = isString(cause.name) && cause.name.trim() !== "" ? cause.name : "Error";
+		const message = isString(cause.message) && cause.message.trim() !== "" ? cause.message : name;
+		const stack = isString(cause.stack) && cause.stack.trim() !== "" ? cause.stack : void 0;
 		return {
-			...error instanceof WorkflowError ? { code: error.code } : {},
 			name,
 			message,
-			...stack === void 0 ? {} : { stack },
-			...workflowErrorDetails(error)
+			...workflowErrorDetails(cause),
+			code: cause instanceof WorkflowError ? cause.code : void 0,
+			stack
 		};
 	}
 	return {
 		name: "Error",
-		message: String(error).trim() === "" ? "Error" : String(error)
+		message: String(cause).trim() === "" ? "Error" : String(cause)
 	};
 }
 function workflowErrorDetails(error) {
 	if (error instanceof WorkflowStepExecutionError) return { details: {
-		...sanitizedWorkflowErrorDetails(error.details),
+		...sanitizedErrorDetails(error.details),
 		...workflowErrorCauseDetails(error.cause)
 	} };
 	if (error instanceof WorkflowError && error.details !== void 0) {
-		const details = sanitizedWorkflowErrorDetails(error.details);
+		const details = sanitizedErrorDetails(error.details);
 		return details === void 0 ? {} : { details };
 	}
 	return {};
@@ -39,12 +41,13 @@ function workflowErrorDetails(error) {
 function workflowErrorCauseDetails(cause) {
 	if (!(cause instanceof Error)) return {};
 	const record = serializeError(cause);
-	return prefixWorkflowErrorCauseDetails({
-		...causeDetailsWithoutReservedIdentity(record.details),
-		...record.code === void 0 ? {} : { code: record.code },
+	const details = causeDetailsWithoutReservedIdentity(record.details);
+	return prefixErrorCauseDetails({
+		...details,
 		name: record.name,
 		message: record.message,
-		...record.stack === void 0 ? {} : { stack: record.stack }
+		code: record.code ?? details.code,
+		stack: record.stack
 	});
 }
 function causeDetailsWithoutReservedIdentity(details) {
@@ -54,14 +57,20 @@ function causeDetailsWithoutReservedIdentity(details) {
 		return prefixedKey !== "causeName" && prefixedKey !== "causeMessage" && prefixedKey !== "causeStack";
 	}));
 }
-function prefixWorkflowErrorCauseDetails(details) {
+function prefixErrorCauseDetails(details) {
 	return Object.fromEntries(Object.entries(details).map(([key, value]) => [key.startsWith("cause") ? key : `cause${key[0]?.toUpperCase() ?? ""}${key.slice(1)}`, value]));
 }
+/** Validates workflow input and returns the value admitted to durable storage. */
+async function parseInput(definition, input) {
+	const schema = definition.config.schema;
+	return toOptionalPersistedValue(schema === void 0 ? input : await validateStandardSchema(schema, input, "Workflow input validation failed"), "workflow input");
+}
 function toPersistedValue(value, path, limits) {
 	const issue = persistedValueIssue(value, path, /* @__PURE__ */ new WeakSet(), false);
 	if (issue !== void 0) WorkflowSerializationError.notSerializable(issue.path, issue.message);
-	enforceStorageValueSize(value, path, limits);
-	return value;
+	const persisted = value;
+	enforceStorageValueSize(persisted, path, limits);
+	return persisted;
 }
 function toOptionalPersistedValue(value, path, limits) {
 	if (value === void 0) return;
@@ -82,4 +91,4 @@ function persistedValueByteLength(value, path) {
 	}
 }
 //#endregion
-export { serializeError, toOptionalPersistedValue, toPersistedValue };
+export { enforceStorageValueSize, parseInput, serializeError, toOptionalPersistedValue, toPersistedValue };

package/dist/engine/signals.d.mts

@@ -0,0 +1,23 @@
+import { RunId } from "../types/ids.mjs";
+import { StepIdentity } from "../types/run.mjs";
+//#region src/engine/signals.d.ts
+/** Stops execution until `availableAt`, such as for a sleep, a message wait, or a step retry. */
+export declare class Suspended extends Error {
+  readonly availableAt: Temporal.Instant;
+  readonly retryAt?: Temporal.Instant;
+  readonly retryReason?: "step";
+  readonly retryAttempt?: number;
+  readonly retryStep?: StepIdentity;
+  constructor(availableAt: Temporal.Instant, retry?: {
+    readonly step: StepIdentity;
+    readonly attempt: number;
+  });
+  static until(this: void, availableAt: Temporal.Instant): never;
+  static forStepRetry(this: void, retryAt: Temporal.Instant, step: StepIdentity, attempt: number): never;
+}
+/** Stops an execution that lost ownership of its run, such as after its lease was reclaimed. */
+export declare class StaleExecutionError extends Error {
+  constructor(runId: RunId);
+  static stale(this: void, runId: RunId): never;
+}
+//#endregion

package/dist/engine/signals.mjs

@@ -0,0 +1,41 @@
+//#region src/engine/signals.ts
+/** Stops execution until `availableAt`, such as for a sleep, a message wait, or a step retry. */
+var Suspended = class Suspended extends Error {
+	availableAt;
+	retryAt;
+	retryReason;
+	retryAttempt;
+	retryStep;
+	constructor(availableAt, retry) {
+		super(`Workflow suspended until ${availableAt.toString()}`);
+		this.name = "WorkflowSuspended";
+		this.availableAt = availableAt;
+		if (retry !== void 0) {
+			this.retryAt = availableAt;
+			this.retryReason = "step";
+			this.retryAttempt = retry.attempt;
+			this.retryStep = retry.step;
+		}
+	}
+	static until(availableAt) {
+		throw new Suspended(availableAt);
+	}
+	static forStepRetry(retryAt, step, attempt) {
+		throw new Suspended(retryAt, {
+			step,
+			attempt
+		});
+	}
+};
+/** Stops an execution that lost ownership of its run, such as after its lease was reclaimed. */
+var StaleExecutionError = class StaleExecutionError extends Error {
+	constructor(runId) {
+		super(`Workflow execution no longer owns run: ${runId}`);
+		this.name = "WorkflowStaleExecutionError";
+	}
+	static stale(runId) {
+		throw new StaleExecutionError(runId);
+	}
+};
+//#endregion
+export { StaleExecutionError, Suspended };

package/dist/engine/start.d.mts

@@ -0,0 +1,18 @@
+import { RunId } from "../types/ids.mjs";
+import { StartTarget, WorkflowDefinition } from "../types/definition.mjs";
+import { ResolvedScheduleNextOptions, ScheduleNextOptions, StartOptions } from "../types/run-options.mjs";
+import { WorkflowEngine } from "./create.mjs";
+import { StorageValue } from "@temelj/storage";
+//#region src/engine/start.d.ts
+/** Resolves schedule-next options and derives the start time for the next run. */
+export declare function resolveScheduleNextOptions(options: ScheduleNextOptions, now: () => Temporal.Instant): ResolvedScheduleNextOptions;
+/** A started or existing run, with the definition that types its output. Internal. */
+export interface RunRef<TOutput> {
+  readonly runId: RunId;
+  readonly definition: WorkflowDefinition<unknown, TOutput, unknown>;
+}
+/** An existing run; its output is the stored value, since a run ID carries no type. */
+export declare function getRunRef(engine: WorkflowEngine, runId: RunId): Promise<RunRef<StorageValue | undefined>>;
+/** Creates a pending run, or returns the run that already holds the idempotency key. */
+export declare function startRun<TInput, TOutput, TRawInput = TInput>(engine: WorkflowEngine, workflow: StartTarget<TInput, TOutput, TRawInput>, input: TRawInput, startOptions?: StartOptions): Promise<RunRef<TOutput>>;
+//#endregion

package/dist/engine/start.mjs

@@ -0,0 +1,88 @@
+import { defineFromName, defineFromTarget } from "../definition.mjs";
+import { getRequiredRun } from "../store/query.mjs";
+import { enforceStorageValueSize, parseInput, toPersistedValue } from "./serialization.mjs";
+import { resolveStartSpec } from "./run-service.mjs";
+import { captureTelemetryContext } from "../telemetry.mjs";
+//#region src/engine/start.ts
+/** Resolves schedule-next options and derives the start time for the next run. */
+function resolveScheduleNextOptions(options, now) {
+	const from = options.from ?? now();
+	const start = {
+		id: options.id,
+		idempotencyKey: options.idempotencyKey,
+		workflowVersion: options.workflowVersion,
+		workflowVersionResolver: options.workflowVersionResolver,
+		context: options.context,
+		parent: options.parent,
+		availableAt: from.toZonedDateTimeISO("UTC").add(options.every).toInstant(),
+		deadlineAt: options.deadlineAt
+	};
+	return {
+		schedule: {
+			...options,
+			from
+		},
+		start
+	};
+}
+/** An existing run; its output is the stored value, since a run ID carries no type. */
+async function getRunRef(engine, runId) {
+	const run = await getRequiredRun(engine.store, runId);
+	return {
+		runId,
+		definition: defineFromName(run.workflowName, run.workflowVersion)
+	};
+}
+/** Creates a pending run, or returns the run that already holds the idempotency key. */
+async function startRun(engine, workflow, input, startOptions) {
+	const context = engine.context;
+	const definition = await resolveStartSpec(defineFromTarget(workflow), startOptions);
+	const persistedInput = await parseInput(definition, input);
+	const idempotencyKey = startOptions?.idempotencyKey;
+	if (idempotencyKey !== void 0) {
+		const keyOptions = {
+			workflowName: definition.name,
+			idempotencyKey,
+			workflowVersion: definition.version
+		};
+		const existingRun = await context.store.getRunByIdempotencyKey(keyOptions);
+		if (existingRun !== void 0) return {
+			runId: existingRun.id,
+			definition
+		};
+	}
+	const runId = startOptions?.id ?? context.createRunId();
+	const timestamp = context.now();
+	const parent = startOptions?.parent;
+	enforceStorageValueSize(persistedInput, "workflow input", context.limits);
+	const run = {
+		id: runId,
+		namespace: context.store.namespace,
+		workflowName: definition.name,
+		workflowVersion: definition.version,
+		status: "pending",
+		input: persistedInput,
+		context: startOptions?.context === void 0 ? void 0 : toPersistedValue(startOptions.context, "workflow context", context.limits),
+		telemetryContext: captureTelemetryContext(context.telemetry),
+		attempts: 0,
+		idempotencyKey,
+		parentRunId: parent?.runId,
+		parentStepId: parent?.stepId,
+		parentStepName: parent?.stepName,
+		parentStepAttempt: parent?.stepAttempt,
+		createdAt: timestamp,
+		updatedAt: timestamp,
+		lastTransitionAt: timestamp,
+		lastTransitionReason: "created",
+		availableAt: startOptions?.availableAt,
+		deadlineAt: startOptions?.deadlineAt
+	};
+	const createdRun = await context.store.createRun(run);
+	context.observation.emitRunEvent(createdRun);
+	return {
+		runId: createdRun.id,
+		definition
+	};
+}
+//#endregion
+export { getRunRef, resolveScheduleNextOptions, startRun };

package/dist/engine/state.d.mts

@@ -1,77 +1,47 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.mjs";
+import { WorkflowErrorRecord } from "../types/error.mjs";
 import { WorkflowDefinition } from "../types/definition.mjs";
-import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
 import { ExecutionResult } from "../types/result.mjs";
-import { WorkflowAttributePatch, WorkflowRunRecord, WorkflowRunRetryReason, WorkflowStepIdentity } from "../types/run.mjs";
-import { WorkflowErrorRecord } from "../types/error.mjs";
+import { AttributePatch, RunRecord, RunRetryReason } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowHistory } from "../history/mod.mjs";
-import { WorkflowConditionalEventAppender, WorkflowEventReader, WorkflowLockConditionalWriterRepository, WorkflowLockListerRepository, WorkflowRunConditionalWriterRepository, WorkflowRunReaderRepository, WorkflowRunUnconditionalWriterRepository, WorkflowRunWriterRepository, WorkflowStepAttemptLookup } from "../types/store.mjs";
-import { getRequiredRun } from "../utility.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import { ExecutionLimits } from "../types/engine-options.mjs";
+import { History } from "../history/replay.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/engine/state.d.ts
-interface WorkflowEngineStateLimits {
-  readonly maximumEventHistoryEvents?: number;
-}
-type WorkflowRunLookup = WorkflowRunReaderRepository;
-type WorkflowRunWriter = WorkflowRunUnconditionalWriterRepository;
-type WorkflowRunConditionalWriter = WorkflowRunConditionalWriterRepository;
-type WorkflowRunStateStore = WorkflowRunLookup & WorkflowRunWriter & WorkflowRunWriterRepository;
-type WorkflowCurrentEventAppender = WorkflowConditionalEventAppender;
-type WorkflowLockReleaseStore = WorkflowLockListerRepository & WorkflowLockConditionalWriterRepository;
-type WorkflowChildWakeStore = WorkflowRunStateStore & WorkflowEventReader & WorkflowStepAttemptLookup;
-type WorkflowChildCascadeStore = WorkflowChildWakeStore & WorkflowLockReleaseStore;
-type WorkflowChildRunStateStore = WorkflowChildCascadeStore & WorkflowCurrentEventAppender;
-declare function requireDefinitionMatchesRun<TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, run: WorkflowRunRecord): void;
-declare function appendEventIfCurrentExecution(store: WorkflowCurrentEventAppender, history: WorkflowHistory, event: EventRecord, executionOwner: WorkflowRunRecord, limits: WorkflowEngineStateLimits, beforeAppend?: () => void, afterAppend?: (event: EventRecord, events: readonly EventRecord[]) => void): Promise<void>;
-declare function requireCurrentExecutionOwner(store: WorkflowRunLookup, runId: RunId, executionOwner: WorkflowRunRecord): Promise<void>;
-declare function patchRun(store: WorkflowRunWriter, current: WorkflowRunRecord, patch: Partial<WorkflowRunRecord>): Promise<WorkflowRunRecord>;
-declare function patchRunIfCurrent(store: WorkflowRunConditionalWriter, current: WorkflowRunRecord, patch: Partial<WorkflowRunRecord>): Promise<WorkflowRunRecord | undefined>;
-declare function updateRunMetadataIfCurrent(store: WorkflowRunLookup & WorkflowRunConditionalWriter, runId: RunId, metadata: StorageValue, timestamp: Temporal.Instant): Promise<WorkflowRunRecord>;
-declare function setRunAttributesIfCurrent(store: WorkflowRunLookup & WorkflowRunConditionalWriter, runId: RunId, attributes: WorkflowAttributePatch, timestamp: Temporal.Instant): Promise<WorkflowRunRecord>;
-declare function patchCurrentExecutionRun(store: WorkflowRunLookup & WorkflowRunConditionalWriter, executionOwner: WorkflowRunRecord, patch: Partial<WorkflowRunRecord>): Promise<WorkflowRunRecord | undefined>;
-declare function patchCurrentExecutionRunAttributes(store: WorkflowRunLookup & WorkflowRunConditionalWriter, executionOwner: WorkflowRunRecord, attributes: WorkflowAttributePatch, timestamp: Temporal.Instant): Promise<WorkflowRunRecord | undefined>;
-declare function transitionRunToMissingImplementationWait(run: WorkflowRunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, retryAttempt: number): WorkflowRunRecord;
-declare function transitionRunToFailed(run: WorkflowRunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant, lastTransitionReason: "deadline" | "failed", deadlineAt?: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunToRunning(run: WorkflowRunRecord, timestamp: Temporal.Instant, attempts: number | undefined): WorkflowRunRecord;
-declare function transitionRunToCompleted(run: WorkflowRunRecord, output: StorageValue | undefined, timestamp: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunToExecutionWait(run: WorkflowRunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, options?: {
+export declare const MAX_RUN_UPDATE_ATTEMPTS = 16;
+export declare function requireDefinitionMatchesRun<TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, run: RunRecord): void;
+export declare function appendEventIfCurrentExecution(store: WorkflowStore, history: History, event: EventRecord, executionOwner: RunRecord, limits: ExecutionLimits, beforeAppend?: () => void, afterAppend?: (event: EventRecord, events: readonly EventRecord[]) => void): Promise<void>;
+export declare function requireCurrentExecutionOwner(store: WorkflowStore, executionOwner: RunRecord): Promise<void>;
+export declare function patchRun(store: WorkflowStore, current: RunRecord, patch: Partial<RunRecord>): Promise<RunRecord>;
+export declare function patchRunIfCurrent(store: WorkflowStore, current: RunRecord, patch: Partial<RunRecord>): Promise<RunRecord | undefined>;
+export declare function updateRunMetadataIfCurrent(store: WorkflowStore, runId: RunId, metadata: StorageValue, timestamp: Temporal.Instant): Promise<RunRecord>;
+export declare function setRunAttributesIfCurrent(store: WorkflowStore, runId: RunId, attributes: AttributePatch, timestamp: Temporal.Instant): Promise<RunRecord>;
+export declare function patchCurrentExecutionRun(store: WorkflowStore, executionOwner: RunRecord, patch: Partial<RunRecord>): Promise<RunRecord | undefined>;
+export declare function patchCurrentExecutionRunAttributes(store: WorkflowStore, executionOwner: RunRecord, attributes: AttributePatch, timestamp: Temporal.Instant): Promise<RunRecord | undefined>;
+export declare function transitionRunToRunning(run: RunRecord, timestamp: Temporal.Instant, attempts: number | undefined): RunRecord;
+export declare function transitionRunToCompleted(run: RunRecord, output: StorageValue | undefined, timestamp: Temporal.Instant): RunRecord;
+export declare function transitionRunToFailed(run: RunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant, reason: "deadline" | "failed" | "permanent_failure", deadlineAt?: Temporal.Instant): RunRecord;
+export declare function transitionRunToCanceled(run: RunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant): RunRecord;
+export declare function transitionRunToWaiting(run: RunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): RunRecord;
+/** Waits after an execution suspended, optionally to retry a failed step or workflow. */
+export declare function transitionRunToExecutionWait(run: RunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, options?: {
   readonly retryAt?: Temporal.Instant;
-  readonly retryReason?: WorkflowRunRetryReason;
+  readonly retryReason?: RunRetryReason;
   readonly retryAttempt?: number;
   readonly retryStepId?: string;
   readonly retryStepName?: string;
   readonly error?: WorkflowErrorRecord;
-}): WorkflowRunRecord;
-declare function transitionRunToWaiting(run: WorkflowRunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunToRescheduled(run: WorkflowRunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunAfterStaleLeaseRelease(run: WorkflowRunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunToManualRetry(run: WorkflowRunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, retryAttempt: number): WorkflowRunRecord;
-declare function transitionRunToPermanentFailure(run: WorkflowRunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunToCanceled(run: WorkflowRunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant): WorkflowRunRecord;
-declare function transitionRunAfterParentWake(run: WorkflowRunRecord, timestamp: Temporal.Instant): WorkflowRunRecord;
-declare function isCurrentExecutionOwner(current: WorkflowRunRecord, execution: WorkflowRunRecord): boolean;
-declare function cancelRunWithChildren(store: WorkflowChildCascadeStore, runId: RunId, canceledAt: Temporal.Instant): Promise<WorkflowRunRecord>;
-declare function cancelActiveChildRuns(store: WorkflowChildCascadeStore, parentRunId: RunId, canceledAt: Temporal.Instant): Promise<void>;
-declare function wakeParentRunForTerminalChild(store: WorkflowChildWakeStore, childRun: WorkflowRunRecord, timestamp: Temporal.Instant): Promise<void>;
-declare function wakeParentRunForWaitingChild(store: WorkflowChildWakeStore, childRun: WorkflowRunRecord, availableAt: Temporal.Instant): Promise<void>;
-declare function parentHasActiveChildWorkflowAttemptForRun(store: WorkflowChildWakeStore, parentRunId: RunId, childRun: WorkflowRunRecord): Promise<boolean>;
-declare function parentHasActiveChildWorkflowEventForAttempt(store: WorkflowEventReader, parentRunId: RunId, attempt: WorkflowStepAttemptRecord): Promise<boolean>;
-declare function failRunForDeadline<TOutput>(store: WorkflowChildRunStateStore, run: WorkflowRunRecord, deadlineAt: Temporal.Instant, failedAt: Temporal.Instant, executionOwner?: WorkflowRunRecord): Promise<ExecutionResult<TOutput>>;
-declare function releaseLocksForRun(store: WorkflowLockReleaseStore, runId: RunId, releasedAt: Temporal.Instant): Promise<void>;
-declare class WorkflowSuspended extends Error {
-  readonly availableAt: Temporal.Instant;
-  readonly retryAt?: Temporal.Instant;
-  readonly retryReason?: "step";
-  readonly retryAttempt?: number;
-  readonly retryStep?: WorkflowStepIdentity;
-  constructor(availableAt: Temporal.Instant, context?: Function);
-  static until(this: void, availableAt: Temporal.Instant): never;
-  static forStepRetry(this: void, retryAt: Temporal.Instant, retryStep: WorkflowStepIdentity, retryAttempt: number): never;
-}
-declare class WorkflowStaleExecutionError extends Error {
-  constructor(runId: RunId, context?: Function);
-  static stale(this: void, runId: RunId): never;
-}
-//#endregion
-export { WorkflowStaleExecutionError, WorkflowSuspended, appendEventIfCurrentExecution, cancelActiveChildRuns, cancelRunWithChildren, failRunForDeadline, getRequiredRun, isCurrentExecutionOwner, parentHasActiveChildWorkflowAttemptForRun, parentHasActiveChildWorkflowEventForAttempt, patchCurrentExecutionRun, patchCurrentExecutionRunAttributes, patchRun, patchRunIfCurrent, releaseLocksForRun, requireCurrentExecutionOwner, requireDefinitionMatchesRun, setRunAttributesIfCurrent, transitionRunAfterParentWake, transitionRunAfterStaleLeaseRelease, transitionRunToCanceled, transitionRunToCompleted, transitionRunToExecutionWait, transitionRunToFailed, transitionRunToManualRetry, transitionRunToMissingImplementationWait, transitionRunToPermanentFailure, transitionRunToRescheduled, transitionRunToRunning, transitionRunToWaiting, updateRunMetadataIfCurrent, wakeParentRunForTerminalChild, wakeParentRunForWaitingChild };
+}): RunRecord;
+export declare function transitionRunToMissingImplementationWait(run: RunRecord, error: WorkflowErrorRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, retryAttempt: number): RunRecord;
+export declare function transitionRunAfterStaleLeaseRelease(run: RunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): RunRecord;
+/** Moves the run's next attempt to `availableAt`, keeping its status and retry details. */
+export declare function transitionRunToRescheduled(run: RunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant): RunRecord;
+export declare function transitionRunToManualRetry(run: RunRecord, timestamp: Temporal.Instant, availableAt: Temporal.Instant, retryAttempt: number): RunRecord;
+export declare function isCurrentExecutionOwner(current: RunRecord, execution: RunRecord): boolean;
+export declare function cancelRunWithChildren(store: WorkflowStore, runId: RunId, canceledAt: Temporal.Instant): Promise<RunRecord>;
+/** Makes a waiting parent run available by `at` when one of its child workflow steps changes. */
+export declare function wakeParentRun(store: WorkflowStore, childRun: RunRecord, at: Temporal.Instant): Promise<void>;
+export declare function failRunForDeadline<TOutput>(store: WorkflowStore, definition: WorkflowDefinition<unknown, TOutput, unknown>, run: RunRecord, deadlineAt: Temporal.Instant, failedAt: Temporal.Instant, executionOwner?: RunRecord): Promise<ExecutionResult<TOutput>>;
+export declare function releaseLocksForRun(store: WorkflowStore, runId: RunId, releasedAt: Temporal.Instant): Promise<void>;
+//#endregion