@ilha/router 0.9.2 → 0.10.0

package/README.md

@@ -246,7 +246,7 @@ If the active island is not found in the registry, falls back to plain SSR and e
 
 | Option     | Type      | Default | Description                                           |
 | ---------- | --------- | ------- | ----------------------------------------------------- |
-| `snapshot` | `boolean` | `true`  | Embed island state as `data-ilha-state` for hydration |
+| `snapshot` | `boolean` | `false` | Embed island state as `data-ilha-state` for hydration |
 
 ---
 
@@ -396,10 +396,17 @@ router()
 Attaches the route's `+error` boundary so **loader** errors render through it — on the server (`renderResponse` returns the boundary's HTML with the error status) and on client navigations. Render errors are already handled by `wrapError` inside the island; this closes the gap for errors thrown before rendering starts. The FS-routing codegen wires the nearest `+error.ts` automatically; manual routers can call it directly. A throwing boundary falls back to the minimal inline error.
 
 ```ts
+import { router } from "@ilha/router";
+import { ilha, html } from "ilha";
+
 router()
   .route("/user/:id", userPage, userLoader)
   .errorBoundary("/user/:id", (err, route) =>
-    ilha.render(() => `<h1>${err.status ?? 500}</h1><p>${err.message}</p>`),
+    ilha(
+      () =>
+        html`<h1>${err.status ?? 500}</h1>
+          <p>${err.message}</p>`,
+    ),
   );
 ```
 
@@ -443,8 +450,9 @@ Reactive — `true` while a client navigation (loader fetch + view swap) is in f
 
 ```ts
 import { navigating } from "@ilha/router";
+import { ilha, html } from "ilha";
 
-const Spinner = ilha.render(() => (navigating() ? `<div class="bar" />` : ""));
+const Spinner = ilha(() => (navigating() ? html`<div class="bar" />` : ""));
 ```
 
 ---
@@ -574,10 +582,11 @@ Returns reactive signal accessors for the current route state. Safe to call insi
 
 ```ts
 import { useRoute } from "@ilha/router";
+import { ilha, html } from "ilha";
 
-const MyPage = ilha.render(() => {
+const MyPage = ilha(() => {
   const { path, params, search, hash } = useRoute();
-  return `<p>user id: ${params().id}</p>`;
+  return html`<p>user id: ${params().id}</p>`;
 });
 ```
 
@@ -685,10 +694,10 @@ A typed helper that returns the layout function as-is. Use it instead of the `sa
 ```ts
 // src/pages/+layout.ts
 import { defineLayout } from "@ilha/router";
-import ilha, { html } from "ilha";
+import { ilha, html } from "ilha";
 
 export default defineLayout((children) =>
-  ilha.render(
+  ilha(
     () => html`
       <nav>
         <a href="/">Home</a>
@@ -714,7 +723,7 @@ import { wrapError } from "@ilha/router";
 const safe = wrapError(myErrorHandler, myPage);
 ```
 
-> **Note:** Error boundaries wrap the _page island's render_, not the loader. Loader errors (thrown via `error()`) are surfaced through `.renderResponse()` — they do not currently route through `+error.ts` boundaries. Use `.renderResponse()` to handle loader errors at the HTTP layer.
+> **Note:** Error boundaries wrap the _page island's render_, not the loader. Loader errors (thrown via `error()`) route through the nearest `+error.ts` / `.errorBoundary()` boundary — on the server `renderResponse` returns the boundary's HTML with the error status, and on client navigations the boundary renders in place. `wrapError` covers render/mount throws inside the island only.
 
 ---
 
@@ -743,8 +752,16 @@ interface LoaderContext {
 
 type Loader<T> = (ctx: LoaderContext) => Promise<T> | T;
 
-// Extract the return type of a loader
-type InferLoader<L> = L extends Loader<infer T> ? Awaited<T> : never;
+// Infer the complete page props produced by a loader
+type InferLoader<L> = L extends Loader<infer T>
+  ? {
+      load: {
+        loading: boolean;
+        value: Awaited<T>;
+        error: Error | undefined;
+      };
+    }
+  : never;
 
 // Merge multiple loader return types — later loaders win on key collision
 type MergeLoaders<Ls extends readonly Loader<any>[]> = /* … */;
@@ -900,10 +917,10 @@ A `+layout.ts` wraps every page in its directory and all subdirectories. Layouts
 ```ts
 // src/pages/+layout.ts
 import { defineLayout } from "@ilha/router";
-import ilha, { html } from "ilha";
+import { ilha, html } from "ilha";
 
 export default defineLayout((children) =>
-  ilha.render(
+  ilha(
     () => html`
       <nav>
         <a href="/">Home</a>
@@ -920,10 +937,10 @@ Alternatively, using the explicit type annotation:
 ```ts
 // src/pages/+layout.ts — using satisfies (equivalent)
 import type { LayoutHandler } from "@ilha/router/vite";
-import ilha, { html } from "ilha";
+import { ilha, html } from "ilha";
 
 export default ((children) =>
-  ilha.render(
+  ilha(
     () => html`
       <nav>
         <a href="/">Home</a>
@@ -953,14 +970,14 @@ A page file can export a `load` function declared with the `loader()` helper. Th
 ```ts
 // src/pages/user/[id].ts
 import { loader } from "@ilha/router";
-import ilha from "ilha";
+import { ilha, html } from "ilha";
 
 export const load = loader(async ({ params }) => {
   const user = await fetchUser(params.id);
   return { user };
 });
 
-export default ilha.input<{ user: User }>().render((input) => `<h1>${input.user.name}</h1>`);
+export default ilha<{ user: User }>(({ user }) => html`<h1>${user.name}</h1>`);
 ```
 
 The `load` export must be declared with the `loader()` helper so the Vite plugin can identify it via export name.
@@ -989,14 +1006,14 @@ A page or layout can export a `clientLoad` function that runs **in the browser**
 ```ts
 // src/pages/dashboard.ts
 import { loader } from "@ilha/router";
-import ilha from "ilha";
+import { ilha } from "ilha";
 
 export const clientLoad = loader(async ({ signal }) => {
   const stats = await fetch("/api/stats", { signal }).then((r) => r.json());
   return { stats };
 });
 
-export default ilha.input<{ stats: Stats }>().render(/* … */);
+export default ilha<{ stats: Stats }>(({ stats }) => html`<pre>${JSON.stringify(stats)}</pre>`);
 ```
 
 Rules and caveats:
@@ -1014,17 +1031,17 @@ A `+error.ts` catches any error thrown during rendering of pages in its director
 ```ts
 // src/pages/+error.ts
 import type { ErrorHandler } from "@ilha/router/vite";
-import ilha from "ilha";
+import { ilha, html } from "ilha";
 
 export default ((error, route) =>
-  ilha.render(
-    () => `
-    <div class="error">
-      <h1>${error.status ?? 500}</h1>
-      <p>${error.message}</p>
-      <p>Path: ${route.path}</p>
-    </div>
-  `,
+  ilha(
+    () => html`
+      <div class="error">
+        <h1>${error.status ?? 500}</h1>
+        <p>${error.message}</p>
+        <p>Path: ${route.path}</p>
+      </div>
+    `,
   )) satisfies ErrorHandler;
 ```
 

package/dist/head.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Render-scoped head collection and serialization.
+ *
+ * Loaders and render-time `head()` calls push `HeadInput` entries into a
+ * store scoped to the current render (`withHeadStore`); `serializeHead`
+ * turns the collected entries into document-shell fragments.
+ */
+/**
+ * Serializable description of `<head>` (and html/body attributes) contributed
+ * by a loader or a render-time `head()` call. Deliberately a plain POJO — Tier
+ * 1 head management is SSR-only, so there is no reactive wrapper. Dedup keys
+ * mirror unhead so a later move to a runtime head manager stays a drop-in.
+ */
+export interface HeadInput {
+    title?: string;
+    /** Wrap the resolved title. The last template in merge order wins. */
+    titleTemplate?: string | ((title?: string) => string);
+    meta?: Array<Record<string, string>>;
+    link?: Array<Record<string, string>>;
+    /**
+     * Inline script bodies are emitted raw in SSR (`serializeHead`). Must be trusted
+     * app code and must not contain a literal `</script>` sequence.
+     */
+    script?: Array<Record<string, string> & {
+        children?: string;
+    }>;
+    htmlAttrs?: Record<string, string>;
+    bodyAttrs?: Record<string, string>;
+}
+/** Serialized head fragments ready to inject into a document shell. */
+export interface SerializedHead {
+    /** Markup for inside `<head>` (title, meta, link, script). */
+    headTags: string;
+    /** Attribute string for the `<html>` tag (leading space included). */
+    htmlAttrs: string;
+    /** Attribute string for the `<body>` tag (leading space included). */
+    bodyAttrs: string;
+}
+export interface HeadStore {
+    entries: HeadInput[];
+}
+/**
+ * Contribute `<head>` data from inside an island's `.render()` body or a
+ * layout. During SSR this collects into the active render window; on the
+ * client, entries are collected when the router re-renders a route inside
+ * `withHeadStore` and then applied to `document`. Prefer a loader's `ctx.head`
+ * for data that depends on the request.
+ */
+export declare function head(input: HeadInput): void;
+export declare function cssEscapeAttr(value: string): string;
+/**
+ * Apply merged head entries on client navigations. Updates `document.title` and
+ * managed meta/link nodes (`data-ilha-head`). Script tags from HeadInput are
+ * SSR-only and are not re-injected here. Removes managed tags from the previous
+ * route that are not part of this navigation's set.
+ */
+export declare function applyHeadEntriesToDocument(entries: HeadInput[]): void;
+export declare function withHeadStore<T>(store: HeadStore, fn: () => T | Promise<T>): Promise<T>;
+export declare function escapeHeadAttr(value: unknown): string;
+/** Escape text content for inline HTML (loader error messages etc.). */
+export declare function escapeHtml(value: unknown): string;
+/**
+ * Merge head entries in contribution order (loader first as the base, then
+ * render-time outer→inner layouts, then the page) and serialize. Later entries
+ * win on collision; the last `titleTemplate` wraps the resolved title.
+ */
+export declare function serializeHead(entries: HeadInput[]): SerializedHead;

package/dist/http.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Standalone HTTP response helper for custom server handlers.
+ */
+import type { SerializedHead } from "./head";
+export interface HttpResponseOptions {
+    status?: number;
+    headers?: HeadersInit;
+    /**
+     * CSP nonce for inline scripts. When set (and `contentSecurityPolicy` is
+     * not), a conservative default CSP is emitted with `'nonce-${nonce}'` for
+     * `script-src` — pass the same nonce to head `<script nonce=…>` tags.
+     */
+    cspNonce?: string;
+    /** Full `Content-Security-Policy` string; overrides the nonce-derived default. */
+    contentSecurityPolicy?: string;
+}
+/**
+ * Build an HTTP `Response` for SSR output with sensible security headers:
+ * `Content-Type: text/html`, `X-Content-Type-Options: nosniff`,
+ * `Referrer-Policy`, `Cache-Control: no-store`, and an optional CSP. This is
+ * a low-level helper — prefer {@link RouterBuilder.respond} for the full
+ * render+head+headers pipeline.
+ */
+export declare function httpResponse(body: string | null, options?: HttpResponseOptions): Response;
+export declare const EMPTY_HEAD: SerializedHead;
+/**
+ * Options for {@link RouterBuilder.respond}.
+ */

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 import type { Island, HydratableOptions } from "ilha";
+import { head, type HeadInput, type SerializedHead } from "./head";
+import { type HttpResponseOptions } from "./http";
 export { setHistoryMode, getHistoryMode } from "./hash";
 export type { HistoryMode } from "./hash";
 export interface RouteRecord {
     pattern: string;
-    island: Island<any, any>;
+    island: Island<any>;
     /** Merged loader chain (layouts outer→inner, then page) — `undefined` if no loaders. */
     loader?: Loader<any>;
     /** True when the route has a server-side loader, even if the client only has a marker. */
@@ -20,39 +22,8 @@ export interface AppError {
     status?: number;
     stack?: string;
 }
-export type LayoutHandler = (children: Island<any, any>) => Island<any, any>;
-export type ErrorHandler = (error: AppError, route: RouteSnapshot) => Island<any, any>;
-/**
- * Serializable description of `<head>` (and html/body attributes) contributed
- * by a loader or a render-time `head()` call. Deliberately a plain POJO — Tier
- * 1 head management is SSR-only, so there is no reactive wrapper. Dedup keys
- * mirror unhead so a later move to a runtime head manager stays a drop-in.
- */
-export interface HeadInput {
-    title?: string;
-    /** Wrap the resolved title. The last template in merge order wins. */
-    titleTemplate?: string | ((title?: string) => string);
-    meta?: Array<Record<string, string>>;
-    link?: Array<Record<string, string>>;
-    /**
-     * Inline script bodies are emitted raw in SSR (`serializeHead`). Must be trusted
-     * app code and must not contain a literal `</script>` sequence.
-     */
-    script?: Array<Record<string, string> & {
-        children?: string;
-    }>;
-    htmlAttrs?: Record<string, string>;
-    bodyAttrs?: Record<string, string>;
-}
-/** Serialized head fragments ready to inject into a document shell. */
-export interface SerializedHead {
-    /** Markup for inside `<head>` (title, meta, link, script). */
-    headTags: string;
-    /** Attribute string for the `<html>` tag (leading space included). */
-    htmlAttrs: string;
-    /** Attribute string for the `<body>` tag (leading space included). */
-    bodyAttrs: string;
-}
+export type LayoutHandler = (children: Island<any>) => Island<any>;
+export type ErrorHandler = (error: AppError, route: RouteSnapshot) => Island<any>;
 export interface LoaderContext {
     params: Record<string, string>;
     request: Request;
@@ -74,8 +45,15 @@ export declare function loader<T>(fn: Loader<T>): Loader<T>;
 export declare namespace loader {
     var client: <T>(fn: Loader<T>) => Loader<T>;
 }
-/** Extract the return type of a loader. */
-export type InferLoader<L> = L extends Loader<infer T> ? Awaited<T> : never;
+/** Infer the page props produced by a loader. */
+export type InferLoader<L> = L extends Loader<infer T> ? {
+    load: {
+        loading: boolean;
+        value: Awaited<T>;
+        error: Error | undefined;
+    };
+} : never;
+type InferLoaderValue<L> = L extends Loader<infer T> ? Awaited<T> : never;
 /**
  * Merge multiple loader return types into a single object type.
  * Later loaders override earlier ones on key collision — matching runtime merge.
@@ -86,7 +64,7 @@ export type InferLoader<L> = L extends Loader<infer T> ? Awaited<T> : never;
 export type MergeLoaders<Ls extends readonly Loader<any>[]> = Ls extends readonly [
     infer First extends Loader<any>,
     ...infer Rest extends readonly Loader<any>[]
-] ? Rest extends readonly [] ? InferLoader<First> : Omit<InferLoader<First>, keyof MergeLoaders<Rest>> & MergeLoaders<Rest> : {};
+] ? Rest extends readonly [] ? InferLoaderValue<First> : Omit<InferLoaderValue<First>, keyof MergeLoaders<Rest>> & MergeLoaders<Rest> : {};
 export declare class Redirect {
     readonly __ilhaRedirect: true;
     readonly to: string;
@@ -111,8 +89,8 @@ export declare function error(status: number, message: string): never;
  * `Redirect` or `LoaderError`, the composed loader re-throws it unchanged.
  */
 export declare function composeLoaders<Ls extends readonly Loader<any>[]>(loaders: Ls): Loader<MergeLoaders<Ls>>;
-export declare function wrapLayout(layout: LayoutHandler, page: Island<any, any>): Island<any, any>;
-export declare function wrapError(handler: ErrorHandler, page: Island<any, any>): Island<any, any>;
+export declare function wrapLayout(layout: LayoutHandler, page: Island<any>): Island<any>;
+export declare function wrapError(handler: ErrorHandler, page: Island<any>): Island<any>;
 export declare function defineLayout(layout: LayoutHandler): LayoutHandler;
 export interface NavigateOptions {
     replace?: boolean;
@@ -144,7 +122,7 @@ export interface RouterOptions {
      * Island rendered when no route matches the current URL — both on the
      * server (with a 404 status) and in the client `RouterView`.
      */
-    notFound?: Island<any, any>;
+    notFound?: Island<any>;
     /**
      * Allow loader `redirect()` targets pointing at other origins. When `false`
      * (default), absolute cross-origin redirect targets are rejected with a 500
@@ -184,7 +162,7 @@ export interface HydrateOptions {
 }
 export interface MountOptions {
     hydrate?: boolean;
-    registry?: Record<string, Island<any, any>>;
+    registry?: Record<string, Island<any>>;
     /**
      * When `true` (default), internal `<a>` clicks are intercepted for
      * client-side navigation. Set to `false` for MPA-style full-page navigations.
@@ -214,7 +192,7 @@ export interface RouterBuilder {
      * (layout loaders outer→inner followed by the page loader) produced by
      * the FS-routing codegen.
      */
-    route(pattern: string, island: Island<any, any>, loader?: Loader<any>): RouterBuilder;
+    route(pattern: string, island: Island<any>, loader?: Loader<any>): RouterBuilder;
     /**
      * Attach (or replace) a loader on an already-registered route pattern.
      * Used by the `ilha:loaders` virtual module to wire server-only loaders
@@ -253,13 +231,13 @@ export interface RouterBuilder {
     prime(): void;
     mount(target: string | Element, options?: MountOptions): () => void;
     render(url: string | URL): string;
-    renderHydratable(urlOrRequest: string | URL | Request, registry: Record<string, Island<any, any>>, options?: HydratableRenderOptions, request?: Request): Promise<string>;
+    renderHydratable(urlOrRequest: string | URL | Request, registry: Record<string, Island<any>>, options?: HydratableRenderOptions, request?: Request): Promise<string>;
     /**
      * Like `renderHydratable` but surfaces loader redirects and errors as
      * structured responses instead of baking them into HTML. Prefer this from
      * host server code so you can emit proper 302 / 4xx responses.
      */
-    renderResponse(urlOrRequest: string | URL | Request, registry: Record<string, Island<any, any>>, options?: HydratableRenderOptions, request?: Request): Promise<RenderResponse>;
+    renderResponse(urlOrRequest: string | URL | Request, registry: Record<string, Island<any>>, options?: HydratableRenderOptions, request?: Request): Promise<RenderResponse>;
     /**
      * Run the loader chain for a given URL without rendering. Backs the
      * `/__ilha/loader` endpoint that the host server handler
@@ -286,20 +264,20 @@ export interface RouterBuilder {
      * loader errors, and security headers. `request` (or a URL string) selects
      * the route; the optional `shell` injects `head` tags into a document.
      */
-    respond(urlOrRequest: string | URL | Request, registry: Record<string, Island<any, any>>, options?: RespondOptions): Promise<Response>;
+    respond(urlOrRequest: string | URL | Request, registry: Record<string, Island<any>>, options?: RespondOptions): Promise<Response>;
     /**
      * Hydrate the application - combines prime(), mount(), and router.mount() into one call.
      * @param registry - The island registry from ilha:registry
      * @param options - Optional root element (defaults to document.body) and router target (defaults to root)
      * @returns Cleanup function
      */
-    hydrate(registry: Record<string, Island<any, any>>, options?: HydrateOptions): () => void;
+    hydrate(registry: Record<string, Island<any>>, options?: HydrateOptions): () => void;
     /**
      * Hydrate islands on the current pre-rendered page without mounting a route
      * view or enabling client navigation. Intended for `static` mode: each page
      * is a self-contained HTML file; only interactive islands need activation.
      */
-    hydrateStatic(registry: Record<string, Island<any, any>>, options?: {
+    hydrateStatic(registry: Record<string, Island<any>>, options?: {
         root?: Element;
     }): () => void;
 }
@@ -311,9 +289,13 @@ export declare const LOADER_ENDPOINT = "/__ilha/loader";
  * navigation) or is superseded by another prefetch.
  */
 export declare function prefetch(pathWithSearch: string): void;
+/** @internal Internal reactive route-state accessor; use the aggregate `useRoute()` for the public surface. */
 export declare function routePath(value?: string): string;
+/** @internal Internal reactive route-state accessor; use the aggregate `useRoute()` for the public surface. */
 export declare function routeParams(value?: Record<string, string>): Record<string, string>;
+/** @internal Internal reactive route-state accessor; use the aggregate `useRoute()` for the public surface. */
 export declare function routeSearch(value?: string): string;
+/** @internal Internal reactive route-state accessor; use the aggregate `useRoute()` for the public surface. */
 export declare function routeHash(value?: string): string;
 /** Reactive: `true` while a client navigation (loader fetch + view swap) is in flight. */
 export declare function navigating(): boolean;
@@ -390,12 +372,11 @@ export interface LinkInterceptionOptions {
     prefetch?: boolean;
 }
 export declare function enableLinkInterception(root?: Element | Document, options?: LinkInterceptionOptions): () => void;
-export declare const RouterView: Island<{
-    [x: string]: unknown;
-}, {}>;
+export declare const RouterView: Island<unknown>;
 export declare const RouterLink: Island<{
-    [x: string]: unknown;
-}, Omit<Omit<{}, K> & Record<"href", string>, "label"> & Record<"label", string>>;
+    href?: string;
+    label?: string;
+}>;
 export interface IsActiveOptions {
     /**
      * When `false`, `isActive("/docs")` also matches nested paths like
@@ -405,43 +386,6 @@ export interface IsActiveOptions {
     exact?: boolean;
 }
 export declare function isActive(pattern: string, options?: IsActiveOptions): boolean;
-/**
- * Contribute `<head>` data from inside an island's `.render()` body or a
- * layout. During SSR this collects into the active render window; on the
- * client, entries are collected when the router re-renders a route inside
- * `withHeadStore` and then applied to `document`. Prefer a loader's `ctx.head`
- * for data that depends on the request.
- */
-export declare function head(input: HeadInput): void;
-/**
- * Merge head entries in contribution order (loader first as the base, then
- * render-time outer→inner layouts, then the page) and serialize. Later entries
- * win on collision; the last `titleTemplate` wraps the resolved title.
- */
-export declare function serializeHead(entries: HeadInput[]): SerializedHead;
-export interface HttpResponseOptions {
-    status?: number;
-    headers?: HeadersInit;
-    /**
-     * CSP nonce for inline scripts. When set (and `contentSecurityPolicy` is
-     * not), a conservative default CSP is emitted with `'nonce-${nonce}'` for
-     * `script-src` — pass the same nonce to head `<script nonce=…>` tags.
-     */
-    cspNonce?: string;
-    /** Full `Content-Security-Policy` string; overrides the nonce-derived default. */
-    contentSecurityPolicy?: string;
-}
-/**
- * Build an HTTP `Response` for SSR output with sensible security headers:
- * `Content-Type: text/html`, `X-Content-Type-Options: nosniff`,
- * `Referrer-Policy`, `Cache-Control: no-store`, and an optional CSP. This is
- * a low-level helper — prefer {@link RouterBuilder.respond} for the full
- * render+head+headers pipeline.
- */
-export declare function httpResponse(body: string | null, options?: HttpResponseOptions): Response;
-/**
- * Options for {@link RouterBuilder.respond}.
- */
 export interface RespondOptions extends HydratableRenderOptions, HttpResponseOptions {
     /**
      * Wrap the rendered body with a document shell. Receives the serialized
@@ -452,9 +396,10 @@ export interface RespondOptions extends HydratableRenderOptions, HttpResponseOpt
 }
 /**
  * Validate a loader redirect target. Relative paths always pass; same-origin
- * absolute URLs collapse to a path; cross-origin targets are rejected unless
- * `allowExternal`. Protocol-relative (`//host`) and unparsable targets are
- * always rejected.
+ * absolute URLs collapse to a path; cross-origin targets (including
+ * protocol-relative `//host` URLs) are rejected unless `allowExternal` is set.
+ * Non-http(s) schemes, backslash/control-char smuggling, and unparsable
+ * targets are always rejected.
  */
 export declare function resolveRedirectTarget(to: string, base: URL, allowExternal: boolean): {
     ok: true;
@@ -473,12 +418,11 @@ declare const _default: {
     prefetch: typeof prefetch;
     beforeNavigate: typeof beforeNavigate;
     afterNavigate: typeof afterNavigate;
-    RouterView: Island<{
-        [x: string]: unknown;
-    }, {}>;
+    RouterView: Island<unknown>;
     RouterLink: Island<{
-        [x: string]: unknown;
-    }, Omit<Omit<{}, K> & Record<"href", string>, "label"> & Record<"label", string>>;
+        href?: string;
+        label?: string;
+    }>;
     loader: typeof loader;
     redirect: typeof redirect;
     error: typeof error;
@@ -486,3 +430,5 @@ declare const _default: {
     head: typeof head;
 };
 export default _default;
+export { head, serializeHead, type HeadInput, type SerializedHead } from "./head";
+export { httpResponse, type HttpResponseOptions } from "./http";

package/dist/index.js

@@ -1,3 +1,4 @@
-import { A as useContext, C as routeHash, D as router, E as routeSearch, L as getHistoryMode, M as wrapError, N as wrapLayout, O as serializeHead, R as setHistoryMode, S as resolveRedirectTarget, T as routePath, _ as navigate, a as RouterView, b as prime, c as composeLoaders, d as error, f as head, g as loader, h as isActive, i as RouterLink, j as useRoute, k as src_default, l as defineLayout, m as invalidate, n as LoaderError, o as afterNavigate, p as httpResponse, r as Redirect, s as beforeNavigate, t as LOADER_ENDPOINT, u as enableLinkInterception, v as navigating, w as routeParams, x as redirect, y as prefetch } from "./src-BBsbD5vU.js";
+import { A as wrapLayout, C as routePath, D as useContext, E as src_default, F as getHistoryMode, I as setHistoryMode, O as useRoute, P as httpResponse, S as routeParams, T as router, _ as prefetch, a as RouterView, b as resolveRedirectTarget, c as composeLoaders, d as error, f as invalidate, g as navigating, h as navigate, i as RouterLink, k as wrapError, l as defineLayout, m as loader, n as LoaderError, o as afterNavigate, p as isActive, r as Redirect, s as beforeNavigate, t as LOADER_ENDPOINT, u as enableLinkInterception, v as prime, w as routeSearch, x as routeHash, y as redirect } from "./src-B5dHU24f.js";
+import { o as head, s as serializeHead } from "./snapshot-CsEaY6h_.js";
 
 export { LOADER_ENDPOINT, LoaderError, Redirect, RouterLink, RouterView, afterNavigate, beforeNavigate, composeLoaders, src_default as default, defineLayout, enableLinkInterception, error, getHistoryMode, head, httpResponse, invalidate, isActive, loader, navigate, navigating, prefetch, prime, redirect, resolveRedirectTarget, routeHash, routeParams, routePath, routeSearch, router, serializeHead, setHistoryMode, useContext, useRoute, wrapError, wrapLayout };