@voltro/cli 0.2.1 → 0.2.2

package/dist/serveCommand-93rRdEp0.js

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