@voltro/cli 0.5.0 → 0.7.0

package/dist/serveCommand-Dn6--0Bv.js

@@ -0,0 +1,1111 @@
+import { pt as e, t } from "./inspectMetrics-BLUBAWLb.js";
+import { A as n, C as r, D as i, E as a, F as o, G as s, H as c, I as l, J as u, K as d, M as ee, N as f, O as p, P as m, Q as te, S as h, T as g, U as ne, W as re, X as ie, Y as _, Z as ae, _ as oe, at as v, b as se, ct as y, d as b, et as x, f as ce, g as le, h as ue, i as S, it as de, j as C, k as w, m as fe, n as pe, nt as T, o as E, q as me, rt as he, s as ge, t as D, v as _e, w as ve, x as ye, y as be } from "./dev-Bqyq62Ak.js";
+import { a as xe, r as Se } from "./startupRunner-DhlX9nqd.js";
+import { a as O, t as Ce } from "./apiBuild-deIjJKJm.js";
+import { join as we } from "node:path";
+import { pathToFileURL as Te } from "node:url";
+import { Cause as Ee, Effect as k, Layer as A, ManagedRuntime as De } from "effect";
+import { createLogger as j } from "@voltro/logger";
+import { existsSync as M } from "node:fs";
+import { AggregateRegistry as Oe, Dispatcher as ke, apiKeyManagementRoutes as N, applySoftDeleteScope as P, applyTenantScope as Ae, attachAnalyticsMirror as je, awaitServerListening as Me, bindMutation as F, bindStream as Ne, bindSubscription as I, buildTracingLayer as Pe, cancelWakeup as Fe, compileCron as Ie, dataStoreApiKeyStore as Le, dataStoreIdempotencyStore as Re, frameworkApiKeyStrategy as ze, installPolicyGuardResolver as Be, loadResourceTuples as Ve, makeActionRunner as He, makeAdvisoryLockCoordinator as Ue, makeApiKeyService as We, makeAsyncKv as Ge, makeCoordinatedScheduler as L, makeEffectStoreLayer as R, makeLazyWorkflowFacade as Ke, makeMutationRunner as qe, makeQueryDescriptorProducer as Je, makeQueryReauthorizer as Ye, makeSchemaRegistry as Xe, makeWorkflowFacade as Ze, makeWorkflowFacadeWithCallerContext as Qe, makeWorkflowLayers as $e, noopKv as et, recordSubscriptionDelivery as tt, registerWakeup as nt, resolveSecretsBackend as rt, runProvidedEffect as z, setSecretsBackend as it, setTupleSource as at, singleCoordinator as ot, startRpcServer as B, startScheduler as st, workflowToRpc as ct, wrapStoreWithMixinBehaviour as lt } from "@voltro/runtime";
+import { createHash as V, timingSafeEqual as H } from "node:crypto";
+import { assertProductionSessionSecret as ut } from "@voltro/protocol/session";
+import { RpcGroup as dt } from "@effect/rpc";
+import { SqlClient as ft } from "@effect/sql";
+import { and as pt, ensureTableRegistered as mt, eq as U, or as ht } from "@voltro/database";
+import { fromNodeReadable as gt, getObjectStream as _t, putObjectStream as vt, resolveStorageProvider as W, toNodeReadable as yt } from "@voltro/plugin-storage";
+import { AuthMiddleware as bt, ConnectionInfoMiddleware as xt, actionToRpc as G, anonymousSubject as St, mutationToRpc as Ct, queryToRpc as K, streamToRpc as wt, workflowCancelDescriptor as Tt, workflowDomainEventsQueryDescriptor as q, workflowEventDeliveriesQueryDescriptor as Et, workflowResumeDescriptor as Dt, workflowRunEventsQueryDescriptor as J, workflowRunQueryDescriptor as Y, workflowRunStepsQueryDescriptor as Ot, workflowRunsQueryDescriptor as X, workflowSignalDescriptor as Z, workflowUpdateDescriptor as kt } from "@voltro/protocol";
+import { declaredSnapshot as At, describeOutcome as jt, runPlannedMigrations as Mt } from "@voltro/database/sql";
+import { getAuthSessionStrategy as Nt } from "@voltro/plugin-auth";
+import { collectPublicApiRoutes as Pt, restRoutesToHttpRoutes as Ft } from "@voltro/protocol/rest";
+import { buildDeliverWebhookExecute as It, buildWebhooksService as Lt, defaultIncomingPath as Rt, deliverWebhookWorkflow as zt, mountIncomingWebhook as Bt } from "@voltro/plugin-webhooks";
+import { packBundle as Vt, runExport as Ht, runImport as Ut, storageBlobSink as Wt, storageRefsBlobSource as Gt, unpackBundle as Kt, unpackBundleToDir as qt } from "@voltro/data-transfer";
+//#region src/bootTiming.ts
+var Jt = () => {
+	let e = process.env.VOLTRO_BOOT_TIMING;
+	return e === "1" || e === "true";
+}, Yt = () => {
+	let e = [{
+		name: "modules",
+		at: performance.now()
+	}];
+	return {
+		mark: (t) => {
+			e.push({
+				name: t,
+				at: performance.now()
+			});
+		},
+		finish: (t) => {
+			let n = Math.round(e[e.length - 1].at);
+			if (!Jt()) {
+				t.info(`serve: ready in ${n}ms`);
+				return;
+			}
+			let r = {}, i = 0;
+			for (let t of e) r[t.name] = Math.round(t.at - i), i = t.at;
+			t.info(`serve: ready in ${n}ms`, {
+				bootMs: n,
+				phases: r
+			});
+		}
+	};
+}, Xt = "/_voltro/admin/import", Zt = "/_voltro/admin/export", Q = (e, t) => ({
+	status: e,
+	contentType: "application/json; charset=utf-8",
+	body: JSON.stringify(t)
+}), Qt = (e) => {
+	let t = e.authorization ?? e.Authorization, n = t ? /^Bearer\s+(.+)$/i.exec(t) : null;
+	return n ? n[1] : null;
+}, $t = (e, t) => H(V("sha256").update(e).digest(), V("sha256").update(t).digest()), en = (e, t) => {
+	if (e.method.toUpperCase() !== "POST") return Q(405, { error: "method not allowed" });
+	if (!t || t.length < 16) return Q(503, { error: "data transfer misconfigured (no/weak secret)" });
+	let n = Qt(e.headers);
+	return !n || !$t(n, t) ? Q(401, { error: "unauthorized" }) : null;
+}, tn = j({ scope: "voltro:admin-import" }), nn = "VBUNDLE2", rn = async function* (e) {
+	yield e;
+}, an = (e) => async (t) => {
+	let n = en(t, e.secret);
+	if (n) return n;
+	let r = t.headers["x-import-mode"], i = t.headers["x-import-on-conflict"], a = t.headers["x-import-atomic"] === "1" || t.headers["x-import-atomic"] === "true", o = t.headers["x-import-force"] === "1" || t.headers["x-import-force"] === "true", s = t.rawBody.byteLength >= 8 && Buffer.from(t.rawBody.subarray(0, 8)).toString("latin1") === nn, c, l;
+	if (s) c = rn(t.rawBody), l = "upload";
+	else {
+		let n;
+		try {
+			n = JSON.parse(Buffer.from(t.rawBody).toString("utf8") || "{}");
+		} catch {
+			return Q(400, { error: "body must be a packed bundle archive or { bundleKey } JSON" });
+		}
+		if (typeof n.bundleKey != "string" || !n.bundleKey) return Q(400, { error: "body.bundleKey (string) is required for the storage transport" });
+		if (!e.openArchive) return Q(501, { error: "storage transport not configured on this instance" });
+		c = e.openArchive(n.bundleKey), l = "storage";
+	}
+	let u = await import("node:os"), d = await import("node:fs/promises"), ee = await import("node:path"), f = await d.mkdtemp(ee.join(u.tmpdir(), "voltro-admin-import-"));
+	try {
+		e.assetSink ? await Kt(c, {
+			dir: f,
+			blobs: e.assetSink
+		}) : await qt(c, f);
+		let t = await k.runPromiseExit(Ut({
+			store: e.store,
+			bundleDir: f,
+			...r ? { mode: r } : {},
+			...i ? { onConflict: i } : {},
+			...a ? { atomic: a } : {},
+			...e.snapshot ? { targetSnapshot: e.snapshot } : {},
+			force: o,
+			onWarn: (e) => tn.warn("admin.import", { message: e }),
+			...e.assetSink ? { assetsAlreadyRestored: !0 } : {}
+		}));
+		if (t._tag === "Failure") {
+			let e = t.cause._tag === "Fail" ? t.cause.error : void 0;
+			if (e && e._tag === "SchemaDriftError") {
+				let t = e;
+				return tn.warn("admin.import refused (schema drift)", {
+					transport: l,
+					bundle: t.bundleFingerprint.slice(0, 16),
+					target: t.targetFingerprint.slice(0, 16)
+				}), Q(409, {
+					error: "schema drift",
+					bundleFingerprint: t.bundleFingerprint,
+					targetFingerprint: t.targetFingerprint,
+					diff: t.diff,
+					hint: "re-export against the current schema, or resend with x-import-force: 1"
+				});
+			}
+			throw Error(String(e?.message ?? e ?? "import failed"));
+		}
+		let n = t.value, s = n.tables.reduce((e, t) => e + t.rowCount, 0);
+		return tn.info("admin.import", {
+			transport: l,
+			tables: n.tables.length,
+			rows: s,
+			mode: r ?? "upsert",
+			atomic: a
+		}), Q(200, {
+			tables: n.tables.length,
+			rows: s,
+			transport: l
+		});
+	} catch (e) {
+		return tn.warn("admin.import failed", {
+			transport: l,
+			error: e?.message ?? String(e)
+		}), Q(500, {
+			error: "import failed",
+			message: e?.message ?? String(e)
+		});
+	} finally {
+		await d.rm(f, {
+			recursive: !0,
+			force: !0
+		});
+	}
+}, on = j({ scope: "voltro:admin-export" }), sn = async (e) => {
+	let t = [];
+	for await (let n of e) t.push(Buffer.from(n));
+	return new Uint8Array(Buffer.concat(t));
+}, cn = (e) => typeof e.tenant == "string" && e.tenant ? {
+	kind: "tenant",
+	tenantId: e.tenant
+} : Array.isArray(e.tables) && e.tables.length ? {
+	kind: "tables",
+	tables: e.tables.filter((e) => typeof e == "string")
+} : { kind: "all" }, ln = (e) => async (t) => {
+	let n = en(t, e.secret);
+	if (n) return n;
+	let r;
+	try {
+		r = JSON.parse(Buffer.from(t.rawBody).toString("utf8") || "{}");
+	} catch {
+		return Q(400, { error: "body must be JSON: { profile?, tenant?, tables?, consistency?, compression?, bundleKey? }" });
+	}
+	let i = {};
+	if (typeof r.profile == "string" && r.profile) {
+		if (!e.loadProfile) return Q(501, { error: "server-side profiles not configured on this instance" });
+		try {
+			i = await e.loadProfile(r.profile);
+		} catch (e) {
+			return Q(400, {
+				error: `profile '${r.profile}' could not be loaded`,
+				message: e?.message ?? String(e)
+			});
+		}
+	}
+	let a = r.consistency === "snapshot" ? "snapshot" : i.consistency ?? "live", o = (typeof r.compression == "string" ? r.compression : void 0) ?? i.compression, s = i.scope ?? cn(r), c = typeof r.bundleKey == "string" && r.bundleKey.length > 0, l = r.assets === !0 && e.assetSource ? { blobs: e.assetSource } : {}, u = await import("node:os"), d = await import("node:fs/promises"), ee = await import("node:path"), f = await d.mkdtemp(ee.join(u.tmpdir(), "voltro-admin-export-"));
+	try {
+		let t = await k.runPromise(Ht({
+			store: e.store,
+			snapshot: e.snapshot,
+			dialect: e.dialect,
+			outDir: f,
+			...i.subset ? { subset: i.subset } : {
+				scope: s,
+				...e.tenantTables && e.tenantTables.length > 0 ? { tenantTables: e.tenantTables } : {}
+			},
+			consistency: a,
+			...o ? { compression: o } : {},
+			...i.masking ? { masking: i.masking } : {}
+		})), n = t.tables.reduce((e, t) => e + t.rowCount, 0), u = t.masking?.transformed.length ?? 0;
+		if (c) {
+			if (!e.putArchive) return Q(501, { error: "storage transport not configured on this instance" });
+			let i = r.bundleKey;
+			return await e.putArchive(i, () => Vt({
+				dir: f,
+				...l
+			})), on.info("admin.export", {
+				transport: "storage",
+				tables: t.tables.length,
+				rows: n,
+				masked: u,
+				bundleKey: i
+			}), Q(200, {
+				bundleKey: i,
+				tables: t.tables.length,
+				rows: n,
+				masked: u,
+				transport: "storage"
+			});
+		}
+		let d = await sn(Vt({
+			dir: f,
+			...l
+		}));
+		return on.info("admin.export", {
+			transport: "download",
+			tables: t.tables.length,
+			rows: n,
+			masked: u,
+			bytes: d.byteLength
+		}), {
+			status: 200,
+			contentType: "application/octet-stream",
+			body: d,
+			headers: {
+				"x-export-tables": String(t.tables.length),
+				"x-export-rows": String(n),
+				"x-export-masked": String(u)
+			}
+		};
+	} catch (e) {
+		return on.warn("admin.export failed", { error: e?.message ?? String(e) }), Q(500, {
+			error: "export failed",
+			message: e?.message ?? String(e)
+		});
+	} finally {
+		await d.rm(f, {
+			recursive: !0,
+			force: !0
+		});
+	}
+}, un = async (e) => {
+	let { resolve: t } = await import("node:path"), { existsSync: n } = await import("node:fs"), r = [
+		e,
+		`${e}.profile.ts`,
+		`data-profiles/${e}.ts`,
+		`data-profiles/${e}.profile.ts`
+	].map((e) => t(process.cwd(), e)), i = r.find((e) => n(e));
+	if (!i) throw Error(`data profile '${e}' not found (looked for: ${r.join(", ")})`);
+	let a = await import(i), o = a.default ?? a.profile;
+	if (!o) throw Error(`data profile '${i}' has no default export`);
+	return o;
+}, dn = {
+	get: async () => void 0,
+	set: async () => {},
+	setWithTags: async () => {},
+	remove: async () => !1,
+	has: async () => !1,
+	clear: async () => {},
+	invalidateTag: async () => 0,
+	wrap: async (e, t, n) => n()
+}, fn = async (e) => {
+	let t = new ke({
+		store: e.store,
+		...e.snapshotCache ? { cache: e.snapshotCache } : {},
+		recordDelivery: (e) => tt({
+			label: e.label,
+			kind: e.kind,
+			durationMs: e.durationMs,
+			rowCount: e.rowCount
+		})
+	}), n = e.cache ?? dn, i = e.kv ?? et, a, s, c, l = /* @__PURE__ */ new Map(), u = () => `wfctx_${globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`}`, f = async (t, n, r) => {
+		let i = {
+			...r,
+			source: r.source ?? `workflow:${t}`
+		};
+		l.set(n, i);
+		try {
+			let r = await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: U("executionId", n),
+				projection: ["id"],
+				skip: void 0,
+				take: 1
+			}), a = {
+				workflowName: t,
+				executionId: n,
+				subject: i.subject ?? null,
+				traceId: i.traceId ?? null,
+				source: i.source ?? null,
+				parentExecutionId: i.parentExecutionId ?? null,
+				parentClosePolicy: i.parentClosePolicy ?? null,
+				createdAt: /* @__PURE__ */ new Date()
+			};
+			r[0] === void 0 ? await e.store.insert("_voltro_workflow_start_contexts", {
+				id: u(),
+				...a
+			}) : await e.store.update("_voltro_workflow_start_contexts", r[0].id, a);
+		} catch (e) {
+			process.stderr.write(`[workflow] failed to persist start context for ${t}/${n}: ${e?.message ?? String(e)}\n`);
+		}
+	}, te = async (t, n) => {
+		let r = l.get(n);
+		if (r !== void 0) return r;
+		try {
+			let t = (await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: U("executionId", n),
+				projection: void 0,
+				skip: void 0,
+				take: 1
+			}))[0];
+			if (t === void 0) return;
+			let r = {
+				...t.subject === null ? {} : { subject: t.subject },
+				...t.traceId === null ? {} : { traceId: t.traceId },
+				...t.source === null ? {} : { source: t.source },
+				...t.parentExecutionId === null ? {} : { parentExecutionId: t.parentExecutionId },
+				...t.parentClosePolicy === null ? {} : { parentClosePolicy: t.parentClosePolicy }
+			};
+			return l.set(n, r), r;
+		} catch (e) {
+			process.stderr.write(`[workflow] failed to load start context for ${n}: ${e?.message ?? String(e)}\n`);
+			return;
+		}
+	}, h = (e.discovered.workflows?.length ?? 0) > 0 ? Ke(() => a) : void 0, g = (e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.eventTriggers?.length ?? 0) > 0, ne = g || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster", re = e.tenantIsolation === "namespace", ae = (e.log ?? j({ scope: "voltro:serve" })).child("webhooks"), oe, v = e.discovered.webhooks;
+	if (v && v.outgoing.length > 0 && e.workflowEngineLayer !== void 0) {
+		let t = e.workflowEngineLayer, r = {
+			store: lt(e.store, {
+				subject: St(null),
+				schemaRegistry: e.schemaRegistry
+			}),
+			request: {
+				subject: St(null),
+				traceId: "webhooks:trigger"
+			},
+			cache: n,
+			kv: i
+		}, a = v.outgoing.map((e) => e.descriptor);
+		oe = Lt(r, async (e) => {
+			let n = zt.execute(e).pipe(k.provide(zt.toLayer(It(r, { events: a })).pipe(A.provideMerge(t))));
+			k.runPromise(n).catch((t) => {
+				ae.error("deliverWebhook workflow crashed", {
+					deliveryId: e.deliveryId,
+					targetId: e.targetId
+				}, t);
+			});
+		}, { events: a });
+	}
+	let se = /* @__PURE__ */ new Map();
+	if (v) for (let e of v.incoming) {
+		let t = e.descriptor.path ?? Rt(e.descriptor.id), n = `VOLTRO_WEBHOOK_SECRET_${e.descriptor.id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`, r = Bt(e.descriptor, {
+			resolveSecret: async () => process.env[n] ?? null,
+			resolveWorkflows: () => h === void 0 ? void 0 : Qe(h, {
+				traceId: `incoming:${e.descriptor.id}`,
+				source: `incoming:${e.descriptor.id}`
+			}),
+			log: (e) => {
+				let t = {
+					webhookId: e.webhookId,
+					status: e.status,
+					signatureOk: String(e.signatureOk),
+					idempotency: e.idempotency,
+					durationMs: e.durationMs
+				};
+				e.status >= 500 ? ae.error("incoming delivery failed", t) : e.status >= 400 ? ae.warn("incoming delivery rejected", t) : ae.info("incoming delivery handled", t);
+			}
+		});
+		se.set(t, { handle: r });
+	}
+	Be(), at((t) => Ve(e.store, t.subjectId, t.resourceType, t.resourceId));
+	let y = (e.discovered.outboxHandlers?.length ?? 0) > 0 ? m({
+		handlers: e.discovered.outboxHandlers ?? [],
+		store: e.store,
+		log: (e.log ?? j({ scope: "voltro:serve" })).child("outbox")
+	}) : void 0, b = ee({
+		definitions: (e.discovered.connections ?? []).map((e) => e.definition),
+		store: e.store,
+		publicUrl: C(e.port ?? 4e3),
+		log: (e.log ?? j({ scope: "voltro:serve" })).child("connections")
+	}), x = ie({
+		store: e.store,
+		schemaRegistry: e.schemaRegistry,
+		cache: n,
+		kv: i,
+		...oe === void 0 ? {} : { webhooksService: oe },
+		...h === void 0 ? {} : { workflowsProxy: h },
+		eventTriggers: e.discovered.eventTriggers ?? [],
+		namespaceIsolationOn: re,
+		...y === void 0 ? {} : { outbox: { nudge: y.nudge } },
+		...b.active ? { connections: { registry: b.registry } } : {}
+	}), ce = A.succeed(Oe, ve), le = (t, n) => {
+		let r = t.pipe(k.provide(R(n)));
+		return z((e.baseLayer ? r.pipe(k.provide(e.baseLayer)) : r).pipe(k.provide(ce)));
+	}, S = qe({
+		store: e.store,
+		buildContext: (e, t, n) => x(e, t, n),
+		runEffect: le,
+		undoCapture: be()
+	}), de = _e(), pe = He({
+		buildContext: (e) => x(e),
+		runEffect: le
+	}), T = Je({
+		buildContext: (e) => x(e),
+		finalize: (t, n) => P(Ae(t, e.tenantScopedTables, n.subject.tenantId), e.softDeleteScopedTables),
+		provideEffect: (e, t) => e.pipe(k.provide(R(t)))
+	}), E = {};
+	for (let n of [
+		...e.discovered.queries,
+		...de.queries,
+		...b.queries
+	]) E[n.descriptor.name] = (e) => I(T(n, e), t, `subscription.${n.descriptor.name}`, void 0, void 0, Ye(n, e));
+	for (let t of [
+		...e.discovered.mutations,
+		...de.mutations,
+		...b.mutations
+	]) E[t.descriptor.name] = (e) => F(async (e, n) => S(t, e, n), e, `mutation.${t.descriptor.name}`);
+	for (let t of [...e.discovered.actions, ...b.actions]) E[t.descriptor.name] = (e) => F(async (e, n) => pe(t, e, n), e, `action.${t.descriptor.name}`);
+	let me = () => `public-${Math.random().toString(36).slice(2, 10)}`, he = [...e.discovered.mutations.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+		descriptor: e.descriptor,
+		invoke: (t, n) => S(e, t, {
+			subject: n.subject,
+			traceId: me()
+		})
+	})), ...e.discovered.actions.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+		descriptor: e.descriptor,
+		invoke: (t, n) => pe(e, t, {
+			subject: n.subject,
+			traceId: me()
+		})
+	}))], ge = he.length > 0 ? Ft(Pt(he), {
+		store: e.store,
+		resolveSubject: (t) => e.resolveSubject(t, -1)
+	}) : [], D = e.dataTransferSecret ?? process.env.VOLTRO_DATA_TRANSFER_SECRET, ye = D && D.length >= 16 ? [{
+		method: "POST",
+		path: Xt,
+		handle: an({
+			secret: D,
+			store: e.store,
+			...e.dataTransferSnapshot ? { snapshot: e.dataTransferSnapshot } : {},
+			assetSink: Wt(W({})),
+			openArchive: (e) => (async function* () {
+				let t = W({}), n = await yt((await k.runPromise(_t(t, e))).stream);
+				for await (let e of n) yield e instanceof Uint8Array ? e : new Uint8Array(e);
+			})()
+		})
+	}, {
+		method: "POST",
+		path: Zt,
+		handle: ln({
+			secret: D,
+			store: e.store,
+			snapshot: e.dataTransferSnapshot ?? { tables: [] },
+			dialect: e.dataTransferDialect ?? "memory",
+			tenantTables: [...e.tenantScopedTables],
+			loadProfile: un,
+			assetSource: Gt(W({}), e.store),
+			putArchive: async (e, t) => {
+				let { Readable: n } = await import("node:stream"), r = W({}), i = gt("storage", () => n.from(t()));
+				await k.runPromise(vt(r, e, i, { contentType: "application/octet-stream" }));
+			}
+		})
+	}] : [], xe = [
+		...e.httpRoutes ?? [],
+		...ge,
+		...ye,
+		...b.httpRoutes
+	];
+	for (let t of e.discovered.streams ?? []) E[t.descriptor.name] = (n) => Ne((r) => {
+		let i = x(r), a = t.executor(n, i);
+		if (k.isEffect(a)) {
+			let t = a.pipe(k.provide(R(i.store)));
+			return (e.baseLayer ? t.pipe(k.provide(e.baseLayer)) : t).pipe(k.provide(ce));
+		}
+		return typeof a == "object" && a && typeof a.then == "function" ? k.promise(() => a) : a;
+	}, `stream.${t.descriptor.name}`);
+	for (let t of e.discovered.workflows ?? []) E[t.definition.name] = (e) => F(async (e, n) => {
+		let r = n;
+		return Qe(h, {
+			subject: r.subject,
+			traceId: r.traceId,
+			source: "workflow-rpc"
+		}).start(t.definition.name, e);
+	}, e, `workflow.${t.definition.name}`);
+	g && (E[Y.name] = (e) => I(T({
+		descriptor: Y,
+		executor: (e) => {
+			let t = e.id;
+			return {
+				table: "_voltro_workflow_runs",
+				order: [{
+					column: "startedAt",
+					direction: "desc"
+				}],
+				predicate: ht(U("id", t), U("executionId", t)),
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Y.name}`), E[X.name] = (e) => I(T({
+		descriptor: X,
+		executor: (e) => {
+			let t = e, n = [...t.tag === void 0 ? [] : [U("tag", t.tag)], ...t.status === void 0 ? [] : [U("status", t.status)]], r = Number.isFinite(t.limit) && t.limit !== void 0 ? Math.min(Math.max(Math.floor(t.limit), 1), 500) : 100;
+			return {
+				table: "_voltro_workflow_runs",
+				order: [{
+					column: "startedAt",
+					direction: "desc"
+				}],
+				predicate: n.length === 0 ? void 0 : n.length === 1 ? n[0] : pt(...n),
+				take: r,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${X.name}`), E[Ot.name] = (e) => I(T({
+		descriptor: Ot,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_steps",
+				order: [{
+					column: "startedAt",
+					direction: "asc"
+				}],
+				predicate: U("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Ot.name}`), E[J.name] = (e) => I(T({
+		descriptor: J,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: U("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${J.name}`), E[q.name] = (e) => I(T({
+		descriptor: q,
+		executor: (e) => {
+			let t = e;
+			return {
+				table: "_voltro_workflow_events",
+				order: [{
+					column: "occurredAt",
+					direction: "desc"
+				}],
+				predicate: t.name === void 0 ? void 0 : U("name", t.name),
+				take: Math.max(1, Math.min(500, t.limit ?? 100)),
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${q.name}`), E[Et.name] = (e) => I(T({
+		descriptor: Et,
+		executor: (e) => {
+			let t = e.eventId;
+			return {
+				table: "_voltro_workflow_event_deliveries",
+				order: [{
+					column: "createdAt",
+					direction: "asc"
+				}],
+				predicate: U("eventId", t),
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Et.name}`), E[Tt.name] = (t) => F(async (t, n) => {
+		let r = t;
+		return await _(e.store, n.subject, { executionId: r.executionId }), await h.cancel(r.workflowName, r.executionId), await Ie(r.workflowName, r.executionId, "workflow.cancel"), { ok: !0 };
+	}, t, `action.${Tt.name}`), E[Dt.name] = (t) => F(async (t, n) => {
+		let r = t;
+		return await _(e.store, n.subject, { executionId: r.executionId }), await h.resume(r.workflowName, r.executionId), { ok: !0 };
+	}, t, `action.${Dt.name}`), E[Z.name] = (t) => F(async (t, n) => {
+		let r = t;
+		return await _(e.store, n.subject, { id: r.id }), h.signal({ id: r.id }, r.signalName, r.payload);
+	}, t, `action.${Z.name}`), E[kt.name] = (t) => F(async (t, n) => {
+		let r = t;
+		return await _(e.store, n.subject, { id: r.id }), h.update({ id: r.id }, r.updateName, r.payload, r.timeoutMs === void 0 ? void 0 : { timeoutMs: r.timeoutMs });
+	}, t, `action.${kt.name}`));
+	let Se = [
+		...e.discovered.queries.map((e) => K(e.descriptor)),
+		...e.discovered.mutations.map((e) => Ct(e.descriptor)),
+		...e.discovered.actions.map((e) => G(e.descriptor)),
+		...de.queries.map((e) => K(e.descriptor)),
+		...de.mutations.map((e) => Ct(e.descriptor)),
+		...b.queries.map((e) => K(e.descriptor)),
+		...b.mutations.map((e) => Ct(e.descriptor)),
+		...b.actions.map((e) => G(e.descriptor)),
+		...(e.discovered.streams ?? []).map((e) => wt(e.descriptor)),
+		...(e.discovered.workflows ?? []).map((e) => ct(e.definition)),
+		...g ? [
+			K(Y),
+			K(X),
+			K(Ot),
+			K(J),
+			K(q),
+			K(Et),
+			G(Tt),
+			G(Dt),
+			G(Z),
+			G(kt)
+		] : []
+	], O = dt.make(...Se).middleware(bt).middleware(xt), Ce = A.succeed(bt, bt.of(({ headers: t, clientId: n }) => k.promise(() => e.resolveSubject(t, n)))), we = A.succeed(xt, xt.of(({ clientId: e }) => k.succeed({ clientId: e }))), Te = e.dormancyTenantId ?? "default", Ee = e.dormancy === "sleep" ? {
+		register: (t, n, r) => nt(e.store, {
+			tenantId: r ?? Te,
+			kind: "workflow",
+			refId: t,
+			wakeAt: n
+		}),
+		cancel: (t, n) => Fe(e.store, {
+			tenantId: n ?? Te,
+			kind: "workflow",
+			refId: t
+		}).then(() => {})
+	} : void 0, M = ne ? await import("@voltro/workflow") : void 0, N = M?.makeWorkflowRunRecorder({
+		store: e.store,
+		...Ee === void 0 ? {} : { wakeups: Ee }
+	}), je = async (t, n) => {
+		await M.closeWorkflowChildrenForParent({
+			store: e.store,
+			parentExecutionId: t,
+			parentStatus: n,
+			recorder: N,
+			log: { warn: (e, t) => {
+				process.stderr.write(`[workflow] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+			} },
+			interruptChild: async (t, n) => {
+				let r = (e.discovered.workflows ?? []).find((e) => e.definition.name === t);
+				if (!r) throw Error(`Unknown child workflow: ${t}`);
+				if (!s) throw Error("Workflow runtime is not ready");
+				await s.runPromise(r.definition.interrupt(n));
+			}
+		});
+	}, Ie = async (t, n, r) => {
+		let i = (await e.store.query({
+			table: "_voltro_workflow_runs",
+			order: [],
+			predicate: U("executionId", n),
+			projection: void 0,
+			skip: void 0,
+			take: 1
+		}))[0];
+		if (i === void 0) return;
+		let a = await e.store.update("_voltro_workflow_runs", i.id, {
+			status: "cancelled",
+			cancelled: !0,
+			completedAt: /* @__PURE__ */ new Date()
+		}), o = i.subject?.tenantId ?? void 0;
+		a && await N.recordEvent({
+			runId: i.id,
+			eventType: "run-cancelled",
+			payload: {
+				reason: r,
+				workflowName: t,
+				executionId: n,
+				...o == null ? {} : { tenantId: o }
+			}
+		}), a && await je(n, "cancelled");
+	}, Le = [...$e(e.discovered.workflows ?? [], {
+		buildContext: (t, n) => {
+			let r = t?.subject ?? {
+				type: "anonymous",
+				id: null,
+				tenantId: null
+			};
+			return e.buildContextForWorkflow?.(t, n) ?? x({
+				subject: r,
+				traceId: t?.traceId ?? "workflow-bootstrap"
+			}, e.store, void 0, `workflow:${n.workflowName}`, { parentExecutionId: n.executionId });
+		},
+		resolveStartContext: te
+	}, (t, n, r) => {
+		let i = M.getWorkflowVersionMetadata(t.definition);
+		return M.wrapWorkflowExecuteWithRunRecording({
+			name: t.definition.name,
+			store: e.store,
+			subject: r?.subject ?? null,
+			source: r?.source ?? null,
+			traceId: r?.traceId ?? null,
+			workflowVersion: i.version,
+			workflowCompatibleVersions: i.compatibleWith,
+			workflowPatches: i.patches,
+			parentExecutionId: r?.parentExecutionId ?? null,
+			parentClosePolicy: r?.parentClosePolicy ?? null,
+			onParentClose: ({ executionId: e, status: t }) => je(e, t),
+			recorder: N
+		}, n);
+	}), ...e.discovered.workflowWorkers ?? []], Re = Le.length > 0 ? A.mergeAll(...Le) : A.empty;
+	((e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster") && e.workflowEngineLayer !== void 0 && (s = De.make(Re.pipe(A.provideMerge(e.workflowEngineLayer))), await s.runPromise(k.void), a = (e.discovered.workflows?.length ?? 0) > 0 ? Ze({
+		workflows: e.discovered.workflows ?? [],
+		runEffect: (e) => s.runPromise(e),
+		rememberStartContext: f,
+		signal: async (t, n, r) => {
+			let i = await M.sendWorkflowSignal({
+				store: e.store,
+				recorder: N,
+				target: t,
+				signalName: n,
+				payload: r
+			});
+			return await s.runPromise(M.completeSuspendingSignal({
+				store: e.store,
+				target: t,
+				signalName: n,
+				payload: r
+			})).catch(() => {}), i;
+		},
+		update: (t, n, r, i) => M.sendWorkflowUpdate({
+			store: e.store,
+			recorder: N,
+			target: t,
+			updateName: n,
+			payload: r,
+			...i === void 0 ? {} : { options: i }
+		}),
+		listRuns: (t) => fe(e.store, t),
+		retry: (t, n) => ue({
+			store: e.store,
+			workflows: e.discovered.workflows ?? [],
+			runPromise: (e) => s.runPromise(e)
+		}, t, n)
+	}) : void 0);
+	let ze = A.mergeAll(O.toLayer(E), Ce, we), We = d(E, e.discovered.queries.map((e) => e.descriptor.name), g), Ge = A.mergeAll(O.toLayer(We), Ce, we), L = e.observability, Xe = await Pe({
+		...L && L.spanProcessors.length > 0 ? { extraSpanProcessors: L.spanProcessors } : {},
+		...L && L.metricReaders.length > 0 ? { extraMetricReaders: L.metricReaders } : {},
+		...L && Object.keys(L.resourceAttributes).length > 0 ? { resourceAttributes: L.resourceAttributes } : {},
+		...L && L.sampler !== void 0 ? { sampler: L.sampler } : {}
+	}), rt = !1, it = e.store.ping ? () => e.store.ping().then(() => !0).catch(() => !1) : void 0, V = B({
+		group: O,
+		handlersLayer: ze,
+		httpHandlersLayer: Ge,
+		port: e.port ?? 4e3,
+		path: e.path ?? "/ws",
+		tracerLayer: Xe.layer,
+		healthCheck: {
+			isReady: () => rt,
+			...it ? { ping: it } : {}
+		},
+		...xe.length > 0 ? { httpRoutes: xe } : {},
+		...se.size > 0 ? { webhookRoutes: se } : {}
+	});
+	if (await Me(V), (e.discovered.schedules?.length ?? 0) > 0) {
+		let t = (e.scheduleCoordination ?? "single") === "advisoryLock" ? Ue(e.store, e.scheduleReplicaId ?? `pid-${process.pid}`) : ot;
+		c = await st(e.discovered.schedules ?? [], {
+			store: e.store,
+			coordinator: t,
+			defaultTrigger: e.scheduleDefaultTrigger ?? "self",
+			replicaId: e.scheduleReplicaId ?? `pid-${process.pid}`,
+			armSelf: e.scheduleArmSelf ?? !0,
+			dormancy: e.dormancy ?? "always-on",
+			dormancyTenantId: e.dormancyTenantId ?? "default",
+			buildContext: ({ traceId: t, scheduleName: n }) => x({
+				subject: {
+					type: "anonymous",
+					id: null,
+					tenantId: null
+				},
+				traceId: t
+			}, e.store, void 0, `schedule:${n}`),
+			log: {
+				info: (e, t) => {
+					process.stdout.write(`[schedule] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				warn: (e, t) => {
+					process.stderr.write(`[schedule] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				debug: () => {}
+			},
+			...e.scheduleFireInterceptor === void 0 ? {} : { interceptFire: e.scheduleFireInterceptor },
+			...e.onScheduleRunEvent === void 0 ? {} : { onRunEvent: e.onScheduleRunEvent }
+		}), e.onSchedulerReady?.(c);
+	}
+	let H = e.log ?? j({ scope: "voltro:serve" }), ut, ft;
+	if ((e.discovered.subscribers?.length ?? 0) > 0 && (ut = o(e.discovered.subscribers ?? [], e.store, H.child("subscribe"))), (e.discovered.reactions?.length ?? 0) > 0) {
+		let t = H.child("reaction");
+		ft = p(e.discovered.reactions ?? [], e.store, {
+			runAct: async (n, r) => {
+				if (n.kind === "workflow") {
+					if (h === void 0) {
+						t.warn("reaction workflow act skipped — no workflow engine in this app", { workflow: n.workflow });
+						return;
+					}
+					let e = r.new ?? r.old ?? {};
+					await Qe(h, {
+						traceId: `reaction:${n.workflow}`,
+						source: `reaction:${n.workflow}`
+					}).start(n.workflow, e);
+					return;
+				}
+				await w(n.agent, r, {
+					findAgentSend: (t) => e.discovered.actions.find((e) => e.descriptor.name === `${t}.send`),
+					runAction: (e, t, n) => Promise.resolve(pe(e, t, n)),
+					makeSubject: (e) => St(e),
+					now: () => Date.now(),
+					log: t
+				});
+			},
+			checkBudget: async (n, r) => {
+				try {
+					let { requireAiBudget: t } = await import("@voltro/ai");
+					return (await k.runPromise(k.either(t(e.store, {
+						tenantId: n,
+						limitUsd: r
+					}))))._tag === "Right";
+				} catch (e) {
+					return t.warn("reaction budget check failed — refusing the act", { tenantId: n }, e), !1;
+				}
+			}
+		}, t);
+	}
+	let mt;
+	return (e.discovered.aggregates?.length ?? 0) > 0 && (mt = await r({
+		discovered: e.discovered.aggregates ?? [],
+		store: e.store,
+		log: H.child("aggregate"),
+		...e.analytics === void 0 ? {} : { analytics: e.analytics },
+		...e.aggregateStorage === void 0 ? {} : { storage: e.aggregateStorage },
+		...e.aggregateCoordinator === void 0 ? {} : { coordinator: e.aggregateCoordinator }
+	}), ce = A.succeed(Oe, mt.registry)), rt = !0, e.bootTiming?.mark("ready"), {
+		dispatcher: t,
+		server: V,
+		scheduler: c,
+		close: async () => {
+			rt = !1, mt?.detach(), ft?.(), ut?.(), await c?.shutdown(), t.close(), await s?.dispose(), await new Promise((e) => V.close(() => e()));
+		}
+	};
+}, $ = j({ scope: "voltro:serve" }), pn = (e, t, n) => (e === "production" || e === "staging") && t !== "memory" && n !== "0", mn = (e, t) => {
+	let n = e.indexOf(t);
+	return n >= 0 ? e[n + 1] : void 0;
+}, hn = async (e) => {
+	let t = O(process.cwd());
+	if (M(t)) {
+		let n;
+		try {
+			let e = await import(Te(t).href);
+			typeof e.runServe == "function" ? n = e.runServe : $.warn("serve bundle has no runServe export — using the standard serve path");
+		} catch (e) {
+			$.warn("serve bundle failed to load — using the standard serve path", {}, e);
+		}
+		if (n) return $.info("serve: booting from the precompiled serve bundle"), n(e);
+	}
+	return gn(e);
+}, gn = async (r) => {
+	let o = Yt();
+	process.env.NODE_ENV || (process.env.NODE_ENV = "production"), ut();
+	let d = process.cwd(), ee = Number(process.env.PORT ?? mn(r, "--port") ?? 4e3), p = await E(d);
+	it(rt(p?.secrets)), await e({
+		rawEnv: p?.env,
+		appType: "api",
+		root: d,
+		log: $,
+		generateTypes: !1
+	}), o.mark("config");
+	let m = (process.env.DB_DIALECT ?? p?.store ?? "memory").toLowerCase(), ie = (m === "mariadb" || m === "postgres" || m === "mssql") && (process.env.CDC ?? "1") !== "0", _ = m === "mariadb" ? "mariadb" : m === "mssql" ? "mssql" : void 0, ue = Ce(d);
+	if (!Se() && M(ue)) try {
+		let e = await import(Te(ue).href);
+		if (e.modules) {
+			let t = {};
+			for (let [n, r] of Object.entries(e.modules)) t[we(d, n)] = r;
+			xe(t), $.info("precompiled api bundle loaded", { modules: Object.keys(t).length });
+		}
+	} catch (e) {
+		$.warn("precompiled api bundle failed to load — falling back to source", {}, e);
+	}
+	let C = await b(d), w = await ge(C, { cdc: ie && _ !== void 0 }), fe = C.filter((e) => ye.test(e)), _e = fe.length > 0 ? await h(fe, $.child("webhooks")) : void 0, ve = x({
+		mix: w.featureMix,
+		plugins: p?.plugins ?? [],
+		cdc: ie && _ !== void 0,
+		..._ ? { cdcDialect: _ } : {}
+	}), be = p?.analytics !== void 0 && p.analytics.kind !== "noop" && m !== "memory" ? (await y(m)).makeSqlLayer(S()) : void 0, O = await ne({
+		spec: p?.analytics,
+		sqlLayer: be,
+		log: $
+	}), j = (() => {
+		let e = new Set(w.tables.map((e) => e.tableName)), t = [...w.tables];
+		for (let n of [...ve, ...O.tables]) e.has(n.tableName) || (e.add(n.tableName), t.push(n));
+		return t;
+	})();
+	for (let e of j) mt(e);
+	let Oe = (process.env.NODE_ENV ?? "").toLowerCase();
+	if (pn(Oe, m, process.env.VOLTRO_AUTO_MIGRATE)) {
+		let e = (await y(m)).makeSqlLayer(S()), t = await k.runPromise(ft.SqlClient.pipe(k.flatMap((e) => Mt(e, j, {
+			appliedBy: `serve:${Oe}`,
+			environment: "prod",
+			dialectId: m
+		})), k.provide(e)));
+		t.kind === "prod-mismatch" && ($.error(jt(t, m)), $.error("serve: refusing to boot — apply the schema first (voltro db apply in a pre-deploy step), or set VOLTRO_AUTO_MIGRATE=0 to bypass this check."), process.exit(1)), $.info(jt(t, m));
+	}
+	let ke = Xe(j);
+	o.mark("discover");
+	let P = await pe(p, void 0);
+	p?.cache && !process.env.CACHE_BACKEND && (process.env.CACHE_BACKEND = p.cache), p?.cacheRedisUrl && !process.env.CACHE_REDIS_URL && (process.env.CACHE_REDIS_URL = p.cacheRedisUrl), p?.cacheRedisDriver && !process.env.CACHE_REDIS_DRIVER && (process.env.CACHE_REDIS_DRIVER = p.cacheRedisDriver), p?.cacheKeyPrefix && !process.env.CACHE_KEY_PREFIX && (process.env.CACHE_KEY_PREFIX = p.cacheKeyPrefix);
+	let { service: Ae, invalidationBus: Me, snapshotCache: F, cache: Ne, backend: I, dispose: Pe } = await te({ env: process.env });
+	$.info(`cache backend resolved: ${I}` + (I === "redis" ? ` (driver ${process.env.CACHE_REDIS_DRIVER ?? "resp"})` : " — in-process, not cross-instance")), P.onChange((e) => {
+		k.runFork(Me.publish(e.table));
+	}), p?.kv && !process.env.KV_BACKEND && (process.env.KV_BACKEND = p.kv), p?.kvRedisUrl && !process.env.KV_REDIS_URL && (process.env.KV_REDIS_URL = p.kvRedisUrl), p?.kvKeyPrefix && !process.env.KV_KEY_PREFIX && (process.env.KV_KEY_PREFIX = p.kvKeyPrefix);
+	let { kv: Fe, service: Be } = await Ge({ store: P });
+	o.mark("store");
+	let Ve = je({
+		store: P,
+		sink: O.sink,
+		log: $
+	}), He = ae({
+		store: P,
+		dialect: m
+	}), R = p?.plugins ?? [], Ke = process.env.POD_NAME ?? process.env.HOSTNAME ?? `serve-${process.pid}`, qe, Je;
+	m !== "memory" && (qe = De.make((await y(m)).makeSqlLayer(S())), Je = await qe.runPromise(ft.SqlClient));
+	let Ye = L({
+		coordinator: [
+			"postgres",
+			"mariadb",
+			"mysql",
+			"mssql"
+		].includes(m) ? Ue(P, Ke, $) : ot,
+		replicaId: Ke,
+		log: $
+	}), Ze = [], Qe = {
+		...Je ? { sql: Je } : {},
+		scheduleCoordinated: (e, t, n) => {
+			let r = Ye(e, t, n);
+			return Ze.push(r), r;
+		}
+	};
+	for (let e of R) e.bindDataStore?.(P, Qe);
+	let $e = R.filter((e) => typeof e.onChangeEvent == "function");
+	if ($e.length > 0) {
+		let e = P.changeScope ?? "local";
+		P.onChange((t) => {
+			let n = {
+				table: t.table,
+				op: t.op,
+				new: t.new ?? null,
+				old: t.old ?? null,
+				...t.origin === void 0 ? {} : { origin: t.origin },
+				changeScope: e
+			};
+			for (let e of $e) k.runFork(e.onChangeEvent(n).pipe(k.catchAllCause((t) => k.sync(() => $.warn(`plugin ${e.name} onChangeEvent failed`, { error: Ee.pretty(t) })))));
+		});
+	}
+	let et = oe({
+		plugins: R,
+		appName: p?.name ?? "voltro-api",
+		appType: "api",
+		voltroVersion: process.env.npm_package_version ?? "0.0.0",
+		log: $
+	});
+	R.length && await et.activate(), o.mark("plugins");
+	let tt = await et.gatherObservability(), nt = await ce(P, p, m, {
+		info: (e, t) => process.stdout.write(`[broadcast] ${e} ${t ? JSON.stringify(t) : ""}\n`),
+		warn: (e, t) => process.stderr.write(`[broadcast] ${e} ${t ? JSON.stringify(t) : ""}\n`),
+		debug: () => {}
+	}), z = p?.apiKeys, at = (typeof z == "object" ? z.prefix : void 0) ?? "voltro_", B = z ? We(Le(P), { prefix: at }) : void 0, st = B ? [ze(B, { prefix: at })] : [], ct = D([...p?.auth?.strategies ?? [], ...st], Nt(p?.plugins ?? []), p?.auth?.anonymousTenantRequired ?? !1), lt = [...p?.restRoutes ?? [], ...B ? N(B, (typeof z == "object" ? z.managementPath : void 0) ?? "/v1/api-keys") : []], V = p?.idempotency, H = V ? {
+		store: Re(P),
+		header: (typeof V == "object" ? V.header : void 0) ?? "Idempotency-Key",
+		ttlMs: (typeof V == "object" ? V.ttlMs : void 0) ?? 864e5
+	} : void 0, dt = lt.length > 0 ? Ft(lt, {
+		store: P,
+		resolveSubject: (e) => ct({
+			headers: e,
+			clientId: -1
+		}),
+		...H ? { idempotency: H } : {}
+	}) : [], pt = R.map((e) => e.services).filter((e) => e !== void 0), U = A.mergeAll(u({
+		analyticsLayer: O.layer,
+		cacheService: Ae,
+		kvService: Be,
+		pluginServices: pt,
+		userLayers: p?.layers ?? []
+	}), me), ht = p?.scheduling ?? {}, gt = ht.trigger ?? "self", _t = /* @__PURE__ */ new Set([
+		"postgres",
+		"mysql",
+		"mariadb",
+		"mssql"
+	]), vt = ht.coordination ?? (_t.has(m) ? "advisoryLock" : "single"), W = vt === "cluster" && _t.has(m), yt = W ? "cluster" : vt === "advisoryLock" && _t.has(m) ? "advisoryLock" : "single";
+	vt === "cluster" && !W && $.warn("scheduling.coordination=cluster needs a sql-backed store except sqlite — falling back to single"), vt === "advisoryLock" && !_t.has(m) && $.warn("scheduling.coordination=advisoryLock needs a SQL store (the claim-row gate) — falling back to single");
+	let bt, xt = w.workflows.length > 0 || w.workflowWorkers.length > 0 || w.eventTriggers.length > 0 || (_e?.outgoing.length ?? 0) > 0 || W, G;
+	if (xt) {
+		if (m === "mssql") {
+			let e = await c(process.cwd());
+			e && $.warn(e);
+		}
+		let [{ WorkflowEngine: e }, { makeClusterCronLayer: t, workflowEngineLayer: n, resolveRunnerStorage: r }] = await Promise.all([import("@effect/workflow"), import("@voltro/workflow/cluster")]), i = W ? w.schedules.filter((e) => (e.trigger ?? gt) === "self").map((e) => t({
+			name: e.name,
+			cron: Ie(e),
+			execute: async () => {
+				await bt?.fireFromCluster(e.name);
+			}
+		})) : [];
+		G = m === "memory" ? e.layerMemory : await (async () => {
+			let e = await y(m), t = r({ sqliteFamily: e.id === "sqlite" || e.id === "turso" });
+			return $.info(`workflow engine: cluster-${t}, dialect=${e.id}` + (t === "memory" ? " — single-process durable replay, no cross-pod shard handoff" + (e.id !== "sqlite" && e.id !== "turso" ? " (VOLTRO_WORKFLOW_RUNNER_STORAGE=memory: SqlRunnerStorage/cluster_runners + GET_LOCK skipped)" : "") : "")), n({
+				sqlClientLayer: e.makeSqlLayer(S()),
+				runnerStorage: t,
+				dialectId: e.id,
+				...process.env.VOLTRO_WORKFLOW_RUNNER_PORT ? { runnerListenPort: Number(process.env.VOLTRO_WORKFLOW_RUNNER_PORT) } : {},
+				...i.length > 0 ? { extraShardingLayers: i } : {}
+			});
+		})();
+	}
+	let St = le(R, t()), Ct = C.filter((e) => /\.subscribe\.tsx?$/.test(e)), K = Ct.length > 0 ? await l(Ct, $) : [], wt = C.filter((e) => /\.reaction\.tsx?$/.test(e)), Tt = wt.length > 0 ? await n(wt, $) : [], q = C.filter((e) => /\.outbox\.tsx?$/.test(e)), Et = q.length > 0 ? await f(q, $) : [], Dt = C.filter((e) => /\.aggregate\.tsx?$/.test(e)), J = Dt.length > 0 ? await g(Dt, $) : [], Y = a();
+	if (J.length > 0 && m !== "memory") try {
+		Y = i((await y(m)).makeSqlLayer(S()));
+	} catch (e) {
+		$.warn("aggregate: SQL storage init failed — falling back to in-process", { err: String(e) });
+	}
+	let Ot = m === "memory" ? ot : Ue(P, `aggregate@${process.pid}`, $), X = [], Z = [], kt = C.filter((e) => T.test(e));
+	if (kt.length > 0) {
+		let e = $.child("agent"), t = C.filter((e) => he.test(e));
+		t.length > 0 && await v(t, e);
+		let n = await de(kt, e);
+		for (let e of n.agents) for (let t of se(e)) (t.kind === "action" ? X : Z).push({
+			file: t.file,
+			descriptor: t.descriptor,
+			executor: t.executor
+		});
+		n.agents.length > 0 && e.info("synthesized agent routes", { agents: n.agents.map((e) => e.descriptor.name) });
+	}
+	o.mark("workflow");
+	let Pt = await fn({
+		bootTiming: o,
+		discovered: {
+			queries: [...w.queries, ...Z],
+			mutations: w.mutations,
+			actions: [...w.actions, ...X],
+			streams: w.streams,
+			workflows: w.workflows,
+			workflowWorkers: w.workflowWorkers,
+			eventTriggers: w.eventTriggers,
+			schedules: w.schedules,
+			subscribers: K,
+			outboxHandlers: Et,
+			connections: w.connections,
+			reactions: Tt,
+			aggregates: J,
+			..._e === void 0 ? {} : { webhooks: _e }
+		},
+		log: $,
+		analytics: O.sink,
+		aggregateStorage: Y,
+		aggregateCoordinator: Ot,
+		store: P,
+		kv: Fe,
+		cache: Ne,
+		snapshotCache: F,
+		schemaRegistry: ke,
+		tenantScopedTables: w.tenantScopedTables,
+		softDeleteScopedTables: w.softDeleteScopedTables,
+		dataTransferSnapshot: At(j),
+		dataTransferDialect: m,
+		tenantIsolation: (process.env.VOLTRO_TENANT_ISOLATION ?? p?.tenancy?.isolation) === "namespace" ? "namespace" : "shared-schema",
+		resolveSubject: (e, t) => ct({
+			headers: e,
+			clientId: t
+		}),
+		httpRoutes: [...R.flatMap((e) => e.httpRoutes ?? []), ...dt],
+		...U ? { baseLayer: U } : {},
+		...G === void 0 ? {} : { workflowEngineLayer: G },
+		scheduleDefaultTrigger: gt,
+		scheduleCoordination: yt,
+		scheduleArmSelf: !W,
+		dormancy: process.env.VOLTRO_DORMANCY === "sleep" || process.env.VOLTRO_DORMANCY === "always-on" ? process.env.VOLTRO_DORMANCY : p?.dormancy ?? "always-on",
+		scheduleReplicaId: process.env.HOSTNAME ?? `pid-${process.pid}`,
+		...St === void 0 ? {} : { scheduleFireInterceptor: St },
+		onSchedulerReady: (e) => {
+			bt = e;
+		},
+		observability: tt,
+		port: ee,
+		...p?.transport?.wsPath ? { path: p.transport.wsPath } : {}
+	});
+	s(re([
+		w.queries,
+		w.mutations,
+		w.actions,
+		w.streams
+	]), (e) => {
+		$.warn(e);
+	}), $.info(`API listening on :${ee}`, {
+		dialect: m,
+		queries: w.queries.length,
+		mutations: w.mutations.length,
+		actions: w.actions.length,
+		streams: w.streams.length,
+		workflows: w.workflows.length,
+		workflowWorkers: w.workflowWorkers.length,
+		schedules: w.schedules.length,
+		scheduleCoordination: yt
+	}), o.finish($);
+	let It = () => {
+		for (let e of Ze) e.stop();
+		Ve.detach(), He.stop(), Pe(), qe?.dispose(), Promise.resolve(et.deactivate()).then(() => nt?.close()).then(() => O.dispose()).then(() => Pt.close()).then(() => P.close?.()).then(() => process.exit(0));
+	};
+	return process.on("SIGINT", It), process.on("SIGTERM", It), await new Promise(() => {}), 0;
+};
+//#endregion
+export { hn as n, un as r, gn as t };