@kasperrt/smolter 0.4.3 → 0.4.4

package/.generated/vite/react.ts

@@ -17,7 +17,18 @@ export function routerPlugin(options: FileRouterOptions = {}): Plugin {
 /** File routing is the default; this alias keeps configuration explicit. */
 export const fileRouter = routerPlugin;
 
+export type { ApplicationOptions } from "./application/vite.ts";
 export {
   type DeploymentPluginOptions,
   deploymentPlugin,
 } from "./deployment.ts";
+
+import {
+  type ApplicationOptions,
+  applicationPlugins as plugins,
+} from "./application/vite.ts";
+
+/** Configure React application SSR, scoped data transport and lazy file routing. */
+export function applicationPlugins(options: ApplicationOptions = {}): Plugin[] {
+  return plugins({ ...options, framework: "react" });
+}

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.4
+
+- Remove the separate `/react/data` resource router. Both main adapters provide route data, forms, submissions and independent fetchers through `createDataRouter`; migrate ResourceProvider/Resource hooks to RouterProvider and the main data hooks. The old pathless resource store and tuple fetcher API are removed, not aliased to incompatible signatures.
+
+- Complete React routing-hook parity: navigation/submission state, URL/search/history helpers, route errors, root data and route-ID data. Add React RouterApplication and match Preact loader/fetcher type inference.
+- Support React application SSR and hydration, document helpers, lazy routes and application Vite middleware. React DOM 19+ powers integrated documents; routing hooks and manual loadRouter SSR retain React 18 support. Share transport, root revalidation, hash history, hydration payloads and server orchestration across renderers.
+- Export renderer-independent dispatchRoute from both server entries. Preserve scoped endpoints, private caching, redirects, cancellation and mutation ownership.
+- Add React link intent prefetching, structured/GET fetcher submissions and real NavLink pending state in both adapters. Report pending destinations under plain providers as well as retained application views.
+- Update compatibility badges, guides, package-isolation checks and bundle tables. Verify React production early hydration, persistent input, root refresh, CSP and abandoned deferred boundaries.
+
 ## 0.4.3
 
 - Prefetch individual guide articles on pointer, keyboard and touch intent. Keep the shared header, sidebar and current article visible during cold guide navigation; show a quiet pending status without replacing the layout. Link the header directly to the canonical Getting started guide.

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.4.3%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.4.3%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.4.3%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.4.3%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.4.4%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.4.4%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.4.4%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.4.4%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.**
@@ -18,6 +18,12 @@ and [React Router](https://reactrouter.com/).
 
 Start with [loaders](https://kasperrt.github.io/smolter/docs/loaders/), [actions](https://kasperrt.github.io/smolter/docs/actions/), [forms and validation](https://kasperrt.github.io/smolter/docs/forms/), or [fetcher reads and mutations](https://kasperrt.github.io/smolter/docs/fetchers/). Each guide connects the handler to an actual route URL and its consuming view.
 
+## React and Preact application APIs
+
+Both adapters expose navigation, submission, error, root-data and route-data hooks. Both server entries expose `dispatchRoute` and `renderApplication`; both client entries provide `mountApplication`, scoped transport and deployment recovery. Import `applicationPlugins` from the matching renderer's `/vite` entry for lazy file routes and development SSR.
+
+Integrated React documents use React DOM 19+ (`react/document`, `react/client`, `react/server`). React 18 remains supported for routing hooks and manual `loadRouter` SSR. Use React's `use(promise)` inside `Suspense` for deferred rendering. Preact uses `Await` with an explicit `fallback` for early hydration. These renderer choices share transport and data ownership, without loading the other framework.
+
 ## Contents
 
 - [Deployment updates](#deployment-updates)
@@ -456,7 +462,7 @@ and `internalURL`. Move `/client`, `/server`,
 `/files`, and `/vite` imports to the corresponding renderer-prefixed path above.
 The bare package root and old top-level subpaths are no longer exported.
 
-See the [0.3 migration guide](https://kasperrt.github.io/smolter/docs/migration-0.3/) and [changelog](./CHANGELOG.md).
+See the [changelog](./CHANGELOG.md) for release history.
 
 **Router factory migration:** code that previously used `createRouter` with
 loaders, actions, fetchers or revalidation must now use `createDataRouter`.
@@ -540,36 +546,30 @@ The adapter has no Express dependency and forwards failures to `next(error)`.
 See the [Express guide](https://kasperrt.github.io/smolter/docs/express)
 for a complete server example and streaming and hydration behavior.
 
-## Resource subscriptions
+## Independent data requests
 
-`@kasperrt/smolter/react/data` adds subscriptions to named resources when their
-lifetime is independent of URL navigation. The state and cancellation logic
-lives in core; the entry adds React bindings without DOM or HTTP globals.
+Both adapters include `useFetcher`, `useSubmit`, `Form` and the loader/action hooks
+in their main entrypoint. Use `createDataRouter` for data routes and `useFetcher`
+for reads or mutations that should not navigate the page. There is no separate
+React resource router or `/react/data` entrypoint.
 
-```ts
-import { createResourceRouter } from "@kasperrt/smolter/react/data";
-
-const resources = createResourceRouter(new Map([
-  ["settings", {
-    loader: async ({ signal }) => ({
-      data: await readSettings(signal),
-      error: "",
-    }),
-    action: async ({ input, signal }) => ({
-      data: await saveSettings(input, signal),
-      error: "",
-    }),
-  }],
-]));
-```
-
-`ResourceProvider` owns the store lifetime. `Resource` selects a resource by
-`routeId` and params. `useResourceData` reads it; `useRouteLoaderData` reads a
-named resource. `useResourceFetcher` returns `[state, operations]`, with
-independent `load` and `submit` operations. Successful mutations consult the
-resource's `shouldRevalidate` before reloading its data. Last-subscriber cleanup
-aborts pending work; `persistent` keeps a resource until explicitly disposed.
-This optional entry does not contribute to the base React bundle measurement.
+```tsx
+import { useFetcher } from "@kasperrt/smolter/react";
+
+function Settings() {
+  const settings = useFetcher();
+  return (
+    <settings.Form method="post" action="/settings">
+      <input name="name" aria-label="Profile name" />
+      <button disabled={settings.state !== "idle"}>Save</button>
+    </settings.Form>
+  );
+}
+```
+
+Use the same imports from `/preact` in a Preact application. Independent
+fetchers share the application router's cancellation, revalidation and deployment
+recovery ownership; they do not require another provider or store.
 
 ## Size and checks
 
@@ -581,7 +581,6 @@ This optional entry does not contribute to the base React bundle measurement.
 | Preact application hydration | `@kasperrt/smolter/preact/client` |
 | Preact document components | `@kasperrt/smolter/preact/document` |
 | Lazy Preact route modules | `@kasperrt/smolter/preact/lazy-route` |
-| Optional React resources | `@kasperrt/smolter/react/data` |
 | Server rendering / Vite integration | Renderer `/server` / `/vite` subpaths; keep out of browser imports |
 
 The measurements below describe retained exports, not the cost of an import
@@ -605,16 +604,17 @@ a claim of identical features.
 | --- | ---: |
 | `React Router: declarative routing subset` | 12882 |
 | `React Router: data routing subset` | 29780 |
-| `React: routing-only named exports` | 1245 |
+| `React: routing-only named exports` | 1419 |
 | `Preact: routing-only named exports` | 1405 |
-| `@kasperrt/smolter/react` | 3082 |
-| `@kasperrt/smolter/preact` | 5016 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 4419 |
-| `@kasperrt/smolter/preact + server transport` | 6291 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9398 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9685 |
-| `@kasperrt/smolter/react/data (optional resource API)` | 2962 |
-| `React: common routing/data exports` | 2761 |
+| `@kasperrt/smolter/react` | 4801 |
+| `@kasperrt/smolter/preact` | 5076 |
+| `@kasperrt/smolter/react + server transport (named client exports)` | 6060 |
+| `@kasperrt/smolter/preact + server transport` | 6345 |
+| `@kasperrt/smolter/react + client + document (application)` | 9124 |
+| `@kasperrt/smolter/react + client + document + lazy-route` | 9401 |
+| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 9435 |
+| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 9721 |
+| `React: common routing/data exports` | 3071 |
 | `Preact: common routing/data exports` | 3046 |
 | `wouter: routing subset (Router, Route, Switch, Link, useParams, useLocation)` | 2854 |
 | `wouter-preact: same routing subset` | 2211 |

package/dist/client/hash-history.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from "../core/index.ts";
+export declare function connectHashHistory(router: Router): void;

package/dist/client/hash-history.js

@@ -0,0 +1,26 @@
+//#region .generated/client/hash-history.ts
+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}${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 { connectHashHistory };

package/dist/client/hydration.d.ts

@@ -0,0 +1,10 @@
+type Settlement = [number, unknown, string | null];
+export interface DeferredWindow extends Window {
+    __smolterDeferred?: Settlement[];
+}
+/** Restore promise identity before hydrating Suspense boundaries. */
+export declare function readHydration(json: string, timeout?: number): {
+    hydration: any;
+    dispose: () => void;
+};
+export {};

package/dist/{preact/deferred-hydration.js → client/hydration.js}

@@ -1,4 +1,4 @@
-//#region .generated/preact/deferred-hydration.ts
+//#region .generated/client/hydration.ts
 /** Restore promise identity before hydrating Suspense boundaries. */
 function readHydration(json, timeout = 3e4) {
 	if (!Number.isInteger(timeout) || timeout < 1 || timeout > 2147483647) throw new RangeError("deferredTimeout must be an integer between 1 and 2147483647 ms");

package/dist/client/root-data.d.ts

@@ -0,0 +1,14 @@
+import type { RevalidationArgs, Router } from "../core/index.ts";
+interface RootModule {
+    default?: unknown;
+    Layout?: unknown;
+    id?: string;
+    loaderPath?: string;
+    shouldRevalidate?: (args: RevalidationArgs) => boolean;
+}
+export { createStore as createRootStore } from "../core/store.ts";
+export declare function attachRootData(router: Router, initial: unknown, rootModule?: RootModule): {
+    getSnapshot: () => unknown;
+    subscribe(listener: () => void): () => void;
+    update(next: unknown): void;
+};

package/dist/{preact → client}/root-data.js

@@ -1,5 +1,5 @@
 import { createStore } from "../core/store.js";
-//#region .generated/preact/root-data.ts
+//#region .generated/client/root-data.ts
 function attachRootData(router, initial, rootModule) {
 	const store = createStore(initial);
 	const loaderPath = rootModule?.loaderPath;

package/dist/core/prepare-routes.d.ts

@@ -0,0 +1,7 @@
+import type { Route } from "./types.ts";
+type AppRoute = Route & {
+    routePath?: string;
+    preload?: () => Promise<void>;
+};
+export declare function prepareRoutes(routes: AppRoute[], preserveDeferred?: boolean): AppRoute[];
+export {};

package/dist/core/prepare-routes.js

@@ -0,0 +1,28 @@
+import { normalizeResult } from "./responses.js";
+//#region .generated/core/prepare-routes.ts
+function prepareRoutes(routes, preserveDeferred = false) {
+	return routes.map((route) => {
+		const wrapped = {
+			...route,
+			path: route.routePath ?? route.path,
+			shouldRevalidate: (args) => {
+				const { currentUrl, nextUrl } = args;
+				if (args.reason === "navigation" && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash) return false;
+				return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
+			}
+		};
+		for (const key of [
+			"loader",
+			"action",
+			"clientLoader",
+			"clientAction"
+		]) {
+			const handler = route[key];
+			if (!handler) continue;
+			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then((value) => normalizeResult(value, !preserveDeferred), (error) => normalizeResult(error, !preserveDeferred));
+		}
+		return wrapped;
+	});
+}
+//#endregion
+export { prepareRoutes };

package/dist/core/presentation.js

@@ -1,7 +1,7 @@
 //#region .generated/core/presentation.ts
 var pending = /* @__PURE__ */ new WeakMap();
 function pendingLocation(router) {
-	const snapshot = pending.get(router)?.();
+	const snapshot = pending.get(router)?.() ?? router.getSnapshot();
 	return snapshot?.state !== "idle" && snapshot?.url ? new URL(snapshot.url) : void 0;
 }
 function retainRoute(router, commitView) {

package/dist/preact/client.js

@@ -3,12 +3,14 @@ import { createDataRouter } from "../core/router.js";
 import { configureApplication } from "../core/environment.js";
 import { retainRoute } from "../core/presentation.js";
 import { connectNavigation } from "../core/navigation.js";
-import { attachRootData } from "./root-data.js";
-import { RouterApplication, prepareRoutes } from "./router.js";
+import { attachRootData } from "../client/root-data.js";
+import { prepareRoutes } from "../core/prepare-routes.js";
+import { RouterApplication } from "./router.js";
 import { deserialize } from "../client/deserialize.js";
 import { recoverDeployment, watchDeployment } from "../client/deployment.js";
 import { serverRoute } from "../client/index.js";
-import { readHydration } from "./deferred-hydration.js";
+import { connectHashHistory } from "../client/hash-history.js";
+import { readHydration } from "../client/hydration.js";
 import { flushSync } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
 import { hydrate, render } from "preact";
@@ -74,28 +76,5 @@ async function mountApplication(routes, rootModule, options = false) {
 	if (target) render(/* @__PURE__ */ jsx(RouterApplication, { ...props }), target);
 	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}${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, recoverDeployment, serverRoute, watchDeployment };

package/dist/preact/deferred-hydration.d.ts

@@ -1,10 +1 @@
-type Settlement = [number, unknown, string | null];
-export interface DeferredWindow extends Window {
-    __smolterDeferred?: Settlement[];
-}
-/** Restore promise identity before hydrating Suspense boundaries. */
-export declare function readHydration(json: string, timeout?: number): {
-    hydration: any;
-    dispose: () => void;
-};
-export {};
+export { type DeferredWindow, readHydration } from "../client/hydration.ts";

package/dist/preact/document.js

@@ -1,8 +1,8 @@
 import { serializeData } from "../core/serialize.js";
-import { useApplication } from "./root-context.js";
-import { useSnapshot } from "./context.js";
 import { applicationEnvironment } from "../core/environment.js";
 import { scrollPositions } from "../core/navigation.js";
+import { useApplication } from "./root-context.js";
+import { useSnapshot } from "./context.js";
 import { useNavigationSnapshot } from "./navigation-state.js";
 import { useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
 import { Fragment, jsx, jsxs } from "preact/jsx-runtime";

package/dist/preact/index.d.ts

@@ -18,5 +18,5 @@ export type { NavigateOptions } from "./navigation.tsx";
 export * from "./navigation.tsx";
 export { useMatches, useNavigation, useOutletContext, useRootData, useRouteError, useRouteLoaderData, useSubmit, } from "./route-hooks.tsx";
 export * from "./route-types.ts";
-export { Outlet, type OutletProps, RouterApplication } from "./router.tsx";
+export { type ApplicationProps, Outlet, type OutletProps, RouterApplication, } from "./router.tsx";
 export * from "./routes.ts";

package/dist/preact/index.js

@@ -1,8 +1,8 @@
 import { defineRoute } from "../core/match.js";
 import { createRouter } from "../core/navigation-router.js";
 import { createDataRouter } from "../core/router.js";
-import { readSubmission } from "../core/submission.js";
 import { data, isRouteErrorResponse, normalizeResult, redirect, resolveData } from "../core/responses.js";
+import { readSubmission } from "../core/submission.js";
 import { Await } from "./await.js";
 import { RouterProvider, useRouter } from "./context.js";
 import { Form } from "./form.js";

package/dist/preact/navigation-state.js

@@ -1,5 +1,5 @@
-import { useSyncExternalStore } from "./runtime.js";
 import { navigationStore } from "../core/navigation.js";
+import { useSyncExternalStore } from "./runtime.js";
 //#region .generated/preact/navigation-state.ts
 function useNavigationSnapshot(router) {
 	const store = navigationStore(router);

package/dist/preact/navigation.js

@@ -1,9 +1,9 @@
 import { matchRoutes } from "../core/match.js";
 import { navigationClick } from "../core/url.js";
+import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
 import { createElement } from "./runtime.js";
 import { useRouter, useSnapshot } from "./context.js";
-import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
-import { useNavigate, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
+import { useNavigate, useNavigation, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
 //#region .generated/preact/navigation.tsx
 /** Render an anchor with same-origin router navigation and optional intent prefetching. */
 function Link(options) {
@@ -44,11 +44,13 @@ function Link(options) {
 /** Render a Link with active-route state and aria-current for the matching destination. */
 function NavLink({ href, to = href ?? "/", end, className, children, ...props }) {
 	const location = useURLLocation();
-	const target = new URL(to, location.href).pathname;
-	const isActive = location.pathname === target || !end && target !== "/" && location.pathname.startsWith(`${target}/`);
+	const destination = resolveApplicationURL(new URL(to, location.href));
+	const target = destination.pathname;
+	const isActive = destination.origin === location.origin && (location.pathname === target || !end && target !== "/" && location.pathname.startsWith(`${target}/`));
+	const pending = useNavigation().location;
 	const state = {
 		isActive,
-		isPending: false
+		isPending: !!pending && pending.origin === destination.origin && (pending.pathname === target || !end && target !== "/" && pending.pathname.startsWith(`${target}/`))
 	};
 	return createElement(Link, {
 		...props,

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

@@ -1,8 +1 @@
-import type { Router } from "../core/index.ts";
-import type { RootModule } from "./route-types.ts";
-export { createStore as createRootStore } from "../core/store.ts";
-export declare function attachRootData(router: Router, initial: unknown, rootModule?: RootModule): {
-    getSnapshot: () => unknown;
-    subscribe(listener: () => void): () => void;
-    update(next: unknown): void;
-};
+export { attachRootData, createRootStore } from "../client/root-data.ts";

package/dist/preact/route-hooks.js

@@ -1,8 +1,8 @@
 import { submissionBody, submissionSearch } from "../core/submission.js";
+import { pendingLocation } from "../core/presentation.js";
 import { useContext, useMemo } from "./runtime.js";
 import { OutletContext, useApplication } from "./root-context.js";
 import { useRouter, useSnapshot } from "./context.js";
-import { pendingLocation } from "../core/presentation.js";
 import { useNavigationSnapshot } from "./navigation-state.js";
 import { useCallback } from "preact/hooks";
 //#region .generated/preact/route-hooks.tsx

package/dist/preact/router.d.ts

@@ -2,7 +2,6 @@
 import type { ReactNode } from "preact/compat";
 import { type ApplicationContext } from "./root-context.ts";
 import { createRootStore } from "./root-data.ts";
-import type { AppRoute } from "./route-types.ts";
 /** Optional children and context shared with descendants through useOutletContext. */
 export interface OutletProps {
     context?: unknown;
@@ -10,10 +9,11 @@ export interface OutletProps {
 }
 /** Render supplied children or the active route, and provide outlet context to descendants. */
 export declare function Outlet({ context, children, }: OutletProps): import("preact").JSX.Element;
+/** Root data, document components and request-scoped router for an application. */
 export interface ApplicationProps extends ApplicationContext {
     document?: boolean;
     rootStore?: ReturnType<typeof createRootStore>;
 }
 /** Render a Preact root document and active route with shared root data and application context. */
 export declare function RouterApplication(props: ApplicationProps): import("preact").JSX.Element;
-export declare function prepareRoutes(routes: AppRoute[], preserveDeferred?: boolean): AppRoute[];
+export { prepareRoutes } from "../core/prepare-routes.ts";

package/dist/preact/router.js

@@ -1,9 +1,9 @@
-import { normalizeResult } from "../core/responses.js";
+import { createStore } from "../core/store.js";
 import { useContext, useMemo, useSyncExternalStore } from "./runtime.js";
 import { Application, OutletContext } from "./root-context.js";
 import { RouterProvider } from "./context.js";
-import { createStore } from "../core/store.js";
 import { Routes } from "./routes.js";
+import { prepareRoutes } from "../core/prepare-routes.js";
 import { jsx } from "preact/jsx-runtime";
 //#region .generated/preact/router.tsx
 /** Render supplied children or the active route, and provide outlet context to descendants. */
@@ -37,29 +37,5 @@ function RouterApplication(props) {
 		})
 	});
 }
-function prepareRoutes(routes, preserveDeferred = false) {
-	return routes.map((route) => {
-		const wrapped = {
-			...route,
-			path: route.routePath ?? route.path,
-			shouldRevalidate: (args) => {
-				const { currentUrl, nextUrl } = args;
-				if (args.reason === "navigation" && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash) return false;
-				return route.shouldRevalidate?.(args) ?? args.defaultShouldRevalidate;
-			}
-		};
-		for (const key of [
-			"loader",
-			"action",
-			"clientLoader",
-			"clientAction"
-		]) {
-			const handler = route[key];
-			if (!handler) continue;
-			wrapped[key] = (args) => Promise.resolve().then(() => handler(args)).then((value) => normalizeResult(value, !preserveDeferred), (error) => normalizeResult(error, !preserveDeferred));
-		}
-		return wrapped;
-	});
-}
 //#endregion
 export { Outlet, RouterApplication, prepareRoutes };

package/dist/react/client.d.ts

@@ -0,0 +1,20 @@
+/**
+ * React document hydration, browser history and deployment recovery.
+ *
+ * @module
+ */
+/** @jsxImportSource react */
+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";
+/** Browser hydration settings for hash history, deployment recovery and deferred-data timeout. */
+export interface MountApplicationOptions {
+    hash?: boolean;
+    deployment?: DeploymentOptions | null;
+    /** Total initial deferred-data budget in integer milliseconds; not an inactivity timeout. Defaults to 30,000. */
+    deferredTimeout?: number;
+}
+/** Create the browser application router and hydrate the document, installing recovery before initial lazy loading. */
+export declare function mountApplication(routes: AppRoute[], rootModule?: RootModule, options?: boolean | MountApplicationOptions): Promise<Router>;

package/dist/react/client.js

@@ -0,0 +1,86 @@
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { configureApplication } from "../core/environment.js";
+import { retainRoute } from "../core/presentation.js";
+import { connectNavigation } from "../core/navigation.js";
+import { RouterApplication } from "./router.js";
+import { attachRootData } from "../client/root-data.js";
+import { prepareRoutes } from "../core/prepare-routes.js";
+import { deserialize } from "../client/deserialize.js";
+import { recoverDeployment, watchDeployment } from "../client/deployment.js";
+import { serverRoute } from "../client/index.js";
+import { connectHashHistory } from "../client/hash-history.js";
+import { readHydration } from "../client/hydration.js";
+import { flushSync } from "react-dom";
+import { createRoot, hydrateRoot } from "react-dom/client";
+import { jsx } from "react/jsx-runtime";
+//#region .generated/react/client.tsx
+/**
+* React document hydration, browser history and deployment recovery.
+*
+* @module
+*/
+/** @jsxImportSource react */
+/** Create the browser application router and hydrate the document, installing recovery before initial lazy loading. */
+async function mountApplication(routes, rootModule, options = false) {
+	const { hash = false, deployment = null, deferredTimeout } = 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?.().catch(async (error) => {
+		await recoverDeployment(deployment, initialURL);
+		throw error;
+	});
+	routes = prepareRoutes(routes);
+	const element = document.getElementById("smolter-data");
+	const initial = element?.textContent ? readHydration(element.textContent, deferredTimeout) : void 0;
+	const hydration = initial?.hydration;
+	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 }
+	});
+	const dispose = router.dispose;
+	router.dispose = () => {
+		initial?.dispose();
+		dispose();
+	};
+	watchDeployment(router, deployment);
+	if (hash) connectHashHistory(router);
+	retainRoute(router, flushSync);
+	connectNavigation(router);
+	const rootStore = attachRootData(router, hydration?.root, rootModule);
+	const props = {
+		routes,
+		router,
+		root: hydration?.root,
+		rootModule,
+		rootStore,
+		rootError: hydration?.rootError,
+		initialData: element?.textContent ?? void 0
+	};
+	if (hydration) {
+		const mounted = hydrateRoot(document, /* @__PURE__ */ jsx(RouterApplication, {
+			...props,
+			document: true
+		}));
+		const cleanup = router.dispose;
+		router.dispose = () => {
+			mounted.unmount();
+			cleanup();
+		};
+		return router;
+	}
+	const target = document.getElementById("root");
+	if (target) {
+		const mounted = createRoot(target);
+		mounted.render(/* @__PURE__ */ jsx(RouterApplication, { ...props }));
+		const cleanup = router.dispose;
+		router.dispose = () => {
+			mounted.unmount();
+			cleanup();
+		};
+	}
+	return router;
+}
+//#endregion
+export { configureApplication, deserialize, mountApplication, recoverDeployment, serverRoute, watchDeployment };

package/dist/react/document.d.ts

@@ -0,0 +1,25 @@
+/**
+ * React document metadata, resource links and hydration scripts.
+ *
+ * @module
+ */
+/** @jsxImportSource react */
+import type { ComponentProps } from "react";
+/** Render root or active-route metadata in the document head. */
+export declare function Meta(): import("react").ReactElement;
+/** Render stylesheet and other link descriptors from the application root. */
+export declare function Links(): import("react").ReactElement;
+/** Nonce and browser entry options for the document hydration scripts. */
+export interface ScriptProps {
+    nonce?: string;
+}
+/** Render the hydration snapshot and browser entry script with an optional CSP nonce. */
+export declare function Scripts({ nonce }: ScriptProps): import("react").ReactElement;
+/** Reset scroll after navigation unless the navigation requests preservation. */
+export declare function ScrollRestoration(_props: ScriptProps): null;
+/** HTML attributes for server markup and client document reconciliation. */
+export interface DocumentProps extends ComponentProps<"html"> {
+    "data-debug"?: boolean;
+}
+/** Render the server document and preserve client-managed theme classes on hydration. */
+export declare function Document(props: DocumentProps): import("react").ReactElement;