@voltro/workflow 0.84.0 → 0.86.0

package/dist/admissionDrainer.js

@@ -0,0 +1,705 @@
+import { loggableCause as e, sealErrorText as t } from "./journalEncryption.js";
+import { isFinishExpired as n, isStartExpired as r, resolveAdmissionKeys as i } from "./admission.js";
+import { recordWorkflowFailureInTransaction as a } from "./failureReportStore.js";
+import { handoffWorkflowFailureInTransaction as o, isFailureDeliveryPending as s } from "./failureHandoff.js";
+import { acknowledgeAdmissionSubmissionInTransaction as c, beginAdmissionSubmissionDispatchInTransaction as l, newAdmissionSubmissionId as u, noteAdmissionSubmissionFailure as d, readAdmissionSubmission as f, rejectAdmissionSubmissionInTransaction as p } from "./admissionSubmission.js";
+import { settlePendingStartReceipts as m } from "./startReceipt.js";
+import { PENDING_TABLE as h, deadLetterIntent as g, decodePendingPayload as _, deleteIntent as v, encodePendingPayload as y, evaluateAdmission as b, noteIntentAttempt as x, pendingWindow as S, persistDefer as C, readPausedWorkflows as w, recordAdmission as T, releaseLease as E, retryBackoffMs as D, toPendingIntent as O } from "./admissionStore.js";
+import { FLOW_CONTROL_FINISH_TIMEOUT as k } from "./controlRequest.js";
+import { takeAdmittedSubmissionInTransaction as A, takePendingAdmissionSubmissionInTransaction as j } from "./pendingSubmission.js";
+import { admitStart as M } from "./admissionGate.js";
+import { prepareSubmissionDispatch as N } from "./prepareSubmissionDispatch.js";
+import { recoverAdmissionSubmissions as P } from "./submissionRecovery.js";
+import { recoverWorkflowFailures as F } from "./failureRecovery.js";
+import { recoverWorkflowParentClosures as I } from "./parentClosureRecovery.js";
+import { forwardStartReceipts as L } from "./forwardStartReceipts.js";
+import { Schema as R } from "effect";
+import { eq as z } from "@voltro/database";
+import { randomUUID as B } from "node:crypto";
+//#region src/admissionDrainer.ts
+var V = {
+	scanned: 0,
+	admitted: 0,
+	deferred: 0,
+	dropped: 0,
+	skipped: 0,
+	expired: 0,
+	evicted: 0,
+	failed: 0,
+	deadLettered: 0,
+	timedOut: 0,
+	examined: !1
+}, H = 200, U = 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;
+	}
+}, W = (e) => e instanceof U && !e.rejected, G = async (n, r = {}) => {
+	let i = n.now ?? (() => Date.now()), a = n.log, o = r.batchSize ?? 200, s, c, l, u, d, f;
+	try {
+		u = await P(n, i(), o, n.deadLetterAfterAttempts ?? 50), d = await F(n, i(), o), f = await I(n, i(), o), s = await (n.readPauses?.() ?? w(n.store));
+		let e = r.skipPending === !0 && !d.hasPending ? {
+			due: [],
+			nextDueAt: void 0
+		} : await S(n.store, i(), o);
+		c = e.due, l = u.nextDueAt === void 0 ? e.nextDueAt : Math.min(e.nextDueAt ?? u.nextDueAt, u.nextDueAt), d.nextDueAt !== void 0 && (l = Math.min(l ?? d.nextDueAt, d.nextDueAt)), f.nextDueAt !== void 0 && (l = Math.min(l ?? f.nextDueAt, f.nextDueAt));
+	} catch (e) {
+		return a?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), {
+			...V,
+			scanned: (u?.scanned ?? 0) + (d?.scanned ?? 0) + (f?.scanned ?? 0),
+			admitted: u?.admitted ?? 0,
+			deadLettered: u?.rejected ?? 0,
+			failed: (u?.failed ?? 0) + (d?.failed ?? 0) + (f?.failed ?? 0) + 1,
+			nextDueAt: i()
+		};
+	}
+	let p = {
+		scanned: c.length + u.scanned + d.scanned + f.scanned,
+		admitted: u.admitted,
+		deferred: 0,
+		dropped: 0,
+		skipped: 0,
+		expired: 0,
+		evicted: 0,
+		failed: u.failed + d.failed + f.failed,
+		deadLettered: u.rejected,
+		timedOut: 0
+	}, m = /* @__PURE__ */ new Map(), g = [];
+	for (let e of c) if (e.mode === "batch") {
+		let t = `${e.workflowName}\u0000${e.controlKey}`, n = m.get(t);
+		n === void 0 ? m.set(t, [e]) : n.push(e);
+	} else g.push(e);
+	let _ = n.deadLetterAfterAttempts === void 0 ? 50 : n.deadLetterAfterAttempts, v = (e, t, r) => {
+		if (n.isPermanentStartError?.(t) === !0) return `pending ${r} was dead-lettered after a permanent start failure: ${String(t)}`;
+		if (_ !== !1 && e.attempts + 1 >= _) return `pending ${r} was dead-lettered after ${e.attempts + 1} failed attempts: ${String(t)}`;
+	};
+	for (let t of g) try {
+		await Y(n, t, s, p, i());
+	} catch (r) {
+		if (p.failed++, r instanceof U) {
+			r.rejected && p.deadLettered++, a?.warn?.(r.message, {
+				submissionId: r.submissionId,
+				cause: e(t.workflowName, r.cause)
+			});
+			continue;
+		}
+		let o = v(t, r, "intent");
+		if (o !== void 0) {
+			let s = i(), c = String(r);
+			if (await q(n, [t], o, c, s, !1).catch((e) => (a?.warn?.("workflow flow control: intent could not be dead-lettered with its report", {
+				workflow: t.workflowName,
+				intent: t.id,
+				cause: String(e)
+			}), 0)) > 0) {
+				p.deadLettered++, a?.warn?.("workflow flow control: intent dead-lettered", {
+					workflow: t.workflowName,
+					intent: t.id,
+					cause: e(t.workflowName, c)
+				});
+				continue;
+			}
+		}
+		a?.warn?.("workflow flow control: an intent failed to drain", {
+			workflow: t.workflowName,
+			intent: t.id,
+			cause: e(t.workflowName, r)
+		}), await x(n.store, t, String(r), i()).catch(() => {});
+	}
+	for (let r of m.values()) try {
+		await Z(n, r, s, p, i());
+	} catch (o) {
+		if (p.failed++, o instanceof U) {
+			o.rejected && p.deadLettered++, a?.warn?.(o.message, {
+				submissionId: o.submissionId,
+				cause: e(r[0]?.workflowName, o.cause)
+			});
+			continue;
+		}
+		let s = r[0], c = s === void 0 ? void 0 : v(s, o, "batch");
+		if (s !== void 0 && c !== void 0) {
+			let t = i(), l = String(o);
+			if (await q(n, r, c, l, t, !0).catch((e) => (a?.warn?.("workflow flow control: batch could not be dead-lettered with its report", {
+				workflow: s.workflowName,
+				intents: r.map((e) => e.id),
+				size: r.length,
+				cause: String(e)
+			}), 0)) === r.length) {
+				p.deadLettered += r.length, a?.warn?.("workflow flow control: batch dead-lettered", {
+					workflow: s.workflowName,
+					intents: r.map((e) => e.id),
+					size: r.length,
+					cause: e(s.workflowName, l)
+				});
+				continue;
+			}
+		}
+		a?.warn?.("workflow flow control: a batch failed to drain", {
+			workflow: s?.workflowName,
+			size: r.length,
+			cause: e(s?.workflowName, o)
+		});
+		let l = i(), u = Math.random();
+		await n.transaction(async (e) => {
+			let n = [];
+			for (let t of r) {
+				let r = await e.query({
+					table: h,
+					predicate: z("id", t.id),
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0,
+					lock: "update"
+				});
+				if (r[0] === void 0) return;
+				let i = O(r[0]);
+				if (i.workflowName !== t.workflowName || i.tenantId !== t.tenantId || i.mode !== t.mode || i.firstSeenAt !== t.firstSeenAt || i.dueAt !== t.dueAt || i.deadLetteredAt !== void 0) return;
+				n.push(i);
+			}
+			let i = new Date(l + D(Math.max(...n.map((e) => e.attempts + 1)), () => u));
+			for (let r of n) if (await e.update("_voltro_workflow_pending", r.id, {
+				attempts: r.attempts + 1,
+				lastError: t(r.workflowName, String(o).slice(0, 500)),
+				dueAt: i,
+				updatedAt: new Date(l)
+			}) === null) throw Error("Batch input disappeared while recording the shared retry deadline");
+		}).catch((e) => a?.warn?.("workflow flow control: batch retry could not be persisted", {
+			workflow: s?.workflowName,
+			intents: r.map((e) => e.id),
+			cause: String(e)
+		}));
+	}
+	let y = await te(n, i()).catch(() => ({ cancelled: 0 }));
+	return p.timedOut = y.cancelled, y.nextDeadlineAt !== void 0 && (l === void 0 || y.nextDeadlineAt < l) && (l = y.nextDeadlineAt), {
+		...p,
+		examined: r.skipPending !== !0 || u.examined || d.examined || f.examined,
+		...l === void 0 ? {} : { nextDueAt: l }
+	};
+}, K = async (e, t, n) => {
+	let r = t.map((e) => ({
+		intent: e,
+		failureId: `wff_${B()}`
+	}));
+	return e.transaction(async (e) => {
+		let t = 0;
+		for (let { intent: i, failureId: o } of r) {
+			let r = (await e.query({
+				table: h,
+				predicate: z("id", i.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			}))[0];
+			if (r === void 0) continue;
+			let s = O(r);
+			if (s.workflowName !== i.workflowName || s.tenantId !== i.tenantId) throw Error("Abandoned queue selection belongs to another workflow or tenant");
+			if (s.dueAt > n || s.deadLetteredAt !== void 0) continue;
+			let c = `workflow '${s.workflowName}' no longer has its queued declaration`;
+			if (await a(e, {
+				id: o,
+				sourceKind: "intent",
+				sourceId: s.id,
+				workflowName: s.workflowName,
+				tenantId: s.tenantId,
+				handler: null,
+				callerContext: s.callerContext,
+				report: {
+					workflow: s.workflowName,
+					payload: s.payload,
+					reason: c,
+					failedAt: n,
+					errorTag: null,
+					errorMessage: null,
+					runId: null,
+					executionId: null
+				}
+			}), await m(e, {
+				pendingId: s.id,
+				workflowName: s.workflowName,
+				tenantId: s.tenantId,
+				terminal: {
+					kind: "abandoned",
+					at: n,
+					failureId: o
+				}
+			}), !await e.delete("_voltro_workflow_pending", s.id)) throw Error("Abandoned queue row disappeared before deletion");
+			t++;
+		}
+		return t;
+	});
+}, q = async (e, t, n, r, i, c) => {
+	let l = `wff_${B()}`;
+	return e.transaction(async (u) => {
+		let d = [];
+		for (let e of t) {
+			let t = await u.query({
+				table: h,
+				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 = O(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;
+			d.push(n);
+		}
+		let f = d[0];
+		if (f === void 0) return 0;
+		let p = await Promise.all(d.map((e) => s(u, e.id)));
+		if (p.some(Boolean) && !p.every(Boolean)) throw Error("Dead-lettered batch mixes failure delivery and ordinary callers; reconciliation required");
+		let _ = e.controls.get(f.workflowName);
+		await a(u, {
+			id: l,
+			sourceKind: "intent",
+			sourceId: f.id,
+			workflowName: f.workflowName,
+			tenantId: f.tenantId,
+			handler: p.every(Boolean) ? null : _?.onFailure ?? null,
+			callerContext: f.callerContext,
+			report: {
+				workflow: f.workflowName,
+				payload: c ? { items: d.map((e) => e.payload) } : f.payload,
+				reason: n,
+				failedAt: i,
+				errorTag: null,
+				errorMessage: r.slice(0, 500),
+				runId: null,
+				executionId: null
+			}
+		});
+		for (let e of d) if (await m(u, {
+			pendingId: e.id,
+			workflowName: e.workflowName,
+			tenantId: e.tenantId,
+			terminal: {
+				kind: "abandoned",
+				at: i,
+				failureId: l
+			}
+		}), !await g(u, e, r, i)) throw Error("Dead-lettered queue row disappeared before marking");
+		return await o(u, l, i), d.length;
+	});
+}, J = async (e, t, n, c, l) => {
+	let u = `wff_${B()}`;
+	return e.transaction(async (e) => {
+		let d = [];
+		for (let r of t) {
+			let t = await e.query({
+				table: h,
+				predicate: z("id", r.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0,
+				lock: "update"
+			});
+			if (t[0] === void 0) return 0;
+			let i = O(t[0]);
+			if (i.workflowName !== n.workflowName || i.tenantId !== r.tenantId) throw Error("Expired queue selection belongs to another workflow or tenant");
+			if (i.mode !== r.mode || i.dueAt > c || i.deadLetteredAt !== void 0) return 0;
+			d.push(i);
+		}
+		d.sort((e, t) => e.firstSeenAt - t.firstSeenAt || e.id.localeCompare(t.id));
+		let f = d[0];
+		if (f === void 0 || !r(n, f, c)) return 0;
+		let p = await Promise.all(d.map((t) => s(e, t.id)));
+		if (p.some(Boolean) && !p.every(Boolean)) throw Error("Expired batch mixes failure delivery and ordinary callers; reconciliation required");
+		let g = `timeouts.start (${n.timeouts?.startMs}ms) elapsed while ${d.length} queued input(s) waited`;
+		await a(e, {
+			id: u,
+			sourceKind: "intent",
+			sourceId: f.id,
+			workflowName: f.workflowName,
+			tenantId: f.tenantId,
+			handler: p.every(Boolean) ? null : n.onFailure ?? null,
+			callerContext: f.callerContext,
+			report: {
+				workflow: f.workflowName,
+				payload: l ? { items: d.map((e) => e.payload) } : f.payload,
+				reason: g,
+				failedAt: c,
+				errorTag: null,
+				errorMessage: null,
+				runId: null,
+				executionId: null
+			}
+		}), await T({
+			store: e,
+			control: n,
+			keys: i(n, _(e, f.workflowName, f.payload)),
+			outcome: "expired",
+			mode: f.mode,
+			reason: g,
+			collapsed: d.reduce((e, t) => e + t.collapsed, 0),
+			waitedMs: c - f.firstSeenAt,
+			executionId: null,
+			runId: null,
+			tenantId: f.tenantId,
+			now: c
+		});
+		for (let t of d) if (await m(e, {
+			pendingId: t.id,
+			workflowName: t.workflowName,
+			tenantId: t.tenantId,
+			terminal: {
+				kind: "abandoned",
+				at: c,
+				failureId: u
+			}
+		}), !await e.delete("_voltro_workflow_pending", t.id)) throw Error("Expired queue row disappeared before deletion");
+		return await o(e, u, c), d.length;
+	});
+}, Y = async (e, t, n, a, o) => {
+	if (t = {
+		...t,
+		payload: _(e.store, t.workflowName, t.payload)
+	}, t.mode === "delayed") return X(e, t, n, a, o);
+	let s = e.controls.get(t.workflowName);
+	if (s === void 0) {
+		a.expired += await K(e, [t], o);
+		return;
+	}
+	if (r(s, t, o)) {
+		a.expired += await J(e, [t], s, o, !1);
+		return;
+	}
+	let c = i(s, t.payload), l = await b({
+		store: e.store,
+		control: s,
+		keys: c,
+		paused: n.has(t.workflowName),
+		now: o,
+		reconsidering: !0
+	});
+	await Q(e, {
+		control: s,
+		intent: t,
+		decision: l,
+		keys: c,
+		counters: a,
+		now: o,
+		paused: n,
+		items: void 0
+	});
+}, X = async (e, t, n, r, i) => {
+	if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
+		r.expired += await K(e, [t], i);
+		return;
+	}
+	let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = u(), s = await e.transaction(async (e) => {
+		let r = await e.query({
+			table: h,
+			predicate: z("id", t.id),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r[0] === void 0) return;
+		let s = O(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 M({
+			store: e,
+			control: a,
+			payload: _(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 L(e, {
+			from: s.id,
+			to: c.intentId,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId
+		}), !await v(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 ? y(e, s.workflowName, c.payload) : { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(c.payload).items.map((t) => y(e, s.workflowName, t)) };
+			return {
+				kind: "submission",
+				submission: await A(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 m(e, {
+			pendingId: s.id,
+			workflowName: s.workflowName,
+			tenantId: s.tenantId,
+			terminal: {
+				...c,
+				at: i
+			}
+		}), !await v(e, s.id))) throw Error("Delayed arrival disappeared while recording its outcome");
+		return c;
+	});
+	s !== void 0 && (s.kind === "queued" ? r.deferred++ : s.kind === "dropped" ? r.dropped++ : s.kind === "skipped" ? r.skipped++ : await $(e, s.submission, a, r, i, a.batch !== void 0, s.keys));
+}, Z = async (e, t, n, a, o) => {
+	t = t.map((t) => ({
+		...t,
+		payload: _(e.store, t.workflowName, t.payload)
+	}));
+	let s = t[0];
+	if (s === void 0) return;
+	let c = e.controls.get(s.workflowName);
+	if (c === void 0 || c.batch === void 0) {
+		a.expired += await K(e, t, o);
+		return;
+	}
+	let l = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), u = l[0];
+	if (r(c, u, o)) {
+		a.expired += await J(e, l, c, o, !0);
+		return;
+	}
+	let d = i(c, u.payload);
+	await Q(e, {
+		control: c,
+		intent: u,
+		decision: await b({
+			store: e.store,
+			control: c,
+			keys: d,
+			paused: n.has(s.workflowName),
+			now: o,
+			reconsidering: !0
+		}),
+		keys: d,
+		counters: a,
+		now: o,
+		paused: n,
+		items: l
+	});
+}, Q = async (e, t) => {
+	let { control: n, intent: r, decision: a, keys: o, counters: s, now: c, items: l, paused: d } = t;
+	if (a.kind === "defer") {
+		await C({
+			store: e.store,
+			control: n,
+			decision: a,
+			payload: r.payload,
+			callerContext: r.callerContext,
+			tenantId: r.tenantId,
+			now: c,
+			existingId: r.id
+		}), s.deferred++;
+		return;
+	}
+	if (a.kind === "drop" || a.kind === "skip") {
+		let t = await e.transaction(async (e) => {
+			let t = [];
+			for (let i of l ?? [r]) {
+				let a = await e.query({
+					table: h,
+					predicate: z("id", i.id),
+					lock: "update",
+					order: [],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				});
+				if (a[0] === void 0) return;
+				let o = O(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 > c || o.deadLetteredAt !== void 0 || o.mode !== i.mode) return;
+				t.push(o);
+			}
+			t.sort((e, t) => e.firstSeenAt - t.firstSeenAt);
+			let a = t[0], o = i(n, _(e, n.workflowName, a.payload)), s = await b({
+				store: e,
+				control: n,
+				keys: o,
+				paused: d.has(n.workflowName) || (await w(e)).has(n.workflowName),
+				now: c,
+				reconsidering: !0
+			});
+			if (s.kind !== "drop" && s.kind !== "skip") return;
+			let u = s.kind === "drop" ? {
+				kind: "dropped",
+				at: c,
+				retryAfterMs: s.retryAfterMs
+			} : {
+				kind: "skipped",
+				at: c,
+				executionId: s.incumbent.executionId,
+				runId: s.incumbent.runId
+			};
+			await T({
+				store: e,
+				control: n,
+				keys: o,
+				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: c - a.firstSeenAt,
+				executionId: u.kind === "skipped" ? u.executionId : null,
+				runId: u.kind === "skipped" && u.runId || null,
+				tenantId: r.tenantId,
+				now: c
+			});
+			for (let n of t) if (await m(e, {
+				pendingId: n.id,
+				workflowName: n.workflowName,
+				tenantId: n.tenantId,
+				terminal: u
+			}), !await v(e, n.id)) throw Error("Queued input disappeared while recording its terminal outcome");
+			return u.kind;
+		});
+		t !== void 0 && s[t]++;
+		return;
+	}
+	let f = u(), p = await e.transaction((t) => j(t, {
+		id: f,
+		workflowName: n.workflowName,
+		tenantId: r.tenantId,
+		intentIds: (l ?? [r]).map((e) => e.id),
+		now: c,
+		prepare: (t) => {
+			let r = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), i = r[0], a = _(e.store, n.workflowName, i.payload);
+			return {
+				control: n,
+				keyPayload: a,
+				encodedPayload: l === void 0 ? i.payload : { items: r.map((e) => e.payload) },
+				callerContext: i.callerContext,
+				paused: d.has(n.workflowName),
+				firstSeenAt: i.firstSeenAt,
+				collapsed: r.reduce((e, t) => e + t.collapsed, 0),
+				mode: i.mode
+			};
+		}
+	}));
+	p.kind !== "selection-unavailable" && (p.kind === "not-admitted" ? s.deferred++ : await $(e, p.submission, n, s, c, l !== void 0, o));
+}, ee = async (e, t, n, r, i) => {
+	let a = await e.transaction((e) => f(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 $(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) => f(e, t.id));
+	if (o?.executionId == null || o.executionId !== o.preparedExecutionId) throw Error("Admission submission has no confirmed engine acceptance");
+	return o.executionId;
+}, $ = async (e, t, n, r, i, a, o) => {
+	let s = t.dispatchAttempts === 0 ? 0 : void 0, u = t.retry.recovery?.attempts ?? 0;
+	try {
+		if (e.acquireSubmissionCapacity !== void 0 && !await e.acquireSubmissionCapacity(t)) {
+			r.deferred++;
+			return;
+		}
+		let d = a ? { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(t.payload).items.map((t) => _(e.store, n.workflowName, t)) } : _(e.store, n.workflowName, t.payload), f = await N(e, t, d), p = await e.transaction((n) => l(n, t.id, e.now?.() ?? Date.now()));
+		if (p === null) return;
+		u = p.retry.recovery?.attempts ?? 0, s = p.dispatchAttempts === 1 ? 1 : void 0;
+		let m = await e.startAdmitted(n.workflowName, d, t.callerContext, f);
+		if (s = void 0, m.executionId !== f) 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 E(e.store, t.eviction.executionId, i), await T({
+			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) => c(e, t.id, {
+			executionId: m.executionId,
+			runId: m.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) => p(e, t.id, o, {
+					handler: n.onFailure ?? null,
+					errorMessage: String(r),
+					now: i
+				}, u)) !== void 0;
+			}
+			if (!a) {
+				let n = await e.transaction((n) => d(n, t.id, String(r), i, e.deadLetterAfterAttempts ?? 50, u));
+				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 U(t.id, AggregateError([r, e], "Submission and retry recording failed"));
+		}
+		throw new U(t.id, r, a);
+	}
+}, te = async (e, t) => {
+	if (e.listRunningRuns === void 0) return { cancelled: 0 };
+	let r = 0, i;
+	for (let a of e.controls.values()) {
+		if (a.timeouts?.finishMs === void 0) continue;
+		let o = await e.listRunningRuns(a.workflowName);
+		for (let s of o) {
+			if (!n(a, {
+				startedAt: s.startedAt,
+				terminal: !1
+			}, t)) {
+				let e = s.startedAt + a.timeouts.finishMs;
+				(i === void 0 || e < i) && (i = e);
+				continue;
+			}
+			let o = `timeouts.finish (${a.timeouts.finishMs}ms) elapsed; the run was cancelled after ${t - s.startedAt}ms`;
+			await e.cancelRun({
+				workflowName: s.workflowName,
+				runId: s.runId,
+				executionId: s.executionId,
+				reason: o,
+				detail: {
+					...k,
+					onFailure: a.onFailure ?? null
+				}
+			}) && (await E(e.store, s.executionId, t), r++);
+		}
+	}
+	return {
+		cancelled: r,
+		...i === void 0 ? {} : { nextDeadlineAt: i }
+	};
+};
+//#endregion
+export { H as DEFAULT_DRAIN_BATCH, ee as acceptAdmissionSubmission, G as drainTick, W as isUnacknowledgedSubmission };