@voltro/cli 0.28.0 → 0.30.0

package/dist/serveCommand-Ciq_wIY8.js

@@ -0,0 +1,1577 @@
+import { lt as e, st as t, t as n } from "./inspectMetrics-BeJdP_3b.js";
+import { n as r, s as i, t as a } from "./seedRunner-Bqxgp7HZ.js";
+import { r as o, t as s } from "./appModuleLoader-C9r9mxZt.js";
+import { $ as c, $t as l, A as u, At as d, B as ee, Bt as f, C as te, Ct as ne, D as p, Dt as m, E as h, Et as g, F as _, Ft as re, G as ie, H as v, I as y, It as ae, J as oe, Jt as b, K as se, L as ce, M as le, Mt as x, N as S, Nt as ue, O as de, Ot as fe, P as pe, Pt as me, Q as he, Qt as ge, R as _e, Rt as C, S as ve, St as ye, T as be, Tt as w, U as xe, V as Se, Vt as T, W as E, X as Ce, Xt as D, Y as we, Yt as Te, Z as Ee, Zt as De, _ as Oe, _t as ke, an as O, at as k, b as Ae, bt as je, c as Me, ct as A, d as Ne, dt as Pe, en as Fe, et as Ie, ft as Le, g as Re, gt as ze, h as Be, ht as Ve, i as He, it as Ue, j, jt as We, k as Ge, kt as Ke, lt as qe, mt as Je, nn as Ye, nt as Xe, o as Ze, on as Qe, ot as $e, pt as M, q as et, qt as tt, r as nt, rn as N, rt, sn as it, st as P, t as at, tn as ot, tt as st, u as ct, ut as lt, v as ut, vt as dt, w as ft, wt as pt, x as mt, xt as ht, y as F, yt as gt, zt as _t } from "./dev-DmnkH-wr.js";
+import { _ as vt, f as yt, m as I, n as L, p as bt, u as xt, v as St } from "./frameworkTableAssembly-BzAajuUv.js";
+import { S as Ct, c as wt, n as Tt, p as Et, s as R } from "./fileConventions-Cof68_BL.js";
+import { m as Dt } from "./inspect-BUUjt773.js";
+import { n as Ot, t as kt } from "./startupRunner-DPGFchOa.js";
+import { r as At, u as jt } from "./apiBuild-BceikpQf.js";
+import { t as z } from "./bootTiming-BdyP9nYw.js";
+import { n as Mt } from "./cliArgs-qdZSElM3.js";
+import { basename as Nt, join as Pt } from "node:path";
+import { pathToFileURL as Ft } from "node:url";
+import { Cause as It, Effect as B, Layer as V, ManagedRuntime as Lt } from "effect";
+import { createLogger as H } from "@voltro/logger";
+import { existsSync as Rt } from "node:fs";
+import { AggregateRegistry as zt, CostRegistry as Bt, Dispatcher as Vt, ExpectationRegistry as Ht, ExperimentRegistry as Ut, apiKeyManagementRoutes as Wt, attachAnalyticsMirror as Gt, attachExpectations as Kt, attachExperiments as qt, attachFinops as Jt, awaitServerListening as Yt, bindMutation as U, bindStream as Xt, bindSubscription as W, buildTracingLayer as Zt, cancelWakeup as Qt, compileCron as $t, dataStoreApiKeyStore as en, dataStoreIdempotencyStore as tn, formatServerOnlyLeaks as nn, formatUnresolvedSources as rn, frameworkApiKeyStrategy as an, getCredentialExpiry as on, installPolicyGuardResolver as sn, loadResourceTuples as cn, makeActionRunner as ln, makeAdvisoryLockCoordinator as un, makeApiKeyService as dn, makeApiKeyUsageBuffer as fn, makeApiKeyUsageFlusher as pn, makeAsyncKv as mn, makeCoordinatedScheduler as hn, makeEffectStoreLayer as gn, makeLazyWorkflowFacade as _n, makeMutationOutputCodec as vn, makeMutationRunner as yn, makeOneShotQueryRunner as bn, makeQueryDescriptorProducer as xn, makeQueryFinalizer as Sn, makeQueryReauthorizer as Cn, makeQuerySubscriber as wn, makeSchemaRegistry as Tn, makeWorkflowFacade as En, makeWorkflowFacadeWithCallerContext as G, makeWorkflowLayers as Dn, noopKv as K, onProcessShutdown as On, recordCredentialExpiry as kn, recordSubscriptionDelivery as An, recordWorkflowRun as jn, registerWakeup as Mn, resolveSecretsBackend as Nn, runProvidedEffect as Pn, setSecretsBackend as Fn, setSystemStoreHandle as In, setTupleSource as Ln, singleCoordinator as Rn, startRpcServer as zn, startScheduler as Bn, stripForbiddenForWire as Vn, unresolvedSources as Hn, workflowToRpc as Un, wrapStoreWithBootCodec as Wn } from "@voltro/runtime";
+import { RpcGroup as Gn } from "@effect/rpc";
+import { SqlClient as Kn } from "@effect/sql";
+import { allRegisteredTables as qn, and as Jn, ensureTableRegistered as Yn, eq as q, or as Xn } from "@voltro/database";
+import { appStorageProvider as Zn, fromNodeReadable as Qn, getObjectStream as $n, putObjectStream as er, toNodeReadable as tr } from "@voltro/plugin-storage";
+import { AuthMiddleware as nr, ConnectionInfoMiddleware as rr, actionToRpc as J, anonymousSubject as ir, isWireReachable as ar, mutationToRpc as Y, queryToRpc as X, streamToRpc as or, workflowCancelDescriptor as Z, workflowDomainEventsQueryDescriptor as sr, workflowEventDeliveriesQueryDescriptor as cr, workflowResumeDescriptor as lr, workflowRunEventsQueryDescriptor as ur, workflowRunQueryDescriptor as dr, workflowRunStepsQueryDescriptor as fr, workflowRunsQueryDescriptor as pr, workflowSignalDescriptor as mr, workflowUpdateDescriptor as hr } from "@voltro/protocol";
+import { isEnvContract as gr } from "@voltro/env";
+import { assertProductionSessionSecret as _r, sessionExpiryFromHeaders as vr } from "@voltro/protocol/session";
+import { createHash as yr, timingSafeEqual as br } from "node:crypto";
+import { declaredSnapshot as xr, describeOutcome as Sr, runPlannedMigrations as Cr } from "@voltro/database/sql";
+import { buildDeliverWebhookExecute as wr, buildWebhooksService as Tr, defaultIncomingPath as Er, deliverWebhookWorkflow as Dr, makeDeferredEmitHandler as Or, mountIncomingWebhook as kr } from "@voltro/plugin-webhooks";
+import { getAuthSessionStrategy as Ar } from "@voltro/plugin-auth";
+import { collectPublicApiRoutes as jr, restRoutesToHttpRoutes as Mr } from "@voltro/protocol/rest";
+import { registerEmailTemplates as Nr } from "@voltro/plugin-mail";
+import { channelFor as Pr, getBroadcastPlugin as Fr } from "@voltro/plugin-broadcast";
+import { packBundle as Ir, runExport as Lr, runImport as Rr, storageBlobSink as zr, storageRefsBlobSource as Br, unpackBundle as Vr, unpackBundleToDir as Hr } from "@voltro/data-transfer";
+//#region src/dbPoolReport.ts
+var Ur = (e, t) => {
+	let n = e !== void 0 && t !== void 0 ? e * t : void 0;
+	return e === void 0 ? "db pool: max per replica UNSET (DB_MAX_CONNECTIONS) — each replica opens the driver's default pool, so the fleet total is that default × replicas. Set DB_MAX_CONNECTIONS so the total stays under your database's connection limit; the pool scales with replicaCount and the database does not." : `db pool: max=${e} per replica (DB_MAX_CONNECTIONS)` + (n === void 0 ? " — the fleet opens up to max × replicas connections. Check that against your database's limit before raising replicaCount." : ` × ${t} replicas = up to ${n} connections. Check that against your database's limit.`);
+}, Wr = (e = process.env) => {
+	let t = e.REPLICA_COUNT;
+	if (t === void 0 || t === "") return;
+	let n = Number(t);
+	return Number.isInteger(n) && n > 0 ? n : void 0;
+}, Gr = "/_voltro/admin/import", Kr = "/_voltro/admin/export", Q = (e, t) => ({
+	status: e,
+	contentType: "application/json; charset=utf-8",
+	body: JSON.stringify(t)
+}), qr = (e) => {
+	let t = e.authorization ?? e.Authorization, n = t ? /^Bearer\s+(.+)$/i.exec(t) : null;
+	return n ? n[1] : null;
+}, Jr = (e, t) => br(yr("sha256").update(e).digest(), yr("sha256").update(t).digest()), Yr = (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 = qr(e.headers);
+	return !n || !Jr(n, t) ? Q(401, { error: "unauthorized" }) : null;
+}, Xr = H({ scope: "voltro:admin-import" }), Zr = "VBUNDLE2", Qr = async function* (e) {
+	yield e;
+}, $r = (e) => async (t) => {
+	let n = Yr(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") === Zr, c, l;
+	if (s) c = Qr(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 Vr(c, {
+			dir: f,
+			blobs: e.assetSink
+		}) : await Hr(c, f);
+		let t = await B.runPromiseExit(Rr({
+			store: e.store,
+			bundleDir: f,
+			...r ? { mode: r } : {},
+			...i ? { onConflict: i } : {},
+			...a ? { atomic: a } : {},
+			...e.snapshot ? { targetSnapshot: e.snapshot } : {},
+			force: o,
+			onWarn: (e) => Xr.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 Xr.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 Xr.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 Xr.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
+		});
+	}
+}, ei = H({ scope: "voltro:admin-export" }), ti = async (e) => {
+	let t = [];
+	for await (let n of e) t.push(Buffer.from(n));
+	return new Uint8Array(Buffer.concat(t));
+}, ni = (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" }, ri = (e) => async (t) => {
+	let n = Yr(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 ?? ni(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 B.runPromise(Lr({
+			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, () => Ir({
+				dir: f,
+				...l
+			})), ei.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 ti(Ir({
+			dir: f,
+			...l
+		}));
+		return ei.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 ei.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
+		});
+	}
+}, ii = 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;
+}, ai = (e, t, n = {}) => (async function* () {
+	let r = await tr((await B.runPromise($n(e, t).pipe(B.timeout(n.openTimeout ?? "30 seconds")))).stream), i = n.stallMs ?? 12e4, a, o = () => {
+		a && clearTimeout(a), a = setTimeout(() => r.destroy(/* @__PURE__ */ Error(`storage read stalled for ${i}ms reading '${t}'`)), i);
+	};
+	try {
+		o();
+		for await (let e of r) o(), yield e instanceof Uint8Array ? e : new Uint8Array(e);
+	} finally {
+		a && clearTimeout(a), r.destroy();
+	}
+})(), oi = {
+	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()
+}, si = async (e) => {
+	In({
+		dataStore: e.store,
+		schemaRegistry: e.schemaRegistry
+	});
+	let t = (e.discovered.budgets?.length ?? 0) > 0, r, i = new Vt({
+		store: e.store,
+		...e.snapshotCache ? { cache: e.snapshotCache } : {},
+		...t ? { recordCost: (e) => r?.record(e) } : {},
+		recordDelivery: (e) => An({
+			label: e.label,
+			kind: e.kind,
+			durationMs: e.durationMs,
+			rowCount: e.rowCount
+		})
+	}), a = e.cache ?? oi, o = e.kv ?? K, s, c = () => void 0, l, u, d, f, te, ne, p, m = /* @__PURE__ */ new Map(), h = () => `wfctx_${globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`}`, ie = async (t, n, r) => {
+		let i = {
+			...r,
+			source: r.source ?? `workflow:${t}`
+		};
+		m.set(n, i);
+		try {
+			let r = await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: q("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: h(),
+				...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`);
+		}
+	}, ae = async (t, n) => {
+		let r = m.get(n);
+		if (r !== void 0) return r;
+		try {
+			let t = (await e.store.query({
+				table: "_voltro_workflow_start_contexts",
+				order: [],
+				predicate: q("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 m.set(n, r), r;
+		} catch (e) {
+			process.stderr.write(`[workflow] failed to load start context for ${n}: ${e?.message ?? String(e)}\n`);
+			return;
+		}
+	}, b = (e.discovered.workflows?.length ?? 0) > 0 ? _n(() => s) : void 0, ce = (e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.eventTriggers?.length ?? 0) > 0, ue = ce || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster", de = e.tenantIsolation === "namespace", fe = (e.log ?? H({ scope: "voltro:serve" })).child("webhooks"), he, _e, C = e.discovered.webhooks;
+	if (C && C.outgoing.length > 0 && e.workflowEngineLayer !== void 0) {
+		e.workflowEngineLayer;
+		let t = ge({
+			store: e.store,
+			schemaRegistry: e.schemaRegistry,
+			cache: a,
+			kv: o
+		}), n = C.outgoing.map((e) => e.descriptor);
+		_e = Dr.toLayer(wr(t, { events: n })), he = Tr(t, async (e) => {
+			let t = d;
+			if (t === void 0) {
+				fe.error("webhook delivery skipped — the workflow runtime was never built. This is a framework defect, not a configuration problem: report it with your engine setting. Deliveries are NOT queued and will not be retried.", {
+					deliveryId: e.deliveryId,
+					targetId: e.targetId
+				});
+				return;
+			}
+			t.runPromise(Dr.execute(e)).catch((t) => {
+				fe.error("deliverWebhook workflow crashed", {
+					deliveryId: e.deliveryId,
+					targetId: e.targetId
+				}, t);
+			});
+		}, { events: n });
+	}
+	let ve = /* @__PURE__ */ new Map();
+	if (C) for (let e of C.incoming) {
+		let t = e.descriptor.path ?? Er(e.descriptor.id), n = `VOLTRO_WEBHOOK_SECRET_${e.descriptor.id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`, r = kr(e.descriptor, {
+			resolveSecret: async () => process.env[n] ?? null,
+			resolveWorkflows: () => b === void 0 ? void 0 : G(b, {
+				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 ? fe.error("incoming delivery failed", t) : e.status >= 400 ? fe.warn("incoming delivery rejected", t) : fe.info("incoming delivery handled", t);
+			}
+		});
+		ve.set(t, { handle: r });
+	}
+	sn(), Ln((t) => cn(e.store, t.subjectId, t.resourceType, t.resourceId));
+	let ye = [...e.discovered.outboxHandlers ?? [], ...Pe((C?.outgoing.length ?? 0) + (C?.incoming.length ?? 0) + (C?.providers.length ?? 0), []) ? [{
+		file: "<framework>/webhooks",
+		id: "voltro-webhook-emit",
+		definition: Or(() => he)
+	}] : []], be = ye.length > 0 ? me({
+		handlers: ye,
+		store: e.store,
+		log: (e.log ?? H({ scope: "voltro:serve" })).child("outbox")
+	}) : void 0, T = x({
+		definitions: (e.discovered.connections ?? []).map((e) => e.definition),
+		store: e.store,
+		publicUrl: We(e.port ?? 4e3),
+		log: (e.log ?? H({ scope: "voltro:serve" })).child("connections")
+	});
+	le({
+		events: e.discovered.events ?? [],
+		rpcTags: [
+			...e.discovered.queries.map((e) => e.descriptor.name),
+			...e.discovered.mutations.map((e) => e.descriptor.name),
+			...e.discovered.actions.map((e) => e.descriptor.name),
+			...(e.discovered.streams ?? []).map((e) => e.descriptor.name)
+		]
+	});
+	let Ce = (e.log ?? H({ scope: "voltro:serve" })).child("events"), Te = e.broadcastNamespace ?? ut(e.plugins, void 0), Ee = F(e.plugins, Te, Ce), Oe = e.membership?.instanceId ?? process.env.POD_NAME ?? process.env.HOSTNAME ?? `serve-${process.pid}`, ke = e.membership ?? Ae(e.plugins, {
+		instanceId: Oe,
+		namespace: Te,
+		meta: { mode: "serve" },
+		logger: Ce
+	}), O = S({
+		events: e.discovered.events ?? [],
+		origin: Oe,
+		...Ee.publishRemote === void 0 ? {} : { publishRemote: Ee.publishRemote }
+	}), Me = (e.discovered.events ?? []).length > 0 ? await Ee.attach(O.bus) : null, A = De({
+		store: e.store,
+		schemaRegistry: e.schemaRegistry,
+		cache: a,
+		kv: o,
+		...he === void 0 ? {} : { webhooksService: he },
+		...b === void 0 ? {} : { workflowsProxy: b },
+		eventTriggers: e.discovered.eventTriggers ?? [],
+		namespaceIsolationOn: de,
+		...be === void 0 ? {} : { outbox: { nudge: be.nudge } },
+		...T.active ? { connections: { registry: T.registry } } : {},
+		eventBus: O.bus
+	}), Ne = V.succeed(zt, ht), Fe = V.succeed(Ht, Ve), Le = V.succeed(Bt, Je), Re = V.succeed(Ut, ze), Be = (t, n) => {
+		let r = t.pipe(B.provide(gn(n)));
+		return (e.baseLayer ? r.pipe(B.provide(e.baseLayer)) : r).pipe(B.provide(Ne)).pipe(B.provide(Fe)).pipe(B.provide(Le)).pipe(B.provide(Re));
+	}, He = (e, t) => Pn(Be(e, t)), Ue = n(), j = se(e.plugins ?? [], Ue), Ge = E(e.plugins ?? [], Ue), Ke = yn({
+		store: e.store,
+		recordMetric: (e) => {
+			Ue.record(e);
+		},
+		...j.mutation === void 0 ? {} : { interceptor: j.mutation },
+		buildContext: (e, t, n) => A(e, t, n),
+		runEffect: He,
+		undoCapture: we()
+	}), Ye = oe(), Xe = ln({
+		buildContext: (e) => A(e),
+		runEffect: He,
+		recordMetric: (e) => {
+			Ue.record(e);
+		},
+		...j.action === void 0 ? {} : { interceptor: j.action }
+	}), Ze = Sn({
+		tenantScopedTables: e.tenantScopedTables,
+		softDeleteScopedTables: e.softDeleteScopedTables
+	}), Qe = {
+		buildContext: (e) => A(e),
+		finalize: (e, t) => Ze(e, t.subject),
+		provideEffect: Be,
+		...j.query === void 0 ? {} : { interceptor: j.query }
+	}, M = xn(Qe), et = bn({
+		...Qe,
+		queryRows: (t, n) => e.store.query(t).then((e) => Vn(t.table, e, n.subject))
+	}), nt = wn({
+		...Qe,
+		subscribeDescriptor: (e, t, n) => i.subscribe(e, t, n),
+		subscribeComputed: (e, t, n) => i.subscribeComputed(e, t, n)
+	}), N = (e) => e.filter((e) => ar(e.descriptor)), P = {};
+	for (let t of [
+		...N(e.discovered.queries),
+		...Ye.queries,
+		...T.queries
+	]) P[t.descriptor.name] = (e) => W(M(t, e), i, `subscription.${t.descriptor.name}`, void 0, void 0, Cn(t, e));
+	for (let t of [
+		...N(e.discovered.mutations),
+		...Ye.mutations,
+		...T.mutations
+	]) {
+		let n = vn(t.descriptor.output);
+		P[t.descriptor.name] = (r) => U(async (e, n) => Ke(t, e, n), r, `mutation.${t.descriptor.name}`, n, e.idempotency, t.descriptor.error);
+	}
+	for (let t of [...N(e.discovered.actions), ...T.actions]) {
+		let n = vn(t.descriptor.output);
+		P[t.descriptor.name] = (r) => U(async (e, n) => Xe(t, e, n), r, `action.${t.descriptor.name}`, n, e.idempotency, t.descriptor.error);
+	}
+	let at = () => `public-${Math.random().toString(36).slice(2, 10)}`, ot = [
+		...e.discovered.queries.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+			descriptor: e.descriptor,
+			invoke: (t, n) => et(e, t, {
+				subject: n.subject,
+				traceId: at()
+			}),
+			subscribe: (t, n, r) => nt(e, t, {
+				subject: n.subject,
+				traceId: at()
+			}, r)
+		})),
+		...e.discovered.mutations.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+			descriptor: e.descriptor,
+			invoke: (t, n) => Ke(e, t, {
+				subject: n.subject,
+				traceId: at()
+			})
+		})),
+		...e.discovered.actions.filter((e) => e.descriptor.publicApi !== void 0).map((e) => ({
+			descriptor: e.descriptor,
+			invoke: (t, n) => Xe(e, t, {
+				subject: n.subject,
+				traceId: at()
+			})
+		}))
+	], ct = ot.length > 0 ? Mr(jr(ot), {
+		store: e.store,
+		resolveSubject: (t) => e.resolveSubject(t, -1)
+	}) : [], lt = e.dataTransferSecret ?? process.env.VOLTRO_DATA_TRANSFER_SECRET, dt = lt && lt.length >= 16 ? [{
+		method: "POST",
+		path: Gr,
+		handle: $r({
+			secret: lt,
+			store: e.store,
+			...e.dataTransferSnapshot ? { snapshot: e.dataTransferSnapshot } : {},
+			assetSink: zr(Zn()),
+			openArchive: (e) => ai(Zn(), e)
+		})
+	}, {
+		method: "POST",
+		path: Kr,
+		handle: ri({
+			secret: lt,
+			store: e.store,
+			snapshot: e.dataTransferSnapshot ?? { tables: [] },
+			dialect: e.dataTransferDialect ?? "memory",
+			tenantTables: [...e.tenantScopedTables],
+			loadProfile: ii,
+			assetSource: Br(Zn(), e.store),
+			putArchive: async (e, t) => {
+				let { Readable: n } = await import("node:stream"), r = Zn(), i = Qn("storage", () => n.from(t()));
+				await B.runPromise(er(r, e, i, { contentType: "application/octet-stream" }));
+			}
+		})
+	}] : [], ft = [
+		...e.httpRoutes ?? [],
+		...ct,
+		...dt,
+		...T.httpRoutes
+	];
+	Object.assign(P, O.handlers);
+	for (let t of N(e.discovered.streams ?? [])) P[t.descriptor.name] = (n) => Xt((r) => {
+		let i = A(r), a = t.executor(n, i);
+		if (B.isEffect(a)) {
+			let t = a.pipe(B.provide(gn(i.store)));
+			return (e.baseLayer ? t.pipe(B.provide(e.baseLayer)) : t).pipe(B.provide(Ne)).pipe(B.provide(Fe)).pipe(B.provide(Le)).pipe(B.provide(Re));
+		}
+		return typeof a == "object" && a && typeof a.then == "function" ? B.promise(() => a) : a;
+	}, `stream.${t.descriptor.name}`);
+	for (let t of e.discovered.workflows ?? []) P[t.definition.name] = (e) => U(async (e, n) => {
+		let r = n;
+		return G(b, {
+			subject: r.subject,
+			traceId: r.traceId,
+			source: "workflow-rpc"
+		}).start(t.definition.name, e);
+	}, e, `workflow.${t.definition.name}`);
+	ce && (P[dr.name] = (e) => W(M({
+		descriptor: dr,
+		executor: (e) => {
+			let t = e.id;
+			return {
+				table: "_voltro_workflow_runs",
+				order: [{
+					column: "startedAt",
+					direction: "desc"
+				}],
+				predicate: Xn(q("id", t), q("executionId", t)),
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${dr.name}`), P[pr.name] = (e) => W(M({
+		descriptor: pr,
+		executor: (e) => {
+			let t = e, n = [...t.tag === void 0 ? [] : [q("tag", t.tag)], ...t.status === void 0 ? [] : [q("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] : Jn(...n),
+				take: r,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${pr.name}`), P[fr.name] = (e) => W(M({
+		descriptor: fr,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_steps",
+				order: [{
+					column: "startedAt",
+					direction: "asc"
+				}],
+				predicate: q("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${fr.name}`), P[ur.name] = (e) => W(M({
+		descriptor: ur,
+		executor: (e) => {
+			let t = e.runId;
+			return {
+				table: "_voltro_workflow_run_events",
+				order: [{
+					column: "occurredAt",
+					direction: "asc"
+				}],
+				predicate: q("runId", t),
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${ur.name}`), P[sr.name] = (e) => W(M({
+		descriptor: sr,
+		executor: (e) => {
+			let t = e;
+			return {
+				table: "_voltro_workflow_events",
+				order: [{
+					column: "occurredAt",
+					direction: "desc"
+				}],
+				predicate: t.name === void 0 ? void 0 : q("name", t.name),
+				take: Math.max(1, Math.min(500, t.limit ?? 100)),
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${sr.name}`), P[cr.name] = (e) => W(M({
+		descriptor: cr,
+		executor: (e) => {
+			let t = e.eventId;
+			return {
+				table: "_voltro_workflow_event_deliveries",
+				order: [{
+					column: "createdAt",
+					direction: "asc"
+				}],
+				predicate: q("eventId", t),
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			};
+		}
+	}, e), i, `subscription.${cr.name}`), P[Z.name] = (t) => U(async (t, n) => {
+		let r = t;
+		return await D(e.store, n.subject, { executionId: r.executionId }), await b.cancel(r.workflowName, r.executionId), await xt(r.workflowName, r.executionId, "workflow.cancel"), { ok: !0 };
+	}, t, `action.${Z.name}`), P[lr.name] = (t) => U(async (t, n) => {
+		let r = t;
+		return await D(e.store, n.subject, { executionId: r.executionId }), await b.resume(r.workflowName, r.executionId), { ok: !0 };
+	}, t, `action.${lr.name}`), P[mr.name] = (t) => U(async (t, n) => {
+		let r = t;
+		return await D(e.store, n.subject, { id: r.id }), b.signal({ id: r.id }, r.signalName, r.payload);
+	}, t, `action.${mr.name}`), P[hr.name] = (t) => U(async (t, n) => {
+		let r = t;
+		return await D(e.store, n.subject, { id: r.id }), b.update({ id: r.id }, r.updateName, r.payload, r.timeoutMs === void 0 ? void 0 : { timeoutMs: r.timeoutMs });
+	}, t, `action.${hr.name}`));
+	let pt = [
+		...N(e.discovered.queries).map((e) => X(e.descriptor)),
+		...N(e.discovered.mutations).map((e) => Y(e.descriptor)),
+		...N(e.discovered.actions).map((e) => J(e.descriptor)),
+		...Ye.queries.map((e) => X(e.descriptor)),
+		...Ye.mutations.map((e) => Y(e.descriptor)),
+		...T.queries.map((e) => X(e.descriptor)),
+		...T.mutations.map((e) => Y(e.descriptor)),
+		...T.actions.map((e) => J(e.descriptor)),
+		...N(e.discovered.streams ?? []).map((e) => or(e.descriptor)),
+		...O.rpcs,
+		...(e.discovered.workflows ?? []).map((e) => Un(e.definition)),
+		...ce ? [
+			X(dr),
+			X(pr),
+			X(fr),
+			X(ur),
+			X(sr),
+			X(cr),
+			J(Z),
+			J(lr),
+			J(mr),
+			J(hr)
+		] : []
+	], mt = Gn.make(...pt).middleware(nr).middleware(rr), gt = V.succeed(nr, nr.of(({ headers: t, clientId: n }) => B.promise(() => e.resolveSubject(t, n)))), _t = V.succeed(rr, rr.of(({ headers: e, clientId: t }) => B.sync(() => {
+		let n = on(t) ?? vr(e);
+		return {
+			clientId: t,
+			...e["idempotency-key"] ? { idempotencyKey: e["idempotency-key"] } : {},
+			...n === void 0 ? {} : { credentialExpiresAt: n }
+		};
+	}))), vt = e.dormancyTenantId ?? "default", yt = e.dormancy === "sleep" ? {
+		register: (t, n, r) => Mn(e.store, {
+			tenantId: r ?? vt,
+			kind: "workflow",
+			refId: t,
+			wakeAt: n
+		}),
+		cancel: (t, n) => Qt(e.store, {
+			tenantId: n ?? vt,
+			kind: "workflow",
+			refId: t
+		}).then(() => {})
+	} : void 0, I = ue ? await import("@voltro/workflow") : void 0, L = I?.makeWorkflowRunRecorder({
+		store: e.store,
+		...yt === void 0 ? {} : { wakeups: yt }
+	}), bt = async (t, n) => {
+		await I.closeWorkflowChildrenForParent({
+			store: e.store,
+			parentExecutionId: t,
+			parentStatus: n,
+			recorder: L,
+			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 (!d) throw Error("Workflow runtime is not ready");
+				await d.runPromise(r.definition.interrupt(n));
+			}
+		});
+	}, xt = async (t, n, r) => {
+		let i = (await e.store.query({
+			table: "_voltro_workflow_runs",
+			order: [],
+			predicate: q("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 L.recordEvent({
+			runId: i.id,
+			eventType: "run-cancelled",
+			payload: {
+				reason: r,
+				workflowName: t,
+				executionId: n,
+				...o == null ? {} : { tenantId: o }
+			}
+		}), a && await bt(n, "cancelled");
+	}, St = [
+		...Dn(e.discovered.workflows ?? [], {
+			buildContext: (t, n) => e.buildContextForWorkflow?.(t, n) ?? A({
+				subject: t.subject,
+				traceId: t.traceId
+			}, e.store, void 0, `workflow:${n.workflowName}`, { parentExecutionId: n.executionId }),
+			resolveStartContext: ae
+		}, (t, n, r) => {
+			let i = I.getWorkflowVersionMetadata(t.definition);
+			return I.wrapWorkflowExecuteWithRunRecording({
+				name: t.definition.name,
+				store: e.store,
+				subject: r.subject,
+				source: r.source ?? null,
+				traceId: r.traceId,
+				workflowVersion: i.version,
+				workflowCompatibleVersions: i.compatibleWith,
+				workflowPatches: i.patches,
+				parentExecutionId: r?.parentExecutionId ?? null,
+				parentClosePolicy: r?.parentClosePolicy ?? null,
+				onParentClose: ({ executionId: e, status: t }) => bt(e, t),
+				...(() => {
+					let e = st(t.definition.name, I.getWorkflowFlowControl(t.definition)?.encryptSteps === !0);
+					return e === void 0 ? {} : { encryptStepPayload: e };
+				})(),
+				onTerminal: async ({ executionId: e }) => {
+					await u?.gate.release(e);
+				},
+				recorder: L,
+				pluginWorkflowStepLayer: Ge,
+				recordRun: jn
+			}, n);
+		}),
+		...e.discovered.workflowWorkers ?? [],
+		..._e === void 0 ? [] : [_e]
+	], Ct = St.length > 0 ? V.mergeAll(...St) : V.empty;
+	if (((e.discovered.workflows?.length ?? 0) > 0 || (e.discovered.workflowWorkers?.length ?? 0) > 0 || e.scheduleCoordination === "cluster" || _e !== void 0) && e.workflowEngineLayer !== void 0) {
+		let t = Ct.pipe(V.provideMerge(e.workflowEngineLayer));
+		d = Lt.make(e.baseLayer === void 0 ? t : t.pipe(V.provideMerge(e.baseLayer))), await d.runPromise(B.void);
+		let n = await import("@voltro/workflow/cluster"), r = (e) => d.runPromise(n.redriveFailedRun(e)), i = (e) => d.runPromise(n.resumeRunFromStep(e));
+		ne = await it({
+			provider: Fr(e.plugins ?? [])?.broadcast?.provider,
+			crossReplica: Fr(e.plugins ?? [])?.broadcast?.crossReplica ?? !1,
+			namespace: Te,
+			replicaId: crypto.randomUUID(),
+			pollStorage: () => d.runPromise(n.pollWorkflowStorage),
+			log: (e.log ?? H({ scope: "voltro:serve" })).child("workflow")
+		}), f = async (t) => {
+			let n = await Se({
+				store: e.store,
+				workflows: e.discovered.workflows ?? [],
+				runRedrive: r
+			}, t.runId);
+			return n.statusReset && await L.recordEvent({
+				runId: t.runId,
+				eventType: "run-redriven",
+				payload: {
+					reason: "inspect.redrive",
+					activitiesReset: n.outcome.activitiesReset
+				}
+			}), {
+				redriven: n.outcome.redriven,
+				activitiesReset: n.outcome.activitiesReset,
+				reason: n.outcome.reason
+			};
+		}, te = async (t) => {
+			let n = await v({
+				store: e.store,
+				workflows: e.discovered.workflows ?? [],
+				runResume: i
+			}, t.runId, t.step);
+			return n.statusReset && await L.recordEvent({
+				runId: t.runId,
+				eventType: "run-redriven",
+				payload: {
+					reason: "inspect.resume-from-step",
+					step: n.stepName,
+					activitiesReset: n.outcome.activitiesReset
+				}
+			}), {
+				redriven: n.outcome.redriven,
+				stepName: n.stepName,
+				activitiesReset: n.outcome.activitiesReset,
+				reason: n.outcome.reason
+			};
+		};
+		let a = hn({
+			coordinator: (e.scheduleCoordination ?? "single") === "advisoryLock" ? un(e.store, e.scheduleReplicaId ?? `pid-${process.pid}`) : Rn,
+			replicaId: e.scheduleReplicaId ?? `pid-${process.pid}`
+		}), o = {
+			info: (e, t) => {
+				process.stdout.write(`[flow-control] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+			},
+			warn: (e, t) => {
+				process.stderr.write(`[flow-control] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+			},
+			error: (e, t) => {
+				process.stderr.write(`[flow-control] ERROR ${e} ${t ? JSON.stringify(t) : ""}\n`);
+			}
+		}, p, m = () => {
+			if (p !== void 0) return p;
+			if (!(s === void 0 || L === void 0)) return p = _({
+				store: e.store,
+				log: z,
+				workflows: e.discovered.workflows ?? [],
+				workflowsProxy: s,
+				workflowRuntime: d,
+				workflowRunRecorder: L,
+				closeChildrenForParent: bt
+			}), p;
+		};
+		c = m, u = qe({
+			store: e.store,
+			workflows: e.discovered.workflows ?? [],
+			facade: () => s,
+			cancelRunWithReason: m,
+			scheduleCoordinated: a,
+			onAbandoned: async (t) => {
+				await Ie({
+					workflows: e.discovered.workflows ?? [],
+					facade: () => s,
+					log: o,
+					...t
+				});
+			},
+			log: o
+		});
+		let h = u;
+		h !== void 0 && On(() => h.stop()), l = $e({
+			store: e.store,
+			enabled: (e.discovered.workflows?.length ?? 0) > 0,
+			resumeSignal: () => d === void 0 || I === void 0 ? void 0 : async ({ executionId: t, workflowName: n, signalName: r, payload: i }) => {
+				await d.runPromise(I.completeSuspendingSignal({
+					store: e.store,
+					target: k(t, n),
+					signalName: r,
+					payload: i
+				}));
+			},
+			runEffect: (e) => d.runPromise(e),
+			scheduleCoordinated: a,
+			log: o
+		});
+		let g = l;
+		g !== void 0 && On(() => g.stop()), s = (e.discovered.workflows?.length ?? 0) > 0 ? En({
+			workflows: e.discovered.workflows ?? [],
+			runEffect: (e) => d.runPromise(e),
+			onEnqueue: () => ne?.publishWake(),
+			...h === void 0 ? {} : { admitStart: h.gate.admitStart },
+			rememberStartContext: ie,
+			signal: async (t, n, r) => {
+				let i = await I.sendWorkflowSignal({
+					store: e.store,
+					recorder: L,
+					target: t,
+					signalName: n,
+					payload: r
+				});
+				return await d.runPromise(I.completeSuspendingSignal({
+					store: e.store,
+					target: t,
+					signalName: n,
+					payload: r
+				})).catch(() => {}), i;
+			},
+			update: (t, n, r, i) => I.sendWorkflowUpdate({
+				store: e.store,
+				recorder: L,
+				target: t,
+				updateName: n,
+				payload: r,
+				...i === void 0 ? {} : { options: i }
+			}),
+			listRuns: (t) => ee(e.store, t),
+			retry: (t, n) => xe({
+				store: e.store,
+				workflows: e.discovered.workflows ?? [],
+				runPromise: (e) => d.runPromise(e)
+			}, t, n),
+			redrive: (t) => Se({
+				store: e.store,
+				workflows: e.discovered.workflows ?? [],
+				runRedrive: r
+			}, t).then((e) => e.outcome)
+		}) : void 0;
+	}
+	let wt = V.mergeAll(mt.toLayer(P), gt, _t), Tt = tt(P, e.discovered.queries.map((e) => e.descriptor.name), ce), Et = V.mergeAll(mt.toLayer(Tt), gt, _t), R = e.observability, Dt = await Zt({
+		...e.appName === void 0 ? {} : { serviceName: e.appName },
+		...R && R.spanProcessors.length > 0 ? { extraSpanProcessors: R.spanProcessors } : {},
+		...R && R.metricReaders.length > 0 ? { extraMetricReaders: R.metricReaders } : {},
+		...R && Object.keys(R.resourceAttributes).length > 0 ? { resourceAttributes: R.resourceAttributes } : {},
+		...R && R.sampler !== void 0 ? { sampler: R.sampler } : {}
+	}), Ot = !1, kt = e.store.ping ? () => e.store.ping().then(() => !0).catch(() => !1) : void 0, { server: At, shutdown: jt } = zn({
+		group: mt,
+		handlersLayer: wt,
+		httpHandlersLayer: Et,
+		port: e.port ?? 4e3,
+		...e.host === void 0 ? {} : { host: e.host },
+		path: e.path ?? "/ws",
+		tracerLayer: Dt.layer,
+		healthCheck: {
+			isReady: () => Ot,
+			...kt ? { ping: kt } : {}
+		},
+		...ft.length > 0 ? { httpRoutes: ft } : {},
+		...e.getStore === void 0 ? {} : { getStore: e.getStore },
+		...ve.size > 0 ? { webhookRoutes: ve } : {},
+		...e.inspectRoute === void 0 ? {} : { inspectRoute: e.inspectRoute }
+	});
+	if (await Yt(At), (e.discovered.schedules?.length ?? 0) > 0) {
+		let t = (e.scheduleCoordination ?? "single") === "advisoryLock" ? un(e.store, e.scheduleReplicaId ?? `pid-${process.pid}`) : Rn;
+		p = await Bn(e.discovered.schedules ?? [], {
+			store: e.store,
+			coordinator: t,
+			defaultTrigger: e.scheduleDefaultTrigger ?? "self",
+			replicaId: e.scheduleReplicaId ?? `pid-${process.pid}`,
+			armSelf: e.scheduleArmSelf ?? !0,
+			dormancy: e.dormancy ?? "always-on",
+			...e.dormancyTenantId === void 0 ? {} : { dormancyTenantId: e.dormancyTenantId },
+			buildContext: ({ traceId: t, scheduleName: n, subject: r }) => A({
+				subject: r,
+				traceId: t
+			}, e.store, void 0, `schedule:${n}`),
+			log: {
+				info: (e, t) => {
+					process.stdout.write(`[schedule] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				warn: (e, t) => {
+					process.stderr.write(`[schedule] ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				error: (e, t) => {
+					process.stderr.write(`[schedule] ERROR ${e} ${t ? JSON.stringify(t) : ""}\n`);
+				},
+				debug: () => {}
+			},
+			...e.scheduleFireInterceptor === void 0 ? {} : { interceptFire: e.scheduleFireInterceptor },
+			...e.onScheduleRunEvent === void 0 ? {} : { onRunEvent: e.onScheduleRunEvent }
+		}), e.onSchedulerReady?.(p);
+	}
+	let z = e.log ?? H({ scope: "voltro:serve" }), Mt, Nt;
+	if ((e.discovered.subscribers?.length ?? 0) > 0 && (Mt = re(e.discovered.subscribers ?? [], e.store, z.child("subscribe"), e.schemaRegistry, O.bus)), (e.discovered.reactions?.length ?? 0) > 0) {
+		let t = z.child("reaction"), n = async (n, r) => {
+			if (n.kind === "workflow") {
+				if (b === void 0) {
+					t.warn("reaction workflow act skipped — no workflow engine in this app", { workflow: n.workflow });
+					return;
+				}
+				let e = n.payload === void 0 ? r.new ?? r.old ?? {} : n.payload(r);
+				await G(b, {
+					traceId: `reaction:${n.workflow}`,
+					source: `reaction:${n.workflow}`
+				}).start(n.workflow, e);
+				return;
+			}
+			await g(n.agent, r, {
+				findAgentSend: (t) => e.discovered.actions.find((e) => e.descriptor.name === `${t}.send`),
+				runAction: (e, t, n) => Promise.resolve(Xe(e, t, n)),
+				makeSubject: (e) => ir(e),
+				now: () => Date.now(),
+				log: t
+			});
+		}, r = async (n, r) => {
+			try {
+				let { requireAiBudget: t } = await import("@voltro/ai");
+				return (await B.runPromise(B.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;
+			}
+		}, i = rt(e.store, { onError: (e) => t.warn("reaction: rate-slot claim failed; refusing the act", { cause: String(e) }) });
+		Nt = w(e.discovered.reactions ?? [], e.store, {
+			runAct: n,
+			checkBudget: r,
+			claimRateSlot: (e) => i.claim(e)
+		}, t);
+	}
+	let Pt;
+	(e.discovered.aggregates?.length ?? 0) > 0 && (Pt = await je({
+		discovered: e.discovered.aggregates ?? [],
+		store: e.store,
+		log: z.child("aggregate"),
+		...e.analytics === void 0 ? {} : { analytics: e.analytics },
+		...e.aggregateStorage === void 0 ? {} : { storage: e.aggregateStorage },
+		...e.aggregateCoordinator === void 0 ? {} : { coordinator: e.aggregateCoordinator }
+	}), Ne = V.succeed(zt, Pt.registry));
+	let Ft;
+	(e.discovered.expectations?.length ?? 0) > 0 && (Ft = Kt({
+		discovered: e.discovered.expectations ?? [],
+		store: e.store,
+		log: z.child("expectation")
+	}), Fe = V.succeed(Ht, Ft.registry)), (e.discovered.budgets?.length ?? 0) > 0 && (r = Jt({
+		discovered: e.discovered.budgets ?? [],
+		log: z.child("finops")
+	}), Le = V.succeed(Bt, r.registry));
+	let It;
+	return (e.discovered.experiments?.length ?? 0) > 0 && (It = qt({
+		discovered: e.discovered.experiments ?? [],
+		store: e.store,
+		log: z.child("experiment")
+	}), Re = V.succeed(Ut, It.registry)), Ot = !0, e.bootTiming?.mark("ready"), {
+		dispatcher: i,
+		server: At,
+		scheduler: p,
+		eventsSnapshot: pe(O.bus, O.declared),
+		membersSnapshot: () => ({
+			members: ke.membership.list(),
+			capturedAt: Date.now()
+		}),
+		rpcMetrics: () => Ue,
+		webhooksService: () => he,
+		runCanceller: () => c(),
+		flowControlHealth: () => u?.cancelHealth(),
+		inferenceHealth: () => l?.health(),
+		workflowWriteActions: () => b === void 0 || L === void 0 ? void 0 : y({
+			store: e.store,
+			log: z,
+			workflows: e.discovered.workflows ?? [],
+			workflowsProxy: s,
+			workflowRuntime: d,
+			workflowRunRecorder: L,
+			closeChildrenForParent: bt
+		}),
+		redriveWorkflowRun: (e) => f ? f(e) : Promise.reject(/* @__PURE__ */ Error("redrive: this app registers no workflows")),
+		resumeWorkflowRunFromStep: (e) => te ? te(e) : Promise.reject(/* @__PURE__ */ Error("resume-from-step: this app registers no workflows")),
+		close: async () => {
+			Ot = !1, await Me?.detach(), await ke.detach(), Pt?.detach(), Ft?.detach(), r?.detach(), It?.detach(), Nt?.(), Mt?.(), await p?.shutdown(), i.close(), await ne?.detach(), await d?.dispose(), await new Promise((e) => At.close(() => e())), await jt();
+		}
+	};
+}, $ = H({ scope: "voltro:serve" }), ci = (e, t, n) => (e === "production" || e === "staging") && t !== "memory" && n !== "0", li = Mt, ui = async (e) => {
+	let t = jt(process.cwd());
+	if (Rt(t)) {
+		let n;
+		try {
+			let e = await import(Ft(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 di(e);
+}, di = async (ee) => {
+	let g = z();
+	process.env.NODE_ENV || (process.env.NODE_ENV = "production");
+	try {
+		_r();
+	} catch (e) {
+		throw Xe(e instanceof Error ? e.message : String(e));
+	}
+	let _ = process.cwd(), re = Number(process.env.PORT ?? li(ee, "--port") ?? 4e3), v = await Me(_);
+	Fn(Nn(v?.secrets)), await e({
+		rawEnv: v?.env,
+		appType: "api",
+		root: _,
+		log: $,
+		generateTypes: !1
+	}), g.mark("config");
+	let y = (process.env.DB_DIALECT ?? v?.store ?? "memory").toLowerCase(), oe = (y === "mariadb" || y === "postgres" || y === "mssql") && (process.env.CDC ?? "1") !== "0", se = y === "mariadb" ? "mariadb" : y === "mssql" ? "mssql" : void 0, le = At(_);
+	if (!s() && Rt(le)) try {
+		let e = await import(Ft(le).href);
+		if (e.modules) {
+			let t = {};
+			for (let [n, r] of Object.entries(e.modules)) t[Pt(_, n)] = r;
+			o(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 Be(_), S = await ct(x, { cdc: oe && se !== void 0 });
+	{
+		let e = /* @__PURE__ */ new Set([
+			...S.queries.filter((e) => e.descriptor.overridesPlugin === !0).map((e) => e.descriptor.name),
+			...S.mutations.filter((e) => e.descriptor.overridesPlugin === !0).map((e) => e.descriptor.name),
+			...S.actions.filter((e) => e.descriptor.overridesPlugin === !0).map((e) => e.descriptor.name)
+		]);
+		vt(St(v?.plugins ?? []), [
+			...S.queries.map((e) => e.descriptor.name),
+			...S.mutations.map((e) => e.descriptor.name),
+			...S.actions.map((e) => e.descriptor.name),
+			...S.streams.map((e) => e.descriptor.name)
+		], e);
+		let t = d(S.serverOnlyLeaks, Ke(process.env, "strict"), nn, "`voltro serve`");
+		if (t.action === "fail") throw Xe(t.message ?? "");
+		t.action === "warn" && $.warn(t.message ?? "");
+	}
+	let pe = x.filter((e) => lt.test(e)), me = pe.length > 0 ? await Le(pe, $.child("webhooks")) : {
+		outgoing: [],
+		incoming: [],
+		providers: []
+	}, ge = M(S.events), w = me.outgoing.length + me.incoming.length + me.providers.length + ge.length === 0 ? void 0 : {
+		...me,
+		outgoing: [...me.outgoing, ...ge]
+	}, xe = L({
+		mix: S.featureMix,
+		plugins: v?.plugins ?? [],
+		cdc: oe && se !== void 0,
+		...se ? { cdcDialect: se } : {}
+	}), Se = v?.analytics !== void 0 && v.analytics.kind !== "noop" && y !== "memory" ? (await i(y)).makeSqlLayer(Ze()) : void 0, E = await _t({
+		spec: v?.analytics,
+		sqlLayer: Se,
+		log: $
+	}), D = (() => {
+		let e = new Set(S.tables.map((e) => e.tableName)), t = [...S.tables];
+		for (let n of [...xe, ...E.tables]) e.has(n.tableName) || (e.add(n.tableName), t.push(n));
+		return t;
+	})();
+	for (let e of D) Yn(e);
+	{
+		let e = rn(Hn(S.queries.map((e) => ({
+			name: e.descriptor.name,
+			source: e.descriptor.source
+		})), new Set(D.flatMap((e) => {
+			let t = e.tableName;
+			return t === void 0 ? [] : [t];
+		}))));
+		e !== void 0 && $.warn(e);
+	}
+	let we = (process.env.NODE_ENV ?? "").toLowerCase();
+	if (ci(we, y, process.env.VOLTRO_AUTO_MIGRATE)) {
+		let e = (await i(y)).makeSqlLayer(Ze()), t = await B.runPromise(Kn.SqlClient.pipe(B.flatMap((e) => Cr(e, D, {
+			appliedBy: `serve:${we}`,
+			environment: "prod",
+			dialectId: y
+		})), B.provide(e)));
+		t.kind === "prod-mismatch" && ($.error(Sr(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(Sr(t, y));
+	}
+	let De = Tn(D);
+	g.mark("discover");
+	let k = await He(v, void 0), je = Wn(k, y);
+	for (let e of N({
+		dialect: String(v?.store ?? process.env.DB_DIALECT ?? "postgres"),
+		changeStrategy: (process.env.CDC ?? "1") === "0" ? "inline" : "cdc",
+		dbUrl: process.env.DB_URL,
+		tables: S.tables.map((e) => ({
+			tableName: e.tableName,
+			isReactive: e.isReactive === !0
+		})),
+		querySources: S.queries.flatMap((e) => {
+			let t = e.descriptor.source;
+			return t === void 0 ? [] : typeof t == "string" ? [t] : [...t];
+		})
+	})) e.level === "warn" ? $.warn(e.message) : $.info(e.message);
+	{
+		let e = Ye(ot({
+			tables: qn().map((e) => ({ tableName: e.tableName })),
+			queries: S.queries.map((e) => ({
+				name: e.descriptor.name,
+				source: e.descriptor.source
+			}))
+		}));
+		e !== void 0 && $.warn(e);
+	}
+	v?.cache && !process.env.CACHE_BACKEND && (process.env.CACHE_BACKEND = v.cache), v?.cacheRedisUrl && !process.env.CACHE_REDIS_URL && (process.env.CACHE_REDIS_URL = v.cacheRedisUrl), v?.cacheRedisDriver && !process.env.CACHE_REDIS_DRIVER && (process.env.CACHE_REDIS_DRIVER = v.cacheRedisDriver), v?.cacheKeyPrefix && !process.env.CACHE_KEY_PREFIX && (process.env.CACHE_KEY_PREFIX = v.cacheKeyPrefix);
+	let { service: Pe, invalidationBus: Ie, snapshotCache: ze, cache: Ve, semantic: We, evictSource: qe, backend: Je, stats: $e, dispose: tt } = await Fe({
+		env: process.env,
+		semantic: v?.cacheSemantic ?? !1
+	});
+	We !== void 0 && $.info("semantic cache enabled — reactive eviction on live writes"), $.info(`cache backend resolved: ${Je}` + (Je === "redis" ? ` (driver ${process.env.CACHE_REDIS_DRIVER ?? "resp"})` : " — in-process, not cross-instance")), k.onChange((e) => {
+		if (B.runFork(Ie.publish(e.table)), qe !== void 0) {
+			let t = (e.new ?? e.old)?.id;
+			qe({
+				table: e.table,
+				op: e.op,
+				...t === void 0 ? {} : { id: t }
+			});
+		}
+	}), v?.kv && !process.env.KV_BACKEND && (process.env.KV_BACKEND = v.kv), v?.kvRedisUrl && !process.env.KV_REDIS_URL && (process.env.KV_REDIS_URL = v.kvRedisUrl), v?.kvKeyPrefix && !process.env.KV_KEY_PREFIX && (process.env.KV_KEY_PREFIX = v.kvKeyPrefix);
+	let { kv: rt, service: it } = await mn({ store: k });
+	$.info(Ur(Ne(), Wr())), g.mark("store");
+	let st = Gt({
+		store: k,
+		sink: E.sink,
+		log: $
+	}), ht = l({
+		store: k,
+		dialect: y
+	}), F = v?.plugins ?? [], jt = process.env.POD_NAME ?? process.env.HOSTNAME ?? `serve-${process.pid}`, Mt, H;
+	y !== "memory" && (Mt = Lt.make((await i(y)).makeSqlLayer(Ze())), H = await Mt.runPromise(Kn.SqlClient));
+	let zt = hn({
+		coordinator: [
+			"postgres",
+			"mariadb",
+			"mysql",
+			"mssql"
+		].includes(y) ? un(k, jt, $) : Rn,
+		replicaId: jt,
+		log: $
+	}), Bt = [], Vt = process.env.POD_NAME ?? process.env.HOSTNAME ?? `serve-${process.pid}`, Ht = Fr(v?.plugins ?? [])?.broadcast?.provider, Ut = ut(v?.plugins, v?.name ?? Nt(_));
+	{
+		let e = Oe(v?.plugins, v?.name ?? Nt(_));
+		e !== void 0 && $.warn(e);
+	}
+	let Kt = Ae(v?.plugins, {
+		instanceId: Vt,
+		namespace: Ut,
+		meta: { mode: "serve" },
+		logger: $
+	}), qt = {
+		...H ? { sql: H } : {},
+		instanceId: Vt,
+		membership: Kt.membership,
+		...Ht === void 0 ? {} : { broadcast: Ht },
+		broadcastChannels: { presence: Pr(Ut, "presence") },
+		scheduleCoordinated: (e, t, n) => {
+			let r = zt(e, t, n);
+			return Bt.push(r), r;
+		}
+	};
+	for (let e of F) e.bindDataStore?.(k, qt);
+	j({
+		store: k,
+		...u(),
+		log: $
+	});
+	let Jt = F.filter((e) => typeof e.onChangeEvent == "function");
+	if (Jt.length > 0) {
+		let e = k.changeScope ?? "local";
+		k.onChange((t) => {
+			let n = fe(t, e);
+			for (let e of Jt) B.runFork(e.onChangeEvent(n).pipe(B.catchAllCause((t) => B.sync(() => $.warn(`plugin ${e.name} onChangeEvent failed`, { error: It.pretty(t) })))));
+		});
+	}
+	let Yt = et({
+		plugins: F,
+		appName: v?.name ?? "voltro-api",
+		appType: "api",
+		voltroVersion: process.env.npm_package_version ?? "0.0.0",
+		log: $
+	});
+	F.length && await Yt.activate(), g.mark("plugins");
+	let U = await Yt.gatherObservability(), Xt = {
+		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: () => {}
+	}, W, Zt = await Re(k, v, y, Ut, Xt, (e, t) => {
+		W?.refreshAll(`broadcast gap: missed ${t} change(s) from ${e}`);
+	}), Qt = v?.apiKeys, on = (typeof Qt == "object" ? Qt.prefix : void 0) ?? "voltro_", sn = Qt ? en(k) : void 0, cn = sn ? fn({ flush: pn(sn) }) : void 0;
+	cn && On(() => cn.shutdown());
+	let ln = sn ? dn(sn, {
+		prefix: on,
+		...cn ? { usage: cn } : {}
+	}) : void 0, gn = ln ? [an(ln, { prefix: on })] : [], _n = nt([...v?.auth?.strategies ?? [], ...gn], Ar(v?.plugins ?? []), v?.auth?.anonymousTenantRequired ?? !1, v?.auth?.resolveScopes, () => je), vn = [...v?.restRoutes ?? [], ...ln ? Wt(ln, (typeof Qt == "object" ? Qt.managementPath : void 0) ?? "/v1/api-keys") : []], yn = v?.idempotency, bn = yn ? {
+		store: tn(k),
+		header: (typeof yn == "object" ? yn.header : void 0) ?? "Idempotency-Key",
+		ttlMs: (typeof yn == "object" ? yn.ttlMs : void 0) ?? 864e5
+	} : void 0, xn = vn.length > 0 ? Mr(vn, {
+		store: k,
+		resolveSubject: async (e) => (await _n({
+			headers: e,
+			clientId: -1
+		})).subject,
+		...bn ? { idempotency: bn } : {}
+	}) : [], Sn = F.map((e) => e.services).filter((e) => e !== void 0), Cn = V.mergeAll(Te({
+		analyticsLayer: E.layer,
+		cacheService: Pe,
+		kvService: it,
+		...We === void 0 ? {} : { semanticCache: We },
+		pluginServices: Sn,
+		userLayers: v?.layers ?? []
+	}), b(v?.http ?? {})), wn = v?.scheduling ?? {}, En = wn.trigger ?? "self", G = /* @__PURE__ */ new Set([
+		"postgres",
+		"mysql",
+		"mariadb",
+		"mssql"
+	]), Dn = wn.coordination ?? (G.has(y) ? "advisoryLock" : "single"), K = Dn === "cluster" && G.has(y), An = K ? "cluster" : Dn === "advisoryLock" && G.has(y) ? "advisoryLock" : "single";
+	Dn === "cluster" && !K && $.warn("scheduling.coordination=cluster needs a sql-backed store except sqlite — falling back to single"), Dn === "advisoryLock" && !G.has(y) && $.warn("scheduling.coordination=advisoryLock needs a SQL store (the claim-row gate) — falling back to single");
+	let jn, Mn = S.workflows.length > 0 || S.workflowWorkers.length > 0 || S.eventTriggers.length > 0 || (w?.outgoing.length ?? 0) > 0 || K, Pn;
+	if (Mn) {
+		if (y === "mssql") {
+			let e = await C(process.cwd());
+			e && $.warn(e);
+		}
+		let [{ WorkflowEngine: e }, { makeClusterCronLayer: t, workflowEngineLayer: n, resolveRunnerStorage: r, resolveFailoverTuning: a }] = await Promise.all([import("@effect/workflow"), import("@voltro/workflow/cluster")]), o = K ? S.schedules.filter((e) => (e.trigger ?? En) === "self").map((e) => t({
+			name: e.name,
+			cron: $t(e),
+			execute: async () => {
+				await jn?.fireFromCluster(e.name);
+			}
+		})) : [];
+		Pn = y === "memory" ? e.layerMemory : await (async () => {
+			let e = await i(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(Ze()),
+				runnerStorage: t,
+				dialectId: e.id,
+				...process.env.VOLTRO_WORKFLOW_RUNNER_PORT ? { runnerListenPort: Number(process.env.VOLTRO_WORKFLOW_RUNNER_PORT) } : {},
+				...a(),
+				...o.length > 0 ? { extraShardingLayers: o } : {}
+			});
+		})();
+	}
+	let In = ie(F, n()), Ln = x.filter((e) => /\.subscribe\.tsx?$/.test(e)), zn = Ln.length > 0 ? await ae(Ln, $) : [], Bn = x.filter((e) => /\.reaction\.tsx?$/.test(e)), Vn = Bn.length > 0 ? await m(Bn, $) : [], Un = x.filter((e) => Et.test(e)), Gn = Un.length > 0 ? await ue(Un, $) : [], Jn = x.filter((e) => /\.aggregate\.tsx?$/.test(e)), q = Jn.length > 0 ? await ye(Jn, $) : [], Xn = ne();
+	if (q.length > 0 && y !== "memory") try {
+		Xn = pt((await i(y)).makeSqlLayer(Ze()));
+	} catch (e) {
+		$.warn("aggregate: SQL storage init failed — falling back to in-process", { err: String(e) });
+	}
+	let Zn = y === "memory" ? Rn : un(k, `aggregate@${process.pid}`, $), Qn = x.filter((e) => R.test(e)), $n = Qn.length > 0 ? await dt(Qn, $) : [], er = x.filter((e) => Tt.test(e)), tr = er.length > 0 ? await ke(er, $) : [], nr = x.filter((e) => wt.test(e)), rr = nr.length > 0 ? await gt(nr, $) : [], J = [], ir = [], ar = x.filter((e) => xt.test(e));
+	if (ar.length > 0) {
+		let e = $.child("agent"), t = x.filter((e) => yt.test(e));
+		t.length > 0 && await I(t, e);
+		let n = await bt(ar, e);
+		for (let e of n.agents) for (let t of Ce(e)) (t.kind === "action" ? J : ir).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) });
+	}
+	g.mark("workflow");
+	let Y = () => {
+		let e = Z.workflowWriteActions();
+		if (e === void 0) throw Error("workflow actions: this app registers no workflows");
+		return e;
+	}, X = await Ee({
+		files: x,
+		store: k,
+		log: $,
+		seedPolicy: "report",
+		seedPattern: a,
+		loadSeedFiles: r,
+		startupPattern: Ct,
+		loadStartupFiles: kt,
+		runStartups: Ot,
+		emailPattern: he,
+		loadEmailFiles: c,
+		registerEmailTemplates: Nr
+	});
+	(X.startupCount > 0 || X.emailCount > 0) && $.info("boot lifecycle", {
+		startups: X.startupCount,
+		emailTemplates: X.emailCount
+	}), X.startups !== void 0 && On(async () => {
+		await X.startups.stop();
+	});
+	let or = {
+		kind: "api",
+		meta: {
+			name: v?.name ?? "voltro-api",
+			voltroVersion: at,
+			port: re,
+			mode: "start",
+			store: y,
+			cdc: oe ? "on" : "off"
+		},
+		rpc: O(S, _),
+		workflows: Qe(S, _),
+		events: () => Z.eventsSnapshot(),
+		members: () => Z.membersSnapshot(),
+		inspectFireSchedule: async ({ name: e, trigger: t }) => {
+			if (!jn) throw Error("scheduler not started — this app registers no self-triggered schedules (all schedules are trigger:'external', or there are none).");
+			return { runId: await jn.fireNow(e, t) ?? null };
+		},
+		...w === void 0 ? {} : { webhooks: () => Ge({
+			store: k,
+			discoveredWebhooks: w
+		}) },
+		plugins: () => ({
+			plugins: Yt.snapshot(),
+			capturedAt: Date.now()
+		}),
+		env: () => t(v?.name ?? Nt(_), {
+			...v?.env !== void 0 && gr(v.env) ? { contract: v.env } : {},
+			plugins: v?.plugins ?? []
+		}),
+		dataCache: () => ve({
+			stats: $e,
+			backendKind: Je
+		}),
+		subscriptions: () => te(() => W),
+		inspectTables: () => ce(S.tables),
+		inspectRows: _e({
+			store: k,
+			tables: S.tables,
+			mask: !0
+		}),
+		metrics: (e) => Z.rpcMetrics().snapshot(e),
+		cluster: () => mt({
+			store: k,
+			dialect: y,
+			useClusterCron: K,
+			scheduleCoordChoice: Dn
+		}),
+		inspectSchedules: () => p({
+			schedules: S.schedules,
+			defaultTrigger: En,
+			coordination: An
+		}),
+		inspectScheduleRuns: (e) => h(k, e),
+		...be(k, {
+			controls: A(S.workflows ?? []),
+			active: (S.workflows?.length ?? 0) > 0,
+			cancellation: () => Z.flowControlHealth()
+		}),
+		webhookActions: ft(() => Z.webhooksService()),
+		inspectStartWorkflow: (e) => Y().inspectStartWorkflow(e),
+		inspectCancelWorkflowRun: (e) => Y().inspectCancelWorkflowRun(e),
+		inspectSuspendWorkflowRun: (e) => Y().inspectSuspendWorkflowRun(e),
+		inspectResumeWorkflowRun: (e) => Y().inspectResumeWorkflowRun(e),
+		inspectDiscardWorkflowRun: (e) => Y().inspectDiscardWorkflowRun(e),
+		inspectRetryWorkflowRun: (e) => Y().inspectRetryWorkflowRun(e),
+		inspectSignalWorkflowRun: (e) => Y().inspectSignalWorkflowRun(e),
+		inspectUpdateWorkflowRun: (e) => Y().inspectUpdateWorkflowRun(e),
+		inspectInferences: (e) => Ue({
+			store: k,
+			active: (S.workflows?.length ?? 0) > 0,
+			dispatcher: () => Z.inferenceHealth()
+		}, e.limit === void 0 ? {} : { limit: e.limit }),
+		...P({
+			store: k,
+			cancelRun: async (e) => await Z.runCanceller()?.(e) ?? !1,
+			retryRun: async (e) => Y().inspectRetryWorkflowRun({ runId: e }),
+			redriveRun: async (e) => Z.redriveWorkflowRun({ runId: e }),
+			log: $
+		}),
+		inspectRedriveWorkflowRun: (e) => Z.redriveWorkflowRun(e),
+		inspectResumeWorkflowRunFromStep: (e) => Z.resumeWorkflowRunFromStep(e)
+	}, Z = await si({
+		bootTiming: g,
+		broadcastNamespace: Ut,
+		membership: {
+			...Kt,
+			instanceId: Vt
+		},
+		...v?.plugins === void 0 ? {} : { plugins: v.plugins },
+		...bn ? { idempotency: {
+			store: bn.store,
+			ttlMs: bn.ttlMs
+		} } : {},
+		discovered: {
+			queries: [...S.queries, ...ir],
+			mutations: S.mutations,
+			actions: [...S.actions, ...J],
+			streams: S.streams,
+			events: S.events,
+			workflows: S.workflows,
+			workflowWorkers: S.workflowWorkers,
+			eventTriggers: S.eventTriggers,
+			schedules: S.schedules,
+			subscribers: zn,
+			outboxHandlers: Gn,
+			connections: S.connections,
+			reactions: Vn,
+			aggregates: q,
+			expectations: $n,
+			budgets: tr,
+			experiments: rr,
+			...w === void 0 ? {} : { webhooks: w }
+		},
+		log: $,
+		analytics: E.sink,
+		aggregateStorage: Xn,
+		aggregateCoordinator: Zn,
+		store: k,
+		kv: rt,
+		cache: Ve,
+		snapshotCache: ze,
+		schemaRegistry: De,
+		tenantScopedTables: S.tenantScopedTables,
+		softDeleteScopedTables: S.softDeleteScopedTables,
+		dataTransferSnapshot: xr(D),
+		dataTransferDialect: y,
+		tenantIsolation: (process.env.VOLTRO_TENANT_ISOLATION ?? v?.tenancy?.isolation) === "namespace" ? "namespace" : "shared-schema",
+		resolveSubject: async (e, t) => {
+			let n = await _n({
+				headers: e,
+				clientId: t
+			});
+			return kn(t, n.credentialExpiresAt), n.subject;
+		},
+		httpRoutes: [...F.flatMap((e) => e.httpRoutes ?? []), ...xn],
+		getStore: () => je,
+		...Cn ? { baseLayer: Cn } : {},
+		...Pn === void 0 ? {} : { workflowEngineLayer: Pn },
+		scheduleDefaultTrigger: En,
+		scheduleCoordination: An,
+		scheduleArmSelf: !K,
+		dormancy: process.env.VOLTRO_DORMANCY === "sleep" || process.env.VOLTRO_DORMANCY === "always-on" ? process.env.VOLTRO_DORMANCY : v?.dormancy ?? "always-on",
+		scheduleReplicaId: process.env.HOSTNAME ?? `pid-${process.pid}`,
+		...In === void 0 ? {} : { scheduleFireInterceptor: In },
+		onSchedulerReady: (e) => {
+			jn = e;
+		},
+		inspectRoute: { handle: async (e, t, n, r) => await de(e, or, t, {
+			method: n,
+			...r === void 0 ? {} : { body: r }
+		}) || (Dt(e, or, t, {
+			method: n,
+			...r === void 0 ? {} : { body: r }
+		}) ?? {
+			status: 404,
+			contentType: "application/json",
+			body: JSON.stringify({ error: "not an inspect route" })
+		}) },
+		...v?.name === void 0 ? {} : { appName: v.name },
+		observability: U,
+		port: re,
+		...v?.transport?.wsPath ? { path: v.transport.wsPath } : {}
+	});
+	return W = Z.dispatcher, T(f([
+		S.queries,
+		S.mutations,
+		S.actions,
+		S.streams
+	]), (e) => {
+		$.warn(e);
+	}), $.info(`API listening on :${re}`, {
+		dialect: y,
+		queries: S.queries.length,
+		mutations: S.mutations.length,
+		actions: S.actions.length,
+		streams: S.streams.length,
+		workflows: S.workflows.length,
+		workflowWorkers: S.workflowWorkers.length,
+		schedules: S.schedules.length,
+		scheduleCoordination: An
+	}), g.finish($), On(async () => {
+		for (let e of Bt) e.stop();
+		st.detach(), ht.stop(), tt(), Mt?.dispose();
+		try {
+			await Yt.deactivate(), await Zt?.close(), await E.dispose(), await Z.close(), await k.close?.();
+		} catch (e) {
+			console.error("serve: shutdown step failed, exiting anyway:", e);
+		}
+	}), await new Promise(() => {}), 0;
+};
+//#endregion
+export { ui as n, ii as r, di as t };