@kasperrt/smolter 0.4.3 → 0.4.4

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

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

package/dist/react/router.d.ts

@@ -0,0 +1,10 @@
+import { createStore } from "../core/store.ts";
+import { type ApplicationContext } from "./root-context.ts";
+import { type ReactNode } from "./runtime.ts";
+/** Root data, document components and request-scoped router for an application. */
+export interface ApplicationProps extends ApplicationContext {
+    document?: boolean;
+    rootStore?: ReturnType<typeof createStore>;
+}
+/** Compose a persistent root layout with route views and observable root loader data. */
+export declare function RouterApplication(props: ApplicationProps): ReactNode;

package/dist/react/router.js

@@ -0,0 +1,22 @@
+import { createElement, useMemo, useSyncExternalStore } from "./runtime.js";
+import { RouterProvider } from "./context.js";
+import { createStore } from "../core/store.js";
+import { Application } from "./root-context.js";
+import { Outlet } from "./outlet.js";
+//#region .generated/react/router.ts
+/** Compose a persistent root layout with route views and observable root loader data. */
+function RouterApplication(props) {
+	const store = useMemo(() => props.rootStore ?? createStore(props.root), [props.rootStore, props.root]);
+	const root = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+	const snapshot = useSyncExternalStore(props.router.subscribe, props.router.getSnapshot, props.router.getSnapshot);
+	const route = props.routes.find((item) => item.path === snapshot.path);
+	const Root = snapshot.error && (props.rootError || !route?.ErrorBoundary) ? props.rootModule?.ErrorBoundary ?? Outlet : props.rootModule?.default ?? Outlet;
+	const Layout = props.rootModule?.Layout;
+	const children = createElement(Root);
+	return createElement(RouterProvider, { router: props.router }, createElement(Application.Provider, { value: {
+		...props,
+		root
+	} }, props.document && Layout ? createElement(Layout, { children }) : children));
+}
+//#endregion
+export { RouterApplication };

package/dist/react/runtime.d.ts

@@ -1,2 +1,2 @@
 export type { AnchorHTMLAttributes, ComponentType, FormHTMLAttributes, MouseEvent, ReactNode, } from "react";
-export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore, } from "react";
+export { createContext, createElement, useCallback, useContext, useEffect, useMemo, useSyncExternalStore, } from "react";

package/dist/react/runtime.js

@@ -1 +1 @@
-export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore } from "react";
+export { createContext, createElement, useCallback, useContext, useEffect, useMemo, useSyncExternalStore } from "react";

package/dist/server/application.d.ts

@@ -1,11 +1,7 @@
 /** @jsxImportSource preact */
 import type { AppRoute, RootModule } from "../preact/route-types.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. */
+import { type RenderApplicationOptions } from "./render-application.ts";
+export { dispatchRoute } from "./dispatch.ts";
+export type { RenderApplicationOptions } from "./render-application.ts";
+/** Render a Preact application response with root data and optional early deferred hydration. */
 export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string, options?: RenderApplicationOptions): Promise<Response>;
-/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
-export declare function dispatchRoute(request: Request, routes: AppRoute[], document?: boolean): Promise<Response>;

package/dist/server/application.js

@@ -1,120 +1,17 @@
-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 { deferredHydration } from "./deferred-hydration.js";
-import { progressiveDocument } from "./progressive-document.js";
-import { resolveHydration, streamDocument } from "./stream-document.js";
+import { RouterApplication } from "../preact/router.js";
+import { dispatchRoute } from "./dispatch.js";
+import { renderDocument } from "./render-application.js";
 import { Suspense } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
 import { renderToReadableStream } from "preact-render-to-string/stream";
 //#region .generated/server/application.tsx
-/** @jsxImportSource preact */
-/** Render a Preact application response with root and route data, streaming deferred content when enabled. */
-async function renderApplication(request, routes, rootModule, entry, options = {}) {
-	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;
-	let actionData;
-	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) => 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
-	})), true).map((route) => {
-		if (!route.loader) return route;
-		const loader = route.loader;
-		return {
-			...route,
-			loader: async (args) => {
-				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 : 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 || rootError) {
-		const hydrationData = {
-			...router.getSnapshot(),
-			actionData: actionData instanceof Error ? void 0 : 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) : void 0;
-	const stream = renderToReadableStream(/* @__PURE__ */ jsx(RouterApplication, {
-		router,
-		routes,
-		root,
+/** Render a Preact application response with root data and optional early deferred hydration. */
+function renderApplication(request, routes, rootModule, entry, options = {}) {
+	return renderDocument(request, routes, rootModule, entry, options, (props) => renderToReadableStream(/* @__PURE__ */ jsx(RouterApplication, {
+		...props,
 		rootModule,
-		entry,
-		rootError: Boolean(rootError),
-		streaming: true,
-		deferredBoundary: options.earlyHydration ? void 0 : deferredBoundary,
-		initialData: deferred?.initial,
-		document: true
-	}), options);
-	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
-	});
+		deferredBoundary: options.earlyHydration ? void 0 : deferredBoundary
+	}), options));
 }
 function deferredBoundary(children, fallback) {
 	return /* @__PURE__ */ jsx(Suspense, {
@@ -122,49 +19,5 @@ function deferredBoundary(children, fallback) {
 		children
 	});
 }
-async function dispatch(request, routes, document = false) {
-	const match = matchRoutes(routes.map((route) => ({
-		...route,
-		path: route.routePath ?? route.path
-	})), new URL(request.url).pathname);
-	if (!match) return Response.json({ error: "No route" }, { status: 404 });
-	const handler = request.method === "GET" || request.method === "HEAD" ? match.route.loader : match.route.action;
-	if (!handler) return Response.json({ error: "No handler" }, { status: 405 });
-	const value = await Promise.resolve().then(() => handler({
-		request,
-		params: match.params,
-		signal: request.signal
-	})).then((result) => result, (error) => error);
-	if (value instanceof Response) {
-		const location = value.headers.get("Location");
-		if (document) return value;
-		if (!location) {
-			if (value.ok) return value;
-			return Response.json({ __routeError: {
-				message: await value.text(),
-				status: value.status,
-				statusText: value.statusText
-			} });
-		}
-		const headers = new Headers(value.headers);
-		headers.delete("Location");
-		headers.set("X-Smolter-Redirect", location);
-		return new Response(null, { headers });
-	}
-	if (value instanceof Error) return Response.json({ __routeError: {
-		...value,
-		message: value.message
-	} });
-	if (value && typeof value === "object" && "__routeData" in value) {
-		const result = value;
-		return Response.json(await resolveData(result.value), document ? result.init : { headers: result.init.headers });
-	}
-	return Response.json(await normalizeResult(value) ?? null);
-}
-/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
-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/dispatch.d.ts

@@ -0,0 +1,5 @@
+import { type Route } from "../core/index.ts";
+/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
+export declare function dispatchRoute(request: Request, routes: readonly (Route & {
+    routePath?: string;
+})[], document?: boolean): Promise<Response>;

package/dist/server/dispatch.js

@@ -0,0 +1,50 @@
+import { matchRoutes } from "../core/match.js";
+import { normalizeResult, resolveData } from "../core/responses.js";
+import { privateResponse } from "./private-response.js";
+//#region .generated/server/dispatch.ts
+async function dispatch(request, routes, document = false) {
+	const match = matchRoutes(routes.map((route) => ({
+		...route,
+		path: route.routePath ?? route.path
+	})), new URL(request.url).pathname);
+	if (!match) return Response.json({ error: "No route" }, { status: 404 });
+	const handler = request.method === "GET" || request.method === "HEAD" ? match.route.loader : match.route.action;
+	if (!handler) return Response.json({ error: "No handler" }, { status: 405 });
+	const value = await Promise.resolve().then(() => handler({
+		request,
+		params: match.params,
+		signal: request.signal
+	})).then((result) => result, (error) => error);
+	if (value instanceof Response) {
+		const location = value.headers.get("Location");
+		if (document) return value;
+		if (!location) {
+			if (value.ok) return value;
+			return Response.json({ __routeError: {
+				message: await value.text(),
+				status: value.status,
+				statusText: value.statusText
+			} });
+		}
+		const headers = new Headers(value.headers);
+		headers.delete("Location");
+		headers.set("X-Smolter-Redirect", location);
+		return new Response(null, { headers });
+	}
+	if (value instanceof Error) return Response.json({ __routeError: {
+		...value,
+		message: value.message
+	} });
+	if (value && typeof value === "object" && "__routeData" in value) {
+		const result = value;
+		return Response.json(await resolveData(result.value), document ? result.init : { headers: result.init.headers });
+	}
+	return Response.json(await normalizeResult(value) ?? null);
+}
+/** Dispatch a normalized application URL to its route loader or action and return an HTTP response. */
+async function dispatchRoute(request, routes, document = false) {
+	const response = await dispatch(request, routes, document);
+	return document ? response : privateResponse(response);
+}
+//#endregion
+export { dispatchRoute };

package/dist/server/index.d.ts

@@ -8,3 +8,4 @@ export declare function loadRouter(routes: readonly Route[], input: string | Req
 export { serialize } from "../core/index.ts";
 /** Dispatch a server data request with an explicit private cache policy. */
 export declare function handleRequest(routes: readonly Route[], request: Request): Promise<Response>;
+export { dispatchRoute } from "./dispatch.ts";

package/dist/server/index.js

@@ -3,6 +3,7 @@ import { matchRoutes } from "../core/match.js";
 import { createDataRouter } from "../core/router.js";
 import { serialize } from "../core/serialize.js";
 import { privateResponse } from "./private-response.js";
+import { dispatchRoute } from "./dispatch.js";
 //#region .generated/server/index.ts
 /**
 * Request-scoped server rendering and HTTP data dispatch.
@@ -83,4 +84,4 @@ async function handleRequest(routes, request) {
 	return privateResponse(await dispatchRequest(routes, request));
 }
 //#endregion
-export { handleRequest, loadRouter, serialize };
+export { dispatchRoute, handleRequest, loadRouter, serialize };

package/dist/server/preact.js

@@ -1,4 +1,5 @@
 import { serialize } from "../core/serialize.js";
+import { dispatchRoute } from "./dispatch.js";
 import { handleRequest, loadRouter } from "./index.js";
-import { dispatchRoute, renderApplication } from "./application.js";
+import { renderApplication } from "./application.js";
 export { dispatchRoute, handleRequest, loadRouter, renderApplication, serialize };

package/dist/server/react.d.ts

@@ -0,0 +1,10 @@
+/**
+ * React SSR rendering and route data dispatch.
+ * @module
+ */
+import type { AppRoute, RootModule } from "../react/route-types.ts";
+import { type RenderApplicationOptions } 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 declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string, options?: RenderApplicationOptions): Promise<Response>;

package/dist/server/react.js

@@ -0,0 +1,22 @@
+import { serialize } from "../core/serialize.js";
+import { RouterApplication } from "../react/router.js";
+import { dispatchRoute } from "./dispatch.js";
+import { handleRequest, loadRouter } from "./index.js";
+import { renderDocument } from "./render-application.js";
+import { createElement } from "react";
+import * as ReactDOMServer from "react-dom/server";
+//#region .generated/server/react.ts
+/** Render a React document with root and route data using React's streaming renderer. */
+async function renderApplication(request, routes, rootModule, entry, options = {}) {
+	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
+	}));
+}
+//#endregion
+export { dispatchRoute, handleRequest, loadRouter, renderApplication, serialize };

package/dist/server/render-application.d.ts

@@ -0,0 +1,31 @@
+import type { DataArgs, Route, Router } from "../core/index.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;
+}
+/** 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 declare 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>;
+export {};

package/dist/server/render-application.js

@@ -0,0 +1,118 @@
+import { safeWrapAsync } from "../core/errors.js";
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { normalizeResult } from "../core/responses.js";
+import { prepareRoutes } from "../core/prepare-routes.js";
+import { dispatchRoute } from "./dispatch.js";
+import { loadRouter } from "./index.js";
+import { deferredHydration } from "./deferred-hydration.js";
+import { progressiveDocument } from "./progressive-document.js";
+import { resolveHydration, streamDocument } from "./stream-document.js";
+//#region .generated/server/render-application.ts
+/** Render a Preact application response with root and route data, streaming deferred content when enabled. */
+async function renderDocument(request, routes, rootModule, entry, options, render) {
+	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;
+	let actionData;
+	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) => 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
+	})), true).map((route) => {
+		if (!route.loader) return route;
+		const loader = route.loader;
+		return {
+			...route,
+			loader: async (args) => {
+				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 : 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 || rootError) {
+		const hydrationData = {
+			...router.getSnapshot(),
+			actionData: actionData instanceof Error ? void 0 : 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) : void 0;
+	const stream = await Promise.resolve().then(() => render({
+		router,
+		routes,
+		root,
+		entry,
+		rootError: Boolean(rootError),
+		streaming: true,
+		initialData: deferred?.initial,
+		document: true
+	})).catch(async (error) => {
+		router.dispose();
+		await deferred?.stream.cancel();
+		throw error;
+	});
+	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
+	});
+}
+//#endregion
+export { renderDocument };

package/dist/vite/application/lazy-files.d.ts

@@ -1,2 +1,2 @@
 import { type Plugin } from "vite";
-export declare function lazyFiles(directory: string, dataEndpoint?: string): Plugin;
+export declare function lazyFiles(directory: string, dataEndpoint?: string, framework?: "react" | "preact"): Plugin;

package/dist/vite/application/lazy-files.js

@@ -3,7 +3,7 @@ import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { transformWithOxc } from "vite";
 //#region .generated/vite/application/lazy-files.ts
-function lazyFiles(directory, dataEndpoint = "/_smolter") {
+function lazyFiles(directory, dataEndpoint = "/_smolter", framework = "preact") {
 	let root;
 	const modules = /* @__PURE__ */ new Map();
 	return {
@@ -81,7 +81,7 @@ function lazyFiles(directory, dataEndpoint = "/_smolter") {
 				if (fields.default) modules.set(file, String(fields.path));
 				definitions.push(`lazyRoute(${JSON.stringify(fields)}, () => import(${JSON.stringify(file)}))`);
 			}
-			return ["import { lazyRoute } from \"@kasperrt/smolter/preact/lazy-route\";", `export default [${definitions.join(",\n")}];`].join("\n");
+			return [`import { lazyRoute } from "@kasperrt/smolter/${framework}/lazy-route";`, `export default [${definitions.join(",\n")}];`].join("\n");
 		}
 	};
 }

package/dist/vite/application/vite.d.ts

@@ -1,10 +1,11 @@
 import type { Plugin, UserConfig } from "vite";
 export interface ApplicationOptions {
     directory?: string;
+    framework?: "react" | "preact";
     dataEndpoint?: string;
     ssr?: boolean;
     splitRoutes?: boolean;
     resourceRequest?: (url: string) => boolean;
 }
 export declare const preactConfig: UserConfig;
-export declare function applicationPlugins({ directory, dataEndpoint, ssr, splitRoutes, resourceRequest, }?: ApplicationOptions): Plugin[];
+export declare function applicationPlugins({ directory, framework, dataEndpoint, ssr, splitRoutes, resourceRequest, }?: ApplicationOptions): Plugin[];