@pracht/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,837 @@
+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-CAoDWWNO.mjs";
+import { Suspense, lazy } from "preact-suspense";
+import { createContext, h, hydrate, render } from "preact";
+import { useContext, useEffect, useMemo, useState } from "preact/hooks";
+//#region src/runtime.ts
+const SAFE_METHODS = new Set(["GET", "HEAD"]);
+const HYDRATION_STATE_ELEMENT_ID = "pracht-state";
+const RouteDataContext = createContext(void 0);
+function PrachtRuntimeProvider({ children, data, params = {}, routeId, url }) {
+	const [routeData, setRouteData] = useState(data);
+	useEffect(() => {
+		setRouteData(data);
+	}, [
+		data,
+		routeId,
+		url
+	]);
+	const context = useMemo(() => ({
+		data: routeData,
+		params,
+		routeId,
+		setData: setRouteData,
+		url
+	}), [
+		routeData,
+		params,
+		routeId,
+		url
+	]);
+	return h(RouteDataContext.Provider, {
+		value: context,
+		children
+	});
+}
+function startApp(options = {}) {
+	if (typeof window === "undefined") return options.initialData;
+	if (typeof options.initialData !== "undefined") return options.initialData;
+	return readHydrationState()?.data;
+}
+function readHydrationState() {
+	if (typeof window === "undefined") return;
+	if (window.__PRACHT_STATE__) return window.__PRACHT_STATE__;
+	const element = document.getElementById(HYDRATION_STATE_ELEMENT_ID);
+	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;
+	}
+}
+function useRouteData() {
+	return useContext(RouteDataContext)?.data;
+}
+function useLocation() {
+	return { pathname: useContext(RouteDataContext)?.url ?? (typeof window !== "undefined" ? window.location.pathname : "/") };
+}
+function useParams() {
+	return useContext(RouteDataContext)?.params ?? {};
+}
+function useRevalidate() {
+	const runtime = useContext(RouteDataContext);
+	return async () => {
+		if (typeof window === "undefined") return;
+		const result = await fetchPrachtRouteState(runtime?.url || window.location.pathname + window.location.search);
+		if (result.type === "redirect") {
+			await navigateToClientLocation(result.location);
+			return;
+		}
+		if (result.type === "error") throw deserializeRouteError$1(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", {
+		...rest,
+		method,
+		onSubmit: async (event) => {
+			onSubmit?.(event);
+			if (event.defaultPrevented) return;
+			const form = event.currentTarget;
+			if (!(form instanceof HTMLFormElement)) return;
+			const formMethod = (method ?? form.method ?? "post").toUpperCase();
+			if (SAFE_METHODS.has(formMethod)) return;
+			event.preventDefault();
+			const response = await fetch(props.action ?? form.action, {
+				method: formMethod,
+				body: new FormData(form),
+				redirect: "manual"
+			});
+			if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+				const location = response.headers.get("location");
+				if (location) {
+					await navigateToClientLocation(location);
+					return;
+				}
+				window.location.href = props.action ?? form.action;
+			}
+		}
+	});
+}
+async function fetchPrachtRouteState(url) {
+	const response = await fetch(url, {
+		headers: {
+			"x-pracht-route-state-request": "1",
+			"Cache-Control": "no-cache"
+		},
+		redirect: "manual"
+	});
+	if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) return {
+		location: response.headers.get("location") ?? url,
+		type: "redirect"
+	};
+	const json = await response.json();
+	if (!response.ok) {
+		if (json.error) return {
+			error: json.error,
+			type: "error"
+		};
+		throw new Error(`Failed to fetch route state (${response.status})`);
+	}
+	return {
+		data: json.data,
+		type: "data"
+	};
+}
+async function handlePrachtRequest(options) {
+	const url = new URL(options.request.url);
+	const registry = options.registry ?? {};
+	if (options.apiRoutes?.length) {
+		const apiMatch = matchApiRoute(options.apiRoutes, url.pathname);
+		if (apiMatch) {
+			const apiMiddlewareFiles = (options.app.api.middleware ?? []).flatMap((name) => {
+				const middlewareFile = options.app.middleware[name];
+				return middlewareFile ? [middlewareFile] : [];
+			});
+			const middlewareResult = await runMiddlewareChain({
+				context: options.context ?? {},
+				middlewareFiles: apiMiddlewareFiles,
+				params: apiMatch.params,
+				registry,
+				request: options.request,
+				route: apiMatch.route,
+				url
+			});
+			if (middlewareResult.response) return middlewareResult.response;
+			const apiModule = await resolveRegistryModule(registry.apiModules, apiMatch.route.file);
+			if (!apiModule) return withDefaultSecurityHeaders(new Response("API route module not found", {
+				status: 500,
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			}));
+			const handler = apiModule[options.request.method.toUpperCase()];
+			if (!handler) return withDefaultSecurityHeaders(new Response("Method not allowed", {
+				status: 405,
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			}));
+			return withDefaultSecurityHeaders(await handler({
+				request: options.request,
+				params: apiMatch.params,
+				context: middlewareResult.context,
+				signal: AbortSignal.timeout(3e4),
+				url,
+				route: apiMatch.route
+			}));
+		}
+	}
+	const match = matchAppRoute(options.app, url.pathname);
+	if (!match) return withDefaultSecurityHeaders(new Response("Not found", {
+		status: 404,
+		headers: { "content-type": "text/plain; charset=utf-8" }
+	}));
+	const isRouteStateRequest = options.request.headers.get("x-pracht-route-state-request") === "1";
+	if (!SAFE_METHODS.has(options.request.method)) return withDefaultSecurityHeaders(new Response("Method not allowed", {
+		status: 405,
+		headers: { "content-type": "text/plain; charset=utf-8" }
+	}));
+	const middlewareResult = await runMiddlewareChain({
+		context: options.context ?? {},
+		middlewareFiles: match.route.middlewareFiles,
+		params: match.params,
+		registry,
+		request: options.request,
+		route: match.route,
+		url
+	});
+	if (middlewareResult.response) return middlewareResult.response;
+	const context = middlewareResult.context;
+	const routeModule = await resolveRegistryModule(registry.routeModules, match.route.file);
+	const routeArgs = {
+		request: options.request,
+		params: match.params,
+		context,
+		signal: AbortSignal.timeout(3e4),
+		url,
+		route: match.route
+	};
+	const { loader } = await resolveDataFunctions(match.route, routeModule, registry);
+	let shellModule;
+	try {
+		const loaderResult = loader ? await loader(routeArgs) : void 0;
+		if (loaderResult instanceof Response) return withDefaultSecurityHeaders(loaderResult);
+		const data = loaderResult;
+		if (isRouteStateRequest) return withDefaultSecurityHeaders(Response.json({ data }));
+		shellModule = match.route.shellFile ? await resolveRegistryModule(registry.shellModules, match.route.shellFile) : void 0;
+		const head = await mergeHeadMetadata(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") return htmlResponse(buildHtmlDocument({
+			head,
+			body: "",
+			hydrationState: {
+				url: url.pathname,
+				routeId: match.route.id ?? "",
+				data: null,
+				error: null
+			},
+			clientEntryUrl: options.clientEntryUrl,
+			cssUrls,
+			modulePreloadUrls
+		}));
+		if (!routeModule?.Component) return withDefaultSecurityHeaders(new Response("Route has no Component export", {
+			status: 500,
+			headers: { "content-type": "text/plain; charset=utf-8" }
+		}));
+		const { renderToStringAsync } = await import("preact-render-to-string");
+		const Component = routeModule.Component;
+		const Shell = shellModule?.Shell;
+		const componentProps = {
+			data,
+			params: match.params
+		};
+		const componentTree = Shell ? h(Shell, null, h(Component, componentProps)) : h(Component, componentProps);
+		return htmlResponse(buildHtmlDocument({
+			head,
+			body: await renderToStringAsync(h(PrachtRuntimeProvider, {
+				data,
+				params: match.params,
+				routeId: match.route.id ?? "",
+				url: url.pathname
+			}, componentTree)),
+			hydrationState: {
+				url: url.pathname,
+				routeId: match.route.id ?? "",
+				data,
+				error: null
+			},
+			clientEntryUrl: options.clientEntryUrl,
+			cssUrls,
+			modulePreloadUrls
+		}));
+	} catch (error) {
+		return renderRouteErrorResponse({
+			error,
+			isRouteStateRequest,
+			options,
+			routeArgs,
+			routeId: match.route.id ?? "",
+			routeModule,
+			shellFile: match.route.shellFile,
+			shellModule,
+			urlPathname: url.pathname
+		});
+	}
+}
+function resolvePageCssUrls(options, shellFile, routeFile) {
+	if (!options.cssManifest) return options.cssUrls ?? [];
+	const css = /* @__PURE__ */ new Set();
+	function addFromManifest(file) {
+		const suffix = file.replace(/^\.\//, "");
+		for (const [key, cssFiles] of Object.entries(options.cssManifest)) if (key === file || key.endsWith(`/${suffix}`) || key.endsWith(suffix)) {
+			for (const c of cssFiles) css.add(c);
+			break;
+		}
+	}
+	if (shellFile) addFromManifest(shellFile);
+	addFromManifest(routeFile);
+	return [...css];
+}
+function resolvePageJsUrls(options, shellFile, routeFile) {
+	if (!options.jsManifest) return [];
+	const js = /* @__PURE__ */ new Set();
+	function addFromManifest(file) {
+		const suffix = file.replace(/^\.\//, "");
+		for (const [key, jsFiles] of Object.entries(options.jsManifest)) if (key === file || key.endsWith(`/${suffix}`) || key.endsWith(suffix)) {
+			for (const j of jsFiles) js.add(j);
+			break;
+		}
+	}
+	if (shellFile) addFromManifest(shellFile);
+	addFromManifest(routeFile);
+	return [...js];
+}
+async function navigateToClientLocation(location, options) {
+	if (typeof window === "undefined") return;
+	const targetUrl = new URL(location, window.location.href);
+	const target = targetUrl.pathname + targetUrl.search + targetUrl.hash;
+	if (targetUrl.origin === window.location.origin && window.__PRACHT_NAVIGATE__) {
+		await window.__PRACHT_NAVIGATE__(target, options);
+		return;
+	}
+	if (options?.replace) {
+		window.location.replace(targetUrl.toString());
+		return;
+	}
+	window.location.href = targetUrl.toString();
+}
+function isPrachtHttpError(error) {
+	return error instanceof Error && error.name === "PrachtHttpError" && "status" in error;
+}
+function normalizeRouteError(error) {
+	if (isPrachtHttpError(error)) return {
+		message: error.message,
+		name: error.name,
+		status: typeof error.status === "number" ? error.status : 500
+	};
+	if (error instanceof Error) return {
+		message: error.message || "Internal Server Error",
+		name: error.name || "Error",
+		status: 500
+	};
+	return {
+		message: "Internal Server Error",
+		name: "Error",
+		status: 500
+	};
+}
+function deserializeRouteError$1(error) {
+	const result = new Error(error.message);
+	result.name = error.name;
+	result.status = error.status;
+	return result;
+}
+async function renderRouteErrorResponse(options) {
+	const routeError = normalizeRouteError(options.error);
+	if (!options.routeModule?.ErrorBoundary) {
+		if (options.isRouteStateRequest) return withDefaultSecurityHeaders(new Response(JSON.stringify({ error: routeError }), {
+			status: routeError.status,
+			headers: { "content-type": "application/json; charset=utf-8" }
+		}));
+		const message = routeError.status >= 500 ? "Internal Server Error" : routeError.message;
+		return withDefaultSecurityHeaders(new Response(message, {
+			status: routeError.status,
+			headers: { "content-type": "text/plain; charset=utf-8" }
+		}));
+	}
+	if (options.isRouteStateRequest) return withDefaultSecurityHeaders(new Response(JSON.stringify({ error: routeError }), {
+		status: routeError.status,
+		headers: { "content-type": "application/json; charset=utf-8" }
+	}));
+	const shellModule = options.shellModule ?? (options.shellFile ? await resolveRegistryModule(options.options.registry?.shellModules, options.shellFile) : void 0);
+	const head = shellModule?.head ? await shellModule.head(options.routeArgs) : {};
+	const cssUrls = resolvePageCssUrls(options.options, options.shellFile, options.routeArgs.route.file);
+	const modulePreloadUrls = resolvePageJsUrls(options.options, options.shellFile, options.routeArgs.route.file);
+	const { renderToStringAsync } = await import("preact-render-to-string");
+	const ErrorBoundary = options.routeModule.ErrorBoundary;
+	const Shell = shellModule?.Shell;
+	const errorValue = deserializeRouteError$1(routeError);
+	const componentTree = Shell ? h(Shell, null, h(ErrorBoundary, { error: errorValue })) : h(ErrorBoundary, { error: errorValue });
+	return htmlResponse(buildHtmlDocument({
+		head,
+		body: await renderToStringAsync(h(PrachtRuntimeProvider, {
+			data: null,
+			routeId: options.routeId,
+			url: options.urlPathname
+		}, componentTree)),
+		hydrationState: {
+			url: options.urlPathname,
+			routeId: options.routeId,
+			data: null,
+			error: routeError
+		},
+		clientEntryUrl: options.options.clientEntryUrl,
+		cssUrls,
+		modulePreloadUrls
+	}), routeError.status);
+}
+async function runMiddlewareChain(options) {
+	let context = options.context;
+	for (const mwFile of options.middlewareFiles) {
+		const mwModule = await resolveRegistryModule(options.registry.middlewareModules, mwFile);
+		if (!mwModule?.middleware) continue;
+		const result = await mwModule.middleware({
+			request: options.request,
+			params: options.params,
+			context,
+			signal: AbortSignal.timeout(3e4),
+			url: options.url,
+			route: options.route
+		});
+		if (!result) continue;
+		if (result instanceof Response) return { response: withDefaultSecurityHeaders(result) };
+		if ("redirect" in result) return { response: withDefaultSecurityHeaders(new Response(null, {
+			status: 302,
+			headers: { location: result.redirect }
+		})) };
+		if ("context" in result) context = {
+			...context,
+			...result.context
+		};
+	}
+	return { context };
+}
+async function resolveDataFunctions(route, routeModule, registry) {
+	let loader = routeModule?.loader;
+	if (route.loaderFile) {
+		const dataModule = await resolveRegistryModule(registry.dataModules, route.loaderFile);
+		if (dataModule?.loader) loader = dataModule.loader;
+	}
+	return { loader };
+}
+async function resolveRegistryModule(modules, file) {
+	if (!modules) return void 0;
+	if (file in modules) return modules[file]();
+	const suffix = file.replace(/^\.\//, "");
+	for (const key of Object.keys(modules)) if (key.endsWith(`/${suffix}`) || key.endsWith(suffix)) return modules[key]();
+}
+async function mergeHeadMetadata(shellModule, routeModule, routeArgs, data) {
+	const shellHead = shellModule?.head ? await shellModule.head(routeArgs) : {};
+	const routeHead = routeModule?.head ? await routeModule.head({
+		...routeArgs,
+		data
+	}) : {};
+	return {
+		title: routeHead.title ?? shellHead.title,
+		lang: routeHead.lang ?? shellHead.lang,
+		meta: [...shellHead.meta ?? [], ...routeHead.meta ?? []],
+		link: [...shellHead.link ?? [], ...routeHead.link ?? []]
+	};
+}
+function buildHtmlDocument(options) {
+	const { head, body, hydrationState, clientEntryUrl, cssUrls = [], modulePreloadUrls = [] } = 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 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>
+<html${head.lang ? ` lang="${escapeHtml(head.lang)}"` : ""}>
+  <head>
+    <meta charset="utf-8">
+    ${titleTag}
+    ${metaTags}
+    ${linkTags}
+    ${cssTags}
+    ${modulePreloadTags}
+  </head>
+  <body>
+    <div id="pracht-root">${body}</div>
+    ${stateScript}
+    ${entryScript}
+  </body>
+</html>`;
+}
+function htmlResponse(html, status = 200) {
+	return withDefaultSecurityHeaders(new Response(html, {
+		status,
+		headers: { "content-type": "text/html; charset=utf-8" }
+	}));
+}
+function applyDefaultSecurityHeaders(headers) {
+	if (!headers.has("permissions-policy")) headers.set("permissions-policy", "accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()");
+	if (!headers.has("referrer-policy")) headers.set("referrer-policy", "strict-origin-when-cross-origin");
+	if (!headers.has("x-content-type-options")) headers.set("x-content-type-options", "nosniff");
+	if (!headers.has("x-frame-options")) headers.set("x-frame-options", "SAMEORIGIN");
+	return headers;
+}
+function withDefaultSecurityHeaders(response) {
+	const headers = applyDefaultSecurityHeaders(new Headers(response.headers));
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+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-CAoDWWNO.mjs").then((n) => n.t);
+	const resolved = resolveApp(options.app);
+	const results = [];
+	const isgManifest = {};
+	for (const route of resolved.routes) {
+		if (route.render !== "ssg" && route.render !== "isg") continue;
+		const paths = await collectSSGPaths(route, options.registry);
+		for (const pathname of paths) {
+			const url = new URL(pathname, "http://localhost");
+			const request = new Request(url, { method: "GET" });
+			const response = await handlePrachtRequest({
+				app: options.app,
+				request,
+				registry: options.registry,
+				clientEntryUrl: options.clientEntryUrl,
+				cssManifest: options.cssManifest
+			});
+			if (response.status !== 200) {
+				console.warn(`  Warning: ${route.render.toUpperCase()} route "${pathname}" returned status ${response.status}, skipping.`);
+				continue;
+			}
+			const html = await response.text();
+			results.push({
+				path: pathname,
+				html
+			});
+			if (route.render === "isg" && route.revalidate) isgManifest[pathname] = { revalidate: route.revalidate };
+		}
+	}
+	if (options.withISGManifest) return {
+		pages: results,
+		isgManifest
+	};
+	return results;
+}
+async function collectSSGPaths(route, registry) {
+	if (!route.segments.some((s) => s.type === "param" || s.type === "catchall")) return [route.path];
+	const routeModule = await resolveRegistryModule(registry?.routeModules, route.file);
+	if (!routeModule?.getStaticPaths) {
+		console.warn(`  Warning: SSG route "${route.path}" has dynamic segments but no getStaticPaths() export, skipping.`);
+		return [];
+	}
+	const { buildPathFromSegments } = await import("./app-CAoDWWNO.mjs").then((n) => n.t);
+	return (await routeModule.getStaticPaths()).map((params) => buildPathFromSegments(route.segments, params));
+}
+//#endregion
+//#region src/prefetch.ts
+const CACHE_TTL_MS = 3e4;
+const prefetchCache = /* @__PURE__ */ new Map();
+function getCachedRouteState(url) {
+	const entry = prefetchCache.get(url);
+	if (!entry) return null;
+	if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+		prefetchCache.delete(url);
+		return null;
+	}
+	return entry.promise;
+}
+function prefetchRouteState(url) {
+	const cached = getCachedRouteState(url);
+	if (cached) return cached;
+	const promise = fetchPrachtRouteState(url);
+	prefetchCache.set(url, {
+		promise,
+		timestamp: Date.now()
+	});
+	return promise;
+}
+function setupPrefetching(app) {
+	let hoverTimer = null;
+	function getInternalHref(anchor) {
+		const href = anchor.getAttribute("href");
+		if (!href || href.startsWith("#")) return null;
+		let url;
+		try {
+			url = new URL(href, window.location.origin);
+		} catch {
+			return null;
+		}
+		if (url.origin !== window.location.origin) return null;
+		return url.pathname + url.search;
+	}
+	function getPrefetchStrategy(pathname) {
+		const match = matchAppRoute(app, pathname);
+		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) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		const href = getInternalHref(anchor);
+		if (!href) return;
+		const strategy = getPrefetchStrategy(href);
+		if (strategy !== "hover" && strategy !== "intent") return;
+		if (hoverTimer) clearTimeout(hoverTimer);
+		hoverTimer = setTimeout(() => {
+			prefetchRouteState(href);
+		}, 50);
+	}, true);
+	document.addEventListener("mouseleave", (e) => {
+		if (!e.target.closest?.("a")) return;
+		if (hoverTimer) {
+			clearTimeout(hoverTimer);
+			hoverTimer = null;
+		}
+	}, true);
+	document.addEventListener("focusin", (e) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		const href = getInternalHref(anchor);
+		if (!href) return;
+		const strategy = getPrefetchStrategy(href);
+		if (strategy !== "hover" && strategy !== "intent") return;
+		prefetchRouteState(href);
+	}, true);
+	if (typeof IntersectionObserver === "undefined") return;
+	const observer = new IntersectionObserver((entries) => {
+		for (const entry of entries) {
+			if (!entry.isIntersecting) continue;
+			const anchor = entry.target;
+			const href = getInternalHref(anchor);
+			if (!href) continue;
+			prefetchRouteState(href);
+			observer.unobserve(anchor);
+		}
+	}, { rootMargin: "200px" });
+	function observeViewportLinks() {
+		const anchors = document.querySelectorAll("a[href]");
+		for (const anchor of anchors) {
+			const href = getInternalHref(anchor);
+			if (!href) continue;
+			if (getPrefetchStrategy(href) !== "viewport") continue;
+			observer.observe(anchor);
+		}
+	}
+	observeViewportLinks();
+	new MutationObserver(() => {
+		observeViewportLinks();
+	}).observe(document.body, {
+		childList: true,
+		subtree: true
+	});
+}
+//#endregion
+//#region src/router.ts
+const NavigateContext = createContext(async () => {});
+function useNavigate() {
+	return useContext(NavigateContext);
+}
+async function initClientRouter(options) {
+	const { app, routeModules, shellModules, root, findModuleKey } = options;
+	async function buildRouteTree(match, state) {
+		const routeKey = findModuleKey(routeModules, match.route.file);
+		if (!routeKey) return null;
+		const routeMod = await routeModules[routeKey]();
+		let Shell = null;
+		if (match.route.shellFile) {
+			const shellKey = findModuleKey(shellModules, match.route.shellFile);
+			if (shellKey) Shell = (await shellModules[shellKey]()).Shell;
+		}
+		const Component = state.error ? routeMod.ErrorBoundary : routeMod.Component;
+		if (!Component) return null;
+		const props = 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, {
+			data: state.data,
+			params: match.params,
+			routeId: match.route.id ?? "",
+			url: match.pathname
+		}, componentTree));
+	}
+	async function navigate(to, opts) {
+		const match = matchAppRoute(app, to);
+		if (!match) {
+			window.location.href = to;
+			return;
+		}
+		let state = {
+			data: void 0,
+			error: null
+		};
+		try {
+			const result = await (getCachedRouteState(to) ?? fetchPrachtRouteState(to));
+			if (result.type === "redirect") {
+				if (result.location) {
+					await navigate(result.location, opts);
+					return;
+				}
+				window.location.href = to;
+				return;
+			}
+			if (result.type === "error") state = {
+				data: void 0,
+				error: result.error
+			};
+			else state = {
+				data: result.data,
+				error: null
+			};
+		} catch {
+			window.location.href = to;
+			return;
+		}
+		if (!opts?._popstate) if (opts?.replace) history.replaceState(null, "", to);
+		else history.pushState(null, "", to);
+		const tree = await buildRouteTree(match, state);
+		if (tree) {
+			render(tree, root);
+			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);
+		};
+	}
+	const initialMatch = matchAppRoute(app, options.initialState.url);
+	if (initialMatch) {
+		let state = {
+			data: options.initialState.data,
+			error: options.initialState.error ?? null
+		};
+		if (initialMatch.route.render === "spa" && state.data == null && !state.error) try {
+			const result = await fetchPrachtRouteState(options.initialState.url);
+			if (result.type === "redirect") {
+				window.location.href = result.location;
+				return;
+			}
+			if (result.type === "error") state = {
+				data: void 0,
+				error: result.error
+			};
+			else state = {
+				data: result.data,
+				error: null
+			};
+		} catch {
+			window.location.href = options.initialState.url;
+			return;
+		}
+		const tree = await buildRouteTree(initialMatch, state);
+		if (tree) if (initialMatch.route.render === "spa") render(tree, root);
+		else hydrate(tree, root);
+	}
+	document.addEventListener("click", (e) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+		if (e.defaultPrevented) return;
+		if (e.button !== 0) return;
+		const target = anchor.getAttribute("target");
+		if (target && target !== "_self") return;
+		if (anchor.hasAttribute("download")) return;
+		const href = anchor.getAttribute("href");
+		if (!href || href.startsWith("#")) return;
+		let url;
+		try {
+			url = new URL(href, window.location.origin);
+		} catch {
+			return;
+		}
+		if (url.origin !== window.location.origin) return;
+		e.preventDefault();
+		navigate(url.pathname + url.search);
+	});
+	window.addEventListener("popstate", () => {
+		navigate(window.location.pathname + window.location.search, { _popstate: true });
+	});
+	window.__PRACHT_NAVIGATE__ = navigate;
+	window.__PRACHT_ROUTER_READY__ = true;
+	setupPrefetching(app);
+}
+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);
+	}
+	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;
+	return result;
+}
+//#endregion
+//#region src/types.ts
+var PrachtHttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "PrachtHttpError";
+		this.status = status;
+	}
+};
+//#endregion
+export { Form, PrachtHttpError, PrachtRuntimeProvider, Suspense, applyDefaultSecurityHeaders, buildPathFromSegments, defineApp, group, handlePrachtRequest, initClientRouter, lazy, matchApiRoute, matchAppRoute, prerenderApp, readHydrationState, resolveApiRoutes, resolveApp, route, startApp, timeRevalidate, useLocation, useNavigate, useParams, useRevalidate, useRevalidateRoute, useRouteData };