@kasperrt/smolter 0.4.2 → 0.4.3

package/.generated/server/assets.ts

@@ -1,11 +1,18 @@
+/**
+ * Production route asset discovery for SSR preload hints.
+ *
+ * @module
+ */
 import { matchRoutes } from "../core/index.ts";
 
+/** Emitted JavaScript and stylesheet URLs associated with a route. */
 export interface RouteAssets {
   path: string;
   files: string[];
   styles?: string[];
 }
 
+/** Collect matched-route JavaScript and stylesheet assets from the production route manifest. */
 export function routePreloads(
   routes: RouteAssets[],
   pathname: string,

package/.generated/server/handler.ts

@@ -8,6 +8,7 @@ export interface ServerBuild {
   handleDataRequest: (request: Request) => Response | Promise<Response>;
 }
 
+/** SSR build, browser entry URL and application-scoped data endpoint for Node or Express. */
 export interface RequestHandlerOptions {
   build: ServerBuild;
   /** Browser entry URL resolved from Vite's production manifest. */
@@ -16,12 +17,14 @@ export interface RequestHandlerOptions {
   dataEndpoint?: string;
 }
 
+/** Node request with optional Express protocol and original URL information. */
 export interface ServerIncomingMessage extends IncomingMessage {
   /** Express supplies this using the application's trust proxy policy. */
   protocol?: string;
   originalUrl?: string;
 }
 
+/** Express-compatible callback for forwarding middleware errors. */
 export type NextHandler = (error?: unknown) => void;
 
 /** Node/Express middleware; mount after metrics, tracing and static assets. */

package/.generated/server/http.ts

@@ -3,6 +3,7 @@ import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import type { ServerIncomingMessage } from "./handler.ts";
 
+/** Convert a Node request to a Web Request with cancellation and an optional normalized route target. */
 export async function webRequest(
   incoming: ServerIncomingMessage,
   outgoing: ServerResponse,
@@ -40,6 +41,7 @@ interface StreamingResponse extends ServerResponse {
   flush?: () => void;
 }
 
+/** Write a Web Response to Node with streaming backpressure and disconnect cancellation. */
 export async function send(response: Response, outgoing: StreamingResponse) {
   outgoing.statusCode = response.status;
   response.headers.forEach((value, name) => {

package/.generated/server/node.ts

@@ -1,4 +1,7 @@
-/** Optional application integration. @module */
-
+/**
+ * Streaming Node and Express adapters for Web requests and responses.
+ *
+ * @module
+ */
 export * from "./handler.ts";
 export * from "./http.ts";

package/.generated/server/preact.ts

@@ -1,5 +1,8 @@
-/** Preact server rendering and HTTP data dispatch. @module */
-
+/**
+ * Preact SSR rendering and route data dispatch.
+ *
+ * @module
+ */
 export {
   dispatchRoute,
   type RenderApplicationOptions,

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.3
+
+- Prefetch individual guide articles on pointer, keyboard and touch intent. Keep the shared header, sidebar and current article visible during cold guide navigation; show a quiet pending status without replacing the layout. Link the header directly to the canonical Getting started guide.
+- Publish compact React/Preact and SSR compatibility indicators in guide navigation and detailed support information on each page.
+- Document every public JSR entrypoint and exported symbol. Validate the generated documentation before publishing, preserving JSR-before-npm release ordering.
+
+- Add React `Outlet`, `useMatches` and `useOutletContext`; allow Preact matches under a plain RouterProvider. Show renderer and SSR compatibility in documentation navigation and on each page. Integrated document/early-hydration APIs remain Preact-only.
+
+- Remove the public `safeWrapAsync` utility; retain it internally for router and server error handling. Existing consumers of this export must provide their own error handling. `useMatches` and `useOutletContext` remain public Preact APIs.
+
 ## 0.4.2
 
 - Add integrated `Await fallback` for early hydration: pending and resolved content belongs to the mounted component, so navigation, root revalidation and late settlement cannot leave abandoned content behind. Migrate early-hydrated deferred sections from outer Preact `Suspense` to this prop, including root sections. Native Preact streamed Suspense remains unsupported for this ownership contract; it is not patched. Ordinary non-early SSR still streams resolved HTML.

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.2%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.2%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&bundle)
-[![preact gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.2%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.2%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&bundle)
+[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.3%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.3%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&bundle)
+[![preact gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.3%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.3%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&bundle)
 <!-- bundlejs:end -->
 
 A typed data router for React and Preact. **Zero runtime dependencies.**
@@ -14,9 +14,9 @@ loader; `shouldRevalidate` decides when that work is needed.
 Inspired by [wouter](https://github.com/molefrog/wouter)
 and [React Router](https://reactrouter.com/).
 
-[Read the documentation](https://kasperrt.github.io/smolter/react/docs/) for guides and the complete API reference. The site itself uses smolter routes.
+[Read the documentation](https://kasperrt.github.io/smolter/docs/) for guides and the complete API reference. The prerendered site uses Preact and Smolter routes. Articles load individually; React examples remain available in the repository.
 
-Start with [loaders](https://kasperrt.github.io/smolter/react/docs/loaders/), [actions](https://kasperrt.github.io/smolter/react/docs/actions/), [forms and validation](https://kasperrt.github.io/smolter/react/docs/forms/), or [fetcher reads and mutations](https://kasperrt.github.io/smolter/react/docs/fetchers/). Each guide connects the handler to an actual route URL and its consuming view.
+Start with [loaders](https://kasperrt.github.io/smolter/docs/loaders/), [actions](https://kasperrt.github.io/smolter/docs/actions/), [forms and validation](https://kasperrt.github.io/smolter/docs/forms/), or [fetcher reads and mutations](https://kasperrt.github.io/smolter/docs/fetchers/). Each guide connects the handler to an actual route URL and its consuming view.
 
 ## Contents
 
@@ -445,18 +445,18 @@ Choose one renderer for your application. Both expose the same routing API:
 | SSR and HTTP data dispatch | `@kasperrt/smolter/react/server` | `@kasperrt/smolter/preact/server` |
 | Vite plugin and flat-file discovery | `@kasperrt/smolter/react/vite` | `@kasperrt/smolter/preact/vite` |
 
-`@kasperrt/smolter/utils` contains browser-safe matching and error helpers.
+`@kasperrt/smolter/utils` contains browser-safe matching and URL helpers.
 The main renderer entries never import server or build modules. Named imports
 are tree-shaken; optional transport is included only when you import `/client`.
 Server entries do not import either UI renderer. Vite entries are build-time only.
 
 **Migrating renderer subpaths:** replace `/core` imports for types, router factories, and
 `defineRoute` with your renderer entry. Use `/utils` for `matchRoutes`,
-`internalURL` and `safeWrapAsync`. Move `/client`, `/server`,
+and `internalURL`. Move `/client`, `/server`,
 `/files`, and `/vite` imports to the corresponding renderer-prefixed path above.
 The bare package root and old top-level subpaths are no longer exported.
 
-See the [0.3 migration guide](https://kasperrt.github.io/smolter/react/docs/migration-0.3/) and [changelog](./CHANGELOG.md).
+See the [0.3 migration guide](https://kasperrt.github.io/smolter/docs/migration-0.3/) and [changelog](./CHANGELOG.md).
 
 **Router factory migration:** code that previously used `createRouter` with
 loaders, actions, fetchers or revalidation must now use `createDataRouter`.
@@ -525,7 +525,7 @@ re-exports and installs server proxies. `entry.client.tsx` and `entry.server.tsx
 are application-owned files wiring those manifests to hydration and SSR.
 Manual tables can be imported directly instead.
 
-See the [virtual routes guide](https://kasperrt.github.io/smolter/react/docs/virtual-routes)
+See the [virtual routes guide](https://kasperrt.github.io/smolter/docs/virtual-routes)
 for the exact contract, TypeScript declaration, and both entrypoint examples.
 
 ### Express hosting
@@ -537,7 +537,7 @@ server entry and `entry` is the browser entry URL from Vite's manifest. Do not
 consume request bodies with Express body parsers before this handler.
 The adapter has no Express dependency and forwards failures to `next(error)`.
 
-See the [Express guide](https://kasperrt.github.io/smolter/react/docs/express)
+See the [Express guide](https://kasperrt.github.io/smolter/docs/express)
 for a complete server example and streaming and hydration behavior.
 
 ## Resource subscriptions
@@ -607,12 +607,12 @@ a claim of identical features.
 | `React Router: data routing subset` | 29780 |
 | `React: routing-only named exports` | 1245 |
 | `Preact: routing-only named exports` | 1405 |
-| `@kasperrt/smolter/react` | 2948 |
-| `@kasperrt/smolter/preact` | 5024 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 4281 |
-| `@kasperrt/smolter/preact + server transport` | 6300 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9405 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9692 |
+| `@kasperrt/smolter/react` | 3082 |
+| `@kasperrt/smolter/preact` | 5016 |
+| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 4419 |
+| `@kasperrt/smolter/preact + server transport` | 6291 |
+| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9398 |
+| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9685 |
 | `@kasperrt/smolter/react/data (optional resource API)` | 2962 |
 | `React: common routing/data exports` | 2761 |
 | `Preact: common routing/data exports` | 3046 |
@@ -735,7 +735,7 @@ normally, and a session marker prevents reload loops. Development/SSR builds
 disable the helper. This optional client module adds nothing to the routing-only
 entrypoints and never replays form submissions.
 
-See [deployment updates](https://kasperrt.github.io/smolter/react/docs/deployments/)
+See [deployment updates](https://kasperrt.github.io/smolter/docs/deployments/)
 for Express, CDN paths, TypeScript declarations and unsaved-state handling.
 
 

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/resource-types.d.ts

@@ -1,13 +1,16 @@
 export type Params = Readonly<Record<string, string>>;
+/** Resource parameters and cancellation signal supplied to a loader. */
 export interface LoaderFunctionArgs {
     params: Params;
     signal: AbortSignal;
 }
+/** Submitted input, resource parameters and cancellation signal supplied to an action. */
 export interface ActionFunctionArgs<Input = unknown> {
     input: Input;
     params: Params;
     signal: AbortSignal;
 }
+/** Successful resource data or a normalized resource failure. */
 export interface DataResult<Data> {
     data: Data | null;
     error: string;
@@ -18,6 +21,7 @@ export interface ResourceModule {
     loader?: (args: LoaderFunctionArgs) => Promise<DataResult<unknown>>;
     shouldRevalidate?: (args: ShouldRevalidateFunctionArgs) => boolean;
 }
+/** Navigation or mutation context used to decide whether loader data should refresh. */
 export interface ShouldRevalidateFunctionArgs {
     actionResult: DataResult<unknown>;
     defaultShouldRevalidate: boolean;

package/dist/core/resources.d.ts

@@ -1,4 +1,5 @@
 import type { DataResult, Params, ResourceModule, RouteState } from "./resource-types.ts";
+/** Manage keyed resource reads, submissions, subscriptions and cancellation independently of navigation. */
 export declare class ResourceRouter {
     #private;
     constructor(routes: ReadonlyMap<string, ResourceModule>);
@@ -16,4 +17,5 @@ export declare class ResourceRouter {
     retry(routeId: string, params: Params): Promise<DataResult<unknown>>;
     reportUnexpected(routeId: string, params: Params): void;
 }
+/** Create an independent resource-data router from registered modules; this does not manage URL history. */
 export declare function createResourceRouter(routes: ReadonlyMap<string, ResourceModule>): ResourceRouter;

package/dist/core/resources.js

@@ -11,6 +11,7 @@ var IDLE_ROUTE_STATE = {
 	navigationState: "idle",
 	unexpectedError: false
 };
+/** Manage keyed resource reads, submissions, subscriptions and cancellation independently of navigation. */
 var ResourceRouter = class {
 	#cleanupTimers = /* @__PURE__ */ new Map();
 	#controllers = /* @__PURE__ */ new Map();
@@ -333,6 +334,7 @@ var ResourceRouter = class {
 		for (const listener of this.#listeners.get(routeKey) ?? []) listener();
 	}
 };
+/** Create an independent resource-data router from registered modules; this does not manage URL history. */
 function createResourceRouter(routes) {
 	return new ResourceRouter(routes);
 }

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

@@ -13,8 +13,13 @@ 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);

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

@@ -8,6 +8,11 @@ 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 { Outlet, type OutletProps, RouterApplication } from "./router.tsx";
 export * from "./routes.ts";

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.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

@@ -5,6 +5,7 @@ import { useRouter, useSnapshot } from "./context.js";
 import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
 import { useNavigate, 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,6 +41,7 @@ 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;

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;