@voltro/workflow 0.33.0 → 0.35.0

package/dist/src-DPkbBZDD.js

@@ -0,0 +1,2501 @@
+import { E as e, F as t, I as n, M as r, N as i, P as a, T as o, w as s } from "./primitives-CyQZeT1t.js";
+import { Activity as c, DurableClock as l, DurableDeferred as u, Workflow as d, WorkflowEngine as f } from "@effect/workflow";
+import { Cause as p, Effect as m, Either as h, Exit as g, FiberRef as _, Layer as v, Schema as y } from "effect";
+import { and as b, boolean as ee, eq as x, generateId as S, gt as C, gte as te, id as w, inSet as ne, integer as T, isNull as E, json as D, lt as O, or as k, queryFor as A, reference as re, registerRetention as ie, retentionTtlMsFromEnv as ae, table as j, text as M, timestamp as N } from "@voltro/database";
+import { createHash as oe } from "node:crypto";
+import { WorkflowInstance as se } from "@effect/workflow/WorkflowEngine";
+import { publishServerError as ce } from "@voltro/protocol";
+//#region src/inMemoryLayer.ts
+var le = f.layerMemory, P = j("_voltro_workflow_runs", {
+	id: w({ prefix: "wfrun" }),
+	tag: M(),
+	executionId: M().unique(),
+	status: M().oneOf([
+		"running",
+		"succeeded",
+		"failed",
+		"cancelled",
+		"suspended"
+	]).default("running"),
+	payload: D(),
+	workflowVersion: M().nullable(),
+	workflowPatches: D().nullable(),
+	runnerEnteredAt: N().nullable(),
+	reclaimCount: T().default(0),
+	output: D().nullable(),
+	subject: D().nullable(),
+	source: M().nullable(),
+	errorTag: M().nullable(),
+	errorMessage: M().nullable(),
+	cancelled: ee().default(!1),
+	discardedAt: N().nullable(),
+	discardedBy: M().nullable(),
+	startedAt: N().default("now"),
+	completedAt: N().nullable(),
+	durationMs: T().nullable(),
+	traceId: M().nullable(),
+	parentExecutionId: M().nullable(),
+	parentClosePolicy: M().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable()
+}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), ue = j("_voltro_workflow_run_steps", {
+	id: w({ prefix: "wfstep" }),
+	runId: re(() => P, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	stepName: M(),
+	attempt: T().default(1),
+	status: M().oneOf([
+		"running",
+		"succeeded",
+		"failed"
+	]).default("running"),
+	input: D().nullable(),
+	retryPolicy: D().nullable(),
+	output: D().nullable(),
+	errorTag: M().nullable(),
+	errorMessage: M().nullable(),
+	errorCause: D().nullable(),
+	startedAt: N().default("now"),
+	completedAt: N().nullable(),
+	durationMs: T().nullable()
+}).index(["runId", "stepName"]).index(["startedAt"]), de = j("_voltro_workflow_run_events", {
+	id: w({ prefix: "wfev" }),
+	runId: re(() => P, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	eventType: M(),
+	payload: D().nullable(),
+	occurredAt: N().default("now"),
+	stepName: M().nullable(),
+	attempt: T().nullable()
+}).index(["runId", "occurredAt"]).index(["eventType"]), fe = j("_voltro_workflow_start_contexts", {
+	id: w({ prefix: "wfctx" }),
+	workflowName: M(),
+	executionId: M().unique(),
+	subject: D().nullable(),
+	traceId: M().nullable(),
+	source: M().nullable(),
+	parentExecutionId: M().nullable(),
+	parentClosePolicy: M().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable(),
+	createdAt: N().default("now")
+}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), pe = j("_voltro_workflow_pending", {
+	id: w({ prefix: "wfp" }),
+	tenantId: M().nullable(),
+	workflowName: M(),
+	controlKey: M(),
+	mode: M().oneOf([
+		"debounce",
+		"batch",
+		"throttle",
+		"concurrency",
+		"paused"
+	]),
+	payload: D(),
+	callerContext: D().nullable(),
+	priority: T().default(0),
+	dueAt: N(),
+	deadlineAt: N().nullable(),
+	collapsed: T().default(1),
+	firstSeenAt: N().default("now"),
+	updatedAt: N().default("now"),
+	attempts: T().default(0),
+	lastError: M().nullable()
+}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), me = j("_voltro_workflow_admissions", {
+	id: w({ prefix: "wfadm" }),
+	tenantId: M().nullable(),
+	workflowName: M(),
+	outcome: M().oneOf([
+		"admitted",
+		"dropped",
+		"skipped",
+		"evicted",
+		"expired",
+		"discarded"
+	]),
+	mode: M().nullable(),
+	reason: M().nullable(),
+	collapsed: T().default(1),
+	waitedMs: T().nullable(),
+	executionId: M().nullable(),
+	runId: M().nullable(),
+	singletonKey: M().nullable(),
+	concurrencyKey: M().nullable(),
+	rateKey: M().nullable(),
+	admittedAt: N().default("now"),
+	expiresAt: N().nullable(),
+	releasedAt: N().nullable()
+}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), he = j("_voltro_workflow_pauses", {
+	id: w({ prefix: "wfpause" }),
+	pausedAt: N().default("now"),
+	pausedBy: M().nullable(),
+	reason: M().nullable()
+}), ge = class extends Error {
+	workflowName;
+	field;
+	constructor(e, t, n) {
+		super(`workflow '${e}': ${t}(payload) threw — a flow-control key function must be total over every payload the workflow accepts, because it runs before the run exists and there is nowhere to report a partial failure to. Cause: ${n instanceof Error ? n.message : String(n)}`), this.name = "FlowControlKeyError", this.workflowName = e, this.field = t, this.cause = n;
+	}
+}, F = (e, t, n, r) => {
+	try {
+		let e = n(r);
+		if (typeof e != "string" || e.length === 0) throw Error(`returned ${e === "" ? "an empty string" : String(e)}; expected a non-empty string`);
+		return e;
+	} catch (n) {
+		throw new ge(e, t, n);
+	}
+}, _e = (e, t) => e === void 0 ? t : `pool\u0000${e}\u0000${t}`, I = (e, t) => {
+	let n = e.workflowName, r = 0;
+	if (e.priority !== void 0) try {
+		let n = e.priority(t);
+		if (!Number.isFinite(n)) throw Error(`returned ${String(n)}; expected a finite number`);
+		r = Math.trunc(n);
+	} catch (e) {
+		throw new ge(n, "priority", e);
+	}
+	return {
+		...e.debounce === void 0 ? {} : { debounceKey: F(n, "debounce.key", e.debounce.key, t) },
+		...e.singleton === void 0 ? {} : { singletonKey: F(n, "singleton.key", e.singleton.key, t) },
+		...e.concurrency === void 0 ? {} : { concurrencyKey: _e(e.concurrency.pool, e.concurrency.key === void 0 ? "" : F(n, "concurrency.key", e.concurrency.key, t)) },
+		...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: F(n, "throttle.key", e.throttle.key, t) },
+		...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: F(n, "rateLimit.key", e.rateLimit.key, t) },
+		...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey: F(n, "batch.key", e.batch.key, t) },
+		priority: r
+	};
+}, ve = (e, t, n, r) => {
+	let i = e.filter((e) => e > r - n);
+	if (i.length < t) return;
+	let a = [...i].sort((e, t) => t - e)[t - 1];
+	if (a !== void 0) return a + n;
+}, ye = (e) => {
+	let { control: t, keys: n, state: r, now: i, reconsidering: a } = e;
+	if (r.paused === !0) return {
+		kind: "defer",
+		mode: "paused",
+		dueAt: i,
+		collapse: a ? "hold" : "append",
+		keys: n
+	};
+	if (t.rateLimit !== void 0) {
+		let e = ve(r.recentAdmissions ?? [], t.rateLimit.limit, t.rateLimit.periodMs, i);
+		if (e !== void 0) return {
+			kind: "drop",
+			reason: "rate-limit",
+			retryAfterMs: Math.max(0, e - i),
+			keys: n
+		};
+	}
+	if (t.singleton !== void 0 && t.singleton.mode === "skip" && r.singletonHolder !== void 0) return {
+		kind: "skip",
+		incumbent: r.singletonHolder,
+		keys: n
+	};
+	if (t.debounce !== void 0) {
+		let e = r.debouncePending, o = e?.firstSeenAt ?? i, s = e?.deadlineAt ?? (t.debounce.timeoutMs === void 0 ? void 0 : o + t.debounce.timeoutMs);
+		return a ? s !== void 0 && i >= s ? {
+			kind: "admit",
+			reason: "debounce-deadline",
+			keys: n,
+			...L(t, r)
+		} : {
+			kind: "admit",
+			reason: "debounce-elapsed",
+			keys: n,
+			...L(t, r)
+		} : {
+			kind: "defer",
+			mode: "debounce",
+			dueAt: s === void 0 ? i + t.debounce.periodMs : Math.min(i + t.debounce.periodMs, s),
+			...s === void 0 ? {} : { deadlineAt: s },
+			collapse: "replace",
+			keys: n
+		};
+	}
+	if (t.batch !== void 0) {
+		let e = r.batchPending, o = (e?.count ?? 0) + +!a, s = (e?.firstSeenAt ?? i) + t.batch.timeoutMs;
+		return o >= t.batch.maxSize ? {
+			kind: "admit",
+			reason: "batch-full",
+			keys: n,
+			...L(t, r)
+		} : a && i >= s ? {
+			kind: "admit",
+			reason: "batch-timeout",
+			keys: n,
+			...L(t, r)
+		} : {
+			kind: "defer",
+			mode: "batch",
+			dueAt: s,
+			collapse: a ? "hold" : "append",
+			keys: n
+		};
+	}
+	if (t.throttle !== void 0) {
+		let e = ve(r.recentAdmissions ?? [], t.throttle.limit, t.throttle.periodMs, i);
+		if (e !== void 0) return {
+			kind: "defer",
+			mode: "throttle",
+			dueAt: e,
+			collapse: a ? "hold" : "append",
+			keys: n
+		};
+	}
+	return t.concurrency !== void 0 && (r.inFlight ?? 0) >= t.concurrency.limit ? {
+		kind: "defer",
+		mode: "concurrency",
+		dueAt: i,
+		collapse: a ? "hold" : "append",
+		keys: n
+	} : {
+		kind: "admit",
+		reason: be(t) ? "under-limits" : "no-controls",
+		keys: n,
+		...L(t, r)
+	};
+}, be = (e) => e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0, L = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, xe = (e, t, n) => {
+	let r = e.timeouts?.startMs;
+	return r !== void 0 && n - t.firstSeenAt >= r;
+}, Se = (e, t, n) => {
+	let r = e.timeouts?.finishMs;
+	return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
+}, Ce = (e, t) => e.priority === t.priority ? e.firstSeenAt === t.firstSeenAt ? e.id < t.id ? -1 : +(e.id > t.id) : e.firstSeenAt - t.firstSeenAt : t.priority - e.priority, R = "_voltro_workflow_pending", z = "_voltro_workflow_admissions", we = "_voltro_workflow_pauses", Te = 1440 * 60 * 1e3, Ee = (e, t, n) => `wfp_${oe("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, B = (e) => {
+	if (e instanceof Date) return e.getTime();
+	if (typeof e == "number") return e;
+	let t = Date.parse(String(e));
+	return Number.isNaN(t) ? 0 : t;
+}, V = (e, t) => {
+	let n = typeof e == "number" ? e : Number(e);
+	return Number.isFinite(n) ? Math.trunc(n) : t;
+}, De = (e) => ({
+	id: String(e.id),
+	tenantId: e.tenantId === null || e.tenantId === void 0 ? null : String(e.tenantId),
+	workflowName: String(e.workflowName),
+	controlKey: String(e.controlKey ?? ""),
+	mode: String(e.mode),
+	payload: e.payload,
+	callerContext: e.callerContext ?? null,
+	priority: V(e.priority, 0),
+	dueAt: B(e.dueAt),
+	deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : B(e.deadlineAt),
+	collapsed: V(e.collapsed, 1),
+	firstSeenAt: B(e.firstSeenAt),
+	attempts: V(e.attempts, 0),
+	lastError: e.lastError === null || e.lastError === void 0 ? null : String(e.lastError)
+}), H = (e, t, n, r) => ({
+	table: e,
+	predicate: t,
+	order: n,
+	take: r,
+	skip: void 0,
+	projection: void 0
+}), Oe = async (e) => {
+	let t = await e.query(H(we, void 0, [], 1e3));
+	return new Set(t.map((e) => String(e.id)));
+}, ke = async (e, t, n, r) => {
+	await e.upsert(we, {
+		id: t,
+		pausedAt: /* @__PURE__ */ new Date(),
+		pausedBy: n,
+		reason: r
+	}, {
+		conflictColumns: ["id"],
+		update: [
+			"pausedAt",
+			"pausedBy",
+			"reason"
+		]
+	});
+}, Ae = async (e, t) => e.delete(we, t), je = async (e) => {
+	let { store: t, control: n, keys: r, now: i } = e, a = { paused: e.paused }, o = [];
+	n.debounce !== void 0 && r.debounceKey !== void 0 && o.push((async () => {
+		let e = (await t.query(H(R, b(x("workflowName", n.workflowName), x("controlKey", r.debounceKey), x("mode", "debounce")), [], 1)))[0];
+		if (e === void 0) return;
+		let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : B(e.deadlineAt);
+		a.debouncePending = {
+			firstSeenAt: B(e.firstSeenAt),
+			collapsed: V(e.collapsed, 1),
+			...i === void 0 ? {} : { deadlineAt: i }
+		};
+	})()), n.batch !== void 0 && r.batchKey !== void 0 && o.push((async () => {
+		let e = await t.query(H(R, b(x("workflowName", n.workflowName), x("controlKey", r.batchKey), x("mode", "batch")), [{
+			column: "firstSeenAt",
+			direction: "asc"
+		}], n.batch.maxSize + 1));
+		e.length !== 0 && (a.batchPending = {
+			count: e.length,
+			firstSeenAt: B(e[0].firstSeenAt)
+		});
+	})()), n.singleton !== void 0 && r.singletonKey !== void 0 && o.push((async () => {
+		let e = await Me(t, n.workflowName, r.singletonKey, i);
+		e !== void 0 && (a.singletonHolder = e);
+	})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && o.push((async () => {
+		let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(H(z, b(...e, x("concurrencyKey", r.concurrencyKey), E("releasedAt"), C("expiresAt", new Date(i))), [], n.concurrency.limit));
+		a.inFlight = o.length;
+	})());
+	let s = n.rateLimit ?? n.throttle, c = r.rateLimitKey ?? r.throttleKey;
+	return s !== void 0 && c !== void 0 && o.push((async () => {
+		let e = await t.query(H(z, b(x("workflowName", n.workflowName), x("rateKey", c), x("outcome", "admitted"), C("admittedAt", new Date(i - s.periodMs))), [{
+			column: "admittedAt",
+			direction: "desc"
+		}], s.limit));
+		a.recentAdmissions = e.map((e) => B(e.admittedAt));
+	})()), await Promise.all(o), a;
+}, Me = async (e, t, n, r) => {
+	let i = (await e.query(H(z, b(x("workflowName", t), x("singletonKey", n), E("releasedAt"), C("expiresAt", new Date(r))), [{
+		column: "admittedAt",
+		direction: "desc"
+	}], 1)))[0];
+	if (i === void 0) return;
+	let a = i.executionId;
+	if (a != null) return {
+		executionId: String(a),
+		runId: i.runId === null || i.runId === void 0 ? "" : String(i.runId),
+		admittedAt: B(i.admittedAt)
+	};
+}, Ne = async (e) => {
+	let { store: t, control: n, decision: r, now: i } = e, a = Fe(r.mode, r.keys);
+	if (r.collapse === "hold") {
+		let o = e.existingId ?? Ee(n.workflowName, r.mode, a);
+		return await t.update(R, o, {
+			dueAt: new Date(r.dueAt),
+			updatedAt: new Date(i)
+		}), o;
+	}
+	if (r.collapse === "replace") {
+		let o = Ee(n.workflowName, r.mode, a);
+		return await t.upsert(R, {
+			id: o,
+			tenantId: e.tenantId,
+			workflowName: n.workflowName,
+			controlKey: a,
+			mode: r.mode,
+			payload: e.payload,
+			callerContext: e.callerContext ?? null,
+			priority: r.keys.priority,
+			dueAt: new Date(r.dueAt),
+			deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
+			collapsed: 1,
+			firstSeenAt: new Date(i),
+			updatedAt: new Date(i),
+			attempts: 0,
+			lastError: null
+		}, {
+			conflictColumns: ["id"],
+			update: (t) => ({
+				payload: e.payload,
+				callerContext: e.callerContext ?? null,
+				priority: r.keys.priority,
+				dueAt: new Date(r.dueAt),
+				deadlineAt: r.deadlineAt === void 0 ? t.deadlineAt ?? null : new Date(r.deadlineAt),
+				collapsed: V(t.collapsed, 1) + 1,
+				updatedAt: new Date(i)
+			})
+		}), o;
+	}
+	let o = await t.insert(R, {
+		tenantId: e.tenantId,
+		workflowName: n.workflowName,
+		controlKey: a,
+		mode: r.mode,
+		payload: e.payload,
+		callerContext: e.callerContext ?? null,
+		priority: r.keys.priority,
+		dueAt: new Date(r.dueAt),
+		deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
+		collapsed: 1,
+		firstSeenAt: new Date(i),
+		updatedAt: new Date(i),
+		attempts: 0,
+		lastError: null
+	});
+	return String(o.id);
+}, Pe = async (e) => {
+	let t = await e.store.insert(R, {
+		tenantId: e.tenantId,
+		workflowName: e.workflowName,
+		controlKey: "",
+		mode: "delayed",
+		payload: e.payload,
+		callerContext: e.callerContext ?? null,
+		priority: 0,
+		dueAt: new Date(e.at),
+		deadlineAt: null,
+		collapsed: 1,
+		firstSeenAt: new Date(e.now),
+		updatedAt: new Date(e.now),
+		attempts: 0,
+		lastError: null
+	});
+	return {
+		intentId: String(t.id),
+		dueAt: e.at
+	};
+}, Fe = (e, t) => {
+	switch (e) {
+		case "debounce": return t.debounceKey ?? "";
+		case "batch": return t.batchKey ?? "";
+		case "throttle": return t.throttleKey ?? "";
+		case "concurrency": return t.concurrencyKey ?? "";
+		default: return "";
+	}
+}, U = async (e) => {
+	let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(z, {
+		tenantId: e.tenantId,
+		workflowName: t.workflowName,
+		outcome: e.outcome,
+		mode: e.mode,
+		reason: e.reason,
+		collapsed: e.collapsed,
+		waitedMs: e.waitedMs,
+		executionId: e.executionId,
+		runId: e.runId,
+		singletonKey: n.singletonKey ?? null,
+		concurrencyKey: n.concurrencyKey ?? null,
+		rateKey: n.rateLimitKey ?? n.throttleKey ?? null,
+		admittedAt: new Date(r),
+		expiresAt: e.outcome === "admitted" ? new Date(r + i) : null,
+		releasedAt: e.outcome === "admitted" ? null : new Date(r)
+	});
+	return String(a.id);
+}, W = async (e, t, n) => {
+	let r = await e.query(H(z, b(x("executionId", t), x("outcome", "admitted"), E("releasedAt")), [], 10));
+	return r.length === 0 ? !1 : (await Promise.all(r.map((t) => e.update(z, String(t.id), { releasedAt: new Date(n) }))), !0);
+}, Ie = async (e, t, n) => (await Le(e, t, n)).due, Le = async (e, t, n) => {
+	let r = (await e.query(H(R, void 0, [{
+		column: "priority",
+		direction: "desc"
+	}, {
+		column: "firstSeenAt",
+		direction: "asc"
+	}], n))).map(De), i;
+	for (let e of r) e.dueAt <= t || (i === void 0 || e.dueAt < i) && (i = e.dueAt);
+	return {
+		due: r.filter((e) => e.dueAt <= t).sort(Ce),
+		nextDueAt: i
+	};
+}, Re = async (e, t) => (await e.query(H(R, void 0, [{
+	column: "firstSeenAt",
+	direction: "asc"
+}], t))).map(De), G = async (e, t) => e.delete(R, t), ze = async (e, t, n, r) => {
+	let i = (await e.query(H(R, x("id", t), [], 1)))[0];
+	if (i === void 0) return !1;
+	let a = De(i);
+	try {
+		await e.insert(z, {
+			tenantId: a.tenantId,
+			workflowName: a.workflowName,
+			outcome: "discarded",
+			mode: a.mode,
+			reason: n,
+			collapsed: a.collapsed,
+			waitedMs: Math.max(0, r - a.firstSeenAt),
+			executionId: null,
+			runId: null,
+			singletonKey: null,
+			concurrencyKey: a.controlKey === "" ? null : a.controlKey,
+			rateKey: null,
+			admittedAt: new Date(r),
+			expiresAt: null,
+			releasedAt: new Date(r)
+		});
+	} catch {}
+	return e.delete(R, t);
+}, Be = async (e, t, n, r) => {
+	await e.update(R, t.id, {
+		attempts: t.attempts + 1,
+		lastError: n.slice(0, 500),
+		updatedAt: new Date(r)
+	});
+}, Ve = async (e) => {
+	let t = await je({
+		store: e.store,
+		control: e.control,
+		keys: e.keys,
+		now: e.now,
+		paused: e.paused
+	});
+	return ye({
+		control: e.control,
+		keys: e.keys,
+		state: t,
+		now: e.now,
+		reconsidering: e.reconsidering
+	});
+}, He = async (e, t, n = 1e3) => {
+	let r = await e.query(H(z, void 0, [{
+		column: "admittedAt",
+		direction: "asc"
+	}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && B(e.admittedAt) < i);
+	return await Promise.all(a.map((t) => e.delete(z, String(t.id)))), a.length;
+}, Ue = async (e) => {
+	let { store: t, control: n, now: r } = e, i = I(n, e.payload), a = await Ve({
+		store: t,
+		control: n,
+		keys: i,
+		paused: e.paused,
+		now: r,
+		reconsidering: !1
+	});
+	if (a.kind === "drop") return await U({
+		store: t,
+		control: n,
+		keys: i,
+		outcome: "dropped",
+		mode: "rateLimit",
+		reason: `rate limit reached; retry after ${a.retryAfterMs}ms`,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: null,
+		runId: null,
+		tenantId: e.tenantId,
+		now: r
+	}), {
+		kind: "dropped",
+		retryAfterMs: a.retryAfterMs
+	};
+	if (a.kind === "skip") return await U({
+		store: t,
+		control: n,
+		keys: i,
+		outcome: "skipped",
+		mode: "singleton",
+		reason: `singleton key held by ${a.incumbent.executionId}`,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: a.incumbent.executionId,
+		runId: a.incumbent.runId || null,
+		tenantId: e.tenantId,
+		now: r
+	}), {
+		kind: "skipped",
+		executionId: a.incumbent.executionId,
+		runId: a.incumbent.runId
+	};
+	if (a.kind === "defer") return {
+		kind: "queued",
+		intentId: await Ne({
+			store: t,
+			control: n,
+			decision: a,
+			payload: e.payload,
+			callerContext: e.callerContext,
+			tenantId: e.tenantId,
+			now: r
+		}),
+		mode: a.mode,
+		dueAt: a.dueAt
+	};
+	let o = e.payload, s = [], c = 1;
+	if (n.batch !== void 0 && i.batchKey !== void 0) {
+		let r = await We(t, n.workflowName, i.batchKey, n.batch.maxSize);
+		o = { items: [...r.map((e) => e.payload), e.payload] }, s = r.map((e) => e.id), c = r.length + 1;
+	}
+	return {
+		kind: "start",
+		ledgerId: await U({
+			store: t,
+			control: n,
+			keys: i,
+			outcome: "admitted",
+			mode: e.waiting ? "immediate" : null,
+			reason: a.reason,
+			collapsed: c,
+			waitedMs: 0,
+			executionId: null,
+			runId: null,
+			tenantId: e.tenantId,
+			now: r
+		}),
+		keys: i,
+		payload: o,
+		consume: s,
+		collapsed: c,
+		...a.evict === void 0 ? {} : { evict: {
+			executionId: a.evict.executionId,
+			runId: a.evict.runId
+		} }
+	};
+}, We = async (e, t, n, r) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: b(x("workflowName", t), x("controlKey", n), x("mode", "batch")),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0
+})).map((e) => ({
+	id: String(e.id),
+	payload: e.payload
+})), Ge = async (e, t, n, r) => {
+	await e.update("_voltro_workflow_admissions", t, {
+		executionId: n,
+		runId: r
+	});
+}, Ke = j("_voltro_workflow_watermarks", {
+	id: w({ prefix: "wfwm" }),
+	positionAt: N(),
+	updatedAt: N().default("now")
+}), qe = (e) => {
+	let t = e instanceof Error ? e.message : String(e);
+	return t.length > 400 ? `${t.slice(0, 400)}…` : t;
+}, Je = (e) => {
+	let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => h.right(e) : (t) => {
+		let n = y.decodeUnknownEither(e.payloadSchema)(t);
+		return h.isRight(n) ? h.right(n.right) : h.left(qe(n.left));
+	}, s = e.runs.map((e) => ({
+		run: e,
+		decoded: o(e.payload)
+	})), c = e.intents.map((e) => ({
+		intent: e,
+		decoded: o(e.payload)
+	}));
+	for (let o of e.entries) for (let l of e.events) {
+		if (l.name !== o.event) continue;
+		let u = y.decodeUnknownEither(o.schema)(l.payload);
+		if (h.isLeft(u)) {
+			r.push({
+				kind: "event-decode",
+				workflowName: e.workflowName,
+				event: o.event,
+				subject: l.id,
+				detail: qe(u.left)
+			});
+			continue;
+		}
+		let d = u.right, f = (e) => e.getTime() > l.occurredAt.getTime() ? !1 : o.withinMs === void 0 || l.occurredAt.getTime() - e.getTime() <= o.withinMs, p = (t, n) => {
+			if (h.isLeft(t)) return r.push({
+				kind: "payload-decode",
+				workflowName: e.workflowName,
+				event: o.event,
+				subject: n,
+				detail: t.left
+			}), !1;
+			try {
+				return o.match(d, t.right) === !0;
+			} catch (t) {
+				return r.push({
+					kind: "match-threw",
+					workflowName: e.workflowName,
+					event: o.event,
+					subject: n,
+					detail: qe(t)
+				}), !1;
+			}
+		};
+		for (let { run: e, decoded: n } of s) i.has(e.runId) || f(e.startedAt) && p(n, e.runId) && (i.add(e.runId), t.push({
+			runId: e.runId,
+			executionId: e.executionId,
+			reason: o.reason,
+			event: o.event,
+			eventId: l.id
+		}));
+		for (let { intent: e, decoded: t } of c) a.has(e.intentId) || f(e.firstSeenAt) && p(t, e.intentId) && (a.add(e.intentId), n.push({
+			intentId: e.intentId,
+			reason: o.reason,
+			event: o.event,
+			eventId: l.id
+		}));
+	}
+	return {
+		cancels: t,
+		discards: n,
+		problems: r
+	};
+}, Ye = (e) => {
+	let t;
+	for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
+	return t;
+}, Xe = "_voltro_workflow_watermarks", Ze = "_voltro_workflow_events", K = "cancelOn", Qe = 3600 * 1e3, $e = 500, q = (e) => {
+	if (e instanceof Date) return e;
+	if (typeof e == "number") return new Date(e);
+	if (typeof e == "string") {
+		let t = new Date(e);
+		if (!Number.isNaN(t.getTime())) return t;
+	}
+}, J = (e) => e instanceof Error ? e.message : String(e), et = async (e, t) => q((await e.query({
+	table: Xe,
+	predicate: x("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0]?.positionAt), tt = async (e, t, n) => {
+	await e.upsert(Xe, {
+		id: t,
+		positionAt: n,
+		updatedAt: /* @__PURE__ */ new Date()
+	}, {
+		conflictColumns: ["id"],
+		update: (e) => {
+			let t = q(e.positionAt);
+			return t !== void 0 && t.getTime() >= n.getTime() ? {
+				positionAt: t,
+				updatedAt: /* @__PURE__ */ new Date()
+			} : {
+				positionAt: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+		}
+	});
+}, nt = async (e, t, n) => {
+	let r = async (r) => e.query({
+		table: "_voltro_workflow_runs",
+		predicate: b(x("tag", t), x("status", r)),
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		take: n,
+		skip: void 0,
+		projection: void 0
+	});
+	return [...await r("running"), ...await r("suspended")].flatMap((e) => {
+		let t = e, n = q(t.startedAt);
+		return typeof t.id != "string" || typeof t.executionId != "string" || n === void 0 ? [] : [{
+			runId: t.id,
+			executionId: t.executionId,
+			payload: t.payload,
+			startedAt: n
+		}];
+	});
+}, rt = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: x("workflowName", t),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = q(t.firstSeenAt);
+	return typeof t.id != "string" || n === void 0 ? [] : [{
+		intentId: t.id,
+		payload: t.payload,
+		firstSeenAt: n
+	}];
+}), it = async (e, t) => {
+	let n = t.workflows.filter((e) => e.entries.length > 0);
+	if (n.length === 0) return {
+		examined: !1,
+		events: 0,
+		cancelled: 0,
+		discarded: 0,
+		catchingUp: !1,
+		sawFullRunPage: !1,
+		problems: [],
+		failures: [],
+		watermark: void 0
+	};
+	let r = e.now?.() ?? Date.now(), i = t.batch ?? 500, a = t.coldLookbackMs ?? 36e5, o = /* @__PURE__ */ new Set();
+	for (let e of n) for (let t of e.entries) o.add(t.event);
+	let s = await et(e.store, K), c = s ?? new Date(r - a), l = await e.store.query({
+		table: Ze,
+		predicate: te("occurredAt", c),
+		order: [{
+			column: "occurredAt",
+			direction: "asc"
+		}],
+		take: i,
+		skip: void 0,
+		projection: void 0
+	}), u = [];
+	for (let e of l) {
+		let t = e, n = q(t.occurredAt);
+		typeof t.id != "string" || typeof t.name != "string" || n === void 0 || o.has(t.name) && u.push({
+			id: t.id,
+			name: t.name,
+			payload: t.payload,
+			occurredAt: n
+		});
+	}
+	let d = [], f = [], p = 0, m = 0, h = !1, g = !1, _ = t.runPage ?? 2e3;
+	if (u.length > 0) for (let t of n) {
+		let n = u.filter((e) => t.entries.some((t) => t.event === e.name));
+		if (n.length === 0) continue;
+		let r = [], i = [];
+		try {
+			r = await nt(e.store, t.workflowName, _), i = await rt(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
+		} catch (e) {
+			f.push({
+				subject: t.workflowName,
+				detail: J(e)
+			}), g = !0;
+			continue;
+		}
+		let a = Je({
+			workflowName: t.workflowName,
+			entries: t.entries,
+			payloadSchema: t.payloadSchema,
+			events: n,
+			runs: r,
+			intents: i
+		});
+		d.push(...a.problems);
+		for (let n of a.cancels) try {
+			await e.cancelRun({
+				workflowName: t.workflowName,
+				runId: n.runId,
+				executionId: n.executionId,
+				reason: n.reason,
+				event: n.event
+			}), p += 1, e.log?.info("workflow.cancelOn: run cancelled", {
+				workflow: t.workflowName,
+				runId: n.runId,
+				event: n.event,
+				eventId: n.eventId
+			});
+		} catch (e) {
+			f.push({
+				subject: n.runId,
+				detail: J(e)
+			});
+		}
+		for (let n of a.discards) try {
+			await e.discardIntent({
+				workflowName: t.workflowName,
+				intentId: n.intentId,
+				reason: n.reason,
+				event: n.event
+			}), m += 1;
+		} catch (e) {
+			f.push({
+				subject: n.intentId,
+				detail: J(e)
+			});
+		}
+	}
+	let v = Ye(u), y = s;
+	if (g) e.log?.warn("workflow.cancelOn: holding the watermark — some workflows could not be evaluated", { failures: f.length });
+	else if (v !== void 0) try {
+		await tt(e.store, K, v), y = v;
+	} catch (e) {
+		f.push({
+			subject: K,
+			detail: J(e)
+		});
+	}
+	else if (s === void 0) try {
+		await tt(e.store, K, c), y = c;
+	} catch (e) {
+		f.push({
+			subject: K,
+			detail: J(e)
+		});
+	}
+	return d.length > 0 && e.log?.warn("workflow.cancelOn: some events could not be evaluated", {
+		count: d.length,
+		first: d[0]
+	}), {
+		examined: !0,
+		events: u.length,
+		cancelled: p,
+		discarded: m,
+		catchingUp: l.length >= i,
+		sawFullRunPage: h,
+		problems: d,
+		failures: f,
+		watermark: y
+	};
+}, at = 1800 * 1e3, ot = 200, st = 20, Y = (e) => {
+	if (e instanceof Date) return e;
+	if (typeof e == "number") return new Date(e);
+	if (typeof e == "string") {
+		let t = new Date(e);
+		if (!Number.isNaN(t.getTime())) return t;
+	}
+}, ct = (e) => e instanceof Error ? e.message : String(e), lt = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_run_events",
+	predicate: x("runId", t),
+	order: [{
+		column: "occurredAt",
+		direction: "desc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = Y(t.occurredAt);
+	return typeof t.eventType != "string" || n === void 0 ? [] : [{
+		eventType: t.eventType,
+		occurredAt: n,
+		payload: t.payload
+	}];
+}), ut = async (e, t) => {
+	let n = (await e.query({
+		table: "_voltro_workflow_run_steps",
+		predicate: x("runId", t),
+		order: [{
+			column: "startedAt",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0) return;
+	let r = Y(n.startedAt), i = Y(n.completedAt);
+	return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
+}, dt = (e, t) => {
+	for (let n of e) {
+		if (n.eventType === "timer-fired") return !1;
+		if (n.eventType !== "timer-set") continue;
+		let e = Y(n.payload?.scheduledWakeAt);
+		return e !== void 0 && e.getTime() > t;
+	}
+	return !1;
+}, ft = (e, t) => {
+	if (e !== "suspended") return "no-progress";
+	for (let e of t) {
+		if (e.eventType === "signal-received" || e.eventType === "signal-sent") return "suspended";
+		if (e.eventType === "signal-awaited") return "awaiting-signal";
+	}
+	return "suspended";
+}, pt = async (e, t = {}) => {
+	let n = e.now?.() ?? Date.now(), r = t.stallAfterMs ?? 18e5, i = t.runPage ?? 200, a = t.eventLookback ?? 20, o = new Date(n - r), s = [], c = [], l = 0, u = 0, d;
+	try {
+		d = await e.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: b(ne("status", ["running", "suspended"]), O("startedAt", o)),
+			order: [{
+				column: "startedAt",
+				direction: "asc"
+			}],
+			take: i,
+			skip: void 0,
+			projection: void 0
+		});
+	} catch (e) {
+		return {
+			examined: 0,
+			stalled: [],
+			alreadyReported: 0,
+			waitingOnTimer: 0,
+			sawFullRunPage: !1,
+			failures: [{
+				subject: "_voltro_workflow_runs",
+				detail: ct(e)
+			}]
+		};
+	}
+	for (let t of d) {
+		let i = t, o = Y(i.startedAt);
+		if (typeof i.id != "string" || typeof i.tag != "string" || typeof i.executionId != "string" || typeof i.status != "string" || o === void 0) continue;
+		let d, f;
+		try {
+			d = await lt(e.store, i.id, a), f = await ut(e.store, i.id);
+		} catch (e) {
+			s.push({
+				subject: i.id,
+				detail: ct(e)
+			});
+			continue;
+		}
+		if (dt(d, n)) {
+			u += 1;
+			continue;
+		}
+		let p = d.find((e) => e.eventType !== "run-stalled")?.occurredAt, m = o;
+		for (let e of [f, p]) e !== void 0 && e.getTime() > m.getTime() && (m = e);
+		let h = n - m.getTime();
+		if (h < r) continue;
+		if (d.some((e) => e.eventType === "run-stalled" && e.occurredAt.getTime() > m.getTime())) {
+			l += 1;
+			continue;
+		}
+		let g = {
+			runId: i.id,
+			tag: i.tag,
+			executionId: i.executionId,
+			status: i.status,
+			lastProgressAt: m,
+			idleMs: h,
+			reason: ft(i.status, d)
+		};
+		if (c.push(g), e.log?.warn("workflow.staleness: run has made no progress", {
+			workflow: g.tag,
+			runId: g.runId,
+			idleMs: g.idleMs,
+			reason: g.reason
+		}), e.recordEvent !== void 0) try {
+			await e.recordEvent({
+				runId: g.runId,
+				eventType: "run-stalled",
+				payload: {
+					idleMs: g.idleMs,
+					stallAfterMs: r,
+					lastProgressAt: g.lastProgressAt.toISOString(),
+					reason: g.reason,
+					tag: g.tag,
+					executionId: g.executionId
+				}
+			});
+		} catch (e) {
+			s.push({
+				subject: g.runId,
+				detail: ct(e)
+			});
+		}
+		if (e.onStalled !== void 0) try {
+			await e.onStalled(g);
+		} catch (e) {
+			s.push({
+				subject: `${g.runId}:onStalled`,
+				detail: ct(e)
+			});
+		}
+	}
+	return {
+		examined: d.length,
+		stalled: c,
+		alreadyReported: l,
+		waitingOnTimer: u,
+		sawFullRunPage: d.length >= i,
+		failures: s
+	};
+}, mt = {
+	scanned: 0,
+	admitted: 0,
+	deferred: 0,
+	dropped: 0,
+	skipped: 0,
+	expired: 0,
+	evicted: 0,
+	failed: 0,
+	timedOut: 0,
+	examined: !1
+}, ht = 200, gt = async (e, t = {}) => {
+	let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, a, o, s;
+	try {
+		a = await Oe(e.store);
+		let t = await Le(e.store, n(), i);
+		o = t.due, s = t.nextDueAt;
+	} catch (e) {
+		return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), mt;
+	}
+	let c = {
+		scanned: o.length,
+		admitted: 0,
+		deferred: 0,
+		dropped: 0,
+		skipped: 0,
+		expired: 0,
+		evicted: 0,
+		failed: 0,
+		timedOut: 0
+	}, l = /* @__PURE__ */ new Map(), u = [];
+	for (let e of o) {
+		if (e.mode === "batch") {
+			let t = `${e.workflowName}\u0000${e.controlKey}`, n = l.get(t);
+			n === void 0 ? l.set(t, [e]) : n.push(e);
+			continue;
+		}
+		u.push(e);
+	}
+	for (let t of u) try {
+		await _t(e, t, a, c, n());
+	} catch (i) {
+		c.failed++, r?.warn?.("workflow flow control: an intent failed to drain", {
+			workflow: t.workflowName,
+			intent: t.id,
+			cause: String(i)
+		}), await Be(e.store, t, String(i), n()).catch(() => {});
+	}
+	for (let t of l.values()) try {
+		await yt(e, t, a, c, n());
+	} catch (i) {
+		c.failed++;
+		let a = t[0];
+		r?.warn?.("workflow flow control: a batch failed to drain", {
+			workflow: a?.workflowName,
+			size: t.length,
+			cause: String(i)
+		}), a !== void 0 && await Be(e.store, a, String(i), n()).catch(() => {});
+	}
+	return c.timedOut = await xt(e, n()).catch(() => 0), {
+		...c,
+		examined: !0,
+		...s === void 0 ? {} : { nextDueAt: s }
+	};
+}, _t = async (e, t, n, r, i) => {
+	if (t.mode === "delayed") return vt(e, t, n, r, i);
+	let a = e.controls.get(t.workflowName);
+	if (a === void 0) {
+		await e.onAbandoned({
+			workflowName: t.workflowName,
+			payload: t.payload,
+			callerContext: t.callerContext,
+			reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this start was waiting in the admission queue`
+		}), await G(e.store, t.id), r.expired++;
+		return;
+	}
+	if (xe(a, t, i)) {
+		await U({
+			store: e.store,
+			control: a,
+			keys: I(a, t.payload),
+			outcome: "expired",
+			mode: t.mode,
+			reason: `timeouts.start elapsed after ${i - t.firstSeenAt}ms`,
+			collapsed: t.collapsed,
+			waitedMs: i - t.firstSeenAt,
+			executionId: null,
+			runId: null,
+			tenantId: t.tenantId,
+			now: i
+		}), await e.onAbandoned({
+			workflowName: t.workflowName,
+			payload: t.payload,
+			callerContext: t.callerContext,
+			reason: `timeouts.start (${a.timeouts?.startMs}ms) elapsed while this start waited in the admission queue; ${t.collapsed} start(s) had collapsed into it`
+		}), await G(e.store, t.id), r.expired++;
+		return;
+	}
+	let o = I(a, t.payload);
+	await bt(e, {
+		control: a,
+		intent: t,
+		decision: await Ve({
+			store: e.store,
+			control: a,
+			keys: o,
+			paused: n.has(t.workflowName),
+			now: i,
+			reconsidering: !0
+		}),
+		keys: o,
+		counters: r,
+		now: i,
+		items: void 0
+	});
+}, vt = async (e, t, n, r, i) => {
+	if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
+		await e.onAbandoned({
+			workflowName: t.workflowName,
+			payload: t.payload,
+			callerContext: t.callerContext,
+			reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this delayed start waited for its 'at' instant`
+		}), await G(e.store, t.id), r.expired++;
+		return;
+	}
+	let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await Ue({
+		store: e.store,
+		control: a,
+		payload: t.payload,
+		callerContext: t.callerContext,
+		tenantId: t.tenantId,
+		paused: n.has(t.workflowName),
+		now: i,
+		waiting: !1
+	});
+	if (o.kind === "queued") {
+		await G(e.store, t.id), r.deferred++;
+		return;
+	}
+	if (o.kind === "dropped") {
+		await G(e.store, t.id), r.dropped++;
+		return;
+	}
+	if (o.kind === "skipped") {
+		await G(e.store, t.id), r.skipped++;
+		return;
+	}
+	let s = await e.startAdmitted(a.workflowName, o.payload, t.callerContext);
+	o.evict !== void 0 && (await e.cancelRun(a.workflowName, o.evict.executionId).catch(() => {}), await W(e.store, o.evict.executionId, i).catch(() => {}), r.evicted++);
+	for (let t of o.consume) await G(e.store, t).catch(() => {});
+	o.ledgerId !== void 0 && await Ge(e.store, o.ledgerId, s.executionId, s.runId ?? null).catch(() => {}), await G(e.store, t.id), r.admitted++;
+}, yt = async (e, t, n, r, i) => {
+	let a = t[0];
+	if (a === void 0) return;
+	let o = e.controls.get(a.workflowName);
+	if (o === void 0 || o.batch === void 0) {
+		for (let n of t) await G(e.store, n.id);
+		r.expired += t.length;
+		return;
+	}
+	let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
+	if (xe(o, c, i)) {
+		await e.onAbandoned({
+			workflowName: a.workflowName,
+			payload: { items: s.map((e) => e.payload) },
+			callerContext: c.callerContext,
+			reason: `timeouts.start elapsed with ${s.length} item(s) accumulated in the batch`
+		});
+		for (let t of s) await G(e.store, t.id);
+		r.expired += s.length;
+		return;
+	}
+	let l = I(o, c.payload);
+	await bt(e, {
+		control: o,
+		intent: c,
+		decision: await Ve({
+			store: e.store,
+			control: o,
+			keys: l,
+			paused: n.has(a.workflowName),
+			now: i,
+			reconsidering: !0
+		}),
+		keys: l,
+		counters: r,
+		now: i,
+		items: s
+	});
+}, bt = async (e, t) => {
+	let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c } = t;
+	if (i.kind === "defer") {
+		await Ne({
+			store: e.store,
+			control: n,
+			decision: i,
+			payload: r.payload,
+			callerContext: r.callerContext,
+			tenantId: r.tenantId,
+			now: s,
+			existingId: r.id
+		}), o.deferred++;
+		return;
+	}
+	if (i.kind === "drop") {
+		await U({
+			store: e.store,
+			control: n,
+			keys: a,
+			outcome: "dropped",
+			mode: "rateLimit",
+			reason: `rate limit reached while queued; retry after ${i.retryAfterMs}ms`,
+			collapsed: r.collapsed,
+			waitedMs: s - r.firstSeenAt,
+			executionId: null,
+			runId: null,
+			tenantId: r.tenantId,
+			now: s
+		});
+		for (let t of c ?? [r]) await G(e.store, t.id);
+		o.dropped++;
+		return;
+	}
+	if (i.kind === "skip") {
+		await U({
+			store: e.store,
+			control: n,
+			keys: a,
+			outcome: "skipped",
+			mode: "singleton",
+			reason: `singleton key held by ${i.incumbent.executionId}`,
+			collapsed: r.collapsed,
+			waitedMs: s - r.firstSeenAt,
+			executionId: i.incumbent.executionId,
+			runId: i.incumbent.runId || null,
+			tenantId: r.tenantId,
+			now: s
+		});
+		for (let t of c ?? [r]) await G(e.store, t.id);
+		o.skipped++;
+		return;
+	}
+	i.evict !== void 0 && (await e.cancelRun(n.workflowName, i.evict.executionId), await W(e.store, i.evict.executionId, s), await U({
+		store: e.store,
+		control: n,
+		keys: a,
+		outcome: "evicted",
+		mode: "singleton",
+		reason: "cancelled to make room for a newer start (singleton mode 'cancel')",
+		collapsed: 1,
+		waitedMs: null,
+		executionId: i.evict.executionId,
+		runId: i.evict.runId || null,
+		tenantId: r.tenantId,
+		now: s
+	}), o.evicted++);
+	let l = c === void 0 ? r.payload : { items: c.map((e) => e.payload) }, u = c === void 0 ? r.collapsed : c.reduce((e, t) => e + t.collapsed, 0), d = await e.startAdmitted(n.workflowName, l, r.callerContext);
+	await U({
+		store: e.store,
+		control: n,
+		keys: a,
+		outcome: "admitted",
+		mode: r.mode,
+		reason: i.reason,
+		collapsed: u,
+		waitedMs: s - r.firstSeenAt,
+		executionId: d.executionId,
+		runId: d.runId ?? null,
+		tenantId: r.tenantId,
+		now: s
+	});
+	for (let t of c ?? [r]) await G(e.store, t.id);
+	o.admitted++;
+}, xt = async (e, t) => {
+	if (e.listRunningRuns === void 0) return 0;
+	let n = 0;
+	for (let r of e.controls.values()) {
+		if (r.timeouts?.finishMs === void 0) continue;
+		let i = await e.listRunningRuns(r.workflowName);
+		for (let a of i) Se(r, {
+			startedAt: a.startedAt,
+			terminal: !1
+		}, t) && (await e.cancelRun(r.workflowName, a.executionId), await W(e.store, a.executionId, t), await e.onAbandoned({
+			workflowName: r.workflowName,
+			payload: null,
+			callerContext: null,
+			reason: `timeouts.finish (${r.timeouts.finishMs}ms) elapsed; the run was cancelled after ${t - a.startedAt}ms`
+		}), n++);
+	}
+	return n;
+}, St = 5 * 6e4, Ct, wt = (e) => {
+	Ct = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
+}, Tt = () => {
+	let e = process.env.VOLTRO_WORKFLOW_SUSPEND_HINT_MS;
+	if (e !== void 0) {
+		let t = Number(e);
+		if (Number.isFinite(t) && t > 0) return t;
+	}
+	return Ct ?? 3e5;
+}, Et = /* @__PURE__ */ new Set(), Dt = () => {
+	Et.clear();
+}, Ot = (e) => {
+	let t = Tt();
+	if (!(e.timeoutMs > t)) return !1;
+	let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
+	if (Et.has(n)) return !1;
+	Et.add(n);
+	let r = e.workflowName === void 0 ? "" : ` in workflow '${e.workflowName}'`;
+	return (e.warn ?? ((e) => console.warn(e)))(`awaitSignal('${e.signalName}')${r} declares a ${Math.round(e.timeoutMs / 1e3)}s timeout — a wait that long holds a worker fiber for its whole duration. For human-approval-length waits, awaitSignalSuspending (same call shape, from @voltro/workflow) SUSPENDS the run and frees the slot until the signal arrives. This is a hint, not a behaviour change; it is logged once per workflow. Threshold: workflows.suspendSignalHintMs in app.config.ts, or VOLTRO_WORKFLOW_SUSPEND_HINT_MS.`), !0;
+}, kt = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, At = (e, t) => {
+	let r = m.gen(function* () {
+		let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 1440 * 6e4, s = yield* m.serviceOption(se);
+		Ot({
+			workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
+			signalName: t.name,
+			timeoutMs: o
+		});
+		let c = yield* a, l = yield* m.serviceOption(n), u = l._tag === "Some" ? l.value : void 0;
+		if (c === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
+		let d = c;
+		yield* m.promise(() => kt(u, {
+			runId: d,
+			eventType: "signal-awaited",
+			payload: { signalName: t.name }
+		}));
+		let f = Date.now(), p = r;
+		for (;;) {
+			let n = Date.now() - f;
+			if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitSignal('${t.name}') timed out after ${n}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: b(x("runId", d), x("eventType", "signal-sent")),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, a = (yield* m.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			})).find((e) => e.payload?.signalName === t.name);
+			if (a !== void 0) {
+				let e = yield* y.decodeUnknown(t.schema)(a.payload?.value);
+				return yield* m.promise(() => kt(u, {
+					runId: d,
+					eventType: "signal-received",
+					payload: {
+						signalName: t.name,
+						value: a.payload?.value
+					}
+				})), e;
+			}
+			yield* m.sleep(`${p} millis`), p = Math.min(p * 2, i);
+		}
+	});
+	return c.make({
+		name: `await-signal:${t.name}`,
+		success: t.schema,
+		execute: r
+	});
+}, jt = async (e, t) => {
+	if (e !== void 0) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Mt = (e, t) => {
+	let r = m.gen(function* () {
+		let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 1440 * 6e4, s = t.take ?? 500, c = yield* a, l = yield* m.serviceOption(n), u = l._tag === "Some" ? l.value : void 0;
+		if (c === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
+		let d = c, f = yield* t.since === "run-start" ? Nt(e, d) : m.succeed(/* @__PURE__ */ new Date());
+		yield* m.promise(() => jt(u, {
+			runId: d,
+			eventType: "event-awaited",
+			payload: {
+				event: t.event,
+				since: t.since ?? "wait-start",
+				cutoff: f.toISOString()
+			}
+		}));
+		let p = Date.now(), h = r, g = 0;
+		for (;;) {
+			let n = Date.now() - p;
+			if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitEvent('${t.event}') timed out after ${n}ms having examined ${g} candidate event(s). ${g === 0 ? "NONE were published under that name in the window — check the spelling against ctx.events.publish, and consider since: 'run-start' if the event may have arrived before this step began." : "The predicate rejected all of them — log one payload and compare it with what `match` expects."}`));
+			let r = {
+				table: "_voltro_workflow_events",
+				predicate: b(x("name", t.event), te("occurredAt", f)),
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				take: s,
+				skip: void 0,
+				projection: void 0
+			}, a = yield* m.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			});
+			g = a.length;
+			for (let e of a) {
+				let n = yield* y.decodeUnknown(t.schema)(e.payload);
+				if (t.match(n)) return yield* m.promise(() => jt(u, {
+					runId: d,
+					eventType: "event-received",
+					payload: {
+						event: t.event,
+						eventId: e.id
+					}
+				})), n;
+			}
+			yield* m.sleep(`${h} millis`), h = Math.min(h * 2, i);
+		}
+	});
+	return c.make({
+		name: `awaitEvent:${t.event}`,
+		success: t.schema,
+		execute: r
+	});
+}, Nt = (e, t) => m.gen(function* () {
+	let n = (yield* m.tryPromise({
+		try: () => e.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: x("id", t),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}),
+		catch: (e) => e
+	}))[0]?.startedAt;
+	if (n instanceof Date) return n;
+	if (typeof n == "string" || typeof n == "number") {
+		let e = new Date(n);
+		if (!Number.isNaN(e.getTime())) return e;
+	}
+	return /* @__PURE__ */ new Date(0);
+}), Pt = (e) => new Promise((t) => setTimeout(t, e)), Ft = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, It = () => `wfu_${Ft()}`, Lt = async (e, t) => {
+	let n = t.id ?? t.executionId;
+	if (!n) throw Error("workflow message target requires target.id or target.executionId");
+	let r = await e.query({
+		table: "_voltro_workflow_runs",
+		order: [],
+		predicate: x("id", n),
+		projection: void 0,
+		skip: void 0,
+		take: 1
+	});
+	if (r[0]) return r[0];
+	let i = (await e.query({
+		table: "_voltro_workflow_runs",
+		order: [],
+		predicate: x("executionId", n),
+		projection: void 0,
+		skip: void 0,
+		take: 1
+	}))[0];
+	if (!i) throw Error(`workflow message target not found: ${n}`);
+	return i;
+}, Rt = async (e) => {
+	let t = await Lt(e.store, e.target);
+	return { eventId: (await e.recorder.recordEvent({
+		runId: t.id,
+		eventType: "signal-sent",
+		payload: {
+			signalName: e.signalName,
+			value: e.payload
+		}
+	})).id };
+}, zt = async (e) => {
+	let t = await Lt(e.store, e.target), n = It(), r = await e.recorder.recordEvent({
+		runId: t.id,
+		eventType: "update-requested",
+		payload: {
+			updateId: n,
+			updateName: e.updateName,
+			value: e.payload
+		}
+	}), i = Date.now(), a = e.options?.timeoutMs ?? 3e4, o = e.options?.pollIntervalMs ?? 100;
+	for (;;) {
+		let s = {
+			table: "_voltro_workflow_run_events",
+			order: [{
+				column: "occurredAt",
+				direction: "asc"
+			}],
+			predicate: x("runId", t.id),
+			projection: void 0,
+			skip: void 0,
+			take: 1e3
+		}, c = await e.store.query(s), l = c.find((e) => e.eventType === "update-completed" && e.payload?.updateId === n);
+		if (l) return {
+			eventId: r.id,
+			updateId: n,
+			completedEventId: l.id,
+			result: l.payload?.result
+		};
+		let u = c.find((e) => e.eventType === "update-failed" && e.payload?.updateId === n);
+		if (u) {
+			let t = Error(u.payload?.errorMessage ?? `workflow update '${e.updateName}' failed`);
+			throw Object.assign(t, {
+				updateId: n,
+				eventId: r.id,
+				errorTag: u.payload?.errorTag ?? null
+			}), t;
+		}
+		if (Date.now() - i >= a) throw Error(`Timed out waiting for workflow update '${e.updateName}' (${n})`);
+		await Pt(o);
+	}
+}, Bt = 1440 * 6e4, Vt = "voltro/suspending-signal", Ht = (e, t) => `${Vt}/${e}/${t}`, Ut = (e) => u.make(e, { success: y.Unknown }), Wt = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Gt = (e, t) => m.gen(function* () {
+	let e = t.timeoutMs ?? Bt, r = Ut(Ht((yield* f.WorkflowInstance).workflow.name, t.name)), i = yield* a, o = yield* m.serviceOption(n), s = o._tag === "Some" ? o.value : void 0;
+	i !== void 0 && (yield* m.promise(() => Wt(s, {
+		runId: i,
+		eventType: "signal-awaited",
+		payload: { signalName: t.name }
+	})));
+	let c = u.await(r), d = Number.isFinite(e) ? yield* m.race(c, l.sleep({
+		name: `await-signal-timeout/${t.name}`,
+		duration: `${e} millis`
+	}).pipe(m.andThen(m.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${t.name}') timed out after ${e}ms`))))) : yield* c, p = yield* y.decodeUnknown(t.schema)(d);
+	return i !== void 0 && (yield* m.promise(() => Wt(s, {
+		runId: i,
+		eventType: "signal-received",
+		payload: {
+			signalName: t.name,
+			value: p
+		}
+	}))), p;
+}), Kt = (e) => m.gen(function* () {
+	let t = e.target.executionId, n = e.target.workflowName;
+	if (t === void 0 || n === void 0) {
+		let r = e.store;
+		if (r === void 0) return yield* m.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
+		let i = yield* m.tryPromise({
+			try: () => Lt(r, e.target),
+			catch: (e) => e
+		});
+		t ??= i.executionId, n ??= i.tag;
+	}
+	if (t === void 0 || n === void 0) return { completed: !1 };
+	let r = Ht(n, e.signalName), i = Ut(r), a = new u.TokenParsed({
+		workflowName: n,
+		executionId: t,
+		deferredName: r
+	}).asToken;
+	return yield* u.done(i, {
+		token: a,
+		exit: g.succeed(e.payload)
+	}), { completed: !0 };
+}), X = "_voltro_budget_holds", qt = "budget-hold", Jt = (e) => `${qt}:${e}`, Yt = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, Xt = async (e, t) => (await e.query({
+	table: X,
+	predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
+	order: []
+})).length, Zt = j(X, {
+	id: w({ prefix: "bhd" }),
+	holdKey: M().maxLength(191),
+	budget: M(),
+	tenantId: M().nullable(),
+	executionId: M(),
+	workflowName: M(),
+	signalName: M(),
+	stepName: M(),
+	spentMicroUsd: M().nullable(),
+	limitMicroUsd: M().nullable(),
+	heldAt: N().default("now"),
+	releasedAt: N().nullable(),
+	outcome: M().nullable()
+}).index(["budget", "releasedAt"]), Qt = () => {
+	ie({
+		source: "framework",
+		table: X,
+		timeColumn: "releasedAt",
+		ttlMs: ae(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
+	});
+}, $t = class extends Error {
+	budget;
+	holdKey;
+	constructor(e, t, n) {
+		super(`budget '${e}': the run was suspended waiting for headroom and gave up after ${n}ms (hold ${t}). Nothing was spent. Raise the budget, reset its window, or lift the hold, then re-drive the run.`), this.name = "BudgetHoldExpired", this.budget = e, this.holdKey = t;
+	}
+}, en = 10080 * 6e4, tn = (e) => m.gen(function* () {
+	Qt();
+	let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
+		executionId: e.executionId,
+		stepName: e.stepName,
+		budget: e.budget
+	};
+	for (;;) {
+		let i = yield* m.promise(() => rn(e.store, r)), a = i.length, o = i.length === 0 ? Date.now() : nn(i[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = Yt({
+			...r,
+			generation: a
+		});
+		if (s <= 0) return yield* m.promise(() => an(e.store, r, "expired")), yield* m.fail(new $t(e.budget, c, t));
+		let l = Jt(c);
+		yield* m.promise(() => e.store.insertIgnore(X, {
+			id: S({
+				kind: "typeid",
+				prefix: "bhd"
+			}, X),
+			holdKey: c,
+			budget: e.budget,
+			tenantId: e.tenantId,
+			executionId: e.executionId,
+			workflowName: e.workflowName,
+			signalName: l,
+			stepName: e.stepName,
+			spentMicroUsd: e.spentMicroUsd === void 0 ? null : String(Math.round(e.spentMicroUsd)),
+			limitMicroUsd: e.limitMicroUsd === void 0 ? null : String(Math.round(e.limitMicroUsd)),
+			heldAt: /* @__PURE__ */ new Date(),
+			releasedAt: null,
+			outcome: null
+		}, { conflictColumns: ["holdKey"] }));
+		let u = Math.min(n, s);
+		if (yield* Gt({ store: e.store }, {
+			name: l,
+			schema: y.Unknown,
+			timeoutMs: u
+		}).pipe(m.catchAllCause((e) => p.isInterruptedOnly(e) ? m.failCause(e) : m.void)), yield* m.promise(() => e.store.updateMany(X, {
+			releasedAt: /* @__PURE__ */ new Date(),
+			outcome: "recheck"
+		}, { where: b(x("holdKey", c), E("releasedAt")) })), yield* e.hasHeadroom) return;
+	}
+}), nn = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), rn = async (e, t) => [...await e.query({
+	table: X,
+	predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
+	order: []
+})].sort((e, t) => String(e.id).localeCompare(String(t.id))), an = async (e, t, n) => {
+	await e.updateMany(X, {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: n
+	}, { where: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget), E("releasedAt")) });
+}, on = (e) => m.gen(function* () {
+	let t = e.tenantId === void 0 ? b(x("budget", e.budget), E("releasedAt")) : b(x("budget", e.budget), x("tenantId", e.tenantId), E("releasedAt")), n = yield* m.promise(() => e.store.query({
+		table: X,
+		predicate: t,
+		order: []
+	})), r = 0;
+	for (let t of n) (yield* m.promise(() => e.store.updateMany("_voltro_budget_holds", {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: e.outcome ?? "released"
+	}, { where: b(x("id", String(t.id)), E("releasedAt")) }))) === 1 && (yield* Kt({
+		target: {
+			executionId: String(t.executionId),
+			workflowName: String(t.workflowName)
+		},
+		signalName: String(t.signalName),
+		payload: {
+			released: !0,
+			budget: e.budget
+		}
+	}).pipe(m.catchAll(() => m.succeed({ completed: !1 }))), r += 1);
+	return { released: r };
+}), sn = async (e, t) => {
+	let n = t?.budget === void 0 ? E("releasedAt") : b(x("budget", t.budget), E("releasedAt"));
+	return (await e.query({
+		table: X,
+		predicate: n,
+		order: []
+	})).map((e) => ({
+		id: String(e.id),
+		holdKey: String(e.holdKey),
+		budget: String(e.budget),
+		tenantId: e.tenantId ?? null,
+		executionId: String(e.executionId),
+		workflowName: String(e.workflowName),
+		stepName: String(e.stepName),
+		heldAt: e.heldAt instanceof Date ? e.heldAt.toISOString() : String(e.heldAt ?? "")
+	}));
+}, cn = async (e) => {
+	let t = await sn(e), n = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = `${e.budget}\u0000${e.tenantId ?? ""}`;
+		n.has(t) || n.set(t, {
+			budget: e.budget,
+			tenantId: e.tenantId
+		});
+	}
+	return [...n.values()];
+}, ln = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, un = (e) => {
+	let t = p.failureOption(e), n = Array.from(p.defects(e)), r = t._tag === "Some" ? t.value : n[0] ?? p.squash(e);
+	return {
+		errorTag: r && typeof r == "object" && "_tag" in r ? String(r._tag) : null,
+		errorMessage: r?.message ?? String(r)
+	};
+}, dn = (e, t) => {
+	let r = m.gen(function* () {
+		let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 3e4, s = yield* a, c = yield* m.serviceOption(n), l = c._tag === "Some" ? c.value : void 0;
+		if (s === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
+		let u = s, d = Date.now(), f = r;
+		for (;;) {
+			let n = Date.now() - d;
+			if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitUpdate('${t.name}') timed out after ${n}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: x("runId", u),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, a = yield* m.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			}), s = new Set(a.filter((e) => e.eventType === "update-completed" || e.eventType === "update-failed").map((e) => e.payload?.updateId).filter((e) => typeof e == "string" && e.length > 0)), c = a.find((e) => e.eventType === "update-requested" && e.payload?.updateName === t.name && typeof e.payload.updateId == "string" && !s.has(e.payload.updateId));
+			if (c !== void 0) {
+				let e = c.payload.updateId;
+				yield* m.promise(() => ln(l, {
+					runId: u,
+					eventType: "update-received",
+					payload: {
+						updateId: e,
+						updateName: t.name
+					}
+				}));
+				let n = yield* y.decodeUnknown(t.schema)(c.payload?.value).pipe(m.tapErrorCause((n) => m.promise(() => ln(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: t.name,
+						...un(n)
+					}
+				})))), r = yield* (t.handle ? t.handle(n) : m.succeed(n)).pipe(m.flatMap((e) => t.success ? y.decodeUnknown(t.success)(e) : m.succeed(e))).pipe(m.tapErrorCause((n) => m.promise(() => ln(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: t.name,
+						...un(n)
+					}
+				}))));
+				return yield* m.promise(() => ln(l, {
+					runId: u,
+					eventType: "update-completed",
+					payload: {
+						updateId: e,
+						updateName: t.name,
+						result: r
+					}
+				})), r;
+			}
+			yield* m.sleep(`${f} millis`), f = Math.min(f * 2, i);
+		}
+	});
+	return c.make({
+		name: `await-update:${t.name}`,
+		success: t.success ?? t.schema,
+		execute: r
+	});
+}, fn = 8 * 1024, pn = 3, mn = 2e3, hn = () => {
+	let e = (e) => {
+		if (e === void 0) return;
+		let t = Number(e);
+		return Number.isFinite(t) && t > 0 ? Math.floor(t) : void 0;
+	}, t = e(process.env.VOLTRO_WORKFLOW_MAX_RECLAIMS), n = e(process.env.VOLTRO_WORKFLOW_REPLAY_SHAPE_LIMIT);
+	return {
+		...t === void 0 ? {} : { maxRunReclaims: t },
+		...n === void 0 ? {} : { replayShapeLimit: n }
+	};
+}, gn = (e) => {
+	let t = typeof e == "string" ? (() => {
+		try {
+			return JSON.parse(e);
+		} catch {
+			return;
+		}
+	})() : e;
+	if (Array.isArray(t)) return t.filter((e) => typeof e == "string");
+}, _n = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, vn = (e) => `${e}_${_n()}`, Z = (e, t = fn) => {
+	if (e == null) return e;
+	try {
+		let n = JSON.stringify(e);
+		return n.length <= t ? e : {
+			__truncated: !0,
+			bytes: n.length,
+			sample: n.slice(0, t)
+		};
+	} catch {
+		return { __unserialisable: String(e) };
+	}
+}, Q = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
+	return t;
+}, yn = (e) => {
+	let t = e.truncateBytes ?? fn, n = e.makeId ?? vn, r = (t, n) => e.log?.warn(t, n), i = e.encryptStepPayload ?? ((e) => e), a = e.emit, o = e.recording === "coarse";
+	return {
+		startStep: async ({ runId: s, stepName: c, attempt: l, stepInput: u, retryPolicy: d }) => {
+			if (!o) try {
+				let r = await e.store.insert("_voltro_workflow_run_steps", {
+					id: n("ws"),
+					runId: s,
+					stepName: c,
+					attempt: l,
+					status: "running",
+					input: u === void 0 ? null : i(Z(u, t)),
+					retryPolicy: d ?? null,
+					output: null,
+					errorTag: null,
+					errorMessage: null,
+					startedAt: /* @__PURE__ */ new Date(),
+					completedAt: null,
+					durationMs: null
+				});
+				return a?.("workflowSteps", {
+					op: "insert",
+					row: Q(r)
+				}), r.id;
+			} catch (e) {
+				r("failed to record step start (continuing)", {
+					runId: s,
+					stepName: c,
+					attempt: l,
+					reason: e?.message ?? String(e)
+				});
+				return;
+			}
+		},
+		endStepSuccess: async ({ stepRecordId: n, output: s, durationMs: c }) => {
+			if (!o) try {
+				let r = await e.store.update("_voltro_workflow_run_steps", n, {
+					status: "succeeded",
+					output: i(Z(s, t)),
+					completedAt: /* @__PURE__ */ new Date(),
+					durationMs: c
+				});
+				r && a?.("workflowSteps", {
+					op: "update",
+					row: Q(r)
+				});
+			} catch (e) {
+				r("failed to record step success", {
+					stepRecordId: n,
+					reason: e?.message ?? String(e)
+				});
+			}
+		},
+		endStepFailure: async ({ stepRecordId: n, errorTag: s, errorMessage: c, errorCause: l, durationMs: u }) => {
+			if (!o) try {
+				let r = await e.store.update("_voltro_workflow_run_steps", n, {
+					status: "failed",
+					errorTag: s,
+					errorMessage: c,
+					errorCause: l === void 0 ? null : i(Z(l, t)),
+					completedAt: /* @__PURE__ */ new Date(),
+					durationMs: u
+				});
+				r && a?.("workflowSteps", {
+					op: "update",
+					row: Q(r)
+				});
+			} catch (e) {
+				r("failed to record step failure", {
+					stepRecordId: n,
+					reason: e?.message ?? String(e)
+				});
+			}
+		},
+		recordEvent: async ({ runId: t, eventType: i, payload: o, stepName: s, attempt: c }) => {
+			let l = n("wfev");
+			try {
+				let n = await e.store.insert("_voltro_workflow_run_events", {
+					id: l,
+					runId: t,
+					eventType: i,
+					payload: o ?? null,
+					occurredAt: /* @__PURE__ */ new Date(),
+					stepName: s ?? null,
+					attempt: c ?? null
+				});
+				a?.("workflowEvents", {
+					op: "insert",
+					row: Q(n)
+				});
+			} catch (e) {
+				r("failed to record workflow event (continuing)", {
+					runId: t,
+					eventType: i,
+					reason: e?.message ?? String(e)
+				});
+			}
+			if (e.wakeups !== void 0) {
+				let n = o?.scheduledWakeAt, r = typeof n == "string" ? new Date(n) : void 0, a = o?.tenantId, s = typeof a == "string" ? a : void 0;
+				i === "timer-set" && r !== void 0 && !Number.isNaN(r.getTime()) ? await e.wakeups.register(t, r, s).catch(() => {}) : (i === "timer-fired" || i === "run-succeeded" || i === "run-failed" || i === "run-cancelled") && await e.wakeups.cancel(t, s).catch(() => {});
+			}
+			return { id: l };
+		}
+	};
+}, bn = (e, t, n) => m.gen(function* () {
+	let r = e.store.query;
+	if (r === void 0) return;
+	let i = e.replayShapeLimit ?? 2e3, a = yield* m.promise(() => r({
+		table: "_voltro_workflow_run_steps",
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		predicate: x("runId", t),
+		projection: ["stepName"],
+		skip: void 0,
+		take: i + 1
+	}).catch((e) => (n("failed to read the replay shape (nondeterminism tripwire disabled for this attempt)", {
+		runId: t,
+		reason: e?.message ?? String(e)
+	}), [])));
+	if (a.length === 0) return;
+	if (a.length > i) {
+		n("replay shape exceeds the step limit — nondeterminism tripwire disabled for this run", {
+			runId: t,
+			limit: i
+		});
+		return;
+	}
+	let s = a.flatMap((e) => {
+		let t = e.stepName;
+		return typeof t == "string" ? [{ stepName: t }] : [];
+	});
+	return s.length === 0 ? void 0 : o(s);
+}), xn = (o, c) => {
+	let l = o.truncateBytes ?? fn, u = o.makeId ?? vn, f = o.recorder ?? yn(o), h = (e, t) => o.log?.warn(e, t), v = o.emit, y = (e, t, n) => m.promise(async () => {
+		if (o.onParentClose) try {
+			await o.onParentClose({
+				workflowName: o.name,
+				executionId: e,
+				...n === void 0 ? {} : { runId: n },
+				status: t
+			});
+		} catch (n) {
+			h("failed to apply workflow parent-close policy", {
+				tag: o.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	}), b = (e, t, n) => m.promise(async () => {
+		if (o.onTerminal) try {
+			await o.onTerminal({
+				workflowName: o.name,
+				executionId: e,
+				...n === void 0 ? {} : { runId: n },
+				status: t
+			});
+		} catch (n) {
+			h("failed to release the workflow admission lease", {
+				tag: o.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	});
+	return (ee, S) => m.gen(function* () {
+		let C = Date.now(), te = yield* _.get(r), w = o.parentExecutionId ?? te ?? null, ne = o.parentClosePolicy ?? null, T, E = (e, t) => t.pipe(m.catchAllCause((t) => p.isInterrupted(t) ? m.failCause(t) : m.sync(() => {
+			let n = p.squash(t);
+			h(e, {
+				tag: o.name,
+				executionId: S,
+				reason: n?.message ?? String(n)
+			});
+		}))), D = (o.store.query ? yield* m.promise(() => o.store.query({
+			table: "_voltro_workflow_runs",
+			order: [],
+			predicate: x("executionId", S),
+			projection: void 0,
+			skip: void 0,
+			take: 1
+		})) : [])[0], O = D?.workflowVersion ?? null;
+		if (D?.id !== void 0 && O !== null && o.workflowCompatibleVersions !== void 0 && o.workflowCompatibleVersions !== null && !o.workflowCompatibleVersions.includes(O)) {
+			let e = `Workflow '${o.name}' run '${S}' was started on version ${O}, but current code is compatible with ${o.workflowCompatibleVersions.join(", ")}`, t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", D.id, {
+				status: "failed",
+				errorTag: "WorkflowVersionIncompatible",
+				errorMessage: e,
+				completedAt: /* @__PURE__ */ new Date(),
+				runnerEnteredAt: null
+			}));
+			return t && v?.("workflowRuns", {
+				op: "update",
+				row: Q(t)
+			}), yield* m.promise(() => f.recordEvent({
+				runId: D.id,
+				eventType: "run-failed",
+				payload: {
+					errorTag: "WorkflowVersionIncompatible",
+					errorMessage: e,
+					workflowVersion: o.workflowVersion ?? null,
+					compatibleWith: o.workflowCompatibleVersions,
+					previousVersion: O
+				}
+			})), yield* m.sync(() => o.recordRun?.({
+				name: o.name,
+				status: "failed",
+				durationMs: 0
+			})), yield* m.fail(Error(e));
+		}
+		let k = o.workflowPatches ?? [], A;
+		if (D?.id !== void 0) {
+			T = D.id, k = gn(D.workflowPatches) ?? k;
+			let e = D.runnerEnteredAt !== null && D.runnerEnteredAt !== void 0, t = typeof D.reclaimCount == "number" ? D.reclaimCount : Number(D.reclaimCount ?? 0), n = e ? (Number.isFinite(t) ? t : 0) + 1 : 0, r = o.maxRunReclaims ?? 3;
+			if (e && n >= r) {
+				let e = `Workflow '${o.name}' run '${S}' killed its runner ${n} times in a row; parked instead of reclaimed again (maxRunReclaims=${r}).`;
+				yield* E("failed to record workflow crash-loop park", m.gen(function* () {
+					let t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
+						status: "suspended",
+						errorTag: "WorkflowCrashLooped",
+						errorMessage: e,
+						reclaimCount: n,
+						runnerEnteredAt: null
+					}));
+					t && v?.("workflowRuns", {
+						op: "update",
+						row: Q(t)
+					}), yield* m.promise(() => f.recordEvent({
+						runId: T,
+						eventType: "run-crashlooped",
+						payload: {
+							reclaimCount: n,
+							maxRunReclaims: r,
+							executionId: S,
+							tag: o.name
+						}
+					}));
+				})), h("workflow run parked after repeated runner deaths", {
+					tag: o.name,
+					executionId: S,
+					runId: T,
+					reclaimCount: n,
+					maxRunReclaims: r
+				});
+				let t = yield* se;
+				return yield* d.suspend(t);
+			}
+			A = yield* bn(o, T, h), yield* E("failed to record workflow re-entry", m.gen(function* () {
+				let t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
+					status: "running",
+					errorTag: null,
+					errorMessage: null,
+					completedAt: null,
+					reclaimCount: n,
+					runnerEnteredAt: /* @__PURE__ */ new Date()
+				}));
+				t && v?.("workflowRuns", {
+					op: "update",
+					row: Q(t)
+				}), e && (yield* m.promise(() => f.recordEvent({
+					runId: T,
+					eventType: "run-resumed",
+					payload: {
+						reason: "runner-reclaim",
+						reclaimCount: n,
+						maxRunReclaims: r
+					}
+				})));
+			}));
+		} else yield* E("failed to record workflow start (continuing)", m.gen(function* () {
+			let e = yield* m.promise(() => o.store.insert("_voltro_workflow_runs", {
+				id: u("wr"),
+				tag: o.name,
+				executionId: S,
+				status: "running",
+				payload: ee,
+				workflowVersion: o.workflowVersion ?? null,
+				workflowPatches: o.workflowPatches ?? null,
+				output: null,
+				subject: o.subject ?? null,
+				source: o.source ?? null,
+				errorTag: null,
+				errorMessage: null,
+				cancelled: !1,
+				startedAt: /* @__PURE__ */ new Date(),
+				completedAt: null,
+				durationMs: null,
+				traceId: o.traceId ?? null,
+				parentExecutionId: w,
+				parentClosePolicy: ne,
+				runnerEnteredAt: /* @__PURE__ */ new Date(),
+				reclaimCount: 0
+			}));
+			if (T = e.id, v?.("workflowRuns", {
+				op: "insert",
+				row: Q(e)
+			}), T) {
+				let e = T;
+				yield* m.promise(() => f.recordEvent({
+					runId: e,
+					eventType: "run-started",
+					payload: {
+						tag: o.name,
+						executionId: S,
+						source: o.source ?? null,
+						workflowVersion: o.workflowVersion ?? null,
+						workflowPatches: o.workflowPatches ?? null,
+						parentExecutionId: w,
+						parentClosePolicy: ne
+					}
+				}));
+			}
+		}));
+		let re = o.subject?.tenantId, ie = c(ee, S).pipe(m.locally(a, T), m.locally(r, S), m.locally(t, typeof re == "string" ? re : void 0), m.locally(i, k), m.locally(s, A), m.provideService(n, f)), ae = o.pluginWorkflowStepLayer ? ie.pipe(m.provide(o.pluginWorkflowStepLayer)) : ie, j = yield* d.intoResult(ae);
+		if (d.isResult(j) && j._tag === "Suspended") {
+			let e = j.cause, t = e !== void 0 && !p.isEmpty(e), n = t ? p.squash(e) : void 0, r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = t ? n?.message ?? String(n) : null;
+			t && (yield* m.sync(() => ce({
+				error: n,
+				source: "workflow",
+				name: o.name,
+				...o.traceId ? { traceId: o.traceId } : {},
+				fields: {
+					executionId: S,
+					suspendedOnFailure: !0,
+					...r ? { errorTag: r } : {},
+					...T ? { runId: T } : {}
+				}
+			}))), T && (yield* E("failed to record workflow suspend", m.gen(function* () {
+				let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
+					status: "suspended",
+					runnerEnteredAt: null,
+					...t ? {
+						errorTag: r,
+						errorMessage: i
+					} : {}
+				}));
+				e && v?.("workflowRuns", {
+					op: "update",
+					row: Q(e)
+				}), yield* m.promise(() => f.recordEvent({
+					runId: T,
+					eventType: "run-suspended",
+					payload: t ? {
+						reason: "suspend-on-failure",
+						errorTag: r,
+						errorMessage: i
+					} : { reason: "workflow-suspend" }
+				}));
+			})));
+			let a = yield* se;
+			return yield* d.suspend(a);
+		}
+		let M = j;
+		if (A !== void 0 && T !== void 0) {
+			let t = A.settle();
+			if (t.length > 0) {
+				let n = T;
+				h("workflow replay reached a different step shape than this run recorded", {
+					tag: o.name,
+					executionId: S,
+					runId: n,
+					findings: t.map((e) => `${e.kind}:${e.stepName}`)
+				}), yield* E("failed to record nondeterminism findings", m.promise(async () => {
+					for (let r of t) await f.recordEvent({
+						runId: n,
+						eventType: "nondeterminism-suspected",
+						payload: e(r)
+					}).catch(() => void 0);
+				}));
+			}
+		}
+		if (g.isFailure(M.exit)) {
+			let e = M.exit.cause, t = p.failureOption(e), n = t._tag === "Some" ? t.value : p.squash(e), r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = n?.message ?? String(n);
+			return yield* m.sync(() => ce({
+				error: n,
+				source: "workflow",
+				name: o.name,
+				...o.traceId ? { traceId: o.traceId } : {},
+				fields: {
+					executionId: S,
+					...r ? { errorTag: r } : {},
+					...T ? { runId: T } : {}
+				}
+			})), T && (yield* E("failed to record workflow failure", m.gen(function* () {
+				let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
+					status: "failed",
+					errorTag: r,
+					errorMessage: i,
+					completedAt: /* @__PURE__ */ new Date(),
+					durationMs: Date.now() - C,
+					runnerEnteredAt: null
+				}));
+				e && v?.("workflowRuns", {
+					op: "update",
+					row: Q(e)
+				}), yield* m.promise(() => f.recordEvent({
+					runId: T,
+					eventType: "run-failed",
+					payload: {
+						errorTag: r,
+						errorMessage: i,
+						durationMs: Date.now() - C
+					}
+				})), yield* y(S, "failed", T);
+			}))), yield* b(S, "failed", T), yield* m.sync(() => o.recordRun?.({
+				name: o.name,
+				status: "failed",
+				durationMs: Date.now() - C
+			})), yield* m.failCause(e);
+		}
+		let N = M.exit.value;
+		return T && (yield* E("failed to record workflow success", m.gen(function* () {
+			let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
+				status: "succeeded",
+				output: Z(N, l),
+				completedAt: /* @__PURE__ */ new Date(),
+				durationMs: Date.now() - C,
+				runnerEnteredAt: null
+			}));
+			e && v?.("workflowRuns", {
+				op: "update",
+				row: Q(e)
+			}), yield* m.promise(() => f.recordEvent({
+				runId: T,
+				eventType: "run-succeeded",
+				payload: { durationMs: Date.now() - C }
+			})), yield* y(S, "succeeded", T);
+		}))), yield* b(S, "succeeded", T), yield* m.sync(() => o.recordRun?.({
+			name: o.name,
+			status: "succeeded",
+			durationMs: Date.now() - C,
+			completedAtSec: Date.now() / 1e3
+		})), N;
+	});
+}, Sn = (e) => e === "cancel" || e === "terminate", Cn = (e) => e === "running" || e === "suspended", wn = async (e) => {
+	let t = await e.store.query({
+		table: "_voltro_workflow_runs",
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		predicate: x("parentExecutionId", e.parentExecutionId),
+		projection: void 0,
+		skip: void 0,
+		take: e.limit ?? 1e3
+	}), n = [];
+	for (let r of t) {
+		let t = {
+			runId: r.id,
+			workflowName: r.tag,
+			executionId: r.executionId,
+			policy: r.parentClosePolicy
+		};
+		if (r.parentClosePolicy === "abandon") {
+			n.push({
+				...t,
+				action: "abandoned"
+			});
+			continue;
+		}
+		if (!Sn(r.parentClosePolicy)) {
+			n.push({
+				...t,
+				action: "skipped",
+				reason: "no-parent-close-policy"
+			});
+			continue;
+		}
+		if (!Cn(r.status)) {
+			n.push({
+				...t,
+				action: "skipped",
+				reason: `status:${r.status}`
+			});
+			continue;
+		}
+		try {
+			await e.interruptChild(r.tag, r.executionId, r.parentClosePolicy);
+			let i = await e.store.update("_voltro_workflow_runs", r.id, {
+				status: "cancelled",
+				cancelled: !0,
+				completedAt: /* @__PURE__ */ new Date()
+			});
+			i && e.emit?.("workflowRuns", {
+				op: "update",
+				row: Q(i)
+			}), await e.recorder?.recordEvent({
+				runId: r.id,
+				eventType: "run-cancelled",
+				payload: {
+					reason: "parent-close",
+					parentExecutionId: e.parentExecutionId,
+					parentStatus: e.parentStatus,
+					parentClosePolicy: r.parentClosePolicy,
+					action: r.parentClosePolicy
+				}
+			}), n.push({
+				...t,
+				action: "cancelled"
+			});
+		} catch (i) {
+			let a = i?.message ?? String(i);
+			e.log?.warn("workflow.parentClose.childInterrupt failed", {
+				parentExecutionId: e.parentExecutionId,
+				childExecutionId: r.executionId,
+				childWorkflowName: r.tag,
+				parentClosePolicy: r.parentClosePolicy,
+				reason: a
+			}), n.push({
+				...t,
+				action: "failed",
+				reason: a
+			});
+		}
+	}
+	return n;
+}, Tn = (e) => {
+	if (e == null) return null;
+	if (e instanceof Date) return e;
+	if (typeof e == "string" || typeof e == "number") {
+		let t = new Date(e);
+		return Number.isNaN(t.getTime()) ? null : t;
+	}
+	return null;
+}, En = (e) => typeof e == "number" ? e : e == null ? null : Number(e), $ = (e) => e == null ? null : String(e), Dn = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = String(n.stepName), r = t.get(e);
+		r === void 0 ? t.set(e, [n]) : r.push(n);
+	}
+	let n = [];
+	for (let [e, r] of t) {
+		r.sort((e, t) => (En(e.attempt) ?? 0) - (En(t.attempt) ?? 0));
+		let t = r[r.length - 1], i = $(t.errorTag), a = $(t.errorMessage), o = i !== null || a !== null ? {
+			tag: i,
+			message: a ?? ""
+		} : null;
+		n.push({
+			name: e,
+			attempt: En(t.attempt) ?? r.length,
+			attempts: r.length,
+			status: t.status ?? "running",
+			input: t.input ?? null,
+			output: t.output ?? null,
+			error: o,
+			durationMs: En(t.durationMs)
+		});
+	}
+	return n.sort((t, n) => {
+		let r = e.find((e) => String(e.stepName) === t.name), i = e.find((e) => String(e.stepName) === n.name);
+		return (Tn(r?.startedAt)?.getTime() ?? 0) - (Tn(i?.startedAt)?.getTime() ?? 0);
+	}), n;
+}, On = (e) => {
+	if (e == null) return null;
+	if (typeof e == "string") try {
+		return JSON.parse(e);
+	} catch {
+		return null;
+	}
+	return typeof e == "object" ? e : null;
+}, kn = async (e, t) => {
+	let n = A(P), r = (await t.query(n.where(k(x("id", e), x("executionId", e))).limit(1).descriptor))[0];
+	if (r === void 0) return null;
+	let i = String(r.id), a = A(ue), o = await t.query(a.where(x("runId", i)).descriptor);
+	return {
+		id: i,
+		executionId: $(r.executionId) ?? "",
+		name: $(r.tag) ?? "",
+		status: r.status ?? "running",
+		input: r.payload ?? null,
+		output: r.output ?? null,
+		subject: On(r.subject),
+		source: $(r.source),
+		steps: Dn(o),
+		startedAt: Tn(r.startedAt) ?? /* @__PURE__ */ new Date(0),
+		finishedAt: Tn(r.completedAt),
+		traceId: $(r.traceId),
+		parentExecutionId: $(r.parentExecutionId),
+		parentClosePolicy: $(r.parentClosePolicy)
+	};
+}, An = () => {
+	let e = [], t = [], r = 0, i = 0;
+	return {
+		layer: v.succeed(n, {
+			startStep: async ({ runId: t, stepName: n, attempt: i, stepInput: a, retryPolicy: o }) => {
+				let s = `wfstep_mem_${++r}`;
+				return e.push({
+					id: s,
+					runId: t,
+					stepName: n,
+					attempt: i,
+					status: "running",
+					input: a ?? null,
+					retryPolicy: o ?? null,
+					output: null,
+					errorTag: null,
+					errorMessage: null,
+					errorCause: null,
+					startedAt: /* @__PURE__ */ new Date(),
+					completedAt: null,
+					durationMs: null
+				}), s;
+			},
+			endStepSuccess: async ({ stepRecordId: t, output: n, durationMs: r }) => {
+				let i = e.find((e) => e.id === t);
+				i !== void 0 && (i.status = "succeeded", i.output = n, i.completedAt = /* @__PURE__ */ new Date(), i.durationMs = r);
+			},
+			endStepFailure: async ({ stepRecordId: t, errorTag: n, errorMessage: r, errorCause: i, durationMs: a }) => {
+				let o = e.find((e) => e.id === t);
+				o !== void 0 && (o.status = "failed", o.errorTag = n, o.errorMessage = r, o.errorCause = i ?? null, o.completedAt = /* @__PURE__ */ new Date(), o.durationMs = a);
+			},
+			recordEvent: async ({ runId: e, eventType: n, payload: r, stepName: a, attempt: o }) => {
+				let s = `wfev_mem_${++i}`;
+				return t.push({
+					id: s,
+					runId: e,
+					eventType: n,
+					payload: r ?? null,
+					stepName: a ?? null,
+					attempt: o ?? null,
+					occurredAt: /* @__PURE__ */ new Date()
+				}), { id: s };
+			}
+		}),
+		readSteps: () => e,
+		readEvents: () => t
+	};
+};
+//#endregion
+export { Je as $, zt as A, _e as At, at as B, tn as C, Ae as Ct, It as D, Se as Dt, Ht as E, ye as Et, Dt as F, fe as Ft, Qe as G, ot as H, Tt as I, de as It, Xe as J, $e as K, wt as L, ue as Lt, At as M, me as Mt, St as N, he as Nt, Lt as O, xe as Ot, Ot as P, pe as Pt, Ye as Q, ht as R, P as Rt, on as S, W as St, Kt as T, Ce as Tt, pt as U, st as V, K as W, it as X, et as Y, tt as Z, Xt as _, Ne as _t, mn as a, we as at, cn as b, Oe as bt, hn as c, G as ct, xn as d, Ve as dt, Ke as et, dn as f, Be as ft, Zt as g, Le as gt, en as h, Ee as ht, pn as i, Te as it, Mt as j, I as jt, Rt as k, ve as kt, Q as l, ze as lt, $t as m, ke as mt, kn as n, Ge as nt, yn as o, R as ot, X as p, Pe as pt, Ze as q, wn as r, z as rt, gn as s, Re as st, An as t, Ue as tt, Z as u, Ie as ut, Yt as v, He as vt, Gt as w, ge as wt, sn as x, U as xt, Jt as y, je as yt, gt as z, le as zt };