@askrjs/askr 0.2.3 → 0.3.0

package/dist/router/index.d.ts

@@ -1,14 +1,73 @@
-import { $ as AccessAllowDecision, At as RouteRefSearch, Ct as RouteOptions, Dt as RouteQuery, Et as RoutePolicy, Ft as RouteRequestResult, It as RouteSearch, Lt as RouteSearchValue, Mt as RouteRegistryOptions, Nt as RouteRenderResult, Ot as RouteRecord, Pt as RouteRequestOptions, Rt as RouteSnapshot, St as RouteMode, Tt as RoutePathParams, _t as RouteHandler, at as GroupHelperOptions, bt as RouteMeta, cn as RenderableChild, ct as PageScopeRecord, dt as RouteAuthOptions, et as AccessDecision, ft as RouteAuthResolver, gt as RouteDestination, ht as RouteDefinition, it as AccessRedirectStatus, jt as RouteRegistry, kt as RouteRef, lt as ParsedSegment, mt as RouteContext, nt as AccessDenyStatus, ot as LayoutScopeRecord, pt as RouteComponent, rt as AccessRedirectDecision, st as PageHelperOptions, tt as AccessDenyDecision, ut as Route, vt as RouteManifest, wt as RouteParams, xt as RouteMetaSource, yt as RouteMatch } from "../index-DSqXWc77.js";
-import { r as JSXElement, s as Props } from "../types-DkVJhVs9.js";
-import { a as ScrollRestorationOptions, i as NavigationScrollBehavior, n as NavigateOptions, r as HistoryScrollBehavior, t as navigate } from "../navigate-wel1e6cU.js";
-import { i as onRouteChange, n as RouteChangeOptions, r as currentRoute, t as RouteChangeCleanup } from "../activity-CAJ5eho-.js";
-import { AuthContext, AuthContext as AuthContext$1, AuthRequirement, AuthRequirement as AuthRequirement$1 } from "@askrjs/auth";
-import { ObjectSchema } from "@askrjs/schema";
-//#region src/router/route-query.d.ts
+import {
+  RouteSnapshot,
+  RouteDefinition,
+  RoutePathParams,
+  RenderableChild,
+  PageScopeRecord,
+  RouteAuthResolver,
+  RouteAuthOptions,
+  RouteMeta,
+  RouteRefSearch,
+  RouteQuery,
+  RouteMetaSource,
+  RouteRenderResult,
+  RouteRegistry,
+  RouteMode,
+  RouteHandler,
+  RouteManifest,
+  RouteComponent,
+  RouteMatch,
+  RouteSearchValue,
+  RouteOptions,
+  PageHelperOptions,
+  Route,
+  RouteRecord,
+  RoutePolicy,
+  RouteRef,
+  RouteRequestResult,
+  RouteRequestOptions,
+  RouteSearch,
+  AccessDenyStatus,
+  GroupHelperOptions,
+  AccessDenyDecision,
+  AccessDecision,
+  RouteDestination,
+  RouteContext,
+  AccessAllowDecision,
+  RouteRegistryOptions,
+  AccessRedirectDecision,
+  ParsedSegment,
+  LayoutScopeRecord,
+  AccessRedirectStatus,
+  RouteParams,
+} from '../core.js';
+import { JSXElement, Props } from '../elements.js';
+import {
+  ScrollRestorationOptions,
+  NavigationScrollBehavior,
+  NavigateOptions,
+  HistoryScrollBehavior,
+  navigate,
+} from '../navigation.js';
+import {
+  onRouteChange,
+  RouteChangeOptions,
+  currentRoute,
+  RouteChangeCleanup,
+} from '../route-activity.js';
+import {
+  AuthContext,
+  AuthContext as AuthContext$1,
+  AuthRequirement,
+  AuthRequirement as AuthRequirement$1,
+} from '@askrjs/auth';
+import { ObjectSchema } from '@askrjs/schema';
 /** A single query-string value accepted by {@link updateRouteQuery}. */
 type RouteQueryParamValue = string | number | boolean | null | undefined;
 /** A query-string value, or an array of them for a repeated param. */
-type RouteQueryParamInput = RouteQueryParamValue | readonly RouteQueryParamValue[];
+type RouteQueryParamInput =
+  | RouteQueryParamValue
+  | readonly RouteQueryParamValue[];
 /** A map of query param updates for {@link updateRouteQuery}; `null`/`undefined` removes the key. */
 type RouteQueryUpdates = Record<string, RouteQueryParamInput>;
 /** A function that mutates a `URLSearchParams` directly, for {@link updateRouteQuery}. */
@@ -22,78 +81,191 @@ type UpdateRouteQueryOptions = {
   history?: 'push' | 'replace';
   replace?: boolean;
 };
-declare function updateRouteQuery(updates: RouteQueryUpdates | RouteQueryUpdater, options?: UpdateRouteQueryOptions): void;
-//#endregion
-//#region src/router/internal-types.d.ts
+declare function updateRouteQuery(
+  updates: RouteQueryUpdates | RouteQueryUpdater,
+  options?: UpdateRouteQueryOptions
+): void;
 type AnyRouteComponent = (...args: any[]) => RenderableChild;
-//#endregion
-//#region src/router/authoring.d.ts
-type RouteComponentParam<TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? unknown : Parameters<TComponent>[0];
-type CompatibleAbsoluteRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? TComponent : RoutePathParams<Path> extends RouteComponentParam<TComponent> ? TComponent : never;
-type CompatibleRelativeRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Parameters<TComponent> extends [] ? TComponent : RouteComponentParam<TComponent> extends Record<keyof RoutePathParams<Path>, string> ? TComponent : never;
-type CompatibleRouteComponent<Path extends string, TComponent extends AnyRouteComponent> = Path extends `/${string}` ? CompatibleAbsoluteRouteComponent<Path, TComponent> : CompatibleRelativeRouteComponent<Path, TComponent>;
-type RouteOptionsForComponent<Path extends string, TComponent extends AnyRouteComponent, TSearchSchema extends ObjectSchema<RouteSearch> | undefined = ObjectSchema<RouteSearch> | undefined, TLoaderData = unknown, TDehydratedData = TLoaderData> = Parameters<TComponent> extends [] ? RouteOptions<RoutePathParams<Path>, TSearchSchema, TLoaderData, TDehydratedData> : RouteComponentParam<TComponent> extends RouteParams ? RouteOptions<RouteComponentParam<TComponent>, TSearchSchema, TLoaderData, TDehydratedData> : RouteOptions<RoutePathParams<Path>, TSearchSchema, TLoaderData, TDehydratedData>;
+type RouteComponentParam<TComponent extends AnyRouteComponent> =
+  Parameters<TComponent> extends [] ? unknown : Parameters<TComponent>[0];
+type CompatibleAbsoluteRouteComponent<
+  Path extends string,
+  TComponent extends AnyRouteComponent,
+> =
+  Parameters<TComponent> extends []
+    ? TComponent
+    : RoutePathParams<Path> extends RouteComponentParam<TComponent>
+      ? TComponent
+      : never;
+type CompatibleRelativeRouteComponent<
+  Path extends string,
+  TComponent extends AnyRouteComponent,
+> =
+  Parameters<TComponent> extends []
+    ? TComponent
+    : RouteComponentParam<TComponent> extends Record<
+          keyof RoutePathParams<Path>,
+          string
+        >
+      ? TComponent
+      : never;
+type CompatibleRouteComponent<
+  Path extends string,
+  TComponent extends AnyRouteComponent,
+> = Path extends `/${string}`
+  ? CompatibleAbsoluteRouteComponent<Path, TComponent>
+  : CompatibleRelativeRouteComponent<Path, TComponent>;
+type RouteOptionsForComponent<
+  Path extends string,
+  TComponent extends AnyRouteComponent,
+  TSearchSchema extends ObjectSchema<RouteSearch> | undefined =
+    | ObjectSchema<RouteSearch>
+    | undefined,
+  TLoaderData = unknown,
+  TDehydratedData = TLoaderData,
+> =
+  Parameters<TComponent> extends []
+    ? RouteOptions<
+        RoutePathParams<Path>,
+        TSearchSchema,
+        TLoaderData,
+        TDehydratedData
+      >
+    : RouteComponentParam<TComponent> extends RouteParams
+      ? RouteOptions<
+          RouteComponentParam<TComponent>,
+          TSearchSchema,
+          TLoaderData,
+          TDehydratedData
+        >
+      : RouteOptions<
+          RoutePathParams<Path>,
+          TSearchSchema,
+          TLoaderData,
+          TDehydratedData
+        >;
 /** Declare a group of routes sharing `options` (auth, policies, layout, meta). */
 declare function group(options: GroupHelperOptions, fn: RouteDefinition): void;
 /**
  * Declare a route page at `path`, nesting a sub-scope for `index`/`page`/`fallback`
  * declarations and options like `preload`/`meta`/`auth`.
  */
-declare function page<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, fn: RouteDefinition): void;
-declare function page<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, fn: RouteDefinition): void;
-declare function page<const TPath extends string>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options: PageHelperOptions, fn: RouteDefinition): void;
-declare function page<const TPath extends string, TComponent extends AnyRouteComponent>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options: PageHelperOptions, fn: RouteDefinition): void;
+declare function page<const TPath extends string>(
+  path: TPath,
+  Component: RouteComponent<RoutePathParams<TPath>>,
+  fn: RouteDefinition
+): void;
+declare function page<
+  const TPath extends string,
+  TComponent extends AnyRouteComponent,
+>(
+  path: TPath,
+  Component: CompatibleRouteComponent<TPath, TComponent>,
+  fn: RouteDefinition
+): void;
+declare function page<const TPath extends string>(
+  path: TPath,
+  Component: RouteComponent<RoutePathParams<TPath>>,
+  options: PageHelperOptions,
+  fn: RouteDefinition
+): void;
+declare function page<
+  const TPath extends string,
+  TComponent extends AnyRouteComponent,
+>(
+  path: TPath,
+  Component: CompatibleRouteComponent<TPath, TComponent>,
+  options: PageHelperOptions,
+  fn: RouteDefinition
+): void;
 /** Declare the index route for the enclosing `page()` scope. */
 declare function index(Component: RouteComponent, options?: RouteOptions): void;
 /** Declare the catch-all `/*` fallback route for the enclosing scope. */
 declare function fallback(Component: RouteComponent): void;
 /** Declare a route at `path` rendering `Component`, returning a typed {@link RouteRef} for building destinations. */
-declare function route<const TPath extends string, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined, TLoaderData = unknown, TDehydratedData = TLoaderData>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>, TSearchSchema, TLoaderData, TDehydratedData>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
-declare function route<const TPath extends string, TComponent extends AnyRouteComponent, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined, TLoaderData = unknown, TDehydratedData = TLoaderData>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent, TSearchSchema, TLoaderData, TDehydratedData>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
-//#endregion
-//#region src/router/auth.d.ts
+declare function route<
+  const TPath extends string,
+  const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined,
+  TLoaderData = unknown,
+  TDehydratedData = TLoaderData,
+>(
+  path: TPath,
+  Component: RouteComponent<RoutePathParams<TPath>>,
+  options?: RouteOptions<
+    RoutePathParams<TPath>,
+    TSearchSchema,
+    TLoaderData,
+    TDehydratedData
+  >
+): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
+declare function route<
+  const TPath extends string,
+  TComponent extends AnyRouteComponent,
+  const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined,
+  TLoaderData = unknown,
+  TDehydratedData = TLoaderData,
+>(
+  path: TPath,
+  Component: CompatibleRouteComponent<TPath, TComponent>,
+  options?: RouteOptionsForComponent<
+    TPath,
+    TComponent,
+    TSearchSchema,
+    TLoaderData,
+    TDehydratedData
+  >
+): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
 /** Return the identity resolved for the route currently being rendered. */
 declare function currentAuth(): AuthContext$1;
-//#endregion
-//#region src/router/resolution.d.ts
 /** Resolve `target` against a route registry, applying auth/policies to produce a render/redirect/deny result. */
-declare function resolveRouteRequest(target: string, options: RouteRequestOptions): RouteRequestResult | Promise<RouteRequestResult>;
-//#endregion
-//#region src/router/manifest.d.ts
+declare function resolveRouteRequest(
+  target: string,
+  options: RouteRequestOptions
+): RouteRequestResult | Promise<RouteRequestResult>;
 /**
  * Run `definition` to declare routes (via `route`/`page`/`group`/`fallback`)
  * and build a {@link RouteRegistry} to pass to `createSPA`/`hydrateSPA`.
  */
-declare function createRouteRegistry(definition: RouteDefinition, options?: RouteRegistryOptions): RouteRegistry;
-//#endregion
-//#region src/router/lazy.d.ts
+declare function createRouteRegistry(
+  definition: RouteDefinition,
+  options?: RouteRegistryOptions
+): RouteRegistry;
 /** A route component loaded on demand via {@link lazy}, with an explicit `preload()`. */
 type LazyRouteComponent<TComponent extends AnyRouteComponent> = TComponent & {
   preload(): Promise<void>;
 };
 /** A route data loader loaded on demand via {@link lazyRouteData}, with an explicit `preload()`. */
-type LazyRouteDataLoader<TModule, TData = TModule> = ((context: RouteContext & {
-  request?: Request;
-}) => Promise<TData>) & {
+type LazyRouteDataLoader<TModule, TData = TModule> = ((
+  context: RouteContext & {
+    request?: Request;
+  }
+) => Promise<TData>) & {
   preload(): Promise<void>;
 };
 /** Wrap a dynamic-import factory as a {@link LazyRouteComponent}, loaded on first use. */
-declare function lazy<TComponent extends AnyRouteComponent>(factory: () => Promise<{
-  default: TComponent;
-} | TComponent>): LazyRouteComponent<TComponent>;
+declare function lazy<TComponent extends AnyRouteComponent>(
+  factory: () => Promise<
+    | {
+        default: TComponent;
+      }
+    | TComponent
+  >
+): LazyRouteComponent<TComponent>;
 /**
  * Create a cached route loader backed by a dynamic import. The module is only
  * requested when the owning route matches, unless preload() is called.
  */
-declare function lazyRouteData<TModule, TData = TModule>(factory: () => PromiseLike<TModule>, select?: (module: TModule, context: RouteContext & {
-  request?: Request;
-}) => TData | PromiseLike<TData>): LazyRouteDataLoader<TModule, TData>;
-//#endregion
-//#region src/router/rendering.d.ts
+declare function lazyRouteData<TModule, TData = TModule>(
+  factory: () => PromiseLike<TModule>,
+  select?: (
+    module: TModule,
+    context: RouteContext & {
+      request?: Request;
+    }
+  ) => TData | PromiseLike<TData>
+): LazyRouteDataLoader<TModule, TData>;
 /** Renders the nested route content for the enclosing layout or page scope. */
 declare function Outlet(): JSXElement;
-//#endregion
-//#region src/router/route-data-loader.d.ts
 /** Which environment a route's data loader ran (or failed) in. */
 type RouteDataLoadPhase = 'client' | 'server' | 'ssg';
 /** Thrown when a route's `loader` rejects; wraps the original `cause`. */
@@ -103,15 +275,16 @@ declare class RouteDataLoadError extends Error {
   readonly cause: unknown;
   constructor(route: string, phase: RouteDataLoadPhase, cause: unknown);
 }
-//#endregion
-//#region src/router/policy.d.ts
 /** Policy decision: allow the route to render. */
 declare function allow(): AccessAllowDecision;
 /** Policy decision: redirect the visitor to `to`. */
-declare function redirect(to: string, init?: {
-  status?: AccessRedirectStatus;
-  replace?: boolean;
-}): AccessRedirectDecision;
+declare function redirect(
+  to: string,
+  init?: {
+    status?: AccessRedirectStatus;
+    replace?: boolean;
+  }
+): AccessRedirectDecision;
 /** Policy decision: deny the request with the given HTTP status. */
 declare function deny(status: AccessDenyStatus): AccessDenyDecision;
 /** Policy decision: deny with 401 Unauthorized. */
@@ -120,20 +293,27 @@ declare function unauthorized(): AccessDenyDecision;
 declare function forbidden(): AccessDenyDecision;
 /** Policy decision: deny with 404 Not Found. */
 declare function notFound(): AccessDenyDecision;
-//#endregion
-//#region src/router/destination.d.ts
 /** Build a {@link RouteDestination} (with a computed `href`) for a {@link RouteRef} and params/search. */
-declare function to$1<TParams extends RouteParams, TSearch extends RouteSearch = RouteSearch>(route: RouteRef<TParams, TSearch>, params: TParams, search?: TSearch): RouteDestination;
-//#endregion
-//#region src/router/metadata.d.ts
+declare function to$1<
+  TParams extends RouteParams,
+  TSearch extends RouteSearch = RouteSearch,
+>(
+  route: RouteRef<TParams, TSearch>,
+  params: TParams,
+  search?: TSearch
+): RouteDestination;
 /** Resolve a route's merged {@link RouteMeta} by running its metadata chain against `context`. */
-declare function resolveRouteMeta(record: RouteRecord, context: RouteContext): Promise<Readonly<RouteMeta>>;
+declare function resolveRouteMeta(
+  record: RouteRecord,
+  context: RouteContext
+): Promise<Readonly<RouteMeta>>;
 /** Replace only Askr-owned head nodes after a successful client navigation. */
-declare function reconcileRouteMeta(meta: Readonly<RouteMeta>, target?: Document): void;
+declare function reconcileRouteMeta(
+  meta: Readonly<RouteMeta>,
+  target?: Document
+): void;
 /** Render a {@link RouteMeta} to the `<title>`/`<meta>`/`<link>`/JSON-LD markup for the document `<head>`. */
 declare function serializeRouteMeta(meta: RouteMeta): string;
-//#endregion
-//#region src/common/deferred-value.d.ts
 declare const DEFERRED_VALUE: unique symbol;
 /** Lifecycle state of a {@link Deferred} value. */
 type DeferredState = 'pending' | 'fulfilled' | 'rejected';
@@ -149,8 +329,6 @@ interface Deferred<T> {
 declare function defer<T>(promise: PromiseLike<T>): Deferred<T>;
 /** Check whether `value` is a {@link Deferred} produced by {@link defer}. */
 declare function isDeferred<T = unknown>(value: unknown): value is Deferred<T>;
-//#endregion
-//#region src/router/deferred.d.ts
 /** Props for {@link Resolve}. */
 interface ResolveProps<T> {
   value: Deferred<T>;
@@ -159,14 +337,24 @@ interface ResolveProps<T> {
   children: (value: T) => RenderableChild;
 }
 /** Recursively await any {@link Deferred} values nested within `input`, returning it once fully resolved. */
-declare function resolveDeferredValues<T>(input: T, signal?: AbortSignal): Promise<T>;
+declare function resolveDeferredValues<T>(
+  input: T,
+  signal?: AbortSignal
+): Promise<T>;
 /** Read the current route's server loader data during render or hydration. */
 declare function routeData<T>(): T;
 /** Render a {@link Deferred} value's fulfilled state, a pending placeholder, or a rejected fallback. */
 declare function Resolve<T>(props: ResolveProps<T>): JSXElement;
-//#endregion
-//#region src/components/link.d.ts
-type LinkBaseProps = Omit<Props, 'children' | 'href' | 'class' | 'rel' | 'target' | 'aria-current' | 'aria-label'> & {
+type LinkBaseProps = Omit<
+  Props,
+  | 'children'
+  | 'href'
+  | 'class'
+  | 'rel'
+  | 'target'
+  | 'aria-current'
+  | 'aria-label'
+> & {
   class?: string;
   children?: RenderableChild;
   /**
@@ -183,7 +371,14 @@ type LinkBaseProps = Omit<Props, 'children' | 'href' | 'class' | 'rel' | 'target
    * Optional aria-current attribute for indicating current page/location.
    * Use "page" for the current page in navigation.
    */
-  'aria-current'?: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+  'aria-current'?:
+    | 'page'
+    | 'step'
+    | 'location'
+    | 'date'
+    | 'time'
+    | 'true'
+    | 'false';
   /**
    * Optional aria-label for accessibility when link text isn't descriptive enough.
    */
@@ -192,13 +387,17 @@ type LinkBaseProps = Omit<Props, 'children' | 'href' | 'class' | 'rel' | 'target
   onClick?: (event: MouseEvent) => void;
 };
 /** Props for {@link Link}: either a raw `href` or a typed route `to` destination. */
-type LinkProps = LinkBaseProps & ({
-  href: string;
-  to?: never;
-} | {
-  href?: never;
-  to: RouteDestination;
-});
+type LinkProps = LinkBaseProps &
+  (
+    | {
+        href: string;
+        to?: never;
+      }
+    | {
+        href?: never;
+        to: RouteDestination;
+      }
+  );
 /**
  * Link component that prevents default navigation and uses navigate()
  * Provides declarative way to navigate between routes
@@ -228,6 +427,106 @@ type LinkProps = LinkBaseProps & ({
  * - Keyboard handling automatic
  * - Composable via mergeProps
  */
-declare function Link({ href: suppliedHref, to, class: className, children, rel, target, 'aria-current': ariaCurrent, 'aria-label': ariaLabel, onPress, onClick, ...rest }: LinkProps): JSXElement;
-//#endregion
-export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type AuthContext, type AuthRequirement, type Deferred, type DeferredState, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, type LazyRouteComponent, type LazyRouteDataLoader, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteChangeCleanup, type RouteChangeOptions, type RouteComponent, type RouteContext, RouteDataLoadError, type RouteDataLoadPhase, type RouteDefinition, type RouteDestination, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMeta, type RouteMetaSource, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRef, type RouteRegistry, type RouteRegistryOptions, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, group, index, isDeferred, lazy, lazyRouteData, navigate, notFound, onRouteChange, page, reconcileRouteMeta, redirect, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };
+declare function Link({
+  href: suppliedHref,
+  to,
+  class: className,
+  children,
+  rel,
+  target,
+  'aria-current': ariaCurrent,
+  'aria-label': ariaLabel,
+  onPress,
+  onClick,
+  ...rest
+}: LinkProps): JSXElement;
+export {
+  type AccessDecision,
+  type AccessDenyDecision,
+  type AccessRedirectDecision,
+  type AuthContext,
+  type AuthRequirement,
+  type Deferred,
+  type DeferredState,
+  type GroupHelperOptions,
+  type HistoryScrollBehavior,
+  type LayoutScopeRecord,
+  type LazyRouteComponent,
+  type LazyRouteDataLoader,
+  Link,
+  type LinkProps,
+  type NavigateOptions,
+  type NavigationScrollBehavior,
+  Outlet,
+  type PageHelperOptions,
+  type PageScopeRecord,
+  type ParsedSegment,
+  Resolve,
+  type ResolveProps,
+  type Route,
+  type RouteAuthOptions,
+  type RouteAuthResolver,
+  type RouteChangeCleanup,
+  type RouteChangeOptions,
+  type RouteComponent,
+  type RouteContext,
+  RouteDataLoadError,
+  type RouteDataLoadPhase,
+  type RouteDefinition,
+  type RouteDestination,
+  type RouteHandler,
+  type RouteManifest,
+  type RouteMatch,
+  type RouteMeta,
+  type RouteMetaSource,
+  type RouteMode,
+  type RouteOptions,
+  type RouteParams,
+  type RoutePathParams,
+  type RoutePolicy,
+  type RouteQuery,
+  type RouteQueryParamInput,
+  type RouteQueryParamValue,
+  type RouteQueryUpdater,
+  type RouteQueryUpdates,
+  type RouteRecord,
+  type RouteRef,
+  type RouteRegistry,
+  type RouteRegistryOptions,
+  type RouteRenderResult,
+  type RouteRequestOptions,
+  type RouteRequestResult,
+  type RouteSearch,
+  type RouteSearchValue,
+  type RouteSnapshot,
+  type ScrollRestorationOptions,
+  type UpdateRouteQueryOptions,
+  allow,
+  createRouteRegistry,
+  currentAuth,
+  currentRoute,
+  defer,
+  deny,
+  fallback,
+  forbidden,
+  group,
+  index,
+  isDeferred,
+  lazy,
+  lazyRouteData,
+  navigate,
+  notFound,
+  onRouteChange,
+  page,
+  reconcileRouteMeta,
+  redirect,
+  resolveDeferredValues,
+  resolveRouteMeta,
+  resolveRouteRequest,
+  route,
+  routeData,
+  serializeRouteMeta,
+  to$1 as to,
+  unauthorized,
+  updateRouteQuery,
+};

package/dist/router/index.js

@@ -1,13 +1,13 @@
-import { n as createRouteRegistry } from "../manifest-D6rfj_jC.js";
-import { a as isSafeHref } from "../csp-nonce-C9OuML0U.js";
-import { jsx } from "../jsx-runtime.js";
-import { o as addRouteBasePath, y as getActiveRouteBasePath } from "../route-matching-Bo6UqG-5.js";
-import { a as group, c as route, i as fallback, n as resolveDeferredValues, o as index, r as routeData, s as page, t as Resolve } from "../deferred-BELyvMsC.js";
-import { S as RouteDataLoadError, a as resolveRouteRequest, b as lazy, f as defer, g as Outlet, h as currentAuth, p as isDeferred, x as lazyRouteData } from "../resolution-t8J0yNaU.js";
-import { n as onRouteChange, t as currentRoute } from "../activity-ZxJXI9hF.js";
-import { a as serializeRouteMeta, c as getCurrentHref, d as parseTargetUrl, h as syncRegisteredRouteSnapshot, i as resolveRouteMeta, l as getRegisteredAppsSnapshot, m as syncAppRegistrationLocation, n as navigate, p as setCurrentRouteLocation, r as reconcileRouteMeta, s as saveScrollPosition, u as getWindowHref } from "../navigate-C46GtScG.js";
+import { n as createRouteRegistry } from "../manifest-D1P3UNWV.js";
+import { n as isSafeHref } from "../router-internal-7nuNEHfG.js";
+import { t as jsx } from "../jsx-runtime-CPJXAOBF.js";
+import { a as serializeRouteMeta, c as getCurrentHref, d as parseTargetUrl, h as syncRegisteredRouteSnapshot, i as resolveRouteMeta, l as getRegisteredAppsSnapshot, m as syncAppRegistrationLocation, n as navigate, p as setCurrentRouteLocation, r as reconcileRouteMeta, s as saveScrollPosition, u as getWindowHref } from "../navigate-prC5V8XV.js";
+import { n as onRouteChange, t as currentRoute } from "../activity-oy2YFTFF.js";
+import { S as isDeferred, a as resolveRouteRequest, c as Outlet, f as lazy, m as RouteDataLoadError, p as lazyRouteData, s as currentAuth, x as defer } from "../resolution-3DskUkjG.js";
+import { b as getActiveRouteBasePath, o as addRouteBasePath } from "../route-matching-CUzZ31gT.js";
+import { a as group, c as route, i as fallback, n as resolveDeferredValues, o as index, r as routeData, s as page, t as Resolve } from "../deferred-CbgNhf67.js";
 import { i as mergeProps } from "../aria-hKjThHcp.js";
-import { t as applyInteractionPolicy } from "../interactions-D102JxBR.js";
+import { t as applyInteractionPolicy } from "../interactions-CTeACdT_.js";
 //#region src/router/route-query.ts
 function getRouteQueryHistoryMode(options) {
 	if (options.history) return options.history;

package/dist/router-internal-7nuNEHfG.js

@@ -0,0 +1,36 @@
+//#region src/common/url.ts
+const SAFE_URL_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"mailto",
+	"sms",
+	"tel"
+]);
+const URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+function isSafeHref(value) {
+	const compact = value.trim().replace(/[\u0000-\u0020\u007f-\u009f]/g, "");
+	const scheme = URL_SCHEME_RE.exec(compact)?.[1]?.toLowerCase();
+	return scheme === void 0 || SAFE_URL_SCHEMES.has(scheme);
+}
+/**
+* Attribute names (lowercased) that can carry a browser-navigable/executable
+* URL and must be checked against isSafeHref. Shared between the client
+* renderer (renderer/attributes.ts) and SSR (ssr/attrs.ts) so their unsafe-
+* URL handling can't drift. Deliberately excludes `src`: it covers a much
+* wider range of legitimate non-navigable values (data: image URIs, blob:
+* URLs, etc.) where the same scheme allowlist would be overly aggressive.
+*/
+const UNSAFE_URL_SCHEME_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"href",
+	"formaction",
+	"action",
+	"xlink:href"
+]);
+function isUnsafeUrlAttribute(key, value) {
+	return UNSAFE_URL_SCHEME_ATTRIBUTES.has(key.toLowerCase()) && !isSafeHref(String(value));
+}
+//#endregion
+//#region src/common/router-internal.ts
+const ROUTE_ROOT_COMPONENT = Symbol.for("askr.route-root-component");
+//#endregion
+export { isSafeHref as n, isUnsafeUrlAttribute as r, ROUTE_ROOT_COMPONENT as t };