alepha 0.15.1 → 0.15.2

package/dist/react/router/index.d.ts

@@ -0,0 +1,2068 @@
+import * as alepha16 from "alepha";
+import { Alepha, AlephaError, Async, FileLike, Json, KIND, Primitive, Static, StreamLike, TObject, TSchema } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { ClientOnlyProps } from "alepha/react";
+import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
+import { ServerRouteCache } from "alepha/server/cache";
+import { LinkProvider } from "alepha/server/links";
+import * as alepha_logger2 from "alepha/logger";
+import * as react0 from "react";
+import { AnchorHTMLAttributes, CSSProperties, FC, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { BrowserHeadProvider, Head, ServerHeadProvider, SimpleHead } from "alepha/react/head";
+import { ServerStaticProvider } from "alepha/server/static";
+import { Readable } from "node:stream";
+import { Route, RouterProvider } from "alepha/router";
+
+//#region ../../src/react/router/constants/PAGE_PRELOAD_KEY.d.ts
+/**
+ * Symbol key for SSR module preloading path.
+ * Using Symbol.for() allows the Vite plugin to inject this at build time.
+ * @internal
+ */
+declare const PAGE_PRELOAD_KEY: unique symbol;
+//#endregion
+//#region ../../src/react/router/errors/Redirection.d.ts
+/**
+ * Used for Redirection during the page loading.
+ *
+ * Depends on the context, it can be thrown or just returned.
+ *
+ * @example
+ * ```ts
+ * import { Redirection } from "alepha/react";
+ *
+ * const MyPage = $page({
+ *   loader: async () => {
+ *    if (needRedirect) {
+ *      throw new Redirection("/new-path");
+ *    }
+ *   },
+ * });
+ * ```
+ */
+declare class Redirection extends AlephaError {
+  readonly redirect: string;
+  constructor(redirect: string);
+}
+//#endregion
+//#region ../../src/react/router/providers/ReactPageProvider.d.ts
+declare const envSchema$1: alepha16.TObject<{
+  REACT_STRICT_MODE: alepha16.TBoolean;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
+}
+/**
+ * Handle page routes for React applications. (Browser and Server)
+ */
+declare class ReactPageProvider {
+  protected readonly log: alepha_logger2.Logger;
+  protected readonly env: {
+    REACT_STRICT_MODE: boolean;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly pages: PageRoute[];
+  getPages(): PageRoute[];
+  getConcretePages(): ConcretePageRoute[];
+  page(name: string): PageRoute;
+  pathname(name: string, options?: {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+  }): string;
+  url(name: string, options?: {
+    params?: Record<string, string>;
+    host?: string;
+  }): URL;
+  root(state: ReactRouterState): ReactNode;
+  protected convertStringObjectToObject: (schema?: TSchema, value?: any) => any;
+  /**
+   * Create a new RouterState based on a given route and request.
+   * This method resolves the layers for the route, applying any query and params schemas defined in the route.
+   * It also handles errors and redirects.
+   */
+  createLayers(route: PageRoute, state: ReactRouterState, previous?: PreviousLayerData[]): Promise<CreateLayersResult>;
+  protected getErrorHandler(route: PageRoute): ErrorHandler | undefined;
+  protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
+  renderError(error: Error): ReactNode;
+  renderEmptyView(): ReactNode;
+  href(page: {
+    options: {
+      name?: string;
+    };
+  }, params?: Record<string, any>): string;
+  compile(path: string, params?: Record<string, string>): string;
+  protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
+  protected readonly configure: alepha16.HookPrimitive<"configure">;
+  protected map(pages: Array<PagePrimitive>, target: PagePrimitive): PageRouteEntry;
+  add(entry: PageRouteEntry): void;
+  protected createMatch(page: PageRoute): string;
+  protected _next: number;
+  protected nextId(): string;
+}
+declare const isPageRoute: (it: any) => it is PageRoute;
+interface PageRouteEntry extends Omit<PagePrimitiveOptions, "children" | "parent"> {
+  children?: PageRouteEntry[];
+}
+interface ConcretePageRoute extends PageRoute {
+  /**
+   * When exported, static routes can be split into multiple pages with different params.
+   * We replace 'name' by the new name for each static entry, and old 'name' becomes 'staticName'.
+   */
+  staticName?: string;
+  params?: Record<string, string>;
+}
+interface PageRoute extends PageRouteEntry {
+  type: "page";
+  name: string;
+  parent?: PageRoute;
+  match: string;
+}
+interface Layer {
+  config?: {
+    query?: Record<string, any>;
+    params?: Record<string, any>;
+    context?: Record<string, any>;
+  };
+  name: string;
+  props?: Record<string, any>;
+  error?: Error;
+  part?: string;
+  element: ReactNode;
+  index: number;
+  path: string;
+  route?: PageRoute;
+  cache?: boolean;
+}
+type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
+interface AnchorProps {
+  href: string;
+  onClick: (ev?: any) => any;
+}
+interface ReactRouterState {
+  /**
+   * Stack of layers for the current page.
+   */
+  layers: Array<Layer>;
+  /**
+   * URL of the current page.
+   */
+  url: URL;
+  /**
+   * Error handler for the current page.
+   */
+  onError: ErrorHandler;
+  /**
+   * Params extracted from the URL for the current page.
+   */
+  params: Record<string, any>;
+  /**
+   * Query parameters extracted from the URL for the current page.
+   */
+  query: Record<string, string>;
+  /**
+   * Optional meta information associated with the current page.
+   */
+  meta: Record<string, any>;
+  /**
+   * Head configuration for the current page (title, meta tags, etc.).
+   * Populated by HeadProvider during SSR.
+   */
+  head: Head;
+  name?: string;
+}
+interface RouterStackItem {
+  route: PageRoute;
+  config?: Record<string, any>;
+  props?: Record<string, any>;
+  error?: Error;
+  cache?: boolean;
+}
+interface TransitionOptions {
+  previous?: PreviousLayerData[];
+}
+interface CreateLayersResult {
+  redirect?: string;
+  state?: ReactRouterState;
+}
+//#endregion
+//#region ../../src/react/router/services/ReactPageService.d.ts
+/**
+ * $page methods interface.
+ */
+declare abstract class ReactPageService {
+  fetch(pathname: string, options?: PagePrimitiveRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+}
+//#endregion
+//#region ../../src/react/router/primitives/$page.d.ts
+/**
+ * Main primitive for defining a React route in the application.
+ *
+ * The $page primitive is the core building block for creating type-safe, SSR-enabled React routes.
+ * It provides a declarative way to define pages with powerful features:
+ *
+ * **Routing & Navigation**
+ * - URL pattern matching with parameters (e.g., `/users/:id`)
+ * - Nested routing with parent-child relationships
+ * - Type-safe URL parameter and query string validation
+ *
+ * **Data Loading**
+ * - Server-side data fetching with the `loader` function
+ * - Automatic serialization and hydration for SSR
+ * - Access to request context, URL params, and parent data
+ *
+ * **Component Loading**
+ * - Direct component rendering or lazy loading for code splitting
+ * - Client-only rendering when browser APIs are needed
+ * - Automatic fallback handling during hydration
+ *
+ * **Performance Optimization**
+ * - Static generation for pre-rendered pages at build time
+ * - Server-side caching with configurable TTL and providers
+ * - Code splitting through lazy component loading
+ *
+ * **Error Handling**
+ * - Custom error handlers with support for redirects
+ * - Hierarchical error handling (child → parent)
+ * - HTTP status code handling (404, 401, etc.)
+ *
+ * **Page Animations**
+ * - CSS-based enter/exit animations
+ * - Dynamic animations based on page state
+ * - Custom timing and easing functions
+ *
+ * **Lifecycle Management**
+ * - Server response hooks for headers and status codes
+ * - Page leave handlers for cleanup (browser only)
+ * - Permission-based access control
+ *
+ * @example Simple page with data fetching
+ * ```typescript
+ * const userProfile = $page({
+ *   path: "/users/:id",
+ *   schema: {
+ *     params: t.object({ id: t.integer() }),
+ *     query: t.object({ tab: t.optional(t.text()) })
+ *   },
+ *   loader: async ({ params }) => {
+ *     const user = await userApi.getUser(params.id);
+ *     return { user };
+ *   },
+ *   lazy: () => import("./UserProfile.tsx")
+ * });
+ * ```
+ *
+ * @example Nested routing with error handling
+ * ```typescript
+ * const projectSection = $page({
+ *   path: "/projects/:id",
+ *   children: () => [projectBoard, projectSettings],
+ *   loader: async ({ params }) => {
+ *     const project = await projectApi.get(params.id);
+ *     return { project };
+ *   },
+ *   errorHandler: (error) => {
+ *     if (HttpError.is(error, 404)) {
+ *       return <ProjectNotFound />;
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @example Static generation with caching
+ * ```typescript
+ * const blogPost = $page({
+ *   path: "/blog/:slug",
+ *   static: {
+ *     entries: posts.map(p => ({ params: { slug: p.slug } }))
+ *   },
+ *   loader: async ({ params }) => {
+ *     const post = await loadPost(params.slug);
+ *     return { post };
+ *   }
+ * });
+ * ```
+ */
+declare const $page: {
+  <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PagePrimitiveOptions<TConfig, TProps, TPropsParent>): PagePrimitive<TConfig, TProps, TPropsParent>;
+  [KIND]: typeof PagePrimitive;
+};
+interface PagePrimitiveOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+  /**
+   * Identifier name for the page. Must be unique.
+   *
+   * @default Primitive key
+   */
+  name?: string;
+  /**
+   * Add a pathname to the page.
+   *
+   * Pathname can contain parameters, like `/post/:slug`.
+   *
+   * @default ""
+   */
+  path?: string;
+  /**
+   * Add an input schema to define:
+   * - `params`: parameters from the pathname.
+   * - `query`: query parameters from the URL.
+   */
+  schema?: TConfig;
+  /**
+   * Load data before rendering the page.
+   *
+   * This function receives
+   * - the request context (params, query, etc.)
+   * - the parent props (if page has a parent)
+   *
+   * > In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
+   *
+   * Loader can be stopped by throwing an error, which will be handled by the `errorHandler` function.
+   * It's common to throw a `NotFoundError` to display a 404 page.
+   *
+   * RedirectError can be thrown to redirect the user to another page.
+   */
+  loader?: (context: PageLoader<TConfig, TPropsParent>) => Async<TProps>;
+  /**
+   * Default props to pass to the component when rendering the page.
+   *
+   * Resolved props from the `resolve` function will override these default props.
+   */
+  props?: () => Partial<TProps>;
+  /**
+   * The component to render when the page is loaded.
+   *
+   * If `lazy` is defined, this will be ignored.
+   * Prefer using `lazy` to improve the initial loading time.
+   */
+  component?: FC<TProps & TPropsParent>;
+  /**
+   * Lazy load the component when the page is loaded.
+   *
+   * It's recommended to use this for components to improve the initial loading time
+   * and enable code-splitting.
+   */
+  lazy?: () => Promise<{
+    default: FC<TProps & TPropsParent>;
+  }>;
+  /**
+   * Attach child pages to create nested routes.
+   * This will make the page a parent route.
+   */
+  children?: Array<PagePrimitive> | (() => Array<PagePrimitive>);
+  /**
+   * Define a parent page for nested routing.
+   */
+  parent?: PagePrimitive<PageConfigSchema, TPropsParent, any>;
+  /**
+   * Function to determine if the page can be accessed.
+   *
+   * If it returns false, the page will not be accessible and a 403 Forbidden error will be returned.
+   * This function can be used to implement permission-based access control.
+   */
+  can?: () => boolean;
+  /**
+   * Catch any error from the `loader` function or during `rendering`.
+   *
+   * Expected to return one of the following:
+   * - a ReactNode to render an error page
+   * - a Redirection to redirect the user
+   * - undefined to let the error propagate
+   *
+   * If not defined, the error will be thrown and handled by the server or client error handler.
+   * If a leaf $page does not define an error handler, the error can be caught by parent pages.
+   *
+   * @example Catch a 404 from API and render a custom not found component:
+   * ```ts
+   * loader: async ({ params, query }) => {
+   *    api.fetch("/api/resource", { params, query });
+   * },
+   * errorHandler: (error, context) => {
+   *   if (HttpError.is(error, 404)) {
+   *     return <ResourceNotFound />;
+   *   }
+   * }
+   * ```
+   *
+   * @example Catch an 401 error and redirect the user to the login page:
+   * ```ts
+   * loader: async ({ params, query }) => {
+   *   // but the user is not authenticated
+   *   api.fetch("/api/resource", { params, query });
+   * },
+   * errorHandler: (error, context) => {
+   *   if (HttpError.is(error, 401)) {
+   *     // throwing a Redirection is also valid!
+   *     return new Redirection("/login");
+   *   }
+   * }
+   * ```
+   */
+  errorHandler?: ErrorHandler;
+  /**
+   * If true, the page will be considered as a static page, immutable and cacheable.
+   * Replace boolean by an object to define static entries. (e.g. list of params/query)
+   *
+   * Browser-side: it only works with `alepha/vite`, which can pre-render the page at build time.
+   *
+   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
+   */
+  static?: boolean | {
+    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
+  };
+  cache?: ServerRouteCache;
+  /**
+   * If true, force the page to be rendered only on the client-side (browser).
+   * It uses the `<ClientOnly/>` component to render the page.
+   */
+  client?: boolean | ClientOnlyProps;
+  /**
+   * Called before the server response is sent to the client. (server only)
+   */
+  onServerResponse?: (request: ServerRequest) => unknown;
+  /**
+   * Called when user enters the page. (browser only)
+   *
+   * Useful for browser-only side effects like analytics, scroll management,
+   * or focus handling that don't need to return data to the component.
+   *
+   * @example
+   * ```ts
+   * onEnter: () => {
+   *   analytics.trackPageView("/dashboard");
+   *   window.scrollTo(0, 0);
+   * }
+   * ```
+   */
+  onEnter?: () => void;
+  /**
+   * Called when user leaves the page. (browser only)
+   */
+  onLeave?: () => void;
+  /**
+   * @experimental
+   *
+   * Add a css animation when the page is loaded or unloaded.
+   * It uses CSS animations, so you need to define the keyframes in your CSS.
+   *
+   * @example Simple animation name
+   * ```ts
+   * animation: "fadeIn"
+   * ```
+   *
+   * CSS example:
+   * ```css
+   * @keyframes fadeIn {
+   *  from { opacity: 0; }
+   *  to { opacity: 1; }
+   * }
+   * ```
+   *
+   * @example Detailed animation
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300 },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   *
+   * @example Only exit animation
+   * ```ts
+   * animation: {
+   *   exit: "fadeOut"
+   * }
+   * ```
+   *
+   * @example With custom timing function
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   */
+  animation?: PageAnimation;
+  /**
+   * Head configuration for the page (title, meta tags, etc.).
+   *
+   * Can be a static object or a function that receives resolved props.
+   *
+   * @example Static head
+   * ```ts
+   * head: {
+   *   title: "My Page",
+   *   description: "Page description",
+   * }
+   * ```
+   *
+   * @example Dynamic head based on props
+   * ```ts
+   * head: (props) => ({
+   *   title: props.user.name,
+   *   description: `Profile of ${props.user.name}`,
+   * })
+   * ```
+   */
+  head?: Head | ((props: TProps, previous?: Head) => Head);
+  /**
+   * Source path for SSR module preloading.
+   *
+   * This is automatically injected by the viteAlephaPreload plugin.
+   * It maps to the source file path used in Vite's SSR manifest.
+   *
+   * @internal
+   */
+  [PAGE_PRELOAD_KEY]?: string;
+}
+type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
+declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Primitive<PagePrimitiveOptions<TConfig, TProps, TPropsParent>> {
+  protected readonly reactPageService: ReactPageService;
+  protected onInit(): void;
+  get name(): string;
+  /**
+   * For testing or build purposes.
+   *
+   * This will render the page (HTML layout included or not) and return the HTML + context.
+   * Only valid for server-side rendering, it will throw an error if called on the client-side.
+   */
+  render(options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  fetch(options?: PagePrimitiveRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  match(url: string): boolean;
+  pathname(config: any): string;
+}
+interface PageConfigSchema {
+  query?: TSchema;
+  params?: TSchema;
+}
+type TPropsDefault = any;
+type TPropsParentDefault = {};
+interface PagePrimitiveRenderOptions {
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  /**
+   * If true, the HTML layout will be included in the response.
+   * If false, only the page content will be returned.
+   *
+   * @default true
+   */
+  html?: boolean;
+  hydration?: boolean;
+}
+interface PagePrimitiveRenderResult {
+  html: string;
+  state: ReactRouterState;
+  redirect?: string;
+}
+interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
+  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
+}
+type PageLoader<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
+type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
+type PageAnimationObject = CssAnimationName | {
+  enter?: CssAnimation | CssAnimationName;
+  exit?: CssAnimation | CssAnimationName;
+};
+type CssAnimationName = string;
+type CssAnimation = {
+  name: string;
+  duration?: number;
+  timing?: string;
+};
+//#endregion
+//#region ../../src/react/router/services/ReactRouter.d.ts
+interface RouterGoOptions {
+  replace?: boolean;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  meta?: Record<string, any>;
+  /**
+   * Recreate the whole page, ignoring the current state.
+   */
+  force?: boolean;
+}
+/**
+ * Friendly browser router API.
+ *
+ * Can be safely used server-side, but most methods will be no-op.
+ */
+declare class ReactRouter<T extends object> {
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  get state(): ReactRouterState;
+  get pages(): PageRoute[];
+  get concretePages(): ConcretePageRoute[];
+  get browser(): ReactBrowserProvider | undefined;
+  isActive(href: string, options?: {
+    startWith?: boolean;
+  }): boolean;
+  node(name: keyof VirtualRouter<T> | string, config?: {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+  }): any;
+  path(name: keyof VirtualRouter<T> | string, config?: {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+  }): string;
+  /**
+   * Reload the current page.
+   * This is equivalent to calling `go()` with the current pathname and search.
+   */
+  reload(): Promise<void>;
+  getURL(): URL;
+  get location(): Location;
+  get current(): ReactRouterState;
+  get pathname(): string;
+  get query(): Record<string, string>;
+  back(): Promise<void>;
+  forward(): Promise<void>;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  go(path: string, options?: RouterGoOptions): Promise<void>;
+  go(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
+  anchor(path: string, options?: RouterGoOptions): AnchorProps;
+  anchor(path: keyof VirtualRouter<T>, options?: RouterGoOptions): AnchorProps;
+  base(path: string): string;
+  /**
+   * Set query params.
+   *
+   * @param record
+   * @param options
+   */
+  setQueryParams(record: Record<string, any> | ((queryParams: Record<string, any>) => Record<string, any>), options?: {
+    /**
+     * If true, this will add a new entry to the history stack.
+     */
+    push?: boolean;
+  }): void;
+}
+type VirtualRouter<T> = { [K in keyof T as T[K] extends PagePrimitive ? K : never]: T[K] };
+//#endregion
+//#region ../../src/react/router/providers/ReactBrowserRouterProvider.d.ts
+interface BrowserRoute extends Route {
+  page: PageRoute;
+}
+/**
+ * Implementation of AlephaRouter for React in browser environment.
+ */
+declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
+  protected readonly log: alepha_logger2.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  protected readonly browserHeadProvider: BrowserHeadProvider;
+  add(entry: PageRouteEntry): void;
+  protected readonly configure: alepha16.HookPrimitive<"configure">;
+  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
+  root(state: ReactRouterState): ReactNode;
+}
+//#endregion
+//#region ../../src/react/router/providers/ReactBrowserProvider.d.ts
+/**
+ * React browser renderer configuration atom
+ */
+declare const reactBrowserOptions: alepha16.Atom<alepha16.TObject<{
+  scrollRestoration: alepha16.TUnsafe<"top" | "manual">;
+}>, "alepha.react.browser.options">;
+type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [reactBrowserOptions.key]: ReactBrowserRendererOptions;
+  }
+}
+declare class ReactBrowserProvider {
+  protected readonly log: alepha_logger2.Logger;
+  protected readonly client: LinkProvider;
+  protected readonly alepha: Alepha;
+  protected readonly router: ReactBrowserRouterProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly browserHeadProvider: BrowserHeadProvider;
+  protected readonly options: Readonly<{
+    scrollRestoration: "top" | "manual";
+  }>;
+  get rootId(): string;
+  protected getRootElement(): HTMLElement;
+  transitioning?: {
+    to: string;
+    from?: string;
+  };
+  get state(): ReactRouterState;
+  /**
+   * Accessor for Document DOM API.
+   */
+  get document(): Document;
+  /**
+   * Accessor for History DOM API.
+   */
+  get history(): History;
+  /**
+   * Accessor for Location DOM API.
+   */
+  get location(): Location;
+  get base(): string;
+  get url(): string;
+  pushState(path: string, replace?: boolean): void;
+  invalidate(props?: Record<string, any>): Promise<void>;
+  go(url: string, options?: RouterGoOptions): Promise<void>;
+  protected render(options?: RouterRenderOptions): Promise<void>;
+  /**
+   * Get embedded layers from the server.
+   */
+  protected getHydrationState(): ReactHydrationState | undefined;
+  protected readonly onTransitionEnd: alepha16.HookPrimitive<"react:transition:end">;
+  readonly ready: alepha16.HookPrimitive<"ready">;
+}
+type ReactHydrationState = {
+  layers?: Array<PreviousLayerData>;
+} & {
+  [key: string]: any;
+};
+interface RouterRenderOptions {
+  url?: string;
+  previous?: PreviousLayerData[];
+  meta?: Record<string, any>;
+}
+//#endregion
+//#region ../../src/react/router/components/ErrorViewer.d.ts
+interface ErrorViewerProps {
+  error: Error;
+  alepha: Alepha;
+}
+/**
+ * Error viewer component - Terminal/brutalist aesthetic
+ */
+declare const ErrorViewer: ({
+  error,
+  alepha
+}: ErrorViewerProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region ../../src/react/router/components/Link.d.ts
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+  href: string;
+}
+/**
+ * Link component for client-side navigation.
+ *
+ * It's a simple wrapper around an anchor (`<a>`) element using the `useRouter` hook.
+ */
+declare const Link: (props: LinkProps) => react0.DetailedReactHTMLElement<{
+  href: string;
+  onClick: (ev?: any) => any;
+  download?: any;
+  hrefLang?: string | undefined;
+  media?: string | undefined;
+  ping?: string | undefined;
+  target?: react0.HTMLAttributeAnchorTarget | undefined;
+  type?: string | undefined;
+  referrerPolicy?: react0.HTMLAttributeReferrerPolicy | undefined;
+  defaultChecked?: boolean | undefined;
+  defaultValue?: string | number | readonly string[] | undefined;
+  suppressContentEditableWarning?: boolean | undefined;
+  suppressHydrationWarning?: boolean | undefined;
+  accessKey?: string | undefined;
+  autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+  autoFocus?: boolean | undefined;
+  className?: string | undefined;
+  contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+  contextMenu?: string | undefined;
+  dir?: string | undefined;
+  draggable?: (boolean | "true" | "false") | undefined;
+  enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+  hidden?: boolean | undefined;
+  id?: string | undefined;
+  lang?: string | undefined;
+  nonce?: string | undefined;
+  slot?: string | undefined;
+  spellCheck?: (boolean | "true" | "false") | undefined;
+  style?: react0.CSSProperties | undefined;
+  tabIndex?: number | undefined;
+  title?: string | undefined;
+  translate?: "yes" | "no" | undefined;
+  radioGroup?: string | undefined;
+  role?: react0.AriaRole | undefined;
+  about?: string | undefined;
+  content?: string | undefined;
+  datatype?: string | undefined;
+  inlist?: any;
+  prefix?: string | undefined;
+  property?: string | undefined;
+  rel?: string | undefined;
+  resource?: string | undefined;
+  rev?: string | undefined;
+  typeof?: string | undefined;
+  vocab?: string | undefined;
+  autoCorrect?: string | undefined;
+  autoSave?: string | undefined;
+  color?: string | undefined;
+  itemProp?: string | undefined;
+  itemScope?: boolean | undefined;
+  itemType?: string | undefined;
+  itemID?: string | undefined;
+  itemRef?: string | undefined;
+  results?: number | undefined;
+  security?: string | undefined;
+  unselectable?: "on" | "off" | undefined;
+  popover?: "" | "auto" | "manual" | "hint" | undefined;
+  popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+  popoverTarget?: string | undefined;
+  inert?: boolean | undefined;
+  inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+  is?: string | undefined;
+  exportparts?: string | undefined;
+  part?: string | undefined;
+  "aria-activedescendant"?: string | undefined;
+  "aria-atomic"?: (boolean | "true" | "false") | undefined;
+  "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+  "aria-braillelabel"?: string | undefined;
+  "aria-brailleroledescription"?: string | undefined;
+  "aria-busy"?: (boolean | "true" | "false") | undefined;
+  "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-colcount"?: number | undefined;
+  "aria-colindex"?: number | undefined;
+  "aria-colindextext"?: string | undefined;
+  "aria-colspan"?: number | undefined;
+  "aria-controls"?: string | undefined;
+  "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+  "aria-describedby"?: string | undefined;
+  "aria-description"?: string | undefined;
+  "aria-details"?: string | undefined;
+  "aria-disabled"?: (boolean | "true" | "false") | undefined;
+  "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+  "aria-errormessage"?: string | undefined;
+  "aria-expanded"?: (boolean | "true" | "false") | undefined;
+  "aria-flowto"?: string | undefined;
+  "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+  "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+  "aria-hidden"?: (boolean | "true" | "false") | undefined;
+  "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+  "aria-keyshortcuts"?: string | undefined;
+  "aria-label"?: string | undefined;
+  "aria-labelledby"?: string | undefined;
+  "aria-level"?: number | undefined;
+  "aria-live"?: "off" | "assertive" | "polite" | undefined;
+  "aria-modal"?: (boolean | "true" | "false") | undefined;
+  "aria-multiline"?: (boolean | "true" | "false") | undefined;
+  "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+  "aria-orientation"?: "horizontal" | "vertical" | undefined;
+  "aria-owns"?: string | undefined;
+  "aria-placeholder"?: string | undefined;
+  "aria-posinset"?: number | undefined;
+  "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+  "aria-readonly"?: (boolean | "true" | "false") | undefined;
+  "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+  "aria-required"?: (boolean | "true" | "false") | undefined;
+  "aria-roledescription"?: string | undefined;
+  "aria-rowcount"?: number | undefined;
+  "aria-rowindex"?: number | undefined;
+  "aria-rowindextext"?: string | undefined;
+  "aria-rowspan"?: number | undefined;
+  "aria-selected"?: (boolean | "true" | "false") | undefined;
+  "aria-setsize"?: number | undefined;
+  "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+  "aria-valuemax"?: number | undefined;
+  "aria-valuemin"?: number | undefined;
+  "aria-valuenow"?: number | undefined;
+  "aria-valuetext"?: string | undefined;
+  children?: react0.ReactNode | undefined;
+  dangerouslySetInnerHTML?: {
+    __html: string | TrustedHTML;
+  } | undefined;
+  onCopy?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCopyCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCut?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCutCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onPaste?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onPasteCapture?: react0.ClipboardEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionEnd?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionEndCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionStart?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionStartCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionUpdate?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onCompositionUpdateCapture?: react0.CompositionEventHandler<HTMLAnchorElement> | undefined;
+  onFocus?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onFocusCapture?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onBlur?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onBlurCapture?: react0.FocusEventHandler<HTMLAnchorElement> | undefined;
+  onChange?: react0.ChangeEventHandler<HTMLAnchorElement, Element> | undefined;
+  onChangeCapture?: react0.ChangeEventHandler<HTMLAnchorElement, Element> | undefined;
+  onBeforeInput?: react0.InputEventHandler<HTMLAnchorElement> | undefined;
+  onBeforeInputCapture?: react0.InputEventHandler<HTMLAnchorElement> | undefined;
+  onInput?: react0.InputEventHandler<HTMLAnchorElement> | undefined;
+  onInputCapture?: react0.InputEventHandler<HTMLAnchorElement> | undefined;
+  onReset?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onResetCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSubmit?: react0.SubmitEventHandler<HTMLAnchorElement> | undefined;
+  onSubmitCapture?: react0.SubmitEventHandler<HTMLAnchorElement> | undefined;
+  onInvalid?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onInvalidCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoad?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onError?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onErrorCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onKeyDown?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyDownCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyPress?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyPressCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyUp?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onKeyUpCapture?: react0.KeyboardEventHandler<HTMLAnchorElement> | undefined;
+  onAbort?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onAbortCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlay?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayThrough?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onCanPlayThroughCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onDurationChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onDurationChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEmptied?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEmptiedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEncrypted?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEncryptedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEnded?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onEndedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedData?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedDataCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedMetadata?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadedMetadataCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadStart?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onLoadStartCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPause?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPauseCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlay?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlayCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlaying?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onPlayingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onProgress?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onProgressCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onRateChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onRateChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeeked?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeekedCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeeking?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSeekingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onStalled?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onStalledCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSuspend?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSuspendCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTimeUpdate?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTimeUpdateCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onVolumeChange?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onVolumeChangeCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onWaiting?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onWaitingCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onAuxClick?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onAuxClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onContextMenu?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onContextMenuCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDoubleClick?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDoubleClickCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onDrag?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnd?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEndCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnter?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragEnterCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragExit?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragExitCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragLeave?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragLeaveCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragOver?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragOverCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragStart?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDragStartCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDrop?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onDropCapture?: react0.DragEventHandler<HTMLAnchorElement> | undefined;
+  onMouseDown?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseDownCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseEnter?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseLeave?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseMove?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseMoveCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOut?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOutCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOver?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseOverCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseUp?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onMouseUpCapture?: react0.MouseEventHandler<HTMLAnchorElement> | undefined;
+  onSelect?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onSelectCapture?: react0.ReactEventHandler<HTMLAnchorElement> | undefined;
+  onTouchCancel?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchCancelCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchEnd?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchEndCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchMove?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchMoveCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchStart?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onTouchStartCapture?: react0.TouchEventHandler<HTMLAnchorElement> | undefined;
+  onPointerDown?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerDownCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerMove?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerMoveCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerUp?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerUpCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerCancel?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerCancelCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerEnter?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerLeave?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOver?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOverCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOut?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onPointerOutCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onGotPointerCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onGotPointerCaptureCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onLostPointerCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onLostPointerCaptureCapture?: react0.PointerEventHandler<HTMLAnchorElement> | undefined;
+  onScroll?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollCapture?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollEnd?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onScrollEndCapture?: react0.UIEventHandler<HTMLAnchorElement> | undefined;
+  onWheel?: react0.WheelEventHandler<HTMLAnchorElement> | undefined;
+  onWheelCapture?: react0.WheelEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationStart?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationStartCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationEnd?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationEndCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationIteration?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onAnimationIterationCapture?: react0.AnimationEventHandler<HTMLAnchorElement> | undefined;
+  onToggle?: react0.ToggleEventHandler<HTMLAnchorElement> | undefined;
+  onBeforeToggle?: react0.ToggleEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionCancel?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionCancelCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionEnd?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionEndCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionRun?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionRunCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionStart?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+  onTransitionStartCapture?: react0.TransitionEventHandler<HTMLAnchorElement> | undefined;
+}, HTMLElement>;
+//#endregion
+//#region ../../src/react/router/components/NestedView.d.ts
+interface NestedViewProps {
+  children?: ReactNode;
+  errorBoundary?: false | ((error: Error) => ReactNode);
+}
+declare const _default: react0.MemoExoticComponent<(props: NestedViewProps) => react_jsx_runtime0.JSX.Element>;
+//#endregion
+//#region ../../src/react/router/components/NotFound.d.ts
+/**
+ * Default 404 Not Found page component.
+ */
+declare const NotFound: (props: {
+  style?: CSSProperties;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region ../../src/react/router/contexts/RouterLayerContext.d.ts
+interface RouterLayerContextValue {
+  index: number;
+  path: string;
+  onError: ErrorHandler;
+}
+declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
+//#endregion
+//#region ../../src/react/router/hooks/useActive.d.ts
+interface UseActiveOptions {
+  href: string;
+  startWith?: boolean;
+}
+/**
+ * Hook to determine if a given route is active and to provide anchor props for navigation.
+ * This hook refreshes on router state changes.
+ */
+declare const useActive: (args: string | UseActiveOptions) => UseActiveHook;
+interface UseActiveHook {
+  isActive: boolean;
+  anchorProps: AnchorProps;
+  isPending: boolean;
+}
+//#endregion
+//#region ../../src/react/router/hooks/useQueryParams.d.ts
+/**
+ * Hook to manage query parameters in the URL using a defined schema.
+ */
+declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Partial<Static<T>>, (data: Static<T>) => void];
+interface UseQueryParamsHookOptions {
+  format?: "base64" | "querystring";
+  key?: string;
+  push?: boolean;
+}
+//#endregion
+//#region ../../src/react/router/hooks/useRouter.d.ts
+/**
+ * Use this hook to access the React Router instance.
+ *
+ * You can add a type parameter to specify the type of your application.
+ * This will allow you to use the router in a typesafe way.
+ *
+ * @example
+ * class App {
+ *   home = $page();
+ * }
+ *
+ * const router = useRouter<App>();
+ * router.go("home"); // typesafe
+ */
+declare const useRouter: <T extends object = any>() => ReactRouter<T>;
+//#endregion
+//#region ../../src/react/router/hooks/useRouterState.d.ts
+declare const useRouterState: () => ReactRouterState;
+//#endregion
+//#region ../../src/system/providers/FileSystemProvider.d.ts
+/**
+ * Options for creating a file from a URL
+ */
+interface CreateFileFromUrlOptions {
+  /**
+   * The URL to load the file from (file://, http://, or https://)
+   */
+  url: string;
+  /**
+   * The MIME type of the file (optional, will be detected from filename if not provided)
+   */
+  type?: string;
+  /**
+   * The name of the file (optional, will be extracted from URL if not provided)
+   */
+  name?: string;
+}
+/**
+ * Options for creating a file from a path (URL with file:// scheme)
+ */
+interface CreateFileFromPathOptions {
+  /**
+   * The path to the file on the local filesystem
+   */
+  path: string;
+  /**
+   * The MIME type of the file (optional, will be detected from filename if not provided)
+   */
+  type?: string;
+  /**
+   * The name of the file (optional, will be extracted from URL if not provided)
+   */
+  name?: string;
+}
+/**
+ * Options for creating a file from a Buffer
+ */
+interface CreateFileFromBufferOptions {
+  /**
+   * The Buffer containing the file data
+   */
+  buffer: Buffer;
+  /**
+   * The MIME type of the file (optional, will be detected from name if not provided)
+   */
+  type?: string;
+  /**
+   * The name of the file (required for proper content type detection)
+   */
+  name?: string;
+}
+/**
+ * Options for creating a file from a stream
+ */
+interface CreateFileFromStreamOptions {
+  /**
+   * The readable stream containing the file data
+   */
+  stream: StreamLike;
+  /**
+   * The MIME type of the file (optional, will be detected from name if not provided)
+   */
+  type?: string;
+  /**
+   * The name of the file (required for proper content type detection)
+   */
+  name?: string;
+  /**
+   * The size of the file in bytes (optional)
+   */
+  size?: number;
+}
+/**
+ * Options for creating a file from text content
+ */
+interface CreateFileFromTextOptions {
+  /**
+   * The text content to create the file from
+   */
+  text: string;
+  /**
+   * The MIME type of the file (default: text/plain)
+   */
+  type?: string;
+  /**
+   * The name of the file (default: "file.txt")
+   */
+  name?: string;
+}
+interface CreateFileFromResponseOptions {
+  /**
+   * The Response object containing the file data
+   */
+  response: Response;
+  /**
+   * Override the name (optional, uses filename from Content-Disposition header if not provided)
+   */
+  name?: string;
+  /**
+   * Override the MIME type (optional, uses file.type if not provided)
+   */
+  type?: string;
+}
+/**
+ * Options for creating a file from a Web File object
+ */
+interface CreateFileFromWebFileOptions {
+  /**
+   * The Web File object
+   */
+  file: File;
+  /**
+   * Override the MIME type (optional, uses file.type if not provided)
+   */
+  type?: string;
+  /**
+   * Override the name (optional, uses file.name if not provided)
+   */
+  name?: string;
+  /**
+   * Override the size (optional, uses file.size if not provided)
+   */
+  size?: number;
+}
+/**
+ * Options for creating a file from an ArrayBuffer
+ */
+interface CreateFileFromArrayBufferOptions {
+  /**
+   * The ArrayBuffer containing the file data
+   */
+  arrayBuffer: ArrayBuffer;
+  /**
+   * The MIME type of the file (optional, will be detected from name if not provided)
+   */
+  type?: string;
+  /**
+   * The name of the file (required for proper content type detection)
+   */
+  name?: string;
+}
+/**
+ * Union type for all createFile options
+ */
+type CreateFileOptions = CreateFileFromUrlOptions | CreateFileFromPathOptions | CreateFileFromBufferOptions | CreateFileFromStreamOptions | CreateFileFromTextOptions | CreateFileFromWebFileOptions | CreateFileFromResponseOptions | CreateFileFromArrayBufferOptions;
+/**
+ * Options for rm (remove) operation
+ */
+interface RmOptions {
+  /**
+   * If true, removes directories and their contents recursively
+   */
+  recursive?: boolean;
+  /**
+   * If true, no error will be thrown if the path does not exist
+   */
+  force?: boolean;
+}
+/**
+ * Options for cp (copy) operation
+ */
+interface CpOptions {
+  /**
+   * If true, copy directories recursively
+   */
+  recursive?: boolean;
+  /**
+   * If true, overwrite existing destination
+   */
+  force?: boolean;
+}
+/**
+ * Options for mkdir operation
+ */
+interface MkdirOptions {
+  /**
+   * If true, creates parent directories as needed
+   */
+  recursive?: boolean;
+  /**
+   * File mode (permission and sticky bits)
+   */
+  mode?: number;
+}
+/**
+ * Options for ls (list) operation
+ */
+interface LsOptions {
+  /**
+   * If true, list contents of directories recursively
+   */
+  recursive?: boolean;
+  /**
+   * If true, include hidden files (starting with .)
+   */
+  hidden?: boolean;
+}
+/**
+ * FileSystem interface providing utilities for working with files.
+ */
+declare abstract class FileSystemProvider {
+  /**
+   * Joins multiple path segments into a single path.
+   *
+   * @param paths - The path segments to join
+   * @returns The joined path
+   */
+  abstract join(...paths: string[]): string;
+  /**
+   * Creates a FileLike object from various sources.
+   *
+   * @param options - Options for creating the file
+   * @returns A FileLike object
+   */
+  abstract createFile(options: CreateFileOptions): FileLike;
+  /**
+   * Removes a file or directory.
+   *
+   * @param path - The path to remove
+   * @param options - Remove options
+   */
+  abstract rm(path: string, options?: RmOptions): Promise<void>;
+  /**
+   * Copies a file or directory.
+   *
+   * @param src - Source path
+   * @param dest - Destination path
+   * @param options - Copy options
+   */
+  abstract cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+  /**
+   * Moves/renames a file or directory.
+   *
+   * @param src - Source path
+   * @param dest - Destination path
+   */
+  abstract mv(src: string, dest: string): Promise<void>;
+  /**
+   * Creates a directory.
+   *
+   * @param path - The directory path to create
+   * @param options - Mkdir options
+   */
+  abstract mkdir(path: string, options?: MkdirOptions): Promise<void>;
+  /**
+   * Lists files in a directory.
+   *
+   * @param path - The directory path to list
+   * @param options - List options
+   * @returns Array of filenames
+   */
+  abstract ls(path: string, options?: LsOptions): Promise<string[]>;
+  /**
+   * Checks if a file or directory exists.
+   *
+   * @param path - The path to check
+   * @returns True if the path exists, false otherwise
+   */
+  abstract exists(path: string): Promise<boolean>;
+  /**
+   * Reads the content of a file.
+   *
+   * @param path - The file path to read
+   * @returns The file content as a Buffer
+   */
+  abstract readFile(path: string): Promise<Buffer>;
+  /**
+   * Writes data to a file.
+   *
+   * @param path - The file path to write to
+   * @param data - The data to write (Buffer or string)
+   */
+  abstract writeFile(path: string, data: Uint8Array | Buffer | string | FileLike): Promise<void>;
+  /**
+   * Reads the content of a file as a string.
+   *
+   * @param path - The file path to read
+   * @returns The file content as a string
+   */
+  abstract readTextFile(path: string): Promise<string>;
+  /**
+   * Reads the content of a file as JSON.
+   *
+   * @param path - The file path to read
+   * @returns The parsed JSON content
+   */
+  abstract readJsonFile<T = unknown>(path: string): Promise<T>;
+}
+//#endregion
+//#region ../../src/react/router/providers/ReactServerTemplateProvider.d.ts
+/**
+ * Handles HTML template parsing, preprocessing, and streaming for SSR.
+ *
+ * Responsibilities:
+ * - Parse template once at startup into logical slots
+ * - Pre-encode static parts as Uint8Array for zero-copy streaming
+ * - Render dynamic parts (attributes, head content) efficiently
+ * - Build hydration data for client-side rehydration
+ *
+ * This provider is injected into ReactServerProvider to handle all
+ * template-related operations, keeping ReactServerProvider focused
+ * on request handling and React rendering coordination.
+ */
+declare class ReactServerTemplateProvider {
+  protected readonly log: alepha_logger2.Logger;
+  protected readonly alepha: Alepha;
+  /**
+   * Shared TextEncoder instance - reused across all requests.
+   */
+  protected readonly encoder: TextEncoder;
+  /**
+   * Pre-encoded common strings for streaming.
+   */
+  protected readonly ENCODED: {
+    readonly HYDRATION_PREFIX: Uint8Array<ArrayBuffer>;
+    readonly HYDRATION_SUFFIX: Uint8Array<ArrayBuffer>;
+    readonly EMPTY: Uint8Array<ArrayBuffer>;
+  };
+  /**
+   * Cached template slots - parsed once, reused for all requests.
+   */
+  protected slots: TemplateSlots | null;
+  /**
+   * Root element ID for React mounting.
+   */
+  get rootId(): string;
+  /**
+   * Regex pattern for matching the root div and extracting its content.
+   */
+  get rootDivRegex(): RegExp;
+  /**
+   * Extract the content inside the root div from HTML.
+   *
+   * @param html - Full HTML string
+   * @returns The content inside the root div, or undefined if not found
+   */
+  extractRootContent(html: string): string | undefined;
+  /**
+   * Check if template has been parsed and slots are available.
+   */
+  isReady(): boolean;
+  /**
+   * Get the parsed template slots.
+   * Throws if template hasn't been parsed yet.
+   */
+  getSlots(): TemplateSlots;
+  /**
+   * Parse an HTML template into logical slots for efficient streaming.
+   *
+   * This should be called once during server startup/configuration.
+   * The parsed slots are cached and reused for all requests.
+   */
+  parseTemplate(template: string): TemplateSlots;
+  /**
+   * Parse HTML attributes string into a record.
+   *
+   * Handles: key="value", key='value', key=value, and boolean key
+   */
+  protected parseAttributes(attrStr: string): Record<string, string>;
+  /**
+   * Render attributes record to HTML string.
+   *
+   * @param attrs - Attributes to render
+   * @returns HTML attribute string like ` lang="en" class="dark"`
+   */
+  renderAttributes(attrs: Record<string, string>): string;
+  /**
+   * Render merged HTML attributes (original + dynamic).
+   */
+  renderMergedHtmlAttrs(dynamicAttrs?: Record<string, string>): string;
+  /**
+   * Render merged body attributes (original + dynamic).
+   */
+  renderMergedBodyAttrs(dynamicAttrs?: Record<string, string>): string;
+  /**
+   * Render head content (title, meta, link, script tags).
+   *
+   * @param head - Head data to render
+   * @param includeOriginal - Whether to include original head content
+   * @returns HTML string with head content
+   */
+  renderHeadContent(head?: SimpleHead, includeOriginal?: boolean): string;
+  /**
+   * Render a meta tag.
+   */
+  protected renderMetaTag(meta: {
+    name?: string;
+    property?: string;
+    content: string;
+  }): string;
+  /**
+   * Render a link tag.
+   */
+  protected renderLinkTag(link: {
+    rel: string;
+    href: string;
+    type?: string;
+    as?: string;
+    crossorigin?: string;
+  }): string;
+  /**
+   * Render a script tag.
+   */
+  protected renderScriptTag(script: string | (Record<string, string | boolean | undefined> & {
+    content?: string;
+  })): string;
+  /**
+   * Escape HTML special characters.
+   */
+  escapeHtml(str: string): string;
+  /**
+   * Safely serialize data to JSON for embedding in HTML.
+   * Escapes characters that could break out of script tags.
+   */
+  safeJsonSerialize(data: unknown): string;
+  /**
+   * Build hydration data from router state.
+   *
+   * This creates the data structure that will be serialized to window.__ssr
+   * for client-side rehydration.
+   */
+  buildHydrationData(state: ReactRouterState): HydrationData;
+  /**
+   * Stream the body content: body tag, root div, React content, hydration, and closing tags.
+   *
+   * If an error occurs during React streaming, it injects error HTML instead of aborting,
+   * ensuring users see an error message rather than a white screen.
+   */
+  protected streamBodyContent(controller: ReadableStreamDefaultController<Uint8Array>, reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, hydration: boolean): Promise<void>;
+  /**
+   * Create a ReadableStream that streams the HTML template with React content.
+   *
+   * This is the main entry point for SSR streaming. It:
+   * 1. Sends <head> immediately (browser starts downloading assets)
+   * 2. Streams React content as it renders
+   * 3. Appends hydration script and closing tags
+   *
+   * @param reactStream - ReadableStream from renderToReadableStream
+   * @param state - Router state with head data
+   * @param options - Streaming options
+   */
+  createHtmlStream(reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, options?: {
+    hydration?: boolean;
+    onError?: (error: unknown) => void;
+  }): ReadableStream<Uint8Array>;
+  /**
+   * Early head content for preloading.
+   *
+   * Contains entry assets (JS + CSS) that are always required and can be
+   * sent before page loaders run.
+   */
+  protected earlyHeadContent: string;
+  /**
+   * Set the early head content (entry script + CSS).
+   *
+   * Also strips these assets from the original head content to avoid duplicates,
+   * since we're moving them to the early phase.
+   *
+   * Automatically prepends critical meta tags (charset, viewport) if not present
+   * in $head configuration, ensuring they're sent as early as possible.
+   *
+   * @param content - HTML string with entry assets
+   * @param globalHead - Global head configuration from $head primitives
+   * @param entryAssets - Entry asset paths to strip from original head
+   */
+  setEarlyHeadContent(content: string, globalHead?: SimpleHead, entryAssets?: {
+    js?: string;
+    css: string[];
+  }): void;
+  /**
+   * Escape special regex characters in a string.
+   */
+  protected escapeRegExp(str: string): string;
+  /**
+   * Create an optimized HTML stream with early head streaming.
+   *
+   * This version sends critical assets (entry.js, CSS) BEFORE page loaders run,
+   * allowing the browser to start downloading them immediately.
+   *
+   * Flow:
+   * 1. Send DOCTYPE, <html>, <head> open, entry preloads (IMMEDIATE)
+   * 2. Run async work (createLayers, etc.)
+   * 3. Send rest of head, body, React content, hydration
+   *
+   * @param globalHead - Global head with htmlAttributes (from $head primitives)
+   * @param asyncWork - Async function to run between early head and rest of stream
+   * @param options - Streaming options
+   */
+  createEarlyHtmlStream(globalHead: SimpleHead, asyncWork: () => Promise<{
+    state: ReactRouterState;
+    reactStream: ReadableStream<Uint8Array>;
+  } | {
+    redirect: string;
+  } | null>, options?: {
+    hydration?: boolean;
+    onError?: (error: unknown) => void;
+  }): ReadableStream<Uint8Array>;
+  /**
+   * Inject error HTML into the stream when an error occurs during streaming.
+   *
+   * Uses the router state's onError handler to render the error component,
+   * falling back to ErrorViewer if no custom handler is defined.
+   * Renders using renderToString to produce static HTML.
+   *
+   * Since we may have already sent partial HTML (DOCTYPE, <html>, <head>),
+   * we need to complete the document with an error message instead of aborting.
+   *
+   * Handles different states:
+   * - headClosed=false, bodyStarted=false: Need to add head content, close head, open body, add error, close all
+   * - headClosed=true, bodyStarted=false: Need to open body, add error, close all
+   * - headClosed=true, bodyStarted=true: Already inside root div, add error, close all
+   */
+  protected injectErrorHtml(controller: ReadableStreamDefaultController<Uint8Array>, encoder: TextEncoder, slots: TemplateSlots, error: unknown, routerState: ReactRouterState | undefined, streamState: {
+    headClosed: boolean;
+    bodyStarted: boolean;
+  }): void;
+  /**
+   * Render an error to HTML string using the router's error handler.
+   *
+   * Falls back to ErrorViewer if:
+   * - No router state is available
+   * - The error handler returns null/undefined
+   * - The error handler itself throws
+   */
+  protected renderErrorToString(error: Error, routerState: ReactRouterState | undefined): string;
+}
+/**
+ * Template slots - the template split into logical parts for efficient streaming.
+ *
+ * Static parts are pre-encoded as Uint8Array for zero-copy streaming.
+ * Dynamic parts (attributes, head content) are kept as strings/objects for merging.
+ */
+interface TemplateSlots {
+  doctype: Uint8Array;
+  htmlOpen: Uint8Array;
+  htmlClose: Uint8Array;
+  headOpen: Uint8Array;
+  headClose: Uint8Array;
+  bodyOpen: Uint8Array;
+  bodyClose: Uint8Array;
+  rootOpen: Uint8Array;
+  rootClose: Uint8Array;
+  scriptClose: Uint8Array;
+  htmlOriginalAttrs: Record<string, string>;
+  bodyOriginalAttrs: Record<string, string>;
+  headOriginalContent: string;
+  beforeRoot: string;
+  afterRoot: string;
+}
+/**
+ * Hydration state that gets serialized to window.__ssr
+ */
+interface HydrationData {
+  layers: Array<{
+    data?: unknown;
+    error?: {
+      name: string;
+      message: string;
+      stack?: string;
+    };
+  }>;
+  [key: string]: unknown;
+}
+//#endregion
+//#region ../../src/react/router/atoms/ssrManifestAtom.d.ts
+/**
+ * Schema for the SSR manifest atom.
+ */
+declare const ssrManifestAtomSchema: alepha16.TObject<{
+  /**
+   * Base path for assets (from Vite's base config).
+   * Used to prefix asset URLs when serving from a subpath.
+   * @example "/devtools" or "/"
+   */
+  base: alepha16.TOptional<alepha16.TString>;
+  /**
+   * Preload manifest mapping short keys to source paths.
+   * Generated by viteAlephaSsrPreload plugin at build time.
+   */
+  preload: alepha16.TOptional<alepha16.TRecord<"^.*$", alepha16.TString>>;
+  /**
+   * Client manifest mapping source files to their output information.
+   * Only includes fields actually used for preloading.
+   */
+  client: alepha16.TOptional<alepha16.TRecord<"^.*$", alepha16.TObject<{
+    file: alepha16.TString;
+    isEntry: alepha16.TOptional<alepha16.TBoolean>;
+    imports: alepha16.TOptional<alepha16.TArray<alepha16.TString>>;
+    css: alepha16.TOptional<alepha16.TArray<alepha16.TString>>;
+  }>>>;
+}>;
+/**
+ * Type for the SSR manifest schema.
+ */
+type SsrManifestAtomSchema = typeof ssrManifestAtomSchema;
+//#endregion
+//#region ../../src/react/router/providers/SSRManifestProvider.d.ts
+/**
+ * Provider for SSR manifest data used for module preloading.
+ *
+ * The manifest is populated at build time by embedding data into the
+ * generated index.js via the ssrManifestAtom. This eliminates filesystem
+ * reads at runtime, making it optimal for serverless deployments.
+ *
+ * Manifest files are generated during `vite build`:
+ * - manifest.json (client manifest)
+ * - preload-manifest.json (from viteAlephaSsrPreload plugin)
+ */
+declare class SSRManifestProvider {
+  protected readonly alepha: Alepha;
+  /**
+   * Get the manifest from the store at runtime.
+   * This ensures the manifest is available even when set after module load.
+   */
+  protected get manifest(): Static<SsrManifestAtomSchema>;
+  /**
+   * Get the base path for assets (from Vite's base config).
+   * Returns empty string if base is "/" (default), otherwise returns the base path.
+   */
+  protected get base(): string;
+  /**
+   * Get the preload manifest.
+   */
+  protected get preloadManifest(): PreloadManifest | undefined;
+  /**
+   * Get the client manifest.
+   */
+  protected get clientManifest(): ClientManifest | undefined;
+  /**
+   * Resolve a preload key to its source path.
+   *
+   * The key is a short hash injected by viteAlephaSsrPreload plugin,
+   * which maps to the full source path in the preload manifest.
+   *
+   * @param key - Short hash key (e.g., "a1b2c3d4")
+   * @returns Source path (e.g., "src/pages/UserDetail.tsx") or undefined
+   */
+  resolvePreloadKey(key: string): string | undefined;
+  /**
+   * Get all chunks required for a source file, including transitive dependencies.
+   *
+   * Uses the client manifest to recursively resolve all imported chunks.
+   *
+   * @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
+   * @returns Array of chunk URLs to preload, or empty array if not found
+   */
+  getChunks(sourcePath: string): string[];
+  /**
+   * Find manifest entry for a source path, trying different extensions.
+   */
+  protected findManifestEntry(sourcePath: string): {
+    file: string;
+    isEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+  } | undefined;
+  /**
+   * Recursively collect all chunk URLs for a manifest entry.
+   */
+  protected collectChunksRecursive(key: string, chunks: Set<string>, visited: Set<string>): void;
+  /**
+   * Collect modulepreload links for a route and its parent chain.
+   */
+  collectPreloadLinks(route: PageRoute): Array<{
+    rel: string;
+    href: string;
+    as?: string;
+    crossorigin?: string;
+  }>;
+  /**
+   * Get all chunks for multiple source files.
+   *
+   * @param sourcePaths - Array of source file paths
+   * @returns Deduplicated array of chunk URLs
+   */
+  getChunksForMultiple(sourcePaths: string[]): string[];
+  /**
+   * Check if manifest is loaded and available.
+   */
+  isAvailable(): boolean;
+  /**
+   * Cached entry assets - computed once at first access.
+   */
+  protected cachedEntryAssets: EntryAssets | null;
+  /**
+   * Get the entry point assets (main entry.js and associated CSS files).
+   *
+   * These assets are always required for all pages and can be preloaded
+   * before page-specific loaders run.
+   *
+   * @returns Entry assets with js and css paths, or null if manifest unavailable
+   */
+  getEntryAssets(): EntryAssets | null;
+  /**
+   * Build preload link tags for entry assets.
+   *
+   * @returns Array of link objects ready to be rendered
+   */
+  getEntryPreloadLinks(): Array<{
+    rel: string;
+    href: string;
+    as?: string;
+    crossorigin?: string;
+  }>;
+}
+/**
+ * Entry assets structure containing the main entry JS and associated CSS files.
+ */
+interface EntryAssets {
+  /** Main entry JavaScript file (e.g., "/assets/entry.abc123.js") */
+  js?: string;
+  /** Associated CSS files (e.g., ["/assets/style.abc123.css"]) */
+  css: string[];
+}
+/**
+ * Client manifest structure from Vite.
+ * Only includes fields actually used for preloading.
+ */
+interface ClientManifest {
+  [key: string]: {
+    file: string;
+    isEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+  };
+}
+/**
+ * Preload manifest mapping short keys to source paths.
+ * Generated by viteAlephaSsrPreload plugin at build time.
+ */
+type PreloadManifest = Record<string, string>;
+//#endregion
+//#region ../../src/react/router/providers/ReactServerProvider.d.ts
+/**
+ * React server provider responsible for SSR and static file serving.
+ *
+ * Coordinates between:
+ * - ReactPageProvider: Page routing and layer resolution
+ * - ReactServerTemplateProvider: HTML template parsing and streaming
+ * - ServerHeadProvider: Head content management
+ * - SSRManifestProvider: Module preload link collection
+ *
+ * Uses `react-dom/server` under the hood.
+ */
+declare class ReactServerProvider {
+  /**
+   * SSR response headers - pre-allocated to avoid object creation per request.
+   */
+  protected readonly SSR_HEADERS: {
+    readonly "content-type": "text/html";
+    readonly "cache-control": "no-store, no-cache, must-revalidate, proxy-revalidate";
+    readonly pragma: "no-cache";
+    readonly expires: "0";
+  };
+  protected readonly fs: FileSystemProvider;
+  protected readonly log: alepha_logger2.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly env: {
+    REACT_SSR_ENABLED?: boolean | undefined;
+  };
+  protected readonly pageApi: ReactPageProvider;
+  protected readonly templateProvider: ReactServerTemplateProvider;
+  protected readonly serverHeadProvider: ServerHeadProvider;
+  protected readonly serverStaticProvider: ServerStaticProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected readonly ssrManifestProvider: SSRManifestProvider;
+  /**
+   * Cached check for ServerLinksProvider - avoids has() lookup per request.
+   */
+  protected hasServerLinksProvider: boolean;
+  protected readonly options: Readonly<{
+    publicDir: string;
+    staticServer: {
+      disabled: boolean;
+      path: string;
+    };
+  }>;
+  /**
+   * Configure the React server provider.
+   */
+  readonly onConfigure: alepha16.HookPrimitive<"configure">;
+  /**
+   * Get the current HTML template.
+   */
+  get template(): string;
+  /**
+   * Register all pages as server routes.
+   */
+  protected registerPages(templateLoader: TemplateLoader): Promise<void>;
+  /**
+   * Set up early head content with entry assets.
+   *
+   * This content is sent immediately when streaming starts, before page loaders run,
+   * allowing the browser to start downloading entry.js and CSS files early.
+   *
+   * Uses <script type="module"> instead of <link rel="modulepreload"> for JS
+   * because the script needs to execute anyway - this way the browser starts
+   * downloading, parsing, AND will execute as soon as ready.
+   *
+   * Also injects critical meta tags (charset, viewport) if not specified in $head,
+   * and strips these assets from the original template head to avoid duplicates.
+   */
+  protected setupEarlyHeadContent(): void;
+  /**
+   * Get the public directory path where static files are located.
+   */
+  protected getPublicDirectory(): Promise<string>;
+  /**
+   * Configure the static file server to serve files from the given root directory.
+   */
+  protected configureStaticServer(root: string): Promise<void>;
+  /**
+   * Create the request handler for a page route.
+   */
+  protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
+  /**
+   * Core page rendering logic shared between SSR handler and static prerendering.
+   *
+   * Handles:
+   * - Layer resolution (loaders)
+   * - Redirect detection
+   * - Head content filling
+   * - Preload link collection
+   * - React stream rendering
+   *
+   * @param route - The page route to render
+   * @param state - The router state
+   * @returns Render result with redirect or React stream
+   */
+  protected renderPage(route: PageRoute, state: ReactRouterState): Promise<{
+    redirect?: string;
+    reactStream?: ReadableStream<Uint8Array>;
+  }>;
+  /**
+   * For testing purposes, renders a page to HTML string.
+   * Uses the same streaming code path as production, then collects to string.
+   *
+   * @param name - Page name to render
+   * @param options - Render options (params, query, html, hydration)
+   */
+  render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
+  /**
+   * Collect a ReadableStream into a string.
+   */
+  protected streamToString(stream: ReadableStream<Uint8Array>): Promise<string>;
+}
+type TemplateLoader = () => Promise<string | undefined>;
+declare const envSchema: alepha16.TObject<{
+  REACT_SSR_ENABLED: alepha16.TOptional<alepha16.TBoolean>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface State {
+    "alepha.react.server.ssr"?: boolean;
+    "alepha.react.server.template"?: string;
+  }
+}
+/**
+ * React server provider configuration atom
+ */
+declare const reactServerOptions: alepha16.Atom<alepha16.TObject<{
+  publicDir: alepha16.TString;
+  staticServer: alepha16.TObject<{
+    disabled: alepha16.TBoolean;
+    path: alepha16.TString;
+  }>;
+}>, "alepha.react.server.options">;
+type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [reactServerOptions.key]: ReactServerProviderOptions;
+  }
+}
+//#endregion
+//#region ../../src/react/router/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.react.router.state"?: ReactRouterState;
+  }
+  interface Hooks {
+    /**
+     * Fires when the React application is starting to be rendered on the server.
+     */
+    "react:server:render:begin": {
+      request?: ServerRequest;
+      state: ReactRouterState;
+    };
+    /**
+     * Fires when the React application has been rendered on the server.
+     */
+    "react:server:render:end": {
+      request?: ServerRequest;
+      state: ReactRouterState;
+      html: string;
+    };
+    /**
+     * Fires when the React application is being rendered on the browser.
+     *
+     * Note: this one is not really necessary, it's a hack because we need to isolate renderer from server code in order
+     * to avoid including react-dom/client in server bundles.
+     */
+    "react:browser:render": {
+      root: HTMLElement;
+      element: ReactNode;
+      state: ReactRouterState;
+      hydration?: ReactHydrationState;
+    };
+    /**
+     * Fires when a route transition is starting.
+     */
+    "react:transition:begin": {
+      previous: ReactRouterState;
+      state: ReactRouterState;
+      animation?: PageAnimation;
+    };
+    /**
+     * Fires when a route transition has succeeded.
+     */
+    "react:transition:success": {
+      state: ReactRouterState;
+    };
+    /**
+     * Fires when a route transition has failed.
+     */
+    "react:transition:error": {
+      state: ReactRouterState;
+      error: Error;
+    };
+    /**
+     * Fires when a route transition has completed, regardless of success or failure.
+     */
+    "react:transition:end": {
+      state: ReactRouterState;
+    };
+  }
+}
+/**
+ * Provides declarative routing with the `$page` primitive for building type-safe React routes.
+ *
+ * This module enables:
+ * - URL pattern matching with parameters (e.g., `/users/:id`)
+ * - Nested routing with parent-child relationships
+ * - Type-safe URL parameter and query string validation
+ * - Server-side data fetching with the `loader` function
+ * - Lazy loading and code splitting
+ * - Page animations and error handling
+ *
+ * @see {@link $page}
+ * @module alepha.react.router
+ */
+declare const AlephaReactRouter: alepha16.Service<alepha16.Module>;
+//#endregion
+export { $page, AlephaReactRouter, AnchorProps, ClientManifest, ConcretePageRoute, CreateLayersResult, EntryAssets, ErrorHandler, ErrorViewer, HydrationData, Layer, Link, type LinkProps, _default as NestedView, NestedViewProps, NotFound, PAGE_PRELOAD_KEY, PageAnimation, PageConfigSchema, PageLoader, PagePrimitive, PagePrimitiveOptions, PagePrimitiveRenderOptions, PagePrimitiveRenderResult, PageRequestConfig, PageRoute, PageRouteEntry, PreloadManifest, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactPageService, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, ReactServerTemplateProvider, Redirection, type RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, SSRManifestProvider, TPropsDefault, TPropsParentDefault, TemplateSlots, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
+//# sourceMappingURL=index.d.ts.map