@voltro/cli 0.6.0 → 0.7.0

package/dist/start-CWZW_4Et.js

@@ -0,0 +1,941 @@
+import { C as e, D as t, E as n, F as r, H as i, I as a, L as o, M as s, R as c, S as l, T as ee, X as u, _ as d, a as f, b as te, ct as p, d as m, gt as h, h as g, i as _, m as v, n as y, o as b, pt as ne, r as re, st as x, t as S, u as C, w as ie, x as w, y as ae, z as oe } from "./inspectMetrics-BLUBAWLb.js";
+import { dirname as se, extname as T, join as E, resolve as D } from "node:path";
+import { fileURLToPath as O, pathToFileURL as k } from "node:url";
+import { createLogger as A, printReadyBlock as ce } from "@voltro/logger";
+import { promises as j } from "node:fs";
+import { snapshotMetricsSync as le } from "@voltro/runtime";
+import { createServer as ue } from "node:http";
+//#region src/routeMeta.ts
+var M = (e) => typeof e.renderMode == "string" ? e.renderMode : e.dynamic === "force-dynamic" ? "ssr" : (e.dynamic, "static"), de = (e) => ({
+	renderMode: M(e),
+	tenantAware: e.tenantAware === !0,
+	revalidateMs: t(e.revalidate),
+	staleWhileRevalidateMs: t(e.staleWhileRevalidate) ?? 0,
+	cacheInvalidatesOn: Array.isArray(e.cacheInvalidatesOn) ? e.cacheInvalidatesOn : [],
+	interactive: e.interactive ?? "full",
+	hasLoader: typeof e.loader == "function",
+	hasMeta: e.meta != null,
+	hasGetStaticPaths: typeof e.getStaticPaths == "function"
+}), N = A({ scope: "voltro:start:cdc" }), P = (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;
+}, F = () => !process.env.PG_HOST && !process.env.PG_DATABASE ? null : {
+	host: process.env.PG_HOST ?? "localhost",
+	port: Number(process.env.PG_PORT ?? 5432),
+	user: process.env.PG_USER ?? "app",
+	password: process.env.PG_PASSWORD ?? "app",
+	database: process.env.PG_DATABASE ?? "app"
+}, fe = (e) => {
+	let t = e.channel ?? "framework_changes", n = P(e), r = null, i = null;
+	return {
+		start: async () => {
+			let a = F();
+			if (!a) {
+				N.debug("skipped — no PG_* env vars set");
+				return;
+			}
+			if (e.tableSubscriptionsByPattern.size === 0) {
+				N.debug("skipped — no pages declare cacheInvalidatesOn");
+				return;
+			}
+			r = new (await (import("pg"))).default.Client(a), await r.connect(), i = (e) => {
+				if (e.channel !== t || !e.payload) return;
+				let r;
+				try {
+					r = JSON.parse(e.payload);
+				} catch (e) {
+					N.warn("bad CDC payload", {}, e);
+					return;
+				}
+				let i = n(r.table);
+				i > 0 && N.info(`${r.op} on '${r.table}' → dropped ${i} cache entries`, {
+					op: r.op,
+					table: r.table,
+					dropped: i
+				});
+			}, r.on("notification", i), await r.query(`LISTEN ${t}`), N.info(`LISTEN ${t}`, {
+				channel: t,
+				host: a.host,
+				port: a.port,
+				database: a.database
+			});
+		},
+		stop: async () => {
+			if (r) {
+				try {
+					i && r.off("notification", i), await r.end();
+				} catch {}
+				r = null, i = null;
+			}
+		}
+	};
+}, I = A({ scope: "voltro:start:isr-cache" }), L = "voltro_isr_cache", R = (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);
+`, pe = (e) => {
+	let t = e.tableName ?? L, { client: n } = e, r = /* @__PURE__ */ new Map(), i = !1, a = (async () => {
+		i || (i = !0, await n.query(R(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) => {
+		I.warn("postgres bootstrap failed", {}, e);
+	}), o = (e, t) => {
+		a.then(() => n.query(e, t)).catch((e) => {
+			I.warn("postgres write failed", {}, e);
+		});
+	};
+	return {
+		get(e) {
+			return r.get(e);
+		},
+		set(e, n) {
+			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
+			]);
+		},
+		invalidate(e) {
+			r.delete(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), i.push(t), n++);
+			return i.length > 0 && o(`DELETE FROM ${t} WHERE cache_key = ANY($1)`, [i]), n;
+		},
+		clear() {
+			r.clear(), o(`DELETE FROM ${t}`, []);
+		},
+		size() {
+			return r.size;
+		},
+		snapshot() {
+			return Array.from(r.entries());
+		}
+	};
+}, z = A({ scope: "voltro:start" }), me = await (async () => {
+	try {
+		let e = E(se(O(import.meta.url)), "..", "package.json"), t = await j.readFile(e, "utf8");
+		return JSON.parse(t).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})(), B = (e) => e instanceof Error && e._voltroControl === "redirect" && typeof e.location == "string", V = (e) => e instanceof Error && e._voltroControl === "not-found", H = {
+	".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"
+}, he = (e) => H[T(e).toLowerCase()] ?? "application/octet-stream", U = (e) => e.replace(/<script\b(?=[^>]*\btype="module")(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<script\b(?=[^>]*\bsrc=)(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<link\b[^>]*\brel="modulepreload"[^>]*>/gi, ""), W = async (e) => {
+	try {
+		return await j.stat(e), !0;
+	} catch {
+		return !1;
+	}
+}, G = (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
+	};
+}, ge = (e) => e.map((e) => {
+	let { regex: t, paramNames: n, priority: r } = G(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), K = (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;
+}, _e = async (e) => {
+	let { provider: n, route: r, params: i, pathname: a, dirs: o, shellTemplate: s, requestHeaders: c, requestUrl: l = "", apiOrigin: ee } = e, u = re(ee, c.cookie), d = await n.getPage(r.pattern, r.file), f = M(d);
+	if (f !== "ssr" && f !== "isr") return null;
+	let te = _(o, r.dirChain), p = {}, m = null, h;
+	try {
+		if (h = await Promise.all(te.map(async (e, t) => {
+			let r = {};
+			if (e.hasLayout) {
+				let o = await n.getLayout(e.dir);
+				if (r.Layout = o.default, typeof o.loader == "function") {
+					r.loader = o.loader;
+					let e = new AbortController();
+					p[t] = await o.loader({
+						params: i,
+						pathname: a,
+						signal: e.signal,
+						headers: c,
+						query: u
+					});
+				}
+			}
+			return e.hasError && (r.Error = (await n.getError(e.dir)).default), e.hasPending && (r.Pending = (await n.getPending(e.dir)).default), {
+				id: e.dir || "/",
+				...r
+			};
+		})), typeof d.loader == "function") {
+			let e = new AbortController();
+			m = await d.loader({
+				params: i,
+				pathname: a,
+				signal: e.signal,
+				headers: c,
+				query: u
+			});
+		}
+	} catch (e) {
+		if (B(e)) return {
+			control: "redirect",
+			status: e.status,
+			location: e.location
+		};
+		if (V(e)) return { control: "not-found" };
+		throw e;
+	}
+	let g = await n.getHelpers(), v = {
+		pattern: r.pattern,
+		Component: d.default,
+		meta: d.meta,
+		loader: d.loader,
+		ErrorBoundary: d.ErrorBoundary,
+		Pending: d.Pending,
+		renderMode: f,
+		chain: h
+	}, y = {
+		cookies: g.parseCookieHeader(c.cookie),
+		headers: c,
+		url: l
+	}, b = g.i18n?.resolve(c.cookie, c["accept-language"]), { html: ne, meta: x } = g.renderPageToHtml({
+		descriptor: v,
+		params: i,
+		pathname: a,
+		loaderData: m,
+		segmentLoaderData: p,
+		requestContext: y,
+		...b ? {
+			outerWrap: b.outerWrap,
+			locale: b.locale
+		} : {}
+	}), S = d.interactive ?? "full", C = [
+		g.renderMetaToHtml(x),
+		`<meta name="voltro-interactive" content="${S}" />`,
+		`<script type="application/json" id="__voltro_state__">${g.serialiseStateForInlining(m)}<\/script>`
+	].filter((e) => e.length > 0).join("\n    "), ie = b?.locale ?? y.cookies["voltro:lang"] ?? "en", w = s.replace("<div id=\"root\"></div>", `<div id="root">${ne}</div>`).replace("</head>", `    ${C}\n  </head>`).replace(/<html(\s+lang="[^"]*")?/i, `<html lang="${ie}"`);
+	S === "none" && (w = U(w));
+	let ae = f === "isr" ? t(d.revalidate) : null;
+	return {
+		html: w,
+		renderMode: f,
+		revalidateMs: ae
+	};
+}, q = (e) => e === "" ? "/" : e, ve = async (e) => {
+	let t = await import(k(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[q(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing layout for dir ${q(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getError(e) {
+			let n = t.errors[q(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing error for dir ${q(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getPending(e) {
+			let n = t.pendings[q(e)];
+			if (!n) throw Error(`[voltro start] ssr bundle missing pending for dir ${q(e)}`);
+			return typeof n == "function" ? await n() : n;
+		},
+		async getHelpers() {
+			return t.helpers;
+		},
+		async close() {}
+	};
+}, ye = async (e, t) => {
+	let n = await h("vite", () => import("vite")), r = (await import("@vitejs/plugin-react")).default, i = (await import("@tailwindcss/vite")).default, a = await n.createServer({
+		root: t,
+		envPrefix: "__VOLTRO_VITE_ENV_DISABLED__",
+		plugins: [r(), i()],
+		resolve: { dedupe: ["react", "react-dom"] },
+		ssr: { noExternal: ["react-intl"] },
+		server: {
+			middlewareMode: !0,
+			hmr: !1
+		},
+		appType: "custom",
+		logLevel: "warn"
+	}), o = E(e, "src", "pages"), s = (e) => e === "" ? o : E(o, e);
+	return {
+		kind: "middleware",
+		async getPage(e, t) {
+			return a.ssrLoadModule(E(o, t));
+		},
+		async getLayout(e) {
+			return a.ssrLoadModule(E(s(e), "layout.tsx"));
+		},
+		async getError(e) {
+			return a.ssrLoadModule(E(s(e), "error.tsx"));
+		},
+		async getPending(e) {
+			return a.ssrLoadModule(E(s(e), "loading.tsx"));
+		},
+		async getHelpers() {
+			return await a.ssrLoadModule("@voltro/web/ssr");
+		},
+		async close() {
+			await a.close();
+		}
+	};
+}, J = async (t) => {
+	let h = await f(t);
+	if (!h) return {
+		ran: !1,
+		exitCode: 0
+	};
+	if (h.type !== "web") return z.error("only web apps are supported by `voltro start`"), {
+		ran: !0,
+		exitCode: 1
+	};
+	let { resolved: _ } = await ne({
+		rawEnv: h.env,
+		appType: "web",
+		root: t,
+		log: z,
+		generateTypes: !1
+	}), re = _.publicValues, se = Date.now(), T = c();
+	r(T), z.info("booting voltro start", { app: h.name ?? "(unnamed)" });
+	let D = (() => {
+		if (process.env.VOLTRO_IS_DASHBOARD === "1" && process.env.VOLTRO_DASHBOARD_PORT) return Number(process.env.VOLTRO_DASHBOARD_PORT);
+		if (process.env.PORT) {
+			let e = Number(process.env.PORT);
+			if (Number.isFinite(e) && e > 0) return e;
+		}
+		return h.port ?? 5173;
+	})(), O = E(t, ".framework"), k = E(O, "dist"), A = E(k, "index.html");
+	if (!await W(A)) return z.error("no built dist found — run `voltro build` first", { distDir: k }), {
+		ran: !0,
+		exitCode: 1
+	};
+	let M = h.name ?? "unnamed", N = ae("web", M, D), P = d(M);
+	await l({
+		id: N,
+		name: M,
+		kind: "web",
+		url: `http://localhost:${D}`,
+		pid: process.pid,
+		status: "booting",
+		logFile: P.path
+	}).catch(() => {});
+	let F = E(k, "_voltro", "shell.html"), I = await W(F) ? await j.readFile(F, "utf8") : await j.readFile(A, "utf8"), L = await b(t, h), R = y(L[0]), B, V = null;
+	process.env.SSR_CACHE === "postgres" && process.env.PG_HOST ? (V = new (await (import("pg"))).default.Client({
+		host: process.env.PG_HOST,
+		port: Number(process.env.PG_PORT ?? 5432),
+		user: process.env.PG_USER ?? "app",
+		password: process.env.PG_PASSWORD ?? "app",
+		database: process.env.PG_DATABASE ?? "app"
+	}), await V.connect(), B = pe({ client: V }), z.info("isr cache backend: postgres", { table: "voltro_isr_cache" })) : (B = n(), z.info("isr cache backend: memory (per-process)", { hint: "set SSR_CACHE=postgres for persistent storage" })), await m(t, h, L, re);
+	let { pages: H, dirs: U } = await C(E(t, "src", "pages")), G = ge(H), q = E(k, "server", "ssrEntry.js"), J = await W(q);
+	if (!J && process.env.NODE_ENV === "production") throw z.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 Y = J ? await ve(q) : await ye(t, O);
+	z.info(`ssr loader: ${Y.kind}`, {
+		kind: Y.kind,
+		...Y.kind === "middleware" ? { hint: "no pre-built SSR bundle found; run `voltro build` to enable bundle mode" } : {}
+	});
+	let be = Y.getPageMeta?.(), X = /* @__PURE__ */ new Map(), Z = 0;
+	for (let e of H) {
+		let t = be?.[e.pattern];
+		if (t) {
+			X.set(e.pattern, t);
+			continue;
+		}
+		try {
+			let t = await Y.getPage(e.pattern, e.file);
+			X.set(e.pattern, de(t)), Z++;
+		} catch (t) {
+			z.warn("failed to load page metadata", { pattern: e.pattern }, t);
+		}
+	}
+	z.info(`registered ${X.size} route(s)`, {
+		count: X.size,
+		fromManifest: X.size - Z,
+		fromModules: Z
+	});
+	let xe = /* @__PURE__ */ new Map();
+	for (let [e, t] of X) t.cacheInvalidatesOn.length > 0 && xe.set(e, t.cacheInvalidatesOn);
+	let Se = /* @__PURE__ */ new Map();
+	for (let e of G) Se.set(e.pattern, e.regex);
+	let Ce = fe({
+		cache: B,
+		tableSubscriptionsByPattern: xe,
+		regexByPattern: Se
+	});
+	await Ce.start();
+	let we = S(), Te = H.map((e) => {
+		let t = X.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
+		};
+	}), Ee = U.map((e) => ({
+		dir: e.dir,
+		hasLayout: e.hasLayout,
+		hasError: e.hasError,
+		hasPending: e.hasPending,
+		hasNotFound: e.hasNotFound
+	})), De = V ? "postgres" : "memory", Oe = {
+		kind: "web",
+		meta: {
+			name: h.name ?? "(unnamed)",
+			voltroVersion: me,
+			port: D,
+			mode: "start",
+			apis: Object.entries(h.apis ?? {}).map(([e, t]) => {
+				let n = {
+					name: e,
+					package: t.package
+				};
+				return t.url !== void 0 && (n.url = t.url), n;
+			})
+		},
+		routes: Te,
+		dirs: Ee,
+		cache: () => {
+			let e = Date.now(), t = B.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: De,
+				size: B.size(),
+				entries: t
+			};
+		},
+		metrics: () => le()
+	}, ke = async (n, r) => {
+		let i = n.split("?")[0] ?? "/";
+		if (h.name === "voltroDashboard" && i === "/api/dashboard/registry") try {
+			let e = await te();
+			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 (h.name === "voltroDashboard" && i === "/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 (i === "/_voltro/inspect/logs") {
+			let e = s(n, a());
+			return {
+				status: e.status,
+				headers: { "content-type": e.contentType },
+				body: e.body
+			};
+		}
+		if (i !== "/_voltro/inspect/stream") {
+			let e = u(n, Oe, r);
+			if (e !== null) return {
+				status: e.status,
+				headers: {
+					"content-type": e.contentType,
+					...e.headers ?? {}
+				},
+				body: e.body
+			};
+		}
+		let o = K(i, G), c = o ? X.get(o.route.pattern)?.renderMode : void 0, l = c === "ssr" || c === "isr", d = i === "/" ? E(k, "index.html") : E(k, i.replace(/^\//, ""), "index.html");
+		if (!l && await W(d)) return {
+			status: 200,
+			headers: { "content-type": "text/html; charset=utf-8" },
+			body: await j.readFile(d)
+		};
+		if (/\.[a-z0-9]+$/i.test(i)) {
+			let e = E(k, i.replace(/^\//, ""));
+			if (await W(e)) {
+				let t = await j.readFile(e);
+				return {
+					status: 200,
+					headers: { "content-type": he(e) },
+					body: t
+				};
+			}
+		}
+		let f = K(i, G);
+		if (!f) return {
+			status: 404,
+			headers: { "content-type": "text/plain" },
+			body: "not found"
+		};
+		let p = X.get(f.route.pattern), m = r["x-tenant"] ?? "anonymous", g = (await Y.getHelpers()).i18n?.resolve(r.cookie, r["accept-language"])?.locale, _ = e(i, {
+			...p?.tenantAware ? { tenant: m } : {},
+			...g ? { locale: g } : {}
+		}), v = B.get(_), y = Date.now();
+		if (v && ie(v, y)) return T.emit("cache", {
+			kind: "HIT",
+			key: _,
+			ageMs: y - v.renderedAt
+		}), {
+			status: 200,
+			headers: {
+				"content-type": "text/html; charset=utf-8",
+				"x-voltro-rendered-by": "isr",
+				"x-voltro-cache": "HIT",
+				"x-voltro-cache-key": _,
+				"x-voltro-cache-age-ms": String(y - v.renderedAt)
+			},
+			body: v.html
+		};
+		if (v && ee(v, y)) return T.emit("cache", {
+			kind: "STALE",
+			key: _,
+			ageMs: y - v.renderedAt
+		}), (async () => {
+			try {
+				let e = await _e({
+					provider: Y,
+					root: t,
+					route: f.route,
+					params: f.params,
+					pathname: i,
+					dirs: U,
+					shellTemplate: I,
+					requestHeaders: r,
+					apiOrigin: R,
+					requestUrl: n
+				});
+				if (e && !("control" in e) && e.renderMode === "isr" && e.revalidateMs !== null) {
+					let t = X.get(f.route.pattern)?.staleWhileRevalidateMs ?? 0, n = Date.now();
+					B.set(_, {
+						html: e.html,
+						renderedAt: n,
+						expiresAt: n + e.revalidateMs,
+						servableUntil: n + e.revalidateMs + t,
+						revalidateMs: e.revalidateMs,
+						staleWhileRevalidateMs: t
+					});
+				}
+			} catch (e) {
+				z.warn("background SWR refresh failed", { url: i }, e);
+			}
+		})(), {
+			status: 200,
+			headers: {
+				"content-type": "text/html; charset=utf-8",
+				"x-voltro-rendered-by": "isr",
+				"x-voltro-cache": "STALE",
+				"x-voltro-cache-key": _,
+				"x-voltro-cache-age-ms": String(y - v.renderedAt)
+			},
+			body: v.html
+		};
+		try {
+			let e = await _e({
+				provider: Y,
+				root: t,
+				route: f.route,
+				params: f.params,
+				pathname: i,
+				dirs: U,
+				shellTemplate: I,
+				requestHeaders: r,
+				apiOrigin: R,
+				requestUrl: n
+			});
+			if (!e) return {
+				status: 200,
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "spa-fallback"
+				},
+				body: I
+			};
+			if ("control" in e) return e.control === "redirect" ? {
+				status: e.status,
+				headers: {
+					location: e.location,
+					"x-voltro-rendered-by": "loader-redirect"
+				},
+				body: ""
+			} : {
+				status: 404,
+				headers: {
+					"content-type": "text/plain; charset=utf-8",
+					"x-voltro-rendered-by": "loader-not-found"
+				},
+				body: "not found"
+			};
+			let a = {
+				"content-type": "text/html; charset=utf-8",
+				"x-voltro-rendered-by": e.renderMode
+			};
+			if (e.renderMode === "isr" && e.revalidateMs !== null) {
+				let t = Date.now(), n = X.get(f.route.pattern)?.staleWhileRevalidateMs ?? 0;
+				B.set(_, {
+					html: e.html,
+					renderedAt: t,
+					expiresAt: t + e.revalidateMs,
+					servableUntil: t + e.revalidateMs + n,
+					revalidateMs: e.revalidateMs,
+					staleWhileRevalidateMs: n
+				}), a["x-voltro-cache"] = "MISS", a["x-voltro-cache-key"] = _, a["x-voltro-cache-revalidate-ms"] = String(e.revalidateMs), n > 0 && (a["x-voltro-cache-swr-ms"] = String(n)), T.emit("cache", {
+					kind: "MISS",
+					key: _,
+					revalidateMs: e.revalidateMs,
+					swrMs: n
+				});
+			} else e.renderMode === "isr" && (a["x-voltro-cache"] = "BYPASS", T.emit("cache", {
+				kind: "BYPASS",
+				key: _
+			}));
+			return {
+				status: 200,
+				headers: a,
+				body: e.html
+			};
+		} catch (e) {
+			return z.error("render error", { url: i }, e), {
+				status: 500,
+				headers: { "content-type": "text/plain" },
+				body: "server error"
+			};
+		}
+	}, Q = !1, Ae = ue(async (e, t) => {
+		let n = e.url ?? "/", r = Date.now(), a = {};
+		for (let [t, n] of Object.entries(e.headers)) n !== void 0 && (a[t.toLowerCase()] = Array.isArray(n) ? n.join(", ") : n);
+		let s = n.split("?")[0] ?? "/", c = (e.method ?? "GET").toUpperCase();
+		if (s === "/internal/liveness") {
+			t.writeHead(200, {
+				"content-type": "text/plain",
+				"cache-control": "no-store"
+			}), t.end("ok");
+			return;
+		}
+		if (s === "/internal/readiness") {
+			let e = Q ? 200 : 503;
+			t.writeHead(e, {
+				"content-type": "text/plain",
+				"cache-control": "no-store"
+			}), t.end(Q ? "ready" : "not-ready");
+			return;
+		}
+		if (c === "OPTIONS" && s.startsWith("/_voltro/inspect")) {
+			let e = x(a.origin);
+			t.writeHead(204, e), t.end();
+			return;
+		}
+		if (h.name === "voltroDashboard" && s === "/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;
+			}
+			try {
+				let n = { accept: a.accept ?? "application/json" }, i = a.authorization;
+				i && (n.authorization = Array.isArray(i) ? i[0] : i);
+				let o;
+				if (c && c !== "GET" && c !== "HEAD") {
+					let t = [];
+					for await (let n of e) t.push(n);
+					o = Buffer.concat(t);
+					let r = a["content-type"];
+					r && (n["content-type"] = Array.isArray(r) ? r[0] : r);
+				}
+				let s = await fetch(r, {
+					method: c,
+					headers: n,
+					...o ? { body: new Uint8Array(o.buffer, o.byteOffset, o.byteLength) } : {}
+				}), l = Buffer.from(await s.arrayBuffer());
+				t.writeHead(s.status, {
+					"content-type": s.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 (h.name === "voltroDashboard" && s === "/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;
+			}
+			let i = new AbortController();
+			e.on("close", () => i.abort()), t.on("close", () => i.abort());
+			try {
+				let e = a.authorization, n = await fetch(r, {
+					method: "GET",
+					headers: {
+						accept: "text/event-stream",
+						...e ? { authorization: Array.isArray(e) ? e[0] : e } : {}
+					},
+					signal: i.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 (s === "/_voltro/inspect/stream") {
+			let n = x(a.origin);
+			if (p()) {
+				t.writeHead(503, {
+					"content-type": "application/json",
+					...n
+				}), t.end(JSON.stringify({ error: "inspect disabled (VOLTRO_INSPECT=off)" }));
+				return;
+			}
+			let r = i(a);
+			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 T.buffered()) t.write(o(e));
+			let s = T.subscribe((e) => {
+				t.write(o(e));
+			}), c = setInterval(() => {
+				t.write(oe());
+			}, 15e3), l = () => {
+				clearInterval(c), s();
+			};
+			e.on("close", l), t.on("close", l);
+			return;
+		}
+		try {
+			let e = await ke(n, a);
+			if (t.writeHead(e.status, e.headers), t.end(e.body), !s.startsWith("/_voltro/inspect")) {
+				let t = Date.now() - r;
+				T.emit("request", {
+					url: s,
+					status: e.status,
+					durationMs: t,
+					renderedBy: e.headers["x-voltro-rendered-by"],
+					cache: e.headers["x-voltro-cache"]
+				});
+				let n = K(s, G)?.route.pattern ?? (e.status === 404 ? "<unmatched>" : "<asset>");
+				we.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) => Ae.listen(D, "::", e)), Q = !0, z.info(`listening on http://localhost:${D}`, {
+		port: D,
+		distDir: k
+	}), z.debug("dynamic + ssr/isr routes resolve via SSR loader");
+	try {
+		await l({
+			id: N,
+			name: M,
+			kind: "web",
+			url: `http://localhost:${D}`,
+			pid: process.pid,
+			status: "live",
+			logFile: P.path
+		});
+		let e = g(t);
+		if (e) {
+			let t = await v({ dashboardAppPath: e });
+			t.status === "launched" ? z.info(`dashboard launched at http://localhost:${t.port}`, { port: t.port }) : t.status === "already-running" && z.debug(`dashboard already running on :${t.port}`, { port: t.port });
+		}
+		setInterval(() => {
+			l({
+				id: N,
+				name: M,
+				kind: "web",
+				url: `http://localhost:${D}`,
+				pid: process.pid,
+				status: "live",
+				logFile: P.path
+			}).catch(() => {});
+		}, 1e4).unref();
+	} catch (e) {
+		z.warn("runtime-registry write failed", {}, e);
+	}
+	ce({
+		app: h.name ?? "unnamed",
+		kind: "web",
+		url: `http://localhost:${D}`,
+		bootMs: Date.now() - se
+	});
+	let je = !1, $ = (e) => async () => {
+		if (!je) {
+			if (je = !0, z.info(`received ${e}, shutting down`, { signal: e }), Ae.close(), await Ce.stop(), V) try {
+				await V.end();
+			} catch {}
+			await Y.close(), await w(N), await P.dispose(), process.exit(0);
+		}
+	};
+	process.on("SIGINT", $("SIGINT")), process.on("SIGTERM", $("SIGTERM"));
+	let Me = process.ppid;
+	if (Me > 1) {
+		let e = setInterval(() => {
+			(process.ppid !== Me || process.ppid === 1) && (clearInterval(e), $("SIGTERM")());
+		}, 2e3);
+		e.unref();
+	}
+	return new Promise(() => {});
+}, Y = async (e) => {
+	process.env.NODE_ENV || (process.env.NODE_ENV = "production");
+	let t = await J(D(e.find((e) => !e.startsWith("-")) ?? process.cwd()));
+	return t.ran ? t.exitCode : (z.error("no web app found at this path"), 1);
+};
+//#endregion
+export { de as n, Y as t };