@voltro/workflow 0.87.0 → 0.88.0

package/dist/clusterTestSuite.js

@@ -9,9 +9,8 @@ import { makeClusterCronLayer as f } from "./clusterCron.js";
 import { Cause as p, Cron as m, Deferred as h, Effect as g, Fiber as _, Layer as v, ManagedRuntime as y, Option as b, Schema as x } from "effect";
 import { SqlClient as S } from "effect/sql";
 import { EntityId as C, Sharding as w } from "effect/cluster";
-import { afterEach as T, beforeAll as E, describe as D, expect as O, test as k } from "vitest";
-//#region src/clusterTestSuite.ts
-var A = async (e, t, n = 750) => {
+// src/clusterTestSuite.ts
+var T = async (e, t, n = 750) => {
 	try {
 		let r = await import("node:net");
 		return await new Promise((i) => {
@@ -27,27 +26,27 @@ var A = async (e, t, n = 750) => {
 	} catch {
 		return !1;
 	}
-}, j = [
+}, E = [
 	"cluster_messages",
 	"cluster_replies",
 	"cluster_locks",
 	"cluster_runners"
-], M = async (e) => {
+], D = async (e) => {
 	try {
 		await g.runPromise(g.gen(function* () {
 			let e = yield* S.SqlClient;
-			for (let t of j) yield* e.unsafe(`DELETE FROM ${t}`).pipe(g.ignore);
+			for (let t of E) yield* e.unsafe(`DELETE FROM ${t}`).pipe(g.ignore);
 		}).pipe(g.scoped, g.provide(e.sqlClientLayer)));
 	} catch {}
-}, N = "10 seconds", P = "30 seconds", F = (e, t) => g.gen(function* () {
+}, O = "10 seconds", k = "30 seconds", A = (e, t) => g.gen(function* () {
 	let n = yield* g.sync(() => Date.now() + t);
 	for (; !e();) {
 		if (Date.now() > n) return !1;
 		yield* g.sleep("250 millis");
 	}
 	return !0;
-}), I = (e) => {
-	let t = `${e.name}-${Date.now()}`, n = (t, n) => d({
+}), j = (e, t) => {
+	let { describe: n, test: c, expect: l, beforeAll: p } = t, b = `${e.name}-${Date.now()}`, S = (t, n) => d({
 		sqlClientLayer: e.sqlClientLayer,
 		runnerStorage: e.runnerStorage,
 		runnerListenPort: t,
@@ -55,21 +54,21 @@ var A = async (e, t, n = 750) => {
 		...e.shardLockMode ? { shardLockMode: e.shardLockMode } : {},
 		...n && n.length > 0 ? { extraShardingLayers: n } : {}
 	});
-	D(`cluster workflow engine — ${e.name}`, () => {
-		let c = !1;
-		E(async () => {
-			c = await e.reachable(), c ? await M(e) : console.warn(`[skip] cluster suite — ${e.name} not reachable`);
-		}, 3e4), (e.runnerStorage === "sql" && e.dialectId !== "sqlite" ? k : (() => {}))("client-only submission executes on a distinct worker and never owns its shard", async (r) => {
-			if (!c) {
-				r.skip();
+	n(`cluster workflow engine — ${e.name}`, () => {
+		let t = !1;
+		p(async () => {
+			t = await e.reachable(), t ? await D(e) : console.warn(`[skip] cluster suite — ${e.name} not reachable`);
+		}, 3e4), (e.runnerStorage === "sql" && e.dialectId !== "sqlite" ? c : (() => {}))("client-only submission executes on a distinct worker and never owns its shard", async (n) => {
+			if (!t) {
+				n.skip();
 				return;
 			}
-			let i = `roleClient_${t}`, a = s({
-				name: i,
+			let r = `roleClient_${b}`, i = s({
+				name: r,
 				payload: { id: x.String },
 				success: x.Number,
-				idempotencyKey: ({ id: e }) => `${i}:${e}`
-			}), o = 0, l = 0, u = y.make(a.toLayer(() => g.sync(() => (o++, 42))).pipe(v.provideMerge(n(e.runnerPort)))), f = y.make(a.toLayer(() => g.sync(() => (l++, -1))).pipe(v.provideMerge(d({
+				idempotencyKey: ({ id: e }) => `${r}:${e}`
+			}), a = 0, o = 0, c = y.make(i.toLayer(() => g.sync(() => (a++, 42))).pipe(v.provideMerge(S(e.runnerPort)))), u = y.make(i.toLayer(() => g.sync(() => (o++, -1))).pipe(v.provideMerge(d({
 				sqlClientLayer: e.sqlClientLayer,
 				runnerStorage: "sql",
 				runnerMode: "client",
@@ -78,24 +77,24 @@ var A = async (e, t, n = 750) => {
 				...e.shardLockMode ? { shardLockMode: e.shardLockMode } : {}
 			}))));
 			try {
-				await u.runPromise(g.void), await f.runPromise(g.void);
-				let e = await f.runPromise(a.execute({ id: "from-client" }).pipe(g.timeout("60 seconds")));
-				O(e).toBe(42), O(o).toBe(1), O(l).toBe(0), O(await f.runPromise(g.map(w.Sharding, (e) => e.hasShardId(e.getShardId(C.make("client-probe"), "default"))))).toBe(!1), O(await f.runPromise(a.execute({ id: "from-client" }).pipe(g.timeout("60 seconds")))).toBe(42), O(o).toBe(1), O(l).toBe(0);
+				await c.runPromise(g.void), await u.runPromise(g.void);
+				let e = await u.runPromise(i.execute({ id: "from-client" }).pipe(g.timeout("60 seconds")));
+				l(e).toBe(42), l(a).toBe(1), l(o).toBe(0), l(await u.runPromise(g.map(w.Sharding, (e) => e.hasShardId(e.getShardId(C.make("client-probe"), "default"))))).toBe(!1), l(await u.runPromise(i.execute({ id: "from-client" }).pipe(g.timeout("60 seconds")))).toBe(42), l(a).toBe(1), l(o).toBe(0);
 			} finally {
 				try {
-					await f.dispose();
-				} finally {
 					await u.dispose();
+				} finally {
+					await c.dispose();
 				}
 			}
-		}, 15e4), k("a two-step workflow runs end-to-end", async () => {
-			if (!c) return;
-			let r = `clusterTwoStep_${t}`, i = s({
-				name: r,
+		}, 15e4), c("a two-step workflow runs end-to-end", async () => {
+			if (!t) return;
+			let n = `clusterTwoStep_${b}`, r = s({
+				name: n,
 				payload: { id: x.String },
 				success: x.Number,
-				idempotencyKey: ({ id: e }) => `${r}:${e}`
-			}), a = i.toLayer(() => g.gen(function* () {
+				idempotencyKey: ({ id: e }) => `${n}:${e}`
+			}), i = r.toLayer(() => g.gen(function* () {
 				let e = yield* o({
 					name: "first",
 					success: x.Number,
@@ -106,86 +105,86 @@ var A = async (e, t, n = 750) => {
 					success: x.Number,
 					execute: g.succeed(e + 2)
 				});
-			})), l = await g.runPromise(g.scoped(i.execute({ id: `e2e-${t}` }).pipe(g.provide(a.pipe(v.provideMerge(n(e.runnerPort)))))));
-			O(l).toBe(42);
-		}, 3e4), k("idempotency-key journal — same payload returns same result", async () => {
-			if (!c) return;
-			let r = `clusterIdempotency_${t}`, i = 0, a = s({
-				name: r,
+			})), a = await g.runPromise(g.scoped(r.execute({ id: `e2e-${b}` }).pipe(g.provide(i.pipe(v.provideMerge(S(e.runnerPort)))))));
+			l(a).toBe(42);
+		}, 3e4), c("idempotency-key journal — same payload returns same result", async () => {
+			if (!t) return;
+			let n = `clusterIdempotency_${b}`, r = 0, i = s({
+				name: n,
 				payload: { id: x.String },
 				success: x.Number,
-				idempotencyKey: ({ id: e }) => `${r}:${e}`
-			}), l = a.toLayer(() => o({
+				idempotencyKey: ({ id: e }) => `${n}:${e}`
+			}), a = i.toLayer(() => o({
 				name: "compute",
 				success: x.Number,
-				execute: g.sync(() => (i++, i * 100))
-			})).pipe(v.provideMerge(n(e.runnerPort))), [u, d] = await g.runPromise(g.scoped(g.gen(function* () {
-				return [yield* a.execute({ id: `same-${t}` }), yield* a.execute({ id: `same-${t}` })];
-			}).pipe(g.provide(l))));
-			O(u).toBe(d), O(i).toBe(1);
-		}, 3e4), k("ClusterCron fires its execute on the shard owner", async () => {
-			if (!c) return;
-			let r = await g.runPromise(h.make()), i = 0, a = f({
-				name: `clusterCron_${t}`,
+				execute: g.sync(() => (r++, r * 100))
+			})).pipe(v.provideMerge(S(e.runnerPort))), [c, u] = await g.runPromise(g.scoped(g.gen(function* () {
+				return [yield* i.execute({ id: `same-${b}` }), yield* i.execute({ id: `same-${b}` })];
+			}).pipe(g.provide(a))));
+			l(c).toBe(u), l(r).toBe(1);
+		}, 3e4), c("ClusterCron fires its execute on the shard owner", async () => {
+			if (!t) return;
+			let n = await g.runPromise(h.make()), r = 0, i = f({
+				name: `clusterCron_${b}`,
 				cron: m.parseUnsafe("*/1 * * * * *", "UTC"),
 				execute: async () => {
-					i += 1, await g.runPromise(h.succeed(r, !0)).catch(() => {});
+					r += 1, await g.runPromise(h.succeed(n, !0)).catch(() => {});
 				}
-			}), o = await g.runPromise(g.scoped(g.gen(function* () {
-				return yield* v.build(n(e.runnerPort + 1, [a])), yield* h.await(r).pipe(g.timeout("25 seconds"), g.orElseSucceed(() => !1));
+			}), a = await g.runPromise(g.scoped(g.gen(function* () {
+				return yield* v.build(S(e.runnerPort + 1, [i])), yield* h.await(n).pipe(g.timeout("25 seconds"), g.orElseSucceed(() => !1));
 			})));
-			O(o).toBe(!0), O(i).toBeGreaterThanOrEqual(1);
+			l(a).toBe(!0), l(r).toBeGreaterThanOrEqual(1);
 		}, 35e3);
-		let l = e.clusterResume ? k : (() => {});
-		l("a sleeping workflow resumes on a fresh runner after the first is torn down", async () => {
-			if (!c) return;
-			let r = `dormancyResume_${t}`, i = [], l = [], u = [], d = () => s({
-				name: r,
+		let n = e.clusterResume ? c : (() => {});
+		n("a sleeping workflow resumes on a fresh runner after the first is torn down", async () => {
+			if (!t) return;
+			let n = `dormancyResume_${b}`, r = [], i = [], c = [], u = () => s({
+				name: n,
 				payload: { id: x.String },
 				success: x.String,
-				idempotencyKey: ({ id: e }) => `${r}:${e}`
-			}), f = (e, t) => e.toLayer(() => g.gen(function* () {
+				idempotencyKey: ({ id: e }) => `${n}:${e}`
+			}), d = (e, t) => e.toLayer(() => g.gen(function* () {
 				return yield* o({
 					name: "step1",
 					success: x.Void,
 					execute: g.sync(() => {
-						i.push(t);
+						r.push(t);
 					})
 				}), yield* o({
 					name: "armed",
 					success: x.Void,
 					execute: g.sync(() => {
-						u.push(t);
+						c.push(t);
 					})
 				}), yield* a({
 					name: "nap",
-					duration: N
+					duration: O
 				}), yield* o({
 					name: "step2",
 					success: x.Void,
 					execute: g.sync(() => {
-						l.push(t);
+						i.push(t);
 					})
 				}), "done";
-			})), p = e.runnerPort + 2, m = (e) => {
-				let t = d();
+			})), f = e.runnerPort + 2, p = (e) => {
+				let t = u();
 				return {
 					wf: t,
-					layer: f(t, e).pipe(v.provideMerge(n(p)))
+					layer: d(t, e).pipe(v.provideMerge(S(f)))
 				};
-			}, h = { id: `resume-${t}` }, y = await g.runPromise(g.scoped(g.gen(function* () {
-				let { wf: e, layer: t } = m("A"), n = yield* v.build(t), r = yield* g.forkDetach(e.execute(h).pipe(g.provide(n), g.ignore));
-				return (yield* F(() => u.length > 0, 6e4)) ? r : yield* g.die(/* @__PURE__ */ Error("runner A never journaled step1"));
+			}, m = { id: `resume-${b}` }, h = await g.runPromise(g.scoped(g.gen(function* () {
+				let { wf: e, layer: t } = p("A"), n = yield* v.build(t), r = yield* g.forkDetach(e.execute(m).pipe(g.provide(n), g.ignore));
+				return (yield* A(() => c.length > 0, 6e4)) ? r : yield* g.die(/* @__PURE__ */ Error("runner A never journaled step1"));
 			})));
-			await g.runPromise(_.interrupt(y).pipe(g.ignore)), O(i).toEqual(["A"]), O(l).toEqual([]);
-			let b = await g.runPromise(g.scoped(g.gen(function* () {
-				let { wf: e, layer: t } = m("B"), n = yield* v.build(t);
-				return yield* e.execute(h).pipe(g.provide(n), g.timeout("240 seconds"), g.orElseSucceed(() => "TIMEOUT"));
+			await g.runPromise(_.interrupt(h).pipe(g.ignore)), l(r).toEqual(["A"]), l(i).toEqual([]);
+			let y = await g.runPromise(g.scoped(g.gen(function* () {
+				let { wf: e, layer: t } = p("B"), n = yield* v.build(t);
+				return yield* e.execute(m).pipe(g.provide(n), g.timeout("240 seconds"), g.orElseSucceed(() => "TIMEOUT"));
 			})));
-			O(b).toBe("done"), O(i).toEqual(["A"]), O(l).toEqual(["B"]);
-		}, 48e4), l("dormancy loop: a wake signal survives teardown and is cleared on resume", async () => {
-			if (!c) return;
-			let l = `dormancyLoop_${t}`, d = `wr_${l}`, f = [], p = /* @__PURE__ */ new Map(), m = u({
+			l(y).toBe("done"), l(r).toEqual(["A"]), l(i).toEqual(["B"]);
+		}, 48e4), n("dormancy loop: a wake signal survives teardown and is cleared on resume", async () => {
+			if (!t) return;
+			let n = `dormancyLoop_${b}`, c = `wr_${n}`, d = [], f = /* @__PURE__ */ new Map(), p = u({
 				store: {
 					insert: async (e, t) => t,
 					update: async () => null,
@@ -193,63 +192,63 @@ var A = async (e, t, n = 750) => {
 				},
 				wakeups: {
 					register: async (e, t) => {
-						p.set(e, { wakeAt: t });
+						f.set(e, { wakeAt: t });
 					},
 					cancel: async (e) => {
-						p.delete(e);
+						f.delete(e);
 					}
 				}
-			}), h = () => s({
-				name: l,
+			}), m = () => s({
+				name: n,
 				payload: { id: x.String },
 				success: x.String,
-				idempotencyKey: ({ id: e }) => `${l}:${e}`
-			}), y = (e, t) => e.toLayer(() => g.gen(function* () {
+				idempotencyKey: ({ id: e }) => `${n}:${e}`
+			}), h = (e, t) => e.toLayer(() => g.gen(function* () {
 				return yield* o({
 					name: "step1",
 					success: x.Void,
 					execute: g.void
 				}), yield* a({
 					name: "nap",
-					duration: P
+					duration: k
 				}), yield* o({
 					name: "step2",
 					success: x.Void,
 					execute: g.sync(() => {
-						f.push(t);
+						d.push(t);
 					})
 				}), "done";
-			}).pipe(g.provideService(r, d), g.provideService(i, m))), b = e.runnerPort + 2, S = (e) => {
-				let t = h();
+			}).pipe(g.provideService(r, c), g.provideService(i, p))), y = e.runnerPort + 2, C = (e) => {
+				let t = m();
 				return {
 					wf: t,
-					layer: y(t, e).pipe(v.provideMerge(n(b)))
+					layer: h(t, e).pipe(v.provideMerge(S(y)))
 				};
-			}, C = { id: `loop-${t}` }, w = await g.runPromise(g.scoped(g.gen(function* () {
-				let { wf: e, layer: t } = S("A"), n = yield* v.build(t), r = yield* g.forkDetach(e.execute(C).pipe(g.provide(n), g.ignore));
-				return (yield* F(() => p.has(d), 6e4)) ? (yield* g.sleep("1 second"), r) : yield* g.die(/* @__PURE__ */ Error("workflow never registered a wakeup"));
+			}, w = { id: `loop-${b}` }, T = await g.runPromise(g.scoped(g.gen(function* () {
+				let { wf: e, layer: t } = C("A"), n = yield* v.build(t), r = yield* g.forkDetach(e.execute(w).pipe(g.provide(n), g.ignore));
+				return (yield* A(() => f.has(c), 6e4)) ? (yield* g.sleep("1 second"), r) : yield* g.die(/* @__PURE__ */ Error("workflow never registered a wakeup"));
 			})));
-			await g.runPromise(_.interrupt(w).pipe(g.ignore)), O(p.has(d)).toBe(!0), O(f).toEqual([]);
-			let T = await g.runPromise(g.scoped(g.gen(function* () {
-				let { wf: e, layer: t } = S("B"), n = yield* v.build(t);
-				return yield* e.execute(C).pipe(g.provide(n), g.timeout("600 seconds"), g.orElseSucceed(() => "TIMEOUT"));
+			await g.runPromise(_.interrupt(T).pipe(g.ignore)), l(f.has(c)).toBe(!0), l(d).toEqual([]);
+			let E = await g.runPromise(g.scoped(g.gen(function* () {
+				let { wf: e, layer: t } = C("B"), n = yield* v.build(t);
+				return yield* e.execute(w).pipe(g.provide(n), g.timeout("600 seconds"), g.orElseSucceed(() => "TIMEOUT"));
 			})));
-			O(T).toBe("done"), O(f).toEqual(["B"]), O(p.has(d)).toBe(!1);
+			l(E).toBe("done"), l(d).toEqual(["B"]), l(f.has(c)).toBe(!1);
 		}, 9e5);
 	});
-}, L = {
+}, M = {
 	encrypt: (e) => `enc:v2:c:${Buffer.from(e, "utf8").toString("base64")}`,
 	decrypt: (e) => Buffer.from(e.slice(9), "base64").toString("utf8")
-}, R = (r) => {
-	let i = `${r.name}-enc-${Date.now()}`, a = () => d({
+}, N = (r, i) => {
+	let { describe: a, test: u, expect: f, beforeAll: m, afterEach: h } = i, _ = `${r.name}-enc-${Date.now()}`, y = () => d({
 		sqlClientLayer: r.sqlClientLayer,
 		runnerStorage: r.runnerStorage,
 		runnerListenPort: r.runnerPort + 7,
 		...r.dialectId ? { dialectId: r.dialectId } : {}
-	}), u = (e) => g.runPromise(g.gen(function* () {
+	}), C = (e) => g.runPromise(g.gen(function* () {
 		let t = yield* S.SqlClient, n = yield* t.unsafe("SELECT * FROM cluster_messages"), r = yield* t.unsafe("SELECT * FROM cluster_replies"), i = (e) => JSON.stringify(e, (e, t) => typeof t == "bigint" ? String(t) : t);
 		return [...n, ...r].filter((t) => i(t).includes(e)).length;
-	}).pipe(g.provideService(S.SafeIntegers, !0), g.scoped, g.provide(r.sqlClientLayer))), f = (e, t) => {
+	}).pipe(g.provideService(S.SafeIntegers, !0), g.scoped, g.provide(r.sqlClientLayer))), w = (e, t) => {
 		let n = s({
 			name: e,
 			payload: {
@@ -271,45 +270,45 @@ var A = async (e, t, n = 750) => {
 			})),
 			executions: () => r
 		};
-	}, m = (e, t) => g.runPromise(g.scoped(e.wf.execute(t).pipe(g.provide(e.handler.pipe(v.provideMerge(a()))))));
-	D(`encrypted workflow journal — ${r.name}`, () => {
-		let d = !1;
-		E(async () => {
-			d = await r.reachable(), d && await M(r);
-		}, 3e4), T(() => n(void 0)), k("payload, step result and result are ciphertext; the unencrypted twin is found (control)", async (e) => {
-			d || e.skip(), n(L);
-			let t = f(`journalPlain_${i}`, !1), r = f(`journalSealed_${i}`, !0);
-			O(await m(t, {
+	}, T = (e, t) => g.runPromise(g.scoped(e.wf.execute(t).pipe(g.provide(e.handler.pipe(v.provideMerge(y()))))));
+	a(`encrypted workflow journal — ${r.name}`, () => {
+		let i = !1;
+		m(async () => {
+			i = await r.reachable(), i && await D(r);
+		}, 3e4), h(() => n(void 0)), u("payload, step result and result are ciphertext; the unencrypted twin is found (control)", async (e) => {
+			i || e.skip(), n(M);
+			let t = w(`journalPlain_${_}`, !1), r = w(`journalSealed_${_}`, !0);
+			f(await T(t, {
 				note: "PLAINMARK",
 				count: 1
-			})).toEqual({ summary: "RESULT-STEP-PLAINMARK" }), O(await m(r, {
+			})).toEqual({ summary: "RESULT-STEP-PLAINMARK" }), f(await T(r, {
 				note: "SEALMARK",
 				count: 1
-			})).toEqual({ summary: "RESULT-STEP-SEALMARK" }), O(await u("PLAINMARK"), "the probe finds plaintext").toBeGreaterThan(0), O(await u("SEALMARK"), "no journal row carries the encrypted run in plaintext").toBe(0), O(await u("enc:v2:c:"), "and the ciphertext is there").toBeGreaterThan(0);
-		}, 6e4), k("a second execute replays the result from the encrypted journal without re-running the step", async (e) => {
-			d || e.skip(), n(L);
-			let t = f(`journalReplay_${i}`, !0), r = await m(t, {
+			})).toEqual({ summary: "RESULT-STEP-SEALMARK" }), f(await C("PLAINMARK"), "the probe finds plaintext").toBeGreaterThan(0), f(await C("SEALMARK"), "no journal row carries the encrypted run in plaintext").toBe(0), f(await C("enc:v2:c:"), "and the ciphertext is there").toBeGreaterThan(0);
+		}, 6e4), u("a second execute replays the result from the encrypted journal without re-running the step", async (e) => {
+			i || e.skip(), n(M);
+			let t = w(`journalReplay_${_}`, !0), r = await T(t, {
 				note: "REPLAYMARK",
 				count: 7
-			}), a = await m(t, {
+			}), a = await T(t, {
 				note: "REPLAYMARK",
 				count: 7
 			});
-			O(a).toEqual(r), O(t.executions()).toBe(1);
-		}, 6e4), k("a run journaled in plaintext before the declaration is still read", async (e) => {
-			d || e.skip();
-			let t = `journalBefore_${i}`, r = await m(f(t, !1), {
+			f(a).toEqual(r), f(t.executions()).toBe(1);
+		}, 6e4), u("a run journaled in plaintext before the declaration is still read", async (e) => {
+			i || e.skip();
+			let t = `journalBefore_${_}`, r = await T(w(t, !1), {
 				note: "OLDMARK",
 				count: 3
 			});
-			n(L);
-			let a = f(t, !0);
-			O(await m(a, {
+			n(M);
+			let a = w(t, !0);
+			f(await T(a, {
 				note: "OLDMARK",
 				count: 3
-			})).toEqual(r), O(a.executions(), "answered from the plaintext journal, not re-run").toBe(0);
+			})).toEqual(r), f(a.executions(), "answered from the plaintext journal, not re-run").toBe(0);
 		}, 6e4);
-		let h = (e, t, n) => {
+		let a = (e, t, n) => {
 			class r extends x.TaggedError()("Refused", { detail: x.String }) {}
 			let i = s({
 				name: e,
@@ -317,23 +316,23 @@ var A = async (e, t, n = 750) => {
 				error: r,
 				idempotencyKey: ({ note: t }) => `${e}:${t}`,
 				encrypted: t
-			}), c = i.toLayer(({ note: e }) => o({
+			}), a = i.toLayer(({ note: e }) => o({
 				name: "call-upstream",
 				success: x.String,
 				error: r,
 				execute: n === "defect" ? g.die(/* @__PURE__ */ Error(`upstream rejected FAILMARK-${e}`)) : g.fail(new r({ detail: `FAILMARK-${e}` }))
 			}));
-			return g.runPromiseExit(g.scoped(i.execute({ note: e }).pipe(g.provide(c.pipe(v.provideMerge(a()))))));
+			return g.runPromiseExit(g.scoped(i.execute({ note: e }).pipe(g.provide(a.pipe(v.provideMerge(y()))))));
 		};
-		for (let t of ["defect", "typed"]) k(`a ${t} failure of an encrypted run leaves no plaintext; the unencrypted twin does (control)`, async (r) => {
-			d || r.skip(), n(L);
-			let a = await h(`journalFailPlain_${t}_${i}`, !1, t);
-			O(a._tag).toBe("Failure"), O(await u(`FAILMARK-journalFailPlain_${t}`), "the probe finds plaintext").toBeGreaterThan(0);
-			let o = await h(`journalFailSealed_${t}_${i}`, !0, t);
-			O(o._tag).toBe("Failure"), O(await u(`FAILMARK-journalFailSealed_${t}`), "no journal row carries the failure in plaintext").toBe(0), O(e(p.squash(o.cause))).toContain(`FAILMARK-journalFailSealed_${t}`);
+		for (let t of ["defect", "typed"]) u(`a ${t} failure of an encrypted run leaves no plaintext; the unencrypted twin does (control)`, async (r) => {
+			i || r.skip(), n(M);
+			let o = await a(`journalFailPlain_${t}_${_}`, !1, t);
+			f(o._tag).toBe("Failure"), f(await C(`FAILMARK-journalFailPlain_${t}`), "the probe finds plaintext").toBeGreaterThan(0);
+			let s = await a(`journalFailSealed_${t}_${_}`, !0, t);
+			f(s._tag).toBe("Failure"), f(await C(`FAILMARK-journalFailSealed_${t}`), "no journal row carries the failure in plaintext").toBe(0), f(e(p.squash(s.cause))).toContain(`FAILMARK-journalFailSealed_${t}`);
 		}, 6e4);
-		k("a journaled wait value of an encrypted run is ciphertext; the unencrypted twin is found (control)", async (e) => {
-			d || e.skip(), n(L);
+		u("a journaled wait value of an encrypted run is ciphertext; the unencrypted twin is found (control)", async (e) => {
+			i || e.skip(), n(M);
 			let r = (e, n) => {
 				let r = s({
 					name: e,
@@ -346,88 +345,87 @@ var A = async (e, t, n = 750) => {
 					success: x.String,
 					execute: g.succeed(`WAITMARK-${e}`)
 				}));
-				return g.runPromise(g.scoped(r.execute({ note: e }).pipe(g.provide(i.pipe(v.provideMerge(a()))))));
+				return g.runPromise(g.scoped(r.execute({ note: e }).pipe(g.provide(i.pipe(v.provideMerge(y()))))));
 			};
-			O(await r(`journalWaitPlain_${i}`, !1)).toBe(`WAITMARK-journalWaitPlain_${i}`), O(await u(`WAITMARK-journalWaitPlain_${i}`), "the probe finds plaintext").toBeGreaterThan(0), O(await r(`journalWaitSealed_${i}`, !0)).toBe(`WAITMARK-journalWaitSealed_${i}`), O(await u(`WAITMARK-journalWaitSealed_${i}`), "no plaintext wait value in the journal").toBe(0);
+			f(await r(`journalWaitPlain_${_}`, !1)).toBe(`WAITMARK-journalWaitPlain_${_}`), f(await C(`WAITMARK-journalWaitPlain_${_}`), "the probe finds plaintext").toBeGreaterThan(0), f(await r(`journalWaitSealed_${_}`, !0)).toBe(`WAITMARK-journalWaitSealed_${_}`), f(await C(`WAITMARK-journalWaitSealed_${_}`), "no plaintext wait value in the journal").toBe(0);
 		}, 6e4);
-		let _ = (e, t, n) => g.gen(function* () {
+		let d = (e, t, n) => g.gen(function* () {
 			for (let r = 0; r < 400; r++) {
 				let r = yield* e.poll(t);
 				if (n(r)) return r;
 				yield* g.sleep("50 millis");
 			}
 			return yield* g.die(/* @__PURE__ */ Error("pollUntil: never satisfied"));
-		}), y = (e) => b.isOption(e) && b.isSome(e) ? e.value._tag : void 0;
-		for (let e of [!1, !0]) k(`a suspending signal's value is ${e ? "ciphertext" : "found (control)"} in the journal, and the run resumes with it`, async (t) => {
-			d || t.skip(), n(L);
-			let r = `journalSignal_${e ? "sealed" : "plain"}_${i}`, o = s({
+		}), S = (e) => b.isOption(e) && b.isSome(e) ? e.value._tag : void 0;
+		for (let e of [!1, !0]) u(`a suspending signal's value is ${e ? "ciphertext" : "found (control)"} in the journal, and the run resumes with it`, async (t) => {
+			i || t.skip(), n(M);
+			let r = `journalSignal_${e ? "sealed" : "plain"}_${_}`, a = s({
 				name: r,
 				payload: { id: x.String },
 				success: x.Unknown,
 				idempotencyKey: ({ id: e }) => `${r}:${e}`,
 				encrypted: e
-			}), f = o.toLayer(() => c({ store: { query: () => Promise.resolve([]) } }, {
+			}), o = a.toLayer(() => c({ store: { query: () => Promise.resolve([]) } }, {
 				name: "approval",
 				schema: x.Struct({ comment: x.String }),
 				timeoutMs: 36e5
-			})), p = `SIGNALMARK-${r}`, m = await g.runPromise(g.scoped(g.gen(function* () {
-				let e = yield* o.executionId({ id: "one" });
-				return yield* o.execute({ id: "one" }, { discard: !0 }), yield* _(o, e, (e) => y(e) === "Suspended"), yield* l({
+			})), u = `SIGNALMARK-${r}`, p = await g.runPromise(g.scoped(g.gen(function* () {
+				let e = yield* a.executionId({ id: "one" });
+				return yield* a.execute({ id: "one" }, { discard: !0 }), yield* d(a, e, (e) => S(e) === "Suspended"), yield* l({
 					target: {
 						executionId: e,
 						workflowName: r
 					},
 					signalName: "approval",
-					payload: { comment: p }
-				}), yield* _(o, e, (e) => y(e) === "Complete");
-			}).pipe(g.provide(f.pipe(v.provideMerge(a()))))));
-			O(JSON.stringify(b.getOrThrow(m).exit), "the body received the value").toContain(p);
-			let h = await u(p);
-			e ? O(h, "no plaintext signal value in the journal").toBe(0) : O(h, "the probe finds plaintext").toBeGreaterThan(0);
+					payload: { comment: u }
+				}), yield* d(a, e, (e) => S(e) === "Complete");
+			}).pipe(g.provide(o.pipe(v.provideMerge(y()))))));
+			f(JSON.stringify(b.getOrThrow(p).exit), "the body received the value").toContain(u);
+			let m = await C(u);
+			e ? f(m, "no plaintext signal value in the journal").toBe(0) : f(m, "the probe finds plaintext").toBeGreaterThan(0);
 		}, 9e4);
-		k("an encrypted child's defect reaches its encrypted parent as thrown, and no journal row carries it", async (e) => {
-			d || e.skip(), n(L);
-			let t = `journalChild_${i}`, r = `journalParent_${i}`, o = `CHILDMARK-${i}`, c = s({
+		u("an encrypted child's defect reaches its encrypted parent as thrown, and no journal row carries it", async (e) => {
+			i || e.skip(), n(M);
+			let t = `journalChild_${_}`, r = `journalParent_${_}`, a = `CHILDMARK-${_}`, o = s({
 				name: t,
 				payload: { id: x.String },
 				success: x.String,
 				idempotencyKey: ({ id: e }) => e,
 				encrypted: !0
-			}), l = s({
+			}), c = s({
 				name: r,
 				payload: { id: x.String },
 				success: x.String,
 				idempotencyKey: ({ id: e }) => e,
 				encrypted: !0
-			}), f = c.toLayer(() => g.die(/* @__PURE__ */ Error(`child failed ${o}`))), p = l.toLayer(({ id: e }) => c.execute({ id: `${e}-child` }).pipe(g.catchDefect((e) => g.succeed(`caught: ${e.message}`)))), m = await g.runPromise(g.scoped(l.execute({ id: "p1" }).pipe(g.provide(v.mergeAll(p, f).pipe(v.provideMerge(a()))))));
-			O(m).toBe(`caught: child failed ${o}`), O(await u(o)).toBe(0);
-		}, 6e4), k("an encrypted run that suspends on a failed step journals no plaintext", async (e) => {
-			d || e.skip(), n(L);
-			let t = `journalSuspendOnFailure_${i}`, r = `SOFMARK-${i}`, c = s({
+			}), l = o.toLayer(() => g.die(/* @__PURE__ */ Error(`child failed ${a}`))), u = c.toLayer(({ id: e }) => o.execute({ id: `${e}-child` }).pipe(g.catchDefect((e) => g.succeed(`caught: ${e.message}`)))), d = await g.runPromise(g.scoped(c.execute({ id: "p1" }).pipe(g.provide(v.mergeAll(u, l).pipe(v.provideMerge(y()))))));
+			f(d).toBe(`caught: child failed ${a}`), f(await C(a)).toBe(0);
+		}, 6e4), u("an encrypted run that suspends on a failed step journals no plaintext", async (e) => {
+			i || e.skip(), n(M);
+			let t = `journalSuspendOnFailure_${_}`, r = `SOFMARK-${_}`, a = s({
 				name: t,
 				payload: { id: x.String },
 				success: x.String,
 				idempotencyKey: ({ id: e }) => e,
 				encrypted: !0,
 				suspendOnFailure: !0
-			}), l = c.toLayer(() => o({
+			}), c = a.toLayer(() => o({
 				name: "call",
 				success: x.String,
 				execute: g.die(/* @__PURE__ */ Error(`step failed ${r}`))
 			}));
 			await g.runPromise(g.scoped(g.gen(function* () {
-				let e = yield* c.executionId({ id: "s1" });
-				yield* c.execute({ id: "s1" }, { discard: !0 }), yield* _(c, e, (e) => y(e) === "Suspended");
-			}).pipe(g.provide(l.pipe(v.provideMerge(a())))))), O(await u(r)).toBe(0);
-		}, 6e4), k("without a registered cipher an encrypted run fails instead of writing plaintext", async (e) => {
-			d || e.skip();
-			let t = f(`journalNoCipher_${i}`, !0);
-			await O(m(t, {
+				let e = yield* a.executionId({ id: "s1" });
+				yield* a.execute({ id: "s1" }, { discard: !0 }), yield* d(a, e, (e) => S(e) === "Suspended");
+			}).pipe(g.provide(c.pipe(v.provideMerge(y())))))), f(await C(r)).toBe(0);
+		}, 6e4), u("without a registered cipher an encrypted run fails instead of writing plaintext", async (e) => {
+			i || e.skip();
+			let t = w(`journalNoCipher_${_}`, !0);
+			await f(T(t, {
 				note: "NOCIPHERMARK",
 				count: 1
-			})).rejects.toThrow(), O(await u("NOCIPHERMARK")).toBe(0);
+			})).rejects.toThrow(), f(await C("NOCIPHERMARK")).toBe(0);
 		}, 6e4);
 	});
 };
-//#endregion
-export { M as purgeClusterState, I as runClusterEngineSuite, R as runJournalEncryptionSuite, A as tcpReachable };
+export { D as purgeClusterState, j as runClusterEngineSuite, N as runJournalEncryptionSuite, T as tcpReachable };

package/dist/controlMonitor.js

@@ -1,7 +1,7 @@
 import { readPendingWorkflowCancellation as e } from "./controlRequest.js";
 import { Effect as t } from "effect";
 import { WorkflowInstance as n } from "effect/workflow/WorkflowEngine";
-//#region src/controlMonitor.ts
+// src/controlMonitor.ts
 var r = (r, i, a) => t.gen(function* () {
 	let o = yield* n;
 	for (;;) {
@@ -9,5 +9,4 @@ var r = (r, i, a) => t.gen(function* () {
 		yield* t.sleep(1e3);
 	}
 });
-//#endregion
 export { r as awaitWorkflowCancellation };

package/dist/controlRequest.js

@@ -1,7 +1,7 @@
 import { isWorkflowEncrypted as e, sealErrorText as t, sealJournalValue as n } from "./journalEncryption.js";
 import { Schema as r } from "effect";
 import { and as i, derivedRowId as a, eq as o, gt as s, or as c } from "@voltro/database";
-//#region src/controlRequest.ts
+// src/controlRequest.ts
 var l = "_voltro_workflow_control_requests", u = r.String.pipe(r.check(r.isMinLength(1))), d = r.Struct({
 	kind: r.Literals(["confirmed", "already-terminal"]),
 	status: r.Literals([
@@ -363,5 +363,4 @@ var l = "_voltro_workflow_control_requests", u = r.String.pipe(r.check(r.isMinLe
 		u = r.id;
 	}
 };
-//#endregion
 export { l as CONTROL_REQUESTS_TABLE, w as FLOW_CONTROL_FINISH_TIMEOUT, k as acceptWorkflowControlInTransaction, j as beginWorkflowControlDispatchInTransaction, A as bindWorkflowResumeJournalInTransaction, E as finishTimeoutCause, C as hasPendingWorkflowCancellation, O as hasUnsettledParentClosureControls, S as readPendingWorkflowCancellation, x as readPendingWorkflowCancellations, D as readWorkflowControlInTransaction, M as settleWorkflowControlsInTransaction, N as settleWorkflowResumesInTransaction };

package/dist/executionRefusal.js

@@ -6,7 +6,7 @@ import { Cause as o, Effect as s, Schema as c } from "effect";
 import { SubjectIdentity as l, publishServerError as u } from "@voltro/protocol";
 import { randomUUID as d } from "node:crypto";
 import { WorkflowInstance as f } from "effect/workflow/WorkflowEngine";
-//#region src/executionRefusal.ts
+// src/executionRefusal.ts
 var p = (p, m) => s.gen(function* () {
 	let h = yield* s.sync(() => c.decodeUnknownSync(l)(p.subject));
 	if (h.tenantId !== p.failureContext.tenantId) return yield* s.die(/* @__PURE__ */ Error("Workflow refusal has inconsistent caller tenant"));
@@ -158,5 +158,4 @@ var p = (p, m) => s.gen(function* () {
 		});
 	}), yield* s.failCause(m.cause);
 });
-//#endregion
 export { p as recordWorkflowExecutionRefusal };

package/dist/failureHandoff.js

@@ -6,7 +6,7 @@ import { PENDING_TABLE as f, parkDelayedStart as p, retryBackoffMs as m } from "
 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
+// src/failureHandoff.ts
 var x = async (e, t, n) => {
 	let r, a = t === "submissionId" ? _(t, n) : g(_(t, n), y("submissionId"), y("terminal"));
 	for (;;) {
@@ -179,5 +179,4 @@ var x = async (e, t, n) => {
 		executionId: c.executionId
 	};
 };
-//#endregion
 export { j as FailureReconciliationError, A as handoffWorkflowFailureInTransaction, w as isFailureDeliveryExecution, C as isFailureDeliveryPending, S as isFailureDeliverySubmission, M as reconcileWorkflowFailureInTransaction };