@kasperrt/smolter 0.3.1 → 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>();
 
@@ -74,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/index.ts

@@ -6,6 +6,7 @@ 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 })})`,
         );
       }
 
@@ -210,7 +212,7 @@ export function routerPlugin({
         server.watcher.off("unlink", refresh);
       });
 
-      configureTransport(server, publicId, framework);
+      configureTransport(server, publicId, framework, dataEndpoint);
     },
   };
 }

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,15 @@
 # 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.

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.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.3.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.3.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.3.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.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.**
@@ -534,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
 
@@ -603,15 +603,15 @@ 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` | 2873 |
-| `@kasperrt/smolter/preact` | 4748 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 3870 |
-| `@kasperrt/smolter/preact + server transport` | 5697 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 8033 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 8317 |
+| `@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 |
@@ -733,3 +733,21 @@ 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;
+};

package/dist/client/deployment-check.js

@@ -0,0 +1,51 @@
+//#region .generated/client/deployment-check.ts
+function deploymentCheck(options) {
+	const { version, manifestURL, timeout = 2e3 } = options;
+	const manifest = new URL(manifestURL, location.href);
+	const key = `smolter:deployment:${manifest.href}:${version}`;
+	let stopped = false;
+	let pending;
+	let controller;
+	function changed() {
+		if (pending) return pending;
+		controller = new AbortController();
+		const timer = setTimeout(() => controller?.abort(), timeout);
+		pending = fetch(manifest, {
+			cache: "no-store",
+			signal: controller.signal
+		}).then(async (response) => {
+			if (!response.ok) return false;
+			const data = await response.json();
+			return typeof data === "object" && data !== null && "version" in data && typeof data.version === "string" && data.version.length > 0 && data.version !== version;
+		}).catch(() => false).finally(() => {
+			clearTimeout(timer);
+			pending = void 0;
+		});
+		return pending;
+	}
+	async function reload(target) {
+		const allowed = await Promise.resolve().then(() => {
+			if (sessionStorage.getItem(key)) return false;
+			sessionStorage.setItem(key, "1");
+			return true;
+		}).catch(() => false);
+		if (allowed && !stopped) {
+			if (options?.reload) options.reload(target);
+			if (!options?.reload) {
+				if (target.href === location.href) location.reload();
+				if (target.href !== location.href) location.assign(target.href);
+			}
+		}
+		return allowed && !stopped;
+	}
+	return {
+		changed,
+		reload,
+		dispose() {
+			stopped = true;
+			controller?.abort();
+		}
+	};
+}
+//#endregion
+export { deploymentCheck };

package/dist/client/deployment.d.ts

@@ -10,3 +10,5 @@ export interface DeploymentOptions {
 }
 /** Check for deployment changes before navigation. Returns a cleanup function. */
 export declare function watchDeployment(router: NavigationRouter, options: DeploymentOptions | null): () => void;
+/** Recover an initial lazy-import failure before a router has mounted. Returns whether a reload was requested. */
+export declare function recoverDeployment(options: DeploymentOptions | null, destination?: URL): Promise<boolean>;

package/dist/client/deployment.js

@@ -1,50 +1,16 @@
+import { deploymentCheck } from "./deployment-check.js";
 //#region .generated/client/deployment.ts
 /** Check for deployment changes before navigation. Returns a cleanup function. */
 function watchDeployment(router, options) {
 	if (!options || typeof window === "undefined") return () => {};
-	const { version, manifestURL, timeout = 2e3 } = options;
+	const check = deploymentCheck(options);
+	const { changed, reload } = check;
 	const navigate = router.navigate;
 	const dispose = router.dispose;
-	const manifest = new URL(manifestURL, location.href);
-	const key = `smolter:deployment:${manifest.href}:${version}`;
 	let sequence = 0;
 	let stopped = false;
 	let replay = false;
 	let destination = new URL(location.href);
-	let pending;
-	let controller;
-	function changed() {
-		if (pending) return pending;
-		controller = new AbortController();
-		const timer = setTimeout(() => controller?.abort(), timeout);
-		pending = fetch(manifest, {
-			cache: "no-store",
-			signal: controller.signal
-		}).then(async (response) => {
-			if (!response.ok) return false;
-			const data = await response.json();
-			return typeof data === "object" && data !== null && "version" in data && typeof data.version === "string" && data.version.length > 0 && data.version !== version;
-		}).catch(() => false).finally(() => {
-			clearTimeout(timer);
-			pending = void 0;
-		});
-		return pending;
-	}
-	async function reload(target) {
-		const allowed = await Promise.resolve().then(() => {
-			if (sessionStorage.getItem(key)) return false;
-			sessionStorage.setItem(key, "1");
-			return true;
-		}).catch(() => false);
-		if (allowed && !stopped) {
-			if (options?.reload) options.reload(target);
-			if (!options?.reload) {
-				if (target.href === location.href) location.reload();
-				if (target.href !== location.href) location.assign(target.href);
-			}
-		}
-		return allowed && !stopped;
-	}
 	const guarded = async (href, operation) => {
 		const target = new URL(href, router.getSnapshot().url);
 		const currentURL = new URL(router.getSnapshot().url);
@@ -82,7 +48,7 @@ function watchDeployment(router, options) {
 	function cleanup() {
 		stopped = true;
 		sequence++;
-		controller?.abort();
+		check.dispose();
 		window.removeEventListener("popstate", pop, true);
 		window.removeEventListener("vite:preloadError", preloadError);
 		if (router.navigate === guarded) router.navigate = navigate;
@@ -98,5 +64,11 @@ function watchDeployment(router, options) {
 	window.addEventListener("vite:preloadError", preloadError);
 	return cleanup;
 }
+/** Recover an initial lazy-import failure before a router has mounted. Returns whether a reload was requested. */
+async function recoverDeployment(options, destination) {
+	if (!options || typeof window === "undefined") return false;
+	const check = deploymentCheck(options);
+	return check.changed().then((changed) => changed ? check.reload(destination ?? new URL(location.href)) : false).finally(check.dispose);
+}
 //#endregion
-export { watchDeployment };
+export { recoverDeployment, watchDeployment };

package/dist/client/index.d.ts

@@ -19,7 +19,9 @@ export interface ClientRouteModule {
 export interface ServerHandlers {
     loader?: boolean;
     action?: boolean;
+    /** Application-scoped HTTP transport path. Defaults to /_smolter. */
+    dataEndpoint?: string;
 }
 /** Browser transport for server routes. File-router builds generate this call. */
 export declare function serverRoute<M extends RouteModule = RouteModule>(path: string, module: ClientRouteModule, handlers?: ServerHandlers): Route<M>;
-export { type DeploymentOptions, watchDeployment } from "./deployment.ts";
+export { type DeploymentOptions, recoverDeployment, watchDeployment, } from "./deployment.ts";

package/dist/client/index.js

@@ -1,5 +1,5 @@
 import { deserialize } from "./deserialize.js";
-import { watchDeployment } from "./deployment.js";
+import { recoverDeployment, watchDeployment } from "./deployment.js";
 //#region .generated/client/index.ts
 /** Browser transport for server routes. File-router builds generate this call. */
 function serverRoute(path, module, handlers = {
@@ -8,7 +8,7 @@ function serverRoute(path, module, handlers = {
 }) {
 	const remote = async ({ request, signal }) => {
 		const url = new URL(request.url);
-		const response = await fetch(`/_smolter?url=${encodeURIComponent(url.pathname + url.search)}`, {
+		const response = await fetch(`${handlers.dataEndpoint ?? "/_smolter"}?url=${encodeURIComponent(url.pathname + url.search)}`, {
 			method: request.method,
 			signal,
 			...request.method !== "GET" && { body: await request.formData() }
@@ -44,4 +44,4 @@ function serverRoute(path, module, handlers = {
 	};
 }
 //#endregion
-export { deserialize, serverRoute, watchDeployment };
+export { deserialize, recoverDeployment, serverRoute, watchDeployment };

package/dist/core/responses.d.ts

@@ -11,5 +11,5 @@ export interface DataResponse<T> {
 export declare function data<T>(value: T, init?: ResponseInit): DataResponse<T>;
 export declare function redirect(location: string, init?: number | ResponseInit): Response;
 export declare function isRouteErrorResponse(value: unknown): value is RouteError;
-export declare function normalizeResult(value: unknown): Promise<unknown>;
+export declare function normalizeResult(value: unknown, resolveDeferred?: boolean): Promise<unknown>;
 export declare function resolveData(value: unknown): Promise<unknown>;