@pyreon/zero 0.12.1 → 0.12.3

package/lib/index.js

@@ -2,7 +2,7 @@ import { a as parseFileRoutes, i as generateRouteModule, o as scanRouteFiles, r
 import { Fragment, createContext, createRef, h, onMount, onUnmount } from "@pyreon/core";
 import { HeadProvider, useHead } from "@pyreon/head";
 import { RouterProvider, RouterView, createRouter, useRouter } from "@pyreon/router";
-import { createHandler } from "@pyreon/server";
+import { createHandler, useRequestLocals } from "@pyreon/server";
 import { renderToString } from "@pyreon/runtime-server";
 import { existsSync, readdirSync } from "node:fs";
 import { basename, extname, join } from "node:path";
@@ -211,14 +211,23 @@ function createRouteMiddlewareDispatcher(entries) {
 		}
 	};
 }
-/** Simple URL pattern matcher supporting :param and :param* segments. */
+/**
+* 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) continue;
-		if (pp.endsWith("*")) return true;
+		if (pp.endsWith("*")) return i <= pathParts.length;
+		if (i >= pathParts.length) return false;
 		if (pp.startsWith(":")) continue;
 		if (pp !== pathParts[i]) return false;
 	}
@@ -496,7 +505,10 @@ function zeroPlugin(userConfig = {}) {
 				if (/\.\w+$/.test(pathname)) return next();
 				handle404(server, routesDir, pathname, res).then((handled) => {
 					if (!handled) next();
-				}, () => next());
+				}, (err) => {
+					console.error("[zero] Error in 404 handler:", err);
+					next();
+				});
 			});
 			server.middlewares.use((req, res, next) => {
 				if (!(req.headers.accept ?? "").includes("text/html")) return next();
@@ -652,6 +664,19 @@ 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(`[zero:adapter] Client build output not found: ${options.clientOutDir}. Run "vite build" first.`);
+	if (!existsSync(options.serverEntry)) throw new Error(`[zero:adapter] Server entry not found: ${options.serverEntry}. Run "vite build --ssr" first.`);
+}
+
 //#endregion
 //#region src/adapters/bun.ts
 /**
@@ -661,6 +686,7 @@ 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;
@@ -709,6 +735,154 @@ console.log("\\n  ⚡ Zero production server running on http://localhost:${port}
 	};
 }
 
+//#endregion
+//#region src/adapters/cloudflare.ts
+/**
+* Cloudflare Pages adapter — generates output for Cloudflare Pages with Functions.
+*
+* Produces:
+* - Client assets in the output directory root (served as static)
+* - `_worker.js` — Cloudflare Pages Function for SSR
+*
+* 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.
+*
+* Deploy with: `npx wrangler pages deploy ./dist`
+*
+* @example
+* ```ts
+* // zero.config.ts
+* import { defineConfig } from "@pyreon/zero"
+*
+* export default defineConfig({
+*   adapter: "cloudflare",
+* })
+* ```
+*/
+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",
+* })
+* ```
+*/
+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
 /**
@@ -718,6 +892,7 @@ 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;
@@ -827,6 +1002,73 @@ function staticAdapter() {
 	};
 }
 
+//#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));
+		}
+	};
+}
+
 //#endregion
 //#region src/adapters/index.ts
 /**
@@ -839,7 +1081,10 @@ function resolveAdapter(config) {
 		case "node": return nodeAdapter();
 		case "bun": return bunAdapter();
 		case "static": return staticAdapter();
-		default: throw new Error(`[zero] Unknown adapter: "${name}". Use "node", "bun", or "static".`);
+		case "vercel": return vercelAdapter();
+		case "cloudflare": return cloudflareAdapter();
+		case "netlify": return netlifyAdapter();
+		default: throw new Error(`[zero] Unknown adapter: "${name}". Use "node", "bun", "static", "vercel", "cloudflare", or "netlify".`);
 	}
 }
 
@@ -1002,9 +1247,14 @@ function Image(props) {
 
 //#endregion
 //#region src/link.tsx
+const MAX_PREFETCH_CACHE = 200;
 const prefetched = /* @__PURE__ */ new Set();
 function doPrefetch(href) {
 	if (prefetched.has(href)) return;
+	if (prefetched.size >= MAX_PREFETCH_CACHE) {
+		const first = prefetched.values().next().value;
+		if (first) prefetched.delete(first);
+	}
 	prefetched.add(href);
 	const docLink = document.createElement("link");
 	docLink.rel = "prefetch";
@@ -1659,10 +1909,10 @@ function fontVariables(families) {
 
 //#endregion
 //#region src/image-plugin.ts
-let sharpWarned$1 = false;
-function warnSharpMissing$1() {
-	if (sharpWarned$1) return;
-	sharpWarned$1 = true;
+let sharpWarned$2 = false;
+function warnSharpMissing$2() {
+	if (sharpWarned$2) return;
+	sharpWarned$2 = true;
 	console.warn("\n[zero:image] sharp not installed — images will not be optimized. Install for full support: bun add -D sharp\n");
 }
 const IMAGE_EXT_RE = /\.(jpe?g|png|webp|avif)$/i;
@@ -1925,7 +2175,7 @@ async function resizeImage(input, output, width, format, quality) {
 		}
 		await pipeline.toFile(output);
 	} catch {
-		warnSharpMissing$1();
+		warnSharpMissing$2();
 		await writeFile(output, await readFile(input));
 	}
 }
@@ -1945,11 +2195,20 @@ async function generateBlurPlaceholder(input, size) {
 const STORAGE_KEY = "zero-theme";
 /** Reactive theme signal. */
 const theme = signal("system");
+/** SSR fallback when system preference can't be detected. Default: 'light'. */
+let _ssrDefault = "light";
+/**
+* Set the default theme for SSR (when `matchMedia` is unavailable).
+* Call once at server startup before rendering.
+*/
+function setSSRThemeDefault(value) {
+	_ssrDefault = value;
+}
 /** Computed resolved theme (what's actually applied). */
 function resolvedTheme() {
 	const t = theme();
 	if (t === "system") {
-		if (typeof window === "undefined") return "dark";
+		if (typeof window === "undefined") return _ssrDefault;
 		return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
 	}
 	return t;
@@ -2123,14 +2382,14 @@ ${[...routeFiles.filter((f) => {
 		priority
 	})), ...config.additionalPaths ?? []].map((entry) => {
 		return `  <url>
-    <loc>${escapeXml(`${origin}${entry.path === "/" ? "" : entry.path}`)}</loc>
+    <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")}
 </urlset>`;
 }
-function escapeXml(str) {
+function escapeXml$1(str) {
 	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 /**
@@ -2311,16 +2570,19 @@ function rateLimitMiddleware(config = {}) {
 	const { max = 100, window: windowSec = 60, keyFn = defaultKeyFn, onLimit, include, exclude } = config;
 	const windowMs = windowSec * 1e3;
 	const store = /* @__PURE__ */ new Map();
-	const cleanupInterval = setInterval(() => {
-		const now = Date.now();
+	const MAX_STORE_SIZE = 1e4;
+	let lastCleanup = Date.now();
+	function cleanupIfNeeded(now) {
+		if (store.size < MAX_STORE_SIZE / 2 && now - lastCleanup < windowMs) return;
+		lastCleanup = now;
 		for (const [key, entry] of store) if (entry.resetAt <= now) store.delete(key);
-	}, windowMs);
-	if (typeof cleanupInterval === "object" && "unref" in cleanupInterval) cleanupInterval.unref();
+	}
 	return (ctx) => {
 		if (include && !include.some((p) => matchSimpleGlob(p, ctx.path))) return;
 		if (exclude?.some((p) => matchSimpleGlob(p, ctx.path))) return;
 		const key = keyFn(ctx);
 		const now = Date.now();
+		cleanupIfNeeded(now);
 		let entry = store.get(key);
 		if (!entry || entry.resetAt <= now) {
 			entry = {
@@ -2422,15 +2684,24 @@ function isCompressible(contentType) {
 	return COMPRESSIBLE_TYPES.some((t) => contentType.includes(t));
 }
 async function compress(data, encoding) {
-	const format = encoding === "gzip" ? "gzip" : "deflate";
-	const stream = new Blob([data]).stream().pipeThrough(new CompressionStream(format));
-	return new Response(stream).arrayBuffer();
+	if (typeof CompressionStream !== "undefined") {
+		const format = encoding === "gzip" ? "gzip" : "deflate";
+		const stream = new Blob([data]).stream().pipeThrough(new CompressionStream(format));
+		return new Response(stream).arrayBuffer();
+	}
+	try {
+		const zlib = await import("node:zlib");
+		const { promisify } = await import("node:util");
+		const result = await (encoding === "gzip" ? promisify(zlib.gzip) : promisify(zlib.deflate))(Buffer.from(data));
+		return result.buffer.slice(result.byteOffset, result.byteOffset + result.byteLength);
+	} catch {
+		return data;
+	}
 }
 
 //#endregion
 //#region src/actions.ts
 const actionRegistry = /* @__PURE__ */ new Map();
-let actionCounter = 0;
 /**
 * Define a server action. Returns a callable function that:
 * - On the **client**: sends a POST request to `/_zero/actions/<id>`
@@ -2448,7 +2719,7 @@ let actionCounter = 0;
 * const result = await createPost({ title: 'Hello', body: '...' })
 */
 function defineAction(handler) {
-	const id = `action_${actionCounter++}`;
+	const id = `action_${crypto.randomUUID().slice(0, 8)}`;
 	actionRegistry.set(id, {
 		id,
 		handler
@@ -2514,10 +2785,10 @@ async function executeAction(action, req) {
 
 //#endregion
 //#region src/favicon.ts
-let sharpWarned = false;
-function warnSharpMissing() {
-	if (sharpWarned) return;
-	sharpWarned = true;
+let sharpWarned$1 = false;
+function warnSharpMissing$1() {
+	if (sharpWarned$1) return;
+	sharpWarned$1 = true;
 	console.warn("\n[zero:favicon] sharp not installed — favicons will not be generated. Install for full support: bun add -D sharp\n");
 }
 const SIZES = [
@@ -2573,17 +2844,31 @@ function faviconPlugin(config) {
 		},
 		configureServer(server) {
 			const sourcePath = join(root, config.source);
+			const devCache = /* @__PURE__ */ new Map();
 			server.middlewares.use(async (req, res, next) => {
 				const url = req.url ?? "";
-				if (url === "/favicon.svg" && config.source.endsWith(".svg")) try {
-					const content = await readFile(sourcePath, "utf-8");
+				const localeSource = resolveLocaleSource(url, config, root);
+				const svgUrl = localeSource ? localeSource.url : url;
+				const svgPath = localeSource ? localeSource.sourcePath : sourcePath;
+				const isSvgSource = localeSource ? localeSource.source.endsWith(".svg") : config.source.endsWith(".svg");
+				if (svgUrl.endsWith("/favicon.svg") && isSvgSource) try {
+					const content = await readFile(svgPath, "utf-8");
 					res.setHeader("Content-Type", "image/svg+xml");
 					res.end(content);
 					return;
 				} catch {}
-				const sizeMatch = SIZES.find((s) => url === `/${s.name}`);
+				const baseName = svgUrl.split("/").pop() ?? "";
+				const sizeMatch = SIZES.find((s) => s.name === baseName);
 				if (sizeMatch) {
-					const png = await resizeToPng(sourcePath, sizeMatch.size);
+					const cacheKey = `${svgPath}:${sizeMatch.size}`;
+					let png = devCache.get(cacheKey);
+					if (!png) {
+						const result = await resizeToPng(svgPath, sizeMatch.size);
+						if (result) {
+							png = result;
+							devCache.set(cacheKey, result);
+						}
+					}
 					if (png) {
 						res.setHeader("Content-Type", "image/png");
 						res.setHeader("Cache-Control", "no-cache");
@@ -2591,8 +2876,16 @@ function faviconPlugin(config) {
 						return;
 					}
 				}
-				if (url === "/favicon.ico") {
-					const ico = await generateIco(sourcePath);
+				if (baseName === "favicon.ico") {
+					const cacheKey = `ico:${svgPath}`;
+					let ico = devCache.get(cacheKey);
+					if (!ico) {
+						const result = await generateIco(svgPath);
+						if (result) {
+							ico = result;
+							devCache.set(cacheKey, result);
+						}
+					}
 					if (ico) {
 						res.setHeader("Content-Type", "image/x-icon");
 						res.setHeader("Cache-Control", "no-cache");
@@ -2600,16 +2893,17 @@ function faviconPlugin(config) {
 						return;
 					}
 				}
-				if (url === "/site.webmanifest" && generateManifest) {
+				if (baseName === "site.webmanifest" && generateManifest) {
+					const prefix = localeSource ? `/${localeSource.locale}` : "";
 					const manifest = {
 						name: config.name ?? "App",
 						short_name: config.name ?? "App",
 						icons: [{
-							src: "/icon-192.png",
+							src: `${prefix}/icon-192.png`,
 							sizes: "192x192",
 							type: "image/png"
 						}, {
-							src: "/icon-512.png",
+							src: `${prefix}/icon-512.png`,
 							sizes: "512x512",
 							type: "image/png"
 						}],
@@ -2683,61 +2977,8 @@ function faviconPlugin(config) {
 		},
 		async generateBundle() {
 			if (!isBuild) return;
-			const sourcePath = join(root, config.source);
-			if (!existsSync(sourcePath)) {
-				console.warn(`[zero:favicon] Source not found: ${sourcePath}`);
-				return;
-			}
-			if (config.source.endsWith(".svg")) {
-				const svgContent = await readFile(sourcePath, "utf-8");
-				let finalSvg = svgContent;
-				if (config.darkSource) {
-					const darkPath = join(root, config.darkSource);
-					if (existsSync(darkPath)) finalSvg = wrapSvgWithDarkMode(svgContent, await readFile(darkPath, "utf-8"));
-				}
-				this.emitFile({
-					type: "asset",
-					fileName: "favicon.svg",
-					source: finalSvg
-				});
-			}
-			for (const { size, name } of SIZES) {
-				const pngBuffer = await resizeToPng(sourcePath, size);
-				if (pngBuffer) this.emitFile({
-					type: "asset",
-					fileName: name,
-					source: pngBuffer
-				});
-			}
-			const ico = await generateIco(sourcePath);
-			if (ico) this.emitFile({
-				type: "asset",
-				fileName: "favicon.ico",
-				source: ico
-			});
-			if (generateManifest) {
-				const manifest = {
-					name: config.name ?? "App",
-					short_name: config.name ?? "App",
-					icons: [{
-						src: "/icon-192.png",
-						sizes: "192x192",
-						type: "image/png"
-					}, {
-						src: "/icon-512.png",
-						sizes: "512x512",
-						type: "image/png"
-					}],
-					theme_color: themeColor,
-					background_color: backgroundColor,
-					display: "standalone"
-				};
-				this.emitFile({
-					type: "asset",
-					fileName: "site.webmanifest",
-					source: JSON.stringify(manifest, null, 2)
-				});
-			}
+			await generateFaviconSet.call(this, root, config.source, config.darkSource, "", config, themeColor, backgroundColor, generateManifest);
+			if (config.locales) for (const [locale, localeConfig] of Object.entries(config.locales)) await generateFaviconSet.call(this, root, localeConfig.source, localeConfig.darkSource, `${locale}/`, config, themeColor, backgroundColor, generateManifest);
 		}
 	};
 }
@@ -2758,6 +2999,126 @@ function wrapSvgWithDarkMode(lightSvg, darkSvg) {
 function stripSvgWrapper(svg) {
 	return svg.replace(/<svg[^>]*>/, "").replace(/<\/svg>\s*$/, "").trim();
 }
+/**
+* Resolve the source path for a locale-prefixed favicon URL.
+* Returns null if the URL is not locale-prefixed or locale has no override.
+*/
+function resolveLocaleSource(url, config, rootDir) {
+	if (!config.locales) return null;
+	for (const [locale, localeConfig] of Object.entries(config.locales)) {
+		const prefix = `/${locale}/`;
+		if (url.startsWith(prefix)) return {
+			locale,
+			url,
+			source: localeConfig.source,
+			sourcePath: join(rootDir, localeConfig.source)
+		};
+	}
+	return null;
+}
+/**
+* Generate a complete favicon set (SVG, PNGs, ICO, manifest) with a file prefix.
+* Called once for base (prefix = '') and once per locale (prefix = '{locale}/').
+*/
+async function generateFaviconSet(rootDir, source, darkSource, prefix, config, themeColor, backgroundColor, generateManifest) {
+	const sourcePath = join(rootDir, source);
+	if (!existsSync(sourcePath)) {
+		console.warn(`[zero:favicon] Source not found: ${sourcePath}`);
+		return;
+	}
+	if (source.endsWith(".svg")) {
+		const svgContent = await readFile(sourcePath, "utf-8");
+		let finalSvg = svgContent;
+		if (darkSource) {
+			const darkPath = join(rootDir, darkSource);
+			if (existsSync(darkPath)) finalSvg = wrapSvgWithDarkMode(svgContent, await readFile(darkPath, "utf-8"));
+		}
+		this.emitFile({
+			type: "asset",
+			fileName: `${prefix}favicon.svg`,
+			source: finalSvg
+		});
+	}
+	for (const { size, name } of SIZES) {
+		const pngBuffer = await resizeToPng(sourcePath, size);
+		if (pngBuffer) this.emitFile({
+			type: "asset",
+			fileName: `${prefix}${name}`,
+			source: pngBuffer
+		});
+	}
+	const ico = await generateIco(sourcePath);
+	if (ico) this.emitFile({
+		type: "asset",
+		fileName: `${prefix}favicon.ico`,
+		source: ico
+	});
+	if (generateManifest) {
+		const manifestPrefix = prefix ? `/${prefix.slice(0, -1)}` : "";
+		const manifest = {
+			name: config.name ?? "App",
+			short_name: config.name ?? "App",
+			icons: [{
+				src: `${manifestPrefix}/icon-192.png`,
+				sizes: "192x192",
+				type: "image/png"
+			}, {
+				src: `${manifestPrefix}/icon-512.png`,
+				sizes: "512x512",
+				type: "image/png"
+			}],
+			theme_color: themeColor,
+			background_color: backgroundColor,
+			display: "standalone"
+		};
+		this.emitFile({
+			type: "asset",
+			fileName: `${prefix}site.webmanifest`,
+			source: JSON.stringify(manifest, null, 2)
+		});
+	}
+}
+/**
+* Get favicon link tags for a specific locale.
+* Returns link objects suitable for `useHead()` or direct HTML injection.
+*
+* @example
+* ```ts
+* const links = faviconLinks("de", { source: "./icon.svg", locales: { de: { source: "./icon-de.svg" } } })
+* // → [{ rel: "icon", type: "image/svg+xml", href: "/de/favicon.svg" }, ...]
+* ```
+*/
+function faviconLinks(locale, config) {
+	const hasLocaleOverride = locale && config.locales?.[locale];
+	const prefix = hasLocaleOverride ? `/${locale}` : "";
+	const isSvg = (hasLocaleOverride ? config.locales[locale].source : config.source).endsWith(".svg");
+	const links = [];
+	if (isSvg) links.push({
+		rel: "icon",
+		type: "image/svg+xml",
+		href: `${prefix}/favicon.svg`
+	});
+	links.push({
+		rel: "icon",
+		type: "image/png",
+		sizes: "32x32",
+		href: `${prefix}/favicon-32x32.png`
+	}, {
+		rel: "icon",
+		type: "image/png",
+		sizes: "16x16",
+		href: `${prefix}/favicon-16x16.png`
+	}, {
+		rel: "apple-touch-icon",
+		sizes: "180x180",
+		href: `${prefix}/apple-touch-icon.png`
+	});
+	if (config.manifest !== false) links.push({
+		rel: "manifest",
+		href: `${prefix}/site.webmanifest`
+	});
+	return links;
+}
 async function resizeToPng(input, size) {
 	try {
 		return await (await import("sharp").then((m) => m.default ?? m))(input).resize(size, size, {
@@ -2770,7 +3131,7 @@ async function resizeToPng(input, size) {
 			}
 		}).png().toBuffer();
 	} catch {
-		warnSharpMissing();
+		warnSharpMissing$1();
 		return null;
 	}
 }
@@ -2803,7 +3164,7 @@ async function generateIco(input) {
 			size: 32
 		}]);
 	} catch {
-		warnSharpMissing();
+		warnSharpMissing$1();
 		return null;
 	}
 }
@@ -2841,95 +3202,323 @@ function createIcoFromPngs(entries) {
 }
 
 //#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;
-}
+//#region src/og-image.ts
 /**
-* 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.
+* OG Image generation plugin.
 *
-* - 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
+* Generates Open Graph images at build time from templates with
+* text overlays. Supports locale-specific text for i18n apps.
+* Uses sharp for image processing (same optional dep as favicon/image plugins).
 *
 * @example
 * ```ts
-* // zero.config.ts
-* import { i18nRouting } from "@pyreon/zero"
+* // vite.config.ts
+* import { ogImagePlugin } from "@pyreon/zero/og-image"
 *
-* export default defineConfig({
+* export default {
 *   plugins: [
-*     i18nRouting({
+*     ogImagePlugin({
 *       locales: ["en", "de", "cs"],
-*       defaultLocale: "en",
+*       templates: [{
+*         name: "default",
+*         background: "./src/assets/og-bg.jpg",
+*         layers: [{
+*           text: { en: "Build faster", de: "Schneller bauen", cs: "Stavte rychleji" },
+*           y: "40%",
+*           fontSize: 72,
+*         }],
+*       }],
 *     }),
 *   ],
-* })
+* }
 * ```
 */
-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",
+let sharpWarned = false;
+function warnSharpMissing() {
+	if (sharpWarned) return;
+	sharpWarned = true;
+	console.warn("\n[zero:og-image] sharp not installed — OG images will not be generated. Install for full support: bun add -D sharp\n");
+}
+function resolvePosition(value, dimension, fallback = "50%") {
+	if (value === void 0) value = fallback;
+	if (typeof value === "number") return value;
+	if (value.endsWith("%")) return Math.round(Number.parseFloat(value) / 100 * dimension);
+	return Number.parseInt(value, 10) || 0;
+}
+function resolveLayerText(layer, locale) {
+	if (typeof layer.text === "string") return layer.text;
+	if (typeof layer.text === "function") return layer.text(locale);
+	return layer.text[locale] ?? layer.text[Object.keys(layer.text)[0] ?? ""] ?? "";
+}
+function escapeXml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Build an SVG overlay with text layers.
+* @internal Exported for testing.
+*/
+function buildTextOverlaySvg(layers, width, height, locale) {
+	return `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">${layers.map((layer) => {
+		const text = resolveLayerText(layer, locale);
+		const x = resolvePosition(layer.x, width, "50%");
+		const y = resolvePosition(layer.y, height, "50%");
+		const fontSize = layer.fontSize ?? 64;
+		const fontFamily = layer.fontFamily ?? "sans-serif";
+		const fontWeight = layer.fontWeight ?? "bold";
+		const color = layer.color ?? "#ffffff";
+		const anchor = layer.textAnchor ?? "middle";
+		const maxWidth = layer.maxWidth ?? Math.round(width * .8);
+		const words = text.split(" ");
+		const lines = [];
+		let currentLine = "";
+		const estimateWidth = (s) => {
+			let width = 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;
+			}
+			return width;
+		};
+		for (const word of words) {
+			const testLine = currentLine ? `${currentLine} ${word}` : word;
+			if (estimateWidth(testLine) > maxWidth && currentLine) {
+				lines.push(currentLine);
+				currentLine = word;
+			} else currentLine = testLine;
+		}
+		if (currentLine) lines.push(currentLine);
+		const tspans = lines.map((line, i) => {
+			return `<tspan x="${x}" dy="${i === 0 ? "0" : `${fontSize * 1.2}`}">${escapeXml(line)}</tspan>`;
+		}).join("");
+		return `<text x="${x}" y="${y}" font-size="${fontSize}" font-family="${escapeXml(fontFamily)}" font-weight="${fontWeight}" fill="${color}" text-anchor="${anchor}" dominant-baseline="middle">${tspans}</text>`;
+	}).join("")}</svg>`;
+}
+/**
+* Render an OG image from a template for a specific locale.
+* @internal Exported for testing.
+*/
+async function renderOgImage(template, locale, rootDir) {
+	try {
+		const sharp = await import("sharp").then((m) => m.default ?? m);
+		const width = template.width ?? 1200;
+		const height = template.height ?? 630;
+		let pipeline;
+		if (typeof template.background === "string") pipeline = sharp(join(rootDir, template.background)).resize(width, height, { fit: "cover" });
+		else pipeline = sharp({ create: {
+			width,
+			height,
+			channels: 4,
+			background: template.background.color
+		} });
+		if (template.layers && template.layers.length > 0) {
+			const svgOverlay = buildTextOverlaySvg(template.layers, width, height, locale);
+			pipeline = pipeline.composite([{
+				input: Buffer.from(svgOverlay),
+				top: 0,
+				left: 0
+			}]);
+		}
+		if (template.format === "jpeg") return await pipeline.jpeg({ quality: template.quality ?? 90 }).toBuffer();
+		return await pipeline.png().toBuffer();
+	} catch {
+		warnSharpMissing();
+		return null;
+	}
+}
+/**
+* Compute the OG image path for a template and locale.
+*
+* @example
+* ```ts
+* ogImagePath("default", "de")      // → "/og/default-de.png"
+* ogImagePath("default")            // → "/og/default.png"
+* ogImagePath("hero", "en", "images") // → "/images/hero-en.png"
+* ```
+*/
+function ogImagePath(templateName, locale, outDir = "og", format = "png") {
+	const ext = format === "jpeg" ? "jpg" : "png";
+	return `/${outDir}/${templateName}${locale ? `-${locale}` : ""}.${ext}`;
+}
+/**
+* OG image generation Vite plugin.
+*
+* Generates Open Graph images at build time. In dev, generates on-demand.
+* Requires `sharp` as an optional dependency.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { ogImagePlugin } from "@pyreon/zero/og-image"
+*
+* export default {
+*   plugins: [
+*     ogImagePlugin({
+*       locales: ["en", "de"],
+*       templates: [{
+*         name: "default",
+*         background: { color: "#0066ff" },
+*         layers: [{ text: { en: "Hello", de: "Hallo" }, fontSize: 72 }],
+*       }],
+*     }),
+*   ],
+* }
+* ```
+*/
+function ogImagePlugin(config) {
+	const outDir = config.outDir ?? "og";
+	let root = "";
+	let isBuild = false;
+	return {
+		name: "pyreon-zero-og-image",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			isBuild = resolvedConfig.command === "build";
+		},
+		configureServer(server) {
+			const devCache = /* @__PURE__ */ new Map();
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url ?? "";
+				if (!url.startsWith(`/${outDir}/`)) return next();
+				const match = url.slice(outDir.length + 2).match(/^(.+?)(?:-([a-z]{2,5}))?\.(png|jpe?g)$/);
+				if (!match) return next();
+				const [, templateName, locale, ext] = match;
+				const template = config.templates.find((t) => t.name === templateName);
+				if (!template) return next();
+				const resolvedLocale = locale ?? config.locales?.[0] ?? "en";
+				const cacheKey = `${templateName}:${resolvedLocale}`;
+				let buffer = devCache.get(cacheKey);
+				if (!buffer) {
+					const result = await renderOgImage(template, resolvedLocale, root);
+					if (!result) return next();
+					buffer = result;
+					devCache.set(cacheKey, result);
+				}
+				const contentType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+				res.setHeader("Content-Type", contentType);
+				res.setHeader("Cache-Control", "no-cache");
+				res.end(Buffer.from(buffer));
+			});
+		},
+		async generateBundle() {
+			if (!isBuild) return;
+			for (const template of config.templates) {
+				const locales = config.locales ?? [void 0];
+				const ext = (template.format ?? "png") === "jpeg" ? "jpg" : "png";
+				for (const locale of locales) {
+					if (typeof template.background === "string") {
+						const bgPath = join(root, template.background);
+						if (!existsSync(bgPath)) {
+							console.warn(`[zero:og-image] Background not found: ${bgPath}`);
+							continue;
+						}
+					}
+					const buffer = await renderOgImage(template, locale ?? "en", root);
+					if (!buffer) continue;
+					const suffix = locale ? `-${locale}` : "";
+					this.emitFile({
+						type: "asset",
+						fileName: `${outDir}/${template.name}${suffix}.${ext}`,
+						source: buffer
+					});
+				}
+			}
+		}
+	};
+}
+
+//#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) => {
@@ -3026,7 +3615,7 @@ const resolveStr = (v) => typeof v === "function" ? v() : v;
 function Meta(props) {
 	const hasReactiveTitle = typeof props.title === "function";
 	const hasReactiveDescription = typeof props.description === "function";
-	if (hasReactiveTitle || hasReactiveDescription) useHead((() => {
+	if (hasReactiveTitle || hasReactiveDescription) useHead(() => {
 		const title = resolveStr(props.title);
 		const description = resolveStr(props.description);
 		const tags = buildMetaTags({
@@ -3034,13 +3623,14 @@ function Meta(props) {
 			title,
 			description
 		});
-		return {
-			title,
+		const input = {
 			meta: tags.meta,
 			link: tags.link,
 			script: tags.script
 		};
-	}));
+		if (title) input.title = title;
+		return input;
+	});
 	else {
 		const title = resolveStr(props.title);
 		const description = resolveStr(props.description);
@@ -3049,12 +3639,13 @@ function Meta(props) {
 			title,
 			description
 		});
-		useHead({
-			title,
+		const input = {
 			meta: tags.meta,
 			link: tags.link,
 			script: tags.script
-		});
+		};
+		if (title) input.title = title;
+		useHead(input);
 	}
 	return props.children ?? null;
 }
@@ -3062,7 +3653,11 @@ function buildMetaTags(props) {
 	const meta = [];
 	const link = [];
 	const script = [];
-	const { title, description, canonical, image, imageAlt, type = "website", siteName, twitterCard = "summary_large_image", twitterSite, twitterCreator, locale = "en_US", alternateLocales, robots = "index, follow", publishedTime, modifiedTime, author, tags, jsonLd, extra } = props;
+	const { title, description, canonical, imageAlt, imageWidth, imageHeight, type = "website", siteName, twitterCard = "summary_large_image", twitterSite, twitterCreator, locale = "en_US", alternateLocales, publishedTime, modifiedTime, author, tags, jsonLd, extra, video, videoWidth, videoHeight, audio, favicon, ogTemplate, ogImageDir, ogImageFormat } = props;
+	const robots = props.noIndex ? "noindex, nofollow" : props.robots ?? "index, follow";
+	const image = props.image ?? (ogTemplate ? ogImagePath(ogTemplate, locale !== "en_US" ? locale : void 0, ogImageDir, ogImageFormat) : void 0);
+	const resolvedImageWidth = imageWidth ?? (ogTemplate && !props.image ? 1200 : void 0);
+	const resolvedImageHeight = imageHeight ?? (ogTemplate && !props.image ? 630 : void 0);
 	if (description) meta.push({
 		name: "description",
 		content: description
@@ -3095,6 +3690,14 @@ function buildMetaTags(props) {
 		property: "og:image:alt",
 		content: imageAlt
 	});
+	if (resolvedImageWidth) meta.push({
+		property: "og:image:width",
+		content: String(resolvedImageWidth)
+	});
+	if (resolvedImageHeight) meta.push({
+		property: "og:image:height",
+		content: String(resolvedImageHeight)
+	});
 	meta.push({
 		property: "og:type",
 		content: type
@@ -3107,6 +3710,32 @@ function buildMetaTags(props) {
 		property: "og:locale",
 		content: locale
 	});
+	if (video) {
+		meta.push({
+			property: "og:video",
+			content: video
+		});
+		if (videoWidth) meta.push({
+			property: "og:video:width",
+			content: String(videoWidth)
+		});
+		if (videoHeight) meta.push({
+			property: "og:video:height",
+			content: String(videoHeight)
+		});
+		if (video.endsWith(".mp4")) meta.push({
+			property: "og:video:type",
+			content: "video/mp4"
+		});
+		else if (video.endsWith(".webm")) meta.push({
+			property: "og:video:type",
+			content: "video/webm"
+		});
+	}
+	if (audio) meta.push({
+		property: "og:audio",
+		content: audio
+	});
 	if (type === "article") {
 		if (publishedTime) meta.push({
 			property: "article:published_time",
@@ -3193,6 +3822,14 @@ function buildMetaTags(props) {
 			href: `${origin}${pathWithoutLocale}`
 		});
 	}
+	if (favicon) {
+		const faviconLocale = locale !== "en_US" ? locale : void 0;
+		for (const fl of faviconLinks(faviconLocale, favicon)) link.push(fl);
+		if (favicon.themeColor) meta.push({
+			name: "theme-color",
+			content: favicon.themeColor
+		});
+	}
 	return {
 		meta,
 		link,
@@ -3201,5 +3838,820 @@ function buildMetaTags(props) {
 }
 
 //#endregion
-export { Image, Link, Meta, Script, ThemeToggle, buildLocalePath, buildMetaTags, bunAdapter, cacheMiddleware, compose, compressResponse, compressionMiddleware, corsMiddleware, createActionMiddleware, createApiMiddleware, createApp, createISRHandler, createLink, createLocaleContext, createServer, zeroPlugin as default, defineAction, defineConfig, detectLocaleFromHeader, extractLocaleFromPath, faviconPlugin, filePathToUrlPath, fontPlugin, fontVariables, generateApiRouteModule, generateMiddlewareModule, generateRobots, generateRouteModule, generateSitemap, getContext, i18nRouting, imagePlugin, initTheme, isCompressible, jsonLd, nodeAdapter, parseFileRoutes, prefetchRoute, rateLimitMiddleware, render404Page, resolveAdapter, resolveConfig, resolvedTheme, scanRouteFiles, securityHeaders, seoMiddleware, seoPlugin, setLocale, setTheme, staticAdapter, theme, themeScript, toggleTheme, useLink, useLocale, varyEncoding };
+//#region src/csp.ts
+/** Client-side fallback nonce (dev server, SPA). */
+let _clientNonce = "";
+/**
+* Read the current CSP nonce in a component.
+*
+* SSR: reads from per-request `ctx.locals.cspNonce` via Pyreon's context
+* system — fully isolated between concurrent requests via AsyncLocalStorage.
+* Client/dev: falls back to module-level variable set by middleware.
+*
+* @example
+* ```tsx
+* import { useNonce } from "@pyreon/zero/csp"
+*
+* function InlineScript() {
+*   const nonce = useNonce()
+*   return <script nonce={nonce}>console.log("safe")<\/script>
+* }
+* ```
+*/
+function useNonce() {
+	const locals = useRequestLocals();
+	if (locals.cspNonce) return locals.cspNonce;
+	return _clientNonce;
+}
+const DIRECTIVE_MAP = {
+	defaultSrc: "default-src",
+	scriptSrc: "script-src",
+	styleSrc: "style-src",
+	imgSrc: "img-src",
+	fontSrc: "font-src",
+	connectSrc: "connect-src",
+	mediaSrc: "media-src",
+	objectSrc: "object-src",
+	frameSrc: "frame-src",
+	childSrc: "child-src",
+	workerSrc: "worker-src",
+	frameAncestors: "frame-ancestors",
+	formAction: "form-action",
+	baseUri: "base-uri",
+	manifestSrc: "manifest-src",
+	reportUri: "report-uri",
+	reportTo: "report-to"
+};
+/**
+* Build a CSP header string from directives.
+* Exported for testing.
+*/
+function buildCspHeader(directives, nonce) {
+	const parts = [];
+	for (const [key, cssProp] of Object.entries(DIRECTIVE_MAP)) {
+		const value = directives[key];
+		if (!value) continue;
+		if (Array.isArray(value)) {
+			const resolved = nonce ? value.map((v) => v === "'nonce'" ? `'nonce-${nonce}'` : v) : value.filter((v) => v !== "'nonce'");
+			parts.push(`${cssProp} ${resolved.join(" ")}`);
+		} else if (typeof value === "string") parts.push(`${cssProp} ${value}`);
+	}
+	if (directives.upgradeInsecureRequests) parts.push("upgrade-insecure-requests");
+	if (directives.blockAllMixedContent) parts.push("block-all-mixed-content");
+	return parts.join("; ");
+}
+/**
+* Generate a random nonce string (base64, 16 bytes).
+*/
+function generateNonce() {
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+		const bytes = new Uint8Array(16);
+		crypto.getRandomValues(bytes);
+		let binary = "";
+		for (const byte of bytes) binary += String.fromCharCode(byte);
+		return typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+	}
+	return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+/**
+* CSP middleware — sets Content-Security-Policy header.
+*
+* When directives contain `"'nonce'"`, a fresh nonce is generated per-request
+* and attached to `ctx.locals.cspNonce` for use in inline script tags.
+*
+* @example
+* ```ts
+* // Apply to all routes
+* export default defineConfig({
+*   middleware: [
+*     cspMiddleware({
+*       directives: {
+*         defaultSrc: ["'self'"],
+*         scriptSrc: ["'self'", "'nonce'"],
+*         styleSrc: ["'self'", "'unsafe-inline'"],
+*         imgSrc: ["'self'", "data:", "https:"],
+*       },
+*     }),
+*   ],
+* })
+* ```
+*/
+function cspMiddleware(config) {
+	const headerName = config.reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy";
+	const staticHeader = Object.values(config.directives).some((v) => Array.isArray(v) && v.includes("'nonce'")) ? null : buildCspHeader(config.directives);
+	return (ctx) => {
+		if (staticHeader) {
+			_clientNonce = "";
+			ctx.headers.set(headerName, staticHeader);
+		} else {
+			const nonce = generateNonce();
+			_clientNonce = nonce;
+			ctx.locals.cspNonce = nonce;
+			ctx.headers.set(headerName, buildCspHeader(config.directives, nonce));
+		}
+	};
+}
+
+//#endregion
+//#region src/logger.ts
+const COLORS = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	red: "\x1B[31m",
+	cyan: "\x1B[36m",
+	magenta: "\x1B[35m"
+};
+function methodColor(method, colors) {
+	if (!colors) return method.padEnd(7);
+	const padded = method.padEnd(7);
+	switch (method) {
+		case "GET": return `${COLORS.green}${padded}${COLORS.reset}`;
+		case "POST": return `${COLORS.cyan}${padded}${COLORS.reset}`;
+		case "PUT": return `${COLORS.yellow}${padded}${COLORS.reset}`;
+		case "PATCH": return `${COLORS.yellow}${padded}${COLORS.reset}`;
+		case "DELETE": return `${COLORS.red}${padded}${COLORS.reset}`;
+		default: return `${COLORS.magenta}${padded}${COLORS.reset}`;
+	}
+}
+function defaultFormat(entry, colors) {
+	const dur = entry.duration < 1 ? "<1ms" : entry.duration < 1e3 ? `${Math.round(entry.duration)}ms` : `${(entry.duration / 1e3).toFixed(2)}s`;
+	const dim = colors ? COLORS.dim : "";
+	const reset = colors ? COLORS.reset : "";
+	return `  ${methodColor(entry.method, colors)} ${entry.path} ${dim}${dur}${reset}`;
+}
+/**
+* Request logging middleware.
+*
+* Logs incoming requests with method, path, and duration.
+* Runs in middleware phase — logs timing from middleware start to
+* microtask completion (approximate request duration).
+*
+* @example
+* ```ts
+* // Basic usage
+* loggerMiddleware()
+*
+* // Custom format
+* loggerMiddleware({
+*   format: (e) => `${e.method} ${e.path} (${e.duration}ms)`,
+* })
+* ```
+*/
+function loggerMiddleware(config) {
+	if ((config?.level ?? "all") === "none") return () => {};
+	const skip = config?.skip ?? [
+		"/__",
+		"/@",
+		"/node_modules"
+	];
+	const isDev = typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+	const colors = config?.colors ?? isDev;
+	return (ctx) => {
+		if (skip.some((p) => ctx.path.startsWith(p))) return;
+		const start = performance.now();
+		const entry = {
+			method: ctx.req.method ?? "GET",
+			path: ctx.path,
+			duration: 0,
+			timestamp: /* @__PURE__ */ new Date(),
+			userAgent: ctx.req.headers.get("user-agent") ?? void 0
+		};
+		queueMicrotask(() => {
+			entry.duration = performance.now() - start;
+			if (config?.format) {
+				const line = config.format(entry);
+				if (line) console.log(line);
+			} else console.log(defaultFormat(entry, colors));
+		});
+	};
+}
+
+//#endregion
+//#region src/env.ts
+/**
+* String validator — accepts any non-empty string.
+*/
+function str(options) {
+	return {
+		__type: "env-validator",
+		required: options?.default === void 0 && options?.required !== false,
+		defaultValue: options?.default,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") {
+				if (options?.default !== void 0) return options.default;
+				throw new EnvError(key, "is required but not set", options?.description);
+			}
+			return raw;
+		}
+	};
+}
+/**
+* Number validator — parses to a number, rejects NaN.
+*/
+function num(options) {
+	return {
+		__type: "env-validator",
+		required: options?.default === void 0 && options?.required !== false,
+		defaultValue: options?.default,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") {
+				if (options?.default !== void 0) return options.default;
+				throw new EnvError(key, "is required but not set", options?.description);
+			}
+			const n = Number(raw);
+			if (Number.isNaN(n)) throw new EnvError(key, `must be a number, got "${raw}"`, options?.description);
+			return n;
+		}
+	};
+}
+/**
+* Boolean validator — accepts "true"/"1" as true, "false"/"0" as false.
+*/
+function bool(options) {
+	return {
+		__type: "env-validator",
+		required: options?.default === void 0 && options?.required !== false,
+		defaultValue: options?.default,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") {
+				if (options?.default !== void 0) return options.default;
+				throw new EnvError(key, "is required but not set", options?.description);
+			}
+			const lower = raw.toLowerCase();
+			if (lower === "true" || lower === "1") return true;
+			if (lower === "false" || lower === "0") return false;
+			throw new EnvError(key, `must be "true" or "false", got "${raw}"`, options?.description);
+		}
+	};
+}
+/**
+* URL validator — validates that the value is a valid URL.
+*/
+function url(options) {
+	return {
+		__type: "env-validator",
+		required: options?.default === void 0 && options?.required !== false,
+		defaultValue: options?.default,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") {
+				if (options?.default !== void 0) return options.default;
+				throw new EnvError(key, "is required but not set", options?.description);
+			}
+			try {
+				new URL(raw);
+				return raw;
+			} catch {
+				throw new EnvError(key, `must be a valid URL, got "${raw}"`, options?.description);
+			}
+		}
+	};
+}
+/**
+* Enum validator — value must be one of the allowed values.
+*/
+function oneOf(values, options) {
+	return {
+		__type: "env-validator",
+		required: options?.default === void 0 && options?.required !== false,
+		defaultValue: options?.default,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") {
+				if (options?.default !== void 0) return options.default;
+				throw new EnvError(key, "is required but not set", options?.description);
+			}
+			if (!values.includes(raw)) throw new EnvError(key, `must be one of [${values.join(", ")}], got "${raw}"`, options?.description);
+			return raw;
+		}
+	};
+}
+var EnvError = class extends Error {
+	constructor(key, message, description) {
+		const desc = description ? ` (${description})` : "";
+		super(`[zero:env] ${key}${desc}: ${message}`);
+		this.name = "EnvError";
+	}
+};
+function isEnvValidator(v) {
+	return typeof v === "object" && v !== null && v.__type === "env-validator";
+}
+/**
+* Convert a plain schema value to an EnvValidator.
+*
+* - `3000` → num({ default: 3000 })
+* - `false` → bool({ default: false })
+* - `"localhost"` → str({ default: "localhost" })
+* - `String` → str() (required)
+* - `Number` → num() (required)
+* - `Boolean` → bool() (required)
+* - EnvValidator → pass through
+*/
+function toValidator(value) {
+	if (isEnvValidator(value)) return value;
+	if (value === String) return str();
+	if (value === Number) return num();
+	if (value === Boolean) return bool();
+	if (typeof value === "number") return num({ default: value });
+	if (typeof value === "boolean") return bool({ default: value });
+	if (typeof value === "string") return str({ default: value });
+	throw new Error(`[zero:env] Invalid schema value: ${String(value)}. Use a default value, String/Number/Boolean, or a validator like url().`);
+}
+/**
+* Validate environment variables.
+*
+* Schema values can be:
+* - **Default values**: `3000`, `false`, `"localhost"` → type inferred, used as default
+* - **Constructors**: `String`, `Number`, `Boolean` → required, no default
+* - **Validators**: `url()`, `oneOf([...])`, `str()`, `num()`, `bool()` → explicit validation
+* - **Custom**: `schema(raw => z.coerce.number().parse(raw))` — bridge to any schema library
+*
+* @example
+* ```ts
+* import { validateEnv, url, oneOf } from "@pyreon/zero/env"
+*
+* const env = validateEnv({
+*   PORT: 3000,                                // optional, default 3000
+*   DATABASE_URL: url(),                       // required, validated URL
+*   NODE_ENV: oneOf(["dev", "prod", "test"]),  // required, must be one of
+*   API_KEY: String,                           // required string
+*   DEBUG: false,                              // optional, default false
+* })
+* ```
+*/
+function validateEnv(schema, source) {
+	const env = source ?? (typeof process !== "undefined" ? process.env : {});
+	const result = {};
+	const errors = [];
+	for (const [key, entry] of Object.entries(schema)) {
+		const validator = toValidator(entry);
+		try {
+			result[key] = validator.parse(env[key], key);
+		} catch (e) {
+			errors.push(e.message);
+		}
+	}
+	if (errors.length > 0) {
+		const header = `\n[zero:env] Environment validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):\n`;
+		const body = errors.map((e) => `  ✗ ${e.replace("[zero:env] ", "")}`).join("\n");
+		throw new Error(header + body + "\n");
+	}
+	return result;
+}
+function publicEnv(schema) {
+	const prefix = "ZERO_PUBLIC_";
+	const env = typeof process !== "undefined" ? process.env : {};
+	if (!schema) {
+		const result = {};
+		for (const [key, value] of Object.entries(env)) if (key.startsWith(prefix) && value !== void 0) result[key.slice(12)] = value;
+		return result;
+	}
+	const prefixedSource = {};
+	for (const key of Object.keys(schema)) prefixedSource[key] = env[`${prefix}${key}`];
+	return validateEnv(schema, prefixedSource);
+}
+/**
+* Create an env validator from a custom parse function.
+* Use this to integrate any schema library (Zod, Valibot, ArkType, etc.).
+*
+* @example
+* ```ts
+* import { z } from "zod"
+* import { validateEnv, schema } from "@pyreon/zero/env"
+*
+* const env = validateEnv({
+*   PORT: schema(raw => z.coerce.number().parse(raw)),
+*   DATABASE_URL: schema(raw => z.string().url().parse(raw)),
+*   HOST: "localhost",  // plain defaults still work alongside
+* })
+* ```
+*/
+function schema(parse) {
+	return {
+		__type: "env-validator",
+		required: true,
+		defaultValue: void 0,
+		parse(raw, key) {
+			if (raw === void 0 || raw === "") throw new Error(`[zero:env] ${key}: is required but not set`);
+			try {
+				return parse(raw);
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				throw new Error(`[zero:env] ${key}: ${msg}`);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/ai.ts
+/**
+* Generate llms.txt content from route files and config.
+*
+* Format follows the llms.txt proposal:
+* ```
+* # {name}
+* > {description}
+*
+* ## Pages
+* - [/about](/about): About page
+*
+* ## API
+* - GET /api/posts: List posts
+* ```
+*
+* @internal Exported for testing.
+*/
+function generateLlmsTxt(routeFiles, apiFiles, config) {
+	const lines = [];
+	lines.push(`# ${config.name}`);
+	lines.push(`> ${config.description}`);
+	lines.push("");
+	const routes = parseFileRoutes(routeFiles);
+	const pages = routes.filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound && !r.isCatchAll && !r.urlPath.includes(":"));
+	if (pages.length > 0) {
+		lines.push("## Pages");
+		lines.push("");
+		for (const page of pages) {
+			const desc = config.pageDescriptions?.[page.urlPath];
+			const url = `${config.origin}${page.urlPath === "/" ? "" : page.urlPath}`;
+			if (desc) lines.push(`- [${page.urlPath}](${url}): ${desc}`);
+			else lines.push(`- [${page.urlPath}](${url})`);
+		}
+		lines.push("");
+	}
+	const dynamicRoutes = routes.filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound && (r.urlPath.includes(":") || r.isCatchAll));
+	if (dynamicRoutes.length > 0) {
+		lines.push("## Dynamic Pages");
+		lines.push("");
+		for (const route of dynamicRoutes) {
+			const desc = config.pageDescriptions?.[route.urlPath];
+			if (desc) lines.push(`- ${route.urlPath}: ${desc}`);
+			else lines.push(`- ${route.urlPath}`);
+		}
+		lines.push("");
+	}
+	const apiPatterns = parseApiFiles(apiFiles);
+	if (apiPatterns.length > 0 || config.apiDescriptions) {
+		lines.push("## API Endpoints");
+		lines.push("");
+		if (config.apiDescriptions) for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) lines.push(`- ${endpoint}: ${desc}`);
+		const describedPatterns = new Set(Object.keys(config.apiDescriptions ?? {}).map((k) => k.replace(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+/, "")));
+		for (const pattern of apiPatterns) if (!describedPatterns.has(pattern)) lines.push(`- ${pattern}`);
+		lines.push("");
+	}
+	if (config.llmsExtra) {
+		lines.push(config.llmsExtra);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Generate llms-full.txt — expanded version with more detail.
+* Includes all route metadata and API descriptions.
+*
+* @internal Exported for testing.
+*/
+function generateLlmsFullTxt(routeFiles, apiFiles, config) {
+	const lines = [];
+	lines.push(`# ${config.name} — Full Reference`);
+	lines.push(`> ${config.description}`);
+	lines.push("");
+	lines.push(`Base URL: ${config.origin}`);
+	lines.push("");
+	const pages = parseFileRoutes(routeFiles).filter((r) => !r.isLayout && !r.isError && !r.isLoading && !r.isNotFound);
+	if (pages.length > 0) {
+		lines.push("## All Routes");
+		lines.push("");
+		for (const page of pages) {
+			const desc = config.pageDescriptions?.[page.urlPath] ?? "";
+			const dynamic = page.urlPath.includes(":") ? " (dynamic)" : "";
+			const catchAll = page.isCatchAll ? " (catch-all)" : "";
+			lines.push(`### ${page.urlPath}${dynamic}${catchAll}`);
+			if (desc) lines.push(desc);
+			lines.push(`- File: ${page.filePath}`);
+			lines.push(`- Render mode: ${page.renderMode}`);
+			lines.push("");
+		}
+	}
+	if (config.apiDescriptions) {
+		lines.push("## API Reference");
+		lines.push("");
+		for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) {
+			lines.push(`### ${endpoint}`);
+			lines.push(desc);
+			lines.push("");
+		}
+	}
+	if (config.llmsExtra) {
+		lines.push("## Additional Information");
+		lines.push("");
+		lines.push(config.llmsExtra);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Auto-infer JSON-LD structured data from page metadata.
+*
+* Returns an array of JSON-LD objects (multiple schemas can apply to one page).
+* For example, an article page gets both `Article` and `BreadcrumbList`.
+*
+* @example
+* ```tsx
+* const schemas = inferJsonLd({
+*   url: "https://example.com/blog/my-post",
+*   title: "My Post",
+*   description: "A great article",
+*   type: "article",
+*   author: "Vit Bokisch",
+*   publishedTime: "2026-03-31",
+* })
+* // → [Article schema, BreadcrumbList schema]
+* ```
+*/
+function inferJsonLd(options) {
+	const schemas = [];
+	if (options.type === "article") {
+		const article = {
+			"@context": "https://schema.org",
+			"@type": "Article",
+			headline: options.title,
+			url: options.url
+		};
+		if (options.description) article.description = options.description;
+		if (options.image) article.image = options.image;
+		if (options.publishedTime) article.datePublished = options.publishedTime;
+		if (options.author) article.author = {
+			"@type": "Person",
+			name: options.author
+		};
+		if (options.tags && options.tags.length > 0) article.keywords = options.tags.join(", ");
+		if (options.siteName) article.publisher = {
+			"@type": "Organization",
+			name: options.siteName
+		};
+		schemas.push(article);
+	} else if (options.type === "product") {
+		const product = {
+			"@context": "https://schema.org",
+			"@type": "Product",
+			name: options.title,
+			url: options.url
+		};
+		if (options.description) product.description = options.description;
+		if (options.image) product.image = options.image;
+		schemas.push(product);
+	} else {
+		const webpage = {
+			"@context": "https://schema.org",
+			"@type": "WebPage",
+			name: options.title,
+			url: options.url
+		};
+		if (options.description) webpage.description = options.description;
+		if (options.image) webpage.thumbnailUrl = options.image;
+		schemas.push(webpage);
+	}
+	if (options.breadcrumbs && options.breadcrumbs.length > 0) schemas.push({
+		"@context": "https://schema.org",
+		"@type": "BreadcrumbList",
+		itemListElement: options.breadcrumbs.map((bc, i) => ({
+			"@type": "ListItem",
+			position: i + 1,
+			name: bc.name,
+			item: bc.url
+		}))
+	});
+	else {
+		const urlObj = safeParseUrl(options.url);
+		if (urlObj) {
+			const segments = urlObj.pathname.split("/").filter(Boolean);
+			if (segments.length > 0) {
+				const items = [{
+					"@type": "ListItem",
+					position: 1,
+					name: "Home",
+					item: urlObj.origin
+				}];
+				let path = "";
+				for (let i = 0; i < segments.length; i++) {
+					path += `/${segments[i]}`;
+					items.push({
+						"@type": "ListItem",
+						position: i + 2,
+						name: capitalize(segments[i].replace(/-/g, " ")),
+						item: `${urlObj.origin}${path}`
+					});
+				}
+				schemas.push({
+					"@context": "https://schema.org",
+					"@type": "BreadcrumbList",
+					itemListElement: items
+				});
+			}
+		}
+	}
+	return schemas;
+}
+/**
+* Generate an OpenAI-compatible AI plugin manifest.
+*
+* Follows the /.well-known/ai-plugin.json spec.
+*
+* @internal Exported for testing.
+*/
+function generateAiPluginManifest(config) {
+	return {
+		schema_version: "v1",
+		name_for_human: config.name,
+		name_for_model: config.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, ""),
+		description_for_human: config.description,
+		description_for_model: config.description,
+		auth: { type: "none" },
+		api: {
+			type: "openapi",
+			url: `${config.origin}/.well-known/openapi.yaml`
+		},
+		logo_url: config.logoUrl ?? `${config.origin}/favicon.svg`,
+		contact_email: config.contactEmail ?? "",
+		legal_info_url: config.legalUrl ?? `${config.origin}/legal`
+	};
+}
+/**
+* Generate a minimal OpenAPI 3.0 spec from API route descriptions.
+*
+* @internal Exported for testing.
+*/
+function generateOpenApiSpec(apiFiles, config) {
+	const paths = {};
+	if (config.apiDescriptions) for (const [endpoint, desc] of Object.entries(config.apiDescriptions)) {
+		const match = endpoint.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(.+)$/);
+		if (match) {
+			const method = match[1].toLowerCase();
+			const openApiPath = match[2].replace(/:(\w+)/g, "{$1}");
+			if (!paths[openApiPath]) paths[openApiPath] = {};
+			paths[openApiPath][method] = {
+				summary: desc,
+				responses: { "200": { description: "Success" } }
+			};
+		}
+	}
+	for (const pattern of parseApiFiles(apiFiles)) {
+		const openApiPath = pattern.replace(/:(\w+)/g, "{$1}");
+		if (!paths[openApiPath]) paths[openApiPath] = { get: {
+			summary: `${openApiPath} endpoint`,
+			responses: { "200": { description: "Success" } }
+		} };
+	}
+	return {
+		openapi: "3.0.0",
+		info: {
+			title: config.name,
+			description: config.description,
+			version: "1.0.0"
+		},
+		servers: [{ url: config.origin }],
+		paths
+	};
+}
+/**
+* AI integration Vite plugin.
+*
+* Generates at build time:
+* - `/llms.txt` — concise site summary for AI agents
+* - `/llms-full.txt` — detailed reference for AI agents
+* - `/.well-known/ai-plugin.json` — OpenAI plugin manifest
+* - `/.well-known/openapi.yaml` — minimal OpenAPI spec from API routes
+*
+* In dev, serves these files via middleware.
+*
+* @example
+* ```ts
+* import { aiPlugin } from "@pyreon/zero/ai"
+*
+* export default {
+*   plugins: [
+*     aiPlugin({
+*       name: "My App",
+*       origin: "https://example.com",
+*       description: "A modern web application",
+*       apiDescriptions: {
+*         "GET /api/posts": "List blog posts",
+*         "GET /api/posts/:id": "Get post by ID",
+*       },
+*     }),
+*   ],
+* }
+* ```
+*/
+function aiPlugin(config) {
+	let root = "";
+	let isBuild = false;
+	let routeFiles = [];
+	let apiFiles = [];
+	return {
+		name: "pyreon-zero-ai",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			isBuild = resolvedConfig.command === "build";
+		},
+		async buildStart() {
+			try {
+				const { join } = await import("node:path");
+				const routesDir = join(root, config.routesDir ?? "src/routes");
+				const apiDir = join(root, config.apiDir ?? "src/api");
+				routeFiles = await scanDir(routesDir, routesDir);
+				apiFiles = await scanDir(apiDir, apiDir);
+			} catch {}
+		},
+		configureServer(server) {
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url ?? "";
+				if (url === "/llms.txt") {
+					res.setHeader("Content-Type", "text/plain; charset=utf-8");
+					res.end(generateLlmsTxt(routeFiles, apiFiles, config));
+					return;
+				}
+				if (url === "/llms-full.txt") {
+					res.setHeader("Content-Type", "text/plain; charset=utf-8");
+					res.end(generateLlmsFullTxt(routeFiles, apiFiles, config));
+					return;
+				}
+				if (url === "/.well-known/ai-plugin.json") {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(generateAiPluginManifest(config), null, 2));
+					return;
+				}
+				if (url === "/.well-known/openapi.yaml" || url === "/.well-known/openapi.json") {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(generateOpenApiSpec(apiFiles, config), null, 2));
+					return;
+				}
+				next();
+			});
+		},
+		async generateBundle() {
+			if (!isBuild) return;
+			this.emitFile({
+				type: "asset",
+				fileName: "llms.txt",
+				source: generateLlmsTxt(routeFiles, apiFiles, config)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: "llms-full.txt",
+				source: generateLlmsFullTxt(routeFiles, apiFiles, config)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: ".well-known/ai-plugin.json",
+				source: JSON.stringify(generateAiPluginManifest(config), null, 2)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: ".well-known/openapi.json",
+				source: JSON.stringify(generateOpenApiSpec(apiFiles, config), null, 2)
+			});
+		}
+	};
+}
+function parseApiFiles(files) {
+	return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js")).map((f) => {
+		let path = f.replace(/\.\w+$/, "").replace(/\/index$/, "");
+		if (!path.startsWith("/")) path = `/${path}`;
+		path = path.replace(/\[\.\.\.(\w+)\]/g, ":$1*").replace(/\[(\w+)\]/g, ":$1");
+		return `/api${path === "/" ? "" : path}`;
+	});
+}
+async function scanDir(dir, base) {
+	const { readdir, stat } = await import("node:fs/promises");
+	const { join, relative } = await import("node:path");
+	try {
+		const entries = await readdir(dir);
+		const files = [];
+		for (const entry of entries) {
+			const full = join(dir, entry);
+			if ((await stat(full)).isDirectory()) files.push(...await scanDir(full, base));
+			else files.push(relative(base, full));
+		}
+		return files;
+	} catch {
+		return [];
+	}
+}
+function safeParseUrl(url) {
+	try {
+		return new URL(url);
+	} catch {
+		return null;
+	}
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+//#endregion
+export { Image, Link, Meta, Script, ThemeToggle, aiPlugin, bool, buildCspHeader, buildLocalePath, buildMetaTags, bunAdapter, cacheMiddleware, cloudflareAdapter, compose, compressResponse, compressionMiddleware, corsMiddleware, createActionMiddleware, createApiMiddleware, createApp, createISRHandler, createLink, createLocaleContext, createServer, cspMiddleware, zeroPlugin as default, defineAction, defineConfig, detectLocaleFromHeader, extractLocaleFromPath, faviconLinks, faviconPlugin, filePathToUrlPath, fontPlugin, fontVariables, generateAiPluginManifest, generateApiRouteModule, generateLlmsFullTxt, generateLlmsTxt, generateMiddlewareModule, generateOpenApiSpec, generateRobots, generateRouteModule, generateSitemap, getContext, i18nRouting, imagePlugin, inferJsonLd, initTheme, isCompressible, jsonLd, loggerMiddleware, netlifyAdapter, nodeAdapter, num, ogImagePath, ogImagePlugin, oneOf, parseFileRoutes, prefetchRoute, publicEnv, rateLimitMiddleware, render404Page, resolveAdapter, resolveConfig, resolvedTheme, scanRouteFiles, schema, securityHeaders, seoMiddleware, seoPlugin, setLocale, setSSRThemeDefault, setTheme, staticAdapter, str, theme, themeScript, toggleTheme, url, useLink, useLocale, useNonce, validateEnv, varyEncoding, vercelAdapter };
 //# sourceMappingURL=index.js.map