@voltro/cli 0.6.0 → 0.8.0

package/dist/start-DuyBQxW3.js

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