@voltro/workflow 0.28.0 → 0.30.0

package/dist/cluster-CyIyBO39.js

@@ -0,0 +1,159 @@
+import { Context as e, Duration as t, Effect as n, Layer as r, Option as i } from "effect";
+import { ClusterCron as a, ClusterSchema as o, ClusterWorkflowEngine as s, EntityAddress as c, EntityId as l, EntityType as u, MessageStorage as d, RunnerAddress as f, Sharding as p, ShardingConfig as m, SingleRunner as h, SqlMessageStorage as g, SqlRunnerStorage as _ } from "@effect/cluster";
+import { SqlClient as v } from "@effect/sql";
+//#region src/clusterMigrationGate.ts
+var y = 6322741009312601n, b = `voltro_cluster_migration_${y.toString(36)}`, x = () => {
+	let e = Number(process.env.VOLTRO_CLUSTER_MIGRATION_LOCK_TIMEOUT_MS);
+	return Number.isFinite(e) && e > 0 ? e : 6e4;
+}, S = 250, C = (e) => e[0]?.[0], w = (e, t) => e.onDialectOrElse({
+	sqlite: () => n.void,
+	mysql: () => t.executeValues(`SELECT GET_LOCK('${b}', ${Math.ceil(x() / 1e3)})`, []).pipe(n.flatMap((e) => C(e) === 1 || C(e) === "1" ? n.void : n.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${b}' (GET_LOCK timed out)`)))),
+	mssql: () => t.executeValues(`DECLARE @res int; EXEC @res = sp_getapplock @Resource = '${b}', @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${x()}; SELECT @res`, []).pipe(n.flatMap((e) => Number(C(e) ?? -999) >= 0 ? n.void : n.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${b}' (sp_getapplock ${String(C(e))})`)))),
+	orElse: () => {
+		let e = y.toString(), r = Date.now(), i = t.executeValues(`SELECT pg_try_advisory_lock(${e}::bigint)`, []).pipe(n.flatMap((e) => {
+			let t = C(e);
+			return t === !0 || t === "t" || t === 1 ? n.void : Date.now() - r >= x() ? n.die(/* @__PURE__ */ Error(`could not acquire the cluster migration advisory lock within ${Math.round(x() / 1e3)}s. Another runner is migrating the cluster schema, or a prior boot wedged while holding it. (Raise VOLTRO_CLUSTER_MIGRATION_LOCK_TIMEOUT_MS, or inspect pg_locks for the holder.)`)) : n.sleep(`${S} millis`).pipe(n.zipRight(i));
+		}));
+		return i;
+	}
+}), T = (e, t) => e.onDialectOrElse({
+	sqlite: () => n.void,
+	mysql: () => n.asVoid(t.executeValues(`SELECT RELEASE_LOCK('${b}')`, [])),
+	mssql: () => n.asVoid(t.executeValues(`EXEC sp_releaseapplock @Resource = '${b}', @LockOwner = 'Session'`, [])),
+	orElse: () => n.asVoid(t.executeValues(`SELECT pg_advisory_unlock(${y.toString()}::bigint)`, []))
+}), E = (e, t) => e.onDialectOrElse({
+	sqlite: () => !0,
+	orElse: () => !1
+}) ? t : n.scoped(n.gen(function* () {
+	let r = yield* e.reserve;
+	return yield* n.acquireRelease(w(e, r), () => T(e, r).pipe(n.orDie)), yield* t;
+})), D = (e) => e === "sql" ? ["cluster_messages", "cluster_runners"] : ["cluster_messages"], O = (e, t) => n.forEach(D(t), (t) => e`SELECT 1 FROM ${e(t)}`.pipe(n.as(!0), n.catchAll(() => n.succeed(!1))), { concurrency: 1 }).pipe(n.map((e) => e.every(Boolean))), k = (e, t) => n.scoped(n.asVoid(r.build(t.pipe(r.provide(m.layerDefaults), r.provide(r.succeed(v.SqlClient, e)))))), A = (e, t) => k(e, g.layer).pipe(n.zipRight(t === "sql" ? k(e, _.layer) : n.void)), j = (e) => r.effect(v.SqlClient, n.gen(function* () {
+	let t = yield* v.SqlClient;
+	return (yield* O(t, e.runnerStorage)) || (yield* E(t, A(t, e.runnerStorage))), t;
+})), M = 34e3, N = (e) => {
+	let t = e.runnerListenHost ?? process.env.POD_IP ?? process.env.VOLTRO_WORKFLOW_RUNNER_HOST ?? "localhost";
+	return {
+		host: t,
+		port: e.runnerListenPort ?? 34e3,
+		localhostRisk: e.runnerStorage === "sql" && (t === "localhost" || t === "127.0.0.1")
+	};
+}, P = (e) => {
+	let t = e.sqliteFamily ? "memory" : "sql", n = e.override ?? process.env.VOLTRO_WORKFLOW_RUNNER_STORAGE;
+	if (n === void 0 || n.trim() === "") return t;
+	let r = n.trim().toLowerCase();
+	if (r !== "memory" && r !== "sql") throw Error(`VOLTRO_WORKFLOW_RUNNER_STORAGE must be 'memory' or 'sql', got '${n}'.`);
+	if (r === "sql" && e.sqliteFamily) throw Error("VOLTRO_WORKFLOW_RUNNER_STORAGE='sql' is unsupported on sqlite / turso — @effect/cluster has no sqlite advisory-lock branch. Use 'memory'.");
+	return r;
+}, F = (e = process.env.VOLTRO_WORKFLOW_SHARD_LOCK) => {
+	if (e === void 0 || e.trim() === "") return "auto";
+	let t = e.trim().toLowerCase();
+	if (t === "auto" || t === "row" || t === "advisory") return t;
+	throw Error(`VOLTRO_WORKFLOW_SHARD_LOCK must be 'auto', 'row', or 'advisory', got '${e}'.`);
+}, I = n.gen(function* () {
+	let e = yield* (yield* v.SqlClient)`SELECT @@wsrep_on AS wsrep`.pipe(n.catchAll(() => n.succeed([])));
+	if (e.length === 0) return !1;
+	let t = e[0].wsrep;
+	return t === 1 || t === "1" || t === !0 || t === "ON" || t === "on";
+}), L = (e) => n.gen(function* () {
+	return e.runnerStorage === "memory" ? !1 : e.mode === "row" ? !0 : e.mode === "advisory" || e.dialectId !== "mysql" && e.dialectId !== "mariadb" ? !1 : yield* I;
+}), R = () => {
+	let e = (e) => {
+		if (e === void 0) return;
+		let t = Number(e);
+		return Number.isFinite(t) && t > 0 ? t : void 0;
+	}, t = e(process.env.VOLTRO_WORKFLOW_FAILOVER_LEASE), n = e(process.env.VOLTRO_WORKFLOW_FAILOVER_HEARTBEAT), r = e(process.env.VOLTRO_WORKFLOW_POLL_INTERVAL);
+	return {
+		...t === void 0 ? {} : { failoverLeaseSeconds: t },
+		...n === void 0 ? {} : { failoverHeartbeatSeconds: n },
+		...r === void 0 ? {} : { messagePollSeconds: r }
+	};
+}, z = n.flatMap(p.Sharding, (e) => e.pollStorage), B = /* @__PURE__ */ new Set(), V = (e) => {
+	let a = N({
+		runnerStorage: e.runnerStorage,
+		runnerListenHost: e.runnerListenHost,
+		runnerListenPort: e.runnerListenPort
+	}), o = a.host, c = a.port;
+	a.localhostRisk && !B.has(o) && (B.add(o), process.stderr.write(`[voltro:workflow] runner host is '${o}' with SQL cluster storage — other pods cannot reach this runner, so a workflow cannot resume on another pod after a reschedule. Inject POD_IP via the K8s downward API (fieldRef: status.podIP) or set runnerListenHost / VOLTRO_WORKFLOW_RUNNER_HOST.
+`));
+	let l = j({ runnerStorage: e.runnerStorage }).pipe(r.provide(e.sqlClientLayer)), u = e.shardLockMode ?? F(), d = r.unwrapEffect(L({
+		dialectId: e.dialectId,
+		runnerStorage: e.runnerStorage,
+		mode: u
+	}).pipe(n.map((n) => (e.runnerStorage === "sql" && process.stderr.write(`[voltro:workflow] shard-lock coordination: ${n ? "row-based" : "advisory"} (dialect=${e.dialectId ?? "unknown"}, mode=${u}` + (n && u === "auto" ? ", wsrep/Galera cluster detected" : "") + ")\n"), h.layer({
+		runnerStorage: e.runnerStorage,
+		shardingConfig: {
+			runnerAddress: i.some(f.make(o, c)),
+			runnerListenAddress: i.some(f.make(o, c)),
+			...n ? { shardLockDisableAdvisory: !0 } : {},
+			...e.failoverLeaseSeconds === void 0 ? {} : { shardLockExpiration: t.seconds(e.failoverLeaseSeconds) },
+			...e.failoverHeartbeatSeconds === void 0 ? {} : { shardLockRefreshInterval: t.seconds(e.failoverHeartbeatSeconds) },
+			...e.messagePollSeconds === void 0 ? {} : { entityMessagePollInterval: t.seconds(e.messagePollSeconds) }
+		}
+	}))))).pipe(r.provide(l)), p = e.extraShardingLayers ?? [];
+	return (p.length === 0 ? s.layer : r.mergeAll(s.layer, ...p)).pipe(r.provideMerge(d));
+}, H = (e) => a.make({
+	name: e.name,
+	cron: e.cron,
+	execute: n.promise(() => e.execute()),
+	skipIfOlderThan: e.skipIfOlderThan ?? t.days(1)
+}), U = (e, t) => `${e}/${t}`, W = (t, n, r) => {
+	let i = l.make(n), a = e.get(t.annotations, o.ShardGroup)(i);
+	return new c.EntityAddress({
+		entityType: u.EntityType.make(`Workflow/${t.name}`),
+		entityId: i,
+		shardId: r.getShardId(i, a)
+	});
+}, G = (e) => {
+	let t = (e) => e && typeof e == "object" && "_tag" in e ? String(e._tag) : void 0, n = t(e);
+	if (n === "Failure" || n !== "Success") return "failed";
+	let r = e.value, i = t(r);
+	if (i === "Suspended") return "suspended";
+	if (i === "Complete") {
+		let e = r.exit;
+		return t(e) === "Success" ? "succeeded" : "failed";
+	}
+	return "failed";
+}, K = (e) => J(e.workflow, e.executionId, e.failedActivities), q = (e) => J(e.workflow, e.executionId, e.resetActivities), J = (e, t, r) => n.gen(function* () {
+	let a = yield* p.Sharding, o = yield* d.MessageStorage, s = W(e, t, a), c = yield* o.requestIdForPrimaryKey({
+		address: s,
+		tag: "run",
+		id: ""
+	}).pipe(n.orElseSucceed(() => i.none()));
+	if (i.isNone(c)) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-journal"
+	};
+	let l = (yield* o.repliesForUnfiltered([c.value]).pipe(n.orElseSucceed(() => []))).filter((e) => e._tag === "WithExit").at(-1);
+	if (l === void 0) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-reply"
+	};
+	if (G(l.exit) === "succeeded") return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "succeeded"
+	};
+	let u = 0;
+	for (let e of r) {
+		let t = yield* o.requestIdForPrimaryKey({
+			address: s,
+			tag: "activity",
+			id: U(e.name, e.attempt)
+		}).pipe(n.orElseSucceed(() => i.none()));
+		i.isSome(t) && (yield* a.reset(t.value)) && (u += 1);
+	}
+	let f = yield* a.reset(c.value);
+	return yield* a.pollStorage, {
+		redriven: !0,
+		runReplyCleared: f,
+		activitiesReset: u,
+		reason: null
+	};
+});
+//#endregion
+export { M as a, z as c, P as d, L as f, H as i, R as l, K as n, I as o, V as p, q as r, F as s, U as t, N as u };

package/dist/cluster.d.ts

@@ -206,6 +206,47 @@ export declare const resolveShardLockDisableAdvisory: (opts: {
     readonly mode: ShardLockMode;
 }) => Effect.Effect<boolean, never, SqlClient.SqlClient>;
 
+export declare interface ResumeFromStepTarget {
+    /** The workflow definition — for its `name` (entity type) + `annotations` (shard group). */
+    readonly workflow: Workflow.Any;
+    /** The engine-assigned execution id (= cluster `entityId`) of the run to resume. */
+    readonly executionId: string;
+    /**
+     * The step attempts to reset so they re-execute fresh: the operator's
+     * chosen rewind target AND every step ordered at/after it — regardless
+     * of whether those steps SUCCEEDED. This is the one difference from
+     * {@link redriveFailedRun}, which resets only the failed attempts: resume
+     * rewinds PAST the failure point, so a step that completed cleanly but
+     * whose result is now stale re-runs too. Steps BEFORE the target keep
+     * their journaled replies and replay. Typically every
+     * `_voltro_workflow_run_steps` row (all attempts) whose `startedAt` is at
+     * or after the target step's first attempt.
+     */
+    readonly resetActivities: ReadonlyArray<FailedActivityRef>;
+}
+
+/**
+ * Resume a terminally-`failed` workflow run from an operator-chosen STEP,
+ * rather than from the step it happened to die on.
+ *
+ * The generalisation of {@link redriveFailedRun}: it resets the target step
+ * AND every step ordered at/after it (all attempts, succeeded ones included),
+ * so those re-execute while the steps BEFORE the target replay from the
+ * journal. Use it when the failure point is not the right rewind point — a
+ * step completed cleanly but on stale/wrong external state, and the operator
+ * wants to re-run from there once the cause is fixed.
+ *
+ * The mechanism is identical to redrive (clear the chosen replies + the run
+ * reply, then re-poll); only the SET of replies cleared differs, and that set
+ * is computed by the caller from `_voltro_workflow_run_steps`. Refuses (no
+ * mutation) for the same reasons — no journal, still running, or already
+ * succeeded.
+ *
+ * Requires the SAME cluster instance's `Sharding` + `MessageStorage` the
+ * workflow engine was built from (see `workflowEngineLayer`).
+ */
+export declare const resumeRunFromStep: (target: ResumeFromStepTarget) => Effect.Effect<RedriveOutcome, never, Sharding.Sharding | MessageStorage.MessageStorage>;
+
 /** Resolved cluster-runner address + the silent-resume-breaker flag.
  *  Single source of truth for both the engine layer and the
  *  `/_voltro/inspect/cluster` snapshot, so the CLI never reports an

package/dist/cluster.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "./cluster-BQ0H5M9n.js";
-export { i as DEFAULT_RUNNER_LISTEN_PORT, u as activityPrimaryKey, e as detectWsrepCluster, c as makeClusterCronLayer, s as parseShardLockMode, l as pollWorkflowStorage, o as redriveFailedRun, t as resolveFailoverTuning, a as resolveRunnerIdentity, d as resolveRunnerStorage, n as resolveShardLockDisableAdvisory, r as workflowEngineLayer };
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, p as c, r as l, s as u, t as d, u as f } from "./cluster-CyIyBO39.js";
+export { e as DEFAULT_RUNNER_LISTEN_PORT, d as activityPrimaryKey, s as detectWsrepCluster, i as makeClusterCronLayer, u as parseShardLockMode, t as pollWorkflowStorage, o as redriveFailedRun, a as resolveFailoverTuning, f as resolveRunnerIdentity, n as resolveRunnerStorage, r as resolveShardLockDisableAdvisory, l as resumeRunFromStep, c as workflowEngineLayer };

package/dist/clusterTestSuite.d.ts

@@ -35,6 +35,35 @@ export declare interface ClusterEngineFixture {
     readonly reachable: () => Promise<boolean>;
 }
 
+/**
+ * Clear cluster state left behind by EARLIER runs of this suite.
+ *
+ * Nothing did this, and the consequence was a suite that got less reliable the
+ * more you ran it. Every scenario names its workflows with a per-run `SUFFIX`,
+ * so a run's cron entities never collide with the next run's — they ACCUMULATE
+ * instead. A fresh runner then finds messages addressed to
+ * `ClusterCron/clusterCron_<oldSuffix>` entity types that no process registers a
+ * handler for any more, and retries them every 10 seconds, forever, holding a
+ * connection each time. Eventually the pool cannot be acquired and whichever
+ * scenario is running dies with `SqlError: Failed to acquire connection` — a
+ * failure that names the victim and not the cause, in a file that passes
+ * perfectly in isolation against a fresh database.
+ *
+ * That is the mechanism behind the "rotating victims" this repo has a
+ * maintainer note about. It reads as machine saturation because the symptom is
+ * timing-shaped, but the load is manufactured by the suite's own leftovers, and
+ * it survives every `docker compose down`-less rerun.
+ *
+ * Purging at the START rather than the end is deliberate: an `afterAll` cannot
+ * clean up after a run that crashed, and the leftovers of a crashed run are
+ * exactly the ones most likely to be there. Same reasoning as the boot path's
+ * `reapTestFixtures`.
+ *
+ * Best-effort per table — on the first ever run against a database the cluster
+ * tables do not exist yet, and that is not a failure.
+ */
+export declare const purgeClusterState: (fixture: ClusterEngineFixture) => Promise<void>;
+
 /**
  * Register the cluster-engine suite for one dialect. Each
  * `@voltro/sql-*` (or the workflow package) calls this from a thin

package/dist/clusterTestSuite.js

@@ -1,6 +1,6 @@
-import { C as e, m as t, p as n, v as r, x as i } from "./primitives-Dgu3O55Q.js";
-import { i as a } from "./src-KDx7NTsa.js";
-import { f as o, r as s } from "./cluster-BQ0H5M9n.js";
+import { E as e, _ as t, h as n, w as r, x as i } from "./primitives-Cwy2zQpU.js";
+import { i as a } from "./src-CMapid4w.js";
+import { i as o, p as s } from "./cluster-CyIyBO39.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";
@@ -41,7 +41,7 @@ var y = async (e, t, n = 750) => {
 	}
 	return !0;
 }), T = (m) => {
-	let y = `${m.name}-${Date.now()}`, b = (e, t) => o({
+	let y = `${m.name}-${Date.now()}`, b = (e, t) => s({
 		sqlClientLayer: m.sqlClientLayer,
 		runnerStorage: m.runnerStorage,
 		runnerListenPort: e,
@@ -50,21 +50,21 @@ var y = async (e, t, n = 750) => {
 		...t && t.length > 0 ? { extraShardingLayers: t } : {}
 	});
 	g(`cluster workflow engine — ${m.name}`, () => {
-		let o = !1;
+		let s = !1;
 		h(async () => {
-			if (o = await m.reachable(), !o) {
+			if (s = await m.reachable(), !s) {
 				console.warn(`[skip] cluster suite — ${m.name} not reachable`);
 				return;
 			}
 			await x(m);
 		}, 3e4), v("a two-step workflow runs end-to-end", async () => {
-			if (!o) return;
-			let e = `clusterTwoStep_${y}`, n = r({
+			if (!s) return;
+			let e = `clusterTwoStep_${y}`, n = i({
 				name: e,
 				payload: { id: p.String },
 				success: p.Number,
 				idempotencyKey: ({ id: t }) => `${e}:${t}`
-			}), i = n.toLayer(() => u.gen(function* () {
+			}), r = n.toLayer(() => u.gen(function* () {
 				let e = yield* t({
 					name: "first",
 					success: p.Number,
@@ -76,25 +76,25 @@ var y = async (e, t, n = 750) => {
 					execute: u.succeed(e + 2)
 				});
 			}));
-			_(await u.runPromise(u.scoped(n.execute({ id: `e2e-${y}` }).pipe(u.provide(i.pipe(f.provideMerge(b(m.runnerPort)))))))).toBe(42);
+			_(await u.runPromise(u.scoped(n.execute({ id: `e2e-${y}` }).pipe(u.provide(r.pipe(f.provideMerge(b(m.runnerPort)))))))).toBe(42);
 		}, 3e4), v("idempotency-key journal — same payload returns same result", async () => {
-			if (!o) return;
-			let e = `clusterIdempotency_${y}`, n = 0, i = r({
+			if (!s) return;
+			let e = `clusterIdempotency_${y}`, n = 0, r = i({
 				name: e,
 				payload: { id: p.String },
 				success: p.Number,
 				idempotencyKey: ({ id: t }) => `${e}:${t}`
-			}), a = i.toLayer(() => t({
+			}), a = r.toLayer(() => t({
 				name: "compute",
 				success: p.Number,
 				execute: u.sync(() => (n++, n * 100))
-			})).pipe(f.provideMerge(b(m.runnerPort))), [s, c] = await u.runPromise(u.scoped(u.gen(function* () {
-				return [yield* i.execute({ id: `same-${y}` }), yield* i.execute({ id: `same-${y}` })];
+			})).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))));
-			_(s).toBe(c), _(n).toBe(1);
+			_(o).toBe(c), _(n).toBe(1);
 		}, 3e4), v("ClusterCron fires its execute on the shard owner", async () => {
-			if (!o) return;
-			let e = await u.runPromise(l.make()), t = 0, n = s({
+			if (!s) return;
+			let e = await u.runPromise(l.make()), t = 0, n = o({
 				name: `clusterCron_${y}`,
 				cron: c.unsafeParse("*/1 * * * * *", "UTC"),
 				execute: async () => {
@@ -107,24 +107,24 @@ var y = async (e, t, n = 750) => {
 		}, 35e3);
 		let g = m.clusterResume ? v : (() => {});
 		g("a sleeping workflow resumes on a fresh runner after the first is torn down", async () => {
-			if (!o) return;
-			let e = `dormancyResume_${y}`, i = [], a = [], s = [], c = () => r({
+			if (!s) return;
+			let e = `dormancyResume_${y}`, r = [], a = [], o = [], c = () => i({
 				name: e,
 				payload: { id: p.String },
 				success: p.String,
 				idempotencyKey: ({ id: t }) => `${e}:${t}`
-			}), l = (e, r) => e.toLayer(() => u.gen(function* () {
+			}), l = (e, i) => e.toLayer(() => u.gen(function* () {
 				return yield* t({
 					name: "step1",
 					success: p.Void,
 					execute: u.sync(() => {
-						i.push(r);
+						r.push(i);
 					})
 				}), yield* t({
 					name: "armed",
 					success: p.Void,
 					execute: u.sync(() => {
-						s.push(r);
+						o.push(i);
 					})
 				}), yield* n({
 					name: "nap",
@@ -133,7 +133,7 @@ var y = async (e, t, n = 750) => {
 					name: "step2",
 					success: p.Void,
 					execute: u.sync(() => {
-						a.push(r);
+						a.push(i);
 					})
 				}), "done";
 			})), h = m.runnerPort + 2, g = (e) => {
@@ -144,15 +144,15 @@ var y = async (e, t, n = 750) => {
 				};
 			}, 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(() => s.length > 0, 6e4)) ? r : yield* u.die(/* @__PURE__ */ Error("runner A never journaled step1"));
+				return (yield* w(() => o.length > 0, 6e4)) ? r : yield* u.die(/* @__PURE__ */ Error("runner A never journaled step1"));
 			})));
-			await u.runPromise(d.interrupt(x).pipe(u.ignore)), _(i).toEqual(["A"]), _(a).toEqual([]), _(await u.runPromise(u.scoped(u.gen(function* () {
+			await u.runPromise(d.interrupt(x).pipe(u.ignore)), _(r).toEqual(["A"]), _(a).toEqual([]), _(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"));
-			})))).toBe("done"), _(i).toEqual(["A"]), _(a).toEqual(["B"]);
+			})))).toBe("done"), _(r).toEqual(["A"]), _(a).toEqual(["B"]);
 		}, 48e4), g("dormancy loop: a wake signal survives teardown and is cleared on resume", async () => {
-			if (!o) return;
-			let s = `dormancyLoop_${y}`, c = `wr_${s}`, l = [], h = /* @__PURE__ */ new Map(), g = a({
+			if (!s) return;
+			let o = `dormancyLoop_${y}`, c = `wr_${o}`, l = [], h = /* @__PURE__ */ new Map(), g = a({
 				store: {
 					insert: async (e, t) => t,
 					update: async () => null,
@@ -166,12 +166,12 @@ var y = async (e, t, n = 750) => {
 						h.delete(e);
 					}
 				}
-			}), v = () => r({
-				name: s,
+			}), v = () => i({
+				name: o,
 				payload: { id: p.String },
 				success: p.String,
-				idempotencyKey: ({ id: e }) => `${s}:${e}`
-			}), x = (r, a) => r.toLayer(() => u.gen(function* () {
+				idempotencyKey: ({ id: e }) => `${o}:${e}`
+			}), x = (i, a) => i.toLayer(() => u.gen(function* () {
 				return yield* t({
 					name: "step1",
 					success: p.Void,
@@ -186,7 +186,7 @@ var y = async (e, t, n = 750) => {
 						l.push(a);
 					})
 				}), "done";
-			}).pipe(u.locally(i, c), u.provideService(e, g))), S = m.runnerPort + 2, T = (e) => {
+			}).pipe(u.locally(r, c), u.provideService(e, g))), S = m.runnerPort + 2, T = (e) => {
 				let t = v();
 				return {
 					wf: t,
@@ -204,4 +204,4 @@ var y = async (e, t, n = 750) => {
 	});
 };
 //#endregion
-export { T as runClusterEngineSuite, y as tcpReachable };
+export { x as purgeClusterState, T as runClusterEngineSuite, y as tcpReachable };