@voltro/workflow 0.85.0 → 0.86.0

package/dist/failureHandoff.js

@@ -0,0 +1,183 @@
+import { isWorkflowEncrypted as e, openErrorText as t, openPayloadFields as n, sealPayloadFields as r } from "./journalEncryption.js";
+import { FAILURE_REPORTS_TABLE as i, readWorkflowFailureRecord as a } from "./failureReportStore.js";
+import { dispatchedExecutionSubmissions as o, readAdmissionSubmission as s } from "./admissionSubmission.js";
+import { START_RECEIPTS_TABLE as c, decodeWorkflowStartReceipt as l, readWorkflowStartReceipt as u, recordWorkflowStartReceipt as d } from "./startReceipt.js";
+import { PENDING_TABLE as f, parkDelayedStart as p, retryBackoffMs as m } from "./admissionStore.js";
+import { Schema as h } from "effect";
+import { and as g, eq as _, gt as v, isNull as y } from "@voltro/database";
+import { createHash as b } from "node:crypto";
+//#region src/failureHandoff.ts
+var x = async (e, t, n) => {
+	let r, a = t === "submissionId" ? _(t, n) : g(_(t, n), y("submissionId"), y("terminal"));
+	for (;;) {
+		let t = await e.query({
+			table: c,
+			predicate: r === void 0 ? a : g(a, v("id", r)),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (t.length === 0) return !1;
+		for (let n of t) {
+			let t = l(n), a = await e.query({
+				table: i,
+				predicate: _("handoffReceiptId", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			});
+			if (a.length !== 0) {
+				if (a[0]?.handler !== t.workflowName || a[0]?.tenantId !== t.tenantId) throw Error("Failure delivery receipt belongs to a different workflow or tenant");
+				return !0;
+			}
+			r = t.id;
+		}
+	}
+}, S = (e, t) => x(e, "submissionId", t), C = (e, t) => x(e, "pendingId", t), w = async (e, t, n, r) => {
+	for await (let i of o(e, t, n)) {
+		if (i.tenantId !== r) throw Error("Failure delivery belongs to a different resident tenant");
+		if (await S(e, i.id)) return !0;
+	}
+	return !1;
+}, T = h.Struct({
+	handoffReceiptId: h.NullOr(h.String),
+	handoffAttempt: h.Number.check(h.isInt(), h.isGreaterThanOrEqualTo(0)),
+	acceptedExecutionId: h.NullOr(h.NonEmptyString)
+}), E = (e, t) => `wfrc_${b("sha256").update(JSON.stringify([
+	"failure",
+	e,
+	t
+])).digest("hex").slice(0, 40)}`, D = async (e, t) => {
+	let n = await e.query({
+		table: i,
+		predicate: _("id", t),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), r = h.decodeUnknownSync(T)(n[0]);
+	if (r.handoffReceiptId === null && (r.handoffAttempt !== 0 || r.acceptedExecutionId !== null)) throw Error("Failure report has contradictory unstarted handoff metadata");
+	return r;
+}, O = (i) => {
+	if (i.handler === null || !e(i.handler)) return i.report;
+	let a = `failure report for '${i.handler}'`;
+	return r({
+		...i.report,
+		payload: n(i.report.payload, `${a}.payload`),
+		errorMessage: t(i.report.errorMessage)
+	}, a);
+}, k = async (e, t, n, r, i) => {
+	if (t.handler === null || t.handler.length === 0) throw Error("Cannot queue an unconfigured failure handler");
+	if (!Number.isSafeInteger(n) || n < 0) throw Error("Failure handoff attempt exhausted");
+	if (!Number.isFinite(r)) throw Error("Failure handoff retry deadline is invalid");
+	let a = await p({
+		store: e,
+		workflowName: t.handler,
+		payload: O(t),
+		callerContext: t.callerContext,
+		tenantId: t.tenantId,
+		at: r,
+		now: i
+	}), o = await d(e, {
+		id: E(t.id, n),
+		workflowName: t.handler,
+		tenantId: t.tenantId,
+		pendingId: a.intentId
+	});
+	if (await e.update("_voltro_workflow_failure_reports", t.id, {
+		handoffReceiptId: o.id,
+		handoffAttempt: n
+	}) === null) throw Error("Failure report disappeared during durable handoff");
+	return {
+		kind: "queued",
+		receiptId: o.id,
+		intentId: o.pendingId
+	};
+}, A = async (e, t, n) => {
+	if (!Number.isFinite(n)) throw Error("Failure handoff requires a finite timestamp");
+	let r = await a(e, t);
+	if (r === void 0) throw Error("Cannot hand off an unknown workflow failure");
+	let { handoffReceiptId: i, handoffAttempt: o, acceptedExecutionId: s } = await D(e, t);
+	if (r.handler === null) {
+		if (i !== null || s !== null) throw Error("Unconfigured failure report has a contradictory handoff");
+		return { kind: "unconfigured" };
+	}
+	if (r.handler.length === 0) throw Error("Failure report has an empty handler");
+	let c = E(t, o);
+	if (i !== null) {
+		if (i !== c) throw Error("Failure handoff receipt belongs to a different report");
+		let t = await u(e, i);
+		if (t === void 0 || t.workflowName !== r.handler || t.tenantId !== r.tenantId) throw Error("Failure report has no matching durable start receipt");
+		return {
+			kind: "queued",
+			receiptId: t.id,
+			intentId: t.pendingId
+		};
+	}
+	return k(e, r, 0, n, n);
+}, j = class extends Error {
+	reason;
+	constructor(e) {
+		super(`Workflow failure delivery requires reconciliation: ${e}`), this.reason = e;
+	}
+}, M = async (e, t, n) => {
+	let r = await A(e, t, n);
+	if (r.kind === "unconfigured") return r;
+	let i = await D(e, t), o = await u(e, r.receiptId);
+	if (o === void 0) throw Error("Failure handoff receipt disappeared during reconciliation");
+	if (i.acceptedExecutionId !== null) {
+		if (o.terminal !== null || o.submissionId === null) throw Error("Accepted failure report has no submitted receipt");
+		return {
+			kind: "accepted",
+			executionId: i.acceptedExecutionId
+		};
+	}
+	if (o.terminal !== null) {
+		if (o.terminal.kind === "cancelled") return {
+			kind: "cancelled",
+			receiptId: o.id
+		};
+		let r = await a(e, t);
+		if (r === void 0) throw Error("Failure report disappeared during retry");
+		let s = i.handoffAttempt + 1, c = Math.max(m(s, () => 1), o.terminal.kind === "dropped" ? o.terminal.retryAfterMs : 0);
+		return k(e, r, s, Math.max(n, o.terminal.at + c), n);
+	}
+	if (o.submissionId === null) {
+		let t = (await e.query({
+			table: f,
+			predicate: _("id", o.pendingId),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0];
+		if (t === void 0) throw new j("arrival-missing");
+		if (t.workflowName !== o.workflowName || t.tenantId !== o.tenantId) throw new j("arrival-owner-mismatch");
+		if (t.deadLetteredAt !== null) throw new j("arrival-dead-lettered");
+		return r;
+	}
+	let c = await s(e, o.submissionId);
+	if (c === void 0 || !c.receiptsBound || c.workflowName !== o.workflowName || c.tenantId !== o.tenantId || !c.intentIds.includes(o.pendingId)) throw Error("Failure handoff receipt has no matching admission submission");
+	if (c.failureId !== null) {
+		let r = await a(e, c.failureId);
+		if (c.executionId !== null || c.dispatchAttempts > 1 || r === void 0 || r.sourceKind !== "submission" || r.sourceId !== c.id || r.workflowName !== c.workflowName || r.tenantId !== c.tenantId || r.report.executionId !== null || r.report.runId !== null) throw new j("rejection-proof-invalid");
+		let o = await a(e, t);
+		if (o === void 0) throw Error("Failure report disappeared during rejected handler retry");
+		let s = i.handoffAttempt + 1;
+		return k(e, o, s, Math.max(n, r.report.failedAt + m(s, () => 1)), n);
+	}
+	if (c.executionId === null) return r;
+	if (c.failureId !== null || c.executionId.length === 0 || c.preparedExecutionId !== c.executionId) throw Error("Failure handler acknowledgement contradicts its prepared submission");
+	if (await e.update("_voltro_workflow_failure_reports", t, { acceptedExecutionId: c.executionId }) === null) throw Error("Failure report disappeared during acceptance acknowledgement");
+	return {
+		kind: "accepted",
+		executionId: c.executionId
+	};
+};
+//#endregion
+export { j as FailureReconciliationError, A as handoffWorkflowFailureInTransaction, w as isFailureDeliveryExecution, C as isFailureDeliveryPending, S as isFailureDeliverySubmission, M as reconcileWorkflowFailureInTransaction };

package/dist/failureMessage.js

@@ -0,0 +1,12 @@
+//#region src/failureMessage.ts
+var e = (e) => {
+	let t = e?.message;
+	if (typeof t == "string" && t.length > 0) return t;
+	if (typeof e == "object" && e && typeof e.toJSON == "function") {
+		let { _tag: t, ...n } = e.toJSON(), r = typeof t == "string" ? t : String(e);
+		return Object.keys(n).length === 0 ? r : `${r}: ${JSON.stringify(n)}`;
+	}
+	return String(e);
+};
+//#endregion
+export { e as failureMessage };

package/dist/failureRecovery.js

@@ -0,0 +1,50 @@
+import { FAILURE_REPORTS_TABLE as e } from "./failureReportStore.js";
+import { FailureReconciliationError as t, reconcileWorkflowFailureInTransaction as n } from "./failureHandoff.js";
+import { retryBackoffMs as r } from "./admissionStore.js";
+import { and as i, gt as a, isNotNull as o, isNull as s } from "@voltro/database";
+//#region src/failureRecovery.ts
+var c = /* @__PURE__ */ new WeakMap(), l = async (l, u, d) => {
+	let f = c.get(l), p = await l.store.query({
+		table: e,
+		predicate: i(o("handler"), s("acceptedExecutionId"), ...f === void 0 ? [] : [a("id", f.afterId)]),
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: d,
+		skip: void 0,
+		projection: void 0
+	}), m = 0, h = !1, g = f?.nextDueAt, _ = () => {
+		let e = u + r(1, () => 1);
+		g = Math.min(g ?? e, e);
+	};
+	for (let e of p) try {
+		if (typeof e.id != "string" || e.id.length === 0) throw Error("Failure report has no identity");
+		let t = e.id;
+		(await l.transaction((e) => n(e, t, u))).kind === "queued" && (h = !0, _());
+	} catch (n) {
+		m++, _(), l.log?.warn?.("workflow failure delivery could not be reconciled", {
+			failureId: typeof e.id == "string" ? e.id : null,
+			...n instanceof t ? { reason: n.reason } : {}
+		});
+	}
+	let v = p.at(-1);
+	return p.length === d && v !== void 0 && typeof v.id == "string" ? (c.set(l, {
+		afterId: v.id,
+		nextDueAt: g
+	}), {
+		scanned: p.length,
+		failed: m,
+		hasPending: h,
+		nextDueAt: u,
+		examined: !0
+	}) : (c.delete(l), {
+		scanned: p.length,
+		failed: m,
+		hasPending: h,
+		nextDueAt: g,
+		examined: p.length > 0
+	});
+};
+//#endregion
+export { l as recoverWorkflowFailures };

package/dist/failureReportStore.js

@@ -0,0 +1,60 @@
+import { sealErrorText as e } from "./journalEncryption.js";
+import { Schema as t } from "effect";
+import { eq as n } from "@voltro/database";
+//#region src/failureReportStore.ts
+var r = "_voltro_workflow_failure_reports", i = t.Struct({
+	id: t.String,
+	workflowName: t.String,
+	tenantId: t.NullOr(t.String),
+	sourceId: t.String,
+	sourceKind: t.Literals([
+		"submission",
+		"intent",
+		"run"
+	]),
+	handler: t.NullOr(t.String),
+	callerContext: t.Unknown,
+	report: t.Struct({
+		workflow: t.String,
+		payload: t.Unknown,
+		errorTag: t.NullOr(t.String),
+		errorMessage: t.NullOr(t.String),
+		runId: t.NullOr(t.String),
+		executionId: t.NullOr(t.String),
+		reason: t.String,
+		failedAt: t.Number
+	})
+}), a = async (e, a) => {
+	let o = await e.query({
+		table: r,
+		predicate: n("id", a),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return o[0] === void 0 ? void 0 : t.decodeUnknownSync(i)(o[0]);
+}, o = async (n, o) => {
+	if (o.id.length === 0 || o.sourceId.length === 0) throw Error("Workflow failure requires a stable report and source identity");
+	let s = await a(n, o.id);
+	if (s !== void 0) {
+		if (s.workflowName !== o.workflowName || s.tenantId !== o.tenantId || s.sourceId !== o.sourceId || s.sourceKind !== o.sourceKind) throw Error("Workflow failure identity belongs to a different source, workflow or tenant");
+		return s;
+	}
+	let c = t.decodeUnknownSync(i)(o), l = {
+		...c,
+		report: {
+			...c.report,
+			errorMessage: e(c.workflowName, c.report.errorMessage)
+		}
+	};
+	if (l.report.workflow !== l.workflowName) throw Error("Workflow failure report does not describe its owning workflow");
+	return await n.insert(r, {
+		...l,
+		handoffReceiptId: null,
+		handoffAttempt: 0,
+		acceptedExecutionId: null
+	}), l;
+};
+//#endregion
+export { r as FAILURE_REPORTS_TABLE, a as readWorkflowFailureRecord, o as recordWorkflowFailureInTransaction };

package/dist/flowControl.js

@@ -0,0 +1,142 @@
+import { sealedSchema as e } from "./journalEncryption.js";
+import { Duration as t, Schema as n } from "effect";
+//#region src/flowControl.ts
+var r = (e) => e !== void 0 && (e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0 || e.timeouts?.startMs !== void 0 || e.timeouts?.finishMs !== void 0), i = (e) => e?.cancelOn !== void 0 && e.cancelOn.length > 0, a = [
+	"debounce",
+	"batch",
+	"throttle",
+	"concurrency"
+], o = (e) => {
+	if (e === void 0) return [];
+	let t = [];
+	return e.debounce !== void 0 && t.push("debounce"), e.batch !== void 0 && t.push("batch"), e.throttle !== void 0 && t.push("throttle"), e.concurrency !== void 0 && t.push("concurrency"), t;
+}, s = (e, n, r) => {
+	let i;
+	try {
+		i = t.toMillis(t.fromInputUnsafe(e));
+	} catch {
+		throw Error(`workflow '${r}': ${n} is not a duration Effect can read (got ${JSON.stringify(e)}). Use a spelled-out unit ('15 minutes', '1 hour', '30 seconds'), a number of milliseconds, or a Duration — the abbreviated forms ('15m', '1h') are NOT accepted.`);
+	}
+	if (!Number.isFinite(i) || i <= 0) throw Error(`workflow '${r}': ${n} must be a positive finite duration, got ${String(e)}`);
+	return i;
+}, c = (e, t, n) => {
+	if (!Number.isInteger(e) || e <= 0) throw Error(`workflow '${n}': ${t} must be a positive integer, got ${String(e)}`);
+	return e;
+}, l = (e, t, n) => {
+	if (typeof e != "function") throw Error(`workflow '${n}': ${t} must be a function of the payload`);
+	return e;
+}, u = (e) => {
+	let t = e?.ast?.propertySignatures;
+	if (!Array.isArray(t)) return !1;
+	let n = t.find((e) => e.name === "items");
+	return n !== void 0 && n.type?._tag === "Arrays";
+}, d = (t) => {
+	let { workflowName: r, control: i } = t;
+	if (i === void 0) return;
+	let a = { workflowName: r };
+	if (i.debounce !== void 0) {
+		let e = i.debounce, t = s(e.period, "debounce.period", r), n = e.timeout === void 0 ? void 0 : s(e.timeout, "debounce.timeout", r);
+		if (n !== void 0 && n < t) throw Error(`workflow '${r}': debounce.timeout (${n}ms) is shorter than debounce.period (${t}ms), so the burst can never be collapsed — the run would be admitted before the quiet period could ever elapse. Raise the timeout or lower the period.`);
+		a.debounce = {
+			key: l(e.key, "debounce.key", r),
+			periodMs: t,
+			...n === void 0 ? {} : { timeoutMs: n }
+		};
+	}
+	if (i.singleton !== void 0) {
+		let e = i.singleton;
+		if (e.mode !== "skip" && e.mode !== "cancel") throw Error(`workflow '${r}': singleton.mode must be 'skip' or 'cancel'. There is no default — 'skip' discards the incoming request and 'cancel' discards the running one, and choosing for you would silently throw away work either way.`);
+		a.singleton = {
+			key: l(e.key, "singleton.key", r),
+			mode: e.mode
+		};
+	}
+	if (i.concurrency !== void 0) {
+		let e = i.concurrency;
+		if (e.pool !== void 0 && (typeof e.pool != "string" || e.pool.trim() === "")) throw Error(`workflow '${r}': concurrency.pool must be a non-empty name — it is the identity other workflows declare to share this budget, and an empty one would silently merge every empty-named pool in the deployment into one.`);
+		a.concurrency = {
+			limit: c(e.limit, "concurrency.limit", r),
+			...e.key === void 0 ? {} : { key: l(e.key, "concurrency.key", r) },
+			...e.pool === void 0 ? {} : { pool: e.pool.trim() }
+		};
+	}
+	if (i.throttle !== void 0) {
+		let e = i.throttle;
+		a.throttle = {
+			limit: c(e.limit, "throttle.limit", r),
+			periodMs: s(e.period, "throttle.period", r),
+			...e.key === void 0 ? {} : { key: l(e.key, "throttle.key", r) }
+		};
+	}
+	if (i.rateLimit !== void 0) {
+		let e = i.rateLimit;
+		a.rateLimit = {
+			limit: c(e.limit, "rateLimit.limit", r),
+			periodMs: s(e.period, "rateLimit.period", r),
+			...e.key === void 0 ? {} : { key: l(e.key, "rateLimit.key", r) }
+		};
+	}
+	if (i.batch !== void 0) {
+		let o = i.batch;
+		if (t.payloadSchema !== void 0 && !u(t.payloadSchema)) throw Error(`workflow '${r}': batch is declared, so the workflow's own \`payload\` must be the BATCH shape — \`Schema.Struct({ items: Schema.Array(Item) })\` — while callers start it with a SINGLE item. Declare the item's schema as \`batch.item\`. Checked here rather than at admission because a decode failure on the batching replica is a failure nobody is watching.`);
+		a.batch = {
+			...o.key === void 0 ? {} : { key: l(o.key, "batch.key", r) },
+			maxSize: c(o.maxSize, "batch.maxSize", r),
+			timeoutMs: s(o.timeout, "batch.timeout", r),
+			...o.item === void 0 ? {} : { item: i.encrypted === !0 && n.isSchema(o.item) ? e(o.item, `workflow '${r}' batch item`) : o.item }
+		};
+	}
+	if (i.priority !== void 0) {
+		if (typeof i.priority != "function") throw Error(`workflow '${r}': priority must be a function of the payload`);
+		a.priority = i.priority;
+	}
+	if (i.timeouts !== void 0) {
+		let e = i.timeouts, t = e.start === void 0 ? void 0 : s(e.start, "timeouts.start", r), n = e.finish === void 0 ? void 0 : s(e.finish, "timeouts.finish", r);
+		(t !== void 0 || n !== void 0) && (a.timeouts = {
+			...t === void 0 ? {} : { startMs: t },
+			...n === void 0 ? {} : { finishMs: n }
+		});
+	}
+	if (a.debounce !== void 0 && a.batch !== void 0) throw Error(`workflow '${r}': debounce and batch cannot both be declared. Both collect starts and admit one run, but debounce's timer RESETS on every arrival (collapse a burst, latest payload wins) while batch's does not (accumulate items until maxSize or timeout). Pick the one you mean.`);
+	if (a.throttle !== void 0 && a.rateLimit !== void 0) throw Error(`workflow '${r}': throttle and rateLimit cannot both be declared. throttle QUEUES the excess and rateLimit DROPS it; declaring both means the drop fires first and the queue is never reached. Pick whether surplus work is late or gone.`);
+	if (i.onFailure !== void 0) {
+		if (typeof i.onFailure != "string" || i.onFailure.length === 0) throw Error(`workflow '${r}': onFailure must be the NAME of another workflow. A function cannot be used — the failure may be noticed by a different replica, minutes later, after the process that held the closure is gone.`);
+		if (i.onFailure === r) throw Error(`workflow '${r}': onFailure points at itself. A workflow that fails would then start another copy of itself, which would fail, forever — one run per failure until something else breaks. Point it at a separate notifier workflow.`);
+		a.onFailure = i.onFailure;
+	}
+	if (i.encrypted === !0 && (a.encrypted = !0), i.cancelOn !== void 0) {
+		if (!Array.isArray(i.cancelOn)) throw Error(`workflow '${r}': cancelOn must be an array of { event, schema, match }`);
+		let e = i.cancelOn.map((e, t) => {
+			let n = `cancelOn[${t}]`;
+			if (typeof e?.event != "string" || e.event.length === 0) throw Error(`workflow '${r}': ${n}.event must be a non-empty event name, exactly as ctx.events.publish writes it.`);
+			if (e.schema === void 0 || typeof e.schema.ast != "object") throw Error(`workflow '${r}': ${n}.schema must be a Schema for the event payload. It is decoded before \`match\` runs, so the predicate reads the domain type rather than raw JSON.`);
+			if (typeof e.match != "function") throw Error(`workflow '${r}': ${n}.match is required. Omitting it would mean "cancel every live run of this workflow whenever '${e.event}' is published" — write \`match: () => true\` if that is what you mean, so it is visible in review.`);
+			let i = e.within === void 0 ? void 0 : s(e.within, `${n}.within`, r);
+			return {
+				event: e.event,
+				schema: e.schema,
+				match: e.match,
+				...i === void 0 ? {} : { withinMs: i },
+				reason: e.reason ?? `cancelOn:${e.event}`
+			};
+		});
+		e.length > 0 && (a.cancelOn = e);
+	}
+	if (a.timeouts?.startMs !== void 0 && o(a).length === 0) throw Error(`workflow '${r}': timeouts.start bounds how long a run may sit in the ADMISSION queue, but this workflow declares no control that can defer one (debounce, batch, throttle, concurrency). It would never fire. Use timeouts.finish to bound the run itself.`);
+	return a;
+}, f = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n?.concurrency;
+		if (e?.pool === void 0) continue;
+		let r = t.get(e.pool);
+		if (r === void 0) t.set(e.pool, {
+			limit: e.limit,
+			workflows: [n.workflowName]
+		});
+		else if (r.limit !== e.limit) throw Error(`concurrency pool '${e.pool}': '${n.workflowName}' declares limit ${e.limit}, but ${r.workflows.map((e) => `'${e}'`).join(", ")} declare${r.workflows.length === 1 ? "s" : ""} limit ${r.limit}. A pool is ONE budget — every member must declare the same number, or the enforced limit would depend on which workflow's start arrived first. Align the limits, or give the workflows different pool names if they were never meant to share.`);
+		else r.workflows.push(n.workflowName);
+	}
+};
+//#endregion
+export { a as DEFERRING_CONTROLS, f as assertConsistentPools, o as deferringControlsOf, i as hasCancelOn, r as hasFlowControl, d as validateFlowControl };

package/dist/forwardStartReceipts.js

@@ -0,0 +1,41 @@
+import { START_RECEIPTS_TABLE as e, decodeWorkflowStartReceipt as t } from "./startReceipt.js";
+import { PENDING_TABLE as n } from "./admissionStore.js";
+import { Schema as r } from "effect";
+import { and as i, eq as a, isNull as o } from "@voltro/database";
+//#region src/forwardStartReceipts.ts
+var s = async (s, c) => {
+	if (c.from === c.to) throw Error("Queue transfer requires distinct source and target");
+	let l = await s.query({
+		table: n,
+		predicate: a("id", c.to),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	}), u = r.decodeUnknownSync(r.Struct({
+		workflowName: r.String,
+		tenantId: r.NullOr(r.String)
+	}))(l[0]);
+	if (u.workflowName !== c.workflowName || u.tenantId !== c.tenantId) throw Error("Receipt target belongs to a different workflow or tenant");
+	for (;;) {
+		let n = await s.query({
+			table: e,
+			predicate: i(a("pendingId", c.from), o("submissionId"), o("terminal")),
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 100,
+			skip: void 0,
+			projection: void 0
+		});
+		if (n.length === 0) return;
+		for (let e of n) {
+			let n = t(e);
+			if (n.workflowName !== c.workflowName || n.tenantId !== c.tenantId) throw Error("Forwarded receipt belongs to a different workflow or tenant");
+			if (await s.update("_voltro_workflow_start_receipts", n.id, { pendingId: c.to }) === null) throw Error("Start receipt disappeared during queue transfer");
+		}
+	}
+};
+//#endregion
+export { s as forwardStartReceipts };

package/dist/inMemoryLayer.js

@@ -0,0 +1,7 @@
+import { WorkflowEngine as e } from "effect/workflow";
+import { RateLimiter as t } from "effect/persistence";
+import { Layer as n } from "effect";
+//#region src/inMemoryLayer.ts
+var r = n.merge(e.layerMemory, t.layer.pipe(n.provide(t.layerStoreMemory)));
+//#endregion
+export { r as inMemoryWorkflowEngineLayer };

package/dist/inMemoryRecorder.js

@@ -0,0 +1,56 @@
+import { WorkflowRunRecorder as e } from "./recorder.js";
+import { Layer as t } from "effect";
+//#region src/inMemoryRecorder.ts
+var n = () => {
+	let n = [], r = [], i = 0, a = 0;
+	return {
+		layer: t.succeed(e, {
+			startStep: async ({ runId: e, stepName: t, attempt: r, stepInput: a, retryPolicy: o }) => {
+				let s = `wfstep_mem_${++i}`;
+				return n.push({
+					id: s,
+					runId: e,
+					stepName: t,
+					attempt: r,
+					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: e, output: t, durationMs: r }) => {
+				let i = n.find((t) => t.id === e);
+				i !== void 0 && (i.status = "succeeded", i.output = t, i.completedAt = /* @__PURE__ */ new Date(), i.durationMs = r);
+			},
+			endStepFailure: async ({ stepRecordId: e, errorTag: t, errorMessage: r, errorCause: i, durationMs: a }) => {
+				let o = n.find((t) => t.id === e);
+				o !== void 0 && (o.status = "failed", o.errorTag = t, o.errorMessage = r, o.errorCause = i ?? null, o.completedAt = /* @__PURE__ */ new Date(), o.durationMs = a);
+			},
+			recordEvent: async ({ runId: e, eventType: t, payload: n, stepName: i, attempt: o }) => {
+				let s = `wfev_mem_${++a}`;
+				return r.push({
+					id: s,
+					runId: e,
+					eventType: t,
+					payload: n ?? null,
+					stepName: i ?? null,
+					attempt: o ?? null,
+					occurredAt: /* @__PURE__ */ new Date()
+				}), {
+					id: s,
+					recorded: !0
+				};
+			}
+		}),
+		readSteps: () => n,
+		readEvents: () => r
+	};
+};
+//#endregion
+export { n as makeInMemoryRecorder };