@voltro/cli 0.33.0 → 0.34.0

package/dist/start-9LiUOfES.js

@@ -0,0 +1,1087 @@
+import { i as e, t } from "./nodeEnvironment-cGFAj1J8.js";
+import { r as n } from "./appPort-B_HpJ_ck.js";
+import { A as r, B as i, C as a, D as o, E as s, H as c, I as l, J as u, N as d, O as f, P as p, S as m, T as ee, U as h, V as g, a as _, b as v, d as y, f as b, i as x, j as S, k as te, n as ne, q as C, s as re, st as ie, ut as w, w as T, x as E, y as ae, z as D } from "./webDev-CBYvPqQr.js";
+import { o as O, t as k } from "./connectionConfig-UFlIEiys.js";
+import { A, D as j, a as M, h as oe, j as N, k as se } from "./inspect-CBqFtAKA.js";
+import { a as ce, c as P, d as le, f as ue, l as F, p as I, u as de } from "./renderModeScan-D7J1B7Kw.js";
+import { i as fe, n as pe, r as me, t as he } from "./runtimeRegistry-DMeKfTHP.js";
+import { n as ge } from "./logFileSink-C_D2wRN1.js";
+import { t as _e } from "./inspectMetrics-CfdKLh6t.js";
+import { t as ve } from "./bootTiming-BdyP9nYw.js";
+import { dirname as ye, extname as be, join as L, resolve as R } from "node:path";
+import { promises as z } from "node:fs";
+import { fileURLToPath as B, pathToFileURL as xe } from "node:url";
+import { createLogger as V, printReadyBlock as Se } from "@voltro/logger";
+import { snapshotMetricsSync as Ce } from "@voltro/runtime";
+import { createServer as we } from "node:http";
+//#region src/isrCdcInvalidator.ts
+var H = V({ scope: "voltro:start:cdc" }), U = (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;
+}, W = () => k() ? O() : null, Te = (e) => {
+	let t = e.channel ?? "framework_changes", n = U(e), r = null, i = null;
+	return {
+		start: async () => {
+			if (e.tableSubscriptionsByPattern.size === 0) {
+				H.debug("skipped — no pages declare cacheInvalidatesOn");
+				return;
+			}
+			let a = W();
+			if (!a) {
+				H.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()] });
+				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) {
+					H.warn("bad CDC payload", {}, e);
+					return;
+				}
+				let i = n(r.table);
+				i > 0 && H.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}`), H.info(`LISTEN ${t}`, {
+				channel: t,
+				..."connectionString" in a ? { target: a.connectionString.replace(/\/\/[^@/]*@/, "//") } : {
+					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;
+			}
+		}
+	};
+}, G = V({ scope: "voltro:start:isr-cache" }), K = "voltro_isr_cache", Ee = (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 ?? K, { client: n } = e, r = /* @__PURE__ */ new Map(), i = !1, a = (async () => {
+		i || (i = !0, await n.query(Ee(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) => {
+		G.warn("postgres bootstrap failed", {}, e);
+	}), o = (e, t) => {
+		a.then(() => n.query(e, t)).catch((e) => {
+			G.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());
+		}
+	};
+}, q = V({ scope: "voltro:start" }), Oe = await (async () => {
+	try {
+		let e = L(ye(B(import.meta.url)), "..", "package.json"), t = await z.readFile(e, "utf8");
+		return JSON.parse(t).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})(), J = (e) => e instanceof Error && e._voltroControl === "redirect" && typeof e.location == "string", Y = (e) => e instanceof Error && e._voltroControl === "not-found", X = {
+	".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"
+}, ke = (e) => X[be(e).toLowerCase()] ?? "application/octet-stream", Ae = (e) => e.replace(/<script\b(?=[^>]*\btype="module")(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<script\b(?=[^>]*\bsrc=)(?:(?!<\/script>).)*<\/script>/gi, "").replace(/<link\b[^>]*\brel="modulepreload"[^>]*>/gi, ""), Z = async (e) => {
+	try {
+		return await z.stat(e), !0;
+	} catch {
+		return !1;
+	}
+}, je = (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
+	};
+}, Me = (e) => e.map((e) => {
+	let { regex: t, paramNames: n, priority: r } = je(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), Q = (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;
+}, Ne = async (e) => {
+	let { provider: t, route: n, params: i, pathname: c, dirs: l, shellTemplate: u, requestHeaders: d, requestUrl: p = "", apiOrigin: ee, apiName: h } = e, { search: g } = r(p), v = x(ee, d.cookie, { apiName: h }), y = await t.getPage(n.pattern, n.file), b = P(y, n.file), S = b === "spa" && re(l, n.dirChain).some((e) => e.hasLayout);
+	if (b !== "ssr" && b !== "isr" && !S) return null;
+	let ne = re(l, n.dirChain), C = {}, ie = null, w, ae = new AbortController();
+	try {
+		(await t.getHelpers()).beginStoreSeeds(), {chain: w, segmentLoaderData: C} = await _({
+			entries: ne,
+			loadLayout: (e) => t.getLayout(e.dir),
+			loadError: (e) => t.getError(e.dir),
+			loadPending: (e) => t.getPending(e.dir),
+			ctx: {
+				params: i,
+				pathname: c,
+				search: g,
+				signal: ae.signal,
+				headers: d,
+				query: v
+			}
+		}), typeof y.loader == "function" && !S && (ie = await y.loader({
+			params: i,
+			pathname: c,
+			search: g,
+			signal: ae.signal,
+			headers: d,
+			query: v
+		}));
+	} catch (e) {
+		if (J(e)) return {
+			control: "redirect",
+			status: e.status,
+			location: e.location
+		};
+		if (Y(e)) return { control: "not-found" };
+		throw e;
+	}
+	let D = await t.getHelpers();
+	S || await E({
+		pageMod: y,
+		params: i,
+		query: v,
+		apiName: h,
+		seed: D.seedPreloadedSubscription,
+		onError: ({ tag: e, apiName: t }, n) => q.warn("preload seed failed", {
+			tag: e,
+			apiName: t,
+			pathname: c
+		}, n)
+	});
+	let O = {
+		pattern: n.pattern,
+		Component: y.default,
+		meta: y.meta,
+		loader: y.loader,
+		ErrorBoundary: y.ErrorBoundary,
+		Pending: y.Pending,
+		renderMode: b,
+		chain: w
+	}, k = {
+		cookies: D.parseCookieHeader(d.cookie),
+		headers: d,
+		url: p
+	}, A = D.i18n?.resolve(d.cookie, d["accept-language"]), j = y.interactive ?? "full";
+	if (S) {
+		let e = o({
+			helpers: D,
+			page: n.pattern,
+			interactive: j,
+			delivery: "stream",
+			renderInput: {
+				descriptor: O,
+				params: i,
+				pathname: c,
+				search: g,
+				segmentLoaderData: C,
+				requestContext: k,
+				...A ? {
+					outerWrap: A.outerWrap,
+					locale: A.locale
+				} : {}
+			}
+		}), t = A?.locale ?? k.cookies["voltro:locale"] ?? "en", r = (t) => te({
+			helpers: D,
+			prepared: e,
+			meta: t,
+			interactive: j
+		});
+		if (e.hasDeferred) {
+			let n = a({ shell: u });
+			return {
+				renderMode: "spa",
+				stream: (i) => T({
+					res: i,
+					shell: n,
+					htmlLang: t,
+					headers: {
+						"content-type": "text/html; charset=utf-8",
+						"x-voltro-rendered-by": "spa"
+					},
+					headInjection: r,
+					render: (t) => D.renderPageToStream({
+						...e.renderInput,
+						...t
+					}),
+					onShellError: (e) => {
+						q.error("spa layout shell render failed", { pathname: c }, e), i.writeHead(500, { "content-type": "text/plain; charset=utf-8" }), i.end("server error");
+					}
+				})
+			};
+		}
+		let s = f({
+			helpers: D,
+			prepared: e
+		});
+		return {
+			html: m(u.replace("<div id=\"root\"></div>", `<div id="root">${s.body}</div>`), r(s.meta)).replace(/<html(\s+lang="[^"]*")?/i, `<html lang="${t}"`),
+			renderMode: "spa",
+			revalidateMs: null
+		};
+	}
+	let M = s({
+		helpers: D,
+		page: n.pattern,
+		pathname: c,
+		renderMode: b,
+		interactive: j,
+		loaderData: ie,
+		segmentLoaderData: C,
+		pageLoaderRan: typeof y.loader == "function"
+	}), oe = {
+		descriptor: O,
+		params: i,
+		pathname: c,
+		search: g,
+		loaderData: M.loaderData,
+		segmentLoaderData: M.segmentLoaderData,
+		requestContext: k,
+		...A ? {
+			outerWrap: A.outerWrap,
+			locale: A.locale
+		} : {}
+	}, N = (e) => [
+		D.renderMetaToHtml(e),
+		`<meta name="voltro-interactive" content="${j}" />`,
+		...M.hasDeferred ? [D.renderDeferredRegistryScript()] : [],
+		D.renderRouterStateScript(M.stateInput)
+	].filter((e) => e.length > 0).join("\n    ");
+	if (b === "ssr" && j === "full" && e.buffered !== !0) {
+		let e = A?.locale ?? k.cookies["voltro:locale"] ?? "en", t = a({ shell: u });
+		return {
+			renderMode: "ssr",
+			stream: (n) => T({
+				res: n,
+				shell: t,
+				htmlLang: e,
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "ssr"
+				},
+				headInjection: N,
+				render: (e) => D.renderPageToStream({
+					...oe,
+					...e
+				}),
+				onShellError: (e) => {
+					q.error("ssr shell render failed", { pathname: c }, e), n.writeHead(500, { "content-type": "text/plain; charset=utf-8" }), n.end("server error");
+				}
+			})
+		};
+	}
+	let { html: se, meta: ce } = D.renderPageToHtml(oe), le = N(ce), ue = A?.locale ?? k.cookies["voltro:locale"] ?? "en", F = m(u.replace("<div id=\"root\"></div>", `<div id="root">${se}</div>`), le).replace(/<html(\s+lang="[^"]*")?/i, `<html lang="${ue}"`);
+	j === "none" && (F = Ae(F));
+	let de = b === "isr" ? I(y.revalidate) : null;
+	return {
+		html: F,
+		renderMode: b,
+		revalidateMs: de
+	};
+}, $ = (e) => e === "" ? "/" : e, Pe = async (e) => {
+	let t = await import(xe(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() {}
+	};
+}, Fe = async (e, t) => {
+	let n = await w("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",
+			"react-intl",
+			"@voltro/i18n"
+		] },
+		ssr: { noExternal: ["react-intl", "@voltro/i18n"] },
+		server: {
+			middlewareMode: !0,
+			hmr: !1
+		},
+		appType: "custom",
+		logLevel: "warn"
+	}), o = L(e, "src", "pages"), s = (e) => e === "" ? o : L(o, e), c = C({
+		limit: u(),
+		onColdStart: (e) => q.debug("ssr cold-compile start", { id: e }),
+		onColdEnd: (e, { durationMs: t, failed: n }) => q.debug(`ssr cold-compile ${n ? "FAILED" : "end"} ${t}ms`, {
+			id: e,
+			ms: t,
+			...n ? { failed: !0 } : {}
+		})
+	}), l = (e) => c.load(e, async () => await a.ssrLoadModule(e));
+	return {
+		kind: "middleware",
+		async getPage(e, t) {
+			return l(L(o, t));
+		},
+		async getLayout(e) {
+			return l(L(s(e), "layout.tsx"));
+		},
+		async getError(e) {
+			return l(L(s(e), "error.tsx"));
+		},
+		async getPending(e) {
+			return l(L(s(e), "loading.tsx"));
+		},
+		async getHelpers() {
+			return await l("@voltro/web/ssr");
+		},
+		async close() {
+			await a.close();
+		}
+	};
+}, Ie = async (t) => {
+	let r = ve(), a = await y(t);
+	if (!a) return {
+		ran: !1,
+		exitCode: 0
+	};
+	if (a.type !== "web") return q.error("only web apps are supported by `voltro start`"), {
+		ran: !0,
+		exitCode: 1
+	};
+	let { resolved: o } = await ie({
+		rawEnv: a.env,
+		appType: "web",
+		root: t,
+		log: q,
+		generateTypes: !1
+	}), s = o.publicValues;
+	r.mark("config");
+	let u = c();
+	D(u), q.info("booting voltro start", { app: a.name ?? "(unnamed)" });
+	let f = n({
+		kind: "web",
+		configPort: a.port,
+		env: process.env,
+		dashboardPin: process.env[S] === "1"
+	});
+	for (let e of f.warnings) q.warn(e);
+	let m = f.port, _ = L(t, ".framework"), x = L(_, "dist"), te = L(x, "index.html");
+	if (!await Z(te)) return q.error("no built dist found — run `voltro build` first", { distDir: x }), {
+		ran: !0,
+		exitCode: 1
+	};
+	let C = a.name ?? "unnamed", w = he("web", C, m), T = ge(C);
+	await fe({
+		id: w,
+		name: C,
+		kind: "web",
+		url: `http://localhost:${m}`,
+		pid: process.pid,
+		status: "booting",
+		logFile: T.path
+	}).catch(() => {});
+	let E = L(x, "_voltro", "shell.html"), P = await Z(E) ? await z.readFile(E, "utf8") : await z.readFile(te, "utf8"), I = await b(t, a), ye = ne(I[0]), be = I[0]?.name, R, B = null, xe = process.env.SSR_CACHE === "postgres";
+	if (xe && k()) B = new (await (import("pg"))).default.Client(O()), await B.connect(), R = De({ client: B }), q.info("isr cache backend: postgres", { table: "voltro_isr_cache" });
+	else if (xe) {
+		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 q.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");
+		R = ue(), q.warn(`${t} Falling back to the per-process memory cache — this would be a hard failure in production.`);
+	} else R = ue(), q.info("isr cache backend: memory (per-process)", { hint: "set SSR_CACHE=postgres for persistent storage" });
+	await v(t, a, I, s);
+	let { pages: V, dirs: H } = await ae(L(t, "src", "pages")), U = Me(V);
+	r.mark("scan");
+	let W = L(x, "server", "ssrEntry.js"), G = await Z(W);
+	if (!G && process.env.NODE_ENV === "production") throw q.fatal(`production \`voltro start\` requires a precompiled SSR bundle at ${W} 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 ${W}`);
+	let K = G ? await Pe(W) : await Fe(t, _);
+	q.info(`ssr loader: ${K.kind}`, {
+		kind: K.kind,
+		...K.kind === "middleware" ? { hint: "no pre-built SSR bundle found; run `voltro build` to enable bundle mode" } : {}
+	}), r.mark("provider");
+	let Ee = K.getPageMeta?.(), J = /* @__PURE__ */ new Map(), Y = 0;
+	for (let e of V) {
+		let t = Ee?.[e.pattern];
+		if (t) {
+			J.set(e.pattern, t);
+			continue;
+		}
+		try {
+			let t = await K.getPage(e.pattern, e.file);
+			J.set(e.pattern, ce(t, e.file)), Y++;
+		} catch (t) {
+			q.warn("failed to load page metadata", { pattern: e.pattern }, t);
+		}
+	}
+	q.info(`registered ${J.size} route(s)`, {
+		count: J.size,
+		fromManifest: J.size - Y,
+		fromModules: Y
+	}), r.mark("routes");
+	let X = /* @__PURE__ */ new Set();
+	for (let e of U) J.get(e.pattern)?.renderMode === "spa" && re(H, e.dirChain).some((e) => e.hasLayout) && X.add(e.pattern);
+	X.size > 0 && q.info(`${X.size} spa route(s) render an SSR layout shell`, { patterns: [...X] });
+	let Ae = /* @__PURE__ */ new Map();
+	for (let [e, t] of J) t.cacheInvalidatesOn.length > 0 && Ae.set(e, t.cacheInvalidatesOn);
+	let je = /* @__PURE__ */ new Map();
+	for (let e of U) je.set(e.pattern, e.regex);
+	let $ = Te({
+		cache: R,
+		tableSubscriptionsByPattern: Ae,
+		regexByPattern: je
+	});
+	await $.start(), r.mark("cdc");
+	let Ie = _e(), Le = V.map((e) => {
+		let t = J.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
+		};
+	}), Re = H.map((e) => ({
+		dir: e.dir,
+		hasLayout: e.hasLayout,
+		hasError: e.hasError,
+		hasPending: e.hasPending,
+		hasNotFound: e.hasNotFound
+	})), ze = B ? "postgres" : "memory", Be = {
+		kind: "web",
+		meta: {
+			name: a.name ?? "(unnamed)",
+			voltroVersion: Oe,
+			port: m,
+			mode: "start",
+			apis: Object.entries(a.apis ?? {}).map(([e, t]) => {
+				let n = {
+					name: e,
+					package: t.package
+				};
+				return t.url !== void 0 && (n.url = t.url), n;
+			})
+		},
+		routes: Le,
+		dirs: Re,
+		cache: () => {
+			let e = Date.now(), t = R.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: ze,
+				size: R.size(),
+				entries: t
+			};
+		},
+		metrics: () => Ce()
+	}, Ve = async (e, n) => {
+		let r = e.split("?")[0] ?? "/";
+		if (a.name === "voltroDashboard" && r === "/api/dashboard/registry") try {
+			let e = await pe();
+			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 (a.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 t = l(e, i(), n);
+			return {
+				status: t.status,
+				headers: {
+					"content-type": t.contentType,
+					...j(n.origin)
+				},
+				body: t.body
+			};
+		}
+		if (r !== "/_voltro/inspect/stream") {
+			let t = oe(e, Be, n);
+			if (t !== null) return {
+				status: t.status,
+				headers: {
+					"content-type": t.contentType,
+					...t.headers ?? {}
+				},
+				body: t.body
+			};
+		}
+		let o = Q(r, U), s = o ? J.get(o.route.pattern)?.renderMode : void 0, c = s === "ssr" || s === "isr" || (o ? X.has(o.route.pattern) : !1), d = r === "/" ? L(x, "index.html") : L(x, r.replace(/^\//, ""), "index.html");
+		if (!c && await Z(d)) return {
+			status: 200,
+			headers: { "content-type": "text/html; charset=utf-8" },
+			body: await z.readFile(d)
+		};
+		if (/\.[a-z0-9]+$/i.test(r)) {
+			let e = L(x, r.replace(/^\//, ""));
+			if (await Z(e)) {
+				let t = await z.readFile(e);
+				return {
+					status: 200,
+					headers: { "content-type": ke(e) },
+					body: t
+				};
+			}
+		}
+		let f = Q(r, U);
+		if (!f) return {
+			status: 404,
+			headers: { "content-type": "text/plain" },
+			body: "not found"
+		};
+		let p = J.get(f.route.pattern), m = n["x-tenant"] ?? "anonymous", h = (await K.getHelpers()).i18n?.resolve(n.cookie, n["accept-language"])?.locale, g = F(r, {
+			...p?.tenantAware ? { tenant: m } : {},
+			...h ? { locale: h } : {}
+		}), _ = R.get(g), v = Date.now();
+		if (_ && de(_, v)) return u.emit("cache", {
+			kind: "HIT",
+			key: g,
+			ageMs: 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": g,
+				"x-voltro-cache-age-ms": String(v - _.renderedAt)
+			},
+			body: _.html
+		};
+		if (_ && le(_, v)) return u.emit("cache", {
+			kind: "STALE",
+			key: g,
+			ageMs: v - _.renderedAt
+		}), (async () => {
+			try {
+				let i = await Ne({
+					provider: K,
+					root: t,
+					route: f.route,
+					params: f.params,
+					pathname: r,
+					dirs: H,
+					shellTemplate: P,
+					requestHeaders: n,
+					apiOrigin: ye,
+					apiName: be,
+					requestUrl: e,
+					buffered: !0
+				});
+				if (i && "html" in i && i.renderMode === "isr" && i.revalidateMs !== null) {
+					let e = J.get(f.route.pattern)?.staleWhileRevalidateMs ?? 0, t = Date.now();
+					R.set(g, {
+						html: i.html,
+						renderedAt: t,
+						expiresAt: t + i.revalidateMs,
+						servableUntil: t + i.revalidateMs + e,
+						revalidateMs: i.revalidateMs,
+						staleWhileRevalidateMs: e
+					});
+				}
+			} catch (e) {
+				q.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": g,
+				"x-voltro-cache-age-ms": String(v - _.renderedAt)
+			},
+			body: _.html
+		};
+		try {
+			let i = await Ne({
+				provider: K,
+				root: t,
+				route: f.route,
+				params: f.params,
+				pathname: r,
+				dirs: H,
+				shellTemplate: P,
+				requestHeaders: n,
+				apiOrigin: ye,
+				apiName: be,
+				requestUrl: e
+			});
+			if (!i) return {
+				status: 200,
+				headers: {
+					"content-type": "text/html; charset=utf-8",
+					"x-voltro-rendered-by": "spa-fallback"
+				},
+				body: P
+			};
+			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: {
+					location: i.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": i.renderMode
+			};
+			if (i.renderMode === "isr" && i.revalidateMs !== null) {
+				let e = Date.now(), t = J.get(f.route.pattern)?.staleWhileRevalidateMs ?? 0;
+				R.set(g, {
+					html: i.html,
+					renderedAt: e,
+					expiresAt: e + i.revalidateMs,
+					servableUntil: e + i.revalidateMs + t,
+					revalidateMs: i.revalidateMs,
+					staleWhileRevalidateMs: t
+				}), a["x-voltro-cache"] = "MISS", a["x-voltro-cache-key"] = g, a["x-voltro-cache-revalidate-ms"] = String(i.revalidateMs), t > 0 && (a["x-voltro-cache-swr-ms"] = String(t)), u.emit("cache", {
+					kind: "MISS",
+					key: g,
+					revalidateMs: i.revalidateMs,
+					swrMs: t
+				});
+			} else i.renderMode === "isr" && (a["x-voltro-cache"] = "BYPASS", u.emit("cache", {
+				kind: "BYPASS",
+				key: g
+			}));
+			return {
+				status: 200,
+				headers: a,
+				body: i.html
+			};
+		} catch (e) {
+			return q.error("render error", { url: r }, e), ee(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"
+			};
+		}
+	}, He = !1, Ue = we(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 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 = He ? 200 : 503;
+			t.writeHead(e, {
+				"content-type": "text/plain",
+				"cache-control": "no-store"
+			}), t.end(He ? "ready" : "not-ready");
+			return;
+		}
+		if (s === "OPTIONS" && o.startsWith("/_voltro/inspect")) {
+			let e = j(i.origin);
+			t.writeHead(204, e), t.end();
+			return;
+		}
+		if (a.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;
+			}
+			if (!se(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 : N(r) && process.env.VOLTRO_INSPECT_TOKEN && (n.authorization = `Bearer ${process.env.VOLTRO_INSPECT_TOKEN}`);
+				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 = i["content-type"];
+					r && (n["content-type"] = Array.isArray(r) ? r[0] : r);
+				}
+				let c = await fetch(r, {
+					redirect: "manual",
+					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 (a.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;
+			}
+			if (!se(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 ?? (N(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 (o === "/_voltro/inspect/stream") {
+			let n = j(i.origin);
+			if (A()) {
+				t.writeHead(503, {
+					"content-type": "application/json",
+					...n
+				}), t.end(JSON.stringify({ error: "inspect disabled (VOLTRO_INSPECT=off)" }));
+				return;
+			}
+			let r = M(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 u.buffered()) t.write(g(e));
+			let a = u.subscribe((e) => {
+				t.write(g(e));
+			}), o = setInterval(() => {
+				t.write(h());
+			}, 15e3), s = () => {
+				clearInterval(o), a();
+			};
+			e.on("close", s), t.on("close", s);
+			return;
+		}
+		try {
+			let e = await Ve(n, i);
+			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;
+				u.emit("request", {
+					url: o,
+					status: e.status,
+					durationMs: t,
+					renderedBy: e.headers["x-voltro-rendered-by"],
+					cache: e.headers["x-voltro-cache"]
+				});
+				let n = Q(o, U)?.route.pattern ?? (e.status === 404 ? "<unmatched>" : "<asset>");
+				Ie.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) => Ue.listen(m, "::", e)), He = !0, r.mark("ready"), q.info(`listening on http://localhost:${m}`, {
+		port: m,
+		distDir: x
+	}), q.debug("dynamic + ssr/isr routes resolve via SSR loader");
+	try {
+		await fe({
+			id: w,
+			name: C,
+			kind: "web",
+			url: `http://localhost:${m}`,
+			pid: process.pid,
+			status: "live",
+			logFile: T.path
+		});
+		let e = p(t);
+		if (e) {
+			let t = await d({ dashboardAppPath: e });
+			t.status === "launched" ? q.info(`dashboard launched at http://localhost:${t.port}`, { port: t.port }) : t.status === "already-running" && q.debug(`dashboard already running on :${t.port}`, { port: t.port });
+		}
+		setInterval(() => {
+			fe({
+				id: w,
+				name: C,
+				kind: "web",
+				url: `http://localhost:${m}`,
+				pid: process.pid,
+				status: "live",
+				logFile: T.path
+			}).catch(() => {});
+		}, 1e4).unref();
+	} catch (e) {
+		q.warn("runtime-registry write failed", {}, e);
+	}
+	Se({
+		app: a.name ?? "unnamed",
+		kind: "web",
+		url: `http://localhost:${m}`,
+		bootMs: r.total()
+	});
+	let We = r.phaseBreakdown();
+	q.info(`start: ready in ${r.total()}ms`, {
+		bootMs: r.total(),
+		...We ? { phases: We } : {}
+	});
+	let Ge = !1, Ke = (e) => async () => {
+		if (!Ge) {
+			if (Ge = !0, q.info(`received ${e}, shutting down`, { signal: e }), Ue.close(), await $.stop(), B) try {
+				await B.end();
+			} catch {}
+			await K.close(), await me(w), await T.dispose(), process.exit(0);
+		}
+	};
+	process.on("SIGINT", Ke("SIGINT")), process.on("SIGTERM", Ke("SIGTERM"));
+	let qe = process.ppid;
+	if (qe > 1) {
+		let e = setInterval(() => {
+			(process.ppid !== qe || process.ppid === 1) && (clearInterval(e), Ke("SIGTERM")());
+		}, 2e3);
+		e.unref();
+	}
+	return new Promise(() => {});
+}, Le = async (e) => {
+	t("start");
+	let n = await Ie(R(e.find((e) => !e.startsWith("-")) ?? process.cwd()));
+	return n.ran ? n.exitCode : (q.error("no web app found at this path"), 1);
+};
+//#endregion
+export { Ie as n, Le as t };