@kasperrt/smolter 0.4.2 → 0.4.4

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/handler.d.ts

@@ -4,6 +4,7 @@ export interface ServerBuild {
     default: (request: Request, entry: string) => Response | Promise<Response>;
     handleDataRequest: (request: Request) => Response | Promise<Response>;
 }
+/** SSR build, browser entry URL and application-scoped data endpoint for Node or Express. */
 export interface RequestHandlerOptions {
     build: ServerBuild;
     /** Browser entry URL resolved from Vite's production manifest. */
@@ -11,11 +12,13 @@ export interface RequestHandlerOptions {
     /** Must match the browser and Vite transport endpoint. */
     dataEndpoint?: string;
 }
+/** Node request with optional Express protocol and original URL information. */
 export interface ServerIncomingMessage extends IncomingMessage {
     /** Express supplies this using the application's trust proxy policy. */
     protocol?: string;
     originalUrl?: string;
 }
+/** Express-compatible callback for forwarding middleware errors. */
 export type NextHandler = (error?: unknown) => void;
 /** Node/Express middleware; mount after metrics, tracing and static assets. */
 export declare function createRequestHandler({ build, entry, dataEndpoint, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;

package/dist/server/http.d.ts

@@ -1,8 +1,10 @@
 import type { ServerResponse } from "node:http";
 import type { ServerIncomingMessage } from "./handler.ts";
+/** Convert a Node request to a Web Request with cancellation and an optional normalized route target. */
 export declare function webRequest(incoming: ServerIncomingMessage, outgoing: ServerResponse, target?: string): Promise<Request>;
 interface StreamingResponse extends ServerResponse {
     flush?: () => void;
 }
+/** Write a Web Response to Node with streaming backpressure and disconnect cancellation. */
 export declare function send(response: Response, outgoing: StreamingResponse): Promise<void>;
 export {};

package/dist/server/http.js

@@ -1,6 +1,7 @@
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 //#region .generated/server/http.ts
+/** Convert a Node request to a Web Request with cancellation and an optional normalized route target. */
 async function webRequest(incoming, outgoing, target) {
 	const origin = `${incoming.protocol ?? "http"}://${incoming.headers.host}`;
 	const headers = new Headers();
@@ -16,6 +17,7 @@ async function webRequest(incoming, outgoing, target) {
 		...incoming.method !== "GET" && incoming.method !== "HEAD" && { body: new Uint8Array(Buffer.concat(chunks)) }
 	});
 }
+/** Write a Web Response to Node with streaming backpressure and disconnect cancellation. */
 async function send(response, outgoing) {
 	outgoing.statusCode = response.status;
 	response.headers.forEach((value, name) => {

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/node.d.ts

@@ -1,3 +1,7 @@
-/** Optional application integration. @module */
+/**
+ * Streaming Node and Express adapters for Web requests and responses.
+ *
+ * @module
+ */
 export * from "./handler.ts";
 export * from "./http.ts";

package/dist/server/preact.d.ts

@@ -1,3 +1,7 @@
-/** Preact server rendering and HTTP data dispatch. @module */
+/**
+ * Preact SSR rendering and route data dispatch.
+ *
+ * @module
+ */
 export { dispatchRoute, type RenderApplicationOptions, renderApplication, } from "./application.tsx";
 export * from "./index.ts";

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[];

package/dist/vite/application/vite.js

@@ -43,12 +43,19 @@ var preactConfig = {
 		"@kasperrt/smolter/preact/lazy-route"
 	] }
 };
-function applicationPlugins({ directory = "src/routes", dataEndpoint = "/_smolter", ssr = true, splitRoutes = true, resourceRequest } = {}) {
+function applicationPlugins({ directory = "src/routes", framework = "preact", dataEndpoint = "/_smolter", ssr = true, splitRoutes = true, resourceRequest } = {}) {
 	return [
 		{
 			name: "smolter-application",
 			enforce: "pre",
-			config: () => preactConfig,
+			config: () => framework === "preact" ? preactConfig : {
+				resolve: { dedupe: [
+					"react",
+					"react-dom",
+					"@kasperrt/smolter"
+				] },
+				ssr: { noExternal: ["@kasperrt/smolter"] }
+			},
 			transformIndexHtml: {
 				order: "post",
 				handler(html, context) {
@@ -66,7 +73,7 @@ function applicationPlugins({ directory = "src/routes", dataEndpoint = "/_smolte
 						const target = new URL(incoming.url, "http://local").searchParams.get("url");
 						if (!target?.startsWith("/") || target.startsWith("//")) return send(new Response("Invalid route URL", { status: 400 }), outgoing);
 						const request = await webRequest(incoming, outgoing, target);
-						const [{ default: routes }, { dispatchRoute }] = await Promise.all([server.ssrLoadModule("virtual:smolter/routes"), server.ssrLoadModule("@kasperrt/smolter/preact/server")]);
+						const [{ default: routes }, { dispatchRoute }] = await Promise.all([server.ssrLoadModule("virtual:smolter/routes"), server.ssrLoadModule(`@kasperrt/smolter/${framework}/server`)]);
 						await send(await dispatchRoute(request, routes), outgoing);
 					};
 					run().catch(next);
@@ -92,10 +99,10 @@ function applicationPlugins({ directory = "src/routes", dataEndpoint = "/_smolte
 			}
 		},
 		browserBoundary(),
-		...splitRoutes ? [lazyFiles(directory, dataEndpoint)] : [],
+		...splitRoutes ? [lazyFiles(directory, dataEndpoint, framework)] : [],
 		routerPlugin({
 			directory,
-			framework: "preact",
+			framework,
 			dataEndpoint
 		})
 	];

package/dist/vite/react.d.ts

@@ -7,4 +7,8 @@ export type { FileRouterOptions } from "./index.ts";
 export declare function routerPlugin(options?: FileRouterOptions): Plugin;
 /** File routing is the default; this alias keeps configuration explicit. */
 export declare const fileRouter: typeof routerPlugin;
+export type { ApplicationOptions } from "./application/vite.ts";
 export { type DeploymentPluginOptions, deploymentPlugin, } from "./deployment.ts";
+import { type ApplicationOptions } from "./application/vite.ts";
+/** Configure React application SSR, scoped data transport and lazy file routing. */
+export declare function applicationPlugins(options?: ApplicationOptions): Plugin[];

package/dist/vite/react.js

@@ -1,6 +1,7 @@
 import { flatRoutes } from "../files/index.js";
 import { routerPlugin as routerPlugin$1 } from "./index.js";
 import { deploymentPlugin } from "./deployment.js";
+import { applicationPlugins as applicationPlugins$1 } from "./application/vite.js";
 //#region .generated/vite/react.ts
 /** Configure flat routes and server transport for React. */
 function routerPlugin(options = {}) {
@@ -11,5 +12,12 @@ function routerPlugin(options = {}) {
 }
 /** File routing is the default; this alias keeps configuration explicit. */
 var fileRouter = routerPlugin;
+/** Configure React application SSR, scoped data transport and lazy file routing. */
+function applicationPlugins(options = {}) {
+	return applicationPlugins$1({
+		...options,
+		framework: "react"
+	});
+}
 //#endregion
-export { deploymentPlugin, fileRouter, flatRoutes, routerPlugin };
+export { applicationPlugins, deploymentPlugin, fileRouter, flatRoutes, routerPlugin };

package/jsr.json

@@ -1,20 +1,21 @@
 {
   "name": "@kasperrt/smolter",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "exports": {
     "./react": "./.generated/react/index.ts",
     "./preact": "./.generated/preact/index.ts",
-    "./react/server": "./.generated/server/index.ts",
+    "./react/server": "./.generated/server/react.ts",
     "./preact/server": "./.generated/server/preact.ts",
-    "./react/client": "./.generated/client/index.ts",
+    "./react/client": "./.generated/react/client.tsx",
     "./preact/client": "./.generated/preact/client.tsx",
     "./utils": "./.generated/core/utils.ts",
     "./utils/http": "./.generated/server/node.ts",
     "./utils/assets": "./.generated/server/assets.ts",
     "./utils/responses": "./.generated/core/responses.ts",
-    "./react/data": "./.generated/react/data.ts",
     "./preact/lazy-route": "./.generated/preact/lazy-route.ts",
-    "./preact/document": "./.generated/preact/document.tsx"
+    "./preact/document": "./.generated/preact/document.tsx",
+    "./react/document": "./.generated/react/document.tsx",
+    "./react/lazy-route": "./.generated/react/lazy-route.ts"
   },
   "imports": {
     "react": "npm:react@19.3.1",
@@ -23,7 +24,10 @@
     "preact/hooks": "npm:preact@11.0.1/hooks",
     "preact/jsx-runtime": "npm:preact@11.0.1/jsx-runtime",
     "preact-render-to-string": "npm:preact-render-to-string@6.8.1",
-    "react/jsx-runtime": "npm:react@19.3.1/jsx-runtime"
+    "react/jsx-runtime": "npm:react@19.3.1/jsx-runtime",
+    "react-dom": "npm:react-dom@19.3.1",
+    "react-dom/client": "npm:react-dom@19.3.1/client",
+    "react-dom/server": "npm:react-dom@19.3.1/server"
   },
   "publish": {
     "include": [

package/package.json

@@ -20,7 +20,7 @@
     "build:examples": "pnpm --filter \"@smolter/example-*\" build",
     "smoke:production": "node scripts/production-smoke.mjs",
     "jsr:check": "node scripts/jsr.mjs",
-    "build:site": "vite build --config apps/site/vite.config.ts && pnpm --filter @smolter/example-react build --mode hosted && pnpm --filter @smolter/example-preact build --mode hosted",
+    "build:site": "pnpm --filter @smolter/example-preact build --mode hosted",
     "smoke:site": "node scripts/site-smoke.mjs",
     "docs:badges": "node scripts/readme-badges.mjs",
     "docs:reference": "pnpm build && node scripts/docs-reference.mjs",
@@ -35,6 +35,7 @@
     "@smolter/preact": "workspace:*",
     "@smolter/react": "workspace:*",
     "@smolter/server": "workspace:*",
+    "@smolter/ui": "workspace:*",
     "@smolter/vite": "workspace:*",
     "@types/node": "24.10.1",
     "@types/react": "19.3.0",
@@ -56,7 +57,7 @@
     "wouter": "3.13.0",
     "wouter-preact": "3.13.0"
   },
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "A tiny typed data router for React and Preact.",
   "sideEffects": false,
   "license": "MIT",
@@ -74,16 +75,16 @@
       "import": "./dist/preact/index.js"
     },
     "./react/server": {
-      "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js"
+      "types": "./dist/server/react.d.ts",
+      "import": "./dist/server/react.js"
     },
     "./preact/server": {
       "types": "./dist/server/preact.d.ts",
       "import": "./dist/server/preact.js"
     },
     "./react/client": {
-      "types": "./dist/client/index.d.ts",
-      "import": "./dist/client/index.js"
+      "types": "./dist/react/client.d.ts",
+      "import": "./dist/react/client.js"
     },
     "./preact/client": {
       "types": "./dist/preact/client.d.ts",
@@ -113,10 +114,6 @@
       "types": "./dist/core/responses.d.ts",
       "import": "./dist/core/responses.js"
     },
-    "./react/data": {
-      "types": "./dist/react/data.d.ts",
-      "import": "./dist/react/data.js"
-    },
     "./preact/lazy-route": {
       "types": "./dist/preact/lazy-route.d.ts",
       "import": "./dist/preact/lazy-route.js"
@@ -124,6 +121,14 @@
     "./preact/document": {
       "types": "./dist/preact/document.d.ts",
       "import": "./dist/preact/document.js"
+    },
+    "./react/document": {
+      "types": "./dist/react/document.d.ts",
+      "import": "./dist/react/document.js"
+    },
+    "./react/lazy-route": {
+      "types": "./dist/react/lazy-route.d.ts",
+      "import": "./dist/react/lazy-route.js"
     }
   },
   "files": [
@@ -135,10 +140,11 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "react": ">=18",
     "preact": ">=11.0.1",
+    "preact-render-to-string": ">=6.8.1",
+    "react": ">=18",
     "vite": ">=8",
-    "preact-render-to-string": ">=6.8.1"
+    "react-dom": ">=18"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -152,6 +158,9 @@
     },
     "preact-render-to-string": {
       "optional": true
+    },
+    "react-dom": {
+      "optional": true
     }
   },
   "author": "Kasper Rynning-Tønnesen <kasperrt@users.noreply.github.com> (https://github.com/kasperrt)",

package/.generated/core/resource-types.ts

@@ -1,44 +0,0 @@
-export type Params = Readonly<Record<string, string>>;
-
-export interface LoaderFunctionArgs {
-  params: Params;
-  signal: AbortSignal;
-}
-
-export interface ActionFunctionArgs<Input = unknown> {
-  input: Input;
-  params: Params;
-  signal: AbortSignal;
-}
-
-export interface DataResult<Data> {
-  data: Data | null;
-  error: string;
-  unexpected?: true;
-}
-
-export interface ResourceModule {
-  action?: (args: ActionFunctionArgs) => Promise<DataResult<unknown>>;
-  loader?: (args: LoaderFunctionArgs) => Promise<DataResult<unknown>>;
-  shouldRevalidate?: (args: ShouldRevalidateFunctionArgs) => boolean;
-}
-
-export interface ShouldRevalidateFunctionArgs {
-  actionResult: DataResult<unknown>;
-  defaultShouldRevalidate: boolean;
-  params: Params;
-}
-
-export type NavigationState = "idle" | "loading" | "submitting";
-
-export interface RouteState {
-  actionData: unknown;
-  actionError: string;
-  actionState: "idle" | "submitting";
-  loaderData: unknown;
-  loaderError: string;
-  loaderInitialized: boolean;
-  loaderState: "idle" | "loading";
-  navigationState: NavigationState;
-  unexpectedError: boolean;
-}