@voltro/cli 0.12.0 → 0.14.0

package/dist/serveCommand-CU3Sw4ZM.js

@@ -0,0 +1,1127 @@
+import { ct as e, t } from "./inspectMetrics-CyVMeofr.js";
+import { s as n } from "./seedRunner-D6eu-u5U.js";
+import { r, t as i } from "./appModuleLoader-C9r9mxZt.js";
+import { f as a, m as o, n as s, p as c, u as l } from "./frameworkTableAssembly-DCLhpHsF.js";
+import { l as u } from "./fileConventions-COg0ZytD.js";
+import { $ as d, A as ee, B as f, C as te, D as ne, E as re, F as p, H as ie, I as m, J as h, K as ae, L as oe, M as g, N as _, O as se, P as v, Q as y, S as ce, T as le, V as ue, X as de, Y as b, Z as x, _ as fe, a as S, b as C, c as pe, et as me, f as w, g as he, h as ge, j as _e, k as ve, n as ye, p as T, q as be, r as xe, s as Se, v as Ce, w as we, x as Te, y as E, z as Ee } from "./dev-CKyW_LAv.js";
+import { c as D, r as De } from "./apiBuild-370ITNRk.js";
+import { t as Oe } from "./bootTiming-BdyP9nYw.js";
+import { n as ke } from "./cliArgs-qdZSElM3.js";
+import { join as Ae } from "node:path";
+import { pathToFileURL as je } from "node:url";
+import { Cause as O, Effect as k, Layer as A, ManagedRuntime as Me } from "effect";
+import { createLogger as j } from "@voltro/logger";
+import { existsSync as M } from "node:fs";
+import { AggregateRegistry as N, Dispatcher as Ne, apiKeyManagementRoutes as Pe, applySoftDeleteScope as Fe, applyTenantScope as Ie, attachAnalyticsMirror as Le, awaitServerListening as Re, bindMutation as P, bindStream as ze, bindSubscription as F, buildTracingLayer as Be, cancelWakeup as Ve, compileCron as He, dataStoreApiKeyStore as Ue, dataStoreIdempotencyStore as We, frameworkApiKeyStrategy as Ge, installPolicyGuardResolver as Ke, loadResourceTuples as I, makeActionRunner as qe, makeAdvisoryLockCoordinator as Je, makeApiKeyService as Ye, makeApiKeyUsageBuffer as L, makeApiKeyUsageFlusher as Xe, makeAsyncKv as Ze, makeCoordinatedScheduler as Qe, makeEffectStoreLayer as R, makeLazyWorkflowFacade as $e, makeMutationRunner as et, makeOneShotQueryRunner as tt, makeQueryDescriptorProducer as nt, makeQueryReauthorizer as rt, makeQuerySubscriber as it, makeSchemaRegistry as at, makeWorkflowFacade as ot, makeWorkflowFacadeWithCallerContext as st, makeWorkflowLayers as z, noopKv as ct, recordSubscriptionDelivery as lt, registerWakeup as ut, resolveSecretsBackend as dt, runProvidedEffect as ft, setSecretsBackend as pt, setSystemStoreHandle as mt, setTupleSource as ht, singleCoordinator as gt, startRpcServer as _t, startScheduler as B, workflowToRpc as vt } from "@voltro/runtime";
+import { RpcGroup as yt } from "@effect/rpc";
+import { SqlClient as bt } from "@effect/sql";
+import { and as xt, ensureTableRegistered as St, eq as V, or as Ct } from "@voltro/database";
+import { appStorageProvider as H, fromNodeReadable as wt, getObjectStream as U, putObjectStream as W, toNodeReadable as Tt } from "@voltro/plugin-storage";
+import { AuthMiddleware as Et, ConnectionInfoMiddleware as Dt, actionToRpc as G, anonymousSubject as Ot, mutationToRpc as kt, queryToRpc as K, streamToRpc as At, workflowCancelDescriptor as jt, workflowDomainEventsQueryDescriptor as q, workflowEventDeliveriesQueryDescriptor as Mt, workflowResumeDescriptor as Nt, workflowRunEventsQueryDescriptor as J, workflowRunQueryDescriptor as Y, workflowRunStepsQueryDescriptor as X, workflowRunsQueryDescriptor as Z, workflowSignalDescriptor as Pt, workflowUpdateDescriptor as Ft } from "@voltro/protocol";
+import { assertProductionSessionSecret as It } from "@voltro/protocol/session";
+import { createHash as Lt, timingSafeEqual as Rt } from "node:crypto";
+import { declaredSnapshot as zt, describeOutcome as Bt, runPlannedMigrations as Vt } from "@voltro/database/sql";
+import { getAuthSessionStrategy as Ht } from "@voltro/plugin-auth";
+import { collectPublicApiRoutes as Ut, restRoutesToHttpRoutes as Wt } from "@voltro/protocol/rest";
+import { buildDeliverWebhookExecute as Gt, buildWebhooksService as Kt, defaultIncomingPath as qt, deliverWebhookWorkflow as Jt, mountIncomingWebhook as Yt } from "@voltro/plugin-webhooks";
+import { packBundle as Xt, runExport as Zt, runImport as Qt, storageBlobSink as $t, storageRefsBlobSource as en, unpackBundle as tn, unpackBundleToDir as nn } from "@voltro/data-transfer";
+//#region src/adminAuth.ts
+var rn = "/_voltro/admin/import", an = "/_voltro/admin/export", Q = (e, t) => ({
+	status: e,
+	contentType: "application/json; charset=utf-8",
+	body: JSON.stringify(t)
+}), on = (e) => {
+	let t = e.authorization ?? e.Authorization, n = t ? /^Bearer\s+(.+)$/i.exec(t) : null;
+	return n ? n[1] : null;
+}, sn = (e, t) => Rt(Lt("sha256").update(e).digest(), Lt("sha256").update(t).digest()), cn = (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 = on(e.headers);
+	return !n || !sn(n, t) ? Q(401, { error: "unauthorized" }) : null;
+}, ln = j({ scope: "voltro:admin-import" }), un = "VBUNDLE2", dn = async function* (e) {
+	yield e;
+}, fn = (e) => async (t) => {
+	let n = cn(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") === un, c, l;
+	if (s) c = dn(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 tn(c, {
+			dir: f,
+			blobs: e.assetSink
+		}) : await nn(c, f);
+		let t = await k.runPromiseExit(Qt({
+			store: e.store,
+			bundleDir: f,
+			...r ? { mode: r } : {},
+			...i ? { onConflict: i } : {},
+			...a ? { atomic: a } : {},
+			...e.snapshot ? { targetSnapshot: e.snapshot } : {},
+			force: o,
+			onWarn: (e) => ln.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 ln.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 ln.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 ln.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
+		});
+	}
+}, pn = j({ scope: "voltro:admin-export" }), mn = async (e) => {
+	let t = [];
+	for await (let n of e) t.push(Buffer.from(n));
+	return new Uint8Array(Buffer.concat(t));
+}, hn = (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" }, gn = (e) => async (t) => {
+	let n = cn(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 ?? hn(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(Zt({
+			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, () => Xt({
+				dir: f,
+				...l
+			})), pn.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 mn(Xt({
+			dir: f,
+			...l
+		}));
+		return pn.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 pn.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
+		});
+	}
+}, _n = 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;
+}, vn = (e, t, n = {}) => (async function* () {
+	let r = await Tt((await k.runPromise(U(e, t).pipe(k.timeout(n.openTimeout ?? "30 seconds")))).stream), i = n.stallMs ?? 12e4, a, o = () => {
+		a && clearTimeout(a), a = setTimeout(() => r.destroy(/* @__PURE__ */ Error(`storage read stalled for ${i}ms reading '${t}'`)), i);
+	};
+	try {
+		o();
+		for await (let e of r) o(), yield e instanceof Uint8Array ? e : new Uint8Array(e);
+	} finally {
+		a && clearTimeout(a), r.destroy();
+	}
+})(), yn = {
+	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()
+}, bn = async (e) => {
+	mt({
+		dataStore: e.store,
+		schemaRegistry: e.schemaRegistry
+	});
+	let t = new Ne({
+		store: e.store,
+		...e.snapshotCache ? { cache: e.snapshotCache } : {},
+		recordDelivery: (e) => lt({
+			label: e.label,
+			kind: e.kind,
+			durationMs: e.durationMs,
+			rowCount: e.rowCount
+		})
+	}), n = e.cache ?? yn, r = e.kv ?? ct, i, a, o, s = /* @__PURE__ */ new Map(), c = () => `wfctx_${globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`}`, l = async (t, n, r) => {
+		let i = {
+			...r,
+			source: r.source ?? `workflow:${t}`
+		};
+		s.set(n, i);
+		try {
+			let r = await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: V("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: c(),
+				...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`);
+		}
+	}, u = async (t, n) => {
+		let r = s.get(n);
+		if (r !== void 0) return r;
+		try {
+			let t = (await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: V("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 s.set(n, r), r;
+		} catch (e) {
+			process.stderr.write(`[workflow] failed to load start context for ${n}: ${e?.message ?? String(e)}\n`);
+			return;
+		}
+	}, d = (e.discovered.workflows?.length ?? 0) > 0 ? $e(() => i) : void 0, f = (e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.eventTriggers?.length ?? 0) > 0, te = f || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster", ne = e.tenantIsolation === "namespace", re = (e.log ?? j({ scope: "voltro:serve" })).child("webhooks"), ie, h = e.discovered.webhooks;
+	if (h && h.outgoing.length > 0 && e.workflowEngineLayer !== void 0) {
+		let t = e.workflowEngineLayer, i = x({
+			store: e.store,
+			schemaRegistry: e.schemaRegistry,
+			cache: n,
+			kv: r
+		}), a = h.outgoing.map((e) => e.descriptor);
+		ie = Kt(i, async (e) => {
+			let n = Jt.execute(e).pipe(k.provide(Jt.toLayer(Gt(i, { events: a })).pipe(A.provideMerge(t))));
+			k.runPromise(n).catch((t) => {
+				re.error("deliverWebhook workflow crashed", {
+					deliveryId: e.deliveryId,
+					targetId: e.targetId
+				}, t);
+			});
+		}, { events: a });
+	}
+	let oe = /* @__PURE__ */ new Map();
+	if (h) for (let e of h.incoming) {
+		let t = e.descriptor.path ?? qt(e.descriptor.id), n = `VOLTRO_WEBHOOK_SECRET_${e.descriptor.id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`, r = Yt(e.descriptor, {
+			resolveSecret: async () => process.env[n] ?? null,
+			resolveWorkflows: () => d === void 0 ? void 0 : st(d, {
+				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 ? re.error("incoming delivery failed", t) : e.status >= 400 ? re.warn("incoming delivery rejected", t) : re.info("incoming delivery handled", t);
+			}
+		});
+		oe.set(t, { handle: r });
+	}
+	Ke(), ht((t) => I(e.store, t.subjectId, t.resourceType, t.resourceId));
+	let se = (e.discovered.outboxHandlers?.length ?? 0) > 0 ? p({
+		handlers: e.discovered.outboxHandlers ?? [],
+		store: e.store,
+		log: (e.log ?? j({ scope: "voltro:serve" })).child("outbox")
+	}) : void 0, v = _({
+		definitions: (e.discovered.connections ?? []).map((e) => e.definition),
+		store: e.store,
+		publicUrl: g(e.port ?? 4e3),
+		log: (e.log ?? j({ scope: "voltro:serve" })).child("connections")
+	}), y = de({
+		store: e.store,
+		schemaRegistry: e.schemaRegistry,
+		cache: n,
+		kv: r,
+		...ie === void 0 ? {} : { webhooksService: ie },
+		...d === void 0 ? {} : { workflowsProxy: d },
+		eventTriggers: e.discovered.eventTriggers ?? [],
+		namespaceIsolationOn: ne,
+		...se === void 0 ? {} : { outbox: { nudge: se.nudge } },
+		...v.active ? { connections: { registry: v.registry } } : {}
+	}), ce = A.succeed(N, le), ue = (t, n) => {
+		let r = t.pipe(k.provide(R(n)));
+		return ft((e.baseLayer ? r.pipe(k.provide(e.baseLayer)) : r).pipe(k.provide(ce)));
+	}, fe = et({
+		store: e.store,
+		buildContext: (e, t, n) => y(e, t, n),
+		runEffect: ue,
+		undoCapture: C()
+	}), S = E(), pe = qe({
+		buildContext: (e) => y(e),
+		runEffect: ue
+	}), me = {
+		buildContext: (e) => y(e),
+		finalize: (t, n) => Fe(Ie(t, e.tenantScopedTables, n.subject.tenantId), e.softDeleteScopedTables),
+		provideEffect: (e, t) => e.pipe(k.provide(R(t)))
+	}, w = nt(me), _e = tt({
+		...me,
+		queryRows: (t) => e.store.query(t)
+	}), ye = it({
+		...me,
+		subscribeDescriptor: (e, n, r) => t.subscribe(e, n, r),
+		subscribeComputed: (e, n, r) => t.subscribeComputed(e, n, r)
+	}), T = {};
+	for (let n of [
+		...e.discovered.queries,
+		...S.queries,
+		...v.queries
+	]) T[n.descriptor.name] = (e) => F(w(n, e), t, `subscription.${n.descriptor.name}`, void 0, void 0, rt(n, e));
+	for (let t of [
+		...e.discovered.mutations,
+		...S.mutations,
+		...v.mutations
+	]) T[t.descriptor.name] = (e) => P(async (e, n) => fe(t, e, n), e, `mutation.${t.descriptor.name}`);
+	for (let t of [...e.discovered.actions, ...v.actions]) T[t.descriptor.name] = (e) => P(async (e, n) => pe(t, e, n), e, `action.${t.descriptor.name}`);
+	let be = () => `public-${Math.random().toString(36).slice(2, 10)}`, xe = [
+		...e.discovered.queries.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+			descriptor: e.descriptor,
+			invoke: (t, n) => _e(e, t, {
+				subject: n.subject,
+				traceId: be()
+			}),
+			subscribe: (t, n, r) => ye(e, t, {
+				subject: n.subject,
+				traceId: be()
+			}, r)
+		})),
+		...e.discovered.mutations.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+			descriptor: e.descriptor,
+			invoke: (t, n) => fe(e, t, {
+				subject: n.subject,
+				traceId: be()
+			})
+		})),
+		...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: be()
+			})
+		}))
+	], Se = xe.length > 0 ? Wt(Ut(xe), {
+		store: e.store,
+		resolveSubject: (t) => e.resolveSubject(t, -1)
+	}) : [], Ce = e.dataTransferSecret ?? process.env.VOLTRO_DATA_TRANSFER_SECRET, Te = Ce && Ce.length >= 16 ? [{
+		method: "POST",
+		path: rn,
+		handle: fn({
+			secret: Ce,
+			store: e.store,
+			...e.dataTransferSnapshot ? { snapshot: e.dataTransferSnapshot } : {},
+			assetSink: $t(H()),
+			openArchive: (e) => vn(H(), e)
+		})
+	}, {
+		method: "POST",
+		path: an,
+		handle: gn({
+			secret: Ce,
+			store: e.store,
+			snapshot: e.dataTransferSnapshot ?? { tables: [] },
+			dialect: e.dataTransferDialect ?? "memory",
+			tenantTables: [...e.tenantScopedTables],
+			loadProfile: _n,
+			assetSource: en(H(), e.store),
+			putArchive: async (e, t) => {
+				let { Readable: n } = await import("node:stream"), r = H(), i = wt("storage", () => n.from(t()));
+				await k.runPromise(W(r, e, i, { contentType: "application/octet-stream" }));
+			}
+		})
+	}] : [], Ee = [
+		...e.httpRoutes ?? [],
+		...Se,
+		...Te,
+		...v.httpRoutes
+	];
+	for (let t of e.discovered.streams ?? []) T[t.descriptor.name] = (n) => ze((r) => {
+		let i = y(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 ?? []) T[t.definition.name] = (e) => P(async (e, n) => {
+		let r = n;
+		return st(d, {
+			subject: r.subject,
+			traceId: r.traceId,
+			source: "workflow-rpc"
+		}).start(t.definition.name, e);
+	}, e, `workflow.${t.definition.name}`);
+	f && (T[Y.name] = (e) => F(w({
+		descriptor: Y,
+		executor: (e) => {
+			let t = e.id;
+			return {
+				table: "_voltro_workflow_runs",
+				order: [{
+					column: "startedAt",
+					direction: "desc"
+				}],
+				predicate: Ct(V("id", t), V("executionId", t)),
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Y.name}`), T[Z.name] = (e) => F(w({
+		descriptor: Z,
+		executor: (e) => {
+			let t = e, n = [...t.tag === void 0 ? [] : [V("tag", t.tag)], ...t.status === void 0 ? [] : [V("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] : xt(...n),
+				take: r,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Z.name}`), T[X.name] = (e) => F(w({
+		descriptor: X,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_steps",
+				order: [{
+					column: "startedAt",
+					direction: "asc"
+				}],
+				predicate: V("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${X.name}`), T[J.name] = (e) => F(w({
+		descriptor: J,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: V("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${J.name}`), T[q.name] = (e) => F(w({
+		descriptor: q,
+		executor: (e) => {
+			let t = e;
+			return {
+				table: "_voltro_workflow_events",
+				order: [{
+					column: "occurredAt",
+					direction: "desc"
+				}],
+				predicate: t.name === void 0 ? void 0 : V("name", t.name),
+				take: Math.max(1, Math.min(500, t.limit ?? 100)),
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${q.name}`), T[Mt.name] = (e) => F(w({
+		descriptor: Mt,
+		executor: (e) => {
+			let t = e.eventId;
+			return {
+				table: "_voltro_workflow_event_deliveries",
+				order: [{
+					column: "createdAt",
+					direction: "asc"
+				}],
+				predicate: V("eventId", t),
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), t, `subscription.${Mt.name}`), T[jt.name] = (t) => P(async (t, n) => {
+		let r = t;
+		return await b(e.store, n.subject, { executionId: r.executionId }), await d.cancel(r.workflowName, r.executionId), await Le(r.workflowName, r.executionId, "workflow.cancel"), { ok: !0 };
+	}, t, `action.${jt.name}`), T[Nt.name] = (t) => P(async (t, n) => {
+		let r = t;
+		return await b(e.store, n.subject, { executionId: r.executionId }), await d.resume(r.workflowName, r.executionId), { ok: !0 };
+	}, t, `action.${Nt.name}`), T[Pt.name] = (t) => P(async (t, n) => {
+		let r = t;
+		return await b(e.store, n.subject, { id: r.id }), d.signal({ id: r.id }, r.signalName, r.payload);
+	}, t, `action.${Pt.name}`), T[Ft.name] = (t) => P(async (t, n) => {
+		let r = t;
+		return await b(e.store, n.subject, { id: r.id }), d.update({ id: r.id }, r.updateName, r.payload, r.timeoutMs === void 0 ? void 0 : { timeoutMs: r.timeoutMs });
+	}, t, `action.${Ft.name}`));
+	let D = [
+		...e.discovered.queries.map((e) => K(e.descriptor)),
+		...e.discovered.mutations.map((e) => kt(e.descriptor)),
+		...e.discovered.actions.map((e) => G(e.descriptor)),
+		...S.queries.map((e) => K(e.descriptor)),
+		...S.mutations.map((e) => kt(e.descriptor)),
+		...v.queries.map((e) => K(e.descriptor)),
+		...v.mutations.map((e) => kt(e.descriptor)),
+		...v.actions.map((e) => G(e.descriptor)),
+		...(e.discovered.streams ?? []).map((e) => At(e.descriptor)),
+		...(e.discovered.workflows ?? []).map((e) => vt(e.definition)),
+		...f ? [
+			K(Y),
+			K(Z),
+			K(X),
+			K(J),
+			K(q),
+			K(Mt),
+			G(jt),
+			G(Nt),
+			G(Pt),
+			G(Ft)
+		] : []
+	], De = yt.make(...D).middleware(Et).middleware(Dt), Oe = A.succeed(Et, Et.of(({ headers: t, clientId: n }) => k.promise(() => e.resolveSubject(t, n)))), ke = A.succeed(Dt, Dt.of(({ clientId: e }) => k.succeed({ clientId: e }))), Ae = e.dormancyTenantId ?? "default", je = e.dormancy === "sleep" ? {
+		register: (t, n, r) => ut(e.store, {
+			tenantId: r ?? Ae,
+			kind: "workflow",
+			refId: t,
+			wakeAt: n
+		}),
+		cancel: (t, n) => Ve(e.store, {
+			tenantId: n ?? Ae,
+			kind: "workflow",
+			refId: t
+		}).then(() => {})
+	} : void 0, O = te ? await import("@voltro/workflow") : void 0, M = O?.makeWorkflowRunRecorder({
+		store: e.store,
+		...je === void 0 ? {} : { wakeups: je }
+	}), Pe = async (t, n) => {
+		await O.closeWorkflowChildrenForParent({
+			store: e.store,
+			parentExecutionId: t,
+			parentStatus: n,
+			recorder: M,
+			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 (!a) throw Error("Workflow runtime is not ready");
+				await a.runPromise(r.definition.interrupt(n));
+			}
+		});
+	}, Le = async (t, n, r) => {
+		let i = (await e.store.query({
+			table: "_voltro_workflow_runs",
+			order: [],
+			predicate: V("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 M.recordEvent({
+			runId: i.id,
+			eventType: "run-cancelled",
+			payload: {
+				reason: r,
+				workflowName: t,
+				executionId: n,
+				...o == null ? {} : { tenantId: o }
+			}
+		}), a && await Pe(n, "cancelled");
+	}, He = [...z(e.discovered.workflows ?? [], {
+		buildContext: (t, n) => e.buildContextForWorkflow?.(t, n) ?? y({
+			subject: t.subject,
+			traceId: t.traceId
+		}, e.store, void 0, `workflow:${n.workflowName}`, { parentExecutionId: n.executionId }),
+		resolveStartContext: u
+	}, (t, n, r) => {
+		let i = O.getWorkflowVersionMetadata(t.definition);
+		return O.wrapWorkflowExecuteWithRunRecording({
+			name: t.definition.name,
+			store: e.store,
+			subject: r.subject,
+			source: r.source ?? null,
+			traceId: r.traceId,
+			workflowVersion: i.version,
+			workflowCompatibleVersions: i.compatibleWith,
+			workflowPatches: i.patches,
+			parentExecutionId: r?.parentExecutionId ?? null,
+			parentClosePolicy: r?.parentClosePolicy ?? null,
+			onParentClose: ({ executionId: e, status: t }) => Pe(e, t),
+			recorder: M
+		}, n);
+	}), ...e.discovered.workflowWorkers ?? []], Ue = He.length > 0 ? A.mergeAll(...He) : A.empty;
+	if (((e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster") && e.workflowEngineLayer !== void 0) {
+		let t = Ue.pipe(A.provideMerge(e.workflowEngineLayer));
+		a = Me.make(e.baseLayer === void 0 ? t : t.pipe(A.provideMerge(e.baseLayer))), await a.runPromise(k.void), i = (e.discovered.workflows?.length ?? 0) > 0 ? ot({
+			workflows: e.discovered.workflows ?? [],
+			runEffect: (e) => a.runPromise(e),
+			rememberStartContext: l,
+			signal: async (t, n, r) => {
+				let i = await O.sendWorkflowSignal({
+					store: e.store,
+					recorder: M,
+					target: t,
+					signalName: n,
+					payload: r
+				});
+				return await a.runPromise(O.completeSuspendingSignal({
+					store: e.store,
+					target: t,
+					signalName: n,
+					payload: r
+				})).catch(() => {}), i;
+			},
+			update: (t, n, r, i) => O.sendWorkflowUpdate({
+				store: e.store,
+				recorder: M,
+				target: t,
+				updateName: n,
+				payload: r,
+				...i === void 0 ? {} : { options: i }
+			}),
+			listRuns: (t) => ge(e.store, t),
+			retry: (t, n) => he({
+				store: e.store,
+				workflows: e.discovered.workflows ?? [],
+				runPromise: (e) => a.runPromise(e)
+			}, t, n)
+		}) : void 0;
+	}
+	let We = A.mergeAll(De.toLayer(T), Oe, ke), Ge = ae(T, e.discovered.queries.map((e) => e.descriptor.name), f), Ye = A.mergeAll(De.toLayer(Ge), Oe, ke), L = e.observability, Xe = await Be({
+		...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 } : {}
+	}), Ze = !1, Qe = e.store.ping ? () => e.store.ping().then(() => !0).catch(() => !1) : void 0, { server: at, shutdown: dt } = _t({
+		group: De,
+		handlersLayer: We,
+		httpHandlersLayer: Ye,
+		port: e.port ?? 4e3,
+		path: e.path ?? "/ws",
+		tracerLayer: Xe.layer,
+		healthCheck: {
+			isReady: () => Ze,
+			...Qe ? { ping: Qe } : {}
+		},
+		...Ee.length > 0 ? { httpRoutes: Ee } : {},
+		...oe.size > 0 ? { webhookRoutes: oe } : {}
+	});
+	if (await Re(at), (e.discovered.schedules?.length ?? 0) > 0) {
+		let t = (e.scheduleCoordination ?? "single") === "advisoryLock" ? Je(e.store, e.scheduleReplicaId ?? `pid-${process.pid}`) : gt;
+		o = await B(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",
+			...e.dormancyTenantId === void 0 ? {} : { dormancyTenantId: e.dormancyTenantId },
+			buildContext: ({ traceId: t, scheduleName: n, subject: r }) => y({
+				subject: r,
+				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`);
+				},
+				error: (e, t) => {
+					process.stderr.write(`[schedule] ERROR ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				debug: () => {}
+			},
+			...e.scheduleFireInterceptor === void 0 ? {} : { interceptFire: e.scheduleFireInterceptor },
+			...e.onScheduleRunEvent === void 0 ? {} : { onRunEvent: e.onScheduleRunEvent }
+		}), e.onSchedulerReady?.(o);
+	}
+	let pt = e.log ?? j({ scope: "voltro:serve" }), bt, St;
+	if ((e.discovered.subscribers?.length ?? 0) > 0 && (bt = m(e.discovered.subscribers ?? [], e.store, pt.child("subscribe"), e.schemaRegistry)), (e.discovered.reactions?.length ?? 0) > 0) {
+		let t = pt.child("reaction");
+		St = ve(e.discovered.reactions ?? [], e.store, {
+			runAct: async (n, r) => {
+				if (n.kind === "workflow") {
+					if (d === 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 st(d, {
+						traceId: `reaction:${n.workflow}`,
+						source: `reaction:${n.workflow}`
+					}).start(n.workflow, e);
+					return;
+				}
+				await ee(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) => Ot(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 U;
+	return (e.discovered.aggregates?.length ?? 0) > 0 && (U = await we({
+		discovered: e.discovered.aggregates ?? [],
+		store: e.store,
+		log: pt.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(N, U.registry)), Ze = !0, e.bootTiming?.mark("ready"), {
+		dispatcher: t,
+		server: at,
+		scheduler: o,
+		close: async () => {
+			Ze = !1, U?.detach(), St?.(), bt?.(), await o?.shutdown(), t.close(), await a?.dispose(), await new Promise((e) => at.close(() => e())), await dt();
+		}
+	};
+}, $ = j({ scope: "voltro:serve" }), xn = (e, t, n) => (e === "production" || e === "staging") && t !== "memory" && n !== "0", Sn = ke, Cn = async (e) => {
+	let t = D(process.cwd());
+	if (M(t)) {
+		let n;
+		try {
+			let e = await import(je(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 wn(e);
+}, wn = async (ee) => {
+	let p = Oe();
+	process.env.NODE_ENV || (process.env.NODE_ENV = "production"), It();
+	let m = process.cwd(), ae = Number(process.env.PORT ?? Sn(ee, "--port") ?? 4e3), g = await Se(m);
+	pt(dt(g?.secrets)), await e({
+		rawEnv: g?.env,
+		appType: "api",
+		root: m,
+		log: $,
+		generateTypes: !1
+	}), p.mark("config");
+	let _ = (process.env.DB_DIALECT ?? g?.store ?? "memory").toLowerCase(), le = (_ === "mariadb" || _ === "postgres" || _ === "mssql") && (process.env.CDC ?? "1") !== "0", de = _ === "mariadb" ? "mariadb" : _ === "mssql" ? "mssql" : void 0, b = De(m);
+	if (!i() && M(b)) try {
+		let e = await import(je(b).href);
+		if (e.modules) {
+			let t = {};
+			for (let [n, r] of Object.entries(e.modules)) t[Ae(m, n)] = r;
+			r(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 x = await w(m), C = await pe(x, { cdc: le && de !== void 0 }), he = x.filter((e) => ce.test(e)), ge = he.length > 0 ? await te(he, $.child("webhooks")) : void 0, ve = s({
+		mix: C.featureMix,
+		plugins: g?.plugins ?? [],
+		cdc: le && de !== void 0,
+		...de ? { cdcDialect: de } : {}
+	}), we = g?.analytics !== void 0 && g.analytics.kind !== "noop" && _ !== "memory" ? (await n(_)).makeSqlLayer(S()) : void 0, E = await f({
+		spec: g?.analytics,
+		sqlLayer: we,
+		log: $
+	}), D = (() => {
+		let e = new Set(C.tables.map((e) => e.tableName)), t = [...C.tables];
+		for (let n of [...ve, ...E.tables]) e.has(n.tableName) || (e.add(n.tableName), t.push(n));
+		return t;
+	})();
+	for (let e of D) St(e);
+	let ke = (process.env.NODE_ENV ?? "").toLowerCase();
+	if (xn(ke, _, process.env.VOLTRO_AUTO_MIGRATE)) {
+		let e = (await n(_)).makeSqlLayer(S()), t = await k.runPromise(bt.SqlClient.pipe(k.flatMap((e) => Vt(e, D, {
+			appliedBy: `serve:${ke}`,
+			environment: "prod",
+			dialectId: _
+		})), k.provide(e)));
+		t.kind === "prod-mismatch" && ($.error(Bt(t, _)), $.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(Bt(t, _));
+	}
+	let j = at(D);
+	p.mark("discover");
+	let N = await xe(g, void 0);
+	for (let e of me({
+		dialect: String(g?.store ?? process.env.DB_DIALECT ?? "postgres"),
+		changeStrategy: (process.env.CDC ?? "1") === "0" ? "inline" : "cdc",
+		dbUrl: process.env.DB_URL,
+		tables: C.tables.map((e) => ({
+			tableName: e.tableName,
+			isReactive: e.isReactive === !0
+		})),
+		querySources: C.queries.flatMap((e) => {
+			let t = e.descriptor.source;
+			return t === void 0 ? [] : typeof t == "string" ? [t] : [...t];
+		})
+	})) e.level === "warn" ? $.warn(e.message) : $.info(e.message);
+	g?.cache && !process.env.CACHE_BACKEND && (process.env.CACHE_BACKEND = g.cache), g?.cacheRedisUrl && !process.env.CACHE_REDIS_URL && (process.env.CACHE_REDIS_URL = g.cacheRedisUrl), g?.cacheRedisDriver && !process.env.CACHE_REDIS_DRIVER && (process.env.CACHE_REDIS_DRIVER = g.cacheRedisDriver), g?.cacheKeyPrefix && !process.env.CACHE_KEY_PREFIX && (process.env.CACHE_KEY_PREFIX = g.cacheKeyPrefix);
+	let { service: Ne, invalidationBus: Fe, snapshotCache: Ie, cache: Re, backend: P, dispose: ze } = await d({ env: process.env });
+	$.info(`cache backend resolved: ${P}` + (P === "redis" ? ` (driver ${process.env.CACHE_REDIS_DRIVER ?? "resp"})` : " — in-process, not cross-instance")), N.onChange((e) => {
+		k.runFork(Fe.publish(e.table));
+	}), g?.kv && !process.env.KV_BACKEND && (process.env.KV_BACKEND = g.kv), g?.kvRedisUrl && !process.env.KV_REDIS_URL && (process.env.KV_REDIS_URL = g.kvRedisUrl), g?.kvKeyPrefix && !process.env.KV_KEY_PREFIX && (process.env.KV_KEY_PREFIX = g.kvKeyPrefix);
+	let { kv: F, service: Be } = await Ze({ store: N });
+	p.mark("store");
+	let Ve = Le({
+		store: N,
+		sink: E.sink,
+		log: $
+	}), Ke = y({
+		store: N,
+		dialect: _
+	}), I = g?.plugins ?? [], qe = process.env.POD_NAME ?? process.env.HOSTNAME ?? `serve-${process.pid}`, R, $e;
+	_ !== "memory" && (R = Me.make((await n(_)).makeSqlLayer(S())), $e = await R.runPromise(bt.SqlClient));
+	let et = Qe({
+		coordinator: [
+			"postgres",
+			"mariadb",
+			"mysql",
+			"mssql"
+		].includes(_) ? Je(N, qe, $) : gt,
+		replicaId: qe,
+		log: $
+	}), tt = [], nt = {
+		...$e ? { sql: $e } : {},
+		scheduleCoordinated: (e, t, n) => {
+			let r = et(e, t, n);
+			return tt.push(r), r;
+		}
+	};
+	for (let e of I) e.bindDataStore?.(N, nt);
+	let rt = I.filter((e) => typeof e.onChangeEvent == "function");
+	if (rt.length > 0) {
+		let e = N.changeScope ?? "local";
+		N.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 rt) k.runFork(e.onChangeEvent(n).pipe(k.catchAllCause((t) => k.sync(() => $.warn(`plugin ${e.name} onChangeEvent failed`, { error: O.pretty(t) })))));
+		});
+	}
+	let it = Ce({
+		plugins: I,
+		appName: g?.name ?? "voltro-api",
+		appType: "api",
+		voltroVersion: process.env.npm_package_version ?? "0.0.0",
+		log: $
+	});
+	I.length && await it.activate(), p.mark("plugins");
+	let ot = await it.gatherObservability(), st = await T(N, g, _, {
+		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 = g?.apiKeys, ct = (typeof z == "object" ? z.prefix : void 0) ?? "voltro_", lt = z ? Ue(N) : void 0, ut = lt ? L({ flush: Xe(lt) }) : void 0;
+	ut && process.once("exit", () => {
+		ut.shutdown();
+	});
+	let ft = lt ? Ye(lt, {
+		prefix: ct,
+		...ut ? { usage: ut } : {}
+	}) : void 0, mt = ft ? [Ge(ft, { prefix: ct })] : [], ht = ye([...g?.auth?.strategies ?? [], ...mt], Ht(g?.plugins ?? []), g?.auth?.anonymousTenantRequired ?? !1, g?.auth?.resolveScopes, () => N), _t = [...g?.restRoutes ?? [], ...ft ? Pe(ft, (typeof z == "object" ? z.managementPath : void 0) ?? "/v1/api-keys") : []], B = g?.idempotency, vt = B ? {
+		store: We(N),
+		header: (typeof B == "object" ? B.header : void 0) ?? "Idempotency-Key",
+		ttlMs: (typeof B == "object" ? B.ttlMs : void 0) ?? 864e5
+	} : void 0, yt = _t.length > 0 ? Wt(_t, {
+		store: N,
+		resolveSubject: (e) => ht({
+			headers: e,
+			clientId: -1
+		}),
+		...vt ? { idempotency: vt } : {}
+	}) : [], xt = I.map((e) => e.services).filter((e) => e !== void 0), V = A.mergeAll(h({
+		analyticsLayer: E.layer,
+		cacheService: Ne,
+		kvService: Be,
+		pluginServices: xt,
+		userLayers: g?.layers ?? []
+	}), be(g?.http ?? {})), Ct = g?.scheduling ?? {}, H = Ct.trigger ?? "self", wt = /* @__PURE__ */ new Set([
+		"postgres",
+		"mysql",
+		"mariadb",
+		"mssql"
+	]), U = Ct.coordination ?? (wt.has(_) ? "advisoryLock" : "single"), W = U === "cluster" && wt.has(_), Tt = W ? "cluster" : U === "advisoryLock" && wt.has(_) ? "advisoryLock" : "single";
+	U === "cluster" && !W && $.warn("scheduling.coordination=cluster needs a sql-backed store except sqlite — falling back to single"), U === "advisoryLock" && !wt.has(_) && $.warn("scheduling.coordination=advisoryLock needs a SQL store (the claim-row gate) — falling back to single");
+	let Et, Dt = C.workflows.length > 0 || C.workflowWorkers.length > 0 || C.eventTriggers.length > 0 || (ge?.outgoing.length ?? 0) > 0 || W, G;
+	if (Dt) {
+		if (_ === "mssql") {
+			let e = await Ee(process.cwd());
+			e && $.warn(e);
+		}
+		let [{ WorkflowEngine: e }, { makeClusterCronLayer: t, workflowEngineLayer: r, resolveRunnerStorage: i }] = await Promise.all([import("@effect/workflow"), import("@voltro/workflow/cluster")]), a = W ? C.schedules.filter((e) => (e.trigger ?? H) === "self").map((e) => t({
+			name: e.name,
+			cron: He(e),
+			execute: async () => {
+				await Et?.fireFromCluster(e.name);
+			}
+		})) : [];
+		G = _ === "memory" ? e.layerMemory : await (async () => {
+			let e = await n(_), t = i({ 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)" : "") : "")), r({
+				sqlClientLayer: e.makeSqlLayer(S()),
+				runnerStorage: t,
+				dialectId: e.id,
+				...process.env.VOLTRO_WORKFLOW_RUNNER_PORT ? { runnerListenPort: Number(process.env.VOLTRO_WORKFLOW_RUNNER_PORT) } : {},
+				...a.length > 0 ? { extraShardingLayers: a } : {}
+			});
+		})();
+	}
+	let Ot = fe(I, t()), kt = x.filter((e) => /\.subscribe\.tsx?$/.test(e)), K = kt.length > 0 ? await oe(kt, $) : [], At = x.filter((e) => /\.reaction\.tsx?$/.test(e)), jt = At.length > 0 ? await _e(At, $) : [], q = x.filter((e) => u.test(e)), Mt = q.length > 0 ? await v(q, $) : [], Nt = x.filter((e) => /\.aggregate\.tsx?$/.test(e)), J = Nt.length > 0 ? await re(Nt, $) : [], Y = ne();
+	if (J.length > 0 && _ !== "memory") try {
+		Y = se((await n(_)).makeSqlLayer(S()));
+	} catch (e) {
+		$.warn("aggregate: SQL storage init failed — falling back to in-process", { err: String(e) });
+	}
+	let X = _ === "memory" ? gt : Je(N, `aggregate@${process.pid}`, $), Z = [], Pt = [], Ft = x.filter((e) => l.test(e));
+	if (Ft.length > 0) {
+		let e = $.child("agent"), t = x.filter((e) => a.test(e));
+		t.length > 0 && await o(t, e);
+		let n = await c(Ft, e);
+		for (let e of n.agents) for (let t of Te(e)) (t.kind === "action" ? Z : Pt).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) });
+	}
+	p.mark("workflow");
+	let Lt = await bn({
+		bootTiming: p,
+		discovered: {
+			queries: [...C.queries, ...Pt],
+			mutations: C.mutations,
+			actions: [...C.actions, ...Z],
+			streams: C.streams,
+			workflows: C.workflows,
+			workflowWorkers: C.workflowWorkers,
+			eventTriggers: C.eventTriggers,
+			schedules: C.schedules,
+			subscribers: K,
+			outboxHandlers: Mt,
+			connections: C.connections,
+			reactions: jt,
+			aggregates: J,
+			...ge === void 0 ? {} : { webhooks: ge }
+		},
+		log: $,
+		analytics: E.sink,
+		aggregateStorage: Y,
+		aggregateCoordinator: X,
+		store: N,
+		kv: F,
+		cache: Re,
+		snapshotCache: Ie,
+		schemaRegistry: j,
+		tenantScopedTables: C.tenantScopedTables,
+		softDeleteScopedTables: C.softDeleteScopedTables,
+		dataTransferSnapshot: zt(D),
+		dataTransferDialect: _,
+		tenantIsolation: (process.env.VOLTRO_TENANT_ISOLATION ?? g?.tenancy?.isolation) === "namespace" ? "namespace" : "shared-schema",
+		resolveSubject: (e, t) => ht({
+			headers: e,
+			clientId: t
+		}),
+		httpRoutes: [...I.flatMap((e) => e.httpRoutes ?? []), ...yt],
+		...V ? { baseLayer: V } : {},
+		...G === void 0 ? {} : { workflowEngineLayer: G },
+		scheduleDefaultTrigger: H,
+		scheduleCoordination: Tt,
+		scheduleArmSelf: !W,
+		dormancy: process.env.VOLTRO_DORMANCY === "sleep" || process.env.VOLTRO_DORMANCY === "always-on" ? process.env.VOLTRO_DORMANCY : g?.dormancy ?? "always-on",
+		scheduleReplicaId: process.env.HOSTNAME ?? `pid-${process.pid}`,
+		...Ot === void 0 ? {} : { scheduleFireInterceptor: Ot },
+		onSchedulerReady: (e) => {
+			Et = e;
+		},
+		observability: ot,
+		port: ae,
+		...g?.transport?.wsPath ? { path: g.transport.wsPath } : {}
+	});
+	ie(ue([
+		C.queries,
+		C.mutations,
+		C.actions,
+		C.streams
+	]), (e) => {
+		$.warn(e);
+	}), $.info(`API listening on :${ae}`, {
+		dialect: _,
+		queries: C.queries.length,
+		mutations: C.mutations.length,
+		actions: C.actions.length,
+		streams: C.streams.length,
+		workflows: C.workflows.length,
+		workflowWorkers: C.workflowWorkers.length,
+		schedules: C.schedules.length,
+		scheduleCoordination: Tt
+	}), p.finish($);
+	let Rt = () => {
+		for (let e of tt) e.stop();
+		Ve.detach(), Ke.stop(), ze(), R?.dispose(), setTimeout(() => process.exit(0), 1e4).unref?.(), Promise.resolve(it.deactivate()).then(() => st?.close()).then(() => E.dispose()).then(() => Lt.close()).then(() => N.close?.()).then(() => process.exit(0)).catch((e) => {
+			console.error("serve: shutdown step failed, exiting anyway:", e), process.exit(0);
+		});
+	};
+	return process.on("SIGINT", Rt), process.on("SIGTERM", Rt), await new Promise(() => {}), 0;
+};
+//#endregion
+export { Cn as n, _n as r, wn as t };