semola 0.5.4 → 0.6.0

package/dist/lib/workflow/index.cjs

@@ -1,11 +1,73 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../../chunk-CKQMccvm.cjs");
 const require_lib_errors_index = require("../errors/index.cjs");
+let node_assert = require("node:assert");
+node_assert = require_chunk.__toESM(node_assert);
+//#region src/lib/workflow/errors.ts
+var WorkflowError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WorkflowError";
+	}
+};
+var NotFoundError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NotFoundError";
+	}
+};
+var StateError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "StateError";
+	}
+};
+var SerializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SerializationError";
+	}
+};
+var ExecutionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExecutionError";
+	}
+};
+var LockError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LockError";
+	}
+};
+var CancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CancelledError";
+	}
+};
+//#endregion
 //#region src/lib/workflow/index.ts
 const DEFAULT_LOCK_TTL = 300 * 1e3;
+const DEFAULT_RETRIES = 3;
+const DEFAULT_RETRY_BASE_DELAY = 1e3;
+const DEFAULT_RETRY_MULTIPLIER = 2;
+const DEFAULT_RETRY_MAX_DELAY = 3e4;
 const now = () => Date.now();
-const toErrorMessage = (error) => {
-	if (error instanceof Error) return error.message;
-	return String(error);
+const delay = async (ms, signal, isCancelled) => {
+	if (signal.aborted) throw new CancelledError("Workflow execution was aborted during retry backoff");
+	const deadline = now() + ms;
+	const pollInterval = 50;
+	while (now() < deadline) {
+		if (signal.aborted) throw new CancelledError("Workflow execution was aborted during retry backoff");
+		if (isCancelled) {
+			if (await isCancelled()) throw new CancelledError("Workflow execution was cancelled during retry backoff");
+		}
+		const remaining = deadline - now();
+		await new Promise((resolve) => {
+			setTimeout(resolve, Math.min(pollInterval, remaining));
+		});
+	}
 };
 const envelopeSerialize = (value) => {
 	return JSON.stringify({ value });
@@ -27,69 +89,67 @@ const knownStatuses = [
 var WorkflowDefinition = class {
 	options;
 	lockTTL;
+	retries;
+	retryBaseDelay;
+	retryMultiplier;
+	retryMaxDelay;
 	constructor(options) {
 		this.options = options;
 		this.lockTTL = options.lockTTL ?? DEFAULT_LOCK_TTL;
+		this.retries = options.retries ?? DEFAULT_RETRIES;
+		this.retryBaseDelay = options.retryBackoff?.baseDelay ?? DEFAULT_RETRY_BASE_DELAY;
+		this.retryMultiplier = options.retryBackoff?.multiplier ?? DEFAULT_RETRY_MULTIPLIER;
+		this.retryMaxDelay = options.retryBackoff?.maxDelay ?? DEFAULT_RETRY_MAX_DELAY;
+		node_assert.default.ok(Number.isFinite(this.retries) && this.retries >= 0, "Invalid retries: must be a non-negative finite number");
+		node_assert.default.ok(Number.isFinite(this.retryBaseDelay) && this.retryBaseDelay > 0, "Invalid retryBackoff.baseDelay: must be a positive finite number");
+		node_assert.default.ok(Number.isFinite(this.retryMultiplier) && this.retryMultiplier > 0, "Invalid retryBackoff.multiplier: must be a positive finite number");
+		node_assert.default.ok(Number.isFinite(this.retryMaxDelay) && this.retryMaxDelay > 0, "Invalid retryBackoff.maxDelay: must be a positive finite number");
+	}
+	runHook(hook) {
+		return require_lib_errors_index.mightThrow(Promise.resolve().then(() => hook()));
+	}
+	computeBackoffDelay(attempt) {
+		return Math.min(this.retryBaseDelay * this.retryMultiplier ** (attempt - 1), this.retryMaxDelay);
 	}
 	async start(input, options) {
 		const executionId = options?.executionId ?? crypto.randomUUID();
-		const [createError] = await this.createExecution(executionId, input);
-		if (createError) return require_lib_errors_index.err(createError.type, createError.message);
+		await this.createExecution(executionId, input);
 		return this.execute(executionId, input);
 	}
 	async run(input, options) {
-		const [startError, startData] = await this.start(input, options);
-		if (startError) return require_lib_errors_index.err(startError.type, startError.message);
-		if (!startData) return require_lib_errors_index.err("WorkflowError", "Unexpected empty start result");
-		if (startData.status === "cancelled") return require_lib_errors_index.err("WorkflowCancelledError", `Workflow execution ${startData.executionId} was cancelled`);
-		if (startData.status !== "completed") return require_lib_errors_index.err("WorkflowExecutionError", `Workflow execution ${startData.executionId} did not complete`);
-		const [getError, execution] = await this.get(startData.executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowError", "Unexpected empty execution");
-		return require_lib_errors_index.ok(execution.result);
+		const startData = await this.start(input, options);
+		if (startData.status === "cancelled") throw new CancelledError(`Workflow execution ${startData.executionId} was cancelled`);
+		return (await this.get(startData.executionId)).result;
 	}
 	async resume(executionId) {
-		const [getError, execution] = await this.get(executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return require_lib_errors_index.ok({
+		const execution = await this.get(executionId);
+		if (execution.status === "completed") return {
 			executionId,
 			status: execution.status
-		});
-		if (execution.status === "cancelled") return require_lib_errors_index.ok({
+		};
+		if (execution.status === "cancelled") return {
 			executionId,
 			status: execution.status
-		});
+		};
 		return this.execute(executionId, execution.input);
 	}
 	async get(executionId) {
-		const [statusError, status] = await this.getMeta(executionId, "status");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		if (!status) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
+		const status = await this.getMeta(executionId, "status");
+		if (!status) throw new NotFoundError(`Workflow execution ${executionId} not found`);
 		const normalizedStatus = this.normalizeStatus(status);
-		if (!normalizedStatus) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} has invalid status ${status}`);
-		const [inputError, input] = await this.readInput(executionId);
-		if (inputError) return require_lib_errors_index.err(inputError.type, inputError.message);
-		if (input === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} has invalid input`);
-		const [resultError, result] = await this.readResult(executionId);
-		if (resultError) return require_lib_errors_index.err(resultError.type, resultError.message);
-		const [stepsError, steps] = await this.readStepSnapshots(executionId);
-		if (stepsError) return require_lib_errors_index.err(stepsError.type, stepsError.message);
-		const [createdAtError, createdAt] = await this.readNumberMeta(executionId, "createdAt");
-		if (createdAtError) return require_lib_errors_index.err(createdAtError.type, createdAtError.message);
-		if (createdAt === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is missing createdAt`);
-		const [updatedAtError, updatedAt] = await this.readNumberMeta(executionId, "updatedAt");
-		if (updatedAtError) return require_lib_errors_index.err(updatedAtError.type, updatedAtError.message);
-		if (updatedAt === null) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is missing updatedAt`);
-		const [metaError, errorMessage] = await this.getMeta(executionId, "error");
-		if (metaError) return require_lib_errors_index.err(metaError.type, metaError.message);
-		const [completedAtError, completedAt] = await this.readNumberMeta(executionId, "completedAt");
-		if (completedAtError) return require_lib_errors_index.err(completedAtError.type, completedAtError.message);
-		const [failedAtError, failedAt] = await this.readNumberMeta(executionId, "failedAt");
-		if (failedAtError) return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-		const [cancelledAtError, cancelledAt] = await this.readNumberMeta(executionId, "cancelledAt");
-		if (cancelledAtError) return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-		return require_lib_errors_index.ok({
+		if (!normalizedStatus) throw new StateError(`Workflow execution ${executionId} has invalid status ${status}`);
+		const input = await this.readInput(executionId);
+		const result = await this.readResult(executionId);
+		const steps = await this.readStepSnapshots(executionId);
+		const createdAt = await this.readNumberMeta(executionId, "createdAt");
+		const updatedAt = await this.readNumberMeta(executionId, "updatedAt");
+		const errorMessage = await this.getMeta(executionId, "error");
+		const completedAt = await this.readNumberMeta(executionId, "completedAt");
+		const failedAt = await this.readNumberMeta(executionId, "failedAt");
+		const cancelledAt = await this.readNumberMeta(executionId, "cancelledAt");
+		if (createdAt === null) throw new StateError(`Workflow execution ${executionId} is missing createdAt`);
+		if (updatedAt === null) throw new StateError(`Workflow execution ${executionId} is missing updatedAt`);
+		return {
 			id: executionId,
 			name: this.options.name,
 			status: normalizedStatus,
@@ -102,31 +162,24 @@ var WorkflowDefinition = class {
 			failedAt,
 			cancelledAt,
 			steps
-		});
+		};
 	}
 	async cancel(executionId) {
-		const [getError, execution] = await this.get(executionId);
-		if (getError) return require_lib_errors_index.err(getError.type, getError.message);
-		if (!execution) return require_lib_errors_index.err("WorkflowNotFoundError", `Workflow execution ${executionId} not found`);
-		if (execution.status === "completed") return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} is already completed`);
+		const execution = await this.get(executionId);
+		if (execution.status === "completed") throw new StateError(`Workflow execution ${executionId} is already completed`);
 		const timestamp = now();
-		const [statusError] = await this.setMeta(executionId, "status", "cancelled");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		const [updatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (updatedAtError) return require_lib_errors_index.err(updatedAtError.type, updatedAtError.message);
-		const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(timestamp));
-		if (cancelledAtError) return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-		const [clearErrorError] = await this.setMeta(executionId, "error", "");
-		if (clearErrorError) return require_lib_errors_index.err(clearErrorError.type, clearErrorError.message);
-		const [clearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (clearFailedAtError) return require_lib_errors_index.err(clearFailedAtError.type, clearFailedAtError.message);
-		return require_lib_errors_index.ok({
+		await this.setMeta(executionId, "status", "cancelled");
+		await this.setMeta(executionId, "updatedAt", String(timestamp));
+		await this.setMeta(executionId, "cancelledAt", String(timestamp));
+		await this.setMeta(executionId, "error", "");
+		await this.setMeta(executionId, "failedAt", "");
+		return {
 			executionId,
 			createdAt: execution.createdAt,
 			cancelledAt: timestamp,
 			updatedAt: timestamp,
 			status: "cancelled"
-		});
+		};
 	}
 	executionKey(executionId) {
 		return `workflow:${this.options.name}:execution:${executionId}`;
@@ -141,12 +194,9 @@ var WorkflowDefinition = class {
 		return `${this.executionKey(executionId)}:lock`;
 	}
 	async createExecution(executionId, input) {
-		const [serializeError, serializedInput] = this.serializeInput(input);
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize workflow input for ${executionId}`);
+		const serializedInput = this.serializeInput(input);
 		const timestamp = now();
-		const [statusReadError, existingStatus] = await this.getMeta(executionId, "status");
-		if (statusReadError) return require_lib_errors_index.err(statusReadError.type, statusReadError.message);
-		if (existingStatus) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} already exists`);
+		if (await this.getMeta(executionId, "status")) throw new StateError(`Workflow execution ${executionId} already exists`);
 		const metadata = {
 			status: "pending",
 			input: serializedInput,
@@ -160,61 +210,44 @@ var WorkflowDefinition = class {
 			steps: "[]"
 		};
 		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.metaKey(executionId), metadata));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist metadata for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
+		if (writeError) throw new WorkflowError(`Unable to persist metadata for execution ${executionId}`);
 	}
 	async execute(executionId, input) {
 		const token = crypto.randomUUID();
-		const [lockError] = await this.acquireLock(executionId, token);
-		if (lockError) return require_lib_errors_index.err(lockError.type, lockError.message);
-		const [statusCheckError, currentStatus] = await this.getMeta(executionId, "status");
-		if (statusCheckError) {
+		await this.acquireLock(executionId, token);
+		if (await this.getMeta(executionId, "status") === "cancelled") {
 			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(statusCheckError.type, statusCheckError.message);
-		}
-		if (currentStatus === "cancelled") {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} was cancelled`);
+			throw new StateError(`Workflow execution ${executionId} was cancelled`);
 		}
 		const timestamp = now();
-		const [runningStatusError] = await this.setMeta(executionId, "status", "running");
-		if (runningStatusError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(runningStatusError.type, runningStatusError.message);
-		}
-		const [runningUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(timestamp));
-		if (runningUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(runningUpdatedAtError.type, runningUpdatedAtError.message);
-		}
+		await this.setMeta(executionId, "status", "running");
+		await this.setMeta(executionId, "updatedAt", String(timestamp));
 		const controller = new AbortController();
 		const renewInterval = Math.floor(this.lockTTL / 3);
 		let lockLost = false;
 		const renewTimer = setInterval(async () => {
-			const [renewError] = await this.extendLock(executionId, token);
+			const [renewError] = await require_lib_errors_index.mightThrow(this.extendLock(executionId, token));
 			if (renewError) {
 				lockLost = true;
 				controller.abort();
 				clearInterval(renewTimer);
 			}
 		}, renewInterval);
+		if (this.options.hooks?.onStart) await this.runHook(() => this.options.hooks?.onStart?.({
+			executionId,
+			input
+		}));
 		const step = async (name, handler) => {
-			const [cancelledError, cancelled] = await this.isCancelled(executionId);
-			if (cancelledError) return Promise.reject(new Error(cancelledError.message));
-			if (cancelled) {
+			await this.throwIfCancelled(executionId, () => {
 				controller.abort();
-				return Promise.reject(/* @__PURE__ */ new Error("Workflow cancelled"));
-			}
-			const [readError, cachedStep] = await this.readStepOutput(executionId, name);
-			if (readError) return Promise.reject(new Error(readError.message));
+			});
+			const cachedStep = await this.readStepOutput(executionId, name);
 			if (cachedStep.found) return cachedStep.value;
-			const [stepError, output] = await require_lib_errors_index.mightThrow(Promise.resolve(handler(input, controller.signal)));
-			if (stepError) return Promise.reject(stepError);
-			const [writeError] = await this.writeStepOutput(executionId, name, output);
-			if (writeError) return Promise.reject(new Error(writeError.message));
-			return output;
+			return this.runStepWithRetries(executionId, input, name, handler, controller.signal, () => {
+				controller.abort();
+			});
 		};
-		const [handlerError, result] = await require_lib_errors_index.mightThrow(Promise.resolve(this.options.handler({
+		const handlerOutcome = await require_lib_errors_index.mightThrow(Promise.resolve(this.options.handler({
 			input,
 			executionId,
 			signal: controller.signal,
@@ -223,188 +256,166 @@ var WorkflowDefinition = class {
 		clearInterval(renewTimer);
 		if (lockLost) {
 			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowLockError", `Lock expired during execution ${executionId}`);
-		}
-		const [cancelledError, cancelled] = await this.isCancelled(executionId);
-		if (cancelledError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(cancelledError.type, cancelledError.message);
+			throw new LockError(`Lock expired during execution ${executionId}`);
 		}
-		if (cancelled) {
+		if (await this.isCancelled(executionId)) {
 			const cancelledAt = now();
-			const [cancelledStatusError] = await this.setMeta(executionId, "status", "cancelled");
-			if (cancelledStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledStatusError.type, cancelledStatusError.message);
-			}
-			const [cancelledUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(cancelledAt));
-			if (cancelledUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledUpdatedAtError.type, cancelledUpdatedAtError.message);
-			}
-			const [cancelledAtError] = await this.setMeta(executionId, "cancelledAt", String(cancelledAt));
-			if (cancelledAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(cancelledAtError.type, cancelledAtError.message);
-			}
+			await this.setMeta(executionId, "status", "cancelled");
+			await this.setMeta(executionId, "updatedAt", String(cancelledAt));
+			await this.setMeta(executionId, "cancelledAt", String(cancelledAt));
+			if (this.options.hooks?.onCancel) await this.runHook(() => this.options.hooks?.onCancel?.({
+				executionId,
+				input
+			}));
 			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.ok({
+			return {
 				executionId,
 				status: "cancelled"
-			});
+			};
 		}
+		const [handlerError, result] = handlerOutcome;
 		if (handlerError) {
 			const failedAt = now();
-			const [failedStatusError] = await this.setMeta(executionId, "status", "failed");
-			if (failedStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", toErrorMessage(handlerError));
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-			}
+			await this.setMeta(executionId, "status", "failed");
+			await this.setMeta(executionId, "error", handlerError.message);
+			await this.setMeta(executionId, "updatedAt", String(failedAt));
+			await this.setMeta(executionId, "failedAt", String(failedAt));
 			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowExecutionError", `Workflow execution ${executionId} failed: ${toErrorMessage(handlerError)}`);
+			throw new ExecutionError(`Workflow execution ${executionId} failed: ${handlerError.message}`);
 		}
-		const [serializeResultError, serializedResult] = this.serializeResult(result);
+		const [serializeResultError, serializedResult] = require_lib_errors_index.mightThrowSync(() => this.serializeResult(result));
 		if (serializeResultError) {
 			const failedAt = now();
-			const [failedStatusError] = await this.setMeta(executionId, "status", "failed");
-			if (failedStatusError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedStatusError.type, failedStatusError.message);
-			}
-			const [failedMessageError] = await this.setMeta(executionId, "error", serializeResultError.message);
-			if (failedMessageError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedMessageError.type, failedMessageError.message);
-			}
-			const [failedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(failedAt));
-			if (failedUpdatedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedUpdatedAtError.type, failedUpdatedAtError.message);
-			}
-			const [failedAtError] = await this.setMeta(executionId, "failedAt", String(failedAt));
-			if (failedAtError) {
-				await this.releaseLock(executionId, token);
-				return require_lib_errors_index.err(failedAtError.type, failedAtError.message);
-			}
+			await this.setMeta(executionId, "status", "failed");
+			await this.setMeta(executionId, "error", serializeResultError.message);
+			await this.setMeta(executionId, "updatedAt", String(failedAt));
+			await this.setMeta(executionId, "failedAt", String(failedAt));
 			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize workflow result for ${executionId}`);
+			throw new SerializationError(`Unable to serialize workflow result for ${executionId}`);
 		}
 		const completedAt = now();
-		const [completedResultError] = await this.setMeta(executionId, "result", serializedResult);
-		if (completedResultError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedResultError.type, completedResultError.message);
-		}
-		const [completedStatusError] = await this.setMeta(executionId, "status", "completed");
-		if (completedStatusError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedStatusError.type, completedStatusError.message);
-		}
-		const [completedClearErrorError] = await this.setMeta(executionId, "error", "");
-		if (completedClearErrorError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedClearErrorError.type, completedClearErrorError.message);
-		}
-		const [completedClearFailedAtError] = await this.setMeta(executionId, "failedAt", "");
-		if (completedClearFailedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedClearFailedAtError.type, completedClearFailedAtError.message);
-		}
-		const [completedUpdatedAtError] = await this.setMeta(executionId, "updatedAt", String(completedAt));
-		if (completedUpdatedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedUpdatedAtError.type, completedUpdatedAtError.message);
-		}
-		const [completedAtError] = await this.setMeta(executionId, "completedAt", String(completedAt));
-		if (completedAtError) {
-			await this.releaseLock(executionId, token);
-			return require_lib_errors_index.err(completedAtError.type, completedAtError.message);
-		}
+		await this.setMeta(executionId, "result", serializedResult);
+		await this.setMeta(executionId, "status", "completed");
+		await this.setMeta(executionId, "error", "");
+		await this.setMeta(executionId, "failedAt", "");
+		await this.setMeta(executionId, "updatedAt", String(completedAt));
+		await this.setMeta(executionId, "completedAt", String(completedAt));
+		if (this.options.hooks?.onComplete) await this.runHook(() => this.options.hooks?.onComplete?.({
+			executionId,
+			input,
+			result
+		}));
 		await this.releaseLock(executionId, token);
-		return require_lib_errors_index.ok({
+		return {
 			executionId,
 			status: "completed"
-		});
+		};
+	}
+	async throwIfCancelled(executionId, abort) {
+		if (await this.isCancelled(executionId)) {
+			abort();
+			throw new CancelledError(`Workflow execution ${executionId} was cancelled`);
+		}
+	}
+	async runStepWithRetries(executionId, input, stepName, handler, signal, abort) {
+		let attempt = 1;
+		const errorHistory = [];
+		while (true) {
+			await this.throwIfCancelled(executionId, abort);
+			const [stepError, output] = await require_lib_errors_index.mightThrow(Promise.resolve(handler(input, signal)));
+			if (!stepError) {
+				await this.writeStepOutput(executionId, stepName, output);
+				return output;
+			}
+			const errorMsg = stepError.message;
+			errorHistory.push({
+				attempt,
+				error: errorMsg,
+				timestamp: now()
+			});
+			if (attempt <= this.retries) {
+				const nextRetryDelayMs = this.computeBackoffDelay(attempt);
+				if (this.options.hooks?.onRetry) await this.runHook(() => this.options.hooks?.onRetry?.({
+					executionId,
+					input,
+					stepName,
+					error: errorMsg,
+					attempt,
+					nextRetryDelayMs,
+					retriesRemaining: this.retries - attempt
+				}));
+				const [delayError] = await require_lib_errors_index.mightThrow(delay(nextRetryDelayMs, signal, () => this.isCancelled(executionId)));
+				if (delayError) throw delayError;
+				attempt++;
+				continue;
+			}
+			if (this.options.hooks?.onError) await this.runHook(() => this.options.hooks?.onError?.({
+				executionId,
+				input,
+				stepName,
+				error: errorMsg,
+				totalAttempts: attempt,
+				errorHistory
+			}));
+			throw stepError;
+		}
 	}
 	async acquireLock(executionId, token) {
 		const [lockError, lockResult] = await require_lib_errors_index.mightThrow(this.options.redis.set(this.lockKey(executionId), token, "PX", String(this.lockTTL), "NX"));
-		if (lockError) return require_lib_errors_index.err("WorkflowLockError", `Unable to acquire lock for execution ${executionId}`);
-		if (lockResult !== "OK") return require_lib_errors_index.err("WorkflowLockError", `Workflow execution ${executionId} is already running`);
-		return require_lib_errors_index.ok(null);
+		if (lockError) throw new LockError(`Unable to acquire lock for execution ${executionId}`);
+		if (lockResult !== "OK") throw new LockError(`Workflow execution ${executionId} is already running`);
 	}
 	async releaseLock(executionId, token) {
-		const [evalError] = await require_lib_errors_index.mightThrow(this.options.redis.send("EVAL", [
+		await require_lib_errors_index.mightThrow(this.options.redis.send("EVAL", [
 			"if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end",
 			"1",
 			this.lockKey(executionId),
 			token
 		]));
-		if (evalError) return require_lib_errors_index.err("WorkflowLockError", `Unable to release lock for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
 	}
 	async extendLock(executionId, token) {
-		const [evalError, result] = await require_lib_errors_index.mightThrow(this.options.redis.send("EVAL", [
+		const [evalError, extendResult] = await require_lib_errors_index.mightThrow(this.options.redis.send("EVAL", [
 			"if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('PEXPIRE', KEYS[1], ARGV[2]) else return 0 end",
 			"1",
 			this.lockKey(executionId),
 			token,
 			String(this.lockTTL)
 		]));
-		if (evalError) return require_lib_errors_index.err("WorkflowLockError", `Unable to extend lock for execution ${executionId}`);
-		if (result === 0) return require_lib_errors_index.err("WorkflowLockError", `Lock ownership lost for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
+		if (evalError) throw new LockError(`Unable to extend lock for execution ${executionId}`);
+		if (extendResult === 0) throw new LockError(`Lock ownership lost for execution ${executionId}`);
 	}
 	async isCancelled(executionId) {
-		const [statusError, status] = await this.getMeta(executionId, "status");
-		if (statusError) return require_lib_errors_index.err(statusError.type, statusError.message);
-		return require_lib_errors_index.ok(status === "cancelled");
+		return await this.getMeta(executionId, "status") === "cancelled";
 	}
 	async setMeta(executionId, field, value) {
 		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.metaKey(executionId), field, value));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist ${field} for execution ${executionId}`);
-		return require_lib_errors_index.ok(null);
+		if (writeError) throw new WorkflowError(`Unable to persist ${field} for execution ${executionId}`);
 	}
 	async getMeta(executionId, field) {
 		const [readError, value] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.metaKey(executionId), field));
-		if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read ${field} for execution ${executionId}`);
-		if (value === null || value === void 0) return require_lib_errors_index.ok(null);
-		if (typeof value !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		if (value.length === 0) return require_lib_errors_index.ok(null);
-		return require_lib_errors_index.ok(value);
+		if (readError) throw new WorkflowError(`Unable to read ${field} for execution ${executionId}`);
+		if (value === null || value === void 0) return null;
+		if (typeof value !== "string") throw new StateError(`Invalid ${field} value for execution ${executionId}`);
+		if (value.length === 0) return null;
+		return value;
 	}
 	async readNumberMeta(executionId, field) {
-		const [readError, value] = await this.getMeta(executionId, field);
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!value) return require_lib_errors_index.ok(null);
+		const value = await this.getMeta(executionId, field);
+		if (!value) return null;
 		const parsed = Number(value);
-		if (!Number.isFinite(parsed)) return require_lib_errors_index.err("WorkflowStateError", `Invalid ${field} value for execution ${executionId}`);
-		return require_lib_errors_index.ok(parsed);
+		if (!Number.isFinite(parsed)) throw new StateError(`Invalid ${field} value for execution ${executionId}`);
+		return parsed;
 	}
 	runSerializer(value, serializer, label) {
 		const [serializeError, serialized] = require_lib_errors_index.mightThrowSync(() => serializer(value));
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize ${label}: ${toErrorMessage(serializeError)}`);
-		if (typeof serialized !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `${label} serializer must return a string`);
-		return require_lib_errors_index.ok(serialized);
+		if (serializeError) throw new SerializationError(`Unable to serialize ${label}: ${serializeError.message}`);
+		if (typeof serialized !== "string") throw new SerializationError(`${label} serializer must return a string`);
+		return serialized;
 	}
 	runDeserializer(raw, deserializer, label) {
-		const [deserializeError, value] = require_lib_errors_index.mightThrowSync(() => deserializer(raw));
-		if (deserializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to deserialize ${label}: ${toErrorMessage(deserializeError)}`);
-		return require_lib_errors_index.ok(value);
+		const result = require_lib_errors_index.mightThrowSync(() => deserializer(raw));
+		if (result[0]) throw new SerializationError(`Unable to deserialize ${label}: ${result[0].message}`);
+		return result[1];
 	}
 	serializeInput(input) {
 		return this.runSerializer(input, this.options.serializeInput ?? envelopeSerialize, "workflow input");
@@ -414,7 +425,7 @@ var WorkflowDefinition = class {
 		return this.runDeserializer(raw, deserializer, "workflow input");
 	}
 	serializeResult(result) {
-		if (result === null) return require_lib_errors_index.ok(envelopeSerialize(null));
+		if (result === null) return envelopeSerialize(null);
 		return this.runSerializer(result, this.options.serializeResult ?? envelopeSerialize, "workflow result");
 	}
 	deserializeResult(raw) {
@@ -429,91 +440,76 @@ var WorkflowDefinition = class {
 		return this.runDeserializer(raw, deserializer, "step output");
 	}
 	async readInput(executionId) {
-		const [readError, raw] = await this.getMeta(executionId, "input");
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!raw) return require_lib_errors_index.err("WorkflowStateError", `Workflow execution ${executionId} input not found`);
+		const raw = await this.getMeta(executionId, "input");
+		if (!raw) throw new StateError(`Workflow execution ${executionId} input not found`);
 		return this.deserializeInput(raw);
 	}
 	async readResult(executionId) {
-		const [readError, raw] = await this.getMeta(executionId, "result");
-		if (readError) return require_lib_errors_index.err(readError.type, readError.message);
-		if (!raw) return require_lib_errors_index.ok(null);
-		const [deserializeError, result] = this.deserializeResult(raw);
-		if (deserializeError) return require_lib_errors_index.err(deserializeError.type, deserializeError.message);
-		return require_lib_errors_index.ok(result);
+		const raw = await this.getMeta(executionId, "result");
+		if (!raw) return null;
+		return this.deserializeResult(raw);
 	}
 	async writeStepOutput(executionId, stepName, output) {
-		const [serializeError, serializedOutput] = this.serializeStepOutput(output);
-		if (serializeError) return require_lib_errors_index.err("WorkflowSerializationError", `Unable to serialize step ${stepName} output`);
 		const payload = {
-			output: serializedOutput,
+			output: this.serializeStepOutput(output),
 			completedAt: now()
 		};
 		const [payloadError, payloadRaw] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(payload));
-		if (payloadError || typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `Unable to persist step ${stepName} output`);
+		if (payloadError || typeof payloadRaw !== "string") throw new SerializationError(`Unable to persist step ${stepName} output`);
 		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.stepsKey(executionId), stepName, payloadRaw));
-		if (writeError) return require_lib_errors_index.err("WorkflowError", `Unable to persist step ${stepName} for execution ${executionId}`);
-		const [stepNamesError, stepNames] = await this.readStepNames(executionId);
-		if (stepNamesError) return require_lib_errors_index.err(stepNamesError.type, stepNamesError.message);
+		if (writeError) throw new WorkflowError(`Unable to persist step ${stepName} for execution ${executionId}`);
+		const stepNames = await this.readStepNames(executionId);
 		if (!stepNames.includes(stepName)) {
 			const nextStepNames = [...stepNames, stepName];
 			const [serializeStepsError, serializedSteps] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(nextStepNames));
-			if (serializeStepsError || typeof serializedSteps !== "string") return require_lib_errors_index.err("WorkflowSerializationError", `Unable to persist step history for execution ${executionId}`);
-			const [updateStepsError] = await this.setMeta(executionId, "steps", serializedSteps);
-			if (updateStepsError) return require_lib_errors_index.err(updateStepsError.type, updateStepsError.message);
+			if (serializeStepsError || typeof serializedSteps !== "string") throw new SerializationError(`Unable to persist step history for execution ${executionId}`);
+			await this.setMeta(executionId, "steps", serializedSteps);
 		}
-		const [updatedError] = await this.setMeta(executionId, "updatedAt", String(now()));
-		if (updatedError) return require_lib_errors_index.err(updatedError.type, updatedError.message);
-		return require_lib_errors_index.ok(null);
+		await this.setMeta(executionId, "updatedAt", String(now()));
 	}
 	async readStepOutput(executionId, stepName) {
 		const [readError, payloadRaw] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-		if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
-		if (!payloadRaw) return require_lib_errors_index.ok({
+		if (readError) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
+		if (!payloadRaw) return {
 			found: false,
 			value: null
-		});
-		if (typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
+		};
+		if (typeof payloadRaw !== "string") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
 		const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(payloadRaw));
-		if (parseError || parsed === null || typeof parsed !== "object") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-		if (typeof parsed.output !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step output for ${stepName} in execution ${executionId}`);
+		if (parseError || parsed === null || typeof parsed !== "object") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
+		if (typeof parsed.output !== "string") throw new StateError(`Invalid step output for ${stepName} in execution ${executionId}`);
 		const outputRaw = parsed.output;
-		const [deserializeError, value] = this.deserializeStepOutput(outputRaw);
-		if (deserializeError) return require_lib_errors_index.err(deserializeError.type, deserializeError.message);
-		return require_lib_errors_index.ok({
+		return {
 			found: true,
-			value
-		});
+			value: this.deserializeStepOutput(outputRaw)
+		};
 	}
 	async readStepNames(executionId) {
-		const [readError, stepsRaw] = await this.getMeta(executionId, "steps");
-		if (readError) return [readError, []];
-		if (!stepsRaw) return require_lib_errors_index.ok([]);
+		const stepsRaw = await this.getMeta(executionId, "steps");
+		if (!stepsRaw) return [];
 		const [parseError, values] = require_lib_errors_index.mightThrowSync(() => JSON.parse(stepsRaw));
-		if (parseError || !Array.isArray(values)) return require_lib_errors_index.err("WorkflowStateError", `Invalid step index for execution ${executionId}`);
+		if (parseError || !Array.isArray(values)) throw new StateError(`Invalid step index for execution ${executionId}`);
 		const stepNames = [];
 		for (const value of values) if (typeof value === "string") stepNames.push(value);
-		return require_lib_errors_index.ok(stepNames);
+		return stepNames;
 	}
 	async readStepSnapshots(executionId) {
-		const [stepNamesError, stepNames] = await this.readStepNames(executionId);
-		if (stepNamesError) return [stepNamesError, []];
+		const stepNames = await this.readStepNames(executionId);
 		const steps = [];
 		for (const stepName of stepNames) {
 			const [readError, payloadRaw] = await require_lib_errors_index.mightThrow(this.options.redis.hget(this.stepsKey(executionId), stepName));
-			if (readError) return require_lib_errors_index.err("WorkflowError", `Unable to read step ${stepName} for execution ${executionId}`);
+			if (readError) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
 			if (!payloadRaw) continue;
-			if (typeof payloadRaw !== "string") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
+			if (typeof payloadRaw !== "string") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
 			const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(payloadRaw));
-			if (parseError || parsed === null || typeof parsed !== "object") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			if (typeof parsed.completedAt !== "number") return require_lib_errors_index.err("WorkflowStateError", `Invalid step payload for ${stepName} in execution ${executionId}`);
-			const completedAt = parsed.completedAt;
+			if (parseError || parsed === null || typeof parsed !== "object") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
+			if (typeof parsed.completedAt !== "number") throw new StateError(`Invalid step payload for ${stepName} in execution ${executionId}`);
 			steps.push({
 				name: stepName,
-				completedAt
+				completedAt: parsed.completedAt
 			});
 		}
-		return require_lib_errors_index.ok(steps);
+		return steps;
 	}
 	normalizeStatus(value) {
 		for (const status of knownStatuses) if (status === value) return status;
@@ -531,4 +527,11 @@ const defineWorkflow = (options) => {
 	};
 };
 //#endregion
+exports.CancelledError = CancelledError;
+exports.ExecutionError = ExecutionError;
+exports.LockError = LockError;
+exports.NotFoundError = NotFoundError;
+exports.SerializationError = SerializationError;
+exports.StateError = StateError;
+exports.WorkflowError = WorkflowError;
 exports.defineWorkflow = defineWorkflow;