@voltro/workflow 0.80.0 → 0.82.0

package/dist/clusterDiagnostics-Dc7yBP3b.js

@@ -0,0 +1,2069 @@
+import { C as e, S as t, _ as n, b as r, l as i, m as a } from "./journalEncryption--n5VDdYO.js";
+import { Context as o, Effect as s, Schema as c } from "effect";
+import { WorkflowRestartObservationSchema as l, WorkflowRestartSelectionSchema as u, WorkflowRestartTargetSchema as d, WorkflowStartTerminalOutcomeSchema as f } from "@voltro/protocol";
+import { and as p, derivedRowId as m, eq as h, gt as g, id as _, integer as ee, isNull as v, json as y, or as te, table as ne, text as b, timestamp as re } from "@voltro/database";
+import { createHash as ie, randomUUID as x } from "node:crypto";
+import { isDeepStrictEqual as ae } from "node:util";
+import { SqlClient as S } from "@effect/sql";
+//#region src/admissionTransaction.ts
+var oe = "_voltro_workflow_admission_locks", se = "deployment", C = async (e, t) => (await e.insertIgnoreWithOutcome(oe, {
+	id: se,
+	nonce: x()
+}, { conflictColumns: ["id"] }), e.transactional(async (e) => {
+	if ((await e.query({
+		table: "_voltro_workflow_admission_locks",
+		predicate: h("id", se),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	})).length !== 1) throw Error("Admission coordinator row is missing; refusing an unlocked decision");
+	if (await e.update("_voltro_workflow_admission_locks", se, { nonce: x() }) === null) throw Error("Admission coordinator row disappeared; refusing an unlocked decision");
+	return t(e);
+})), ce = 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;
+	}
+}, w = (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 ce(e, t, n);
+	}
+}, le = (e, t) => JSON.stringify([e ?? null, t]), ue = (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 ce(n, "priority", e);
+	}
+	return {
+		...e.debounce === void 0 ? {} : { debounceKey: w(n, "debounce.key", e.debounce.key, t) },
+		...e.singleton === void 0 ? {} : { singletonKey: w(n, "singleton.key", e.singleton.key, t) },
+		...e.concurrency === void 0 ? {} : { concurrencyKey: le(e.concurrency.pool, e.concurrency.key === void 0 ? "" : w(n, "concurrency.key", e.concurrency.key, t)) },
+		...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: w(n, "throttle.key", e.throttle.key, t) },
+		...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: w(n, "rateLimit.key", e.rateLimit.key, t) },
+		...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey: w(n, "batch.key", e.batch.key, t) },
+		priority: r
+	};
+}, de = (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;
+}, fe = (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 = de(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 && r.singletonUnacknowledged === !0) return {
+		kind: "defer",
+		mode: "singleton",
+		dueAt: i,
+		collapse: a ? "hold" : "append",
+		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,
+			...T(t, r)
+		} : {
+			kind: "admit",
+			reason: "debounce-elapsed",
+			keys: n,
+			...T(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,
+			...T(t, r)
+		} : a && i >= s ? {
+			kind: "admit",
+			reason: "batch-timeout",
+			keys: n,
+			...T(t, r)
+		} : {
+			kind: "defer",
+			mode: "batch",
+			dueAt: s,
+			collapse: a ? "hold" : "append",
+			keys: n
+		};
+	}
+	if (t.throttle !== void 0) {
+		let e = de(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: pe(t) ? "under-limits" : "no-controls",
+		keys: n,
+		...T(t, r)
+	};
+}, pe = (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, T = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, me = (e, t, n) => {
+	let r = e.timeouts?.startMs;
+	return r !== void 0 && n - t.firstSeenAt >= r;
+}, he = (e, t, n) => {
+	let r = e.timeouts?.finishMs;
+	return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
+}, ge = (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, E = "_voltro_workflow_failure_reports", _e = c.Struct({
+	id: c.String,
+	workflowName: c.String,
+	tenantId: c.NullOr(c.String),
+	sourceId: c.String,
+	sourceKind: c.Literal("submission", "intent", "run"),
+	handler: c.NullOr(c.String),
+	callerContext: c.Unknown,
+	report: c.Struct({
+		workflow: c.String,
+		payload: c.Unknown,
+		errorTag: c.NullOr(c.String),
+		errorMessage: c.NullOr(c.String),
+		runId: c.NullOr(c.String),
+		executionId: c.NullOr(c.String),
+		reason: c.String,
+		failedAt: c.Number
+	})
+}), D = async (e, t) => {
+	let n = await e.query({
+		table: E,
+		predicate: h("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : c.decodeUnknownSync(_e)(n[0]);
+}, ve = async (e, t) => {
+	if (t.id.length === 0 || t.sourceId.length === 0) throw Error("Workflow failure requires a stable report and source identity");
+	let n = await D(e, t.id);
+	if (n !== void 0) {
+		if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.sourceId !== t.sourceId || n.sourceKind !== t.sourceKind) throw Error("Workflow failure identity belongs to a different source, workflow or tenant");
+		return n;
+	}
+	let i = c.decodeUnknownSync(_e)(t), a = {
+		...i,
+		report: {
+			...i.report,
+			errorMessage: r(i.workflowName, i.report.errorMessage)
+		}
+	};
+	if (a.report.workflow !== a.workflowName) throw Error("Workflow failure report does not describe its owning workflow");
+	return await e.insert(E, {
+		...a,
+		handoffReceiptId: null,
+		handoffAttempt: 0,
+		acceptedExecutionId: null
+	}), a;
+}, ye = async (e, t, n) => {
+	let r, i = t === "submissionId" ? h(t, n) : p(h(t, n), v("submissionId"), v("terminal"));
+	for (;;) {
+		let t = await e.query({
+			table: N,
+			predicate: r === void 0 ? i : p(i, g("id", r)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (t.length === 0) return !1;
+		for (let n of t) {
+			let t = P(n), i = await e.query({
+				table: E,
+				predicate: h("handoffReceiptId", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (i.length !== 0) {
+				if (i[0]?.handler !== t.workflowName || i[0]?.tenantId !== t.tenantId) throw Error("Failure delivery receipt belongs to a different workflow or tenant");
+				return !0;
+			}
+			r = t.id;
+		}
+	}
+}, be = (e, t) => ye(e, "submissionId", t), xe = (e, t) => ye(e, "pendingId", t), Se = async (e, t, n, r) => {
+	for await (let i of Pe(e, t, n)) {
+		if (i.tenantId !== r) throw Error("Failure delivery belongs to a different resident tenant");
+		if (await be(e, i.id)) return !0;
+	}
+	return !1;
+}, Ce = c.Struct({
+	handoffReceiptId: c.NullOr(c.String),
+	handoffAttempt: c.NonNegativeInt,
+	acceptedExecutionId: c.NullOr(c.NonEmptyString)
+}), we = (e, t) => `wfrc_${ie("sha256").update(JSON.stringify([
+	"failure",
+	e,
+	t
+])).digest("hex").slice(0, 40)}`, Te = async (e, t) => {
+	let n = await e.query({
+		table: E,
+		predicate: h("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), r = c.decodeUnknownSync(Ce)(n[0]);
+	if (r.handoffReceiptId === null && (r.handoffAttempt !== 0 || r.acceptedExecutionId !== null)) throw Error("Failure report has contradictory unstarted handoff metadata");
+	return r;
+}, Ee = (t) => {
+	if (t.handler === null || !i(t.handler)) return t.report;
+	let r = `failure report for '${t.handler}'`;
+	return e({
+		...t.report,
+		payload: n(t.report.payload, `${r}.payload`),
+		errorMessage: a(t.report.errorMessage)
+	}, r);
+}, De = async (e, t, n, r, i) => {
+	if (t.handler === null || t.handler.length === 0) throw Error("Cannot queue an unconfigured failure handler");
+	if (!Number.isSafeInteger(n) || n < 0) throw Error("Failure handoff attempt exhausted");
+	if (!Number.isFinite(r)) throw Error("Failure handoff retry deadline is invalid");
+	let a = await st({
+		store: e,
+		workflowName: t.handler,
+		payload: Ee(t),
+		callerContext: t.callerContext,
+		tenantId: t.tenantId,
+		at: r,
+		now: i
+	}), o = await Ye(e, {
+		id: we(t.id, n),
+		workflowName: t.handler,
+		tenantId: t.tenantId,
+		pendingId: a.intentId
+	});
+	if (await e.update("_voltro_workflow_failure_reports", t.id, {
+		handoffReceiptId: o.id,
+		handoffAttempt: n
+	}) === null) throw Error("Failure report disappeared during durable handoff");
+	return {
+		kind: "queued",
+		receiptId: o.id,
+		intentId: o.pendingId
+	};
+}, O = async (e, t, n) => {
+	if (!Number.isFinite(n)) throw Error("Failure handoff requires a finite timestamp");
+	let r = await D(e, t);
+	if (r === void 0) throw Error("Cannot hand off an unknown workflow failure");
+	let { handoffReceiptId: i, handoffAttempt: a, acceptedExecutionId: o } = await Te(e, t);
+	if (r.handler === null) {
+		if (i !== null || o !== null) throw Error("Unconfigured failure report has a contradictory handoff");
+		return { kind: "unconfigured" };
+	}
+	if (r.handler.length === 0) throw Error("Failure report has an empty handler");
+	let s = we(t, a);
+	if (i !== null) {
+		if (i !== s) throw Error("Failure handoff receipt belongs to a different report");
+		let t = await F(e, i);
+		if (t === void 0 || t.workflowName !== r.handler || t.tenantId !== r.tenantId) throw Error("Failure report has no matching durable start receipt");
+		return {
+			kind: "queued",
+			receiptId: t.id,
+			intentId: t.pendingId
+		};
+	}
+	return De(e, r, 0, n, n);
+}, k = class extends Error {
+	reason;
+	constructor(e) {
+		super(`Workflow failure delivery requires reconciliation: ${e}`), this.reason = e;
+	}
+}, Oe = async (e, t, n) => {
+	let r = await O(e, t, n);
+	if (r.kind === "unconfigured") return r;
+	let i = await Te(e, t), a = await F(e, r.receiptId);
+	if (a === void 0) throw Error("Failure handoff receipt disappeared during reconciliation");
+	if (i.acceptedExecutionId !== null) {
+		if (a.terminal !== null || a.submissionId === null) throw Error("Accepted failure report has no submitted receipt");
+		return {
+			kind: "accepted",
+			executionId: i.acceptedExecutionId
+		};
+	}
+	if (a.terminal !== null) {
+		if (a.terminal.kind === "cancelled") return {
+			kind: "cancelled",
+			receiptId: a.id
+		};
+		let r = await D(e, t);
+		if (r === void 0) throw Error("Failure report disappeared during retry");
+		let o = i.handoffAttempt + 1, s = Math.max(W(o, () => 1), a.terminal.kind === "dropped" ? a.terminal.retryAfterMs : 0);
+		return De(e, r, o, Math.max(n, a.terminal.at + s), n);
+	}
+	if (a.submissionId === null) {
+		let t = (await e.query({
+			table: I,
+			predicate: h("id", a.pendingId),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0];
+		if (t === void 0) throw new k("arrival-missing");
+		if (t.workflowName !== a.workflowName || t.tenantId !== a.tenantId) throw new k("arrival-owner-mismatch");
+		if (t.deadLetteredAt !== null) throw new k("arrival-dead-lettered");
+		return r;
+	}
+	let o = await M(e, a.submissionId);
+	if (o === void 0 || !o.receiptsBound || o.workflowName !== a.workflowName || o.tenantId !== a.tenantId || !o.intentIds.includes(a.pendingId)) throw Error("Failure handoff receipt has no matching admission submission");
+	if (o.failureId !== null) {
+		let r = await D(e, o.failureId);
+		if (o.executionId !== null || o.dispatchAttempts > 1 || r === void 0 || r.sourceKind !== "submission" || r.sourceId !== o.id || r.workflowName !== o.workflowName || r.tenantId !== o.tenantId || r.report.executionId !== null || r.report.runId !== null) throw new k("rejection-proof-invalid");
+		let a = await D(e, t);
+		if (a === void 0) throw Error("Failure report disappeared during rejected handler retry");
+		let s = i.handoffAttempt + 1;
+		return De(e, a, s, Math.max(n, r.report.failedAt + W(s, () => 1)), n);
+	}
+	if (o.executionId === null) return r;
+	if (o.failureId !== null || o.executionId.length === 0 || o.preparedExecutionId !== o.executionId) throw Error("Failure handler acknowledgement contradicts its prepared submission");
+	if (await e.update("_voltro_workflow_failure_reports", t, { acceptedExecutionId: o.executionId }) === null) throw Error("Failure report disappeared during acceptance acknowledgement");
+	return {
+		kind: "accepted",
+		executionId: o.executionId
+	};
+}, ke = c.Struct({
+	runId: c.NonEmptyString,
+	workflowName: c.NonEmptyString,
+	executionId: c.NonEmptyString,
+	generation: c.NonEmptyString,
+	parentStatus: c.Literal("succeeded", "failed", "cancelled"),
+	closedAt: c.DateFromSelf
+}), Ae = async (e, t, n) => {
+	let [r] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("executionId", n),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r !== void 0) {
+		if (r.tag !== t) throw Error("Admission acknowledgement belongs to a different resident workflow");
+		if (typeof r.id != "string" || r.id.length === 0) throw Error("Resident execution has no run identity");
+		if (r.status === "running" || r.status === "suspended") return {
+			runId: r.id,
+			completedAt: null
+		};
+		if (r.status !== "succeeded" && r.status !== "failed" && r.status !== "cancelled") throw Error("Resident execution has an unrecognized status");
+		if (!(r.completedAt instanceof Date) || !Number.isFinite(r.completedAt.getTime())) throw Error("Terminal workflow has no valid completion timestamp for lease release");
+		return {
+			runId: r.id,
+			completedAt: r.completedAt
+		};
+	}
+	let [i] = await e.query({
+		table: "_voltro_workflow_parent_closures",
+		predicate: h("executionId", n),
+		lock: "update",
+		order: [{
+			column: "closedAt",
+			direction: "desc"
+		}, {
+			column: "id",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i === void 0) return;
+	let a = c.decodeUnknownSync(ke)(i);
+	if (a.workflowName !== t || a.executionId !== n) throw Error("Admission acknowledgement belongs to a different resident workflow");
+	if (!Number.isFinite(a.closedAt.getTime())) throw Error("Workflow closure has no valid completion timestamp");
+	return {
+		runId: a.runId,
+		completedAt: a.closedAt
+	};
+}, A = "_voltro_workflow_submissions", je = "wfsub", Me = () => `${je}_${x()}`, j = c.Struct({
+	id: c.String,
+	workflowName: c.String,
+	tenantId: c.NullOr(c.String),
+	ledgerId: c.String,
+	preparedExecutionId: c.NullOr(c.String),
+	executionId: c.NullOr(c.String),
+	runId: c.NullOr(c.String),
+	receiptsBound: c.Boolean,
+	dispatchAttempts: c.NonNegativeInt,
+	failureId: c.NullOr(c.String),
+	retry: c.Struct({
+		attempts: c.Int,
+		after: c.Number,
+		lastError: c.NullOr(c.String),
+		stoppedAt: c.NullOr(c.Number)
+	}),
+	payload: c.Unknown,
+	callerContext: c.Unknown,
+	intentIds: c.Array(c.String),
+	eviction: c.NullOr(c.Struct({
+		executionId: c.String,
+		runId: c.String
+	}))
+}), Ne = c.decodeUnknownSync(j);
+async function* Pe(e, t, n) {
+	let r;
+	for (;;) {
+		let i = p(h("preparedExecutionId", t), g("dispatchAttempts", 0)), a = await e.query({
+			table: A,
+			predicate: r === void 0 ? i : p(i, g("id", r)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (a.length === 0) return;
+		for (let e of a) {
+			let i = Ne(e);
+			if (i.workflowName !== n || !i.receiptsBound || i.failureId !== null || i.executionId !== null && i.executionId !== t) throw Error("Workflow completion has an inconsistent resident submission owner");
+			yield i, r = i.id;
+		}
+	}
+}
+var Fe = async (e, t, n) => (await Ie(e, t, n)).map((e) => Ne(e)), Ie = async (e, t, n) => {
+	if (!Number.isSafeInteger(t) || t < 1) throw Error("Submission recovery requires a positive page size");
+	return e.query({
+		table: A,
+		predicate: n === void 0 ? p(h("receiptsBound", !0), v("executionId"), v("failureId")) : p(h("receiptsBound", !0), v("executionId"), v("failureId"), g("id", n)),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: t,
+		skip: void 0,
+		projection: void 0
+	});
+}, M = async (e, t) => {
+	let n = await e.query({
+		table: A,
+		predicate: h("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : c.decodeUnknownSync(j)(n[0]);
+}, Le = async (e, t) => C(e, (e) => Re(e, t)), Re = async (e, t) => {
+	if (t.id.length === 0) throw Error("Admission submission requires a stable non-empty identity");
+	let n = await e.query({
+		table: A,
+		predicate: h("id", t.id),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n[0] !== void 0) {
+		let e = c.decodeUnknownSync(j)(n[0]);
+		if (e.workflowName !== t.control.workflowName || e.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
+		let r = JSON.parse(JSON.stringify(e.payload) ?? "null"), i = JSON.parse(JSON.stringify(t.encodedPayload) ?? "null");
+		if (!ae(r, i)) throw Error("Admission submission identity is already bound to a different payload");
+		return {
+			kind: "reserved",
+			submission: e,
+			reused: !0
+		};
+	}
+	let r = ue(t.control, t.keyPayload), i = await bt({
+		store: e,
+		control: t.control,
+		keys: r,
+		paused: t.paused,
+		now: t.now,
+		reconsidering: !0
+	});
+	if (i.kind !== "admit") return {
+		kind: "not-admitted",
+		decision: i
+	};
+	let a = await lt({
+		store: e,
+		control: t.control,
+		keys: r,
+		outcome: "admitted",
+		mode: t.mode,
+		reason: i.reason,
+		collapsed: t.collapsed,
+		waitedMs: t.now - t.firstSeenAt,
+		executionId: null,
+		runId: null,
+		tenantId: t.tenantId,
+		now: t.now
+	});
+	if (a === void 0) throw Error("Admission reservation has no ledger identity");
+	return {
+		kind: "reserved",
+		submission: await ze(e, {
+			id: t.id,
+			workflowName: t.control.workflowName,
+			tenantId: t.tenantId,
+			ledgerId: a,
+			payload: t.encodedPayload,
+			callerContext: t.callerContext,
+			intentIds: t.intentIds,
+			eviction: i.evict ?? null
+		}),
+		reused: !1
+	};
+}, ze = async (e, t) => {
+	if (t.id.length === 0 || t.ledgerId.length === 0) throw Error("Submission requires its reserved admission identity");
+	let n = {
+		...t,
+		callerContext: t.callerContext ?? null,
+		intentIds: [...t.intentIds],
+		preparedExecutionId: null,
+		executionId: null,
+		runId: null,
+		receiptsBound: !1,
+		dispatchAttempts: 0,
+		failureId: null,
+		retry: {
+			attempts: 0,
+			after: 0,
+			lastError: null,
+			stoppedAt: null
+		}
+	};
+	return await e.insert(A, n), n;
+}, Be = async (e, t, n) => C(e, (e) => Ve(e, t, n)), Ve = async (e, t, n) => {
+	if (n.executionId.length === 0) throw Error("Engine acknowledgement requires an execution identity");
+	let r = await e.query({
+		table: A,
+		predicate: h("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r[0] === void 0) throw Error("Cannot acknowledge an unknown admission submission");
+	let i = c.decodeUnknownSync(j)(r[0]);
+	if (i.failureId !== null) throw Error("Cannot acknowledge a permanently rejected admission submission");
+	if (i.preparedExecutionId !== null && i.preparedExecutionId !== n.executionId) throw Error("Engine acknowledgement contradicts the prepared execution identity");
+	if (i.executionId !== null && i.executionId !== n.executionId || i.runId !== null && n.runId !== null && i.runId !== n.runId) throw Error("Admission submission already belongs to a different execution or run");
+	let a = await Ae(e, i.workflowName, n.executionId), o = i.runId ?? n.runId;
+	if (a !== void 0 && o !== null && a.runId !== o) throw Error("Admission acknowledgement belongs to a different resident run");
+	let s = {
+		executionId: n.executionId,
+		runId: o ?? a?.runId ?? null
+	}, l = a?.completedAt ?? void 0;
+	if (await e.update("_voltro_workflow_admissions", i.ledgerId, {
+		...s,
+		...l === void 0 ? {} : { releasedAt: l }
+	}) === null) throw Error("Admission submission has no lease to acknowledge");
+	if (await e.update("_voltro_workflow_submissions", t, s) === null) throw Error("Admission submission disappeared during acknowledgement");
+	return {
+		...i,
+		...s
+	};
+}, He = async (e, t, n) => {
+	if (n.length === 0) throw Error("Prepared submission requires a non-empty execution identity");
+	let r = await M(e, t);
+	if (r === void 0) throw Error("Cannot prepare an unknown admission submission");
+	if (!r.receiptsBound || r.failureId !== null) throw Error("Cannot prepare an incomplete or terminal admission submission");
+	if (r.preparedExecutionId !== null) {
+		if (r.executionId !== null && r.executionId !== r.preparedExecutionId) throw Error("Submission acceptance contradicts its prepared identity");
+		return r;
+	}
+	if (r.executionId !== null) throw Error("Cannot prepare an accepted submission without its prepared identity");
+	if (r.dispatchAttempts !== 0) throw Error("Cannot choose an execution identity after an unbound dispatch");
+	if (r.retry.stoppedAt !== null) throw Error("Cannot prepare a stopped admission submission");
+	if (await e.update("_voltro_workflow_submissions", t, { preparedExecutionId: n }) === null) throw Error("Admission submission disappeared while preparing execution");
+	return {
+		...r,
+		preparedExecutionId: n
+	};
+}, Ue = async (e, t, n, i, a = !1) => {
+	if (a !== !1 && (!Number.isSafeInteger(a) || a < 1)) throw Error("Submission retry limit must be a positive integer or false");
+	let o = await M(e, t);
+	if (o === void 0) throw Error("Cannot record failure for an unknown submission");
+	if (o.executionId !== null || o.failureId !== null || o.retry.stoppedAt !== null) return o;
+	let s = o.retry.attempts + 1, c = {
+		attempts: s,
+		lastError: r(o.workflowName, n),
+		after: i + W(s),
+		stoppedAt: a !== !1 && s >= a ? i : null
+	};
+	if (await e.update("_voltro_workflow_submissions", t, { retry: c }) === null) throw Error("Admission submission disappeared while recording failure");
+	return {
+		...o,
+		retry: c
+	};
+}, We = async (e, t, n) => {
+	let r = await M(e, t);
+	if (r === void 0) throw Error("Cannot dispatch an unknown admission submission");
+	if (!r.receiptsBound || r.executionId !== null || r.failureId !== null || r.retry.stoppedAt !== null || r.retry.after > n) return null;
+	let i = r.dispatchAttempts + 1;
+	if (!Number.isSafeInteger(i)) throw Error("Submission dispatch counter exhausted");
+	if (await e.update("_voltro_workflow_submissions", t, { dispatchAttempts: i }) === null) throw Error("Admission submission disappeared before dispatch");
+	return {
+		...r,
+		dispatchAttempts: i
+	};
+}, Ge = async (e, t, n, r) => {
+	if (!Number.isSafeInteger(n) || n < 0) throw Error("Invalid submission dispatch attempt");
+	let i = await M(e, t);
+	if (i === void 0) throw Error("Cannot reject an unknown admission submission");
+	if (i.failureId !== null) {
+		let n = await D(e, i.failureId);
+		if (n === void 0 || n.sourceKind !== "submission" || n.sourceId !== t || n.workflowName !== i.workflowName || n.tenantId !== i.tenantId) throw Error("Rejected submission has no matching durable failure report");
+		return await O(e, n.id, r.now), n;
+	}
+	if (!i.receiptsBound || i.executionId !== null || i.dispatchAttempts !== n || n > 1) return;
+	let a = `wffr_${ie("sha256").update(JSON.stringify(["submission", t])).digest("hex").slice(0, 40)}`, o = await ve(e, {
+		id: a,
+		sourceKind: "submission",
+		sourceId: t,
+		workflowName: i.workflowName,
+		tenantId: i.tenantId,
+		handler: await be(e, t) ? null : r.handler,
+		callerContext: i.callerContext,
+		report: {
+			workflow: i.workflowName,
+			payload: i.payload,
+			errorTag: "WorkflowPayloadError",
+			errorMessage: r.errorMessage,
+			reason: "permanent input rejection before engine acceptance",
+			failedAt: r.now,
+			runId: null,
+			executionId: null
+		}
+	});
+	if (await e.update("_voltro_workflow_admissions", i.ledgerId, { releasedAt: new Date(r.now) }) === null) throw Error("Rejected admission submission has no lease");
+	if (await e.update("_voltro_workflow_submissions", t, { failureId: a }) === null) throw Error("Admission submission disappeared during rejection");
+	return await O(e, o.id, r.now), o;
+}, Ke = async (e, t) => {
+	if (t.failureId === null) throw Error("Workflow submission has no rejection marker");
+	let n = await D(e, t.failureId);
+	if (t.executionId !== null || t.dispatchAttempts > 1 || n === void 0 || n.sourceKind !== "submission" || n.sourceId !== t.id || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.report.executionId !== null || n.report.runId !== null) throw Error("Workflow start rejection has contradictory ownership or execution evidence");
+	return n.id;
+}, N = "_voltro_workflow_start_receipts", qe = c.Struct({
+	id: c.String,
+	workflowName: c.String,
+	tenantId: c.NullOr(c.String),
+	pendingId: c.String,
+	submissionId: c.NullOr(c.String),
+	terminal: c.NullOr(f)
+}).pipe(c.filter((e) => e.submissionId === null || e.terminal === null, { message: () => "A start receipt cannot be both submitted and terminal before admission" })), P = c.decodeUnknownSync(qe), F = async (e, t) => {
+	let n = await e.query({
+		table: N,
+		predicate: h("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : P(n[0]);
+}, Je = async (e, t) => {
+	let n = await F(e, t.receiptId);
+	if (n === void 0 || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Workflow start receipt is missing or belongs to another workflow or tenant");
+	if (n.terminal !== null) {
+		if (n.terminal.kind === "abandoned") {
+			let t = await D(e, n.terminal.failureId);
+			if (t === void 0 || t.workflowName !== n.workflowName || t.tenantId !== n.tenantId || t.sourceKind !== "intent" || t.report.executionId !== null || t.report.runId !== null) throw Error("Abandoned workflow receipt has no matching failure report");
+		}
+		return {
+			kind: "terminal",
+			outcome: n.terminal
+		};
+	}
+	if (n.submissionId === null) {
+		let t = await e.query({
+			table: I,
+			predicate: h("id", n.pendingId),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (t[0] === void 0) throw Error("Workflow receipt has no pending input or submission");
+		let r = H(t[0]);
+		if (r.workflowName !== n.workflowName || r.tenantId !== n.tenantId) throw Error("Workflow receipt pending input belongs to another workflow or tenant");
+		if (r.deadLetteredAt !== void 0) throw Error("Workflow receipt input is dead-lettered; reconciliation required");
+		return { kind: "pending" };
+	}
+	let r = await M(e, n.submissionId);
+	if (r === void 0 || !r.receiptsBound || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId || !r.intentIds.includes(n.pendingId)) throw Error("Workflow receipt has no matching admission submission");
+	if (r.failureId !== null) return {
+		kind: "rejected",
+		failureId: await Ke(e, r)
+	};
+	if (r.executionId === null) {
+		if (r.retry.stoppedAt !== null) throw Error("Workflow start acceptance is unresolved; reconciliation required");
+		return { kind: "pending" };
+	}
+	if (r.executionId.length === 0 || r.executionId !== r.preparedExecutionId) throw Error("Workflow start acknowledgement contradicts its prepared identity");
+	return {
+		kind: "accepted",
+		executionId: r.executionId
+	};
+}, Ye = async (e, t) => {
+	if (t.id.length === 0 || t.id === t.pendingId) throw Error("Workflow start receipt requires an identity distinct from its queue slot");
+	let n = P((await e.insertIgnoreWithOutcome(N, {
+		...t,
+		submissionId: null,
+		terminal: null
+	}, { conflictColumns: ["id"] })).row);
+	if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.pendingId !== t.pendingId) throw Error("Workflow start receipt identity belongs to a different start");
+	return n;
+}, Xe = async (e, t) => {
+	let n = await M(e, t);
+	if (n === void 0) throw Error("Cannot bind receipts to an unknown admission submission");
+	if (n.receiptsBound) return 0;
+	let r = 0;
+	for (let t of new Set(n.intentIds)) for (;;) {
+		let i = await e.query({
+			table: N,
+			predicate: p(h("pendingId", t), v("submissionId"), v("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (i.length === 0) break;
+		for (let t of i) {
+			let i = P(t);
+			if (i.workflowName !== n.workflowName || i.tenantId !== n.tenantId) throw Error("Pending receipt belongs to a different workflow or tenant");
+			if (await e.update("_voltro_workflow_start_receipts", i.id, { submissionId: n.id }) === null) throw Error("Workflow start receipt disappeared during queue transfer");
+			r++;
+		}
+	}
+	if (await e.update("_voltro_workflow_submissions", t, { receiptsBound: !0 }) === null) throw Error("Admission submission disappeared during receipt binding");
+	return r;
+}, Ze = async (e, t) => {
+	let n = c.decodeUnknownSync(f)(t.terminal);
+	for (;;) {
+		let r = await e.query({
+			table: N,
+			predicate: p(h("pendingId", t.pendingId), v("submissionId"), v("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r.length === 0) return;
+		for (let i of r) {
+			let r = P(i);
+			if (r.workflowName !== t.workflowName || r.tenantId !== t.tenantId) throw Error("Terminal receipt belongs to a different workflow or tenant");
+			if (await e.update("_voltro_workflow_start_receipts", r.id, { terminal: n }) === null) throw Error("Start receipt disappeared while recording its terminal outcome");
+		}
+	}
+}, I = "_voltro_workflow_pending", L = "_voltro_workflow_admissions", R = "_voltro_workflow_pauses", z = (e, t, n) => e.encodeWorkflowPayload === void 0 ? n : e.encodeWorkflowPayload(t, n), Qe = (e, t, n) => e.decodeWorkflowPayload === void 0 ? n : e.decodeWorkflowPayload(t, n), $e = 864e5, et = (e, t, n) => `wfp_${ie("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;
+}, H = (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,
+	queuedAppVersion: e.queuedAppVersion === null || e.queuedAppVersion === void 0 ? null : String(e.queuedAppVersion),
+	queuedSchemaFingerprint: e.queuedSchemaFingerprint === null || e.queuedSchemaFingerprint === void 0 ? null : String(e.queuedSchemaFingerprint),
+	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 : a(String(e.lastError)),
+	deadLetteredAt: e.deadLetteredAt === null || e.deadLetteredAt === void 0 ? void 0 : B(e.deadLetteredAt)
+}), U = (e, t, n, r) => ({
+	table: e,
+	predicate: t,
+	order: n,
+	take: r,
+	skip: void 0,
+	projection: void 0
+}), tt = async (e) => {
+	let t = await e.query(U(R, void 0, [], 1e3));
+	return new Set(t.map((e) => String(e.id)));
+}, nt = async (e, t, n, r) => {
+	await e.upsert(R, {
+		id: t,
+		pausedAt: /* @__PURE__ */ new Date(),
+		pausedBy: n,
+		reason: r
+	}, {
+		conflictColumns: ["id"],
+		update: [
+			"pausedAt",
+			"pausedBy",
+			"reason"
+		]
+	});
+}, rt = async (e, t) => e.delete(R, t), it = 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(U(I, p(h("workflowName", n.workflowName), h("controlKey", r.debounceKey), h("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(U(I, p(h("workflowName", n.workflowName), h("controlKey", r.batchKey), h("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 at(t, n.workflowName, r.singletonKey, i);
+		e === "unacknowledged" ? a.singletonUnacknowledged = !0 : e !== void 0 && (a.singletonHolder = e);
+	})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && o.push((async () => {
+		let e = n.concurrency.pool === void 0 ? [h("workflowName", n.workflowName)] : [], o = await t.query(U(L, p(...e, h("concurrencyKey", r.concurrencyKey), v("releasedAt"), te(v("executionId"), g("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(U(L, p(h("workflowName", n.workflowName), h("rateKey", c), h("outcome", "admitted"), g("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;
+}, at = async (e, t, n, r) => {
+	if ((await e.query(U("_voltro_workflow_admissions", p(h("workflowName", t), h("singletonKey", n), v("releasedAt"), v("executionId")), [], 1))).length > 0) return "unacknowledged";
+	let i = (await e.query(U(L, p(h("workflowName", t), h("singletonKey", n), v("releasedAt"), g("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)
+	};
+}, ot = async (e) => {
+	let { store: t, control: n, decision: r, now: i } = e, a = ct(r.mode, r.keys);
+	if (r.collapse === "hold") {
+		let o = e.existingId ?? et(n.workflowName, r.mode, a);
+		return await t.update(I, o, {
+			dueAt: new Date(r.dueAt),
+			updatedAt: new Date(i)
+		}), o;
+	}
+	if (r.collapse === "replace") {
+		let o = et(n.workflowName, r.mode, a);
+		return await Ze(t, {
+			pendingId: o,
+			workflowName: n.workflowName,
+			tenantId: e.tenantId,
+			terminal: {
+				kind: "superseded",
+				at: i
+			}
+		}), await t.upsert(I, {
+			id: o,
+			tenantId: e.tenantId,
+			workflowName: n.workflowName,
+			controlKey: a,
+			mode: r.mode,
+			payload: z(t, n.workflowName, e.payload),
+			callerContext: e.callerContext ?? null,
+			queuedAppVersion: e.queuedAppVersion ?? null,
+			queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? 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,
+			deadLetteredAt: null
+		}, {
+			conflictColumns: ["id"],
+			update: (a) => ({
+				payload: z(t, n.workflowName, e.payload),
+				callerContext: e.callerContext ?? null,
+				queuedAppVersion: e.queuedAppVersion ?? null,
+				queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
+				priority: r.keys.priority,
+				dueAt: new Date(r.dueAt),
+				deadlineAt: r.deadlineAt === void 0 ? a.deadlineAt ?? null : new Date(r.deadlineAt),
+				collapsed: V(a.collapsed, 1) + 1,
+				updatedAt: new Date(i),
+				attempts: 0,
+				lastError: null,
+				deadLetteredAt: null
+			})
+		}), o;
+	}
+	let o = await t.insert(I, {
+		id: `wfpi_${x()}`,
+		tenantId: e.tenantId,
+		workflowName: n.workflowName,
+		controlKey: a,
+		mode: r.mode,
+		payload: z(t, n.workflowName, e.payload),
+		callerContext: e.callerContext ?? null,
+		queuedAppVersion: e.queuedAppVersion ?? null,
+		queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? 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,
+		deadLetteredAt: null
+	});
+	return String(o.id);
+}, st = async (e) => {
+	let t = await e.store.insert(I, {
+		id: `wfpi_${x()}`,
+		tenantId: e.tenantId,
+		workflowName: e.workflowName,
+		controlKey: "",
+		mode: "delayed",
+		payload: z(e.store, e.workflowName, e.payload),
+		callerContext: e.callerContext ?? null,
+		queuedAppVersion: e.queuedAppVersion ?? null,
+		queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? 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,
+		deadLetteredAt: null
+	});
+	return {
+		intentId: String(t.id),
+		dueAt: e.at
+	};
+}, ct = (e, t) => {
+	switch (e) {
+		case "debounce": return t.debounceKey ?? "";
+		case "batch": return t.batchKey ?? "";
+		case "throttle": return t.throttleKey ?? "";
+		case "concurrency": return t.concurrencyKey ?? "";
+		case "singleton": return t.singletonKey ?? "";
+		default: return "";
+	}
+}, lt = async (e) => {
+	let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(L, {
+		id: `wfad_${x()}`,
+		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,
+		concurrencyReservation: t.concurrency === void 0 ? null : {
+			pool: t.concurrency.pool ?? null,
+			key: n.concurrencyKey ?? null,
+			limit: t.concurrency.limit
+		},
+		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);
+}, ut = async (e, t, n) => {
+	let r = !1;
+	for (;;) {
+		let i = await e.query(U(L, p(h("executionId", t), h("outcome", "admitted"), v("releasedAt")), [], 10));
+		if (i.length === 0) return r;
+		for (let t of i) if (await e.update("_voltro_workflow_admissions", String(t.id), { releasedAt: new Date(n) }) === null) throw Error("Admission lease disappeared during release");
+		r = !0;
+	}
+}, dt = async (e, t, n) => (await ft(e, t, n)).due, ft = async (e, t, n) => {
+	let r = (await e.query(U(I, v("deadLetteredAt"), [{
+		column: "priority",
+		direction: "desc"
+	}, {
+		column: "firstSeenAt",
+		direction: "asc"
+	}], n))).map(H), 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(ge),
+		nextDueAt: i
+	};
+}, pt = async (e, t) => (await e.query(U(I, void 0, [{
+	column: "firstSeenAt",
+	direction: "asc"
+}], t))).map(H), mt = async (e, t) => e.delete(I, t), ht = async (e, t, n, r) => C(e, (e) => gt(e, t, n, r)), gt = async (e, t, n, r) => {
+	let i = (await e.query(U(I, h("id", t), [], 1)))[0];
+	if (i === void 0) return !1;
+	let a = H(i);
+	if (await e.insert(L, {
+		id: `wfa_${x()}`,
+		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)
+	}), await Ze(e, {
+		pendingId: t,
+		workflowName: a.workflowName,
+		tenantId: a.tenantId,
+		terminal: {
+			kind: "cancelled",
+			at: r
+		}
+	}), !await e.delete("_voltro_workflow_pending", t)) throw Error("Pending intent disappeared during discard");
+	return !0;
+}, W = (e, t = Math.random) => {
+	let n = Math.min(1e3 * 2 ** Math.max(0, e - 1), 3e5);
+	return Math.round(n / 2 + t() * (n / 2));
+}, _t = async (e, t, n, i) => {
+	let a = t.attempts + 1;
+	await e.update(I, t.id, {
+		attempts: a,
+		lastError: r(t.workflowName, n.slice(0, 500)),
+		dueAt: new Date(i + W(a)),
+		updatedAt: new Date(i)
+	});
+}, vt = async (e, t, n, i) => await e.update(I, t.id, {
+	attempts: t.attempts + 1,
+	lastError: r(t.workflowName, n.slice(0, 500)),
+	deadLetteredAt: new Date(i),
+	updatedAt: new Date(i)
+}) !== null, yt = async (e, t, n) => {
+	let r = (await e.query(U(I, h("id", t), [], 1)))[0];
+	return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(I, t, {
+		attempts: 0,
+		lastError: null,
+		deadLetteredAt: null,
+		dueAt: new Date(n),
+		updatedAt: new Date(n)
+	}) !== null;
+}, bt = async (e) => {
+	let t = await it({
+		store: e.store,
+		control: e.control,
+		keys: e.keys,
+		now: e.now,
+		paused: e.paused
+	});
+	return fe({
+		control: e.control,
+		keys: e.keys,
+		state: t,
+		now: e.now,
+		reconsidering: e.reconsidering
+	});
+}, xt = async (e, t, n = 1e3) => {
+	let r = await e.query(U(L, 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(L, String(t.id)))), a.length;
+}, G = "_voltro_workflow_control_requests", K = c.String.pipe(c.minLength(1)), St = c.Struct({
+	kind: c.Literal("confirmed", "already-terminal"),
+	status: c.Literal("succeeded", "failed", "cancelled"),
+	completedAt: c.Number.pipe(c.finite()),
+	output: c.Unknown,
+	errorTag: c.NullOr(c.String),
+	errorMessage: c.NullOr(c.String)
+}), Ct = c.Struct({
+	kind: c.Literal("confirmed"),
+	status: c.Literal("running"),
+	enteredAt: c.Number.pipe(c.finite()),
+	generation: K
+}), wt = c.Union(St, Ct), Tt = c.Struct({
+	reason: c.NonEmptyString,
+	detail: c.optional(c.Record({
+		key: c.String,
+		value: c.Unknown
+	}))
+}), Et = c.Struct({ tenantId: c.NullOr(c.String) }), q = c.Struct({
+	requestId: c.String.pipe(c.pattern(/^[1-9]\d*$/)),
+	replyId: c.String.pipe(c.pattern(/^[1-9]\d*$/)),
+	restartToken: c.NullOr(c.NonEmptyString)
+}), Dt = c.Struct({
+	id: K,
+	runId: K,
+	workflowName: K,
+	executionId: K,
+	generation: K,
+	operation: c.Literal("cancel", "terminate", "resume"),
+	requestedAt: c.Number.pipe(c.finite()),
+	owner: c.NullOr(Et),
+	cause: c.optional(c.NullOr(Tt)),
+	dispatchAttempts: c.Number.pipe(c.int(), c.nonNegative()),
+	resumeJournal: c.NullOr(q),
+	result: c.NullOr(wt)
+}), Ot = c.Struct({
+	...Dt.fields,
+	requestedAt: c.DateFromSelf
+}), J = (e) => {
+	let t = c.decodeUnknownSync(Ot)(e);
+	return c.decodeUnknownSync(Dt)({
+		...t,
+		requestedAt: t.requestedAt.getTime()
+	});
+}, kt = async (e, t, n, r) => {
+	if (await e.update("_voltro_workflow_control_requests", t.id, { result: n }) === null) throw Error("Workflow control request disappeared during settlement");
+	await e.insert("_voltro_workflow_run_events", {
+		id: m("wfev", JSON.stringify(["control-settled", t.id])),
+		runId: t.runId,
+		eventType: "control-settled",
+		occurredAt: new Date(r),
+		stepName: null,
+		attempt: null,
+		payload: {
+			requestId: t.id,
+			operation: t.operation,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: t.generation,
+			cause: t.cause ?? null,
+			kind: n.kind,
+			status: n.status,
+			..."generation" in n ? { enteredGeneration: n.generation } : {}
+		}
+	});
+}, At = async (e, t) => {
+	let n = [], r;
+	for (;;) {
+		let i = await e({
+			table: G,
+			predicate: p(h("runId", t.runId), h("workflowName", t.workflowName), h("executionId", t.executionId), h("generation", t.generation), te(h("operation", "cancel"), h("operation", "terminate")), ...r === void 0 ? [] : [g("id", r)]),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of i) {
+			let t = J(e);
+			t.result === null && n.push(t);
+		}
+		if (i.length < 100) return n;
+		r = J(i[i.length - 1]).id;
+	}
+}, jt = async (e, t) => (await At(e, t)).length > 0, Mt = (e, t) => jt((t) => e.query({
+	...t,
+	lock: "update"
+}), t), Nt = {
+	source: "flow-control",
+	timeout: "finish"
+}, Pt = c.Struct({
+	reason: c.NonEmptyString,
+	detail: c.Struct({
+		source: c.Literal("flow-control"),
+		timeout: c.Literal("finish"),
+		onFailure: c.NullOr(c.NonEmptyString)
+	})
+}), Ft = (e) => {
+	let t = c.decodeUnknownOption(Pt)(e.cause);
+	return t._tag === "Some" ? t.value : void 0;
+}, Y = async (e, t) => {
+	let [n] = await e.query({
+		table: G,
+		predicate: h("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n !== void 0) return J(n);
+}, It = async (e, t) => {
+	let n;
+	for (;;) {
+		let r = await e.query({
+			table: G,
+			predicate: p(h("parentClosureId", t), ...n === void 0 ? [] : [g("id", n)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of r) {
+			let r = J(e);
+			if (r.cause?.reason !== "parent-close" || r.cause.detail?.closureId !== t || r.operation === "resume") throw Error("Parent closure control has contradictory ownership");
+			if (r.result === null) return !0;
+			n = r.id;
+		}
+		if (r.length < 100) return !1;
+	}
+}, Lt = async (e, t) => {
+	let n = c.decodeUnknownSync(Dt)({
+		...t,
+		owner: null,
+		cause: t.cause ?? null,
+		dispatchAttempts: 0,
+		resumeJournal: null,
+		result: null
+	}), r = await Y(e, n.id);
+	if (r !== void 0) {
+		if (r.runId !== n.runId || r.workflowName !== n.workflowName || r.executionId !== n.executionId || r.generation !== n.generation || r.operation !== n.operation) throw Error("Workflow control identity belongs to a different target or operation");
+		return r;
+	}
+	let i = new Date(n.requestedAt);
+	if (!Number.isFinite(i.getTime())) throw Error("Workflow control timestamp is outside the supported date range");
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a !== void 0 && (a.tag !== n.workflowName || a.executionId !== n.executionId)) throw Error("Workflow control target does not match its resident run");
+	let o = c.decodeUnknownOption(Et)(a?.runnerGeneration === n.generation ? a.subject : void 0), s = {
+		...n,
+		owner: o._tag === "Some" ? o.value : null
+	}, l = a !== void 0 && a.runnerGeneration === n.generation && (a.status === "succeeded" || a.status === "failed" || a.status === "cancelled") ? {
+		...s,
+		result: c.decodeUnknownSync(wt)({
+			kind: "already-terminal",
+			status: a.status,
+			completedAt: c.decodeUnknownSync(c.DateFromSelf)(a.completedAt).getTime(),
+			output: a.output,
+			errorTag: a.errorTag,
+			errorMessage: a.errorMessage
+		})
+	} : s, u = l.cause?.reason === "parent-close" ? c.decodeUnknownSync(c.NonEmptyString)(l.cause.detail?.closureId) : null;
+	return await e.insert(G, {
+		...l,
+		requestedAt: i,
+		parentClosureId: u
+	}), l.result !== null && await kt(e, l, l.result, n.requestedAt), l;
+}, Rt = async (e, t, n) => {
+	let r = await Y(e, t);
+	if (r === void 0) throw Error("Workflow control request is missing");
+	if (r.operation !== "resume") throw Error("Only resume controls can bind a suspension journal");
+	if (r.result !== null) return {
+		kind: "settled",
+		request: r
+	};
+	let [i] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i === void 0) return {
+		kind: "unknown",
+		request: r
+	};
+	if (i.tag !== r.workflowName || i.executionId !== r.executionId) throw Error("Workflow control target does not match its resident run");
+	if (i.runnerGeneration !== r.generation) return {
+		kind: "superseded",
+		request: r
+	};
+	if (i.status !== "suspended" || i.runnerEnteredAt !== null) return {
+		kind: "not-suspended",
+		request: r
+	};
+	let a = c.decodeUnknownSync(c.NullOr(c.Struct({
+		requestId: q.fields.requestId,
+		restartToken: q.fields.restartToken
+	})))(i.engineDelivery);
+	if (a === null) return {
+		kind: "unknown",
+		request: r
+	};
+	if (r.resumeJournal !== null) {
+		if (r.resumeJournal.requestId !== a.requestId || r.resumeJournal.restartToken !== a.restartToken) throw Error("Resume journal binding does not match its resident delivery");
+		return {
+			kind: "bound",
+			request: r
+		};
+	}
+	if (r.dispatchAttempts !== 0) return {
+		kind: "unknown",
+		request: r
+	};
+	let o = await n({
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		...a
+	});
+	if (o === void 0) return {
+		kind: "waiting-journal",
+		request: r
+	};
+	let s = c.decodeUnknownSync(q)(o);
+	if (s.requestId !== a.requestId || s.restartToken !== a.restartToken) throw Error("Observed suspension belongs to another engine delivery");
+	if (await e.update("_voltro_workflow_control_requests", r.id, { resumeJournal: s }) === null) throw Error("Workflow control request disappeared during suspension binding");
+	return {
+		kind: "bound",
+		request: {
+			...r,
+			resumeJournal: s
+		}
+	};
+}, zt = async (e, t) => {
+	let n = await Y(e, t);
+	if (n === void 0) throw Error("Workflow control request is missing");
+	if (n.result !== null) return {
+		kind: "settled",
+		request: n
+	};
+	let [r] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return {
+		kind: "unknown",
+		request: n
+	};
+	if (r.tag !== n.workflowName || r.executionId !== n.executionId) throw Error("Workflow control target does not match its resident run");
+	if (r.runnerGeneration !== n.generation) return {
+		kind: "superseded",
+		request: n
+	};
+	if (r.status === "succeeded" || r.status === "failed" || r.status === "cancelled") return {
+		kind: "already-terminal",
+		request: n,
+		run: r
+	};
+	if (r.status !== "running" && r.status !== "suspended") throw Error("Workflow control target has an invalid resident status");
+	let i = n.dispatchAttempts + 1;
+	if (!Number.isSafeInteger(i)) throw Error("Workflow control attempt counter exhausted");
+	if (await e.update("_voltro_workflow_control_requests", n.id, { dispatchAttempts: i }) === null) throw Error("Workflow control request disappeared before dispatch");
+	return {
+		kind: "dispatch",
+		request: {
+			...n,
+			dispatchAttempts: i
+		}
+	};
+}, Bt = async (e, n) => {
+	let a = n.owner, o;
+	for (;;) {
+		let s = await e.query({
+			table: G,
+			predicate: p(h("runId", a.runId), h("workflowName", a.workflowName), h("executionId", a.executionId), h("generation", a.generation), ...o === void 0 ? [] : [g("id", o)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let o of s) {
+			if (typeof o.id != "string") throw Error("Workflow control request has an invalid identity");
+			let s = await Y(e, o.id);
+			if (s === void 0) throw Error("Workflow control request disappeared during completion");
+			if (s.result !== null) continue;
+			let l = n.outcome;
+			await kt(e, s, c.decodeUnknownSync(wt)({
+				kind: l.status === "cancelled" && s.operation !== "resume" ? "confirmed" : "already-terminal",
+				status: l.status,
+				completedAt: n.now,
+				output: l.status === "succeeded" ? i(a.workflowName) ? t(l.output, `workflow '${a.workflowName}' result`) : l.output : null,
+				errorTag: l.status === "failed" ? l.errorTag : null,
+				errorMessage: l.status === "failed" ? r(a.workflowName, l.errorMessage) : null
+			}), n.now);
+		}
+		if (s.length < 100) return;
+		let l = s[s.length - 1];
+		if (typeof l.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		o = l.id;
+	}
+}, Vt = async (e, t, n, r) => {
+	let i = c.decodeUnknownSync(Ct)({
+		kind: "confirmed",
+		status: "running",
+		generation: n,
+		enteredAt: r
+	}), a;
+	for (;;) {
+		let n = await e.query({
+			table: G,
+			predicate: p(h("runId", t.runId), h("workflowName", t.workflowName), h("executionId", t.executionId), h("generation", t.generation), h("operation", "resume"), ...a === void 0 ? [] : [g("id", a)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let t of n) {
+			if (typeof t.id != "string") throw Error("Workflow control request has an invalid identity");
+			let n = await Y(e, t.id);
+			if (n === void 0) throw Error("Workflow control request disappeared during resume");
+			n.result === null && await kt(e, n, i, r);
+		}
+		if (n.length < 100) return;
+		let o = n[n.length - 1];
+		if (typeof o.id != "string") throw Error("Workflow control cursor has an invalid identity");
+		a = o.id;
+	}
+}, Ht = "voltro-workflow-restart", Ut = class extends o.Tag("voltro/CurrentWorkflowDelivery")() {}, Wt = (e) => ({
+	...e,
+	registerEntity: (t, n, r) => e.registerEntity(t, t.type.startsWith("Workflow/") ? n.pipe(s.map((e) => {
+		let t = e.run;
+		if (typeof t != "function") throw Error("Workflow entity is missing its run handler");
+		return {
+			...e,
+			run: (e) => {
+				let n = {
+					requestId: String(e.requestId),
+					restartToken: e.headers["voltro-workflow-restart"] ?? null
+				};
+				return s.suspend(() => {
+					let n = t(e);
+					return s.isEffect(n) ? n : s.die(/* @__PURE__ */ Error("Workflow run handler must return an Effect"));
+				}).pipe(s.provideService(Ut, n));
+			}
+		};
+	})) : n, r)
+}), Gt = c.parseJson(c.Struct({
+	_tag: c.Literal("Success"),
+	value: c.Struct({ _tag: c.Literal("Suspended") })
+})), Kt = c.parseJson(c.Record({
+	key: c.String,
+	value: c.String
+})), qt = (e) => s.gen(function* () {
+	if (!/^[1-9]\d*$/.test(e.requestId) || e.workflowName.length === 0 || e.executionId.length === 0) return yield* s.die(/* @__PURE__ */ Error("Suspension observation requires an exact engine delivery owner"));
+	let [t] = yield* (yield* S.SqlClient).withoutTransforms()`
+      SELECT m.entity_type, m.entity_id, m.tag, m.headers, r.id AS reply_id, r.payload
+      FROM cluster_messages m LEFT JOIN cluster_replies r
+        ON r.id = m.last_reply_id AND r.request_id = m.id AND r.kind = 0
+      WHERE m.id = ${e.requestId} AND m.kind = 0`;
+	if (t === void 0) return;
+	if (t.entity_type !== `Workflow/${e.workflowName}` || t.entity_id !== e.executionId || t.tag !== "run") return yield* s.die(/* @__PURE__ */ Error("Suspension observation belongs to another execution or procedure"));
+	if (((yield* s.sync(() => c.decodeUnknownSync(Kt)(t.headers)))["voltro-workflow-restart"] ?? null) !== e.restartToken || t.reply_id === null || c.decodeUnknownOption(Gt)(t.payload)._tag === "None") return;
+	let n = String(t.reply_id);
+	return /^[1-9]\d*$/.test(n) ? {
+		...e,
+		replyId: n
+	} : yield* s.die(/* @__PURE__ */ Error("Suspension reply has an invalid identity"));
+}).pipe(s.provideService(S.SafeIntegers, !0)), Jt = (e, t) => s.gen(function* () {
+	let { restart: n, suspension: r } = t, i = /* @__PURE__ */ new Map();
+	for (let t of e) {
+		if (!/^[1-9]\d*$/.test(t.requestId) || !/^[1-9]\d*$/.test(t.replyId)) return yield* s.die(/* @__PURE__ */ Error("Journal reset requires positive decimal request and reply identities"));
+		let e = i.get(t.requestId);
+		if (e !== void 0 && e !== t.replyId) return yield* s.die(/* @__PURE__ */ Error("Journal reset contains conflicting observations for one request"));
+		i.set(t.requestId, t.replyId);
+	}
+	if (n !== void 0 && (!i.has(n.requestId) || n.token.length === 0 || n.token === n.previousToken || n.workflowName.length === 0 || n.executionId.length === 0)) return yield* s.die(/* @__PURE__ */ Error("Journal restart requires a selected request, new token and execution owner"));
+	if (i.size === 0) return {
+		kind: "reset",
+		count: 0
+	};
+	let a = [...i].sort(([e], [t]) => e < t ? -1 : +(e > t)), o = (yield* S.SqlClient).withoutTransforms(), l = o("cluster_messages"), u = o("cluster_replies"), d = o.onDialectOrElse({
+		pg: () => o.literal("FALSE"),
+		orElse: () => o.literal("0")
+	});
+	return yield* s.gen(function* () {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t] of a) {
+			let r = yield* o.onDialectOrElse({
+				mssql: () => o`
+            SELECT last_reply_id FROM ${l} WITH (UPDLOCK, HOLDLOCK)
+            WHERE id = ${t} AND kind = 0`,
+				sqlite: () => o`
+            SELECT last_reply_id FROM ${l} WHERE id = ${t} AND kind = 0`,
+				orElse: () => o`
+            SELECT last_reply_id FROM ${l} WHERE id = ${t} AND kind = 0 FOR UPDATE`
+			});
+			if (r.length !== 1) return {
+				kind: "changed",
+				requestId: t
+			};
+			if (e.set(t, String(r[0]?.last_reply_id)), n !== void 0) {
+				let [e] = yield* o`
+            SELECT entity_type, entity_id, tag FROM ${l} WHERE id = ${t}`;
+				if (e?.entity_type !== `Workflow/${n.workflowName}` || e.entity_id !== n.executionId || e.tag !== (t === n.requestId ? "run" : "activity")) return yield* s.die(/* @__PURE__ */ Error("Journal restart selection belongs to another execution or procedure"));
+			}
+		}
+		let t;
+		if (r !== void 0) {
+			let [e] = yield* o`
+          SELECT entity_type, entity_id, tag, headers FROM ${l} WHERE id = ${r.requestId}`;
+			if (e?.entity_type !== `Workflow/${r.workflowName}` || e.entity_id !== r.executionId || e.tag !== "run" || r.workflowName.length === 0 || r.executionId.length === 0) return yield* s.die(/* @__PURE__ */ Error("Journal resume selection belongs to another execution or procedure"));
+			if (((yield* s.sync(() => c.decodeUnknownSync(c.parseJson(c.Record({
+				key: c.String,
+				value: c.String
+			})))(e.headers)))["voltro-workflow-restart"] ?? null) !== r.restartToken) return {
+				kind: "changed",
+				requestId: r.requestId
+			};
+		}
+		if (n !== void 0) {
+			let [e] = yield* o`
+          SELECT tag, entity_type, headers FROM ${l} WHERE id = ${n.requestId}`;
+			if (e?.tag !== "run" || !e.entity_type.startsWith("Workflow/")) return yield* s.die(/* @__PURE__ */ Error("Journal restart marker can only target a workflow run"));
+			if (t = yield* s.sync(() => c.decodeUnknownSync(c.parseJson(c.Record({
+				key: c.String,
+				value: c.String
+			})))(e.headers)), t["voltro-workflow-restart"] === n.token) return {
+				kind: "already-reset",
+				count: a.length
+			};
+			if ((t["voltro-workflow-restart"] ?? null) !== n.previousToken) return {
+				kind: "changed",
+				requestId: n.requestId
+			};
+		}
+		for (let [t, n] of a) {
+			if (e.get(t) !== n) return {
+				kind: "changed",
+				requestId: t
+			};
+			let i = yield* o`SELECT payload FROM ${u}
+          WHERE id = ${n} AND request_id = ${t} AND kind = 0`;
+			if (i.length !== 1 || r !== void 0 && c.decodeUnknownOption(Gt)(i[0]?.payload)._tag === "None") return {
+				kind: "changed",
+				requestId: t
+			};
+		}
+		n !== void 0 && (yield* o`UPDATE ${l} SET headers = ${JSON.stringify({
+			...t,
+			[Ht]: n.token
+		})}
+          WHERE id = ${n.requestId}`);
+		for (let [e] of a) yield* o`DELETE FROM ${u} WHERE request_id = ${e} AND kind = 0`, yield* o`DELETE FROM ${l} WHERE request_id = ${e} AND kind = 2`, yield* o`UPDATE ${l} SET processed = ${d}, last_reply_id = NULL,
+          last_read = NULL WHERE request_id = ${e}`;
+		return {
+			kind: "reset",
+			count: a.length
+		};
+	}).pipe(o.withTransaction, s.provideService(S.SafeIntegers, !0));
+}), Yt = (e, t) => Jt(e, t === void 0 ? {} : { restart: t }), Xt = (e) => Jt([e], { suspension: e }), X = ne("_voltro_workflow_restart_requests", {
+	id: _({ prefix: "wfrs" }),
+	runId: b(),
+	workflowName: b(),
+	executionId: b(),
+	generation: b(),
+	token: b(),
+	ledgerId: b(),
+	tenantId: b().nullable(),
+	delivery: y(),
+	replies: y(),
+	selection: y().nullable(),
+	eviction: y().nullable(),
+	requestedAt: re(),
+	dispatchAttempts: ee().default(0),
+	enteredGeneration: b().nullable()
+}).unique(["runId", "generation"]).unique(["runId", "token"]).nonReactive(), Z = c.NonEmptyString, Q = c.Struct({
+	requestId: Z,
+	restartToken: c.NullOr(Z)
+}), Zt = c.Struct({
+	requestId: Z,
+	replyId: Z
+}), Qt = u, $t = ne("_voltro_workflow_restart_withdrawals", {
+	id: _({ prefix: "wfrw" }),
+	runId: b(),
+	workflowName: b(),
+	tenantId: b().nullable(),
+	selection: y(),
+	withdrawnAt: re()
+}).nonReactive(), en = c.Struct({
+	id: c.NonEmptyString,
+	runId: c.NonEmptyString,
+	workflowName: c.NonEmptyString,
+	tenantId: c.NullOr(c.NonEmptyString),
+	selection: Qt,
+	withdrawnAt: c.DateFromSelf
+}), tn = async (e, t) => {
+	let n = c.decodeUnknownSync(d)(t), [r] = await e.query({
+		table: $t.tableName,
+		predicate: h("id", n.requestId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return;
+	let i = c.decodeUnknownSync(en)(r);
+	if (i.runId !== n.runId) throw Error("Restart identity belongs to a different command");
+	if (!Number.isFinite(i.withdrawnAt.getTime())) throw Error("Invalid restart withdrawal timestamp");
+	return i;
+}, nn = async (e, t) => {
+	if (await tn(e, t) !== void 0) throw Error("Restart request was permanently withdrawn");
+}, $ = c.Struct({
+	id: Z,
+	runId: Z,
+	workflowName: Z,
+	executionId: Z,
+	generation: Z,
+	token: Z,
+	ledgerId: Z,
+	tenantId: c.NullOr(Z),
+	delivery: Q,
+	replies: c.Array(Zt),
+	selection: Qt,
+	eviction: c.NullOr(c.Struct({
+		executionId: Z,
+		runId: c.String
+	})),
+	requestedAt: c.DateFromSelf,
+	dispatchAttempts: c.NonNegativeInt,
+	enteredGeneration: c.NullOr(Z)
+}), rn = (e, t) => e.kind === t.kind && (e.kind === "failed-steps" || t.kind === "from-step" && e.stepName === t.stepName), an = async (e, t) => {
+	let n = c.decodeUnknownSync(d)(t), [r] = await e.query({
+		table: X.tableName,
+		predicate: h("id", n.requestId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return;
+	let i = c.decodeUnknownSync($)(r);
+	if (i.runId !== n.runId) throw Error("Restart identity belongs to a different command");
+	return i;
+}, on = async (e, t) => {
+	let n = await tn(e, t);
+	if (n !== void 0) return c.decodeUnknownSync(l)({
+		...t,
+		kind: "withdrawn",
+		workflowName: n.workflowName,
+		selection: n.selection,
+		withdrawnAt: n.withdrawnAt.getTime()
+	});
+	let r = await an(e, t);
+	if (r === void 0) return c.decodeUnknownSync(l)({
+		...t,
+		kind: "not-found"
+	});
+	let i = {
+		requestId: r.id,
+		runId: r.runId,
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		originalGeneration: r.generation,
+		selection: r.selection,
+		requestedAt: r.requestedAt.getTime(),
+		dispatchAttempts: r.dispatchAttempts
+	};
+	return c.decodeUnknownSync(l)(r.enteredGeneration === null ? {
+		...i,
+		kind: "pending"
+	} : {
+		...i,
+		kind: "entered",
+		enteredGeneration: r.enteredGeneration
+	});
+}, sn = async (e, t) => {
+	for (let e of [
+		t.id,
+		t.runId,
+		t.workflowName
+	]) c.decodeUnknownSync(Z)(e);
+	if (t.id.length > 64) throw Error("Invalid restart request identity");
+	c.decodeUnknownSync(c.NullOr(Z))(t.tenantId);
+	let n = c.decodeUnknownSync(Qt)(t.selection);
+	await nn(e, {
+		requestId: t.id,
+		runId: t.runId
+	});
+	let r = await an(e, {
+		requestId: t.id,
+		runId: t.runId
+	});
+	if (r !== void 0) {
+		if (r.runId !== t.runId || r.workflowName !== t.workflowName || r.tenantId !== t.tenantId || !rn(r.selection, n)) throw Error("Restart identity belongs to a different command");
+		return r;
+	}
+}, cn = async (e, t) => {
+	let n = c.decodeUnknownSync(en)({
+		...t,
+		withdrawnAt: new Date(t.now)
+	});
+	if (c.decodeUnknownSync(d)({
+		requestId: n.id,
+		runId: n.runId
+	}), !Number.isFinite(n.withdrawnAt.getTime())) throw Error("Invalid restart withdrawal timestamp");
+	let r = await tn(e, {
+		requestId: n.id,
+		runId: n.runId
+	});
+	if (r !== void 0) {
+		if (r.workflowName !== n.workflowName || r.tenantId !== n.tenantId || !rn(r.selection, n.selection)) throw Error("Restart identity belongs to a different command");
+		return {
+			kind: "withdrawn",
+			withdrawal: r,
+			reused: !0
+		};
+	}
+	let i = await sn(e, n);
+	if (i !== void 0) return {
+		kind: "reserved",
+		request: i
+	};
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a === void 0 || a.tag !== n.workflowName) throw Error("Restart withdrawal requires its resident workflow");
+	if ((c.decodeUnknownSync(c.NullOr(c.Struct({ tenantId: c.NullOr(Z) })))(a.subject ?? null)?.tenantId ?? null) !== n.tenantId) throw Error("Restart withdrawal belongs to another resident tenant");
+	return await e.insert($t.tableName, n), {
+		kind: "withdrawn",
+		withdrawal: n,
+		reused: !1
+	};
+}, ln = async (e, t) => {
+	c.decodeUnknownSync(Z)(t.generation);
+	let n = await sn(e, t);
+	if (n !== void 0 && n.generation !== t.generation) throw Error("Restart identity belongs to a different command");
+	return n;
+}, un = async (e, t) => {
+	for (let e of [
+		t.id,
+		t.runId,
+		t.generation,
+		t.token
+	]) c.decodeUnknownSync(Z)(e);
+	if (t.id.length > 64 || !Number.isFinite(new Date(t.now).getTime())) throw Error("Invalid restart request identity or timestamp");
+	await nn(e, {
+		requestId: t.id,
+		runId: t.runId
+	});
+	let n = c.decodeUnknownSync(Q)(t.delivery), r = c.decodeUnknownSync(Qt)(t.selection);
+	if (n.restartToken === t.token) throw Error("Restart requires a new delivery token");
+	let i = c.decodeUnknownSync(c.Array(Zt))(t.replies), a = /* @__PURE__ */ new Map();
+	for (let e of i) {
+		if (!/^[1-9]\d*$/.test(e.requestId) || !/^[1-9]\d*$/.test(e.replyId) || a.has(e.requestId)) throw Error("Restart requires distinct, exact journal reply identities");
+		a.set(e.requestId, e.replyId);
+	}
+	if (!a.has(n.requestId)) throw Error("Restart selection must include its run reply");
+	let [o] = await e.query({
+		table: X.tableName,
+		predicate: h("id", t.id),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (o !== void 0) {
+		let e = c.decodeUnknownSync($)(o);
+		if (e.runId !== t.runId || e.generation !== t.generation || e.token !== t.token || e.workflowName !== t.control.workflowName || e.tenantId !== t.tenantId || e.delivery.requestId !== n.requestId || e.delivery.restartToken !== n.restartToken || !rn(e.selection, r) || e.replies.length !== a.size || e.replies.some((e) => a.get(e.requestId) !== e.replyId)) throw Error("Restart identity belongs to a different request");
+		return {
+			kind: "reserved",
+			request: e,
+			reused: !0
+		};
+	}
+	let [s] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", t.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s === void 0 || s.tag !== t.control.workflowName || s.runnerGeneration !== t.generation || s.status !== "failed" || s.discardedAt != null || typeof s.executionId != "string" || s.executionId.length === 0) throw Error("Restart requires its undiscarded failed resident generation");
+	if ((c.decodeUnknownSync(c.NullOr(c.Struct({ tenantId: c.NullOr(Z) })))(s.subject ?? null)?.tenantId ?? null) !== t.tenantId) throw Error("Restart belongs to another resident tenant");
+	let l = c.decodeUnknownSync(Q)(s.engineDelivery);
+	if (l.requestId !== n.requestId || l.restartToken !== n.restartToken) throw Error("Restart journal delivery does not belong to its resident generation");
+	let [u] = await e.query({
+		table: X.tableName,
+		predicate: p(h("runId", t.runId), te(h("generation", t.generation), h("token", t.token))),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id", "generation"]
+	});
+	if (u !== void 0) {
+		if (u.generation !== t.generation) throw Error("Restart delivery token was already used by this run");
+		return { kind: "already-requested" };
+	}
+	let d = Qe(e, t.control.workflowName, s.payload), f = ue(t.control, d), m = await bt({
+		store: e,
+		control: t.control,
+		keys: f,
+		paused: t.paused,
+		now: t.now,
+		reconsidering: !0
+	});
+	if (m.kind !== "admit") return {
+		kind: "not-admitted",
+		decision: m
+	};
+	let g = await lt({
+		store: e,
+		control: t.control,
+		keys: f,
+		outcome: "admitted",
+		mode: "restart",
+		reason: m.reason,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: null,
+		runId: null,
+		tenantId: t.tenantId,
+		now: t.now
+	});
+	if (g === void 0) throw Error("Restart has no admission reservation");
+	let _ = c.decodeUnknownSync($)({
+		id: t.id,
+		runId: t.runId,
+		workflowName: t.control.workflowName,
+		executionId: s.executionId,
+		generation: t.generation,
+		token: t.token,
+		ledgerId: g,
+		tenantId: t.tenantId,
+		delivery: n,
+		replies: i,
+		selection: r,
+		eviction: m.evict ?? null,
+		requestedAt: new Date(t.now),
+		dispatchAttempts: 0,
+		enteredGeneration: null
+	});
+	return await e.insert(X.tableName, _), {
+		kind: "reserved",
+		request: _,
+		reused: !1
+	};
+}, dn = async (e, t) => {
+	let [n] = await e.query({
+		table: X.tableName,
+		predicate: h("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n === void 0) throw Error("Restart dispatch has no resident request");
+	let r = c.decodeUnknownSync($)(n);
+	if (r.enteredGeneration !== null) throw Error("Restart request has already entered its resident generation");
+	let [i] = await e.query({
+		table: "_voltro_workflow_admissions",
+		predicate: h("id", r.ledgerId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i === void 0 || i.outcome !== "admitted" || i.releasedAt !== null || i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.executionId !== null || i.runId !== null) throw Error("Restart dispatch has no matching held resident reservation");
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: h("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a === void 0 || a.tag !== r.workflowName || a.executionId !== r.executionId || a.runnerGeneration !== r.generation || a.status !== "failed" || a.discardedAt != null) throw Error("Restart dispatch no longer owns its failed resident generation");
+	let o = c.decodeUnknownSync(Q)(a.engineDelivery);
+	if (o.requestId !== r.delivery.requestId || o.restartToken !== r.delivery.restartToken) throw Error("Restart dispatch no longer owns its journal delivery");
+	return {
+		request: r,
+		run: a
+	};
+}, fn = async (e, t) => {
+	let { request: n } = await dn(e, t), r = n.dispatchAttempts + 1;
+	if (!Number.isSafeInteger(r)) throw Error("Restart dispatch attempt counter exhausted");
+	if (await e.update(X.tableName, t, { dispatchAttempts: r }) === null) throw Error("Restart request disappeared before dispatch");
+	return {
+		...n,
+		dispatchAttempts: r
+	};
+}, pn = (e) => s.gen(function* () {
+	let { request: t } = yield* s.promise(() => e.transaction((t) => dn(t, e.requestId)));
+	if (!(yield* s.promise(() => e.acquireCapacity(t)))) return { kind: "waiting-capacity" };
+	let n = yield* s.promise(() => e.transaction((e) => fn(e, t.id)));
+	return yield* Yt(n.replies, {
+		requestId: n.delivery.requestId,
+		previousToken: n.delivery.restartToken,
+		token: n.token,
+		workflowName: n.workflowName,
+		executionId: n.executionId
+	});
+}), mn = async (e, t) => {
+	for (let e of [
+		t.runId,
+		t.workflowName,
+		t.executionId,
+		t.generation
+	]) c.decodeUnknownSync(Z)(e);
+	if (!Number.isFinite(new Date(t.now).getTime())) throw Error("Restart entry requires a valid timestamp");
+	let n = c.decodeUnknownSync(Q)(t.delivery);
+	if (n.restartToken === null) throw Error("Restart entry has no delivery token");
+	let [r] = await e.query({
+		table: X.tableName,
+		predicate: p(h("runId", t.runId), h("token", n.restartToken)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	});
+	if (r === void 0) throw Error("Restart delivery has no matching resident request");
+	let { request: i, run: a } = await dn(e, c.decodeUnknownSync(Z)(r.id));
+	if (i.runId !== t.runId || i.workflowName !== t.workflowName || i.executionId !== t.executionId || i.generation === t.generation || i.delivery.requestId !== n.requestId || i.token !== n.restartToken) throw Error("Restart entry does not match its reserved delivery");
+	if (i.dispatchAttempts === 0) throw Error("Restart entry has no committed dispatch attempt");
+	if (await e.update("_voltro_workflow_admissions", i.ledgerId, {
+		executionId: i.executionId,
+		runId: i.runId
+	}) === null) throw Error("Restart reservation disappeared during entry");
+	if (await e.update(X.tableName, i.id, { enteredGeneration: t.generation }) === null) throw Error("Restart request disappeared during entry");
+	let o = await e.update("_voltro_workflow_runs", i.runId, {
+		runnerGeneration: t.generation,
+		engineDelivery: n,
+		runnerEnteredAt: new Date(t.now),
+		reclaimCount: 0,
+		status: "running",
+		errorTag: null,
+		errorMessage: null,
+		output: null,
+		completedAt: null,
+		durationMs: null
+	});
+	if (o === null) throw Error("Restart run disappeared during entry");
+	return {
+		row: o,
+		previous: a,
+		event: await e.insert("_voltro_workflow_run_events", {
+			id: m("wfev", JSON.stringify(["restart", i.id])),
+			runId: i.runId,
+			eventType: "run-redriven",
+			occurredAt: new Date(t.now),
+			stepName: null,
+			attempt: null,
+			payload: {
+				requestId: i.id,
+				executionId: i.executionId,
+				previousGeneration: i.generation,
+				generation: t.generation
+			}
+		})
+	};
+}, hn = 6e5, gn = class extends o.Tag("@voltro/workflow/ClusterDiagnostics")() {}, _n = (e, t, n = Date.now()) => s.flatMap(e.messagesFor(t), (t) => {
+	if (t.length === 0) return s.succeed(void 0);
+	let r = [...new Set(t.filter((e) => !e.processed).map((e) => e.shardId))], i = r.length === 0 ? s.succeed([]) : e.shardLockHolders(r);
+	return s.map(i, (r) => ({
+		runner: e.ownAddress,
+		shardLockMode: e.shardLockMode,
+		messages: t.map((e) => ({
+			tag: e.tag,
+			shardId: e.shardId,
+			processed: e.processed,
+			lastRead: e.lastRead === null ? null : e.lastRead.toISOString(),
+			unreadForMs: !e.processed && e.lastRead !== null ? Math.max(0, n - e.lastRead.getTime()) : null
+		})),
+		shardLocks: r
+	}));
+});
+//#endregion
+export { ut as $, L as A, O as At, dt as B, he as Bt, Mt as C, M as Ct, Y as D, Re as Dt, At as E, Le as Et, vt as F, D as Ft, nt as G, C as Gt, bt as H, de as Ht, Qe as I, ve as It, ot as J, et as K, mt as L, ce as Lt, R as M, xe as Mt, I as N, Oe as Nt, Bt as O, Ae as Ot, pt as P, E as Pt, lt as Q, ht as R, ge as Rt, Ft as S, He as St, jt as T, Ge as Tt, _t as U, le as Ut, z as V, me as Vt, st as W, ue as Wt, it as X, xt as Y, tt as Z, Wt as _, Pe as _t, sn as a, Xe as at, zt as b, Fe as bt, un as c, Ye as ct, X as d, Ke as dt, rt as et, $t as f, je as ft, Ht as g, Ne as gt, Ut as h, We as ht, mn as i, N as it, $e as j, Se as jt, Vt as k, k as kt, pn as l, Je as lt, Xt as m, Ve as mt, gn as n, yt as nt, on as o, P as ot, qt as p, Be as pt, ft as q, _n as r, H as rt, ln as s, F as st, hn as t, W as tt, cn as u, Ze as ut, Nt as v, Me as vt, It as w, Ie as wt, Rt as x, ze as xt, Lt as y, Ue as yt, gt as z, fe as zt };