@alepha/react 0.14.4 → 0.15.0

package/dist/router/index.d.ts

@@ -15,7 +15,6 @@ import { ServerStaticProvider } from "alepha/server/static";
 import { ServerRouteCache } from "alepha/server/cache";
 
 //#region ../../src/router/errors/Redirection.d.ts
-
 /**
  * Used for Redirection during the page loading.
  *
@@ -70,10 +69,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>;
@@ -99,9 +98,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>;
 }
@@ -134,33 +133,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;
 }
@@ -294,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;
@@ -510,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;
@@ -533,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;
 }
@@ -588,8 +587,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;
 }
 /**
@@ -616,9 +615,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;
@@ -634,15 +633,15 @@ 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;
 }
@@ -679,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;
@@ -697,8 +696,8 @@ 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">;
@@ -1115,94 +1114,94 @@ 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.
+       *
+       * @param template - The HTML template string (typically index.html)
+       */
   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;
@@ -1210,99 +1209,100 @@ declare class ReactServerTemplateProvider {
     crossorigin?: string;
   }): string;
   /**
-   * Render a script tag.
-   */
+       * Render a script tag.
+       */
   protected renderScriptTag(script: Record<string, string | boolean>): 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 a string to Uint8Array using the shared encoder.
+       */
   encode(str: string): Uint8Array;
   /**
-   * Get the pre-encoded hydration script prefix.
-   */
+       * Get the pre-encoded hydration script prefix.
+       */
   get hydrationPrefix(): Uint8Array;
   /**
-   * Get the pre-encoded hydration script suffix.
-   */
+       * 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
-   */
+       * 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>;
+  } | {
+    redirect: string;
   } | null>, options?: {
     hydration?: boolean;
     onError?: (error: unknown) => void;
-    onRedirect?: (url: string) => void;
   }): ReadableStream<Uint8Array>;
 }
 /**
@@ -1349,17 +1349,17 @@ interface HydrationData {
  */
 declare const ssrManifestAtomSchema: alepha1.TObject<{
   /**
-   * Preload manifest mapping short keys to source paths.
-   * Generated by viteAlephaSsrPreload plugin at build time.
-   */
+       * 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 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 manifest mapping source files to their output information.
+       */
   client: alepha1.TOptional<alepha1.TRecord<"^.*$", alepha1.TObject<{
     file: alepha1.TString;
     src: alepha1.TOptional<alepha1.TString>;
@@ -1392,45 +1392,45 @@ type SsrManifestAtomSchema = typeof ssrManifestAtomSchema;
 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.
-   */
+       * 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,
+       * 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
+       */
   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;
@@ -1442,16 +1442,16 @@ declare class SSRManifestProvider {
     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.
-   */
+       * 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 +1459,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 manifests are 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;
@@ -1544,8 +1544,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";
@@ -1566,8 +1566,8 @@ declare class ReactServerProvider {
   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,75 +1577,75 @@ declare class ReactServerProvider {
     };
   }>;
   /**
-   * Configure the React server provider.
-   */
+       * Configure the React server provider.
+       */
   readonly onConfigure: alepha1.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.
-   */
+       * 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>;
@@ -1683,26 +1683,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 +1710,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;
     };