@voltro/workflow 0.80.0 → 0.82.0

package/dist/clusterTestSuite.d.ts

@@ -1,5 +1,6 @@
 import { ConfigError } from 'effect';
 import { Layer } from 'effect';
+import { MysqlCharset } from '@voltro/database/sql';
 import { Sharding } from '@effect/cluster';
 import { SqlClient } from '@effect/sql';
 import { SqlError } from '@effect/sql';
@@ -71,6 +72,8 @@ export declare const purgeClusterState: (fixture: ClusterEngineFixture) => Promi
  */
 export declare const runClusterEngineSuite: (fixture: ClusterEngineFixture) => void;
 
+export declare const runJournalEncryptionSuite: (fixture: ClusterEngineFixture) => void;
+
 /**
  * Runner-storage backend for `@effect/cluster.SingleRunner`.
  *
@@ -145,6 +148,13 @@ declare interface WorkflowEngineLayerOptions {
     readonly shardLockMode?: ShardLockMode;
     readonly runnerListenHost?: string;
     readonly runnerListenPort?: number;
+    /**
+     * The declared store charset (`store: { dialect, charset }`, mysql family).
+     * The engine's tables are created by the library with no character set named;
+     * the migration gate converts the ones it creates to this, so a workflow input
+     * with a 4-byte character is not refused on a `utf8mb3` server.
+     */
+    readonly charset?: MysqlCharset | undefined;
     /**
      * FAILOVER TUNING — the two knobs that govern how fast a SURVIVING replica
      * takes over a CRASHED replica's in-flight workflows. Reclaim is a

package/dist/clusterTestSuite.js

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