@kasperrt/smolter 0.4.2 → 0.4.4

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/index.ts

@@ -117,3 +117,5 @@ export async function handleRequest(
 ): Promise<Response> {
   return privateResponse(await dispatchRequest(routes, request));
 }
+
+export { dispatchRoute } from "./dispatch.ts";

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/server/react.ts

@@ -0,0 +1,34 @@
+/**
+ * React SSR rendering and route data dispatch.
+ * @module
+ */
+import type { AppRoute, RootModule } from "../react/route-types.ts";
+import { RouterApplication } from "../react/router.ts";
+import { createElement } from "react";
+import * as ReactDOMServer from "react-dom/server";
+import {
+  type RenderApplicationOptions,
+  renderDocument,
+} from "./render-application.ts";
+
+export * from "./index.ts";
+export type { RenderApplicationOptions } from "./render-application.ts";
+
+/** Render a React document with root and route data using React's streaming renderer. */
+export async function renderApplication(
+  request: Request,
+  routes: AppRoute[],
+  rootModule: RootModule,
+  entry: string,
+  options: RenderApplicationOptions = {},
+): Promise<Response> {
+  const { renderToReadableStream } = ReactDOMServer;
+  if (!renderToReadableStream)
+    throw new Error("renderApplication requires React DOM 19 or newer.");
+  return renderDocument(request, routes, rootModule, entry, options, (props) =>
+    renderToReadableStream(
+      createElement(RouterApplication, { ...props, rootModule }),
+      { nonce: options.nonce, signal: request.signal },
+    ),
+  );
+}

package/.generated/server/render-application.ts

@@ -0,0 +1,203 @@
+import type { DataArgs, Route, Router } from "../core/index.ts";
+import { createDataRouter, matchRoutes, safeWrapAsync } from "../core/index.ts";
+import { prepareRoutes } from "../core/prepare-routes.ts";
+import { normalizeResult } from "../core/responses.ts";
+import { loadRouter } from "./index.ts";
+import { deferredHydration } from "./deferred-hydration.ts";
+import { dispatchRoute } from "./dispatch.ts";
+
+interface ServerRoot {
+  loader?: (args: DataArgs) => unknown;
+  ErrorBoundary?: unknown;
+}
+
+export interface RenderProps {
+  router: Router;
+  routes: (Route & { routePath?: string })[];
+  root: unknown;
+  entry: string;
+  rootError: boolean;
+  streaming: boolean;
+  initialData?: string;
+  document: boolean;
+}
+
+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 renderDocument(
+  request: Request,
+  routes: (Route & { routePath?: string })[],
+  rootModule: ServerRoot,
+  entry: string,
+  options: RenderApplicationOptions,
+  render: (
+    props: RenderProps,
+  ) =>
+    | (ReadableStream<Uint8Array> & { allReady: Promise<unknown> })
+    | Promise<ReadableStream<Uint8Array> & { allReady: Promise<unknown> }>,
+): Promise<Response> {
+  routes = routes.map((route) => ({
+    ...route,
+    path: route.routePath ?? route.path,
+  }));
+  const match = matchRoutes(routes, new URL(request.url).pathname);
+
+  if (match && !match.route.default)
+    return dispatchRoute(request, routes, true);
+
+  let actionResponse: Response | undefined;
+  let actionData: unknown;
+
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    actionResponse = await dispatchRoute(request, routes, true);
+
+    if (
+      actionResponse.headers.has("Location") ||
+      !actionResponse.headers.get("Content-Type")?.includes("application/json")
+    )
+      return actionResponse;
+
+    actionData = await normalizeResult(await actionResponse.json());
+  }
+
+  const rootResult = safeWrapAsync(() =>
+    Promise.resolve()
+      .then(() =>
+        rootModule.loader?.({ request, params: {}, signal: request.signal }),
+      )
+      .then(
+        (value) => normalizeResult(value, false),
+        (error: unknown) =>
+          error instanceof Response
+            ? normalizeResult(error, false)
+            : error instanceof Error
+              ? error
+              : new Error(String(error), { cause: error }),
+      ),
+  );
+  let redirectResponse: Response | undefined;
+  const prepared = prepareRoutes(
+    routes.map((route) => ({
+      ...route,
+      ErrorBoundary: route.ErrorBoundary ?? rootModule.ErrorBoundary,
+    })),
+    true,
+  ).map((route) => {
+    if (!route.loader) return route;
+
+    const loader = route.loader;
+
+    return {
+      ...route,
+      loader: async (args: Parameters<typeof loader>[0]) => {
+        const value = await loader(args);
+
+        if (value instanceof Response && value.headers.has("Location"))
+          redirectResponse = value;
+
+        return value;
+      },
+    };
+  });
+  const [rootState, loadedRouter] = await Promise.all([
+    rootResult,
+    loadRouter(prepared, request),
+  ]);
+  let router = loadedRouter;
+  const rootError =
+    rootState.error ??
+    (rootState.data instanceof Error ? rootState.data : undefined);
+  const root = rootError ? undefined : rootState.data;
+
+  if (root instanceof Response && root.headers.has("Location")) {
+    router.dispose();
+    return root;
+  }
+
+  if (redirectResponse) {
+    router.dispose();
+
+    return redirectResponse;
+  }
+
+  if (actionResponse || rootError) {
+    const hydrationData = {
+      ...router.getSnapshot(),
+      actionData: actionData instanceof Error ? undefined : actionData,
+      ...(actionData instanceof Error && { error: actionData }),
+      ...(rootError && { error: rootError }),
+    };
+    router.dispose();
+    router = createDataRouter(router.routes, { hydrationData });
+  }
+
+  const snapshot = router.getSnapshot();
+  const hydrationData = {
+    root,
+    snapshot: {
+      ...snapshot,
+      error: snapshot.error && {
+        ...snapshot.error,
+        name: snapshot.error.name,
+        message: snapshot.error.message,
+      },
+    },
+    ...(rootError && { rootError: true }),
+  };
+  const deferred = options.earlyHydration
+    ? deferredHydration(hydrationData, options.nonce)
+    : undefined;
+  const stream = await Promise.resolve()
+    .then(() =>
+      render({
+        router,
+        routes,
+        root,
+        entry,
+        rootError: Boolean(rootError),
+        streaming: true,
+        initialData: deferred?.initial,
+        document: true,
+      }),
+    )
+    .catch(async (error: unknown) => {
+      router.dispose();
+      await deferred?.stream.cancel();
+      throw error;
+    });
+  // The renderer reports the same rejection through its stream reader.
+  void stream.allReady.catch(() => {});
+  const headers = new Headers(actionResponse?.headers);
+  headers.delete("Content-Length");
+  headers.delete("Content-Encoding");
+  headers.set("Content-Type", "text/html; charset=utf-8");
+  headers.set("Cache-Control", "no-store");
+
+  return new Response(
+    deferred
+      ? progressiveDocument(stream, deferred.stream, {
+          signal: request.signal,
+          dispose: () => router.dispose(),
+        })
+      : streamDocument(stream, {
+          hydration: resolveHydration(hydrationData),
+          signal: request.signal,
+          nonce: options.nonce,
+          dispose: () => router.dispose(),
+        }),
+    {
+      status: snapshot.error
+        ? Number("status" in snapshot.error ? snapshot.error.status : 500)
+        : (actionResponse?.status ?? 200),
+      headers,
+    },
+  );
+}

package/.generated/vite/application/lazy-files.ts

@@ -12,6 +12,7 @@ interface ChunkMetadata {
 export function lazyFiles(
   directory: string,
   dataEndpoint = "/_smolter",
+  framework: "react" | "preact" = "preact",
 ): Plugin {
   let root: string;
   const modules = new Map<string, string>();
@@ -139,7 +140,7 @@ export function lazyFiles(
       }
 
       return [
-        'import { lazyRoute } from "@kasperrt/smolter/preact/lazy-route";',
+        `import { lazyRoute } from "@kasperrt/smolter/${framework}/lazy-route";`,
         `export default [${definitions.join(",\n")}];`,
       ].join("\n");
     },

package/.generated/vite/application/vite.ts

@@ -6,6 +6,7 @@ import { lazyFiles } from "./lazy-files.ts";
 
 export interface ApplicationOptions {
   directory?: string;
+  framework?: "react" | "preact";
   dataEndpoint?: string;
   ssr?: boolean;
   splitRoutes?: boolean;
@@ -43,6 +44,7 @@ export const preactConfig: UserConfig = {
 
 export function applicationPlugins({
   directory = "src/routes",
+  framework = "preact",
   dataEndpoint = "/_smolter",
   ssr = true,
   splitRoutes = true,
@@ -51,7 +53,13 @@ export function applicationPlugins({
   const application: Plugin = {
     name: "smolter-application",
     enforce: "pre",
-    config: () => preactConfig,
+    config: () =>
+      framework === "preact"
+        ? preactConfig
+        : {
+            resolve: { dedupe: ["react", "react-dom", "@kasperrt/smolter"] },
+            ssr: { noExternal: ["@kasperrt/smolter"] },
+          },
     transformIndexHtml: {
       order: "post",
       handler(html, context) {
@@ -93,7 +101,7 @@ export function applicationPlugins({
           const request = await webRequest(incoming, outgoing, target);
           const [{ default: routes }, { dispatchRoute }] = await Promise.all([
             server.ssrLoadModule("virtual:smolter/routes"),
-            server.ssrLoadModule("@kasperrt/smolter/preact/server"),
+            server.ssrLoadModule(`@kasperrt/smolter/${framework}/server`),
           ]);
           await send(await dispatchRoute(request, routes), outgoing);
         };
@@ -144,7 +152,7 @@ export function applicationPlugins({
   return [
     application,
     browserBoundary(),
-    ...(splitRoutes ? [lazyFiles(directory, dataEndpoint)] : []),
-    routerPlugin({ directory, framework: "preact", dataEndpoint }),
+    ...(splitRoutes ? [lazyFiles(directory, dataEndpoint, framework)] : []),
+    routerPlugin({ directory, framework, dataEndpoint }),
   ];
 }

package/.generated/vite/react.ts

@@ -17,7 +17,18 @@ export function routerPlugin(options: FileRouterOptions = {}): Plugin {
 /** File routing is the default; this alias keeps configuration explicit. */
 export const fileRouter = routerPlugin;
 
+export type { ApplicationOptions } from "./application/vite.ts";
 export {
   type DeploymentPluginOptions,
   deploymentPlugin,
 } from "./deployment.ts";
+
+import {
+  type ApplicationOptions,
+  applicationPlugins as plugins,
+} from "./application/vite.ts";
+
+/** Configure React application SSR, scoped data transport and lazy file routing. */
+export function applicationPlugins(options: ApplicationOptions = {}): Plugin[] {
+  return plugins({ ...options, framework: "react" });
+}

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.4.4
+
+- Remove the separate `/react/data` resource router. Both main adapters provide route data, forms, submissions and independent fetchers through `createDataRouter`; migrate ResourceProvider/Resource hooks to RouterProvider and the main data hooks. The old pathless resource store and tuple fetcher API are removed, not aliased to incompatible signatures.
+
+- Complete React routing-hook parity: navigation/submission state, URL/search/history helpers, route errors, root data and route-ID data. Add React RouterApplication and match Preact loader/fetcher type inference.
+- Support React application SSR and hydration, document helpers, lazy routes and application Vite middleware. React DOM 19+ powers integrated documents; routing hooks and manual loadRouter SSR retain React 18 support. Share transport, root revalidation, hash history, hydration payloads and server orchestration across renderers.
+- Export renderer-independent dispatchRoute from both server entries. Preserve scoped endpoints, private caching, redirects, cancellation and mutation ownership.
+- Add React link intent prefetching, structured/GET fetcher submissions and real NavLink pending state in both adapters. Report pending destinations under plain providers as well as retained application views.
+- Update compatibility badges, guides, package-isolation checks and bundle tables. Verify React production early hydration, persistent input, root refresh, CSP and abandoned deferred boundaries.
+
+## 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.4%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.4%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.4%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.4%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,15 @@ 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.
+
+## React and Preact application APIs
+
+Both adapters expose navigation, submission, error, root-data and route-data hooks. Both server entries expose `dispatchRoute` and `renderApplication`; both client entries provide `mountApplication`, scoped transport and deployment recovery. Import `applicationPlugins` from the matching renderer's `/vite` entry for lazy file routes and development SSR.
+
+Integrated React documents use React DOM 19+ (`react/document`, `react/client`, `react/server`). React 18 remains supported for routing hooks and manual `loadRouter` SSR. Use React's `use(promise)` inside `Suspense` for deferred rendering. Preact uses `Await` with an explicit `fallback` for early hydration. These renderer choices share transport and data ownership, without loading the other framework.
 
 ## Contents
 
@@ -445,18 +451,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 [changelog](./CHANGELOG.md) for release history.
 
 **Router factory migration:** code that previously used `createRouter` with
 loaders, actions, fetchers or revalidation must now use `createDataRouter`.
@@ -525,7 +531,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,39 +543,33 @@ 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
+## Independent data requests
 
-`@kasperrt/smolter/react/data` adds subscriptions to named resources when their
-lifetime is independent of URL navigation. The state and cancellation logic
-lives in core; the entry adds React bindings without DOM or HTTP globals.
+Both adapters include `useFetcher`, `useSubmit`, `Form` and the loader/action hooks
+in their main entrypoint. Use `createDataRouter` for data routes and `useFetcher`
+for reads or mutations that should not navigate the page. There is no separate
+React resource router or `/react/data` entrypoint.
 
-```ts
-import { createResourceRouter } from "@kasperrt/smolter/react/data";
-
-const resources = createResourceRouter(new Map([
-  ["settings", {
-    loader: async ({ signal }) => ({
-      data: await readSettings(signal),
-      error: "",
-    }),
-    action: async ({ input, signal }) => ({
-      data: await saveSettings(input, signal),
-      error: "",
-    }),
-  }],
-]));
-```
-
-`ResourceProvider` owns the store lifetime. `Resource` selects a resource by
-`routeId` and params. `useResourceData` reads it; `useRouteLoaderData` reads a
-named resource. `useResourceFetcher` returns `[state, operations]`, with
-independent `load` and `submit` operations. Successful mutations consult the
-resource's `shouldRevalidate` before reloading its data. Last-subscriber cleanup
-aborts pending work; `persistent` keeps a resource until explicitly disposed.
-This optional entry does not contribute to the base React bundle measurement.
+```tsx
+import { useFetcher } from "@kasperrt/smolter/react";
+
+function Settings() {
+  const settings = useFetcher();
+  return (
+    <settings.Form method="post" action="/settings">
+      <input name="name" aria-label="Profile name" />
+      <button disabled={settings.state !== "idle"}>Save</button>
+    </settings.Form>
+  );
+}
+```
+
+Use the same imports from `/preact` in a Preact application. Independent
+fetchers share the application router's cancellation, revalidation and deployment
+recovery ownership; they do not require another provider or store.
 
 ## Size and checks
 
@@ -581,7 +581,6 @@ This optional entry does not contribute to the base React bundle measurement.
 | Preact application hydration | `@kasperrt/smolter/preact/client` |
 | Preact document components | `@kasperrt/smolter/preact/document` |
 | Lazy Preact route modules | `@kasperrt/smolter/preact/lazy-route` |
-| Optional React resources | `@kasperrt/smolter/react/data` |
 | Server rendering / Vite integration | Renderer `/server` / `/vite` subpaths; keep out of browser imports |
 
 The measurements below describe retained exports, not the cost of an import
@@ -605,16 +604,17 @@ a claim of identical features.
 | --- | ---: |
 | `React Router: declarative routing subset` | 12882 |
 | `React Router: data routing subset` | 29780 |
-| `React: routing-only named exports` | 1245 |
+| `React: routing-only named exports` | 1419 |
 | `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/data (optional resource API)` | 2962 |
-| `React: common routing/data exports` | 2761 |
+| `@kasperrt/smolter/react` | 4801 |
+| `@kasperrt/smolter/preact` | 5076 |
+| `@kasperrt/smolter/react + server transport (named client exports)` | 6060 |
+| `@kasperrt/smolter/preact + server transport` | 6345 |
+| `@kasperrt/smolter/react + client + document (application)` | 9124 |
+| `@kasperrt/smolter/react + client + document + lazy-route` | 9401 |
+| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9435 |
+| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9721 |
+| `React: common routing/data exports` | 3071 |
 | `Preact: common routing/data exports` | 3046 |
 | `wouter: routing subset (Router, Route, Switch, Link, useParams, useLocation)` | 2854 |
 | `wouter-preact: same routing subset` | 2211 |
@@ -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/client/hash-history.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from "../core/index.ts";
+export declare function connectHashHistory(router: Router): void;

package/dist/client/hash-history.js

@@ -0,0 +1,26 @@
+//#region .generated/client/hash-history.ts
+function connectHashHistory(router) {
+	const read = router.getSnapshot;
+	const navigate = router.navigate;
+	router.navigate = async (url, options) => {
+		const target = new URL(url, router.getSnapshot().url);
+		const hash = `#${target.pathname}${target.search}${target.hash}`;
+		history[options?.replace ? "replaceState" : "pushState"](null, "", hash);
+		await navigate(url, options);
+	};
+	const unsubscribe = router.subscribe(() => {
+		const target = new URL(read().url);
+		const hash = `#${target.pathname}${target.search}${target.hash}`;
+		if (location.hash !== hash) history.replaceState(history.state, "", hash);
+	});
+	const onHashChange = () => void navigate(location.hash.slice(1) || "/");
+	window.addEventListener("hashchange", onHashChange);
+	const dispose = router.dispose;
+	router.dispose = () => {
+		unsubscribe();
+		window.removeEventListener("hashchange", onHashChange);
+		dispose();
+	};
+}
+//#endregion
+export { connectHashHistory };

package/dist/client/hydration.d.ts

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

package/dist/{preact/deferred-hydration.js → client/hydration.js}

@@ -1,4 +1,4 @@
-//#region .generated/preact/deferred-hydration.ts
+//#region .generated/client/hydration.ts
 /** Restore promise identity before hydrating Suspense boundaries. */
 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");

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

@@ -0,0 +1,14 @@
+import type { RevalidationArgs, Router } from "../core/index.ts";
+interface RootModule {
+    default?: unknown;
+    Layout?: unknown;
+    id?: string;
+    loaderPath?: string;
+    shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+export { createStore as createRootStore } from "../core/store.ts";
+export declare function attachRootData(router: Router, initial: unknown, rootModule?: RootModule): {
+    getSnapshot: () => unknown;
+    subscribe(listener: () => void): () => void;
+    update(next: unknown): void;
+};