@kasperrt/smolter 0.4.2 → 0.4.4

package/dist/{preact → client}/root-data.js

@@ -1,5 +1,5 @@
 import { createStore } from "../core/store.js";
-//#region .generated/preact/root-data.ts
+//#region .generated/client/root-data.ts
 function attachRootData(router, initial, rootModule) {
 	const store = createStore(initial);
 	const loaderPath = rootModule?.loaderPath;

package/dist/core/environment.d.ts

@@ -1,3 +1,4 @@
+/** Application base URLs, navigation handoff and document-transition settings shared by browser integrations. */
 export interface ApplicationEnvironment {
     resolveURL?: (url: URL) => URL;
     isDocumentHandoff?: (from: URL, to: URL) => boolean;

package/dist/core/navigation.d.ts

@@ -1,4 +1,5 @@
 import type { Router } from "./types.ts";
+/** Browser history operation: POP, PUSH or REPLACE. */
 export type NavigationType = "POP" | "PUSH" | "REPLACE";
 export interface NavigationSnapshot {
     type: NavigationType;

package/dist/core/prepare-routes.d.ts

@@ -0,0 +1,7 @@
+import type { Route } from "./types.ts";
+type AppRoute = Route & {
+    routePath?: string;
+    preload?: () => Promise<void>;
+};
+export declare function prepareRoutes(routes: AppRoute[], preserveDeferred?: boolean): AppRoute[];
+export {};

package/dist/core/prepare-routes.js

@@ -0,0 +1,28 @@
+import { normalizeResult } from "./responses.js";
+//#region .generated/core/prepare-routes.ts
+function prepareRoutes(routes, preserveDeferred = false) {
+	return routes.map((route) => {
+		const wrapped = {
+			...route,
+			path: route.routePath ?? route.path,
+			shouldRevalidate: (args) => {
+				const { currentUrl, nextUrl } = args;
+				if (args.reason === "navigation" && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash) return false;
+				return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
+			}
+		};
+		for (const key of [
+			"loader",
+			"action",
+			"clientLoader",
+			"clientAction"
+		]) {
+			const handler = route[key];
+			if (!handler) continue;
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then((value) => normalizeResult(value, !preserveDeferred), (error) => normalizeResult(error, !preserveDeferred));
+		}
+		return wrapped;
+	});
+}
+//#endregion
+export { prepareRoutes };

package/dist/core/presentation.js

@@ -1,7 +1,7 @@
 //#region .generated/core/presentation.ts
 var pending = /* @__PURE__ */ new WeakMap();
 function pendingLocation(router) {
-	const snapshot = pending.get(router)?.();
+	const snapshot = pending.get(router)?.() ?? router.getSnapshot();
 	return snapshot?.state !== "idle" && snapshot?.url ? new URL(snapshot.url) : void 0;
 }
 function retainRoute(router, commitView) {

package/dist/core/responses.d.ts

@@ -1,15 +1,27 @@
+/**
+ * HTTP response helpers and loader result normalization.
+ *
+ * @module
+ */
+/** Normalized route failure with an HTTP status, status text and optional response data. */
 export interface RouteError extends Error {
     status: number;
     statusText: string;
     data?: unknown;
 }
+/** Loader value paired with HTTP response metadata. */
 export interface DataResponse<T> {
     value: T;
     init: ResponseInit;
     __routeData: true;
 }
+/** Wrap loader data with HTTP status and headers without creating a Response body. */
 export declare function data<T>(value: T, init?: ResponseInit): DataResponse<T>;
+/** Create an empty redirect Response with a Location header; defaults to HTTP 302. */
 export declare function redirect(location: string, init?: number | ResponseInit): Response;
+/** Identify normalized Error objects carrying an HTTP status. */
 export declare function isRouteErrorResponse(value: unknown): value is RouteError;
+/** Normalize transport responses and wrapped data, optionally resolving nested deferred values. */
 export declare function normalizeResult(value: unknown, resolveDeferred?: boolean): Promise<unknown>;
+/** Recursively resolve promises in arrays and plain objects before JSON serialization. */
 export declare function resolveData(value: unknown): Promise<unknown>;

package/dist/core/responses.js

@@ -1,4 +1,5 @@
 //#region .generated/core/responses.ts
+/** Wrap loader data with HTTP status and headers without creating a Response body. */
 function data(value, init = {}) {
 	return {
 		value,
@@ -6,6 +7,7 @@ function data(value, init = {}) {
 		__routeData: true
 	};
 }
+/** Create an empty redirect Response with a Location header; defaults to HTTP 302. */
 function redirect(location, init = 302) {
 	const options = typeof init === "number" ? { status: init } : init;
 	const headers = new Headers(options.headers);
@@ -16,9 +18,11 @@ function redirect(location, init = 302) {
 		headers
 	});
 }
+/** Identify normalized Error objects carrying an HTTP status. */
 function isRouteErrorResponse(value) {
 	return value instanceof Error && "status" in value;
 }
+/** Normalize transport responses and wrapped data, optionally resolving nested deferred values. */
 async function normalizeResult(value, resolveDeferred = true) {
 	if (value && typeof value === "object" && "__routeError" in value) {
 		const error = value.__routeError;
@@ -35,6 +39,7 @@ async function normalizeResult(value, resolveDeferred = true) {
 	if (value && typeof value === "object" && "__routeData" in value) return resolveDeferred ? resolveData(value.value) : value.value;
 	return resolveDeferred ? resolveData(value) : value;
 }
+/** Recursively resolve promises in arrays and plain objects before JSON serialization. */
 async function resolveData(value) {
 	const resolved = await value;
 	if (Array.isArray(resolved)) return Promise.all(resolved.map(resolveData));

package/dist/core/utils.d.ts

@@ -1,5 +1,8 @@
-/** Framework-independent, browser-safe utilities. @module */
-export * from "./errors.ts";
+/**
+ * Routing patterns, query strings and serialized data utilities.
+ *
+ * @module
+ */
 export * from "./match.ts";
 export * from "./serialize.ts";
 export * from "./url.ts";

package/dist/core/utils.js

@@ -1,5 +1,4 @@
-import { safeWrapAsync } from "./errors.js";
 import { defineRoute, matchRoutes } from "./match.js";
 import { internalURL, navigationClick } from "./url.js";
 import { serialize, serializeData } from "./serialize.js";
-export { defineRoute, internalURL, matchRoutes, navigationClick, safeWrapAsync, serialize, serializeData };
+export { defineRoute, internalURL, matchRoutes, navigationClick, serialize, serializeData };

package/dist/preact/await.d.ts

@@ -7,4 +7,5 @@ export interface AwaitProps<T> {
     /** Component-owned pending content, safe during early hydration. Pass null to render nothing. */
     fallback?: ComponentChildren;
 }
+/** Render a value or promise. An explicit fallback owns pending content during early hydration; errorElement handles rejection. */
 export declare function Await<T>(props: AwaitProps<T>): ComponentChildren;

package/dist/preact/await.js

@@ -4,6 +4,7 @@ import { use, useContext } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
 //#region .generated/preact/await.tsx
 var resolutions = /* @__PURE__ */ new WeakMap();
+/** Render a value or promise. An explicit fallback owns pending content during early hydration; errorElement handles rejection. */
 function Await(props) {
 	const app = useContext(Application);
 	if (!(props.resolve instanceof Promise)) return props.children(props.resolve);

package/dist/preact/client.d.ts

@@ -1,14 +1,20 @@
-/** Browser mounting and hydration for Preact applications. @module */
+/**
+ * Preact document hydration, browser history and deployment recovery.
+ *
+ * @module
+ */
 /** @jsxImportSource preact */
 import { type DeploymentOptions } from "../client/index.ts";
 import { type Router } from "../core/index.ts";
 import type { AppRoute, RootModule } from "./route-types.ts";
 export * from "../client/index.ts";
 export { configureApplication } from "../core/environment.ts";
+/** Browser hydration settings for hash history, deployment recovery and deferred-data timeout. */
 export interface MountApplicationOptions {
     hash?: boolean;
     deployment?: DeploymentOptions | null;
     /** Total initial deferred-data budget in integer milliseconds; not an inactivity timeout. Defaults to 30,000. */
     deferredTimeout?: number;
 }
+/** Create the browser application router and hydrate the document, installing recovery before initial lazy loading. */
 export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, options?: boolean | MountApplicationOptions): Promise<Router>;

package/dist/preact/client.js

@@ -3,18 +3,25 @@ import { createDataRouter } from "../core/router.js";
 import { configureApplication } from "../core/environment.js";
 import { retainRoute } from "../core/presentation.js";
 import { connectNavigation } from "../core/navigation.js";
-import { attachRootData } from "./root-data.js";
-import { RouterApplication, prepareRoutes } from "./router.js";
+import { attachRootData } from "../client/root-data.js";
+import { prepareRoutes } from "../core/prepare-routes.js";
+import { RouterApplication } from "./router.js";
 import { deserialize } from "../client/deserialize.js";
 import { recoverDeployment, watchDeployment } from "../client/deployment.js";
 import { serverRoute } from "../client/index.js";
-import { readHydration } from "./deferred-hydration.js";
+import { connectHashHistory } from "../client/hash-history.js";
+import { readHydration } from "../client/hydration.js";
 import { flushSync } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
 import { hydrate, render } from "preact";
 //#region .generated/preact/client.tsx
-/** Browser mounting and hydration for Preact applications. @module */
+/**
+* Preact document hydration, browser history and deployment recovery.
+*
+* @module
+*/
 /** @jsxImportSource preact */
+/** Create the browser application router and hydrate the document, installing recovery before initial lazy loading. */
 async function mountApplication(routes, rootModule, options = false) {
 	const { hash = false, deployment = null, deferredTimeout } = typeof options === "boolean" ? { hash: options } : options;
 	const initialURL = new URL(hash ? location.hash.slice(1) || "/" : location.href, location.origin);
@@ -69,28 +76,5 @@ async function mountApplication(routes, rootModule, options = false) {
 	if (target) render(/* @__PURE__ */ jsx(RouterApplication, { ...props }), target);
 	return router;
 }
-function connectHashHistory(router) {
-	const read = router.getSnapshot;
-	const navigate = router.navigate;
-	router.navigate = async (url, options) => {
-		const target = new URL(url, router.getSnapshot().url);
-		const hash = `#${target.pathname}${target.search}${target.hash}`;
-		history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
-		await navigate(url, options);
-	};
-	const unsubscribe = router.subscribe(() => {
-		const target = new URL(read().url);
-		const hash = `#${target.pathname}${target.search}${target.hash}`;
-		if (location.hash !== hash) history.replaceState(history.state, "", hash);
-	});
-	const onHashChange = () => void navigate(location.hash.slice(1) || "/");
-	window.addEventListener("hashchange", onHashChange);
-	const dispose = router.dispose;
-	router.dispose = () => {
-		unsubscribe();
-		window.removeEventListener("hashchange", onHashChange);
-		dispose();
-	};
-}
 //#endregion
 export { configureApplication, deserialize, mountApplication, recoverDeployment, serverRoute, watchDeployment };

package/dist/preact/deferred-hydration.d.ts

@@ -1,10 +1 @@
-type Settlement = [number, unknown, string | null];
-export interface DeferredWindow extends Window {
-    __smolterDeferred?: Settlement[];
-}
-/** Restore promise identity before hydrating Suspense boundaries. */
-export declare function readHydration(json: string, timeout?: number): {
-    hydration: any;
-    dispose: () => void;
-};
-export {};
+export { type DeferredWindow, readHydration } from "../client/hydration.ts";

package/dist/preact/document.d.ts

@@ -1,11 +1,21 @@
+/**
+ * Preact document metadata, resource links and hydration scripts.
+ *
+ * @module
+ */
 /** @jsxImportSource preact */
 import type { ComponentProps } from "preact/compat";
+/** Render root or active-route metadata in the document head. */
 export declare function Meta(): import("preact").JSX.Element;
+/** Render stylesheet and other link descriptors from the application root. */
 export declare function Links(): import("preact").JSX.Element;
+/** Nonce and browser entry options for the document hydration scripts. */
 export interface ScriptProps {
     nonce?: string;
 }
+/** Render the hydration snapshot and browser entry script with an optional CSP nonce. */
 export declare function Scripts({ nonce }: ScriptProps): import("preact").JSX.Element;
+/** Reset scroll after navigation unless the navigation requests preservation. */
 export declare function ScrollRestoration(_props: ScriptProps): null;
 /** HTML attributes for server markup and client document reconciliation. */
 export interface DocumentProps extends ComponentProps<"html"> {

package/dist/preact/document.js

@@ -1,13 +1,18 @@
 import { serializeData } from "../core/serialize.js";
-import { useApplication } from "./root-context.js";
-import { useSnapshot } from "./context.js";
 import { applicationEnvironment } from "../core/environment.js";
 import { scrollPositions } from "../core/navigation.js";
+import { useApplication } from "./root-context.js";
+import { useSnapshot } from "./context.js";
 import { useNavigationSnapshot } from "./navigation-state.js";
 import { useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
 import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
 import { Fragment as Fragment$1, createElement } from "preact";
 //#region .generated/preact/document.tsx
+/**
+* Preact document metadata, resource links and hydration scripts.
+*
+* @module
+*/
 /** @jsxImportSource preact */
 function renderMeta(item, index) {
 	if (typeof item.title === "string") return /* @__PURE__ */ jsx("title", { children: item.title }, index);
@@ -21,6 +26,7 @@ function renderMeta(item, index) {
 		key: index
 	});
 }
+/** Render root or active-route metadata in the document head. */
 function Meta() {
 	const { routes, rootModule } = useApplication();
 	const snapshot = useSnapshot();
@@ -39,10 +45,12 @@ function Meta() {
 	}, [values]);
 	return /* @__PURE__ */ jsx(Fragment$1, { children: values.map(renderMeta) });
 }
+/** Render stylesheet and other link descriptors from the application root. */
 function Links() {
 	const { rootModule } = useApplication();
 	return /* @__PURE__ */ jsx(Fragment$1, { children: rootModule?.links?.().map((props, index) => /* @__PURE__ */ jsx("link", { ...props }, index)) });
 }
+/** Render the hydration snapshot and browser entry script with an optional CSP nonce. */
 function Scripts({ nonce }) {
 	const { root, rootError, router, entry, streaming, initialData } = useApplication();
 	const [json] = useState(() => {
@@ -82,6 +90,7 @@ function Scripts({ nonce }) {
 		})
 	] });
 }
+/** Reset scroll after navigation unless the navigation requests preservation. */
 function ScrollRestoration(_props) {
 	const { router } = useApplication();
 	const { url, state } = useSnapshot();

package/dist/preact/index.d.ts

@@ -1,4 +1,8 @@
-/** Framework components and typed data hooks. @module */
+/**
+ * Preact routing components, typed data hooks and application integration.
+ *
+ * @module
+ */
 export type * from "../core/index.ts";
 export { createDataRouter, createRouter, defineRoute, } from "../core/index.ts";
 export type { ApplicationEnvironment } from "../core/environment.ts";
@@ -14,5 +18,5 @@ export type { NavigateOptions } from "./navigation.tsx";
 export * from "./navigation.tsx";
 export { useMatches, useNavigation, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSubmit, } from "./route-hooks.tsx";
 export * from "./route-types.ts";
-export { Outlet, RouterApplication } from "./router.tsx";
+export { type ApplicationProps, Outlet, type OutletProps, RouterApplication, } from "./router.tsx";
 export * from "./routes.ts";

package/dist/preact/index.js

@@ -1,8 +1,8 @@
 import { defineRoute } from "../core/match.js";
 import { createRouter } from "../core/navigation-router.js";
 import { createDataRouter } from "../core/router.js";
-import { readSubmission } from "../core/submission.js";
 import { data, isRouteErrorResponse, normalizeResult, redirect, resolveData } from "../core/responses.js";
+import { readSubmission } from "../core/submission.js";
 import { Await } from "./await.js";
 import { RouterProvider, useRouter } from "./context.js";
 import { Form } from "./form.js";

package/dist/preact/lazy-route.d.ts

@@ -1,6 +1,7 @@
 import type { RouteModule } from "../core/index.ts";
 import { type ComponentType } from "preact";
 import type { AppRoute } from "./route-types.ts";
+/** Lazy route path, server transport endpoint and available handler capabilities. */
 export interface LazyRouteOptions {
     path: string;
     dataEndpoint?: string;
@@ -16,5 +17,6 @@ type LoadedRoute = RouteModule & Pick<AppRoute, "meta">;
 interface LazyAppRoute extends AppRoute {
     resolveComponent: () => ComponentType | undefined;
 }
+/** Create a route that imports its module on demand and shares the import with intent prefetching. */
 export declare function lazyRoute(options: LazyRouteOptions, importer: () => Promise<LoadedRoute>): LazyAppRoute;
 export {};

package/dist/preact/lazy-route.js

@@ -3,12 +3,18 @@ import { useRouter } from "./context.js";
 import { serverRoute } from "../client/index.js";
 import { createElement } from "preact";
 //#region .generated/preact/lazy-route.ts
+/**
+* On-demand Preact route modules with shared intent prefetching.
+*
+* @module
+*/
 function LazyView() {
 	const router = useRouter();
 	const { path } = useSyncExternalStore(router.subscribe, router.getSnapshot);
 	const Component = router.routes.find((item) => item.path === path)?.resolveComponent();
 	return Component && createElement(Component, {});
 }
+/** Create a route that imports its module on demand and shares the import with intent prefetching. */
 function lazyRoute(options, importer) {
 	let module;
 	let pending;

package/dist/preact/navigation-state.js

@@ -1,5 +1,5 @@
-import { useSyncExternalStore } from "./runtime.js";
 import { navigationStore } from "../core/navigation.js";
+import { useSyncExternalStore } from "./runtime.js";
 //#region .generated/preact/navigation-state.ts
 function useNavigationSnapshot(router) {
 	const store = navigationStore(router);

package/dist/preact/navigation.d.ts

@@ -2,7 +2,9 @@ import { type NavigateOptions } from "../core/index.ts";
 import type { ComponentProps, ReactNode } from "preact/compat";
 export type { NavigateOptions } from "../core/index.ts";
 export type { NavigationType } from "../core/navigation.ts";
+/** Navigate to a URL or move through browser history using a numeric offset. */
 export type NavigateFunction = (to: string | number | Partial<Pick<URL, "pathname" | "search" | "hash">>, options?: NavigateOptions) => void;
+/** Anchor properties and router navigation options, including document reload and prefetch controls. */
 export interface LinkProps extends Omit<ComponentProps<"a">, "href" | "role"> {
     to?: string;
     href?: string;
@@ -14,15 +16,19 @@ export interface LinkProps extends Omit<ComponentProps<"a">, "href" | "role"> {
     viewTransition?: boolean;
     reloadDocument?: boolean;
 }
+/** Active and pending flags supplied to NavLink render callbacks. */
 export interface NavLinkRenderProps {
     isActive: boolean;
     isPending: boolean;
 }
+/** Link options with matching rules and state-aware class or children callbacks. */
 export interface NavLinkProps extends Omit<LinkProps, "className" | "children"> {
     end?: boolean;
     className?: string | ((state: NavLinkRenderProps) => string);
     children?: ReactNode | ((state: NavLinkRenderProps) => ReactNode);
 }
+/** Render an anchor with same-origin router navigation and optional intent prefetching. */
 export declare function Link(options: LinkProps): ReactNode;
+/** Render a Link with active-route state and aria-current for the matching destination. */
 export declare function NavLink({ href, to, end, className, children, ...props }: NavLinkProps): ReactNode;
 export { useNavigate, useNavigationType, useSearchParams, useURLLocation, } from "./route-hooks.tsx";

package/dist/preact/navigation.js

@@ -1,10 +1,11 @@
 import { matchRoutes } from "../core/match.js";
 import { navigationClick } from "../core/url.js";
+import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
 import { createElement } from "./runtime.js";
 import { useRouter, useSnapshot } from "./context.js";
-import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
-import { useNavigate, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
+import { useNavigate, useNavigation, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
 //#region .generated/preact/navigation.tsx
+/** Render an anchor with same-origin router navigation and optional intent prefetching. */
 function Link(options) {
 	const { href: hrefProp, to = hrefProp ?? "/", replace, preventScrollReset, viewTransition, prefetch, state, reloadDocument, ...props } = options;
 	const router = useRouter();
@@ -40,13 +41,16 @@ function Link(options) {
 		}
 	});
 }
+/** Render a Link with active-route state and aria-current for the matching destination. */
 function NavLink({ href, to = href ?? "/", end, className, children, ...props }) {
 	const location = useURLLocation();
-	const target = new URL(to, location.href).pathname;
-	const isActive = location.pathname === target || !end && target !== "/" && location.pathname.startsWith(`${target}/`);
+	const destination = resolveApplicationURL(new URL(to, location.href));
+	const target = destination.pathname;
+	const isActive = destination.origin === location.origin && (location.pathname === target || !end && target !== "/" && location.pathname.startsWith(`${target}/`));
+	const pending = useNavigation().location;
 	const state = {
 		isActive,
-		isPending: false
+		isPending: !!pending && pending.origin === destination.origin && (pending.pathname === target || !end && target !== "/" && pending.pathname.startsWith(`${target}/`))
 	};
 	return createElement(Link, {
 		...props,

package/dist/preact/root-data.d.ts

@@ -1,8 +1 @@
-import type { Router } from "../core/index.ts";
-import type { RootModule } from "./route-types.ts";
-export { createStore as createRootStore } from "../core/store.ts";
-export declare function attachRootData(router: Router, initial: unknown, rootModule?: RootModule): {
-    getSnapshot: () => unknown;
-    subscribe(listener: () => void): () => void;
-    update(next: unknown): void;
-};
+export { attachRootData, createRootStore } from "../client/root-data.ts";

package/dist/preact/route-hooks.d.ts

@@ -4,29 +4,39 @@ import { type Submission, type SubmissionOptions } from "../core/submission.ts";
 import { useSnapshot } from "./context.ts";
 import type { NavigateFunction } from "./navigation.tsx";
 import type { RouteData } from "./route-types.ts";
+/** Read root loader data from the application context. */
 export declare function useRootData<T = unknown>(): RouteData<T>;
 /** Read root data or the active route's data by its manifest identifier. */
 export declare function useRouteLoaderData<T = unknown>(id: string): RouteData<T> | undefined;
 export { useSnapshot };
+/** Read the current route error for an error boundary. */
 export declare function useRouteError(): Error | undefined;
+/** Read the current page navigation or submission state. */
 export declare function useNavigation(): {
     state: "idle" | "loading" | "submitting";
     location: URL | undefined;
 };
+/** Read the active flat route match and loader data; this is not a nested layout match chain. */
 export declare function useMatches(): {
     id: string;
     data: unknown;
     params: import("../core/index.ts").Params;
 }[];
+/** Read context supplied by the nearest Outlet. */
 export declare function useOutletContext<T>(): T;
+/** Return a function that submits form data through the current router. */
 export declare function useSubmit(): (value: Submission, options?: SubmissionOptions) => Promise<void> | Promise<import("../core/index.ts").Result<unknown>>;
+/** Read the current router location as a URL. */
 export declare function useURLLocation(): URL & {
     state: unknown;
     key: string;
 };
+/** Return the application navigation function, including history offsets and relative destinations. */
 export declare function useNavigate(): NavigateFunction;
+/** Read URL search parameters and update them through router navigation. */
 export declare function useSearchParams(): [
     URLSearchParams,
     (value: URLSearchParams | Record<string, string>, options?: NavigateOptions) => void
 ];
+/** Read the last browser history operation. */
 export declare function useNavigationType(): NavigationType;

package/dist/preact/route-hooks.js

@@ -1,11 +1,12 @@
 import { submissionBody, submissionSearch } from "../core/submission.js";
+import { pendingLocation } from "../core/presentation.js";
 import { useContext, useMemo } from "./runtime.js";
 import { OutletContext, useApplication } from "./root-context.js";
 import { useRouter, useSnapshot } from "./context.js";
-import { pendingLocation } from "../core/presentation.js";
 import { useNavigationSnapshot } from "./navigation-state.js";
 import { useCallback } from "preact/hooks";
 //#region .generated/preact/route-hooks.tsx
+/** Read root loader data from the application context. */
 function useRootData() {
 	return useApplication().root;
 }
@@ -18,9 +19,11 @@ function useRouteLoaderData(id) {
 	if (!route || route.path !== snapshot.path) return void 0;
 	return snapshot.data;
 }
+/** Read the current route error for an error boundary. */
 function useRouteError() {
 	return useSnapshot("error");
 }
+/** Read the current page navigation or submission state. */
 function useNavigation() {
 	const router = useRouter();
 	const snapshot = useSnapshot();
@@ -30,18 +33,21 @@ function useNavigation() {
 		location
 	}), [snapshot.state, location?.href]);
 }
+/** Read the active flat route match and loader data; this is not a nested layout match chain. */
 function useMatches() {
-	const { routes } = useApplication();
+	const router = useRouter();
 	const snapshot = useSnapshot();
 	return [{
-		id: routes.find((item) => item.path === snapshot.path)?.id ?? "",
+		id: router.routes.find((item) => item.path === snapshot.path)?.id ?? "",
 		data: snapshot.data,
 		params: snapshot.params
 	}];
 }
+/** Read context supplied by the nearest Outlet. */
 function useOutletContext() {
 	return useContext(OutletContext);
 }
+/** Return a function that submits form data through the current router. */
 function useSubmit() {
 	const router = useRouter();
 	return useCallback((value, options = {}) => {
@@ -56,6 +62,7 @@ function useSubmit() {
 		return router.submit(target, body, { method });
 	}, [router]);
 }
+/** Read the current router location as a URL. */
 function useURLLocation() {
 	const href = useSnapshot("url");
 	const snapshot = useNavigationSnapshot(useRouter());
@@ -68,6 +75,7 @@ function useURLLocation() {
 		snapshot.key
 	]);
 }
+/** Return the application navigation function, including history offsets and relative destinations. */
 function useNavigate() {
 	const router = useRouter();
 	return useCallback((to, options) => {
@@ -80,6 +88,7 @@ function useNavigate() {
 		router.navigate(target, options);
 	}, [router]);
 }
+/** Read URL search parameters and update them through router navigation. */
 function useSearchParams() {
 	const location = useURLLocation();
 	const navigate = useNavigate();
@@ -87,6 +96,7 @@ function useSearchParams() {
 		navigate(`${location.pathname}?${new URLSearchParams(value)}`, options);
 	}, [location.pathname, navigate])];
 }
+/** Read the last browser history operation. */
 function useNavigationType() {
 	return useNavigationSnapshot(useRouter()).type;
 }