@voltro/workflow 0.81.0 → 0.82.0

package/README.md

@@ -24,3 +24,7 @@ deliberately short so there is nothing here to drift out of date.
 
 Proprietary. © 2026 Voltro UG. Your use is governed by the
 [Terms of Service](https://voltro.cloud/legal/terms). See the bundled `LICENSE`.
+
+### Read a persisted engine delivery
+
+`readWorkflowRunReply(workflow, executionId)` from `@voltro/workflow/cluster` reads the original run delivery using the engine's `Sharding` and `MessageStorage` services. It distinguishes no journal request, a request without a terminal reply, and a stored encoded Exit with string request/reply IDs. It preserves outer delivery failures that `workflow.poll` throws instead of returning as workflow results. Read failures remain Effect errors. This server-only diagnostic never resets, acknowledges or dispatches messages; authorize and project raw replies before client exposure. It does not prove recorder entry or add a dashboard endpoint by itself.

package/dist/cluster-MboOAwcv.js

@@ -0,0 +1,604 @@
+import { _ as e, a as t, b as n, c as r, l as i, m as a, n as o, p as s, s as c, t as l, x as u } from "./clusterDiagnostics-Dc7yBP3b.js";
+import { Context as d, Duration as f, Effect as p, Layer as m, Option as h, Runtime as g, Schema as _ } from "effect";
+import { eq as v } from "@voltro/database";
+import { SqlClient as y } from "@effect/sql";
+import { ClusterCron as ee, ClusterSchema as te, ClusterWorkflowEngine as b, EntityAddress as ne, EntityId as re, EntityType as ie, MessageStorage as x, RunnerAddress as S, ShardId as ae, Sharding as C, ShardingConfig as oe, SingleRunner as se, SqlMessageStorage as ce, SqlRunnerStorage as le } from "@effect/cluster";
+import { applyUndeclaredCharsetWork as ue, fnv1a64 as w, readUndeclaredCharsetColumns as de, resolveMigrationLockSchema as T, sqlPoolCapacity as fe, undeclaredCharsetWork as pe } from "@voltro/database/sql";
+import { realpath as me } from "node:fs/promises";
+import { createLogger as he } from "@voltro/logger";
+//#region src/workflowResumeDispatch.ts
+var ge = (e) => p.gen(function* () {
+	let t = yield* p.runtime(), r = yield* p.promise(() => e.transaction((n) => u(n, e.requestId, (e) => g.runPromise(t)(s(e)))));
+	if (r.kind !== "bound") return r;
+	let i = yield* p.promise(() => e.transaction((t) => n(t, e.requestId)));
+	if (i.kind !== "dispatch") return i;
+	let { request: o } = i;
+	if (o.operation !== "resume" || o.resumeJournal === null) return yield* p.die(/* @__PURE__ */ Error("Resume dispatch requires its committed suspension binding"));
+	let c = yield* a({
+		workflowName: o.workflowName,
+		executionId: o.executionId,
+		...o.resumeJournal
+	});
+	return yield* (yield* C.Sharding).pollStorage, {
+		kind: "attempted",
+		request: o,
+		journal: c
+	};
+}), E = class extends d.Tag("@voltro/workflow/WorkflowResumeDispatcher")() {}, _e = p.gen(function* () {
+	let e = yield* y.SqlClient, t = yield* C.Sharding;
+	return E.of({ dispatch: (n) => ge(n).pipe(p.provideService(y.SqlClient, e), p.provideService(C.Sharding, t)) });
+}), ve = async (e) => {
+	if (e.workflow.name !== e.command.workflowName || e.control.workflowName !== e.command.workflowName) throw Error("Restart preparation requires the matching workflow");
+	let n = await e.transaction(async (n) => {
+		let r = await t(n, e.command);
+		if (r !== void 0) return {
+			kind: "accepted",
+			request: r
+		};
+		let [i] = await n.query({
+			table: "_voltro_workflow_runs",
+			predicate: v("id", e.command.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["runnerGeneration"]
+		});
+		return {
+			kind: "captured",
+			generation: _.decodeUnknownSync(_.NonEmptyString)(i?.runnerGeneration)
+		};
+	});
+	return n.kind === "accepted" ? {
+		kind: "reserved",
+		request: n.request,
+		reused: !0
+	} : be({
+		...e,
+		command: {
+			...e.command,
+			generation: n.generation
+		}
+	});
+}, ye = _.Struct({
+	requestId: _.NonEmptyString,
+	restartToken: _.NullOr(_.NonEmptyString)
+}), be = async (e) => {
+	let { command: t } = e;
+	if (e.workflow.name !== t.workflowName || e.control.workflowName !== t.workflowName) throw Error("Restart preparation requires the matching workflow");
+	let n = await e.transaction(async (n) => {
+		let r = await c(n, t);
+		if (r !== void 0) return {
+			kind: "accepted",
+			request: r
+		};
+		let [i] = await n.query({
+			table: "_voltro_workflow_runs",
+			predicate: v("id", t.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (i === void 0 || i.tag !== t.workflowName || i.runnerGeneration !== t.generation || i.status !== "failed" || i.discardedAt != null || typeof i.executionId != "string" || i.executionId.length === 0) throw Error("Restart preparation requires its failed resident generation");
+		if ((_.decodeUnknownSync(_.NullOr(_.Struct({ tenantId: _.NullOr(_.NonEmptyString) })))(i.subject ?? null)?.tenantId ?? null) !== t.tenantId) throw Error("Restart preparation belongs to another tenant");
+		return {
+			kind: "observe",
+			executionId: i.executionId,
+			delivery: _.decodeUnknownSync(ye)(i.engineDelivery),
+			activities: await e.readActivities(n)
+		};
+	});
+	if (n.kind === "accepted") return {
+		kind: "reserved",
+		request: n.request,
+		reused: !0
+	};
+	let i = await e.observe({
+		workflow: e.workflow,
+		executionId: n.executionId,
+		delivery: n.delivery,
+		activities: n.activities
+	});
+	return e.transaction(async (a) => {
+		let o = await c(a, t);
+		if (o !== void 0) return {
+			kind: "reserved",
+			request: o,
+			reused: !0
+		};
+		if (i.kind === "unavailable") return i;
+		let [s] = await a.query({
+			table: "_voltro_workflow_runs",
+			predicate: v("id", t.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["executionId"]
+		});
+		if (s?.executionId !== n.executionId) throw Error("Restart execution changed during observation");
+		return r(a, {
+			...t,
+			token: e.createToken(),
+			delivery: n.delivery,
+			replies: i.replies,
+			control: e.control,
+			paused: await e.readPaused(a),
+			now: e.now
+		});
+	});
+}, D = (e, t) => `${e}/${t}`, O = (e, t, n) => {
+	let r = re.make(t), i = d.get(e.annotations, te.ShardGroup)(r);
+	return new ne.EntityAddress({
+		entityType: ie.EntityType.make(`Workflow/${e.name}`),
+		entityId: r,
+		shardId: n.getShardId(r, i)
+	});
+}, xe = (e, t) => p.gen(function* () {
+	let n = yield* C.Sharding, r = yield* x.MessageStorage, i = yield* r.requestIdForPrimaryKey({
+		address: O(e, t, n),
+		tag: "run",
+		id: ""
+	});
+	if (h.isNone(i)) return { kind: "not-found" };
+	let a = String(i.value), o = (yield* r.repliesForUnfiltered([i.value])).filter((e) => e._tag === "WithExit").at(-1);
+	return o === void 0 ? {
+		kind: "pending",
+		requestId: a
+	} : {
+		kind: "reply",
+		requestId: a,
+		replyId: String(o.id),
+		exit: o.exit
+	};
+}), k = _.decodeUnknownOption(_.Exit({
+	success: _.Unknown,
+	failure: _.Unknown,
+	defect: _.Unknown
+})), A = (e) => {
+	let t = (e) => e && typeof e == "object" && "_tag" in e && typeof e._tag == "string" ? e._tag : void 0, n = k(e);
+	if (h.isNone(n)) return "unrecognized-reply";
+	if (n.value._tag === "Failure") return "failed";
+	let r = n.value.value, i = t(r);
+	if (i === "Suspended") return "suspended";
+	if (i === "Complete") {
+		let e = r.exit, t = k(e);
+		return h.isNone(t) ? "unrecognized-reply" : t.value._tag === "Success" ? "succeeded" : "failed";
+	}
+	return "unrecognized-reply";
+}, Se = (e) => M(e.workflow, e.executionId, e.failedActivities), j = (e) => M(e.workflow, e.executionId, e.resetActivities), M = (e, t, n) => p.gen(function* () {
+	let r = yield* C.Sharding, i = yield* x.MessageStorage, a = O(e, t, r), o = yield* i.requestIdForPrimaryKey({
+		address: a,
+		tag: "run",
+		id: ""
+	}).pipe(p.orDie);
+	if (h.isNone(o)) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-journal"
+	};
+	let s = (yield* i.repliesForUnfiltered([o.value]).pipe(p.orDie)).filter((e) => e._tag === "WithExit").at(-1);
+	if (s === void 0) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-reply"
+	};
+	let c = A(s.exit);
+	if (c !== "failed") return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: c
+	};
+	let l = /* @__PURE__ */ new Set();
+	for (let e of n) {
+		let t = yield* i.requestIdForPrimaryKey({
+			address: a,
+			tag: "activity",
+			id: D(e.name, e.attempt)
+		}).pipe(p.orDie);
+		if (h.isNone(t)) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: 0,
+			reason: "activity-not-found"
+		};
+		l.add(t.value);
+	}
+	let u = 0;
+	for (let e of l) {
+		if (!(yield* r.reset(e))) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: u,
+			reason: "activity-reset-unconfirmed"
+		};
+		u++;
+	}
+	let d = yield* r.reset(o.value);
+	return d ? (yield* r.pollStorage, {
+		redriven: !0,
+		runReplyCleared: d,
+		activitiesReset: u,
+		reason: null
+	}) : {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: u,
+		reason: "run-reset-unconfirmed"
+	};
+}), Ce = _.parseJson(_.Record({
+	key: _.String,
+	value: _.String
+})), we = (e) => p.gen(function* () {
+	if (!/^[1-9]\d*$/.test(e.delivery.requestId) || e.executionId.length === 0 || e.activities.some((e) => e.name.length === 0 || !Number.isSafeInteger(e.attempt) || e.attempt < 1)) return yield* p.die(/* @__PURE__ */ Error("Restart observation requires an exact delivery and valid activity attempts"));
+	let t = (yield* y.SqlClient).withoutTransforms(), n = yield* x.MessageStorage, r = yield* C.Sharding, i = O(e.workflow, e.executionId, r), a = (n, r) => p.gen(function* () {
+		let [i] = yield* t`SELECT m.entity_type, m.entity_id, m.tag, m.headers, r.id AS reply_id, r.payload
+       FROM cluster_messages m
+       LEFT JOIN cluster_replies r ON r.id = m.last_reply_id AND r.request_id = m.id AND r.kind = 0
+       WHERE m.id = ${n} AND m.kind = 0`;
+		if (i !== void 0) return i.entity_type !== `Workflow/${e.workflow.name}` || i.entity_id !== e.executionId || i.tag !== r ? yield* p.die(/* @__PURE__ */ Error("Restart observation belongs to another execution or procedure")) : i;
+	}), o = yield* a(e.delivery.requestId, "run");
+	if (o === void 0) return {
+		kind: "unavailable",
+		reason: "no-journal"
+	};
+	if (((yield* p.sync(() => _.decodeUnknownSync(Ce)(o.headers)))["voltro-workflow-restart"] ?? null) !== e.delivery.restartToken) return {
+		kind: "unavailable",
+		reason: "delivery-changed"
+	};
+	if (o.reply_id === null || o.payload === null) return {
+		kind: "unavailable",
+		reason: "no-reply"
+	};
+	let s = A(yield* p.sync(() => JSON.parse(o.payload)));
+	if (s !== "failed") return {
+		kind: "unavailable",
+		reason: s
+	};
+	let c = /* @__PURE__ */ new Map([[e.delivery.requestId, String(o.reply_id)]]);
+	for (let t of e.activities) {
+		let e = yield* n.requestIdForPrimaryKey({
+			address: i,
+			tag: "activity",
+			id: D(t.name, t.attempt)
+		});
+		if (h.isNone(e)) return {
+			kind: "unavailable",
+			reason: "activity-not-found"
+		};
+		let r = String(e.value), o = yield* a(r, "activity");
+		if (o?.reply_id == null) return {
+			kind: "unavailable",
+			reason: "activity-not-found"
+		};
+		c.set(r, String(o.reply_id));
+	}
+	return {
+		kind: "observed",
+		replies: [...c].map(([e, t]) => ({
+			requestId: e,
+			replyId: t
+		}))
+	};
+}).pipe(p.provideService(y.SafeIntegers, !0)), Te = (e) => p.gen(function* () {
+	let t = yield* i(e);
+	return t.kind === "waiting-capacity" ? t : (yield* (yield* C.Sharding).pollStorage, {
+		kind: "attempted",
+		journal: t
+	});
+}), N = class extends d.Tag("@voltro/workflow/WorkflowRestartDispatcher")() {}, Ee = p.gen(function* () {
+	let e = yield* y.SqlClient, t = yield* C.Sharding, n = yield* x.MessageStorage, r = (r) => we(r).pipe(p.provideService(y.SqlClient, e), p.provideService(C.Sharding, t), p.provideService(x.MessageStorage, n));
+	return N.of({
+		prepare: (e) => p.tryPromise({
+			try: (t) => ve({
+				...e,
+				observe: (e) => p.runPromise(r(e), { signal: t })
+			}),
+			catch: (e) => e
+		}),
+		observe: r,
+		dispatch: (n) => Te(n).pipe(p.provideService(y.SqlClient, e), p.provideService(C.Sharding, t))
+	});
+}), P = 6322741009312601n, F = () => {
+	let e = T();
+	return e === void 0 ? P : w(`voltro_cluster_migration_lock:${e}`) & 9223372036854775807n;
+}, I = () => {
+	let e = `voltro_cluster_migration_${P.toString(36)}`, t = T();
+	if (t === void 0) return e;
+	let n = `${e}_${t}`;
+	return /^[A-Za-z0-9_]+$/.test(t) && n.length <= 64 ? n : `${e}_h${w(`voltro_cluster_migration_lock:${t}`).toString(16)}`;
+}, L = () => {
+	let e = Number(process.env.VOLTRO_CLUSTER_MIGRATION_LOCK_TIMEOUT_MS);
+	return Number.isFinite(e) && e > 0 ? e : 6e4;
+}, De = 250, R = (e) => e[0]?.[0], Oe = (e, t) => e.onDialectOrElse({
+	sqlite: () => p.void,
+	mysql: () => t.executeValues(`SELECT GET_LOCK('${I()}', ${Math.ceil(L() / 1e3)})`, []).pipe(p.flatMap((e) => R(e) === 1 || R(e) === "1" ? p.void : p.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${I()}' (GET_LOCK timed out)`)))),
+	mssql: () => t.executeValues(`DECLARE @res int; EXEC @res = sp_getapplock @Resource = '${I()}', @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${L()}; SELECT @res`, []).pipe(p.flatMap((e) => Number(R(e) ?? -999) >= 0 ? p.void : p.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${I()}' (sp_getapplock ${String(R(e))})`)))),
+	orElse: () => {
+		let e = F().toString(), n = Date.now(), r = t.executeValues(`SELECT pg_try_advisory_lock(${e}::bigint)`, []).pipe(p.flatMap((e) => {
+			let t = R(e);
+			return t === !0 || t === "t" || t === 1 ? p.void : Date.now() - n >= L() ? p.die(/* @__PURE__ */ Error(`could not acquire the cluster migration advisory lock within ${Math.round(L() / 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.)`)) : p.sleep(`${De} millis`).pipe(p.zipRight(r));
+		}));
+		return r;
+	}
+}), z = (e, t) => e.onDialectOrElse({
+	sqlite: () => p.void,
+	mysql: () => p.asVoid(t.executeValues(`SELECT RELEASE_LOCK('${I()}')`, [])),
+	mssql: () => p.asVoid(t.executeValues(`EXEC sp_releaseapplock @Resource = '${I()}', @LockOwner = 'Session'`, [])),
+	orElse: () => p.asVoid(t.executeValues(`SELECT pg_advisory_unlock(${F().toString()}::bigint)`, []))
+}), ke = (e, t) => e.onDialectOrElse({
+	sqlite: () => !0,
+	orElse: () => !1
+}) ? t : p.scoped(p.gen(function* () {
+	let n = yield* e.reserve;
+	return yield* p.acquireRelease(Oe(e, n), () => z(e, n).pipe(p.orDie)), yield* t;
+})), Ae = (e) => e === "sql" ? ["cluster_messages", "cluster_runners"] : ["cluster_messages"], je = (e, t) => e.onDialectOrElse({
+	pg: () => e`SELECT (to_regclass(${t}) IS NOT NULL) AS present`,
+	mysql: () => e`SELECT (COUNT(*) > 0) AS present FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ${t}`,
+	mssql: () => e`SELECT CASE WHEN OBJECT_ID(${t}, 'U') IS NULL THEN 0 ELSE 1 END AS present`,
+	orElse: () => e`SELECT (COUNT(*) > 0) AS present FROM sqlite_master WHERE type = 'table' AND name = ${t}`
+}).pipe(p.map((e) => {
+	let t = e[0]?.present;
+	return t === !0 || t === 1 || t === "1" || t === "t" || typeof t == "bigint" && t === 1n;
+}), p.catchAll(() => p.succeed(!1))), Me = (e, t) => p.forEach(Ae(t), (t) => je(e, t), { concurrency: 1 }).pipe(p.map((e) => e.every(Boolean))), B = (e, t) => p.scoped(p.asVoid(m.build(t.pipe(m.provide(oe.layerDefaults), m.provide(m.succeed(y.SqlClient, e)))))), V = (e, t) => B(e, ce.layer).pipe(p.zipRight(t === "sql" ? B(e, le.layer) : p.void)), H = (e) => p.map(e.unsafe("SELECT table_name AS t FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name LIKE 'cluster\\_%'"), (e) => new Set(e.map((e) => String(e.t ?? e.T)))), Ne = (e, t, n) => n === void 0 || !e.onDialectOrElse({
+	mysql: () => !0,
+	orElse: () => !1
+}) ? V(e, t) : p.gen(function* () {
+	let r = yield* H(e);
+	yield* V(e, t);
+	let i = new Set([...yield* H(e)].filter((e) => !r.has(e)));
+	i.size !== 0 && (yield* ue(e, pe(yield* de(e), /* @__PURE__ */ new Set(), n, i)));
+}), Pe = (e) => e === "sql" ? 3 : 2, U = (e) => m.effect(y.SqlClient, p.gen(function* () {
+	let t = yield* y.SqlClient, n = Pe(e.runnerStorage), r = fe(t);
+	return r !== void 0 && r < n ? yield* p.dieMessage(`the workflow runtime needs ${n} database connections at once and the pool has ${r}: ` + (e.runnerStorage === "sql" ? "on a first boot it holds its migration lock and its runner lock while the migration runs on a third, and once running it keeps the runner lock and needs one more to work. " : "on a first boot it holds its migration lock while the migration runs on a second. ") + `Set DB_MAX_CONNECTIONS (or PG_MAX_CONNECTIONS) to at least ${n}` + (e.runnerStorage === "sql" ? ", or VOLTRO_WORKFLOW_RUNNER_STORAGE=memory for a single-process runtime that needs 2 (no cross-pod shard handoff)." : ".")) : ((yield* Me(t, e.runnerStorage)) || (yield* ke(t, Ne(t, e.runnerStorage, e.charset))), t);
+})), Fe = (e) => p.gen(function* () {
+	let t = yield* p.tryPromise({
+		try: () => me(e),
+		catch: W
+	}), n = yield* p.acquireRelease(p.tryPromise({
+		try: async () => {
+			let { DatabaseSync: e } = await import("node:sqlite");
+			return new e(`${t}.voltro-workflow-lock`);
+		},
+		catch: W
+	}), (e) => p.sync(() => e.close()));
+	yield* p.try({
+		try: () => {
+			n.exec("PRAGMA busy_timeout=0"), n.exec("CREATE TABLE IF NOT EXISTS workflow_mutex(id INTEGER PRIMARY KEY)"), n.exec("BEGIN IMMEDIATE");
+		},
+		catch: (e) => {
+			let n = W(e), r = n.errcode;
+			return r !== void 0 && ((r & 255) == 5 || (r & 255) == 6) ? Error("SQLite workflow journal is already owned by another engine. Stop that engine before starting another, or use a SQL dialect with shared runner coordination for replicas.", { cause: n }) : Error(`Could not acquire SQLite workflow ownership for ${t}`, { cause: n });
+		}
+	});
+}), W = (e) => e instanceof Error ? e : Error(String(e)), G = (e) => {
+	if (e instanceof Date) return Number.isNaN(e.getTime()) ? null : e;
+	if (typeof e == "string" || typeof e == "number") {
+		let t = typeof e == "string" && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(e) ? `${e.replace(" ", "T")}Z` : e, n = new Date(t);
+		return Number.isNaN(n.getTime()) ? null : n;
+	}
+	return null;
+}, K = (e) => e === !0 || e === 1 || e === "1" || e instanceof Uint8Array && e[0] === 1, Ie = (e, t) => {
+	let n = e.lastIndexOf(":");
+	if (n < 0) return;
+	let r = e.slice(0, n), i = Number(e.slice(n + 1)), a = t.indexOf(r);
+	if (!(a < 0 || !Number.isInteger(i))) return (a + 1) * 1e6 + i;
+}, q = (e) => p.gen(function* () {
+	let t = yield* y.SqlClient, n = e.shardGroups ?? ["default"], r = e.dialectId ?? "", i = r.startsWith("postgres") || r === "pg", a = (e) => e.pipe(p.catchAll(() => p.succeed([]))), o = t.onDialectOrElse({
+		pg: () => t.literal("NOW()"),
+		mysql: () => t.literal("NOW()"),
+		mssql: () => t.literal("GETDATE()"),
+		orElse: () => t.literal("CURRENT_TIMESTAMP")
+	}), s = (e, t) => {
+		let n = G(e.last_read), r = G(e.server_now), i = n !== null && r !== null ? Math.max(0, r.getTime() - n.getTime()) : null;
+		return {
+			tag: typeof e.tag == "string" ? e.tag : null,
+			entityType: String(e.entity_type ?? ""),
+			entityId: String(e.entity_id ?? ""),
+			shardId: String(e.shard_id ?? ""),
+			processed: K(e.processed),
+			lastRead: i === null ? null : new Date(t - i)
+		};
+	}, c = (e) => t.onDialectOrElse({
+		pg: () => t.literal(`NOW() - INTERVAL '${e} seconds'`),
+		mysql: () => t.literal(`NOW() - INTERVAL ${e} SECOND`),
+		mssql: () => t.literal(`DATEADD(SECOND, -${e}, GETDATE())`),
+		orElse: () => t.literal(`DATETIME('now', '-${e} seconds')`)
+	}), u = t.onDialectOrElse({
+		pg: () => t.literal("FALSE"),
+		orElse: () => t.literal("0")
+	}), d = (e) => {
+		let n = Date.now();
+		return a(t`
+        SELECT tag, entity_type, entity_id, shard_id, processed, last_read, ${o} AS server_now
+        FROM cluster_messages
+        WHERE entity_id = ${e}
+        ORDER BY rowid ASC
+      `).pipe(p.map((e) => e.map((e) => s(e, n))));
+	}, f = (e = l) => {
+		let n = Math.max(1, Math.ceil(e / 1e3)), r = Date.now();
+		return a(t`
+        SELECT tag, entity_type, entity_id, shard_id, processed, last_read, ${o} AS server_now
+        FROM cluster_messages
+        WHERE processed = ${u}
+        AND last_read IS NOT NULL
+        AND last_read < ${c(n)}
+        AND (deliver_at IS NULL OR deliver_at <= ${r})
+        ORDER BY last_read ASC
+      `).pipe(p.map((e) => e.flatMap((e) => {
+			let t = s(e, r);
+			return t.lastRead === null ? [] : [{
+				...t,
+				unreadForMs: Math.max(0, r - t.lastRead.getTime())
+			}];
+		})));
+	}, m = (n) => a(t`
+        SELECT shard_id, address, acquired_at FROM cluster_locks WHERE ${t.in("shard_id", n)}
+      `).pipe(p.map((t) => t.map((t) => {
+		let n = t, r = String(n.address ?? ""), i = String(n.shard_id ?? "");
+		return {
+			shardId: i,
+			mode: "row",
+			holder: r,
+			own: r === e.ownAddress || (e.hasShard?.(i) ?? !1),
+			since: G(n.acquired_at)
+		};
+	}))), h = (r) => {
+		let i = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let t = Ie(e, n);
+			t !== void 0 && i.set(t, e);
+		}
+		return i.size === 0 ? p.succeed([]) : p.gen(function* () {
+			return (yield* a(t`
+          SELECT l.objid, a.pid, a.client_addr, a.application_name, a.state, a.state_change, a.backend_start, a.wait_event_type
+          FROM pg_locks l
+          JOIN pg_stat_activity a ON a.pid = l.pid
+          WHERE l.locktype = 'advisory' AND l.granted AND l.classid = 0 AND ${t.in("l.objid", [...i.keys()])}
+        `)).flatMap((t) => {
+				let n = t, r = i.get(Number(n.objid));
+				if (r === void 0) return [];
+				let a = Number(n.pid), o = n.client_addr === null || n.client_addr === void 0 ? "local socket" : String(n.client_addr), s = e.hasShard?.(r) ?? !1;
+				return [{
+					shardId: r,
+					mode: "advisory",
+					holder: s ? `this runner (pid ${a})` : `pid ${a} from ${o}`,
+					own: s,
+					since: G(n.state_change),
+					detail: {
+						pid: a,
+						clientAddr: n.client_addr ?? null,
+						applicationName: n.application_name ?? null,
+						state: n.state ?? null,
+						waitEventType: n.wait_event_type ?? null,
+						backendStart: G(n.backend_start)?.toISOString() ?? null
+					}
+				}];
+			});
+		});
+	};
+	return {
+		ownAddress: e.ownAddress,
+		shardLockMode: e.shardLockMode,
+		messagesFor: d,
+		unreadMessages: f,
+		shardLockHolders: (t) => t.length === 0 || e.runnerStorage !== "sql" ? p.succeed([]) : e.shardLockMode === "row" ? m(t) : e.shardLockMode === "advisory" && i ? h(t) : p.succeed([]),
+		runners: () => e.runnerStorage === "sql" ? a(t`SELECT address, last_heartbeat, healthy FROM cluster_runners ORDER BY last_heartbeat DESC`).pipe(p.map((e) => e.map((e) => {
+			let t = e;
+			return {
+				address: String(t.address ?? ""),
+				lastHeartbeat: G(t.last_heartbeat),
+				healthy: K(t.healthy)
+			};
+		}))) : p.succeed([]),
+		discardMessages: (e) => {
+			let n = e.unreadForMs === void 0 ? t.literal("") : t`AND last_read IS NOT NULL AND last_read < ${c(Math.max(1, Math.ceil(e.unreadForMs / 1e3)))}`;
+			return p.gen(function* () {
+				let r = (yield* t`
+          SELECT id FROM cluster_messages
+          WHERE entity_type = ${e.entityType} AND entity_id = ${e.entityId}
+          AND processed = ${u}
+          ${n}
+        `).map((e) => e.id).filter((e) => e != null);
+				return r.length === 0 ? 0 : (yield* t`DELETE FROM cluster_replies WHERE ${t.in("request_id", r)}`, yield* t`DELETE FROM cluster_messages WHERE ${t.in("id", r)}`, r.length);
+			}).pipe(t.withTransaction, p.catchAll(() => p.succeed(0)));
+		}
+	};
+}), J = he({ scope: "voltro:workflow" }), Le = 34e3, Y = (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")
+	};
+}, Re = (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;
+}, X = (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}'.`);
+}, Z = p.gen(function* () {
+	let e = yield* (yield* y.SqlClient)`SELECT @@wsrep_on AS wsrep`.pipe(p.catchAll(() => p.succeed([])));
+	if (e.length === 0) return !1;
+	let t = e[0].wsrep;
+	return t === 1 || t === "1" || t === !0 || t === "ON" || t === "on";
+}), Q = (e) => p.gen(function* () {
+	return e.runnerStorage === "memory" ? !1 : e.mode === "row" ? !0 : e.mode === "advisory" || e.dialectId !== "mysql" && e.dialectId !== "mariadb" ? !1 : yield* Z;
+}), ze = (e) => ({
+	coordination: e.disableAdvisory ? "row-based" : "advisory",
+	dialect: e.dialectId ?? "unknown",
+	mode: e.mode,
+	...e.disableAdvisory && e.mode === "auto" ? { reason: "wsrep/Galera cluster detected" } : {}
+}), Be = () => {
+	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 }
+	};
+}, Ve = p.flatMap(C.Sharding, (e) => e.pollStorage), $ = /* @__PURE__ */ new Set(), He = (t) => {
+	let n = Y({
+		runnerStorage: t.runnerStorage,
+		runnerListenHost: t.runnerListenHost,
+		runnerListenPort: t.runnerListenPort
+	}), r = n.host, i = n.port;
+	n.localhostRisk && !$.has(r) && ($.add(r), J.warn("runner host is not routable from other pods with SQL cluster storage — 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.", { runnerHost: r }));
+	let a = t.dialectId === "sqlite" ? m.scoped(y.SqlClient, p.gen(function* () {
+		let e = yield* y.SqlClient, t = (yield* e.unsafe("PRAGMA database_list")).find((e) => e.name === "main");
+		return t === void 0 ? yield* p.die(/* @__PURE__ */ Error("SQLite workflow connection has no main database")) : (t.file !== "" && (yield* Fe(t.file)), e);
+	}).pipe(p.orDie)).pipe(m.provide(t.sqlClientLayer)) : t.sqlClientLayer, s = U({
+		runnerStorage: t.runnerStorage,
+		charset: t.charset
+	}).pipe(m.provide(a)), c = t.shardLockMode ?? X(), l = m.unwrapEffect(Q({
+		dialectId: t.dialectId,
+		runnerStorage: t.runnerStorage,
+		mode: c
+	}).pipe(p.map((e) => {
+		t.runnerStorage === "sql" && J.info("shard-lock coordination", ze({
+			disableAdvisory: e,
+			dialectId: t.dialectId,
+			mode: c
+		}));
+		let n = m.effect(o, p.flatMap(C.Sharding, (n) => q({
+			ownAddress: S.make(r, i).toString(),
+			shardLockMode: t.runnerStorage === "sql" ? e ? "row" : "advisory" : "none",
+			runnerStorage: t.runnerStorage,
+			dialectId: t.dialectId,
+			hasShard: (e) => n.hasShardId(ae.ShardId.fromString(e))
+		}))), a = se.layer({
+			runnerStorage: t.runnerStorage,
+			shardingConfig: {
+				runnerAddress: h.some(S.make(r, i)),
+				runnerListenAddress: h.some(S.make(r, i)),
+				...e ? { shardLockDisableAdvisory: !0 } : {},
+				...t.failoverLeaseSeconds === void 0 ? {} : { shardLockExpiration: f.seconds(t.failoverLeaseSeconds) },
+				...t.failoverHeartbeatSeconds === void 0 ? {} : { shardLockRefreshInterval: f.seconds(t.failoverHeartbeatSeconds) },
+				...t.messagePollSeconds === void 0 ? {} : { entityMessagePollInterval: f.seconds(t.messagePollSeconds) }
+			}
+		});
+		return m.mergeAll(n, m.effect(E, _e), m.effect(N, Ee)).pipe(m.provideMerge(a));
+	}))).pipe(m.provide(s)), u = t.extraShardingLayers ?? [], g = u.length === 0 ? b.layer : m.mergeAll(b.layer, ...u), _ = l.pipe(m.map((t) => d.add(t, C.Sharding, e(d.get(t, C.Sharding)))));
+	return g.pipe(m.provideMerge(_));
+}, Ue = (e) => ee.make({
+	name: e.name,
+	cron: e.cron,
+	execute: p.promise(() => e.execute()),
+	skipIfOlderThan: e.skipIfOlderThan ?? f.days(1)
+});
+//#endregion
+export { j as _, Ve as a, Re as c, q as d, U as f, Se as g, xe as h, X as i, Q as l, D as m, Le as n, Be as o, N as p, Z as r, Y as s, Ue as t, He as u, E as v };