@kasperrt/smolter 0.3.0 → 0.3.2

package/.generated/server/handler.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { send, webRequest } from "./http.ts";
+import { privateResponse } from "./private-response.ts";
 
 /** Server module produced by an application's SSR entrypoint. */
 export interface ServerBuild {
@@ -11,6 +12,8 @@ export interface RequestHandlerOptions {
   build: ServerBuild;
   /** Browser entry URL resolved from Vite's production manifest. */
   entry: string;
+  /** Must match the browser and Vite transport endpoint. */
+  dataEndpoint?: string;
 }
 
 export interface ServerIncomingMessage extends IncomingMessage {
@@ -25,6 +28,7 @@ export type NextHandler = (error?: unknown) => void;
 export function createRequestHandler({
   build,
   entry,
+  dataEndpoint = "/_smolter",
 }: RequestHandlerOptions): (
   incoming: ServerIncomingMessage,
   outgoing: ServerResponse,
@@ -40,7 +44,9 @@ export function createRequestHandler({
         incoming.originalUrl ?? incoming.url ?? "/",
         "http://local",
       );
-      const dataRequest = url.pathname === "/_smolter";
+      const dataRequest = url.pathname === dataEndpoint;
+      if (dataRequest) outgoing.setHeader("Cache-Control", "private, no-store");
+
       const target = dataRequest ? url.searchParams.get("url") : undefined;
 
       if (
@@ -61,7 +67,7 @@ export function createRequestHandler({
         ? await build.handleDataRequest(request)
         : await build.default(request, entry);
 
-      await send(response, outgoing);
+      await send(dataRequest ? privateResponse(response) : response, outgoing);
     };
 
     return handle().catch(next);

package/.generated/server/http.ts

@@ -1,4 +1,6 @@
 import type { ServerResponse } from "node:http";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import type { ServerIncomingMessage } from "./handler.ts";
 
 export async function webRequest(
@@ -34,7 +36,11 @@ export async function webRequest(
   );
 }
 
-export async function send(response: Response, outgoing: ServerResponse) {
+interface StreamingResponse extends ServerResponse {
+  flush?: () => void;
+}
+
+export async function send(response: Response, outgoing: StreamingResponse) {
   outgoing.statusCode = response.status;
   response.headers.forEach((value, name) => {
     if (name !== "set-cookie") outgoing.setHeader(name, value);
@@ -51,5 +57,21 @@ export async function send(response: Response, outgoing: ServerResponse) {
       ),
     );
 
-  outgoing.end(new Uint8Array(await response.arrayBuffer()));
+  if (!response.body) {
+    outgoing.end();
+    return;
+  }
+
+  await pipeline(
+    Readable.fromWeb(
+      response.body as import("node:stream/web").ReadableStream<Uint8Array>,
+    ),
+    new Transform({
+      transform(chunk, _encoding, done) {
+        done(null, chunk);
+        outgoing.flush?.();
+      },
+    }),
+    outgoing,
+  );
 }

package/.generated/server/index.ts

@@ -1,3 +1,4 @@
+import { privateResponse } from "./private-response.ts";
 /**
  * Request-scoped server rendering and HTTP data dispatch.
  * @module
@@ -63,7 +64,7 @@ export async function loadRouter(
 export { serialize } from "../core/index.ts";
 
 /** Dispatch an HTTP data request to a registered server loader or action. */
-export async function handleRequest(
+async function dispatchRequest(
   routes: readonly Route[],
   request: Request,
 ): Promise<Response> {
@@ -93,10 +94,13 @@ export async function handleRequest(
   if (result.data instanceof Response) {
     const location = result.data.headers.get("Location");
 
-    if (location)
-      return new Response(null, {
-        headers: { "X-Smolter-Redirect": location },
-      });
+    if (location) {
+      const headers = new Headers(result.data.headers);
+      headers.delete("Location");
+      headers.set("X-Smolter-Redirect", location);
+
+      return new Response(null, { headers });
+    }
 
     return result.data;
   }
@@ -105,3 +109,11 @@ export async function handleRequest(
     headers: { "Cache-Control": "no-store" },
   });
 }
+
+/** Dispatch a server data request with an explicit private cache policy. */
+export async function handleRequest(
+  routes: readonly Route[],
+  request: Request,
+): Promise<Response> {
+  return privateResponse(await dispatchRequest(routes, request));
+}

package/.generated/server/preact.ts

@@ -2,6 +2,7 @@
 
 export {
   dispatchRoute,
+  type RenderApplicationOptions,
   renderApplication,
 } from "./application.tsx";
 export * from "./index.ts";

package/.generated/server/private-response.ts

@@ -0,0 +1,11 @@
+/** Transport data must not be cached by shared intermediaries or the browser. */
+export function privateResponse(response: Response): Response {
+  const headers = new Headers(response.headers);
+  headers.set("Cache-Control", "private, no-store");
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}

package/.generated/server/stream-document.ts

@@ -0,0 +1,121 @@
+import { serializeData } from "../core/serialize.ts";
+
+// Deferred failures must remain rejected promises after hydration so Await's
+// errorElement has the same behavior on the server and in the browser.
+export async function resolveHydration(value: unknown): Promise<unknown> {
+  if (value instanceof Promise)
+    return value.then(resolveHydration, (error: unknown) => ({
+      __smolterRejected: {
+        message: error instanceof Error ? error.message : String(error),
+      },
+    }));
+
+  if (Array.isArray(value)) return Promise.all(value.map(resolveHydration));
+
+  if (
+    value &&
+    typeof value === "object" &&
+    Object.getPrototypeOf(value) === Object.prototype
+  ) {
+    const entries = await Promise.all(
+      Object.entries(value).map(async ([key, field]) => [
+        key,
+        await resolveHydration(field),
+      ]),
+    );
+
+    return Object.fromEntries(entries);
+  }
+
+  return value;
+}
+
+export interface StreamDocumentOptions {
+  hydration: Promise<unknown>;
+  nonce?: string;
+  signal: AbortSignal;
+  dispose: () => void;
+}
+
+/** Stream the shell immediately, then finalize the JSON snapshot before module scripts execute. */
+export function streamDocument(
+  source: ReadableStream<Uint8Array>,
+  options: StreamDocumentOptions,
+): ReadableStream<Uint8Array> {
+  const reader = source.getReader();
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let suffix = "";
+  let first = true;
+  let cancelled = false;
+  let finish!: () => void;
+  const interrupted = new Promise<void>((resolve) => {
+    finish = resolve;
+  });
+
+  const abort = () => {
+    finish();
+    void reader.cancel().catch(() => {});
+  };
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted) abort();
+
+  function dispose() {
+    options.signal.removeEventListener("abort", abort);
+    options.dispose();
+  }
+
+  return new ReadableStream({
+    async pull(controller) {
+      const result = await reader.read().catch((error: unknown) => ({ error }));
+
+      if ("error" in result) {
+        dispose();
+        controller.error(result.error);
+        return;
+      }
+
+      if (result.done) {
+        if (!options.signal.aborted) {
+          const value = await Promise.race([options.hydration, interrupted]);
+          if (cancelled) return;
+          if (options.signal.aborted) {
+            dispose();
+            controller.close();
+            return;
+          }
+          const hydration = serializeData(value);
+          const nonce = options.nonce
+            ? ` nonce="${options.nonce.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;")}"`
+            : "";
+          controller.enqueue(
+            encoder.encode(
+              `<script type="application/json"${nonce}>${hydration}</script><script${nonce}>(function(){var script=document.currentScript,payload=script.previousElementSibling,data=document.getElementById("smolter-data");if(data)data.textContent=payload.textContent;payload.remove();script.remove()})()</script>${suffix}`,
+            ),
+          );
+        }
+
+        dispose();
+        controller.close();
+        return;
+      }
+
+      let chunk = decoder.decode(result.value, { stream: true });
+      if (first && !/^<!doctype/i.test(chunk))
+        chunk = `<!doctype html>${chunk}`;
+      first = false;
+      const closing = chunk.lastIndexOf("</body>");
+      if (closing !== -1) {
+        suffix = chunk.slice(closing);
+        chunk = chunk.slice(0, closing);
+      }
+      controller.enqueue(encoder.encode(chunk));
+    },
+    async cancel() {
+      cancelled = true;
+      finish();
+      dispose();
+      await reader.cancel();
+    },
+  });
+}

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

@@ -5,7 +5,10 @@ import { type Plugin, transformWithOxc } from "vite";
 
 // Reuse Smolter's file discovery and server-export stripping. Only the browser
 // route manifest changes: matched routes load before their data is committed.
-export function lazyFiles(directory: string): Plugin {
+export function lazyFiles(
+  directory: string,
+  dataEndpoint = "/_smolter",
+): Plugin {
   let root: string;
   const modules = new Map<string, string>();
 
@@ -64,6 +67,8 @@ export function lazyFiles(directory: string): Plugin {
 
       if (routes instanceof Error) return this.error(routes.message);
 
+      modules.clear();
+
       const definitions: string[] = [];
 
       for (const route of routes) {
@@ -72,7 +77,10 @@ export function lazyFiles(directory: string): Plugin {
         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 };
+        const fields: Record<string, string | boolean> = {
+          path: route.path,
+          dataEndpoint,
+        };
 
         for (const statement of ast.body) {
           if (statement.type === "ExportDefaultDeclaration") {

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

@@ -6,6 +6,7 @@ import { lazyFiles } from "./lazy-files.ts";
 
 export interface ApplicationOptions {
   directory?: string;
+  dataEndpoint?: string;
   ssr?: boolean;
   splitRoutes?: boolean;
   resourceRequest?: (url: string) => boolean;
@@ -42,6 +43,7 @@ export const preactConfig: UserConfig = {
 
 export function applicationPlugins({
   directory = "src/routes",
+  dataEndpoint = "/_smolter",
   ssr = true,
   splitRoutes = true,
   resourceRequest,
@@ -72,7 +74,9 @@ export function applicationPlugins({
     configureServer(server) {
       // Own the HTTP adapter so redirects retain authentication cookies.
       server.middlewares.use((incoming, outgoing, next) => {
-        if (!incoming.url?.startsWith("/_smolter?")) return next();
+        if (!incoming.url?.startsWith(`${dataEndpoint}?`)) return next();
+
+        outgoing.setHeader("Cache-Control", "private, no-store");
 
         const run = async () => {
           const target = new URL(
@@ -106,6 +110,8 @@ export function applicationPlugins({
           )
             return next();
 
+          outgoing.setHeader("Cache-Control", "private, no-store");
+
           const run = async () => {
             const request = await webRequest(incoming, outgoing);
             const entry = await server.ssrLoadModule("/src/entry.server.tsx");
@@ -138,7 +144,7 @@ export function applicationPlugins({
   return [
     application,
     browserBoundary(),
-    ...(splitRoutes ? [lazyFiles(directory)] : []),
-    routerPlugin({ directory, framework: "preact" }),
+    ...(splitRoutes ? [lazyFiles(directory, dataEndpoint)] : []),
+    routerPlugin({ directory, framework: "preact", dataEndpoint }),
   ];
 }

package/.generated/vite/deployment.ts

@@ -0,0 +1,46 @@
+import { randomUUID } from "node:crypto";
+import type { Plugin } from "vite";
+
+/** Deployment manifest configuration. Serve the emitted file with Cache-Control: no-store. */
+export interface DeploymentPluginOptions {
+  /** Public URL, optionally on an asset host. Defaults to Vite base + smolter-manifest.json. */
+  manifestURL?: string;
+}
+
+/** Emit a build manifest and expose its identity through virtual:smolter/deployment. */
+export function deploymentPlugin(
+  options: DeploymentPluginOptions = {},
+): Plugin {
+  const version = randomUUID();
+  const virtualId = "\0virtual:smolter/deployment";
+  let enabled = false;
+  let manifestURL = "";
+
+  return {
+    name: "smolter-deployment",
+    configResolved(config) {
+      enabled = config.command === "build" && !config.build.ssr;
+      manifestURL =
+        options.manifestURL ?? `${config.base}smolter-manifest.json`;
+    },
+    resolveId(id) {
+      if (id === "virtual:smolter/deployment") return virtualId;
+    },
+    load(id) {
+      if (id !== virtualId) return;
+
+      const deployment = enabled ? { version, manifestURL } : null;
+
+      return `export default ${JSON.stringify(deployment)};`;
+    },
+    generateBundle() {
+      if (!enabled) return;
+
+      this.emitFile({
+        type: "asset",
+        fileName: "smolter-manifest.json",
+        source: JSON.stringify({ version }),
+      });
+    },
+  };
+}

package/.generated/vite/index.ts

@@ -1,11 +1,12 @@
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { flatRoutes } from "../files/index.ts";
 import { type Plugin, transformWithOxc } from "vite";
 import { configureTransport } from "./transport.ts";
 
 export interface FileRouterOptions {
   directory?: string;
+  dataEndpoint?: string;
   clientRoutes?: string;
   serverRoutes?: string;
   framework?: "react" | "preact";
@@ -14,6 +15,7 @@ export interface FileRouterOptions {
 /** Build-time flat route discovery and the optional server data transport. */
 export function routerPlugin({
   directory = "src/routes",
+  dataEndpoint = "/_smolter",
   clientRoutes,
   serverRoutes,
   framework = "react",
@@ -166,7 +168,7 @@ export function routerPlugin({
         definitions.push(
           options?.ssr || !Object.keys(handlers).length
             ? `{ ...route${index}, path: ${JSON.stringify(route.path)} }`
-            : `serverRoute(${JSON.stringify(route.path)}, route${index}, ${JSON.stringify(handlers)})`,
+            : `serverRoute(${JSON.stringify(route.path)}, route${index}, ${JSON.stringify({ ...handlers, dataEndpoint })})`,
         );
       }
 
@@ -185,11 +187,18 @@ export function routerPlugin({
       server.watcher.add(root);
 
       const refresh = (file: string) => {
-        if (!file.startsWith(`${root}/`)) return;
+        if (clientRoutes || serverRoutes) return;
 
-        const module = server.moduleGraph.getModuleById(virtualId);
+        const path = relative(root, file).replaceAll("\\", "/");
 
-        if (module) server.moduleGraph.invalidateModule(module);
+        if (!/^(?:[^/]+\.[jt]sx?|[^/]+\/route\.[jt]sx?)$/.test(path)) return;
+        if (path.endsWith(".d.ts")) return;
+
+        for (const environment of Object.values(server.environments)) {
+          const module = environment.moduleGraph.getModuleById(virtualId);
+
+          if (module) environment.moduleGraph.invalidateModule(module);
+        }
 
         server.ws.send({ type: "full-reload" });
       };
@@ -203,7 +212,7 @@ export function routerPlugin({
         server.watcher.off("unlink", refresh);
       });
 
-      configureTransport(server, publicId, framework);
+      configureTransport(server, publicId, framework, dataEndpoint);
     },
   };
 }

package/.generated/vite/preact.ts

@@ -22,3 +22,8 @@ export {
   applicationPlugins,
   preactConfig,
 } from "./application/vite.ts";
+
+export {
+  type DeploymentPluginOptions,
+  deploymentPlugin,
+} from "./deployment.ts";

package/.generated/vite/react.ts

@@ -16,3 +16,8 @@ export function routerPlugin(options: FileRouterOptions = {}): Plugin {
 
 /** File routing is the default; this alias keeps configuration explicit. */
 export const fileRouter = routerPlugin;
+
+export {
+  type DeploymentPluginOptions,
+  deploymentPlugin,
+} from "./deployment.ts";

package/.generated/vite/transport.ts

@@ -4,9 +4,12 @@ export function configureTransport(
   server: ViteDevServer,
   publicId: string,
   framework: "react" | "preact" = "react",
+  dataEndpoint = "/_smolter",
 ): void {
   server.middlewares.use((incoming, outgoing, next) => {
-    if (!incoming.url?.startsWith("/_smolter?")) return next();
+    if (!incoming.url?.startsWith(`${dataEndpoint}?`)) return next();
+
+    outgoing.setHeader("Cache-Control", "private, no-store");
 
     const dispatch = async () => {
       const origin = `http://${incoming.headers.host}`;

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.2
+
+- Configure transport endpoints consistently across browser handlers, file routes, Express and development middleware for multiple apps sharing one origin.
+- Refresh root data after action redirects, preserve redirect cookies and synchronize hash-history redirects.
+- Recover missing initial route chunks when deployment metadata is passed to mountApplication.
+- Stream Preact SSR with concurrent root/route loading, deferred data, root error boundaries and disconnect cleanup. Hydration begins after the document stream completes; requires preact-render-to-string >=6.8.1.
+- Enforce private, no-store on route-data responses, including errors and mutations.
+- Expose loader execution reason for explicit navigation/revalidation handling.
+- Add regression coverage, production streaming browser tests and updated API documentation.
+
+## 0.3.1
+
+- Refresh browser and SSR file-route discovery on additions, renames and removals; preserve normal Vite HMR for colocated helpers and components.
+
+- Add optional production deployment manifests through `deploymentPlugin` for both React and Preact Vite integrations.
+- Add `watchDeployment` to both client entrypoints: check before navigation and Back/Forward, recover stale Vite chunks after confirmed build changes, and preserve the requested URL.
+- Skip hash-only links, development builds and SSR; bound failed checks and prevent repeated reloads. Keep routing-only bundles unchanged.
+- Document production cache headers, CDN/application-specific manifest paths, unsaved state and rollout limitations.
+
 ## 0.3.0
 
 ### Migration from 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.0%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.3.0%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.3.0%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.3.0%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.3.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.3.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.3.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.3.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)
 <!-- bundlejs:end -->
 
 A typed data router for React and Preact. **Zero runtime dependencies.**
@@ -20,6 +20,8 @@ Start with [loaders](https://kasperrt.github.io/smolter/react/docs/loaders/), [a
 
 ## Contents
 
+- [Deployment updates](#deployment-updates)
+
 - [Install](#install)
 - [Try the four standalone examples](#try-the-four-standalone-examples)
 - [Choose file routing or manual routes](#choose-file-routing-or-manual-routes)
@@ -532,7 +534,7 @@ 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)
-for a complete server example and current buffering limitations.
+for a complete server example and streaming and hydration behavior.
 
 ## Resource subscriptions
 
@@ -567,6 +569,22 @@ This optional entry does not contribute to the base React bundle measurement.
 
 ## Size and checks
 
+| Need | Public import |
+| --- | --- |
+| Navigation only | `@kasperrt/smolter/react` or `/preact`, using `createRouter` |
+| Loaders, actions, forms and fetchers | Same entry, using `createDataRouter` |
+| Browser server-request transport | Renderer `/client` subpath |
+| 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
+statement. Browser transport rows include the router and transport together;
+application rows include the listed modules together. Server and Vite modules
+have no browser cost when kept in their intended server/build entrypoints.
+
 Use `createRouter` for navigation only, or `createDataRouter` for loaders,
 actions, fetchers and revalidation. Both are named exports from
 `@kasperrt/smolter/preact` and `/react`. No extra package or plugin is required.
@@ -581,17 +599,19 @@ a claim of identical features.
 <!-- size-comparison:start -->
 | Browser exports | Gzip bytes |
 | --- | ---: |
+| `React Router: declarative routing subset` | 12882 |
+| `React Router: data routing subset` | 29780 |
 | `React: routing-only named exports` | 1245 |
 | `Preact: routing-only named exports` | 1405 |
-| `@kasperrt/smolter/react` | 2873 |
-| `@kasperrt/smolter/preact` | 4748 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 3219 |
-| `@kasperrt/smolter/preact + server transport` | 5059 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 7415 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 7696 |
+| `@kasperrt/smolter/react` | 2948 |
+| `@kasperrt/smolter/preact` | 4842 |
+| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 4046 |
+| `@kasperrt/smolter/preact + server transport` | 5886 |
+| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 8418 |
+| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 8704 |
 | `@kasperrt/smolter/react/data (optional resource API)` | 2962 |
-| `React: common routing/data exports` | 2683 |
-| `Preact: common routing/data exports` | 2966 |
+| `React: common routing/data exports` | 2761 |
+| `Preact: common routing/data exports` | 3046 |
 | `wouter: routing subset (Router, Route, Switch, Link, useParams, useLocation)` | 2854 |
 | `wouter-preact: same routing subset` | 2211 |
 | `wouter@3.13.0` | 3091 |
@@ -604,6 +624,13 @@ The common-export rows measure the same named API set: `createDataRouter`,
 `useLoaderData`, `useActionData`, `useParams`, `useLocation`,
 `useRevalidator` and `useFetcher`. Preact’s link and submission APIs currently
 have additional behavior; equal names do not imply identical implementations.
+React Router's declarative subset retains `BrowserRouter`, `Routes`, `Route`,
+`Link`, `useParams`, and `useLocation`. Its data subset retains
+`createBrowserRouter`, `RouterProvider`, `Link`, `Form`, `useLoaderData`,
+`useActionData`, `useParams`, `useLocation`, `useRevalidator`, and `useFetcher`.
+React Router has no dedicated Preact entry; these are React API measurements,
+not a Preact compatibility build. The selected APIs have different capabilities.
+
 The routing-only rows retain `createRouter`, `defineRoute`, `RouterProvider`,
 `Routes`, `Link`, `useParams` and `useLocation`. Full Preact also exposes richer
 application APIs. These tiers overlap: do not add the rows together.
@@ -683,3 +710,44 @@ pnpm add /absolute/path/to/kasperrt-smolter-0.0.1.tgz
 ```
 
 Workspace structure and rendering checks are documented in [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Deployment updates
+
+For production tabs that survive a deployment, add `deploymentPlugin()` from
+`@kasperrt/smolter/react/vite` or `/preact/vite`, then connect the router:
+
+```ts
+import deployment from "virtual:smolter/deployment";
+import { watchDeployment } from "@kasperrt/smolter/preact/client";
+
+watchDeployment(router, deployment);
+```
+
+Serve the emitted `smolter-manifest.json` with `Cache-Control: no-store` and HTML
+with `no-cache`. Navigation checks its build version before loading another route;
+a newer version reloads the destination, including its query and hash. Vite chunk
+failures are checked again. Hash-only links skip the check, failed checks continue
+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/)
+for Express, CDN paths, TypeScript declarations and unsaved-state handling.
+
+
+### Shared origins and streaming SSR
+
+Set the same `dataEndpoint` in `applicationPlugins` (or `fileRouter`), browser `serverRoute` handlers and `createRequestHandler`. For example, Admin can use `/admin/_smolter` while Platform uses `/_smolter`. Transport responses, including errors and redirects, use `Cache-Control: private, no-store`.
+
+Pass deployment metadata before mounting so recovery covers the initial route import:
+
+```ts
+import deployment from "virtual:smolter/deployment";
+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. 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.

package/dist/client/deployment-check.d.ts

@@ -0,0 +1,6 @@
+import type { DeploymentOptions } from "./deployment.ts";
+export declare function deploymentCheck(options: DeploymentOptions): {
+    changed: () => Promise<boolean>;
+    reload: (target: URL) => Promise<boolean>;
+    dispose(): void;
+};