@pyreon/zero 0.15.0 → 0.18.0

package/lib/server.js

@@ -1,10 +1,8 @@
-import { i as generateRouteModule, o as parseFileRoutes, r as generateMiddlewareModule, s as scanRouteFiles, t as filePathToUrlPath } from "./fs-router-ZebyutPa.js";
-import { a as createServer, i as resolveConfig, n as zeroPlugin, o as render404Page, r as defineConfig, s as createApp } from "./vite-plugin-E4BHYvYW.js";
-import { createContext } from "@pyreon/core";
+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-y0NmCLJA.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 } from "node:path";
-import { readFile } from "node:fs/promises";
-import { signal } from "@pyreon/reactivity";
+import { join, resolve } from "node:path";
+import { readFile, rm, writeFile } from "node:fs/promises";
 
 //#region src/isr.ts
 /**
@@ -25,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);
@@ -42,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) => {
@@ -65,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: {
@@ -86,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()
@@ -103,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.
 */
-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));
-		}
-	};
-}
-
-//#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.
+* 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 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 });
+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/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
@@ -1150,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) => {
@@ -1168,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 = {}) {
@@ -1231,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-ZebyutPa.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",
@@ -1262,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 {}
 		}
 	};
 }
@@ -1273,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-ZebyutPa.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 {}
@@ -1351,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;
@@ -1918,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