@voltro/cli 0.3.0 → 0.4.0

package/dist/serveCommand-BZzUJIyo.js

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