alepha 0.15.2 → 0.15.3

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

@@ -1,11 +1,11 @@
-import * as alepha16 from "alepha";
+import * as alepha6 from "alepha";
 import { Alepha, AlephaError, Async, FileLike, Json, KIND, Primitive, Static, StreamLike, TObject, TSchema } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { ClientOnlyProps } from "alepha/react";
 import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
 import { ServerRouteCache } from "alepha/server/cache";
 import { LinkProvider } from "alepha/server/links";
-import * as alepha_logger2 from "alepha/logger";
+import * as 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";
@@ -47,8 +47,8 @@ declare class Redirection extends AlephaError {
 }
 //#endregion
 //#region ../../src/react/router/providers/ReactPageProvider.d.ts
-declare const envSchema$1: alepha16.TObject<{
-  REACT_STRICT_MODE: alepha16.TBoolean;
+declare const envSchema$1: alepha6.TObject<{
+  REACT_STRICT_MODE: alepha6.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -57,7 +57,7 @@ declare module "alepha" {
  * Handle page routes for React applications. (Browser and Server)
  */
 declare class ReactPageProvider {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger0.Logger;
   protected readonly env: {
     REACT_STRICT_MODE: boolean;
   };
@@ -93,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: alepha16.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;
@@ -518,7 +518,6 @@ interface PagePrimitiveOptions<TConfig extends PageConfigSchema = PageConfigSche
    */
   [PAGE_PRELOAD_KEY]?: string;
 }
-type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
 declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Primitive<PagePrimitiveOptions<TConfig, TProps, TPropsParent>> {
   protected readonly reactPageService: ReactPageService;
   protected onInit(): void;
@@ -534,9 +533,8 @@ declare class PagePrimitive<TConfig extends PageConfigSchema = PageConfigSchema,
     html: string;
     response: Response;
   }>;
-  match(url: string): boolean;
-  pathname(config: any): string;
 }
+type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
 interface PageConfigSchema {
   query?: TSchema;
   params?: TSchema;
@@ -578,7 +576,7 @@ type CssAnimation = {
 };
 //#endregion
 //#region ../../src/react/router/services/ReactRouter.d.ts
-interface RouterGoOptions {
+interface RouterPushOptions {
   replace?: boolean;
   params?: Record<string, string>;
   query?: Record<string, string>;
@@ -624,10 +622,10 @@ declare class ReactRouter<T extends object> {
   back(): Promise<void>;
   forward(): Promise<void>;
   invalidate(props?: Record<string, any>): Promise<void>;
-  go(path: string, options?: RouterGoOptions): Promise<void>;
-  go(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
-  anchor(path: string, options?: RouterGoOptions): AnchorProps;
-  anchor(path: keyof VirtualRouter<T>, options?: RouterGoOptions): AnchorProps;
+  push(path: string, options?: RouterPushOptions): Promise<void>;
+  push(path: keyof VirtualRouter<T>, options?: RouterPushOptions): Promise<void>;
+  anchor(path: string, options?: RouterPushOptions): AnchorProps;
+  anchor(path: keyof VirtualRouter<T>, options?: RouterPushOptions): AnchorProps;
   base(path: string): string;
   /**
    * Set query params.
@@ -652,12 +650,12 @@ interface BrowserRoute extends Route {
  * Implementation of AlephaRouter for React in browser environment.
  */
 declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: alepha_logger2.Logger;
+  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: alepha16.HookPrimitive<"configure">;
+  protected readonly configure: alepha6.HookPrimitive<"configure">;
   transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
   root(state: ReactRouterState): ReactNode;
 }
@@ -666,8 +664,8 @@ declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
 /**
  * React browser renderer configuration atom
  */
-declare const reactBrowserOptions: alepha16.Atom<alepha16.TObject<{
-  scrollRestoration: alepha16.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" {
@@ -676,7 +674,7 @@ declare module "alepha" {
   }
 }
 declare class ReactBrowserProvider {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger0.Logger;
   protected readonly client: LinkProvider;
   protected readonly alepha: Alepha;
   protected readonly router: ReactBrowserRouterProvider;
@@ -708,14 +706,14 @@ declare class ReactBrowserProvider {
   get url(): string;
   pushState(path: string, replace?: boolean): void;
   invalidate(props?: Record<string, any>): Promise<void>;
-  go(url: string, options?: RouterGoOptions): Promise<void>;
+  push(url: string, options?: RouterPushOptions): Promise<void>;
   protected render(options?: RouterRenderOptions): Promise<void>;
   /**
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: alepha16.HookPrimitive<"react:transition:end">;
-  readonly ready: alepha16.HookPrimitive<"ready">;
+  protected readonly onTransitionEnd: alepha6.HookPrimitive<"react:transition:end">;
+  readonly ready: alepha6.HookPrimitive<"ready">;
 }
 type ReactHydrationState = {
   layers?: Array<PreviousLayerData>;
@@ -1104,13 +1102,217 @@ interface UseQueryParamsHookOptions {
  * }
  *
  * const router = useRouter<App>();
- * router.go("home"); // typesafe
+ * router.push("home"); // typesafe
  */
 declare const useRouter: <T extends object = any>() => ReactRouter<T>;
 //#endregion
 //#region ../../src/react/router/hooks/useRouterState.d.ts
 declare const useRouterState: () => ReactRouterState;
 //#endregion
+//#region ../../src/react/router/atoms/ssrManifestAtom.d.ts
+/**
+ * Schema for the SSR manifest atom.
+ */
+declare const ssrManifestAtomSchema: alepha6.TObject<{
+  /**
+   * Base path for assets (from Vite's base config).
+   * Used to prefix asset URLs when serving from a subpath.
+   * @example "/devtools" or "/"
+   */
+  base: alepha6.TOptional<alepha6.TString>;
+  /**
+   * 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>>;
+  }>>>;
+}>;
+/**
+ * Type for the SSR manifest schema.
+ */
+type SsrManifestAtomSchema = typeof ssrManifestAtomSchema;
+//#endregion
+//#region ../../src/react/router/providers/SSRManifestProvider.d.ts
+/**
+ * Provider for SSR manifest data used for module preloading.
+ *
+ * The manifest is populated at build time by embedding data into the
+ * generated index.js via the ssrManifestAtom. This eliminates filesystem
+ * reads at runtime, making it optimal for serverless deployments.
+ *
+ * Manifest files are generated during `vite build`:
+ * - manifest.json (client manifest)
+ * - preload-manifest.json (from viteAlephaSsrPreload plugin)
+ */
+declare class SSRManifestProvider {
+  protected readonly alepha: Alepha;
+  /**
+   * Get the manifest from the store at runtime.
+   * This ensures the manifest is available even when set after module load.
+   */
+  protected get manifest(): Static<SsrManifestAtomSchema>;
+  /**
+   * Get the base path for assets (from Vite's base config).
+   * Returns empty string if base is "/" (default), otherwise returns the base path.
+   */
+  protected get base(): string;
+  /**
+   * Get the preload manifest.
+   */
+  protected get preloadManifest(): PreloadManifest | undefined;
+  /**
+   * Get the client manifest.
+   */
+  protected get clientManifest(): ClientManifest | undefined;
+  /**
+   * Resolve a preload key to its source path.
+   *
+   * The key is a short hash injected by viteAlephaSsrPreload plugin,
+   * which maps to the full source path in the preload manifest.
+   *
+   * @param key - Short hash key (e.g., "a1b2c3d4")
+   * @returns Source path (e.g., "src/pages/UserDetail.tsx") or undefined
+   */
+  resolvePreloadKey(key: string): string | undefined;
+  /**
+   * Get all chunks required for a source file, including transitive dependencies.
+   *
+   * Uses the client manifest to recursively resolve all imported chunks.
+   *
+   * @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
+   * @returns Array of chunk URLs to preload, or empty array if not found
+   */
+  getChunks(sourcePath: string): string[];
+  /**
+   * Find manifest entry for a source path, trying different extensions.
+   */
+  protected findManifestEntry(sourcePath: string): {
+    file: string;
+    isEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+  } | undefined;
+  /**
+   * Recursively collect all chunk URLs for a manifest entry.
+   */
+  protected collectChunksRecursive(key: string, chunks: Set<string>, visited: Set<string>): void;
+  /**
+   * Collect modulepreload links for a route and its parent chain.
+   */
+  collectPreloadLinks(route: PageRoute): Array<{
+    rel: string;
+    href: string;
+    as?: string;
+    crossorigin?: string;
+  }>;
+  /**
+   * Get all chunks for multiple source files.
+   *
+   * @param sourcePaths - Array of source file paths
+   * @returns Deduplicated array of chunk URLs
+   */
+  getChunksForMultiple(sourcePaths: string[]): string[];
+  /**
+   * Check if manifest is loaded and available.
+   */
+  isAvailable(): boolean;
+  /**
+   * Cached entry assets - computed once at first access.
+   */
+  protected cachedEntryAssets: EntryAssets | null;
+  /**
+   * Get the entry point assets (main entry.js and associated CSS files).
+   *
+   * These assets are always required for all pages and can be preloaded
+   * before page-specific loaders run.
+   *
+   * @returns Entry assets with js and css paths, or null if manifest unavailable
+   */
+  getEntryAssets(): EntryAssets | null;
+  /**
+   * Build preload link tags for entry assets.
+   *
+   * @returns Array of link objects ready to be rendered
+   */
+  getEntryPreloadLinks(): Array<{
+    rel: string;
+    href: string;
+    as?: string;
+    crossorigin?: string;
+  }>;
+}
+/**
+ * Entry assets structure containing the main entry JS and associated CSS files.
+ */
+interface EntryAssets {
+  /** Main entry JavaScript file (e.g., "/assets/entry.abc123.js") */
+  js?: string;
+  /** Associated CSS files (e.g., ["/assets/style.abc123.css"]) */
+  css: string[];
+}
+/**
+ * Client manifest structure from Vite.
+ * Only includes fields actually used for preloading.
+ */
+interface ClientManifest {
+  [key: string]: {
+    file: string;
+    isEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+  };
+}
+/**
+ * Preload manifest mapping short keys to source paths.
+ * Generated by viteAlephaSsrPreload plugin at build time.
+ */
+type PreloadManifest = Record<string, string>;
+//#endregion
+//#region ../../src/react/router/providers/ReactPreloadProvider.d.ts
+/**
+ * Adds HTTP Link headers for preloading entry assets.
+ *
+ * Benefits:
+ * - Early Hints (103): Servers can send preload hints before the full response
+ * - CDN optimization: Many CDNs use Link headers to optimize asset delivery
+ * - Browser prefetching: Browsers can start fetching resources earlier
+ *
+ * The Link header is computed once at first request and cached for reuse.
+ */
+declare class ReactPreloadProvider {
+  protected readonly alepha: Alepha;
+  protected readonly ssrManifest: SSRManifestProvider;
+  /**
+   * Cached Link header value - computed once, reused for all requests.
+   */
+  protected cachedLinkHeader: string | null | undefined;
+  /**
+   * Build the Link header string from entry assets.
+   *
+   * Format: <url>; rel=preload; as=type, <url>; rel=modulepreload
+   *
+   * @returns Link header string or null if no assets
+   */
+  protected buildLinkHeader(): string | null;
+  /**
+   * Get the cached Link header, computing it on first access.
+   */
+  protected getLinkHeader(): string | null;
+  /**
+   * Add Link header to HTML responses for asset preloading.
+   */
+  protected readonly onResponse: alepha6.HookPrimitive<"server:onResponse">;
+}
+//#endregion
 //#region ../../src/system/providers/FileSystemProvider.d.ts
 /**
  * Options for creating a file from a URL
@@ -1289,8 +1491,16 @@ interface CpOptions {
 interface MkdirOptions {
   /**
    * If true, creates parent directories as needed
+   *
+   * @default true
    */
   recursive?: boolean;
+  /**
+   * If true, does not throw an error if the directory already exists
+   *
+   * @default true
+   */
+  force?: boolean;
   /**
    * File mode (permission and sticky bits)
    */
@@ -1403,202 +1613,94 @@ declare abstract class FileSystemProvider {
 //#endregion
 //#region ../../src/react/router/providers/ReactServerTemplateProvider.d.ts
 /**
- * Handles HTML template parsing, preprocessing, and streaming for SSR.
- *
- * Responsibilities:
- * - Parse template once at startup into logical slots
- * - Pre-encode static parts as Uint8Array for zero-copy streaming
- * - Render dynamic parts (attributes, head content) efficiently
- * - Build hydration data for client-side rehydration
+ * Handles HTML streaming for SSR.
  *
- * This provider is injected into ReactServerProvider to handle all
- * template-related operations, keeping ReactServerProvider focused
- * on request handling and React rendering coordination.
+ * Uses hardcoded HTML structure - all customization via $head primitive.
+ * Pre-encodes static parts as Uint8Array for zero-copy streaming.
  */
 declare class ReactServerTemplateProvider {
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   /**
-   * Shared TextEncoder instance - reused across all requests.
+   * Shared TextEncoder - reused across all requests.
    */
   protected readonly encoder: TextEncoder;
   /**
-   * Pre-encoded common strings for streaming.
-   */
-  protected readonly ENCODED: {
+   * Pre-encoded static HTML parts for zero-copy streaming.
+   */
+  protected readonly SLOTS: {
+    readonly DOCTYPE: Uint8Array<ArrayBuffer>;
+    readonly HTML_OPEN: Uint8Array<ArrayBuffer>;
+    readonly HTML_CLOSE: Uint8Array<ArrayBuffer>;
+    readonly HEAD_OPEN: Uint8Array<ArrayBuffer>;
+    readonly HEAD_CLOSE: Uint8Array<ArrayBuffer>;
+    readonly BODY_OPEN: Uint8Array<ArrayBuffer>;
+    readonly BODY_CLOSE: Uint8Array<ArrayBuffer>;
+    readonly ROOT_OPEN: Uint8Array<ArrayBuffer>;
+    readonly ROOT_CLOSE: Uint8Array<ArrayBuffer>;
+    readonly BODY_HTML_CLOSE: Uint8Array<ArrayBuffer>;
     readonly HYDRATION_PREFIX: Uint8Array<ArrayBuffer>;
     readonly HYDRATION_SUFFIX: Uint8Array<ArrayBuffer>;
-    readonly EMPTY: Uint8Array<ArrayBuffer>;
   };
   /**
-   * Cached template slots - parsed once, reused for all requests.
+   * Early head content (charset, viewport, entry assets).
+   * Set once during configuration, reused for all requests.
    */
-  protected slots: TemplateSlots | null;
+  protected earlyHeadContent: string;
   /**
    * Root element ID for React mounting.
    */
-  get rootId(): string;
+  readonly rootId = "root";
   /**
-   * Regex pattern for matching the root div and extracting its content.
+   * Regex for extracting root div content from HTML.
    */
-  get rootDivRegex(): RegExp;
+  readonly 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 content inside the root div from HTML.
    */
   extractRootContent(html: string): string | undefined;
   /**
-   * Check if template has been parsed and slots are available.
-   */
-  isReady(): boolean;
-  /**
-   * Get the parsed template slots.
-   * Throws if template hasn't been parsed yet.
-   */
-  getSlots(): TemplateSlots;
-  /**
-   * Parse an HTML template into logical slots for efficient streaming.
-   *
-   * This should be called once during server startup/configuration.
-   * The parsed slots are cached and reused for all requests.
-   */
-  parseTemplate(template: string): TemplateSlots;
-  /**
-   * Parse HTML attributes string into a record.
-   *
-   * Handles: key="value", key='value', key=value, and boolean key
+   * Set early head content (charset, viewport, entry assets).
+   * Called once during server configuration.
    */
-  protected parseAttributes(attrStr: string): Record<string, string>;
+  setEarlyHeadContent(entryAssets: string, globalHead?: SimpleHead): void;
   /**
    * Render attributes record to HTML string.
-   *
-   * @param attrs - Attributes to render
-   * @returns HTML attribute string like ` lang="en" class="dark"`
    */
-  renderAttributes(attrs: Record<string, string>): string;
-  /**
-   * Render merged HTML attributes (original + dynamic).
-   */
-  renderMergedHtmlAttrs(dynamicAttrs?: Record<string, string>): string;
-  /**
-   * Render merged body attributes (original + dynamic).
-   */
-  renderMergedBodyAttrs(dynamicAttrs?: Record<string, string>): string;
+  renderAttributes(attrs?: Record<string, string>): string;
   /**
    * Render head content (title, meta, link, script tags).
-   *
-   * @param head - Head data to render
-   * @param includeOriginal - Whether to include original head content
-   * @returns HTML string with head content
-   */
-  renderHeadContent(head?: SimpleHead, includeOriginal?: boolean): string;
-  /**
-   * Render a meta tag.
    */
-  protected renderMetaTag(meta: {
-    name?: string;
-    property?: string;
-    content: string;
-  }): string;
-  /**
-   * Render a link tag.
-   */
-  protected renderLinkTag(link: {
-    rel: string;
-    href: string;
-    type?: string;
-    as?: string;
-    crossorigin?: string;
-  }): string;
-  /**
-   * Render a script tag.
-   */
-  protected renderScriptTag(script: string | (Record<string, string | boolean | undefined> & {
-    content?: string;
-  })): string;
+  renderHeadContent(head?: SimpleHead): string;
   /**
    * Escape HTML special characters.
    */
   escapeHtml(str: string): string;
   /**
    * Safely serialize data to JSON for embedding in HTML.
-   * Escapes characters that could break out of script tags.
    */
   safeJsonSerialize(data: unknown): string;
   /**
    * Build hydration data from router state.
-   *
-   * This creates the data structure that will be serialized to window.__ssr
-   * for client-side rehydration.
    */
   buildHydrationData(state: ReactRouterState): HydrationData;
   /**
-   * Stream the body content: body tag, root div, React content, hydration, and closing tags.
-   *
-   * If an error occurs during React streaming, it injects error HTML instead of aborting,
-   * ensuring users see an error message rather than a white screen.
-   */
-  protected streamBodyContent(controller: ReadableStreamDefaultController<Uint8Array>, reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, hydration: boolean): Promise<void>;
-  /**
-   * Create a ReadableStream that streams the HTML template with React content.
-   *
-   * This is the main entry point for SSR streaming. It:
-   * 1. Sends <head> immediately (browser starts downloading assets)
-   * 2. Streams React content as it renders
-   * 3. Appends hydration script and closing tags
-   *
-   * @param reactStream - ReadableStream from renderToReadableStream
-   * @param state - Router state with head data
-   * @param options - Streaming options
-   */
-  createHtmlStream(reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, options?: {
-    hydration?: boolean;
-    onError?: (error: unknown) => void;
-  }): ReadableStream<Uint8Array>;
-  /**
-   * Early head content for preloading.
-   *
-   * Contains entry assets (JS + CSS) that are always required and can be
-   * sent before page loaders run.
-   */
-  protected earlyHeadContent: string;
-  /**
-   * Set the early head content (entry script + CSS).
-   *
-   * Also strips these assets from the original head content to avoid duplicates,
-   * since we're moving them to the early phase.
-   *
-   * Automatically prepends critical meta tags (charset, viewport) if not present
-   * in $head configuration, ensuring they're sent as early as possible.
-   *
-   * @param content - HTML string with entry assets
-   * @param globalHead - Global head configuration from $head primitives
-   * @param entryAssets - Entry asset paths to strip from original head
+   * Pipe React stream to controller with backpressure handling.
+   * Returns true if stream completed successfully, false if error occurred.
    */
-  setEarlyHeadContent(content: string, globalHead?: SimpleHead, entryAssets?: {
-    js?: string;
-    css: string[];
-  }): void;
+  protected pipeReactStream(controller: ReadableStreamDefaultController<Uint8Array>, reactStream: ReadableStream<Uint8Array>, state: ReactRouterState): Promise<boolean>;
   /**
-   * Escape special regex characters in a string.
+   * Stream complete HTML document (head already closed).
+   * Used by both createHtmlStream and late phase of createEarlyHtmlStream.
    */
-  protected escapeRegExp(str: string): string;
+  protected streamBodyAndClose(controller: ReadableStreamDefaultController<Uint8Array>, reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, hydration: boolean): Promise<void>;
   /**
-   * 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.
+   * Create HTML stream with early head optimization.
    *
    * Flow:
    * 1. Send DOCTYPE, <html>, <head> open, entry preloads (IMMEDIATE)
-   * 2. Run async work (createLayers, etc.)
+   * 2. Run async work (page loaders)
    * 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;
@@ -1610,59 +1712,26 @@ declare class ReactServerTemplateProvider {
     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
+   * Create HTML stream (non-early version, for testing/prerender).
+   */
+  createHtmlStream(reactStream: ReadableStream<Uint8Array>, state: ReactRouterState, options?: {
+    hydration?: boolean;
+    onError?: (error: unknown) => void;
+  }): ReadableStream<Uint8Array>;
+  /**
+   * Inject error HTML when streaming fails.
    */
-  protected injectErrorHtml(controller: ReadableStreamDefaultController<Uint8Array>, encoder: TextEncoder, slots: TemplateSlots, error: unknown, routerState: ReactRouterState | undefined, streamState: {
+  protected injectErrorHtml(controller: ReadableStreamDefaultController<Uint8Array>, 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
+   * Render error to HTML string.
    */
   protected renderErrorToString(error: Error, routerState: ReactRouterState | undefined): string;
 }
 /**
- * Template slots - the template split into logical parts for efficient streaming.
- *
- * Static parts are pre-encoded as Uint8Array for zero-copy streaming.
- * Dynamic parts (attributes, head content) are kept as strings/objects for merging.
- */
-interface TemplateSlots {
-  doctype: Uint8Array;
-  htmlOpen: Uint8Array;
-  htmlClose: Uint8Array;
-  headOpen: Uint8Array;
-  headClose: Uint8Array;
-  bodyOpen: Uint8Array;
-  bodyClose: Uint8Array;
-  rootOpen: Uint8Array;
-  rootClose: Uint8Array;
-  scriptClose: Uint8Array;
-  htmlOriginalAttrs: Record<string, string>;
-  bodyOriginalAttrs: Record<string, string>;
-  headOriginalContent: string;
-  beforeRoot: string;
-  afterRoot: string;
-}
-/**
- * Hydration state that gets serialized to window.__ssr
+ * Hydration state serialized to window.__ssr
  */
 interface HydrationData {
   layers: Array<{
@@ -1676,174 +1745,6 @@ interface HydrationData {
   [key: string]: unknown;
 }
 //#endregion
-//#region ../../src/react/router/atoms/ssrManifestAtom.d.ts
-/**
- * Schema for the SSR manifest atom.
- */
-declare const ssrManifestAtomSchema: alepha16.TObject<{
-  /**
-   * Base path for assets (from Vite's base config).
-   * Used to prefix asset URLs when serving from a subpath.
-   * @example "/devtools" or "/"
-   */
-  base: alepha16.TOptional<alepha16.TString>;
-  /**
-   * Preload manifest mapping short keys to source paths.
-   * Generated by viteAlephaSsrPreload plugin at build time.
-   */
-  preload: alepha16.TOptional<alepha16.TRecord<"^.*$", alepha16.TString>>;
-  /**
-   * Client manifest mapping source files to their output information.
-   * Only includes fields actually used for preloading.
-   */
-  client: alepha16.TOptional<alepha16.TRecord<"^.*$", alepha16.TObject<{
-    file: alepha16.TString;
-    isEntry: alepha16.TOptional<alepha16.TBoolean>;
-    imports: alepha16.TOptional<alepha16.TArray<alepha16.TString>>;
-    css: alepha16.TOptional<alepha16.TArray<alepha16.TString>>;
-  }>>>;
-}>;
-/**
- * Type for the SSR manifest schema.
- */
-type SsrManifestAtomSchema = typeof ssrManifestAtomSchema;
-//#endregion
-//#region ../../src/react/router/providers/SSRManifestProvider.d.ts
-/**
- * Provider for SSR manifest data used for module preloading.
- *
- * The manifest is populated at build time by embedding data into the
- * generated index.js via the ssrManifestAtom. This eliminates filesystem
- * reads at runtime, making it optimal for serverless deployments.
- *
- * Manifest files are generated during `vite build`:
- * - manifest.json (client manifest)
- * - preload-manifest.json (from viteAlephaSsrPreload plugin)
- */
-declare class SSRManifestProvider {
-  protected readonly alepha: Alepha;
-  /**
-   * Get the manifest from the store at runtime.
-   * This ensures the manifest is available even when set after module load.
-   */
-  protected get manifest(): Static<SsrManifestAtomSchema>;
-  /**
-   * Get the base path for assets (from Vite's base config).
-   * Returns empty string if base is "/" (default), otherwise returns the base path.
-   */
-  protected get base(): string;
-  /**
-   * Get the preload manifest.
-   */
-  protected get preloadManifest(): PreloadManifest | undefined;
-  /**
-   * Get the client manifest.
-   */
-  protected get clientManifest(): ClientManifest | undefined;
-  /**
-   * Resolve a preload key to its source path.
-   *
-   * The key is a short hash injected by viteAlephaSsrPreload plugin,
-   * which maps to the full source path in the preload manifest.
-   *
-   * @param key - Short hash key (e.g., "a1b2c3d4")
-   * @returns Source path (e.g., "src/pages/UserDetail.tsx") or undefined
-   */
-  resolvePreloadKey(key: string): string | undefined;
-  /**
-   * Get all chunks required for a source file, including transitive dependencies.
-   *
-   * Uses the client manifest to recursively resolve all imported chunks.
-   *
-   * @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
-   * @returns Array of chunk URLs to preload, or empty array if not found
-   */
-  getChunks(sourcePath: string): string[];
-  /**
-   * Find manifest entry for a source path, trying different extensions.
-   */
-  protected findManifestEntry(sourcePath: string): {
-    file: string;
-    isEntry?: boolean;
-    imports?: string[];
-    css?: string[];
-  } | undefined;
-  /**
-   * Recursively collect all chunk URLs for a manifest entry.
-   */
-  protected collectChunksRecursive(key: string, chunks: Set<string>, visited: Set<string>): void;
-  /**
-   * Collect modulepreload links for a route and its parent chain.
-   */
-  collectPreloadLinks(route: PageRoute): Array<{
-    rel: string;
-    href: string;
-    as?: string;
-    crossorigin?: string;
-  }>;
-  /**
-   * Get all chunks for multiple source files.
-   *
-   * @param sourcePaths - Array of source file paths
-   * @returns Deduplicated array of chunk URLs
-   */
-  getChunksForMultiple(sourcePaths: string[]): string[];
-  /**
-   * Check if manifest is loaded and available.
-   */
-  isAvailable(): boolean;
-  /**
-   * Cached entry assets - computed once at first access.
-   */
-  protected cachedEntryAssets: EntryAssets | null;
-  /**
-   * Get the entry point assets (main entry.js and associated CSS files).
-   *
-   * These assets are always required for all pages and can be preloaded
-   * before page-specific loaders run.
-   *
-   * @returns Entry assets with js and css paths, or null if manifest unavailable
-   */
-  getEntryAssets(): EntryAssets | null;
-  /**
-   * Build preload link tags for entry assets.
-   *
-   * @returns Array of link objects ready to be rendered
-   */
-  getEntryPreloadLinks(): Array<{
-    rel: string;
-    href: string;
-    as?: string;
-    crossorigin?: string;
-  }>;
-}
-/**
- * Entry assets structure containing the main entry JS and associated CSS files.
- */
-interface EntryAssets {
-  /** Main entry JavaScript file (e.g., "/assets/entry.abc123.js") */
-  js?: string;
-  /** Associated CSS files (e.g., ["/assets/style.abc123.css"]) */
-  css: string[];
-}
-/**
- * Client manifest structure from Vite.
- * Only includes fields actually used for preloading.
- */
-interface ClientManifest {
-  [key: string]: {
-    file: string;
-    isEntry?: boolean;
-    imports?: string[];
-    css?: string[];
-  };
-}
-/**
- * Preload manifest mapping short keys to source paths.
- * Generated by viteAlephaSsrPreload plugin at build time.
- */
-type PreloadManifest = Record<string, string>;
-//#endregion
 //#region ../../src/react/router/providers/ReactServerProvider.d.ts
 /**
  * React server provider responsible for SSR and static file serving.
@@ -1867,7 +1768,7 @@ declare class ReactServerProvider {
     readonly expires: "0";
   };
   protected readonly fs: FileSystemProvider;
-  protected readonly log: alepha_logger2.Logger;
+  protected readonly log: alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   protected readonly env: {
     REACT_SSR_ENABLED?: boolean | undefined;
@@ -1892,27 +1793,16 @@ declare class ReactServerProvider {
   /**
    * Configure the React server provider.
    */
-  readonly onConfigure: alepha16.HookPrimitive<"configure">;
-  /**
-   * Get the current HTML template.
-   */
-  get template(): string;
+  readonly onConfigure: alepha6.HookPrimitive<"configure">;
   /**
    * Register all pages as server routes.
    */
-  protected registerPages(templateLoader: TemplateLoader): Promise<void>;
+  protected registerPages(): void;
   /**
    * Set up early head content with entry assets.
    *
    * This content is sent immediately when streaming starts, before page loaders run,
    * allowing the browser to start downloading entry.js and CSS files early.
-   *
-   * Uses <script type="module"> instead of <link rel="modulepreload"> for JS
-   * because the script needs to execute anyway - this way the browser starts
-   * downloading, parsing, AND will execute as soon as ready.
-   *
-   * Also injects critical meta tags (charset, viewport) if not specified in $head,
-   * and strips these assets from the original template head to avoid duplicates.
    */
   protected setupEarlyHeadContent(): void;
   /**
@@ -1926,7 +1816,7 @@ declare class ReactServerProvider {
   /**
    * Create the request handler for a page route.
    */
-  protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
+  protected createHandler(route: PageRoute): ServerHandler;
   /**
    * Core page rendering logic shared between SSR handler and static prerendering.
    *
@@ -1958,25 +1848,23 @@ declare class ReactServerProvider {
    */
   protected streamToString(stream: ReadableStream<Uint8Array>): Promise<string>;
 }
-type TemplateLoader = () => Promise<string | undefined>;
-declare const envSchema: alepha16.TObject<{
-  REACT_SSR_ENABLED: alepha16.TOptional<alepha16.TBoolean>;
+declare const envSchema: alepha6.TObject<{
+  REACT_SSR_ENABLED: alepha6.TOptional<alepha6.TBoolean>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
     "alepha.react.server.ssr"?: boolean;
-    "alepha.react.server.template"?: string;
   }
 }
 /**
  * React server provider configuration atom
  */
-declare const reactServerOptions: alepha16.Atom<alepha16.TObject<{
-  publicDir: alepha16.TString;
-  staticServer: alepha16.TObject<{
-    disabled: alepha16.TBoolean;
-    path: alepha16.TString;
+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>;
@@ -2062,7 +1950,7 @@ declare module "alepha" {
  * @see {@link $page}
  * @module alepha.react.router
  */
-declare const AlephaReactRouter: alepha16.Service<alepha16.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, 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, ReactPreloadProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, ReactServerTemplateProvider, Redirection, RouterLayerContext, RouterLayerContextValue, type RouterPushOptions, RouterRenderOptions, RouterStackItem, SSRManifestProvider, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
 //# sourceMappingURL=index.d.ts.map