@pyreon/zero 0.12.0 → 0.12.2

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";
@@ -709,6 +709,152 @@ 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) {
+			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) {
+			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
 /**
@@ -827,6 +973,72 @@ 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) {
+			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 +1051,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".`);
 	}
 }
 
@@ -1520,7 +1735,19 @@ function extractFontUrls(css) {
 /**
 * Self-host Google Fonts: download CSS + font files, rewrite URLs to local paths.
 */
-async function selfHostFonts(cssUrl, fontsSubDir) {
+async function selfHostFonts(cssUrl, fontsSubDir, root) {
+	const cacheDir = join(root, "node_modules", ".cache", "zero-fonts");
+	const cachePath = join(cacheDir, `${Buffer.from(cssUrl).toString("base64url")}.json`);
+	try {
+		const cached = JSON.parse(await readFile(cachePath, "utf-8"));
+		if (cached.css && cached.fontFiles) return {
+			css: cached.css,
+			fontFiles: cached.fontFiles.map((f) => ({
+				name: f.name,
+				content: Buffer.from(f.content, "base64")
+			}))
+		};
+	} catch {}
 	const css = await downloadGoogleFontsCSS(cssUrl);
 	const fontUrls = extractFontUrls(css);
 	const fontFiles = [];
@@ -1534,6 +1761,16 @@ async function selfHostFonts(cssUrl, fontsSubDir) {
 		});
 		rewrittenCss = rewrittenCss.replace(url, `/${fontsSubDir}/${fileName}`);
 	}
+	try {
+		await mkdir(cacheDir, { recursive: true });
+		await writeFile(cachePath, JSON.stringify({
+			css: rewrittenCss,
+			fontFiles: fontFiles.map((f) => ({
+				name: f.name,
+				content: f.content.toString("base64")
+			}))
+		}));
+	} catch {}
 	return {
 		css: rewrittenCss,
 		fontFiles
@@ -1567,18 +1804,20 @@ function fontPlugin(config = {}) {
 	const shouldSelfHost = config.selfHost !== false;
 	const googleFamilies = (config.google ?? []).map(resolveGoogleFont);
 	let isBuild = false;
+	let root = "";
 	let selfHostedCSS = "";
 	let selfHostedFontFiles = [];
 	return {
 		name: "pyreon-zero-fonts",
 		configResolved(resolvedConfig) {
 			isBuild = resolvedConfig.command === "build";
+			root = resolvedConfig.root;
 		},
 		async buildStart() {
 			if (isBuild && shouldSelfHost && googleFamilies.length > 0) {
 				const cssUrl = googleFontsUrl(googleFamilies, display);
 				try {
-					const result = await selfHostFonts(cssUrl, "assets/fonts");
+					const result = await selfHostFonts(cssUrl, "assets/fonts", root);
 					selfHostedCSS = result.css;
 					selfHostedFontFiles = result.fontFiles;
 				} catch {}
@@ -1635,10 +1874,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;
@@ -1901,7 +2140,7 @@ async function resizeImage(input, output, width, format, quality) {
 		}
 		await pipeline.toFile(output);
 	} catch {
-		warnSharpMissing$1();
+		warnSharpMissing$2();
 		await writeFile(output, await readFile(input));
 	}
 }
@@ -2099,14 +2338,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;");
 }
 /**
@@ -2490,10 +2729,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 = [
@@ -2549,17 +2788,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");
@@ -2567,8 +2820,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");
@@ -2576,16 +2837,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"
 						}],
@@ -2659,61 +2921,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);
 		}
 	};
 }
@@ -2734,6 +2943,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, {
@@ -2746,7 +3075,7 @@ async function resizeToPng(input, size) {
 			}
 		}).png().toBuffer();
 	} catch {
-		warnSharpMissing();
+		warnSharpMissing$1();
 		return null;
 	}
 }
@@ -2779,7 +3108,7 @@ async function generateIco(input) {
 			size: 32
 		}]);
 	} catch {
-		warnSharpMissing();
+		warnSharpMissing$1();
 		return null;
 	}
 }
@@ -2816,6 +3145,234 @@ function createIcoFromPngs(entries) {
 	]);
 }
 
+//#endregion
+//#region src/og-image.ts
+/**
+* OG Image generation plugin.
+*
+* 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
+* // vite.config.ts
+* import { ogImagePlugin } from "@pyreon/zero/og-image"
+*
+* export default {
+*   plugins: [
+*     ogImagePlugin({
+*       locales: ["en", "de", "cs"],
+*       templates: [{
+*         name: "default",
+*         background: "./src/assets/og-bg.jpg",
+*         layers: [{
+*           text: { en: "Build faster", de: "Schneller bauen", cs: "Stavte rychleji" },
+*           y: "40%",
+*           fontSize: 72,
+*         }],
+*       }],
+*     }),
+*   ],
+* }
+* ```
+*/
+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
 /**
@@ -3038,7 +3595,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
@@ -3071,6 +3632,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
@@ -3083,7 +3652,33 @@ function buildMetaTags(props) {
 		property: "og:locale",
 		content: locale
 	});
-	if (type === "article") {
+	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",
 			content: publishedTime
@@ -3169,6 +3764,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,
@@ -3177,5 +3780,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, setTheme, staticAdapter, str, theme, themeScript, toggleTheme, url, useLink, useLocale, useNonce, validateEnv, varyEncoding, vercelAdapter };
 //# sourceMappingURL=index.js.map