@kasperrt/smolter 0.3.0 → 0.3.2

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

@@ -0,0 +1,14 @@
+import type { NavigationRouter } from "../core/index.ts";
+/** Build identity and the fresh, non-cacheable manifest URL emitted by deploymentPlugin. */
+export interface DeploymentOptions {
+    version: string;
+    manifestURL: string;
+    /** Maximum time to wait for the update check before continuing navigation. */
+    timeout?: number;
+    /** Override document navigation, for example to ask about unsaved changes. */
+    reload?: (destination: URL) => void;
+}
+/** 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

@@ -0,0 +1,74 @@
+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 check = deploymentCheck(options);
+	const { changed, reload } = check;
+	const navigate = router.navigate;
+	const dispose = router.dispose;
+	let sequence = 0;
+	let stopped = false;
+	let replay = false;
+	let destination = new URL(location.href);
+	const guarded = async (href, operation) => {
+		const target = new URL(href, router.getSnapshot().url);
+		const currentURL = new URL(router.getSnapshot().url);
+		const current = ++sequence;
+		destination = target;
+		if (target.origin === location.origin && (target.pathname !== currentURL.pathname || target.search !== currentURL.search) && await changed()) {
+			if (current !== sequence || stopped || await reload(target)) return;
+		}
+		if (current === sequence && !stopped) await navigate(href, operation);
+	};
+	const pop = (event) => {
+		if (replay) return;
+		const target = new URL(location.href);
+		const previous = new URL(router.getSnapshot().url);
+		if (target.pathname === previous.pathname && target.search === previous.search) return;
+		event.stopImmediatePropagation();
+		const current = ++sequence;
+		destination = target;
+		changed().then(async (updated) => {
+			if (stopped || current !== sequence) return;
+			if (updated && await reload(target)) return;
+			replay = true;
+			window.dispatchEvent(new PopStateEvent("popstate", { state: event.state }));
+			replay = false;
+		});
+	};
+	const preloadError = () => {
+		if (router.getSnapshot().state === "submitting") return;
+		const current = sequence;
+		const target = destination;
+		changed().then((updated) => {
+			if (updated && current === sequence && !stopped) return reload(target);
+		});
+	};
+	function cleanup() {
+		stopped = true;
+		sequence++;
+		check.dispose();
+		window.removeEventListener("popstate", pop, true);
+		window.removeEventListener("vite:preloadError", preloadError);
+		if (router.navigate === guarded) router.navigate = navigate;
+		if (router.dispose === guardedDispose) router.dispose = dispose;
+	}
+	function guardedDispose() {
+		cleanup();
+		dispose();
+	}
+	router.navigate = guarded;
+	router.dispose = guardedDispose;
+	window.addEventListener("popstate", pop, true);
+	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 { recoverDeployment, watchDeployment };

package/dist/client/index.d.ts

@@ -19,6 +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, recoverDeployment, watchDeployment, } from "./deployment.ts";

package/dist/client/index.js

@@ -1,4 +1,5 @@
 import { deserialize } from "./deserialize.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 = {
@@ -7,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() }
@@ -43,4 +44,4 @@ function serverRoute(path, module, handlers = {
 	};
 }
 //#endregion
-export { deserialize, serverRoute };
+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>;

package/dist/core/responses.js

@@ -19,7 +19,7 @@ function redirect(location, init = 302) {
 function isRouteErrorResponse(value) {
 	return value instanceof Error && "status" in value;
 }
-async function normalizeResult(value) {
+async function normalizeResult(value, resolveDeferred = true) {
 	if (value && typeof value === "object" && "__routeError" in value) {
 		const error = value.__routeError;
 		return Object.assign(Error(error.message), error);
@@ -32,8 +32,8 @@ async function normalizeResult(value) {
 		});
 		return value.json();
 	}
-	if (value && typeof value === "object" && "__routeData" in value) return resolveData(value.value);
-	return resolveData(value);
+	if (value && typeof value === "object" && "__routeData" in value) return resolveDeferred ? resolveData(value.value) : value.value;
+	return resolveDeferred ? resolveData(value) : value;
 }
 async function resolveData(value) {
 	const resolved = await value;

package/dist/core/router.js

@@ -71,6 +71,7 @@ function createDataRouter(routes, options = {}) {
 				const fn = match.route[body ? "clientAction" : "clientLoader"] || match.route[body ? "action" : "loader"];
 				if (!fn) return body && Error("No action");
 				return fn({
+					reason: body ? "action" : navigation !== void 0 ? "navigation" : local ? "fetcher" : previous.loaded ? "revalidation" : "initial",
 					request: new Request(url, {
 						signal,
 						method: body && method,
@@ -84,6 +85,21 @@ function createDataRouter(routes, options = {}) {
 			const redirectTo = result.data instanceof Response && result.data.headers.get("Location");
 			if (redirectTo && redirects) {
 				await main.load(new URL(redirectTo, url).href, void 0, { replace: true }, true, redirects - 1);
+				if (body) {
+					const destination = new URL(main.getSnapshot().url);
+					const args = {
+						url: destination,
+						currentUrl: destination,
+						nextUrl: destination,
+						defaultShouldRevalidate: true,
+						reason: "action",
+						formMethod: method,
+						formAction: url.href,
+						formData: body,
+						actionResult: result.data
+					};
+					await Promise.all([...revalidators].filter((task) => task !== main).map((task) => task.revalidate(args)));
+				}
 				if (!signal.aborted) {
 					submission = void 0;
 					emit("idle");

package/dist/core/types.d.ts

@@ -6,6 +6,8 @@
 export type Params = Record<string, string>;
 /** Request, path parameters, and cancellation signal passed to a data handler. */
 export interface DataArgs {
+    /** Why this handler ran; independent of when browser history is committed. */
+    reason?: "initial" | "navigation" | "revalidation" | "fetcher" | "action";
     request: Request;
     params: Params;
     signal: AbortSignal;

package/dist/preact/client.d.ts

@@ -1,7 +1,12 @@
 /** Browser mounting and hydration for Preact applications. @module */
 /** @jsxImportSource preact */
+import { type DeploymentOptions } from "../client/index.ts";
 import { type Router } from "../core/index.ts";
 import type { AppRoute, RootModule } from "./route-types.ts";
 export * from "../client/index.ts";
 export { configureApplication } from "../core/environment.ts";
-export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, hash?: boolean): Promise<Router>;
+export interface MountApplicationOptions {
+    hash?: boolean;
+    deployment?: DeploymentOptions | null;
+}
+export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, options?: boolean | MountApplicationOptions): Promise<Router>;

package/dist/preact/client.js

@@ -6,6 +6,7 @@ import { connectNavigation } from "../core/navigation.js";
 import { attachRootData } from "./root-data.js";
 import { RouterApplication, prepareRoutes } from "./router.js";
 import { deserialize } from "../client/deserialize.js";
+import { recoverDeployment, watchDeployment } from "../client/deployment.js";
 import { serverRoute } from "../client/index.js";
 import { flushSync } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
@@ -13,20 +14,31 @@ import { hydrate, render } from "preact";
 //#region .generated/preact/client.tsx
 /** Browser mounting and hydration for Preact applications. @module */
 /** @jsxImportSource preact */
-async function mountApplication(routes, rootModule, hash = false) {
+async function mountApplication(routes, rootModule, options = false) {
+	const { hash = false, deployment = null } = typeof options === "boolean" ? { hash: options } : options;
 	const initialURL = new URL(hash ? location.hash.slice(1) || "/" : location.href, location.origin);
-	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.();
+	await (matchRoutes(routes, initialURL.pathname)?.route)?.preload?.().catch(async (error) => {
+		await recoverDeployment(deployment, initialURL);
+		throw error;
+	});
 	routes = prepareRoutes(routes);
 	const element = document.getElementById("smolter-data");
-	const hydration = element?.textContent ? JSON.parse(element.textContent) : void 0;
+	const hydration = element?.textContent ? JSON.parse(element.textContent, (_key, value) => {
+		if (!value || typeof value !== "object" || !("__smolterRejected" in value)) return value;
+		const error = Object.assign(new Error(value.__smolterRejected.message), value.__smolterRejected);
+		const rejected = Promise.reject(error);
+		rejected.catch(() => {});
+		return rejected;
+	}) : void 0;
 	if (hydration?.snapshot.error) hydration.snapshot.error = Object.assign(new Error(hydration.snapshot.error.message), hydration.snapshot.error);
 	const router = createDataRouter(routes, {
 		browser: !hash,
 		url: hash ? new URL(location.hash.slice(1) || "/", location.origin).href : location.href,
 		...hydration && { hydrationData: hydration.snapshot }
 	});
-	retainRoute(router, flushSync);
+	watchDeployment(router, deployment);
 	if (hash) connectHashHistory(router);
+	retainRoute(router, flushSync);
 	connectNavigation(router);
 	const rootStore = attachRootData(router, hydration?.root, rootModule);
 	const props = {
@@ -34,7 +46,8 @@ async function mountApplication(routes, rootModule, hash = false) {
 		router,
 		root: hydration?.root,
 		rootModule,
-		rootStore
+		rootStore,
+		rootError: hydration?.rootError
 	};
 	if (hydration) {
 		hydrate(/* @__PURE__ */ jsx(RouterApplication, {
@@ -48,20 +61,27 @@ async function mountApplication(routes, rootModule, hash = false) {
 	return router;
 }
 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}`;
+		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 { configureApplication, deserialize, mountApplication, serverRoute };
+export { configureApplication, deserialize, mountApplication, recoverDeployment, serverRoute, watchDeployment };

package/dist/preact/document.js

@@ -44,8 +44,9 @@ function Links() {
 	return /* @__PURE__ */ jsx(Fragment$1, { children: rootModule?.links?.().map((props, index) => /* @__PURE__ */ jsx("link", { ...props }, index)) });
 }
 function Scripts({ nonce }) {
-	const { root, router, entry } = useApplication();
+	const { root, rootError, router, entry, streaming } = useApplication();
 	const [json] = useState(() => {
+		if (streaming) return "";
 		const current = router.getSnapshot();
 		const snapshot = {
 			...current,
@@ -57,7 +58,8 @@ function Scripts({ nonce }) {
 		};
 		return serializeData({
 			root,
-			snapshot
+			snapshot,
+			...rootError && { rootError }
 		});
 	});
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [

package/dist/preact/lazy-route.d.ts

@@ -3,6 +3,7 @@ import { type ComponentType } from "preact";
 import type { AppRoute } from "./route-types.ts";
 export interface LazyRouteOptions {
     path: string;
+    dataEndpoint?: string;
     id?: string;
     loader?: boolean;
     action?: boolean;

package/dist/preact/lazy-route.js

@@ -16,7 +16,8 @@ function lazyRoute(options, importer) {
 		pending ??= importer().then((loaded) => {
 			module = serverRoute(options.path, loaded, {
 				loader: options.loader,
-				action: options.action
+				action: options.action,
+				dataEndpoint: options.dataEndpoint
 			});
 		}).catch((error) => {
 			pending = void 0;

package/dist/preact/root-context.d.ts

@@ -4,6 +4,8 @@ export interface ApplicationContext {
     router: Router;
     routes: AppRoute[];
     root: unknown;
+    rootError?: boolean;
+    streaming?: boolean;
     rootModule?: RootModule;
     hydration?: Hydration;
     entry?: string;

package/dist/preact/route-types.d.ts

@@ -47,6 +47,7 @@ export interface RootModule {
     shouldRevalidate?: (args: RevalidationArgs) => boolean;
 }
 export interface Hydration {
+    rootError?: boolean;
     root: unknown;
     snapshot: Snapshot;
 }

package/dist/preact/router.d.ts

@@ -13,4 +13,4 @@ export interface ApplicationProps extends ApplicationContext {
     rootStore?: ReturnType<typeof createRootStore>;
 }
 export declare function RouterApplication(props: ApplicationProps): import("preact").JSX.Element;
-export declare function prepareRoutes(routes: AppRoute[]): AppRoute[];
+export declare function prepareRoutes(routes: AppRoute[], preserveDeferred?: boolean): AppRoute[];

package/dist/preact/router.js

@@ -21,7 +21,7 @@ function RouterApplication(props) {
 	const root = useSyncExternalStore(rootStore.subscribe, rootStore.getSnapshot);
 	const snapshot = useSyncExternalStore(props.router.subscribe, props.router.getSnapshot);
 	const route = props.routes.find((item) => item.path === snapshot.path);
-	const Root = snapshot.error && !route?.ErrorBoundary ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
+	const Root = snapshot.error && (props.rootError || !route?.ErrorBoundary) ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
 	const Layout = props.rootModule?.Layout;
 	const children = /* @__PURE__ */ jsx(Root, {});
 	return /* @__PURE__ */ jsx(RouterProvider, {
@@ -35,7 +35,7 @@ function RouterApplication(props) {
 		})
 	});
 }
-function prepareRoutes(routes) {
+function prepareRoutes(routes, preserveDeferred = false) {
 	return routes.map((route) => {
 		const wrapped = {
 			...route,
@@ -54,7 +54,7 @@ function prepareRoutes(routes) {
 		]) {
 			const handler = route[key];
 			if (!handler) continue;
-			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then(normalizeResult, normalizeResult);
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then((value) => normalizeResult(value, !preserveDeferred), (error) => normalizeResult(error, !preserveDeferred));
 		}
 		return wrapped;
 	});

package/dist/server/application.d.ts

@@ -1,4 +1,7 @@
 /** @jsxImportSource preact */
 import type { AppRoute, RootModule } from "../preact/route-types.ts";
-export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string): Promise<Response>;
+export interface RenderApplicationOptions {
+    nonce?: string;
+}
+export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string, options?: RenderApplicationOptions): Promise<Response>;
 export declare function dispatchRoute(request: Request, routes: AppRoute[], document?: boolean): Promise<Response>;

package/dist/server/application.js

@@ -1,13 +1,16 @@
+import { safeWrapAsync } from "../core/errors.js";
 import { matchRoutes } from "../core/match.js";
 import { createDataRouter } from "../core/router.js";
 import { normalizeResult, resolveData } from "../core/responses.js";
 import { RouterApplication, prepareRoutes } from "../preact/router.js";
+import { privateResponse } from "./private-response.js";
 import { loadRouter } from "./index.js";
+import { resolveHydration, streamDocument } from "./stream-document.js";
 import { jsx } from "preact/jsx-runtime";
-import { renderToStringAsync } from "preact-render-to-string";
+import { renderToReadableStream } from "preact-render-to-string/stream";
 //#region .generated/server/application.tsx
 /** @jsxImportSource preact */
-async function renderApplication(request, routes, rootModule, entry) {
+async function renderApplication(request, routes, rootModule, entry, options = {}) {
 	routes = routes.map((route) => ({
 		...route,
 		path: route.routePath ?? route.path
@@ -21,16 +24,16 @@ async function renderApplication(request, routes, rootModule, entry) {
 		if (actionResponse.headers.has("Location") || !actionResponse.headers.get("Content-Type")?.includes("application/json")) return actionResponse;
 		actionData = await normalizeResult(await actionResponse.json());
 	}
-	const root = await resolveData(await rootModule.loader?.({
+	const rootResult = safeWrapAsync(() => Promise.resolve().then(() => rootModule.loader?.({
 		request,
 		params: {},
 		signal: request.signal
-	}));
+	})).then((value) => normalizeResult(value, false), (error) => error instanceof Response ? normalizeResult(error, false) : error instanceof Error ? error : new Error(String(error), { cause: error })));
 	let redirectResponse;
 	const prepared = prepareRoutes(routes.map((route) => ({
 		...route,
 		ErrorBoundary: route.ErrorBoundary ?? rootModule.ErrorBoundary
-	}))).map((route) => {
+	})), true).map((route) => {
 		if (!route.loader) return route;
 		const loader = route.loader;
 		return {
@@ -42,41 +45,68 @@ async function renderApplication(request, routes, rootModule, entry) {
 			}
 		};
 	});
-	let router = await loadRouter(prepared, request);
+	const [rootState, loadedRouter] = await Promise.all([rootResult, loadRouter(prepared, request)]);
+	let router = loadedRouter;
+	const rootError = rootState.error ?? (rootState.data instanceof Error ? rootState.data : void 0);
+	const root = rootError ? void 0 : rootState.data;
+	if (root instanceof Response && root.headers.has("Location")) {
+		router.dispose();
+		return root;
+	}
 	if (redirectResponse) {
 		router.dispose();
 		return redirectResponse;
 	}
-	if (actionResponse) {
+	if (actionResponse || rootError) {
 		const hydrationData = {
 			...router.getSnapshot(),
 			actionData: actionData instanceof Error ? void 0 : actionData,
-			...actionData instanceof Error && { error: actionData }
+			...actionData instanceof Error && { error: actionData },
+			...rootError && { error: rootError }
 		};
 		router.dispose();
 		router = createDataRouter(router.routes, { hydrationData });
 	}
 	const snapshot = router.getSnapshot();
-	const html = await renderToStringAsync(/* @__PURE__ */ jsx(RouterApplication, {
+	const stream = renderToReadableStream(/* @__PURE__ */ jsx(RouterApplication, {
 		router,
 		routes,
 		root,
 		rootModule,
 		entry,
+		rootError: Boolean(rootError),
+		streaming: true,
 		document: true
-	}));
-	router.dispose();
+	}), options);
+	const hydration = resolveHydration({
+		root,
+		snapshot: {
+			...snapshot,
+			error: snapshot.error && {
+				...snapshot.error,
+				name: snapshot.error.name,
+				message: snapshot.error.message
+			}
+		},
+		...rootError && { rootError: true }
+	});
+	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(`<!doctype html>${html}`, {
+	return new Response(streamDocument(stream, {
+		hydration,
+		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
 	});
 }
-async function dispatchRoute(request, routes, document = false) {
+async function dispatch(request, routes, document = false) {
 	const match = matchRoutes(routes.map((route) => ({
 		...route,
 		path: route.routePath ?? route.path
@@ -115,5 +145,9 @@ async function dispatchRoute(request, routes, document = false) {
 	}
 	return Response.json(await normalizeResult(value) ?? null);
 }
+async function dispatchRoute(request, routes, document = false) {
+	const response = await dispatch(request, routes, document);
+	return document ? response : privateResponse(response);
+}
 //#endregion
 export { dispatchRoute, renderApplication };

package/dist/server/handler.d.ts

@@ -8,6 +8,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 {
     /** Express supplies this using the application's trust proxy policy. */
@@ -16,4 +18,4 @@ export interface ServerIncomingMessage extends IncomingMessage {
 }
 export type NextHandler = (error?: unknown) => void;
 /** Node/Express middleware; mount after metrics, tracing and static assets. */
-export declare function createRequestHandler({ build, entry, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;
+export declare function createRequestHandler({ build, entry, dataEndpoint, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;

package/dist/server/handler.js

@@ -1,11 +1,13 @@
+import { privateResponse } from "./private-response.js";
 import { send, webRequest } from "./http.js";
 //#region .generated/server/handler.ts
 /** Node/Express middleware; mount after metrics, tracing and static assets. */
-function createRequestHandler({ build, entry }) {
+function createRequestHandler({ build, entry, dataEndpoint = "/_smolter" }) {
 	return (incoming, outgoing, next) => {
 		const handle = async () => {
 			const url = new URL(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") : void 0;
 			if (dataRequest && (!target?.startsWith("/") || new URL(target, "http://local").origin !== "http://local")) {
 				await send(new Response("Invalid route URL", { status: 400 }), outgoing);
@@ -13,7 +15,7 @@ function createRequestHandler({ build, entry }) {
 			}
 			const request = await webRequest(incoming, outgoing, target ?? void 0);
 			const response = dataRequest ? 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/dist/server/http.d.ts

@@ -1,4 +1,8 @@
 import type { ServerResponse } from "node:http";
 import type { ServerIncomingMessage } from "./handler.ts";
 export declare function webRequest(incoming: ServerIncomingMessage, outgoing: ServerResponse, target?: string): Promise<Request>;
-export declare function send(response: Response, outgoing: ServerResponse): Promise<void>;
+interface StreamingResponse extends ServerResponse {
+    flush?: () => void;
+}
+export declare function send(response: Response, outgoing: StreamingResponse): Promise<void>;
+export {};

package/dist/server/http.js

@@ -1,3 +1,5 @@
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
 //#region .generated/server/http.ts
 async function webRequest(incoming, outgoing, target) {
 	const origin = `${incoming.protocol ?? "http"}://${incoming.headers.host}`;
@@ -21,7 +23,14 @@ async function send(response, outgoing) {
 	});
 	const cookies = response.headers.getSetCookie();
 	if (cookies.length) outgoing.setHeader("set-cookie", cookies.map((cookie) => process.env.NODE_ENV === "production" ? cookie : cookie.replace(/; Secure/gi, "")));
-	outgoing.end(new Uint8Array(await response.arrayBuffer()));
+	if (!response.body) {
+		outgoing.end();
+		return;
+	}
+	await pipeline(Readable.fromWeb(response.body), new Transform({ transform(chunk, _encoding, done) {
+		done(null, chunk);
+		outgoing.flush?.();
+	} }), outgoing);
 }
 //#endregion
 export { send, webRequest };