@voltro/cli 0.4.0 → 0.5.0

package/dist/serveCommand-C0WFA396.js

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