@kasperrt/smolter 0.4.1 → 0.4.3

package/dist/client/deployment.js

@@ -1,51 +1,56 @@
 import { deploymentCheck } from "./deployment-check.js";
 //#region .generated/client/deployment.ts
+var watchers = /* @__PURE__ */ new WeakMap();
 /** Check for deployment changes before navigation. Install before creating fetchers. Returns a cleanup function. */
 function watchDeployment(router, options) {
 	if (!options || typeof window === "undefined") return () => {};
+	const state = watchers.get(router) ?? {
+		sequence: 0,
+		mutations: 0
+	};
+	state.cleanup?.();
+	watchers.set(router, state);
 	const check = deploymentCheck(options);
 	const { changed, reload } = check;
 	const read = router.getSnapshot;
 	const navigate = router.navigate;
 	const dispose = router.dispose;
-	let sequence = 0;
 	let stopped = false;
 	let replay = false;
-	let mutations = 0;
 	const dataRouter = router;
 	const createFetcher = dataRouter.createFetcher;
+	const submit = dataRouter.submit;
+	const trackSubmission = (submit) => (...args) => {
+		state.sequence++;
+		state.mutations++;
+		return submit(...args).finally(() => {
+			state.mutations--;
+		});
+	};
+	const guardedSubmit = submit && trackSubmission(submit);
 	const guardedFetcher = createFetcher && (() => {
 		const fetcher = createFetcher();
-		const submit = fetcher.submit;
-		fetcher.submit = (...args) => {
-			sequence++;
-			mutations++;
-			return submit(...args).finally(() => {
-				mutations--;
-			});
-		};
+		fetcher.submit = trackSubmission(fetcher.submit);
 		return fetcher;
 	});
+	if (guardedSubmit) dataRouter.submit = guardedSubmit;
 	if (guardedFetcher) dataRouter.createFetcher = guardedFetcher;
-	const valid = (current) => current === sequence && !stopped;
-	const canReload = (current) => valid(current) && mutations === 0;
-	const unsubscribe = router.subscribe(() => {
-		if (read().state === "submitting") sequence++;
-	});
+	const valid = (current) => current === state.sequence && !stopped;
+	const canReload = (current) => valid(current) && state.mutations === 0;
 	const guarded = async (href, operation) => {
 		const target = new URL(href, router.getSnapshot().url);
 		const currentURL = new URL(router.getSnapshot().url);
-		const current = ++sequence;
+		const current = ++state.sequence;
 		if (target.origin === location.origin && (target.pathname !== currentURL.pathname || target.search !== currentURL.search) && await changed()) {
 			if (!valid(current) || await reload(target, () => canReload(current))) return;
 		}
-		if (current === sequence && !stopped) await navigate(href, operation);
+		if (current === state.sequence && !stopped) await navigate(href, operation);
 	};
 	const pop = (event) => {
 		if (replay) return;
 		const target = new URL(location.href);
 		const previous = new URL(read().url);
-		const current = ++sequence;
+		const current = ++state.sequence;
 		if (target.pathname === previous.pathname && target.search === previous.search) return;
 		event.stopImmediatePropagation();
 		changed().then(async (updated) => {
@@ -59,20 +64,22 @@ function watchDeployment(router, options) {
 	};
 	const preloadError = () => {
 		if (read().state !== "loading") return;
-		const current = sequence;
+		const current = state.sequence;
 		const target = new URL(read().url);
 		changed().then((updated) => {
 			if (updated) return reload(target, () => canReload(current) && read().state !== "submitting" && read().url === target.href);
 		});
 	};
 	function cleanup() {
+		if (stopped) return;
+		if (state.cleanup === cleanup) state.cleanup = void 0;
 		stopped = true;
-		sequence++;
+		state.sequence++;
 		check.dispose();
-		unsubscribe();
 		window.removeEventListener("popstate", pop, true);
 		window.removeEventListener("vite:preloadError", preloadError);
-		if (dataRouter.createFetcher === guardedFetcher) dataRouter.createFetcher = createFetcher;
+		if (guardedSubmit && dataRouter.submit === guardedSubmit) dataRouter.submit = submit;
+		if (guardedFetcher && dataRouter.createFetcher === guardedFetcher) dataRouter.createFetcher = createFetcher;
 		if (router.navigate === guarded) router.navigate = navigate;
 		if (router.dispose === guardedDispose) router.dispose = dispose;
 	}
@@ -80,6 +87,7 @@ function watchDeployment(router, options) {
 		cleanup();
 		dispose();
 	}
+	state.cleanup = cleanup;
 	router.navigate = guarded;
 	router.dispose = guardedDispose;
 	window.addEventListener("popstate", pop, true);

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/files/index.js

@@ -26,15 +26,16 @@ async function flatRoutes(directory) {
 				if (!entry.isFile() || !flatFile.test(name) || name.endsWith(".d.ts")) continue;
 				name = name.replace(flatFile, "");
 			}
-			if (/[()[\]:*?]/.test(name)) return /* @__PURE__ */ new Error(`Unsupported flat route name: ${name}`);
-			const segments = name.split(".");
+			const escaped = name.replaceAll("[.]", "\0");
+			if (/[()[\]:*?]/.test(escaped)) return /* @__PURE__ */ new Error(`Unsupported flat route name: ${name}`);
+			const segments = escaped.split(".");
 			const parts = [];
 			for (const [index, segment] of segments.entries()) {
 				if (!segment) return /* @__PURE__ */ new Error(`Empty route segment: ${name}`);
 				if (segment === "_index" && index !== segments.length - 1) return /* @__PURE__ */ new Error(`_index must be last: ${name}`);
 				if (segment === "$" && index !== segments.length - 1) return /* @__PURE__ */ new Error(`Splat must be last: ${name}`);
 				if (segment.startsWith("_")) continue;
-				const part = segment.replace(/_$/, "");
+				const part = segment.replace(/_$/, "").replaceAll("\0", ".");
 				parts.push(part === "$" ? "*" : part.replace(/^\$/, ":"));
 			}
 			if (segments.at(-1)?.startsWith("_") && segments.at(-1) !== "_index") continue;

package/dist/preact/await-fallback.d.ts

@@ -0,0 +1,4 @@
+import type { AwaitProps } from "./await.tsx";
+export declare function AwaitFallback<T>({ resolve, fallback, errorElement, children, }: AwaitProps<T> & {
+    resolve: Promise<T>;
+}): import("preact").ComponentChildren;

package/dist/preact/await-fallback.js

@@ -0,0 +1,29 @@
+import { useEffect, useState } from "preact/hooks";
+//#region .generated/preact/await-fallback.tsx
+/** @jsxImportSource preact */
+function AwaitFallback({ resolve, fallback, errorElement, children }) {
+	const [result, setResult] = useState();
+	useEffect(() => {
+		let current = true;
+		resolve.then((value) => {
+			if (current) setResult({
+				source: resolve,
+				value
+			});
+		}, (error) => {
+			if (current) setResult({
+				source: resolve,
+				error
+			});
+		});
+		return () => {
+			current = false;
+		};
+	}, [resolve]);
+	if (!result || result.source !== resolve) return fallback;
+	if ("value" in result) return children(result.value);
+	if (errorElement !== void 0) return errorElement;
+	throw result.error;
+}
+//#endregion
+export { AwaitFallback };

package/dist/preact/await.d.ts

@@ -1,7 +1,11 @@
+/** @jsxImportSource preact */
 import type { ComponentChildren } from "preact";
 export interface AwaitProps<T> {
     resolve: T | Promise<T>;
     children: (value: Awaited<T>) => ComponentChildren;
     errorElement?: ComponentChildren;
+    /** Component-owned pending content, safe during early hydration. Pass null to render nothing. */
+    fallback?: ComponentChildren;
 }
-export declare function Await<T>({ resolve, children, errorElement, }: AwaitProps<T>): 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

@@ -1,8 +1,27 @@
-import { use } from "preact/compat";
+import { AwaitFallback } from "./await-fallback.js";
+import { Application } from "./root-context.js";
+import { use, useContext } from "preact/compat";
+import { jsx } from "preact/jsx-runtime";
 //#region .generated/preact/await.tsx
 var resolutions = /* @__PURE__ */ new WeakMap();
-function Await({ resolve, children, errorElement }) {
-	if (!(resolve instanceof Promise)) return children(resolve);
+/** 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);
+	if (!("fallback" in props)) return /* @__PURE__ */ jsx(SuspendedAwait, {
+		...props,
+		resolve: props.resolve
+	});
+	if (app?.deferredBoundary) return app.deferredBoundary(/* @__PURE__ */ jsx(SuspendedAwait, {
+		...props,
+		resolve: props.resolve
+	}), props.fallback);
+	return /* @__PURE__ */ jsx(AwaitFallback, {
+		...props,
+		resolve: props.resolve
+	});
+}
+function SuspendedAwait({ resolve, children, errorElement }) {
 	let pending = resolutions.get(resolve);
 	if (!pending) {
 		pending = resolve.then((value) => ({ value }), (error) => ({ error }));

package/dist/preact/client.d.ts

@@ -1,12 +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,10 +13,15 @@ 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 } = typeof options === "boolean" ? { hash: options } : options;
+	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);
 	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.().catch(async (error) => {
 		await recoverDeployment(deployment, initialURL);
@@ -24,7 +29,7 @@ async function mountApplication(routes, rootModule, options = false) {
 	});
 	routes = prepareRoutes(routes);
 	const element = document.getElementById("smolter-data");
-	const initial = element?.textContent ? readHydration(element.textContent) : void 0;
+	const initial = element?.textContent ? readHydration(element.textContent, deferredTimeout) : void 0;
 	const hydration = initial?.hydration;
 	if (hydration?.snapshot.error) hydration.snapshot.error = Object.assign(new Error(hydration.snapshot.error.message), hydration.snapshot.error);
 	const router = createDataRouter(routes, {

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

@@ -3,7 +3,7 @@ export interface DeferredWindow extends Window {
     __smolterDeferred?: Settlement[];
 }
 /** Restore promise identity before hydrating Suspense boundaries. */
-export declare function readHydration(json: string): {
+export declare function readHydration(json: string, timeout?: number): {
     hydration: any;
     dispose: () => void;
 };

package/dist/preact/deferred-hydration.js

@@ -1,6 +1,7 @@
 //#region .generated/preact/deferred-hydration.ts
 /** Restore promise identity before hydrating Suspense boundaries. */
-function readHydration(json) {
+function readHydration(json, timeout = 3e4) {
+	if (!Number.isInteger(timeout) || timeout < 1 || timeout > 2147483647) throw new RangeError("deferredTimeout must be an integer between 1 and 2147483647 ms");
 	const pending = /* @__PURE__ */ new Map();
 	const queue = window.__smolterDeferred ??= [];
 	function revive(_key, value) {
@@ -34,11 +35,16 @@ function readHydration(json) {
 	}
 	const hydration = JSON.parse(json, revive);
 	const dispose = () => {
+		clearTimeout(deadline);
 		window.removeEventListener("DOMContentLoaded", dispose);
 		for (const target of pending.values()) target.reject(/* @__PURE__ */ new Error("Hydration stream closed"));
 		pending.clear();
 		queue.push = () => 0;
 	};
+	const deadline = pending.size ? setTimeout(() => {
+		for (const target of pending.values()) target.reject(/* @__PURE__ */ new Error("Hydration stream timed out"));
+		dispose();
+	}, timeout) : void 0;
 	const receive = (packet) => {
 		const [id, value, error] = packet;
 		if (id === -1) return dispose();

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 { useNavigationSnapshot } from "./navigation-state.js";
-import { useApplication } from "./root-context.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 { 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/root-context.d.ts

@@ -6,6 +6,7 @@ export interface ApplicationContext {
     root: unknown;
     rootError?: boolean;
     streaming?: boolean;
+    deferredBoundary?: (children: import("preact").ComponentChildren, fallback: import("preact").ComponentChildren) => import("preact").ComponentChildren;
     initialData?: string;
     rootModule?: RootModule;
     hydration?: Hydration;