@pyreon/zero 0.12.2 → 0.12.3

package/lib/types/index.d.ts

@@ -1,56 +1,1961 @@
-export type { CreateAppOptions } from "./app";
-export { createApp } from "./app";
-export type { CreateServerOptions } from "./entry-server";
-export { createServer } from "./entry-server";
-export { zeroPlugin as default } from "./vite-plugin";
-export type { GenerateRouteModuleOptions } from './fs-router';
-export { filePathToUrlPath, generateMiddlewareModule, generateRouteModule, parseFileRoutes, scanRouteFiles, } from './fs-router';
-export { defineConfig, resolveConfig } from "./config";
-export { createISRHandler } from "./isr";
-export { bunAdapter, cloudflareAdapter, netlifyAdapter, nodeAdapter, resolveAdapter, staticAdapter, vercelAdapter, } from "./adapters";
-export type { ImageProps, ImageSource } from "./image";
-export { Image } from "./image";
-export type { LinkProps, LinkRenderProps, UseLinkReturn } from "./link";
-export { createLink, Link, prefetchRoute, useLink } from "./link";
-export type { ScriptProps, ScriptStrategy } from "./script";
-export { Script } from "./script";
-export { render404Page } from "./not-found";
-export type { CacheConfig, CacheRule } from "./cache";
-export { cacheMiddleware, securityHeaders, varyEncoding } from "./cache";
-export { compose, getContext } from "./middleware";
-export type { FallbackMetrics, FontConfig, FontDisplay, GoogleFontInput, GoogleFontStatic, GoogleFontVariable, LocalFont, } from "./font";
-export { fontPlugin, fontVariables } from "./font";
-export type { FormatSource, ImageFormat, ImagePluginConfig, ProcessedImage, } from "./image-plugin";
-export { imagePlugin } from "./image-plugin";
-export type { Theme } from "./theme";
-export { initTheme, resolvedTheme, setTheme, ThemeToggle, theme, themeScript, toggleTheme, } from "./theme";
-export type { ChangeFreq, JsonLdType, RobotsConfig, RobotsRule, SeoPluginConfig, SitemapConfig, SitemapEntry, } from "./seo";
-export { generateRobots, generateSitemap, jsonLd, seoMiddleware, seoPlugin, } from "./seo";
-export type { ApiContext, ApiHandler, ApiRouteEntry, ApiRouteModule, HttpMethod, } from "./api-routes";
-export { createApiMiddleware, generateApiRouteModule } from "./api-routes";
-export type { CorsConfig } from "./cors";
-export { corsMiddleware } from "./cors";
-export type { RateLimitConfig } from "./rate-limit";
-export { rateLimitMiddleware } from "./rate-limit";
-export type { CompressionConfig } from "./compression";
-export { compressionMiddleware, compressResponse, isCompressible, } from "./compression";
-export type { Action, ActionContext, ActionHandler } from "./actions";
-export { createActionMiddleware, defineAction } from "./actions";
-export type { FaviconLocaleConfig, FaviconPluginConfig } from "./favicon";
-export { faviconLinks, faviconPlugin } from "./favicon";
-export type { OgImageLayer, OgImagePluginConfig, OgImageTemplate, } from "./og-image";
-export { ogImagePath, ogImagePlugin } from "./og-image";
-export type { MetaProps } from "./meta";
-export { buildMetaTags, Meta } from "./meta";
-export type { I18nRoutingConfig, LocaleContext } from "./i18n-routing";
-export { buildLocalePath, createLocaleContext, detectLocaleFromHeader, extractLocaleFromPath, i18nRouting, setLocale, useLocale, } from "./i18n-routing";
-export type { CspConfig, CspDirectives } from "./csp";
-export { buildCspHeader, cspMiddleware, useNonce } from "./csp";
-export type { LogEntry, LoggerConfig } from "./logger";
-export { loggerMiddleware } from "./logger";
-export type { EnvValidator } from "./env";
-export { bool, num, oneOf, publicEnv, schema, str, url, validateEnv } from "./env";
-export type { AiPluginConfig, InferJsonLdOptions } from "./ai";
-export { aiPlugin, generateAiPluginManifest, generateLlmsFullTxt, generateLlmsTxt, generateOpenApiSpec, inferJsonLd, } from "./ai";
-export type { Adapter, AdapterBuildOptions, FileRoute, ISRConfig, LoaderContext, RenderMode, RouteMeta, RouteMiddlewareEntry, RouteModule, ZeroConfig, } from "./types";
-//# sourceMappingURL=index.d.ts.map
+import * as _pyreon_core0 from "@pyreon/core";
+import { ComponentFn, VNodeChild } from "@pyreon/core";
+import * as _pyreon_router0 from "@pyreon/router";
+import { NavigationGuard, RouteRecord } from "@pyreon/router";
+import { Middleware, MiddlewareContext } from "@pyreon/server";
+import { Plugin } from "vite";
+import * as _pyreon_reactivity0 from "@pyreon/reactivity";
+
+//#region src/app.d.ts
+interface CreateAppOptions {
+  /** Route definitions (from file-based routing or manual). */
+  routes: RouteRecord[];
+  /** Router mode. Default: "history" for SSR, "hash" for SPA. */
+  routerMode?: 'hash' | 'history';
+  /** Initial URL for SSR. */
+  url?: string;
+  /** Root layout component wrapping all routes. */
+  layout?: ComponentFn;
+  /** Global error component. */
+  errorComponent?: ComponentFn;
+}
+/**
+ * Create a full Zero app — assembles router, head provider, and root layout.
+ *
+ * Used internally by entry-server and entry-client.
+ */
+declare function createApp(options: CreateAppOptions): {
+  App: () => _pyreon_core0.VNode;
+  router: _pyreon_router0.Router;
+};
+//#endregion
+//#region src/api-routes.d.ts
+/** HTTP methods supported by API routes. */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/** Context passed to API route handlers. */
+interface ApiContext {
+  /** The incoming request. */
+  request: Request;
+  /** Parsed URL. */
+  url: URL;
+  /** URL path. */
+  path: string;
+  /** Dynamic route parameters (e.g., { id: "123" }). */
+  params: Record<string, string>;
+  /** Request headers. */
+  headers: Headers;
+}
+/** An API route handler function. */
+type ApiHandler = (ctx: ApiContext) => Response | Promise<Response>;
+/** An API route module — exports named HTTP method handlers. */
+interface ApiRouteModule {
+  GET?: ApiHandler;
+  POST?: ApiHandler;
+  PUT?: ApiHandler;
+  PATCH?: ApiHandler;
+  DELETE?: ApiHandler;
+  HEAD?: ApiHandler;
+  OPTIONS?: ApiHandler;
+}
+/** A registered API route entry. */
+interface ApiRouteEntry {
+  /** URL pattern (e.g., "/api/posts/:id"). */
+  pattern: string;
+  /** The route module with method handlers. */
+  module: ApiRouteModule;
+}
+/**
+ * Create a middleware that dispatches API route requests.
+ * API routes are matched by URL pattern and HTTP method.
+ */
+declare function createApiMiddleware(routes: ApiRouteEntry[]): Middleware;
+/**
+ * Generate a virtual module that exports API route entries.
+ * Each entry maps a URL pattern to a module with HTTP method handlers.
+ */
+declare function generateApiRouteModule(files: string[], routesDir: string): string;
+//#endregion
+//#region src/types.d.ts
+/** What a route file (e.g. `src/routes/index.tsx`) can export. */
+interface RouteModule {
+  /** Default export is the page component. */
+  default?: ComponentFn;
+  /** Layout wrapper — wraps this route and all children. */
+  layout?: ComponentFn;
+  /** Loading component shown while lazy-loading or during Suspense. */
+  loading?: ComponentFn;
+  /** Error component shown when the route errors. */
+  error?: ComponentFn;
+  /** Server-side data loader. */
+  loader?: (ctx: LoaderContext) => Promise<unknown>;
+  /** Per-route middleware. */
+  middleware?: Middleware | Middleware[];
+  /** Navigation guard — can redirect or block navigation. */
+  guard?: NavigationGuard;
+  /** Route metadata. */
+  meta?: RouteMeta;
+  /** Rendering mode override for this route. */
+  renderMode?: RenderMode;
+}
+/** Context passed to route loaders. */
+interface LoaderContext {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  signal: AbortSignal;
+  request: Request;
+}
+/** Per-route metadata. */
+interface RouteMeta {
+  title?: string;
+  description?: string;
+  [key: string]: unknown;
+}
+type RenderMode = 'ssr' | 'ssg' | 'spa' | 'isr';
+interface ISRConfig {
+  /** Revalidation interval in seconds. */
+  revalidate: number;
+}
+interface ZeroConfig {
+  /** Default rendering mode. Default: "ssr" */
+  mode?: RenderMode;
+  /** Vite config overrides. */
+  vite?: Record<string, unknown>;
+  /** SSR options. */
+  ssr?: {
+    /** Streaming mode. Default: "string" */mode?: 'string' | 'stream';
+  };
+  /** SSG options — only used when mode is "ssg". */
+  ssg?: {
+    /** Paths to prerender (or function returning paths). */paths?: string[] | (() => string[] | Promise<string[]>);
+  };
+  /** ISR config — only used when mode is "isr". */
+  isr?: ISRConfig;
+  /** Deploy adapter. Default: "node" */
+  adapter?: 'node' | 'bun' | 'static' | 'vercel' | 'cloudflare' | 'netlify';
+  /** Base URL path. Default: "/" */
+  base?: string;
+  /** App-level middleware applied to all routes. */
+  middleware?: Middleware[];
+  /** Server port for dev/preview. Default: 3000 */
+  port?: number;
+}
+/** Internal representation of a file-system route before conversion to RouteRecord. */
+interface FileRoute {
+  /** File path relative to routes dir (e.g. "users/[id].tsx") */
+  filePath: string;
+  /** Parsed URL path pattern (e.g. "/users/:id") */
+  urlPath: string;
+  /** Directory path for grouping (e.g. "users" or "" for root) */
+  dirPath: string;
+  /** Route segment depth for nesting. */
+  depth: number;
+  /** Whether this is a layout file. */
+  isLayout: boolean;
+  /** Whether this is an error boundary file. */
+  isError: boolean;
+  /** Whether this is a loading fallback file. */
+  isLoading: boolean;
+  /** Whether this is a not-found (404) file. */
+  isNotFound: boolean;
+  /** Whether this is a catch-all route. */
+  isCatchAll: boolean;
+  /** Resolved rendering mode. */
+  renderMode: RenderMode;
+}
+/** Entry mapping a URL pattern to its route-level middleware. */
+interface RouteMiddlewareEntry {
+  pattern: string;
+  middleware: Middleware | Middleware[];
+}
+interface Adapter {
+  name: string;
+  /** Build the production server/output for this adapter. */
+  build(options: AdapterBuildOptions): Promise<void>;
+}
+interface AdapterBuildOptions {
+  /** Path to the built server entry. */
+  serverEntry: string;
+  /** Path to the client build output. */
+  clientOutDir: string;
+  /** Final output directory. */
+  outDir: string;
+  config: ZeroConfig;
+}
+//#endregion
+//#region src/entry-server.d.ts
+interface CreateServerOptions {
+  /** Route definitions. */
+  routes: RouteRecord[];
+  /** Zero config. */
+  config?: ZeroConfig;
+  /** Additional middleware. */
+  middleware?: Middleware[];
+  /** Per-route middleware from virtual:zero/route-middleware. */
+  routeMiddleware?: RouteMiddlewareEntry[];
+  /** API route entries from virtual:zero/api-routes. */
+  apiRoutes?: ApiRouteEntry[];
+  /** HTML template override. */
+  template?: string;
+  /** Client entry path. */
+  clientEntry?: string;
+  /** Component to render when no route matches (from _404.tsx). */
+  notFoundComponent?: ComponentFn;
+}
+/**
+ * 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 })
+ */
+declare function createServer(options: CreateServerOptions): (req: Request) => Promise<Response>;
+//#endregion
+//#region src/vite-plugin.d.ts
+/**
+ * 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()],
+ * }
+ */
+declare function zeroPlugin(userConfig?: ZeroConfig): Plugin;
+//#endregion
+//#region src/fs-router.d.ts
+/**
+ * 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
+ */
+declare function parseFileRoutes(files: string[], defaultMode?: RenderMode): FileRoute[];
+/**
+ * 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)
+ */
+declare function filePathToUrlPath(filePath: string): string;
+/**
+ * Generate a virtual module that exports a nested route tree.
+ * Wires up layouts as parent routes with children, loaders, guards,
+ * error/loading components, middleware, and meta from route module exports.
+ */
+interface GenerateRouteModuleOptions {
+  /**
+   * When true, skip lazy() for route components and use static imports.
+   * Use for SSG/prerender mode where all routes are rendered at build time
+   * and code splitting provides no benefit. Avoids Rolldown warnings about
+   * static + dynamic imports of the same module.
+   */
+  staticImports?: boolean;
+}
+declare function generateRouteModule(files: string[], routesDir: string, options?: GenerateRouteModuleOptions): string;
+/**
+ * Generate a virtual module that maps URL patterns to their middleware exports.
+ * Used by the server entry to dispatch per-route middleware.
+ */
+declare function generateMiddlewareModule(files: string[], routesDir: string): string;
+/**
+ * Scan a directory for route files.
+ * Returns paths relative to the routes directory.
+ */
+declare function scanRouteFiles(routesDir: string): Promise<string[]>;
+//#endregion
+//#region src/config.d.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,
+ * })
+ */
+declare function defineConfig(config: ZeroConfig): ZeroConfig;
+/** Merge user config with defaults. */
+declare function resolveConfig(userConfig?: ZeroConfig): Required<Pick<ZeroConfig, 'mode' | 'base' | 'port' | 'adapter'>> & ZeroConfig;
+//#endregion
+//#region src/isr.d.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.
+ */
+declare function createISRHandler(handler: (req: Request) => Promise<Response>, config: ISRConfig): (req: Request) => Promise<Response>;
+//#endregion
+//#region src/adapters/bun.d.ts
+/**
+ * Bun adapter — generates a standalone Bun.serve() entry.
+ */
+declare function bunAdapter(): Adapter;
+//#endregion
+//#region src/adapters/cloudflare.d.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",
+ * })
+ * ```
+ */
+declare function cloudflareAdapter(): Adapter;
+//#endregion
+//#region src/adapters/netlify.d.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",
+ * })
+ * ```
+ */
+declare function netlifyAdapter(): Adapter;
+//#endregion
+//#region src/adapters/node.d.ts
+/**
+ * Node.js adapter — generates a standalone server entry using node:http.
+ */
+declare function nodeAdapter(): Adapter;
+//#endregion
+//#region src/adapters/static.d.ts
+/**
+ * Static adapter — just copies the client build output.
+ * Used with SSG mode where all pages are pre-rendered at build time.
+ */
+declare function staticAdapter(): Adapter;
+//#endregion
+//#region src/adapters/vercel.d.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",
+ * })
+ * ```
+ */
+declare function vercelAdapter(): Adapter;
+//#endregion
+//#region src/adapters/index.d.ts
+/**
+ * Resolve the adapter from config.
+ * Returns a built-in adapter or throws if unknown.
+ */
+declare function resolveAdapter(config: ZeroConfig): Adapter;
+//#endregion
+//#region src/image-plugin.d.ts
+interface ImagePluginConfig {
+  /** Output directory for processed images. Default: "assets/img" */
+  outDir?: string;
+  /** Default widths for responsive images. Default: [640, 1024, 1920] */
+  widths?: number[];
+  /** Output formats. Default: ["webp"] */
+  formats?: ImageFormat[];
+  /** Quality for lossy formats (1-100). Default: 80 */
+  quality?: number;
+  /** Blur placeholder size in px. Default: 16 */
+  placeholderSize?: number;
+  /** File patterns to process. Default: /\.(jpe?g|png|webp|avif)$/i */
+  include?: RegExp;
+}
+type ImageFormat = 'webp' | 'avif' | 'jpeg' | 'png';
+/** Per-format source set for <picture> <source> elements. */
+interface FormatSource {
+  /** MIME type. e.g. "image/webp", "image/avif" */
+  type: string;
+  /** srcset string for this format. e.g. "/img-640.webp 640w, /img-1920.webp 1920w" */
+  srcset: string;
+}
+interface ProcessedImage {
+  /** Fallback source path (last format, largest width). */
+  src: string;
+  /** Fallback srcset string (last format). */
+  srcset: string;
+  /** Intrinsic width. */
+  width: number;
+  /** Intrinsic height. */
+  height: number;
+  /** Base64 blur placeholder data URI. */
+  placeholder: string;
+  /** Per-format source sets for <picture> element. Ordered by priority (best format first). */
+  formats: FormatSource[];
+  /** Flat list of all sources. */
+  sources: Array<{
+    src: string;
+    width: number;
+    format: string;
+  }>;
+}
+/**
+ * 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 />
+ */
+declare function imagePlugin(config?: ImagePluginConfig): Plugin;
+//#endregion
+//#region src/image.d.ts
+interface ImageProps {
+  /** Image source URL. */
+  src: string;
+  /** Alt text (required for accessibility). */
+  alt: string;
+  /** Intrinsic width of the image. */
+  width: number;
+  /** Intrinsic height of the image. */
+  height: number;
+  /** Responsive sizes attribute. Default: "100vw" */
+  sizes?: string;
+  /** Responsive srcset string or source array. */
+  srcset?: string | ImageSource[];
+  /** Per-format source sets for <picture>. Provided automatically by imagePlugin. */
+  formats?: FormatSource[];
+  /** Loading strategy. "lazy" uses IntersectionObserver, "eager" loads immediately. Default: "lazy" */
+  loading?: 'lazy' | 'eager';
+  /** Mark as priority (LCP image). Disables lazy loading, adds fetchPriority="high". */
+  priority?: boolean;
+  /** Low-quality placeholder image URL or base64 data URI for blur-up effect. */
+  placeholder?: string;
+  /** CSS class name. */
+  class?: string;
+  /** Inline styles. */
+  style?: string;
+  /** CSS object-fit. Default: "cover" */
+  fit?: 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+  /** Decode async. Default: true */
+  decoding?: 'sync' | 'async' | 'auto';
+}
+interface ImageSource {
+  src: string;
+  width: number;
+}
+/**
+ * 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} />
+ */
+declare function Image(props: ImageProps): VNodeChild;
+//#endregion
+//#region src/link.d.ts
+interface LinkProps {
+  /** Target URL path. */
+  href: string;
+  /** Link content. */
+  children?: any;
+  /** CSS class name. */
+  class?: string;
+  /** Class applied when this link matches the current route. */
+  activeClass?: string;
+  /** Class applied when this link exactly matches the current route. */
+  exactActiveClass?: string;
+  /** Prefetch strategy. Default: "hover" */
+  prefetch?: 'hover' | 'viewport' | 'none';
+  /** Open in new tab. */
+  external?: boolean;
+  /** Inline styles. */
+  style?: string;
+  /** ARIA label. */
+  'aria-label'?: string;
+  /** Additional click handler — called before navigation. Call e.preventDefault() to cancel. */
+  onClick?: ((e: MouseEvent) => void) | undefined;
+}
+/** Props passed to a custom component via createLink. */
+interface LinkRenderProps {
+  href: string;
+  ref: _pyreon_core0.Ref<HTMLAnchorElement>;
+  onClick: (e: MouseEvent) => void;
+  onMouseEnter: () => void;
+  onTouchStart: () => void;
+  isActive: () => boolean;
+  isExactActive: () => boolean;
+  /** Reactive class string — pass directly to element for auto-updates on route change. */
+  class: (() => string) | string | undefined;
+  style?: string;
+  target?: string;
+  rel?: string;
+  'aria-label'?: string;
+  children?: any;
+}
+/** Return type of useLink. */
+interface UseLinkReturn {
+  /** Ref object — attach to the root element for viewport-based prefetch. */
+  ref: _pyreon_core0.Ref<HTMLAnchorElement>;
+  /** Click handler — performs client-side navigation. */
+  handleClick: (e: MouseEvent) => void;
+  /** Mouse enter handler — triggers hover prefetch. */
+  handleMouseEnter: () => void;
+  /** Touch start handler — triggers prefetch on mobile. */
+  handleTouchStart: () => void;
+  /** Whether the link partially matches the current route. */
+  isActive: () => boolean;
+  /** Whether the link exactly matches the current route. */
+  isExactActive: () => boolean;
+  /** Resolved class string including active classes. */
+  classes: () => string;
+}
+/**
+ * Prefetch a route's JS chunk by injecting `<link rel="prefetch">` into the
+ * document head. Deduplicates — calling with the same href twice is a no-op.
+ *
+ * @example
+ * prefetchRoute('/about')
+ * prefetchRoute('/dashboard')
+ */
+declare function prefetchRoute(href: string): void;
+/**
+ * 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>
+ *   )
+ * }
+ */
+declare function useLink(props: LinkProps): UseLinkReturn;
+/**
+ * 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>
+ */
+declare function createLink(Component: (props: LinkRenderProps) => any): (props: LinkProps) => any;
+/**
+ * Default navigation link built on an `<a>` tag.
+ *
+ * @example
+ * <Link href="/about" prefetch="viewport">About</Link>
+ * <Link href="/posts" activeClass="nav-active">Posts</Link>
+ */
+declare const Link: (props: LinkProps) => any;
+//#endregion
+//#region src/script.d.ts
+interface ScriptProps {
+  /** Script source URL. */
+  src: string;
+  /** Loading strategy. Default: "afterHydration" */
+  strategy?: ScriptStrategy;
+  /** Inline script content (alternative to src). */
+  children?: string;
+  /** Script id for deduplication. */
+  id?: string;
+  /** Async attribute. Default: true */
+  async?: boolean;
+  /** onLoad callback. */
+  onLoad?: () => void;
+  /** onError callback. */
+  onError?: (error: Error) => void;
+}
+type ScriptStrategy = 'beforeHydration' | 'afterHydration' | 'onIdle' | 'onInteraction' | 'onViewport';
+/**
+ * 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>
+ */
+declare function Script(props: ScriptProps): VNodeChild;
+//#endregion
+//#region src/not-found.d.ts
+/**
+ * Render a 404 component to a full HTML string.
+ * If no component is provided, returns a default 404 page.
+ */
+declare function render404Page(component: ComponentFn | undefined, template?: string): Promise<string>;
+//#endregion
+//#region src/cache.d.ts
+interface CacheConfig {
+  /** Cache duration for immutable hashed assets (seconds). Default: 31536000 (1 year) */
+  immutable?: number;
+  /** Cache duration for static assets like images/fonts (seconds). Default: 86400 (1 day) */
+  static?: number;
+  /** Cache duration for pages (seconds). Default: 0 (no cache) */
+  pages?: number;
+  /** Stale-while-revalidate window for pages (seconds). Default: 60 */
+  staleWhileRevalidate?: number;
+  /** Custom rules by URL pattern. */
+  rules?: CacheRule[];
+}
+interface CacheRule {
+  /** URL pattern to match (glob-style). e.g. "/api/*" */
+  match: string;
+  /** Cache-Control header value. */
+  control: string;
+}
+/**
+ * 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" },
+ *       ],
+ *     }),
+ *   ],
+ * })
+ */
+declare function cacheMiddleware(config?: CacheConfig): Middleware;
+/**
+ * Security headers middleware.
+ * Adds common security headers to all responses.
+ */
+declare function securityHeaders(): Middleware;
+/**
+ * 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.
+ */
+declare function varyEncoding(): Middleware;
+//#endregion
+//#region src/middleware.d.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(),
+ * )
+ */
+declare function compose(...middlewares: Middleware[]): Middleware;
+/**
+ * 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)
+ * }
+ */
+declare function getContext(ctx: MiddlewareContext): Record<string, unknown>;
+//#endregion
+//#region src/font.d.ts
+interface FontConfig {
+  /**
+   * Google Fonts families.
+   *
+   * Accepts both string shorthand and structured objects:
+   * - String: "Inter:wght@400;500;700" or "Inter:wght@100..900"
+   * - Object: { family: "Inter", weights: [400, 500, 700] }
+   * - Variable: { family: "Inter", variable: true, weightRange: [100, 900] }
+   */
+  google?: GoogleFontInput[];
+  /** Local font files. */
+  local?: LocalFont[];
+  /** Default font-display strategy. Default: "swap" */
+  display?: FontDisplay;
+  /** Preload critical fonts. Default: true */
+  preload?: boolean;
+  /** Self-host Google Fonts at build time. Default: true */
+  selfHost?: boolean;
+  /** Fallback font metrics for reducing CLS. */
+  fallbacks?: Record<string, FallbackMetrics>;
+}
+/** Static Google Font config. */
+interface GoogleFontStatic {
+  family: string;
+  weights: number[];
+  italic?: boolean;
+  variable?: false;
+}
+/** Variable Google Font config. */
+interface GoogleFontVariable {
+  family: string;
+  /** Weight range as [min, max] tuple. e.g. [100, 900] */
+  weightRange: [number, number];
+  italic?: boolean;
+  variable: true;
+}
+/** Google font input: structured object or string shorthand. */
+type GoogleFontInput = GoogleFontStatic | GoogleFontVariable | string;
+interface LocalFont {
+  family: string;
+  src: string;
+  /** Single weight (400) or variable range ("100 900"). */
+  weight?: number | `${number} ${number}`;
+  style?: 'normal' | 'italic';
+  display?: FontDisplay;
+}
+type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+/** Metrics for generating size-adjusted fallback fonts to reduce CLS. */
+interface FallbackMetrics {
+  /** The fallback font to adjust. e.g. "Arial", "Georgia" */
+  fallback: string;
+  /** Size adjustment factor. e.g. 1.05 */
+  sizeAdjust?: number;
+  /** Ascent override percentage. e.g. 90 */
+  ascentOverride?: number;
+  /** Descent override percentage. e.g. 22 */
+  descentOverride?: number;
+  /** Line gap override percentage. e.g. 0 */
+  lineGapOverride?: number;
+}
+/**
+ * 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 },
+ *       },
+ *     }),
+ *   ],
+ * }
+ */
+declare function fontPlugin(config?: FontConfig): Plugin;
+/**
+ * Generate CSS variables for font families.
+ */
+declare function fontVariables(families: Record<string, string>): string;
+//#endregion
+//#region src/theme.d.ts
+type Theme = 'light' | 'dark' | 'system';
+/** Reactive theme signal. */
+declare const theme: _pyreon_reactivity0.Signal<Theme>;
+/**
+ * Set the default theme for SSR (when `matchMedia` is unavailable).
+ * Call once at server startup before rendering.
+ */
+declare function setSSRThemeDefault(value: 'light' | 'dark'): void;
+/** Computed resolved theme (what's actually applied). */
+declare function resolvedTheme(): 'light' | 'dark';
+/** Toggle between light and dark. */
+declare function toggleTheme(): void;
+/** Set theme explicitly. */
+declare function setTheme(t: Theme): void;
+/**
+ * Initialize the theme system. Call once in your app entry or layout.
+ * Reads from localStorage, listens for system preference changes.
+ */
+declare function initTheme(): void;
+/**
+ * Theme toggle button component.
+ *
+ * @example
+ * import { ThemeToggle } from "@pyreon/zero/theme"
+ * <ThemeToggle />
+ */
+declare function ThemeToggle(props: {
+  class?: string;
+  style?: string;
+}): VNodeChild;
+/**
+ * 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>
+ */
+declare const themeScript = "(function(){try{var t=localStorage.getItem(\"zero-theme\");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.d.ts
+interface SitemapConfig {
+  /** Base URL of the site (required). e.g. "https://example.com" */
+  origin: string;
+  /** Paths to exclude from the sitemap. */
+  exclude?: string[];
+  /** Default change frequency. Default: "weekly" */
+  changefreq?: ChangeFreq;
+  /** Default priority. Default: 0.7 */
+  priority?: number;
+  /** Additional URLs to include (for dynamic routes). */
+  additionalPaths?: SitemapEntry[];
+}
+interface SitemapEntry {
+  path: string;
+  changefreq?: ChangeFreq;
+  priority?: number;
+  lastmod?: string;
+}
+type ChangeFreq = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+/**
+ * Generate a sitemap.xml string from route file paths.
+ */
+declare function generateSitemap(routeFiles: string[], config: SitemapConfig): string;
+interface RobotsConfig {
+  /** Rules per user-agent. */
+  rules?: RobotsRule[];
+  /** Sitemap URL. */
+  sitemap?: string;
+  /** Host directive. */
+  host?: string;
+}
+interface RobotsRule {
+  userAgent: string;
+  allow?: string[];
+  disallow?: string[];
+  crawlDelay?: number;
+}
+/**
+ * Generate a robots.txt string.
+ */
+declare function generateRobots(config?: RobotsConfig): string;
+type JsonLdType = 'WebSite' | 'WebPage' | 'Article' | 'BlogPosting' | 'Product' | 'Organization' | 'Person' | 'BreadcrumbList' | 'FAQPage' | (string & {});
+/**
+ * Generate a JSON-LD script tag string for structured data.
+ *
+ * @example
+ * useHead({
+ *   script: [jsonLd({
+ *     "@type": "WebSite",
+ *     name: "My Site",
+ *     url: "https://example.com",
+ *   })],
+ * })
+ */
+declare function jsonLd(data: Record<string, unknown>): string;
+interface SeoPluginConfig {
+  /** Sitemap configuration. */
+  sitemap?: SitemapConfig;
+  /** Robots.txt configuration. */
+  robots?: RobotsConfig;
+}
+/**
+ * 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" },
+ *     }),
+ *   ],
+ * }
+ */
+declare function seoPlugin(config?: SeoPluginConfig): Plugin;
+/**
+ * SEO middleware for dev server.
+ * Serves sitemap.xml and robots.txt dynamically during development.
+ */
+declare function seoMiddleware(config?: SeoPluginConfig): Middleware;
+//#endregion
+//#region src/cors.d.ts
+interface CorsConfig {
+  /** Allowed origins. Use `"*"` for any origin. Default: `"*"` */
+  origin?: string | string[] | ((origin: string) => boolean);
+  /** Allowed HTTP methods. Default: `["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]` */
+  methods?: string[];
+  /** Allowed request headers. Default: `["Content-Type", "Authorization"]` */
+  allowedHeaders?: string[];
+  /** Headers exposed to the client. Default: `[]` */
+  exposedHeaders?: string[];
+  /** Allow credentials (cookies, auth headers). Default: `false` */
+  credentials?: boolean;
+  /** Preflight cache duration in seconds. Default: `86400` (24 hours) */
+  maxAge?: number;
+}
+/**
+ * CORS middleware — handles preflight requests and sets appropriate
+ * Access-Control headers on all responses.
+ *
+ * @example
+ * import { corsMiddleware } from "@pyreon/zero/cors"
+ *
+ * corsMiddleware({ origin: "https://example.com", credentials: true })
+ *
+ * // Allow any origin
+ * corsMiddleware({ origin: "*" })
+ *
+ * // Multiple origins
+ * corsMiddleware({ origin: ["https://app.com", "https://admin.com"] })
+ */
+declare function corsMiddleware(config?: CorsConfig): Middleware;
+//#endregion
+//#region src/rate-limit.d.ts
+interface RateLimitConfig {
+  /** Maximum requests per window. Default: `100` */
+  max?: number;
+  /** Time window in seconds. Default: `60` */
+  window?: number;
+  /** Function to extract the client identifier. Default: IP from headers. */
+  keyFn?: (ctx: MiddlewareContext) => string;
+  /** Custom response when rate limited. */
+  onLimit?: (ctx: MiddlewareContext) => Response;
+  /** URL patterns to rate limit (glob-style). Default: all paths. */
+  include?: string[];
+  /** URL patterns to exclude from rate limiting. */
+  exclude?: string[];
+}
+/**
+ * Rate limiting middleware — limits requests per client within a time window.
+ * Uses an in-memory store (suitable for single-instance deployments).
+ *
+ * @example
+ * import { rateLimitMiddleware } from "@pyreon/zero/rate-limit"
+ *
+ * // 100 requests per minute (default)
+ * rateLimitMiddleware()
+ *
+ * // Strict API rate limiting
+ * rateLimitMiddleware({
+ *   max: 20,
+ *   window: 60,
+ *   include: ["/api/*"],
+ * })
+ */
+declare function rateLimitMiddleware(config?: RateLimitConfig): Middleware;
+//#endregion
+//#region src/compression.d.ts
+interface CompressionConfig {
+  /** Minimum response size in bytes to compress. Default: `1024` (1KB) */
+  threshold?: number;
+  /** Encoding preference order. Default: `["gzip", "deflate"]` */
+  encodings?: ('gzip' | 'deflate')[];
+}
+/**
+ * Compression middleware — compresses responses using gzip or deflate
+ * based on the client's Accept-Encoding header.
+ *
+ * Only compresses text-based content types (HTML, JSON, JS, CSS, XML, SVG).
+ * Skips responses below the size threshold and already-encoded responses.
+ *
+ * @example
+ * import { compressionMiddleware } from "@pyreon/zero/compression"
+ *
+ * compressionMiddleware() // gzip with 1KB threshold
+ * compressionMiddleware({ threshold: 512, encodings: ["gzip"] })
+ */
+declare function compressionMiddleware(config?: CompressionConfig): Middleware;
+/**
+ * Compress a Response body if it meets the criteria.
+ * Use this to post-process responses after the handler runs.
+ *
+ * @example
+ * const response = await handler(request)
+ * const compressed = await compressResponse(response, 'gzip', 1024)
+ */
+declare function compressResponse(response: Response, encoding: 'gzip' | 'deflate', threshold: number): Promise<Response>;
+/** Check if a content type is compressible. Exported for testing. */
+declare function isCompressible(contentType: string): boolean;
+//#endregion
+//#region src/actions.d.ts
+/** Context passed to server action handlers. */
+interface ActionContext {
+  /** The original request. */
+  request: Request;
+  /** Parsed form data (for form submissions). */
+  formData: FormData | null;
+  /** Parsed JSON body (for JSON submissions). */
+  json: unknown;
+  /** Request headers. */
+  headers: Headers;
+}
+/** A server action handler function. */
+type ActionHandler<T = unknown> = (ctx: ActionContext) => T | Promise<T>;
+/** Client-side callable action returned by defineAction. */
+interface Action<T = unknown> {
+  /** Call the action with JSON data. */
+  (data?: unknown): Promise<T>;
+  /** The action's unique ID. */
+  actionId: string;
+}
+/**
+ * Define a server action. Returns a callable function that:
+ * - On the **client**: sends a POST request to `/_zero/actions/<id>`
+ * - On the **server** (SSR): executes the handler directly (no fetch)
+ *
+ * @example
+ * // In a route file or module:
+ * export const createPost = defineAction(async (ctx) => {
+ *   const data = ctx.json as { title: string; body: string }
+ *   // ... save to database
+ *   return { success: true, id: 123 }
+ * })
+ *
+ * // In a component:
+ * const result = await createPost({ title: 'Hello', body: '...' })
+ */
+declare function defineAction<T = unknown>(handler: ActionHandler<T>): Action<T>;
+/**
+ * Create a middleware that handles action requests at `/_zero/actions/*`.
+ * Mount this before the SSR handler in the server entry.
+ */
+declare function createActionMiddleware(): (ctx: MiddlewareContext) => Response | undefined | Promise<Response | undefined>;
+//#endregion
+//#region src/favicon.d.ts
+interface FaviconLocaleConfig {
+  /** Locale-specific source icon (SVG or PNG). */
+  source: string;
+  /** Optional dark mode variant for this locale. */
+  darkSource?: string;
+}
+interface FaviconPluginConfig {
+  /** Path to the source icon (SVG or PNG, at least 512x512 for PNG). */
+  source: string;
+  /** Theme color for web manifest. Default: "#ffffff" */
+  themeColor?: string;
+  /** Background color for web manifest. Default: "#ffffff" */
+  backgroundColor?: string;
+  /** App name for web manifest. Uses package.json name if not set. */
+  name?: string;
+  /** Generate web manifest. Default: true */
+  manifest?: boolean;
+  /**
+   * Dark mode favicon (SVG only).
+   * When provided, the SVG favicon uses prefers-color-scheme media query
+   * to switch between light and dark variants.
+   */
+  darkSource?: string;
+  /**
+   * Locale-specific icon overrides. Each key is a locale code,
+   * value is a source icon (and optional dark variant).
+   * Locales not in this map use the base `source`.
+   *
+   * Generated files are placed under `/{locale}/` prefix:
+   *   /de/favicon.svg, /de/favicon-32x32.png, etc.
+   *
+   * @example
+   * ```ts
+   * faviconPlugin({
+   *   source: "./icon.svg",
+   *   locales: {
+   *     de: { source: "./icon-de.svg" },
+   *     cs: { source: "./icon-cs.svg" },
+   *   },
+   * })
+   * ```
+   */
+  locales?: Record<string, FaviconLocaleConfig>;
+}
+/**
+ * Favicon generation Vite plugin.
+ *
+ * Generates all required favicon formats at build time from a single source.
+ * In dev mode, serves the source directly.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { faviconPlugin } from "@pyreon/zero"
+ *
+ * export default {
+ *   plugins: [faviconPlugin({ source: "./src/assets/icon.svg" })],
+ * }
+ * ```
+ */
+declare function faviconPlugin(config: FaviconPluginConfig): Plugin;
+/**
+ * Get favicon link tags for a specific locale.
+ * Returns link objects suitable for `useHead()` or direct HTML injection.
+ *
+ * @example
+ * ```ts
+ * const links = faviconLinks("de", { source: "./icon.svg", locales: { de: { source: "./icon-de.svg" } } })
+ * // → [{ rel: "icon", type: "image/svg+xml", href: "/de/favicon.svg" }, ...]
+ * ```
+ */
+declare function faviconLinks(locale: string | undefined, config: FaviconPluginConfig): Array<{
+  rel: string;
+  type?: string;
+  sizes?: string;
+  href: string;
+}>;
+//#endregion
+//#region src/og-image.d.ts
+interface OgImageLayer {
+  /**
+   * Text content. Can be:
+   * - A string (same for all locales)
+   * - A record mapping locale → text
+   * - A function receiving locale and returning text
+   */
+  text: string | Record<string, string> | ((locale: string) => string);
+  /** X position — number (px) or string with % (e.g. "50%"). Default: "50%" */
+  x?: number | string;
+  /** Y position — number (px) or string with % (e.g. "40%"). Default: "50%" */
+  y?: number | string;
+  /** Font size in px. Default: 64 */
+  fontSize?: number;
+  /** Font family. Default: "sans-serif" */
+  fontFamily?: string;
+  /** Font weight. Default: "bold" */
+  fontWeight?: string;
+  /** Text color. Default: "#ffffff" */
+  color?: string;
+  /** Text anchor (alignment). Default: "middle" */
+  textAnchor?: 'start' | 'middle' | 'end';
+  /** Max width in px before wrapping. Default: 80% of image width. */
+  maxWidth?: number;
+}
+interface OgImageTemplate {
+  /** Template name — used for output file naming. */
+  name: string;
+  /**
+   * Background: path to an image file, or a solid color config.
+   *
+   * @example "./src/assets/og-bg.jpg"
+   * @example { color: "#0066ff", width: 1200, height: 630 }
+   */
+  background: string | {
+    color: string;
+    width?: number;
+    height?: number;
+  };
+  /** Output width. Default: 1200 */
+  width?: number;
+  /** Output height. Default: 630 */
+  height?: number;
+  /** Output format. Default: "png" */
+  format?: 'png' | 'jpeg';
+  /** JPEG quality (1-100). Default: 90 */
+  quality?: number;
+  /** Text layers to overlay on the background. */
+  layers?: OgImageLayer[];
+}
+interface OgImagePluginConfig {
+  /** Templates to generate. */
+  templates: OgImageTemplate[];
+  /** Locales to generate for. When omitted, generates a single image per template. */
+  locales?: string[];
+  /** Output directory prefix. Default: "og" */
+  outDir?: string;
+}
+/**
+ * Compute the OG image path for a template and locale.
+ *
+ * @example
+ * ```ts
+ * ogImagePath("default", "de")      // → "/og/default-de.png"
+ * ogImagePath("default")            // → "/og/default.png"
+ * ogImagePath("hero", "en", "images") // → "/images/hero-en.png"
+ * ```
+ */
+declare function ogImagePath(templateName: string, locale?: string, outDir?: string, format?: 'png' | 'jpeg'): string;
+/**
+ * OG image generation Vite plugin.
+ *
+ * Generates Open Graph images at build time. In dev, generates on-demand.
+ * Requires `sharp` as an optional dependency.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { ogImagePlugin } from "@pyreon/zero/og-image"
+ *
+ * export default {
+ *   plugins: [
+ *     ogImagePlugin({
+ *       locales: ["en", "de"],
+ *       templates: [{
+ *         name: "default",
+ *         background: { color: "#0066ff" },
+ *         layers: [{ text: { en: "Hello", de: "Hallo" }, fontSize: 72 }],
+ *       }],
+ *     }),
+ *   ],
+ * }
+ * ```
+ */
+declare function ogImagePlugin(config: OgImagePluginConfig): Plugin;
+//#endregion
+//#region src/i18n-routing.d.ts
+interface I18nRoutingConfig {
+  /** Supported locales. e.g. ["en", "de", "cs"] */
+  locales: string[];
+  /** Default locale — served without prefix (/ instead of /en/). */
+  defaultLocale: string;
+  /** Redirect root to detected locale. Default: true */
+  detectLocale?: boolean;
+  /** Cookie name to persist locale preference. Default: "locale" */
+  cookieName?: string;
+  /** URL strategy. Default: "prefix-except-default" */
+  strategy?: 'prefix' | 'prefix-except-default';
+}
+interface LocaleContext {
+  /** Current locale code. e.g. "en", "de" */
+  locale: string;
+  /** All supported locales. */
+  locales: string[];
+  /** Default locale. */
+  defaultLocale: string;
+  /** Build a localized path. e.g. localePath("/about", "de") → "/de/about" */
+  localePath: (path: string, locale?: string) => string;
+  /** Get hreflang alternates for the current path. */
+  alternates: () => Array<{
+    locale: string;
+    url: string;
+  }>;
+}
+/**
+ * Detect preferred locale from Accept-Language header.
+ */
+declare function detectLocaleFromHeader(acceptLanguage: string | null | undefined, locales: string[], defaultLocale: string): string;
+/**
+ * Extract locale from a URL path.
+ * Returns { locale, pathWithoutLocale }.
+ */
+declare function extractLocaleFromPath(path: string, locales: string[], defaultLocale: string): {
+  locale: string;
+  pathWithoutLocale: string;
+};
+/**
+ * Build a localized path.
+ */
+declare function buildLocalePath(path: string, locale: string, defaultLocale: string, strategy: 'prefix' | 'prefix-except-default'): string;
+/**
+ * Create a LocaleContext for use in components and loaders.
+ */
+declare function createLocaleContext(locale: string, path: string, config: I18nRoutingConfig): LocaleContext;
+/**
+ * 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",
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare function i18nRouting(config: I18nRoutingConfig): Plugin;
+/**
+ * Read the current locale reactively.
+ *
+ * Returns the locale signal value directly — reactive in both SSR and CSR.
+ * The server middleware sets `localeSignal` per-request, and client-side
+ * `setLocale()` updates it as well.
+ *
+ * @example
+ * ```tsx
+ * const locale = useLocale() // "en", "de", etc.
+ * ```
+ */
+declare function useLocale(): string;
+/**
+ * Set the locale client-side and update the URL.
+ *
+ * @example
+ * ```tsx
+ * <button onClick={() => setLocale('de')}>Deutsch</button>
+ * ```
+ */
+declare function setLocale(locale: string, config: I18nRoutingConfig): void;
+//#endregion
+//#region src/meta.d.ts
+interface MetaProps {
+  /** Page title. Accepts reactive accessor `() => string`. */
+  title?: string | (() => string);
+  /** Page description. Accepts reactive accessor. */
+  description?: string | (() => string);
+  /** Canonical URL. Also sets og:url. */
+  canonical?: string;
+  /** Open Graph image URL. Also sets twitter:image. */
+  image?: string;
+  /** Image alt text for accessibility. */
+  imageAlt?: string;
+  /** Image width in pixels (og:image:width). Helps crawlers layout before loading. */
+  imageWidth?: number;
+  /** Image height in pixels (og:image:height). */
+  imageHeight?: number;
+  /** Open Graph type. Default: "website" */
+  type?: 'website' | 'article' | 'product' | 'profile';
+  /** Site name for og:site_name. */
+  siteName?: string;
+  /** Twitter card type. Default: "summary_large_image" */
+  twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
+  /** Twitter @handle. */
+  twitterSite?: string;
+  /** Twitter creator @handle. */
+  twitterCreator?: string;
+  /** Locale. Default: "en_US" */
+  locale?: string;
+  /** Alternate locales for hreflang. */
+  alternateLocales?: Array<{
+    locale: string;
+    url: string;
+  }>;
+  /** Robots directives. Default: "index, follow" */
+  robots?: string;
+  /** Convenience: set `true` to emit `noindex, nofollow`. Overrides `robots`. */
+  noIndex?: boolean;
+  /** Published time (ISO 8601) for article type. */
+  publishedTime?: string;
+  /** Modified time (ISO 8601) for article type. */
+  modifiedTime?: string;
+  /** Article author. */
+  author?: string;
+  /** Article tags. */
+  tags?: string[];
+  /** JSON-LD structured data object. */
+  jsonLd?: Record<string, unknown>;
+  /** Additional custom meta tags. */
+  extra?: Array<{
+    name?: string;
+    property?: string;
+    content: string;
+  }>;
+  /**
+   * Open Graph video URL. Also sets og:video:type if the URL ends with
+   * a known extension (.mp4, .webm).
+   */
+  video?: string;
+  /** Video width in pixels. */
+  videoWidth?: number;
+  /** Video height in pixels. */
+  videoHeight?: number;
+  /**
+   * Open Graph audio URL.
+   */
+  audio?: string;
+  /**
+   * I18n routing config — when provided, auto-generates hreflang alternate
+   * links for all locales based on the current path.
+   * Also sets og:locale and og:locale:alternate.
+   */
+  i18n?: I18nRoutingConfig;
+  /** Base URL for building absolute hreflang URLs. e.g. "https://example.com" */
+  origin?: string;
+  /**
+   * Favicon plugin config — when provided, injects locale-aware favicon
+   * `<link>` tags into `<head>`. Uses the current locale to select
+   * the correct favicon set.
+   */
+  favicon?: FaviconPluginConfig;
+  /**
+   * OG image template name — auto-resolves to the correct locale-specific
+   * OG image path generated by `ogImagePlugin`.
+   * Sets both `og:image` and `twitter:image` unless `image` is also provided.
+   */
+  ogTemplate?: string;
+  /** Output directory for OG images. Default: "og" */
+  ogImageDir?: string;
+  /** OG image format. Default: "png" */
+  ogImageFormat?: 'png' | 'jpeg';
+  children?: VNodeChild;
+}
+/**
+ * Declarative meta component for SSR-compatible page metadata.
+ *
+ * Supports reactive title/description — when passed as `() => string` accessors,
+ * they are forwarded to `useHead()` as a reactive getter so updates propagate
+ * automatically via signal tracking.
+ *
+ * @example
+ * ```tsx
+ * <Meta title="My Page" description="..." image="/og.jpg" canonical="https://..." />
+ * ```
+ *
+ * @example Reactive title
+ * ```tsx
+ * const count = signal(0)
+ * <Meta title={() => `${count()} items`} />
+ * ```
+ */
+declare function Meta(props: MetaProps): VNodeChild;
+interface MetaTagEntry {
+  name?: string;
+  property?: string;
+  content: string;
+  [key: string]: string | undefined;
+}
+interface LinkTagEntry {
+  rel: string;
+  href?: string;
+  hreflang?: string;
+  type?: string;
+  sizes?: string;
+  [key: string]: string | undefined;
+}
+interface ScriptTagEntry {
+  type: string;
+  children: string;
+}
+interface MetaTags {
+  meta: MetaTagEntry[];
+  link: LinkTagEntry[];
+  script: ScriptTagEntry[];
+}
+declare function buildMetaTags(props: Omit<MetaProps, 'title' | 'description' | 'children'> & {
+  title?: string;
+  description?: string;
+}): MetaTags;
+//#endregion
+//#region src/csp.d.ts
+/**
+ * Read the current CSP nonce in a component.
+ *
+ * SSR: reads from per-request `ctx.locals.cspNonce` via Pyreon's context
+ * system — fully isolated between concurrent requests via AsyncLocalStorage.
+ * Client/dev: falls back to module-level variable set by middleware.
+ *
+ * @example
+ * ```tsx
+ * import { useNonce } from "@pyreon/zero/csp"
+ *
+ * function InlineScript() {
+ *   const nonce = useNonce()
+ *   return <script nonce={nonce}>console.log("safe")</script>
+ * }
+ * ```
+ */
+declare function useNonce(): string;
+interface CspDirectives {
+  defaultSrc?: string[];
+  scriptSrc?: string[];
+  styleSrc?: string[];
+  imgSrc?: string[];
+  fontSrc?: string[];
+  connectSrc?: string[];
+  mediaSrc?: string[];
+  objectSrc?: string[];
+  frameSrc?: string[];
+  childSrc?: string[];
+  workerSrc?: string[];
+  frameAncestors?: string[];
+  formAction?: string[];
+  baseUri?: string[];
+  manifestSrc?: string[];
+  /** Reporting endpoint URL. */
+  reportUri?: string;
+  /** Reporting endpoint name (CSP Level 3). */
+  reportTo?: string;
+  /** Upgrade insecure requests. */
+  upgradeInsecureRequests?: boolean;
+  /** Block all mixed content. */
+  blockAllMixedContent?: boolean;
+}
+interface CspConfig {
+  /** CSP directives. */
+  directives: CspDirectives;
+  /**
+   * Report-only mode — logs violations without blocking.
+   * Uses Content-Security-Policy-Report-Only header instead.
+   * Default: false
+   */
+  reportOnly?: boolean;
+}
+/**
+ * Build a CSP header string from directives.
+ * Exported for testing.
+ */
+declare function buildCspHeader(directives: CspDirectives, nonce?: string): string;
+/**
+ * CSP middleware — sets Content-Security-Policy header.
+ *
+ * When directives contain `"'nonce'"`, a fresh nonce is generated per-request
+ * and attached to `ctx.locals.cspNonce` for use in inline script tags.
+ *
+ * @example
+ * ```ts
+ * // Apply to all routes
+ * export default defineConfig({
+ *   middleware: [
+ *     cspMiddleware({
+ *       directives: {
+ *         defaultSrc: ["'self'"],
+ *         scriptSrc: ["'self'", "'nonce'"],
+ *         styleSrc: ["'self'", "'unsafe-inline'"],
+ *         imgSrc: ["'self'", "data:", "https:"],
+ *       },
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare function cspMiddleware(config: CspConfig): Middleware;
+//#endregion
+//#region src/logger.d.ts
+interface LoggerConfig {
+  /**
+   * Log level — controls which requests are logged.
+   * - "all": log every request
+   * - "none": disable logging
+   * Default: "all"
+   */
+  level?: 'all' | 'none';
+  /**
+   * Custom log formatter. Receives request details and returns
+   * the string to log (or null to skip).
+   */
+  format?: (entry: LogEntry) => string | null;
+  /**
+   * Skip logging for these path prefixes.
+   * Default: ["/__", "/@", "/node_modules"]
+   */
+  skip?: string[];
+  /**
+   * Enable colorized output (ANSI codes).
+   * Default: true in development, false in production.
+   */
+  colors?: boolean;
+}
+interface LogEntry {
+  method: string;
+  path: string;
+  duration: number;
+  timestamp: Date;
+  userAgent?: string | undefined;
+  ip?: string | undefined;
+}
+/**
+ * Request logging middleware.
+ *
+ * Logs incoming requests with method, path, and duration.
+ * Runs in middleware phase — logs timing from middleware start to
+ * microtask completion (approximate request duration).
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * loggerMiddleware()
+ *
+ * // Custom format
+ * loggerMiddleware({
+ *   format: (e) => `${e.method} ${e.path} (${e.duration}ms)`,
+ * })
+ * ```
+ */
+declare function loggerMiddleware(config?: LoggerConfig): Middleware;
+//#endregion
+//#region src/env.d.ts
+/**
+ * Environment variable validation.
+ *
+ * Infers types from default values — no verbose validator imports needed.
+ * Explicit validators (`url()`, `oneOf()`) available for special cases.
+ *
+ * @example
+ * ```ts
+ * import { validateEnv, url, oneOf } from "@pyreon/zero/env"
+ *
+ * const env = validateEnv({
+ *   PORT: 3000,                                // number, default 3000
+ *   DEBUG: false,                              // boolean, default false
+ *   HOST: "localhost",                         // string, default "localhost"
+ *   DATABASE_URL: url(),                       // validated URL, required
+ *   NODE_ENV: oneOf(["development", "production", "test"]),
+ *   API_KEY: String,                           // required string, no default
+ *   MAX_RETRIES: Number,                       // required number, no default
+ * })
+ * ```
+ */
+interface EnvValidatorOptions<T = string> {
+  /** Whether this variable is required. Default: true */
+  required?: boolean;
+  /** Default value when not set. Makes the variable optional. */
+  default?: T;
+  /** Human-readable description for error messages. */
+  description?: string;
+}
+interface EnvValidator<T> {
+  __type: 'env-validator';
+  parse: (raw: string | undefined, key: string) => T;
+  required: boolean;
+  defaultValue?: T | undefined;
+}
+/**
+ * String validator — accepts any non-empty string.
+ */
+declare function str(options?: EnvValidatorOptions<string>): EnvValidator<string>;
+/**
+ * Number validator — parses to a number, rejects NaN.
+ */
+declare function num(options?: EnvValidatorOptions<number>): EnvValidator<number>;
+/**
+ * Boolean validator — accepts "true"/"1" as true, "false"/"0" as false.
+ */
+declare function bool(options?: EnvValidatorOptions<boolean>): EnvValidator<boolean>;
+/**
+ * URL validator — validates that the value is a valid URL.
+ */
+declare function url(options?: EnvValidatorOptions<string>): EnvValidator<string>;
+/**
+ * Enum validator — value must be one of the allowed values.
+ */
+declare function oneOf<T extends string>(values: readonly T[], options?: EnvValidatorOptions<T>): EnvValidator<T>;
+/** Schema entry: plain value, constructor, or explicit validator. */
+type SchemaEntry = string | number | boolean | StringConstructor | NumberConstructor | BooleanConstructor | EnvValidator<any>;
+/** Infer the output type from a schema entry. */
+type InferEntry<T> = T extends EnvValidator<infer V> ? V : T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type InferEnvSchema<T> = { [K in keyof T]: InferEntry<T[K]> };
+/**
+ * Validate environment variables.
+ *
+ * Schema values can be:
+ * - **Default values**: `3000`, `false`, `"localhost"` → type inferred, used as default
+ * - **Constructors**: `String`, `Number`, `Boolean` → required, no default
+ * - **Validators**: `url()`, `oneOf([...])`, `str()`, `num()`, `bool()` → explicit validation
+ * - **Custom**: `schema(raw => z.coerce.number().parse(raw))` — bridge to any schema library
+ *
+ * @example
+ * ```ts
+ * import { validateEnv, url, oneOf } from "@pyreon/zero/env"
+ *
+ * const env = validateEnv({
+ *   PORT: 3000,                                // optional, default 3000
+ *   DATABASE_URL: url(),                       // required, validated URL
+ *   NODE_ENV: oneOf(["dev", "prod", "test"]),  // required, must be one of
+ *   API_KEY: String,                           // required string
+ *   DEBUG: false,                              // optional, default false
+ * })
+ * ```
+ */
+declare function validateEnv<T extends Record<string, SchemaEntry>>(schema: T, source?: Record<string, string | undefined>): InferEnvSchema<T>;
+/**
+ * Extract public environment variables (prefixed with `ZERO_PUBLIC_`).
+ *
+ * @example
+ * ```ts
+ * const pub = publicEnv()
+ * // → { API_URL: "https://...", APP_NAME: "MyApp" }
+ *
+ * const pub = publicEnv({ API_URL: url(), APP_NAME: "Default" })
+ * // → validated against ZERO_PUBLIC_API_URL, ZERO_PUBLIC_APP_NAME
+ * ```
+ */
+declare function publicEnv(): Record<string, string>;
+declare function publicEnv<T extends Record<string, SchemaEntry>>(schema: T): InferEnvSchema<T>;
+/**
+ * Create an env validator from a custom parse function.
+ * Use this to integrate any schema library (Zod, Valibot, ArkType, etc.).
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod"
+ * import { validateEnv, schema } from "@pyreon/zero/env"
+ *
+ * const env = validateEnv({
+ *   PORT: schema(raw => z.coerce.number().parse(raw)),
+ *   DATABASE_URL: schema(raw => z.string().url().parse(raw)),
+ *   HOST: "localhost",  // plain defaults still work alongside
+ * })
+ * ```
+ */
+declare function schema<T>(parse: (raw: string) => T): EnvValidator<T>;
+//#endregion
+//#region src/ai.d.ts
+interface AiPluginConfig {
+  /** App/API name. */
+  name: string;
+  /** App description for AI agents. */
+  description: string;
+  /** Base URL. e.g. "https://example.com" */
+  origin: string;
+  /** Contact email (required by OpenAI plugin spec). */
+  contactEmail?: string;
+  /** Legal info URL. */
+  legalUrl?: string;
+  /** Logo URL for the plugin. */
+  logoUrl?: string;
+  /** Routes directory relative to project root. Default: "src/routes" */
+  routesDir?: string;
+  /** API routes directory relative to project root. Default: "src/api" */
+  apiDir?: string;
+  /**
+   * API route descriptions — map of pattern to description.
+   * Used for llms.txt and ai-plugin.json.
+   *
+   * @example
+   * ```ts
+   * apiDescriptions: {
+   *   "GET /api/posts": "List all blog posts, supports ?page=N&limit=N",
+   *   "GET /api/posts/:id": "Get a single post by ID",
+   *   "POST /api/posts": "Create a new post (requires auth)",
+   * }
+   * ```
+   */
+  apiDescriptions?: Record<string, string>;
+  /**
+   * Page descriptions — map of URL path to description.
+   * Used for llms.txt. Falls back to route meta.title/description.
+   */
+  pageDescriptions?: Record<string, string>;
+  /**
+   * Additional content to append to llms.txt.
+   * Useful for authentication instructions, rate limits, etc.
+   */
+  llmsExtra?: string;
+}
+/**
+ * Generate llms.txt content from route files and config.
+ *
+ * Format follows the llms.txt proposal:
+ * ```
+ * # {name}
+ * > {description}
+ *
+ * ## Pages
+ * - [/about](/about): About page
+ *
+ * ## API
+ * - GET /api/posts: List posts
+ * ```
+ *
+ * @internal Exported for testing.
+ */
+declare function generateLlmsTxt(routeFiles: string[], apiFiles: string[], config: AiPluginConfig): string;
+/**
+ * Generate llms-full.txt — expanded version with more detail.
+ * Includes all route metadata and API descriptions.
+ *
+ * @internal Exported for testing.
+ */
+declare function generateLlmsFullTxt(routeFiles: string[], apiFiles: string[], config: AiPluginConfig): string;
+interface InferJsonLdOptions {
+  /** Page URL. */
+  url: string;
+  /** Page title. */
+  title?: string;
+  /** Page description. */
+  description?: string;
+  /** Page image. */
+  image?: string;
+  /** Site name. */
+  siteName?: string;
+  /** Page type hint. */
+  type?: 'website' | 'article' | 'product' | 'profile';
+  /** Article metadata. */
+  publishedTime?: string;
+  /** Article author. */
+  author?: string;
+  /** Article tags. */
+  tags?: string[];
+  /** Breadcrumb path segments. */
+  breadcrumbs?: Array<{
+    name: string;
+    url: string;
+  }>;
+}
+/**
+ * Auto-infer JSON-LD structured data from page metadata.
+ *
+ * Returns an array of JSON-LD objects (multiple schemas can apply to one page).
+ * For example, an article page gets both `Article` and `BreadcrumbList`.
+ *
+ * @example
+ * ```tsx
+ * const schemas = inferJsonLd({
+ *   url: "https://example.com/blog/my-post",
+ *   title: "My Post",
+ *   description: "A great article",
+ *   type: "article",
+ *   author: "Vit Bokisch",
+ *   publishedTime: "2026-03-31",
+ * })
+ * // → [Article schema, BreadcrumbList schema]
+ * ```
+ */
+declare function inferJsonLd(options: InferJsonLdOptions): Record<string, unknown>[];
+/**
+ * Generate an OpenAI-compatible AI plugin manifest.
+ *
+ * Follows the /.well-known/ai-plugin.json spec.
+ *
+ * @internal Exported for testing.
+ */
+declare function generateAiPluginManifest(config: AiPluginConfig): Record<string, unknown>;
+/**
+ * Generate a minimal OpenAPI 3.0 spec from API route descriptions.
+ *
+ * @internal Exported for testing.
+ */
+declare function generateOpenApiSpec(apiFiles: string[], config: AiPluginConfig): Record<string, unknown>;
+/**
+ * AI integration Vite plugin.
+ *
+ * Generates at build time:
+ * - `/llms.txt` — concise site summary for AI agents
+ * - `/llms-full.txt` — detailed reference for AI agents
+ * - `/.well-known/ai-plugin.json` — OpenAI plugin manifest
+ * - `/.well-known/openapi.yaml` — minimal OpenAPI spec from API routes
+ *
+ * In dev, serves these files via middleware.
+ *
+ * @example
+ * ```ts
+ * import { aiPlugin } from "@pyreon/zero/ai"
+ *
+ * export default {
+ *   plugins: [
+ *     aiPlugin({
+ *       name: "My App",
+ *       origin: "https://example.com",
+ *       description: "A modern web application",
+ *       apiDescriptions: {
+ *         "GET /api/posts": "List blog posts",
+ *         "GET /api/posts/:id": "Get post by ID",
+ *       },
+ *     }),
+ *   ],
+ * }
+ * ```
+ */
+declare function aiPlugin(config: AiPluginConfig): Plugin;
+//#endregion
+export { type Action, type ActionContext, type ActionHandler, type Adapter, type AdapterBuildOptions, type AiPluginConfig, type ApiContext, type ApiHandler, type ApiRouteEntry, type ApiRouteModule, type CacheConfig, type CacheRule, type ChangeFreq, type CompressionConfig, type CorsConfig, type CreateAppOptions, type CreateServerOptions, type CspConfig, type CspDirectives, type EnvValidator, type FallbackMetrics, type FaviconLocaleConfig, type FaviconPluginConfig, type FileRoute, type FontConfig, type FontDisplay, type FormatSource, type GenerateRouteModuleOptions, type GoogleFontInput, type GoogleFontStatic, type GoogleFontVariable, type HttpMethod, type I18nRoutingConfig, type ISRConfig, Image, type ImageFormat, type ImagePluginConfig, type ImageProps, type ImageSource, type InferJsonLdOptions, type JsonLdType, Link, type LinkProps, type LinkRenderProps, type LoaderContext, type LocalFont, type LocaleContext, type LogEntry, type LoggerConfig, Meta, type MetaProps, type OgImageLayer, type OgImagePluginConfig, type OgImageTemplate, type ProcessedImage, type RateLimitConfig, type RenderMode, type RobotsConfig, type RobotsRule, type RouteMeta, type RouteMiddlewareEntry, type RouteModule, Script, type ScriptProps, type ScriptStrategy, type SeoPluginConfig, type SitemapConfig, type SitemapEntry, type Theme, ThemeToggle, type UseLinkReturn, type ZeroConfig, aiPlugin, bool, buildCspHeader, buildLocalePath, buildMetaTags, bunAdapter, cacheMiddleware, cloudflareAdapter, compose, compressResponse, compressionMiddleware, corsMiddleware, createActionMiddleware, createApiMiddleware, createApp, createISRHandler, createLink, createLocaleContext, createServer, cspMiddleware, zeroPlugin as default, defineAction, defineConfig, detectLocaleFromHeader, extractLocaleFromPath, faviconLinks, faviconPlugin, filePathToUrlPath, fontPlugin, fontVariables, generateAiPluginManifest, generateApiRouteModule, generateLlmsFullTxt, generateLlmsTxt, generateMiddlewareModule, generateOpenApiSpec, generateRobots, generateRouteModule, generateSitemap, getContext, i18nRouting, imagePlugin, inferJsonLd, initTheme, isCompressible, jsonLd, loggerMiddleware, netlifyAdapter, nodeAdapter, num, ogImagePath, ogImagePlugin, oneOf, parseFileRoutes, prefetchRoute, publicEnv, rateLimitMiddleware, render404Page, resolveAdapter, resolveConfig, resolvedTheme, scanRouteFiles, schema, securityHeaders, seoMiddleware, seoPlugin, setLocale, setSSRThemeDefault, setTheme, staticAdapter, str, theme, themeScript, toggleTheme, url, useLink, useLocale, useNonce, validateEnv, varyEncoding, vercelAdapter };
+//# sourceMappingURL=index2.d.ts.map