@voltro/workflow 0.84.0 → 0.85.0

package/dist/cluster-F_bhqVP7.js

@@ -0,0 +1,679 @@
+import { C as e, S as t, d as n, g as r, h as i, i as a, l as o, r as s, s as c, t as l, u, y as d } from "./workflowReadSelections-CZAUjP7f.js";
+import { RateLimiter as f } from "effect/persistence";
+import { Context as p, Crypto as m, Duration as h, Effect as g, Layer as _, Option as v, PlatformError as y, Schedule as ee, Schema as b, Semaphore as te } from "effect";
+import { eq as x } from "@voltro/database";
+import { SqlClient as S } from "effect/sql";
+import { ClusterCron as ne, ClusterSchema as re, ClusterWorkflowEngine as C, EntityAddress as ie, EntityId as ae, EntityType as oe, MessageStorage as w, RunnerAddress as T, RunnerHealth as se, RunnerStorage as E, Runners as ce, ShardId as le, Sharding as D, ShardingConfig as ue, SqlMessageStorage as O, SqlRunnerStorage as k } from "effect/cluster";
+import { applyUndeclaredCharsetWork as de, fnv1a64 as A, readUndeclaredCharsetColumns as fe, resolveMigrationLockSchema as j, sqlPoolCapacity as pe, undeclaredCharsetWork as me } from "@voltro/database/sql";
+import { PersistenceError as he } from "effect/cluster/ClusterError";
+import { realpath as ge } from "node:fs/promises";
+import { createLogger as _e } from "@voltro/logger";
+//#region src/workflowResumeDispatch.ts
+var ve = (n) => g.gen(function* () {
+	let a = yield* g.context(), o = yield* g.promise(() => n.transaction((t) => e(t, n.requestId, (e) => g.runPromiseWith(a)(i(e)))));
+	if (o.kind !== "bound") return o;
+	let s = yield* g.promise(() => n.transaction((e) => t(e, n.requestId)));
+	if (s.kind !== "dispatch") return s;
+	let { request: c } = s;
+	if (c.operation !== "resume" || c.resumeJournal === null) return yield* g.die(/* @__PURE__ */ Error("Resume dispatch requires its committed suspension binding"));
+	let l = yield* r({
+		workflowName: c.workflowName,
+		executionId: c.executionId,
+		...c.resumeJournal
+	});
+	return yield* (yield* D.Sharding).pollStorage, {
+		kind: "attempted",
+		request: c,
+		journal: l
+	};
+}), M = class extends p.Service()("@voltro/workflow/WorkflowResumeDispatcher") {}, ye = g.gen(function* () {
+	let e = yield* S.SqlClient, t = yield* D.Sharding;
+	return M.of({ dispatch: (n) => ve(n).pipe(g.provideService(S.SqlClient, e), g.provideService(D.Sharding, t)) });
+}), be = async (e) => {
+	if (e.workflow._tag !== e.command.workflowName || e.control.workflowName !== e.command.workflowName) throw Error("Restart preparation requires the matching workflow");
+	let t = await e.transaction(async (t) => {
+		let n = await c(t, e.command);
+		if (n !== void 0) return {
+			kind: "accepted",
+			request: n
+		};
+		let [r] = await t.query({
+			table: "_voltro_workflow_runs",
+			predicate: x("id", e.command.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["runnerGeneration"]
+		});
+		return {
+			kind: "captured",
+			generation: b.decodeUnknownSync(b.NonEmptyString)(r?.runnerGeneration)
+		};
+	});
+	return t.kind === "accepted" ? {
+		kind: "reserved",
+		request: t.request,
+		reused: !0
+	} : Se({
+		...e,
+		command: {
+			...e.command,
+			generation: t.generation
+		}
+	});
+}, xe = b.Struct({
+	requestId: b.NonEmptyString,
+	restartToken: b.NullOr(b.NonEmptyString)
+}), Se = async (e) => {
+	let { command: t } = e;
+	if (e.workflow._tag !== 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 o(n, t);
+		if (r !== void 0) return {
+			kind: "accepted",
+			request: r
+		};
+		let [i] = await n.query({
+			table: "_voltro_workflow_runs",
+			predicate: x("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 ((b.decodeUnknownSync(b.NullOr(b.Struct({ tenantId: b.NullOr(b.NonEmptyString) })))(i.subject ?? null)?.tenantId ?? null) !== t.tenantId) throw Error("Restart preparation belongs to another tenant");
+		return {
+			kind: "observe",
+			executionId: i.executionId,
+			delivery: b.decodeUnknownSync(xe)(i.engineDelivery),
+			activities: await e.readActivities(n)
+		};
+	});
+	if (n.kind === "accepted") return {
+		kind: "reserved",
+		request: n.request,
+		reused: !0
+	};
+	let r = await e.observe({
+		workflow: e.workflow,
+		executionId: n.executionId,
+		delivery: n.delivery,
+		activities: n.activities
+	});
+	return e.transaction(async (i) => {
+		let a = await o(i, t);
+		if (a !== void 0) return {
+			kind: "reserved",
+			request: a,
+			reused: !0
+		};
+		if (r.kind === "unavailable") return r;
+		let [s] = await i.query({
+			table: "_voltro_workflow_runs",
+			predicate: x("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 u(i, {
+			...t,
+			token: e.createToken(),
+			delivery: n.delivery,
+			replies: r.replies,
+			control: e.control,
+			paused: await e.readPaused(i),
+			now: e.now
+		});
+	});
+}, N = (e, t) => `${e}/${t}`, P = (e, t, n) => {
+	let r = ae.make(t), i = p.get(e.annotations, re.ShardGroup)(r);
+	return new ie.EntityAddress({
+		entityType: oe.EntityType.make(`Workflow/${e._tag}`),
+		entityId: r,
+		shardId: n.getShardId(r, i)
+	});
+}, Ce = (e, t) => g.gen(function* () {
+	let n = yield* D.Sharding, r = yield* w.MessageStorage, i = yield* r.requestIdForPrimaryKey({
+		address: P(e, t, n),
+		tag: "run",
+		id: ""
+	});
+	if (v.isNone(i)) return { kind: "not-found" };
+	let a = String(i.value), o = yield* r.repliesForUnfiltered([i.value]), s = l(o);
+	return s === void 0 ? {
+		kind: "pending",
+		requestId: a
+	} : {
+		kind: "reply",
+		requestId: a,
+		replyId: String(s.id),
+		exit: s.exit
+	};
+}), F = b.Union([b.Struct({
+	_tag: b.Literal("Success"),
+	value: b.Unknown
+}), b.Struct({
+	_tag: b.Literal("Failure"),
+	cause: b.Array(b.Union([
+		b.Struct({
+			_tag: b.Literal("Fail"),
+			error: b.Unknown
+		}),
+		b.Struct({
+			_tag: b.Literal("Die"),
+			defect: b.Unknown
+		}),
+		b.Struct({
+			_tag: b.Literal("Interrupt"),
+			fiberId: b.optional(b.NullOr(b.Number))
+		})
+	]))
+})]), I = b.decodeUnknownOption(F), L = (e) => {
+	let t = (e) => e && typeof e == "object" && "_tag" in e && typeof e._tag == "string" ? e._tag : void 0, n = I(e);
+	if (v.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 = I(e);
+		return v.isNone(t) ? "unrecognized-reply" : t.value._tag === "Success" ? "succeeded" : "failed";
+	}
+	return "unrecognized-reply";
+}, we = (e) => R(e.workflow, e.executionId, e.failedActivities), Te = (e) => R(e.workflow, e.executionId, e.resetActivities), R = (e, t, n) => g.gen(function* () {
+	let r = yield* D.Sharding, i = yield* w.MessageStorage, a = P(e, t, r), o = yield* i.requestIdForPrimaryKey({
+		address: a,
+		tag: "run",
+		id: ""
+	}).pipe(g.orDie);
+	if (v.isNone(o)) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-journal"
+	};
+	let s = yield* i.repliesForUnfiltered([o.value]).pipe(g.orDie), c = l(s);
+	if (c === void 0) return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: "no-reply"
+	};
+	let u = L(c.exit);
+	if (u !== "failed") return {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: 0,
+		reason: u
+	};
+	let d = /* @__PURE__ */ new Set();
+	for (let e of n) {
+		let t = yield* i.requestIdForPrimaryKey({
+			address: a,
+			tag: "activity",
+			id: N(e.name, e.attempt)
+		}).pipe(g.orDie);
+		if (v.isNone(t)) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: 0,
+			reason: "activity-not-found"
+		};
+		d.add(t.value);
+	}
+	let f = 0;
+	for (let e of d) {
+		if (!(yield* r.reset(e))) return {
+			redriven: !1,
+			runReplyCleared: !1,
+			activitiesReset: f,
+			reason: "activity-reset-unconfirmed"
+		};
+		f++;
+	}
+	let p = yield* r.reset(o.value);
+	return p ? (yield* r.pollStorage, {
+		redriven: !0,
+		runReplyCleared: p,
+		activitiesReset: f,
+		reason: null
+	}) : {
+		redriven: !1,
+		runReplyCleared: !1,
+		activitiesReset: f,
+		reason: "run-reset-unconfirmed"
+	};
+}), Ee = b.fromJsonString(b.Record(b.String, b.String)), De = (e) => g.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* g.die(/* @__PURE__ */ Error("Restart observation requires an exact delivery and valid activity attempts"));
+	let t = (yield* S.SqlClient).withoutTransforms(), n = yield* w.MessageStorage, r = yield* D.Sharding, i = P(e.workflow, e.executionId, r), a = (n, r) => g.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._tag}` || i.entity_id !== e.executionId || i.tag !== r ? yield* g.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* g.sync(() => b.decodeUnknownSync(Ee)(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 = L(yield* g.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: N(t.name, t.attempt)
+		});
+		if (v.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(g.provideService(S.SafeIntegers, !0)), Oe = (e) => g.gen(function* () {
+	let t = yield* n(e);
+	return t.kind === "waiting-capacity" ? t : (yield* (yield* D.Sharding).pollStorage, {
+		kind: "attempted",
+		journal: t
+	});
+}), z = class extends p.Service()("@voltro/workflow/WorkflowRestartDispatcher") {}, ke = g.gen(function* () {
+	let e = yield* S.SqlClient, t = yield* D.Sharding, n = yield* w.MessageStorage, r = (r) => De(r).pipe(g.provideService(S.SqlClient, e), g.provideService(D.Sharding, t), g.provideService(w.MessageStorage, n));
+	return z.of({
+		prepare: (e) => g.tryPromise({
+			try: (t) => be({
+				...e,
+				observe: (e) => g.runPromise(r(e), { signal: t })
+			}),
+			catch: (e) => e
+		}),
+		observe: r,
+		dispatch: (n) => Oe(n).pipe(g.provideService(S.SqlClient, e), g.provideService(D.Sharding, t))
+	});
+}), Ae = m.make({
+	randomBytes: (e) => globalThis.crypto.getRandomValues(new Uint8Array(e)),
+	digest: (e, t) => g.tryPromise({
+		try: async () => new Uint8Array(await globalThis.crypto.subtle.digest(e, new Uint8Array(t).buffer)),
+		catch: (t) => y.systemError({
+			_tag: "Unknown",
+			module: "Crypto",
+			method: "digest",
+			description: `digest ${e} failed`,
+			cause: t
+		})
+	})
+}), B = _.succeed(m.Crypto, Ae), V = 6322741009312601n, H = () => {
+	let e = j();
+	return e === void 0 ? V : A(`voltro_cluster_migration_lock:${e}`) & 9223372036854775807n;
+}, U = () => {
+	let e = `voltro_cluster_migration_${V.toString(36)}`, t = j();
+	if (t === void 0) return e;
+	let n = `${e}_${t}`;
+	return /^[A-Za-z0-9_]+$/.test(t) && n.length <= 64 ? n : `${e}_h${A(`voltro_cluster_migration_lock:${t}`).toString(16)}`;
+}, W = () => {
+	let e = Number(process.env.VOLTRO_CLUSTER_MIGRATION_LOCK_TIMEOUT_MS);
+	return Number.isFinite(e) && e > 0 ? e : 6e4;
+}, je = 250, G = (e) => e[0]?.[0], Me = (e, t) => e.onDialectOrElse({
+	sqlite: () => g.void,
+	mysql: () => t.executeValues(`SELECT GET_LOCK('${U()}', ${Math.ceil(W() / 1e3)})`, []).pipe(g.flatMap((e) => G(e) === 1 || G(e) === "1" ? g.void : g.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${U()}' (GET_LOCK timed out)`)))),
+	mssql: () => t.executeValues(`DECLARE @res int; EXEC @res = sp_getapplock @Resource = '${U()}', @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${W()}; SELECT @res`, []).pipe(g.flatMap((e) => Number(G(e) ?? -999) >= 0 ? g.void : g.die(/* @__PURE__ */ Error(`could not acquire cluster migration lock '${U()}' (sp_getapplock ${String(G(e))})`)))),
+	orElse: () => {
+		let e = H().toString(), n = Date.now(), r = t.executeValues(`SELECT pg_try_advisory_lock(${e}::bigint)`, []).pipe(g.flatMap((e) => {
+			let t = G(e);
+			return t === !0 || t === "t" || t === 1 ? g.void : Date.now() - n >= W() ? g.die(/* @__PURE__ */ Error(`could not acquire the cluster migration advisory lock within ${Math.round(W() / 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.)`)) : g.sleep(`${je} millis`).pipe(g.andThen(r));
+		}));
+		return r;
+	}
+}), Ne = (e, t) => e.onDialectOrElse({
+	sqlite: () => g.void,
+	mysql: () => g.asVoid(t.executeValues(`SELECT RELEASE_LOCK('${U()}')`, [])),
+	mssql: () => g.asVoid(t.executeValues(`EXEC sp_releaseapplock @Resource = '${U()}', @LockOwner = 'Session'`, [])),
+	orElse: () => g.asVoid(t.executeValues(`SELECT pg_advisory_unlock(${H().toString()}::bigint)`, []))
+}), Pe = (e, t) => e.onDialectOrElse({
+	sqlite: () => !0,
+	orElse: () => !1
+}) ? t : g.scoped(g.gen(function* () {
+	let n = yield* e.reserve;
+	return yield* g.acquireRelease(Me(e, n), () => Ne(e, n).pipe(g.orDie)), yield* t;
+})), Fe = (e) => e === "sql" ? ["cluster_messages", "cluster_runners"] : ["cluster_messages"], Ie = (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(g.map((e) => {
+	let t = e[0]?.present;
+	return t === !0 || t === 1 || t === "1" || t === "t" || typeof t == "bigint" && t === 1n;
+}), g.catch(() => g.succeed(!1))), Le = (e, t) => g.forEach(Fe(t), (t) => Ie(e, t), { concurrency: 1 }).pipe(g.map((e) => e.every(Boolean))), K = (e, t) => g.scoped(g.asVoid(_.build(t.pipe(_.provide(ue.layerDefaults), _.provide(_.succeed(S.SqlClient, e)), _.provide(B))))), q = (e, t) => K(e, O.layer).pipe(g.andThen(t === "sql" ? K(e, k.layer) : g.void)), J = (e) => g.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)))), Re = (e, t, n) => n === void 0 || !e.onDialectOrElse({
+	mysql: () => !0,
+	orElse: () => !1
+}) ? q(e, t) : g.gen(function* () {
+	let r = yield* J(e);
+	yield* q(e, t);
+	let i = new Set([...yield* J(e)].filter((e) => !r.has(e)));
+	i.size !== 0 && (yield* de(e, me(yield* fe(e), /* @__PURE__ */ new Set(), n, i)));
+}), ze = (e) => e === "sql" ? 3 : 2, Y = (e) => _.effect(S.SqlClient, g.gen(function* () {
+	let t = yield* S.SqlClient, n = ze(e.runnerStorage), r = pe(t);
+	return r !== void 0 && r < n ? yield* g.die(/* @__PURE__ */ Error(`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* Le(t, e.runnerStorage)) || (yield* Pe(t, Re(t, e.runnerStorage, e.charset))), t);
+})), Be = (e, t) => g.gen(function* () {
+	let n = h.fromInputUnsafe(t.interval), r = h.toMillis(t.giveUpAfter), i, a, o = !1, s = !1;
+	yield* t.probe.pipe(g.timeout(n), g.isSuccess, g.flatMap((e) => g.sync(() => {
+		let n = Date.now();
+		if (e) {
+			if (i = void 0, !o || (a ??= n, n - a < r)) return;
+			t.log.info("workflow runner: its storage answers again — taking part in shard assignment again"), a = void 0, o = !1, s = !1;
+			return;
+		}
+		a = void 0, i ??= n, !o && n - i >= r && (o = !0, t.log.warn(`workflow runner: its connection pool has not served a query for ${Math.round((n - i) / 1e3)}s — released its shards and stopped its heartbeat, so another runner takes them`, { fix: "look for what holds this process's database connections (`voltro_db_operations_in_flight` against DB_MAX_CONNECTIONS)" }));
+	}))).pipe(g.repeat(ee.spaced(n)), g.forkScoped);
+	let c = () => new he({ cause: /* @__PURE__ */ Error("workflow runner gave its shards up: its connection pool does not serve queries") });
+	return E.RunnerStorage.of({
+		...e,
+		register: (t, n) => g.suspend(() => o ? g.fail(c()) : e.register(t, n)),
+		acquire: (t, n) => g.suspend(() => o ? g.succeed([]) : e.acquire(t, n)),
+		refresh: (t, n) => g.suspend(() => {
+			if (!o) return e.refresh(t, n);
+			let r = s ? g.void : e.releaseAll(t).pipe(g.tap(() => g.sync(() => {
+				s = !0;
+			})), g.ignore);
+			return g.andThen(r, g.fail(c()));
+		})
+	});
+}), Ve = (e) => g.map(te.make(1), (t) => ({
+	...e,
+	release: (n, r) => t.withPermits(1)(g.suspend(() => e.release(n, r)))
+})), He = _.unwrap(g.map(S.SqlClient, (e) => e.onDialectOrElse({
+	sqlite: () => _.effect(E.RunnerStorage, g.flatMap(E.RunnerStorage, Ve)).pipe(_.provide(k.layer)),
+	orElse: () => k.layer
+}))), Ue = (e) => _.effect(E.RunnerStorage, g.gen(function* () {
+	let t = yield* S.SqlClient;
+	return yield* Be(yield* E.RunnerStorage, {
+		...e,
+		probe: t`SELECT 1`
+	});
+})).pipe(_.provide(_.orDie(He))), We = (e) => D.layer.pipe(_.provideMerge(ce.layerNoop), _.provideMerge(O.layer), _.provide([e.runnerStorage === "memory" ? E.layerMemory : Ue(e.guard), se.layerNoop]), _.provide(ue.layerFromEnv(e.shardingConfig)), _.provide(B)), Ge = (e) => g.gen(function* () {
+	let t = yield* g.tryPromise({
+		try: () => ge(e),
+		catch: X
+	}), n = yield* g.acquireRelease(g.tryPromise({
+		try: async () => {
+			let { DatabaseSync: e } = await import("node:sqlite");
+			return new e(`${t}.voltro-workflow-lock`);
+		},
+		catch: X
+	}), (e) => g.sync(() => e.close()));
+	yield* g.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 = X(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 });
+		}
+	});
+}), X = (e) => e instanceof Error ? e : Error(String(e)), Z = (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;
+}, Ke = (e) => e === !0 || e === 1 || e === "1" || e instanceof Uint8Array && e[0] === 1, qe = "cluster", Je = (e = qe) => {
+	let t = new TextEncoder().encode(`effect-cluster:${e}`), n = 2166136261;
+	for (let e of t) n = Math.imul(n ^ e, 16777619);
+	return (n | 0) >>> 0;
+}, Ye = (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) => g.gen(function* () {
+	let t = yield* S.SqlClient, n = e.shardGroups ?? ["default"], r = e.dialectId ?? "", i = r.startsWith("postgres") || r === "pg", a = (e) => e.pipe(g.catch(() => g.succeed([]))), o = t.onDialectOrElse({
+		pg: () => t.literal("NOW()"),
+		mysql: () => t.literal("NOW()"),
+		mssql: () => t.literal("GETDATE()"),
+		orElse: () => t.literal("CURRENT_TIMESTAMP")
+	}), c = (e, t) => {
+		let n = Z(e.last_read), r = Z(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: Ke(e.processed),
+			lastRead: i === null ? null : new Date(t - i)
+		};
+	}, l = (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(g.map((e) => e.map((e) => c(e, n))));
+	}, f = (e = s) => {
+		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 < ${l(n)}
+        AND (deliver_at IS NULL OR deliver_at <= ${r})
+        ORDER BY last_read ASC
+      `).pipe(g.map((e) => e.flatMap((e) => {
+			let t = c(e, r);
+			return t.lastRead === null ? [] : [{
+				...t,
+				unreadForMs: Math.max(0, r - t.lastRead.getTime())
+			}];
+		})));
+	}, p = (n) => a(t`
+        SELECT shard_id, address, acquired_at FROM cluster_locks WHERE ${t.in("shard_id", n)}
+      `).pipe(g.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: Z(n.acquired_at)
+		};
+	}))), m = (r) => {
+		let i = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let t = Ye(e, n);
+			t !== void 0 && i.set(t, e);
+		}
+		return i.size === 0 ? g.succeed([]) : g.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.objsubid = 2
+            AND l.classid = ${Je()} 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: Z(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: Z(n.backend_start)?.toISOString() ?? null
+					}
+				}];
+			});
+		});
+	};
+	return {
+		ownAddress: e.ownAddress,
+		shardLockMode: e.shardLockMode,
+		messagesFor: d,
+		unreadMessages: f,
+		shardLockHolders: (t) => t.length === 0 || e.runnerStorage !== "sql" ? g.succeed([]) : e.shardLockMode === "row" ? p(t) : e.shardLockMode === "advisory" && i ? m(t) : g.succeed([]),
+		runners: () => e.runnerStorage === "sql" ? a(t`SELECT address, last_heartbeat, healthy FROM cluster_runners ORDER BY last_heartbeat DESC`).pipe(g.map((e) => e.map((e) => {
+			let t = e;
+			return {
+				address: String(t.address ?? ""),
+				lastHeartbeat: Z(t.last_heartbeat),
+				healthy: Ke(t.healthy)
+			};
+		}))) : g.succeed([]),
+		discardMessages: (e) => {
+			let n = e.unreadForMs === void 0 ? t.literal("") : t`AND last_read IS NOT NULL AND last_read < ${l(Math.max(1, Math.ceil(e.unreadForMs / 1e3)))}`;
+			return g.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).map(String);
+				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, g.provideService(S.SafeIntegers, !0), g.catch(() => g.succeed(0)));
+		}
+	};
+}), $ = _e({ scope: "voltro:workflow" }), Xe = 34e3, Ze = (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")
+	};
+}, Qe = (e) => {
+	let t = e.sqlRunnerSupported ?? !e.sqliteFamily, n = t ? "sql" : "memory", r = e.override ?? process.env.VOLTRO_WORKFLOW_RUNNER_STORAGE;
+	if (r === void 0 || r.trim() === "") return n;
+	let i = r.trim().toLowerCase();
+	if (i !== "memory" && i !== "sql") throw Error(`VOLTRO_WORKFLOW_RUNNER_STORAGE must be 'memory' or 'sql', got '${r}'.`);
+	if (i === "sql" && !t) throw Error("VOLTRO_WORKFLOW_RUNNER_STORAGE='sql' is unsupported for this database connection. Use 'memory' for a local or embedded SQLite-family connection.");
+	return i;
+}, $e = (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}'.`);
+}, et = g.gen(function* () {
+	let e = yield* (yield* S.SqlClient)`SELECT @@wsrep_on AS wsrep`.pipe(g.catch(() => g.succeed([])));
+	if (e.length === 0) return !1;
+	let t = e[0].wsrep;
+	return t === 1 || t === "1" || t === !0 || t === "ON" || t === "on";
+}), tt = (e) => g.gen(function* () {
+	return e.runnerStorage === "memory" ? !1 : e.dialectId === "sqlite" || e.dialectId === "turso" || e.mode === "row" ? !0 : e.mode === "advisory" || e.dialectId !== "mysql" && e.dialectId !== "mariadb" ? !1 : yield* et;
+}), nt = (e) => ({
+	coordination: e.disableAdvisory ? "row-based" : "advisory",
+	dialect: e.dialectId ?? "unknown",
+	mode: e.mode,
+	...e.disableAdvisory && e.mode === "auto" ? { reason: e.dialectId === "sqlite" || e.dialectId === "turso" ? "SQLite-family connection uses row locks" : "wsrep/Galera cluster detected" } : {}
+}), rt = () => {
+	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 }
+	};
+}, it = g.flatMap(D.Sharding, (e) => e.pollStorage), at = /* @__PURE__ */ new Set(), ot = (e) => Object.assign(Object.create(Object.getPrototypeOf(e)), e, { requestIdForPrimaryKey: (t) => e.requestIdForPrimaryKey(t).pipe(g.provideService(S.SafeIntegers, !0)) }), st = (e) => {
+	let t = Ze({
+		runnerStorage: e.runnerStorage,
+		runnerListenHost: e.runnerListenHost,
+		runnerListenPort: e.runnerListenPort
+	}), n = t.host, r = t.port;
+	t.localhostRisk && !at.has(n) && (at.add(n), $.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: n }));
+	let i = e.dialectId === "sqlite" ? _.effect(S.SqlClient, g.gen(function* () {
+		let e = yield* S.SqlClient, t = (yield* e.unsafe("PRAGMA database_list")).find((e) => e.name === "main");
+		return t === void 0 ? yield* g.die(/* @__PURE__ */ Error("SQLite workflow connection has no main database")) : (t.file !== "" && (yield* Ge(t.file)), e);
+	}).pipe(g.orDie)).pipe(_.provide(e.sqlClientLayer)) : e.sqlClientLayer, o = Y({
+		runnerStorage: e.runnerStorage,
+		charset: e.charset
+	}).pipe(_.provide(i)), s = e.shardLockMode ?? $e(), c = _.unwrap(tt({
+		dialectId: e.dialectId,
+		runnerStorage: e.runnerStorage,
+		mode: s
+	}).pipe(g.map((t) => {
+		e.runnerStorage === "sql" && $.info("shard-lock coordination", nt({
+			disableAdvisory: t,
+			dialectId: e.dialectId,
+			mode: s
+		}));
+		let i = _.effect(a, g.flatMap(D.Sharding, (i) => Q({
+			ownAddress: T.make(n, r).toString(),
+			shardLockMode: e.runnerStorage === "sql" ? t ? "row" : "advisory" : "none",
+			runnerStorage: e.runnerStorage,
+			dialectId: e.dialectId,
+			hasShard: (e) => i.hasShardId(le.fromString(e))
+		}))), o = {
+			runnerAddress: v.some(T.make(n, r)),
+			runnerListenAddress: v.some(T.make(n, r)),
+			...t ? { shardLockDisableAdvisory: !0 } : {},
+			...e.failoverLeaseSeconds === void 0 ? {} : { shardLockExpiration: h.seconds(e.failoverLeaseSeconds) },
+			...e.failoverHeartbeatSeconds === void 0 ? {} : { shardLockRefreshInterval: h.seconds(e.failoverHeartbeatSeconds) },
+			...e.messagePollSeconds === void 0 ? {} : { entityMessagePollInterval: h.seconds(e.messagePollSeconds) }
+		}, c = h.seconds(e.failoverHeartbeatSeconds ?? 10), l = We({
+			runnerStorage: e.runnerStorage,
+			shardingConfig: o,
+			guard: {
+				interval: c,
+				giveUpAfter: h.times(c, 3),
+				log: $
+			}
+		});
+		return _.mergeAll(i, _.effect(M, ye), _.effect(z, ke)).pipe(_.provideMerge(l));
+	}))).pipe(_.provide(o)), l = e.extraShardingLayers ?? [], u = l.length === 0 ? C.layer : _.mergeAll(C.layer, ...l), m = _.flatMap(c, (t) => {
+		let n = p.add(t, D.Sharding, d(p.get(t, D.Sharding)));
+		return _.succeedContext(e.dialectId === "sqlite" ? p.add(n, w.MessageStorage, ot(p.get(n, w.MessageStorage))) : n);
+	}), y = f.layer.pipe(_.provide(f.layerStoreMemory));
+	return _.merge(u, y).pipe(_.provideMerge(m));
+}, ct = (e) => ne.make({
+	name: e.name,
+	cron: e.cron,
+	execute: g.promise(() => e.execute()),
+	skipIfOlderThan: e.skipIfOlderThan ?? h.days(1)
+});
+//#endregion
+export { Ce as _, it as a, M as b, Qe as c, Je as d, Q as f, N as g, F as h, $e as i, tt as l, z as m, Xe as n, rt as o, Y as p, et as r, Ze as s, ct as t, st as u, we as v, Te as y };