@voltro/cli 0.50.1 → 0.52.0

package/dist/start-jw89Xbqy.js

@@ -0,0 +1,1339 @@
+import { i as e, t } from "./nodeEnvironment-cGFAj1J8.js";
+import { r as n } from "./appPort-B_HpJ_ck.js";
+import { $ as r, A as i, At as a, B as o, C as s, Dt as c, E as l, F as u, G as d, H as f, I as p, J as m, K as h, L as g, M as _, N as v, O as ee, P as y, S as b, T as x, Y as S, a as C, at as te, b as w, c as ne, ct as T, dt as re, et as E, f as D, ft as ie, it as ae, j as oe, k as se, mt as O, n as ce, nt as k, o as le, p as ue, pt as A, q as de, rt as fe, tt as pe, w as me, x as j, z as M } from "./webDev-BgWL9gKV.js";
+import { o as N, t as P } from "./connectionConfig-Bk9IC7D0.js";
+import { A as he, D as F, a as ge, h as _e, j as ve, k as I } from "./inspect-CtL_xTbu.js";
+import { n as ye, r as be, t as xe } from "./inspectMetrics-CGF94puw.js";
+import { a as Se, c as L, d as Ce, f as we, l as Te, p as R, u as Ee } from "./renderModeScan-CcH2X1_D.js";
+import { i as De, n as Oe, r as ke, t as Ae } from "./runtimeRegistry-DMeKfTHP.js";
+import { n as je } from "./logFileSink-B4uP8pvf.js";
+import { t as Me } from "./bootTiming-BdyP9nYw.js";
+import { dirname as Ne, extname as Pe, join as z, resolve as B } from "node:path";
+import { promises as V } from "node:fs";
+import { fileURLToPath as H, pathToFileURL as U } from "node:url";
+import { createLogger as W, printReadyBlock as Fe } from "@voltro/logger";
+import { Effect as Ie } from "effect";
+import { maybeCompress as Le, snapshotMetricsSync as Re } from "@voltro/runtime";
+import { createHash as ze } from "node:crypto";
+import { resolveBroadcastProvider as Be } from "@voltro/plugin-broadcast";
+import { createServer as Ve } from "node:http";
+//#region src/httpResponseWrite.ts
+var G = (e) => `W/"${ze("md5").update(e).digest("hex")}"`, He = (e) => {
+	let { response: t, status: n, headers: r, body: i, requestHeaders: a } = e, o = r["cache-control"], s = (typeof o == "string" ? o : "").toLowerCase();
+	if (i === void 0 || n !== 200 || s.includes("no-store")) return !1;
+	let c = r["content-type"], l = typeof c == "string" ? c : void 0, u = G(i), d = a["if-none-match"];
+	if (d !== void 0 && d.split(",").some((e) => e.trim() === u)) return t.writeHead(304, {
+		...r,
+		etag: u
+	}), t.end(), !0;
+	let f = Le({
+		body: typeof i == "string" ? new TextEncoder().encode(i) : new Uint8Array(i),
+		contentType: l,
+		acceptEncoding: a["accept-encoding"],
+		options: e.compression
+	}), p = {
+		...r,
+		...f.headers,
+		etag: u
+	};
+	return f.compressed && delete p["content-length"], t.writeHead(n, p), t.end(Buffer.from(f.bytes)), !0;
+}, K = W({ scope: "voltro:start:cdc" }), Ue = (e) => (t) => {
+	let n = 0;
+	for (let [r, i] of e.tableSubscriptionsByPattern) {
+		if (!i.includes(t)) continue;
+		let a = e.regexByPattern.get(r);
+		a && (n += e.cache.invalidateBy((e) => {
+			let t = e.split("|")[0] ?? e;
+			return a.test(t);
+		}));
+	}
+	return n;
+}, q = () => P() ? N() : null, We = (e) => {
+	let t = e.channel ?? "framework_changes", n = e.revalidateChannel ?? "voltro_revalidate", r = Ue(e), i = null, a = null;
+	return {
+		start: async () => {
+			let o = e.tableSubscriptionsByPattern.size > 0, s = e.onRevalidate !== void 0;
+			if (!o && !s) return K.debug("skipped — no pages declare cacheInvalidatesOn and no revalidation handler is wired"), !1;
+			let c = q();
+			if (!c && !o) return K.debug("no database configured — the revalidation LISTEN line is unavailable"), !1;
+			if (!c) return K.warn(`${e.tableSubscriptionsByPattern.size} route(s) declare \`cacheInvalidatesOn\` and will NOT be invalidated live — no database is configured for this web process. Set DB_URL (or DB_HOST / PG_HOST) so the CDC listener can connect; until then those routes go stale until their \`revalidate\` window expires.`, { routes: [...e.tableSubscriptionsByPattern.keys()] }), !1;
+			i = new (await (import("pg"))).default.Client(c), await i.connect(), a = (i) => {
+				if (i.channel === n && i.payload && e.onRevalidate) {
+					e.onRevalidate(i.payload);
+					return;
+				}
+				if (i.channel !== t || !i.payload) return;
+				let a;
+				try {
+					a = JSON.parse(i.payload);
+				} catch (e) {
+					K.warn("bad CDC payload", {}, e);
+					return;
+				}
+				let o = r(a.table);
+				o > 0 && K.info(`${a.op} on '${a.table}' → dropped ${o} cache entries`, {
+					op: a.op,
+					table: a.table,
+					dropped: o
+				});
+			}, i.on("notification", a), o && await i.query(`LISTEN ${t}`), s && await i.query(`LISTEN ${n}`);
+			let l = [...o ? [t] : [], ...s ? [n] : []];
+			return K.info(`LISTEN ${l.join(", ")}`, {
+				channels: l,
+				..."connectionString" in c ? { target: c.connectionString.replace(/\/\/[^@/]*@/, "//") } : {
+					host: c.host,
+					port: c.port,
+					database: c.database
+				}
+			}), !0;
+		},
+		stop: async () => {
+			if (i) {
+				try {
+					a && i.off("notification", a), await i.end();
+				} catch {}
+				i = null, a = null;
+			}
+		}
+	};
+}, Ge = W({ scope: "voltro:start:isr-cache" }), J = "voltro_isr_cache", Ke = (e) => `
+CREATE TABLE IF NOT EXISTS ${e} (
+  cache_key                TEXT PRIMARY KEY,
+  html                     TEXT NOT NULL,
+  rendered_at              BIGINT NOT NULL,
+  expires_at               BIGINT NOT NULL,
+  servable_until           BIGINT NOT NULL,
+  revalidate_ms            BIGINT NOT NULL,
+  stale_while_revalidate_ms BIGINT NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS ${e}_servable_until_idx ON ${e} (servable_until);
+`, qe = (e) => {
+	let t = e.tableName ?? J, { client: n } = e, r = /* @__PURE__ */ new Map(), i = !1, a = (async () => {
+		i || (i = !0, await n.query(Ke(t)));
+	})().then(async () => {
+		let e = await n.query(`SELECT * FROM ${t}`);
+		for (let t of e.rows) r.set(t.cache_key, {
+			html: t.html,
+			renderedAt: Number(t.rendered_at),
+			expiresAt: Number(t.expires_at),
+			servableUntil: Number(t.servable_until),
+			revalidateMs: Number(t.revalidate_ms),
+			staleWhileRevalidateMs: Number(t.stale_while_revalidate_ms)
+		});
+	}).catch((e) => {
+		Ge.warn("postgres bootstrap failed", {}, e);
+	}), o = (e, t) => {
+		a.then(() => n.query(e, t)).catch((e) => {
+			Ge.warn("postgres write failed", {}, e);
+		});
+	}, s = /* @__PURE__ */ new Map(), c = (e) => {
+		s.set(e, (s.get(e) ?? 0) + 1);
+	};
+	return {
+		get(e) {
+			return r.get(e);
+		},
+		set(e, n, i) {
+			return i?.ifGeneration !== void 0 && (s.get(e) ?? 0) !== i.ifGeneration ? !1 : (r.set(e, n), o(`INSERT INTO ${t}
+           (cache_key, html, rendered_at, expires_at, servable_until, revalidate_ms, stale_while_revalidate_ms)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)
+         ON CONFLICT (cache_key) DO UPDATE SET
+           html = EXCLUDED.html,
+           rendered_at = EXCLUDED.rendered_at,
+           expires_at = EXCLUDED.expires_at,
+           servable_until = EXCLUDED.servable_until,
+           revalidate_ms = EXCLUDED.revalidate_ms,
+           stale_while_revalidate_ms = EXCLUDED.stale_while_revalidate_ms`, [
+				e,
+				n.html,
+				n.renderedAt,
+				n.expiresAt,
+				n.servableUntil,
+				n.revalidateMs,
+				n.staleWhileRevalidateMs
+			]), !0);
+		},
+		generation(e) {
+			return s.get(e) ?? 0;
+		},
+		invalidate(e) {
+			r.delete(e), c(e), o(`DELETE FROM ${t} WHERE cache_key = $1`, [e]);
+		},
+		invalidateBy(e) {
+			let n = 0, i = [];
+			for (let t of r.keys()) e(t) && (r.delete(t), c(t), i.push(t), n++);
+			return i.length > 0 && o(`DELETE FROM ${t} WHERE cache_key = ANY($1)`, [i]), n;
+		},
+		clear() {
+			for (let e of r.keys()) c(e);
+			r.clear(), o(`DELETE FROM ${t}`, []);
+		},
+		size() {
+			return r.size;
+		},
+		snapshot() {
+			return Array.from(r.entries());
+		}
+	};
+}, Y = W({ scope: "voltro:start:revalidate" }), Je = (e) => {
+	try {
+		let t = JSON.parse(e);
+		return (t.kind === "path" || t.kind === "table" || t.kind === "tag") && typeof t.value == "string" && t.value.length > 0 && (t.tenant === void 0 || typeof t.tenant == "string") ? {
+			kind: t.kind,
+			value: t.value,
+			...t.tenant === void 0 ? {} : { tenant: t.tenant }
+		} : (Y.warn("bad revalidation payload (shape)", { payload: e }), null);
+	} catch {
+		return Y.warn("bad revalidation payload (not JSON)", { payload: e }), null;
+	}
+}, Ye = (e, t) => {
+	if (t.kind === "table" || t.kind === "tag") {
+		let n = e.tableSink(t.value);
+		return Y.info(`revalidate ${t.kind} '${t.value}' → dropped ${n} cache entries`, {
+			kind: t.kind,
+			value: t.value,
+			dropped: n
+		}), n;
+	}
+	let n = t.value, r = (e) => t.tenant === void 0 || e.split("|").includes(`tenant=${t.tenant}`), i = e.regexByPattern.get(n);
+	if (i !== void 0) {
+		let a = e.renderModeByPattern.get(n);
+		if (a !== "isr") return Y.error(`revalidatePath('${n}') targets a '${a ?? "unknown"}' route — only \`renderMode: 'isr'\` routes have cache entries to drop. Static HTML is a build artifact this process never re-renders; rebuild to change it.`, {
+			path: n,
+			renderMode: a ?? "unknown"
+		}), 0;
+		let o = e.cache.invalidateBy((e) => {
+			let t = e.split("|")[0] ?? e;
+			return i.test(t) && r(e);
+		});
+		return Y.info(`revalidate path pattern '${n}' → dropped ${o} cache entries`, {
+			path: n,
+			dropped: o,
+			...t.tenant === void 0 ? {} : { tenant: t.tenant }
+		}), o;
+	}
+	let a = [...e.regexByPattern.entries()].find(([, e]) => e.test(n));
+	if (a === void 0) return Y.error(`revalidatePath('${n}') matches no declared route — nothing was dropped. Pass a declared route pattern (e.g. /blog/[slug]) or a concrete path of one.`, { path: n }), 0;
+	let o = e.renderModeByPattern.get(a[0]);
+	if (o !== "isr") return Y.error(`revalidatePath('${n}') targets a '${o ?? "unknown"}' route (${a[0]}) — only \`renderMode: 'isr'\` routes have cache entries to drop.`, {
+		path: n,
+		route: a[0],
+		renderMode: o ?? "unknown"
+	}), 0;
+	let s = e.cache.invalidateBy((e) => (e.split("|")[0] ?? e) === n && r(e));
+	return Y.info(`revalidate path '${n}' → dropped ${s} cache entries`, {
+		path: n,
+		dropped: s,
+		...t.tenant === void 0 ? {} : { tenant: t.tenant }
+	}), s;
+}, X = W({ scope: "voltro:start" }), Xe = await (async () => {
+	try {
+		let e = z(Ne(H(import.meta.url)), "..", "package.json"), t = await V.readFile(e, "utf8");
+		return JSON.parse(t).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})(), Ze = (e) => e instanceof Error && e._voltroControl === "redirect" && typeof e.location == "string", Qe = (e) => e instanceof Error && e._voltroControl === "not-found", Z = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript",
+	".mjs": "application/javascript",
+	".css": "text/css",
+	".json": "application/json",
+	".xml": "application/xml; charset=utf-8",
+	".rss": "application/rss+xml; charset=utf-8",
+	".atom": "application/atom+xml; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".txt": "text/plain; charset=utf-8"
+}, $e = (e) => Z[Pe(e).toLowerCase()] ?? "application/octet-stream", et = (e) => e.replace(/<script\b(?=[^>]*\btype="module")(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<script\b(?=[^>]*\bsrc=)(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<link\b[^>]*\brel="modulepreload"[^>]*>/gi, ""), Q = async (e) => {
+	try {
+		return await V.stat(e), !0;
+	} catch {
+		return !1;
+	}
+}, tt = (e) => {
+	let t = [], n = 0, r = e.split("/").filter(Boolean), i = [];
+	for (let e of r) e.startsWith("[[...") && e.endsWith("]]") ? (i.push("(.*)"), t.push(e.slice(5, -2)), n += 2) : e.startsWith("[...") && e.endsWith("]") ? (i.push("(.+)"), t.push(e.slice(4, -1)), n += 3) : e.startsWith("[") && e.endsWith("]") ? (i.push("([^/]+)"), t.push(e.slice(1, -1)), n += 1) : i.push(e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+	let a = i.join("/");
+	return {
+		regex: a.length === 0 ? /^\/?$/ : RegExp(`^/${a}/?$`),
+		paramNames: t,
+		priority: n
+	};
+}, nt = (e) => e.map((e) => {
+	let { regex: t, paramNames: n, priority: r } = tt(e.pattern);
+	return {
+		pattern: e.pattern,
+		file: e.file,
+		dirChain: e.dirChain,
+		regex: t,
+		paramNames: n,
+		priority: r
+	};
+}).slice().sort((e, t) => e.priority - t.priority), rt = (e, t) => {
+	for (let n of t) {
+		let t = n.regex.exec(e);
+		if (!t) continue;
+		let r = {};
+		for (let e = 0; e < n.paramNames.length; e++) r[n.paramNames[e]] = t[e + 1] ?? "";
+		return {
+			route: n,
+			params: r
+		};
+	}
+	return null;
+}, it = async (e) => {
+	let { provider: t, route: n, params: r, pathname: a, dirs: o, shellTemplate: c, requestHeaders: l, requestUrl: d = "", apiOrigin: f, apiName: m } = e, { search: h } = ae(d), g = await se(i(e.middlewares ?? [], {
+		route: n.pattern,
+		pathname: a
+	}), {
+		pathname: a,
+		search: h,
+		headers: l,
+		cookies: ee(l.cookie),
+		route: n.pattern
+	}, e.onCookieWarning), S = await t.getPage(n.pattern, n.file), w = L(S, n.file), T = w === "isr" ? s(g.headers) : g.headers, re = C(f, T.cookie, {
+		apiName: m,
+		headers: T
+	}), D = w === "spa" && ne(o, n.dirChain).some((e) => e.hasLayout);
+	if (w !== "ssr" && w !== "isr" && !D) return null;
+	let ie = ne(o, n.dirChain), oe = {}, O = null, ce, ue = new AbortController();
+	try {
+		(await t.getHelpers()).beginStoreSeeds(), {chain: ce, segmentLoaderData: oe} = await le({
+			entries: ie,
+			loadLayout: (e) => t.getLayout(e.dir),
+			loadError: (e) => t.getError(e.dir),
+			loadPending: (e) => t.getPending(e.dir),
+			ctx: {
+				params: r,
+				pathname: a,
+				search: h,
+				signal: ue.signal,
+				headers: T,
+				query: re,
+				isServer: !0
+			}
+		}), typeof S.loader == "function" && !D && (O = await S.loader({
+			params: r,
+			pathname: a,
+			search: h,
+			signal: ue.signal,
+			headers: T,
+			query: re,
+			isServer: !0
+		}));
+	} catch (e) {
+		if (Ze(e)) return {
+			control: "redirect",
+			status: e.status,
+			location: e.location,
+			setCookies: g.setCookies,
+			responseHeaders: g.responseHeaders
+		};
+		if (Qe(e)) return {
+			control: "not-found",
+			setCookies: g.setCookies,
+			responseHeaders: g.responseHeaders
+		};
+		throw e;
+	}
+	let A = await t.getHelpers();
+	D || await _({
+		pageMod: S,
+		params: r,
+		query: re,
+		apiName: m,
+		seed: A.seedPreloadedSubscription,
+		seedFailure: A.seedPreloadedSubscriptionFailure,
+		onError: ({ tag: e, apiName: t }, n) => X.warn("preload seed failed", {
+			tag: e,
+			apiName: t,
+			pathname: a
+		}, n)
+	});
+	let de = {
+		pattern: n.pattern,
+		Component: S.default,
+		meta: S.meta,
+		loader: S.loader,
+		ErrorBoundary: S.ErrorBoundary,
+		Pending: S.Pending,
+		renderMode: w,
+		chain: ce
+	};
+	if (w === "isr" && g.cspNonce !== void 0) throw Error(`page '${n.pattern}' is renderMode 'isr' while middleware.ts mints a cspNonce — an isr render is CACHED and a cached nonce is a lie the browser enforces. Use renderMode 'ssr' for nonce'd pages, or a hash-based CSP for isr.`);
+	let me = {
+		cookies: w === "isr" ? b(g.cookies) : g.cookies,
+		headers: T,
+		url: d,
+		...e.formFlash === void 0 ? {} : { formFlash: e.formFlash }
+	}, j = A.i18n?.resolve(T.cookie, T["accept-language"]), M = {
+		lang: j?.locale ?? me.cookies["voltro:locale"] ?? "en",
+		...j?.timeZone === void 0 ? {} : { timeZone: j.timeZone },
+		renderedAt: Date.now()
+	}, N = S.interactive ?? "full";
+	if (D) {
+		let e = pe({
+			helpers: A,
+			page: n.pattern,
+			interactive: N,
+			delivery: "stream",
+			renderInput: {
+				descriptor: de,
+				params: r,
+				pathname: a,
+				search: h,
+				segmentLoaderData: oe,
+				requestContext: me,
+				...j ? {
+					outerWrap: j.outerWrap,
+					locale: j.locale
+				} : {}
+			}
+		}), t = (t) => fe({
+			helpers: A,
+			prepared: e,
+			meta: t,
+			interactive: N
+		});
+		if (e.hasDeferred) {
+			let n = u({ shell: c });
+			return {
+				renderMode: "spa",
+				setCookies: g.setCookies,
+				responseHeaders: g.responseHeaders,
+				stream: (r) => p({
+					res: r,
+					shell: n,
+					documentAttrs: M,
+					headers: {
+						...g.responseHeaders,
+						"content-type": "text/html; charset=utf-8",
+						"x-voltro-rendered-by": "spa",
+						...x(g.setCookies)
+					},
+					headInjection: t,
+					render: (t) => A.renderPageToStream({
+						...e.renderInput,
+						...t
+					}),
+					onShellError: (e) => {
+						X.error("spa layout shell render failed", { pathname: a }, e), r.writeHead(500, { "content-type": "text/plain; charset=utf-8" }), r.end("server error");
+					}
+				})
+			};
+		}
+		let i = k({
+			helpers: A,
+			prepared: e
+		});
+		return {
+			html: v(y(c.replace("<div id=\"root\"></div>", `<div id="root">${i.body}</div>`), t(i.meta)), M),
+			renderMode: "spa",
+			revalidateMs: null,
+			setCookies: g.setCookies,
+			responseHeaders: g.responseHeaders
+		};
+	}
+	let P = E({
+		helpers: A,
+		page: n.pattern,
+		pathname: a,
+		renderMode: w,
+		interactive: N,
+		loaderData: O,
+		segmentLoaderData: oe,
+		pageLoaderRan: typeof S.loader == "function"
+	}), he = {
+		descriptor: de,
+		params: r,
+		pathname: a,
+		search: h,
+		loaderData: P.loaderData,
+		segmentLoaderData: P.segmentLoaderData,
+		requestContext: me,
+		...j ? {
+			outerWrap: j.outerWrap,
+			locale: j.locale
+		} : {}
+	}, F = (e) => [
+		A.renderMetaToHtml(e),
+		`<meta name="voltro-interactive" content="${N}" />`,
+		...P.hasDeferred ? [A.renderDeferredRegistryScript()] : [],
+		A.renderRouterStateScript(P.stateInput)
+	].filter((e) => e.length > 0).join("\n    ");
+	if (w === "ssr" && N === "full" && e.buffered !== !0) {
+		let e = u({ shell: c });
+		return {
+			renderMode: "ssr",
+			setCookies: g.setCookies,
+			stream: (t) => p({
+				res: t,
+				shell: e,
+				documentAttrs: M,
+				headers: {
+					...g.responseHeaders,
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "ssr",
+					...x(g.setCookies)
+				},
+				headInjection: F,
+				render: (e) => A.renderPageToStream({
+					...he,
+					...e,
+					...g.cspNonce === void 0 ? {} : { nonce: g.cspNonce }
+				}),
+				onShellError: (e) => {
+					X.error("ssr shell render failed", { pathname: a }, e), t.writeHead(500, { "content-type": "text/plain; charset=utf-8" }), t.end("server error");
+				}
+			})
+		};
+	}
+	let { html: ge, meta: _e } = A.renderPageToHtml(he), ve = F(_e), I = v(y(c.replace("<div id=\"root\"></div>", `<div id="root">${ge}</div>`), ve), M);
+	N === "none" && (I = et(I));
+	let ye = w === "isr" ? R(S.revalidate) : null;
+	return {
+		html: g.cspNonce === void 0 ? I : te(I, g.cspNonce),
+		renderMode: w,
+		revalidateMs: ye,
+		setCookies: g.setCookies,
+		responseHeaders: g.responseHeaders
+	};
+}, $ = (e) => e === "" ? "/" : e, at = async (e) => {
+	let t = await import(U(e).href);
+	return {
+		kind: "bundle",
+		getPageMeta: () => t.pageMeta,
+		async getPage(e, n) {
+			let r = t.pages[e];
+			if (!r) throw Error(`[voltro start] ssr bundle missing page for pattern ${e}`);
+			return typeof r == "function" ? await r() : r;
+		},
+		async getLayout(e) {
+			let n = t.layouts[$(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing layout for dir ${$(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getError(e) {
+			let n = t.errors[$(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing error for dir ${$(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getPending(e) {
+			let n = t.pendings[$(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing pending for dir ${$(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getHelpers() {
+			return t.helpers;
+		},
+		async close() {}
+	};
+}, ot = async (e, t) => {
+	let n = await a("vite", () => import("vite")), r = (await import("@vitejs/plugin-react")).default, i = (await import("@tailwindcss/vite")).default, o = await n.createServer({
+		root: t,
+		envPrefix: "__VOLTRO_VITE_ENV_DISABLED__",
+		plugins: [r(), i()],
+		resolve: { dedupe: [
+			"react",
+			"react-dom",
+			"react-intl",
+			"@voltro/i18n"
+		] },
+		ssr: { noExternal: ["react-intl", "@voltro/i18n"] },
+		server: {
+			middlewareMode: !0,
+			hmr: !1
+		},
+		appType: "custom",
+		logLevel: "warn"
+	}), s = z(e, "src", "pages"), c = (e) => e === "" ? s : z(s, e), l = A({
+		limit: O(),
+		onColdStart: (e) => X.debug("ssr cold-compile start", { id: e }),
+		onColdEnd: (e, { durationMs: t, failed: n }) => X.debug(`ssr cold-compile ${n ? "FAILED" : "end"} ${t}ms`, {
+			id: e,
+			ms: t,
+			...n ? { failed: !0 } : {}
+		})
+	}), u = (e) => l.load(e, async () => await o.ssrLoadModule(e));
+	return {
+		kind: "middleware",
+		async getPage(e, t) {
+			return u(z(s, t));
+		},
+		async getLayout(e) {
+			return u(z(c(e), "layout.tsx"));
+		},
+		async getError(e) {
+			return u(z(c(e), "error.tsx"));
+		},
+		async getPending(e) {
+			return u(z(c(e), "loading.tsx"));
+		},
+		async getHelpers() {
+			return await u("@voltro/web/ssr");
+		},
+		async close() {
+			await o.close();
+		}
+	};
+}, st = async (t) => {
+	let a = Me(), s = await D(t);
+	if (!s) return {
+		ran: !1,
+		exitCode: 0
+	};
+	if (s.type !== "web") return X.error("only web apps are supported by `voltro start`"), {
+		ran: !0,
+		exitCode: 1
+	};
+	let { resolved: u } = await c({
+		rawEnv: s.env,
+		appType: "web",
+		root: t,
+		log: X,
+		generateTypes: !1
+	}), p = u.publicValues;
+	a.mark("config");
+	let _ = m();
+	d(_), X.info("booting voltro start", { app: s.name ?? "(unnamed)" });
+	let v = n({
+		kind: "web",
+		configPort: s.port,
+		env: process.env,
+		dashboardPin: process.env[g] === "1"
+	});
+	for (let e of v.warnings) X.warn(e);
+	let y = v.port, b = z(t, ".framework"), x = z(b, "dist"), te = z(x, "index.html");
+	if (!await Q(te)) return X.error("no built dist found — run `voltro build` first", { distDir: x }), {
+		ran: !0,
+		exitCode: 1
+	};
+	let E = s.name ?? "unnamed", O = Ae("web", E, y), k = je(E);
+	await De({
+		id: O,
+		name: E,
+		kind: "web",
+		url: `http://localhost:${y}`,
+		pid: process.pid,
+		status: "booting",
+		logFile: k.path
+	}).catch(() => {});
+	let le = z(x, "_voltro", "shell.html"), A = await Q(le) ? await V.readFile(le, "utf8") : await V.readFile(te, "utf8"), fe = await ue(t, s), pe = ye(s), L = ce(fe[0]), R = fe[0]?.name, Ne = /* @__PURE__ */ new Set(), Pe = (e) => {
+		Ne.has(e.name) || (Ne.add(e.name), X.warn(`middleware.ts wrote the cookie "${e.name}" with the HttpOnly default — a browser SDK cannot read it`, {
+			cookie: e.name,
+			hint: "If your IdP client reads this from `document.cookie` (Supabase's `createBrowserClient` does), pass `httpOnly: false`. Otherwise the SSR render succeeds and the user is signed out at the first client-side call. Set `httpOnly: true` explicitly to silence this."
+		}));
+	}, B = await l(t);
+	B.length > 0 && X.info(`middleware.ts loaded — ${B.length} middleware(s): ` + B.map((e) => e.exportName).join(", "));
+	let H, U = null, W = process.env.SSR_CACHE === "postgres";
+	if (W && P()) U = new (await (import("pg"))).default.Client(N()), await U.connect(), H = qe({ client: U }), X.info("isr cache backend: postgres", { table: "voltro_isr_cache" });
+	else if (W) {
+		let t = "SSR_CACHE=postgres, but nothing in the environment names a database (looked for DB_URL, DB_PRIMARY_URL, DB_DIRECT_URL, DB_MIGRATE_URL, DB_HOST, PG_HOST).";
+		if (e()) throw X.fatal(`${t} Refusing to fall back to the per-process memory cache: it is not shared between instances and does not survive a restart, so the pages this process serves would differ from its replicas' with nothing to indicate it.`), Error("[voltro start] SSR_CACHE=postgres with no database configured");
+		H = we(), X.warn(`${t} Falling back to the per-process memory cache — this would be a hard failure in production.`);
+	} else H = we(), X.info("isr cache backend: memory (per-process)", { hint: "set SSR_CACHE=postgres for persistent storage" });
+	await j(t, s, fe, p);
+	let Le = z(t, "src", "pages"), { pages: ze, dirs: G } = await w(Le), K = nt(ze);
+	me(B, K.map((e) => e.pattern)), a.mark("scan");
+	let q = z(x, "server", "ssrEntry.js"), Ge = await Q(q);
+	if (!Ge && process.env.NODE_ENV === "production") throw X.fatal(`production \`voltro start\` requires a precompiled SSR bundle at ${q} but it is missing. Run \`voltro build\` before serving — production renders from the bundle and never compiles on demand.`), Error(`[voltro start] missing SSR bundle at ${q}`);
+	let J = Ge ? await at(q) : await ot(t, b);
+	X.info(`ssr loader: ${J.kind}`, {
+		kind: J.kind,
+		...J.kind === "middleware" ? { hint: "no pre-built SSR bundle found; run `voltro build` to enable bundle mode" } : {}
+	}), a.mark("provider");
+	let Ke = J.getPageMeta?.(), Y = /* @__PURE__ */ new Map(), Ze = 0;
+	for (let e of ze) {
+		let t = Ke?.[e.pattern];
+		if (t) {
+			Y.set(e.pattern, t);
+			continue;
+		}
+		try {
+			let t = await J.getPage(e.pattern, e.file);
+			Y.set(e.pattern, Se(t, e.file)), Ze++;
+		} catch (t) {
+			X.warn("failed to load page metadata", { pattern: e.pattern }, t);
+		}
+	}
+	let Qe = /* @__PURE__ */ new Map();
+	for (let [e, t] of Y) {
+		if (t.interactive !== "islands") continue;
+		let n = z(x, "island-shells", `${T(e)}.html`);
+		try {
+			Qe.set(e, await V.readFile(n, "utf8"));
+		} catch {
+			X.warn("islands page has no built per-page shell — serving the full app shell", {
+				pattern: e,
+				expected: n
+			});
+		}
+	}
+	X.info(`registered ${Y.size} route(s)`, {
+		count: Y.size,
+		fromManifest: Y.size - Ze,
+		fromModules: Ze
+	}), a.mark("routes");
+	let Z = /* @__PURE__ */ new Set();
+	for (let e of K) Y.get(e.pattern)?.renderMode === "spa" && ne(G, e.dirChain).some((e) => e.hasLayout) && Z.add(e.pattern);
+	Z.size > 0 && X.info(`${Z.size} spa route(s) render an SSR layout shell`, { patterns: [...Z] });
+	let et = /* @__PURE__ */ new Map();
+	for (let [e, t] of Y) t.cacheInvalidatesOn.length > 0 && et.set(e, t.cacheInvalidatesOn);
+	let tt = /* @__PURE__ */ new Map();
+	for (let e of K) tt.set(e.pattern, e.regex);
+	let $ = /* @__PURE__ */ new Map();
+	for (let [e, t] of Y) $.set(e, t.renderMode);
+	let st = [...Y.values()].some((e) => e.renderMode === "isr"), ct = {
+		cache: H,
+		tableSink: Ue({
+			cache: H,
+			tableSubscriptionsByPattern: et,
+			regexByPattern: tt
+		}),
+		regexByPattern: tt,
+		renderModeByPattern: $
+	}, lt = (e) => {
+		let t = Je(e);
+		t && Ye(ct, t);
+	}, ut = We({
+		cache: H,
+		tableSubscriptionsByPattern: et,
+		regexByPattern: tt,
+		...st ? { onRevalidate: lt } : {}
+	}), dt = await ut.start(), ft = null, pt = null;
+	if (st) {
+		let e = Be({}, process.env);
+		if (e.crossReplica) try {
+			pt = e.provider;
+			let t = be(process.env);
+			ft = await Ie.runPromise(e.provider.subscribe(t, lt)), X.info(`revalidation subscriber: broker (${e.provider.name})`, { channel: t });
+		} catch (e) {
+			X.warn("revalidation broker subscribe failed — broker leg disabled", {}, e), pt = null;
+		}
+		dt && ft === null && X.info("revalidation subscriber: postgres LISTEN (voltro_revalidate)"), !dt && ft === null && X.warn("isr routes exist, but this web process has NO revalidation transport: no database is configured for the LISTEN line and no broker is configured. `revalidatePath` / `revalidateTable` / `revalidateTag` from the api will not reach this process — cached pages stay until their own `revalidate` window expires. Set DB_URL (postgres) or BROADCAST_URL (redis:// or nats://) on BOTH the api and this web deployment.");
+	}
+	a.mark("cdc");
+	let mt = xe(), ht = ze.map((e) => {
+		let t = Y.get(e.pattern);
+		return {
+			pattern: e.pattern,
+			file: e.file,
+			dirChain: e.dirChain,
+			renderMode: t?.renderMode ?? "static",
+			interactive: t?.interactive ?? "full",
+			tenantAware: t?.tenantAware ?? !1,
+			revalidateMs: t?.revalidateMs ?? null,
+			staleWhileRevalidateMs: t?.staleWhileRevalidateMs ?? 0,
+			cacheInvalidatesOn: t?.cacheInvalidatesOn ?? [],
+			hasLoader: t?.hasLoader ?? !1,
+			hasMeta: t?.hasMeta ?? !1,
+			hasGetStaticPaths: t?.hasGetStaticPaths ?? !1
+		};
+	}), gt = G.map((e) => ({
+		dir: e.dir,
+		hasLayout: e.hasLayout,
+		hasError: e.hasError,
+		hasPending: e.hasPending,
+		hasNotFound: e.hasNotFound
+	})), _t = U ? "postgres" : "memory", vt = {
+		kind: "web",
+		meta: {
+			name: s.name ?? "(unnamed)",
+			voltroVersion: Xe,
+			port: y,
+			mode: "start",
+			apis: Object.entries(s.apis ?? {}).map(([e, t]) => {
+				let n = {
+					name: e,
+					package: t.package
+				};
+				return t.url !== void 0 && (n.url = t.url), n;
+			})
+		},
+		routes: ht,
+		dirs: gt,
+		cache: () => {
+			let e = Date.now(), t = H.snapshot().map(([t, n]) => ({
+				key: t,
+				renderedAt: n.renderedAt,
+				expiresAt: n.expiresAt,
+				servableUntil: n.servableUntil,
+				ageMs: e - n.renderedAt,
+				htmlBytes: Buffer.byteLength(n.html, "utf8"),
+				revalidateMs: n.revalidateMs,
+				staleWhileRevalidateMs: n.staleWhileRevalidateMs
+			}));
+			return {
+				backend: _t,
+				size: H.size(),
+				entries: t
+			};
+		},
+		metrics: () => Re()
+	}, yt = async (e, n) => {
+		let a = e.split("?")[0] ?? "/";
+		if (s.name === "voltroDashboard" && a === "/api/dashboard/registry") try {
+			let e = await Oe();
+			return {
+				status: 200,
+				headers: { "content-type": "application/json; charset=utf-8" },
+				body: JSON.stringify(e)
+			};
+		} catch (e) {
+			return {
+				status: 500,
+				headers: { "content-type": "text/plain" },
+				body: `registry read error: ${e.message}`
+			};
+		}
+		if (s.name === "voltroDashboard" && a === "/api/dashboard/config") {
+			let e = process.env.VOLTRO_DASHBOARD_APPS, t = [];
+			if (e && e.trim().length > 0) {
+				let n;
+				try {
+					n = JSON.parse(e);
+				} catch (e) {
+					return {
+						status: 500,
+						headers: { "content-type": "text/plain" },
+						body: `VOLTRO_DASHBOARD_APPS is not valid JSON: ${e.message}`
+					};
+				}
+				for (let e of Array.isArray(n) ? n : []) {
+					if (typeof e != "object" || !e) continue;
+					let n = e;
+					typeof n.url == "string" && n.url.length !== 0 && t.push({
+						url: n.url,
+						...typeof n.name == "string" ? { name: n.name } : {},
+						...typeof n.token == "string" ? { token: n.token } : {}
+					});
+				}
+			}
+			return {
+				status: 200,
+				headers: { "content-type": "application/json; charset=utf-8" },
+				body: JSON.stringify({ apps: t })
+			};
+		}
+		if (a === "/_voltro/inspect/logs") {
+			let t = f(e, h(), n);
+			return {
+				status: t.status,
+				headers: {
+					"content-type": t.contentType,
+					...F(n.origin)
+				},
+				body: t.body
+			};
+		}
+		if (a !== "/_voltro/inspect/stream") {
+			let t = _e(e, vt, n);
+			if (t !== null) return {
+				status: t.status,
+				headers: {
+					"content-type": t.contentType,
+					...t.headers ?? {}
+				},
+				body: t.body
+			};
+		}
+		let o = rt(a, K), c = o ? Y.get(o.route.pattern)?.renderMode : void 0, l = c === "ssr" || c === "isr" || (o ? Z.has(o.route.pattern) : !1), u = [];
+		if (!l && B.length > 0) {
+			let t = i(B, {
+				route: void 0,
+				pathname: a
+			});
+			if (t !== void 0) {
+				let r = await se(t, {
+					pathname: a,
+					search: e.slice(a.length),
+					headers: n,
+					cookies: ee(n.cookie),
+					route: void 0
+				});
+				u.push(...r.setCookies);
+			}
+		}
+		let d = (e) => u.length === 0 ? e : {
+			...e,
+			"set-cookie": u.map(oe)
+		}, p = a === "/" ? z(x, "index.html") : z(x, a.replace(/^\//, ""), "index.html");
+		if (!l && await Q(p)) {
+			let e = await V.readFile(p);
+			return {
+				status: 200,
+				headers: d({ "content-type": "text/html; charset=utf-8" }),
+				body: e
+			};
+		}
+		if (/\.[a-z0-9]+$/i.test(a)) {
+			let e = z(x, a.replace(/^\//, ""));
+			if (await Q(e)) {
+				let t = await V.readFile(e);
+				return {
+					status: 200,
+					headers: d({ "content-type": $e(e) }),
+					body: t
+				};
+			}
+		}
+		let m = rt(a, K);
+		if (!m) return {
+			status: 404,
+			headers: d({ "content-type": "text/plain" }),
+			body: "not found"
+		};
+		let g = Y.get(m.route.pattern), v = n["x-tenant"] ?? "anonymous", y = (await J.getHelpers()).i18n?.resolve(n.cookie, n["accept-language"])?.locale, b = Te(a, {
+			...g?.tenantAware ? { tenant: v } : {},
+			...y ? { locale: y } : {}
+		}), S = H.get(b), C = Date.now();
+		if (S && Ee(S, C)) return _.emit("cache", {
+			kind: "HIT",
+			key: b,
+			ageMs: C - S.renderedAt
+		}), {
+			status: 200,
+			headers: {
+				"content-type": "text/html; charset=utf-8",
+				"x-voltro-rendered-by": "isr",
+				"x-voltro-cache": "HIT",
+				"x-voltro-cache-key": b,
+				"x-voltro-cache-age-ms": String(C - S.renderedAt)
+			},
+			body: S.html
+		};
+		if (S && Ce(S, C)) {
+			_.emit("cache", {
+				kind: "STALE",
+				key: b,
+				ageMs: C - S.renderedAt
+			});
+			let r = H.generation(b);
+			return (async () => {
+				try {
+					let i = await it({
+						provider: J,
+						root: t,
+						route: m.route,
+						params: m.params,
+						pathname: a,
+						dirs: G,
+						shellTemplate: Qe.get(m.route.pattern) ?? A,
+						requestHeaders: n,
+						apiOrigin: L,
+						apiName: R,
+						middlewares: B,
+						onCookieWarning: Pe,
+						requestUrl: e,
+						buffered: !0
+					});
+					if (i && "html" in i && i.renderMode === "isr" && i.revalidateMs !== null) {
+						let e = Y.get(m.route.pattern)?.staleWhileRevalidateMs ?? 0, t = Date.now();
+						H.set(b, {
+							html: i.html,
+							renderedAt: t,
+							expiresAt: t + i.revalidateMs,
+							servableUntil: t + i.revalidateMs + e,
+							revalidateMs: i.revalidateMs,
+							staleWhileRevalidateMs: e
+						}, { ifGeneration: r }) || X.info("SWR refresh discarded — the entry was purged while it rendered", { key: b });
+					}
+				} catch (e) {
+					X.warn("background SWR refresh failed", { url: a }, e);
+				}
+			})(), {
+				status: 200,
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "isr",
+					"x-voltro-cache": "STALE",
+					"x-voltro-cache-key": b,
+					"x-voltro-cache-age-ms": String(C - S.renderedAt)
+				},
+				body: S.html
+			};
+		}
+		try {
+			let r = H.generation(b), i = await it({
+				provider: J,
+				root: t,
+				route: m.route,
+				params: m.params,
+				pathname: a,
+				dirs: G,
+				shellTemplate: Qe.get(m.route.pattern) ?? A,
+				requestHeaders: n,
+				apiOrigin: L,
+				apiName: R,
+				middlewares: B,
+				onCookieWarning: Pe,
+				requestUrl: e
+			});
+			if (!i) return {
+				status: 200,
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "spa-fallback"
+				},
+				body: A
+			};
+			let o = i.setCookies ?? [], s = i.responseHeaders ?? {}, c = (e) => ({
+				...s,
+				...e,
+				...o.length === 0 ? {} : { "set-cookie": o.map(oe) }
+			});
+			if ("stream" in i) return {
+				status: 200,
+				headers: { "x-voltro-rendered-by": i.renderMode },
+				body: "",
+				stream: i.stream
+			};
+			if ("control" in i) return i.control === "redirect" ? {
+				status: i.status,
+				headers: c({
+					location: i.location,
+					"x-voltro-rendered-by": "loader-redirect"
+				}),
+				body: ""
+			} : {
+				status: 404,
+				headers: c({
+					"content-type": "text/plain; charset=utf-8",
+					"x-voltro-rendered-by": "loader-not-found"
+				}),
+				body: "not found"
+			};
+			let l = c({
+				"content-type": "text/html; charset=utf-8",
+				"x-voltro-rendered-by": i.renderMode
+			});
+			if (i.renderMode === "isr" && i.revalidateMs !== null) {
+				let e = Date.now(), t = Y.get(m.route.pattern)?.staleWhileRevalidateMs ?? 0;
+				H.set(b, {
+					html: i.html,
+					renderedAt: e,
+					expiresAt: e + i.revalidateMs,
+					servableUntil: e + i.revalidateMs + t,
+					revalidateMs: i.revalidateMs,
+					staleWhileRevalidateMs: t
+				}, { ifGeneration: r }) || X.info("miss fill discarded — the entry was purged while it rendered", { key: b }), l["x-voltro-cache"] = "MISS", l["x-voltro-cache-key"] = b, l["x-voltro-cache-revalidate-ms"] = String(i.revalidateMs), t > 0 && (l["x-voltro-cache-swr-ms"] = String(t)), _.emit("cache", {
+					kind: "MISS",
+					key: b,
+					revalidateMs: i.revalidateMs,
+					swrMs: t
+				});
+			} else i.renderMode === "isr" && (l["x-voltro-cache"] = "BYPASS", _.emit("cache", {
+				kind: "BYPASS",
+				key: b
+			}));
+			return {
+				status: 200,
+				headers: l,
+				body: i.html
+			};
+		} catch (e) {
+			return X.error("render error", { url: a }, e), r(e) ? {
+				status: 500,
+				headers: {
+					"content-type": "text/plain; charset=utf-8",
+					"x-voltro-rendered-by": "defer-unsupported"
+				},
+				body: e.message
+			} : {
+				status: 500,
+				headers: { "content-type": "text/plain" },
+				body: "server error"
+			};
+		}
+	}, bt = !1, xt = ie({
+		apiName: R,
+		apiOrigin: L,
+		loadDescriptors: async () => {
+			if (R === void 0) return;
+			let e = (await J.getHelpers()).apiDescriptors?.[R];
+			return e === void 0 ? void 0 : await e();
+		},
+		rpcQuery: (e, t) => C(L, e, {
+			apiName: R,
+			headers: t
+		}),
+		renderErrorPage: async ({ path: e, headers: n, flash: r }) => {
+			let { pathname: i } = ae(e), a = rt(i, K);
+			if (!a) return;
+			let o = await it({
+				provider: J,
+				root: t,
+				route: a.route,
+				params: a.params,
+				pathname: i,
+				dirs: G,
+				shellTemplate: A,
+				requestHeaders: n,
+				apiOrigin: L,
+				apiName: R,
+				middlewares: B,
+				onCookieWarning: Pe,
+				requestUrl: e,
+				formFlash: r,
+				buffered: !0
+			});
+			return o !== null && "html" in o ? o.html : void 0;
+		}
+	}), St = Ve(async (e, t) => {
+		let n = e.url ?? "/", r = Date.now(), i = {};
+		for (let [t, n] of Object.entries(e.headers)) n !== void 0 && (i[t.toLowerCase()] = Array.isArray(n) ? n.join(", ") : n);
+		let a = n.split("?")[0] ?? "/", o = (e.method ?? "GET").toUpperCase();
+		if (a === "/internal/liveness") {
+			t.writeHead(200, {
+				"content-type": "text/plain",
+				"cache-control": "no-store"
+			}), t.end("ok");
+			return;
+		}
+		if (a === "/internal/readiness") {
+			let e = bt ? 200 : 503;
+			t.writeHead(e, {
+				"content-type": "text/plain",
+				"cache-control": "no-store"
+			}), t.end(bt ? "ready" : "not-ready");
+			return;
+		}
+		if (!(a.startsWith(re) && await xt(e, t))) {
+			if (o === "OPTIONS" && a.startsWith("/_voltro/inspect")) {
+				let e = F(i.origin);
+				t.writeHead(204, e), t.end();
+				return;
+			}
+			if (s.name === "voltroDashboard" && a === "/api/dashboard/proxy") {
+				let r = new URL(n, "http://x").searchParams.get("target");
+				if (!r) {
+					t.writeHead(400, { "content-type": "text/plain" }), t.end("missing ?target=");
+					return;
+				}
+				if (!I(r)) {
+					t.writeHead(400, { "content-type": "text/plain" }), t.end("target not allowed: must be loopback or an origin configured in VOLTRO_DASHBOARD_APPS");
+					return;
+				}
+				try {
+					let n = { accept: i.accept ?? "application/json" }, a = i.authorization;
+					a ? n.authorization = Array.isArray(a) ? a[0] : a : ve(r) && process.env.VOLTRO_INSPECT_TOKEN && (n.authorization = `Bearer ${process.env.VOLTRO_INSPECT_TOKEN}`);
+					let s;
+					if (o && o !== "GET" && o !== "HEAD") {
+						let t = [];
+						for await (let n of e) t.push(n);
+						s = Buffer.concat(t);
+						let r = i["content-type"];
+						r && (n["content-type"] = Array.isArray(r) ? r[0] : r);
+					}
+					let c = await fetch(r, {
+						redirect: "manual",
+						method: o,
+						headers: n,
+						...s ? { body: new Uint8Array(s.buffer, s.byteOffset, s.byteLength) } : {}
+					}), l = Buffer.from(await c.arrayBuffer());
+					t.writeHead(c.status, {
+						"content-type": c.headers.get("content-type") ?? "application/octet-stream",
+						"content-length": String(l.length)
+					}), t.end(l);
+				} catch (e) {
+					t.writeHead(502, { "content-type": "text/plain" }), t.end(`proxy error: ${e.message}`);
+				}
+				return;
+			}
+			if (s.name === "voltroDashboard" && a === "/api/dashboard/proxy/stream") {
+				let r = new URL(n, "http://x").searchParams.get("target");
+				if (!r) {
+					t.writeHead(400, { "content-type": "text/plain" }), t.end("missing ?target=");
+					return;
+				}
+				if (!I(r)) {
+					t.writeHead(400, { "content-type": "text/plain" }), t.end("target not allowed: must be loopback or an origin configured in VOLTRO_DASHBOARD_APPS");
+					return;
+				}
+				let a = new AbortController();
+				e.on("close", () => a.abort()), t.on("close", () => a.abort());
+				try {
+					let e = i.authorization ?? (ve(r) && process.env.VOLTRO_INSPECT_TOKEN ? `Bearer ${process.env.VOLTRO_INSPECT_TOKEN}` : void 0), n = await fetch(r, {
+						redirect: "manual",
+						method: "GET",
+						headers: {
+							accept: "text/event-stream",
+							...e ? { authorization: Array.isArray(e) ? e[0] : e } : {}
+						},
+						signal: a.signal
+					});
+					if (!n.ok || !n.body) {
+						t.writeHead(n.status, { "content-type": "text/plain" }), t.end(`upstream ${n.status}`);
+						return;
+					}
+					t.writeHead(200, {
+						"content-type": "text/event-stream; charset=utf-8",
+						"cache-control": "no-cache, no-transform",
+						connection: "keep-alive",
+						"x-accel-buffering": "no"
+					}), t.flushHeaders();
+					let o = n.body.getReader();
+					try {
+						for (;;) {
+							let { done: e, value: n } = await o.read();
+							if (e) break;
+							n && t.write(Buffer.from(n));
+						}
+					} finally {
+						o.releaseLock(), t.end();
+					}
+				} catch (e) {
+					e.name !== "AbortError" && (t.writeHead(502, { "content-type": "text/plain" }), t.end(`proxy stream error: ${e.message}`));
+				}
+				return;
+			}
+			if (a === "/_voltro/inspect/stream") {
+				let n = F(i.origin);
+				if (he()) {
+					t.writeHead(503, {
+						"content-type": "application/json",
+						...n
+					}), t.end(JSON.stringify({ error: "inspect disabled (VOLTRO_INSPECT=off)" }));
+					return;
+				}
+				let r = ge(i, "GET");
+				if (!r.ok) {
+					t.writeHead(401, {
+						"content-type": "application/json",
+						...n
+					}), t.end(JSON.stringify({
+						error: "unauthorized",
+						reason: r.reason
+					}));
+					return;
+				}
+				t.writeHead(200, {
+					"content-type": "text/event-stream; charset=utf-8",
+					"cache-control": "no-cache, no-transform",
+					connection: "keep-alive",
+					"x-accel-buffering": "no",
+					...n
+				}), t.flushHeaders(), t.write("retry: 5000\n\n");
+				for (let e of _.buffered()) t.write(de(e));
+				let a = _.subscribe((e) => {
+					t.write(de(e));
+				}), o = setInterval(() => {
+					t.write(S());
+				}, 15e3), s = () => {
+					clearInterval(o), a();
+				};
+				e.on("close", s), t.on("close", s);
+				return;
+			}
+			try {
+				let e = await yt(n, i);
+				if (e.stream ? e.stream(t) : He({
+					response: t,
+					status: e.status,
+					headers: e.headers,
+					body: e.body,
+					requestHeaders: i,
+					compression: pe.compression
+				}) || (t.writeHead(e.status, e.headers), t.end(e.body)), !a.startsWith("/_voltro/inspect")) {
+					let t = Date.now() - r;
+					_.emit("request", {
+						url: a,
+						status: e.status,
+						durationMs: t,
+						renderedBy: e.headers["x-voltro-rendered-by"],
+						cache: e.headers["x-voltro-cache"]
+					});
+					let n = rt(a, K)?.route.pattern ?? (e.status === 404 ? "<unmatched>" : "<asset>");
+					mt.record({
+						kind: "request",
+						tag: n,
+						durationMs: t,
+						status: e.status >= 500 ? "error" : "ok"
+					});
+				}
+			} catch (e) {
+				t.writeHead(500, { "content-type": "text/plain" }), t.end(`internal error: ${e.message}`);
+			}
+		}
+	});
+	await new Promise((e) => St.listen(y, "::", e)), bt = !0, a.mark("ready"), X.info(`listening on http://localhost:${y}`, {
+		port: y,
+		distDir: x
+	}), X.debug("dynamic + ssr/isr routes resolve via SSR loader");
+	try {
+		await De({
+			id: O,
+			name: E,
+			kind: "web",
+			url: `http://localhost:${y}`,
+			pid: process.pid,
+			status: "live",
+			logFile: k.path
+		});
+		let e = o(t);
+		if (e) {
+			let t = await M({ dashboardAppPath: e });
+			t.status === "launched" ? X.info(`dashboard launched at http://localhost:${t.port}`, { port: t.port }) : t.status === "already-running" && X.debug(`dashboard already running on :${t.port}`, { port: t.port });
+		}
+		setInterval(() => {
+			De({
+				id: O,
+				name: E,
+				kind: "web",
+				url: `http://localhost:${y}`,
+				pid: process.pid,
+				status: "live",
+				logFile: k.path
+			}).catch(() => {});
+		}, 1e4).unref();
+	} catch (e) {
+		X.warn("runtime-registry write failed", {}, e);
+	}
+	Fe({
+		app: s.name ?? "unnamed",
+		kind: "web",
+		url: `http://localhost:${y}`,
+		bootMs: a.total()
+	});
+	let Ct = a.phaseBreakdown();
+	X.info(`start: ready in ${a.total()}ms`, {
+		bootMs: a.total(),
+		...Ct ? { phases: Ct } : {}
+	});
+	let wt = !1, Tt = (e) => async () => {
+		if (!wt) {
+			if (wt = !0, X.info(`received ${e}, shutting down`, { signal: e }), St.close(), await ut.stop(), ft) try {
+				ft();
+			} catch {}
+			if (pt) try {
+				await Ie.runPromise(pt.close());
+			} catch {}
+			if (U) try {
+				await U.end();
+			} catch {}
+			await J.close(), await ke(O), await k.dispose(), process.exit(0);
+		}
+	};
+	process.on("SIGINT", Tt("SIGINT")), process.on("SIGTERM", Tt("SIGTERM"));
+	let Et = process.ppid;
+	if (Et > 1) {
+		let e = setInterval(() => {
+			(process.ppid !== Et || process.ppid === 1) && (clearInterval(e), Tt("SIGTERM")());
+		}, 2e3);
+		e.unref();
+	}
+	return new Promise(() => {});
+}, ct = async (e) => {
+	t("start");
+	let n = e.find((e) => !e.startsWith("-")) ?? process.cwd(), r = await st(B(n));
+	return r.ran ? r.exitCode : (X.error("no web app found at this path"), 1);
+};
+//#endregion
+export { st as n, ct as t };