@pyreon/zero 0.12.3 → 0.12.5

package/lib/server.js

@@ -0,0 +1,1534 @@
+import { Fragment, createContext, h } from "@pyreon/core";
+import { HeadProvider } from "@pyreon/head";
+import { RouterProvider, RouterView, createRouter } from "@pyreon/router";
+import { createHandler } from "@pyreon/server";
+import { renderToString } from "@pyreon/runtime-server";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { signal } from "@pyreon/reactivity";
+
+//#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",
+		...options.url ? { 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/api-routes.ts
+/**
+* Match a URL path against an API route pattern.
+* Returns extracted params or null if no match.
+*/
+function matchApiRoute(pattern, path) {
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = path.split("/").filter(Boolean);
+	const params = {};
+	for (let i = 0; i < patternParts.length; i++) {
+		const pp = patternParts[i];
+		if (!pp) continue;
+		if (pp.endsWith("*")) {
+			const paramName = pp.slice(1, -1);
+			params[paramName] = pathParts.slice(i).join("/");
+			return params;
+		}
+		if (i >= pathParts.length) return null;
+		if (pp.startsWith(":")) {
+			params[pp.slice(1)] = pathParts[i];
+			continue;
+		}
+		if (pp !== pathParts[i]) return null;
+	}
+	return patternParts.length === pathParts.length ? params : null;
+}
+const HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS"
+];
+/**
+* Create a middleware that dispatches API route requests.
+* API routes are matched by URL pattern and HTTP method.
+*/
+function createApiMiddleware(routes) {
+	return async (ctx) => {
+		for (const route of routes) {
+			const params = matchApiRoute(route.pattern, ctx.path);
+			if (!params) continue;
+			const method = ctx.req.method.toUpperCase();
+			const handler = route.module[method];
+			if (!handler) {
+				const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(", ");
+				return new Response(null, {
+					status: 405,
+					headers: {
+						Allow: allowed,
+						"Content-Type": "application/json"
+					}
+				});
+			}
+			return handler({
+				request: ctx.req,
+				url: ctx.url,
+				path: ctx.path,
+				params,
+				headers: ctx.req.headers
+			});
+		}
+	};
+}
+/**
+* Detect whether a route file is an API route.
+* API routes are `.ts` or `.js` files inside an `api/` directory.
+*/
+function isApiRoute(filePath) {
+	const normalized = filePath.replace(/\\/g, "/");
+	return normalized.startsWith("api/") && (normalized.endsWith(".ts") || normalized.endsWith(".js")) && !normalized.endsWith(".tsx") && !normalized.endsWith(".jsx");
+}
+/**
+* Convert an API route file path to a URL pattern.
+*
+* Examples:
+*   "api/posts.ts"        → "/api/posts"
+*   "api/posts/index.ts"  → "/api/posts"
+*   "api/posts/[id].ts"   → "/api/posts/:id"
+*   "api/[...path].ts"    → "/api/:path*"
+*/
+function apiFilePathToPattern(filePath) {
+	let route = filePath;
+	for (const ext of [".ts", ".js"]) if (route.endsWith(ext)) {
+		route = route.slice(0, -ext.length);
+		break;
+	}
+	const segments = route.split("/");
+	const urlSegments = [];
+	for (const seg of segments) {
+		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("/")}`;
+}
+/**
+* Generate a virtual module that exports API route entries.
+* Each entry maps a URL pattern to a module with HTTP method handlers.
+*/
+function generateApiRouteModule(files, routesDir) {
+	const apiFiles = files.filter(isApiRoute);
+	if (apiFiles.length === 0) return "export const apiRoutes = []\n";
+	const imports = [];
+	const entries = [];
+	for (let i = 0; i < apiFiles.length; i++) {
+		const name = `_api${i}`;
+		const file = apiFiles[i];
+		if (!file) continue;
+		const fullPath = `${routesDir}/${file}`;
+		const pattern = apiFilePathToPattern(file);
+		imports.push(`import * as ${name} from "${fullPath}"`);
+		entries.push(`  { pattern: ${JSON.stringify(pattern)}, module: ${name} }`);
+	}
+	return [
+		...imports,
+		"",
+		"export const apiRoutes = [",
+		entries.join(",\n"),
+		"]"
+	].join("\n");
+}
+
+//#endregion
+//#region src/not-found.ts
+const DEFAULT_404_BODY = "<h1>404 — Not Found</h1><p>The page you requested does not exist.</p>";
+/**
+* Render a 404 component to a full HTML string.
+* If no component is provided, returns a default 404 page.
+*/
+async function render404Page(component, template) {
+	let body;
+	if (component) body = await renderToString(h(component, null));
+	else body = DEFAULT_404_BODY;
+	if (template?.includes("<!--pyreon-app-->")) return template.replace("<!--pyreon-app-->", body);
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>404 — Not Found</title>
+</head>
+<body>
+  ${body}
+</body>
+</html>`;
+}
+
+//#endregion
+//#region src/entry-server.ts
+/**
+* Create a middleware that dispatches per-route middleware based on URL pattern matching.
+*/
+function createRouteMiddlewareDispatcher(entries) {
+	return async (ctx) => {
+		for (const entry of entries) if (matchPattern(entry.pattern, ctx.path)) {
+			const mw = Array.isArray(entry.middleware) ? entry.middleware : [entry.middleware];
+			for (const fn of mw) {
+				const result = await fn(ctx);
+				if (result) return result;
+			}
+		}
+	};
+}
+/**
+* URL pattern matcher supporting :param and :param* segments.
+*
+* Rules:
+* - Static segments must match exactly
+* - `:param` matches a single path segment
+* - `:param*` matches all remaining segments (must be last, and path must
+*   have matched all preceding segments)
+* - Path length must match pattern length (unless catch-all)
+*/
+function matchPattern(pattern, path) {
+	const patternParts = pattern.split("/").filter(Boolean);
+	const pathParts = path.split("/").filter(Boolean);
+	for (let i = 0; i < patternParts.length; i++) {
+		const pp = patternParts[i];
+		if (pp.endsWith("*")) return i <= pathParts.length;
+		if (i >= pathParts.length) return false;
+		if (pp.startsWith(":")) continue;
+		if (pp !== pathParts[i]) return false;
+	}
+	return patternParts.length === pathParts.length;
+}
+/**
+* Create the SSR request handler for production.
+*
+* @example
+* import { routes } from "virtual:zero/routes"
+* import { routeMiddleware } from "virtual:zero/route-middleware"
+* import { createServer } from "@pyreon/zero"
+*
+* export default createServer({ routes, routeMiddleware, apiRoutes })
+*/
+function createServer(options) {
+	const config = options.config ?? {};
+	const allMiddleware = [];
+	if (options.apiRoutes?.length) allMiddleware.push(createApiMiddleware(options.apiRoutes));
+	if (options.routeMiddleware?.length) allMiddleware.push(createRouteMiddlewareDispatcher(options.routeMiddleware));
+	allMiddleware.push(...config.middleware ?? []);
+	allMiddleware.push(...options.middleware ?? []);
+	const { App } = createApp({
+		routes: options.routes,
+		routerMode: "history"
+	});
+	const handler = createHandler({
+		App,
+		routes: options.routes,
+		middleware: allMiddleware,
+		mode: config.ssr?.mode ?? "string",
+		...options.template ? { template: options.template } : {},
+		...options.clientEntry ? { clientEntry: options.clientEntry } : {}
+	});
+	if (!options.notFoundComponent) return handler;
+	const NotFound = options.notFoundComponent;
+	const routePatterns = flattenRoutePatterns$1(options.routes);
+	return async (req) => {
+		const pathname = new URL(req.url).pathname;
+		if (!routePatterns.some((pattern) => matchPattern(pattern, pathname))) {
+			const fullHtml = await render404Page(NotFound, options.template);
+			return new Response(fullHtml, {
+				status: 404,
+				headers: { "Content-Type": "text/html; charset=utf-8" }
+			});
+		}
+		return handler(req);
+	};
+}
+/** Extract all URL patterns from a nested route tree. */
+function flattenRoutePatterns$1(routes, prefix = "") {
+	const patterns = [];
+	for (const route of routes) {
+		const fullPath = route.path === "/" && prefix ? prefix : `${prefix}${route.path}`;
+		patterns.push(fullPath);
+		if (route.children) patterns.push(...flattenRoutePatterns$1(route.children, fullPath));
+	}
+	return patterns;
+}
+
+//#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/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
+/**
+* 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/validate.ts
+/**
+* Validate that adapter build inputs exist before copying.
+* Throws with a clear error message if directories are missing.
+* @internal
+*/
+async function validateBuildInputs(options) {
+	const { existsSync } = await import("node:fs");
+	if (!existsSync(options.clientOutDir)) throw new Error(`[zero:adapter] Client build output not found: ${options.clientOutDir}. Run "vite build" first.`);
+	if (!existsSync(options.serverEntry)) throw new Error(`[zero:adapter] Server entry not found: ${options.serverEntry}. Run "vite build --ssr" first.`);
+}
+
+//#endregion
+//#region src/adapters/bun.ts
+/**
+* Bun adapter — generates a standalone Bun.serve() entry.
+*/
+function bunAdapter() {
+	return {
+		name: "bun",
+		async build(options) {
+			await validateBuildInputs(options);
+			const { writeFile, cp, mkdir } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			const outDir = options.outDir;
+			await mkdir(outDir, { recursive: true });
+			await cp(options.clientOutDir, join(outDir, "client"), { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
+			const port = options.config.port ?? 3e3;
+			const serverEntry = `
+const handler = (await import("./server/entry-server.js")).default
+const clientDir = new URL("./client/", import.meta.url).pathname
+
+Bun.serve({
+  port: ${port},
+  async fetch(req) {
+    const url = new URL(req.url)
+
+    // Try static files first
+    if (req.method === "GET") {
+      const filePath = clientDir + (url.pathname === "/" ? "index.html" : url.pathname)
+      // Prevent path traversal — ensure resolved path stays within clientDir
+      const resolved = Bun.resolveSync(filePath, ".")
+      if (!resolved.startsWith(Bun.resolveSync(clientDir, "."))) {
+        return new Response("Forbidden", { status: 403 })
+      }
+      const file = Bun.file(filePath)
+      if (await file.exists()) {
+        return new Response(file, {
+          headers: {
+            "cache-control": filePath.endsWith(".js") || filePath.endsWith(".css")
+              ? "public, max-age=31536000, immutable"
+              : "public, max-age=3600",
+          },
+        })
+      }
+    }
+
+    // Fall through to SSR handler
+    return handler(req)
+  },
+})
+
+console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
+`.trimStart();
+			await writeFile(join(outDir, "index.ts"), serverEntry);
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/cloudflare.ts
+/**
+* Cloudflare Pages adapter — generates output for Cloudflare Pages with Functions.
+*
+* Produces:
+* - Client assets in the output directory root (served as static)
+* - `_worker.js` — Cloudflare Pages Function for SSR
+*
+* Note: Cloudflare Pages Functions have a ~1MB module size limit.
+* For large apps, configure Vite's SSR build to bundle server code:
+* `ssr: { noExternal: true }` in vite.config.ts.
+*
+* Deploy with: `npx wrangler pages deploy ./dist`
+*
+* @example
+* ```ts
+* // zero.config.ts
+* import { defineConfig } from "@pyreon/zero"
+*
+* export default defineConfig({
+*   adapter: "cloudflare",
+* })
+* ```
+*/
+function cloudflareAdapter() {
+	return {
+		name: "cloudflare",
+		async build(options) {
+			await validateBuildInputs(options);
+			const { writeFile, cp, mkdir } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			const outDir = options.outDir;
+			await mkdir(outDir, { recursive: true });
+			await cp(options.clientOutDir, outDir, { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(outDir, "_server"), { recursive: true });
+			const workerEntry = `
+import handler from "./_server/entry-server.js"
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url)
+
+    // Let Cloudflare serve static assets (files with extensions)
+    // This check is a fallback — Pages routes static files automatically
+    const ext = url.pathname.split(".").pop()
+    if (ext && ext !== url.pathname && !url.pathname.endsWith("/")) {
+      // Cloudflare Pages handles static assets automatically via its asset binding
+      // Only reach here if the file doesn't exist — fall through to SSR
+    }
+
+    // SSR handler
+    try {
+      return await handler(request)
+    } catch (err) {
+      return new Response("Internal Server Error", { status: 500 })
+    }
+  },
+}
+`.trimStart();
+			await writeFile(join(outDir, "_worker.js"), workerEntry);
+			await writeFile(join(outDir, "_routes.json"), JSON.stringify({
+				version: 1,
+				include: ["/*"],
+				exclude: [
+					"/assets/*",
+					"/favicon.*",
+					"/site.webmanifest",
+					"/robots.txt",
+					"/sitemap.xml"
+				]
+			}, null, 2));
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/netlify.ts
+/**
+* Netlify adapter — generates output for Netlify Functions (v2).
+*
+* Produces:
+* - Client assets in `publish/` directory
+* - `netlify/functions/ssr.mjs` — Netlify Function for SSR
+* - `netlify.toml` — routing configuration
+*
+* @example
+* ```ts
+* // zero.config.ts
+* import { defineConfig } from "@pyreon/zero"
+*
+* export default defineConfig({
+*   adapter: "netlify",
+* })
+* ```
+*/
+function netlifyAdapter() {
+	return {
+		name: "netlify",
+		async build(options) {
+			await validateBuildInputs(options);
+			const { writeFile, cp, mkdir } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			const outDir = options.outDir;
+			const publishDir = join(outDir, "publish");
+			const functionsDir = join(outDir, "netlify", "functions");
+			await mkdir(publishDir, { recursive: true });
+			await mkdir(functionsDir, { recursive: true });
+			await cp(options.clientOutDir, publishDir, { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(functionsDir, "_server"), { recursive: true });
+			const funcEntry = `
+import handler from "./_server/entry-server.js"
+
+export default async function(req, context) {
+  try {
+    return await handler(req)
+  } catch (err) {
+    return new Response("Internal Server Error", { status: 500 })
+  }
+}
+
+export const config = {
+  path: "/*",
+  preferStatic: true,
+}
+`.trimStart();
+			await writeFile(join(functionsDir, "ssr.mjs"), funcEntry);
+			const toml = `
+[build]
+  publish = "publish"
+  functions = "netlify/functions"
+
+[[headers]]
+  for = "/assets/*"
+  [headers.values]
+    Cache-Control = "public, max-age=31536000, immutable"
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/functions/ssr"
+  status = 200
+  conditions = {Role = ["admin", "user", ""]}
+`.trimStart();
+			await writeFile(join(outDir, "netlify.toml"), toml);
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/node.ts
+/**
+* Node.js adapter — generates a standalone server entry using node:http.
+*/
+function nodeAdapter() {
+	return {
+		name: "node",
+		async build(options) {
+			await validateBuildInputs(options);
+			const { writeFile, cp, mkdir } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			const outDir = options.outDir;
+			await mkdir(outDir, { recursive: true });
+			await cp(options.clientOutDir, join(outDir, "client"), { recursive: true });
+			await cp(join(options.serverEntry, ".."), join(outDir, "server"), { recursive: true });
+			const port = options.config.port ?? 3e3;
+			const serverEntry = `
+import { createServer } from "node:http"
+import { readFile } from "node:fs/promises"
+import { join, extname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url))
+const handler = (await import("./server/entry-server.js")).default
+const clientDir = join(__dirname, "client")
+
+const MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ico": "image/x-icon",
+}
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", "http://localhost")
+
+  // Try to serve static files first
+  if (req.method === "GET") {
+    try {
+      const filePath = join(clientDir, url.pathname === "/" ? "index.html" : url.pathname)
+      // Prevent path traversal — ensure resolved path stays within clientDir
+      const { resolve } = await import("node:path")
+      const resolved = resolve(filePath)
+      if (!resolved.startsWith(resolve(clientDir))) {
+        res.writeHead(403)
+        res.end("Forbidden")
+        return
+      }
+      const ext = extname(filePath)
+      if (ext && ext !== ".html") {
+        const data = await readFile(filePath)
+        const mime = MIME_TYPES[ext] || "application/octet-stream"
+        res.writeHead(200, {
+          "content-type": mime,
+          "cache-control": ext === ".js" || ext === ".css"
+            ? "public, max-age=31536000, immutable"
+            : "public, max-age=3600",
+        })
+        res.end(data)
+        return
+      }
+    } catch {}
+  }
+
+  // Fall through to SSR handler
+  const headers = {}
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) headers[key] = Array.isArray(value) ? value.join(", ") : value
+  }
+
+  const request = new Request(url.href, {
+    method: req.method,
+    headers,
+  })
+
+  const response = await handler(request)
+  const body = await response.text()
+
+  const responseHeaders = {}
+  response.headers.forEach((v, k) => { responseHeaders[k] = v })
+
+  res.writeHead(response.status, responseHeaders)
+  res.end(body)
+})
+
+server.listen(${port}, () => {
+  console.log("\\n  ⚡ Zero production server running on http://localhost:${port}\\n")
+})
+`.trimStart();
+			await writeFile(join(outDir, "index.js"), serverEntry);
+			await writeFile(join(outDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/static.ts
+/**
+* Static adapter — just copies the client build output.
+* Used with SSG mode where all pages are pre-rendered at build time.
+*/
+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/vercel.ts
+/**
+* Vercel adapter — generates output for Vercel's Build Output API v3.
+*
+* Produces a `.vercel/output` directory with:
+* - `static/` — client-side assets (JS, CSS, images)
+* - `functions/ssr.func/` — serverless function for SSR
+* - `config.json` — routing configuration
+*
+* @example
+* ```ts
+* // zero.config.ts
+* import { defineConfig } from "@pyreon/zero"
+*
+* export default defineConfig({
+*   adapter: "vercel",
+* })
+* ```
+*/
+function vercelAdapter() {
+	return {
+		name: "vercel",
+		async build(options) {
+			await validateBuildInputs(options);
+			const { writeFile, cp, mkdir } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			const vercelDir = join(options.outDir, ".vercel", "output");
+			const staticDir = join(vercelDir, "static");
+			const funcDir = join(vercelDir, "functions", "ssr.func");
+			await mkdir(staticDir, { recursive: true });
+			await mkdir(funcDir, { recursive: true });
+			await cp(options.clientOutDir, staticDir, { recursive: true });
+			await cp(join(options.serverEntry, ".."), funcDir, { recursive: true });
+			const funcEntry = `
+export default async function handler(req) {
+  const handler = (await import("./entry-server.js")).default
+  return handler(req)
+}
+`.trimStart();
+			await writeFile(join(funcDir, "index.js"), funcEntry);
+			await writeFile(join(funcDir, ".vc-config.json"), JSON.stringify({
+				runtime: "nodejs20.x",
+				handler: "index.js",
+				launcherType: "Nodejs"
+			}, null, 2));
+			await writeFile(join(vercelDir, "config.json"), JSON.stringify({
+				version: 3,
+				routes: [
+					{
+						src: "/assets/(.*)",
+						headers: { "Cache-Control": "public, max-age=31536000, immutable" }
+					},
+					{
+						src: "/(favicon\\..*|site\\.webmanifest|robots\\.txt|sitemap\\.xml)",
+						dest: "/$1"
+					},
+					{
+						src: "/(.*)",
+						dest: "/ssr"
+					}
+				]
+			}, null, 2));
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/index.ts
+/**
+* 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();
+		case "vercel": return vercelAdapter();
+		case "cloudflare": return cloudflareAdapter();
+		case "netlify": return netlifyAdapter();
+		default: throw new Error(`[zero] Unknown adapter: "${name}". Use "node", "bun", "static", "vercel", "cloudflare", or "netlify".`);
+	}
+}
+
+//#endregion
+//#region src/middleware.ts
+/**
+* Compose multiple middleware into a single middleware function.
+* Middleware runs sequentially — if any returns a Response, the chain stops.
+*
+* @example
+* import { compose } from "@pyreon/zero/middleware"
+* import { corsMiddleware } from "@pyreon/zero/cors"
+* import { rateLimitMiddleware } from "@pyreon/zero/rate-limit"
+*
+* const combined = compose(
+*   corsMiddleware({ origin: "*" }),
+*   rateLimitMiddleware({ max: 100 }),
+*   cacheMiddleware(),
+* )
+*/
+function compose(...middlewares) {
+	return async (ctx) => {
+		for (const mw of middlewares) {
+			const result = await mw(ctx);
+			if (result instanceof Response) return result;
+		}
+	};
+}
+const ZERO_CTX_KEY = "__zeroCtx";
+/**
+* Get the shared Zero context from a middleware context.
+* Creates one if it doesn't exist. Middleware can use this to
+* pass data to downstream middleware without polluting `ctx.locals`.
+*
+* @example
+* const authMiddleware: Middleware = (ctx) => {
+*   const zctx = getContext(ctx)
+*   zctx.userId = "user_123"
+* }
+*
+* const loggingMiddleware: Middleware = (ctx) => {
+*   const zctx = getContext(ctx)
+*   console.log("User:", zctx.userId)
+* }
+*/
+function getContext(ctx) {
+	let zctx = ctx.locals[ZERO_CTX_KEY];
+	if (!zctx) {
+		zctx = {};
+		ctx.locals[ZERO_CTX_KEY] = zctx;
+	}
+	return zctx;
+}
+
+//#endregion
+//#region src/error-overlay.ts
+/**
+* Dev-only error overlay for SSR/loader errors.
+* Renders a styled HTML page with the error stack trace.
+*/
+function renderErrorOverlay(error) {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>SSR Error — Pyreon Zero</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: ui-monospace, "Cascadia Code", "Source Code Pro", Menlo, Consolas, monospace;
+      background: #1a1a2e;
+      color: #e0e0e0;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+    .overlay {
+      max-width: 900px;
+      margin: 0 auto;
+    }
+    .header {
+      display: flex;
+      align-items: center;
+      gap: 0.75rem;
+      margin-bottom: 1.5rem;
+    }
+    .badge {
+      background: #e74c3c;
+      color: white;
+      padding: 0.25rem 0.75rem;
+      border-radius: 4px;
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    .label {
+      color: #888;
+      font-size: 0.85rem;
+    }
+    .message {
+      font-size: 1.25rem;
+      color: #ff6b6b;
+      margin-bottom: 1.5rem;
+      line-height: 1.5;
+      word-break: break-word;
+    }
+    .stack {
+      background: #16213e;
+      border: 1px solid #2a2a4a;
+      border-radius: 8px;
+      padding: 1.25rem;
+      overflow-x: auto;
+      font-size: 0.8rem;
+      line-height: 1.7;
+      white-space: pre-wrap;
+      word-break: break-all;
+    }
+    .stack .at { color: #888; }
+    .stack .file { color: #4ecdc4; }
+    .hint {
+      margin-top: 1.5rem;
+      padding: 1rem;
+      background: #1e2a45;
+      border-radius: 6px;
+      border-left: 3px solid #3498db;
+      font-size: 0.8rem;
+      color: #aaa;
+      line-height: 1.5;
+    }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="header">
+      <span class="badge">SSR Error</span>
+      <span class="label">Pyreon Zero — Dev Mode</span>
+    </div>
+    <div class="message">${escapeHtml(error.message || "Unknown error")}</div>
+    <pre class="stack">${formatStack(escapeHtml(error.stack || ""))}</pre>
+    <div class="hint">
+      This error occurred during server-side rendering. Check the terminal for
+      the full stack trace. This overlay is only shown in development.
+    </div>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function formatStack(stack) {
+	return stack.split("\n").map((line) => {
+		if (line.includes("at ")) {
+			const fileMatch = line.match(/\(([^)]+)\)/);
+			if (fileMatch) return line.replace(fileMatch[0], `(<span class="file">${fileMatch[1]}</span>)`);
+		}
+		return line;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/vite-plugin.ts
+/**
+* Scan node_modules/@pyreon/ to discover all installed Pyreon packages.
+* Returns package names to exclude from Vite's dep optimizer.
+*/
+function scanPyreonPackages(root) {
+	const pyreonDir = join(root, "node_modules", "@pyreon");
+	if (!existsSync(pyreonDir)) return [];
+	try {
+		return readdirSync(pyreonDir).filter((name) => !name.startsWith(".")).map((name) => `@pyreon/${name}`);
+	} catch {
+		return [];
+	}
+}
+const VIRTUAL_ROUTES_ID = "virtual:zero/routes";
+const RESOLVED_VIRTUAL_ROUTES_ID = `\0${VIRTUAL_ROUTES_ID}`;
+const VIRTUAL_MIDDLEWARE_ID = "virtual:zero/route-middleware";
+const RESOLVED_VIRTUAL_MIDDLEWARE_ID = `\0${VIRTUAL_MIDDLEWARE_ID}`;
+const VIRTUAL_API_ROUTES_ID = "virtual:zero/api-routes";
+const RESOLVED_VIRTUAL_API_ROUTES_ID = `\0${VIRTUAL_API_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;
+			if (id === VIRTUAL_MIDDLEWARE_ID) return RESOLVED_VIRTUAL_MIDDLEWARE_ID;
+			if (id === VIRTUAL_API_ROUTES_ID) return RESOLVED_VIRTUAL_API_ROUTES_ID;
+		},
+		async load(id) {
+			if (id === RESOLVED_VIRTUAL_ROUTES_ID) try {
+				return generateRouteModule(await scanRouteFiles(routesDir), routesDir, { staticImports: config.mode === "ssg" });
+			} catch (_err) {
+				return `export const routes = []`;
+			}
+			if (id === RESOLVED_VIRTUAL_MIDDLEWARE_ID) try {
+				return generateMiddlewareModule(await scanRouteFiles(routesDir), routesDir);
+			} catch (_err) {
+				return `export const routeMiddleware = []`;
+			}
+			if (id === RESOLVED_VIRTUAL_API_ROUTES_ID) try {
+				return generateApiRouteModule(await scanRouteFiles(routesDir), routesDir);
+			} catch (_err) {
+				return `export const apiRoutes = []`;
+			}
+		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				const accept = req.headers.accept ?? "";
+				if (!accept.includes("text/html") && !accept.includes("*/*")) return next();
+				const pathname = req.url?.split("?")[0] ?? "/";
+				if (pathname.startsWith("/@") || pathname.startsWith("/__")) return next();
+				if (/\.\w+$/.test(pathname)) return next();
+				handle404(server, routesDir, pathname, res).then((handled) => {
+					if (!handled) next();
+				}, (err) => {
+					console.error("[zero] Error in 404 handler:", err);
+					next();
+				});
+			});
+			server.middlewares.use((req, res, next) => {
+				if (!(req.headers.accept ?? "").includes("text/html")) return next();
+				const originalEnd = res.end.bind(res);
+				let errored = false;
+				const handleError = (err) => {
+					if (errored) return;
+					errored = true;
+					const error = err instanceof Error ? err : new Error(String(err));
+					server.ssrFixStacktrace(error);
+					const html = renderErrorOverlay(error);
+					res.statusCode = 500;
+					res.setHeader("Content-Type", "text/html; charset=utf-8");
+					res.setHeader("Content-Length", Buffer.byteLength(html));
+					originalEnd(html);
+				};
+				res.on("error", handleError);
+				try {
+					const result = next();
+					if (result && typeof result.catch === "function") result.catch(handleError);
+				} catch (err) {
+					handleError(err);
+				}
+			});
+			server.watcher.add(`${routesDir}/**/*.{tsx,jsx,ts,js}`);
+			server.watcher.on("all", (event, path) => {
+				if (path.startsWith(routesDir) && (event === "add" || event === "unlink")) {
+					for (const resolvedId of [
+						RESOLVED_VIRTUAL_ROUTES_ID,
+						RESOLVED_VIRTUAL_MIDDLEWARE_ID,
+						RESOLVED_VIRTUAL_API_ROUTES_ID
+					]) {
+						const mod = server.moduleGraph.getModuleById(resolvedId);
+						if (mod) server.moduleGraph.invalidateModule(mod);
+					}
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+		},
+		config(userConfig) {
+			return {
+				resolve: { conditions: ["bun"] },
+				optimizeDeps: { exclude: scanPyreonPackages(userConfig.root ?? process.cwd()) },
+				server: { port: config.port },
+				define: {
+					__ZERO_MODE__: JSON.stringify(config.mode),
+					__ZERO_BASE__: JSON.stringify(config.base)
+				}
+			};
+		}
+	};
+}
+/**
+* Check if the requested path matches any route. If not, render a 404 page.
+* Returns true if the 404 was handled (response sent), false otherwise.
+*
+* In dev mode, the _404.tsx component cannot be SSR-rendered because
+* the compiler emits _tpl() calls that require `document`. Instead,
+* we return a static 404 page. The actual component rendering happens
+* on the client side when the SPA loads.
+*/
+async function handle404(server, _routesDir, pathname, res) {
+	const routes = (await server.ssrLoadModule(VIRTUAL_ROUTES_ID)).routes;
+	if (flattenRoutePatterns(routes).some((pattern) => matchPattern(pattern, pathname))) return false;
+	const html = await render404Page(void 0);
+	res.statusCode = 404;
+	res.setHeader("Content-Type", "text/html; charset=utf-8");
+	res.setHeader("Content-Length", Buffer.byteLength(html));
+	res.end(html);
+	return true;
+}
+/** Extract all URL patterns from a nested route tree. */
+function flattenRoutePatterns(routes, prefix = "") {
+	const patterns = [];
+	for (const route of routes) {
+		if (!route.path) continue;
+		const fullPath = route.path === "/" && prefix ? prefix : `${prefix}${route.path}`;
+		patterns.push(fullPath);
+		if (route.children) patterns.push(...flattenRoutePatterns(route.children, fullPath));
+	}
+	return patterns;
+}
+
+//#endregion
+//#region src/i18n-routing.ts
+/**
+* Detect preferred locale from Accept-Language header.
+*/
+function detectLocaleFromHeader(acceptLanguage, locales, defaultLocale) {
+	if (!acceptLanguage) return defaultLocale;
+	const preferred = acceptLanguage.split(",").map((part) => {
+		const [lang, q] = part.trim().split(";q=");
+		return {
+			lang: lang?.split("-")[0]?.toLowerCase() ?? "",
+			quality: q ? Number.parseFloat(q) : 1
+		};
+	}).sort((a, b) => b.quality - a.quality);
+	for (const { lang } of preferred) if (locales.includes(lang)) return lang;
+	return defaultLocale;
+}
+/**
+* Extract locale from a URL path.
+* Returns { locale, pathWithoutLocale }.
+*/
+function extractLocaleFromPath(path, locales, defaultLocale) {
+	const segments = path.split("/").filter(Boolean);
+	const firstSegment = segments[0]?.toLowerCase();
+	if (firstSegment && locales.includes(firstSegment)) return {
+		locale: firstSegment,
+		pathWithoutLocale: "/" + segments.slice(1).join("/") || "/"
+	};
+	return {
+		locale: defaultLocale,
+		pathWithoutLocale: path
+	};
+}
+/**
+* Build a localized path.
+*/
+function buildLocalePath(path, locale, defaultLocale, strategy) {
+	const clean = path === "/" ? "" : path;
+	if (strategy === "prefix-except-default" && locale === defaultLocale) return path;
+	return `/${locale}${clean}`;
+}
+/**
+* Create a LocaleContext for use in components and loaders.
+*/
+function createLocaleContext(locale, path, config) {
+	const strategy = config.strategy ?? "prefix-except-default";
+	return {
+		locale,
+		locales: config.locales,
+		defaultLocale: config.defaultLocale,
+		localePath(targetPath, targetLocale) {
+			return buildLocalePath(targetPath, targetLocale ?? locale, config.defaultLocale, strategy);
+		},
+		alternates() {
+			const { pathWithoutLocale } = extractLocaleFromPath(path, config.locales, config.defaultLocale);
+			return config.locales.map((loc) => ({
+				locale: loc,
+				url: buildLocalePath(pathWithoutLocale, loc, config.defaultLocale, strategy)
+			}));
+		}
+	};
+}
+/**
+* I18n routing middleware for Zero's server.
+*
+* - Detects locale from URL prefix or Accept-Language header
+* - Redirects root to preferred locale (when detectLocale is true)
+* - Sets locale context for loaders and components
+*
+* @example
+* ```ts
+* // zero.config.ts
+* import { i18nRouting } from "@pyreon/zero"
+*
+* export default defineConfig({
+*   plugins: [
+*     i18nRouting({
+*       locales: ["en", "de", "cs"],
+*       defaultLocale: "en",
+*     }),
+*   ],
+* })
+* ```
+*/
+function i18nRouting(config) {
+	const strategy = config.strategy ?? "prefix-except-default";
+	const detectEnabled = config.detectLocale !== false;
+	const cookieName = config.cookieName ?? "locale";
+	return {
+		name: "pyreon-zero-i18n-routing",
+		configResolved() {},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				const url = req.url ?? "/";
+				if (url.startsWith("/@") || url.startsWith("/__") || url.includes(".")) return next();
+				const { locale } = extractLocaleFromPath(url, config.locales, config.defaultLocale);
+				if (detectEnabled && url === "/") {
+					const preferredFromCookie = parseCookies(req.headers.cookie)[cookieName];
+					const preferredFromHeader = detectLocaleFromHeader(req.headers["accept-language"], config.locales, config.defaultLocale);
+					const preferred = preferredFromCookie && config.locales.includes(preferredFromCookie) ? preferredFromCookie : preferredFromHeader;
+					if (strategy === "prefix" || preferred !== config.defaultLocale) {
+						res.writeHead(302, { Location: `/${preferred}/` });
+						res.end();
+						return;
+					}
+				}
+				req.__locale = locale;
+				req.__localeContext = createLocaleContext(locale, url, config);
+				localeSignal.set(locale);
+				next();
+			});
+		}
+	};
+}
+function parseCookies(header) {
+	if (!header) return {};
+	const result = {};
+	for (const pair of header.split(";")) {
+		const [key, value] = pair.trim().split("=");
+		if (key && value) result[key] = decodeURIComponent(value);
+	}
+	return result;
+}
+/** @internal Context for the current locale. */
+const LocaleCtx = createContext("en");
+/** Current locale signal — set by the server middleware or client-side detection. */
+const localeSignal = signal("en");
+
+//#endregion
+export { 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 };
+//# sourceMappingURL=server.js.map