@pracht/core 0.2.5 → 0.2.7

package/dist/index.mjs

@@ -1,7 +1,241 @@
-import { a as matchApiRoute, c as resolveApp, i as group, l as route, n as buildPathFromSegments, o as matchAppRoute, r as defineApp, s as resolveApiRoutes, u as timeRevalidate } from "./app-Cep0el7c.mjs";
 import { createContext, h, hydrate, options, render } from "preact";
 import { useContext, useEffect, useMemo, useState } from "preact/hooks";
 import { Suspense, lazy } from "preact-suspense";
+//#region src/app.ts
+function timeRevalidate(seconds) {
+	if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("timeRevalidate expects a positive integer number of seconds.");
+	return {
+		kind: "time",
+		seconds
+	};
+}
+function route(path, fileOrConfig, meta = {}) {
+	if (typeof fileOrConfig === "string" || typeof fileOrConfig === "function") return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: resolveModuleRef(fileOrConfig),
+		...meta
+	};
+	const { component, loader, ...routeMeta } = fileOrConfig;
+	return {
+		kind: "route",
+		path: normalizeRoutePath(path),
+		file: resolveModuleRef(component),
+		loaderFile: resolveModuleRef(loader),
+		...routeMeta
+	};
+}
+function resolveModuleRef(ref) {
+	if (ref === void 0) return void 0;
+	if (typeof ref === "string") return ref;
+	return "";
+}
+function group(meta, routes) {
+	return {
+		kind: "group",
+		meta,
+		routes
+	};
+}
+function defineApp(config) {
+	return {
+		shells: resolveModuleRefRecord(config.shells ?? {}),
+		middleware: resolveModuleRefRecord(config.middleware ?? {}),
+		api: config.api ?? {},
+		routes: config.routes
+	};
+}
+function resolveModuleRefRecord(record) {
+	const result = {};
+	for (const [key, value] of Object.entries(record)) result[key] = resolveModuleRef(value);
+	return result;
+}
+function resolveApp(app) {
+	const routes = [];
+	const inherited = {
+		pathPrefix: "/",
+		middleware: []
+	};
+	for (const node of app.routes) flattenRouteNode(app, node, inherited, routes);
+	return {
+		shells: app.shells,
+		middleware: app.middleware,
+		api: app.api,
+		routes,
+		apiRoutes: []
+	};
+}
+function matchAppRoute(app, pathname) {
+	const resolved = isResolvedApp(app) ? app : resolveApp(app);
+	const normalizedPathname = normalizeRoutePath(pathname);
+	const targetSegments = splitPathSegments(normalizedPathname);
+	for (const currentRoute of resolved.routes) {
+		const params = matchRouteSegments(currentRoute.segments, targetSegments);
+		if (params) return {
+			route: currentRoute,
+			params,
+			pathname: normalizedPathname
+		};
+	}
+}
+function flattenRouteNode(app, node, inherited, routes) {
+	if (node.kind === "group") {
+		const nextInherited = {
+			pathPrefix: mergeRoutePaths(inherited.pathPrefix, node.meta.pathPrefix),
+			shell: node.meta.shell ?? inherited.shell,
+			render: node.meta.render ?? inherited.render,
+			middleware: [...inherited.middleware, ...node.meta.middleware ?? []]
+		};
+		for (const child of node.routes) flattenRouteNode(app, child, nextInherited, routes);
+		return;
+	}
+	const fullPath = mergeRoutePaths(inherited.pathPrefix, node.path);
+	const shell = node.shell ?? inherited.shell;
+	const middleware = [...inherited.middleware, ...node.middleware ?? []];
+	routes.push({
+		id: node.id ?? createRouteId(fullPath),
+		path: fullPath,
+		file: node.file,
+		loaderFile: node.loaderFile,
+		shell,
+		shellFile: shell ? app.shells[shell] : void 0,
+		render: node.render ?? inherited.render,
+		middleware,
+		middlewareFiles: middleware.flatMap((name) => {
+			const middlewareFile = app.middleware[name];
+			return middlewareFile ? [middlewareFile] : [];
+		}),
+		revalidate: node.revalidate,
+		segments: parseRouteSegments(fullPath)
+	});
+}
+function isResolvedApp(app) {
+	return app.routes.length === 0 || "segments" in app.routes[0];
+}
+function matchRouteSegments(routeSegments, targetSegments) {
+	const params = {};
+	let routeIndex = 0;
+	let targetIndex = 0;
+	while (routeIndex < routeSegments.length) {
+		const currentSegment = routeSegments[routeIndex];
+		if (currentSegment.type === "catchall") {
+			params[currentSegment.name] = targetSegments.slice(targetIndex).join("/");
+			return params;
+		}
+		const targetSegment = targetSegments[targetIndex];
+		if (typeof targetSegment === "undefined") return null;
+		if (currentSegment.type === "static") {
+			if (currentSegment.value !== targetSegment) return null;
+		} else try {
+			params[currentSegment.name] = decodeURIComponent(targetSegment);
+		} catch {
+			return null;
+		}
+		routeIndex += 1;
+		targetIndex += 1;
+	}
+	return targetIndex === targetSegments.length ? params : null;
+}
+function parseRouteSegments(path) {
+	return splitPathSegments(path).map((segment) => {
+		if (segment === "*") return {
+			type: "catchall",
+			name: "*"
+		};
+		if (segment.startsWith(":")) return {
+			type: "param",
+			name: segment.slice(1)
+		};
+		return {
+			type: "static",
+			value: segment
+		};
+	});
+}
+function splitPathSegments(path) {
+	return normalizeRoutePath(path).split("/").filter(Boolean);
+}
+function mergeRoutePaths(prefix, path) {
+	if (!path) return normalizeRoutePath(prefix);
+	const normalizedPrefix = normalizeRoutePath(prefix);
+	const normalizedPath = normalizeRoutePath(path);
+	if (normalizedPrefix === "/") return normalizedPath;
+	if (normalizedPath === "/") return normalizedPrefix;
+	return normalizeRoutePath(`${normalizedPrefix}/${normalizedPath.slice(1)}`);
+}
+function normalizeRoutePath(path) {
+	if (!path || path === "/") return "/";
+	const collapsed = (path.startsWith("/") ? path : `/${path}`).replace(/\/{2,}/g, "/");
+	return collapsed.length > 1 && collapsed.endsWith("/") ? collapsed.slice(0, -1) : collapsed;
+}
+function buildPathFromSegments(segments, params) {
+	return normalizeRoutePath("/" + segments.map((segment) => {
+		if (segment.type === "static") return segment.value;
+		if (segment.type === "param") return encodeURIComponent(params[segment.name] ?? "");
+		return params["*"] ?? "";
+	}).join("/"));
+}
+/**
+* Convert a list of file paths from `import.meta.glob` into resolved API routes.
+*
+* Example: `"/src/api/health.ts"` → path `/api/health`
+*          `"/src/api/users/[id].ts"` → path `/api/users/:id`
+*          `"/src/api/index.ts"` → path `/api`
+*/
+function resolveApiRoutes(files, apiDir = "/src/api") {
+	const normalizedDir = apiDir.replace(/\/$/, "");
+	return files.map((file) => {
+		let relative = file;
+		if (relative.startsWith(normalizedDir)) relative = relative.slice(normalizedDir.length);
+		relative = relative.replace(/\.(ts|tsx|js|jsx)$/, "");
+		if (relative.endsWith("/index")) relative = relative.slice(0, -6) || "/";
+		relative = relative.replace(/\[([^\]]+)\]/g, ":$1");
+		const path = normalizeRoutePath(`/api${relative}`);
+		return {
+			path,
+			file,
+			segments: parseRouteSegments(path)
+		};
+	}).sort(compareResolvedApiRoutes);
+}
+function matchApiRoute(apiRoutes, pathname) {
+	const normalizedPathname = normalizeRoutePath(pathname);
+	const targetSegments = splitPathSegments(normalizedPathname);
+	for (const route of apiRoutes) {
+		const params = matchRouteSegments(route.segments, targetSegments);
+		if (params) return {
+			route,
+			params,
+			pathname: normalizedPathname
+		};
+	}
+}
+function createRouteId(path) {
+	if (path === "/") return "index";
+	return path.slice(1).split("/").map((segment) => {
+		if (segment === "*") return "splat";
+		return segment.startsWith(":") ? segment.slice(1) : segment;
+	}).join("-").replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function compareResolvedApiRoutes(left, right) {
+	const length = Math.max(left.segments.length, right.segments.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftSegment = left.segments[index];
+		const rightSegment = right.segments[index];
+		if (!leftSegment) return 1;
+		if (!rightSegment) return -1;
+		const leftScore = getRouteSegmentSpecificity(leftSegment);
+		const rightScore = getRouteSegmentSpecificity(rightSegment);
+		if (leftScore !== rightScore) return rightScore - leftScore;
+	}
+	return left.path.localeCompare(right.path);
+}
+function getRouteSegmentSpecificity(segment) {
+	if (segment.type === "static") return 3;
+	if (segment.type === "param") return 2;
+	return 1;
+}
+//#endregion
 //#region src/forwardRef.ts
 let oldDiffHook = options.__b;
 options.__b = (vnode) => {
@@ -80,6 +314,7 @@ const SAFE_METHODS = new Set(["GET", "HEAD"]);
 const HYDRATION_STATE_ELEMENT_ID = "pracht-state";
 const ROUTE_STATE_REQUEST_HEADER = "x-pracht-route-state-request";
 const ROUTE_STATE_CACHE_CONTROL = "no-store";
+const EMPTY_ROUTE_PARAMS = {};
 let _renderToStringAsync;
 async function getRenderToStringAsync() {
 	if (_renderToStringAsync) return _renderToStringAsync;
@@ -87,25 +322,37 @@ async function getRenderToStringAsync() {
 	return _renderToStringAsync;
 }
 const RouteDataContext = createContext(void 0);
-function PrachtRuntimeProvider({ children, data, params = {}, routeId, url }) {
-	const [routeData, setRouteData] = useState(data);
+function PrachtRuntimeProvider({ children, data, params = EMPTY_ROUTE_PARAMS, routeId, stateVersion = 0, url }) {
+	const [routeDataState, setRouteDataState] = useState({
+		data,
+		stateVersion
+	});
+	const routeData = routeDataState.stateVersion === stateVersion ? routeDataState.data : data;
 	useEffect(() => {
-		setRouteData(data);
+		setRouteDataState({
+			data,
+			stateVersion
+		});
 	}, [
 		data,
 		routeId,
+		stateVersion,
 		url
 	]);
 	const context = useMemo(() => ({
 		data: routeData,
 		params,
 		routeId,
-		setData: setRouteData,
+		setData: (nextData) => setRouteDataState({
+			data: nextData,
+			stateVersion
+		}),
 		url
 	}), [
 		routeData,
 		params,
 		routeId,
+		stateVersion,
 		url
 	]);
 	return h(RouteDataContext.Provider, {
@@ -125,19 +372,15 @@ function readHydrationState() {
 	if (!(element instanceof HTMLScriptElement)) return;
 	const raw = element.textContent;
 	if (!raw) return;
-	try {
-		const state = JSON.parse(raw);
-		window.__PRACHT_STATE__ = state;
-		return state;
-	} catch {
-		return;
-	}
+	const state = JSON.parse(raw);
+	window.__PRACHT_STATE__ = state;
+	return state;
 }
 function useRouteData() {
 	return useContext(RouteDataContext)?.data;
 }
 function useLocation() {
-	return { pathname: useContext(RouteDataContext)?.url ?? (typeof window !== "undefined" ? window.location.pathname : "/") };
+	return parseLocation(useContext(RouteDataContext)?.url ?? (typeof window !== "undefined" ? window.location.pathname + window.location.search : "/"));
 }
 function useParams() {
 	return useContext(RouteDataContext)?.params ?? {};
@@ -151,13 +394,11 @@ function useRevalidate() {
 			await navigateToClientLocation(result.location);
 			return;
 		}
-		if (result.type === "error") throw deserializeRouteError$1(result.error);
+		if (result.type === "error") throw deserializeRouteError(result.error);
 		runtime?.setData(result.data);
 		return result.data;
 	};
 }
-/** @deprecated Use useRevalidate instead. */
-const useRevalidateRoute = useRevalidate;
 function Form(props) {
 	const { onSubmit, method, ...rest } = props;
 	return h("form", {
@@ -187,9 +428,10 @@ function Form(props) {
 		}
 	});
 }
-async function fetchPrachtRouteState(url) {
-	const response = await fetch(url, {
-		headers: {
+async function fetchPrachtRouteState(url, options) {
+	const fetchUrl = options?.useDataParam ? buildRouteStateUrl(url) : url;
+	const response = await fetch(fetchUrl, {
+		headers: options?.useDataParam ? {} : {
 			[ROUTE_STATE_REQUEST_HEADER]: "1",
 			"Cache-Control": "no-cache"
 		},
@@ -200,6 +442,10 @@ async function fetchPrachtRouteState(url) {
 		type: "redirect"
 	};
 	const json = await response.json();
+	if (json.redirect) return {
+		location: json.redirect,
+		type: "redirect"
+	};
 	if (!response.ok) {
 		if (json.error) return {
 			error: json.error,
@@ -212,10 +458,16 @@ async function fetchPrachtRouteState(url) {
 		type: "data"
 	};
 }
+function buildRouteStateUrl(url) {
+	return `${url}${url.includes("?") ? "&" : "?"}_data=1`;
+}
 async function handlePrachtRequest(options) {
 	const url = new URL(options.request.url);
+	const hasDataParam = url.searchParams.get("_data") === "1";
+	if (hasDataParam) url.searchParams.delete("_data");
+	const requestPath = getRequestPath(url);
 	const registry = options.registry ?? {};
-	const isRouteStateRequest = options.request.headers.get(ROUTE_STATE_REQUEST_HEADER) === "1";
+	const isRouteStateRequest = options.request.headers.get(ROUTE_STATE_REQUEST_HEADER) === "1" || hasDataParam;
 	const exposeDiagnostics = shouldExposeServerErrors(options);
 	if (options.apiRoutes?.length) {
 		const apiMatch = matchApiRoute(options.apiRoutes, url.pathname);
@@ -306,7 +558,7 @@ async function handlePrachtRequest(options) {
 	let loaderFile;
 	let currentPhase = "middleware";
 	try {
-		const middlewareResult = await runMiddlewareChain({
+		const middlewarePromise = runMiddlewareChain({
 			context: routeArgs.context,
 			middlewareFiles: match.route.middlewareFiles,
 			params: match.params,
@@ -315,25 +567,31 @@ async function handlePrachtRequest(options) {
 			route: match.route,
 			url
 		});
-		if (middlewareResult.response) return withRouteResponseHeaders(middlewareResult.response, { isRouteStateRequest });
+		const routeModulePromise = resolveRegistryModule(registry.routeModules, match.route.file);
+		const shellModulePromise = match.route.shellFile ? resolveRegistryModule(registry.shellModules, match.route.shellFile) : Promise.resolve(void 0);
+		const dataFunctionsPromise = routeModulePromise.then((mod) => resolveDataFunctions(match.route, mod, registry));
+		routeModulePromise.catch(() => {});
+		shellModulePromise.catch(() => {});
+		dataFunctionsPromise.catch(() => {});
+		const middlewareResult = await middlewarePromise;
+		if (middlewareResult.response) return normalizePageResponse(middlewareResult.response, { isRouteStateRequest });
 		routeArgs = {
 			...routeArgs,
 			context: middlewareResult.context
 		};
 		currentPhase = "render";
-		routeModule = await resolveRegistryModule(registry.routeModules, match.route.file);
+		routeModule = await routeModulePromise;
 		if (!routeModule) throw new Error("Route module not found");
 		currentPhase = "loader";
-		const { loader, loaderFile: resolvedLoaderFile } = await resolveDataFunctions(match.route, routeModule, registry);
+		const { loader, loaderFile: resolvedLoaderFile } = await dataFunctionsPromise;
 		loaderFile = resolvedLoaderFile;
 		const loaderResult = loader ? await loader(routeArgs) : void 0;
-		if (loaderResult instanceof Response) return withRouteResponseHeaders(loaderResult, { isRouteStateRequest });
+		if (loaderResult instanceof Response) return normalizePageResponse(loaderResult, { isRouteStateRequest });
 		const data = loaderResult;
 		if (isRouteStateRequest) return withRouteResponseHeaders(Response.json({ data }), { isRouteStateRequest: true });
 		currentPhase = "render";
-		shellModule = match.route.shellFile ? await resolveRegistryModule(registry.shellModules, match.route.shellFile) : void 0;
-		const head = await mergeHeadMetadata(shellModule, routeModule, routeArgs, data);
-		const documentHeaders = await mergeDocumentHeaders(shellModule, routeModule, routeArgs, data);
+		shellModule = await shellModulePromise;
+		const [head, documentHeaders] = await Promise.all([mergeHeadMetadata(shellModule, routeModule, routeArgs, data), mergeDocumentHeaders(shellModule, routeModule, routeArgs, data)]);
 		const cssUrls = resolvePageCssUrls(options, match.route.shellFile, match.route.file);
 		const modulePreloadUrls = resolvePageJsUrls(options, match.route.shellFile, match.route.file);
 		if (match.route.render === "spa") {
@@ -348,7 +606,7 @@ async function handlePrachtRequest(options) {
 				head,
 				body,
 				hydrationState: {
-					url: url.pathname,
+					url: requestPath,
 					routeId: match.route.id ?? "",
 					data: null,
 					error: null,
@@ -356,29 +614,31 @@ async function handlePrachtRequest(options) {
 				},
 				clientEntryUrl: options.clientEntryUrl,
 				cssUrls,
-				modulePreloadUrls
+				modulePreloadUrls,
+				routeStatePreloadUrl: loader ? buildRouteStateUrl(requestPath) : void 0
 			}), 200, documentHeaders);
 		}
 		const DefaultComponent = typeof routeModule.default === "function" ? routeModule.default : void 0;
 		const Component = routeModule.Component ?? DefaultComponent;
 		if (!Component) throw new Error("Route has no Component or default export");
 		const Shell = shellModule?.Shell;
+		const Comp = Component;
 		const componentProps = {
 			data,
 			params: match.params
 		};
-		const componentTree = Shell ? h(Shell, null, h(Component, componentProps)) : h(Component, componentProps);
+		const componentTree = Shell ? h(Shell, null, h(Comp, componentProps)) : h(Comp, componentProps);
 		const tree = h(PrachtRuntimeProvider, {
 			data,
 			params: match.params,
 			routeId: match.route.id ?? "",
-			url: url.pathname
+			url: requestPath
 		}, componentTree);
 		return htmlResponse(buildHtmlDocument({
 			head,
 			body: await (await getRenderToStringAsync())(tree),
 			hydrationState: {
-				url: url.pathname,
+				url: requestPath,
 				routeId: match.route.id ?? "",
 				data,
 				error: null
@@ -399,10 +659,20 @@ async function handlePrachtRequest(options) {
 			routeModule,
 			shellFile: match.route.shellFile,
 			shellModule,
-			urlPathname: url.pathname
+			requestPath
 		});
 	}
 }
+function parseLocation(value) {
+	const url = new URL(value, "http://pracht.local");
+	return {
+		pathname: url.pathname,
+		search: url.search
+	};
+}
+function getRequestPath(url) {
+	return `${url.pathname}${url.search}`;
+}
 /** Strip leading `./` and `/` so all module paths share one canonical form. */
 function normalizeModulePath(path) {
 	return path.replace(/^\.?\//, "");
@@ -433,27 +703,23 @@ function resolveManifestEntries(manifest, file) {
 	const resolved = getSuffixIndex(manifest).get(normalizeModulePath(file));
 	if (resolved) return manifest[resolved];
 }
+function resolvePageUrlsFromManifest(manifest, shellFile, routeFile) {
+	const urls = /* @__PURE__ */ new Set();
+	const add = (file) => {
+		const entries = resolveManifestEntries(manifest, file);
+		if (entries) for (const url of entries) urls.add(url);
+	};
+	if (shellFile) add(shellFile);
+	add(routeFile);
+	return [...urls];
+}
 function resolvePageCssUrls(options, shellFile, routeFile) {
-	if (!options.cssManifest) return options.cssUrls ?? [];
-	const css = /* @__PURE__ */ new Set();
-	function addFromManifest(file) {
-		const entries = resolveManifestEntries(options.cssManifest, file);
-		if (entries) for (const c of entries) css.add(c);
-	}
-	if (shellFile) addFromManifest(shellFile);
-	addFromManifest(routeFile);
-	return [...css];
+	if (!options.cssManifest) return [];
+	return resolvePageUrlsFromManifest(options.cssManifest, shellFile, routeFile);
 }
 function resolvePageJsUrls(options, shellFile, routeFile) {
 	if (!options.jsManifest) return [];
-	const js = /* @__PURE__ */ new Set();
-	function addFromManifest(file) {
-		const entries = resolveManifestEntries(options.jsManifest, file);
-		if (entries) for (const j of entries) js.add(j);
-	}
-	if (shellFile) addFromManifest(shellFile);
-	addFromManifest(routeFile);
-	return [...js];
+	return resolvePageUrlsFromManifest(options.jsManifest, shellFile, routeFile);
 }
 async function navigateToClientLocation(location, options) {
 	if (typeof window === "undefined") return;
@@ -539,7 +805,7 @@ function normalizeRouteError(error, options) {
 		status: 500
 	};
 }
-function deserializeRouteError$1(error) {
+function deserializeRouteError(error) {
 	const result = new Error(error.message);
 	result.name = error.name;
 	result.status = error.status;
@@ -553,6 +819,24 @@ function jsonErrorResponse(routeError, options) {
 		headers
 	});
 }
+function jsonRedirectResponse(location, options) {
+	const headers = new Headers(options.headers);
+	headers.set("content-type", "application/json; charset=utf-8");
+	return withRouteResponseHeaders(new Response(JSON.stringify({ redirect: location }), {
+		status: 200,
+		headers
+	}), { isRouteStateRequest: options.isRouteStateRequest });
+}
+function normalizePageResponse(response, options) {
+	if (options.isRouteStateRequest && response.status >= 300 && response.status < 400) {
+		const location = response.headers.get("location");
+		if (location) return jsonRedirectResponse(location, {
+			headers: response.headers,
+			isRouteStateRequest: true
+		});
+	}
+	return withRouteResponseHeaders(response, options);
+}
 function renderApiErrorResponse(options) {
 	const exposeDetails = shouldExposeServerErrors(options.options);
 	const routeError = normalizeRouteError(options.error, { exposeDetails });
@@ -603,17 +887,17 @@ async function renderRouteErrorResponse(options) {
 	const renderToString = await getRenderToStringAsync();
 	const ErrorBoundary = options.routeModule.ErrorBoundary;
 	const Shell = shellModule?.Shell;
-	const errorValue = deserializeRouteError$1(routeErrorWithDiagnostics);
+	const errorValue = deserializeRouteError(routeErrorWithDiagnostics);
 	const componentTree = Shell ? h(Shell, null, h(ErrorBoundary, { error: errorValue })) : h(ErrorBoundary, { error: errorValue });
 	return htmlResponse(buildHtmlDocument({
 		head,
 		body: await renderToString(h(PrachtRuntimeProvider, {
 			data: null,
 			routeId: options.routeId,
-			url: options.urlPathname
+			url: options.requestPath
 		}, componentTree)),
 		hydrationState: {
-			url: options.urlPathname,
+			url: options.requestPath,
 			routeId: options.routeId,
 			data: null,
 			error: routeErrorWithDiagnostics
@@ -625,8 +909,10 @@ async function renderRouteErrorResponse(options) {
 }
 async function runMiddlewareChain(options) {
 	let context = options.context;
-	for (const mwFile of options.middlewareFiles) {
-		const mwModule = await resolveRegistryModule(options.registry.middlewareModules, mwFile);
+	const modulePromises = options.middlewareFiles.map((mwFile) => resolveRegistryModule(options.registry.middlewareModules, mwFile));
+	for (const p of modulePromises) p.catch(() => {});
+	for (const modulePromise of modulePromises) {
+		const mwModule = await modulePromise;
 		if (!mwModule?.middleware) continue;
 		const result = await mwModule.middleware({
 			request: options.request,
@@ -671,11 +957,10 @@ async function resolveRegistryModule(modules, file) {
 	if (resolved) return modules[resolved]();
 }
 async function mergeHeadMetadata(shellModule, routeModule, routeArgs, data) {
-	const shellHead = shellModule?.head ? await shellModule.head(routeArgs) : {};
-	const routeHead = routeModule?.head ? await routeModule.head({
+	const [shellHead, routeHead] = await Promise.all([shellModule?.head ? shellModule.head(routeArgs) : Promise.resolve({}), routeModule?.head ? routeModule.head({
 		...routeArgs,
 		data
-	}) : {};
+	}) : Promise.resolve({})]);
 	return {
 		title: routeHead.title ?? shellHead.title,
 		lang: routeHead.lang ?? shellHead.lang,
@@ -685,12 +970,11 @@ async function mergeHeadMetadata(shellModule, routeModule, routeArgs, data) {
 }
 async function mergeDocumentHeaders(shellModule, routeModule, routeArgs, data) {
 	const headers = new Headers();
-	const shellHeaders = shellModule?.headers ? await shellModule.headers(routeArgs) : void 0;
-	if (shellHeaders) applyHeaders(headers, shellHeaders);
-	const routeHeaders = routeModule?.headers ? await routeModule.headers({
+	const [shellHeaders, routeHeaders] = await Promise.all([shellModule?.headers ? shellModule.headers(routeArgs) : Promise.resolve(void 0), routeModule?.headers ? routeModule.headers({
 		...routeArgs,
 		data
-	}) : void 0;
+	}) : Promise.resolve(void 0)]);
+	if (shellHeaders) applyHeaders(headers, shellHeaders);
 	if (routeHeaders) applyHeaders(headers, routeHeaders);
 	return headers;
 }
@@ -700,12 +984,13 @@ function applyHeaders(headers, init) {
 	});
 }
 function buildHtmlDocument(options) {
-	const { head, body, hydrationState, clientEntryUrl, cssUrls = [], modulePreloadUrls = [] } = options;
+	const { head, body, hydrationState, clientEntryUrl, cssUrls = [], modulePreloadUrls = [], routeStatePreloadUrl } = options;
 	const titleTag = head.title ? `<title>${escapeHtml(head.title)}</title>` : "";
 	const metaTags = (head.meta ?? []).map((m) => `<meta ${Object.entries(m).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ")}>`).join("\n    ");
 	const linkTags = (head.link ?? []).map((l) => `<link ${Object.entries(l).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ")}>`).join("\n    ");
 	const cssTags = cssUrls.map((url) => `<link rel="stylesheet" href="${escapeHtml(url)}">`).join("\n    ");
 	const modulePreloadTags = modulePreloadUrls.map((url) => `<link rel="modulepreload" href="${escapeHtml(url)}">`).join("\n    ");
+	const routeStatePreloadTag = routeStatePreloadUrl ? `<link rel="preload" as="fetch" href="${escapeHtml(routeStatePreloadUrl)}" crossorigin="anonymous">` : "";
 	const stateScript = `<script id="${HYDRATION_STATE_ELEMENT_ID}" type="application/json">${serializeJsonForHtml(hydrationState)}<\/script>`;
 	const entryScript = clientEntryUrl ? `<script type="module" src="${escapeHtml(clientEntryUrl)}"><\/script>` : "";
 	return `<!DOCTYPE html>
@@ -717,6 +1002,7 @@ function buildHtmlDocument(options) {
     ${linkTags}
     ${cssTags}
     ${modulePreloadTags}
+    ${routeStatePreloadTag}
   </head>
   <body>
     <div id="pracht-root">${body}</div>
@@ -784,7 +1070,6 @@ function serializeJsonForHtml(value) {
 	return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
 async function prerenderApp(options) {
-	const { resolveApp } = await import("./app-Cep0el7c.mjs").then((n) => n.t);
 	const resolved = resolveApp(options.app);
 	const results = [];
 	const isgManifest = {};
@@ -846,7 +1131,6 @@ async function collectSSGPaths(route, registry) {
 		console.warn(`  Warning: SSG route "${route.path}" has dynamic segments but no getStaticPaths() export, skipping.`);
 		return [];
 	}
-	const { buildPathFromSegments } = await import("./app-Cep0el7c.mjs").then((n) => n.t);
 	return (await routeModule.getStaticPaths()).map((params) => buildPathFromSegments(route.segments, params));
 }
 //#endregion
@@ -874,6 +1158,13 @@ function prefetchRouteState(url) {
 }
 function setupPrefetching(app, warmModules) {
 	let hoverTimer = null;
+	function getRoutePathname(url) {
+		try {
+			return new URL(url, window.location.origin).pathname;
+		} catch {
+			return null;
+		}
+	}
 	function getInternalHref(anchor) {
 		const href = anchor.getAttribute("href");
 		if (!href || href.startsWith("#")) return null;
@@ -887,10 +1178,11 @@ function setupPrefetching(app, warmModules) {
 		return url.pathname + url.search;
 	}
 	function getPrefetchStrategy(pathname) {
-		const match = matchAppRoute(app, pathname);
+		const routePathname = getRoutePathname(pathname);
+		if (!routePathname) return "none";
+		const match = matchAppRoute(app, routePathname);
 		if (!match) return "none";
 		if (match.route.prefetch) return match.route.prefetch;
-		if (match.route.render === "spa") return "none";
 		return "intent";
 	}
 	document.addEventListener("mouseenter", (e) => {
@@ -904,7 +1196,8 @@ function setupPrefetching(app, warmModules) {
 		hoverTimer = setTimeout(() => {
 			prefetchRouteState(href);
 			if (warmModules) {
-				const m = matchAppRoute(app, href);
+				const pathname = getRoutePathname(href);
+				const m = pathname ? matchAppRoute(app, pathname) : void 0;
 				if (m) warmModules(m);
 			}
 		}, 50);
@@ -925,7 +1218,8 @@ function setupPrefetching(app, warmModules) {
 		if (strategy !== "hover" && strategy !== "intent") return;
 		prefetchRouteState(href);
 		if (warmModules) {
-			const m = matchAppRoute(app, href);
+			const pathname = getRoutePathname(href);
+			const m = pathname ? matchAppRoute(app, pathname) : void 0;
 			if (m) warmModules(m);
 		}
 	}, true);
@@ -938,7 +1232,8 @@ function setupPrefetching(app, warmModules) {
 			if (!href) continue;
 			prefetchRouteState(href);
 			if (warmModules) {
-				const m = matchAppRoute(app, href);
+				const pathname = getRoutePathname(href);
+				const m = pathname ? matchAppRoute(app, pathname) : void 0;
 				if (m) warmModules(m);
 			}
 			observer.unobserve(anchor);
@@ -989,7 +1284,30 @@ async function initClientRouter(options) {
 		if (!shellKey) return null;
 		return loadModule(shellModules, shellKey);
 	}
-	async function buildRouteTree(match, state, routeModPromise, shellModPromise) {
+	let updateRouteState = null;
+	let routeStateVersion = 0;
+	function RouterRoot({ initialState }) {
+		const [routeState, setRouteState] = useState(initialState);
+		updateRouteState = setRouteState;
+		const navigateValue = useMemo(() => navigate, []);
+		const { Shell, Component, componentProps, data, params, routeId, url, version } = routeState;
+		const componentTree = Shell ? h(Shell, null, h(Component, componentProps)) : h(Component, componentProps);
+		return h(NavigateContext.Provider, { value: navigateValue }, h(PrachtRuntimeProvider, {
+			data,
+			params,
+			routeId,
+			stateVersion: version,
+			url
+		}, componentTree));
+	}
+	function applyRouteState(routeState) {
+		if (updateRouteState) {
+			updateRouteState(routeState);
+			return;
+		}
+		render(h(RouterRoot, { initialState: routeState }), root);
+	}
+	async function resolveRouteState(match, state, currentUrl, routeModPromise, shellModPromise) {
 		const routeMod = await (routeModPromise ?? startRouteImport(match));
 		if (!routeMod) return null;
 		let Shell = null;
@@ -998,39 +1316,69 @@ async function initClientRouter(options) {
 		const DefaultComponent = typeof routeMod.default === "function" ? routeMod.default : void 0;
 		const Component = state.error ? routeMod.ErrorBoundary : routeMod.Component ?? DefaultComponent;
 		if (!Component) return null;
-		const props = state.error ? { error: deserializeRouteError(state.error) } : {
+		const componentProps = state.error ? { error: deserializeRouteError(state.error) } : {
 			data: state.data,
 			params: match.params
 		};
-		const componentTree = Shell ? h(Shell, null, h(Component, props)) : h(Component, props);
-		return h(NavigateContext.Provider, { value: navigate }, h(PrachtRuntimeProvider, {
+		return {
+			Shell,
+			Component,
+			componentProps,
 			data: state.data,
 			params: match.params,
 			routeId: match.route.id ?? "",
-			url: match.pathname
-		}, componentTree));
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
 	}
-	async function buildSpaPendingTree(match, shellModPromise) {
+	async function resolveSpaPendingState(match, currentUrl, shellModPromise) {
 		const resolvedShell = await (shellModPromise ?? startShellImport(match));
 		if (!resolvedShell) return null;
-		const Shell = resolvedShell.Shell;
+		const Shell = resolvedShell.Shell ?? null;
 		const Loading = resolvedShell.Loading;
-		const componentTree = Shell != null ? h(Shell, null, Loading ? h(Loading, null) : null) : Loading ? h(Loading, null) : null;
-		if (!componentTree) return null;
-		return h(NavigateContext.Provider, { value: navigate }, h(PrachtRuntimeProvider, {
+		if (!Shell && !Loading) return null;
+		return {
+			Shell,
+			Component: Loading ?? (() => null),
+			componentProps: {},
 			data: void 0,
 			params: match.params,
 			routeId: match.route.id ?? "",
-			url: match.pathname
-		}, componentTree));
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
+	}
+	function resolveRedirectTarget(location) {
+		const targetUrl = new URL(location, window.location.href);
+		const fullInternalTarget = targetUrl.pathname + targetUrl.search + targetUrl.hash;
+		const internalPath = targetUrl.pathname + targetUrl.search;
+		const currentPath = window.location.pathname + window.location.search + window.location.hash;
+		const isCurrentLocation = targetUrl.origin === window.location.origin && fullInternalTarget === currentPath;
+		if (targetUrl.origin !== window.location.origin) return {
+			externalUrl: targetUrl.toString(),
+			isCurrentLocation: false
+		};
+		if (targetUrl.hash) return {
+			documentUrl: targetUrl.toString(),
+			isCurrentLocation
+		};
+		return {
+			internalPath,
+			isCurrentLocation
+		};
 	}
 	async function navigate(to, opts) {
-		const match = matchAppRoute(app, to);
-		if (!match) {
+		const target = resolveBrowserRouteTarget(to);
+		if (!target) {
 			window.location.href = to;
 			return;
 		}
-		const statePromise = getCachedRouteState(to) ?? fetchPrachtRouteState(to);
+		const match = matchAppRoute(app, target.pathname);
+		if (!match) {
+			window.location.href = target.browserUrl;
+			return;
+		}
+		const statePromise = getCachedRouteState(target.requestUrl) ?? fetchPrachtRouteState(target.requestUrl);
 		const routeModPromise = startRouteImport(match);
 		const shellModPromise = startShellImport(match);
 		let state = {
@@ -1041,10 +1389,24 @@ async function initClientRouter(options) {
 			const result = await statePromise;
 			if (result.type === "redirect") {
 				if (result.location) {
-					await navigate(result.location, opts);
+					const redirect = resolveRedirectTarget(result.location);
+					if (redirect.externalUrl) {
+						window.location.href = redirect.externalUrl;
+						return;
+					}
+					if (redirect.isCurrentLocation) return;
+					if (redirect.documentUrl) {
+						window.location.href = redirect.documentUrl;
+						return;
+					}
+					if (redirect.internalPath) {
+						await navigate(redirect.internalPath, opts);
+						return;
+					}
+					window.location.href = result.location;
 					return;
 				}
-				window.location.href = to;
+				window.location.href = target.browserUrl;
 				return;
 			}
 			if (result.type === "error") state = {
@@ -1056,27 +1418,21 @@ async function initClientRouter(options) {
 				error: null
 			};
 		} catch {
-			window.location.href = to;
+			window.location.href = target.browserUrl;
 			return;
 		}
-		if (!opts?._popstate) if (opts?.replace) history.replaceState(null, "", to);
-		else history.pushState(null, "", to);
-		const tree = await buildRouteTree(match, state, routeModPromise, shellModPromise);
-		if (tree) {
-			render(tree, root);
+		if (!opts?._popstate) if (opts?.replace) history.replaceState(null, "", target.browserUrl);
+		else history.pushState(null, "", target.browserUrl);
+		const routeState = await resolveRouteState(match, state, target.requestUrl, routeModPromise, shellModPromise);
+		if (routeState) {
+			applyRouteState(routeState);
 			window.scrollTo(0, 0);
-		} else window.location.href = to;
-	}
-	if (import.meta.env?.DEV) {
-		const prev = options.__m;
-		options.__m = (vnode, s) => {
-			const message = `Hydration mismatch in <${(typeof vnode.type === "function" ? vnode.type.displayName || vnode.type.name : vnode.type) || "Unknown"}>: ${s}`;
-			console.warn(`[pracht] ${message}`);
-			appendHydrationWarning(message);
-			if (prev) prev(vnode, s);
-		};
+		} else window.location.href = target.browserUrl;
 	}
-	const initialMatch = matchAppRoute(app, options.initialState.url);
+	const initialTarget = resolveBrowserRouteTarget(options.initialState.url);
+	const initialRequestUrl = initialTarget?.requestUrl ?? options.initialState.url;
+	const initialBrowserUrl = initialTarget?.browserUrl ?? options.initialState.url;
+	const initialMatch = matchAppRoute(app, initialTarget?.pathname ?? options.initialState.url);
 	if (initialMatch) {
 		const initialShellPromise = initialMatch.route.render === "spa" && options.initialState.pending ? startShellImport(initialMatch) : null;
 		let state = {
@@ -1084,9 +1440,9 @@ async function initClientRouter(options) {
 			error: options.initialState.error ?? null
 		};
 		if (initialMatch.route.render === "spa" && options.initialState.pending) {
-			const dataPromise = fetchPrachtRouteState(options.initialState.url);
-			const pendingTree = await buildSpaPendingTree(initialMatch, initialShellPromise);
-			if (pendingTree) hydrate(pendingTree, root);
+			const dataPromise = fetchPrachtRouteState(initialRequestUrl, { useDataParam: true });
+			const pendingState = await resolveSpaPendingState(initialMatch, initialRequestUrl, initialShellPromise);
+			if (pendingState) hydrate(h(RouterRoot, { initialState: pendingState }), root);
 			try {
 				const result = await dataPromise;
 				if (result.type === "redirect") {
@@ -1102,15 +1458,18 @@ async function initClientRouter(options) {
 					error: null
 				};
 			} catch {
-				window.location.href = options.initialState.url;
+				window.location.href = initialBrowserUrl;
 				return;
 			}
-		}
-		const tree = await buildRouteTree(initialMatch, state, void 0, initialShellPromise);
-		if (tree) if (initialMatch.route.render === "spa") render(tree, root);
-		else {
-			markHydrating();
-			hydrate(tree, root);
+			const resolvedState = await resolveRouteState(initialMatch, state, initialRequestUrl, void 0, initialShellPromise);
+			if (resolvedState) applyRouteState(resolvedState);
+		} else {
+			const initialRouteState = await resolveRouteState(initialMatch, state, initialRequestUrl, void 0, initialShellPromise);
+			if (initialRouteState) if (initialMatch.route.render === "spa") render(h(RouterRoot, { initialState: initialRouteState }), root);
+			else {
+				markHydrating();
+				hydrate(h(RouterRoot, { initialState: initialRouteState }), root);
+			}
 		}
 	}
 	document.addEventListener("click", (e) => {
@@ -1132,10 +1491,10 @@ async function initClientRouter(options) {
 		}
 		if (url.origin !== window.location.origin) return;
 		e.preventDefault();
-		navigate(url.pathname + url.search);
+		navigate(url.pathname + url.search + url.hash);
 	});
 	window.addEventListener("popstate", () => {
-		navigate(window.location.pathname + window.location.search, { _popstate: true });
+		navigate(window.location.pathname + window.location.search + window.location.hash, { _popstate: true });
 	});
 	window.__PRACHT_NAVIGATE__ = navigate;
 	window.__PRACHT_ROUTER_READY__ = true;
@@ -1145,60 +1504,19 @@ async function initClientRouter(options) {
 	};
 	setupPrefetching(app, warmModules);
 }
-const HYDRATION_BANNER_ID = "__pracht_hydration_warnings__";
-function appendHydrationWarning(message) {
-	let container = document.getElementById(HYDRATION_BANNER_ID);
-	if (!container) {
-		container = document.createElement("div");
-		container.id = HYDRATION_BANNER_ID;
-		Object.assign(container.style, {
-			position: "fixed",
-			bottom: "0",
-			left: "0",
-			right: "0",
-			maxHeight: "30vh",
-			overflow: "auto",
-			background: "#2d1b00",
-			borderTop: "2px solid #f0ad4e",
-			color: "#ffc107",
-			fontFamily: "ui-monospace, Consolas, monospace",
-			fontSize: "13px",
-			padding: "12px 16px",
-			zIndex: "2147483647"
-		});
-		const header = document.createElement("div");
-		Object.assign(header.style, {
-			display: "flex",
-			justifyContent: "space-between",
-			alignItems: "center",
-			marginBottom: "8px"
-		});
-		header.innerHTML = "<strong style=\"color:#f0ad4e\">⚠ Hydration Mismatches</strong>";
-		const close = document.createElement("button");
-		close.textContent = "×";
-		Object.assign(close.style, {
-			background: "none",
-			border: "none",
-			color: "#f0ad4e",
-			fontSize: "18px",
-			cursor: "pointer"
-		});
-		close.onclick = () => container.remove();
-		header.appendChild(close);
-		container.appendChild(header);
-		document.body.appendChild(container);
+function resolveBrowserRouteTarget(to) {
+	if (typeof window === "undefined") return null;
+	try {
+		const url = new URL(to, window.location.href);
+		if (url.origin !== window.location.origin) return null;
+		return {
+			browserUrl: url.pathname + url.search + url.hash,
+			pathname: url.pathname,
+			requestUrl: url.pathname + url.search
+		};
+	} catch {
+		return null;
 	}
-	const entry = document.createElement("div");
-	entry.textContent = message;
-	Object.assign(entry.style, { padding: "2px 0" });
-	container.appendChild(entry);
-}
-function deserializeRouteError(error) {
-	const result = new Error(error.message);
-	result.name = error.name;
-	result.status = error.status;
-	result.diagnostics = error.diagnostics;
-	return result;
 }
 //#endregion
 //#region src/types.ts
@@ -1211,4 +1529,4 @@ var PrachtHttpError = class extends Error {
 	}
 };
 //#endregion
-export { Form, PrachtHttpError, PrachtRuntimeProvider, Suspense, applyDefaultSecurityHeaders, buildPathFromSegments, defineApp, forwardRef, group, handlePrachtRequest, initClientRouter, lazy, matchApiRoute, matchAppRoute, prerenderApp, readHydrationState, resolveApiRoutes, resolveApp, route, startApp, timeRevalidate, useIsHydrated, useLocation, useNavigate, useParams, useRevalidate, useRevalidateRoute, useRouteData };
+export { Form, PrachtHttpError, PrachtRuntimeProvider, Suspense, applyDefaultSecurityHeaders, buildPathFromSegments, defineApp, forwardRef, group, handlePrachtRequest, initClientRouter, lazy, matchApiRoute, matchAppRoute, prerenderApp, readHydrationState, resolveApiRoutes, resolveApp, route, startApp, timeRevalidate, useIsHydrated, useLocation, useNavigate, useParams, useRevalidate, useRouteData };