@voltro/workflow 0.85.0 → 0.86.0

package/dist/runsTable.js

@@ -0,0 +1,42 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+//#region src/runsTable.ts
+var s = i("_voltro_workflow_runs", {
+	id: t({ prefix: "wfrun" }),
+	tag: a(),
+	executionId: a().unique(),
+	status: a().oneOf([
+		"running",
+		"succeeded",
+		"failed",
+		"cancelled",
+		"suspended"
+	]).default("running"),
+	payload: r(),
+	workflowVersion: a().nullable(),
+	workflowPatches: r().nullable(),
+	runnerEnteredAt: o().nullable(),
+	runnerGeneration: a().nullable(),
+	engineDelivery: r().nullable(),
+	reclaimCount: n().default(0),
+	output: r().nullable(),
+	subject: r().nullable(),
+	source: a().nullable(),
+	errorTag: a().nullable(),
+	errorMessage: a().nullable(),
+	cancelled: e().default(!1),
+	discardedAt: o().nullable(),
+	discardedBy: a().nullable(),
+	startedAt: o().default("now"),
+	completedAt: o().nullable(),
+	durationMs: n().nullable(),
+	traceId: a().nullable(),
+	parentExecutionId: a().nullable(),
+	parentGeneration: a().nullable(),
+	parentClosePolicy: a().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable()
+}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]);
+//#endregion
+export { s as _voltroWorkflowRunsTable };

package/dist/scheduleDeclaration.js

@@ -0,0 +1,44 @@
+import { Cron as e, Duration as t, Result as n } from "effect";
+//#region src/scheduleDeclaration.ts
+var r = 864e5, i = /* @__PURE__ */ new Set([
+	"skip",
+	"buffer",
+	"cancelOther"
+]), a = /* @__PURE__ */ new Set([
+	"skip",
+	"latest",
+	"all"
+]), o = (t, o) => {
+	if (o === void 0) return;
+	if (typeof o.timezone != "string" || o.timezone.trim() === "") throw Error(`workflow '${t}': schedule.timezone is required (e.g. "UTC", "Europe/Berlin") — never server-local, which differs between your machine and the container.`);
+	let c = e.parse(o.cron, o.timezone);
+	if (n.isFailure(c)) throw Error(`workflow '${t}': schedule.cron "${o.cron}" (tz="${o.timezone}") is not a valid cron expression — ${String(c.failure)}`);
+	let l = o.onOverlap ?? "skip";
+	if (!i.has(l)) throw Error(`workflow '${t}': schedule.onOverlap must be 'skip' | 'buffer' | 'cancelOther', got ${JSON.stringify(l)}`);
+	let u = o.backfill ?? "skip";
+	if (!a.has(u)) throw Error(`workflow '${t}': schedule.backfill must be 'skip' | 'latest' | 'all', got ${JSON.stringify(u)}`);
+	let d = r;
+	return o.maxRuntime !== void 0 && (d = s(o.maxRuntime, t)), {
+		cron: o.cron,
+		timezone: o.timezone,
+		...o.payload === void 0 ? {} : { payload: o.payload },
+		onOverlap: l,
+		backfill: u,
+		maxRuntimeMs: d
+	};
+}, s = (e, n) => {
+	let r;
+	try {
+		r = t.toMillis(t.fromInputUnsafe(e));
+	} catch {
+		throw Error(`workflow '${n}': schedule.maxRuntime is not a duration Effect can read (got ${JSON.stringify(e)}). Use '2 hours', a number of milliseconds, or a Duration.`);
+	}
+	if (!Number.isFinite(r) || r <= 0) throw Error(`workflow '${n}': schedule.maxRuntime must be a positive finite duration`);
+	return r;
+}, c = "__voltroWorkflowSchedule", l = (e) => {
+	if (typeof e != "object" && typeof e != "function" || e === null) return;
+	let t = e[c];
+	return t === void 0 ? void 0 : t;
+};
+//#endregion
+export { r as DEFAULT_WORKFLOW_SCHEDULE_MAX_RUNTIME_MS, c as WorkflowScheduleProperty, l as getWorkflowSchedule, o as validateWorkflowSchedule };

package/dist/signalHint.js

@@ -0,0 +1,23 @@
+//#region src/signalHint.ts
+var e = 3e5, t, n = (e) => {
+	t = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
+}, r = () => {
+	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 t ?? 3e5;
+}, i = /* @__PURE__ */ new Set(), a = () => {
+	i.clear();
+}, o = (e) => {
+	let t = r();
+	if (!(e.timeoutMs > t)) return !1;
+	let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
+	if (i.has(n)) return !1;
+	i.add(n);
+	let a = e.workflowName === void 0 ? "" : ` in workflow '${e.workflowName}'`;
+	return (e.warn ?? ((e) => console.warn(e)))(`awaitSignal('${e.signalName}')${a} 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;
+};
+//#endregion
+export { e as DEFAULT_SUSPEND_HINT_MS, o as maybeHintSuspendingSignal, a as resetSuspendHintsForTest, r as resolveSuspendHintMs, n as setSuspendSignalHintMs };

package/dist/signals.js

@@ -0,0 +1,70 @@
+import { encryptionAwareActivity as e, openEventPayload as t } from "./journalEncryption.js";
+import { CurrentWorkflowRunId as n, WorkflowRunRecorder as r } from "./recorder.js";
+import { maybeHintSuspendingSignal as i } from "./signalHint.js";
+import { Effect as a, Schema as o } from "effect";
+import { and as s, eq as c } from "@voltro/database";
+import { WorkflowInstance as l } from "effect/workflow/WorkflowEngine";
+//#region src/signals.ts
+var u = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, d = (d, f) => {
+	let p = a.gen(function* () {
+		let e = f.pollIntervalMs ?? 200, p = f.maxPollIntervalMs ?? 5e3, m = f.timeoutMs ?? 864e5, h = yield* a.serviceOption(l), g;
+		i({
+			workflowName: h._tag === "Some" ? h.value.workflow._tag : void 0,
+			signalName: f.name,
+			timeoutMs: m,
+			warn: (e) => {
+				g = e;
+			}
+		}), g !== void 0 && (yield* a.logWarning(g));
+		let _ = yield* n, v = yield* a.serviceOption(r), y = v._tag === "Some" ? v.value : void 0;
+		if (_ === void 0) return yield* a.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
+		let b = _;
+		yield* a.promise(() => u(y, {
+			runId: b,
+			eventType: "signal-awaited",
+			payload: { signalName: f.name }
+		}));
+		let x = Date.now(), S = e;
+		for (;;) {
+			let e = Date.now() - x;
+			if (e > m) return yield* a.die(/* @__PURE__ */ Error(`awaitSignal('${f.name}') timed out after ${e}ms`));
+			let n = {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: s(c("runId", b), c("eventType", "signal-sent")),
+				projection: void 0,
+				skip: void 0,
+				take: 1e3
+			}, r = (yield* a.tryPromise({
+				try: () => d.store.query(n),
+				catch: (e) => e
+			})).find((e) => e.payload?.signalName === f.name);
+			if (r !== void 0) {
+				let e = t(r.payload)?.value, n = yield* o.decodeUnknownEffect(f.schema)(e);
+				return yield* a.promise(() => u(y, {
+					runId: b,
+					eventType: "signal-received",
+					payload: {
+						signalName: f.name,
+						value: e
+					}
+				})), n;
+			}
+			yield* a.sleep(`${S} millis`), S = Math.min(S * 2, p);
+		}
+	});
+	return e({
+		name: `await-signal:${f.name}`,
+		success: f.schema,
+		execute: p
+	});
+};
+//#endregion
+export { d as awaitSignal };

package/dist/signalsSuspending.js

@@ -0,0 +1,57 @@
+import { isWorkflowEncrypted as e, sealedSchema as t } from "./journalEncryption.js";
+import { CurrentWorkflowRunId as n, WorkflowRunRecorder as r } from "./recorder.js";
+import { SuspensionUnavailable as i, WorkflowCannotPark as a } from "./suspensionUnavailable.js";
+import { resolveWorkflowMessageRun as o } from "./messages.js";
+import { DurableClock as s, DurableDeferred as c, Workflow as l, WorkflowEngine as u } from "effect/workflow";
+import { Cause as d, Effect as f, Exit as p, Schema as m } from "effect";
+//#region src/signalsSuspending.ts
+var h = 864e5, g = "voltro/suspending-signal", _ = (e, t) => `${g}/${e}/${t}`, v = (n, r) => c.make(n, { success: e(r) ? t(m.Unknown, `signal '${n}' value`) : m.Unknown }), y = async (e, t) => {
+	if (e) try {
+		await e.recordEvent(t);
+	} catch {}
+}, b = (e, t) => f.gen(function* () {
+	let e = yield* i;
+	if (e !== void 0) return yield* f.die(new a(`awaitSignalSuspending('${t.name}')`, e));
+	let o = t.timeoutMs ?? h, p = yield* u.WorkflowInstance, g = v(_(p.workflow._tag, t.name), p.workflow._tag), b = yield* n, x = yield* f.serviceOption(r), S = x._tag === "Some" ? x.value : void 0;
+	b !== void 0 && (yield* f.promise(() => y(S, {
+		runId: b,
+		eventType: "signal-awaited",
+		payload: { signalName: t.name }
+	})));
+	let C = c.await(g), w = Number.isFinite(o) ? yield* f.race(C, s.sleep({
+		name: `await-signal-timeout/${t.name}`,
+		inMemoryThreshold: "0 millis",
+		duration: `${o} millis`
+	}).pipe(f.andThen(f.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${t.name}') timed out after ${o}ms`))))).pipe(f.catchCause((e) => p.suspended ? d.hasInterruptsOnly(e) ? l.suspend(p) : f.failCause(d.fromReasons(e.reasons.filter((e) => !d.isInterruptReason(e)))) : f.failCause(e))) : yield* C, T = yield* m.decodeUnknownEffect(t.schema)(w);
+	return b !== void 0 && (yield* f.promise(() => y(S, {
+		runId: b,
+		eventType: "signal-received",
+		payload: {
+			signalName: t.name,
+			value: T
+		}
+	}))), T;
+}), x = (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: () => o(r, e.target),
+			catch: (e) => e
+		});
+		t ??= i.executionId, n ??= i.tag;
+	}
+	if (t === void 0 || n === void 0) return { completed: !1 };
+	let r = _(n, e.signalName), i = v(r, n), a = new c.TokenParsed({
+		workflowName: n,
+		executionId: t,
+		deferredName: r
+	}).asToken;
+	return yield* c.done(i, {
+		token: a,
+		exit: p.succeed(e.payload)
+	}), { completed: !0 };
+});
+//#endregion
+export { b as awaitSignalSuspending, x as completeSuspendingSignal, _ as suspendingSignalDeferredName };

package/dist/sqliteWorkflowOwnership.js

@@ -0,0 +1,26 @@
+import { Effect as e } from "effect";
+import { realpath as t } from "node:fs/promises";
+//#region src/sqliteWorkflowOwnership.ts
+var n = (n) => e.gen(function* () {
+	let i = yield* e.tryPromise({
+		try: () => t(n),
+		catch: r
+	}), a = yield* e.acquireRelease(e.tryPromise({
+		try: async () => {
+			let { DatabaseSync: e } = await import("node:sqlite");
+			return new e(`${i}.voltro-workflow-lock`);
+		},
+		catch: r
+	}), (t) => e.sync(() => t.close()));
+	yield* e.try({
+		try: () => {
+			a.exec("PRAGMA busy_timeout=0"), a.exec("CREATE TABLE IF NOT EXISTS workflow_mutex(id INTEGER PRIMARY KEY)"), a.exec("BEGIN IMMEDIATE");
+		},
+		catch: (e) => {
+			let t = r(e), n = t.errcode;
+			return n !== void 0 && ((n & 255) == 5 || (n & 255) == 6) ? Error("SQLite workflow journal is already owned by another engine. Stop that engine before starting another, or use a SQL dialect with shared runner coordination for replicas.", { cause: t }) : Error(`Could not acquire SQLite workflow ownership for ${i}`, { cause: t });
+		}
+	});
+}), r = (e) => e instanceof Error ? e : Error(String(e));
+//#endregion
+export { n as acquireSqliteWorkflowOwnership };

package/dist/stalenessSweep.js

@@ -0,0 +1,191 @@
+import { and as e, eq as t, gt as n, inSet as r, lt as i, or as a } from "@voltro/database";
+//#region src/stalenessSweep.ts
+var o = 18e5, s = 200, c = 20, l = (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;
+	}
+}, u = (e) => e instanceof Error ? e.message : String(e), d = async (e, n, r) => (await e.query({
+	table: "_voltro_workflow_run_events",
+	predicate: t("runId", n),
+	order: [{
+		column: "occurredAt",
+		direction: "desc"
+	}],
+	take: r,
+	skip: void 0,
+	projection: void 0
+})).flatMap((e) => {
+	let t = e, n = l(t.occurredAt);
+	return typeof t.eventType != "string" || n === void 0 ? [] : [{
+		eventType: t.eventType,
+		occurredAt: n,
+		payload: t.payload
+	}];
+}), f = async (e, n) => {
+	let r = (await e.query({
+		table: "_voltro_workflow_run_steps",
+		predicate: t("runId", n),
+		order: [{
+			column: "startedAt",
+			direction: "desc"
+		}],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}))[0];
+	if (r === void 0) return;
+	let i = l(r.startedAt), a = l(r.completedAt);
+	return i === void 0 ? a : a === void 0 ? i : a.getTime() > i.getTime() ? a : i;
+}, p = (e, t) => {
+	for (let n of e) {
+		if (n.eventType === "timer-fired") return !1;
+		if (n.eventType !== "timer-set") continue;
+		let e = l(n.payload?.scheduledWakeAt);
+		return e !== void 0 && e.getTime() > t;
+	}
+	return !1;
+}, m = (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";
+}, h = async (o, s = {}) => {
+	let c = o.now?.() ?? Date.now(), h = s.stallAfterMs ?? 18e5, g = s.runPage ?? 200, _ = s.eventLookback ?? 20, v = new Date(c - h), y = [], b = [], x = 0, S = 0, C, w;
+	try {
+		if (!Number.isSafeInteger(g) || g < 1) throw Error("Staleness run page must be a positive integer");
+		let c = s.afterRun;
+		if (c !== void 0 && (!(c.startedAt instanceof Date) || !Number.isFinite(c.startedAt.getTime()) || typeof c.runId != "string" || c.runId.length === 0)) throw Error("Invalid staleness run cursor");
+		C = await o.store.query({
+			table: "_voltro_workflow_runs",
+			predicate: e(r("status", ["running", "suspended"]), i("startedAt", v), ...c === void 0 ? [] : [a(n("startedAt", c.startedAt), e(t("startedAt", c.startedAt), n("id", c.runId)))]),
+			order: [{
+				column: "startedAt",
+				direction: "asc"
+			}, {
+				column: "id",
+				direction: "asc"
+			}],
+			take: g,
+			skip: void 0,
+			projection: void 0
+		});
+		let u = c;
+		for (let e of C) {
+			let t = l(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 (u !== void 0 && (t.getTime() < u.startedAt.getTime() || t.getTime() === u.startedAt.getTime() && e.id <= u.runId)) throw Error("Staleness candidate page did not advance");
+			u = {
+				startedAt: t,
+				runId: e.id
+			};
+		}
+		C.length >= g && (w = u);
+	} catch (e) {
+		return {
+			examined: 0,
+			stalled: [],
+			alreadyReported: 0,
+			waitingOnTimer: 0,
+			sawFullRunPage: !1,
+			failures: [{
+				subject: "_voltro_workflow_runs",
+				detail: u(e)
+			}]
+		};
+	}
+	for (let e of C) {
+		let t = e, n = l(t.startedAt);
+		if (typeof t.id != "string" || typeof t.tag != "string" || typeof t.executionId != "string" || typeof t.status != "string" || n === void 0) continue;
+		let r, i;
+		try {
+			r = await d(o.store, t.id, _), i = await f(o.store, t.id);
+		} catch (e) {
+			y.push({
+				subject: t.id,
+				detail: u(e)
+			});
+			continue;
+		}
+		if (p(r, c)) {
+			S += 1;
+			continue;
+		}
+		let a = r.find((e) => e.eventType !== "run-stalled")?.occurredAt, s = n;
+		for (let e of [i, a]) e !== void 0 && e.getTime() > s.getTime() && (s = e);
+		let g = c - s.getTime();
+		if (g < h) continue;
+		if (r.some((e) => e.eventType === "run-stalled" && e.occurredAt.getTime() > s.getTime())) {
+			x += 1;
+			continue;
+		}
+		let v = {
+			runId: t.id,
+			tag: t.tag,
+			executionId: t.executionId,
+			status: t.status,
+			lastProgressAt: s,
+			idleMs: g,
+			reason: m(t.status, r)
+		};
+		b.push(v);
+		let C = {};
+		if (o.describeRun !== void 0) try {
+			C = await o.describeRun(v) ?? {};
+		} catch (e) {
+			y.push({
+				subject: `${v.runId}:describeRun`,
+				detail: u(e)
+			});
+		}
+		if (o.log?.warn("workflow.staleness: run has made no progress", {
+			workflow: v.tag,
+			runId: v.runId,
+			idleMs: v.idleMs,
+			reason: v.reason,
+			...C
+		}), o.recordEvent !== void 0) try {
+			await o.recordEvent({
+				runId: v.runId,
+				eventType: "run-stalled",
+				payload: {
+					idleMs: v.idleMs,
+					stallAfterMs: h,
+					lastProgressAt: v.lastProgressAt.toISOString(),
+					reason: v.reason,
+					tag: v.tag,
+					executionId: v.executionId,
+					...C
+				}
+			});
+		} catch (e) {
+			y.push({
+				subject: v.runId,
+				detail: u(e)
+			});
+		}
+		if (o.onStalled !== void 0) try {
+			await o.onStalled(v);
+		} catch (e) {
+			y.push({
+				subject: `${v.runId}:onStalled`,
+				detail: u(e)
+			});
+		}
+	}
+	return {
+		examined: C.length,
+		stalled: b,
+		alreadyReported: x,
+		waitingOnTimer: S,
+		sawFullRunPage: C.length >= g,
+		failures: y,
+		...w === void 0 ? {} : { nextRun: w }
+	};
+};
+//#endregion
+export { o as DEFAULT_STALL_AFTER_MS, c as DEFAULT_STALL_EVENT_LOOKBACK, s as DEFAULT_STALL_RUN_PAGE, h as sweepStalledRuns };

package/dist/startContextsTable.js

@@ -0,0 +1,20 @@
+import { id as e, json as t, table as n, text as r, timestamp as i } from "@voltro/database";
+//#region src/startContextsTable.ts
+var a = n("_voltro_workflow_start_contexts", {
+	id: e({ prefix: "wfctx" }),
+	workflowName: r(),
+	executionId: r().unique(),
+	subject: t().nullable(),
+	traceId: r().nullable(),
+	source: r().nullable(),
+	parentExecutionId: r().nullable(),
+	parentGeneration: r().nullable(),
+	parentClosePolicy: r().oneOf([
+		"cancel",
+		"terminate",
+		"abandon"
+	]).nullable(),
+	createdAt: i().default("now")
+}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]);
+//#endregion
+export { a as _voltroWorkflowStartContextsTable };

package/dist/startReceipt.js

@@ -0,0 +1,143 @@
+import { readWorkflowFailureRecord as e } from "./failureReportStore.js";
+import { readAdmissionSubmission as t } from "./admissionSubmission.js";
+import { readProvenSubmissionRejection as n } from "./submissionRejection.js";
+import { PENDING_TABLE as r, toPendingIntent as i } from "./admissionStore.js";
+import { Schema as a } from "effect";
+import { WorkflowStartTerminalOutcomeSchema as o } from "@voltro/protocol";
+import { and as s, eq as c, isNull as l } from "@voltro/database";
+//#region src/startReceipt.ts
+var u = "_voltro_workflow_start_receipts", d = class extends Error {
+	_tag = "WorkflowStartRequestConflictError";
+	constructor() {
+		super("Workflow start request identity belongs to a different start"), this.name = "WorkflowStartRequestConflictError";
+	}
+}, f = a.Struct({
+	id: a.String,
+	workflowName: a.String,
+	tenantId: a.NullOr(a.String),
+	pendingId: a.String,
+	submissionId: a.NullOr(a.String),
+	terminal: a.NullOr(o),
+	requestFingerprint: a.optional(a.NullOr(a.String.pipe(a.check(a.isPattern(/^[a-f0-9]{64}$/)))))
+}).pipe(a.check(a.makeFilter((e) => e.submissionId === null || e.terminal === null, { message: "A start receipt cannot be both submitted and terminal before admission" }))), p = a.decodeUnknownSync(f), m = async (e, t) => {
+	let n = await e.query({
+		table: u,
+		predicate: c("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return n[0] === void 0 ? void 0 : p(n[0]);
+}, h = async (e, t) => {
+	if (t.id.trim().length === 0 || !/^[a-f0-9]{64}$/.test(t.requestFingerprint)) throw Error("Workflow start request requires an identity and a SHA-256 fingerprint");
+	let n = await m(e, t.id);
+	if (n !== void 0) {
+		if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.requestFingerprint !== t.requestFingerprint) throw new d();
+		return n;
+	}
+}, g = async (a, o) => {
+	let s = await m(a, o.receiptId);
+	if (s === void 0 || s.workflowName !== o.workflowName || s.tenantId !== o.tenantId) throw Error("Workflow start receipt is missing or belongs to another workflow or tenant");
+	if (s.terminal !== null) {
+		if (s.terminal.kind === "abandoned") {
+			let t = await e(a, s.terminal.failureId);
+			if (t === void 0 || t.workflowName !== s.workflowName || t.tenantId !== s.tenantId || t.sourceKind !== "intent" || t.report.executionId !== null || t.report.runId !== null) throw Error("Abandoned workflow receipt has no matching failure report");
+		}
+		return {
+			kind: "terminal",
+			outcome: s.terminal
+		};
+	}
+	if (s.submissionId === null) {
+		let e = await a.query({
+			table: r,
+			predicate: c("id", s.pendingId),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (e[0] === void 0) throw Error("Workflow receipt has no pending input or submission");
+		let t = i(e[0]);
+		if (t.workflowName !== s.workflowName || t.tenantId !== s.tenantId) throw Error("Workflow receipt pending input belongs to another workflow or tenant");
+		if (t.deadLetteredAt !== void 0) throw Error("Workflow receipt input is dead-lettered; reconciliation required");
+		return { kind: "pending" };
+	}
+	let l = await t(a, s.submissionId);
+	if (l === void 0 || !l.receiptsBound || l.workflowName !== s.workflowName || l.tenantId !== s.tenantId || !l.intentIds.includes(s.pendingId)) throw Error("Workflow receipt has no matching admission submission");
+	if (l.failureId !== null) return {
+		kind: "rejected",
+		failureId: await n(a, l)
+	};
+	if (l.executionId === null) {
+		if (l.retry.stoppedAt !== null) throw Error("Workflow start acceptance is unresolved; reconciliation required");
+		return { kind: "pending" };
+	}
+	if (l.executionId.length === 0 || l.executionId !== l.preparedExecutionId) throw Error("Workflow start acknowledgement contradicts its prepared identity");
+	return {
+		kind: "accepted",
+		executionId: l.executionId
+	};
+}, _ = async (e, t) => {
+	if (t.id.length === 0 || t.id === t.pendingId) throw Error("Workflow start receipt requires an identity distinct from its queue slot");
+	if (t.requestFingerprint != null && !/^[a-f0-9]{64}$/.test(t.requestFingerprint)) throw Error("Workflow start request requires a SHA-256 fingerprint");
+	let n = p((await e.insertIgnoreWithOutcome(u, {
+		...t,
+		requestFingerprint: t.requestFingerprint ?? null,
+		submissionId: null,
+		terminal: null
+	}, { conflictColumns: ["id"] })).row);
+	if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.pendingId !== t.pendingId || (n.requestFingerprint ?? null) !== (t.requestFingerprint ?? null)) throw Error("Workflow start receipt identity belongs to a different start");
+	return n;
+}, v = async (e, n) => {
+	let r = await t(e, n);
+	if (r === void 0) throw Error("Cannot bind receipts to an unknown admission submission");
+	if (r.receiptsBound) return 0;
+	let i = 0;
+	for (let t of new Set(r.intentIds)) for (;;) {
+		let n = await e.query({
+			table: u,
+			predicate: s(c("pendingId", t), l("submissionId"), l("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (n.length === 0) break;
+		for (let t of n) {
+			let n = p(t);
+			if (n.workflowName !== r.workflowName || n.tenantId !== r.tenantId) throw Error("Pending receipt belongs to a different workflow or tenant");
+			if (await e.update("_voltro_workflow_start_receipts", n.id, { submissionId: r.id }) === null) throw Error("Workflow start receipt disappeared during queue transfer");
+			i++;
+		}
+	}
+	if (await e.update("_voltro_workflow_submissions", n, { receiptsBound: !0 }) === null) throw Error("Admission submission disappeared during receipt binding");
+	return i;
+}, y = async (e, t) => {
+	let n = a.decodeUnknownSync(o)(t.terminal);
+	for (;;) {
+		let r = await e.query({
+			table: u,
+			predicate: s(c("pendingId", t.pendingId), l("submissionId"), l("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (r.length === 0) return;
+		for (let i of r) {
+			let r = p(i);
+			if (r.workflowName !== t.workflowName || r.tenantId !== t.tenantId) throw Error("Terminal receipt belongs to a different workflow or tenant");
+			if (await e.update("_voltro_workflow_start_receipts", r.id, { terminal: n }) === null) throw Error("Start receipt disappeared while recording its terminal outcome");
+		}
+	}
+};
+//#endregion
+export { u as START_RECEIPTS_TABLE, d as WorkflowStartRequestConflictError, v as bindWorkflowStartReceipts, p as decodeWorkflowStartReceipt, m as readWorkflowStartReceipt, h as readWorkflowStartRequest, _ as recordWorkflowStartReceipt, g as resolveWorkflowStartReceipt, y as settlePendingStartReceipts };