@kasperrt/smolter 0.4.2 → 0.4.4

package/dist/react/link.d.ts

@@ -1,12 +1 @@
-/**
- * React components and typed data hooks. Import from @kasperrt/smolter/react.
- * @module
- */
-import { type AnchorHTMLAttributes, type ReactNode } from "./runtime.ts";
-/** Anchor attributes with internal navigation and optional history replacement. */
-export interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
-    href: string;
-    replace?: boolean;
-}
-/** Render an anchor that handles internal navigation and preserves native modified clicks. */
-export declare function Link(options: LinkProps): ReactNode;
+export { Link, type LinkProps } from "./navigation.ts";

package/dist/react/navigation-state.d.ts

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

package/dist/react/navigation-state.js

@@ -0,0 +1,9 @@
+import { useSyncExternalStore } from "./runtime.js";
+import { navigationStore } from "../core/navigation.js";
+//#region .generated/react/navigation-state.ts
+function useNavigationSnapshot(router) {
+	const store = navigationStore(router);
+	return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+//#endregion
+export { useNavigationSnapshot };

package/dist/react/navigation.d.ts

@@ -0,0 +1,33 @@
+import { type NavigateOptions } from "../core/index.ts";
+import type { AnchorHTMLAttributes, ReactNode } from "./runtime.ts";
+export type { NavigateOptions } from "../core/index.ts";
+export type { NavigationType } from "../core/navigation.ts";
+/** Navigate to a URL or move through browser history using a numeric offset. */
+export type NavigateFunction = (to: string | number | Partial<Pick<URL, "pathname" | "search" | "hash">>, options?: NavigateOptions) => void;
+/** Anchor properties and router navigation options, including document reload and prefetch controls. */
+export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    to?: string;
+    href?: string;
+    replace?: boolean;
+    prefetch?: string;
+    state?: unknown;
+    preventScrollReset?: boolean;
+    viewTransition?: boolean;
+    reloadDocument?: boolean;
+}
+/** Active and pending flags supplied to NavLink render callbacks. */
+export interface NavLinkRenderProps {
+    isActive: boolean;
+    isPending: boolean;
+}
+/** Link options with matching rules and state-aware class or children callbacks. */
+export interface NavLinkProps extends Omit<LinkProps, "className" | "children"> {
+    end?: boolean;
+    className?: string | ((state: NavLinkRenderProps) => string);
+    children?: ReactNode | ((state: NavLinkRenderProps) => ReactNode);
+}
+/** Render an anchor with same-origin router navigation and optional intent prefetching. */
+export declare function Link(options: LinkProps): ReactNode;
+/** Render a Link with active-route state and aria-current for the matching destination. */
+export declare function NavLink({ href, to, end, className, children, ...props }: NavLinkProps): ReactNode;
+export { useNavigate, useNavigationType, useSearchParams, useURLLocation, } from "./route-hooks.ts";

package/dist/react/navigation.js

@@ -0,0 +1,64 @@
+import { matchRoutes } from "../core/match.js";
+import { navigationClick } from "../core/url.js";
+import { createElement } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { handoffDocument, resolveApplicationURL } from "../core/environment.js";
+import { useNavigate, useNavigation, useNavigationType, useSearchParams, useURLLocation } from "./route-hooks.js";
+//#region .generated/react/navigation.ts
+/** Render an anchor with same-origin router navigation and optional intent prefetching. */
+function Link(options) {
+	const { href: hrefProp, to = hrefProp ?? "/", replace, preventScrollReset, viewTransition, prefetch, state, reloadDocument, ...props } = options;
+	const router = useRouter();
+	const current = new URL(useSnapshot("url"));
+	const destination = resolveApplicationURL(new URL(to, current));
+	const internal = destination.origin === current.origin;
+	const preload = () => {
+		(matchRoutes(router.routes, destination.pathname)?.route)?.preload?.().catch(() => {});
+	};
+	if (!reloadDocument && prefetch !== "none" && internal) for (const name of [
+		"onPointerEnter",
+		"onFocus",
+		"onTouchStart"
+	]) {
+		const handler = props[name];
+		props[name] = (event) => {
+			handler?.(event);
+			preload();
+		};
+	}
+	return createElement("a", {
+		...props,
+		href: destination.href,
+		onClick(event) {
+			props.onClick?.(event);
+			if (reloadDocument || !navigationClick(event, event.currentTarget)) return;
+			if (!internal) {
+				handoffDocument(event.nativeEvent, destination);
+				return;
+			}
+			event.preventDefault();
+			router.navigate(destination.href, 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 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: !!pending && pending.origin === destination.origin && (pending.pathname === target || !end && target !== "/" && pending.pathname.startsWith(`${target}/`))
+	};
+	return createElement(Link, {
+		...props,
+		to,
+		className: typeof className === "function" ? className(state) : className,
+		...isActive && { "aria-current": "page" },
+		children: typeof children === "function" ? children(state) : children
+	});
+}
+//#endregion
+export { Link, NavLink, useNavigate, useNavigationType, useSearchParams, useURLLocation };

package/dist/react/outlet.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "./runtime.ts";
+/** Optional children and context shared with descendants through useOutletContext. */
+export interface OutletProps {
+    context?: unknown;
+    children?: ReactNode;
+}
+/** Render the active route under a layout's shared context. */
+export declare function Outlet({ context, children }: OutletProps): ReactNode;
+/** Read the nearest Outlet's context. */
+export declare function useOutletContext<T>(): T;
+/** Read the active flat route match; this is not a nested layout match chain. */
+export declare function useMatches(): {
+    id: string;
+    data: unknown;
+    params: import("../core/index.ts").Params;
+}[];

package/dist/react/outlet.js

@@ -0,0 +1,26 @@
+import { createContext, createElement, useContext } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { Routes } from "./routes.js";
+//#region .generated/react/outlet.ts
+var OutletContext = createContext(void 0);
+/** Render the active route under a layout's shared context. */
+function Outlet({ context, children }) {
+	const inherited = useContext(OutletContext);
+	return createElement(OutletContext.Provider, { value: context ?? inherited }, children ?? createElement(Routes, { fallback: createElement("p", { role: "status" }, "Loading…") }));
+}
+/** Read the nearest Outlet's context. */
+function useOutletContext() {
+	return useContext(OutletContext);
+}
+/** Read the active flat route match; this is not a nested layout match chain. */
+function useMatches() {
+	const router = useRouter();
+	const snapshot = useSnapshot();
+	return [{
+		id: router.routes.find((item) => item.path === snapshot.path)?.id ?? "",
+		data: snapshot.data,
+		params: snapshot.params
+	}];
+}
+//#endregion
+export { Outlet, useMatches, useOutletContext };

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

@@ -0,0 +1,14 @@
+import type { Router } from "../core/index.ts";
+import type { AppRoute, RootModule } from "./route-types.ts";
+export interface ApplicationContext {
+    router: Router;
+    routes: AppRoute[];
+    root: unknown;
+    rootError?: boolean;
+    entry?: string;
+    streaming?: boolean;
+    initialData?: string;
+    rootModule?: RootModule;
+}
+export declare const Application: import("react").Context<ApplicationContext | null>;
+export declare function useApplication(): ApplicationContext;

package/dist/react/root-context.js

@@ -0,0 +1,10 @@
+import { createContext, useContext } from "./runtime.js";
+//#region .generated/react/root-context.ts
+var Application = createContext(null);
+function useApplication() {
+	const app = useContext(Application);
+	if (!app) throw new Error("Root data requires RouterApplication.");
+	return app;
+}
+//#endregion
+export { Application, useApplication };

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

@@ -0,0 +1,34 @@
+import type { NavigateOptions } from "../core/index.ts";
+import type { NavigationType } from "../core/navigation.ts";
+import { type Submission, type SubmissionOptions } from "../core/submission.ts";
+import { useSnapshot } from "./context.ts";
+import type { NavigateFunction } from "./navigation.ts";
+import type { RouteData } from "./route-types.ts";
+/** Read root loader data from the application context. */
+export declare function useRootData<T = unknown>(): RouteData<T>;
+/** Read root data or the active route's data by its manifest identifier. */
+export declare function useRouteLoaderData<T = unknown>(id: string): RouteData<T> | undefined;
+export { useSnapshot };
+/** Read the current route error for an error boundary. */
+export declare function useRouteError(): Error | undefined;
+/** Read the current page navigation or submission state. */
+export declare function useNavigation(): {
+    state: "idle" | "loading" | "submitting";
+    location: URL | undefined;
+};
+/** Return a function that submits form data through the current router. */
+export declare function useSubmit(): (value: Submission, options?: SubmissionOptions) => Promise<void> | Promise<import("../core/index.ts").Result<unknown>>;
+/** Read the current router location as a URL. */
+export declare function useURLLocation(): URL & {
+    state: unknown;
+    key: string;
+};
+/** Return the application navigation function, including history offsets and relative destinations. */
+export declare function useNavigate(): NavigateFunction;
+/** Read URL search parameters and update them through router navigation. */
+export declare function useSearchParams(): [
+    URLSearchParams,
+    (value: URLSearchParams | Record<string, string>, options?: NavigateOptions) => void
+];
+/** Read the last browser history operation. */
+export declare function useNavigationType(): NavigationType;

package/dist/react/route-hooks.js

@@ -0,0 +1,89 @@
+import { submissionBody, submissionSearch } from "../core/submission.js";
+import { useCallback, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+import { pendingLocation } from "../core/presentation.js";
+import { useNavigationSnapshot } from "./navigation-state.js";
+import { useApplication } from "./root-context.js";
+//#region .generated/react/route-hooks.ts
+/** Read root loader data from the application context. */
+function useRootData() {
+	return useApplication().root;
+}
+/** Read root data or the active route's data by its manifest identifier. */
+function useRouteLoaderData(id) {
+	const app = useApplication();
+	const snapshot = useSnapshot();
+	if (id === "root") return app.root;
+	const route = app.routes.find((item) => item.id === id);
+	if (!route || route.path !== snapshot.path) return void 0;
+	return snapshot.data;
+}
+/** Read the current route error for an error boundary. */
+function useRouteError() {
+	return useSnapshot("error");
+}
+/** Read the current page navigation or submission state. */
+function useNavigation() {
+	const router = useRouter();
+	const snapshot = useSnapshot();
+	const location = pendingLocation(router);
+	return useMemo(() => ({
+		state: snapshot.state,
+		location
+	}), [snapshot.state, location?.href]);
+}
+/** Return a function that submits form data through the current router. */
+function useSubmit() {
+	const router = useRouter();
+	return useCallback((value, options = {}) => {
+		const body = submissionBody(value, options.encType);
+		const method = options.method?.toUpperCase();
+		const target = options.action ?? router.getSnapshot().url;
+		if (method === "GET") {
+			const url = new URL(target, router.getSnapshot().url);
+			url.search = submissionSearch(body);
+			return router.navigate(url.href, options);
+		}
+		return router.submit(target, body, { method });
+	}, [router]);
+}
+/** Read the current router location as a URL. */
+function useURLLocation() {
+	const href = useSnapshot("url");
+	const snapshot = useNavigationSnapshot(useRouter());
+	return useMemo(() => Object.assign(new URL(href), {
+		state: snapshot.state,
+		key: snapshot.key
+	}), [
+		href,
+		snapshot.state,
+		snapshot.key
+	]);
+}
+/** Return the application navigation function, including history offsets and relative destinations. */
+function useNavigate() {
+	const router = useRouter();
+	return useCallback((to, options) => {
+		if (typeof to === "number") {
+			window.history.go(to);
+			return;
+		}
+		const current = new URL(router.getSnapshot().url);
+		const target = typeof to === "string" ? to : `${to.pathname ?? current.pathname}${to.search ?? current.search}${to.hash ?? current.hash}`;
+		router.navigate(target, options);
+	}, [router]);
+}
+/** Read URL search parameters and update them through router navigation. */
+function useSearchParams() {
+	const location = useURLLocation();
+	const navigate = useNavigate();
+	return [useMemo(() => new URLSearchParams(location.search), [location.search]), useCallback((value, options) => {
+		navigate(`${location.pathname}?${new URLSearchParams(value)}`, options);
+	}, [location.pathname, navigate])];
+}
+/** Read the last browser history operation. */
+function useNavigationType() {
+	return useNavigationSnapshot(useRouter()).type;
+}
+//#endregion
+export { useNavigate, useNavigation, useNavigationType, useRootData, useRouteError, useRouteLoaderData, useSearchParams, useSnapshot, useSubmit, useURLLocation };

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

package/dist/server/application.js

@@ -1,119 +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 */
-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, {
@@ -121,48 +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);
-}
-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/assets.d.ts

@@ -1,6 +1,8 @@
+/** Emitted JavaScript and stylesheet URLs associated with a route. */
 export interface RouteAssets {
     path: string;
     files: string[];
     styles?: string[];
 }
+/** Collect matched-route JavaScript and stylesheet assets from the production route manifest. */
 export declare function routePreloads(routes: RouteAssets[], pathname: string, base: string): string;

package/dist/server/assets.js

@@ -1,5 +1,11 @@
 import { matchRoutes } from "../core/match.js";
 //#region .generated/server/assets.ts
+/**
+* Production route asset discovery for SSR preload hints.
+*
+* @module
+*/
+/** Collect matched-route JavaScript and stylesheet assets from the production route manifest. */
 function routePreloads(routes, pathname, base) {
 	const route = matchRoutes(routes, pathname)?.route;
 	const prefix = base.replace(/\/$/, "");

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