@voltro/workflow 0.80.0 → 0.82.0

package/dist/src-BAN5Xovf.js

@@ -0,0 +1,3860 @@
+import { E as e, F as t, L as n, M as r, N as i, P as a, R as o, T as s, w as c } from "./primitives-Btjhjm8P.js";
+import { S as l, T as u, _ as d, a as f, b as p, g as m, h, i as g, l as _, n as v, u as y, v as ee, x as b } from "./journalEncryption--n5VDdYO.js";
+import { $ as x, A as te, At as ne, Bt as re, C as ie, Ct as S, D as C, Dt as w, E as T, F as ae, Gt as oe, H as se, I as E, It as D, J as ce, L as O, Mt as k, N as A, Nt as le, O as ue, Ot as de, Pt as fe, Q as j, S as pe, St as me, T as he, Tt as ge, U as _e, V as ve, Vt as ye, Wt as be, Z as xe, _t as Se, at as Ce, dt as we, gt as Te, h as Ee, ht as De, i as Oe, it as ke, jt as Ae, k as je, kt as Me, mt as Ne, ot as Pe, q as Fe, rt as M, st as Ie, tt as Le, ut as N, v as Re, vt as ze, w as Be, wt as Ve, xt as He, y as Ue, yt as We } from "./clusterDiagnostics-Dc7yBP3b.js";
+import { DurableClock as Ge, DurableDeferred as Ke, Workflow as qe, WorkflowEngine as Je } from "@effect/workflow";
+import { Cause as P, Effect as F, Either as I, Exit as Ye, Fiber as Xe, FiberRef as Ze, Layer as Qe, Schema as L } from "effect";
+import { WorkflowQueuedCancellationResultSchema as $e, publishServerError as et } from "@voltro/protocol";
+import { and as R, boolean as tt, derivedRowId as nt, eq as z, generateId as rt, gt as B, gte as it, id as V, inSet as at, integer as H, isNotNull as ot, isNull as U, json as W, lt as st, or as ct, queryFor as lt, real as ut, reference as dt, registerRetention as ft, retentionTtlMsFromEnv as pt, table as G, text as K, timestamp as q } from "@voltro/database";
+import { createHash as mt, randomUUID as ht } from "node:crypto";
+import { WorkflowInstance as J } from "@effect/workflow/WorkflowEngine";
+//#region src/inMemoryLayer.ts
+var gt = Je.layerMemory, _t = G("_voltro_workflow_runs", {
+	id: V({ prefix: "wfrun" }),
+	tag: K(),
+	executionId: K().unique(),
+	status: K().oneOf([
+		"running",
+		"succeeded",
+		"failed",
+		"cancelled",
+		"suspended"
+	]).default("running"),
+	payload: W(),
+	workflowVersion: K().nullable(),
+	workflowPatches: W().nullable(),
+	runnerEnteredAt: q().nullable(),
+	runnerGeneration: K().nullable(),
+	engineDelivery: W().nullable(),
+	reclaimCount: H().default(0),
+	output: W().nullable(),
+	subject: W().nullable(),
+	source: K().nullable(),
+	errorTag: K().nullable(),
+	errorMessage: K().nullable(),
+	cancelled: tt().default(!1),
+	discardedAt: q().nullable(),
+	discardedBy: K().nullable(),
+	startedAt: q().default("now"),
+	completedAt: q().nullable(),
+	durationMs: H().nullable(),
+	traceId: K().nullable(),
+	parentExecutionId: K().nullable(),
+	parentGeneration: K().nullable(),
+	parentClosePolicy: K().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable()
+}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), vt = G("_voltro_workflow_run_steps", {
+	id: V({ prefix: "wfstep" }),
+	runId: dt(() => _t, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	stepName: K(),
+	attempt: H().default(1),
+	status: K().oneOf([
+		"running",
+		"succeeded",
+		"failed"
+	]).default("running"),
+	input: W().nullable(),
+	retryPolicy: W().nullable(),
+	output: W().nullable(),
+	errorTag: K().nullable(),
+	errorMessage: K().nullable(),
+	errorCause: W().nullable(),
+	startedAt: q().default("now"),
+	completedAt: q().nullable(),
+	durationMs: H().nullable()
+}).index(["runId", "stepName"]).index(["startedAt"]), yt = G("_voltro_workflow_run_events", {
+	id: V({ prefix: "wfev" }),
+	runId: dt(() => _t, {
+		index: !1,
+		onDelete: "cascade"
+	}),
+	eventType: K(),
+	payload: W().nullable(),
+	occurredAt: q().default("now"),
+	stepName: K().nullable(),
+	attempt: H().nullable()
+}).index(["runId", "occurredAt"]).index(["eventType"]), bt = G("_voltro_workflow_start_contexts", {
+	id: V({ prefix: "wfctx" }),
+	workflowName: K(),
+	executionId: K().unique(),
+	subject: W().nullable(),
+	traceId: K().nullable(),
+	source: K().nullable(),
+	parentExecutionId: K().nullable(),
+	parentGeneration: K().nullable(),
+	parentClosePolicy: K().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable(),
+	createdAt: q().default("now")
+}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), xt = G("_voltro_workflow_admission_locks", {
+	id: V({ prefix: "wfalk" }),
+	nonce: K()
+}).nonReactive(), St = G("_voltro_workflow_parent_closures", {
+	id: V({ prefix: "wfpc" }),
+	runId: K(),
+	workflowName: K(),
+	executionId: K(),
+	generation: K(),
+	parentStatus: K().oneOf([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	closedAt: q(),
+	afterChildId: K().nullable(),
+	scanHasOpenChildren: tt().default(!1),
+	completedAt: q().nullable()
+}).index(["executionId"]).index(["completedAt", "id"]).nonReactive(), Ct = G("_voltro_workflow_control_requests", {
+	id: V({ prefix: "wfctl" }),
+	runId: K(),
+	workflowName: K(),
+	executionId: K(),
+	generation: K(),
+	operation: K().oneOf([
+		"cancel",
+		"terminate",
+		"resume"
+	]),
+	requestedAt: q(),
+	owner: W().nullable(),
+	cause: W().nullable(),
+	parentClosureId: K().nullable(),
+	resumeJournal: W().nullable(),
+	dispatchAttempts: H().default(0),
+	result: W().nullable()
+}).index(["runId"]).index(["parentClosureId", "id"]).nonReactive(), wt = G("_voltro_workflow_failure_reports", {
+	id: V({ prefix: "wffr" }),
+	workflowName: K(),
+	tenantId: K().nullable(),
+	sourceId: K(),
+	sourceKind: K().oneOf([
+		"submission",
+		"intent",
+		"run"
+	]),
+	handler: K().nullable(),
+	callerContext: W().nullable(),
+	report: W(),
+	handoffReceiptId: K().nullable(),
+	handoffAttempt: H().default(0),
+	acceptedExecutionId: K().nullable()
+}).index(["sourceKind", "sourceId"]).nonReactive(), Tt = G("_voltro_workflow_submissions", {
+	id: V({ prefix: "wfsub" }),
+	workflowName: K(),
+	tenantId: K().nullable(),
+	ledgerId: K(),
+	executionId: K().nullable(),
+	runId: K().nullable(),
+	receiptsBound: tt().default(!1),
+	preparedExecutionId: K().nullable(),
+	dispatchAttempts: H().default(0),
+	failureId: K().nullable(),
+	retry: W(),
+	payload: W(),
+	callerContext: W().nullable(),
+	intentIds: W(),
+	eviction: W().nullable()
+}).nonReactive(), Et = G("_voltro_workflow_start_receipts", {
+	id: V({ prefix: "wfrc" }),
+	workflowName: K(),
+	tenantId: K().nullable(),
+	pendingId: K().maxLength(64),
+	submissionId: K().maxLength(64).nullable(),
+	terminal: W().nullable()
+}).index(["pendingId"]).nonReactive(), Dt = G("_voltro_workflow_pending", {
+	id: V({ prefix: "wfp" }),
+	tenantId: K().nullable(),
+	workflowName: K(),
+	controlKey: K(),
+	mode: K().oneOf([
+		"debounce",
+		"batch",
+		"throttle",
+		"concurrency",
+		"paused",
+		"delayed"
+	]),
+	payload: W(),
+	callerContext: W().nullable(),
+	queuedAppVersion: K().nullable(),
+	queuedSchemaFingerprint: K().nullable(),
+	priority: H().default(0),
+	dueAt: q(),
+	deadlineAt: q().nullable(),
+	collapsed: H().default(1),
+	firstSeenAt: q().default("now"),
+	updatedAt: q().default("now"),
+	attempts: H().default(0),
+	lastError: K().nullable(),
+	deadLetteredAt: q().nullable()
+}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), Ot = G("_voltro_workflow_admissions", {
+	id: V({ prefix: "wfadm" }),
+	tenantId: K().nullable(),
+	workflowName: K(),
+	outcome: K().oneOf([
+		"admitted",
+		"dropped",
+		"skipped",
+		"evicted",
+		"expired",
+		"discarded"
+	]),
+	mode: K().nullable(),
+	reason: K().nullable(),
+	collapsed: H().default(1),
+	waitedMs: ut().nullable().narrowedFrom("integer"),
+	executionId: K().nullable(),
+	runId: K().nullable(),
+	singletonKey: K().nullable(),
+	concurrencyKey: K().nullable(),
+	concurrencyReservation: W().nullable(),
+	rateKey: K().nullable(),
+	admittedAt: q().default("now"),
+	expiresAt: q().nullable(),
+	releasedAt: q().nullable()
+}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), kt = G("_voltro_workflow_pauses", {
+	id: V({ prefix: "wfpause" }),
+	pausedAt: q().default("now"),
+	pausedBy: K().nullable(),
+	reason: K().nullable()
+}), At = 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 Ie(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 S(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: A,
+		predicate: z("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 = M(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 N(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
+	};
+}, jt = "_voltro_workflow_parent_closures", Y = L.NonEmptyString, Mt = L.Struct({
+	id: Y,
+	runId: Y,
+	workflowName: Y,
+	executionId: Y,
+	generation: Y,
+	parentStatus: L.Literal("succeeded", "failed", "cancelled"),
+	closedAt: L.DateFromSelf,
+	afterChildId: L.NullOr(Y),
+	scanHasOpenChildren: L.Boolean,
+	completedAt: L.NullOr(L.DateFromSelf)
+}), Nt = L.Struct({
+	id: Y,
+	tag: Y,
+	executionId: Y,
+	status: L.Literal("running", "suspended", "succeeded", "failed", "cancelled"),
+	runnerGeneration: L.optional(L.NullOr(Y)),
+	parentGeneration: L.optional(L.NullOr(Y)),
+	parentClosePolicy: L.NullOr(L.Literal("cancel", "terminate", "abandon"))
+}), Pt = 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: jt,
+		predicate: R(z("executionId", t.parentExecutionId), z("generation", t.parentGeneration)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (r === void 0) return !1;
+	let i = L.decodeUnknownSync(Mt)(r);
+	if (i.executionId !== t.parentExecutionId || i.generation !== t.parentGeneration) return !1;
+	let a = L.decodeUnknownSync(Nt)(t), o = nt("wfctl", JSON.stringify([
+		"parent-close",
+		i.id,
+		a.id
+	])), s = await C(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 Ue(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;
+}, Ft = async (e, t, n = Date.now()) => {
+	let [r] = await e.query({
+		table: jt,
+		predicate: z("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 = L.decodeUnknownSync(Mt)(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: R(z("parentExecutionId", i.executionId), ...i.afterChildId === null ? [] : [B("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 = L.decodeUnknownSync(Nt)(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 Pt(e, t, i) && (o++, r.status === "suspended" && typeof r.runnerGeneration == "string" && await Vt(e, {
+				runId: r.id,
+				workflowName: r.tag,
+				executionId: r.executionId,
+				generation: r.runnerGeneration
+			}, n)));
+		}
+	}
+	let l = a.length < 100, u = l && !s && !await Be(e, i.id);
+	if (await e.update(jt, i.id, {
+		afterChildId: l ? null : c,
+		scanHasOpenChildren: !l && s,
+		completedAt: u ? new Date(n) : null
+	}) === null) throw Error("Parent closure disappeared before saving its cursor");
+	return {
+		scanned: a.length,
+		controls: o,
+		wrapped: l
+	};
+}, X = "_voltro_workflow_runs", It = L.NullOr(L.Struct({
+	requestId: L.NonEmptyString,
+	restartToken: L.NullOr(L.NonEmptyString)
+})), Lt = 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 nn(e, i), o = await Pt(e, t);
+	if (!a && !o) return;
+	let s = await Ut(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
+	};
+}, Rt = async (e, t) => {
+	let n = await Oe(e, t);
+	return {
+		...await Lt(e, n.row, t, n.previous) ?? {
+			kind: "entered",
+			row: n.row,
+			previous: n.previous
+		},
+		restartEvent: n.event
+	};
+}, zt = 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: X,
+		predicate: z("executionId", t.executionId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0], r = L.decodeUnknownSync(It)(t.delivery ?? null), i = (r) => Lt(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: z("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(X, {
+			...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 = L.decodeUnknownSync(It)(n.engineDelivery ?? null);
+	if (a?.requestId !== r?.requestId || a?.restartToken !== r?.restartToken) {
+		if (n.status === "failed" && r !== null && r.restartToken !== null && a?.requestId === r.requestId) return Rt(e, {
+			runId: n.id,
+			workflowName: t.workflowName,
+			executionId: t.executionId,
+			generation: t.generation,
+			delivery: r,
+			now: t.now
+		});
+		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 ie(e, r)) {
+			let i = await Ut(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(X, 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 je(e, {
+		runId: n.id,
+		workflowName: t.workflowName,
+		executionId: t.executionId,
+		generation: n.runnerGeneration
+	}, t.generation, t.now), {
+		kind: "entered",
+		row: l,
+		previous: n
+	}) : u;
+}, Bt = 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: X,
+		predicate: z("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;
+}, Vt = async (e, t, n) => {
+	let r = await Bt(e, t);
+	if (r.runnerGeneration !== t.generation || r.status !== "suspended" || r.runnerEnteredAt !== null || !await ie(e, t)) return !1;
+	if ((await Ut(e, {
+		owner: t,
+		now: n,
+		durationMs: 0,
+		outcome: { status: "cancelled" }
+	}, "suspended")).kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
+	return !0;
+}, Ht = async (e, t, n) => {
+	let r = await Bt(e, t);
+	if (r.runnerGeneration !== t.generation) return { kind: "superseded" };
+	if (r.status !== "running") return { kind: "not-running" };
+	let i = await e.update(X, 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
+	};
+}, Ut = async (e, t, n) => {
+	let r = await Bt(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;
+	if (i.status === "failed" && (a = `wffr_${mt("sha256").update(JSON.stringify([
+		"run",
+		t.owner.workflowName,
+		t.owner.runId,
+		t.owner.generation
+	])).digest("hex").slice(0, 40)}`, await D(e, {
+		id: a,
+		sourceKind: "run",
+		sourceId: t.owner.runId,
+		workflowName: t.owner.workflowName,
+		tenantId: i.tenantId,
+		handler: await Ae(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 ne(e, a, t.now)), i.status === "cancelled") {
+		let n = (await T((t) => e.query({
+			...t,
+			lock: "update"
+		}), t.owner)).map((e) => ({
+			request: e,
+			cause: pe(e)
+		})).find((e) => e.cause !== void 0);
+		if (n !== void 0 && n.cause !== void 0) {
+			let i = L.decodeUnknownOption(L.Struct({ tenantId: L.NullOr(L.String) }))(r.subject), o = n.request.owner?.tenantId ?? (i._tag === "Some" ? i.value.tenantId : null);
+			a = `wffr_${mt("sha256").update(JSON.stringify([
+				"finish-timeout",
+				t.owner.workflowName,
+				t.owner.runId,
+				t.owner.generation
+			])).digest("hex").slice(0, 40)}`, await D(e, {
+				id: a,
+				sourceKind: "run",
+				sourceId: t.owner.runId,
+				workflowName: t.owner.workflowName,
+				tenantId: o,
+				handler: await Ae(e, t.owner.executionId, t.owner.workflowName, o) ? null : n.cause.detail.onFailure,
+				callerContext: {
+					subject: r.subject ?? null,
+					traceId: r.traceId ?? null,
+					source: r.source ?? null,
+					parentExecutionId: r.parentExecutionId ?? null,
+					parentGeneration: r.parentGeneration ?? null,
+					parentClosePolicy: r.parentClosePolicy ?? null
+				},
+				report: {
+					workflow: t.owner.workflowName,
+					payload: r.payload,
+					errorTag: null,
+					errorMessage: null,
+					runId: t.owner.runId,
+					executionId: t.owner.executionId,
+					reason: n.cause.reason,
+					failedAt: t.now
+				}
+			}), await ne(e, a, t.now);
+		}
+	}
+	let o = await e.update(X, t.owner.runId, {
+		status: i.status,
+		completedAt: new Date(t.now),
+		durationMs: t.durationMs,
+		cancelled: i.status === "cancelled",
+		runnerEnteredAt: null,
+		output: i.status === "succeeded" ? _(t.owner.workflowName) ? l(i.output, `workflow '${t.owner.workflowName}' result`) : i.output : null,
+		errorTag: i.status === "failed" ? i.errorTag : null,
+		errorMessage: i.status === "failed" ? p(t.owner.workflowName, i.errorMessage) : null
+	});
+	if (o === null) throw Error("Workflow run disappeared during terminal recording");
+	await e.insert("_voltro_workflow_parent_closures", {
+		id: nt("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: nt("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: p(t.owner.workflowName, i.errorMessage)
+			} : {}
+		}
+	});
+	await ue(e, t), await x(e, t.owner.executionId, t.now);
+	for await (let n of Se(e, t.owner.executionId, t.owner.workflowName)) {
+		let [r] = await e.query({
+			table: te,
+			predicate: z("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
+	};
+}, Wt = (e, t) => Ut(e, t, "running"), Gt = G("_voltro_workflow_queued_cancellations", {
+	id: V({ prefix: "wfqc" }),
+	receiptId: K(),
+	workflowName: K(),
+	tenantId: K().nullable(),
+	requestedAt: q(),
+	cause: W().nullable(),
+	target: W(),
+	controlBinding: W().nullable()
+}).index(["receiptId"]).index(["workflowName", "id"]).nonReactive(), Kt = L.NullOr(L.Struct({
+	reason: L.NonEmptyString,
+	detail: L.optional(L.Record({
+		key: L.String,
+		value: L.Unknown
+	}))
+})), qt = L.Struct({
+	id: L.NonEmptyString,
+	receiptId: L.NonEmptyString,
+	workflowName: L.NonEmptyString,
+	tenantId: L.NullOr(L.String),
+	requestedAt: L.DateFromSelf,
+	cause: Kt,
+	controlBinding: L.NullOr(L.Struct({
+		controlId: L.NonEmptyString,
+		runId: L.NonEmptyString,
+		executionId: L.NonEmptyString,
+		generation: L.NonEmptyString
+	})),
+	target: L.Union(L.Struct({
+		kind: L.Literal("submission"),
+		submissionId: L.NonEmptyString
+	}), L.Struct({
+		kind: L.Literal("terminal"),
+		receipt: L.Unknown
+	}))
+}), Jt = (e) => {
+	let t = L.decodeUnknownSync(qt)(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 = Pe(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
+		}
+	};
+}, Yt = async (e, t) => {
+	let [n] = await e.query({
+		table: Gt.tableName,
+		predicate: z("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n === void 0 ? void 0 : Jt(n);
+}, Xt = async (e, t) => {
+	let n = t.controlBinding;
+	if (n === null) throw Error("Queued cancellation has no control binding");
+	let r = await C(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;
+}, Zt = async (e, t, n) => {
+	if (t.controlBinding === null) return;
+	let r = await Xt(e, t);
+	if (r.result !== null) return;
+	let [i] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: z("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	i !== void 0 && await Vt(e, {
+		runId: r.runId,
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		generation: r.generation
+	}, n);
+}, Qt = async (e, t) => {
+	let n = await Yt(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 Xt(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: z("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 S(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 we(e, r)
+		}
+	};
+}, $t = (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 = L.decodeUnknownSync($e);
+	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" }
+	});
+}, en = async (e, t) => {
+	let n = L.decodeUnknownSync(L.Struct({
+		id: L.NonEmptyString,
+		receiptId: L.NonEmptyString,
+		workflowName: L.NonEmptyString,
+		tenantId: L.NullOr(L.String),
+		requestedAt: L.DateFromSelf,
+		cause: Kt
+	}))({
+		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 Yt(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 Zt(e, r, t.now), r;
+	}
+	let i = await At(e, t), a;
+	if (i.kind === "submitted") a = {
+		kind: "submission",
+		submissionId: i.submissionId
+	};
+	else {
+		let n = await Ie(e, t.receiptId);
+		if (n === void 0) throw Error("Cancelled start receipt disappeared during request acceptance");
+		a = {
+			kind: "terminal",
+			receipt: n
+		};
+	}
+	let o = Jt({
+		...n,
+		target: a,
+		controlBinding: null
+	});
+	if (await e.insert(Gt.tableName, o), a.kind === "submission") {
+		let n = await S(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: z("executionId", n.preparedExecutionId),
+				lock: "update",
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (r !== void 0) {
+				let n = L.decodeUnknownSync(L.Struct({
+					id: L.NonEmptyString,
+					tag: L.NonEmptyString,
+					executionId: L.NonEmptyString,
+					runnerGeneration: L.NonEmptyString
+				}))(r), i = {
+					runId: n.id,
+					workflowName: n.tag,
+					executionId: n.executionId,
+					generation: n.runnerGeneration
+				}, a = await tn(e, o.id, i);
+				return await Zt(e, a.request, t.now), a.request;
+			}
+		}
+	}
+	return o;
+}, tn = async (e, t, n) => {
+	let r = await Yt(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 Xt(e, r)
+	};
+	let i = await S(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: z("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), o = L.decodeUnknownOption(L.Struct({ tenantId: L.NullOr(L.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: nt("wfctl", JSON.stringify(["queued-cancel", r.id])),
+		runId: n.runId,
+		executionId: n.executionId,
+		generation: n.generation
+	}, c = await Ue(e, {
+		id: s.controlId,
+		...n,
+		operation: "cancel",
+		requestedAt: r.requestedAt.getTime(),
+		cause: r.cause
+	});
+	if (await e.update(Gt.tableName, r.id, { controlBinding: s }) === null) throw Error("Queued cancellation request disappeared during run binding");
+	return {
+		kind: "bound",
+		request: {
+			...r,
+			controlBinding: s
+		},
+		control: c
+	};
+}, nn = async (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for await (let r of Se(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: Gt.tableName,
+			predicate: R(z("workflowName", t.workflowName), ...r === void 0 ? [] : [B("id", r)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let o of a) {
+			let a = Jt(o);
+			if (r = a.id, a.target.kind !== "submission" || !n.has(a.target.submissionId)) continue;
+			let s = await tn(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;
+	}
+}, rn = L.Struct({
+	requestId: L.NonEmptyString,
+	receiptId: L.NonEmptyString,
+	workflowName: L.NonEmptyString,
+	tenantId: L.NullOr(L.String)
+}), an = async (e, t) => {
+	let n = L.decodeUnknownSync(rn)(t);
+	return await en(e, {
+		...n,
+		now: t.now,
+		...t.cause === void 0 ? {} : { cause: t.cause }
+	}), on(e, n);
+}, on = async (e, t) => {
+	let n = L.decodeUnknownSync(rn)(t);
+	return $t(n, await Qt(e, n));
+}, sn = async (e, t) => {
+	if (new Set(t.intentIds).size !== t.intentIds.length) throw Error("Admitted transfer requires distinct pending identities");
+	let n = await S(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: A,
+			predicate: z("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 = M(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 He(e, t);
+	await Ce(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
+	};
+}, cn = async (e, t) => oe(e, (e) => ln(e, t)), ln = 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 S(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: A,
+			predicate: z("id", n),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0,
+			lock: "update"
+		});
+		if (i[0] === void 0) return { kind: "selection-unavailable" };
+		let a = M(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 w(e, {
+		...i,
+		id: t.id,
+		tenantId: t.tenantId,
+		intentIds: t.intentIds,
+		now: t.now
+	});
+	if (a.kind !== "reserved") return a;
+	await Ce(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
+		}
+	};
+}, un = async (e) => {
+	let { store: t, control: n, now: r } = e, i = be(n, e.payload), a = await se({
+		store: t,
+		control: n,
+		keys: i,
+		paused: e.paused,
+		now: r,
+		reconsidering: !1
+	});
+	if (a.kind === "drop") return await j({
+		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 j({
+		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 ce({
+			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 dn(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 j({
+			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
+		} }
+	};
+}, dn = async (e, t, n, r) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: R(z("workflowName", t), z("controlKey", n), z("mode", "batch")),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0
+})).map((n) => ({
+	id: String(n.id),
+	payload: E(e, t, n.payload)
+})), fn = async (e, t, n, r) => {
+	await e.update("_voltro_workflow_admissions", t, {
+		executionId: n,
+		runId: r
+	});
+}, pn = G("_voltro_workflow_watermarks", {
+	id: V({ prefix: "wfwm" }),
+	positionAt: q(),
+	updatedAt: q().default("now")
+}), mn = (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) => I.right(e) : (t) => {
+		let n = L.decodeUnknownEither(e.payloadSchema)(t);
+		return I.isRight(n) ? I.right(n.right) : I.left(mn(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 = L.decodeUnknownEither(o.schema)(l.payload);
+		if (I.isLeft(u)) {
+			r.push({
+				kind: "event-decode",
+				workflowName: e.workflowName,
+				event: o.event,
+				subject: l.id,
+				detail: mn(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 (I.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: mn(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
+	};
+}, gn = (e) => {
+	let t;
+	for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
+	return t;
+}, _n = "_voltro_workflow_watermarks", vn = "_voltro_workflow_events", yn = "cancelOn", bn = 36e5, xn = 500, Sn = (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;
+	}
+}, Cn = (e) => e instanceof Error ? e.message : String(e), wn = async (e, t) => Sn((await e.query({
+	table: _n,
+	predicate: z("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0]?.positionAt), Tn = async (e, t, n) => {
+	await e.upsert(_n, {
+		id: t,
+		positionAt: n,
+		updatedAt: /* @__PURE__ */ new Date()
+	}, {
+		conflictColumns: ["id"],
+		update: (e) => {
+			let t = Sn(e.positionAt);
+			return t !== void 0 && t.getTime() >= n.getTime() ? {
+				positionAt: t,
+				updatedAt: /* @__PURE__ */ new Date()
+			} : {
+				positionAt: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+		}
+	});
+}, En = async (e, t, n) => {
+	let r = async (r) => e.query({
+		table: "_voltro_workflow_runs",
+		predicate: R(z("tag", t), z("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 = Sn(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
+		}];
+	});
+}, Dn = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_pending",
+	predicate: z("workflowName", t),
+	order: [{
+		column: "firstSeenAt",
+		direction: "asc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = Sn(t.firstSeenAt);
+	return typeof t.id != "string" || n === void 0 ? [] : [{
+		intentId: t.id,
+		payload: t.payload,
+		firstSeenAt: n
+	}];
+}), On = 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 wn(e.store, yn), c = s ?? new Date(r - a);
+	s === void 0 && (await Tn(e.store, yn, c), s = c);
+	let l = await e.store.query({
+		table: vn,
+		predicate: it("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 = Sn(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 En(e.store, t.workflowName, _), i = await Dn(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
+		} catch (e) {
+			f.push({
+				subject: t.workflowName,
+				detail: Cn(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: Cn(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: Cn(e)
+			}), g = !0;
+		}
+	}
+	let v = gn(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 Tn(e.store, yn, v), y = v;
+	} catch (e) {
+		f.push({
+			subject: yn,
+			detail: Cn(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
+	};
+}, kn = 18e5, An = 200, jn = 20, Mn = (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;
+	}
+}, Nn = (e) => e instanceof Error ? e.message : String(e), Pn = async (e, t, n) => (await e.query({
+	table: "_voltro_workflow_run_events",
+	predicate: z("runId", t),
+	order: [{
+		column: "occurredAt",
+		direction: "desc"
+	}],
+	take: n,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = Mn(t.occurredAt);
+	return typeof t.eventType != "string" || n === void 0 ? [] : [{
+		eventType: t.eventType,
+		occurredAt: n,
+		payload: t.payload
+	}];
+}), Fn = async (e, t) => {
+	let n = (await e.query({
+		table: "_voltro_workflow_run_steps",
+		predicate: z("runId", t),
+		order: [{
+			column: "startedAt",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (n === void 0) return;
+	let r = Mn(n.startedAt), i = Mn(n.completedAt);
+	return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
+}, In = (e, t) => {
+	for (let n of e) {
+		if (n.eventType === "timer-fired") return !1;
+		if (n.eventType !== "timer-set") continue;
+		let e = Mn(n.payload?.scheduledWakeAt);
+		return e !== void 0 && e.getTime() > t;
+	}
+	return !1;
+}, Ln = (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";
+}, Rn = 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: R(at("status", ["running", "suspended"]), st("startedAt", o), ...n === void 0 ? [] : [ct(B("startedAt", n.startedAt), R(z("startedAt", n.startedAt), B("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 = Mn(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: Nn(e)
+			}]
+		};
+	}
+	for (let t of d) {
+		let i = t, o = Mn(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 Pn(e.store, i.id, a), f = await Fn(e.store, i.id);
+		} catch (e) {
+			s.push({
+				subject: i.id,
+				detail: Nn(e)
+			});
+			continue;
+		}
+		if (In(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: Ln(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: Nn(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: Nn(e)
+			});
+		}
+		if (e.onStalled !== void 0) try {
+			await e.onStalled(g);
+		} catch (e) {
+			s.push({
+				subject: `${g.runId}:onStalled`,
+				detail: Nn(e)
+			});
+		}
+	}
+	return {
+		examined: d.length,
+		stalled: c,
+		alreadyReported: l,
+		waitingOnTimer: u,
+		sawFullRunPage: d.length >= i,
+		failures: s,
+		...f === void 0 ? {} : { nextRun: f }
+	};
+}, zn = async (e, t, n) => {
+	let r = await e.transaction((e) => S(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) => me(e, t.id, i));
+	if (a.preparedExecutionId === null) throw Error("Submission preparation returned no execution identity");
+	return a.preparedExecutionId;
+}, Bn = /* @__PURE__ */ new WeakMap(), Vn = async (e, t, n, r) => {
+	let i = Bn.get(e), a = await Ve(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 = Te(n);
+		} catch {
+			o++, c++, d(t + Le(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 de(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 ? E(e.store, i.workflowName, i.payload) : { items: L.decodeUnknownSync(L.Struct({ items: L.Array(L.Unknown) }))(i.payload).items.map((t) => E(e.store, i.workflowName, t)) }, r = await zn(e, i, n), o = await e.transaction((e) => De(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 x(e.store, i.eviction.executionId, t)), await e.transaction((e) => Ne(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) => ge(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) => We(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: y(i.workflowName, 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: y(i.workflowName, n),
+				retryStoppedAt: o.retry.stoppedAt,
+				acceptance: "unknown"
+			});
+		}
+	}
+	let f = a.at(-1);
+	return a.length === n && f !== void 0 && typeof f.id == "string" ? (Bn.set(e, {
+		afterId: f.id,
+		nextDueAt: u
+	}), {
+		scanned: o,
+		admitted: s,
+		failed: c,
+		rejected: l,
+		nextDueAt: t,
+		examined: !0
+	}) : (Bn.delete(e), {
+		scanned: o,
+		admitted: s,
+		failed: c,
+		rejected: l,
+		nextDueAt: u,
+		examined: a.length > 0
+	});
+}, Hn = /* @__PURE__ */ new WeakMap(), Un = async (e, t, n) => {
+	let r = Hn.get(e), i = await e.store.query({
+		table: fe,
+		predicate: R(ot("handler"), U("acceptedExecutionId"), ...r === void 0 ? [] : [B("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 + Le(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) => le(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 Me ? { reason: t.reason } : {}
+		});
+	}
+	let l = i.at(-1);
+	return i.length === n && l !== void 0 && typeof l.id == "string" ? (Hn.set(e, {
+		afterId: l.id,
+		nextDueAt: s
+	}), {
+		scanned: i.length,
+		failed: a,
+		hasPending: o,
+		nextDueAt: t,
+		examined: !0
+	}) : (Hn.delete(e), {
+		scanned: i.length,
+		failed: a,
+		hasPending: o,
+		nextDueAt: s,
+		examined: i.length > 0
+	});
+}, Wn = "_voltro_workflow_parent_closures", Gn = /* @__PURE__ */ new WeakMap(), Kn = async (e, t, n) => {
+	let r = Gn.get(e), i = await e.store.query({
+		table: Wn,
+		predicate: R(U("completedAt"), ...r === void 0 ? [] : [B("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 Ft(e, r, t);
+			let [n] = await e.query({
+				table: Wn,
+				predicate: z("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" ? (Gn.set(e, {
+		afterId: c.id,
+		nextDueAt: o
+	}), {
+		scanned: i.length,
+		failed: a,
+		nextDueAt: t,
+		examined: !0
+	}) : (Gn.delete(e), {
+		scanned: i.length,
+		failed: a,
+		nextDueAt: o,
+		examined: i.length > 0
+	});
+}, qn = async (e, t) => {
+	if (t.from === t.to) throw Error("Queue transfer requires distinct source and target");
+	let n = await e.query({
+		table: A,
+		predicate: z("id", t.to),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), r = L.decodeUnknownSync(L.Struct({
+		workflowName: L.String,
+		tenantId: L.NullOr(L.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: ke,
+			predicate: R(z("pendingId", t.from), U("submissionId"), U("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 = Pe(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");
+		}
+	}
+}, Jn = {
+	scanned: 0,
+	admitted: 0,
+	deferred: 0,
+	dropped: 0,
+	skipped: 0,
+	expired: 0,
+	evicted: 0,
+	failed: 0,
+	deadLettered: 0,
+	timedOut: 0,
+	examined: !1
+}, Yn = 200, Xn = 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;
+	}
+}, Zn = (e) => e instanceof Xn && !e.rejected, Qn = 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 Vn(e, n(), i, e.deadLetterAfterAttempts ?? 50), l = await Un(e, n(), i), u = await Kn(e, n(), i), a = await (e.readPauses?.() ?? xe(e.store));
+		let r = t.skipPending === !0 && !l.hasPending ? {
+			due: [],
+			nextDueAt: void 0
+		} : await Fe(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) }), {
+			...Jn,
+			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(), m = [];
+	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;
+		}
+		m.push(e);
+	}
+	let h = e.deadLetterAfterAttempts === void 0 ? 50 : e.deadLetterAfterAttempts, g = (t, n, r) => {
+		if (e.isPermanentStartError?.(n) === !0) return `pending ${r} was dead-lettered after a permanent start failure: ${String(n)}`;
+		if (h !== !1 && t.attempts + 1 >= h) return `pending ${r} was dead-lettered after ${t.attempts + 1} failed attempts: ${String(n)}`;
+	};
+	for (let t of m) try {
+		await nr(e, t, a, d, n());
+	} catch (i) {
+		if (d.failed++, i instanceof Xn) {
+			i.rejected && d.deadLettered++, r?.warn?.(i.message, {
+				submissionId: i.submissionId,
+				cause: y(t.workflowName, i.cause)
+			});
+			continue;
+		}
+		let a = g(t, i, "intent");
+		if (a !== void 0) {
+			let o = n(), s = String(i);
+			if (await er(e, [t], a, s, o, !1).catch((e) => (r?.warn?.("workflow flow control: intent could not be dead-lettered with its report", {
+				workflow: t.workflowName,
+				intent: t.id,
+				cause: String(e)
+			}), 0)) > 0) {
+				d.deadLettered++, r?.warn?.("workflow flow control: intent dead-lettered", {
+					workflow: t.workflowName,
+					intent: t.id,
+					cause: y(t.workflowName, s)
+				});
+				continue;
+			}
+		}
+		r?.warn?.("workflow flow control: an intent failed to drain", {
+			workflow: t.workflowName,
+			intent: t.id,
+			cause: y(t.workflowName, i)
+		}), await _e(e.store, t, String(i), n()).catch(() => {});
+	}
+	for (let t of f.values()) try {
+		await ir(e, t, a, d, n());
+	} catch (i) {
+		if (d.failed++, i instanceof Xn) {
+			i.rejected && d.deadLettered++, r?.warn?.(i.message, {
+				submissionId: i.submissionId,
+				cause: y(t[0]?.workflowName, i.cause)
+			});
+			continue;
+		}
+		let a = t[0], o = a === void 0 ? void 0 : g(a, i, "batch");
+		if (a !== void 0 && o !== void 0) {
+			let s = n(), c = String(i);
+			if (await er(e, t, o, c, s, !0).catch((e) => (r?.warn?.("workflow flow control: batch could not be dead-lettered with its report", {
+				workflow: a.workflowName,
+				intents: t.map((e) => e.id),
+				size: t.length,
+				cause: String(e)
+			}), 0)) === t.length) {
+				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: y(a.workflowName, c)
+				});
+				continue;
+			}
+		}
+		r?.warn?.("workflow flow control: a batch failed to drain", {
+			workflow: a?.workflowName,
+			size: t.length,
+			cause: y(a?.workflowName, 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: A,
+					predicate: z("id", r.id),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				if (t[0] === void 0) return;
+				let i = M(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 + Le(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: p(t.workflowName, 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 _ = await cr(e, n()).catch(() => ({ cancelled: 0 }));
+	return d.timedOut = _.cancelled, _.nextDeadlineAt !== void 0 && (s === void 0 || _.nextDeadlineAt < s) && (s = _.nextDeadlineAt), {
+		...d,
+		examined: t.skipPending !== !0 || c.examined || l.examined || u.examined,
+		...s === void 0 ? {} : { nextDueAt: s }
+	};
+}, $n = async (e, t, n) => {
+	let r = t.map((e) => ({
+		intent: e,
+		failureId: `wff_${ht()}`
+	}));
+	return e.transaction(async (e) => {
+		let t = 0;
+		for (let { intent: i, failureId: a } of r) {
+			let r = (await e.query({
+				table: A,
+				predicate: z("id", i.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			}))[0];
+			if (r === void 0) continue;
+			let o = M(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 D(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 N(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, a) => {
+	let o = `wff_${ht()}`;
+	return e.transaction(async (s) => {
+		let c = [];
+		for (let e of t) {
+			let t = await s.query({
+				table: A,
+				predicate: z("id", e.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			});
+			if (t[0] === void 0) return 0;
+			let n = M(t[0]);
+			if (n.workflowName !== e.workflowName || n.tenantId !== e.tenantId) throw Error("Dead-letter selection belongs to another workflow or tenant");
+			if (n.deadLetteredAt !== void 0) return 0;
+			c.push(n);
+		}
+		let l = c[0];
+		if (l === void 0) return 0;
+		let u = await Promise.all(c.map((e) => k(s, e.id)));
+		if (u.some(Boolean) && !u.every(Boolean)) throw Error("Dead-lettered batch mixes failure delivery and ordinary callers; reconciliation required");
+		let d = e.controls.get(l.workflowName);
+		await D(s, {
+			id: o,
+			sourceKind: "intent",
+			sourceId: l.id,
+			workflowName: l.workflowName,
+			tenantId: l.tenantId,
+			handler: u.every(Boolean) ? null : d?.onFailure ?? null,
+			callerContext: l.callerContext,
+			report: {
+				workflow: l.workflowName,
+				payload: a ? { items: c.map((e) => e.payload) } : l.payload,
+				reason: n,
+				failedAt: i,
+				errorTag: null,
+				errorMessage: r.slice(0, 500),
+				runId: null,
+				executionId: null
+			}
+		});
+		for (let e of c) if (await N(s, {
+			pendingId: e.id,
+			workflowName: e.workflowName,
+			tenantId: e.tenantId,
+			terminal: {
+				kind: "abandoned",
+				at: i,
+				failureId: o
+			}
+		}), !await ae(s, e, r, i)) throw Error("Dead-lettered queue row disappeared before marking");
+		return await ne(s, o, i), c.length;
+	});
+}, tr = async (e, t, n, r, i) => {
+	let a = `wff_${ht()}`;
+	return e.transaction(async (e) => {
+		let o = [];
+		for (let i of t) {
+			let t = await e.query({
+				table: A,
+				predicate: z("id", i.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			});
+			if (t[0] === void 0) return 0;
+			let a = M(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 || !ye(n, s, r)) return 0;
+		let c = await Promise.all(o.map((t) => k(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 D(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 j({
+			store: e,
+			control: n,
+			keys: be(n, E(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 N(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 ne(e, a, r), o.length;
+	});
+}, nr = async (e, t, n, r, i) => {
+	if (t = {
+		...t,
+		payload: E(e.store, t.workflowName, t.payload)
+	}, t.mode === "delayed") return rr(e, t, n, r, i);
+	let a = e.controls.get(t.workflowName);
+	if (a === void 0) {
+		r.expired += await $n(e, [t], i);
+		return;
+	}
+	if (ye(a, t, i)) {
+		r.expired += await tr(e, [t], a, i, !1);
+		return;
+	}
+	let o = be(a, t.payload), s = await se({
+		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
+	});
+}, rr = async (e, t, n, r, i) => {
+	if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
+		r.expired += await $n(e, [t], i);
+		return;
+	}
+	let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = ze(), s = await e.transaction(async (e) => {
+		let r = await e.query({
+			table: A,
+			predicate: z("id", t.id),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r[0] === void 0) return;
+		let s = M(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 un({
+			store: e,
+			control: a,
+			payload: E(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 qn(e, {
+			from: s.id,
+			to: c.intentId,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId
+		}), !await O(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 ? ve(e, s.workflowName, c.payload) : { items: L.decodeUnknownSync(L.Struct({ items: L.Array(L.Unknown) }))(c.payload).items.map((t) => ve(e, s.workflowName, t)) };
+			return {
+				kind: "submission",
+				submission: await sn(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 N(e, {
+			pendingId: s.id,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId,
+			terminal: {
+				...c,
+				at: i
+			}
+		}), !await O(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 sr(e, s.submission, a, r, i, a.batch !== void 0, s.keys);
+	}
+}, ir = async (e, t, n, r, i) => {
+	t = t.map((t) => ({
+		...t,
+		payload: E(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 $n(e, t, i);
+		return;
+	}
+	let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
+	if (ye(o, c, i)) {
+		r.expired += await tr(e, s, o, i, !0);
+		return;
+	}
+	let l = be(o, c.payload);
+	await ar(e, {
+		control: o,
+		intent: c,
+		decision: await se({
+			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 ce({
+			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: A,
+					predicate: z("id", i.id),
+					lock: "update",
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (a[0] === void 0) return;
+				let o = M(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 = be(n, E(e, n.workflowName, i.payload)), o = await se({
+				store: e,
+				control: n,
+				keys: a,
+				paused: l.has(n.workflowName) || (await xe(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 j({
+				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 N(e, {
+				pendingId: n.id,
+				workflowName: n.workflowName,
+				tenantId: n.tenantId,
+				terminal: u
+			}), !await O(e, n.id)) throw Error("Queued input disappeared while recording its terminal outcome");
+			return u.kind;
+		});
+		t !== void 0 && o[t]++;
+		return;
+	}
+	let u = ze(), d = await e.transaction((t) => ln(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 = E(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 sr(e, d.submission, n, o, s, c !== void 0, a);
+	}
+}, or = async (e, t, n, r, i) => {
+	let a = await e.transaction((e) => S(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 sr(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) => S(e, t.id));
+	if (o?.executionId == null || o.executionId !== o.preparedExecutionId) throw Error("Admission submission has no confirmed engine acceptance");
+	return o.executionId;
+}, sr = 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: L.decodeUnknownSync(L.Struct({ items: L.Array(L.Unknown) }))(t.payload).items.map((t) => E(e.store, n.workflowName, t)) } : E(e.store, n.workflowName, t.payload), l = await zn(e, t, c), u = await e.transaction((e) => De(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 x(e.store, t.eviction.executionId, i), await j({
+			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) => Ne(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) => ge(e, t.id, o, {
+					handler: n.onFailure ?? null,
+					errorMessage: String(r),
+					now: i
+				})) !== void 0;
+			}
+			if (!a) {
+				let n = await e.transaction((n) => We(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 Xn(t.id, AggregateError([r, e], "Submission and retry recording failed"));
+		}
+		throw new Xn(t.id, r, a);
+	}
+}, cr = 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 (!re(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: {
+					...Re,
+					onFailure: i.onFailure ?? null
+				}
+			}) && (await x(e.store, o.executionId, t), n++);
+		}
+	}
+	return {
+		cancelled: n,
+		...r === void 0 ? {} : { nextDeadlineAt: r }
+	};
+}, lr = 3e5, ur, dr = (e) => {
+	ur = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
+}, fr = () => {
+	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 ur ?? 3e5;
+}, pr = /* @__PURE__ */ new Set(), mr = () => {
+	pr.clear();
+}, hr = (e) => {
+	let t = fr();
+	if (!(e.timeoutMs > t)) return !1;
+	let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
+	if (pr.has(n)) return !1;
+	pr.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;
+}, gr = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, _r = (e, n) => {
+	let r = F.gen(function* () {
+		let r = n.pollIntervalMs ?? 200, i = n.maxPollIntervalMs ?? 5e3, a = n.timeoutMs ?? 864e5, s = yield* F.serviceOption(J), c;
+		hr({
+			workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
+			signalName: n.name,
+			timeoutMs: a,
+			warn: (e) => {
+				c = e;
+			}
+		}), c !== void 0 && (yield* F.logWarning(c));
+		let l = yield* t, u = yield* F.serviceOption(o), d = u._tag === "Some" ? u.value : void 0;
+		if (l === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
+		let f = l;
+		yield* F.promise(() => gr(d, {
+			runId: f,
+			eventType: "signal-awaited",
+			payload: { signalName: n.name }
+		}));
+		let p = Date.now(), m = r;
+		for (;;) {
+			let t = Date.now() - p;
+			if (t > a) return yield* F.die(/* @__PURE__ */ Error(`awaitSignal('${n.name}') timed out after ${t}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: R(z("runId", f), z("eventType", "signal-sent")),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, o = (yield* F.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			})).find((e) => e.payload?.signalName === n.name);
+			if (o !== void 0) {
+				let e = h(o.payload)?.value, t = yield* L.decodeUnknown(n.schema)(e);
+				return yield* F.promise(() => gr(d, {
+					runId: f,
+					eventType: "signal-received",
+					payload: {
+						signalName: n.name,
+						value: e
+					}
+				})), t;
+			}
+			yield* F.sleep(`${m} millis`), m = Math.min(m * 2, i);
+		}
+	});
+	return f({
+		name: `await-signal:${n.name}`,
+		success: n.schema,
+		execute: r
+	});
+}, vr = async (e, t) => {
+	if (e !== void 0) try {
+		await e.recordEvent(t);
+	} catch {}
+}, yr = (e, n) => {
+	let r = F.gen(function* () {
+		let r = n.pollIntervalMs ?? 200, i = n.maxPollIntervalMs ?? 5e3, a = n.timeoutMs ?? 864e5, s = n.take ?? 500, c = yield* t, l = yield* F.serviceOption(o), u = l._tag === "Some" ? l.value : void 0;
+		if (c === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
+		let d = c, f = yield* n.since === "run-start" ? br(e, d) : F.succeed(/* @__PURE__ */ new Date());
+		yield* F.promise(() => vr(u, {
+			runId: d,
+			eventType: "event-awaited",
+			payload: {
+				event: n.event,
+				since: n.since ?? "wait-start",
+				cutoff: f.toISOString()
+			}
+		}));
+		let p = Date.now(), m = r, h = 0;
+		for (;;) {
+			let t = Date.now() - p;
+			if (t > a) return yield* F.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: R(z("name", n.event), it("occurredAt", f)),
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				take: s,
+				skip: void 0,
+				projection: void 0
+			}, o = yield* F.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			});
+			h = o.length;
+			for (let e of o) {
+				let t = yield* L.decodeUnknown(n.schema)(e.payload);
+				if (n.match(t)) return yield* F.promise(() => vr(u, {
+					runId: d,
+					eventType: "event-received",
+					payload: {
+						event: n.event,
+						eventId: e.id
+					}
+				})), t;
+			}
+			yield* F.sleep(`${m} millis`), m = Math.min(m * 2, i);
+		}
+	});
+	return f({
+		name: `awaitEvent:${n.event}`,
+		success: n.schema,
+		execute: r
+	});
+}, br = (e, t) => F.gen(function* () {
+	let n = (yield* F.tryPromise({
+		try: () => e.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: z("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);
+}), xr = (e) => new Promise((t) => setTimeout(t, e)), Sr = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, Cr = () => `wfu_${Sr()}`, wr = 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: z("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: z("executionId", n),
+		projection: void 0,
+		skip: void 0,
+		take: 1
+	}))[0];
+	if (!i) throw Error(`workflow message target not found: ${n}`);
+	return i;
+}, Tr = class extends Error {
+	runId;
+	eventType;
+	eventId;
+	_tag = "WorkflowMessageNotRecorded";
+	constructor(e, t, n) {
+		super(`workflow ${t} for run ${e} was NOT recorded (event ${n}): the run will not see it — the store refused the row, see the recorder's warning`), this.runId = e, this.eventType = t, this.eventId = n, this.name = "WorkflowMessageNotRecorded";
+	}
+}, Er = async (e) => {
+	let t = await wr(e.store, e.target), n = await e.recorder.recordEvent({
+		runId: t.id,
+		eventType: "signal-sent",
+		payload: {
+			signalName: e.signalName,
+			value: e.payload
+		}
+	});
+	if (n.recorded === !1) throw new Tr(t.id, "signal-sent", n.id);
+	return { eventId: n.id };
+}, Dr = async (e) => {
+	let t = await wr(e.store, e.target), n = Cr(), r = await e.recorder.recordEvent({
+		runId: t.id,
+		eventType: "update-requested",
+		payload: {
+			updateId: n,
+			updateName: e.updateName,
+			value: e.payload
+		}
+	});
+	if (r.recorded === !1) throw new Tr(t.id, "update-requested", r.id);
+	let 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: z("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: h(l.payload)?.result
+		};
+		let u = c.find((e) => e.eventType === "update-failed" && e.payload?.updateId === n);
+		if (u) {
+			let t = Error(h(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 xr(o);
+	}
+}, Or = 864e5, kr = "voltro/suspending-signal", Ar = (e, t) => `${kr}/${e}/${t}`, jr = (e, t) => Ke.make(e, { success: _(t) ? u(L.Unknown, `signal '${e}' value`) : L.Unknown }), Mr = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Nr = (e, n) => F.gen(function* () {
+	let e = n.timeoutMs ?? Or, r = yield* Je.WorkflowInstance, i = jr(Ar(r.workflow.name, n.name), r.workflow.name), a = yield* t, s = yield* F.serviceOption(o), c = s._tag === "Some" ? s.value : void 0;
+	a !== void 0 && (yield* F.promise(() => Mr(c, {
+		runId: a,
+		eventType: "signal-awaited",
+		payload: { signalName: n.name }
+	})));
+	let l = Ke.await(i), u = Number.isFinite(e) ? yield* F.race(l, Ge.sleep({
+		name: `await-signal-timeout/${n.name}`,
+		inMemoryThreshold: "0 millis",
+		duration: `${e} millis`
+	}).pipe(F.andThen(F.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${n.name}') timed out after ${e}ms`))))).pipe(F.catchAllCause((e) => r.suspended ? P.isInterruptedOnly(e) ? qe.suspend(r) : F.failCause(P.filter(e, (e) => !P.isInterruptType(e))) : F.failCause(e))) : yield* l, d = yield* L.decodeUnknown(n.schema)(u);
+	return a !== void 0 && (yield* F.promise(() => Mr(c, {
+		runId: a,
+		eventType: "signal-received",
+		payload: {
+			signalName: n.name,
+			value: d
+		}
+	}))), d;
+}), Pr = (e) => F.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* F.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
+		let i = yield* F.tryPromise({
+			try: () => wr(r, e.target),
+			catch: (e) => e
+		});
+		t ??= i.executionId, n ??= i.tag;
+	}
+	if (t === void 0 || n === void 0) return { completed: !1 };
+	let r = Ar(n, e.signalName), i = jr(r, n), a = new Ke.TokenParsed({
+		workflowName: n,
+		executionId: t,
+		deferredName: r
+	}).asToken;
+	return yield* Ke.done(i, {
+		token: a,
+		exit: Ye.succeed(e.payload)
+	}), { completed: !0 };
+}), Z = "_voltro_budget_holds", Fr = "budget-hold", Ir = (e) => `${Fr}:${e}`, Lr = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, Rr = async (e, t) => (await e.query({
+	table: Z,
+	predicate: R(z("executionId", t.executionId), z("stepName", t.stepName), z("budget", t.budget)),
+	order: []
+})).length, zr = G(Z, {
+	id: V({ prefix: "bhd" }),
+	holdKey: K().maxLength(191).unique(),
+	budget: K(),
+	tenantId: K().nullable(),
+	executionId: K(),
+	workflowName: K(),
+	signalName: K(),
+	stepName: K(),
+	spentMicroUsd: K().nullable(),
+	limitMicroUsd: K().nullable(),
+	heldAt: q().default("now"),
+	releasedAt: q().nullable(),
+	outcome: K().nullable()
+}).index(["budget", "releasedAt"]), Br = () => {
+	ft({
+		source: "framework",
+		table: Z,
+		timeColumn: "releasedAt",
+		ttlMs: pt(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
+	});
+}, Vr = 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;
+	}
+}, Hr = 6048e5, Ur = (e) => F.gen(function* () {
+	Br();
+	let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
+		executionId: e.executionId,
+		stepName: e.stepName,
+		budget: e.budget
+	};
+	for (let i = 0;; i++) {
+		let a = yield* F.promise(() => Gr(e.store, r)), o = a.length === 0 ? Date.now() : Wr(a[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = Lr({
+			...r,
+			generation: i
+		});
+		if (s <= 0) return yield* F.promise(() => Kr(e.store, r, "expired")), yield* F.fail(new Vr(e.budget, c, t));
+		let l = Ir(c);
+		yield* F.promise(() => e.store.insertIgnore(Z, {
+			id: rt({
+				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* Nr({ store: e.store }, {
+			name: l,
+			schema: L.Unknown,
+			timeoutMs: u
+		}).pipe(F.catchAllCause((e) => P.isInterruptedOnly(e) ? F.failCause(e) : F.void)), yield* F.promise(() => e.store.updateMany(Z, {
+			releasedAt: /* @__PURE__ */ new Date(),
+			outcome: "recheck"
+		}, { where: R(z("holdKey", c), U("releasedAt")) })), yield* e.hasHeadroom) return;
+	}
+}), Wr = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), Gr = async (e, t) => [...await e.query({
+	table: Z,
+	predicate: R(z("executionId", t.executionId), z("stepName", t.stepName), z("budget", t.budget)),
+	order: []
+})].sort((e, t) => String(e.id).localeCompare(String(t.id))), Kr = async (e, t, n) => {
+	await e.updateMany(Z, {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: n
+	}, { where: R(z("executionId", t.executionId), z("stepName", t.stepName), z("budget", t.budget), U("releasedAt")) });
+}, qr = (e) => F.gen(function* () {
+	let t = e.tenantId === void 0 ? R(z("budget", e.budget), U("releasedAt")) : R(z("budget", e.budget), z("tenantId", e.tenantId), U("releasedAt")), n = yield* F.promise(() => e.store.query({
+		table: Z,
+		predicate: t,
+		order: []
+	})), r = 0;
+	for (let t of n) (yield* F.promise(() => e.store.updateMany("_voltro_budget_holds", {
+		releasedAt: /* @__PURE__ */ new Date(),
+		outcome: e.outcome ?? "released"
+	}, { where: R(z("id", String(t.id)), U("releasedAt")) }))) === 1 && (yield* Pr({
+		target: {
+			executionId: String(t.executionId),
+			workflowName: String(t.workflowName)
+		},
+		signalName: String(t.signalName),
+		payload: {
+			released: !0,
+			budget: e.budget
+		}
+	}).pipe(F.catchAll(() => F.succeed({ completed: !1 }))), r += 1);
+	return { released: r };
+}), Jr = async (e, t) => {
+	let n = t?.budget === void 0 ? U("releasedAt") : R(z("budget", t.budget), U("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 ?? "")
+	}));
+}, Yr = async (e) => {
+	let t = await Jr(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()];
+}, Xr = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, Zr = (e) => {
+	let t = P.failureOption(e), n = Array.from(P.defects(e)), r = t._tag === "Some" ? t.value : n[0] ?? P.squash(e);
+	return {
+		errorTag: r && typeof r == "object" && "_tag" in r ? String(r._tag) : null,
+		errorMessage: r?.message ?? String(r)
+	};
+}, Qr = (e, n) => {
+	let r = F.gen(function* () {
+		let r = n.pollIntervalMs ?? 200, i = n.maxPollIntervalMs ?? 5e3, a = n.timeoutMs ?? 3e4, s = yield* t, c = yield* F.serviceOption(o), l = c._tag === "Some" ? c.value : void 0;
+		if (s === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
+		let u = s, d = Date.now(), f = r;
+		for (;;) {
+			let t = Date.now() - d;
+			if (t > a) return yield* F.die(/* @__PURE__ */ Error(`awaitUpdate('${n.name}') timed out after ${t}ms`));
+			let r = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: z("runId", u),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, o = yield* F.tryPromise({
+				try: () => e.store.query(r),
+				catch: (e) => e
+			}), s = new Set(o.filter((e) => e.eventType === "update-completed" || e.eventType === "update-failed").map((e) => e.payload?.updateId).filter((e) => typeof e == "string" && e.length > 0)), c = o.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* F.promise(() => Xr(l, {
+					runId: u,
+					eventType: "update-received",
+					payload: {
+						updateId: e,
+						updateName: n.name
+					}
+				}));
+				let t = yield* L.decodeUnknown(n.schema)(h(c.payload)?.value).pipe(F.tapErrorCause((t) => F.promise(() => Xr(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						...Zr(t)
+					}
+				})))), r = yield* (n.handle ? n.handle(t) : F.succeed(t)).pipe(F.flatMap((e) => n.success ? L.decodeUnknown(n.success)(e) : F.succeed(e))).pipe(F.tapErrorCause((t) => F.promise(() => Xr(l, {
+					runId: u,
+					eventType: "update-failed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						...Zr(t)
+					}
+				}))));
+				return yield* F.promise(() => Xr(l, {
+					runId: u,
+					eventType: "update-completed",
+					payload: {
+						updateId: e,
+						updateName: n.name,
+						result: r
+					}
+				})), r;
+			}
+			yield* F.sleep(`${f} millis`), f = Math.min(f * 2, i);
+		}
+	});
+	return f({
+		name: `await-update:${n.name}`,
+		success: n.success ?? n.schema,
+		execute: r
+	});
+}, $r = (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;
+}, ei = (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) => (ei(e.attempt) ?? 0) - (ei(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: ei(t.attempt) ?? r.length,
+			attempts: r.length,
+			status: t.status ?? "running",
+			input: t.input ?? null,
+			output: t.output ?? null,
+			error: o,
+			durationMs: ei(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 ($r(r?.startedAt)?.getTime() ?? 0) - ($r(i?.startedAt)?.getTime() ?? 0);
+	}), n;
+}, ni = (e) => {
+	if (e == null) return null;
+	if (typeof e == "string") try {
+		return JSON.parse(e);
+	} catch {
+		return null;
+	}
+	return typeof e == "object" ? e : null;
+}, ri = async (e, t) => {
+	let n = lt(_t), r = (await t.query(n.where(ct(z("id", e), z("executionId", e))).limit(1).descriptor))[0];
+	if (r === void 0) return null;
+	let i = String(r.id), a = lt(vt), o = await t.query(a.where(z("runId", i)).descriptor);
+	return {
+		id: i,
+		executionId: Q(r.executionId) ?? "",
+		name: Q(r.tag) ?? "",
+		status: r.status ?? "running",
+		input: d(r.payload ?? null, "workflow run payload"),
+		output: m(r.output ?? null, "workflow run result"),
+		subject: ni(r.subject),
+		source: Q(r.source),
+		steps: ti(o),
+		startedAt: $r(r.startedAt) ?? /* @__PURE__ */ new Date(0),
+		finishedAt: $r(r.completedAt),
+		traceId: Q(r.traceId),
+		parentExecutionId: Q(r.parentExecutionId),
+		parentClosePolicy: Q(r.parentClosePolicy)
+	};
+}, ii = () => {
+	let e = [], t = [], n = 0, r = 0;
+	return {
+		layer: Qe.succeed(o, {
+			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: i, stepName: a, attempt: o }) => {
+				let s = `wfev_mem_${++r}`;
+				return t.push({
+					id: s,
+					runId: e,
+					eventType: n,
+					payload: i ?? null,
+					stepName: a ?? null,
+					attempt: o ?? null,
+					occurredAt: /* @__PURE__ */ new Date()
+				}), {
+					id: s,
+					recorded: !0
+				};
+			}
+		}),
+		readSteps: () => e,
+		readEvents: () => t
+	};
+}, ai = (e, t, n) => F.gen(function* () {
+	let r = yield* J;
+	for (;;) {
+		if (yield* F.tryPromise(() => he(t, e)).pipe(F.catchAll(() => F.sync(() => (n(), !1))))) return r.interrupted = !0, yield* F.interrupt;
+		yield* F.sleep(1e3);
+	}
+}), oi = 8192, si = 3, ci = 2e3, li = () => {
+	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 }
+	};
+}, ui = (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");
+}, di = () => {
+	let e = globalThis.crypto;
+	return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}, fi = (e) => `${e}_${di()}`, pi = (e, t = oi) => {
+	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) };
+	}
+}, mi = async (e, t, n) => {
+	if (n === null || !g() || !("value" in n || "result" in n || "errorMessage" in n) || e.query === void 0) return n;
+	let [r] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: z("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return typeof r?.tag == "string" ? b(r.tag, n) : n;
+}, $ = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
+	return ee(t);
+}, hi = (e) => {
+	let t = e.truncateBytes ?? oi, n = e.makeId ?? fi, r = (t, n) => e.log?.warn(t, n), i = (e, t) => t === !0 ? l(e, "workflow step value", v) : e, a = e.emit, o = e.recording === "coarse";
+	return {
+		startStep: async ({ runId: s, stepName: c, attempt: l, stepInput: u, retryPolicy: d, sealed: f }) => {
+			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(pi(u, t), f),
+					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, sealed: l }) => {
+			if (!o) try {
+				let r = await e.store.update("_voltro_workflow_run_steps", n, {
+					status: "succeeded",
+					output: i(pi(s, t), l),
+					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, sealed: d }) => {
+			if (!o) try {
+				let r = await e.store.update("_voltro_workflow_run_steps", n, {
+					status: "failed",
+					errorTag: s,
+					errorMessage: c == null ? c : i(c, d),
+					errorCause: l === void 0 ? null : i(pi(l, t), d),
+					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"), u = !0;
+			try {
+				let n = await e.store.insert("_voltro_workflow_run_events", {
+					id: l,
+					runId: t,
+					eventType: i,
+					payload: await mi(e.store, t, o ?? null),
+					occurredAt: /* @__PURE__ */ new Date(),
+					stepName: s ?? null,
+					attempt: c ?? null
+				});
+				a?.("workflowEvents", {
+					op: "insert",
+					row: $(n)
+				});
+			} catch (e) {
+				u = !1, 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,
+				recorded: u
+			};
+		}
+	};
+}, gi = (e, t, n) => F.gen(function* () {
+	let r = e.store.query;
+	if (r === void 0) return;
+	let i = e.replayShapeLimit ?? 2e3, a = yield* F.promise(() => r.call(e.store, {
+		table: "_voltro_workflow_run_steps",
+		order: [{
+			column: "startedAt",
+			direction: "asc"
+		}],
+		predicate: z("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);
+}), _i = (s, l) => {
+	let u = s.truncateBytes ?? oi, d = s.makeId ?? fi, f = s.recorder ?? hi(s), p = (e, t) => s.log?.warn(e, t), m = s.emit, h = (e) => F.gen(function* () {
+		yield* F.sync(() => m?.("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* F.promise(() => t.cancel(n, typeof e == "string" ? e : void 0).catch(() => {
+				p("failed to clear terminal workflow wakeup", { runId: n });
+			}));
+		}
+	}), g = (e, t, n) => F.promise(async () => {
+		if (s.onParentClose) try {
+			await s.onParentClose({
+				workflowName: s.name,
+				executionId: e,
+				...n === void 0 ? {} : { runId: n },
+				status: t
+			});
+		} catch (n) {
+			p("failed to apply workflow parent-close policy", {
+				tag: s.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	}), v = (e, t, n, r) => F.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) {
+			p("workflow terminal observer failed", {
+				tag: s.name,
+				executionId: e,
+				status: t,
+				reason: n?.message ?? String(n)
+			});
+		}
+	});
+	return (ee, b) => F.gen(function* () {
+		let x = Date.now(), te = yield* Ze.get(r), ne = yield* Ze.get(i), re = s.parentExecutionId ?? te ?? null, ie = s.parentGeneration ?? (s.parentExecutionId == null ? ne : void 0) ?? null, S = s.parentClosePolicy ?? null, C, w = (e, t) => t.pipe(F.catchAllCause((t) => P.isInterrupted(t) ? F.failCause(t) : F.sync(() => {
+			let n = P.squash(t);
+			p(e, {
+				tag: s.name,
+				executionId: b,
+				reason: n?.message ?? String(n)
+			});
+		}))), T = `wfrg_${di()}`, ae = yield* F.serviceOption(Ee), oe = d("wr"), se = yield* F.sync(() => s.encodePayload === void 0 ? ee : s.encodePayload(ee)), E = yield* F.promise(() => s.transaction((e) => zt(e, {
+			workflowName: s.name,
+			executionId: b,
+			generation: T,
+			now: x,
+			delivery: ae._tag === "Some" ? ae.value : null,
+			initialRow: {
+				id: oe,
+				payload: se,
+				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(x),
+				completedAt: null,
+				durationMs: null,
+				traceId: s.traceId ?? null,
+				parentExecutionId: re,
+				parentGeneration: ie,
+				parentClosePolicy: S
+			}
+		})));
+		if (typeof E.row.id != "string") return yield* F.die(/* @__PURE__ */ Error("Recorded workflow entry has no run identity"));
+		if (C = E.row.id, E.restartEvent !== void 0) {
+			let e = E.restartEvent;
+			yield* w("failed to observe recorded workflow restart", F.sync(() => {
+				m?.("workflowEvents", {
+					op: "insert",
+					row: $(e)
+				});
+			}));
+		}
+		if (E.kind === "cancelled" || E.kind === "already-cancelled") {
+			let e = yield* J;
+			return e.interrupted = !0, E.kind === "cancelled" && (yield* w("failed to observe suspended workflow cancellation", F.gen(function* () {
+				if (m?.("workflowRuns", {
+					op: "update",
+					row: $(E.row)
+				}), E.terminalEvent === void 0) return yield* F.die(/* @__PURE__ */ Error("Cancelled entry has no terminal event"));
+				yield* h(E.terminalEvent), yield* g(b, "cancelled", C);
+			})), yield* v(b, "cancelled", C), yield* F.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "cancelled",
+				durationMs: 0
+			}))), yield* F.interrupt;
+		}
+		let D = E.previous, ce = D?.workflowVersion ?? null;
+		if (D?.id !== void 0 && ce !== null && s.workflowCompatibleVersions !== void 0 && s.workflowCompatibleVersions !== null && !s.workflowCompatibleVersions.includes(ce)) {
+			let e = `Workflow '${s.name}' run '${b}' was started on version ${ce}, but current code is compatible with ${s.workflowCompatibleVersions.join(", ")}`, t = s.failureContext ?? {
+				handler: null,
+				callerContext: null,
+				tenantId: null
+			}, n = yield* F.promise(() => s.transaction((n) => Wt(n, {
+				owner: {
+					runId: C,
+					workflowName: s.name,
+					executionId: b,
+					generation: T
+				},
+				now: Date.now(),
+				durationMs: 0,
+				outcome: {
+					status: "failed",
+					errorTag: "WorkflowVersionIncompatible",
+					errorMessage: e,
+					...t
+				}
+			})));
+			return n.kind === "committed" && (yield* w("failed to observe workflow version rejection", F.gen(function* () {
+				m?.("workflowRuns", {
+					op: "update",
+					row: $(n.row)
+				}), yield* h(n.terminalEvent), yield* g(b, "failed", C);
+			})), yield* v(b, "failed", C, {
+				payload: E.row.payload,
+				errorTag: "WorkflowVersionIncompatible",
+				errorMessage: e
+			}), yield* F.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "failed",
+				durationMs: 0
+			})), p("workflow run failed", {
+				workflow: s.name,
+				executionId: b,
+				runId: C,
+				errorTag: "WorkflowVersionIncompatible",
+				cause: e
+			})), yield* F.fail(Error(e));
+		}
+		let O = s.workflowPatches ?? [], k;
+		if (D?.id !== void 0) {
+			C = D.id, O = ui(D.workflowPatches) ?? O;
+			let e = E.row.reclaimCount;
+			if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0) return yield* F.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* F.promise(() => s.transaction((e) => Ht(e, {
+					runId: C,
+					workflowName: s.name,
+					executionId: b,
+					generation: T
+				}, {
+					errorTag: "WorkflowCrashLooped",
+					errorMessage: t
+				})));
+				r.kind === "committed" && (yield* w("failed to observe workflow crash-loop park", F.gen(function* () {
+					m?.("workflowRuns", {
+						op: "update",
+						row: $(r.row)
+					}), yield* F.promise(() => f.recordEvent({
+						runId: C,
+						eventType: "run-crashlooped",
+						payload: {
+							reclaimCount: e,
+							maxRunReclaims: n,
+							executionId: b,
+							tag: s.name
+						}
+					}));
+				})), p("workflow run parked after repeated runner deaths", {
+					tag: s.name,
+					executionId: b,
+					runId: C,
+					reclaimCount: e,
+					maxRunReclaims: n
+				}));
+				let i = yield* J;
+				return yield* qe.suspend(i);
+			}
+			k = yield* gi(s, C, p), yield* w("failed to record workflow re-entry", F.gen(function* () {
+				m?.("workflowRuns", {
+					op: "update",
+					row: $(E.row)
+				}), t && (yield* F.promise(() => f.recordEvent({
+					runId: C,
+					eventType: "run-resumed",
+					payload: {
+						reason: "runner-reclaim",
+						reclaimCount: e,
+						maxRunReclaims: n
+					}
+				})));
+			}));
+		} else yield* w("failed to emit recorded workflow start", F.gen(function* () {
+			if (m?.("workflowRuns", {
+				op: "insert",
+				row: $(E.row)
+			}), C) {
+				let e = C;
+				yield* F.promise(() => f.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: re,
+						parentClosePolicy: S
+					}
+				}));
+			}
+		}));
+		let A = s.subject?.tenantId, le = F.suspend(() => l(ee, b, T)).pipe(F.locally(t, C), F.locally(r, b), F.locally(i, T), F.locally(n, typeof A == "string" ? A : void 0), F.locally(a, O), F.locally(c, k), F.provideService(o, f)), ue = s.pluginWorkflowStepLayer ? le.pipe(F.provide(s.pluginWorkflowStepLayer)) : le, de = yield* qe.intoResult(F.raceWith(ue, ai({
+			runId: C,
+			workflowName: s.name,
+			executionId: b,
+			generation: T
+		}, async (e) => s.store.query(e), () => p("workflow control read failed; retrying without claiming cancellation", {
+			executionId: b,
+			runId: C
+		})).pipe(F.interruptible), {
+			onSelfDone: (e, t) => Xe.interrupt(t).pipe(F.zipRight(e)),
+			onOtherDone: (e, t) => Xe.interrupt(t).pipe(F.zipRight(e))
+		}));
+		if (qe.isResult(de) && de._tag === "Suspended") {
+			let e = de.cause, t = e !== void 0 && !P.isEmpty(e), n = t ? P.squash(e) : void 0, r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = t ? n?.message ?? String(n) : null, a = yield* F.promise(() => s.transaction((e) => Ht(e, {
+				runId: C,
+				workflowName: s.name,
+				executionId: b,
+				generation: T
+			}, {
+				errorTag: r,
+				errorMessage: i
+			})));
+			a.kind === "committed" && t && (yield* F.sync(() => et({
+				error: n,
+				source: "workflow",
+				name: s.name,
+				contentSensitive: _(s.name),
+				...s.traceId ? { traceId: s.traceId } : {},
+				fields: {
+					executionId: b,
+					suspendedOnFailure: !0,
+					...r ? { errorTag: r } : {},
+					...C ? { runId: C } : {}
+				}
+			}))), a.kind === "committed" && (yield* w("failed to observe workflow suspend", F.gen(function* () {
+				m?.("workflowRuns", {
+					op: "update",
+					row: $(a.row)
+				}), yield* F.promise(() => f.recordEvent({
+					runId: C,
+					eventType: "run-suspended",
+					payload: t ? {
+						reason: "suspend-on-failure",
+						errorTag: r,
+						errorMessage: i
+					} : { reason: "workflow-suspend" }
+				}));
+			})));
+			let o = yield* J;
+			return yield* qe.suspend(o);
+		}
+		let fe = de;
+		if (k !== void 0 && C !== void 0) {
+			let t = k.settle();
+			if (t.length > 0) {
+				let n = C;
+				p("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* w("failed to record nondeterminism findings", F.promise(async () => {
+					for (let r of t) await f.recordEvent({
+						runId: n,
+						eventType: "nondeterminism-suspected",
+						payload: e(r)
+					}).catch(() => void 0);
+				}));
+			}
+		}
+		if (Ye.isFailure(fe.exit)) {
+			let e = fe.exit.cause;
+			if ((yield* J).interrupted && P.isInterruptedOnly(e)) {
+				let t = Date.now(), n = yield* F.promise(() => s.transaction((e) => Wt(e, {
+					owner: {
+						runId: C,
+						workflowName: s.name,
+						executionId: b,
+						generation: T
+					},
+					now: t,
+					durationMs: t - x,
+					outcome: { status: "cancelled" }
+				})));
+				return n.kind === "committed" && (yield* w("failed to observe workflow cancellation", F.gen(function* () {
+					m?.("workflowRuns", {
+						op: "update",
+						row: $(n.row)
+					}), yield* h(n.terminalEvent), yield* g(b, "cancelled", C);
+				})), yield* v(b, "cancelled", C), yield* F.sync(() => s.recordRun?.({
+					name: s.name,
+					status: "cancelled",
+					durationMs: t - x
+				}))), yield* F.failCause(e);
+			}
+			let t = P.failureOption(e), n = t._tag === "Some" ? t.value : P.squash(e), r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = n?.message ?? String(n), a = Date.now(), o = s.failureContext ?? {
+				handler: null,
+				callerContext: null,
+				tenantId: null
+			}, c = yield* F.promise(() => s.transaction((e) => Wt(e, {
+				owner: {
+					runId: C,
+					workflowName: s.name,
+					executionId: b,
+					generation: T
+				},
+				now: a,
+				durationMs: a - x,
+				outcome: {
+					status: "failed",
+					errorTag: r,
+					errorMessage: i,
+					...o
+				}
+			})));
+			return c.kind === "committed" ? (p("workflow run failed", {
+				workflow: s.name,
+				executionId: b,
+				runId: C,
+				...r ? { errorTag: r } : {},
+				cause: y(s.name, n)
+			}), yield* F.sync(() => et({
+				error: n,
+				source: "workflow",
+				name: s.name,
+				contentSensitive: _(s.name),
+				...s.traceId ? { traceId: s.traceId } : {},
+				fields: {
+					executionId: b,
+					...r ? { errorTag: r } : {},
+					...C ? { runId: C } : {}
+				}
+			})), C && (yield* w("failed to record workflow failure", F.gen(function* () {
+				m?.("workflowRuns", {
+					op: "update",
+					row: $(c.row)
+				}), yield* h(c.terminalEvent), yield* g(b, "failed", C);
+			}))), yield* v(b, "failed", C, {
+				payload: ee,
+				errorTag: r,
+				errorMessage: i
+			}), yield* F.sync(() => s.recordRun?.({
+				name: s.name,
+				status: "failed",
+				durationMs: Date.now() - x
+			})), yield* F.failCause(e)) : yield* F.failCause(e);
+		}
+		let j = fe.exit.value, pe = Date.now(), me = yield* F.promise(() => s.transaction((e) => Wt(e, {
+			owner: {
+				runId: C,
+				workflowName: s.name,
+				executionId: b,
+				generation: T
+			},
+			now: pe,
+			durationMs: pe - x,
+			outcome: {
+				status: "succeeded",
+				output: pi(j, u)
+			}
+		})));
+		return me.kind === "committed" ? (C && (yield* w("failed to record workflow success", F.gen(function* () {
+			m?.("workflowRuns", {
+				op: "update",
+				row: $(me.row)
+			}), yield* h(me.terminalEvent), yield* g(b, "succeeded", C);
+		}))), yield* v(b, "succeeded", C), yield* F.sync(() => s.recordRun?.({
+			name: s.name,
+			status: "succeeded",
+			durationMs: Date.now() - x,
+			completedAtSec: Date.now() / 1e3
+		})), j) : j;
+	});
+};
+//#endregion
+export { gn as $, yr as A, Zn as B, Nr as C, yt as Ct, wr as D, Cr as E, gt as Et, fr as F, yn as G, jn as H, dr as I, vn as J, bn as K, Yn as L, lr as M, hr as N, Er as O, mr as P, Tn as Q, or as R, Ur as S, bt as St, Ar as T, _t as Tt, An as U, kn as V, Rn as W, wn as X, _n as Y, On as Z, Lr as _, St as _t, li as a, cn as at, Jr as b, Et as bt, _i as c, Gt as ct, Qr as d, zt as dt, hn as et, Z as f, Ft as ft, Rr as g, wt as gt, zr as h, Ct as ht, ui as i, sn as it, _r as j, Dr as k, ii as l, Vt as lt, Hr as m, Ot as mt, ci as n, un as nt, $ as o, an as ot, Vr as p, xt as pt, xn as q, hi as r, fn as rt, pi as s, on as st, si as t, pn as tt, ri as u, Wt as ut, Ir as v, kt as vt, Pr as w, vt as wt, qr as x, Tt as xt, Yr as y, Dt as yt, Qn as z };