@alepha/react 0.15.0 → 0.15.1

package/dist/router/index.d.ts

@@ -1,19 +1,27 @@
 import { ClientOnlyProps } from "@alepha/react";
-import * as alepha1 from "alepha";
+import * as alepha6 from "alepha";
 import { Alepha, AlephaError, Async, KIND, Primitive, Static, TObject, TSchema } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
-import * as alepha_logger0 from "alepha/logger";
+import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
+import { ServerRouteCache } from "alepha/server/cache";
 import { LinkProvider } from "alepha/server/links";
-import { BrowserHeadProvider, Head, ServerHeadProvider, SimpleHead } from "@alepha/react/head";
-import { Route, RouterProvider } from "alepha/router";
+import * as alepha_logger0 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 { ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
+import { BrowserHeadProvider, Head, ServerHeadProvider, SimpleHead } from "@alepha/react/head";
 import { FileSystemProvider } from "alepha/file";
 import { ServerStaticProvider } from "alepha/server/static";
-import { ServerRouteCache } from "alepha/server/cache";
+import { Route, RouterProvider } from "alepha/router";
 
+//#region ../../src/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/router/errors/Redirection.d.ts
 /**
  * Used for Redirection during the page loading.
@@ -39,8 +47,8 @@ declare class Redirection extends AlephaError {
 }
 //#endregion
 //#region ../../src/router/providers/ReactPageProvider.d.ts
-declare const envSchema$1: alepha1.TObject<{
-  REACT_STRICT_MODE: alepha1.TBoolean;
+declare const envSchema$1: alepha6.TObject<{
+  REACT_STRICT_MODE: alepha6.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -69,10 +77,10 @@ declare class ReactPageProvider {
   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.
-       */
+   * 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>;
@@ -85,7 +93,7 @@ declare class ReactPageProvider {
   }, 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: alepha1.HookPrimitive<"configure">;
+  protected readonly configure: alepha6.HookPrimitive<"configure">;
   protected map(pages: Array<PagePrimitive>, target: PagePrimitive): PageRouteEntry;
   add(entry: PageRouteEntry): void;
   protected createMatch(page: PageRoute): string;
@@ -98,9 +106,9 @@ interface PageRouteEntry extends Omit<PagePrimitiveOptions, "children" | "parent
 }
 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'.
-       */
+   * 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>;
 }
@@ -133,33 +141,33 @@ interface AnchorProps {
 }
 interface ReactRouterState {
   /**
-       * Stack of layers for the current page.
-       */
+   * Stack of layers for the current page.
+   */
   layers: Array<Layer>;
   /**
-       * URL of the current page.
-       */
+   * URL of the current page.
+   */
   url: URL;
   /**
-       * Error handler for the current page.
-       */
+   * Error handler for the current page.
+   */
   onError: ErrorHandler;
   /**
-       * Params extracted from the URL for the current page.
-       */
+   * Params extracted from the URL for the current page.
+   */
   params: Record<string, any>;
   /**
-       * Query parameters extracted from the URL for the current page.
-       */
+   * Query parameters extracted from the URL for the current page.
+   */
   query: Record<string, string>;
   /**
-       * Optional meta information associated with the current page.
-       */
+   * 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 configuration for the current page (title, meta tags, etc.).
+   * Populated by HeadProvider during SSR.
+   */
   head: Head;
   name?: string;
 }
@@ -190,14 +198,6 @@ declare abstract class ReactPageService {
   render(name: string, options?: PagePrimitiveRenderOptions): Promise<PagePrimitiveRenderResult>;
 }
 //#endregion
-//#region ../../src/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/router/primitives/$page.d.ts
 /**
  * Main primitive for defining a React route in the application.
@@ -293,214 +293,214 @@ declare const $page: {
 };
 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
-       */
+   * 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 ""
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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 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.
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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");
-       *   }
-       * }
-       * ```
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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)
-       */
+   * Called before the server response is sent to the client. (server only)
+   */
   onServerResponse?: (request: ServerRequest) => unknown;
   /**
-       * Called when user leaves the page. (browser only)
-       */
+   * 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" },
-       * }
-       * ```
-       */
+   * @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 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
-       */
+   * 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;
@@ -509,11 +509,11 @@ declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema,
   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.
-       */
+   * 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;
@@ -532,11 +532,11 @@ 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
-       */
+   * 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;
 }
@@ -562,24 +562,6 @@ type CssAnimation = {
   timing?: string;
 };
 //#endregion
-//#region ../../src/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_logger0.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly pageApi: ReactPageProvider;
-  protected readonly browserHeadProvider: BrowserHeadProvider;
-  add(entry: PageRouteEntry): void;
-  protected readonly configure: alepha1.HookPrimitive<"configure">;
-  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
-  root(state: ReactRouterState): ReactNode;
-}
-//#endregion
 //#region ../../src/router/services/ReactRouter.d.ts
 interface RouterGoOptions {
   replace?: boolean;
@@ -587,8 +569,8 @@ interface RouterGoOptions {
   query?: Record<string, string>;
   meta?: Record<string, any>;
   /**
-       * Recreate the whole page, ignoring the current state.
-       */
+   * Recreate the whole page, ignoring the current state.
+   */
   force?: boolean;
 }
 /**
@@ -615,9 +597,9 @@ declare class ReactRouter<T extends object> {
     query?: Record<string, any>;
   }): string;
   /**
-       * Reload the current page.
-       * This is equivalent to calling `go()` with the current pathname and search.
-       */
+   * Reload the current page.
+   * This is equivalent to calling `go()` with the current pathname and search.
+   */
   reload(): Promise<void>;
   getURL(): URL;
   get location(): Location;
@@ -633,26 +615,44 @@ declare class ReactRouter<T extends object> {
   anchor(path: keyof VirtualRouter<T>, options?: RouterGoOptions): AnchorProps;
   base(path: string): string;
   /**
-       * Set query params.
-       *
-       * @param record
-       * @param options
-       */
+   * 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.
-             */
+     * 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/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_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly pageApi: ReactPageProvider;
+  protected readonly browserHeadProvider: BrowserHeadProvider;
+  add(entry: PageRouteEntry): void;
+  protected readonly configure: alepha6.HookPrimitive<"configure">;
+  transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
+  root(state: ReactRouterState): ReactNode;
+}
+//#endregion
 //#region ../../src/router/providers/ReactBrowserProvider.d.ts
 /**
  * React browser renderer configuration atom
  */
-declare const reactBrowserOptions: alepha1.Atom<alepha1.TObject<{
-  scrollRestoration: alepha1.TUnsafe<"top" | "manual">;
+declare const reactBrowserOptions: alepha6.Atom<alepha6.TObject<{
+  scrollRestoration: alepha6.TUnsafe<"top" | "manual">;
 }>, "alepha.react.browser.options">;
 type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
 declare module "alepha" {
@@ -678,16 +678,16 @@ declare class ReactBrowserProvider {
   };
   get state(): ReactRouterState;
   /**
-       * Accessor for Document DOM API.
-       */
+   * Accessor for Document DOM API.
+   */
   get document(): Document;
   /**
-       * Accessor for History DOM API.
-       */
+   * Accessor for History DOM API.
+   */
   get history(): History;
   /**
-       * Accessor for Location DOM API.
-       */
+   * Accessor for Location DOM API.
+   */
   get location(): Location;
   get base(): string;
   get url(): string;
@@ -696,11 +696,11 @@ declare class ReactBrowserProvider {
   go(url: string, options?: RouterGoOptions): Promise<void>;
   protected render(options?: RouterRenderOptions): Promise<void>;
   /**
-       * Get embedded layers from the server.
-       */
+   * Get embedded layers from the server.
+   */
   protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: alepha1.HookPrimitive<"react:transition:end">;
-  readonly ready: alepha1.HookPrimitive<"ready">;
+  protected readonly onTransitionEnd: alepha6.HookPrimitive<"react:transition:end">;
+  readonly ready: alepha6.HookPrimitive<"ready">;
 }
 type ReactHydrationState = {
   layers?: Array<PreviousLayerData>;
@@ -719,7 +719,7 @@ interface ErrorViewerProps {
   alepha: Alepha;
 }
 /**
- * Error viewer component that displays error details in development mode
+ * Error viewer component - Terminal/brutalist aesthetic
  */
 declare const ErrorViewer: ({
   error,
@@ -1114,187 +1114,183 @@ declare class ReactServerTemplateProvider {
   protected readonly log: alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   /**
-       * Shared TextEncoder instance - reused across all requests.
-       */
+   * Shared TextEncoder instance - reused across all requests.
+   */
   protected readonly encoder: TextEncoder;
   /**
-       * Pre-encoded common strings for streaming.
-       */
+   * 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.
-       */
+   * Cached template slots - parsed once, reused for all requests.
+   */
   protected slots: TemplateSlots | null;
   /**
-       * Root element ID for React mounting.
-       */
+   * Root element ID for React mounting.
+   */
   get rootId(): string;
   /**
-       * Regex pattern for matching the root div and extracting its content.
-       */
+   * 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
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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.
-       *
-       * @param template - The HTML template string (typically index.html)
-       */
+   * 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
-       */
+   * 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"`
-       */
+   * 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).
-       */
+   * Render merged HTML attributes (original + dynamic).
+   */
   renderMergedHtmlAttrs(dynamicAttrs?: Record<string, string>): string;
   /**
-       * Render merged body attributes (original + dynamic).
-       */
+   * 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
-       */
+   * 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.
-       */
+   * Render a meta tag.
+   */
   protected renderMetaTag(meta: {
     name?: string;
     property?: string;
     content: string;
   }): string;
   /**
-       * Render a link tag.
-       */
+   * 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: Record<string, string | boolean>): string;
+   * Render a script tag.
+   */
+  protected renderScriptTag(script: string | (Record<string, string | boolean | undefined> & {
+    content?: string;
+  })): string;
   /**
-       * Escape HTML special characters.
-       */
+   * 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.
-       */
+   * 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.
-       */
+   * 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;
   /**
-       * Encode a string to Uint8Array using the shared encoder.
-       */
-  encode(str: string): Uint8Array;
-  /**
-       * Get the pre-encoded hydration script prefix.
-       */
-  get hydrationPrefix(): Uint8Array;
-  /**
-       * Get the pre-encoded hydration script suffix.
-       */
-  get hydrationSuffix(): Uint8Array;
-  /**
-       * 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
-       */
+   * 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.
-       */
+   * 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.
-       *
-       * @param content - HTML string with entry assets
-       * @param entryAssets - Entry asset paths to strip from original head
-       */
+   * 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.
+   *
+   * @param content - HTML string with entry assets
+   * @param entryAssets - Entry asset paths to strip from original head
+   */
   setEarlyHeadContent(content: string, entryAssets?: {
     js?: string;
     css: string[];
   }): void;
   /**
-       * Escape special regex characters in a string.
-       */
+   * 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
-       */
+   * 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>;
@@ -1304,6 +1300,34 @@ declare class ReactServerTemplateProvider {
     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.
@@ -1347,28 +1371,21 @@ interface HydrationData {
 /**
  * Schema for the SSR manifest atom.
  */
-declare const ssrManifestAtomSchema: alepha1.TObject<{
-  /**
-       * Preload manifest mapping short keys to source paths.
-       * Generated by viteAlephaSsrPreload plugin at build time.
-       */
-  preload: alepha1.TOptional<alepha1.TRecord<"^.*$", alepha1.TString>>;
-  /**
-       * SSR manifest mapping source files to their required chunks.
-       */
-  ssr: alepha1.TOptional<alepha1.TRecord<"^.*$", alepha1.TArray<alepha1.TString>>>;
-  /**
-       * Client manifest mapping source files to their output information.
-       */
-  client: alepha1.TOptional<alepha1.TRecord<"^.*$", alepha1.TObject<{
-    file: alepha1.TString;
-    src: alepha1.TOptional<alepha1.TString>;
-    isEntry: alepha1.TOptional<alepha1.TBoolean>;
-    isDynamicEntry: alepha1.TOptional<alepha1.TBoolean>;
-    imports: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-    dynamicImports: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-    css: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
-    assets: alepha1.TOptional<alepha1.TArray<alepha1.TString>>;
+declare const ssrManifestAtomSchema: alepha6.TObject<{
+  /**
+   * Preload manifest mapping short keys to source paths.
+   * Generated by viteAlephaSsrPreload plugin at build time.
+   */
+  preload: alepha6.TOptional<alepha6.TRecord<"^.*$", alepha6.TString>>;
+  /**
+   * Client manifest mapping source files to their output information.
+   * Only includes fields actually used for preloading.
+   */
+  client: alepha6.TOptional<alepha6.TRecord<"^.*$", alepha6.TObject<{
+    file: alepha6.TString;
+    isEntry: alepha6.TOptional<alepha6.TBoolean>;
+    imports: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
+    css: alepha6.TOptional<alepha6.TArray<alepha6.TString>>;
   }>>>;
 }>;
 /**
@@ -1386,72 +1403,58 @@ type SsrManifestAtomSchema = typeof ssrManifestAtomSchema;
  *
  * Manifest files are generated during `vite build`:
  * - manifest.json (client manifest)
- * - ssr-manifest.json (SSR 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.
-       */
+   * 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 preload manifest.
-       */
+   * Get the preload manifest.
+   */
   protected get preloadManifest(): PreloadManifest | undefined;
   /**
-       * Get the SSR manifest.
-       */
-  protected get ssrManifest(): SSRManifest | undefined;
-  /**
-       * Get the client manifest.
-       */
+   * 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
-       */
+   * 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,
-       * not just the direct chunks from the SSR manifest.
-       *
-       * @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
-       * @returns Array of chunk URLs to preload, or empty array if not found
-       */
+   * 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.
-       */
+   * Find manifest entry for a source path, trying different extensions.
+   */
   protected findManifestEntry(sourcePath: string): {
     file: string;
-    src?: string;
     isEntry?: boolean;
-    isDynamicEntry?: boolean;
     imports?: string[];
-    dynamicImports?: string[];
     css?: string[];
-    assets?: string[];
   } | undefined;
   /**
-       * Recursively collect all chunk URLs for a manifest entry.
-       */
+   * Recursively collect all chunk URLs for a manifest entry.
+   */
   protected collectChunksRecursive(key: string, chunks: Set<string>, visited: Set<string>): void;
   /**
-       * Fallback to SSR manifest for chunk lookup.
-       */
-  protected getChunksFromSSRManifest(sourcePath: string): string[];
-  /**
-       * Collect modulepreload links for a route and its parent chain.
-       */
+   * Collect modulepreload links for a route and its parent chain.
+   */
   collectPreloadLinks(route: PageRoute): Array<{
     rel: string;
     href: string;
@@ -1459,34 +1462,34 @@ declare class SSRManifestProvider {
     crossorigin?: string;
   }>;
   /**
-       * Get all chunks for multiple source files.
-       *
-       * @param sourcePaths - Array of source file paths
-       * @returns Deduplicated array of chunk URLs
-       */
+   * 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 manifests are loaded and available.
-       */
+   * Check if manifest is loaded and available.
+   */
   isAvailable(): boolean;
   /**
-       * Cached entry assets - computed once at first access.
-       */
+   * 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
-       */
+   * 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
-       */
+   * Build preload link tags for entry assets.
+   *
+   * @returns Array of link objects ready to be rendered
+   */
   getEntryPreloadLinks(): Array<{
     rel: string;
     href: string;
@@ -1503,25 +1506,16 @@ interface EntryAssets {
   /** Associated CSS files (e.g., ["/assets/style.abc123.css"]) */
   css: string[];
 }
-/**
- * SSR Manifest structure from Vite.
- * Maps source file paths to their required chunks/assets.
- */
-type SSRManifest = Record<string, string[]>;
 /**
  * Client manifest structure from Vite.
- * Maps source files to their output information.
+ * Only includes fields actually used for preloading.
  */
 interface ClientManifest {
   [key: string]: {
     file: string;
-    src?: string;
     isEntry?: boolean;
-    isDynamicEntry?: boolean;
     imports?: string[];
-    dynamicImports?: string[];
     css?: string[];
-    assets?: string[];
   };
 }
 /**
@@ -1544,8 +1538,8 @@ type PreloadManifest = Record<string, string>;
  */
 declare class ReactServerProvider {
   /**
-       * SSR response headers - pre-allocated to avoid object creation per request.
-       */
+   * 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";
@@ -1563,11 +1557,10 @@ declare class ReactServerProvider {
   protected readonly serverHeadProvider: ServerHeadProvider;
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
-  protected readonly serverTimingProvider: ServerTimingProvider;
   protected readonly ssrManifestProvider: SSRManifestProvider;
   /**
-       * Cached check for ServerLinksProvider - avoids has() lookup per request.
-       */
+   * Cached check for ServerLinksProvider - avoids has() lookup per request.
+   */
   protected hasServerLinksProvider: boolean;
   protected readonly options: Readonly<{
     publicDir: string;
@@ -1577,80 +1570,76 @@ declare class ReactServerProvider {
     };
   }>;
   /**
-       * Configure the React server provider.
-       */
-  readonly onConfigure: alepha1.HookPrimitive<"configure">;
+   * Configure the React server provider.
+   */
+  readonly onConfigure: alepha6.HookPrimitive<"configure">;
   /**
-       * Get the current HTML template.
-       */
+   * Get the current HTML template.
+   */
   get template(): string;
   /**
-       * Register all pages as server routes.
-       */
+   * 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 strips these assets from the original template head to avoid duplicates.
-       */
+   * 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 strips these assets from the original template head to avoid duplicates.
+   */
   protected setupEarlyHeadContent(): void;
   /**
-       * Get the public directory path where static files are located.
-       */
+   * 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.
-       */
+   * Configure the static file server to serve files from the given root directory.
+   */
   protected configureStaticServer(root: string): Promise<void>;
   /**
-       * Configure Vite for SSR in development mode.
-       */
-  protected configureVite(ssrEnabled: boolean): Promise<void>;
-  /**
-       * Create the request handler for a page route.
-       */
+   * 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
-       */
+   * 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)
-       */
+   * 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.
-       */
+   * Collect a ReadableStream into a string.
+   */
   protected streamToString(stream: ReadableStream<Uint8Array>): Promise<string>;
 }
 type TemplateLoader = () => Promise<string | undefined>;
-declare const envSchema: alepha1.TObject<{
-  REACT_SSR_ENABLED: alepha1.TOptional<alepha1.TBoolean>;
+declare const envSchema: alepha6.TObject<{
+  REACT_SSR_ENABLED: alepha6.TOptional<alepha6.TBoolean>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -1662,11 +1651,11 @@ declare module "alepha" {
 /**
  * React server provider configuration atom
  */
-declare const reactServerOptions: alepha1.Atom<alepha1.TObject<{
-  publicDir: alepha1.TString;
-  staticServer: alepha1.TObject<{
-    disabled: alepha1.TBoolean;
-    path: alepha1.TString;
+declare const reactServerOptions: alepha6.Atom<alepha6.TObject<{
+  publicDir: alepha6.TString;
+  staticServer: alepha6.TObject<{
+    disabled: alepha6.TBoolean;
+    path: alepha6.TString;
   }>;
 }>, "alepha.react.server.options">;
 type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
@@ -1683,26 +1672,26 @@ declare module "alepha" {
   }
   interface Hooks {
     /**
-             * Fires when the React application is starting to be rendered on the server.
-             */
+     * 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.
-             */
+     * 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.
-             */
+     * 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;
@@ -1710,29 +1699,29 @@ declare module "alepha" {
       hydration?: ReactHydrationState;
     };
     /**
-             * Fires when a route transition is starting.
-             */
+     * Fires when a route transition is starting.
+     */
     "react:transition:begin": {
       previous: ReactRouterState;
       state: ReactRouterState;
       animation?: PageAnimation;
     };
     /**
-             * Fires when a route transition has succeeded.
-             */
+     * Fires when a route transition has succeeded.
+     */
     "react:transition:success": {
       state: ReactRouterState;
     };
     /**
-             * Fires when a route transition has failed.
-             */
+     * 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.
-             */
+     * Fires when a route transition has completed, regardless of success or failure.
+     */
     "react:transition:end": {
       state: ReactRouterState;
     };
@@ -1752,7 +1741,7 @@ declare module "alepha" {
  * @see {@link $page}
  * @module alepha.react.router
  */
-declare const AlephaReactRouter: alepha1.Service<alepha1.Module>;
+declare const AlephaReactRouter: alepha6.Service<alepha6.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, SSRManifest, SSRManifestProvider, TPropsDefault, TPropsParentDefault, TemplateSlots, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
+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