@kasperrt/smolter 0.4.1 → 0.4.3

package/.generated/preact/route-types.ts

@@ -7,30 +7,38 @@ import type {
 import type { DataResponse } from "../core/responses.ts";
 import type { ComponentType, ReactNode } from "preact/compat";
 
+/** Request, route parameters and cancellation signal supplied to a loader. */
 export interface LoaderFunctionArgs extends DataArgs {
   context?: unknown;
 }
 
+/** Request, route parameters and cancellation signal supplied to an action. */
 export type ActionFunctionArgs = LoaderFunctionArgs;
 
+/** Loader arguments with a serverLoader callback for the server transport. */
 export interface ClientLoaderFunctionArgs extends LoaderFunctionArgs {
   serverLoader: <T = unknown>() => Promise<T>;
 }
 
+/** Action arguments with a serverAction callback for the server transport. */
 export interface ClientActionFunctionArgs extends LoaderFunctionArgs {
   serverAction: <T = unknown>() => Promise<T>;
 }
 
+/** Navigation or mutation context used to decide whether loader data should refresh. */
 export type ShouldRevalidateFunctionArgs = RevalidationArgs;
 
 type UnwrapData<T> = T extends DataResponse<infer V> ? V : T;
 
+/** Infer successful loader data, unwrapping promises and data responses. */
 export type RouteData<T> = T extends (...args: never[]) => infer R
   ? UnwrapData<Exclude<Awaited<R>, Response | Error>>
   : T;
 
+/** A document metadata descriptor, such as a title, meta tag or structured-data record. */
 export type MetaDescriptor = Record<string, unknown>;
 
+/** Loader data, error, parameters and location supplied to a route metadata function. */
 export interface MetaArgs<T> {
   data: RouteData<T> | undefined;
   loaderData: RouteData<T> | undefined;
@@ -39,10 +47,13 @@ export interface MetaArgs<T> {
   location: URL;
 }
 
+/** Derive document metadata descriptors from the current route data and location. */
 export type MetaFunction<T = unknown> = (args: MetaArgs<T>) => MetaDescriptor[];
 
+/** Return link descriptors rendered in the document head. */
 export type LinksFunction = () => Record<string, string>[];
 
+/** Data route with optional lazy component, preload and document metadata integration. */
 export interface AppRoute extends Route {
   resolveComponent?: () => ComponentType | undefined;
   preload?: () => Promise<void>;
@@ -51,6 +62,7 @@ export interface AppRoute extends Route {
   meta?: MetaFunction;
 }
 
+/** Root document components, loader, metadata and revalidation policy for a Preact application. */
 export interface RootModule {
   /** Route identity used by targeted revalidation. Defaults to root. */
   id?: string;
@@ -65,12 +77,14 @@ export interface RootModule {
   shouldRevalidate?: (args: RevalidationArgs) => boolean;
 }
 
+/** Serialized root data and route snapshot used to hydrate without repeating initial loaders. */
 export interface Hydration {
   rootError?: boolean;
   root: unknown;
   snapshot: Snapshot;
 }
 
+/** Transform a data transport response using the current request context. */
 export type HandleDataRequestFunction = (
   response: Response,
   args: LoaderFunctionArgs,

package/.generated/preact/router.tsx

@@ -14,11 +14,13 @@ import type { AppRoute } from "./route-types.ts";
 import { Routes } from "./routes.ts";
 import { useContext, useMemo, useSyncExternalStore } from "./runtime.ts";
 
+/** Optional children and context shared with descendants through useOutletContext. */
 export interface OutletProps {
   context?: unknown;
   children?: ReactNode;
 }
 
+/** Render supplied children or the active route, and provide outlet context to descendants. */
 export function Outlet({
   context,
   children,
@@ -37,6 +39,7 @@ export interface ApplicationProps extends ApplicationContext {
   rootStore?: ReturnType<typeof createRootStore>;
 }
 
+/** Render a Preact root document and active route with shared root data and application context. */
 export function RouterApplication(
   props: ApplicationProps,
 ): import("preact").JSX.Element {

package/.generated/react/data.ts

@@ -1,4 +1,8 @@
-/** Resource subscriptions independent of URL navigation. @module */
+/**
+ * Independent React resource data, forms and subscriptions.
+ *
+ * @module
+ */
 export type {
   ActionFunctionArgs as ResourceActionArgs,
   DataResult as ResourceResult,

package/.generated/react/index.ts

@@ -1,4 +1,8 @@
-/** Framework components and typed data hooks. @module */
+/**
+ * React routing components, typed data hooks and forms.
+ *
+ * @module
+ */
 export type * from "../core/index.ts";
 export {
   createDataRouter,
@@ -14,4 +18,10 @@ export * from "./fetcher.ts";
 export * from "./form.ts";
 export * from "./hooks.ts";
 export * from "./link.ts";
+export {
+  Outlet,
+  type OutletProps,
+  useMatches,
+  useOutletContext,
+} from "./outlet.ts";
 export * from "./routes.ts";

package/.generated/react/outlet.ts

@@ -0,0 +1,48 @@
+import { useRouter, useSnapshot } from "./context.ts";
+import { Routes } from "./routes.ts";
+import {
+  createContext,
+  createElement,
+  type ReactNode,
+  useContext,
+} from "./runtime.ts";
+
+const OutletContext = createContext<unknown>(undefined);
+
+/** Optional children and context shared with descendants through useOutletContext. */
+export interface OutletProps {
+  context?: unknown;
+  children?: ReactNode;
+}
+
+/** Render the active route under a layout's shared context. */
+export function Outlet({ context, children }: OutletProps): ReactNode {
+  const inherited = useContext(OutletContext);
+  return createElement(
+    OutletContext.Provider,
+    { value: context ?? inherited },
+    children ??
+      createElement(Routes, {
+        fallback: createElement("p", { role: "status" }, "Loading…"),
+      }),
+  );
+}
+
+/** Read the nearest Outlet's context. */
+export function useOutletContext<T>(): T {
+  return useContext(OutletContext) as T;
+}
+
+/** Read the active flat route match; this is not a nested layout match chain. */
+export function useMatches(): {
+  id: string;
+  data: unknown;
+  params: import("../core/index.ts").Params;
+}[] {
+  const router = useRouter();
+  const snapshot = useSnapshot();
+  const route = router.routes.find((item) => item.path === snapshot.path);
+  return [
+    { id: route?.id ?? "", data: snapshot.data, params: snapshot.params },
+  ];
+}

package/.generated/react/resources/components.tsx

@@ -23,6 +23,7 @@ import {
   useSyncExternalStore,
 } from "react";
 
+/** Resource handlers with optional React content, pending UI and retry boundary. */
 export interface ResourceRouteModule extends ResourceModule {
   default?: ComponentType;
   ErrorBoundary?: ComponentType<{ retry: () => void }>;
@@ -42,6 +43,7 @@ interface RouterProviderProps extends PropsWithChildren {
   router: ResourceRouter;
 }
 
+/** Provide a resource router and load initial matches; dispose it when unmounted. */
 export function RouterProvider({
   children,
   initialMatches = EMPTY_MATCHES,
@@ -66,6 +68,7 @@ interface RouteProps extends PropsWithChildren {
   routeId: string;
 }
 
+/** Provide a resource route and render its content, loading state or retry boundary. */
 export function Route({
   children,
   params = {},
@@ -121,12 +124,14 @@ export function Route({
   );
 }
 
+/** Read the current resource route loader result. */
 export function useLoaderData<Data>(): Data | null {
   const route = useCurrentRoute();
 
   return useRouteLoaderData<Data>(route.routeId, route.params);
 }
 
+/** Read loader data for a registered resource route. */
 export function useRouteLoaderData<Data>(
   routeId: string,
   params: Params = {},
@@ -136,6 +141,7 @@ export function useRouteLoaderData<Data>(
   return state.loaderData as Data | null;
 }
 
+/** Read the current resource route action result. */
 export function useActionData<Data>(): Data | null {
   const route = useCurrentRoute();
   const state = useRouteState(route.routeId, route.params, false);
@@ -143,6 +149,7 @@ export function useActionData<Data>(): Data | null {
   return state.actionData as Data | null;
 }
 
+/** Read the current page navigation or submission state. */
 export function useNavigation(): { state: NavigationState } {
   const route = useCurrentRoute();
   const state = useRouteState(route.routeId, route.params, false);
@@ -150,6 +157,7 @@ export function useNavigation(): { state: NavigationState } {
   return { state: state.navigationState };
 }
 
+/** Return the resource route revalidation function. */
 export function useRevalidator(): {
   revalidate: () => Promise<DataResult<unknown>>;
   state: string;
@@ -183,6 +191,7 @@ interface FormProps extends PropsWithChildren {
   params?: Params;
 }
 
+/** Submit a resource action from a form without document navigation. */
 export function Form({
   action,
   children,
@@ -208,6 +217,7 @@ export function Form({
   return <FormContext.Provider value={submit}>{children}</FormContext.Provider>;
 }
 
+/** Return a function that submits form data through the current router. */
 export function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>> {
   const submit = useContext(FormContext);
 
@@ -216,6 +226,7 @@ export function useSubmit(): (input?: unknown) => Promise<DataResult<unknown>> {
   return submit;
 }
 
+/** Read or mutate a resource independently of the rendered route. */
 export function useFetcher<Data = unknown>(
   options: FetcherOptions = {},
 ): readonly [
@@ -312,6 +323,7 @@ export function useFetcher<Data = unknown>(
   return [fetcherState, fetcherOperations] as const;
 }
 
+/** Read the resource router supplied by its provider. */
 export function useRouter(): ResourceRouter {
   const router = useContext(RouterContext);
 

package/.generated/server/application.tsx

@@ -9,17 +9,21 @@ import {
 import type { AppRoute, RootModule } from "../preact/route-types.ts";
 import { prepareRoutes, RouterApplication } from "../preact/router.tsx";
 import { loadRouter } from "./index.ts";
+import type { ComponentChildren } from "preact";
+import { Suspense } from "preact/compat";
 import { renderToReadableStream } from "preact-render-to-string/stream";
 import { deferredHydration } from "./deferred-hydration.ts";
 import { privateResponse } from "./private-response.ts";
 import { progressiveDocument } from "./progressive-document.ts";
 import { resolveHydration, streamDocument } from "./stream-document.ts";
 
+/** SSR settings for CSP nonce and early deferred-data hydration. */
 export interface RenderApplicationOptions {
   nonce?: string;
   earlyHydration?: boolean;
 }
 
+/** Render a Preact application response with root and route data, streaming deferred content when enabled. */
 export async function renderApplication(
   request: Request,
   routes: AppRoute[],
@@ -147,6 +151,7 @@ export async function renderApplication(
       entry={entry}
       rootError={Boolean(rootError)}
       streaming
+      deferredBoundary={options.earlyHydration ? undefined : deferredBoundary}
       initialData={deferred?.initial}
       document
     />,
@@ -181,6 +186,13 @@ export async function renderApplication(
   );
 }
 
+function deferredBoundary(
+  children: ComponentChildren,
+  fallback: ComponentChildren,
+) {
+  return <Suspense fallback={fallback}>{children}</Suspense>;
+}
+
 async function dispatch(
   request: Request,
   routes: AppRoute[],
@@ -250,6 +262,7 @@ async function dispatch(
   return Response.json((await normalizeResult(value)) ?? null);
 }
 
+/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
 export async function dispatchRoute(
   request: Request,
   routes: AppRoute[],

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/.generated/vite/application/lazy-files.ts

@@ -87,10 +87,7 @@ export function lazyFiles(
         const source = await readFile(route.file, "utf8");
         const transformed = await transformWithOxc(source, route.file);
         const ast = this.parse(transformed.code);
-        const fields: Record<string, string | boolean> = {
-          path: route.path,
-          dataEndpoint,
-        };
+        const fields: Record<string, string | boolean> = {};
 
         for (const statement of ast.body) {
           if (statement.type === "ExportDefaultDeclaration") {
@@ -120,22 +117,18 @@ export function lazyFiles(
           for (const declaration of statement.declaration.declarations) {
             if (declaration.id.type === "Identifier")
               fields[declaration.id.name] = true;
-
-            if (
-              declaration.id.type !== "Identifier" ||
-              declaration.init?.type !== "Literal" ||
-              typeof declaration.init.value !== "string"
-            )
-              continue;
-
-            const name = declaration.id.name;
-
-            if (name === "id") fields.id = declaration.init.value;
-
-            if (name === "routePath") fields.path = declaration.init.value;
           }
         }
 
+        if (fields.id || fields.routePath)
+          return this.error(
+            `File routes derive identity and paths from filenames: remove id/routePath exports from ${route.file}. Use [.] for a literal dot.`,
+          );
+
+        // Export discovery records capabilities, never routing configuration.
+        fields.path = route.path;
+        fields.dataEndpoint = dataEndpoint;
+
         const file = `${route.file.replaceAll("\\", "/")}?smolter-client`;
 
         if (fields.default) modules.set(file, String(fields.path));

package/.generated/vite/index.ts

@@ -152,6 +152,20 @@ export function routerPlugin({
         for (const statement of ast.body) {
           if (statement.type !== "ExportNamedDeclaration") continue;
 
+          const declared = statement.declaration;
+          const names = statement.specifiers.map((specifier) =>
+            specifier.exported.type === "Identifier"
+              ? specifier.exported.name
+              : specifier.exported.value,
+          );
+          if (declared?.type === "VariableDeclaration")
+            for (const item of declared.declarations)
+              if (item.id.type === "Identifier") names.push(item.id.name);
+          if (names.some((name) => name === "id" || name === "routePath"))
+            return this.error(
+              `File routes derive identity and paths from filenames: remove id/routePath exports from ${file}. Use [.] for a literal dot.`,
+            );
+
           for (const specifier of statement.specifiers) {
             const name =
               specifier.exported.type === "Identifier"

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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.
+- Preserve deployment recovery ownership across overlapping page/fetcher submissions and watcher replacement, including old cleanup calls. Mutations are not replayed and pending submissions continue to prevent recovery reloads.
+- Bound initial deferred-data hydration with one total deadline (30 seconds by default); validate integer millisecond budgets, reject outstanding promises on expiry and clear lifecycle state on disposal. This is not an inactivity timer or an immediate network-disconnect detector.
+- Support literal dots in flat route filenames and folders: `robots[.]txt` maps to `/robots.txt`. Generated file routes reject `id` and `routePath` overrides; derive identity from their filename and use their path for targeted revalidation. Manually defined route arrays retain explicit identities.
+- Keep the thirteen-case ownership matrix, streaming/CSP/head-preservation checks, scoped transports, deployment recovery and route HMR as production regression gates. Preserve the native Preact diagnostic separately; passing Smolter tests do not claim native Preact or Vibes/device parity.
+
 ## 0.4.1
 
 - Invalidate pending deployment recovery when an independent fetcher submits. Prevent recovery reloads while any tracked fetcher submission is pending, without blocking ordinary client navigation. Install the watcher before creating fetchers; mountApplication already does this.

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.1%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.1%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.1%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.1%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
 
@@ -123,7 +123,11 @@ route folders are ignored. `.ts`, `.tsx`, `.js`, and `.jsx` are supported.
 **Only flat matching:** there are no nested outlets, inherited loaders, or layout
 chains. A pathless group module itself is not rendered or executed. Group names
 do not provide authentication. Static paths are ordered before parameters, then
-splats. Conflicting patterns and unsupported optional/escaped syntax are rejected.
+splats. Escape a literal dot with `[.]`: `robots[.]txt.ts` and
+`robots[.]txt/route.ts` both map to `/robots.txt`. File routes derive their
+identity and URL from their filename; do not export `id` or `routePath`.
+Target revalidation with the generated path (or `root` for root data).
+Conflicting patterns and unsupported optional/bracket syntax are rejected.
 
 For the virtual module, add this declaration to your app:
 
@@ -441,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`.
@@ -521,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
@@ -533,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
@@ -603,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` | 4842 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 4186 |
-| `@kasperrt/smolter/preact + server transport` | 6033 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9034 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9314 |
+| `@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 |
@@ -731,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.
 
 
@@ -748,7 +752,7 @@ import { mountApplication } from "@kasperrt/smolter/preact/client";
 await mountApplication(routes, root, { deployment });
 ```
 
-Preact SSR starts root and route loaders concurrently. Return nested promises and render them with `Await` inside `Suspense` to stream a shell before optional data resolves. The Node/Express adapter streams the response; hydration starts after the document stream finishes by default. Pass `{ earlyHydration: true }` to `renderApplication` to hydrate the shell while optional promises stream independently. Root-loader failures render the root error boundary. Vite development HTML transformation still buffers the document.
+Preact SSR starts root and route loaders concurrently. Return nested promises and use `Await` with an explicit `fallback` for component-owned pending content during early hydration. The Node/Express adapter streams the response; hydration starts after the document stream finishes by default. Pass `{ earlyHydration: true }` to `renderApplication` to hydrate the shell while optional promises stream independently. Initial deferred values share a total 30-second budget after their payload is read, not an inactivity timeout or reliable disconnect detector. Settlements do not extend it; configure `mountApplication` with `{ deferredTimeout: 60_000 }` for intentionally slower data (integer milliseconds from 1 through 2147483647; invalid values throw RangeError). A broken document can emit no completion event, so this deadline rejects unfinished values without retrying requests. Root-loader failures render the root error boundary. Vite development HTML transformation still buffers the document.
 
 Successful action redirects refresh registered root data without replaying the mutation. Loader arguments expose `reason` to distinguish initial loads, navigation, revalidation and fetcher reads without comparing browser URLs.
 
@@ -780,3 +784,19 @@ The generated route asset manifest follows static imports for each route and lea
 The file-router build emits `.vite/route-assets.json` with each route's static JavaScript dependency closure and its CSS in `styles`. `routePreloads` from `@kasperrt/smolter/utils/assets` produces modulepreload hints for JavaScript and `preload; as=style; crossorigin` hints for CSS (matching Vite’s anonymous CORS mode), respecting your CDN/base URL. Set these hints on the document response or send Early Hints from your host. Stylesheet preloads fetch files; they do not apply styles. Keep the application stylesheet links and Vite's CSS handling in place. Optional dynamic imports are excluded, and unrelated routes stay lazy.
 
 Root stylesheet URL imports such as `import stylesUrl from "./index.css?url"` are not route CSS imports. Keep rendering `<link rel="stylesheet" href={stylesUrl}>` in the root document; an empty route `styles` array is expected when all CSS is loaded this way. Smolter does not infer stylesheet use from arbitrary asset URLs. If measurements show late root CSS discovery, your host can send an explicit preload or Early Hint for that same resolved URL, with the same CORS mode as the stylesheet link. Preloading does not replace the stylesheet link. Do not reorganize CSS merely to populate the route manifest.
+
+
+### Component-owned deferred loading
+
+For early Preact hydration, pass pending content directly to the built-in `Await`:
+
+```tsx
+import { Await } from "@kasperrt/smolter/preact";
+
+<Await resolve={data.stats} fallback={<p>Loading statistics…</p>}
+  errorElement={<p>Statistics unavailable.</p>}>
+  {(stats) => <Stats value={stats} />}
+</Await>
+```
+
+Replace the surrounding native `Suspense` for each deferred section, including root sections. This uses ordinary component-owned fallback HTML and the existing deferred data stream, avoiding Preact 11.0.1's abandoned streamed-boundary problem. No separate entrypoint, dependency patch, DOM cleanup, extra request or polling is needed. Late results cannot update an unmounted owner. Early-mode resolved content requires JavaScript; ordinary SSR without early hydration still streams resolved HTML. Existing `Await` without `fallback` keeps its Suspense semantics and its known early-hydration limitation. This does not repair arbitrary native Suspense/lazy boundaries.