@askrjs/askr 0.0.52 → 0.0.53

package/dist/router/index.d.ts

@@ -1,14 +1,166 @@
-import { AccessDecision, AccessDenyDecision, AccessRedirectDecision, GroupHelperOptions, LayoutScopeRecord, PageHelperOptions, PageScopeRecord, ParsedSegment, RegisterRoutesOptions, Route, RouteAuthMode, RouteAuthOptions, RouteAuthResolver, RouteAuthState, RouteComponent, RouteContext, RouteDefinition, RouteHandler, RouteManifest, RouteMatch, RouteMode, RouteOptions, RouteParams, RoutePathParams, RoutePolicy, RouteQuery, RouteRecord, RouteRegistry, RouteRenderResult, RouteRequestOptions, RouteRequestResult, RouteSnapshot } from "../common/router.js";
-import { HistoryScrollBehavior, NavigationScrollBehavior, ScrollRestorationOptions } from "./navigation-scroll.js";
-import { NavigateOptions } from "./navigation-targets.js";
-import { RouteQueryParamInput, RouteQueryParamValue, RouteQueryUpdater, RouteQueryUpdates, UpdateRouteQueryOptions, updateRouteQuery } from "./route-query.js";
-import { navigate } from "./navigate.js";
-import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
-import { currentRoute } from "./activity.js";
-import { allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized } from "./policy.js";
-import { clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
-import { getRoutes } from "./store.js";
-import { lazy } from "./lazy.js";
-import { Outlet } from "./rendering.js";
-import { Link, LinkProps } from "../components/link.js";
-export { type AccessDecision, type AccessDenyDecision, type AccessRedirectDecision, type GroupHelperOptions, type HistoryScrollBehavior, type LayoutScopeRecord, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, type RegisterRoutesOptions, type Route, type RouteAuthMode, type RouteAuthOptions, type RouteAuthResolver, type RouteAuthState, type RouteComponent, type RouteContext, type RouteDefinition, type RouteHandler, type RouteManifest, type RouteMatch, type RouteMode, type RouteOptions, type RouteParams, type RoutePathParams, type RoutePolicy, type RouteQuery, type RouteQueryParamInput, type RouteQueryParamValue, type RouteQueryUpdater, type RouteQueryUpdates, type RouteRecord, type RouteRegistry, type RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, clearRoutes, createRouteRegistry, currentRoute, deny, fallback, forbidden, getManifest, getRoutes, group, index, lazy, navigate, notFound, page, redirect, registerRoutes, requireAuth, requirePermission, requireRole, route, unauthorized, updateRouteQuery };
+import { c as RenderableChild } from "../control-BQvNVfAd.js";
+import { r as JSXElement, s as Props } from "../jsx-CP0gmYwJ.js";
+import { A as RouteQuery, B as RouteSnapshot, C as RouteMeta, D as RouteParams, E as RouteOptions, F as RouteRenderResult, I as RouteRequestOptions, L as RouteRequestResult, M as RouteRef, N as RouteRefSearch, O as RoutePathParams, P as RouteRegistry, R as RouteSearch, S as RouteMatch, T as RouteMode, _ as RouteContext, a as AccessRedirectDecision, b as RouteHandler, c as LayoutScopeRecord, d as ParsedSegment, f as RegisterRoutesOptions, g as RouteComponent, h as RouteAuthResolver, i as AccessDenyStatus, j as RouteRecord, k as RoutePolicy, l as PageHelperOptions, m as RouteAuthOptions, n as AccessDecision, o as AccessRedirectStatus, p as Route, r as AccessDenyDecision, s as GroupHelperOptions, t as AccessAllowDecision, u as PageScopeRecord, v as RouteDefinition, w as RouteMetaSource, x as RouteManifest, y as RouteDestination, z as RouteSearchValue } from "../router-CeYvjj5_.js";
+import { a as RouteQueryUpdates, c as NavigateOptions, d as ScrollRestorationOptions, i as RouteQueryUpdater, l as HistoryScrollBehavior, n as RouteQueryParamInput, o as UpdateRouteQueryOptions, r as RouteQueryParamValue, s as updateRouteQuery, t as navigate, u as NavigationScrollBehavior } from "../navigate-BVDCzOuB.js";
+import { AuthContext, AuthContext as AuthContext$1, AuthRequirement, AuthRequirement as AuthRequirement$1 } from "@askrjs/auth";
+import { ObjectSchema } from "@askrjs/schema";
+
+//#region src/router/internal-types.d.ts
+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> = Parameters<TComponent> extends [] ? RouteOptions<RoutePathParams<Path>, TSearchSchema> : RouteComponentParam<TComponent> extends RouteParams ? RouteOptions<RouteComponentParam<TComponent>, TSearchSchema> : RouteOptions<RoutePathParams<Path>, TSearchSchema>;
+declare function group(options: GroupHelperOptions, 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 function index(Component: RouteComponent, options?: RouteOptions): void;
+declare function fallback(Component: RouteComponent): void;
+declare function registerRoutes(definition: RouteDefinition, options?: RegisterRoutesOptions): void;
+declare function route<const TPath extends string, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: RouteComponent<RoutePathParams<TPath>>, options?: RouteOptions<RoutePathParams<TPath>, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
+declare function route<const TPath extends string, TComponent extends AnyRouteComponent, const TSearchSchema extends ObjectSchema<RouteSearch> | undefined = undefined>(path: TPath, Component: CompatibleRouteComponent<TPath, TComponent>, options?: RouteOptionsForComponent<TPath, TComponent, TSearchSchema>): RouteRef<RoutePathParams<TPath>, RouteRefSearch<TSearchSchema>>;
+//#endregion
+//#region src/router/activity.d.ts
+declare function currentRoute<TParams extends RouteParams = RouteParams>(): RouteSnapshot<TParams>;
+//#endregion
+//#region src/router/auth.d.ts
+/** Return the identity resolved for the route currently being rendered. */
+declare function currentAuth(): AuthContext$1;
+//#endregion
+//#region src/router/resolution.d.ts
+declare function resolveRouteRequest(target: string, options?: RouteRequestOptions): RouteRequestResult | Promise<RouteRequestResult>;
+//#endregion
+//#region src/router/manifest.d.ts
+declare function getManifest(): RouteManifest;
+declare function clearRoutes(): void;
+declare function createRouteRegistry(definition: RouteDefinition, options?: RegisterRoutesOptions): RouteRegistry;
+//#endregion
+//#region src/router/store.d.ts
+declare function getRoutes(): Route[];
+//#endregion
+//#region src/router/lazy.d.ts
+declare function lazy<TComponent extends AnyRouteComponent>(factory: () => Promise<{
+  default: TComponent;
+} | TComponent>): TComponent;
+//#endregion
+//#region src/router/rendering.d.ts
+declare function Outlet(): JSXElement;
+//#endregion
+//#region src/router/policy.d.ts
+declare function allow(): AccessAllowDecision;
+declare function redirect(to: string, init?: {
+  status?: AccessRedirectStatus;
+  replace?: boolean;
+}): AccessRedirectDecision;
+declare function deny(status: AccessDenyStatus): AccessDenyDecision;
+declare function unauthorized(): AccessDenyDecision;
+declare function forbidden(): AccessDenyDecision;
+declare function notFound(): AccessDenyDecision;
+//#endregion
+//#region src/router/destination.d.ts
+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 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 serializeRouteMeta(meta: RouteMeta): string;
+//#endregion
+//#region src/router/deferred.d.ts
+declare const DEFERRED_VALUE: unique symbol;
+type DeferredState = 'pending' | 'fulfilled' | 'rejected';
+interface Deferred<T> {
+  readonly state: DeferredState;
+  readonly value: T | undefined;
+  readonly error: unknown;
+  readonly promise: Promise<T>;
+  readonly [DEFERRED_VALUE]: true;
+}
+interface ResolveProps<T> {
+  value: Deferred<T>;
+  pending?: RenderableChild;
+  rejected?: RenderableChild | ((error: unknown) => RenderableChild);
+  children: (value: T) => RenderableChild;
+}
+declare function defer<T>(promise: PromiseLike<T>): Deferred<T>;
+declare function isDeferred<T = unknown>(value: unknown): value is Deferred<T>;
+declare function resolveDeferredValues<T>(input: T, signal?: AbortSignal): Promise<T>;
+declare function routeData<T>(): T;
+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'> & {
+  class?: string;
+  children?: RenderableChild;
+  /**
+   * Optional rel attribute for link relationships.
+   * Common values: "noopener", "noreferrer", "nofollow"
+   */
+  rel?: string;
+  /**
+   * Optional target attribute.
+   * Use "_blank" for new tab/window.
+   */
+  target?: string;
+  /**
+   * 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';
+  /**
+   * Optional aria-label for accessibility when link text isn't descriptive enough.
+   */
+  'aria-label'?: string;
+};
+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
+ *
+ * Accessibility features:
+ * - Proper semantic <a> element (not a button)
+ * - Supports aria-current for indicating active page
+ * - Supports aria-label for descriptive labels
+ * - Keyboard accessible (Enter key handled by native <a> element)
+ *
+ * Respects native browser behaviors:
+ * - Middle-click (opens in new tab)
+ * - Ctrl/Cmd+click (opens in new tab)
+ * - Shift+click (opens in new window)
+ * - Alt+click (downloads link)
+ * - Right-click context menu
+ *
+ * Best practices:
+ * - Use target="_blank" with rel="noopener noreferrer" for external links
+ * - Use aria-current="page" for the current page in navigation
+ * - Provide descriptive link text or aria-label
+ *
+ * Uses applyInteractionPolicy to enforce pit-of-success principles:
+ * - Interaction behavior centralized in foundations
+ * - Keyboard handling automatic
+ * - Composable via mergeProps
+ */
+declare function Link({
+  href: suppliedHref,
+  to,
+  class: className,
+  children,
+  rel,
+  target,
+  'aria-current': ariaCurrent,
+  'aria-label': ariaLabel,
+  ...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, Link, type LinkProps, type NavigateOptions, type NavigationScrollBehavior, Outlet, type PageHelperOptions, type PageScopeRecord, type ParsedSegment, type RegisterRoutesOptions, Resolve, type ResolveProps, type Route, type RouteAuthOptions, type RouteAuthResolver, type RouteComponent, type RouteContext, 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 RouteRenderResult, type RouteRequestOptions, type RouteRequestResult, type RouteSearch, type RouteSearchValue, type RouteSnapshot, type ScrollRestorationOptions, type UpdateRouteQueryOptions, allow, clearRoutes, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, getManifest, getRoutes, group, index, isDeferred, lazy, navigate, notFound, page, reconcileRouteMeta, redirect, registerRoutes, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to$1 as to, unauthorized, updateRouteQuery };

package/dist/router/index.js

@@ -1,12 +1,150 @@
-import { allow, deny, forbidden, notFound, redirect, requireAuth, requirePermission, requireRole, unauthorized } from "./policy.js";
-import { Outlet } from "./rendering.js";
-import { getRoutes } from "./store.js";
-import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
-import { currentRoute } from "./activity.js";
-import { lazy } from "./lazy.js";
-import { clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
-import "./route.js";
-import { updateRouteQuery } from "./route-query.js";
-import { navigate } from "./navigate.js";
-import { Link } from "../components/link.js";
-export { Link, Outlet, allow, clearRoutes, createRouteRegistry, currentRoute, deny, fallback, forbidden, getManifest, getRoutes, group, index, lazy, navigate, notFound, page, redirect, registerRoutes, requireAuth, requirePermission, requireRole, route, unauthorized, updateRouteQuery };
+import { C as index, E as route, S as group, T as registerRoutes, _ as lazy, a as resolveRouteMeta, d as clearRoutes, f as createRouteRegistry, i as reconcileRouteMeta, n as navigate, o as serializeRouteMeta, p as getManifest, r as updateRouteQuery, v as currentRoute, w as page, x as fallback } from "../navigate-CmPLSXyw.js";
+import { jsx } from "../jsx-runtime.js";
+import { D as getRoutes } from "../route-matching-vJpvLVbX.js";
+import { a as resolveDeferredValues, f as resolveRouteRequest, i as isDeferred, n as Resolve, p as currentAuth, r as defer, s as routeData, v as Outlet } from "../deferred-lKE8uR0z.js";
+import { o as mergeProps } from "../compose-ref-Cc_YkUpM.js";
+import { t as applyInteractionPolicy } from "../interactions-w7gQN4ha.js";
+//#region src/router/policy.ts
+function allow() {
+	return { kind: "allow" };
+}
+function redirect(to, init = {}) {
+	return {
+		kind: "redirect",
+		to,
+		...init.status ? { status: init.status } : {},
+		...init.replace !== void 0 ? { replace: init.replace } : {}
+	};
+}
+function deny(status) {
+	return {
+		kind: "deny",
+		status
+	};
+}
+function unauthorized() {
+	return deny(401);
+}
+function forbidden() {
+	return deny(403);
+}
+function notFound() {
+	return deny(404);
+}
+//#endregion
+//#region src/router/destination.ts
+function routeParameterName(segment) {
+	if (segment === "*") return {
+		name: "*",
+		splat: true
+	};
+	if (!(segment.startsWith("{") && segment.endsWith("}"))) return null;
+	const raw = segment.slice(1, -1).trim();
+	return raw.startsWith("*") ? {
+		name: raw.slice(1).trim(),
+		splat: true
+	} : {
+		name: raw,
+		splat: false
+	};
+}
+function encodeParameter(value, splat) {
+	return splat ? value.split("/").map((part) => encodeURIComponent(part)).join("/") : encodeURIComponent(value);
+}
+function buildPath(route, params) {
+	return route.path.split("/").map((segment) => {
+		const parameter = routeParameterName(segment);
+		if (!parameter) return segment;
+		const value = params[parameter.name];
+		if (value === void 0) throw new Error(`Missing route parameter "${parameter.name}".`);
+		return encodeParameter(value, parameter.splat);
+	}).join("/");
+}
+function appendSearchValue(query, key, value) {
+	if (value === void 0) return;
+	if (Array.isArray(value)) {
+		for (const entry of value) query.append(key, String(entry));
+		return;
+	}
+	query.set(key, String(value));
+}
+function formatSearchIssues(issues) {
+	return issues.map((issue) => `${issue.path.length ? issue.path.join(".") : "search"}: ${issue.message}`).join("; ");
+}
+function to(route, params, search) {
+	const path = buildPath(route, params);
+	const parsedSearch = route.searchSchema?.safeParse(search ?? {});
+	if (parsedSearch && !parsedSearch.success) throw new Error(`Invalid route search. ${formatSearchIssues(parsedSearch.issues)}`);
+	const values = parsedSearch?.success ? parsedSearch.data : search;
+	if (!values) return Object.freeze({ href: path });
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(values)) appendSearchValue(query, key, value);
+	const suffix = query.toString();
+	return Object.freeze({ href: suffix ? `${path}?${suffix}` : path });
+}
+//#endregion
+//#region src/components/link.tsx
+function isSameOriginNavigableHref(href) {
+	if (typeof window === "undefined") return true;
+	try {
+		const target = new URL(href, window.location.href);
+		return target.origin === window.location.origin && (target.protocol === "http:" || target.protocol === "https:");
+	} catch {
+		return false;
+	}
+}
+/**
+* Link component that prevents default navigation and uses navigate()
+* Provides declarative way to navigate between routes
+*
+* Accessibility features:
+* - Proper semantic <a> element (not a button)
+* - Supports aria-current for indicating active page
+* - Supports aria-label for descriptive labels
+* - Keyboard accessible (Enter key handled by native <a> element)
+*
+* Respects native browser behaviors:
+* - Middle-click (opens in new tab)
+* - Ctrl/Cmd+click (opens in new tab)
+* - Shift+click (opens in new window)
+* - Alt+click (downloads link)
+* - Right-click context menu
+*
+* Best practices:
+* - Use target="_blank" with rel="noopener noreferrer" for external links
+* - Use aria-current="page" for the current page in navigation
+* - Provide descriptive link text or aria-label
+*
+* Uses applyInteractionPolicy to enforce pit-of-success principles:
+* - Interaction behavior centralized in foundations
+* - Keyboard handling automatic
+* - Composable via mergeProps
+*/
+function Link({ href: suppliedHref, to, class: className, children, rel, target, "aria-current": ariaCurrent, "aria-label": ariaLabel, ...rest }) {
+	const href = to?.href ?? suppliedHref;
+	if (!href) throw new Error("Link requires href or to.");
+	return /* @__PURE__ */ jsx("a", {
+		...mergeProps(rest, {
+			...applyInteractionPolicy({
+				isNative: true,
+				disabled: false,
+				onPress: (e) => {
+					const event = e;
+					if ((event.button ?? 0) !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+					if (target || !isSameOriginNavigableHref(href)) return;
+					event.preventDefault();
+					navigate(href);
+				}
+			}),
+			href,
+			class: className,
+			rel,
+			target,
+			"aria-current": ariaCurrent,
+			"aria-label": ariaLabel
+		}),
+		children
+	});
+}
+//#endregion
+export { Link, Outlet, Resolve, allow, clearRoutes, createRouteRegistry, currentAuth, currentRoute, defer, deny, fallback, forbidden, getManifest, getRoutes, group, index, isDeferred, lazy, navigate, notFound, page, reconcileRouteMeta, redirect, registerRoutes, resolveDeferredValues, resolveRouteMeta, resolveRouteRequest, route, routeData, serializeRouteMeta, to, unauthorized, updateRouteQuery };

package/dist/{common/router.d.ts → router-CeYvjj5_.d.ts}

@@ -1,4 +1,8 @@
-import { RenderableChild } from "./vnode.js";
+import { c as RenderableChild } from "./control-BQvNVfAd.js";
+import { D as QueryPrefetchContext, u as CoreTelemetry } from "./index-Bki2rqcr.js";
+import { t as ActionDescriptor } from "./index-SJXJkssx.js";
+import { AuthContext, AuthRequirement } from "@askrjs/auth";
+import { InferSchema, ObjectSchema } from "@askrjs/schema";
 
 //#region src/common/router.d.ts
 /**
@@ -20,7 +24,6 @@ type RoutePathParams<Path extends string> = [ExtractRoutePathParamNames<Path>] e
  */
 type RouteComponent<TParams extends RouteParams = RouteParams> = (props: TParams) => RenderableChild;
 type RouteMode = 'spa' | 'ssr' | 'ssg';
-type RouteAuthMode = true | 'guest';
 type AccessRedirectStatus = 301 | 302 | 303 | 307 | 308;
 type AccessDenyStatus = 401 | 403 | 404;
 interface AccessAllowDecision {
@@ -37,36 +40,28 @@ interface AccessDenyDecision {
   status: AccessDenyStatus;
 }
 type AccessDecision = AccessAllowDecision | AccessRedirectDecision | AccessDenyDecision;
-interface RouteContext<Session = unknown, User = unknown, TParams extends RouteParams = RouteParams> {
+interface RouteContext<TParams extends RouteParams = RouteParams> {
   mode: RouteMode;
   params: TParams;
   pathname: string;
   search: string;
   hash: string;
   href: string;
-  session: Session | null;
-  user: User | null;
+  auth: AuthContext;
   signal: AbortSignal;
 }
 type RoutePolicy = (context: RouteContext) => AccessDecision | PromiseLike<AccessDecision>;
-interface RouteAuthState<Session = unknown, User = unknown> {
-  session: Session | null;
-  user: User | null;
-}
-type RouteAuthResolver<Session = unknown, User = unknown> = (context: Omit<RouteContext<Session, User>, 'session' | 'user'>) => RouteAuthState<Session, User> | PromiseLike<RouteAuthState<Session, User>>;
-interface RouteAuthOptions<Session = unknown, User = unknown> {
-  resolve: RouteAuthResolver<Session, User>;
-  loginPath?: string | ((context: RouteContext<Session, User>) => string | PromiseLike<string>);
-  guestRedirectTo?: string | ((context: RouteContext<Session, User>) => string | PromiseLike<string>);
-  hasRole?: (user: User, role: string, context: RouteContext<Session, User>) => boolean | PromiseLike<boolean>;
-  hasPermission?: (user: User, permission: string, context: RouteContext<Session, User>) => boolean | PromiseLike<boolean>;
+type RouteAuthResolver = (context: Omit<RouteContext, 'auth'>) => AuthContext | PromiseLike<AuthContext>;
+interface RouteAuthOptions {
+  resolve: RouteAuthResolver;
+  loginPath?: string | ((context: RouteContext) => string | PromiseLike<string>);
+  authenticatedRedirectTo?: string | ((context: RouteContext) => string | PromiseLike<string>);
 }
 interface CommonAccessOptions {
-  auth?: RouteAuthMode;
-  role?: string;
-  permission?: string;
+  auth?: AuthRequirement;
   policies?: readonly RoutePolicy[];
 }
+type RouteMetaSource<TParams extends RouteParams = RouteParams> = RouteMeta | ((context: RouteContext<TParams>) => RouteMeta | PromiseLike<RouteMeta>);
 /**
  * Options for `route()` declarations.
  *
@@ -75,15 +70,59 @@ interface CommonAccessOptions {
  * - `title`: page title hint used by SSG and document-meta integrations
  * - `namespace`: MFE namespace key for grouped route management
  */
-interface RouteOptions<TParams extends RouteParams = RouteParams> extends CommonAccessOptions {
-  loader?: (context: {
-    params: TParams;
+interface RouteOptions<TParams extends RouteParams = RouteParams, TSearchSchema extends ObjectSchema<RouteSearch> | undefined = ObjectSchema<RouteSearch> | undefined> extends CommonAccessOptions {
+  loader?: (context: RouteContext<TParams> & {
+    request?: Request;
+  }) => unknown;
+  preload?: (context: RouteContext<TParams> & {
+    request?: Request;
+    data: QueryPrefetchContext;
   }) => unknown;
   entries?: () => Array<TParams> | Promise<Array<TParams>>;
   title?: string;
   namespace?: string;
+  search?: TSearchSchema;
+  meta?: RouteMetaSource<TParams>;
+  actions?: readonly ActionDescriptor[];
+}
+interface RouteMeta {
+  title?: string;
+  description?: string;
+  canonical?: string;
+  robots?: string;
+  openGraph?: Record<string, string>;
+  links?: readonly {
+    rel: string;
+    href: string;
+    [key: string]: string;
+  }[];
+  jsonLd?: unknown | readonly unknown[];
+  html?: {
+    lang?: string;
+    dir?: 'ltr' | 'rtl' | 'auto';
+  };
+}
+/** A stable, typed reference returned by route() for destination construction. */
+type RouteSearchValue = string | number | boolean | null | undefined | readonly (string | number | boolean | null)[];
+type RouteSearch = Record<string, RouteSearchValue>;
+interface RouteRef<TParams extends RouteParams = RouteParams, TSearch = RouteSearch> {
+  readonly path: string;
+  /** @internal Executable schema retained for destination validation. */
+  readonly searchSchema?: ObjectSchema<TSearch & RouteSearch>;
+  readonly __params?: TParams;
+  readonly __search?: TSearch;
+}
+type RouteRefSearch<TSchema extends ObjectSchema<RouteSearch> | undefined> = TSchema extends ObjectSchema<RouteSearch> ? InferSchema<TSchema> : RouteSearch;
+interface RouteDestination {
+  readonly href: string;
+}
+interface PageHelperOptions extends CommonAccessOptions {
+  preload?: (context: RouteContext & {
+    request?: Request;
+    data: QueryPrefetchContext;
+  }) => unknown;
+  meta?: RouteMetaSource;
 }
-interface PageHelperOptions extends CommonAccessOptions {}
 /**
  * A single parsed segment from a route path.
  *
@@ -115,19 +154,26 @@ type RouteDefinition = () => void;
 interface RouteRequestOptions {
   manifest?: RouteManifest;
   mode?: RouteMode;
+  /** @internal Hydration adopts server loader data instead of rerunning it. */
+  load?: boolean;
   auth?: RouteAuthOptions;
+  authContext?: AuthContext;
   signal?: AbortSignal;
+  request?: Request;
+  telemetry?: CoreTelemetry;
 }
 interface RouteRenderResult<TParams extends RouteParams = RouteParams> {
   kind: 'render';
   handler: RouteHandler<TParams>;
   params: TParams;
+  record?: RouteRecord;
 }
 type RouteRequestResult<TParams extends RouteParams = RouteParams> = RouteRenderResult<TParams> | AccessRedirectDecision | AccessDenyDecision | null;
 interface GroupHelperOptions extends CommonAccessOptions {
   layout?: (props: {
     children?: RenderableChild;
   }) => RenderableChild;
+  meta?: RouteMetaSource;
 }
 /**
  * A fully normalized route record produced by `route(path, Component, options?)`.
@@ -152,6 +198,8 @@ interface RouteRecord {
   pageChain: PageScopeRecord[];
   /** Route metadata: loader, entries, policies, title, namespace */
   options: RouteOptions;
+  /** Metadata sources ordered from outermost group/page to the route leaf. */
+  metaChain?: readonly RouteMetaSource[];
   /** True when this is the `/*` catch-all fallback route */
   isFallback: boolean;
   /**
@@ -189,10 +237,6 @@ interface RouteRegistry {
   manifest: RouteManifest;
   routes: readonly Route[];
 }
-interface ResolvedRoute<TParams extends RouteParams = RouteParams> {
-  handler: RouteHandler<TParams>;
-  params: TParams;
-}
 interface RouteMatch<TParams extends RouteParams = RouteParams> {
   path: string;
   params: Readonly<TParams>;
@@ -215,4 +259,4 @@ interface RouteSnapshot<TParams extends RouteParams = RouteParams> {
   matches: readonly RouteMatch<TParams>[];
 }
 //#endregion
-export { AccessAllowDecision, AccessDecision, AccessDenyDecision, AccessDenyStatus, AccessRedirectDecision, AccessRedirectStatus, CommonAccessOptions, GroupHelperOptions, LayoutScopeRecord, PageHelperOptions, PageScopeRecord, ParsedSegment, RegisterRoutesOptions, ResolvedRoute, Route, RouteAuthMode, RouteAuthOptions, RouteAuthResolver, RouteAuthState, RouteComponent, RouteContext, RouteDefinition, RouteHandler, RouteManifest, RouteMatch, RouteMode, RouteOptions, RouteParams, RoutePathParams, RoutePolicy, RouteQuery, RouteRecord, RouteRegistry, RouteRenderResult, RouteRequestOptions, RouteRequestResult, RouteSnapshot };
+export { RouteQuery as A, RouteSnapshot as B, RouteMeta as C, RouteParams as D, RouteOptions as E, RouteRenderResult as F, RouteRequestOptions as I, RouteRequestResult as L, RouteRef as M, RouteRefSearch as N, RoutePathParams as O, RouteRegistry as P, RouteSearch as R, RouteMatch as S, RouteMode as T, RouteContext as _, AccessRedirectDecision as a, RouteHandler as b, LayoutScopeRecord as c, ParsedSegment as d, RegisterRoutesOptions as f, RouteComponent as g, RouteAuthResolver as h, AccessDenyStatus as i, RouteRecord as j, RoutePolicy as k, PageHelperOptions as l, RouteAuthOptions as m, AccessDecision as n, AccessRedirectStatus as o, Route as p, AccessDenyDecision as r, GroupHelperOptions as s, AccessAllowDecision as t, PageScopeRecord as u, RouteDefinition as v, RouteMetaSource as w, RouteManifest as x, RouteDestination as y, RouteSearchValue as z };

package/dist/{common/router-internal.js → router-internal-BC0w1_xk.js}

@@ -1,4 +1,4 @@
 //#region src/common/router-internal.ts
 const ROUTE_ROOT_COMPONENT = Symbol.for("askr.route-root-component");
 //#endregion
-export { ROUTE_ROOT_COMPONENT };
+export { ROUTE_ROOT_COMPONENT as t };

package/dist/{runtime/scheduler.d.ts → scheduler-CmLO4Dfm.d.ts}

@@ -60,8 +60,6 @@ declare class Scheduler {
   clearPendingSyncTasks(): number;
   private resolveWaiters;
 }
-declare const globalScheduler: Scheduler;
-declare function isSchedulerExecuting(): boolean;
 declare function scheduleEventHandler(handler: EventListener): EventListener;
 //#endregion
-export { Scheduler, SchedulerBulkCommitProbe, SchedulerLane, scheduleEventHandler };
+export { scheduleEventHandler as n, Scheduler as t };

package/dist/{runtime/selector.js → selector-DafVYzV4.js}

@@ -1,15 +1,35 @@
-import "./perf-metrics.js";
-import { clearDerivedDependencySubscriptions, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, syncDerivedDependencySubscriptions, withDerivedReadTracking } from "./readable.js";
-import { claimHookIndex, getCurrentInstance } from "./component-scope.js";
-import "./component.js";
-import { markDirtySelectorRecord, takeDirtySelectorRecords } from "./selector-store.js";
+import { t as enqueueRuntimeLane } from "./access-Bg4RJNC8.js";
+import { d as markReadableUsage, f as notifyReadableReaders, g as withDerivedReadTracking, h as syncDerivedDependencySubscriptions, l as markReactivePropsDirtySource, o as clearDerivedDependencySubscriptions, p as recordReadableRead, u as markReadableDerivedSubscribersDirty } from "./fastlane-Dw8SOBr9.js";
+import { i as claimHookIndex, p as getCurrentInstance } from "./component-scope-CC3cojX9.js";
+//#region src/runtime/selector-store.ts
+const dirtySelectorRecords = /* @__PURE__ */ new Set();
+let hasPendingSelectorFlush = false;
+function markDirtySelectorRecord(record, flush) {
+	record._dirty = true;
+	if (record._scheduled) return;
+	record._scheduled = true;
+	dirtySelectorRecords.add(record);
+	if (hasPendingSelectorFlush) return;
+	hasPendingSelectorFlush = true;
+	enqueueRuntimeLane("derived", flush);
+}
+function takeDirtySelectorRecords() {
+	hasPendingSelectorFlush = false;
+	if (dirtySelectorRecords.size === 0) return [];
+	const pending = Array.from(dirtySelectorRecords);
+	dirtySelectorRecords.clear();
+	return pending;
+}
+//#endregion
+//#region src/runtime/selector.ts
 const selectorCells = /* @__PURE__ */ new WeakMap();
 const selectorRecords = /* @__PURE__ */ new WeakMap();
 function getSelectorStore(instance) {
-	let store = selectorCells.get(instance);
+	const generation = instance._ownershipGeneration;
+	let store = selectorCells.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
-		selectorCells.set(instance, store);
+		selectorCells.set(generation, store);
 	}
 	return store;
 }
@@ -103,10 +123,12 @@ function createSelectorLane(record, equals) {
 		_objectCandidateSources: /* @__PURE__ */ new Set(),
 		_cleanup: () => {
 			for (const sourceRef of lane._primitiveCandidates.values()) {
+				sourceRef._readers?.size;
 				sourceRef._readers?.clear();
 				sourceRef._derivedSubscribers?.clear();
 			}
 			for (const sourceRef of lane._objectCandidateSources) {
+				sourceRef._readers?.size;
 				sourceRef._readers?.clear();
 				sourceRef._derivedSubscribers?.clear();
 			}
@@ -198,7 +220,7 @@ function ensureSelectorHookBinding(hook) {
 	attachSelectorHookBinding(hook, hook._source, hook._equals);
 	return hook._record;
 }
-function createSelectorHook(instance, hookIndex, source, equals) {
+function createSelectorHook(instance, generation, store, hookIndex, source, equals) {
 	const hook = function selectorPredicate(candidate) {
 		const selectorHook = hook;
 		const record = selectorHook._record ?? ensureSelectorHookBinding(selectorHook);
@@ -220,7 +242,8 @@ function createSelectorHook(instance, hookIndex, source, equals) {
 	attachSelectorHookBinding(hook, source, equals);
 	(instance.cleanupFns ??= []).push(() => {
 		hook._cleanup();
-		selectorCells.get(instance)?.delete(hookIndex);
+		store.delete(hookIndex);
+		if (store.size === 0 && selectorCells.get(generation) === store) selectorCells.delete(generation);
 	});
 	return hook;
 }
@@ -234,7 +257,7 @@ function getOrCreateSelectorHook(instance, hookIndex, source, equals) {
 		} else ensureSelectorHookBinding(existing);
 		return existing;
 	}
-	const created = createSelectorHook(instance, hookIndex, source, equals);
+	const created = createSelectorHook(instance, instance._ownershipGeneration, store, hookIndex, source, equals);
 	store.set(hookIndex, created);
 	return created;
 }
@@ -248,4 +271,4 @@ function selector(source, equals = Object.is) {
 	return hook;
 }
 //#endregion
-export { selector };
+export { selector as t };

package/dist/{runtime/snapshot-source.js → snapshot-source-BB42xgwb.js}

@@ -12,4 +12,4 @@ function isSnapshotSource(value) {
 	return !!value && typeof value === "object" && value[SNAPSHOT_SOURCE_BRAND] === true;
 }
 //#endregion
-export { SNAPSHOT_SOURCE_BRAND, brandSnapshotSource, isSnapshotSource };
+export { isSnapshotSource as n, brandSnapshotSource as t };