semola 0.6.0 → 0.6.2

package/dist/lib/workflow/index.cjs

@@ -1,537 +1 @@
-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 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 });
-};
-const envelopeDeserialize = (raw) => {
-	const [parseError, parsed] = require_lib_errors_index.mightThrowSync(() => JSON.parse(raw));
-	if (parseError) throw parseError;
-	if (parsed === null) return;
-	if (typeof parsed !== "object") return;
-	if ("value" in parsed) return parsed.value;
-};
-const knownStatuses = [
-	"pending",
-	"running",
-	"completed",
-	"failed",
-	"cancelled"
-];
-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();
-		await this.createExecution(executionId, input);
-		return this.execute(executionId, input);
-	}
-	async run(input, options) {
-		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 execution = await this.get(executionId);
-		if (execution.status === "completed") return {
-			executionId,
-			status: execution.status
-		};
-		if (execution.status === "cancelled") return {
-			executionId,
-			status: execution.status
-		};
-		return this.execute(executionId, execution.input);
-	}
-	async get(executionId) {
-		const status = await this.getMeta(executionId, "status");
-		if (!status) throw new NotFoundError(`Workflow execution ${executionId} not found`);
-		const normalizedStatus = this.normalizeStatus(status);
-		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,
-			input,
-			result,
-			error: errorMessage,
-			createdAt,
-			updatedAt,
-			completedAt,
-			failedAt,
-			cancelledAt,
-			steps
-		};
-	}
-	async cancel(executionId) {
-		const execution = await this.get(executionId);
-		if (execution.status === "completed") throw new StateError(`Workflow execution ${executionId} is already completed`);
-		const timestamp = now();
-		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}`;
-	}
-	metaKey(executionId) {
-		return `${this.executionKey(executionId)}:meta`;
-	}
-	stepsKey(executionId) {
-		return `${this.executionKey(executionId)}:steps`;
-	}
-	lockKey(executionId) {
-		return `${this.executionKey(executionId)}:lock`;
-	}
-	async createExecution(executionId, input) {
-		const serializedInput = this.serializeInput(input);
-		const timestamp = now();
-		if (await this.getMeta(executionId, "status")) throw new StateError(`Workflow execution ${executionId} already exists`);
-		const metadata = {
-			status: "pending",
-			input: serializedInput,
-			result: "",
-			error: "",
-			createdAt: String(timestamp),
-			updatedAt: String(timestamp),
-			completedAt: "",
-			failedAt: "",
-			cancelledAt: "",
-			steps: "[]"
-		};
-		const [writeError] = await require_lib_errors_index.mightThrow(this.options.redis.hset(this.metaKey(executionId), metadata));
-		if (writeError) throw new WorkflowError(`Unable to persist metadata for execution ${executionId}`);
-	}
-	async execute(executionId, input) {
-		const token = crypto.randomUUID();
-		await this.acquireLock(executionId, token);
-		if (await this.getMeta(executionId, "status") === "cancelled") {
-			await this.releaseLock(executionId, token);
-			throw new StateError(`Workflow execution ${executionId} was cancelled`);
-		}
-		const timestamp = now();
-		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 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) => {
-			await this.throwIfCancelled(executionId, () => {
-				controller.abort();
-			});
-			const cachedStep = await this.readStepOutput(executionId, name);
-			if (cachedStep.found) return cachedStep.value;
-			return this.runStepWithRetries(executionId, input, name, handler, controller.signal, () => {
-				controller.abort();
-			});
-		};
-		const handlerOutcome = await require_lib_errors_index.mightThrow(Promise.resolve(this.options.handler({
-			input,
-			executionId,
-			signal: controller.signal,
-			step
-		})));
-		clearInterval(renewTimer);
-		if (lockLost) {
-			await this.releaseLock(executionId, token);
-			throw new LockError(`Lock expired during execution ${executionId}`);
-		}
-		if (await this.isCancelled(executionId)) {
-			const cancelledAt = now();
-			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 {
-				executionId,
-				status: "cancelled"
-			};
-		}
-		const [handlerError, result] = handlerOutcome;
-		if (handlerError) {
-			const failedAt = now();
-			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);
-			throw new ExecutionError(`Workflow execution ${executionId} failed: ${handlerError.message}`);
-		}
-		const [serializeResultError, serializedResult] = require_lib_errors_index.mightThrowSync(() => this.serializeResult(result));
-		if (serializeResultError) {
-			const failedAt = now();
-			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);
-			throw new SerializationError(`Unable to serialize workflow result for ${executionId}`);
-		}
-		const completedAt = now();
-		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 {
-			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) 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) {
-		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
-		]));
-	}
-	async extendLock(executionId, token) {
-		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) 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) {
-		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) 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) 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 value = await this.getMeta(executionId, field);
-		if (!value) return null;
-		const parsed = Number(value);
-		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) 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 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");
-	}
-	deserializeInput(raw) {
-		const deserializer = this.options.deserializeInput ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "workflow input");
-	}
-	serializeResult(result) {
-		if (result === null) return envelopeSerialize(null);
-		return this.runSerializer(result, this.options.serializeResult ?? envelopeSerialize, "workflow result");
-	}
-	deserializeResult(raw) {
-		const deserializer = this.options.deserializeResult ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "workflow result");
-	}
-	serializeStepOutput(output) {
-		return this.runSerializer(output, this.options.serializeStepOutput ?? envelopeSerialize, "step output");
-	}
-	deserializeStepOutput(raw) {
-		const deserializer = this.options.deserializeStepOutput ?? ((value) => envelopeDeserialize(value));
-		return this.runDeserializer(raw, deserializer, "step output");
-	}
-	async readInput(executionId) {
-		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 raw = await this.getMeta(executionId, "result");
-		if (!raw) return null;
-		return this.deserializeResult(raw);
-	}
-	async writeStepOutput(executionId, stepName, output) {
-		const payload = {
-			output: this.serializeStepOutput(output),
-			completedAt: now()
-		};
-		const [payloadError, payloadRaw] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(payload));
-		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) 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") throw new SerializationError(`Unable to persist step history for execution ${executionId}`);
-			await this.setMeta(executionId, "steps", serializedSteps);
-		}
-		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) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
-		if (!payloadRaw) return {
-			found: false,
-			value: null
-		};
-		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") 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;
-		return {
-			found: true,
-			value: this.deserializeStepOutput(outputRaw)
-		};
-	}
-	async readStepNames(executionId) {
-		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)) throw new StateError(`Invalid step index for execution ${executionId}`);
-		const stepNames = [];
-		for (const value of values) if (typeof value === "string") stepNames.push(value);
-		return stepNames;
-	}
-	async readStepSnapshots(executionId) {
-		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) throw new WorkflowError(`Unable to read step ${stepName} for execution ${executionId}`);
-			if (!payloadRaw) continue;
-			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") 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: parsed.completedAt
-			});
-		}
-		return steps;
-	}
-	normalizeStatus(value) {
-		for (const status of knownStatuses) if (status === value) return status;
-		return null;
-	}
-};
-const defineWorkflow = (options) => {
-	const workflow = new WorkflowDefinition(options);
-	return {
-		start: (input, startOptions) => workflow.start(input, startOptions),
-		run: (input, startOptions) => workflow.run(input, startOptions),
-		resume: (executionId) => workflow.resume(executionId),
-		get: (executionId) => workflow.get(executionId),
-		cancel: (executionId) => workflow.cancel(executionId)
-	};
-};
-//#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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../../rolldown-runtime-CMqjfN_6.cjs"),t=require("../errors/index.cjs");let n=require("node:assert");n=e.t(n,1);var r=class extends Error{constructor(e){super(e),this.name=`WorkflowError`}},i=class extends Error{constructor(e){super(e),this.name=`NotFoundError`}},a=class extends Error{constructor(e){super(e),this.name=`StateError`}},o=class extends Error{constructor(e){super(e),this.name=`SerializationError`}},s=class extends Error{constructor(e){super(e),this.name=`ExecutionError`}},c=class extends Error{constructor(e){super(e),this.name=`LockError`}},l=class extends Error{constructor(e){super(e),this.name=`CancelledError`}};const u=()=>Date.now(),d=async(e,t,n)=>{if(t.aborted)throw new l(`Workflow execution was aborted during retry backoff`);let r=u()+e;for(;u()<r;){if(t.aborted)throw new l(`Workflow execution was aborted during retry backoff`);if(n&&await n())throw new l(`Workflow execution was cancelled during retry backoff`);let e=r-u();await new Promise(t=>{setTimeout(t,Math.min(50,e))})}},f=e=>JSON.stringify({value:e}),p=e=>{let[n,r]=t.mightThrowSync(()=>JSON.parse(e));if(n)throw n;if(typeof r==`object`&&r&&`value`in r)return r.value},m=[`pending`,`running`,`completed`,`failed`,`cancelled`];var h=class{options;lockTTL;retries;retryBaseDelay;retryMultiplier;retryMaxDelay;constructor(e){this.options=e,this.lockTTL=e.lockTTL??3e5,this.retries=e.retries??3,this.retryBaseDelay=e.retryBackoff?.baseDelay??1e3,this.retryMultiplier=e.retryBackoff?.multiplier??2,this.retryMaxDelay=e.retryBackoff?.maxDelay??3e4,n.default.ok(Number.isFinite(this.retries)&&this.retries>=0,`Invalid retries: must be a non-negative finite number`),n.default.ok(Number.isFinite(this.retryBaseDelay)&&this.retryBaseDelay>0,`Invalid retryBackoff.baseDelay: must be a positive finite number`),n.default.ok(Number.isFinite(this.retryMultiplier)&&this.retryMultiplier>0,`Invalid retryBackoff.multiplier: must be a positive finite number`),n.default.ok(Number.isFinite(this.retryMaxDelay)&&this.retryMaxDelay>0,`Invalid retryBackoff.maxDelay: must be a positive finite number`)}runHook(e){return t.mightThrow(Promise.resolve().then(()=>e()))}computeBackoffDelay(e){return Math.min(this.retryBaseDelay*this.retryMultiplier**(e-1),this.retryMaxDelay)}async start(e,t){let n=t?.executionId??crypto.randomUUID();return await this.createExecution(n,e),this.scheduleExecution(n,e),{executionId:n,status:`pending`}}async resume(e){let t=await this.get(e);return t.status===`completed`||t.status===`cancelled`?{executionId:e,status:t.status}:(this.scheduleExecution(e,t.input),{executionId:e,status:`pending`})}async get(e){let t=await this.getMeta(e,`status`);if(!t)throw new i(`Workflow execution ${e} not found`);let n=this.normalizeStatus(t);if(!n)throw new a(`Workflow execution ${e} has invalid status ${t}`);let r=await this.readInput(e),o=await this.readResult(e),s=await this.readStepSnapshots(e),c=await this.readNumberMeta(e,`createdAt`),l=await this.readNumberMeta(e,`updatedAt`),u=await this.getMeta(e,`error`),d=await this.readNumberMeta(e,`completedAt`),f=await this.readNumberMeta(e,`failedAt`),p=await this.readNumberMeta(e,`cancelledAt`);if(c===null)throw new a(`Workflow execution ${e} is missing createdAt`);if(l===null)throw new a(`Workflow execution ${e} is missing updatedAt`);return{id:e,name:this.options.name,status:n,input:r,result:o,error:u,createdAt:c,updatedAt:l,completedAt:d,failedAt:f,cancelledAt:p,steps:s}}async cancel(e){let t=await this.get(e);if(t.status===`completed`)throw new a(`Workflow execution ${e} is already completed`);let n=u();return await this.setMeta(e,`status`,`cancelled`),await this.setMeta(e,`updatedAt`,String(n)),await this.setMeta(e,`cancelledAt`,String(n)),await this.setMeta(e,`error`,``),await this.setMeta(e,`failedAt`,``),{executionId:e,createdAt:t.createdAt,cancelledAt:n,updatedAt:n,status:`cancelled`}}executionKey(e){return`workflow:${this.options.name}:execution:${e}`}metaKey(e){return`${this.executionKey(e)}:meta`}stepsKey(e){return`${this.executionKey(e)}:steps`}lockKey(e){return`${this.executionKey(e)}:lock`}async createExecution(e,n){let i=this.serializeInput(n),o=u();if(await this.getMeta(e,`status`))throw new a(`Workflow execution ${e} already exists`);let s={status:`pending`,input:i,result:``,error:``,createdAt:String(o),updatedAt:String(o),completedAt:``,failedAt:``,cancelledAt:``,steps:`[]`},[c]=await t.mightThrow(this.options.redis.hset(this.metaKey(e),s));if(c)throw new r(`Unable to persist metadata for execution ${e}`)}scheduleExecution(e,t){queueMicrotask(()=>{this.executeInBackground(e,t)})}async executeInBackground(e,n){let[r]=await t.mightThrow(this.execute(e,n));if(!r)return;let[i]=await t.mightThrow(this.recordBackgroundFailure(e,r));i&&console.error(`Unable to record background workflow failure`,{executionId:e,error:i})}async recordBackgroundFailure(e,t){if(await this.getMeta(e,`status`)!==`pending`)return;let n=u();await this.setMeta(e,`status`,`failed`),await this.setMeta(e,`error`,t.message),await this.setMeta(e,`updatedAt`,String(n)),await this.setMeta(e,`failedAt`,String(n))}async execute(e,n){let r=crypto.randomUUID();if(await this.acquireLock(e,r),await this.getMeta(e,`status`)===`cancelled`)throw await this.releaseLock(e,r),new a(`Workflow execution ${e} was cancelled`);let i=u();await this.setMeta(e,`status`,`running`),await this.setMeta(e,`updatedAt`,String(i));let l=new AbortController,d=Math.floor(this.lockTTL/3),f=!1,p=setInterval(async()=>{let[n]=await t.mightThrow(this.extendLock(e,r));n&&(f=!0,l.abort(),clearInterval(p))},d);this.options.hooks?.onStart&&await this.runHook(()=>this.options.hooks?.onStart?.({executionId:e,input:n}));let m=await t.mightThrow(Promise.resolve(this.options.handler({input:n,executionId:e,signal:l.signal,step:async(t,r)=>{await this.throwIfCancelled(e,()=>{l.abort()});let i=await this.readStepOutput(e,t);return i.found?i.value:this.runStepWithRetries(e,n,t,r,l.signal,()=>{l.abort()})}})));if(clearInterval(p),f)throw await this.releaseLock(e,r),new c(`Lock expired during execution ${e}`);if(await this.isCancelled(e)){let t=u();return await this.setMeta(e,`status`,`cancelled`),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`cancelledAt`,String(t)),this.options.hooks?.onCancel&&await this.runHook(()=>this.options.hooks?.onCancel?.({executionId:e,input:n})),await this.releaseLock(e,r),{executionId:e,status:`cancelled`}}let[h,g]=m;if(h){let t=u();throw await this.setMeta(e,`status`,`failed`),await this.setMeta(e,`error`,h.message),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`failedAt`,String(t)),await this.releaseLock(e,r),new s(`Workflow execution ${e} failed: ${h.message}`)}let[_,v]=t.mightThrowSync(()=>this.serializeResult(g));if(_){let t=u();throw await this.setMeta(e,`status`,`failed`),await this.setMeta(e,`error`,_.message),await this.setMeta(e,`updatedAt`,String(t)),await this.setMeta(e,`failedAt`,String(t)),await this.releaseLock(e,r),new o(`Unable to serialize workflow result for ${e}`)}let y=u();return await this.setMeta(e,`result`,v),await this.setMeta(e,`status`,`completed`),await this.setMeta(e,`error`,``),await this.setMeta(e,`failedAt`,``),await this.setMeta(e,`updatedAt`,String(y)),await this.setMeta(e,`completedAt`,String(y)),this.options.hooks?.onComplete&&await this.runHook(()=>this.options.hooks?.onComplete?.({executionId:e,input:n,result:g})),await this.releaseLock(e,r),{executionId:e,status:`completed`}}async throwIfCancelled(e,t){if(await this.isCancelled(e))throw t(),new l(`Workflow execution ${e} was cancelled`)}async runStepWithRetries(e,n,r,i,a,o){let s=1,c=[];for(;;){await this.throwIfCancelled(e,o);let[l,f]=await t.mightThrow(Promise.resolve(i(n,a)));if(!l)return await this.writeStepOutput(e,r,f),f;let p=l.message;if(c.push({attempt:s,error:p,timestamp:u()}),s<=this.retries){let i=this.computeBackoffDelay(s);this.options.hooks?.onRetry&&await this.runHook(()=>this.options.hooks?.onRetry?.({executionId:e,input:n,stepName:r,error:p,attempt:s,nextRetryDelayMs:i,retriesRemaining:this.retries-s}));let[o]=await t.mightThrow(d(i,a,()=>this.isCancelled(e)));if(o)throw o;s++;continue}throw this.options.hooks?.onError&&await this.runHook(()=>this.options.hooks?.onError?.({executionId:e,input:n,stepName:r,error:p,totalAttempts:s,errorHistory:c})),l}}async acquireLock(e,n){let[r,i]=await t.mightThrow(this.options.redis.set(this.lockKey(e),n,`PX`,String(this.lockTTL),`NX`));if(r)throw new c(`Unable to acquire lock for execution ${e}`);if(i!==`OK`)throw new c(`Workflow execution ${e} is already running`)}async releaseLock(e,n){await t.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(e),n]))}async extendLock(e,n){let[r,i]=await t.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(e),n,String(this.lockTTL)]));if(r)throw new c(`Unable to extend lock for execution ${e}`);if(i===0)throw new c(`Lock ownership lost for execution ${e}`)}async isCancelled(e){return await this.getMeta(e,`status`)===`cancelled`}async setMeta(e,n,i){let[a]=await t.mightThrow(this.options.redis.hset(this.metaKey(e),n,i));if(a)throw new r(`Unable to persist ${n} for execution ${e}`)}async getMeta(e,n){let[i,o]=await t.mightThrow(this.options.redis.hget(this.metaKey(e),n));if(i)throw new r(`Unable to read ${n} for execution ${e}`);if(o==null)return null;if(typeof o!=`string`)throw new a(`Invalid ${n} value for execution ${e}`);return o.length===0?null:o}async readNumberMeta(e,t){let n=await this.getMeta(e,t);if(!n)return null;let r=Number(n);if(!Number.isFinite(r))throw new a(`Invalid ${t} value for execution ${e}`);return r}runSerializer(e,n,r){let[i,a]=t.mightThrowSync(()=>n(e));if(i)throw new o(`Unable to serialize ${r}: ${i.message}`);if(typeof a!=`string`)throw new o(`${r} serializer must return a string`);return a}runDeserializer(e,n,r){let i=t.mightThrowSync(()=>n(e));if(i[0])throw new o(`Unable to deserialize ${r}: ${i[0].message}`);return i[1]}serializeInput(e){return this.runSerializer(e,this.options.serializeInput??f,`workflow input`)}deserializeInput(e){let t=this.options.deserializeInput??(e=>p(e));return this.runDeserializer(e,t,`workflow input`)}serializeResult(e){return e===null?f(null):this.runSerializer(e,this.options.serializeResult??f,`workflow result`)}deserializeResult(e){let t=this.options.deserializeResult??(e=>p(e));return this.runDeserializer(e,t,`workflow result`)}serializeStepOutput(e){return this.runSerializer(e,this.options.serializeStepOutput??f,`step output`)}deserializeStepOutput(e){let t=this.options.deserializeStepOutput??(e=>p(e));return this.runDeserializer(e,t,`step output`)}async readInput(e){let t=await this.getMeta(e,`input`);if(!t)throw new a(`Workflow execution ${e} input not found`);return this.deserializeInput(t)}async readResult(e){let t=await this.getMeta(e,`result`);return t?this.deserializeResult(t):null}async writeStepOutput(e,n,i){let a={output:this.serializeStepOutput(i),completedAt:u()},[s,c]=t.mightThrowSync(()=>JSON.stringify(a));if(s||typeof c!=`string`)throw new o(`Unable to persist step ${n} output`);let[l]=await t.mightThrow(this.options.redis.hset(this.stepsKey(e),n,c));if(l)throw new r(`Unable to persist step ${n} for execution ${e}`);let d=await this.readStepNames(e);if(!d.includes(n)){let r=[...d,n],[i,a]=t.mightThrowSync(()=>JSON.stringify(r));if(i||typeof a!=`string`)throw new o(`Unable to persist step history for execution ${e}`);await this.setMeta(e,`steps`,a)}await this.setMeta(e,`updatedAt`,String(u()))}async readStepOutput(e,n){let[i,o]=await t.mightThrow(this.options.redis.hget(this.stepsKey(e),n));if(i)throw new r(`Unable to read step ${n} for execution ${e}`);if(!o)return{found:!1,value:null};if(typeof o!=`string`)throw new a(`Invalid step payload for ${n} in execution ${e}`);let[s,c]=t.mightThrowSync(()=>JSON.parse(o));if(s||typeof c!=`object`||!c)throw new a(`Invalid step payload for ${n} in execution ${e}`);if(typeof c.output!=`string`)throw new a(`Invalid step output for ${n} in execution ${e}`);let l=c.output;return{found:!0,value:this.deserializeStepOutput(l)}}async readStepNames(e){let n=await this.getMeta(e,`steps`);if(!n)return[];let[r,i]=t.mightThrowSync(()=>JSON.parse(n));if(r||!Array.isArray(i))throw new a(`Invalid step index for execution ${e}`);let o=[];for(let e of i)typeof e==`string`&&o.push(e);return o}async readStepSnapshots(e){let n=await this.readStepNames(e),i=[];for(let o of n){let[n,s]=await t.mightThrow(this.options.redis.hget(this.stepsKey(e),o));if(n)throw new r(`Unable to read step ${o} for execution ${e}`);if(!s)continue;if(typeof s!=`string`)throw new a(`Invalid step payload for ${o} in execution ${e}`);let[c,l]=t.mightThrowSync(()=>JSON.parse(s));if(c||typeof l!=`object`||!l||typeof l.completedAt!=`number`)throw new a(`Invalid step payload for ${o} in execution ${e}`);i.push({name:o,completedAt:l.completedAt})}return i}normalizeStatus(e){for(let t of m)if(t===e)return t;return null}};const g=e=>{let t=new h(e);return{start:(e,n)=>t.start(e,n),resume:e=>t.resume(e),get:e=>t.get(e),cancel:e=>t.cancel(e)}};exports.CancelledError=l,exports.ExecutionError=s,exports.LockError=c,exports.NotFoundError=i,exports.SerializationError=o,exports.StateError=a,exports.WorkflowError=r,exports.defineWorkflow=g;