@pyreon/zero 0.1.0

package/lib/index.js

@@ -0,0 +1,1665 @@
+import { a as scanRouteFiles, i as parseFileRoutes, r as generateRouteModule, t as filePathToUrlPath } from "./fs-router-jfd1QGLB.js";
+import { Fragment, createRef, h, onMount, onUnmount } from "@pyreon/core";
+import { HeadProvider } from "@pyreon/head";
+import { RouterProvider, RouterView, createRouter, useRouter } from "@pyreon/router";
+import { createHandler } from "@pyreon/server";
+import { effect, signal } from "@pyreon/reactivity";
+import { jsx, jsxs } from "@pyreon/core/jsx-runtime";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+
+//#region src/app.ts
+/**
+* Create a full Zero app — assembles router, head provider, and root layout.
+*
+* Used internally by entry-server and entry-client.
+*/
+function createApp(options) {
+	const router = createRouter({
+		routes: options.routes,
+		mode: options.routerMode ?? "history",
+		url: options.url,
+		scrollBehavior: "top"
+	});
+	const Layout = options.layout ?? DefaultLayout;
+	function App() {
+		return h(HeadProvider, null, h(RouterProvider, { router }, h(Layout, null, h(RouterView, null))));
+	}
+	return {
+		App,
+		router
+	};
+}
+function DefaultLayout(props) {
+	return h(Fragment, null, ...Array.isArray(props.children) ? props.children : [props.children]);
+}
+
+//#endregion
+//#region src/entry-server.ts
+/**
+* Create the SSR request handler for production.
+*
+* @example
+* import { routes } from "virtual:zero/routes"
+* import { createServer } from "@pyreon/zero"
+*
+* export default createServer({ routes })
+*/
+function createServer(options) {
+	const config = options.config ?? {};
+	const allMiddleware = [...config.middleware ?? [], ...options.middleware ?? []];
+	const { App } = createApp({
+		routes: options.routes,
+		routerMode: "history"
+	});
+	return createHandler({
+		App,
+		routes: options.routes,
+		middleware: allMiddleware,
+		mode: config.ssr?.mode ?? "string",
+		template: options.template,
+		clientEntry: options.clientEntry
+	});
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Define a Zero configuration.
+* Used in `zero.config.ts` at the project root.
+*
+* @example
+* import { defineConfig } from "@pyreon/zero/config"
+*
+* export default defineConfig({
+*   mode: "ssr",
+*   ssr: { mode: "stream" },
+*   port: 3000,
+* })
+*/
+function defineConfig(config) {
+	return config;
+}
+/** Merge user config with defaults. */
+function resolveConfig(userConfig = {}) {
+	return {
+		mode: "ssr",
+		base: "/",
+		port: 3e3,
+		adapter: "node",
+		...userConfig,
+		ssr: {
+			mode: "string",
+			...userConfig.ssr
+		}
+	};
+}
+
+//#endregion
+//#region src/vite-plugin.ts
+const VIRTUAL_ROUTES_ID = "virtual:zero/routes";
+const RESOLVED_VIRTUAL_ROUTES_ID = `\0${VIRTUAL_ROUTES_ID}`;
+/**
+* Zero Vite plugin — adds file-based routing and zero-config conventions
+* on top of @pyreon/vite-plugin.
+*
+* @example
+* // vite.config.ts
+* import pyreon from "@pyreon/vite-plugin"
+* import zero from "@pyreon/zero"
+*
+* export default {
+*   plugins: [pyreon(), zero()],
+* }
+*/
+function zeroPlugin(userConfig = {}) {
+	const config = resolveConfig(userConfig);
+	let routesDir;
+	let root;
+	return {
+		name: "pyreon-zero",
+		enforce: "pre",
+		_zeroConfig: userConfig,
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			routesDir = `${root}/src/routes`;
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_ROUTES_ID) return RESOLVED_VIRTUAL_ROUTES_ID;
+		},
+		async load(id) {
+			if (id === RESOLVED_VIRTUAL_ROUTES_ID) try {
+				return generateRouteModule(await scanRouteFiles(routesDir), routesDir);
+			} catch (_err) {
+				return `export const routes = []`;
+			}
+		},
+		configureServer(server) {
+			server.watcher.add(`${routesDir}/**/*.{tsx,jsx,ts,js}`);
+			server.watcher.on("all", (event, path) => {
+				if (path.startsWith(routesDir) && (event === "add" || event === "unlink")) {
+					const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ROUTES_ID);
+					if (mod) {
+						server.moduleGraph.invalidateModule(mod);
+						server.ws.send({ type: "full-reload" });
+					}
+				}
+			});
+		},
+		config() {
+			return {
+				resolve: { conditions: ["bun"] },
+				server: { port: config.port },
+				define: {
+					__ZERO_MODE__: JSON.stringify(config.mode),
+					__ZERO_BASE__: JSON.stringify(config.base)
+				}
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/isr.ts
+/**
+* In-memory ISR cache with stale-while-revalidate semantics.
+*
+* Wraps an SSR handler and caches responses per URL path.
+* Serves stale content immediately while revalidating in the background.
+*/
+function createISRHandler(handler, config) {
+	const cache = /* @__PURE__ */ new Map();
+	const revalidating = /* @__PURE__ */ new Set();
+	const revalidateMs = config.revalidate * 1e3;
+	async function revalidate(url) {
+		const key = url.pathname;
+		if (revalidating.has(key)) return;
+		revalidating.add(key);
+		try {
+			const res = await handler(new Request(url.href, { method: "GET" }));
+			const html = await res.text();
+			const headers = {};
+			res.headers.forEach((v, k) => {
+				headers[k] = v;
+			});
+			cache.set(key, {
+				html,
+				headers,
+				timestamp: Date.now()
+			});
+		} catch {} finally {
+			revalidating.delete(key);
+		}
+	}
+	return async (req) => {
+		if (req.method !== "GET") return handler(req);
+		const url = new URL(req.url);
+		const key = url.pathname;
+		const entry = cache.get(key);
+		if (entry) {
+			const age = Date.now() - entry.timestamp;
+			if (age > revalidateMs) revalidate(url);
+			return new Response(entry.html, {
+				status: 200,
+				headers: {
+					...entry.headers,
+					"content-type": "text/html; charset=utf-8",
+					"x-isr-cache": age > revalidateMs ? "STALE" : "HIT",
+					"x-isr-age": String(Math.round(age / 1e3))
+				}
+			});
+		}
+		const res = await handler(req);
+		const html = await res.text();
+		const headers = {};
+		res.headers.forEach((v, k) => {
+			headers[k] = v;
+		});
+		cache.set(key, {
+			html,
+			headers,
+			timestamp: Date.now()
+		});
+		return new Response(html, {
+			status: 200,
+			headers: {
+				...headers,
+				"content-type": "text/html; charset=utf-8",
+				"x-isr-cache": "MISS"
+			}
+		});
+	};
+}
+
+//#endregion
+//#region src/adapters/bun.ts
+/**
+* Bun adapter — generates a standalone Bun.serve() entry.
+*/
+function bunAdapter() {
+	return {
+		name: "bun",
+		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, join(outDir, "client"), { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
+			const port = options.config.port ?? 3e3;
+			const serverEntry = `
+const handler = (await import("./server/entry-server.js")).default
+const clientDir = new URL("./client/", import.meta.url).pathname
+
+Bun.serve({
+  port: ${port},
+  async fetch(req) {
+    const url = new URL(req.url)
+
+    // Try static files first
+    if (req.method === "GET") {
+      const filePath = clientDir + (url.pathname === "/" ? "index.html" : url.pathname)
+      // Prevent path traversal — ensure resolved path stays within clientDir
+      const resolved = Bun.resolveSync(filePath, ".")
+      if (!resolved.startsWith(Bun.resolveSync(clientDir, "."))) {
+        return new Response("Forbidden", { status: 403 })
+      }
+      const file = Bun.file(filePath)
+      if (await file.exists()) {
+        return new Response(file, {
+          headers: {
+            "cache-control": filePath.endsWith(".js") || filePath.endsWith(".css")
+              ? "public, max-age=31536000, immutable"
+              : "public, max-age=3600",
+          },
+        })
+      }
+    }
+
+    // Fall through to SSR handler
+    return handler(req)
+  },
+})
+
+console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
+`.trimStart();
+			await writeFile(join(outDir, "index.ts"), serverEntry);
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/node.ts
+/**
+* Node.js adapter — generates a standalone server entry using node:http.
+*/
+function nodeAdapter() {
+	return {
+		name: "node",
+		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, join(outDir, "client"), { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
+			const port = options.config.port ?? 3e3;
+			const serverEntry = `
+import { createServer } from "node:http"
+import { readFile } from "node:fs/promises"
+import { join, extname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url))
+const handler = (await import("./server/entry-server.js")).default
+const clientDir = join(__dirname, "client")
+
+const MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ico": "image/x-icon",
+}
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", "http://localhost")
+
+  // Try to serve static files first
+  if (req.method === "GET") {
+    try {
+      const filePath = join(clientDir, url.pathname === "/" ? "index.html" : url.pathname)
+      // Prevent path traversal — ensure resolved path stays within clientDir
+      const { resolve } = await import("node:path")
+      const resolved = resolve(filePath)
+      if (!resolved.startsWith(resolve(clientDir))) {
+        res.writeHead(403)
+        res.end("Forbidden")
+        return
+      }
+      const ext = extname(filePath)
+      if (ext && ext !== ".html") {
+        const data = await readFile(filePath)
+        const mime = MIME_TYPES[ext] || "application/octet-stream"
+        res.writeHead(200, {
+          "content-type": mime,
+          "cache-control": ext === ".js" || ext === ".css"
+            ? "public, max-age=31536000, immutable"
+            : "public, max-age=3600",
+        })
+        res.end(data)
+        return
+      }
+    } catch {}
+  }
+
+  // Fall through to SSR handler
+  const headers = {}
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) headers[key] = Array.isArray(value) ? value.join(", ") : value
+  }
+
+  const request = new Request(url.href, {
+    method: req.method,
+    headers,
+  })
+
+  const response = await handler(request)
+  const body = await response.text()
+
+  const responseHeaders = {}
+  response.headers.forEach((v, k) => { responseHeaders[k] = v })
+
+  res.writeHead(response.status, responseHeaders)
+  res.end(body)
+})
+
+server.listen(${port}, () => {
+  console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
+})
+`.trimStart();
+			await writeFile(join(outDir, "index.js"), serverEntry);
+			await writeFile(join(outDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/static.ts
+/**
+* Static adapter — just copies the client build output.
+* Used with SSG mode where all pages are pre-rendered at build time.
+*/
+function staticAdapter() {
+	return {
+		name: "static",
+		async build(options) {
+			const { cp, mkdir } = await import("node:fs/promises");
+			await mkdir(options.outDir, { recursive: true });
+			await cp(options.clientOutDir, options.outDir, { recursive: true });
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/index.ts
+/**
+* Resolve the adapter from config.
+* Returns a built-in adapter or throws if unknown.
+*/
+function resolveAdapter(config) {
+	const name = config.adapter ?? "node";
+	switch (name) {
+		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".`);
+	}
+}
+
+//#endregion
+//#region src/utils/use-intersection-observer.ts
+/**
+* Observes an element and calls `onIntersect` once it enters the viewport.
+* Automatically disconnects after the first intersection.
+*
+* @param getElement - Getter for the target element (may be undefined before mount).
+* @param onIntersect - Callback fired when the element becomes visible.
+* @param rootMargin - IntersectionObserver rootMargin. Default: "200px".
+*/
+function useIntersectionObserver(getElement, onIntersect, rootMargin = "200px") {
+	onMount(() => {
+		const el = getElement();
+		if (!el) return void 0;
+		const observer = new IntersectionObserver((entries) => {
+			for (const entry of entries) if (entry.isIntersecting) {
+				onIntersect();
+				observer.disconnect();
+			}
+		}, { rootMargin });
+		observer.observe(el);
+		onUnmount(() => observer.disconnect());
+	});
+}
+
+//#endregion
+//#region src/image.tsx
+/**
+* Optimized image component with lazy loading, responsive images,
+* multi-format <picture> support, and blur-up placeholders.
+*
+* @example
+* // With imagePlugin — spread the import directly
+* import hero from "./hero.jpg?optimize"
+* <Image {...hero} alt="Hero" priority />
+*
+* @example
+* // Manual usage
+* <Image src="/hero.jpg" alt="Hero" width={1200} height={630} />
+*/
+function Image(props) {
+	const isEager = props.priority || props.loading === "eager";
+	const loaded = signal(isEager);
+	const inView = signal(isEager);
+	const containerRef = createRef();
+	const resolvedSrcset = typeof props.srcset === "string" ? props.srcset : props.srcset?.map((s) => `${s.src} ${s.width}w`).join(", ");
+	const sizes = props.sizes ?? "100vw";
+	const fit = props.fit ?? "cover";
+	const hasFormats = props.formats && props.formats.length > 0;
+	const aspectRatio = `${props.width} / ${props.height}`;
+	if (!isEager) useIntersectionObserver(() => containerRef.current ?? void 0, () => inView.set(true));
+	const containerStyle = [
+		"position: relative",
+		"overflow: hidden",
+		`aspect-ratio: ${aspectRatio}`,
+		`max-width: ${props.width}px`,
+		"width: 100%",
+		props.style
+	].filter(Boolean).join("; ");
+	const imgEl = /* @__PURE__ */ jsx("img", {
+		src: () => inView() ? props.src : "",
+		srcset: () => !hasFormats && inView() && resolvedSrcset ? resolvedSrcset : "",
+		sizes: resolvedSrcset ? sizes : void 0,
+		alt: props.alt,
+		width: props.width,
+		height: props.height,
+		loading: isEager ? "eager" : "lazy",
+		decoding: props.decoding ?? "async",
+		fetchpriority: props.priority ? "high" : void 0,
+		onload: () => loaded.set(true),
+		style: () => [
+			"display: block",
+			"width: 100%",
+			"height: 100%",
+			`object-fit: ${fit}`,
+			"transition: opacity 0.3s ease",
+			props.placeholder && !loaded() ? "opacity: 0" : "opacity: 1"
+		].join("; ")
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		ref: containerRef,
+		class: props.class,
+		style: containerStyle,
+		children: [props.placeholder && /* @__PURE__ */ jsx("img", {
+			src: props.placeholder,
+			alt: "",
+			"aria-hidden": "true",
+			loading: "eager",
+			style: () => [
+				"position: absolute",
+				"inset: 0",
+				"width: 100%",
+				"height: 100%",
+				"object-fit: cover",
+				"filter: blur(20px)",
+				"transform: scale(1.1)",
+				"transition: opacity 0.4s ease",
+				loaded() ? "opacity: 0; pointer-events: none" : "opacity: 1"
+			].join("; ")
+		}), hasFormats ? /* @__PURE__ */ jsxs("picture", { children: [props.formats?.map((fmt) => /* @__PURE__ */ jsx("source", {
+			type: fmt.type,
+			srcset: () => inView() ? fmt.srcset : void 0,
+			sizes
+		})), imgEl] }) : imgEl]
+	});
+}
+
+//#endregion
+//#region src/link.tsx
+const prefetched = /* @__PURE__ */ new Set();
+function doPrefetch(href) {
+	if (prefetched.has(href)) return;
+	prefetched.add(href);
+	const docLink = document.createElement("link");
+	docLink.rel = "prefetch";
+	docLink.href = href;
+	docLink.as = "document";
+	document.head.appendChild(docLink);
+	try {
+		const chunkHint = document.createElement("link");
+		chunkHint.rel = "modulepreload";
+		chunkHint.href = href;
+		document.head.appendChild(chunkHint);
+	} catch {}
+}
+/**
+* Composable that provides all link behavior — navigation, prefetching,
+* active state, and viewport observation.
+*
+* Use this for full control when `createLink` is too opinionated.
+*
+* @example
+* function MyLink(props: LinkProps) {
+*   const link = useLink(props)
+*   return (
+*     <button ref={link.ref} class={link.classes()} onclick={link.handleClick}>
+*       {props.children}
+*     </button>
+*   )
+* }
+*/
+function useLink(props) {
+	const router = useRouter();
+	const elementRef = createRef();
+	const strategy = props.prefetch ?? "hover";
+	function handleClick(e) {
+		if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || props.external) return;
+		e.preventDefault();
+		router.push(props.href);
+	}
+	function handleMouseEnter() {
+		if (strategy === "hover") doPrefetch(props.href);
+	}
+	function handleTouchStart() {
+		if (strategy === "hover" || strategy === "viewport") doPrefetch(props.href);
+	}
+	if (strategy === "viewport") useIntersectionObserver(() => elementRef.current ?? void 0, () => doPrefetch(props.href));
+	const isActive = () => {
+		const currentPath = router.currentRoute()?.path;
+		if (!currentPath || !props.href) return false;
+		if (props.href === "/") return currentPath === "/";
+		return currentPath.startsWith(props.href);
+	};
+	const isExactActive = () => {
+		const currentPath = router.currentRoute()?.path;
+		if (!currentPath) return false;
+		return currentPath === props.href;
+	};
+	const classes = () => {
+		const cls = [];
+		if (props.class) cls.push(props.class);
+		if (props.activeClass && isActive()) cls.push(props.activeClass);
+		if (props.exactActiveClass && isExactActive()) cls.push(props.exactActiveClass);
+		return cls.join(" ");
+	};
+	return {
+		ref: elementRef,
+		handleClick,
+		handleMouseEnter,
+		handleTouchStart,
+		isActive,
+		isExactActive,
+		classes
+	};
+}
+/**
+* Higher-order component that wraps any component with link behavior.
+*
+* The wrapped component receives {@link LinkRenderProps} with all handlers,
+* active state, and accessibility attributes pre-wired.
+*
+* @example
+* // Custom button link
+* const ButtonLink = createLink((props) => (
+*   <button
+*     ref={props.ref}
+*     class={props.class}
+*     onclick={props.onClick}
+*     onmouseenter={props.onMouseEnter}
+*   >
+*     {props.children}
+*   </button>
+* ))
+*
+* // Custom styled component
+* const CardLink = createLink((props) => (
+*   <div
+*     ref={props.ref}
+*     class={`card ${props.isActive() ? "card--active" : ""}`}
+*     onclick={props.onClick}
+*     onmouseenter={props.onMouseEnter}
+*   >
+*     {props.children}
+*   </div>
+* ))
+*
+* // Usage
+* <ButtonLink href="/about">About</ButtonLink>
+* <CardLink href="/posts" prefetch="viewport">Posts</CardLink>
+*/
+function createLink(Component) {
+	return function WrappedLink(props) {
+		const link = useLink(props);
+		return /* @__PURE__ */ jsx(Component, {
+			href: props.href,
+			ref: link.ref,
+			onClick: link.handleClick,
+			onMouseEnter: link.handleMouseEnter,
+			onTouchStart: link.handleTouchStart,
+			isActive: link.isActive,
+			isExactActive: link.isExactActive,
+			class: link.classes,
+			style: props.style,
+			target: props.external ? "_blank" : void 0,
+			rel: props.external ? "noopener noreferrer" : void 0,
+			"aria-label": props["aria-label"],
+			children: props.children
+		});
+	};
+}
+/**
+* Default navigation link built on an `<a>` tag.
+*
+* @example
+* <Link href="/about" prefetch="viewport">About</Link>
+* <Link href="/posts" activeClass="nav-active">Posts</Link>
+*/
+const Link = createLink((props) => /* @__PURE__ */ jsx("a", {
+	ref: props.ref,
+	href: props.href,
+	class: props.class,
+	style: props.style,
+	target: props.target,
+	rel: props.rel,
+	"aria-label": props["aria-label"],
+	"aria-current": props.isExactActive() ? "page" : void 0,
+	onclick: props.onClick,
+	onmouseenter: props.onMouseEnter,
+	ontouchstart: props.onTouchStart,
+	children: props.children
+}));
+
+//#endregion
+//#region src/script.tsx
+/**
+* Optimized script loading component.
+*
+* @example
+* // Load analytics after page is interactive
+* <Script src="https://analytics.example.com/script.js" strategy="onIdle" />
+*
+* // Load chat widget when user scrolls
+* <Script src="/chat-widget.js" strategy="onViewport" />
+*
+* // Inline script with deferred execution
+* <Script strategy="afterHydration">
+*   {`console.log("App hydrated!")`}
+* <\/Script>
+*/
+function Script(props) {
+	function loadScript() {
+		if (props.id && document.getElementById(props.id)) return;
+		const script = document.createElement("script");
+		if (props.src) script.src = props.src;
+		if (props.id) script.id = props.id;
+		script.async = props.async !== false;
+		if (props.onLoad) script.onload = props.onLoad;
+		if (props.onError) script.onerror = () => props.onError?.(/* @__PURE__ */ new Error(`Failed to load: ${props.src}`));
+		if (props.children && !props.src) script.textContent = props.children;
+		document.head.appendChild(script);
+	}
+	onMount(() => {
+		switch (props.strategy ?? "afterHydration") {
+			case "beforeHydration": break;
+			case "afterHydration":
+				loadScript();
+				break;
+			case "onIdle":
+				if ("requestIdleCallback" in window) requestIdleCallback(() => loadScript(), { timeout: 5e3 });
+				else setTimeout(loadScript, 200);
+				break;
+			case "onInteraction": {
+				const events = [
+					"click",
+					"scroll",
+					"keydown",
+					"touchstart"
+				];
+				function handler() {
+					for (const e of events) document.removeEventListener(e, handler);
+					loadScript();
+				}
+				for (const e of events) document.addEventListener(e, handler, {
+					once: true,
+					passive: true
+				});
+				onUnmount(() => {
+					for (const e of events) document.removeEventListener(e, handler);
+				});
+				break;
+			}
+			case "onViewport": break;
+		}
+	});
+	const sentinelRef = createRef();
+	const strategy = props.strategy ?? "afterHydration";
+	if (strategy === "onViewport") useIntersectionObserver(() => sentinelRef.current ?? void 0, () => loadScript());
+	if (strategy === "onViewport") return /* @__PURE__ */ jsx("div", {
+		ref: sentinelRef,
+		style: "width:0;height:0;overflow:hidden"
+	});
+	return null;
+}
+
+//#endregion
+//#region src/cache.ts
+const HASHED_ASSET = /\.[a-f0-9]{8,}\.\w+$/;
+const STATIC_EXT = /\.(png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|otf|eot|mp4|webm|ogg|mp3|wav)$/i;
+const SCRIPT_EXT = /\.(js|css|mjs)$/i;
+/** @internal Exported for testing */
+function matchGlob(pattern, path) {
+	const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+	return new RegExp(`^${regex}$`).test(path);
+}
+function resolveControl(path, immutableDuration, staticDuration, pageDuration, swr) {
+	if (HASHED_ASSET.test(path)) return `public, max-age=${immutableDuration}, immutable`;
+	if (SCRIPT_EXT.test(path)) return `public, max-age=3600, stale-while-revalidate=${swr}`;
+	if (STATIC_EXT.test(path)) return `public, max-age=${staticDuration}, stale-while-revalidate=${swr}`;
+	if (pageDuration > 0) return `public, max-age=${pageDuration}, stale-while-revalidate=${swr}`;
+	return "no-cache";
+}
+/**
+* Cache control middleware for Zero.
+* Sets Cache-Control headers on the response based on asset type.
+*
+* @example
+* import { cacheMiddleware } from "@pyreon/zero/cache"
+*
+* export default createHandler({
+*   routes,
+*   middleware: [
+*     cacheMiddleware({
+*       pages: 60,
+*       staleWhileRevalidate: 300,
+*       rules: [
+*         { match: "/api/*", control: "no-store" },
+*       ],
+*     }),
+*   ],
+* })
+*/
+function cacheMiddleware(config = {}) {
+	const immutableDuration = config.immutable ?? 31536e3;
+	const staticDuration = config.static ?? 86400;
+	const pageDuration = config.pages ?? 0;
+	const swr = config.staleWhileRevalidate ?? 60;
+	const rules = config.rules ?? [];
+	return (ctx) => {
+		const path = ctx.url.pathname;
+		for (const rule of rules) if (matchGlob(rule.match, path)) {
+			ctx.headers.set("Cache-Control", rule.control);
+			return;
+		}
+		const control = resolveControl(path, immutableDuration, staticDuration, pageDuration, swr);
+		ctx.headers.set("Cache-Control", control);
+	};
+}
+/**
+* Security headers middleware.
+* Adds common security headers to all responses.
+*/
+function securityHeaders() {
+	return (ctx) => {
+		ctx.headers.set("X-Content-Type-Options", "nosniff");
+		ctx.headers.set("X-Frame-Options", "DENY");
+		ctx.headers.set("X-XSS-Protection", "1; mode=block");
+		ctx.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+		ctx.headers.set("Permissions-Policy", "camera=(), microphone=(), geolocation=()");
+	};
+}
+/**
+* Compression detection middleware.
+* Sets Vary: Accept-Encoding header so caches can serve compressed variants.
+* Actual compression is handled by the runtime (Bun/Node) or reverse proxy.
+*/
+function varyEncoding() {
+	return (ctx) => {
+		const existing = ctx.headers.get("Vary");
+		if (!existing?.includes("Accept-Encoding")) ctx.headers.set("Vary", existing ? `${existing}, Accept-Encoding` : "Accept-Encoding");
+	};
+}
+
+//#endregion
+//#region src/font.ts
+/**
+* Normalize a GoogleFontInput (string or object) into a ResolvedFont.
+*/
+function resolveGoogleFont(input) {
+	if (typeof input === "string") return parseGoogleFamily(input);
+	if (input.variable) return {
+		family: input.family,
+		italic: input.italic ?? false,
+		variable: true,
+		weightRange: input.weightRange
+	};
+	return {
+		family: input.family,
+		italic: input.italic ?? false,
+		variable: false,
+		weights: input.weights
+	};
+}
+/**
+* Parse Google Fonts family string shorthand.
+*
+* Static weights: "Inter:wght@400;500;700"
+* Variable range:  "Inter:wght@100..900"
+* Variable with italic: "Inter:ital,wght@100..900"
+*/
+function parseGoogleFamily(input) {
+	const [familyPart, spec] = input.split(":");
+	const family = familyPart?.trim();
+	let italic = false;
+	if (spec) {
+		italic = spec.includes("ital");
+		const rangeMatch = spec.match(/wght@(\d+)\.\.(\d+)/);
+		if (rangeMatch) return {
+			family,
+			italic,
+			variable: true,
+			weightRange: [Number(rangeMatch[1]), Number(rangeMatch[2])]
+		};
+		const weightMatch = spec.match(/wght@([\d;]+)/);
+		if (weightMatch) return {
+			family,
+			italic,
+			variable: false,
+			weights: weightMatch[1]?.split(";").map(Number)
+		};
+	}
+	return {
+		family,
+		italic,
+		variable: false,
+		weights: [400]
+	};
+}
+/**
+* Generate a Google Fonts CSS URL.
+*/
+function googleFontsUrl(families, display = "swap") {
+	return `https://fonts.googleapis.com/css2?${families.map((f) => {
+		const axes = f.italic ? "ital,wght" : "wght";
+		const name = f.family.replace(/ /g, "+");
+		if (f.variable) {
+			const range = `${f.weightRange[0]}..${f.weightRange[1]}`;
+			return `family=${name}:${axes}@${f.italic ? `0,${range};1,${range}` : range}`;
+		}
+		return `family=${name}:${axes}@${f.weights.map((w) => f.italic ? `0,${w};1,${w}` : String(w)).join(";")}`;
+	}).join("&")}&display=${display}`;
+}
+/**
+* Generate @font-face CSS for local fonts.
+*/
+function localFontFaces(fonts, display) {
+	return fonts.map((f) => `@font-face {
+  font-family: "${f.family}";
+  src: url("${f.src}");
+  font-weight: ${f.weight ?? "400"};
+  font-style: ${f.style ?? "normal"};
+  font-display: ${f.display ?? display};
+}`).join("\n\n");
+}
+/**
+* Generate size-adjusted fallback @font-face declarations to reduce CLS.
+*/
+function fallbackFontFaces(fallbacks) {
+	return Object.entries(fallbacks).map(([family, metrics]) => {
+		const overrides = [];
+		if (metrics.sizeAdjust != null) overrides.push(`  size-adjust: ${metrics.sizeAdjust * 100}%;`);
+		if (metrics.ascentOverride != null) overrides.push(`  ascent-override: ${metrics.ascentOverride}%;`);
+		if (metrics.descentOverride != null) overrides.push(`  descent-override: ${metrics.descentOverride}%;`);
+		if (metrics.lineGapOverride != null) overrides.push(`  line-gap-override: ${metrics.lineGapOverride}%;`);
+		return `@font-face {
+  font-family: "${family} Fallback";
+  src: local("${metrics.fallback}");
+${overrides.join("\n")}
+}`;
+	}).join("\n\n");
+}
+/**
+* Generate preload link tags for critical font files.
+*/
+function preloadTags(fonts) {
+	return fonts.map((f) => {
+		const ext = f.src.split(".").pop();
+		const type = ext === "woff2" ? "font/woff2" : ext === "woff" ? "font/woff" : ext === "ttf" ? "font/ttf" : "font/otf";
+		return `<link rel="preload" href="${f.src}" as="font" type="${type}" crossorigin>`;
+	}).join("\n");
+}
+/**
+* Download Google Fonts CSS with woff2 user agent.
+*/
+async function downloadGoogleFontsCSS(url) {
+	const response = await fetch(url, { headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" } });
+	if (!response.ok) throw new Error(`Failed to fetch Google Fonts CSS: ${response.status}`);
+	return response.text();
+}
+/**
+* Download a font file.
+*/
+async function downloadFontFile(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to download font: ${url}`);
+	const arrayBuffer = await response.arrayBuffer();
+	return Buffer.from(arrayBuffer);
+}
+/**
+* Extract font file URLs from Google Fonts CSS.
+*/
+function extractFontUrls(css) {
+	const urls = [];
+	for (const match of css.matchAll(/url\((https:\/\/fonts\.gstatic\.com\/[^)]+)\)/g)) if (match[1]) urls.push(match[1]);
+	return urls;
+}
+/**
+* Self-host Google Fonts: download CSS + font files, rewrite URLs to local paths.
+*/
+async function selfHostFonts(cssUrl, fontsSubDir) {
+	const css = await downloadGoogleFontsCSS(cssUrl);
+	const fontUrls = extractFontUrls(css);
+	const fontFiles = [];
+	let rewrittenCss = css;
+	for (const url of fontUrls) {
+		const fileName = url.split("/").at(-1)?.split("?")[0] ?? "font";
+		const content = await downloadFontFile(url);
+		fontFiles.push({
+			name: fileName,
+			content
+		});
+		rewrittenCss = rewrittenCss.replace(url, `/${fontsSubDir}/${fileName}`);
+	}
+	return {
+		css: rewrittenCss,
+		fontFiles
+	};
+}
+/**
+* Zero font optimization Vite plugin.
+*
+* Dev mode: injects Google Fonts CDN link for fast startup.
+* Build mode: downloads and self-hosts fonts for maximum performance + privacy.
+*
+* @example
+* import { fontPlugin } from "@pyreon/zero/font"
+*
+* export default {
+*   plugins: [
+*     pyreon(),
+*     zero(),
+*     fontPlugin({
+*       google: ["Inter:wght@400;500;600;700", "JetBrains Mono:wght@400"],
+*       fallbacks: {
+*         "Inter": { fallback: "Arial", sizeAdjust: 1.07, ascentOverride: 90 },
+*       },
+*     }),
+*   ],
+* }
+*/
+function fontPlugin(config = {}) {
+	const display = config.display ?? "swap";
+	const shouldPreload = config.preload !== false;
+	const shouldSelfHost = config.selfHost !== false;
+	const googleFamilies = (config.google ?? []).map(resolveGoogleFont);
+	let isBuild = false;
+	let selfHostedCSS = "";
+	let selfHostedFontFiles = [];
+	return {
+		name: "pyreon-zero-fonts",
+		configResolved(resolvedConfig) {
+			isBuild = resolvedConfig.command === "build";
+		},
+		async buildStart() {
+			if (isBuild && shouldSelfHost && googleFamilies.length > 0) {
+				const cssUrl = googleFontsUrl(googleFamilies, display);
+				try {
+					const result = await selfHostFonts(cssUrl, "assets/fonts");
+					selfHostedCSS = result.css;
+					selfHostedFontFiles = result.fontFiles;
+				} catch {}
+			}
+		},
+		generateBundle() {
+			for (const file of selfHostedFontFiles) this.emitFile({
+				type: "asset",
+				fileName: `assets/fonts/${file.name}`,
+				source: file.content
+			});
+		},
+		transformIndexHtml(html) {
+			const tags = [];
+			collectGoogleFontTags(tags, {
+				isBuild,
+				selfHostedCSS,
+				selfHostedFontFiles,
+				shouldPreload,
+				googleFamilies,
+				display
+			});
+			collectLocalFontTags(tags, config, shouldPreload, display);
+			if (tags.length === 0) return html;
+			return html.replace("</head>", `${tags.join("\n")}\n</head>`);
+		}
+	};
+}
+function collectGoogleFontTags(tags, opts) {
+	if (opts.isBuild && opts.selfHostedCSS) {
+		tags.push(`<style>${opts.selfHostedCSS}</style>`);
+		if (opts.shouldPreload) for (const file of opts.selfHostedFontFiles.slice(0, opts.googleFamilies.length)) {
+			const type = file.name.split(".").pop() === "woff2" ? "font/woff2" : "font/woff";
+			tags.push(`<link rel="preload" href="/assets/fonts/${file.name}" as="font" type="${type}" crossorigin>`);
+		}
+	} else if (opts.googleFamilies.length > 0) {
+		const cssUrl = googleFontsUrl(opts.googleFamilies, opts.display);
+		tags.push(`<link rel="preconnect" href="https://fonts.googleapis.com">`);
+		tags.push(`<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>`);
+		tags.push(`<link rel="stylesheet" href="${cssUrl}">`);
+	}
+}
+function collectLocalFontTags(tags, config, shouldPreload, display) {
+	if (shouldPreload && config.local?.length) tags.push(preloadTags(config.local));
+	if (config.local?.length) tags.push(`<style>${localFontFaces(config.local, display)}</style>`);
+	if (config.fallbacks && Object.keys(config.fallbacks).length > 0) tags.push(`<style>${fallbackFontFaces(config.fallbacks)}</style>`);
+}
+/**
+* Generate CSS variables for font families.
+*/
+function fontVariables(families) {
+	return `:root {\n${Object.entries(families).map(([key, value]) => `  --font-${key}: ${value};`).join("\n")}\n}`;
+}
+
+//#endregion
+//#region src/image-plugin.ts
+let sharpWarned = false;
+function warnSharpMissing() {
+	if (sharpWarned) return;
+	sharpWarned = 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;
+/**
+* Zero image processing Vite plugin.
+*
+* Transforms image imports with query params into optimized responsive images:
+*
+* @example
+* // vite.config.ts
+* import { imagePlugin } from "@pyreon/zero/image-plugin"
+*
+* export default {
+*   plugins: [
+*     pyreon(),
+*     zero(),
+*     imagePlugin({ widths: [480, 960, 1440], quality: 85 }),
+*   ],
+* }
+*
+* @example
+* // In a component — import with ?optimize
+* import hero from "./images/hero.jpg?optimize"
+* // hero = { src, srcset, width, height, placeholder }
+*
+* <Image {...hero} alt="Hero" priority />
+*/
+function imagePlugin(config = {}) {
+	const defaultWidths = config.widths ?? [
+		640,
+		1024,
+		1920
+	];
+	const defaultFormats = config.formats ?? ["webp"];
+	const quality = config.quality ?? 80;
+	const placeholderSize = config.placeholderSize ?? 16;
+	const outSubDir = config.outDir ?? "assets/img";
+	const include = config.include ?? IMAGE_EXT_RE;
+	let root = "";
+	let outDir = "";
+	let isBuild = false;
+	return {
+		name: "pyreon-zero-images",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			root = resolvedConfig.root;
+			outDir = resolvedConfig.build.outDir;
+			isBuild = resolvedConfig.command === "build";
+		},
+		async resolveId(id) {
+			if (id.includes("?optimize") && include.test(id.split("?")[0])) return `\0virtual:zero-image:${id}`;
+			return null;
+		},
+		async load(id) {
+			if (!id.startsWith("\0virtual:zero-image:")) return null;
+			const rawPath = id.replace("\0virtual:zero-image:", "").split("?")[0] ?? id;
+			const absPath = rawPath.startsWith("/") ? join(root, "public", rawPath) : rawPath;
+			if (!isBuild) {
+				const result = await loadDevImage(absPath, rawPath, placeholderSize);
+				return `export default ${JSON.stringify(result)}`;
+			}
+			const processed = await processImage(absPath, {
+				widths: defaultWidths,
+				formats: defaultFormats,
+				quality,
+				placeholderSize,
+				outSubDir,
+				outDir: join(root, outDir)
+			});
+			await emitProcessedSources(processed, outSubDir, this);
+			rebuildFormatSrcsets(processed, absPath);
+			return `export default ${JSON.stringify(processed)}`;
+		}
+	};
+}
+async function loadDevImage(absPath, rawPath, placeholderSize) {
+	const metadata = await getImageMetadata(absPath);
+	const publicPath = rawPath.startsWith("/") ? rawPath : `/@fs/${absPath}`;
+	return {
+		src: publicPath,
+		srcset: "",
+		width: metadata.width,
+		height: metadata.height,
+		placeholder: await generateBlurPlaceholder(absPath, placeholderSize),
+		formats: [],
+		sources: [{
+			src: publicPath,
+			width: metadata.width,
+			format: "original"
+		}]
+	};
+}
+async function emitProcessedSources(processed, outSubDir, ctx) {
+	for (const source of processed.sources) {
+		const fileName = join(outSubDir, basename(source.src));
+		const content = await readFile(source.src);
+		ctx.emitFile({
+			type: "asset",
+			fileName,
+			source: content
+		});
+		source.src = `/${fileName}`;
+	}
+}
+function rebuildFormatSrcsets(processed, fallbackPath) {
+	const formatGroups = /* @__PURE__ */ new Map();
+	for (const s of processed.sources) {
+		let group = formatGroups.get(s.format);
+		if (!group) {
+			group = [];
+			formatGroups.set(s.format, group);
+		}
+		group.push(`${s.src} ${s.width}w`);
+	}
+	processed.formats = [...formatGroups.entries()].map(([fmt, entries]) => ({
+		type: `image/${fmt}`,
+		srcset: entries.join(", ")
+	}));
+	processed.srcset = processed.formats.at(-1)?.srcset ?? "";
+	processed.src = processed.sources.at(-1)?.src ?? fallbackPath;
+}
+async function processImage(absPath, opts) {
+	const metadata = await getImageMetadata(absPath);
+	const name = basename(absPath, extname(absPath));
+	const sources = [];
+	const processedDir = join(opts.outDir, opts.outSubDir);
+	if (!existsSync(processedDir)) await mkdir(processedDir, { recursive: true });
+	for (const format of opts.formats) for (const targetWidth of opts.widths) {
+		const width = Math.min(targetWidth, metadata.width);
+		const outPath = join(processedDir, `${name}-${width}.${format}`);
+		await resizeImage(absPath, outPath, width, format, opts.quality);
+		sources.push({
+			src: outPath,
+			width,
+			format
+		});
+	}
+	const formatGroups = /* @__PURE__ */ new Map();
+	for (const s of sources) {
+		let group = formatGroups.get(s.format);
+		if (!group) {
+			group = [];
+			formatGroups.set(s.format, group);
+		}
+		group.push({
+			src: s.src,
+			width: s.width
+		});
+	}
+	const formats = [...formatGroups.entries()].map(([fmt, group]) => ({
+		type: `image/${fmt === "jpeg" ? "jpeg" : fmt}`,
+		srcset: group.map((s) => `${s.src} ${s.width}w`).join(", ")
+	}));
+	const fallbackFormat = formats[formats.length - 1];
+	const fallbackSources = formatGroups.get([...formatGroups.keys()].pop());
+	const placeholder = await generateBlurPlaceholder(absPath, opts.placeholderSize);
+	return {
+		src: fallbackSources[fallbackSources.length - 1]?.src ?? absPath,
+		srcset: fallbackFormat?.srcset ?? "",
+		width: metadata.width,
+		height: metadata.height,
+		placeholder,
+		formats,
+		sources
+	};
+}
+/**
+* Read basic image metadata.
+* Uses minimal binary header parsing — no external dependencies.
+*/
+async function getImageMetadata(absPath) {
+	const buffer = await readFile(absPath);
+	const ext = extname(absPath).toLowerCase();
+	if (ext === ".png") return {
+		width: buffer.readUInt32BE(16),
+		height: buffer.readUInt32BE(20),
+		format: "png"
+	};
+	if (ext === ".jpg" || ext === ".jpeg") return {
+		...parseJpegDimensions(buffer),
+		format: "jpeg"
+	};
+	if (ext === ".webp") return {
+		...parseWebPDimensions(buffer),
+		format: "webp"
+	};
+	return {
+		width: 0,
+		height: 0,
+		format: ext.slice(1)
+	};
+}
+/** @internal Exported for testing */
+function parseJpegDimensions(buffer) {
+	let offset = 2;
+	while (offset < buffer.length) {
+		if (buffer[offset] !== 255) break;
+		const marker = buffer[offset + 1];
+		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+			const height = buffer.readUInt16BE(offset + 5);
+			return {
+				width: buffer.readUInt16BE(offset + 7),
+				height
+			};
+		}
+		const length = buffer.readUInt16BE(offset + 2);
+		offset += 2 + length;
+	}
+	return {
+		width: 0,
+		height: 0
+	};
+}
+/** @internal Exported for testing */
+function parseWebPDimensions(buffer) {
+	const chunk = buffer.toString("ascii", 12, 16);
+	if (chunk === "VP8 ") return {
+		width: buffer.readUInt16LE(26) & 16383,
+		height: buffer.readUInt16LE(28) & 16383
+	};
+	if (chunk === "VP8L") {
+		const bits = buffer.readUInt32LE(21);
+		return {
+			width: (bits & 16383) + 1,
+			height: (bits >> 14 & 16383) + 1
+		};
+	}
+	if (chunk === "VP8X") return {
+		width: 1 + ((buffer[24] | buffer[25] << 8 | buffer[26] << 16) & 16777215),
+		height: 1 + ((buffer[27] | buffer[28] << 8 | buffer[29] << 16) & 16777215)
+	};
+	return {
+		width: 0,
+		height: 0
+	};
+}
+/**
+* Resize an image using native platform capabilities.
+* Uses sharp if available, falls back to canvas API.
+*/
+async function resizeImage(input, output, width, format, quality) {
+	try {
+		let pipeline = (await import("sharp").then((m) => m.default ?? m))(input).resize(width);
+		switch (format) {
+			case "webp":
+				pipeline = pipeline.webp({ quality });
+				break;
+			case "avif":
+				pipeline = pipeline.avif({ quality });
+				break;
+			case "jpeg":
+				pipeline = pipeline.jpeg({
+					quality,
+					mozjpeg: true
+				});
+				break;
+			case "png":
+				pipeline = pipeline.png({ compressionLevel: 9 });
+				break;
+		}
+		await pipeline.toFile(output);
+	} catch {
+		warnSharpMissing();
+		await writeFile(output, await readFile(input));
+	}
+}
+/**
+* Generate a tiny blur placeholder as a base64 data URI.
+*/
+async function generateBlurPlaceholder(input, size) {
+	try {
+		return `data:image/webp;base64,${(await (await import("sharp").then((m) => m.default ?? m))(input).resize(size, size, { fit: "inside" }).blur(2).webp({ quality: 20 }).toBuffer()).toString("base64")}`;
+	} catch {
+		return "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='1' height='1'%3E%3C/svg%3E";
+	}
+}
+
+//#endregion
+//#region src/theme.tsx
+const STORAGE_KEY = "zero-theme";
+/** Reactive theme signal. */
+const theme = signal("system");
+/** Computed resolved theme (what's actually applied). */
+function resolvedTheme() {
+	const t = theme();
+	if (t === "system") {
+		if (typeof window === "undefined") return "dark";
+		return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+	}
+	return t;
+}
+/** Toggle between light and dark. */
+function toggleTheme() {
+	setTheme(resolvedTheme() === "dark" ? "light" : "dark");
+}
+/** Set theme explicitly. */
+function setTheme(t) {
+	theme.set(t);
+	if (typeof document !== "undefined") {
+		document.documentElement.dataset.theme = resolvedTheme();
+		try {
+			localStorage.setItem(STORAGE_KEY, t);
+		} catch {}
+	}
+}
+/**
+* Initialize the theme system. Call once in your app entry or layout.
+* Reads from localStorage, listens for system preference changes.
+*/
+function initTheme() {
+	onMount(() => {
+		try {
+			const stored = localStorage.getItem(STORAGE_KEY);
+			if (stored === "light" || stored === "dark" || stored === "system") theme.set(stored);
+		} catch {}
+		document.documentElement.dataset.theme = resolvedTheme();
+		const mq = window.matchMedia("(prefers-color-scheme: dark)");
+		function onChange() {
+			if (theme() === "system") document.documentElement.dataset.theme = resolvedTheme();
+		}
+		mq.addEventListener("change", onChange);
+		onUnmount(() => mq.removeEventListener("change", onChange));
+		const dispose = effect(() => {
+			document.documentElement.dataset.theme = resolvedTheme();
+		});
+		if (dispose) onUnmount(() => dispose.dispose());
+	});
+}
+/**
+* Theme toggle button component.
+*
+* @example
+* import { ThemeToggle } from "@pyreon/zero/theme"
+* <ThemeToggle />
+*/
+function ThemeToggle(props) {
+	initTheme();
+	return /* @__PURE__ */ jsx("button", {
+		class: props.class,
+		style: props.style,
+		onclick: toggleTheme,
+		"aria-label": "Toggle theme",
+		title: "Toggle theme",
+		type: "button",
+		children: () => resolvedTheme() === "dark" ? /* @__PURE__ */ jsxs("svg", {
+			width: "18",
+			height: "18",
+			viewBox: "0 0 24 24",
+			fill: "none",
+			stroke: "currentColor",
+			"stroke-width": "2",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round",
+			"aria-hidden": "true",
+			children: [
+				/* @__PURE__ */ jsx("circle", {
+					cx: "12",
+					cy: "12",
+					r: "5"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "12",
+					y1: "1",
+					x2: "12",
+					y2: "3"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "12",
+					y1: "21",
+					x2: "12",
+					y2: "23"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "4.22",
+					y1: "4.22",
+					x2: "5.64",
+					y2: "5.64"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "18.36",
+					y1: "18.36",
+					x2: "19.78",
+					y2: "19.78"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "1",
+					y1: "12",
+					x2: "3",
+					y2: "12"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "21",
+					y1: "12",
+					x2: "23",
+					y2: "12"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "4.22",
+					y1: "19.78",
+					x2: "5.64",
+					y2: "18.36"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: "18.36",
+					y1: "5.64",
+					x2: "19.78",
+					y2: "4.22"
+				})
+			]
+		}) : /* @__PURE__ */ jsx("svg", {
+			width: "18",
+			height: "18",
+			viewBox: "0 0 24 24",
+			fill: "none",
+			stroke: "currentColor",
+			"stroke-width": "2",
+			"stroke-linecap": "round",
+			"stroke-linejoin": "round",
+			"aria-hidden": "true",
+			children: /* @__PURE__ */ jsx("path", { d: "M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z" })
+		})
+	});
+}
+/**
+* Inline script to prevent flash of wrong theme.
+* Include this in your index.html <head> BEFORE any stylesheets.
+*
+* @example
+* // index.html
+* <head>
+*   <script>{themeScript}<\/script>
+*   ...
+* </head>
+*/
+const themeScript = `(function(){try{var t=localStorage.getItem("${STORAGE_KEY}");var r=t==="light"?"light":t==="dark"?"dark":window.matchMedia("(prefers-color-scheme:dark)").matches?"dark":"light";document.documentElement.dataset.theme=r}catch(e){}})()`;
+
+//#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(`${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) {
+	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-jfd1QGLB.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-jfd1QGLB.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
+export { Image, Link, Script, ThemeToggle, bunAdapter, cacheMiddleware, createApp, createISRHandler, createLink, createServer, zeroPlugin as default, defineConfig, filePathToUrlPath, fontPlugin, fontVariables, generateRobots, generateRouteModule, generateSitemap, imagePlugin, initTheme, jsonLd, nodeAdapter, parseFileRoutes, resolveAdapter, resolveConfig, resolvedTheme, scanRouteFiles, securityHeaders, seoMiddleware, seoPlugin, setTheme, staticAdapter, theme, themeScript, toggleTheme, useLink, varyEncoding };
+//# sourceMappingURL=index.js.map