@pyreon/zero 0.14.0 → 0.16.0

package/lib/server.js

@@ -1,327 +1,9 @@
-import { a as generateRouteModuleFromRoutes, c as scanRouteFilesWithExports, i as generateRouteModule, o as parseFileRoutes, r as generateMiddlewareModule, s as scanRouteFiles, t as filePathToUrlPath } from "./fs-router-CQ7Zxeca.js";
-import { Fragment, createContext, h } from "@pyreon/core";
-import { HeadProvider } from "@pyreon/head";
-import { RouterProvider, RouterView, createRouter } from "@pyreon/router";
-import { createHandler } from "@pyreon/server";
-import { renderToString } from "@pyreon/runtime-server";
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { readFile } from "node:fs/promises";
-import { signal } from "@pyreon/reactivity";
+import { _ as render404Page, a as detectLocaleFromHeader, c as vercelAdapter, d as netlifyAdapter, f as cloudflareAdapter, g as createServer, h as resolveConfig, i as createLocaleContext, l as staticAdapter, m as defineConfig, o as i18nRouting, p as bunAdapter, r as zeroPlugin, s as resolveAdapter, t as getZeroPluginConfig, u as nodeAdapter, v as createApp } from "./vite-plugin-xjWZwudX.js";
+import { i as generateRouteModule, o as parseFileRoutes, r as generateMiddlewareModule, s as scanRouteFiles, t as filePathToUrlPath } from "./fs-router-MewHc5SB.js";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readFile, rm, writeFile } from "node:fs/promises";
 
-//#region src/app.ts
-/**
-* Create a full Zero app — assembles router, head provider, and root layout.
-*
-* Used internally by entry-server and entry-client.
-*/
-function createApp(options) {
-	const router = createRouter({
-		routes: options.routes,
-		mode: options.routerMode ?? "history",
-		...options.url ? { url: options.url } : {},
-		scrollBehavior: "top"
-	});
-	const Layout = options.layout ?? DefaultLayout;
-	function App() {
-		return h(HeadProvider, null, h(RouterProvider, { router }, h(Layout, null, h(RouterView, null))));
-	}
-	return {
-		App,
-		router
-	};
-}
-function DefaultLayout(props) {
-	return h(Fragment, null, ...Array.isArray(props.children) ? props.children : [props.children]);
-}
-
-//#endregion
-//#region src/api-routes.ts
-/**
-* Match a URL path against an API route pattern.
-* Returns extracted params or null if no match.
-*/
-function matchApiRoute(pattern, path) {
-	const patternParts = pattern.split("/").filter(Boolean);
-	const pathParts = path.split("/").filter(Boolean);
-	const params = {};
-	for (let i = 0; i < patternParts.length; i++) {
-		const pp = patternParts[i];
-		if (!pp) continue;
-		if (pp.endsWith("*")) {
-			const paramName = pp.slice(1, -1);
-			params[paramName] = pathParts.slice(i).join("/");
-			return params;
-		}
-		if (i >= pathParts.length) return null;
-		if (pp.startsWith(":")) {
-			params[pp.slice(1)] = pathParts[i];
-			continue;
-		}
-		if (pp !== pathParts[i]) return null;
-	}
-	return patternParts.length === pathParts.length ? params : null;
-}
-const HTTP_METHODS = [
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE",
-	"HEAD",
-	"OPTIONS"
-];
-/**
-* Create a middleware that dispatches API route requests.
-* API routes are matched by URL pattern and HTTP method.
-*/
-function createApiMiddleware(routes) {
-	return async (ctx) => {
-		for (const route of routes) {
-			const params = matchApiRoute(route.pattern, ctx.path);
-			if (!params) continue;
-			const method = ctx.req.method.toUpperCase();
-			const handler = route.module[method];
-			if (!handler) {
-				const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(", ");
-				return new Response(null, {
-					status: 405,
-					headers: {
-						Allow: allowed,
-						"Content-Type": "application/json"
-					}
-				});
-			}
-			return handler({
-				request: ctx.req,
-				url: ctx.url,
-				path: ctx.path,
-				params,
-				headers: ctx.req.headers
-			});
-		}
-	};
-}
-/**
-* Detect whether a route file is an API route.
-* API routes are `.ts` or `.js` files inside an `api/` directory.
-*/
-function isApiRoute(filePath) {
-	const normalized = filePath.replace(/\\/g, "/");
-	return normalized.startsWith("api/") && (normalized.endsWith(".ts") || normalized.endsWith(".js")) && !normalized.endsWith(".tsx") && !normalized.endsWith(".jsx");
-}
-/**
-* Convert an API route file path to a URL pattern.
-*
-* Examples:
-*   "api/posts.ts"        → "/api/posts"
-*   "api/posts/index.ts"  → "/api/posts"
-*   "api/posts/[id].ts"   → "/api/posts/:id"
-*   "api/[...path].ts"    → "/api/:path*"
-*/
-function apiFilePathToPattern(filePath) {
-	let route = filePath;
-	for (const ext of [".ts", ".js"]) if (route.endsWith(ext)) {
-		route = route.slice(0, -ext.length);
-		break;
-	}
-	const segments = route.split("/");
-	const urlSegments = [];
-	for (const seg of segments) {
-		if (seg === "index") continue;
-		const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/);
-		if (catchAll) {
-			urlSegments.push(`:${catchAll[1]}*`);
-			continue;
-		}
-		const dynamic = seg.match(/^\[(\w+)\]$/);
-		if (dynamic) {
-			urlSegments.push(`:${dynamic[1]}`);
-			continue;
-		}
-		urlSegments.push(seg);
-	}
-	return `/${urlSegments.join("/")}`;
-}
-/**
-* Generate a virtual module that exports API route entries.
-* Each entry maps a URL pattern to a module with HTTP method handlers.
-*/
-function generateApiRouteModule(files, routesDir) {
-	const apiFiles = files.filter(isApiRoute);
-	if (apiFiles.length === 0) return "export const apiRoutes = []\n";
-	const imports = [];
-	const entries = [];
-	for (let i = 0; i < apiFiles.length; i++) {
-		const name = `_api${i}`;
-		const file = apiFiles[i];
-		if (!file) continue;
-		const fullPath = `${routesDir}/${file}`;
-		const pattern = apiFilePathToPattern(file);
-		imports.push(`import * as ${name} from "${fullPath}"`);
-		entries.push(`  { pattern: ${JSON.stringify(pattern)}, module: ${name} }`);
-	}
-	return [
-		...imports,
-		"",
-		"export const apiRoutes = [",
-		entries.join(",\n"),
-		"]"
-	].join("\n");
-}
-
-//#endregion
-//#region src/not-found.ts
-const DEFAULT_404_BODY = "<h1>404 — Not Found</h1><p>The page you requested does not exist.</p>";
-/**
-* Render a 404 component to a full HTML string.
-* If no component is provided, returns a default 404 page.
-*/
-async function render404Page(component, template) {
-	let body;
-	if (component) body = await renderToString(h(component, null));
-	else body = DEFAULT_404_BODY;
-	if (template?.includes("<!--pyreon-app-->")) return template.replace("<!--pyreon-app-->", body);
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>404 — Not Found</title>
-</head>
-<body>
-  ${body}
-</body>
-</html>`;
-}
-
-//#endregion
-//#region src/entry-server.ts
-/**
-* Create a middleware that dispatches per-route middleware based on URL pattern matching.
-*/
-function createRouteMiddlewareDispatcher(entries) {
-	return async (ctx) => {
-		for (const entry of entries) if (matchPattern(entry.pattern, ctx.path)) {
-			const mw = Array.isArray(entry.middleware) ? entry.middleware : [entry.middleware];
-			for (const fn of mw) {
-				const result = await fn(ctx);
-				if (result) return result;
-			}
-		}
-	};
-}
-/**
-* URL pattern matcher supporting :param and :param* segments.
-*
-* Rules:
-* - Static segments must match exactly
-* - `:param` matches a single path segment
-* - `:param*` matches all remaining segments (must be last, and path must
-*   have matched all preceding segments)
-* - Path length must match pattern length (unless catch-all)
-*/
-function matchPattern(pattern, path) {
-	const patternParts = pattern.split("/").filter(Boolean);
-	const pathParts = path.split("/").filter(Boolean);
-	for (let i = 0; i < patternParts.length; i++) {
-		const pp = patternParts[i];
-		if (pp.endsWith("*")) return i <= pathParts.length;
-		if (i >= pathParts.length) return false;
-		if (pp.startsWith(":")) continue;
-		if (pp !== pathParts[i]) return false;
-	}
-	return patternParts.length === pathParts.length;
-}
-/**
-* Create the SSR request handler for production.
-*
-* @example
-* import { routes } from "virtual:zero/routes"
-* import { routeMiddleware } from "virtual:zero/route-middleware"
-* import { createServer } from "@pyreon/zero"
-*
-* export default createServer({ routes, routeMiddleware, apiRoutes })
-*/
-function createServer(options) {
-	const config = options.config ?? {};
-	const allMiddleware = [];
-	if (options.apiRoutes?.length) allMiddleware.push(createApiMiddleware(options.apiRoutes));
-	if (options.routeMiddleware?.length) allMiddleware.push(createRouteMiddlewareDispatcher(options.routeMiddleware));
-	allMiddleware.push(...config.middleware ?? []);
-	allMiddleware.push(...options.middleware ?? []);
-	const { App } = createApp({
-		routes: options.routes,
-		routerMode: "history"
-	});
-	const handler = createHandler({
-		App,
-		routes: options.routes,
-		middleware: allMiddleware,
-		mode: config.ssr?.mode ?? "string",
-		...options.template ? { template: options.template } : {},
-		...options.clientEntry ? { clientEntry: options.clientEntry } : {}
-	});
-	if (!options.notFoundComponent) return handler;
-	const NotFound = options.notFoundComponent;
-	const routePatterns = flattenRoutePatterns$1(options.routes);
-	return async (req) => {
-		const pathname = new URL(req.url).pathname;
-		if (!routePatterns.some((pattern) => matchPattern(pattern, pathname))) {
-			const fullHtml = await render404Page(NotFound, options.template);
-			return new Response(fullHtml, {
-				status: 404,
-				headers: { "Content-Type": "text/html; charset=utf-8" }
-			});
-		}
-		return handler(req);
-	};
-}
-/** Extract all URL patterns from a nested route tree. */
-function flattenRoutePatterns$1(routes, prefix = "") {
-	const patterns = [];
-	for (const route of routes) {
-		const fullPath = route.path === "/" && prefix ? prefix : `${prefix}${route.path}`;
-		patterns.push(fullPath);
-		if (route.children) patterns.push(...flattenRoutePatterns$1(route.children, fullPath));
-	}
-	return patterns;
-}
-
-//#endregion
-//#region src/config.ts
-/**
-* Define a Zero configuration.
-* Used in `zero.config.ts` at the project root.
-*
-* @example
-* import { defineConfig } from "@pyreon/zero/config"
-*
-* export default defineConfig({
-*   mode: "ssr",
-*   ssr: { mode: "stream" },
-*   port: 3000,
-* })
-*/
-function defineConfig(config) {
-	return config;
-}
-/** Merge user config with defaults. */
-function resolveConfig(userConfig = {}) {
-	return {
-		mode: "ssr",
-		base: "/",
-		port: 3e3,
-		adapter: "node",
-		...userConfig,
-		ssr: {
-			mode: "string",
-			...userConfig.ssr
-		}
-	};
-}
-
-//#endregion
 //#region src/isr.ts
 /**
 * In-memory ISR cache with stale-while-revalidate semantics.
@@ -341,6 +23,7 @@ function createISRHandler(handler, config) {
 	const revalidating = /* @__PURE__ */ new Set();
 	const revalidateMs = config.revalidate * 1e3;
 	const maxEntries = Math.max(1, config.maxEntries ?? 1e3);
+	const deriveKey = typeof config.cacheKey === "function" ? (req, _url) => config.cacheKey(req) : (_req, url) => url.pathname;
 	function set(key, entry) {
 		if (cache.has(key)) cache.delete(key);
 		cache.set(key, entry);
@@ -358,12 +41,15 @@ function createISRHandler(handler, config) {
 		}
 		return entry;
 	}
-	async function revalidate(url) {
-		const key = url.pathname;
+	async function revalidate(url, originalReq) {
+		const key = deriveKey(originalReq, url);
 		if (revalidating.has(key)) return;
 		revalidating.add(key);
 		try {
-			const res = await handler(new Request(url.href, { method: "GET" }));
+			const res = await handler(new Request(url.href, {
+				method: "GET",
+				headers: originalReq.headers
+			}));
 			const html = await res.text();
 			const headers = {};
 			res.headers.forEach((v, k) => {
@@ -381,11 +67,11 @@ function createISRHandler(handler, config) {
 	return async (req) => {
 		if (req.method !== "GET") return handler(req);
 		const url = new URL(req.url);
-		const key = url.pathname;
+		const key = deriveKey(req, url);
 		const entry = touch(key);
 		if (entry) {
 			const age = Date.now() - entry.timestamp;
-			if (age > revalidateMs) revalidate(url);
+			if (age > revalidateMs) revalidate(url, req);
 			return new Response(entry.html, {
 				status: 200,
 				headers: {
@@ -402,7 +88,7 @@ function createISRHandler(handler, config) {
 		res.headers.forEach((v, k) => {
 			headers[k] = v;
 		});
-		cache.set(key, {
+		set(key, {
 			html,
 			headers,
 			timestamp: Date.now()
@@ -419,428 +105,97 @@ function createISRHandler(handler, config) {
 }
 
 //#endregion
-//#region src/adapters/validate.ts
-/**
-* Validate that adapter build inputs exist before copying.
-* Throws with a clear error message if directories are missing.
-* @internal
-*/
-async function validateBuildInputs(options) {
-	const { existsSync } = await import("node:fs");
-	if (!existsSync(options.clientOutDir)) throw new Error(`[Pyreon] Client build output not found: ${options.clientOutDir}. Run "vite build" first.`);
-	if (!existsSync(options.serverEntry)) throw new Error(`[Pyreon] Server entry not found: ${options.serverEntry}. Run "vite build --ssr" first.`);
-}
-
-//#endregion
-//#region src/adapters/bun.ts
-/**
-* Bun adapter — generates a standalone Bun.serve() entry.
-*/
-function bunAdapter() {
-	return {
-		name: "bun",
-		async build(options) {
-			await validateBuildInputs(options);
-			const { writeFile, cp, mkdir } = await import("node:fs/promises");
-			const { join } = await import("node:path");
-			const outDir = options.outDir;
-			await mkdir(outDir, { recursive: true });
-			await cp(options.clientOutDir, join(outDir, "client"), { recursive: true });
-			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
-			const port = options.config.port ?? 3e3;
-			const serverEntry = `
-const handler = (await import("./server/entry-server.js")).default
-const clientDir = new URL("./client/", import.meta.url).pathname
-
-Bun.serve({
-  port: ${port},
-  async fetch(req) {
-    const url = new URL(req.url)
-
-    // Try static files first
-    if (req.method === "GET") {
-      const filePath = clientDir + (url.pathname === "/" ? "index.html" : url.pathname)
-      // Prevent path traversal — ensure resolved path stays within clientDir
-      const resolved = Bun.resolveSync(filePath, ".")
-      if (!resolved.startsWith(Bun.resolveSync(clientDir, "."))) {
-        return new Response("Forbidden", { status: 403 })
-      }
-      const file = Bun.file(filePath)
-      if (await file.exists()) {
-        return new Response(file, {
-          headers: {
-            "cache-control": filePath.endsWith(".js") || filePath.endsWith(".css")
-              ? "public, max-age=31536000, immutable"
-              : "public, max-age=3600",
-          },
-        })
-      }
-    }
-
-    // Fall through to SSR handler
-    return handler(req)
-  },
-})
-
-console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
-`.trimStart();
-			await writeFile(join(outDir, "index.ts"), serverEntry);
-		}
-	};
-}
-
-//#endregion
-//#region src/adapters/cloudflare.ts
+//#region src/vercel-revalidate-handler.ts
 /**
-* Cloudflare Pages adapter — generates output for Cloudflare Pages with Functions.
+* M3.1 — Drop-in Vercel revalidate webhook handler.
+*
+* Pre-M3.1 the `vercelAdapter.revalidate(path)` (PR I) POSTed to
+* `/api/_pyreon-revalidate?path=...&secret=...` — a CONVENTION that users
+* had to implement themselves. This helper scaffolds the convention:
 *
-* Produces:
-* - Client assets in the output directory root (served as static)
-* - `_worker.js` — Cloudflare Pages Function for SSR
+*     // src/routes/api/_pyreon-revalidate.ts (or `pages/api/...` in
+*     // Next-style apps deployed to Vercel)
+*     export { vercelRevalidateHandler as default } from '@pyreon/zero/server'
 *
-* Note: Cloudflare Pages Functions have a ~1MB module size limit.
-* For large apps, configure Vite's SSR build to bundle server code:
-* `ssr: { noExternal: true }` in vite.config.ts.
+* The handler validates the secret query param against
+* `VERCEL_REVALIDATE_TOKEN`, validates the path is in the build-time
+* revalidate manifest, and calls Vercel's `res.revalidate(path)` API.
 *
-* Deploy with: `npx wrangler pages deploy ./dist`
+* Returns a standard `(req: Request) => Response` Web API handler — works
+* with Vercel Edge functions, Node serverless functions (via Vercel's
+* `@vercel/node` adapter that bridges Node `req`/`res` to Web standard
+* fetch shapes), and the in-process `mode: 'ssr'` runtime.
 *
 * @example
-* ```ts
-* // zero.config.ts
-* import { defineConfig } from "@pyreon/zero"
+* // src/routes/api/_pyreon-revalidate.ts
+* import { vercelRevalidateHandler } from '@pyreon/zero/server'
 *
-* export default defineConfig({
-*   adapter: "cloudflare",
+* export const POST = vercelRevalidateHandler({
+*   // Optional — defaults to reading `_pyreon-revalidate.json` from cwd.
+*   manifestPath: './dist/_pyreon-revalidate.json',
 * })
-* ```
-*/
-function cloudflareAdapter() {
-	return {
-		name: "cloudflare",
-		async build(options) {
-			await validateBuildInputs(options);
-			const { writeFile, cp, mkdir } = await import("node:fs/promises");
-			const { join } = await import("node:path");
-			const outDir = options.outDir;
-			await mkdir(outDir, { recursive: true });
-			await cp(options.clientOutDir, outDir, { recursive: true });
-			await cp(join(options.serverEntry, ".."), join(outDir, "_server"), { recursive: true });
-			const workerEntry = `
-import handler from "./_server/entry-server.js"
-
-export default {
-  async fetch(request, env, ctx) {
-    const url = new URL(request.url)
-
-    // Let Cloudflare serve static assets (files with extensions)
-    // This check is a fallback — Pages routes static files automatically
-    const ext = url.pathname.split(".").pop()
-    if (ext && ext !== url.pathname && !url.pathname.endsWith("/")) {
-      // Cloudflare Pages handles static assets automatically via its asset binding
-      // Only reach here if the file doesn't exist — fall through to SSR
-    }
-
-    // SSR handler
-    try {
-      return await handler(request)
-    } catch (err) {
-      return new Response("Internal Server Error", { status: 500 })
-    }
-  },
-}
-`.trimStart();
-			await writeFile(join(outDir, "_worker.js"), workerEntry);
-			await writeFile(join(outDir, "_routes.json"), JSON.stringify({
-				version: 1,
-				include: ["/*"],
-				exclude: [
-					"/assets/*",
-					"/favicon.*",
-					"/site.webmanifest",
-					"/robots.txt",
-					"/sitemap.xml"
-				]
-			}, null, 2));
-		}
-	};
-}
-
-//#endregion
-//#region src/adapters/netlify.ts
-/**
-* Netlify adapter — generates output for Netlify Functions (v2).
-*
-* Produces:
-* - Client assets in `publish/` directory
-* - `netlify/functions/ssr.mjs` — Netlify Function for SSR
-* - `netlify.toml` — routing configuration
 *
 * @example
-* ```ts
-* // zero.config.ts
-* import { defineConfig } from "@pyreon/zero"
-*
-* export default defineConfig({
-*   adapter: "netlify",
+* // Custom revalidate impl (e.g. for a self-hosted Pyreon SSR runtime
+* // that wants build-time revalidate behavior without Vercel's
+* // `res.revalidate()` API):
+* export const POST = vercelRevalidateHandler({
+*   onRevalidate: async (path) => {
+*     // Clear your in-process ISR cache, emit a metrics event, etc.
+*     await myCache.invalidate(path)
+*   },
 * })
-* ```
 */
-function netlifyAdapter() {
-	return {
-		name: "netlify",
-		async build(options) {
-			await validateBuildInputs(options);
-			const { writeFile, cp, mkdir } = await import("node:fs/promises");
-			const { join } = await import("node:path");
-			const outDir = options.outDir;
-			const publishDir = join(outDir, "publish");
-			const functionsDir = join(outDir, "netlify", "functions");
-			await mkdir(publishDir, { recursive: true });
-			await mkdir(functionsDir, { recursive: true });
-			await cp(options.clientOutDir, publishDir, { recursive: true });
-			await cp(join(options.serverEntry, ".."), join(functionsDir, "_server"), { recursive: true });
-			const funcEntry = `
-import handler from "./_server/entry-server.js"
-
-export default async function(req, context) {
-  try {
-    return await handler(req)
-  } catch (err) {
-    return new Response("Internal Server Error", { status: 500 })
-  }
-}
-
-export const config = {
-  path: "/*",
-  preferStatic: true,
-}
-`.trimStart();
-			await writeFile(join(functionsDir, "ssr.mjs"), funcEntry);
-			const toml = `
-[build]
-  publish = "publish"
-  functions = "netlify/functions"
-
-[[headers]]
-  for = "/assets/*"
-  [headers.values]
-    Cache-Control = "public, max-age=31536000, immutable"
-
-[[redirects]]
-  from = "/*"
-  to = "/.netlify/functions/ssr"
-  status = 200
-  conditions = {Role = ["admin", "user", ""]}
-`.trimStart();
-			await writeFile(join(outDir, "netlify.toml"), toml);
-		}
-	};
-}
-
-//#endregion
-//#region src/adapters/node.ts
 /**
-* Node.js adapter — generates a standalone server entry using node:http.
+* Create the Web-standard request handler. Reads the manifest once on first
+* invocation (cached in-process) so repeated revalidations don't re-read the
+* file. Manifest read failures cache the failure too — until next process
+* restart, all requests get the same 500 response (signals deploy-time misconfig).
 */
-function nodeAdapter() {
-	return {
-		name: "node",
-		async build(options) {
-			await validateBuildInputs(options);
-			const { writeFile, cp, mkdir } = await import("node:fs/promises");
-			const { join } = await import("node:path");
-			const outDir = options.outDir;
-			await mkdir(outDir, { recursive: true });
-			await cp(options.clientOutDir, join(outDir, "client"), { recursive: true });
-			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
-			const port = options.config.port ?? 3e3;
-			const serverEntry = `
-import { createServer } from "node:http"
-import { readFile } from "node:fs/promises"
-import { join, extname } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = fileURLToPath(new URL(".", import.meta.url))
-const handler = (await import("./server/entry-server.js")).default
-const clientDir = join(__dirname, "client")
-
-const MIME_TYPES = {
-  ".html": "text/html",
-  ".js": "application/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".svg": "image/svg+xml",
-  ".woff2": "font/woff2",
-  ".woff": "font/woff",
-  ".ico": "image/x-icon",
-}
-
-const server = createServer(async (req, res) => {
-  const url = new URL(req.url ?? "/", "http://localhost")
-
-  // Try to serve static files first
-  if (req.method === "GET") {
-    try {
-      const filePath = join(clientDir, url.pathname === "/" ? "index.html" : url.pathname)
-      // Prevent path traversal — ensure resolved path stays within clientDir
-      const { resolve } = await import("node:path")
-      const resolved = resolve(filePath)
-      if (!resolved.startsWith(resolve(clientDir))) {
-        res.writeHead(403)
-        res.end("Forbidden")
-        return
-      }
-      const ext = extname(filePath)
-      if (ext && ext !== ".html") {
-        const data = await readFile(filePath)
-        const mime = MIME_TYPES[ext] || "application/octet-stream"
-        res.writeHead(200, {
-          "content-type": mime,
-          "cache-control": ext === ".js" || ext === ".css"
-            ? "public, max-age=31536000, immutable"
-            : "public, max-age=3600",
-        })
-        res.end(data)
-        return
-      }
-    } catch {}
-  }
-
-  // Fall through to SSR handler
-  const headers = {}
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value) headers[key] = Array.isArray(value) ? value.join(", ") : value
-  }
-
-  const request = new Request(url.href, {
-    method: req.method,
-    headers,
-  })
-
-  const response = await handler(request)
-  const body = await response.text()
-
-  const responseHeaders = {}
-  response.headers.forEach((v, k) => { responseHeaders[k] = v })
-
-  res.writeHead(response.status, responseHeaders)
-  res.end(body)
-})
-
-server.listen(${port}, () => {
-  console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
-})
-`.trimStart();
-			await writeFile(join(outDir, "index.js"), serverEntry);
-			await writeFile(join(outDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+function vercelRevalidateHandler(options = {}) {
+	const manifestPath = options.manifestPath ?? "./dist/_pyreon-revalidate.json";
+	const secretEnvVar = options.secretEnvVar ?? "VERCEL_REVALIDATE_TOKEN";
+	let cache = null;
+	return async function handler(req) {
+		if (req.method !== "POST") return new Response(`Method ${req.method} not allowed`, { status: 405 });
+		const url = new URL(req.url);
+		const path = url.searchParams.get("path");
+		const secret = url.searchParams.get("secret");
+		if (!path || !secret) return new Response("Bad Request: missing path or secret", { status: 400 });
+		const expected = process.env[secretEnvVar];
+		if (!expected) return new Response(`Server misconfigured: ${secretEnvVar} env var not set`, { status: 500 });
+		if (secret !== expected) return new Response("Forbidden: invalid secret", { status: 403 });
+		if (cache === null) try {
+			const fileContent = await readFile(resolve(process.cwd(), manifestPath), "utf-8");
+			const parsed = JSON.parse(fileContent);
+			if (typeof parsed?.revalidate !== "object" || parsed.revalidate === null) throw new Error(`Malformed revalidate manifest at ${manifestPath}: missing or non-object \`revalidate\` field`);
+			cache = { manifest: parsed };
+		} catch (err) {
+			cache = { error: err };
 		}
-	};
-}
-
-//#endregion
-//#region src/adapters/static.ts
-/**
-* Static adapter — just copies the client build output.
-* Used with SSG mode where all pages are pre-rendered at build time.
-*/
-function staticAdapter() {
-	return {
-		name: "static",
-		async build(options) {
-			const { cp, mkdir } = await import("node:fs/promises");
-			await mkdir(options.outDir, { recursive: true });
-			await cp(options.clientOutDir, options.outDir, { recursive: true });
-		}
-	};
-}
-
-//#endregion
-//#region src/adapters/vercel.ts
-/**
-* Vercel adapter — generates output for Vercel's Build Output API v3.
-*
-* Produces a `.vercel/output` directory with:
-* - `static/` — client-side assets (JS, CSS, images)
-* - `functions/ssr.func/` — serverless function for SSR
-* - `config.json` — routing configuration
-*
-* @example
-* ```ts
-* // zero.config.ts
-* import { defineConfig } from "@pyreon/zero"
-*
-* export default defineConfig({
-*   adapter: "vercel",
-* })
-* ```
-*/
-function vercelAdapter() {
-	return {
-		name: "vercel",
-		async build(options) {
-			await validateBuildInputs(options);
-			const { writeFile, cp, mkdir } = await import("node:fs/promises");
-			const { join } = await import("node:path");
-			const vercelDir = join(options.outDir, ".vercel", "output");
-			const staticDir = join(vercelDir, "static");
-			const funcDir = join(vercelDir, "functions", "ssr.func");
-			await mkdir(staticDir, { recursive: true });
-			await mkdir(funcDir, { recursive: true });
-			await cp(options.clientOutDir, staticDir, { recursive: true });
-			await cp(join(options.serverEntry, ".."), funcDir, { recursive: true });
-			const funcEntry = `
-export default async function handler(req) {
-  const handler = (await import("./entry-server.js")).default
-  return handler(req)
-}
-`.trimStart();
-			await writeFile(join(funcDir, "index.js"), funcEntry);
-			await writeFile(join(funcDir, ".vc-config.json"), JSON.stringify({
-				runtime: "nodejs20.x",
-				handler: "index.js",
-				launcherType: "Nodejs"
-			}, null, 2));
-			await writeFile(join(vercelDir, "config.json"), JSON.stringify({
-				version: 3,
-				routes: [
-					{
-						src: "/assets/(.*)",
-						headers: { "Cache-Control": "public, max-age=31536000, immutable" }
-					},
-					{
-						src: "/(favicon\\..*|site\\.webmanifest|robots\\.txt|sitemap\\.xml)",
-						dest: "/$1"
-					},
-					{
-						src: "/(.*)",
-						dest: "/ssr"
-					}
-				]
-			}, null, 2));
+		if ("error" in cache) return new Response(`Server misconfigured: revalidate manifest at ${manifestPath} unreadable or malformed`, { status: 500 });
+		if (!Object.prototype.hasOwnProperty.call(cache.manifest.revalidate, path)) return new Response(`Path "${path}" not in revalidate manifest`, { status: 404 });
+		if (options.onRevalidate) try {
+			await options.onRevalidate(path);
+		} catch (err) {
+			return new Response(`Revalidation failed for "${path}": ${err instanceof Error ? err.message : String(err)}`, { status: 500 });
 		}
+		return new Response(JSON.stringify({
+			revalidated: true,
+			path
+		}), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
 	};
 }
-
-//#endregion
-//#region src/adapters/index.ts
 /**
-* Resolve the adapter from config.
-* Returns a built-in adapter or throws if unknown.
+* Reset the in-process manifest cache. Test-only — production code never
+* reaches this. Used by unit tests to exercise the "manifest changed
+* between requests" path without spinning up a new handler.
+* @internal
 */
-function resolveAdapter(config) {
-	const name = config.adapter ?? "node";
-	switch (name) {
-		case "node": return nodeAdapter();
-		case "bun": return bunAdapter();
-		case "static": return staticAdapter();
-		case "vercel": return vercelAdapter();
-		case "cloudflare": return cloudflareAdapter();
-		case "netlify": return netlifyAdapter();
-		default: throw new Error(`[Pyreon] Unknown adapter: "${name}". Use "node", "bun", "static", "vercel", "cloudflare", or "netlify".`);
-	}
-}
+function _resetVercelRevalidateHandlerCache(handler) {}
 
 //#endregion
 //#region src/middleware.ts
@@ -893,372 +248,6 @@ function getContext(ctx) {
 	return zctx;
 }
 
-//#endregion
-//#region src/error-overlay.ts
-/**
-* Dev-only error overlay for SSR/loader errors.
-* Renders a styled HTML page with the error stack trace.
-*/
-function renderErrorOverlay(error) {
-	return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SSR Error — Pyreon Zero</title>
-  <style>
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      font-family: ui-monospace, "Cascadia Code", "Source Code Pro", Menlo, Consolas, monospace;
-      background: #1a1a2e;
-      color: #e0e0e0;
-      min-height: 100vh;
-      padding: 2rem;
-    }
-    .overlay {
-      max-width: 900px;
-      margin: 0 auto;
-    }
-    .header {
-      display: flex;
-      align-items: center;
-      gap: 0.75rem;
-      margin-bottom: 1.5rem;
-    }
-    .badge {
-      background: #e74c3c;
-      color: white;
-      padding: 0.25rem 0.75rem;
-      border-radius: 4px;
-      font-size: 0.75rem;
-      font-weight: 600;
-      text-transform: uppercase;
-      letter-spacing: 0.05em;
-    }
-    .label {
-      color: #888;
-      font-size: 0.85rem;
-    }
-    .message {
-      font-size: 1.25rem;
-      color: #ff6b6b;
-      margin-bottom: 1.5rem;
-      line-height: 1.5;
-      word-break: break-word;
-    }
-    .stack {
-      background: #16213e;
-      border: 1px solid #2a2a4a;
-      border-radius: 8px;
-      padding: 1.25rem;
-      overflow-x: auto;
-      font-size: 0.8rem;
-      line-height: 1.7;
-      white-space: pre-wrap;
-      word-break: break-all;
-    }
-    .stack .at { color: #888; }
-    .stack .file { color: #4ecdc4; }
-    .hint {
-      margin-top: 1.5rem;
-      padding: 1rem;
-      background: #1e2a45;
-      border-radius: 6px;
-      border-left: 3px solid #3498db;
-      font-size: 0.8rem;
-      color: #aaa;
-      line-height: 1.5;
-    }
-  </style>
-</head>
-<body>
-  <div class="overlay">
-    <div class="header">
-      <span class="badge">SSR Error</span>
-      <span class="label">Pyreon Zero — Dev Mode</span>
-    </div>
-    <div class="message">${escapeHtml(error.message || "Unknown error")}</div>
-    <pre class="stack">${formatStack(escapeHtml(error.stack || ""))}</pre>
-    <div class="hint">
-      This error occurred during server-side rendering. Check the terminal for
-      the full stack trace. This overlay is only shown in development.
-    </div>
-  </div>
-</body>
-</html>`;
-}
-function escapeHtml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function formatStack(stack) {
-	return stack.split("\n").map((line) => {
-		if (line.includes("at ")) {
-			const fileMatch = line.match(/\(([^)]+)\)/);
-			if (fileMatch) return line.replace(fileMatch[0], `(<span class="file">${fileMatch[1]}</span>)`);
-		}
-		return line;
-	}).join("\n");
-}
-
-//#endregion
-//#region src/vite-plugin.ts
-/**
-* Scan node_modules/@pyreon/ to discover all installed Pyreon packages.
-* Returns package names to exclude from Vite's dep optimizer.
-*/
-function scanPyreonPackages(root) {
-	const pyreonDir = join(root, "node_modules", "@pyreon");
-	if (!existsSync(pyreonDir)) return [];
-	try {
-		return readdirSync(pyreonDir).filter((name) => !name.startsWith(".")).map((name) => `@pyreon/${name}`);
-	} catch {
-		return [];
-	}
-}
-/**
-* Resolve a package that isn't at the app's top-level `node_modules` but is
-* nested under another `@pyreon/*` package. Used to alias `@pyreon/runtime-server`
-* to the copy under `node_modules/@pyreon/zero/node_modules/@pyreon/runtime-server`
-* so `ssrLoadModule` works without requiring the app to declare it as a
-* direct dep.
-*/
-function resolveNestedPackage(root, name) {
-	const direct = join(root, "node_modules", name);
-	if (existsSync(direct)) return direct;
-	const nested = join(root, "node_modules", "@pyreon", "zero", "node_modules", name);
-	if (existsSync(nested)) return nested;
-}
-const VIRTUAL_ROUTES_ID = "virtual:zero/routes";
-const RESOLVED_VIRTUAL_ROUTES_ID = `\0${VIRTUAL_ROUTES_ID}`;
-const VIRTUAL_MIDDLEWARE_ID = "virtual:zero/route-middleware";
-const RESOLVED_VIRTUAL_MIDDLEWARE_ID = `\0${VIRTUAL_MIDDLEWARE_ID}`;
-const VIRTUAL_API_ROUTES_ID = "virtual:zero/api-routes";
-const RESOLVED_VIRTUAL_API_ROUTES_ID = `\0${VIRTUAL_API_ROUTES_ID}`;
-/**
-* Zero Vite plugin — adds file-based routing and zero-config conventions
-* on top of @pyreon/vite-plugin.
-*
-* @example
-* // vite.config.ts
-* import pyreon from "@pyreon/vite-plugin"
-* import zero from "@pyreon/zero"
-*
-* export default {
-*   plugins: [pyreon(), zero()],
-* }
-*/
-function zeroPlugin(userConfig = {}) {
-	const config = resolveConfig(userConfig);
-	let routesDir;
-	let root;
-	return {
-		name: "pyreon-zero",
-		enforce: "pre",
-		_zeroConfig: userConfig,
-		configResolved(resolvedConfig) {
-			root = resolvedConfig.root;
-			routesDir = `${root}/src/routes`;
-		},
-		resolveId(id) {
-			if (id === VIRTUAL_ROUTES_ID) return RESOLVED_VIRTUAL_ROUTES_ID;
-			if (id === VIRTUAL_MIDDLEWARE_ID) return RESOLVED_VIRTUAL_MIDDLEWARE_ID;
-			if (id === VIRTUAL_API_ROUTES_ID) return RESOLVED_VIRTUAL_API_ROUTES_ID;
-		},
-		async load(id) {
-			if (id === RESOLVED_VIRTUAL_ROUTES_ID) try {
-				return generateRouteModuleFromRoutes(await scanRouteFilesWithExports(routesDir, config.mode), routesDir, { staticImports: config.mode === "ssg" });
-			} catch (_err) {
-				return `export const routes = []`;
-			}
-			if (id === RESOLVED_VIRTUAL_MIDDLEWARE_ID) try {
-				return generateMiddlewareModule(await scanRouteFiles(routesDir), routesDir);
-			} catch (_err) {
-				return `export const routeMiddleware = []`;
-			}
-			if (id === RESOLVED_VIRTUAL_API_ROUTES_ID) try {
-				return generateApiRouteModule(await scanRouteFiles(routesDir), routesDir);
-			} catch (_err) {
-				return `export const apiRoutes = []`;
-			}
-		},
-		configureServer(server) {
-			if (config.mode === "ssr") server.middlewares.use((req, res, next) => {
-				const accept = req.headers.accept ?? "";
-				if (!accept.includes("text/html") && !accept.includes("*/*")) return next();
-				const pathname = req.url?.split("?")[0] ?? "/";
-				if (pathname.startsWith("/@") || pathname.startsWith("/__")) return next();
-				if (/\.\w+$/.test(pathname)) return next();
-				renderSsr(server, root, req.originalUrl ?? pathname, pathname).then((result) => {
-					if (result === null) return next();
-					res.statusCode = 200;
-					res.setHeader("Content-Type", "text/html; charset=utf-8");
-					res.setHeader("Content-Length", Buffer.byteLength(result));
-					res.end(result);
-				}, (err) => {
-					const error = err instanceof Error ? err : new Error(String(err));
-					server.ssrFixStacktrace(error);
-					const html = renderErrorOverlay(error);
-					res.statusCode = 500;
-					res.setHeader("Content-Type", "text/html; charset=utf-8");
-					res.setHeader("Content-Length", Buffer.byteLength(html));
-					res.end(html);
-				});
-			});
-			server.middlewares.use((req, res, next) => {
-				const accept = req.headers.accept ?? "";
-				if (!accept.includes("text/html") && !accept.includes("*/*")) return next();
-				const pathname = req.url?.split("?")[0] ?? "/";
-				if (pathname.startsWith("/@") || pathname.startsWith("/__")) return next();
-				if (/\.\w+$/.test(pathname)) return next();
-				handle404(server, routesDir, pathname, res).then((handled) => {
-					if (!handled) next();
-				}, (err) => {
-					console.error("[Pyreon] Error in 404 handler:", err);
-					next();
-				});
-			});
-			server.middlewares.use((req, res, next) => {
-				if (!(req.headers.accept ?? "").includes("text/html")) return next();
-				const originalEnd = res.end.bind(res);
-				let errored = false;
-				const handleError = (err) => {
-					if (errored) return;
-					errored = true;
-					const error = err instanceof Error ? err : new Error(String(err));
-					server.ssrFixStacktrace(error);
-					const html = renderErrorOverlay(error);
-					res.statusCode = 500;
-					res.setHeader("Content-Type", "text/html; charset=utf-8");
-					res.setHeader("Content-Length", Buffer.byteLength(html));
-					originalEnd(html);
-				};
-				res.on("error", handleError);
-				try {
-					const result = next();
-					if (result && typeof result.catch === "function") result.catch(handleError);
-				} catch (err) {
-					handleError(err);
-				}
-			});
-			server.watcher.add(`${routesDir}/**/*.{tsx,jsx,ts,js}`);
-			server.watcher.on("all", (event, path) => {
-				if (path.startsWith(routesDir) && (event === "add" || event === "unlink")) {
-					for (const resolvedId of [
-						RESOLVED_VIRTUAL_ROUTES_ID,
-						RESOLVED_VIRTUAL_MIDDLEWARE_ID,
-						RESOLVED_VIRTUAL_API_ROUTES_ID
-					]) {
-						const mod = server.moduleGraph.getModuleById(resolvedId);
-						if (mod) server.moduleGraph.invalidateModule(mod);
-					}
-					server.ws.send({ type: "full-reload" });
-				}
-			});
-		},
-		config(userConfig) {
-			const root = userConfig.root ?? process.cwd();
-			const pyreonExclude = scanPyreonPackages(root);
-			const runtimeServerAlias = resolveNestedPackage(root, "@pyreon/runtime-server");
-			return {
-				resolve: {
-					conditions: ["bun"],
-					...runtimeServerAlias ? { alias: { "@pyreon/runtime-server": runtimeServerAlias } } : {}
-				},
-				ssr: { resolve: {
-					conditions: ["bun"],
-					...runtimeServerAlias ? { alias: { "@pyreon/runtime-server": runtimeServerAlias } } : {}
-				} },
-				optimizeDeps: { exclude: pyreonExclude },
-				server: { port: config.port },
-				define: {
-					__ZERO_MODE__: JSON.stringify(config.mode),
-					__ZERO_BASE__: JSON.stringify(config.base)
-				}
-			};
-		}
-	};
-}
-/**
-* Check if the requested path matches any route. If not, render a 404 page.
-* Returns true if the 404 was handled (response sent), false otherwise.
-*
-* In dev mode, the _404.tsx component cannot be SSR-rendered because
-* the compiler emits _tpl() calls that require `document`. Instead,
-* we return a static 404 page. The actual component rendering happens
-* on the client side when the SPA loads.
-*/
-async function handle404(server, _routesDir, pathname, res) {
-	const routes = (await server.ssrLoadModule(VIRTUAL_ROUTES_ID)).routes;
-	if (flattenRoutePatterns(routes).some((pattern) => matchPattern(pattern, pathname))) return false;
-	const html = await render404Page(void 0);
-	res.statusCode = 404;
-	res.setHeader("Content-Type", "text/html; charset=utf-8");
-	res.setHeader("Content-Length", Buffer.byteLength(html));
-	res.end(html);
-	return true;
-}
-/**
-* Dev-mode SSR render pipeline. Returns the composed HTML string, or `null`
-* if the URL doesn't match any known route (caller falls through to the 404
-* middleware). Mirrors the production `createServer` flow:
-*   1. Load virtual:zero/routes + app.ts via Vite's ssrLoadModule
-*   2. Create a per-request router bound to the request URL
-*   3. Pre-run loaders for the matched route(s)
-*   4. Render app tree with head tag collection
-*   5. Serialize loader data into `window.__PYREON_LOADER_DATA__`
-*   6. Inject everything into the user's transformed index.html (so Vite
-*      still gets a chance to inject its HMR client + JSX runtime prelude)
-*/
-async function renderSsr(server, root, originalUrl, pathname) {
-	const routes = (await server.ssrLoadModule(VIRTUAL_ROUTES_ID)).routes;
-	if (!flattenRoutePatterns(routes).some((pattern) => matchPattern(pattern, pathname))) return null;
-	let template = await readFile(join(root, "index.html"), "utf-8");
-	template = await server.transformIndexHtml(originalUrl, template);
-	const [core, headPkg, headSsr, routerPkg, runtimeServer] = await Promise.all([
-		server.ssrLoadModule("@pyreon/core"),
-		server.ssrLoadModule("@pyreon/head"),
-		server.ssrLoadModule("@pyreon/head/ssr"),
-		server.ssrLoadModule("@pyreon/router"),
-		server.ssrLoadModule("@pyreon/runtime-server")
-	]);
-	let userLayout;
-	for (const ext of [
-		"tsx",
-		"ts",
-		"jsx",
-		"js"
-	]) try {
-		const layoutMod = await server.ssrLoadModule(`/src/routes/_layout.${ext}`);
-		userLayout = layoutMod.layout ?? layoutMod.default;
-		if (userLayout) break;
-	} catch {}
-	const { App, router: routerInst } = (await server.ssrLoadModule("@pyreon/zero/server")).createApp({
-		routes,
-		routerMode: "history",
-		url: pathname,
-		...userLayout ? { layout: userLayout } : {}
-	});
-	await routerInst.preload(pathname);
-	return runtimeServer.runWithRequestContext(async () => {
-		const app = core.h(App, null);
-		const { html: appHtml, head } = await headSsr.renderWithHead(app);
-		const loaderData = routerPkg.serializeLoaderData(routerInst);
-		const loaderScript = loaderData && Object.keys(loaderData).length > 0 ? `<script>window.__PYREON_LOADER_DATA__=${JSON.stringify(loaderData).replace(/<\//g, "<\\/")}<\/script>` : "";
-		return template.replace("<!--pyreon-head-->", head).replace("<!--pyreon-app-->", appHtml).replace("<!--pyreon-scripts-->", loaderScript);
-	});
-}
-/** Extract all URL patterns from a nested route tree. */
-function flattenRoutePatterns(routes, prefix = "") {
-	const patterns = [];
-	for (const route of routes) {
-		if (!route.path) continue;
-		const fullPath = route.path === "/" && prefix ? prefix : `${prefix}${route.path}`;
-		patterns.push(fullPath);
-		if (route.children) patterns.push(...flattenRoutePatterns(route.children, fullPath));
-	}
-	return patterns;
-}
-
 //#endregion
 //#region src/favicon.ts
 let sharpWarned$1 = false;
@@ -1832,12 +821,16 @@ async function addDevBadgeToPng(pngBuffer, size) {
 //#region src/seo.ts
 /**
 * Generate a sitemap.xml string from route file paths.
+*
+* When `i18n` is set (PR K — passed by `seoPlugin` after reading the
+* i18n config from `zero({ i18n: ... })`), URLs are clustered by their
+* un-prefixed (default-locale) form and each `<url>` carries
+* `<xhtml:link rel="alternate" hreflang="...">` siblings for every
+* locale variant + an `x-default` entry pointing at the default locale.
 */
-function generateSitemap(routeFiles, config) {
+function generateSitemap(routeFiles, config, i18n) {
 	const { origin, exclude = [], changefreq = "weekly", priority = .7 } = config;
-	return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${[...routeFiles.filter((f) => {
+	const clusters = clusterPathsByLocale([...routeFiles.filter((f) => {
 		const name = f.split("/").pop()?.replace(/\.\w+$/, "");
 		return name !== "_layout" && name !== "_error" && name !== "_loading";
 	}).map((f) => {
@@ -1850,19 +843,141 @@ ${[...routeFiles.filter((f) => {
 		path: p,
 		changefreq,
 		priority
-	})), ...config.additionalPaths ?? []].map((entry) => {
-		return `  <url>
-    <loc>${escapeXml$1(`${origin}${entry.path === "/" ? "" : entry.path}`)}</loc>
-    <changefreq>${entry.changefreq ?? changefreq}</changefreq>
-    <priority>${entry.priority ?? priority}</priority>${entry.lastmod ? `\n    <lastmod>${entry.lastmod}</lastmod>` : ""}
-  </url>`;
-	}).join("\n")}
+	})), ...config.additionalPaths ?? []], i18n);
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${i18n != null && i18n.locales.length > 0 ? " xmlns:xhtml=\"http://www.w3.org/1999/xhtml\"" : ""}>
+${clusters.map((cluster) => renderClusterEntry(cluster, origin, changefreq, priority, i18n)).join("\n")}
 </urlset>`;
 }
+/**
+* Cluster URL entries by their un-prefixed (default-locale) form.
+*
+* Each output cluster has:
+*   - `canonical`: the SitemapEntry that should be used as the `<url>`
+*     payload (default-locale variant; falls back to the first variant
+*     if no default-locale entry exists in the cluster).
+*   - `variantsByLocale`: Map of locale → SitemapEntry for the cluster.
+*
+* Without i18n, every entry becomes its own single-variant cluster.
+*
+* @internal — exported for unit testing.
+*/
+function clusterPathsByLocale(entries, i18n) {
+	if (i18n == null || i18n.locales.length === 0) return entries.map((entry) => ({
+		canonical: entry,
+		variantsByLocale: new Map([[null, entry]])
+	}));
+	const strategy = i18n.strategy ?? "prefix-except-default";
+	const { defaultLocale, locales } = i18n;
+	const byUnPrefixed = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const { unPrefixed, locale } = stripLocalePrefix(entry.path, locales, defaultLocale, strategy);
+		let cluster = byUnPrefixed.get(unPrefixed);
+		if (!cluster) {
+			cluster = /* @__PURE__ */ new Map();
+			byUnPrefixed.set(unPrefixed, cluster);
+		}
+		cluster.set(locale, entry);
+	}
+	const out = [];
+	for (const variantsByLocale of byUnPrefixed.values()) {
+		const canonical = variantsByLocale.get(defaultLocale) ?? variantsByLocale.get(null) ?? [...variantsByLocale.values()][0];
+		out.push({
+			canonical,
+			variantsByLocale
+		});
+	}
+	return out;
+}
+/**
+* Strip the locale prefix from a path under the i18n strategy.
+*
+* Returns `{ unPrefixed, locale }`:
+*   - `/about` under `prefix-except-default` (default=en) → `{ unPrefixed: '/about', locale: 'en' }`
+*   - `/de/about` under either strategy → `{ unPrefixed: '/about', locale: 'de' }`
+*   - `/de` (locale root) → `{ unPrefixed: '/', locale: 'de' }`
+*   - `/about` under `prefix` → no locale match, returns `{ unPrefixed: '/about', locale: null }`
+*     (the URL doesn't fit any locale subtree — sitemap treats it as standalone).
+*
+* @internal — exported for unit testing.
+*/
+function stripLocalePrefix(path, locales, defaultLocale, strategy) {
+	for (const locale of locales) {
+		if (path === `/${locale}`) return {
+			unPrefixed: "/",
+			locale
+		};
+		if (path.startsWith(`/${locale}/`)) return {
+			unPrefixed: path.slice(`/${locale}`.length),
+			locale
+		};
+	}
+	if (strategy === "prefix-except-default") return {
+		unPrefixed: path,
+		locale: defaultLocale
+	};
+	return {
+		unPrefixed: path,
+		locale: null
+	};
+}
+function renderClusterEntry(cluster, origin, changefreq, priority, i18n) {
+	const { canonical, variantsByLocale } = cluster;
+	const lines = [
+		"  <url>",
+		`    <loc>${escapeXml$1(`${origin}${canonical.path === "/" ? "" : canonical.path}`)}</loc>`,
+		`    <changefreq>${canonical.changefreq ?? changefreq}</changefreq>`,
+		`    <priority>${canonical.priority ?? priority}</priority>`
+	];
+	if (canonical.lastmod) lines.push(`    <lastmod>${canonical.lastmod}</lastmod>`);
+	if (i18n != null && i18n.locales.length > 0 && variantsByLocale.size > 1) {
+		for (const locale of i18n.locales) {
+			const variant = variantsByLocale.get(locale);
+			if (!variant) continue;
+			const variantLoc = `${origin}${variant.path === "/" ? "" : variant.path}`;
+			lines.push(`    <xhtml:link rel="alternate" hreflang="${escapeXml$1(locale)}" href="${escapeXml$1(variantLoc)}"/>`);
+		}
+		const defaultVariant = variantsByLocale.get(i18n.defaultLocale);
+		if (defaultVariant) {
+			const defaultLoc = `${origin}${defaultVariant.path === "/" ? "" : defaultVariant.path}`;
+			lines.push(`    <xhtml:link rel="alternate" hreflang="x-default" href="${escapeXml$1(defaultLoc)}"/>`);
+		}
+	}
+	lines.push("  </url>");
+	return lines.join("\n");
+}
 function escapeXml$1(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 /**
+* Resolve the i18n config to feed `generateSitemap` for hreflang
+* emission. Priority order:
+*   1. Explicit user config — `hreflang: I18nRoutingConfig` (object)
+*   2. Auto-detect from SSG manifest — `hreflang: true` + `manifestI18n`
+*      present (only happens in SSG mode where the manifest exists)
+*   3. Nothing — emit plain sitemap without xhtml:link siblings
+*
+* @internal — exported for unit testing.
+*/
+function resolveHreflangI18n(hreflang, manifestI18n) {
+	if (hreflang == null || hreflang === false) return void 0;
+	if (hreflang === true) return manifestI18n;
+	return hreflang;
+}
+/**
+* Duck-type guard for `I18nRoutingConfig`. The SSG manifest is JSON,
+* so the embedded i18n field could in principle be malformed if a
+* downstream user hand-edits the manifest (don't). Validate the shape
+* before trusting it.
+*
+* @internal
+*/
+function isI18nRoutingConfig(value) {
+	if (value == null || typeof value !== "object") return false;
+	const v = value;
+	return Array.isArray(v.locales) && v.locales.every((l) => typeof l === "string") && typeof v.defaultLocale === "string";
+}
+/**
 * Generate a robots.txt string.
 */
 function generateRobots(config = {}) {
@@ -1913,22 +1028,33 @@ function jsonLd(data) {
 *     pyreon(),
 *     zero(),
 *     seoPlugin({
-*       sitemap: { origin: "https://example.com" },
+*       sitemap: {
+*         origin: "https://example.com",
+*         useSsgPaths: true, // include dynamic-route enumerations
+*       },
 *       robots: { sitemap: "https://example.com/sitemap.xml" },
 *     }),
 *   ],
 * }
 */
 function seoPlugin(config = {}) {
+	const useSsgPaths = config.sitemap?.useSsgPaths === true;
+	let distDir = "";
 	return {
 		name: "pyreon-zero-seo",
 		apply: "build",
+		...useSsgPaths ? { enforce: "post" } : {},
+		configResolved(resolved) {
+			distDir = resolve(resolved.root, resolved.build.outDir);
+		},
 		async generateBundle(_, _bundle) {
-			if (config.sitemap) {
-				const { scanRouteFiles } = await import("./fs-router-CQ7Zxeca.js").then((n) => n.n);
+			if (config.sitemap && !useSsgPaths) {
+				const { scanRouteFiles } = await import("./fs-router-MewHc5SB.js").then((n) => n.n);
 				const routesDir = `${process.cwd()}/src/routes`;
 				try {
-					const sitemap = generateSitemap(await scanRouteFiles(routesDir), config.sitemap);
+					const files = await scanRouteFiles(routesDir);
+					const hreflangI18n = resolveHreflangI18n(config.sitemap.hreflang, void 0);
+					const sitemap = generateSitemap(files, config.sitemap, hreflangI18n);
 					this.emitFile({
 						type: "asset",
 						fileName: "sitemap.xml",
@@ -1944,6 +1070,36 @@ function seoPlugin(config = {}) {
 					source: robots
 				});
 			}
+		},
+		async closeBundle() {
+			if (!config.sitemap || !useSsgPaths) return;
+			const { scanRouteFiles } = await import("./fs-router-MewHc5SB.js").then((n) => n.n);
+			const routesDir = `${process.cwd()}/src/routes`;
+			const manifestPath = join(distDir, "_pyreon-ssg-paths.json");
+			try {
+				let ssgPaths = [];
+				let manifestI18n;
+				if (existsSync(manifestPath)) {
+					const raw = await readFile(manifestPath, "utf-8");
+					const parsed = JSON.parse(raw);
+					if (Array.isArray(parsed.paths)) ssgPaths = parsed.paths.filter((p) => typeof p === "string").map((path) => ({ path }));
+					if (isI18nRoutingConfig(parsed.i18n)) manifestI18n = parsed.i18n;
+					try {
+						await rm(manifestPath, { force: true });
+					} catch {}
+				}
+				let files = [];
+				try {
+					files = await scanRouteFiles(routesDir);
+				} catch {}
+				const merged = {
+					...config.sitemap,
+					additionalPaths: [...ssgPaths, ...config.sitemap.additionalPaths ?? []]
+				};
+				const hreflangI18n = resolveHreflangI18n(config.sitemap.hreflang, manifestI18n);
+				const sitemap = generateSitemap(files, merged, hreflangI18n);
+				await writeFile(join(distDir, "sitemap.xml"), sitemap, "utf-8");
+			} catch {}
 		}
 	};
 }
@@ -1955,7 +1111,7 @@ function seoMiddleware(config = {}) {
 	return async (ctx) => {
 		if (ctx.url.pathname === "/robots.txt" && config.robots) return new Response(generateRobots(config.robots), { headers: { "Content-Type": "text/plain" } });
 		if (ctx.url.pathname === "/sitemap.xml" && config.sitemap) try {
-			const { scanRouteFiles } = await import("./fs-router-CQ7Zxeca.js").then((n) => n.n);
+			const { scanRouteFiles } = await import("./fs-router-MewHc5SB.js").then((n) => n.n);
 			const sitemap = generateSitemap(await scanRouteFiles(`${process.cwd()}/src/routes`), config.sitemap);
 			return new Response(sitemap, { headers: { "Content-Type": "application/xml" } });
 		} catch {}
@@ -2033,14 +1189,14 @@ function buildTextOverlaySvg(layers, width, height, locale) {
 		const lines = [];
 		let currentLine = "";
 		const estimateWidth = (s) => {
-			let width = 0;
+			let w = 0;
 			for (let i = 0; i < s.length; i++) {
 				const code = s.charCodeAt(i);
-				if (code >= 12288 && code <= 40959) width += fontSize * 1;
-				else if (code <= 126 && "iljft!|:;.,'".includes(s[i])) width += fontSize * .35;
-				else width += fontSize * .55;
+				if (code >= 12288 && code <= 40959) w += fontSize * 1;
+				else if (code <= 126 && "iljft!|:;.,'".includes(s[i])) w += fontSize * .35;
+				else w += fontSize * .55;
 			}
-			return width;
+			return w;
 		};
 		for (const word of words) {
 			const testLine = currentLine ? `${currentLine} ${word}` : word;
@@ -2600,133 +1756,5 @@ function capitalize(s) {
 }
 
 //#endregion
-//#region src/i18n-routing.ts
-/**
-* Detect preferred locale from Accept-Language header.
-*/
-function detectLocaleFromHeader(acceptLanguage, locales, defaultLocale) {
-	if (!acceptLanguage) return defaultLocale;
-	const preferred = acceptLanguage.split(",").map((part) => {
-		const [lang, q] = part.trim().split(";q=");
-		return {
-			lang: lang?.split("-")[0]?.toLowerCase() ?? "",
-			quality: q ? Number.parseFloat(q) : 1
-		};
-	}).sort((a, b) => b.quality - a.quality);
-	for (const { lang } of preferred) if (locales.includes(lang)) return lang;
-	return defaultLocale;
-}
-/**
-* Extract locale from a URL path.
-* Returns { locale, pathWithoutLocale }.
-*/
-function extractLocaleFromPath(path, locales, defaultLocale) {
-	const segments = path.split("/").filter(Boolean);
-	const firstSegment = segments[0]?.toLowerCase();
-	if (firstSegment && locales.includes(firstSegment)) return {
-		locale: firstSegment,
-		pathWithoutLocale: "/" + segments.slice(1).join("/") || "/"
-	};
-	return {
-		locale: defaultLocale,
-		pathWithoutLocale: path
-	};
-}
-/**
-* Build a localized path.
-*/
-function buildLocalePath(path, locale, defaultLocale, strategy) {
-	const clean = path === "/" ? "" : path;
-	if (strategy === "prefix-except-default" && locale === defaultLocale) return path;
-	return `/${locale}${clean}`;
-}
-/**
-* Create a LocaleContext for use in components and loaders.
-*/
-function createLocaleContext(locale, path, config) {
-	const strategy = config.strategy ?? "prefix-except-default";
-	return {
-		locale,
-		locales: config.locales,
-		defaultLocale: config.defaultLocale,
-		localePath(targetPath, targetLocale) {
-			return buildLocalePath(targetPath, targetLocale ?? locale, config.defaultLocale, strategy);
-		},
-		alternates() {
-			const { pathWithoutLocale } = extractLocaleFromPath(path, config.locales, config.defaultLocale);
-			return config.locales.map((loc) => ({
-				locale: loc,
-				url: buildLocalePath(pathWithoutLocale, loc, config.defaultLocale, strategy)
-			}));
-		}
-	};
-}
-/**
-* I18n routing middleware for Zero's server.
-*
-* - Detects locale from URL prefix or Accept-Language header
-* - Redirects root to preferred locale (when detectLocale is true)
-* - Sets locale context for loaders and components
-*
-* @example
-* ```ts
-* // zero.config.ts
-* import { i18nRouting } from "@pyreon/zero"
-*
-* export default defineConfig({
-*   plugins: [
-*     i18nRouting({
-*       locales: ["en", "de", "cs"],
-*       defaultLocale: "en",
-*     }),
-*   ],
-* })
-* ```
-*/
-function i18nRouting(config) {
-	const strategy = config.strategy ?? "prefix-except-default";
-	const detectEnabled = config.detectLocale !== false;
-	const cookieName = config.cookieName ?? "locale";
-	return {
-		name: "pyreon-zero-i18n-routing",
-		configResolved() {},
-		configureServer(server) {
-			server.middlewares.use((req, res, next) => {
-				const url = req.url ?? "/";
-				if (url.startsWith("/@") || url.startsWith("/__") || url.includes(".")) return next();
-				const { locale } = extractLocaleFromPath(url, config.locales, config.defaultLocale);
-				if (detectEnabled && url === "/") {
-					const preferredFromCookie = parseCookies(req.headers.cookie)[cookieName];
-					const preferredFromHeader = detectLocaleFromHeader(req.headers["accept-language"], config.locales, config.defaultLocale);
-					const preferred = preferredFromCookie && config.locales.includes(preferredFromCookie) ? preferredFromCookie : preferredFromHeader;
-					if (strategy === "prefix" || preferred !== config.defaultLocale) {
-						res.writeHead(302, { Location: `/${preferred}/` });
-						res.end();
-						return;
-					}
-				}
-				req.__locale = locale;
-				req.__localeContext = createLocaleContext(locale, url, config);
-				localeSignal.set(locale);
-				next();
-			});
-		}
-	};
-}
-function parseCookies(header) {
-	if (!header) return {};
-	const result = {};
-	for (const pair of header.split(";")) {
-		const [key, value] = pair.trim().split("=");
-		if (key && value) result[key] = decodeURIComponent(value);
-	}
-	return result;
-}
-/** @internal Context for the current locale. */
-const LocaleCtx = createContext("en");
-/** Current locale signal — set by the server middleware or client-side detection. */
-const localeSignal = signal("en");
-
-//#endregion
-export { aiPlugin, bunAdapter, cloudflareAdapter, compose, createApp, createISRHandler, createLocaleContext, createServer, zeroPlugin as default, defineConfig, detectLocaleFromHeader, faviconLinks, faviconPlugin, filePathToUrlPath, generateLlmsFullTxt, generateLlmsTxt, generateMiddlewareModule, generateRobots, generateRouteModule, generateSitemap, getContext, i18nRouting, inferJsonLd, jsonLd, netlifyAdapter, nodeAdapter, ogImagePath, ogImagePlugin, parseFileRoutes, render404Page, resolveAdapter, resolveConfig, scanRouteFiles, seoMiddleware, seoPlugin, staticAdapter, vercelAdapter };
+export { _resetVercelRevalidateHandlerCache, aiPlugin, bunAdapter, cloudflareAdapter, compose, createApp, createISRHandler, createLocaleContext, createServer, zeroPlugin as default, defineConfig, detectLocaleFromHeader, faviconLinks, faviconPlugin, filePathToUrlPath, generateLlmsFullTxt, generateLlmsTxt, generateMiddlewareModule, generateRobots, generateRouteModule, generateSitemap, getContext, getZeroPluginConfig, i18nRouting, inferJsonLd, jsonLd, netlifyAdapter, nodeAdapter, ogImagePath, ogImagePlugin, parseFileRoutes, render404Page, resolveAdapter, resolveConfig, scanRouteFiles, seoMiddleware, seoPlugin, staticAdapter, vercelAdapter, vercelRevalidateHandler };
 //# sourceMappingURL=server.js.map