@ilha/router 0.2.5 → 0.3.0

package/README.md

@@ -75,6 +75,65 @@ pageRouter.hydrate(registry);
 
 ---
 
+## Hash mode
+
+By default, the router uses the HTML5 History API and treats `location.pathname` as the route. This requires either a server that serves the SPA shell at every URL, or a static host with a SPA fallback. When neither is available — the document is loaded over `file://`, embedded in a desktop wrapper like Electron or Electrobun, opened directly from disk, or served from a host that can't be configured for SPA fallbacks — switch to **hash mode**, which stores the route in `location.hash`:
+
+```ts
+import { setHistoryMode, router } from "@ilha/router";
+
+setHistoryMode("hash"); // ← call once, before mounting
+
+router().route("/", homePage).route("/about", aboutPage).route("/user/:id", userPage).mount("#app");
+```
+
+`setHistoryMode("hash")` must be called **before** `.mount()`, `.hydrate()`, or `prime()`. Once set, every navigation API in this package — `navigate()`, `RouterLink`, `enableLinkInterception()`, popstate handling — operates against `location.hash` instead of `location.pathname`.
+
+URLs in hash mode look like:
+
+```
+file:///path/to/index.html#/
+file:///path/to/index.html#/about
+file:///path/to/index.html#/user/42?tab=overview
+file:///path/to/index.html#/docs/intro#section
+```
+
+The portion after the `#` is parsed as if it were a real URL — the path comes first, followed by an optional query string and an optional in-page anchor. `routeHash()` returns the in-hash anchor (`#section`), so in-page anchor links keep working alongside hash routing.
+
+### Links
+
+Both forms work — pick whichever is easier in your code:
+
+```html
+<a href="/about">About</a>
+<!-- plain path — preferred for shared code -->
+<a href="#/about">About</a>
+<!-- explicit hash form — also intercepted -->
+```
+
+`<RouterLink>` automatically renders the hash form (`<a href="#/about">`) in hash mode, so right-click → copy link gives a working URL.
+
+In-page anchor links (`<a href="#section">`) are not intercepted — they behave as normal browser anchors. Only links beginning with `#/` (a slash after the hash) are treated as in-app navigations.
+
+### What's not supported in hash mode
+
+**SSR + hydration.** The hash is never sent to the server, so it cannot pre-render the active route. Calling `mount({ hydrate: true })` or `.hydrate(registry)` while in hash mode logs a warning. Use plain SPA mode for hash-mode apps:
+
+```ts
+setHistoryMode("hash");
+pageRouter.mount("#app"); // ← no { hydrate: true }
+```
+
+You can still register loaders, but they run on the client (via the loader endpoint or by calling `runLoader()` yourself) — there is no server-rendered initial state.
+
+**Per-router mode.** History mode is process-global, not per-builder. This is intentional: `navigate()`, `RouterLink`, and `prefetch()` are module-level and would otherwise need explicit instance threading. If your app needs both modes simultaneously, that's not a use case this router supports.
+
+### Switching modes
+
+`setHistoryMode()` can be called more than once, but listeners registered before a switch keep using their original adapter until the router is unmounted and remounted. In practice, set the mode once at app entry and leave it alone.
+
+---
+
 ## Core API
 
 ### `router()`
@@ -136,6 +195,8 @@ unmount();
 
 When `hydrate: true`, `.mount()` does **not** wipe existing SSR HTML. It instead mounts a hidden navigation handler that re-renders routes with hydration on subsequent navigations.
 
+> Combining `hydrate: true` with hash mode logs a warning — hash routes are never visible to the server, so SSR can't pre-render them. Use plain SPA mode (no `hydrate`) for hash-mode apps.
+
 No-op with a console warning when called outside a browser environment.
 
 ---
@@ -253,6 +314,8 @@ pageRouter.hydrate(registry, {
 
 Returns an `unmount` function that tears down all listeners and hydrated islands.
 
+> `.hydrate()` is for SSR + history-mode apps. In hash mode, use plain `.mount("#app")` instead — the server has no visibility into hash routes, so there's nothing to hydrate against.
+
 ---
 
 #### `.attachLoader(pattern, loader)` — runtime
@@ -265,6 +328,21 @@ router().route("/user/:id", userPage).attachLoader("/user/:id", serverLoader);
 
 ---
 
+### `setHistoryMode(mode)` · `getHistoryMode()`
+
+Selects the history strategy used by the router. Defaults to `"history"` (HTML5 History API, reads/writes `location.pathname`). Set to `"hash"` to store the route in `location.hash` instead — see the [Hash mode](#hash-mode) section above for when to use it.
+
+```ts
+import { setHistoryMode, getHistoryMode } from "@ilha/router";
+
+setHistoryMode("hash");
+getHistoryMode(); // → "hash"
+```
+
+The mode is process-global. Call `setHistoryMode()` once at app entry, before any `.mount()`, `.hydrate()`, or `prime()` call.
+
+---
+
 ### `navigate(to, options?)`
 
 Programmatically navigate to a path. Updates the URL, history stack, and all reactive signals. Duplicate navigations (same URL) are no-ops.
@@ -276,6 +354,8 @@ navigate("/about");
 navigate("/about", { replace: true }); // replaces instead of pushing
 ```
 
+In hash mode, `navigate("/about")` writes `#/about` into `location.hash`. The argument is always the logical path — no need to prefix it with `#`.
+
 No-op on the server.
 
 ---
@@ -583,6 +663,8 @@ interface HydrateOptions {
   target?: string | Element;
 }
 
+type HistoryMode = "history" | "hash";
+
 // Helper — returns fn as-is with LayoutHandler type enforced
 function defineLayout(fn: LayoutHandler): LayoutHandler;
 
@@ -597,6 +679,10 @@ function error(status: number, message: string): never;
 
 // Merges loaders — later loaders win on key collision
 function composeLoaders<Ls extends readonly Loader<any>[]>(loaders: Ls): Loader<MergeLoaders<Ls>>;
+
+// Selects the history strategy. Default: "history". Call before .mount() / .hydrate().
+function setHistoryMode(mode: HistoryMode): void;
+function getHistoryMode(): HistoryMode;
 ```
 
 ---

package/dist/index-BsCpWQzC.d.ts

@@ -0,0 +1,254 @@
+import { HydratableOptions, Island } from "ilha";
+
+//#region src/hash.d.ts
+type HistoryMode = "history" | "hash";
+/**
+ * Set the router's history mode. Call this once at app entry, before
+ * mounting any router. Defaults to "history" (HTML5 History API).
+ *
+ * Use "hash" when the document is loaded over file:// (Electron, Tauri, etc.)
+ * or any time there's no server able to serve a SPA fallback at arbitrary
+ * pathnames.
+ *
+ * Switching modes mid-session is supported but not common — listeners
+ * registered before the switch will keep using their original adapter
+ * until they're re-attached (typically by unmounting and remounting
+ * the router).
+ */
+declare function setHistoryMode(mode: HistoryMode): void;
+declare function getHistoryMode(): HistoryMode;
+//#endregion
+//#region src/index.d.ts
+interface RouteRecord {
+  pattern: string;
+  island: Island<any, any>;
+  /** Merged loader chain (layouts outer→inner, then page) — `undefined` if no loaders. */
+  loader?: Loader<any>;
+}
+interface RouteSnapshot {
+  path: string;
+  params: Record<string, string>;
+  search: string;
+  hash: string;
+}
+interface AppError {
+  message: string;
+  status?: number;
+  stack?: string;
+}
+type LayoutHandler = (children: Island<any, any>) => Island<any, any>;
+type ErrorHandler = (error: AppError, route: RouteSnapshot) => Island<any, any>;
+interface LoaderContext {
+  params: Record<string, string>;
+  request: Request;
+  url: URL;
+  signal: AbortSignal;
+}
+type Loader<T> = (ctx: LoaderContext) => Promise<T> | T;
+/**
+ * Identity function for declaring a loader. Exists purely as a type anchor and
+ * a marker for the Vite plugin to detect by export name.
+ */
+declare function loader<T>(fn: Loader<T>): Loader<T>;
+/** Extract the return type of a loader. */
+type InferLoader<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.
+ *
+ * @example
+ * type PageInput = MergeLoaders<[typeof rootLayoutLoad, typeof sectionLayoutLoad, typeof pageLoad]>;
+ */
+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> : {};
+declare class Redirect {
+  readonly __ilhaRedirect: true;
+  readonly to: string;
+  readonly status: number;
+  constructor(to: string, status?: number);
+}
+declare class LoaderError {
+  readonly __ilhaLoaderError: true;
+  readonly status: number;
+  readonly message: string;
+  constructor(status: number, message: string);
+}
+declare function redirect(to: string, status?: number): never;
+declare function error(status: number, message: string): never;
+/**
+ * Compose a list of loaders into a single loader. Later loaders win on key
+ * collision (page loader overrides layout loader for the same key). All loaders
+ * run concurrently within a chain since they share the same abort signal and
+ * request — re-fetching is cheap with a request-scoped cache (future work).
+ *
+ * For v1 we run them in parallel via `Promise.all`. If a loader throws a
+ * `Redirect` or `LoaderError`, the composed loader re-throws it unchanged.
+ */
+declare function composeLoaders<Ls extends readonly Loader<any>[]>(loaders: Ls): Loader<MergeLoaders<Ls>>;
+declare function wrapLayout(layout: LayoutHandler, page: Island<any, any>): Island<any, any>;
+declare function wrapError(handler: ErrorHandler, page: Island<any, any>): Island<any, any>;
+declare function defineLayout(layout: LayoutHandler): LayoutHandler;
+interface NavigateOptions {
+  replace?: boolean;
+}
+interface HydratableRenderOptions extends Partial<Omit<HydratableOptions, "name">> {}
+interface HydrateOptions {
+  root?: Element;
+  target?: string | Element;
+}
+interface MountOptions {
+  hydrate?: boolean;
+  registry?: Record<string, Island<any, any>>;
+}
+/** Response envelope returned by `renderResponse` — lets the host app handle redirects. */
+type RenderResponse = {
+  kind: "html";
+  html: string;
+  status?: number;
+} | {
+  kind: "redirect";
+  to: string;
+  status: number;
+} | {
+  kind: "error";
+  status: number;
+  message: string;
+  html: string;
+};
+interface RouterBuilder {
+  /**
+   * Register a route. The optional `loader` is the merged loader chain
+   * (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;
+  /**
+   * Attach (or replace) a loader on an already-registered route pattern.
+   * Used by the `ilha:loaders` virtual module to wire server-only loaders
+   * onto the client-safe `pageRouter` at SSR time. No-op if the pattern
+   * was never registered via `.route()`.
+   */
+  attachLoader(pattern: string, loader: Loader<any>): RouterBuilder;
+  prime(): void;
+  mount(target: string | Element, options?: MountOptions): () => void;
+  render(url: string | URL): string;
+  renderHydratable(url: string | URL, registry: Record<string, Island<any, 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(url: string | URL, registry: Record<string, Island<any, any>>, options?: HydratableRenderOptions, request?: Request): Promise<RenderResponse>;
+  /**
+   * Run the loader chain for a given URL without rendering. Used by the
+   * `/__ilha/loader` endpoint the Vite plugin exposes for client-side
+   * navigation. Returns the raw loader result, a redirect sentinel, or an
+   * error sentinel.
+   */
+  runLoader(url: string | URL, request?: Request): Promise<{
+    kind: "data";
+    data: Record<string, unknown>;
+  } | {
+    kind: "redirect";
+    to: string;
+    status: number;
+  } | {
+    kind: "error";
+    status: number;
+    message: string;
+  } | {
+    kind: "not-found";
+  }>;
+  /**
+   * 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;
+}
+/** Path of the loader endpoint served by the Vite plugin / production adapter. */
+declare const LOADER_ENDPOINT = "/__ilha/loader";
+/**
+ * Prefetch loader data for a given path. Safe to call repeatedly — a single
+ * inflight request is reused until it either resolves (and is consumed by
+ * navigation) or is superseded by another prefetch.
+ */
+declare function prefetch(pathWithSearch: string): void;
+declare const routePath: {
+  (): string;
+  (value: string): void;
+};
+declare const routeParams: {
+  (): Record<string, string>;
+  (value: Record<string, string>): void;
+};
+declare const routeSearch: {
+  (): string;
+  (value: string): void;
+};
+declare const routeHash: {
+  (): string;
+  (value: string): void;
+};
+declare function useRoute(): {
+  path: {
+    (): string;
+    (value: string): void;
+  };
+  params: {
+    (): Record<string, string>;
+    (value: Record<string, string>): void;
+  };
+  search: {
+    (): string;
+    (value: string): void;
+  };
+  hash: {
+    (): string;
+    (value: string): void;
+  };
+};
+/**
+ * Prime route context signals from the current `location` so that islands
+ * hydrated by `ilha.mount()` see the correct route values on their first
+ * render — preventing a mismatch morph that would destroy hydrated bindings.
+ */
+declare function prime(): void;
+declare function navigate(to: string, opts?: NavigateOptions): void;
+interface LinkInterceptionOptions {
+  /**
+   * Prefetch loader data on `mouseenter` for eligible links. Links opt in via
+   * the `data-prefetch` attribute (set `data-prefetch="false"` to opt out a
+   * specific link even when the framework is configured to prefetch by default).
+   * Default: `true` — prefetches on hover for any link with `data-prefetch`.
+   */
+  prefetch?: boolean;
+}
+declare function enableLinkInterception(root?: Element | Document, options?: LinkInterceptionOptions): () => void;
+declare const RouterView: Island<Record<string, unknown>, Record<string, never>>;
+declare const RouterLink: Island<Record<string, unknown>, {
+  [x: string]: never;
+  href: string;
+} & Record<"label", string>>;
+declare function isActive(pattern: string): boolean;
+declare function router(): RouterBuilder;
+declare const _default: {
+  router: typeof router;
+  navigate: typeof navigate;
+  useRoute: typeof useRoute;
+  isActive: typeof isActive;
+  enableLinkInterception: typeof enableLinkInterception;
+  prime: typeof prime;
+  prefetch: typeof prefetch;
+  RouterView: Island<Record<string, unknown>, Record<string, never>>;
+  RouterLink: Island<Record<string, unknown>, {
+    [x: string]: never;
+    href: string;
+  } & Record<"label", string>>;
+  loader: typeof loader;
+  redirect: typeof redirect;
+  error: typeof error;
+  composeLoaders: typeof composeLoaders;
+};
+//#endregion
+export { prefetch as A, wrapLayout as B, composeLoaders as C, isActive as D, error as E, routePath as F, getHistoryMode as H, routeSearch as I, router as L, redirect as M, routeHash as N, loader as O, routeParams as P, useRoute as R, _default as S, enableLinkInterception as T, setHistoryMode as U, HistoryMode as V, RouteRecord as _, InferLoader as a, RouterLink as b, LinkInterceptionOptions as c, LoaderError as d, MergeLoaders as f, RenderResponse as g, Redirect as h, HydrateOptions as i, prime as j, navigate as k, Loader as l, NavigateOptions as m, ErrorHandler as n, LOADER_ENDPOINT as o, MountOptions as p, HydratableRenderOptions as r, LayoutHandler as s, AppError as t, LoaderContext as u, RouteSnapshot as v, defineLayout as w, RouterView as x, RouterBuilder as y, wrapError as z };

package/dist/index.d.ts

@@ -1,236 +1,2 @@
-import { HydratableOptions, Island } from "ilha";
-
-//#region src/index.d.ts
-interface RouteRecord {
-  pattern: string;
-  island: Island<any, any>;
-  /** Merged loader chain (layouts outer→inner, then page) — `undefined` if no loaders. */
-  loader?: Loader<any>;
-}
-interface RouteSnapshot {
-  path: string;
-  params: Record<string, string>;
-  search: string;
-  hash: string;
-}
-interface AppError {
-  message: string;
-  status?: number;
-  stack?: string;
-}
-type LayoutHandler = (children: Island<any, any>) => Island<any, any>;
-type ErrorHandler = (error: AppError, route: RouteSnapshot) => Island<any, any>;
-interface LoaderContext {
-  params: Record<string, string>;
-  request: Request;
-  url: URL;
-  signal: AbortSignal;
-}
-type Loader<T> = (ctx: LoaderContext) => Promise<T> | T;
-/**
- * Identity function for declaring a loader. Exists purely as a type anchor and
- * a marker for the Vite plugin to detect by export name.
- */
-declare function loader<T>(fn: Loader<T>): Loader<T>;
-/** Extract the return type of a loader. */
-type InferLoader<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.
- *
- * @example
- * type PageInput = MergeLoaders<[typeof rootLayoutLoad, typeof sectionLayoutLoad, typeof pageLoad]>;
- */
-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> : {};
-declare class Redirect {
-  readonly __ilhaRedirect: true;
-  readonly to: string;
-  readonly status: number;
-  constructor(to: string, status?: number);
-}
-declare class LoaderError {
-  readonly __ilhaLoaderError: true;
-  readonly status: number;
-  readonly message: string;
-  constructor(status: number, message: string);
-}
-declare function redirect(to: string, status?: number): never;
-declare function error(status: number, message: string): never;
-/**
- * Compose a list of loaders into a single loader. Later loaders win on key
- * collision (page loader overrides layout loader for the same key). All loaders
- * run concurrently within a chain since they share the same abort signal and
- * request — re-fetching is cheap with a request-scoped cache (future work).
- *
- * For v1 we run them in parallel via `Promise.all`. If a loader throws a
- * `Redirect` or `LoaderError`, the composed loader re-throws it unchanged.
- */
-declare function composeLoaders<Ls extends readonly Loader<any>[]>(loaders: Ls): Loader<MergeLoaders<Ls>>;
-declare function wrapLayout(layout: LayoutHandler, page: Island<any, any>): Island<any, any>;
-declare function wrapError(handler: ErrorHandler, page: Island<any, any>): Island<any, any>;
-declare function defineLayout(layout: LayoutHandler): LayoutHandler;
-interface NavigateOptions {
-  replace?: boolean;
-}
-interface HydratableRenderOptions extends Partial<Omit<HydratableOptions, "name">> {}
-interface HydrateOptions {
-  root?: Element;
-  target?: string | Element;
-}
-interface MountOptions {
-  hydrate?: boolean;
-  registry?: Record<string, Island<any, any>>;
-}
-/** Response envelope returned by `renderResponse` — lets the host app handle redirects. */
-type RenderResponse = {
-  kind: "html";
-  html: string;
-  status?: number;
-} | {
-  kind: "redirect";
-  to: string;
-  status: number;
-} | {
-  kind: "error";
-  status: number;
-  message: string;
-  html: string;
-};
-interface RouterBuilder {
-  /**
-   * Register a route. The optional `loader` is the merged loader chain
-   * (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;
-  /**
-   * Attach (or replace) a loader on an already-registered route pattern.
-   * Used by the `ilha:loaders` virtual module to wire server-only loaders
-   * onto the client-safe `pageRouter` at SSR time. No-op if the pattern
-   * was never registered via `.route()`.
-   */
-  attachLoader(pattern: string, loader: Loader<any>): RouterBuilder;
-  prime(): void;
-  mount(target: string | Element, options?: MountOptions): () => void;
-  render(url: string | URL): string;
-  renderHydratable(url: string | URL, registry: Record<string, Island<any, 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(url: string | URL, registry: Record<string, Island<any, any>>, options?: HydratableRenderOptions, request?: Request): Promise<RenderResponse>;
-  /**
-   * Run the loader chain for a given URL without rendering. Used by the
-   * `/__ilha/loader` endpoint the Vite plugin exposes for client-side
-   * navigation. Returns the raw loader result, a redirect sentinel, or an
-   * error sentinel.
-   */
-  runLoader(url: string | URL, request?: Request): Promise<{
-    kind: "data";
-    data: Record<string, unknown>;
-  } | {
-    kind: "redirect";
-    to: string;
-    status: number;
-  } | {
-    kind: "error";
-    status: number;
-    message: string;
-  } | {
-    kind: "not-found";
-  }>;
-  /**
-   * 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;
-}
-/** Path of the loader endpoint served by the Vite plugin / production adapter. */
-declare const LOADER_ENDPOINT = "/__ilha/loader";
-/**
- * Prefetch loader data for a given path. Safe to call repeatedly — a single
- * inflight request is reused until it either resolves (and is consumed by
- * navigation) or is superseded by another prefetch.
- */
-declare function prefetch(pathWithSearch: string): void;
-declare const routePath: {
-  (): string;
-  (value: string): void;
-};
-declare const routeParams: {
-  (): Record<string, string>;
-  (value: Record<string, string>): void;
-};
-declare const routeSearch: {
-  (): string;
-  (value: string): void;
-};
-declare const routeHash: {
-  (): string;
-  (value: string): void;
-};
-declare function useRoute(): {
-  path: {
-    (): string;
-    (value: string): void;
-  };
-  params: {
-    (): Record<string, string>;
-    (value: Record<string, string>): void;
-  };
-  search: {
-    (): string;
-    (value: string): void;
-  };
-  hash: {
-    (): string;
-    (value: string): void;
-  };
-};
-/**
- * Prime route context signals from the current `location` so that islands
- * hydrated by `ilha.mount()` see the correct route values on their first
- * render — preventing a mismatch morph that would destroy hydrated bindings.
- */
-declare function prime(): void;
-declare function navigate(to: string, opts?: NavigateOptions): void;
-interface LinkInterceptionOptions {
-  /**
-   * Prefetch loader data on `mouseenter` for eligible links. Links opt in via
-   * the `data-prefetch` attribute (set `data-prefetch="false"` to opt out a
-   * specific link even when the framework is configured to prefetch by default).
-   * Default: `true` — prefetches on hover for any link with `data-prefetch`.
-   */
-  prefetch?: boolean;
-}
-declare function enableLinkInterception(root?: Element | Document, options?: LinkInterceptionOptions): () => void;
-declare const RouterView: Island<Record<string, unknown>, Record<string, never>>;
-declare const RouterLink: Island<Record<string, unknown>, {
-  [x: string]: never;
-  href: string;
-} & Record<"label", string>>;
-declare function isActive(pattern: string): boolean;
-declare function router(): RouterBuilder;
-declare const _default: {
-  router: typeof router;
-  navigate: typeof navigate;
-  useRoute: typeof useRoute;
-  isActive: typeof isActive;
-  enableLinkInterception: typeof enableLinkInterception;
-  prime: typeof prime;
-  prefetch: typeof prefetch;
-  RouterView: Island<Record<string, unknown>, Record<string, never>>;
-  RouterLink: Island<Record<string, unknown>, {
-    [x: string]: never;
-    href: string;
-  } & Record<"label", string>>;
-  loader: typeof loader;
-  redirect: typeof redirect;
-  error: typeof error;
-  composeLoaders: typeof composeLoaders;
-};
-//#endregion
-export { AppError, ErrorHandler, HydratableRenderOptions, HydrateOptions, InferLoader, LOADER_ENDPOINT, LayoutHandler, LinkInterceptionOptions, Loader, LoaderContext, LoaderError, MergeLoaders, MountOptions, NavigateOptions, Redirect, RenderResponse, RouteRecord, RouteSnapshot, RouterBuilder, RouterLink, RouterView, composeLoaders, _default as default, defineLayout, enableLinkInterception, error, isActive, loader, navigate, prefetch, prime, redirect, routeHash, routeParams, routePath, routeSearch, router, useRoute, wrapError, wrapLayout };
+import { A as prefetch, B as wrapLayout, C as composeLoaders, D as isActive, E as error, F as routePath, H as getHistoryMode, I as routeSearch, L as router, M as redirect, N as routeHash, O as loader, P as routeParams, R as useRoute, S as _default, T as enableLinkInterception, U as setHistoryMode, V as HistoryMode, _ as RouteRecord, a as InferLoader, b as RouterLink, c as LinkInterceptionOptions, d as LoaderError, f as MergeLoaders, g as RenderResponse, h as Redirect, i as HydrateOptions, j as prime, k as navigate, l as Loader, m as NavigateOptions, n as ErrorHandler, o as LOADER_ENDPOINT, p as MountOptions, r as HydratableRenderOptions, s as LayoutHandler, t as AppError, u as LoaderContext, v as RouteSnapshot, w as defineLayout, x as RouterView, y as RouterBuilder, z as wrapError } from "./index-BsCpWQzC.js";
+export { AppError, ErrorHandler, HistoryMode, HydratableRenderOptions, HydrateOptions, InferLoader, LOADER_ENDPOINT, LayoutHandler, LinkInterceptionOptions, Loader, LoaderContext, LoaderError, MergeLoaders, MountOptions, NavigateOptions, Redirect, RenderResponse, RouteRecord, RouteSnapshot, RouterBuilder, RouterLink, RouterView, composeLoaders, _default as default, defineLayout, enableLinkInterception, error, getHistoryMode, isActive, loader, navigate, prefetch, prime, redirect, routeHash, routeParams, routePath, routeSearch, router, setHistoryMode, useRoute, wrapError, wrapLayout };