@voltro/workflow 0.69.1 → 0.71.0

package/dist/src-OEBqLBJl.js

@@ -0,0 +1,4842 @@
+import { E as e, F as t, I as n, L as r, M as i, N as a, P as o, T as s, w as c } from "./primitives-DsMsMr5S.js";
+import { d as l, f as u, h as d, i as f, m as p, p as m, s as h, u as g } from "./clusterDiagnostics-jpkNVay6.js";
+import { Activity as _, DurableClock as v, DurableDeferred as y, Workflow as ee, WorkflowEngine as b } from "@effect/workflow";
+import { Cause as x, Effect as S, Either as C, Exit as te, Fiber as ne, FiberRef as re, Layer as ie, Schema as w } from "effect";
+import { WorkflowQueuedCancellationResultSchema as ae, WorkflowStartTerminalOutcomeSchema as oe, publishServerError as se } from "@voltro/protocol";
+import { and as T, boolean as E, derivedRowId as D, eq as O, generateId as ce, gt as k, gte as le, id as A, inSet as ue, integer as j, isNotNull as de, isNull as M, json as N, lt as fe, or as pe, queryFor as me, reference as he, registerRetention as ge, retentionTtlMsFromEnv as _e, table as P, text as F, timestamp as I } from "@voltro/database";
+import { createHash as ve, randomUUID as L } from "node:crypto";
+import { WorkflowInstance as ye } from "@effect/workflow/WorkflowEngine";
+//#region src/inMemoryLayer.ts
+var be = b.layerMemory, xe = P("_voltro_workflow_runs", {
+	id: A({ prefix: "wfrun" }),
+	tag: F(),
+	executionId: F().unique(),
+	status: F().oneOf([
+		"running",
+		"succeeded",
+		"failed",
+		"cancelled",
+		"suspended"
+	]).default("running"),
+	payload: N(),
+	workflowVersion: F().nullable(),
+	workflowPatches: N().nullable(),
+	runnerEnteredAt: I().nullable(),
+	runnerGeneration: F().nullable(),
+	engineDelivery: N().nullable(),
+	reclaimCount: j().default(0),
+	output: N().nullable(),
+	subject: N().nullable(),
+	source: F().nullable(),
+	errorTag: F().nullable(),
+	errorMessage: F().nullable(),
+	cancelled: E().default(!1),
+	discardedAt: I().nullable(),
+	discardedBy: F().nullable(),
+	startedAt: I().default("now"),
+	completedAt: I().nullable(),
+	durationMs: j().nullable(),
+	traceId: F().nullable(),
+	parentExecutionId: F().nullable(),
+	parentGeneration: F().nullable(),
+	parentClosePolicy: F().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable()
+}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), Se = P("_voltro_workflow_run_steps", {
+	id: A({ prefix: "wfstep" }),
+	runId: he(() => xe, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	stepName: F(),
+	attempt: j().default(1),
+	status: F().oneOf([
+		"running",
+		"succeeded",
+		"failed"
+	]).default("running"),
+	input: N().nullable(),
+	retryPolicy: N().nullable(),
+	output: N().nullable(),
+	errorTag: F().nullable(),
+	errorMessage: F().nullable(),
+	errorCause: N().nullable(),
+	startedAt: I().default("now"),
+	completedAt: I().nullable(),
+	durationMs: j().nullable()
+}).index(["runId", "stepName"]).index(["startedAt"]), Ce = P("_voltro_workflow_run_events", {
+	id: A({ prefix: "wfev" }),
+	runId: he(() => xe, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	eventType: F(),
+	payload: N().nullable(),
+	occurredAt: I().default("now"),
+	stepName: F().nullable(),
+	attempt: j().nullable()
+}).index(["runId", "occurredAt"]).index(["eventType"]), we = P("_voltro_workflow_start_contexts", {
+	id: A({ prefix: "wfctx" }),
+	workflowName: F(),
+	executionId: F().unique(),
+	subject: N().nullable(),
+	traceId: F().nullable(),
+	source: F().nullable(),
+	parentExecutionId: F().nullable(),
+	parentGeneration: F().nullable(),
+	parentClosePolicy: F().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable(),
+	createdAt: I().default("now")
+}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), Te = P("_voltro_workflow_admission_locks", {
+	id: A({ prefix: "wfalk" }),
+	nonce: F()
+}).nonReactive(), Ee = P("_voltro_workflow_parent_closures", {
+	id: A({ prefix: "wfpc" }),
+	runId: F(),
+	workflowName: F(),
+	executionId: F(),
+	generation: F(),
+	parentStatus: F().oneOf([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	closedAt: I(),
+	afterChildId: F().nullable(),
+	scanHasOpenChildren: E().default(!1),
+	completedAt: I().nullable()
+}).index(["executionId"]).index(["completedAt", "id"]).nonReactive(), De = P("_voltro_workflow_control_requests", {
+	id: A({ prefix: "wfctl" }),
+	runId: F(),
+	workflowName: F(),
+	executionId: F(),
+	generation: F(),
+	operation: F().oneOf([
+		"cancel",
+		"terminate",
+		"resume"
+	]),
+	requestedAt: I(),
+	owner: N().nullable(),
+	cause: N().nullable(),
+	parentClosureId: F().nullable(),
+	resumeJournal: N().nullable(),
+	dispatchAttempts: j().default(0),
+	result: N().nullable()
+}).index(["runId"]).index(["parentClosureId", "id"]).nonReactive(), Oe = P("_voltro_workflow_failure_reports", {
+	id: A({ prefix: "wffr" }),
+	workflowName: F(),
+	tenantId: F().nullable(),
+	sourceId: F(),
+	sourceKind: F().oneOf([
+		"submission",
+		"intent",
+		"run"
+	]),
+	handler: F().nullable(),
+	callerContext: N().nullable(),
+	report: N(),
+	handoffReceiptId: F().nullable(),
+	handoffAttempt: j().default(0),
+	acceptedExecutionId: F().nullable()
+}).index(["sourceKind", "sourceId"]).nonReactive(), ke = P("_voltro_workflow_submissions", {
+	id: A({ prefix: "wfsub" }),
+	workflowName: F(),
+	tenantId: F().nullable(),
+	ledgerId: F(),
+	executionId: F().nullable(),
+	runId: F().nullable(),
+	receiptsBound: E().default(!1),
+	preparedExecutionId: F().nullable(),
+	dispatchAttempts: j().default(0),
+	failureId: F().nullable(),
+	retry: N(),
+	payload: N(),
+	callerContext: N().nullable(),
+	intentIds: N(),
+	eviction: N().nullable()
+}).nonReactive(), Ae = P("_voltro_workflow_start_receipts", {
+	id: A({ prefix: "wfrc" }),
+	workflowName: F(),
+	tenantId: F().nullable(),
+	pendingId: F().maxLength(64),
+	submissionId: F().maxLength(64).nullable(),
+	terminal: N().nullable()
+}).index(["pendingId"]).nonReactive(), je = P("_voltro_workflow_pending", {
+	id: A({ prefix: "wfp" }),
+	tenantId: F().nullable(),
+	workflowName: F(),
+	controlKey: F(),
+	mode: F().oneOf([
+		"debounce",
+		"batch",
+		"throttle",
+		"concurrency",
+		"paused",
+		"delayed"
+	]),
+	payload: N(),
+	callerContext: N().nullable(),
+	queuedAppVersion: F().nullable(),
+	queuedSchemaFingerprint: F().nullable(),
+	priority: j().default(0),
+	dueAt: I(),
+	deadlineAt: I().nullable(),
+	collapsed: j().default(1),
+	firstSeenAt: I().default("now"),
+	updatedAt: I().default("now"),
+	attempts: j().default(0),
+	lastError: F().nullable(),
+	deadLetteredAt: I().nullable()
+}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), Me = P("_voltro_workflow_admissions", {
+	id: A({ prefix: "wfadm" }),
+	tenantId: F().nullable(),
+	workflowName: F(),
+	outcome: F().oneOf([
+		"admitted",
+		"dropped",
+		"skipped",
+		"evicted",
+		"expired",
+		"discarded"
+	]),
+	mode: F().nullable(),
+	reason: F().nullable(),
+	collapsed: j().default(1),
+	waitedMs: j().nullable(),
+	executionId: F().nullable(),
+	runId: F().nullable(),
+	singletonKey: F().nullable(),
+	concurrencyKey: F().nullable(),
+	concurrencyReservation: N().nullable(),
+	rateKey: F().nullable(),
+	admittedAt: I().default("now"),
+	expiresAt: I().nullable(),
+	releasedAt: I().nullable()
+}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), Ne = P("_voltro_workflow_pauses", {
+	id: A({ prefix: "wfpause" }),
+	pausedAt: I().default("now"),
+	pausedBy: F().nullable(),
+	reason: F().nullable()
+}), Pe = "_voltro_workflow_admission_locks", Fe = "deployment", Ie = async (e, t) => (await e.insertIgnoreWithOutcome(Pe, {
+	id: Fe,
+	nonce: L()
+}, { conflictColumns: ["id"] }), e.transactional(async (e) => {
+	if ((await e.query({
+		table: "_voltro_workflow_admission_locks",
+		predicate: O("id", Fe),
+		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", Fe, { nonce: L() }) === null) throw Error("Admission coordinator row disappeared; refusing an unlocked decision");
+	return t(e);
+})), Le = 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;
+	}
+}, Re = (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 Le(e, t, n);
+	}
+}, ze = (e, t) => JSON.stringify([e ?? null, t]), R = (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 Le(n, "priority", e);
+	}
+	return {
+		...e.debounce === void 0 ? {} : { debounceKey: Re(n, "debounce.key", e.debounce.key, t) },
+		...e.singleton === void 0 ? {} : { singletonKey: Re(n, "singleton.key", e.singleton.key, t) },
+		...e.concurrency === void 0 ? {} : { concurrencyKey: ze(e.concurrency.pool, e.concurrency.key === void 0 ? "" : Re(n, "concurrency.key", e.concurrency.key, t)) },
+		...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: Re(n, "throttle.key", e.throttle.key, t) },
+		...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: Re(n, "rateLimit.key", e.rateLimit.key, t) },
+		...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey: Re(n, "batch.key", e.batch.key, t) },
+		priority: r
+	};
+}, Be = (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;
+}, Ve = (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 = Be(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,
+			...Ue(t, r)
+		} : {
+			kind: "admit",
+			reason: "debounce-elapsed",
+			keys: n,
+			...Ue(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,
+			...Ue(t, r)
+		} : a && i >= s ? {
+			kind: "admit",
+			reason: "batch-timeout",
+			keys: n,
+			...Ue(t, r)
+		} : {
+			kind: "defer",
+			mode: "batch",
+			dueAt: s,
+			collapse: a ? "hold" : "append",
+			keys: n
+		};
+	}
+	if (t.throttle !== void 0) {
+		let e = Be(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: He(t) ? "under-limits" : "no-controls",
+		keys: n,
+		...Ue(t, r)
+	};
+}, He = (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, Ue = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, We = (e, t, n) => {
+	let r = e.timeouts?.startMs;
+	return r !== void 0 && n - t.firstSeenAt >= r;
+}, Ge = (e, t, n) => {
+	let r = e.timeouts?.finishMs;
+	return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
+}, Ke = (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, qe = "_voltro_workflow_failure_reports", Je = w.Struct({
+	id: w.String,
+	workflowName: w.String,
+	tenantId: w.NullOr(w.String),
+	sourceId: w.String,
+	sourceKind: w.Literal("submission", "intent", "run"),
+	handler: w.NullOr(w.String),
+	callerContext: w.Unknown,
+	report: w.Struct({
+		workflow: w.String,
+		payload: w.Unknown,
+		errorTag: w.NullOr(w.String),
+		errorMessage: w.NullOr(w.String),
+		runId: w.NullOr(w.String),
+		executionId: w.NullOr(w.String),
+		reason: w.String,
+		failedAt: w.Number
+	})
+}), z = async (e, t) => {
+	let n = await e.query({
+		table: qe,
+		predicate: O("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : w.decodeUnknownSync(Je)(n[0]);
+}, Ye = 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 z(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 r = w.decodeUnknownSync(Je)(t);
+	if (r.report.workflow !== r.workflowName) throw Error("Workflow failure report does not describe its owning workflow");
+	return await e.insert(qe, {
+		...r,
+		handoffReceiptId: null,
+		handoffAttempt: 0,
+		acceptedExecutionId: null
+	}), r;
+}, Xe = async (e, t, n) => {
+	let r, i = t === "submissionId" ? O(t, n) : T(O(t, n), M("submissionId"), M("terminal"));
+	for (;;) {
+		let t = await e.query({
+			table: Tt,
+			predicate: r === void 0 ? i : T(i, k("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 = V(n), i = await e.query({
+				table: qe,
+				predicate: O("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;
+		}
+	}
+}, Ze = (e, t) => Xe(e, "submissionId", t), Qe = (e, t) => Xe(e, "pendingId", t), $e = async (e, t, n, r) => {
+	for await (let i of ft(e, t, n)) {
+		if (i.tenantId !== r) throw Error("Failure delivery belongs to a different resident tenant");
+		if (await Ze(e, i.id)) return !0;
+	}
+	return !1;
+}, et = w.Struct({
+	handoffReceiptId: w.NullOr(w.String),
+	handoffAttempt: w.NonNegativeInt,
+	acceptedExecutionId: w.NullOr(w.NonEmptyString)
+}), tt = (e, t) => `wfrc_${ve("sha256").update(JSON.stringify([
+	"failure",
+	e,
+	t
+])).digest("hex").slice(0, 40)}`, nt = async (e, t) => {
+	let n = await e.query({
+		table: qe,
+		predicate: O("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), r = w.decodeUnknownSync(et)(n[0]);
+	if (r.handoffReceiptId === null && (r.handoffAttempt !== 0 || r.acceptedExecutionId !== null)) throw Error("Failure report has contradictory unstarted handoff metadata");
+	return r;
+}, rt = 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 Ht({
+		store: e,
+		workflowName: t.handler,
+		payload: t.report,
+		callerContext: t.callerContext,
+		tenantId: t.tenantId,
+		at: r,
+		now: i
+	}), o = await kt(e, {
+		id: tt(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
+	};
+}, it = async (e, t, n) => {
+	if (!Number.isFinite(n)) throw Error("Failure handoff requires a finite timestamp");
+	let r = await z(e, t);
+	if (r === void 0) throw Error("Cannot hand off an unknown workflow failure");
+	let { handoffReceiptId: i, handoffAttempt: a, acceptedExecutionId: o } = await nt(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 = tt(t, a);
+	if (i !== null) {
+		if (i !== s) throw Error("Failure handoff receipt belongs to a different report");
+		let t = await Dt(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 rt(e, r, 0, n, n);
+}, at = class extends Error {
+	reason;
+	constructor(e) {
+		super(`Workflow failure delivery requires reconciliation: ${e}`), this.reason = e;
+	}
+}, ot = async (e, t, n) => {
+	let r = await it(e, t, n);
+	if (r.kind === "unconfigured") return r;
+	let i = await nt(e, t), a = await Dt(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 z(e, t);
+		if (r === void 0) throw Error("Failure report disappeared during retry");
+		let o = i.handoffAttempt + 1, s = Math.max(Zt(o, () => 1), a.terminal.kind === "dropped" ? a.terminal.retryAfterMs : 0);
+		return rt(e, r, o, Math.max(n, a.terminal.at + s), n);
+	}
+	if (a.submissionId === null) {
+		let t = (await e.query({
+			table: U,
+			predicate: O("id", a.pendingId),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0];
+		if (t === void 0) throw new at("arrival-missing");
+		if (t.workflowName !== a.workflowName || t.tenantId !== a.tenantId) throw new at("arrival-owner-mismatch");
+		if (t.deadLetteredAt !== null) throw new at("arrival-dead-lettered");
+		return r;
+	}
+	let o = await B(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 z(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 at("rejection-proof-invalid");
+		let a = await z(e, t);
+		if (a === void 0) throw Error("Failure report disappeared during rejected handler retry");
+		let s = i.handoffAttempt + 1;
+		return rt(e, a, s, Math.max(n, r.report.failedAt + Zt(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
+	};
+}, st = w.Struct({
+	runId: w.NonEmptyString,
+	workflowName: w.NonEmptyString,
+	executionId: w.NonEmptyString,
+	generation: w.NonEmptyString,
+	parentStatus: w.Literal("succeeded", "failed", "cancelled"),
+	closedAt: w.DateFromSelf
+}), ct = async (e, t, n) => {
+	let [r] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: O("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: O("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 = w.decodeUnknownSync(st)(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
+	};
+}, lt = "_voltro_workflow_submissions", ut = w.Struct({
+	id: w.String,
+	workflowName: w.String,
+	tenantId: w.NullOr(w.String),
+	ledgerId: w.String,
+	preparedExecutionId: w.NullOr(w.String),
+	executionId: w.NullOr(w.String),
+	runId: w.NullOr(w.String),
+	receiptsBound: w.Boolean,
+	dispatchAttempts: w.NonNegativeInt,
+	failureId: w.NullOr(w.String),
+	retry: w.Struct({
+		attempts: w.Int,
+		after: w.Number,
+		lastError: w.NullOr(w.String),
+		stoppedAt: w.NullOr(w.Number)
+	}),
+	payload: w.Unknown,
+	callerContext: w.Unknown,
+	intentIds: w.Array(w.String),
+	eviction: w.NullOr(w.Struct({
+		executionId: w.String,
+		runId: w.String
+	}))
+}), dt = w.decodeUnknownSync(ut);
+async function* ft(e, t, n) {
+	let r;
+	for (;;) {
+		let i = T(O("preparedExecutionId", t), k("dispatchAttempts", 0)), a = await e.query({
+			table: lt,
+			predicate: r === void 0 ? i : T(i, k("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 = dt(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 pt = async (e, t, n) => (await mt(e, t, n)).map((e) => dt(e)), mt = async (e, t, n) => {
+	if (!Number.isSafeInteger(t) || t < 1) throw Error("Submission recovery requires a positive page size");
+	return e.query({
+		table: lt,
+		predicate: n === void 0 ? T(O("receiptsBound", !0), M("executionId"), M("failureId")) : T(O("receiptsBound", !0), M("executionId"), M("failureId"), k("id", n)),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: t,
+		skip: void 0,
+		projection: void 0
+	});
+}, B = async (e, t) => {
+	let n = await e.query({
+		table: lt,
+		predicate: O("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : w.decodeUnknownSync(ut)(n[0]);
+}, ht = async (e, t) => Ie(e, (e) => gt(e, t)), gt = async (e, t) => {
+	if (t.id.length === 0) throw Error("Admission submission requires a stable non-empty identity");
+	let n = await e.query({
+		table: lt,
+		predicate: O("id", t.id),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n[0] !== void 0) {
+		let e = w.decodeUnknownSync(ut)(n[0]);
+		if (e.workflowName !== t.control.workflowName || e.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
+		return {
+			kind: "reserved",
+			submission: e,
+			reused: !0
+		};
+	}
+	let r = R(t.control, t.keyPayload), i = await tn({
+		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 Y({
+		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 _t(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
+	};
+}, _t = 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(lt, n), n;
+}, vt = async (e, t, n) => Ie(e, (e) => yt(e, t, n)), yt = async (e, t, n) => {
+	if (n.executionId.length === 0) throw Error("Engine acknowledgement requires an execution identity");
+	let r = await e.query({
+		table: lt,
+		predicate: O("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 = w.decodeUnknownSync(ut)(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 ct(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
+	}, c = a?.completedAt ?? void 0;
+	if (await e.update("_voltro_workflow_admissions", i.ledgerId, {
+		...s,
+		...c === void 0 ? {} : { releasedAt: c }
+	}) === 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
+	};
+}, bt = async (e, t, n) => {
+	if (n.length === 0) throw Error("Prepared submission requires a non-empty execution identity");
+	let r = await B(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
+	};
+}, xt = async (e, t, n, r, i = !1) => {
+	if (i !== !1 && (!Number.isSafeInteger(i) || i < 1)) throw Error("Submission retry limit must be a positive integer or false");
+	let a = await B(e, t);
+	if (a === void 0) throw Error("Cannot record failure for an unknown submission");
+	if (a.executionId !== null || a.failureId !== null || a.retry.stoppedAt !== null) return a;
+	let o = a.retry.attempts + 1, s = {
+		attempts: o,
+		lastError: n,
+		after: r + Zt(o),
+		stoppedAt: i !== !1 && o >= i ? r : null
+	};
+	if (await e.update("_voltro_workflow_submissions", t, { retry: s }) === null) throw Error("Admission submission disappeared while recording failure");
+	return {
+		...a,
+		retry: s
+	};
+}, St = async (e, t, n) => {
+	let r = await B(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
+	};
+}, Ct = async (e, t, n, r) => {
+	if (!Number.isSafeInteger(n) || n < 0) throw Error("Invalid submission dispatch attempt");
+	let i = await B(e, t);
+	if (i === void 0) throw Error("Cannot reject an unknown admission submission");
+	if (i.failureId !== null) {
+		let n = await z(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 it(e, n.id, r.now), n;
+	}
+	if (!i.receiptsBound || i.executionId !== null || i.dispatchAttempts !== n || n > 1) return;
+	let a = `wffr_${ve("sha256").update(JSON.stringify(["submission", t])).digest("hex").slice(0, 40)}`, o = await Ye(e, {
+		id: a,
+		sourceKind: "submission",
+		sourceId: t,
+		workflowName: i.workflowName,
+		tenantId: i.tenantId,
+		handler: await Ze(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 it(e, o.id, r.now), o;
+}, wt = async (e, t) => {
+	if (t.failureId === null) throw Error("Workflow submission has no rejection marker");
+	let n = await z(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;
+}, Tt = "_voltro_workflow_start_receipts", Et = w.Struct({
+	id: w.String,
+	workflowName: w.String,
+	tenantId: w.NullOr(w.String),
+	pendingId: w.String,
+	submissionId: w.NullOr(w.String),
+	terminal: w.NullOr(oe)
+}).pipe(w.filter((e) => e.submissionId === null || e.terminal === null, { message: () => "A start receipt cannot be both submitted and terminal before admission" })), V = w.decodeUnknownSync(Et), Dt = async (e, t) => {
+	let n = await e.query({
+		table: Tt,
+		predicate: O("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : V(n[0]);
+}, Ot = async (e, t) => {
+	let n = await Dt(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 z(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: U,
+			predicate: O("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 = q(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 B(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 wt(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
+	};
+}, kt = 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 = V((await e.insertIgnoreWithOutcome(Tt, {
+		...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;
+}, At = async (e, t) => {
+	let n = await B(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: Tt,
+			predicate: T(O("pendingId", t), M("submissionId"), M("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 = V(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;
+}, H = async (e, t) => {
+	let n = w.decodeUnknownSync(oe)(t.terminal);
+	for (;;) {
+		let r = await e.query({
+			table: Tt,
+			predicate: T(O("pendingId", t.pendingId), M("submissionId"), M("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 = V(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");
+		}
+	}
+}, U = "_voltro_workflow_pending", W = "_voltro_workflow_admissions", jt = "_voltro_workflow_pauses", Mt = (e, t, n) => e.encodeWorkflowPayload === void 0 ? n : e.encodeWorkflowPayload(t, n), G = (e, t, n) => e.decodeWorkflowPayload === void 0 ? n : e.decodeWorkflowPayload(t, n), Nt = 864e5, Pt = (e, t, n) => `wfp_${ve("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, K = (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;
+}, Ft = (e, t) => {
+	let n = typeof e == "number" ? e : Number(e);
+	return Number.isFinite(n) ? Math.trunc(n) : t;
+}, q = (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: Ft(e.priority, 0),
+	dueAt: K(e.dueAt),
+	deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : K(e.deadlineAt),
+	collapsed: Ft(e.collapsed, 1),
+	firstSeenAt: K(e.firstSeenAt),
+	attempts: Ft(e.attempts, 0),
+	lastError: e.lastError === null || e.lastError === void 0 ? null : String(e.lastError),
+	deadLetteredAt: e.deadLetteredAt === null || e.deadLetteredAt === void 0 ? void 0 : K(e.deadLetteredAt)
+}), J = (e, t, n, r) => ({
+	table: e,
+	predicate: t,
+	order: n,
+	take: r,
+	skip: void 0,
+	projection: void 0
+}), It = async (e) => {
+	let t = await e.query(J(jt, void 0, [], 1e3));
+	return new Set(t.map((e) => String(e.id)));
+}, Lt = async (e, t, n, r) => {
+	await e.upsert(jt, {
+		id: t,
+		pausedAt: /* @__PURE__ */ new Date(),
+		pausedBy: n,
+		reason: r
+	}, {
+		conflictColumns: ["id"],
+		update: [
+			"pausedAt",
+			"pausedBy",
+			"reason"
+		]
+	});
+}, Rt = async (e, t) => e.delete(jt, t), zt = 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(J(U, T(O("workflowName", n.workflowName), O("controlKey", r.debounceKey), O("mode", "debounce")), [], 1)))[0];
+		if (e === void 0) return;
+		let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : K(e.deadlineAt);
+		a.debouncePending = {
+			firstSeenAt: K(e.firstSeenAt),
+			collapsed: Ft(e.collapsed, 1),
+			...i === void 0 ? {} : { deadlineAt: i }
+		};
+	})()), n.batch !== void 0 && r.batchKey !== void 0 && o.push((async () => {
+		let e = await t.query(J(U, T(O("workflowName", n.workflowName), O("controlKey", r.batchKey), O("mode", "batch")), [{
+			column: "firstSeenAt",
+			direction: "asc"
+		}], n.batch.maxSize + 1));
+		e.length !== 0 && (a.batchPending = {
+			count: e.length,
+			firstSeenAt: K(e[0].firstSeenAt)
+		});
+	})()), n.singleton !== void 0 && r.singletonKey !== void 0 && o.push((async () => {
+		let e = await Bt(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 ? [O("workflowName", n.workflowName)] : [], o = await t.query(J(W, T(...e, O("concurrencyKey", r.concurrencyKey), M("releasedAt"), pe(M("executionId"), k("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(J(W, T(O("workflowName", n.workflowName), O("rateKey", c), O("outcome", "admitted"), k("admittedAt", new Date(i - s.periodMs))), [{
+			column: "admittedAt",
+			direction: "desc"
+		}], s.limit));
+		a.recentAdmissions = e.map((e) => K(e.admittedAt));
+	})()), await Promise.all(o), a;
+}, Bt = async (e, t, n, r) => {
+	if ((await e.query(J("_voltro_workflow_admissions", T(O("workflowName", t), O("singletonKey", n), M("releasedAt"), M("executionId")), [], 1))).length > 0) return "unacknowledged";
+	let i = (await e.query(J(W, T(O("workflowName", t), O("singletonKey", n), M("releasedAt"), k("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: K(i.admittedAt)
+	};
+}, Vt = async (e) => {
+	let { store: t, control: n, decision: r, now: i } = e, a = Ut(r.mode, r.keys);
+	if (r.collapse === "hold") {
+		let o = e.existingId ?? Pt(n.workflowName, r.mode, a);
+		return await t.update(U, o, {
+			dueAt: new Date(r.dueAt),
+			updatedAt: new Date(i)
+		}), o;
+	}
+	if (r.collapse === "replace") {
+		let o = Pt(n.workflowName, r.mode, a);
+		return await H(t, {
+			pendingId: o,
+			workflowName: n.workflowName,
+			tenantId: e.tenantId,
+			terminal: {
+				kind: "superseded",
+				at: i
+			}
+		}), await t.upsert(U, {
+			id: o,
+			tenantId: e.tenantId,
+			workflowName: n.workflowName,
+			controlKey: a,
+			mode: r.mode,
+			payload: Mt(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: Mt(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: Ft(a.collapsed, 1) + 1,
+				updatedAt: new Date(i),
+				attempts: 0,
+				lastError: null,
+				deadLetteredAt: null
+			})
+		}), o;
+	}
+	let o = await t.insert(U, {
+		id: `wfpi_${L()}`,
+		tenantId: e.tenantId,
+		workflowName: n.workflowName,
+		controlKey: a,
+		mode: r.mode,
+		payload: Mt(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);
+}, Ht = async (e) => {
+	let t = await e.store.insert(U, {
+		id: `wfpi_${L()}`,
+		tenantId: e.tenantId,
+		workflowName: e.workflowName,
+		controlKey: "",
+		mode: "delayed",
+		payload: Mt(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
+	};
+}, Ut = (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 "";
+	}
+}, Y = async (e) => {
+	let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(W, {
+		id: `wfad_${L()}`,
+		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);
+}, Wt = async (e, t, n) => {
+	let r = !1;
+	for (;;) {
+		let i = await e.query(J(W, T(O("executionId", t), O("outcome", "admitted"), M("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;
+	}
+}, Gt = async (e, t, n) => (await Kt(e, t, n)).due, Kt = async (e, t, n) => {
+	let r = (await e.query(J(U, M("deadLetteredAt"), [{
+		column: "priority",
+		direction: "desc"
+	}, {
+		column: "firstSeenAt",
+		direction: "asc"
+	}], n))).map(q), 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(Ke),
+		nextDueAt: i
+	};
+}, qt = async (e, t) => (await e.query(J(U, void 0, [{
+	column: "firstSeenAt",
+	direction: "asc"
+}], t))).map(q), Jt = async (e, t) => e.delete(U, t), Yt = async (e, t, n, r) => Ie(e, (e) => Xt(e, t, n, r)), Xt = async (e, t, n, r) => {
+	let i = (await e.query(J(U, O("id", t), [], 1)))[0];
+	if (i === void 0) return !1;
+	let a = q(i);
+	if (await e.insert(W, {
+		id: `wfa_${L()}`,
+		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 H(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;
+}, Zt = (e, t = Math.random) => {
+	let n = Math.min(1e3 * 2 ** Math.max(0, e - 1), 3e5);
+	return Math.round(n / 2 + t() * (n / 2));
+}, Qt = async (e, t, n, r) => {
+	let i = t.attempts + 1;
+	await e.update(U, t.id, {
+		attempts: i,
+		lastError: n.slice(0, 500),
+		dueAt: new Date(r + Zt(i)),
+		updatedAt: new Date(r)
+	});
+}, $t = async (e, t, n, r) => await e.update(U, t.id, {
+	attempts: t.attempts + 1,
+	lastError: n.slice(0, 500),
+	deadLetteredAt: new Date(r),
+	updatedAt: new Date(r)
+}) !== null, en = async (e, t, n) => {
+	let r = (await e.query(J(U, O("id", t), [], 1)))[0];
+	return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(U, t, {
+		attempts: 0,
+		lastError: null,
+		deadLetteredAt: null,
+		dueAt: new Date(n),
+		updatedAt: new Date(n)
+	}) !== null;
+}, tn = async (e) => {
+	let t = await zt({
+		store: e.store,
+		control: e.control,
+		keys: e.keys,
+		now: e.now,
+		paused: e.paused
+	});
+	return Ve({
+		control: e.control,
+		keys: e.keys,
+		state: t,
+		now: e.now,
+		reconsidering: e.reconsidering
+	});
+}, nn = async (e, t, n = 1e3) => {
+	let r = await e.query(J(W, void 0, [{
+		column: "admittedAt",
+		direction: "asc"
+	}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && K(e.admittedAt) < i);
+	return await Promise.all(a.map((t) => e.delete(W, String(t.id)))), a.length;
+}, rn = async (e, t) => {
+	if (!Number.isFinite(t.now) || !Number.isFinite(new Date(t.now).getTime())) throw Error("Queued cancellation requires a valid timestamp");
+	let n = await Dt(e, t.receiptId);
+	if (n === void 0 || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Queued cancellation receipt is missing or belongs to another workflow or tenant");
+	if (n.terminal !== null) return {
+		kind: "terminal",
+		outcome: n.terminal
+	};
+	if (n.submissionId !== null) {
+		let t = await B(e, n.submissionId);
+		if (t === void 0 || !t.receiptsBound || t.workflowName !== n.workflowName || t.tenantId !== n.tenantId || !t.intentIds.includes(n.pendingId)) throw Error("Queued cancellation receipt has no matching submission");
+		return {
+			kind: "submitted",
+			submissionId: t.id
+		};
+	}
+	let [r] = await e.query({
+		table: U,
+		predicate: O("id", n.pendingId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) throw Error("Queued cancellation has no pending input or submission");
+	let i = q(r);
+	if (i.workflowName !== n.workflowName || i.tenantId !== n.tenantId || i.deadLetteredAt !== void 0) throw Error("Queued cancellation input has contradictory ownership or is dead-lettered");
+	let a = {
+		kind: "cancelled",
+		at: t.now
+	};
+	if (await H(e, {
+		pendingId: n.pendingId,
+		workflowName: n.workflowName,
+		tenantId: n.tenantId,
+		terminal: a
+	}), !await e.delete("_voltro_workflow_pending", n.pendingId)) throw Error("Queued cancellation lost its pending input");
+	return {
+		kind: "terminal",
+		outcome: a
+	};
+}, an = "_voltro_workflow_parent_closures", X = w.NonEmptyString, on = w.Struct({
+	id: X,
+	runId: X,
+	workflowName: X,
+	executionId: X,
+	generation: X,
+	parentStatus: w.Literal("succeeded", "failed", "cancelled"),
+	closedAt: w.DateFromSelf,
+	afterChildId: w.NullOr(X),
+	scanHasOpenChildren: w.Boolean,
+	completedAt: w.NullOr(w.DateFromSelf)
+}), sn = w.Struct({
+	id: X,
+	tag: X,
+	executionId: X,
+	status: w.Literal("running", "suspended", "succeeded", "failed", "cancelled"),
+	runnerGeneration: w.optional(w.NullOr(X)),
+	parentGeneration: w.optional(w.NullOr(X)),
+	parentClosePolicy: w.NullOr(w.Literal("cancel", "terminate", "abandon"))
+}), cn = async (e, t, n) => {
+	if (t.parentClosePolicy !== "cancel" && t.parentClosePolicy !== "terminate") return !1;
+	if (typeof t.parentExecutionId != "string" || t.parentExecutionId.length === 0 || typeof t.parentGeneration != "string" || t.parentGeneration.length === 0) throw Error("Child entry requires its original parent execution and generation");
+	let r = n ?? (await e.query({
+		table: an,
+		predicate: T(O("executionId", t.parentExecutionId), O("generation", t.parentGeneration)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (r === void 0) return !1;
+	let i = w.decodeUnknownSync(on)(r);
+	if (i.executionId !== t.parentExecutionId || i.generation !== t.parentGeneration) return !1;
+	let a = w.decodeUnknownSync(sn)(t), o = D("wfctl", JSON.stringify([
+		"parent-close",
+		i.id,
+		a.id
+	])), s = await m(e, o);
+	if (s !== void 0) {
+		if (s.runId !== a.id || s.workflowName !== a.tag || s.executionId !== a.executionId || s.operation === "resume" || s.cause?.reason !== "parent-close" || s.cause.detail?.closureId !== i.id) throw Error("Parent closure receipt belongs to another child");
+	} else {
+		if (a.status !== "running" && a.status !== "suspended") return !1;
+		if (a.runnerGeneration === void 0 || a.runnerGeneration === null) throw Error("Child entry requires its own generation");
+		await h(e, {
+			id: o,
+			runId: a.id,
+			workflowName: a.tag,
+			executionId: a.executionId,
+			generation: a.runnerGeneration,
+			operation: t.parentClosePolicy,
+			requestedAt: i.closedAt.getTime(),
+			cause: {
+				reason: "parent-close",
+				detail: {
+					closureId: i.id,
+					parentRunId: i.runId,
+					parentExecutionId: i.executionId,
+					parentGeneration: i.generation,
+					parentStatus: i.parentStatus,
+					parentClosePolicy: t.parentClosePolicy
+				}
+			}
+		});
+	}
+	return !0;
+}, ln = async (e, t, n = Date.now()) => {
+	let [r] = await e.query({
+		table: an,
+		predicate: O("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) throw Error("Parent closure is missing");
+	let i = w.decodeUnknownSync(on)(r);
+	if (i.completedAt !== null) return {
+		scanned: 0,
+		controls: 0,
+		wrapped: !1
+	};
+	if (!Number.isFinite(n)) throw Error("Parent closure requires a finite completion timestamp");
+	let a = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: T(O("parentExecutionId", i.executionId), ...i.afterChildId === null ? [] : [k("id", i.afterChildId)]),
+		lock: "update",
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: 100,
+		skip: void 0,
+		projection: void 0
+	}), o = 0, s = i.scanHasOpenChildren, c = null;
+	for (let t of a) {
+		let r = w.decodeUnknownSync(sn)(t);
+		if (c = r.id, r.parentClosePolicy !== null && r.parentClosePolicy !== "abandon") {
+			if (r.parentGeneration === void 0 || r.parentGeneration === null) throw Error("Parent closure cannot attribute a child without its parent generation");
+			r.parentGeneration === i.generation && ((r.status === "running" || r.status === "suspended") && (s = !0), await cn(e, t, i) && (o++, r.status === "suspended" && typeof r.runnerGeneration == "string" && await hn(e, {
+				runId: r.id,
+				workflowName: r.tag,
+				executionId: r.executionId,
+				generation: r.runnerGeneration
+			}, n)));
+		}
+	}
+	let u = a.length < 100, d = u && !s && !await l(e, i.id);
+	if (await e.update(an, i.id, {
+		afterChildId: u ? null : c,
+		scanHasOpenChildren: !u && s,
+		completedAt: d ? new Date(n) : null
+	}) === null) throw Error("Parent closure disappeared before saving its cursor");
+	return {
+		scanned: a.length,
+		controls: o,
+		wrapped: u
+	};
+}, un = "_voltro_workflow_runs", dn = w.NullOr(w.Struct({
+	requestId: w.NonEmptyString,
+	restartToken: w.NullOr(w.NonEmptyString)
+})), fn = async (e, t, n, r) => {
+	if (typeof t.id != "string") throw Error("Child entry has no allocated run identity");
+	let i = {
+		runId: t.id,
+		workflowName: n.workflowName,
+		executionId: n.executionId,
+		generation: n.generation
+	}, a = await An(e, i), o = await cn(e, t);
+	if (!a && !o) return;
+	let s = await _n(e, {
+		owner: i,
+		now: n.now,
+		durationMs: 0,
+		outcome: { status: "cancelled" }
+	}, "running");
+	if (s.kind !== "committed") throw Error("Child entry cancellation lost its resident owner");
+	return {
+		kind: "cancelled",
+		row: s.row,
+		previous: r,
+		terminalEvent: s.terminalEvent
+	};
+}, pn = async (e, t) => {
+	if ([
+		t.workflowName,
+		t.executionId,
+		t.generation
+	].some((e) => e.length === 0) || typeof t.initialRow.id != "string" || t.initialRow.id.length === 0 || !Number.isFinite(t.now)) throw Error("Workflow entry requires allocated identities and a finite timestamp");
+	let n = (await e.query({
+		table: un,
+		predicate: O("executionId", t.executionId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0], r = w.decodeUnknownSync(dn)(t.delivery ?? null), i = (r) => fn(e, r, t, n);
+	if (n === void 0) {
+		if (r !== null && r.restartToken !== null) throw Error("Workflow restart delivery has no resident authorization");
+		if ((await e.query({
+			table: "_voltro_workflow_parent_closures",
+			predicate: O("executionId", t.executionId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["id"]
+		})).length !== 0) throw Error("Workflow execution is already terminal; restore its engine journal instead of re-entering the body");
+		let n = await e.insert(un, {
+			...t.initialRow,
+			tag: t.workflowName,
+			executionId: t.executionId,
+			runnerGeneration: t.generation,
+			engineDelivery: r,
+			status: "running",
+			runnerEnteredAt: new Date(t.now),
+			reclaimCount: 0
+		});
+		return await i(n) ?? {
+			kind: "created",
+			row: n,
+			previous: void 0
+		};
+	}
+	if (n.tag !== t.workflowName || typeof n.id != "string") throw Error("Workflow entry execution belongs to a different resident run");
+	let a = w.decodeUnknownSync(dn)(n.engineDelivery ?? null);
+	if (a?.requestId !== r?.requestId || a?.restartToken !== r?.restartToken) throw Error("Workflow delivery does not match its resident owner");
+	if (n.status === "cancelled") return {
+		kind: "already-cancelled",
+		row: n,
+		previous: n
+	};
+	if (n.status === "succeeded" || n.status === "failed") throw Error("Workflow execution is already terminal; restore its engine journal instead of re-entering the body");
+	if (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string") {
+		let r = {
+			runId: n.id,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: n.runnerGeneration
+		};
+		if (await g(e, r)) {
+			let i = await _n(e, {
+				owner: r,
+				now: t.now,
+				durationMs: 0,
+				outcome: { status: "cancelled" }
+			}, "suspended");
+			if (i.kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
+			return {
+				kind: "cancelled",
+				row: i.row,
+				previous: n,
+				terminalEvent: i.terminalEvent
+			};
+		}
+	}
+	if (n.runnerGeneration === t.generation) return {
+		kind: "replayed",
+		row: n,
+		previous: void 0
+	};
+	let o = n.runnerEnteredAt !== null && n.runnerEnteredAt !== void 0, s = n.reclaimCount;
+	if (typeof s != "number" || !Number.isSafeInteger(s) || s < 0) throw Error("Workflow entry has an invalid resident reclaim counter");
+	let c = o ? s + 1 : 0;
+	if (!Number.isSafeInteger(c)) throw Error("Workflow reclaim counter exhausted");
+	let l = await e.update(un, n.id, {
+		runnerGeneration: t.generation,
+		runnerEnteredAt: new Date(t.now),
+		reclaimCount: c,
+		status: "running",
+		errorTag: null,
+		errorMessage: null,
+		output: null,
+		completedAt: null
+	});
+	if (l === null) throw Error("Workflow run disappeared while entering its new generation");
+	let u = await i(l);
+	return u === void 0 ? (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string" && await d(e, {
+		runId: n.id,
+		workflowName: t.workflowName,
+		executionId: t.executionId,
+		generation: n.runnerGeneration
+	}, t.generation, t.now), {
+		kind: "entered",
+		row: l,
+		previous: n
+	}) : u;
+}, mn = async (e, t) => {
+	if ([
+		t.runId,
+		t.workflowName,
+		t.executionId,
+		t.generation
+	].some((e) => e.length === 0)) throw Error("Workflow runner ownership requires non-empty identities");
+	let n = (await e.query({
+		table: un,
+		predicate: O("id", t.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0 || n.tag !== t.workflowName || n.executionId !== t.executionId) throw Error("Workflow runner ownership does not match its resident run");
+	return n;
+}, hn = async (e, t, n) => {
+	let r = await mn(e, t);
+	if (r.runnerGeneration !== t.generation || r.status !== "suspended" || r.runnerEnteredAt !== null || !await g(e, t)) return !1;
+	if ((await _n(e, {
+		owner: t,
+		now: n,
+		durationMs: 0,
+		outcome: { status: "cancelled" }
+	}, "suspended")).kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
+	return !0;
+}, gn = async (e, t, n) => {
+	let r = await mn(e, t);
+	if (r.runnerGeneration !== t.generation) return { kind: "superseded" };
+	if (r.status !== "running") return { kind: "not-running" };
+	let i = await e.update(un, t.runId, {
+		status: "suspended",
+		runnerEnteredAt: null,
+		errorTag: n.errorTag,
+		errorMessage: n.errorMessage
+	});
+	if (i === null) throw Error("Workflow run disappeared during suspension recording");
+	return {
+		kind: "committed",
+		row: i
+	};
+}, _n = async (e, t, n) => {
+	let r = await mn(e, t.owner);
+	if (r.runnerGeneration !== t.owner.generation) return { kind: "superseded" };
+	if (r.status !== n) return { kind: "not-running" };
+	if (!Number.isFinite(t.now) || !Number.isFinite(t.durationMs) || t.durationMs < 0) throw Error("Workflow completion requires finite time and non-negative duration");
+	let i = t.outcome, a = null;
+	i.status === "failed" && (a = `wffr_${ve("sha256").update(JSON.stringify([
+		"run",
+		t.owner.workflowName,
+		t.owner.runId,
+		t.owner.generation
+	])).digest("hex").slice(0, 40)}`, await Ye(e, {
+		id: a,
+		sourceKind: "run",
+		sourceId: t.owner.runId,
+		workflowName: t.owner.workflowName,
+		tenantId: i.tenantId,
+		handler: await $e(e, t.owner.executionId, t.owner.workflowName, i.tenantId) ? null : i.handler,
+		callerContext: i.callerContext,
+		report: {
+			workflow: t.owner.workflowName,
+			payload: r.payload,
+			errorTag: i.errorTag,
+			errorMessage: i.errorMessage,
+			runId: t.owner.runId,
+			executionId: t.owner.executionId,
+			reason: "the run failed",
+			failedAt: t.now
+		}
+	}), await it(e, a, t.now));
+	let o = await e.update(un, t.owner.runId, {
+		status: i.status,
+		completedAt: new Date(t.now),
+		durationMs: t.durationMs,
+		cancelled: i.status === "cancelled",
+		runnerEnteredAt: null,
+		output: i.status === "succeeded" ? i.output : null,
+		errorTag: i.status === "failed" ? i.errorTag : null,
+		errorMessage: i.status === "failed" ? i.errorMessage : null
+	});
+	if (o === null) throw Error("Workflow run disappeared during terminal recording");
+	await e.insert("_voltro_workflow_parent_closures", {
+		id: D("wfpc", JSON.stringify([t.owner.runId, t.owner.generation])),
+		runId: t.owner.runId,
+		workflowName: t.owner.workflowName,
+		executionId: t.owner.executionId,
+		generation: t.owner.generation,
+		parentStatus: i.status,
+		closedAt: new Date(t.now),
+		afterChildId: null,
+		scanHasOpenChildren: !1,
+		completedAt: null
+	});
+	let s = await e.insert("_voltro_workflow_run_events", {
+		id: D("wfev", JSON.stringify([
+			"terminal",
+			t.owner.runId,
+			t.owner.generation
+		])),
+		runId: t.owner.runId,
+		eventType: `run-${i.status}`,
+		occurredAt: new Date(t.now),
+		stepName: null,
+		attempt: null,
+		payload: {
+			executionId: t.owner.executionId,
+			generation: t.owner.generation,
+			durationMs: t.durationMs,
+			...i.status === "failed" ? {
+				errorTag: i.errorTag,
+				errorMessage: i.errorMessage
+			} : {}
+		}
+	});
+	await p(e, t), await Wt(e, t.owner.executionId, t.now);
+	for await (let n of ft(e, t.owner.executionId, t.owner.workflowName)) {
+		let [r] = await e.query({
+			table: W,
+			predicate: O("id", n.ledgerId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r === void 0 || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId || r.outcome !== "admitted" || r.executionId !== null && r.executionId !== t.owner.executionId) throw Error("Workflow terminal reservation does not match its resident submission");
+		if (r.releasedAt === null && await e.update("_voltro_workflow_admissions", n.ledgerId, { releasedAt: new Date(t.now) }) === null) throw Error("Workflow terminal reservation disappeared during release");
+	}
+	return {
+		kind: "committed",
+		row: o,
+		failureId: a,
+		terminalEvent: s
+	};
+}, vn = (e, t) => _n(e, t, "running"), yn = P("_voltro_workflow_queued_cancellations", {
+	id: A({ prefix: "wfqc" }),
+	receiptId: F(),
+	workflowName: F(),
+	tenantId: F().nullable(),
+	requestedAt: I(),
+	cause: N().nullable(),
+	target: N(),
+	controlBinding: N().nullable()
+}).index(["receiptId"]).index(["workflowName", "id"]).nonReactive(), bn = w.NullOr(w.Struct({
+	reason: w.NonEmptyString,
+	detail: w.optional(w.Record({
+		key: w.String,
+		value: w.Unknown
+	}))
+})), xn = w.Struct({
+	id: w.NonEmptyString,
+	receiptId: w.NonEmptyString,
+	workflowName: w.NonEmptyString,
+	tenantId: w.NullOr(w.String),
+	requestedAt: w.DateFromSelf,
+	cause: bn,
+	controlBinding: w.NullOr(w.Struct({
+		controlId: w.NonEmptyString,
+		runId: w.NonEmptyString,
+		executionId: w.NonEmptyString,
+		generation: w.NonEmptyString
+	})),
+	target: w.Union(w.Struct({
+		kind: w.Literal("submission"),
+		submissionId: w.NonEmptyString
+	}), w.Struct({
+		kind: w.Literal("terminal"),
+		receipt: w.Unknown
+	}))
+}), Sn = (e) => {
+	let t = w.decodeUnknownSync(xn)(e);
+	if (!Number.isFinite(t.requestedAt.getTime())) throw Error("Queued cancellation request has an invalid timestamp");
+	if (t.target.kind === "submission") return {
+		...t,
+		target: t.target
+	};
+	let n = V(t.target.receipt);
+	if (t.controlBinding !== null) throw Error("A non-executed start cannot have a run control binding");
+	if (n.id !== t.receiptId || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.terminal === null) throw Error("Queued cancellation terminal evidence belongs to another start or is not terminal");
+	return {
+		...t,
+		target: {
+			kind: "terminal",
+			receipt: n
+		}
+	};
+}, Cn = async (e, t) => {
+	let [n] = await e.query({
+		table: yn.tableName,
+		predicate: O("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n === void 0 ? void 0 : Sn(n);
+}, wn = async (e, t) => {
+	let n = t.controlBinding;
+	if (n === null) throw Error("Queued cancellation has no control binding");
+	let r = await m(e, n.controlId);
+	if (r === void 0 || r.operation !== "cancel" || r.workflowName !== t.workflowName || r.runId !== n.runId || r.executionId !== n.executionId || r.generation !== n.generation || r.owner?.tenantId !== t.tenantId || r.result?.status === "running") throw Error("Queued cancellation lost its original resident control owner");
+	return r;
+}, Tn = async (e, t, n) => {
+	if (t.controlBinding === null) return;
+	let r = await wn(e, t);
+	if (r.result !== null) return;
+	let [i] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: O("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	i !== void 0 && await hn(e, {
+		runId: r.runId,
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		generation: r.generation
+	}, n);
+}, En = async (e, t) => {
+	let n = await Cn(e, t.requestId);
+	if (n === void 0) return {
+		kind: "unknown",
+		reason: "missing-request"
+	};
+	if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Queued cancellation request belongs to another workflow or tenant");
+	if (n.target.kind === "terminal") {
+		let e = n.target.receipt.terminal;
+		if (e === null) throw Error("Queued cancellation has no terminal evidence");
+		return {
+			kind: e.kind === "cancelled" ? "confirmed" : "already-terminal",
+			request: n,
+			outcome: e
+		};
+	}
+	if (n.controlBinding !== null) {
+		let t = await wn(e, n);
+		if (t.result !== null) return {
+			kind: t.result.kind,
+			request: n,
+			control: t
+		};
+		let [r] = await e.query({
+			table: "_voltro_workflow_runs",
+			predicate: O("id", t.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r === void 0) return {
+			kind: "unknown",
+			reason: "missing-run",
+			request: n,
+			control: t
+		};
+		if (r.tag !== t.workflowName || r.executionId !== t.executionId) throw Error("Queued cancellation control belongs to another resident execution");
+		return r.runnerGeneration !== t.generation || r.status !== "running" && r.status !== "suspended" ? {
+			kind: "unknown",
+			reason: "unconfirmed-generation",
+			request: n,
+			control: t
+		} : {
+			kind: "accepted",
+			request: n,
+			control: t,
+			run: r
+		};
+	}
+	let r = await B(e, n.target.submissionId);
+	if (r === void 0 || !r.receiptsBound || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId) throw Error("Queued cancellation has no matching submission evidence");
+	return r.failureId === null ? r.retry.stoppedAt !== null || r.runId !== null ? {
+		kind: "unknown",
+		reason: "unbound-submission",
+		request: n
+	} : {
+		kind: "accepted",
+		request: n
+	} : {
+		kind: "already-terminal",
+		request: n,
+		outcome: {
+			kind: "rejected",
+			failureId: await wt(e, r)
+		}
+	};
+}, Dn = (e, t) => {
+	let n = "request" in t ? t.request : void 0;
+	if (n !== void 0 && (n.id !== e.requestId || n.receiptId !== e.receiptId || n.workflowName !== e.workflowName)) throw Error("Queued control result belongs to another request or receipt");
+	let r = {
+		operation: "cancel",
+		workflowName: e.workflowName,
+		receiptId: e.receiptId,
+		requestId: n?.id ?? null,
+		kind: t.kind
+	}, i = w.decodeUnknownSync(ae);
+	if (t.kind === "unknown") return i({
+		...r,
+		observation: {
+			kind: "unavailable",
+			reason: t.reason
+		}
+	});
+	if ("outcome" in t && t.outcome !== void 0) return i({
+		...r,
+		observation: {
+			kind: "admission",
+			outcome: t.outcome
+		}
+	});
+	if ("control" in t && t.control !== void 0) {
+		let e = t.control, n = e.result;
+		return i({
+			...r,
+			observation: {
+				kind: "execution",
+				snapshot: {
+					id: e.runId,
+					workflowName: e.workflowName,
+					executionId: e.executionId,
+					status: n?.status ?? ("run" in t ? t.run?.status : void 0),
+					...n !== null && n.status === "succeeded" ? { output: n.output } : {},
+					...n !== null && n.status === "failed" && n.errorMessage !== null ? { error: {
+						tag: n.errorTag,
+						message: n.errorMessage
+					} } : {}
+				}
+			}
+		});
+	}
+	return i({
+		...r,
+		observation: { kind: "pending" }
+	});
+}, On = async (e, t) => {
+	let n = w.decodeUnknownSync(w.Struct({
+		id: w.NonEmptyString,
+		receiptId: w.NonEmptyString,
+		workflowName: w.NonEmptyString,
+		tenantId: w.NullOr(w.String),
+		requestedAt: w.DateFromSelf,
+		cause: bn
+	}))({
+		id: t.requestId,
+		receiptId: t.receiptId,
+		workflowName: t.workflowName,
+		tenantId: t.tenantId,
+		requestedAt: new Date(t.now),
+		cause: t.cause ?? null
+	});
+	if (!Number.isFinite(n.requestedAt.getTime())) throw Error("Queued cancellation request requires a valid timestamp");
+	let r = await Cn(e, n.id);
+	if (r !== void 0) {
+		if (r.receiptId !== n.receiptId || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId) throw Error("Queued cancellation identity belongs to a different start or owner");
+		return await Tn(e, r, t.now), r;
+	}
+	let i = await rn(e, t), a;
+	if (i.kind === "submitted") a = {
+		kind: "submission",
+		submissionId: i.submissionId
+	};
+	else {
+		let n = await Dt(e, t.receiptId);
+		if (n === void 0) throw Error("Cancelled start receipt disappeared during request acceptance");
+		a = {
+			kind: "terminal",
+			receipt: n
+		};
+	}
+	let o = Sn({
+		...n,
+		target: a,
+		controlBinding: null
+	});
+	if (await e.insert(yn.tableName, o), a.kind === "submission") {
+		let n = await B(e, a.submissionId);
+		if (n === void 0) throw Error("Queued cancellation submission disappeared during acceptance");
+		if (n.preparedExecutionId !== null && n.dispatchAttempts > 0) {
+			let [r] = await e.query({
+				table: "_voltro_workflow_runs",
+				predicate: O("executionId", n.preparedExecutionId),
+				lock: "update",
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (r !== void 0) {
+				let n = w.decodeUnknownSync(w.Struct({
+					id: w.NonEmptyString,
+					tag: w.NonEmptyString,
+					executionId: w.NonEmptyString,
+					runnerGeneration: w.NonEmptyString
+				}))(r), i = {
+					runId: n.id,
+					workflowName: n.tag,
+					executionId: n.executionId,
+					generation: n.runnerGeneration
+				}, a = await kn(e, o.id, i);
+				return await Tn(e, a.request, t.now), a.request;
+			}
+		}
+	}
+	return o;
+}, kn = async (e, t, n) => {
+	let r = await Cn(e, t);
+	if (r === void 0) throw Error("Queued cancellation request is missing");
+	if (r.target.kind === "terminal") return {
+		kind: "terminal",
+		request: r
+	};
+	if (r.controlBinding !== null) return {
+		kind: "bound",
+		request: r,
+		control: await wn(e, r)
+	};
+	let i = await B(e, r.target.submissionId);
+	if (i === void 0 || i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || !i.receiptsBound || i.failureId !== null || i.dispatchAttempts === 0 || i.preparedExecutionId !== n.executionId || i.executionId !== null && i.executionId !== n.executionId || i.runId !== null && i.runId !== n.runId || n.workflowName !== r.workflowName) throw Error("Queued cancellation has no dispatched submission for this resident execution");
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: O("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), o = w.decodeUnknownOption(w.Struct({ tenantId: w.NullOr(w.String) }))(a?.subject);
+	if (a === void 0 || a.tag !== n.workflowName || a.executionId !== n.executionId || a.runnerGeneration !== n.generation || o._tag === "None" || o.value.tenantId !== r.tenantId || ![
+		"running",
+		"suspended",
+		"succeeded",
+		"failed",
+		"cancelled"
+	].includes(String(a.status))) throw Error("Queued cancellation generation or tenant does not match the resident run");
+	let s = {
+		controlId: D("wfctl", JSON.stringify(["queued-cancel", r.id])),
+		runId: n.runId,
+		executionId: n.executionId,
+		generation: n.generation
+	}, c = await h(e, {
+		id: s.controlId,
+		...n,
+		operation: "cancel",
+		requestedAt: r.requestedAt.getTime(),
+		cause: r.cause
+	});
+	if (await e.update(yn.tableName, r.id, { controlBinding: s }) === null) throw Error("Queued cancellation request disappeared during run binding");
+	return {
+		kind: "bound",
+		request: {
+			...r,
+			controlBinding: s
+		},
+		control: c
+	};
+}, An = async (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for await (let r of ft(e, t.executionId, t.workflowName)) n.add(r.id);
+	if (n.size === 0) return !1;
+	let r, i = !1;
+	for (;;) {
+		let a = await e.query({
+			table: yn.tableName,
+			predicate: T(O("workflowName", t.workflowName), ...r === void 0 ? [] : [k("id", r)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let o of a) {
+			let a = Sn(o);
+			if (r = a.id, a.target.kind !== "submission" || !n.has(a.target.submissionId)) continue;
+			let s = await kn(e, a.id, t);
+			if (s.kind === "bound") {
+				if (s.control.runId !== t.runId || s.control.executionId !== t.executionId || s.control.workflowName !== t.workflowName) throw Error("Queued cancellation entry does not match its original resident execution");
+				s.control.result === null && (i = !0);
+			}
+		}
+		if (a.length < 100) return i;
+	}
+}, jn = w.Struct({
+	requestId: w.NonEmptyString,
+	receiptId: w.NonEmptyString,
+	workflowName: w.NonEmptyString,
+	tenantId: w.NullOr(w.String)
+}), Mn = async (e, t) => {
+	let n = w.decodeUnknownSync(jn)(t);
+	return await On(e, {
+		...n,
+		now: t.now,
+		...t.cause === void 0 ? {} : { cause: t.cause }
+	}), Nn(e, n);
+}, Nn = async (e, t) => {
+	let n = w.decodeUnknownSync(jn)(t);
+	return Dn(n, await En(e, n));
+}, Pn = async (e, t) => {
+	if (new Set(t.intentIds).size !== t.intentIds.length) throw Error("Admitted transfer requires distinct pending identities");
+	let n = await B(e, t.id);
+	if (n !== void 0) {
+		if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.ledgerId !== t.ledgerId || !n.receiptsBound) throw Error("Admitted transfer contradicts its existing submission");
+		return n;
+	}
+	for (let n of t.intentIds) {
+		let r = await e.query({
+			table: U,
+			predicate: O("id", n),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (r[0] === void 0) throw Error("Admitted transfer lost a selected input");
+		let i = q(r[0]);
+		if (i.workflowName !== t.workflowName || i.tenantId !== t.tenantId || i.deadLetteredAt !== void 0) throw Error("Admitted transfer selected a foreign or dead-lettered input");
+	}
+	let r = await _t(e, t);
+	await At(e, r.id);
+	for (let t of r.intentIds) if (!await e.delete("_voltro_workflow_pending", t)) throw Error("Admitted input disappeared during submission transfer");
+	return {
+		...r,
+		receiptsBound: !0
+	};
+}, Fn = async (e, t) => Ie(e, (e) => In(e, t)), In = async (e, t) => {
+	if (t.id.length === 0 || t.intentIds.length === 0 || new Set(t.intentIds).size !== t.intentIds.length) throw Error("Queue transfer requires a submission identity and distinct pending identities");
+	let n = await B(e, t.id);
+	if (n !== void 0) {
+		if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
+		if (!n.receiptsBound) throw Error("Submission exists without completed queue transfer");
+		return {
+			kind: "reserved",
+			submission: n,
+			reused: !0
+		};
+	}
+	let r = [];
+	for (let n of t.intentIds) {
+		let i = await e.query({
+			table: U,
+			predicate: O("id", n),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (i[0] === void 0) return { kind: "selection-unavailable" };
+		let a = q(i[0]);
+		if (a.workflowName !== t.workflowName || a.tenantId !== t.tenantId) throw Error("Selected pending start belongs to a different workflow or tenant");
+		if (a.deadLetteredAt !== void 0 || a.dueAt > t.now) return { kind: "selection-unavailable" };
+		r.push(a);
+	}
+	let i = t.prepare(r);
+	if (i.control.workflowName !== t.workflowName) throw Error("Prepared submission belongs to a different workflow");
+	let a = await gt(e, {
+		...i,
+		id: t.id,
+		tenantId: t.tenantId,
+		intentIds: t.intentIds,
+		now: t.now
+	});
+	if (a.kind !== "reserved") return a;
+	await At(e, t.id);
+	for (let t of r) if (!await e.delete("_voltro_workflow_pending", t.id)) throw Error("Pending start disappeared during queue transfer");
+	return {
+		...a,
+		submission: {
+			...a.submission,
+			receiptsBound: !0
+		}
+	};
+}, Ln = async (e) => {
+	let { store: t, control: n, now: r } = e, i = R(n, e.payload), a = await tn({
+		store: t,
+		control: n,
+		keys: i,
+		paused: e.paused,
+		now: r,
+		reconsidering: !1
+	});
+	if (a.kind === "drop") return await Y({
+		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 Y({
+		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 Vt({
+			store: t,
+			control: n,
+			decision: a,
+			payload: e.payload,
+			callerContext: e.callerContext,
+			tenantId: e.tenantId,
+			now: r,
+			...e.queuedAppVersion === void 0 ? {} : { queuedAppVersion: e.queuedAppVersion },
+			...e.queuedSchemaFingerprint === void 0 ? {} : { queuedSchemaFingerprint: e.queuedSchemaFingerprint }
+		}),
+		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 Rn(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 Y({
+			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
+		} }
+	};
+}, Rn = async (e, t, n, r) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: T(O("workflowName", t), O("controlKey", n), O("mode", "batch")),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0
+})).map((n) => ({
+	id: String(n.id),
+	payload: G(e, t, n.payload)
+})), zn = async (e, t, n, r) => {
+	await e.update("_voltro_workflow_admissions", t, {
+		executionId: n,
+		runId: r
+	});
+}, Bn = P("_voltro_workflow_watermarks", {
+	id: A({ prefix: "wfwm" }),
+	positionAt: I(),
+	updatedAt: I().default("now")
+}), Vn = (e) => {
+	let t = e instanceof Error ? e.message : String(e);
+	return t.length > 400 ? `${t.slice(0, 400)}…` : t;
+}, Hn = (e) => {
+	let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => C.right(e) : (t) => {
+		let n = w.decodeUnknownEither(e.payloadSchema)(t);
+		return C.isRight(n) ? C.right(n.right) : C.left(Vn(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 = w.decodeUnknownEither(o.schema)(l.payload);
+		if (C.isLeft(u)) {
+			r.push({
+				kind: "event-decode",
+				workflowName: e.workflowName,
+				event: o.event,
+				subject: l.id,
+				detail: Vn(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 (C.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: Vn(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
+	};
+}, Un = (e) => {
+	let t;
+	for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
+	return t;
+}, Wn = "_voltro_workflow_watermarks", Gn = "_voltro_workflow_events", Kn = "cancelOn", qn = 36e5, Jn = 500, Yn = (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;
+	}
+}, Xn = (e) => e instanceof Error ? e.message : String(e), Zn = async (e, t) => Yn((await e.query({
+	table: Wn,
+	predicate: O("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0]?.positionAt), Qn = async (e, t, n) => {
+	await e.upsert(Wn, {
+		id: t,
+		positionAt: n,
+		updatedAt: /* @__PURE__ */ new Date()
+	}, {
+		conflictColumns: ["id"],
+		update: (e) => {
+			let t = Yn(e.positionAt);
+			return t !== void 0 && t.getTime() >= n.getTime() ? {
+				positionAt: t,
+				updatedAt: /* @__PURE__ */ new Date()
+			} : {
+				positionAt: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+		}
+	});
+}, $n = async (e, t, n) => {
+	let r = async (r) => e.query({
+		table: "_voltro_workflow_runs",
+		predicate: T(O("tag", t), O("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 = Yn(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
+		}];
+	});
+}, er = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: O("workflowName", t),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = Yn(t.firstSeenAt);
+	return typeof t.id != "string" || n === void 0 ? [] : [{
+		intentId: t.id,
+		payload: t.payload,
+		firstSeenAt: n
+	}];
+}), tr = 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 Zn(e.store, Kn), c = s ?? new Date(r - a);
+	s === void 0 && (await Qn(e.store, Kn, c), s = c);
+	let l = await e.store.query({
+		table: Gn,
+		predicate: le("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 = Yn(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 $n(e.store, t.workflowName, _), i = await er(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
+		} catch (e) {
+			f.push({
+				subject: t.workflowName,
+				detail: Xn(e)
+			}), g = !0;
+			continue;
+		}
+		let a = Hn({
+			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({
+				...n,
+				workflowName: t.workflowName
+			}), 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: Xn(e)
+			}), g = !0;
+		}
+		for (let n of a.discards) try {
+			await e.discardIntent({
+				...n,
+				workflowName: t.workflowName
+			}), m += 1;
+		} catch (e) {
+			f.push({
+				subject: n.intentId,
+				detail: Xn(e)
+			}), g = !0;
+		}
+	}
+	let v = Un(u), y = s;
+	if (g) e.log?.warn("workflow.cancelOn: holding the watermark — evaluation or delivery remains incomplete", { failures: f.length });
+	else if (v !== void 0) try {
+		await Qn(e.store, Kn, v), y = v;
+	} catch (e) {
+		f.push({
+			subject: Kn,
+			detail: Xn(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
+	};
+}, nr = 18e5, rr = 200, ir = 20, ar = (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;
+	}
+}, or = (e) => e instanceof Error ? e.message : String(e), sr = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_run_events",
+	predicate: O("runId", t),
+	order: [{
+		column: "occurredAt",
+		direction: "desc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = ar(t.occurredAt);
+	return typeof t.eventType != "string" || n === void 0 ? [] : [{
+		eventType: t.eventType,
+		occurredAt: n,
+		payload: t.payload
+	}];
+}), cr = async (e, t) => {
+	let n = (await e.query({
+		table: "_voltro_workflow_run_steps",
+		predicate: O("runId", t),
+		order: [{
+			column: "startedAt",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0) return;
+	let r = ar(n.startedAt), i = ar(n.completedAt);
+	return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
+}, lr = (e, t) => {
+	for (let n of e) {
+		if (n.eventType === "timer-fired") return !1;
+		if (n.eventType !== "timer-set") continue;
+		let e = ar(n.payload?.scheduledWakeAt);
+		return e !== void 0 && e.getTime() > t;
+	}
+	return !1;
+}, ur = (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";
+}, dr = 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, f;
+	try {
+		if (!Number.isSafeInteger(i) || i < 1) throw Error("Staleness run page must be a positive integer");
+		let n = t.afterRun;
+		if (n !== void 0 && (!(n.startedAt instanceof Date) || !Number.isFinite(n.startedAt.getTime()) || typeof n.runId != "string" || n.runId.length === 0)) throw Error("Invalid staleness run cursor");
+		d = await e.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: T(ue("status", ["running", "suspended"]), fe("startedAt", o), ...n === void 0 ? [] : [pe(k("startedAt", n.startedAt), T(O("startedAt", n.startedAt), k("id", n.runId)))]),
+			order: [{
+				column: "startedAt",
+				direction: "asc"
+			}, {
+				column: "id",
+				direction: "asc"
+			}],
+			take: i,
+			skip: void 0,
+			projection: void 0
+		});
+		let r = n;
+		for (let e of d) {
+			let t = ar(e.startedAt);
+			if (t === void 0 || !Number.isFinite(t.getTime()) || typeof e.id != "string" || e.id.length === 0) throw Error("Staleness candidate has no valid pagination identity");
+			if (r !== void 0 && (t.getTime() < r.startedAt.getTime() || t.getTime() === r.startedAt.getTime() && e.id <= r.runId)) throw Error("Staleness candidate page did not advance");
+			r = {
+				startedAt: t,
+				runId: e.id
+			};
+		}
+		d.length >= i && (f = r);
+	} catch (e) {
+		return {
+			examined: 0,
+			stalled: [],
+			alreadyReported: 0,
+			waitingOnTimer: 0,
+			sawFullRunPage: !1,
+			failures: [{
+				subject: "_voltro_workflow_runs",
+				detail: or(e)
+			}]
+		};
+	}
+	for (let t of d) {
+		let i = t, o = ar(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 sr(e.store, i.id, a), f = await cr(e.store, i.id);
+		} catch (e) {
+			s.push({
+				subject: i.id,
+				detail: or(e)
+			});
+			continue;
+		}
+		if (lr(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: ur(i.status, d)
+		};
+		c.push(g);
+		let _ = {};
+		if (e.describeRun !== void 0) try {
+			_ = await e.describeRun(g) ?? {};
+		} catch (e) {
+			s.push({
+				subject: `${g.runId}:describeRun`,
+				detail: or(e)
+			});
+		}
+		if (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: or(e)
+			});
+		}
+		if (e.onStalled !== void 0) try {
+			await e.onStalled(g);
+		} catch (e) {
+			s.push({
+				subject: `${g.runId}:onStalled`,
+				detail: or(e)
+			});
+		}
+	}
+	return {
+		examined: d.length,
+		stalled: c,
+		alreadyReported: l,
+		waitingOnTimer: u,
+		sawFullRunPage: d.length >= i,
+		failures: s,
+		...f === void 0 ? {} : { nextRun: f }
+	};
+}, fr = async (e, t, n) => {
+	let r = await e.transaction((e) => B(e, t.id));
+	if (r === void 0 || r.workflowName !== t.workflowName || r.tenantId !== t.tenantId || r.ledgerId !== t.ledgerId) throw Error("Submission dispatch lost its resident owner");
+	if (!r.receiptsBound || r.failureId !== null) throw Error("Cannot dispatch an incomplete or rejected submission");
+	if (r.preparedExecutionId !== null) {
+		if (r.executionId !== null && r.executionId !== r.preparedExecutionId) throw Error("Submission acceptance contradicts its prepared identity");
+		return r.preparedExecutionId;
+	}
+	if (r.dispatchAttempts !== 0 || r.executionId !== null) throw Error("Submission has an unbound prior dispatch; reconciliation required");
+	let i = await e.resolveExecutionId(t.workflowName, n), a = await e.transaction((e) => bt(e, t.id, i));
+	if (a.preparedExecutionId === null) throw Error("Submission preparation returned no execution identity");
+	return a.preparedExecutionId;
+}, pr = /* @__PURE__ */ new WeakMap(), mr = async (e, t, n, r) => {
+	let i = pr.get(e), a = await mt(e.store, n, i?.afterId), o = 0, s = 0, c = 0, l = 0, u = i?.nextDueAt, d = (e) => {
+		u = Math.min(u ?? e, e);
+	};
+	for (let n of a) {
+		let i;
+		try {
+			i = dt(n);
+		} catch {
+			o++, c++, d(t + Zt(1)), e.log?.warn?.("workflow submission metadata is invalid", { submissionId: typeof n.id == "string" ? n.id : null });
+			continue;
+		}
+		o++;
+		let a = i.dispatchAttempts === 0 ? 0 : void 0;
+		try {
+			let n = i.preparedExecutionId, r = n === null || i.dispatchAttempts === 0 ? void 0 : await e.transaction(async (e) => {
+				let t = await ct(e, i.workflowName, n);
+				return t === void 0 ? void 0 : {
+					executionId: n,
+					runId: t.runId
+				};
+			});
+			if (r === void 0 && i.retry.stoppedAt !== null) {
+				o--;
+				continue;
+			}
+			if (r === void 0 && i.retry.after > t) {
+				o--, d(i.retry.after);
+				continue;
+			}
+			if (r === void 0 && e.acquireSubmissionCapacity !== void 0 && !await e.acquireSubmissionCapacity(i)) {
+				d(t + 1e3);
+				continue;
+			}
+			let c = r ?? await (async () => {
+				let n = e.controls.get(i.workflowName)?.batch === void 0 ? G(e.store, i.workflowName, i.payload) : { items: w.decodeUnknownSync(w.Struct({ items: w.Array(w.Unknown) }))(i.payload).items.map((t) => G(e.store, i.workflowName, t)) }, r = await fr(e, i, n), o = await e.transaction((e) => St(e, i.id, t));
+				if (o === null) return;
+				a = o.dispatchAttempts === 1 ? 1 : void 0;
+				let s = await e.startAdmitted(i.workflowName, n, i.callerContext, r);
+				if (a = void 0, s.executionId !== r) throw Error("Engine returned a different prepared execution identity");
+				return s;
+			})();
+			if (c === void 0) continue;
+			a = void 0, i.eviction !== null && (await e.cancelRun({
+				workflowName: i.workflowName,
+				...i.eviction,
+				reason: "cancelled to make room for a newer start (singleton mode 'cancel')",
+				detail: {
+					source: "flow-control",
+					mode: "singleton"
+				}
+			}), await Wt(e.store, i.eviction.executionId, t)), await e.transaction((e) => yt(e, i.id, {
+				executionId: c.executionId,
+				runId: c.runId ?? null
+			})), s++;
+		} catch (n) {
+			c++;
+			let o;
+			try {
+				if (a !== void 0 && e.isPermanentStartError?.(n) === !0) {
+					let r = a, o = await e.transaction((a) => Ct(a, i.id, r, {
+						handler: e.controls.get(i.workflowName)?.onFailure ?? null,
+						errorMessage: String(n),
+						now: t
+					}));
+					if (o !== void 0) {
+						l++, e.log?.warn?.("workflow submission rejected; failure report retained", {
+							workflow: i.workflowName,
+							submissionId: i.id,
+							failureId: o.id
+						});
+						continue;
+					}
+				}
+				o = await e.transaction((e) => xt(e, i.id, String(n), t, r));
+			} catch (r) {
+				d(t), e.log?.warn?.("workflow submission retry state could not be recorded", {
+					workflow: i.workflowName,
+					submissionId: i.id,
+					cause: String(n),
+					recordingCause: String(r)
+				});
+				continue;
+			}
+			o.retry.stoppedAt === null && d(o.retry.after), e.log?.warn?.("workflow submission remains unacknowledged", {
+				workflow: i.workflowName,
+				submissionId: i.id,
+				cause: String(n),
+				retryStoppedAt: o.retry.stoppedAt,
+				acceptance: "unknown"
+			});
+		}
+	}
+	let f = a.at(-1);
+	return a.length === n && f !== void 0 && typeof f.id == "string" ? (pr.set(e, {
+		afterId: f.id,
+		nextDueAt: u
+	}), {
+		scanned: o,
+		admitted: s,
+		failed: c,
+		rejected: l,
+		nextDueAt: t,
+		examined: !0
+	}) : (pr.delete(e), {
+		scanned: o,
+		admitted: s,
+		failed: c,
+		rejected: l,
+		nextDueAt: u,
+		examined: a.length > 0
+	});
+}, hr = /* @__PURE__ */ new WeakMap(), gr = async (e, t, n) => {
+	let r = hr.get(e), i = await e.store.query({
+		table: qe,
+		predicate: T(de("handler"), M("acceptedExecutionId"), ...r === void 0 ? [] : [k("id", r.afterId)]),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: n,
+		skip: void 0,
+		projection: void 0
+	}), a = 0, o = !1, s = r?.nextDueAt, c = () => {
+		let e = t + Zt(1, () => 1);
+		s = Math.min(s ?? e, e);
+	};
+	for (let n of i) try {
+		if (typeof n.id != "string" || n.id.length === 0) throw Error("Failure report has no identity");
+		let r = n.id;
+		(await e.transaction((e) => ot(e, r, t))).kind === "queued" && (o = !0, c());
+	} catch (t) {
+		a++, c(), e.log?.warn?.("workflow failure delivery could not be reconciled", {
+			failureId: typeof n.id == "string" ? n.id : null,
+			...t instanceof at ? { reason: t.reason } : {}
+		});
+	}
+	let l = i.at(-1);
+	return i.length === n && l !== void 0 && typeof l.id == "string" ? (hr.set(e, {
+		afterId: l.id,
+		nextDueAt: s
+	}), {
+		scanned: i.length,
+		failed: a,
+		hasPending: o,
+		nextDueAt: t,
+		examined: !0
+	}) : (hr.delete(e), {
+		scanned: i.length,
+		failed: a,
+		hasPending: o,
+		nextDueAt: s,
+		examined: i.length > 0
+	});
+}, _r = "_voltro_workflow_parent_closures", vr = /* @__PURE__ */ new WeakMap(), yr = async (e, t, n) => {
+	let r = vr.get(e), i = await e.store.query({
+		table: _r,
+		predicate: T(M("completedAt"), ...r === void 0 ? [] : [k("id", r.afterId)]),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: n,
+		skip: void 0,
+		projection: void 0
+	}), a = 0, o = r?.nextDueAt, s = () => {
+		o = Math.min(o ?? t + 1e3, t + 1e3);
+	};
+	for (let n of i) try {
+		if (typeof n.id != "string" || n.id.length === 0) throw Error("Parent closure has no identity");
+		let r = n.id;
+		await e.transaction(async (e) => {
+			await ln(e, r, t);
+			let [n] = await e.query({
+				table: _r,
+				predicate: O("id", r),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["completedAt"]
+			});
+			if (n === void 0) throw Error("Parent closure disappeared");
+			return n.completedAt instanceof Date && Number.isFinite(n.completedAt.getTime());
+		}) || s();
+	} catch {
+		a++, s(), e.log?.warn?.("workflow parent closure could not be reconciled", { closureId: typeof n.id == "string" ? n.id : null });
+	}
+	let c = i.at(-1);
+	return i.length === n && typeof c?.id == "string" ? (vr.set(e, {
+		afterId: c.id,
+		nextDueAt: o
+	}), {
+		scanned: i.length,
+		failed: a,
+		nextDueAt: t,
+		examined: !0
+	}) : (vr.delete(e), {
+		scanned: i.length,
+		failed: a,
+		nextDueAt: o,
+		examined: i.length > 0
+	});
+}, br = async (e, t) => {
+	if (t.from === t.to) throw Error("Queue transfer requires distinct source and target");
+	let n = await e.query({
+		table: U,
+		predicate: O("id", t.to),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), r = w.decodeUnknownSync(w.Struct({
+		workflowName: w.String,
+		tenantId: w.NullOr(w.String)
+	}))(n[0]);
+	if (r.workflowName !== t.workflowName || r.tenantId !== t.tenantId) throw Error("Receipt target belongs to a different workflow or tenant");
+	for (;;) {
+		let n = await e.query({
+			table: Tt,
+			predicate: T(O("pendingId", t.from), M("submissionId"), M("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (n.length === 0) return;
+		for (let r of n) {
+			let n = V(r);
+			if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Forwarded receipt belongs to a different workflow or tenant");
+			if (await e.update("_voltro_workflow_start_receipts", n.id, { pendingId: t.to }) === null) throw Error("Start receipt disappeared during queue transfer");
+		}
+	}
+}, xr = {
+	scanned: 0,
+	admitted: 0,
+	deferred: 0,
+	dropped: 0,
+	skipped: 0,
+	expired: 0,
+	evicted: 0,
+	failed: 0,
+	deadLettered: 0,
+	timedOut: 0,
+	examined: !1
+}, Sr = 200, Cr = class extends Error {
+	submissionId;
+	rejected;
+	constructor(e, t, n = !1) {
+		super(n ? `Submission ${e} rejected; failure report retained` : `Submission ${e} remains unacknowledged`, { cause: t }), this.submissionId = e, this.rejected = n;
+	}
+}, wr = async (e, t = {}) => {
+	let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, a, o, s, c, l, u;
+	try {
+		c = await mr(e, n(), i, e.deadLetterAfterAttempts ?? 50), l = await gr(e, n(), i), u = await yr(e, n(), i), a = await (e.readPauses?.() ?? It(e.store));
+		let r = t.skipPending === !0 && !l.hasPending ? {
+			due: [],
+			nextDueAt: void 0
+		} : await Kt(e.store, n(), i);
+		o = r.due, s = c.nextDueAt === void 0 ? r.nextDueAt : Math.min(r.nextDueAt ?? c.nextDueAt, c.nextDueAt), l.nextDueAt !== void 0 && (s = Math.min(s ?? l.nextDueAt, l.nextDueAt)), u.nextDueAt !== void 0 && (s = Math.min(s ?? u.nextDueAt, u.nextDueAt));
+	} catch (e) {
+		return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), {
+			...xr,
+			scanned: (c?.scanned ?? 0) + (l?.scanned ?? 0) + (u?.scanned ?? 0),
+			admitted: c?.admitted ?? 0,
+			deadLettered: c?.rejected ?? 0,
+			failed: (c?.failed ?? 0) + (l?.failed ?? 0) + (u?.failed ?? 0) + 1,
+			nextDueAt: n()
+		};
+	}
+	let d = {
+		scanned: o.length + c.scanned + l.scanned + u.scanned,
+		admitted: c.admitted,
+		deferred: 0,
+		dropped: 0,
+		skipped: 0,
+		expired: 0,
+		evicted: 0,
+		failed: c.failed + l.failed + u.failed,
+		deadLettered: c.rejected,
+		timedOut: 0
+	}, f = /* @__PURE__ */ new Map(), p = [];
+	for (let e of o) {
+		if (e.mode === "batch") {
+			let t = `${e.workflowName}\u0000${e.controlKey}`, n = f.get(t);
+			n === void 0 ? f.set(t, [e]) : n.push(e);
+			continue;
+		}
+		p.push(e);
+	}
+	let m = e.deadLetterAfterAttempts === void 0 ? 50 : e.deadLetterAfterAttempts, h = (t, n, r) => {
+		if (e.isPermanentStartError?.(n) === !0) return `pending ${r} was dead-lettered after a permanent start failure: ${String(n)}`;
+		if (m !== !1 && t.attempts + 1 >= m) return `pending ${r} was dead-lettered after ${t.attempts + 1} failed attempts: ${String(n)}`;
+	};
+	for (let t of p) try {
+		await Dr(e, t, a, d, n());
+	} catch (i) {
+		if (d.failed++, i instanceof Cr) {
+			i.rejected && d.deadLettered++, r?.warn?.(i.message, {
+				submissionId: i.submissionId,
+				cause: String(i.cause)
+			});
+			continue;
+		}
+		let a = h(t, i, "intent");
+		if (a !== void 0) {
+			let o = n(), s = String(i);
+			if (!await e.onAbandoned({
+				workflowName: t.workflowName,
+				payload: t.payload,
+				callerContext: t.callerContext,
+				reason: a,
+				runId: null,
+				executionId: null
+			}).then(() => !0, (e) => (r?.warn?.("workflow flow control: permanent failure could not signal onFailure", {
+				workflow: t.workflowName,
+				intent: t.id,
+				cause: String(e)
+			}), !1))) {
+				await Qt(e.store, t, s, o).catch(() => {});
+				continue;
+			}
+			if (await $t(e.store, t, s, o).catch(() => !1)) {
+				d.deadLettered++, r?.warn?.("workflow flow control: intent dead-lettered", {
+					workflow: t.workflowName,
+					intent: t.id,
+					cause: s
+				});
+				continue;
+			}
+		}
+		r?.warn?.("workflow flow control: an intent failed to drain", {
+			workflow: t.workflowName,
+			intent: t.id,
+			cause: String(i)
+		}), await Qt(e.store, t, String(i), n()).catch(() => {});
+	}
+	for (let t of f.values()) try {
+		await kr(e, t, a, d, n());
+	} catch (i) {
+		if (d.failed++, i instanceof Cr) {
+			i.rejected && d.deadLettered++, r?.warn?.(i.message, {
+				submissionId: i.submissionId,
+				cause: String(i.cause)
+			});
+			continue;
+		}
+		let a = t[0], o = a === void 0 ? void 0 : h(a, i, "batch");
+		if (a !== void 0 && o !== void 0) {
+			let s = n(), c = String(i);
+			if (!await e.onAbandoned({
+				workflowName: a.workflowName,
+				payload: { items: t.map((e) => e.payload) },
+				callerContext: a.callerContext,
+				reason: o,
+				runId: null,
+				executionId: null
+			}).then(() => !0, (e) => (r?.warn?.("workflow flow control: permanent batch failure could not signal onFailure", {
+				workflow: a.workflowName,
+				intents: t.map((e) => e.id),
+				size: t.length,
+				cause: String(e)
+			}), !1))) {
+				await Promise.all(t.map((t) => Qt(e.store, t, c, s).catch(() => {})));
+				continue;
+			}
+			if ((await Promise.all(t.map((t) => $t(e.store, t, c, s).catch(() => !1)))).every(Boolean)) {
+				d.deadLettered += t.length, r?.warn?.("workflow flow control: batch dead-lettered", {
+					workflow: a.workflowName,
+					intents: t.map((e) => e.id),
+					size: t.length,
+					cause: c
+				});
+				continue;
+			}
+		}
+		r?.warn?.("workflow flow control: a batch failed to drain", {
+			workflow: a?.workflowName,
+			size: t.length,
+			cause: String(i)
+		});
+		let s = n(), c = Math.random();
+		await e.transaction(async (e) => {
+			let n = [];
+			for (let r of t) {
+				let t = await e.query({
+					table: U,
+					predicate: O("id", r.id),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				if (t[0] === void 0) return;
+				let i = q(t[0]);
+				if (i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.mode !== r.mode || i.firstSeenAt !== r.firstSeenAt || i.dueAt !== r.dueAt || i.deadLetteredAt !== void 0) return;
+				n.push(i);
+			}
+			let r = new Date(s + Zt(Math.max(...n.map((e) => e.attempts + 1)), () => c));
+			for (let t of n) if (await e.update("_voltro_workflow_pending", t.id, {
+				attempts: t.attempts + 1,
+				lastError: String(i).slice(0, 500),
+				dueAt: r,
+				updatedAt: new Date(s)
+			}) === null) throw Error("Batch input disappeared while recording the shared retry deadline");
+		}).catch((e) => r?.warn?.("workflow flow control: batch retry could not be persisted", {
+			workflow: a?.workflowName,
+			intents: t.map((e) => e.id),
+			cause: String(e)
+		}));
+	}
+	let g = await Nr(e, n()).catch(() => ({ cancelled: 0 }));
+	return d.timedOut = g.cancelled, g.nextDeadlineAt !== void 0 && (s === void 0 || g.nextDeadlineAt < s) && (s = g.nextDeadlineAt), {
+		...d,
+		examined: t.skipPending !== !0 || c.examined || l.examined || u.examined,
+		...s === void 0 ? {} : { nextDueAt: s }
+	};
+}, Tr = async (e, t, n) => {
+	let r = t.map((e) => ({
+		intent: e,
+		failureId: `wff_${L()}`
+	}));
+	return e.transaction(async (e) => {
+		let t = 0;
+		for (let { intent: i, failureId: a } of r) {
+			let r = (await e.query({
+				table: U,
+				predicate: O("id", i.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			}))[0];
+			if (r === void 0) continue;
+			let o = q(r);
+			if (o.workflowName !== i.workflowName || o.tenantId !== i.tenantId) throw Error("Abandoned queue selection belongs to another workflow or tenant");
+			if (o.dueAt > n || o.deadLetteredAt !== void 0) continue;
+			let s = `workflow '${o.workflowName}' no longer has its queued declaration`;
+			if (await Ye(e, {
+				id: a,
+				sourceKind: "intent",
+				sourceId: o.id,
+				workflowName: o.workflowName,
+				tenantId: o.tenantId,
+				handler: null,
+				callerContext: o.callerContext,
+				report: {
+					workflow: o.workflowName,
+					payload: o.payload,
+					reason: s,
+					failedAt: n,
+					errorTag: null,
+					errorMessage: null,
+					runId: null,
+					executionId: null
+				}
+			}), await H(e, {
+				pendingId: o.id,
+				workflowName: o.workflowName,
+				tenantId: o.tenantId,
+				terminal: {
+					kind: "abandoned",
+					at: n,
+					failureId: a
+				}
+			}), !await e.delete("_voltro_workflow_pending", o.id)) throw Error("Abandoned queue row disappeared before deletion");
+			t++;
+		}
+		return t;
+	});
+}, Er = async (e, t, n, r, i) => {
+	let a = `wff_${L()}`;
+	return e.transaction(async (e) => {
+		let o = [];
+		for (let i of t) {
+			let t = await e.query({
+				table: U,
+				predicate: O("id", i.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			});
+			if (t[0] === void 0) return 0;
+			let a = q(t[0]);
+			if (a.workflowName !== n.workflowName || a.tenantId !== i.tenantId) throw Error("Expired queue selection belongs to another workflow or tenant");
+			if (a.mode !== i.mode || a.dueAt > r || a.deadLetteredAt !== void 0) return 0;
+			o.push(a);
+		}
+		o.sort((e, t) => e.firstSeenAt - t.firstSeenAt || e.id.localeCompare(t.id));
+		let s = o[0];
+		if (s === void 0 || !We(n, s, r)) return 0;
+		let c = await Promise.all(o.map((t) => Qe(e, t.id)));
+		if (c.some(Boolean) && !c.every(Boolean)) throw Error("Expired batch mixes failure delivery and ordinary callers; reconciliation required");
+		let l = `timeouts.start (${n.timeouts?.startMs}ms) elapsed while ${o.length} queued input(s) waited`;
+		await Ye(e, {
+			id: a,
+			sourceKind: "intent",
+			sourceId: s.id,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId,
+			handler: c.every(Boolean) ? null : n.onFailure ?? null,
+			callerContext: s.callerContext,
+			report: {
+				workflow: s.workflowName,
+				payload: i ? { items: o.map((e) => e.payload) } : s.payload,
+				reason: l,
+				failedAt: r,
+				errorTag: null,
+				errorMessage: null,
+				runId: null,
+				executionId: null
+			}
+		}), await Y({
+			store: e,
+			control: n,
+			keys: R(n, G(e, s.workflowName, s.payload)),
+			outcome: "expired",
+			mode: s.mode,
+			reason: l,
+			collapsed: o.reduce((e, t) => e + t.collapsed, 0),
+			waitedMs: r - s.firstSeenAt,
+			executionId: null,
+			runId: null,
+			tenantId: s.tenantId,
+			now: r
+		});
+		for (let t of o) if (await H(e, {
+			pendingId: t.id,
+			workflowName: t.workflowName,
+			tenantId: t.tenantId,
+			terminal: {
+				kind: "abandoned",
+				at: r,
+				failureId: a
+			}
+		}), !await e.delete("_voltro_workflow_pending", t.id)) throw Error("Expired queue row disappeared before deletion");
+		return await it(e, a, r), o.length;
+	});
+}, Dr = async (e, t, n, r, i) => {
+	if (t = {
+		...t,
+		payload: G(e.store, t.workflowName, t.payload)
+	}, t.mode === "delayed") return Or(e, t, n, r, i);
+	let a = e.controls.get(t.workflowName);
+	if (a === void 0) {
+		r.expired += await Tr(e, [t], i);
+		return;
+	}
+	if (We(a, t, i)) {
+		r.expired += await Er(e, [t], a, i, !1);
+		return;
+	}
+	let o = R(a, t.payload), s = await tn({
+		store: e.store,
+		control: a,
+		keys: o,
+		paused: n.has(t.workflowName),
+		now: i,
+		reconsidering: !0
+	});
+	await Ar(e, {
+		control: a,
+		intent: t,
+		decision: s,
+		keys: o,
+		counters: r,
+		now: i,
+		paused: n,
+		items: void 0
+	});
+}, Or = async (e, t, n, r, i) => {
+	if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
+		r.expired += await Tr(e, [t], i);
+		return;
+	}
+	let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = `wfsub_${L()}`, s = await e.transaction(async (e) => {
+		let r = await e.query({
+			table: U,
+			predicate: O("id", t.id),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r[0] === void 0) return;
+		let s = q(r[0]);
+		if (s.workflowName !== t.workflowName || s.tenantId !== t.tenantId) throw Error("Delayed arrival belongs to a different workflow or tenant");
+		if (s.mode !== "delayed" || s.deadLetteredAt !== void 0 || s.dueAt > i) return;
+		let c = await Ln({
+			store: e,
+			control: a,
+			payload: G(e, s.workflowName, s.payload),
+			callerContext: s.callerContext,
+			tenantId: s.tenantId,
+			paused: n.has(s.workflowName),
+			now: i,
+			waiting: !1
+		});
+		if (c.kind === "queued" && (await br(e, {
+			from: s.id,
+			to: c.intentId,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId
+		}), !await Jt(e, s.id))) throw Error("Delayed arrival disappeared during queue transfer");
+		if (c.kind === "start") {
+			if (c.ledgerId === void 0) throw Error("Delayed arrival has no admission reservation");
+			let t = a.batch === void 0 ? Mt(e, s.workflowName, c.payload) : { items: w.decodeUnknownSync(w.Struct({ items: w.Array(w.Unknown) }))(c.payload).items.map((t) => Mt(e, s.workflowName, t)) };
+			return {
+				kind: "submission",
+				submission: await Pn(e, {
+					id: o,
+					workflowName: s.workflowName,
+					tenantId: s.tenantId,
+					ledgerId: c.ledgerId,
+					payload: t,
+					callerContext: s.callerContext,
+					intentIds: [.../* @__PURE__ */ new Set([s.id, ...c.consume])],
+					eviction: c.evict ?? null
+				}),
+				keys: c.keys
+			};
+		}
+		if ((c.kind === "dropped" || c.kind === "skipped") && (await H(e, {
+			pendingId: s.id,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId,
+			terminal: {
+				...c,
+				at: i
+			}
+		}), !await Jt(e, s.id))) throw Error("Delayed arrival disappeared while recording its outcome");
+		return c;
+	});
+	if (s !== void 0) {
+		if (s.kind === "queued") {
+			r.deferred++;
+			return;
+		}
+		if (s.kind === "dropped") {
+			r.dropped++;
+			return;
+		}
+		if (s.kind === "skipped") {
+			r.skipped++;
+			return;
+		}
+		await Mr(e, s.submission, a, r, i, a.batch !== void 0, s.keys);
+	}
+}, kr = async (e, t, n, r, i) => {
+	t = t.map((t) => ({
+		...t,
+		payload: G(e.store, t.workflowName, t.payload)
+	}));
+	let a = t[0];
+	if (a === void 0) return;
+	let o = e.controls.get(a.workflowName);
+	if (o === void 0 || o.batch === void 0) {
+		r.expired += await Tr(e, t, i);
+		return;
+	}
+	let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
+	if (We(o, c, i)) {
+		r.expired += await Er(e, s, o, i, !0);
+		return;
+	}
+	let l = R(o, c.payload);
+	await Ar(e, {
+		control: o,
+		intent: c,
+		decision: await tn({
+			store: e.store,
+			control: o,
+			keys: l,
+			paused: n.has(a.workflowName),
+			now: i,
+			reconsidering: !0
+		}),
+		keys: l,
+		counters: r,
+		now: i,
+		paused: n,
+		items: s
+	});
+}, Ar = async (e, t) => {
+	let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c, paused: l } = t;
+	if (i.kind === "defer") {
+		await Vt({
+			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" || i.kind === "skip") {
+		let t = await e.transaction(async (e) => {
+			let t = [];
+			for (let i of c ?? [r]) {
+				let a = await e.query({
+					table: U,
+					predicate: O("id", i.id),
+					lock: "update",
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (a[0] === void 0) return;
+				let o = q(a[0]);
+				if (o.workflowName !== n.workflowName || o.tenantId !== r.tenantId) throw Error("Terminal queue selection belongs to a different workflow or tenant");
+				if (o.dueAt > s || o.deadLetteredAt !== void 0 || o.mode !== i.mode) return;
+				t.push(o);
+			}
+			t.sort((e, t) => e.firstSeenAt - t.firstSeenAt);
+			let i = t[0], a = R(n, G(e, n.workflowName, i.payload)), o = await tn({
+				store: e,
+				control: n,
+				keys: a,
+				paused: l.has(n.workflowName) || (await It(e)).has(n.workflowName),
+				now: s,
+				reconsidering: !0
+			});
+			if (o.kind !== "drop" && o.kind !== "skip") return;
+			let u = o.kind === "drop" ? {
+				kind: "dropped",
+				at: s,
+				retryAfterMs: o.retryAfterMs
+			} : {
+				kind: "skipped",
+				at: s,
+				executionId: o.incumbent.executionId,
+				runId: o.incumbent.runId
+			};
+			await Y({
+				store: e,
+				control: n,
+				keys: a,
+				outcome: u.kind,
+				mode: u.kind === "dropped" ? "rateLimit" : "singleton",
+				reason: u.kind === "dropped" ? `rate limit reached while queued; retry after ${u.retryAfterMs}ms` : `singleton key held by ${u.executionId}`,
+				collapsed: t.reduce((e, t) => e + t.collapsed, 0),
+				waitedMs: s - i.firstSeenAt,
+				executionId: u.kind === "skipped" ? u.executionId : null,
+				runId: u.kind === "skipped" && u.runId || null,
+				tenantId: r.tenantId,
+				now: s
+			});
+			for (let n of t) if (await H(e, {
+				pendingId: n.id,
+				workflowName: n.workflowName,
+				tenantId: n.tenantId,
+				terminal: u
+			}), !await Jt(e, n.id)) throw Error("Queued input disappeared while recording its terminal outcome");
+			return u.kind;
+		});
+		t !== void 0 && o[t]++;
+		return;
+	}
+	let u = `wfsub_${L()}`, d = await e.transaction((t) => In(t, {
+		id: u,
+		workflowName: n.workflowName,
+		tenantId: r.tenantId,
+		intentIds: (c ?? [r]).map((e) => e.id),
+		now: s,
+		prepare: (t) => {
+			let r = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), i = r[0], a = G(e.store, n.workflowName, i.payload);
+			return {
+				control: n,
+				keyPayload: a,
+				encodedPayload: c === void 0 ? i.payload : { items: r.map((e) => e.payload) },
+				callerContext: i.callerContext,
+				paused: l.has(n.workflowName),
+				firstSeenAt: i.firstSeenAt,
+				collapsed: r.reduce((e, t) => e + t.collapsed, 0),
+				mode: i.mode
+			};
+		}
+	}));
+	if (d.kind !== "selection-unavailable") {
+		if (d.kind === "not-admitted") {
+			o.deferred++;
+			return;
+		}
+		await Mr(e, d.submission, n, o, s, c !== void 0, a);
+	}
+}, jr = async (e, t, n, r, i) => {
+	let a = await e.transaction((e) => B(e, t.id));
+	if (a === void 0 || !a.receiptsBound || a.workflowName !== n.workflowName || a.workflowName !== t.workflowName || a.tenantId !== t.tenantId || a.ledgerId !== t.ledgerId) throw Error("Admission acceptance callback no longer has its resident submission owner");
+	if (a.executionId !== null) {
+		if (a.failureId !== null || a.executionId.length === 0 || a.executionId !== a.preparedExecutionId) throw Error("Admission acceptance has contradictory resident execution evidence");
+		return a.executionId;
+	}
+	await Mr(e, a, n, {
+		admitted: 0,
+		deferred: 0,
+		dropped: 0,
+		skipped: 0,
+		expired: 0,
+		evicted: 0
+	}, i, n.batch !== void 0, r);
+	let o = await e.transaction((e) => B(e, t.id));
+	if (o?.executionId == null || o.executionId !== o.preparedExecutionId) throw Error("Admission submission has no confirmed engine acceptance");
+	return o.executionId;
+}, Mr = async (e, t, n, r, i, a, o) => {
+	let s = t.dispatchAttempts === 0 ? 0 : void 0;
+	try {
+		if (e.acquireSubmissionCapacity !== void 0 && !await e.acquireSubmissionCapacity(t)) {
+			r.deferred++;
+			return;
+		}
+		let c = a ? { items: w.decodeUnknownSync(w.Struct({ items: w.Array(w.Unknown) }))(t.payload).items.map((t) => G(e.store, n.workflowName, t)) } : G(e.store, n.workflowName, t.payload), l = await fr(e, t, c), u = await e.transaction((e) => St(e, t.id, i));
+		if (u === null) return;
+		s = u.dispatchAttempts === 1 ? 1 : void 0;
+		let d = await e.startAdmitted(n.workflowName, c, t.callerContext, l);
+		if (s = void 0, d.executionId !== l) throw Error("Engine returned a different prepared execution identity");
+		t.eviction !== null && (await e.cancelRun({
+			workflowName: n.workflowName,
+			runId: t.eviction.runId,
+			executionId: t.eviction.executionId,
+			reason: "cancelled to make room for a newer start (singleton mode 'cancel')",
+			detail: {
+				source: "flow-control",
+				mode: "singleton"
+			}
+		}), await Wt(e.store, t.eviction.executionId, i), await Y({
+			store: e.store,
+			control: n,
+			keys: o,
+			outcome: "evicted",
+			mode: "singleton",
+			reason: "cancelled to make room for a newer start (singleton mode 'cancel')",
+			collapsed: 1,
+			waitedMs: null,
+			executionId: t.eviction.executionId,
+			runId: t.eviction.runId || null,
+			tenantId: t.tenantId,
+			now: i
+		}), r.evicted++), await e.transaction((e) => yt(e, t.id, {
+			executionId: d.executionId,
+			runId: d.runId ?? null
+		})), r.admitted++;
+	} catch (r) {
+		let a = !1;
+		try {
+			if (s !== void 0 && e.isPermanentStartError?.(r) === !0) {
+				let o = s;
+				a = await e.transaction((e) => Ct(e, t.id, o, {
+					handler: n.onFailure ?? null,
+					errorMessage: String(r),
+					now: i
+				})) !== void 0;
+			}
+			if (!a) {
+				let n = await e.transaction((n) => xt(n, t.id, String(r), i, e.deadLetterAfterAttempts ?? 50));
+				n.retry.stoppedAt !== null && e.log?.warn?.("workflow submission automatic retry stopped; engine acceptance unknown", {
+					submissionId: t.id,
+					workflow: t.workflowName,
+					attempts: n.retry.attempts
+				});
+			}
+		} catch (e) {
+			throw new Cr(t.id, AggregateError([r, e], "Submission and retry recording failed"));
+		}
+		throw new Cr(t.id, r, a);
+	}
+}, Nr = async (e, t) => {
+	if (e.listRunningRuns === void 0) return { cancelled: 0 };
+	let n = 0, r;
+	for (let i of e.controls.values()) {
+		if (i.timeouts?.finishMs === void 0) continue;
+		let a = await e.listRunningRuns(i.workflowName);
+		for (let o of a) {
+			if (!Ge(i, {
+				startedAt: o.startedAt,
+				terminal: !1
+			}, t)) {
+				let e = o.startedAt + i.timeouts.finishMs;
+				(r === void 0 || e < r) && (r = e);
+				continue;
+			}
+			let a = `timeouts.finish (${i.timeouts.finishMs}ms) elapsed; the run was cancelled after ${t - o.startedAt}ms`;
+			await e.cancelRun({
+				workflowName: o.workflowName,
+				runId: o.runId,
+				executionId: o.executionId,
+				reason: a,
+				detail: {
+					source: "flow-control",
+					timeout: "finish"
+				}
+			}) && (await Wt(e.store, o.executionId, t), await e.onAbandoned({
+				workflowName: o.workflowName,
+				payload: o.payload,
+				callerContext: null,
+				reason: a,
+				runId: o.runId,
+				executionId: o.executionId
+			}), n++);
+		}
+	}
+	return {
+		cancelled: n,
+		...r === void 0 ? {} : { nextDeadlineAt: r }
+	};
+}, Pr = 3e5, Fr, Ir = (e) => {
+	Fr = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
+}, Lr = () => {
+	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 Fr ?? 3e5;
+}, Rr = /* @__PURE__ */ new Set(), zr = () => {
+	Rr.clear();
+}, Br = (e) => {
+	let t = Lr();
+	if (!(e.timeoutMs > t)) return !1;
+	let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
+	if (Rr.has(n)) return !1;
+	Rr.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;
+}, Vr = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Hr = (e, n) => {
+	let i = S.gen(function* () {
+		let i = n.pollIntervalMs ?? 200, a = n.maxPollIntervalMs ?? 5e3, o = n.timeoutMs ?? 864e5, s = yield* S.serviceOption(ye), c;
+		Br({
+			workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
+			signalName: n.name,
+			timeoutMs: o,
+			warn: (e) => {
+				c = e;
+			}
+		}), c !== void 0 && (yield* S.logWarning(c));
+		let l = yield* t, u = yield* S.serviceOption(r), d = u._tag === "Some" ? u.value : void 0;
+		if (l === void 0) return yield* S.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
+		let f = l;
+		yield* S.promise(() => Vr(d, {
+			runId: f,
+			eventType: "signal-awaited",
+			payload: { signalName: n.name }
+		}));
+		let p = Date.now(), m = i;
+		for (;;) {
+			let t = Date.now() - p;
+			if (t > o) return yield* S.die(/* @__PURE__ */ Error(`awaitSignal('${n.name}') timed out after ${t}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: T(O("runId", f), O("eventType", "signal-sent")),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, i = (yield* S.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			})).find((e) => e.payload?.signalName === n.name);
+			if (i !== void 0) {
+				let e = yield* w.decodeUnknown(n.schema)(i.payload?.value);
+				return yield* S.promise(() => Vr(d, {
+					runId: f,
+					eventType: "signal-received",
+					payload: {
+						signalName: n.name,
+						value: i.payload?.value
+					}
+				})), e;
+			}
+			yield* S.sleep(`${m} millis`), m = Math.min(m * 2, a);
+		}
+	});
+	return _.make({
+		name: `await-signal:${n.name}`,
+		success: n.schema,
+		execute: i
+	});
+}, Ur = async (e, t) => {
+	if (e !== void 0) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Wr = (e, n) => {
+	let i = S.gen(function* () {
+		let i = n.pollIntervalMs ?? 200, a = n.maxPollIntervalMs ?? 5e3, o = n.timeoutMs ?? 864e5, s = n.take ?? 500, c = yield* t, l = yield* S.serviceOption(r), u = l._tag === "Some" ? l.value : void 0;
+		if (c === void 0) return yield* S.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
+		let d = c, f = yield* n.since === "run-start" ? Gr(e, d) : S.succeed(/* @__PURE__ */ new Date());
+		yield* S.promise(() => Ur(u, {
+			runId: d,
+			eventType: "event-awaited",
+			payload: {
+				event: n.event,
+				since: n.since ?? "wait-start",
+				cutoff: f.toISOString()
+			}
+		}));
+		let p = Date.now(), m = i, h = 0;
+		for (;;) {
+			let t = Date.now() - p;
+			if (t > o) return yield* S.die(/* @__PURE__ */ Error(`awaitEvent('${n.event}') timed out after ${t}ms having examined ${h} candidate event(s). ${h === 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: T(O("name", n.event), le("occurredAt", f)),
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				take: s,
+				skip: void 0,
+				projection: void 0
+			}, i = yield* S.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			});
+			h = i.length;
+			for (let e of i) {
+				let t = yield* w.decodeUnknown(n.schema)(e.payload);
+				if (n.match(t)) return yield* S.promise(() => Ur(u, {
+					runId: d,
+					eventType: "event-received",
+					payload: {
+						event: n.event,
+						eventId: e.id
+					}
+				})), t;
+			}
+			yield* S.sleep(`${m} millis`), m = Math.min(m * 2, a);
+		}
+	});
+	return _.make({
+		name: `awaitEvent:${n.event}`,
+		success: n.schema,
+		execute: i
+	});
+}, Gr = (e, t) => S.gen(function* () {
+	let n = (yield* S.tryPromise({
+		try: () => e.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: O("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);
+}), Kr = (e) => new Promise((t) => setTimeout(t, e)), qr = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, Jr = () => `wfu_${qr()}`, Yr = 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: O("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: O("executionId", n),
+		projection: void 0,
+		skip: void 0,
+		take: 1
+	}))[0];
+	if (!i) throw Error(`workflow message target not found: ${n}`);
+	return i;
+}, Xr = async (e) => {
+	let t = await Yr(e.store, e.target);
+	return { eventId: (await e.recorder.recordEvent({
+		runId: t.id,
+		eventType: "signal-sent",
+		payload: {
+			signalName: e.signalName,
+			value: e.payload
+		}
+	})).id };
+}, Zr = async (e) => {
+	let t = await Yr(e.store, e.target), n = Jr(), 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: O("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 Kr(o);
+	}
+}, Qr = 864e5, $r = "voltro/suspending-signal", ei = (e, t) => `${$r}/${e}/${t}`, ti = (e) => y.make(e, { success: w.Unknown }), ni = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, ri = (e, n) => S.gen(function* () {
+	let e = n.timeoutMs ?? Qr, i = ti(ei((yield* b.WorkflowInstance).workflow.name, n.name)), a = yield* t, o = yield* S.serviceOption(r), s = o._tag === "Some" ? o.value : void 0;
+	a !== void 0 && (yield* S.promise(() => ni(s, {
+		runId: a,
+		eventType: "signal-awaited",
+		payload: { signalName: n.name }
+	})));
+	let c = y.await(i), l = Number.isFinite(e) ? yield* S.race(c, v.sleep({
+		name: `await-signal-timeout/${n.name}`,
+		duration: `${e} millis`
+	}).pipe(S.andThen(S.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${n.name}') timed out after ${e}ms`))))) : yield* c, u = yield* w.decodeUnknown(n.schema)(l);
+	return a !== void 0 && (yield* S.promise(() => ni(s, {
+		runId: a,
+		eventType: "signal-received",
+		payload: {
+			signalName: n.name,
+			value: u
+		}
+	}))), u;
+}), ii = (e) => S.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* S.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
+		let i = yield* S.tryPromise({
+			try: () => Yr(r, e.target),
+			catch: (e) => e
+		});
+		t ??= i.executionId, n ??= i.tag;
+	}
+	if (t === void 0 || n === void 0) return { completed: !1 };
+	let r = ei(n, e.signalName), i = ti(r), a = new y.TokenParsed({
+		workflowName: n,
+		executionId: t,
+		deferredName: r
+	}).asToken;
+	return yield* y.done(i, {
+		token: a,
+		exit: te.succeed(e.payload)
+	}), { completed: !0 };
+}), Z = "_voltro_budget_holds", ai = "budget-hold", oi = (e) => `${ai}:${e}`, si = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, ci = async (e, t) => (await e.query({
+	table: Z,
+	predicate: T(O("executionId", t.executionId), O("stepName", t.stepName), O("budget", t.budget)),
+	order: []
+})).length, li = P(Z, {
+	id: A({ prefix: "bhd" }),
+	holdKey: F().maxLength(191),
+	budget: F(),
+	tenantId: F().nullable(),
+	executionId: F(),
+	workflowName: F(),
+	signalName: F(),
+	stepName: F(),
+	spentMicroUsd: F().nullable(),
+	limitMicroUsd: F().nullable(),
+	heldAt: I().default("now"),
+	releasedAt: I().nullable(),
+	outcome: F().nullable()
+}).index(["budget", "releasedAt"]), ui = () => {
+	ge({
+		source: "framework",
+		table: Z,
+		timeColumn: "releasedAt",
+		ttlMs: _e(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
+	});
+}, di = 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;
+	}
+}, fi = 6048e5, pi = (e) => S.gen(function* () {
+	ui();
+	let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
+		executionId: e.executionId,
+		stepName: e.stepName,
+		budget: e.budget
+	};
+	for (;;) {
+		let i = yield* S.promise(() => hi(e.store, r)), a = i.length, o = i.length === 0 ? Date.now() : mi(i[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = si({
+			...r,
+			generation: a
+		});
+		if (s <= 0) return yield* S.promise(() => gi(e.store, r, "expired")), yield* S.fail(new di(e.budget, c, t));
+		let l = oi(c);
+		yield* S.promise(() => e.store.insertIgnore(Z, {
+			id: ce({
+				kind: "typeid",
+				prefix: "bhd"
+			}, Z),
+			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* ri({ store: e.store }, {
+			name: l,
+			schema: w.Unknown,
+			timeoutMs: u
+		}).pipe(S.catchAllCause((e) => x.isInterruptedOnly(e) ? S.failCause(e) : S.void)), yield* S.promise(() => e.store.updateMany(Z, {
+			releasedAt: /* @__PURE__ */ new Date(),
+			outcome: "recheck"
+		}, { where: T(O("holdKey", c), M("releasedAt")) })), yield* e.hasHeadroom) return;
+	}
+}), mi = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), hi = async (e, t) => [...await e.query({
+	table: Z,
+	predicate: T(O("executionId", t.executionId), O("stepName", t.stepName), O("budget", t.budget)),
+	order: []
+})].sort((e, t) => String(e.id).localeCompare(String(t.id))), gi = async (e, t, n) => {
+	await e.updateMany(Z, {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: n
+	}, { where: T(O("executionId", t.executionId), O("stepName", t.stepName), O("budget", t.budget), M("releasedAt")) });
+}, _i = (e) => S.gen(function* () {
+	let t = e.tenantId === void 0 ? T(O("budget", e.budget), M("releasedAt")) : T(O("budget", e.budget), O("tenantId", e.tenantId), M("releasedAt")), n = yield* S.promise(() => e.store.query({
+		table: Z,
+		predicate: t,
+		order: []
+	})), r = 0;
+	for (let t of n) (yield* S.promise(() => e.store.updateMany("_voltro_budget_holds", {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: e.outcome ?? "released"
+	}, { where: T(O("id", String(t.id)), M("releasedAt")) }))) === 1 && (yield* ii({
+		target: {
+			executionId: String(t.executionId),
+			workflowName: String(t.workflowName)
+		},
+		signalName: String(t.signalName),
+		payload: {
+			released: !0,
+			budget: e.budget
+		}
+	}).pipe(S.catchAll(() => S.succeed({ completed: !1 }))), r += 1);
+	return { released: r };
+}), vi = async (e, t) => {
+	let n = t?.budget === void 0 ? M("releasedAt") : T(O("budget", t.budget), M("releasedAt"));
+	return (await e.query({
+		table: Z,
+		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 ?? "")
+	}));
+}, yi = async (e) => {
+	let t = await vi(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()];
+}, bi = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, xi = (e) => {
+	let t = x.failureOption(e), n = Array.from(x.defects(e)), r = t._tag === "Some" ? t.value : n[0] ?? x.squash(e);
+	return {
+		errorTag: r && typeof r == "object" && "_tag" in r ? String(r._tag) : null,
+		errorMessage: r?.message ?? String(r)
+	};
+}, Si = (e, n) => {
+	let i = S.gen(function* () {
+		let i = n.pollIntervalMs ?? 200, a = n.maxPollIntervalMs ?? 5e3, o = n.timeoutMs ?? 3e4, s = yield* t, c = yield* S.serviceOption(r), l = c._tag === "Some" ? c.value : void 0;
+		if (s === void 0) return yield* S.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
+		let u = s, d = Date.now(), f = i;
+		for (;;) {
+			let t = Date.now() - d;
+			if (t > o) return yield* S.die(/* @__PURE__ */ Error(`awaitUpdate('${n.name}') timed out after ${t}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: O("runId", u),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, i = yield* S.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			}), s = new Set(i.filter((e) => e.eventType === "update-completed" || e.eventType === "update-failed").map((e) => e.payload?.updateId).filter((e) => typeof e == "string" && e.length > 0)), c = i.find((e) => e.eventType === "update-requested" && e.payload?.updateName === n.name && typeof e.payload.updateId == "string" && !s.has(e.payload.updateId));
+			if (c !== void 0) {
+				let e = c.payload.updateId;
+				yield* S.promise(() => bi(l, {
+					runId: u,
+					eventType: "update-received",
+					payload: {
+						updateId: e,
+						updateName: n.name
+					}
+				}));
+				let t = yield* w.decodeUnknown(n.schema)(c.payload?.value).pipe(S.tapErrorCause((t) => S.promise(() => bi(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						...xi(t)
+					}
+				})))), r = yield* (n.handle ? n.handle(t) : S.succeed(t)).pipe(S.flatMap((e) => n.success ? w.decodeUnknown(n.success)(e) : S.succeed(e))).pipe(S.tapErrorCause((t) => S.promise(() => bi(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						...xi(t)
+					}
+				}))));
+				return yield* S.promise(() => bi(l, {
+					runId: u,
+					eventType: "update-completed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						result: r
+					}
+				})), r;
+			}
+			yield* S.sleep(`${f} millis`), f = Math.min(f * 2, a);
+		}
+	});
+	return _.make({
+		name: `await-update:${n.name}`,
+		success: n.success ?? n.schema,
+		execute: i
+	});
+}, Ci = (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;
+}, wi = (e) => typeof e == "number" ? e : e == null ? null : Number(e), Q = (e) => e == null ? null : String(e), Ti = (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) => (wi(e.attempt) ?? 0) - (wi(t.attempt) ?? 0));
+		let t = r[r.length - 1], i = Q(t.errorTag), a = Q(t.errorMessage), o = i !== null || a !== null ? {
+			tag: i,
+			message: a ?? ""
+		} : null;
+		n.push({
+			name: e,
+			attempt: wi(t.attempt) ?? r.length,
+			attempts: r.length,
+			status: t.status ?? "running",
+			input: t.input ?? null,
+			output: t.output ?? null,
+			error: o,
+			durationMs: wi(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 (Ci(r?.startedAt)?.getTime() ?? 0) - (Ci(i?.startedAt)?.getTime() ?? 0);
+	}), n;
+}, Ei = (e) => {
+	if (e == null) return null;
+	if (typeof e == "string") try {
+		return JSON.parse(e);
+	} catch {
+		return null;
+	}
+	return typeof e == "object" ? e : null;
+}, Di = async (e, t) => {
+	let n = me(xe), r = (await t.query(n.where(pe(O("id", e), O("executionId", e))).limit(1).descriptor))[0];
+	if (r === void 0) return null;
+	let i = String(r.id), a = me(Se), o = await t.query(a.where(O("runId", i)).descriptor);
+	return {
+		id: i,
+		executionId: Q(r.executionId) ?? "",
+		name: Q(r.tag) ?? "",
+		status: r.status ?? "running",
+		input: r.payload ?? null,
+		output: r.output ?? null,
+		subject: Ei(r.subject),
+		source: Q(r.source),
+		steps: Ti(o),
+		startedAt: Ci(r.startedAt) ?? /* @__PURE__ */ new Date(0),
+		finishedAt: Ci(r.completedAt),
+		traceId: Q(r.traceId),
+		parentExecutionId: Q(r.parentExecutionId),
+		parentClosePolicy: Q(r.parentClosePolicy)
+	};
+}, Oi = () => {
+	let e = [], t = [], n = 0, i = 0;
+	return {
+		layer: ie.succeed(r, {
+			startStep: async ({ runId: t, stepName: r, attempt: i, stepInput: a, retryPolicy: o }) => {
+				let s = `wfstep_mem_${++n}`;
+				return e.push({
+					id: s,
+					runId: t,
+					stepName: r,
+					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
+	};
+}, ki = (e, t, n) => S.gen(function* () {
+	let r = yield* ye;
+	for (;;) {
+		if (yield* S.tryPromise(() => u(t, e)).pipe(S.catchAll(() => S.sync(() => (n(), !1))))) return r.interrupted = !0, yield* S.interrupt;
+		yield* S.sleep(1e3);
+	}
+}), Ai = 8192, ji = 3, Mi = 2e3, Ni = () => {
+	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 }
+	};
+}, Pi = (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");
+}, Fi = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, Ii = (e) => `${e}_${Fi()}`, Li = (e, t = Ai) => {
+	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) };
+	}
+}, $ = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
+	return t;
+}, Ri = (e) => {
+	let t = e.truncateBytes ?? Ai, n = e.makeId ?? Ii, 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(Li(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: $(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(Li(s, t)),
+					completedAt: /* @__PURE__ */ new Date(),
+					durationMs: c
+				});
+				r && a?.("workflowSteps", {
+					op: "update",
+					row: $(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(Li(l, t)),
+					completedAt: /* @__PURE__ */ new Date(),
+					durationMs: u
+				});
+				r && a?.("workflowSteps", {
+					op: "update",
+					row: $(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: $(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 };
+		}
+	};
+}, zi = (e, t, n) => S.gen(function* () {
+	let r = e.store.query;
+	if (r === void 0) return;
+	let i = e.replayShapeLimit ?? 2e3, a = yield* S.promise(() => r.call(e.store, {
+		table: "_voltro_workflow_run_steps",
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		predicate: O("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 o = a.flatMap((e) => {
+		let t = e.stepName;
+		return typeof t == "string" ? [{ stepName: t }] : [];
+	});
+	return o.length === 0 ? void 0 : s(o);
+}), Bi = (s, l) => {
+	let u = s.truncateBytes ?? Ai, d = s.makeId ?? Ii, p = s.recorder ?? Ri(s), m = (e, t) => s.log?.warn(e, t), h = s.emit, g = (e) => S.gen(function* () {
+		yield* S.sync(() => h?.("workflowEvents", {
+			op: "insert",
+			row: $(e)
+		}));
+		let t = s.wakeups, n = e.runId;
+		if (t !== void 0 && typeof n == "string") {
+			let e = s.subject?.tenantId;
+			yield* S.promise(() => t.cancel(n, typeof e == "string" ? e : void 0).catch(() => {
+				m("failed to clear terminal workflow wakeup", { runId: n });
+			}));
+		}
+	}), _ = (e, t, n) => S.promise(async () => {
+		if (s.onParentClose) try {
+			await s.onParentClose({
+				workflowName: s.name,
+				executionId: e,
+				...n === void 0 ? {} : { runId: n },
+				status: t
+			});
+		} catch (n) {
+			m("failed to apply workflow parent-close policy", {
+				tag: s.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	}), v = (e, t, n, r) => S.promise(async () => {
+		if (s.onTerminal) try {
+			await s.onTerminal({
+				workflowName: s.name,
+				executionId: e,
+				...n === void 0 ? {} : { runId: n },
+				status: t,
+				...r === void 0 ? {} : r
+			});
+		} catch (n) {
+			m("workflow terminal observer failed", {
+				tag: s.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	});
+	return (y, b) => S.gen(function* () {
+		let C = Date.now(), ie = yield* re.get(i), w = yield* re.get(a), ae = s.parentExecutionId ?? ie ?? null, oe = s.parentGeneration ?? (s.parentExecutionId == null ? w : void 0) ?? null, T = s.parentClosePolicy ?? null, E, D = (e, t) => t.pipe(S.catchAllCause((t) => x.isInterrupted(t) ? S.failCause(t) : S.sync(() => {
+			let n = x.squash(t);
+			m(e, {
+				tag: s.name,
+				executionId: b,
+				reason: n?.message ?? String(n)
+			});
+		}))), O = `wfrg_${Fi()}`, ce = yield* S.serviceOption(f), k = d("wr"), le = yield* S.sync(() => s.encodePayload === void 0 ? y : s.encodePayload(y)), A = yield* S.promise(() => s.transaction((e) => pn(e, {
+			workflowName: s.name,
+			executionId: b,
+			generation: O,
+			now: C,
+			delivery: ce._tag === "Some" ? ce.value : null,
+			initialRow: {
+				id: k,
+				payload: le,
+				workflowVersion: s.workflowVersion ?? null,
+				workflowPatches: s.workflowPatches ?? null,
+				output: null,
+				subject: s.subject ?? null,
+				source: s.source ?? null,
+				errorTag: null,
+				errorMessage: null,
+				cancelled: !1,
+				startedAt: new Date(C),
+				completedAt: null,
+				durationMs: null,
+				traceId: s.traceId ?? null,
+				parentExecutionId: ae,
+				parentGeneration: oe,
+				parentClosePolicy: T
+			}
+		})));
+		if (typeof A.row.id != "string") return yield* S.die(/* @__PURE__ */ Error("Recorded workflow entry has no run identity"));
+		if (E = A.row.id, A.kind === "cancelled" || A.kind === "already-cancelled") {
+			let e = yield* ye;
+			return e.interrupted = !0, A.kind === "cancelled" && (yield* D("failed to observe suspended workflow cancellation", S.gen(function* () {
+				if (h?.("workflowRuns", {
+					op: "update",
+					row: $(A.row)
+				}), A.terminalEvent === void 0) return yield* S.die(/* @__PURE__ */ Error("Cancelled entry has no terminal event"));
+				yield* g(A.terminalEvent), yield* _(b, "cancelled", E);
+			})), yield* v(b, "cancelled", E), yield* S.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "cancelled",
+				durationMs: 0
+			}))), yield* S.interrupt;
+		}
+		let ue = A.previous, j = ue?.workflowVersion ?? null;
+		if (ue?.id !== void 0 && j !== null && s.workflowCompatibleVersions !== void 0 && s.workflowCompatibleVersions !== null && !s.workflowCompatibleVersions.includes(j)) {
+			let e = `Workflow '${s.name}' run '${b}' was started on version ${j}, but current code is compatible with ${s.workflowCompatibleVersions.join(", ")}`, t = s.failureContext ?? {
+				handler: null,
+				callerContext: null,
+				tenantId: null
+			}, n = yield* S.promise(() => s.transaction((n) => vn(n, {
+				owner: {
+					runId: E,
+					workflowName: s.name,
+					executionId: b,
+					generation: O
+				},
+				now: Date.now(),
+				durationMs: 0,
+				outcome: {
+					status: "failed",
+					errorTag: "WorkflowVersionIncompatible",
+					errorMessage: e,
+					...t
+				}
+			})));
+			return n.kind === "committed" && (yield* D("failed to observe workflow version rejection", S.gen(function* () {
+				h?.("workflowRuns", {
+					op: "update",
+					row: $(n.row)
+				}), yield* g(n.terminalEvent), yield* _(b, "failed", E);
+			})), yield* v(b, "failed", E, {
+				payload: A.row.payload,
+				errorTag: "WorkflowVersionIncompatible",
+				errorMessage: e
+			}), yield* S.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "failed",
+				durationMs: 0
+			}))), yield* S.fail(Error(e));
+		}
+		let de = s.workflowPatches ?? [], M;
+		if (ue?.id !== void 0) {
+			E = ue.id, de = Pi(ue.workflowPatches) ?? de;
+			let e = A.row.reclaimCount;
+			if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0) return yield* S.die(/* @__PURE__ */ Error("Recorded workflow entry has an invalid reclaim counter"));
+			let t = e > 0, n = s.maxRunReclaims ?? 3;
+			if (t && e >= n) {
+				let t = `Workflow '${s.name}' run '${b}' killed its runner ${e} times in a row; parked instead of reclaimed again (maxRunReclaims=${n}).`, r = yield* S.promise(() => s.transaction((e) => gn(e, {
+					runId: E,
+					workflowName: s.name,
+					executionId: b,
+					generation: O
+				}, {
+					errorTag: "WorkflowCrashLooped",
+					errorMessage: t
+				})));
+				r.kind === "committed" && (yield* D("failed to observe workflow crash-loop park", S.gen(function* () {
+					h?.("workflowRuns", {
+						op: "update",
+						row: $(r.row)
+					}), yield* S.promise(() => p.recordEvent({
+						runId: E,
+						eventType: "run-crashlooped",
+						payload: {
+							reclaimCount: e,
+							maxRunReclaims: n,
+							executionId: b,
+							tag: s.name
+						}
+					}));
+				})), m("workflow run parked after repeated runner deaths", {
+					tag: s.name,
+					executionId: b,
+					runId: E,
+					reclaimCount: e,
+					maxRunReclaims: n
+				}));
+				let i = yield* ye;
+				return yield* ee.suspend(i);
+			}
+			M = yield* zi(s, E, m), yield* D("failed to record workflow re-entry", S.gen(function* () {
+				h?.("workflowRuns", {
+					op: "update",
+					row: $(A.row)
+				}), t && (yield* S.promise(() => p.recordEvent({
+					runId: E,
+					eventType: "run-resumed",
+					payload: {
+						reason: "runner-reclaim",
+						reclaimCount: e,
+						maxRunReclaims: n
+					}
+				})));
+			}));
+		} else yield* D("failed to emit recorded workflow start", S.gen(function* () {
+			if (h?.("workflowRuns", {
+				op: "insert",
+				row: $(A.row)
+			}), E) {
+				let e = E;
+				yield* S.promise(() => p.recordEvent({
+					runId: e,
+					eventType: "run-started",
+					payload: {
+						tag: s.name,
+						executionId: b,
+						source: s.source ?? null,
+						workflowVersion: s.workflowVersion ?? null,
+						workflowPatches: s.workflowPatches ?? null,
+						parentExecutionId: ae,
+						parentClosePolicy: T
+					}
+				}));
+			}
+		}));
+		let N = s.subject?.tenantId, fe = S.suspend(() => l(y, b, O)).pipe(S.locally(t, E), S.locally(i, b), S.locally(a, O), S.locally(n, typeof N == "string" ? N : void 0), S.locally(o, de), S.locally(c, M), S.provideService(r, p)), pe = s.pluginWorkflowStepLayer ? fe.pipe(S.provide(s.pluginWorkflowStepLayer)) : fe, me = yield* ee.intoResult(S.raceWith(pe, ki({
+			runId: E,
+			workflowName: s.name,
+			executionId: b,
+			generation: O
+		}, async (e) => s.store.query(e), () => m("workflow control read failed; retrying without claiming cancellation", {
+			executionId: b,
+			runId: E
+		})).pipe(S.interruptible), {
+			onSelfDone: (e, t) => ne.interrupt(t).pipe(S.zipRight(e)),
+			onOtherDone: (e, t) => ne.interrupt(t).pipe(S.zipRight(e))
+		}));
+		if (ee.isResult(me) && me._tag === "Suspended") {
+			let e = me.cause, t = e !== void 0 && !x.isEmpty(e), n = t ? x.squash(e) : void 0, r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = t ? n?.message ?? String(n) : null, a = yield* S.promise(() => s.transaction((e) => gn(e, {
+				runId: E,
+				workflowName: s.name,
+				executionId: b,
+				generation: O
+			}, {
+				errorTag: r,
+				errorMessage: i
+			})));
+			a.kind === "committed" && t && (yield* S.sync(() => se({
+				error: n,
+				source: "workflow",
+				name: s.name,
+				...s.traceId ? { traceId: s.traceId } : {},
+				fields: {
+					executionId: b,
+					suspendedOnFailure: !0,
+					...r ? { errorTag: r } : {},
+					...E ? { runId: E } : {}
+				}
+			}))), a.kind === "committed" && (yield* D("failed to observe workflow suspend", S.gen(function* () {
+				h?.("workflowRuns", {
+					op: "update",
+					row: $(a.row)
+				}), yield* S.promise(() => p.recordEvent({
+					runId: E,
+					eventType: "run-suspended",
+					payload: t ? {
+						reason: "suspend-on-failure",
+						errorTag: r,
+						errorMessage: i
+					} : { reason: "workflow-suspend" }
+				}));
+			})));
+			let o = yield* ye;
+			return yield* ee.suspend(o);
+		}
+		let he = me;
+		if (M !== void 0 && E !== void 0) {
+			let t = M.settle();
+			if (t.length > 0) {
+				let n = E;
+				m("workflow replay reached a different step shape than this run recorded", {
+					tag: s.name,
+					executionId: b,
+					runId: n,
+					findings: t.map((e) => `${e.kind}:${e.stepName}`)
+				}), yield* D("failed to record nondeterminism findings", S.promise(async () => {
+					for (let r of t) await p.recordEvent({
+						runId: n,
+						eventType: "nondeterminism-suspected",
+						payload: e(r)
+					}).catch(() => void 0);
+				}));
+			}
+		}
+		if (te.isFailure(he.exit)) {
+			let e = he.exit.cause;
+			if ((yield* ye).interrupted && x.isInterruptedOnly(e)) {
+				let t = Date.now(), n = yield* S.promise(() => s.transaction((e) => vn(e, {
+					owner: {
+						runId: E,
+						workflowName: s.name,
+						executionId: b,
+						generation: O
+					},
+					now: t,
+					durationMs: t - C,
+					outcome: { status: "cancelled" }
+				})));
+				return n.kind === "committed" && (yield* D("failed to observe workflow cancellation", S.gen(function* () {
+					h?.("workflowRuns", {
+						op: "update",
+						row: $(n.row)
+					}), yield* g(n.terminalEvent), yield* _(b, "cancelled", E);
+				})), yield* v(b, "cancelled", E), yield* S.sync(() => s.recordRun?.({
+					name: s.name,
+					status: "cancelled",
+					durationMs: t - C
+				}))), yield* S.failCause(e);
+			}
+			let t = x.failureOption(e), n = t._tag === "Some" ? t.value : x.squash(e), r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = n?.message ?? String(n), a = Date.now(), o = s.failureContext ?? {
+				handler: null,
+				callerContext: null,
+				tenantId: null
+			}, c = yield* S.promise(() => s.transaction((e) => vn(e, {
+				owner: {
+					runId: E,
+					workflowName: s.name,
+					executionId: b,
+					generation: O
+				},
+				now: a,
+				durationMs: a - C,
+				outcome: {
+					status: "failed",
+					errorTag: r,
+					errorMessage: i,
+					...o
+				}
+			})));
+			return c.kind === "committed" ? (yield* S.sync(() => se({
+				error: n,
+				source: "workflow",
+				name: s.name,
+				...s.traceId ? { traceId: s.traceId } : {},
+				fields: {
+					executionId: b,
+					...r ? { errorTag: r } : {},
+					...E ? { runId: E } : {}
+				}
+			})), E && (yield* D("failed to record workflow failure", S.gen(function* () {
+				h?.("workflowRuns", {
+					op: "update",
+					row: $(c.row)
+				}), yield* g(c.terminalEvent), yield* _(b, "failed", E);
+			}))), yield* v(b, "failed", E, {
+				payload: y,
+				errorTag: r,
+				errorMessage: i
+			}), yield* S.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "failed",
+				durationMs: Date.now() - C
+			})), yield* S.failCause(e)) : yield* S.failCause(e);
+		}
+		let ge = he.exit.value, _e = Date.now(), P = yield* S.promise(() => s.transaction((e) => vn(e, {
+			owner: {
+				runId: E,
+				workflowName: s.name,
+				executionId: b,
+				generation: O
+			},
+			now: _e,
+			durationMs: _e - C,
+			outcome: {
+				status: "succeeded",
+				output: Li(ge, u)
+			}
+		})));
+		return P.kind === "committed" ? (E && (yield* D("failed to record workflow success", S.gen(function* () {
+			h?.("workflowRuns", {
+				op: "update",
+				row: $(P.row)
+			}), yield* g(P.terminalEvent), yield* _(b, "succeeded", E);
+		}))), yield* v(b, "succeeded", E), yield* S.sync(() => s.recordRun?.({
+			name: s.name,
+			status: "succeeded",
+			durationMs: Date.now() - C,
+			completedAtSec: Date.now() / 1e3
+		})), ge) : ge;
+	});
+};
+//#endregion
+export { Hn as $, Ke as $t, Wr as A, zt as At, nr as B, vt as Bt, ri as C, Qt as Ct, Yr as D, Kt as Dt, Jr as E, Pt as Et, Lr as F, en as Ft, qn as G, B as Gt, rr as H, xt as Ht, Ir as I, At as It, Wn as J, it as Jt, Jn as K, Ct as Kt, Sr as L, Dt as Lt, Pr as M, Y as Mt, Br as N, Wt as Nt, Xr as O, Vt as Ot, zr as P, Rt as Pt, Un as Q, Le as Qt, jr as R, kt as Rt, pi as S, tn as St, ei as T, Lt as Tt, dr as U, pt as Ut, ir as V, St as Vt, Kn as W, bt as Wt, tr as X, z as Xt, Zn as Y, ot as Yt, Qn as Z, Ye as Zt, si as _, Ce as _n, $t as _t, Ni as a, R as an, Mn as at, vi as b, be as bn, Xt as bt, Bi as c, Me as cn, hn as ct, Si as d, Ee as dn, ln as dt, Ve as en, Bn as et, Z as f, Ne as fn, W as ft, ci as g, we as gn, qt as gt, li as h, ke as hn, U as ht, Pi as i, ze as in, Fn as it, Hr as j, It as jt, Zr as k, nn as kt, Oi as l, De as ln, vn as lt, fi as m, Ae as mn, jt as mt, Mi as n, We as nn, zn as nt, $ as o, Ie as on, Nn as ot, di as p, je as pn, Nt as pt, Gn as q, ht as qt, Ri as r, Be as rn, Pn as rt, Li as s, Te as sn, yn as st, ji as t, Ge as tn, Ln as tt, Di as u, Oe as un, pn as ut, oi as v, Se as vn, Jt as vt, ii as w, Ht as wt, _i as x, Gt as xt, yi as y, xe as yn, Yt as yt, wr as z, Ot as zt };