@pyreon/zero 0.12.6 → 0.12.8

package/lib/server.js

@@ -1,3 +1,4 @@
+import { a as parseFileRoutes, i as generateRouteModule, o as scanRouteFiles, r as generateMiddlewareModule, t as filePathToUrlPath } from "./fs-router-Dil4IKZR.js";
 import { Fragment, createContext, h } from "@pyreon/core";
 import { HeadProvider } from "@pyreon/head";
 import { RouterProvider, RouterView, createRouter } from "@pyreon/router";
@@ -5,6 +6,7 @@ import { createHandler } from "@pyreon/server";
 import { renderToString } from "@pyreon/runtime-server";
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
+import { readFile } from "node:fs/promises";
 import { signal } from "@pyreon/reactivity";
 
 //#region src/app.ts
@@ -319,270 +321,6 @@ function resolveConfig(userConfig = {}) {
 	};
 }
 
-//#endregion
-//#region src/fs-router.ts
-const ROUTE_EXTENSIONS = [
-	".tsx",
-	".jsx",
-	".ts",
-	".js"
-];
-/**
-* Parse a set of file paths (relative to routes dir) into FileRoute objects.
-*
-* @param files Array of file paths like ["index.tsx", "users/[id].tsx"]
-* @param defaultMode Default rendering mode from config
-*/
-function parseFileRoutes(files, defaultMode = "ssr") {
-	return files.filter((f) => ROUTE_EXTENSIONS.some((ext) => f.endsWith(ext))).map((filePath) => parseFilePath(filePath, defaultMode)).sort(sortRoutes);
-}
-function parseFilePath(filePath, defaultMode) {
-	let route = filePath;
-	for (const ext of ROUTE_EXTENSIONS) if (route.endsWith(ext)) {
-		route = route.slice(0, -ext.length);
-		break;
-	}
-	const fileName = getFileName(route);
-	const isLayout = fileName === "_layout";
-	const isError = fileName === "_error";
-	const isLoading = fileName === "_loading";
-	const isNotFound = fileName === "_404" || fileName === "_not-found";
-	const isCatchAll = route.includes("[...");
-	const parts = route.split("/");
-	parts.pop();
-	const dirPath = parts.filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/");
-	const urlPath = filePathToUrlPath(route);
-	return {
-		filePath,
-		urlPath,
-		dirPath,
-		depth: urlPath === "/" ? 0 : urlPath.split("/").filter(Boolean).length,
-		isLayout,
-		isError,
-		isLoading,
-		isNotFound,
-		isCatchAll,
-		renderMode: defaultMode
-	};
-}
-/**
-* Convert a file path (without extension) to a URL path pattern.
-*
-* Examples:
-*   "index"            → "/"
-*   "about"            → "/about"
-*   "users/index"      → "/users"
-*   "users/[id]"       → "/users/:id"
-*   "blog/[...slug]"   → "/blog/:slug*"
-*   "(auth)/login"     → "/login"         (group stripped)
-*   "_layout"          → "/"              (layout marker)
-*/
-function filePathToUrlPath(filePath) {
-	const segments = filePath.split("/");
-	const urlSegments = [];
-	for (const seg of segments) {
-		if (seg.startsWith("(") && seg.endsWith(")")) continue;
-		if (seg === "_layout" || seg === "_error" || seg === "_loading" || seg === "_404" || seg === "_not-found") continue;
-		if (seg === "index") continue;
-		const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/);
-		if (catchAll) {
-			urlSegments.push(`:${catchAll[1]}*`);
-			continue;
-		}
-		const dynamic = seg.match(/^\[(\w+)\]$/);
-		if (dynamic) {
-			urlSegments.push(`:${dynamic[1]}`);
-			continue;
-		}
-		urlSegments.push(seg);
-	}
-	return `/${urlSegments.join("/")}` || "/";
-}
-/** Sort routes: static before dynamic, catch-all last. */
-function sortRoutes(a, b) {
-	if (a.isCatchAll !== b.isCatchAll) return a.isCatchAll ? 1 : -1;
-	if (a.isLayout !== b.isLayout) return a.isLayout ? -1 : 1;
-	const aDynamic = a.urlPath.includes(":");
-	if (aDynamic !== b.urlPath.includes(":")) return aDynamic ? 1 : -1;
-	return a.urlPath.localeCompare(b.urlPath);
-}
-function getFileName(filePath) {
-	const parts = filePath.split("/");
-	return parts[parts.length - 1] ?? "";
-}
-/**
-* Group flat file routes into a directory tree.
-*/
-function getOrCreateChild(node, segment) {
-	let child = node.children.get(segment);
-	if (!child) {
-		child = {
-			pages: [],
-			children: /* @__PURE__ */ new Map()
-		};
-		node.children.set(segment, child);
-	}
-	return child;
-}
-function resolveNode(root, dirPath) {
-	let node = root;
-	if (dirPath) for (const segment of dirPath.split("/")) node = getOrCreateChild(node, segment);
-	return node;
-}
-function placeRoute(node, route) {
-	if (route.isLayout) node.layout = route;
-	else if (route.isError) node.error = route;
-	else if (route.isLoading) node.loading = route;
-	else if (route.isNotFound) node.notFound = route;
-	else node.pages.push(route);
-}
-function buildRouteTree(routes) {
-	const root = {
-		pages: [],
-		children: /* @__PURE__ */ new Map()
-	};
-	for (const route of routes) placeRoute(resolveNode(root, route.dirPath), route);
-	return root;
-}
-function generateRouteModule(files, routesDir, options) {
-	const tree = buildRouteTree(parseFileRoutes(files));
-	const imports = [];
-	let importCounter = 0;
-	const useStaticImports = options?.staticImports ?? false;
-	function nextImport(filePath, exportName = "default") {
-		const name = `_${importCounter++}`;
-		const fullPath = `${routesDir}/${filePath}`;
-		if (exportName === "default") imports.push(`import ${name} from "${fullPath}"`);
-		else imports.push(`import { ${exportName} as ${name} } from "${fullPath}"`);
-		return name;
-	}
-	function nextLazy(filePath, loadingName, errorName) {
-		const name = `_${importCounter++}`;
-		const fullPath = `${routesDir}/${filePath}`;
-		if (useStaticImports) imports.push(`import ${name} from "${fullPath}"`);
-		else {
-			const opts = [];
-			if (loadingName) opts.push(`loading: ${loadingName}`);
-			if (errorName) opts.push(`error: ${errorName}`);
-			const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
-			imports.push(`const ${name} = lazy(() => import("${fullPath}")${optsStr})`);
-		}
-		return name;
-	}
-	function nextModuleImport(filePath) {
-		const name = `_m${importCounter++}`;
-		const fullPath = `${routesDir}/${filePath}`;
-		imports.push(`import * as ${name} from "${fullPath}"`);
-		return name;
-	}
-	function generatePageRoute(page, indent, loadingName, errorName, notFoundName) {
-		const mod = nextModuleImport(page.filePath);
-		const comp = nextLazy(page.filePath, loadingName, errorName);
-		const props = [
-			`${indent}  path: ${JSON.stringify(page.urlPath)}`,
-			`${indent}  component: ${comp}`,
-			`${indent}  loader: ${mod}.loader`,
-			`${indent}  beforeEnter: ${mod}.guard`,
-			`${indent}  meta: { ...${mod}.meta, renderMode: ${mod}.renderMode }`
-		];
-		if (errorName) props.push(`${indent}  errorComponent: ${mod}.error || ${errorName}`);
-		if (notFoundName) props.push(`${indent}  notFoundComponent: ${notFoundName}`);
-		return `${indent}{\n${props.join(",\n")}\n${indent}}`;
-	}
-	function wrapWithLayout(node, children, indent, errorName, notFoundName) {
-		const layout = node.layout;
-		const layoutMod = nextModuleImport(layout.filePath);
-		const layoutComp = nextImport(layout.filePath, "layout");
-		const props = [
-			`${indent}path: ${JSON.stringify(layout.urlPath)}`,
-			`${indent}component: ${layoutComp}`,
-			`${indent}loader: ${layoutMod}.loader`,
-			`${indent}beforeEnter: ${layoutMod}.guard`,
-			`${indent}meta: { ...${layoutMod}.meta, renderMode: ${layoutMod}.renderMode }`
-		];
-		if (errorName) props.push(`${indent}errorComponent: ${errorName}`);
-		if (notFoundName) props.push(`${indent}notFoundComponent: ${notFoundName}`);
-		if (children.length > 0) props.push(`${indent}children: [\n${children.join(",\n")}\n${indent}]`);
-		return `${indent}{\n${props.map((p) => `  ${p}`).join(",\n")}\n${indent}}`;
-	}
-	/**
-	* Generate route definitions for a tree node.
-	*/
-	function generateNode(node, depth) {
-		const indent = "  ".repeat(depth + 1);
-		const errorName = node.error ? nextImport(node.error.filePath) : void 0;
-		const loadingName = node.loading ? nextImport(node.loading.filePath) : void 0;
-		const notFoundName = node.notFound ? nextImport(node.notFound.filePath) : void 0;
-		const childRouteDefs = [];
-		for (const [, childNode] of node.children) childRouteDefs.push(...generateNode(childNode, depth + 1));
-		const allChildren = [...node.pages.map((page) => generatePageRoute(page, indent, loadingName, errorName, notFoundName)), ...childRouteDefs];
-		if (node.layout) return [wrapWithLayout(node, allChildren, indent, errorName, notFoundName)];
-		return allChildren;
-	}
-	const routeDefs = generateNode(tree, 0);
-	return [
-		`import { lazy } from "@pyreon/router"`,
-		"",
-		...imports,
-		"",
-		`function clean(routes) {`,
-		`  return routes.map(r => {`,
-		`    const c = {}`,
-		`    for (const k in r) if (r[k] !== undefined) c[k] = r[k]`,
-		`    if (c.children) c.children = clean(c.children)`,
-		`    return c`,
-		`  })`,
-		`}`,
-		"",
-		`export const routes = clean([`,
-		routeDefs.join(",\n"),
-		`])`
-	].join("\n");
-}
-/**
-* Generate a virtual module that maps URL patterns to their middleware exports.
-* Used by the server entry to dispatch per-route middleware.
-*/
-function generateMiddlewareModule(files, routesDir) {
-	const routes = parseFileRoutes(files);
-	const imports = [];
-	const entries = [];
-	let counter = 0;
-	for (const route of routes) {
-		if (route.isLayout || route.isError || route.isLoading || route.isNotFound) continue;
-		const name = `_mw${counter++}`;
-		const fullPath = `${routesDir}/${route.filePath}`;
-		imports.push(`import { middleware as ${name} } from "${fullPath}"`);
-		entries.push(`  { pattern: ${JSON.stringify(route.urlPath)}, middleware: ${name} }`);
-	}
-	return [
-		...imports,
-		"",
-		`export const routeMiddleware = [`,
-		entries.join(",\n"),
-		`].filter(e => e.middleware)`
-	].join("\n");
-}
-/**
-* Scan a directory for route files.
-* Returns paths relative to the routes directory.
-*/
-async function scanRouteFiles(routesDir) {
-	const { readdir } = await import("node:fs/promises");
-	const { join, relative } = await import("node:path");
-	const files = [];
-	async function walk(dir) {
-		const entries = await readdir(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			const fullPath = join(dir, entry.name);
-			if (entry.isDirectory()) await walk(fullPath);
-			else if (ROUTE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) files.push(relative(routesDir, fullPath));
-		}
-	}
-	await walk(routesDir);
-	return files;
-}
-
 //#endregion
 //#region src/isr.ts
 /**
@@ -1401,6 +1139,1340 @@ function flattenRoutePatterns(routes, prefix = "") {
 	return patterns;
 }
 
+//#endregion
+//#region src/favicon.ts
+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 = [
+	{
+		size: 16,
+		name: "favicon-16x16.png"
+	},
+	{
+		size: 32,
+		name: "favicon-32x32.png"
+	},
+	{
+		size: 180,
+		name: "apple-touch-icon.png"
+	},
+	{
+		size: 192,
+		name: "icon-192.png"
+	},
+	{
+		size: 512,
+		name: "icon-512.png"
+	}
+];
+/**
+* Favicon generation Vite plugin.
+*
+* Generates all required favicon formats at build time from a single source.
+* In dev mode, serves the source directly.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { faviconPlugin } from "@pyreon/zero"
+*
+* export default {
+*   plugins: [faviconPlugin({ source: "./src/assets/icon.svg" })],
+* }
+* ```
+*/
+function faviconPlugin(config) {
+	const themeColor = config.themeColor ?? "#ffffff";
+	const backgroundColor = config.backgroundColor ?? "#ffffff";
+	const generateManifest = config.manifest !== false;
+	let root = "";
+	let isBuild = false;
+	return {
+		name: "pyreon-zero-favicon",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			isBuild = resolvedConfig.command === "build";
+		},
+		configureServer(server) {
+			const sourcePath = join(root, config.source);
+			const darkPath = config.darkSource ? join(root, config.darkSource) : null;
+			const devSourcePath = typeof config.devSource === "string" ? join(root, config.devSource) : null;
+			const autoDevBadge = config.devSource === true;
+			const devCache = /* @__PURE__ */ new Map();
+			/** Resolve source path for a request — handles dark variants and dev badge. */
+			function resolveSourceForDev(baseName, defaultSource) {
+				if (darkPath && baseName.includes("-dark-")) return darkPath;
+				if (baseName.includes("-light-")) return defaultSource;
+				return defaultSource;
+			}
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url ?? "";
+				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 {
+					let content = await readFile(svgPath, "utf-8");
+					if (autoDevBadge) content = addDevBadgeToSvg(content);
+					else if (devSourcePath && existsSync(devSourcePath)) content = await readFile(devSourcePath, "utf-8");
+					res.setHeader("Content-Type", "image/svg+xml");
+					res.end(content);
+					return;
+				} catch {}
+				const baseName = svgUrl.split("/").pop() ?? "";
+				const cleanName = baseName.replace(/-?(light|dark)-/, "-");
+				const sizeMatch = SIZES.find((s) => s.name === cleanName || baseName === s.name);
+				if (sizeMatch) {
+					const resolvedSource = resolveSourceForDev(baseName, svgPath);
+					const cacheKey = `${resolvedSource}:${sizeMatch.size}:${autoDevBadge}`;
+					let png = devCache.get(cacheKey);
+					if (!png) {
+						let result = await resizeToPng(resolvedSource, sizeMatch.size);
+						if (result && autoDevBadge) result = await addDevBadgeToPng(result, sizeMatch.size);
+						if (result) {
+							png = result;
+							devCache.set(cacheKey, result);
+						}
+					}
+					if (png) {
+						res.setHeader("Content-Type", "image/png");
+						res.setHeader("Cache-Control", "no-cache");
+						res.end(Buffer.from(png));
+						return;
+					}
+				}
+				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");
+						res.end(Buffer.from(ico));
+						return;
+					}
+				}
+				if (baseName === "site.webmanifest" && generateManifest) {
+					const prefix = localeSource ? `/${localeSource.locale}` : "";
+					const manifest = {
+						name: config.name ?? "App",
+						short_name: config.name ?? "App",
+						icons: [{
+							src: `${prefix}/icon-192.png`,
+							sizes: "192x192",
+							type: "image/png"
+						}, {
+							src: `${prefix}/icon-512.png`,
+							sizes: "512x512",
+							type: "image/png"
+						}],
+						theme_color: themeColor,
+						background_color: backgroundColor,
+						display: "standalone"
+					};
+					res.setHeader("Content-Type", "application/manifest+json");
+					res.end(JSON.stringify(manifest, null, 2));
+					return;
+				}
+				next();
+			});
+		},
+		transformIndexHtml() {
+			const isSvg = config.source.endsWith(".svg");
+			const hasDark = !!config.darkSource;
+			const tags = [];
+			if (isSvg) tags.push({
+				tag: "link",
+				attrs: {
+					rel: "icon",
+					type: "image/svg+xml",
+					href: "/favicon.svg"
+				},
+				injectTo: "head"
+			});
+			if (hasDark) {
+				const lightAttrs = { "data-favicon-theme": "light" };
+				const darkAttrs = {
+					"data-favicon-theme": "dark",
+					media: "not all"
+				};
+				tags.push({
+					tag: "link",
+					attrs: {
+						rel: "icon",
+						type: "image/png",
+						sizes: "32x32",
+						href: "/favicon-light-32x32.png",
+						...lightAttrs
+					},
+					injectTo: "head"
+				}, {
+					tag: "link",
+					attrs: {
+						rel: "icon",
+						type: "image/png",
+						sizes: "32x32",
+						href: "/favicon-dark-32x32.png",
+						...darkAttrs
+					},
+					injectTo: "head"
+				}, {
+					tag: "link",
+					attrs: {
+						rel: "icon",
+						type: "image/png",
+						sizes: "16x16",
+						href: "/favicon-light-16x16.png",
+						...lightAttrs
+					},
+					injectTo: "head"
+				}, {
+					tag: "link",
+					attrs: {
+						rel: "icon",
+						type: "image/png",
+						sizes: "16x16",
+						href: "/favicon-dark-16x16.png",
+						...darkAttrs
+					},
+					injectTo: "head"
+				}, {
+					tag: "link",
+					attrs: {
+						rel: "apple-touch-icon",
+						sizes: "180x180",
+						href: "/apple-touch-icon-light.png",
+						...lightAttrs
+					},
+					injectTo: "head"
+				}, {
+					tag: "link",
+					attrs: {
+						rel: "apple-touch-icon",
+						sizes: "180x180",
+						href: "/apple-touch-icon-dark.png",
+						...darkAttrs
+					},
+					injectTo: "head"
+				});
+			} else tags.push({
+				tag: "link",
+				attrs: {
+					rel: "icon",
+					type: "image/png",
+					sizes: "32x32",
+					href: "/favicon-32x32.png"
+				},
+				injectTo: "head"
+			}, {
+				tag: "link",
+				attrs: {
+					rel: "icon",
+					type: "image/png",
+					sizes: "16x16",
+					href: "/favicon-16x16.png"
+				},
+				injectTo: "head"
+			}, {
+				tag: "link",
+				attrs: {
+					rel: "apple-touch-icon",
+					sizes: "180x180",
+					href: "/apple-touch-icon.png"
+				},
+				injectTo: "head"
+			});
+			if (generateManifest) tags.push({
+				tag: "link",
+				attrs: {
+					rel: "manifest",
+					href: "/site.webmanifest"
+				},
+				injectTo: "head"
+			});
+			tags.push({
+				tag: "meta",
+				attrs: {
+					name: "theme-color",
+					content: themeColor
+				},
+				injectTo: "head"
+			});
+			return tags;
+		},
+		async generateBundle() {
+			if (!isBuild) return;
+			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);
+		}
+	};
+}
+/**
+* Wrap two SVGs into a single SVG that switches based on prefers-color-scheme.
+*/
+function wrapSvgWithDarkMode(lightSvg, darkSvg) {
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${lightSvg.match(/viewBox="([^"]*)"/)?.[1] ?? "0 0 32 32"}">
+  <style>
+    :root { color-scheme: light dark; }
+    @media (prefers-color-scheme: dark) { .light { display: none; } }
+    @media (prefers-color-scheme: light), (prefers-color-scheme: no-preference) { .dark { display: none; } }
+  </style>
+  <g class="light">${stripSvgWrapper(lightSvg)}</g>
+  <g class="dark">${stripSvgWrapper(darkSvg)}</g>
+</svg>`;
+}
+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
+		});
+	}
+	if (darkSource) {
+		const darkPath = join(rootDir, darkSource);
+		const darkExists = existsSync(darkPath);
+		for (const { size, name } of SIZES) {
+			const lightName = name.replace(/^(favicon-)/, "$1light-").replace(/^(apple-touch-icon)/, "$1-light").replace(/^(icon-)/, "$1light-");
+			const lightPng = await resizeToPng(sourcePath, size);
+			if (lightPng) this.emitFile({
+				type: "asset",
+				fileName: `${prefix}${lightName}`,
+				source: lightPng
+			});
+			if (darkExists) {
+				const darkName = name.replace(/^(favicon-)/, "$1dark-").replace(/^(apple-touch-icon)/, "$1-dark").replace(/^(icon-)/, "$1dark-");
+				const darkPng = await resizeToPng(darkPath, size);
+				if (darkPng) this.emitFile({
+					type: "asset",
+					fileName: `${prefix}${darkName}`,
+					source: darkPng
+				});
+			}
+		}
+		for (const { size, name } of SIZES) {
+			const pngBuffer = await resizeToPng(sourcePath, size);
+			if (pngBuffer) this.emitFile({
+				type: "asset",
+				fileName: `${prefix}${name}`,
+				source: pngBuffer
+			});
+		}
+	} else 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, {
+			fit: "contain",
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		}).png().toBuffer();
+	} catch {
+		warnSharpMissing$1();
+		return null;
+	}
+}
+async function generateIco(input) {
+	try {
+		const sharp = await import("sharp").then((m) => m.default ?? m);
+		const png16 = await sharp(input).resize(16, 16, {
+			fit: "contain",
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		}).png().toBuffer();
+		const png32 = await sharp(input).resize(32, 32, {
+			fit: "contain",
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		}).png().toBuffer();
+		return createIcoFromPngs([{
+			buffer: png16,
+			size: 16
+		}, {
+			buffer: png32,
+			size: 32
+		}]);
+	} catch {
+		warnSharpMissing$1();
+		return null;
+	}
+}
+/** @internal Exported for testing */
+function createIcoFromPngs(entries) {
+	const headerSize = 6;
+	const dirEntrySize = 16;
+	const dirSize = dirEntrySize * entries.length;
+	let dataOffset = headerSize + dirSize;
+	const header = Buffer.alloc(headerSize);
+	header.writeUInt16LE(0, 0);
+	header.writeUInt16LE(1, 2);
+	header.writeUInt16LE(entries.length, 4);
+	const dirEntries = Buffer.alloc(dirSize);
+	const dataBuffers = [];
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		const offset = i * dirEntrySize;
+		dirEntries.writeUInt8(entry.size === 256 ? 0 : entry.size, offset);
+		dirEntries.writeUInt8(entry.size === 256 ? 0 : entry.size, offset + 1);
+		dirEntries.writeUInt8(0, offset + 2);
+		dirEntries.writeUInt8(0, offset + 3);
+		dirEntries.writeUInt16LE(1, offset + 4);
+		dirEntries.writeUInt16LE(32, offset + 6);
+		dirEntries.writeUInt32LE(entry.buffer.length, offset + 8);
+		dirEntries.writeUInt32LE(dataOffset, offset + 12);
+		dataOffset += entry.buffer.length;
+		dataBuffers.push(entry.buffer);
+	}
+	return Buffer.concat([
+		header,
+		dirEntries,
+		...dataBuffers
+	]);
+}
+/**
+* Add a "DEV" badge overlay to an SVG string.
+* Adds a small colored circle with "DEV" text in the bottom-right corner.
+*/
+function addDevBadgeToSvg(svg) {
+	const [, , w, h] = (svg.match(/viewBox="([^"]*)"/)?.[1] ?? "0 0 32 32").split(" ").map(Number);
+	const size = Math.min(w ?? 32, h ?? 32);
+	const r = size * .28;
+	const cx = (w ?? 32) - r;
+	const cy = (h ?? 32) - r;
+	const fontSize = r * .85;
+	const badge = `<circle cx="${cx}" cy="${cy}" r="${r}" fill="#ef4444" stroke="white" stroke-width="${size * .03}"/><text x="${cx}" y="${cy}" font-size="${fontSize}" font-weight="bold" fill="white" text-anchor="middle" dominant-baseline="central" font-family="sans-serif">D</text>`;
+	return svg.replace(/<\/svg>\s*$/, `${badge}</svg>`);
+}
+/**
+* Add a "DEV" badge to a PNG buffer via sharp composite.
+* Composites a red circle with "D" in the bottom-right corner.
+*/
+async function addDevBadgeToPng(pngBuffer, size) {
+	try {
+		const sharp = await import("sharp").then((m) => m.default ?? m);
+		const r = Math.round(size * .28);
+		const d = r * 2;
+		const badgeSvg = `<svg width="${d}" height="${d}" xmlns="http://www.w3.org/2000/svg">
+      <circle cx="${r}" cy="${r}" r="${r}" fill="#ef4444"/>
+      <text x="${r}" y="${r}" font-size="${Math.round(r * .85)}" font-weight="bold" fill="white" text-anchor="middle" dominant-baseline="central" font-family="sans-serif">D</text>
+    </svg>`;
+		const badgePng = await sharp(Buffer.from(badgeSvg)).png().toBuffer();
+		return await sharp(Buffer.from(pngBuffer)).composite([{
+			input: badgePng,
+			gravity: "southeast"
+		}]).png().toBuffer();
+	} catch {
+		return pngBuffer;
+	}
+}
+
+//#endregion
+//#region src/seo.ts
+/**
+* Generate a sitemap.xml string from route file paths.
+*/
+function generateSitemap(routeFiles, config) {
+	const { origin, exclude = [], changefreq = "weekly", priority = .7 } = config;
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${[...routeFiles.filter((f) => {
+		const name = f.split("/").pop()?.replace(/\.\w+$/, "");
+		return name !== "_layout" && name !== "_error" && name !== "_loading";
+	}).map((f) => {
+		let path = f.replace(/\.\w+$/, "").replace(/\/index$/, "/").replace(/^index$/, "/");
+		if (path.includes("[")) return null;
+		path = path.replace(/\([\w-]+\)\//g, "");
+		if (!path.startsWith("/")) path = `/${path}`;
+		return path;
+	}).filter((p) => p !== null).filter((p) => !exclude.some((e) => p.startsWith(e))).map((p) => ({
+		path: p,
+		changefreq,
+		priority
+	})), ...config.additionalPaths ?? []].map((entry) => {
+		return `  <url>
+    <loc>${escapeXml$1(`${origin}${entry.path === "/" ? "" : entry.path}`)}</loc>
+    <changefreq>${entry.changefreq ?? changefreq}</changefreq>
+    <priority>${entry.priority ?? priority}</priority>${entry.lastmod ? `\n    <lastmod>${entry.lastmod}</lastmod>` : ""}
+  </url>`;
+	}).join("\n")}
+</urlset>`;
+}
+function escapeXml$1(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Generate a robots.txt string.
+*/
+function generateRobots(config = {}) {
+	const { rules = [{
+		userAgent: "*",
+		allow: ["/"]
+	}], sitemap, host } = config;
+	const lines = [];
+	for (const rule of rules) {
+		lines.push(`User-agent: ${rule.userAgent}`);
+		if (rule.allow) for (const path of rule.allow) lines.push(`Allow: ${path}`);
+		if (rule.disallow) for (const path of rule.disallow) lines.push(`Disallow: ${path}`);
+		if (rule.crawlDelay) lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+		lines.push("");
+	}
+	if (sitemap) lines.push(`Sitemap: ${sitemap}`);
+	if (host) lines.push(`Host: ${host}`);
+	return lines.join("\n");
+}
+/**
+* Generate a JSON-LD script tag string for structured data.
+*
+* @example
+* useHead({
+*   script: [jsonLd({
+*     "@type": "WebSite",
+*     name: "My Site",
+*     url: "https://example.com",
+*   })],
+* })
+*/
+function jsonLd(data) {
+	const ld = {
+		"@context": "https://schema.org",
+		...data
+	};
+	return `<script type="application/ld+json">${JSON.stringify(ld)}<\/script>`;
+}
+/**
+* Zero SEO Vite plugin.
+* Generates sitemap.xml and robots.txt at build time.
+*
+* @example
+* import { seoPlugin } from "@pyreon/zero/seo"
+*
+* export default {
+*   plugins: [
+*     pyreon(),
+*     zero(),
+*     seoPlugin({
+*       sitemap: { origin: "https://example.com" },
+*       robots: { sitemap: "https://example.com/sitemap.xml" },
+*     }),
+*   ],
+* }
+*/
+function seoPlugin(config = {}) {
+	return {
+		name: "pyreon-zero-seo",
+		apply: "build",
+		async generateBundle(_, _bundle) {
+			if (config.sitemap) {
+				const { scanRouteFiles } = await import("./fs-router-Dil4IKZR.js").then((n) => n.n);
+				const routesDir = `${process.cwd()}/src/routes`;
+				try {
+					const sitemap = generateSitemap(await scanRouteFiles(routesDir), config.sitemap);
+					this.emitFile({
+						type: "asset",
+						fileName: "sitemap.xml",
+						source: sitemap
+					});
+				} catch {}
+			}
+			if (config.robots) {
+				const robots = generateRobots(config.robots);
+				this.emitFile({
+					type: "asset",
+					fileName: "robots.txt",
+					source: robots
+				});
+			}
+		}
+	};
+}
+/**
+* SEO middleware for dev server.
+* Serves sitemap.xml and robots.txt dynamically during development.
+*/
+function seoMiddleware(config = {}) {
+	return async (ctx) => {
+		if (ctx.url.pathname === "/robots.txt" && config.robots) return new Response(generateRobots(config.robots), { headers: { "Content-Type": "text/plain" } });
+		if (ctx.url.pathname === "/sitemap.xml" && config.sitemap) try {
+			const { scanRouteFiles } = await import("./fs-router-Dil4IKZR.js").then((n) => n.n);
+			const sitemap = generateSitemap(await scanRouteFiles(`${process.cwd()}/src/routes`), config.sitemap);
+			return new Response(sitemap, { headers: { "Content-Type": "application/xml" } });
+		} catch {}
+	};
+}
+
+//#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/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
 //#region src/i18n-routing.ts
 /**
@@ -1530,5 +2602,5 @@ const LocaleCtx = createContext("en");
 const localeSignal = signal("en");
 
 //#endregion
-export { bunAdapter, cloudflareAdapter, compose, createApp, createISRHandler, createLocaleContext, createServer, zeroPlugin as default, defineConfig, detectLocaleFromHeader, filePathToUrlPath, generateMiddlewareModule, generateRouteModule, getContext, i18nRouting, netlifyAdapter, nodeAdapter, parseFileRoutes, render404Page, resolveAdapter, resolveConfig, scanRouteFiles, staticAdapter, vercelAdapter };
+export { aiPlugin, bunAdapter, cloudflareAdapter, compose, createApp, createISRHandler, createLocaleContext, createServer, zeroPlugin as default, defineConfig, detectLocaleFromHeader, faviconLinks, faviconPlugin, filePathToUrlPath, generateLlmsFullTxt, generateLlmsTxt, generateMiddlewareModule, generateRobots, generateRouteModule, generateSitemap, getContext, i18nRouting, inferJsonLd, jsonLd, netlifyAdapter, nodeAdapter, ogImagePath, ogImagePlugin, parseFileRoutes, render404Page, resolveAdapter, resolveConfig, scanRouteFiles, seoMiddleware, seoPlugin, staticAdapter, vercelAdapter };
 //# sourceMappingURL=server.js.map