@pracht/core 0.7.0 → 0.8.0

package/dist/router-B7J4YYwg.mjs

@@ -0,0 +1,418 @@
+import { o as matchAppRoute, t as buildHref } from "./app-BvC1uQG5.mjs";
+import { i as getCachedRouteState, l as parseSafeNavigationUrl, s as fetchPrachtRouteState, u as routeNeedsServerFetch } from "./prefetch-cache-DzP2Bj9H.mjs";
+import { s as deserializeRouteError, t as PrachtRuntimeProvider } from "./runtime-context-B5pREhcM.mjs";
+import { createContext, h, hydrate, options, render } from "preact";
+import { useContext, useEffect, useMemo, useState } from "preact/hooks";
+import { Suspense } from "preact-suspense";
+//#region src/hydration.ts
+const MODE_HYDRATE = 32;
+let _hydrating = false;
+let _suspensionCount = 0;
+let _hydrated = false;
+new Suspense({});
+const oldCatchError = options.__e;
+options.__e = (err, newVNode, oldVNode, errorInfo) => {
+	if (_hydrating && !_hydrated && err && err.then) {
+		if (!!(newVNode && newVNode.__u && newVNode.__u & MODE_HYDRATE) || !!(newVNode && newVNode.__h)) {
+			_suspensionCount++;
+			let settled = false;
+			const onSettled = () => {
+				if (settled) return;
+				settled = true;
+				_suspensionCount--;
+			};
+			err.then(onSettled, onSettled);
+		}
+	}
+	if (oldCatchError) oldCatchError(err, newVNode, oldVNode, errorInfo);
+};
+const oldCommit = options.__c;
+options.__c = (vnode, commitQueue) => {
+	if (_hydrating && !_hydrated && _suspensionCount <= 0) {
+		_hydrated = true;
+		_hydrating = false;
+	}
+	if (oldCommit) oldCommit(vnode, commitQueue);
+};
+/**
+* Mark the start of a hydration pass. Call this right before `hydrate()`.
+*/
+function markHydrating() {
+	if (!_hydrated) _hydrating = true;
+}
+/**
+* Returns `true` once the initial hydration (including all Suspense
+* boundaries) has fully resolved. During SSR and hydration this returns
+* `false`.
+*/
+function useIsHydrated() {
+	const [hydrated, setHydrated] = useState(_hydrated);
+	useEffect(() => {
+		setHydrated(true);
+	}, []);
+	return hydrated;
+}
+//#endregion
+//#region src/hydration-mismatch.ts
+const HYDRATION_BANNER_ID = "__pracht_hydration_mismatch__";
+let installed = false;
+function installHydrationMismatchWarning() {
+	if (installed) return;
+	installed = true;
+	const prev = options.__m;
+	options.__m = function(vnode) {
+		appendHydrationWarning(vnode);
+		if (prev) prev(vnode);
+	};
+}
+function appendHydrationWarning(vnode) {
+	if (typeof document === "undefined") return;
+	const componentName = getVNodeName(vnode);
+	let banner = document.getElementById(HYDRATION_BANNER_ID);
+	const message = `Hydration mismatch detected on <${componentName}>. The server-rendered HTML did not match the client.`;
+	if (banner) {
+		const list = banner.querySelector(`[data-pracht-mismatch-list]`);
+		if (list) {
+			const item = document.createElement("li");
+			item.textContent = message;
+			list.appendChild(item);
+		}
+		return;
+	}
+	banner = document.createElement("div");
+	banner.id = HYDRATION_BANNER_ID;
+	banner.setAttribute("role", "alert");
+	banner.style.cssText = [
+		"position:fixed",
+		"top:0",
+		"left:0",
+		"right:0",
+		"z-index:2147483647",
+		"background:#1a1a2e",
+		"color:#ff6b6b",
+		"padding:12px 16px",
+		"font:12px/1.5 ui-monospace,Menlo,Consolas,monospace",
+		"border-bottom:2px solid #e74c3c",
+		"box-shadow:0 2px 8px rgba(0,0,0,0.3)"
+	].join(";");
+	const title = document.createElement("strong");
+	title.textContent = "pracht: hydration mismatch";
+	title.style.cssText = "display:block;margin-bottom:4px;color:#fff";
+	banner.appendChild(title);
+	const list = document.createElement("ul");
+	list.setAttribute("data-pracht-mismatch-list", "");
+	list.style.cssText = "margin:0;padding-left:18px";
+	const item = document.createElement("li");
+	item.textContent = message;
+	list.appendChild(item);
+	banner.appendChild(list);
+	document.body.appendChild(banner);
+}
+function getVNodeName(vnode) {
+	if (!vnode) return "Unknown";
+	const type = vnode.type;
+	if (typeof type === "string") return type;
+	if (typeof type === "function") {
+		const fn = type;
+		return fn.displayName || fn.name || "Component";
+	}
+	return "Unknown";
+}
+//#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;
+	if (import.meta.env?.DEV) installHydrationMismatchWarning();
+	const moduleCache = /* @__PURE__ */ new Map();
+	function loadModule(modules, key) {
+		let cached = moduleCache.get(key);
+		if (!cached) {
+			cached = modules[key]();
+			moduleCache.set(key, cached);
+		}
+		return cached;
+	}
+	function startRouteImport(match) {
+		const routeKey = findModuleKey(routeModules, match.route.file);
+		if (!routeKey) return null;
+		return loadModule(routeModules, routeKey);
+	}
+	function startShellImport(match) {
+		if (!match.route.shellFile) return null;
+		const shellKey = findModuleKey(shellModules, match.route.shellFile);
+		if (!shellKey) return null;
+		return loadModule(shellModules, shellKey);
+	}
+	let updateRouteState = null;
+	let routeStateVersion = 0;
+	let latestNavigationId = 0;
+	let activeNavigationAbort = null;
+	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,
+			routes: app.routes,
+			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;
+		const resolvedShell = await (shellModPromise ?? startShellImport(match));
+		if (resolvedShell) Shell = resolvedShell.Shell;
+		const DefaultComponent = typeof routeMod.default === "function" ? routeMod.default : void 0;
+		const ErrorBoundary = routeMod.ErrorBoundary ?? resolvedShell?.ErrorBoundary;
+		const Component = state.error ? ErrorBoundary : routeMod.Component ?? DefaultComponent;
+		if (!Component) return null;
+		const componentProps = state.error ? { error: deserializeRouteError(state.error) } : {
+			data: state.data,
+			params: match.params
+		};
+		return {
+			Shell,
+			Component,
+			componentProps,
+			data: state.data,
+			params: match.params,
+			routeId: match.route.id ?? "",
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
+	}
+	async function resolveSpaPendingState(match, currentUrl, shellModPromise) {
+		const resolvedShell = await (shellModPromise ?? startShellImport(match));
+		if (!resolvedShell) return null;
+		const Shell = resolvedShell.Shell ?? null;
+		const Loading = resolvedShell.Loading;
+		if (!Shell && !Loading) return null;
+		return {
+			Shell,
+			Component: Loading ?? (() => null),
+			componentProps: {},
+			data: void 0,
+			params: match.params,
+			routeId: match.route.id ?? "",
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
+	}
+	function resolveRedirectTarget(location) {
+		const targetUrl = parseSafeNavigationUrl(location, window.location.href);
+		if (!targetUrl) return {
+			isCurrentLocation: false,
+			unsafe: true
+		};
+		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 navigationId = ++latestNavigationId;
+		activeNavigationAbort?.abort();
+		const abortController = new AbortController();
+		activeNavigationAbort = abortController;
+		const navigationTarget = typeof to === "string" ? to : buildHref(app.routes, to.route, to);
+		const target = resolveBrowserRouteTarget(navigationTarget);
+		if (!target) {
+			window.location.href = navigationTarget;
+			return;
+		}
+		const match = matchAppRoute(app, target.pathname);
+		if (!match) {
+			window.location.href = target.browserUrl;
+			return;
+		}
+		let statePromise;
+		if (routeNeedsServerFetch(match.route)) statePromise = getCachedRouteState(target.requestUrl) ?? fetchPrachtRouteState(target.requestUrl, { signal: abortController.signal });
+		else statePromise = Promise.resolve({
+			type: "data",
+			data: void 0
+		});
+		const routeModPromise = startRouteImport(match);
+		const shellModPromise = startShellImport(match);
+		let state = {
+			data: void 0,
+			error: null
+		};
+		try {
+			const result = await statePromise;
+			if (navigationId !== latestNavigationId) return;
+			if (result.type === "redirect") {
+				if (result.location) {
+					const redirect = resolveRedirectTarget(result.location);
+					if (redirect.unsafe) {
+						console.error(`[pracht] refused to navigate to unsafe URL: ${result.location}`);
+						return;
+					}
+					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 = target.browserUrl;
+					return;
+				}
+				window.location.href = target.browserUrl;
+				return;
+			}
+			if (result.type === "error") state = {
+				data: void 0,
+				error: result.error
+			};
+			else state = {
+				data: result.data,
+				error: null
+			};
+		} catch {
+			if (abortController.signal.aborted || navigationId !== latestNavigationId) return;
+			window.location.href = target.browserUrl;
+			return;
+		}
+		if (navigationId !== latestNavigationId) return;
+		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 (navigationId !== latestNavigationId) return;
+		if (routeState) {
+			applyRouteState(routeState);
+			window.scrollTo(0, 0);
+		} else window.location.href = target.browserUrl;
+	}
+	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 = {
+			data: options.initialState.data,
+			error: options.initialState.error ?? null
+		};
+		if (initialMatch.route.render === "spa" && options.initialState.pending) {
+			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") {
+					const safeRedirect = parseSafeNavigationUrl(result.location, window.location.href);
+					if (!safeRedirect) {
+						console.error(`[pracht] refused to navigate to unsafe URL: ${result.location}`);
+						return;
+					}
+					window.location.href = safeRedirect.toString();
+					return;
+				}
+				if (result.type === "error") state = {
+					data: void 0,
+					error: result.error
+				};
+				else state = {
+					data: result.data,
+					error: null
+				};
+			} catch {
+				window.location.href = initialBrowserUrl;
+				return;
+			}
+			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) => {
+		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 + url.hash);
+	});
+	window.addEventListener("popstate", () => {
+		navigate(window.location.pathname + window.location.search + window.location.hash, { _popstate: true });
+	});
+	window.__PRACHT_NAVIGATE__ = navigate;
+	window.__PRACHT_ROUTER_READY__ = true;
+	const warmModules = (match) => {
+		startRouteImport(match);
+		startShellImport(match);
+	};
+	import("./prefetch-B50kX9RL.mjs").then(({ setupPrefetching }) => {
+		setupPrefetching(app, warmModules);
+	});
+}
+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;
+	}
+}
+//#endregion
+export { useNavigate as n, useIsHydrated as r, initClientRouter as t };

package/dist/router-BcUmg1kB.d.mts

@@ -0,0 +1,27 @@
+import { U as NavigateOptions, Z as ResolvedPrachtApp, dt as RouteTarget, nt as RouteId } from "./app-BWriseLj.mjs";
+import { t as PrachtHydrationState } from "./runtime-context-ytVd7GmZ.mjs";
+
+//#region src/router.d.ts
+declare global {
+  interface Window {
+    __PRACHT_NAVIGATE__?: NavigateFn;
+    __PRACHT_ROUTER_READY__?: boolean;
+  }
+}
+type ModuleMap = Record<string, () => Promise<unknown>>;
+interface NavigateFn {
+  (to: string, options?: NavigateOptions): Promise<void>;
+  <TRoute extends RouteId>(to: RouteTarget<TRoute>, options?: NavigateOptions): Promise<void>;
+}
+declare function useNavigate(): NavigateFn;
+interface InitClientRouterOptions {
+  app: ResolvedPrachtApp;
+  routeModules: ModuleMap;
+  shellModules: ModuleMap;
+  initialState: PrachtHydrationState;
+  root: HTMLElement;
+  findModuleKey: (modules: ModuleMap, file: string) => string | null;
+}
+declare function initClientRouter(options: InitClientRouterOptions): Promise<void>;
+//#endregion
+export { useNavigate as i, NavigateFn as n, initClientRouter as r, InitClientRouterOptions as t };

package/dist/runtime-context-B5pREhcM.mjs

@@ -0,0 +1,164 @@
+import { d as EMPTY_ROUTE_PARAMS, f as HYDRATION_STATE_ELEMENT_ID } from "./prefetch-cache-DzP2Bj9H.mjs";
+import { createContext, h } from "preact";
+import { useEffect, useMemo, useState } from "preact/hooks";
+//#region src/runtime-errors.ts
+function isPrachtHttpError(error) {
+	return error instanceof Error && error.name === "PrachtHttpError" && "status" in error;
+}
+let warnedAboutProductionDebugErrors = false;
+/**
+* `debugErrors: true` opts into surfacing stack traces, module paths,
+* and middleware names in error responses. That is great in dev and
+* dangerous in production — a misconfigured deploy would leak internals
+* to the public. When `NODE_ENV === "production"` we refuse to honor
+* the flag and emit a single console warning so the misconfiguration
+* is visible in logs.
+*/
+function shouldExposeServerErrors(options) {
+	if (options.debugErrors !== true) return false;
+	if ((typeof process !== "undefined" && process.env ? process.env.NODE_ENV : typeof globalThis !== "undefined" && globalThis.process ? globalThis.process?.env?.NODE_ENV : void 0) === "production") {
+		if (!warnedAboutProductionDebugErrors) {
+			warnedAboutProductionDebugErrors = true;
+			console.warn("[pracht] debugErrors is ignored in production builds. Remove it to silence this warning.");
+		}
+		return false;
+	}
+	return true;
+}
+function createSerializedRouteError(message, status, options = {}) {
+	return {
+		message,
+		name: options.name ?? "Error",
+		status,
+		...options.diagnostics ? { diagnostics: options.diagnostics } : {}
+	};
+}
+function buildRuntimeDiagnostics(options) {
+	const route = options.route;
+	const routeId = route && "id" in route ? route.id : void 0;
+	return {
+		phase: options.phase,
+		routeId,
+		routePath: route?.path,
+		routeFile: route?.file,
+		loaderFile: options.loaderFile,
+		shellFile: options.shellFile,
+		middlewareFiles: options.middlewareFiles ? [...options.middlewareFiles] : [],
+		status: options.status
+	};
+}
+function normalizeRouteError(error, options) {
+	if (isPrachtHttpError(error)) {
+		const status = typeof error.status === "number" ? error.status : 500;
+		if (status >= 400 && status < 500) return {
+			message: error.message,
+			name: error.name,
+			status
+		};
+		if (options.exposeDetails) return {
+			message: error.message || "Internal Server Error",
+			name: error.name || "Error",
+			status
+		};
+		return {
+			message: "Internal Server Error",
+			name: "Error",
+			status
+		};
+	}
+	if (error instanceof Error) {
+		if (options.exposeDetails) return {
+			message: error.message || "Internal Server Error",
+			name: error.name || "Error",
+			status: 500
+		};
+		return {
+			message: "Internal Server Error",
+			name: "Error",
+			status: 500
+		};
+	}
+	if (options.exposeDetails) return {
+		message: typeof error === "string" && error ? error : "Internal Server Error",
+		name: "Error",
+		status: 500
+	};
+	return {
+		message: "Internal Server Error",
+		name: "Error",
+		status: 500
+	};
+}
+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/runtime-context.ts
+const RouteDataContext = createContext(void 0);
+function PrachtRuntimeProvider({ children, data, params = EMPTY_ROUTE_PARAMS, routeId, routes, stateVersion = 0, url }) {
+	registerRuntimeRoutes(routes);
+	const [routeDataState, setRouteDataState] = useState({
+		data,
+		stateVersion
+	});
+	const routeData = routeDataState.stateVersion === stateVersion ? routeDataState.data : data;
+	useEffect(() => {
+		setRouteDataState({
+			data,
+			stateVersion
+		});
+	}, [
+		data,
+		routeId,
+		stateVersion,
+		url
+	]);
+	const context = useMemo(() => ({
+		data: routeData,
+		params,
+		routeId,
+		routes,
+		setData: (nextData) => setRouteDataState({
+			data: nextData,
+			stateVersion
+		}),
+		url
+	}), [
+		routeData,
+		params,
+		routeId,
+		routes,
+		stateVersion,
+		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;
+	const state = JSON.parse(raw);
+	window.__PRACHT_STATE__ = state;
+	return state;
+}
+function registerRuntimeRoutes(routes) {
+	if (!routes) return;
+	globalThis.__PRACHT_ROUTE_DEFINITIONS__ = routes;
+}
+//#endregion
+export { buildRuntimeDiagnostics as a, normalizeRouteError as c, startApp as i, shouldExposeServerErrors as l, RouteDataContext as n, createSerializedRouteError as o, readHydrationState as r, deserializeRouteError as s, PrachtRuntimeProvider as t };

package/dist/runtime-context-ytVd7GmZ.d.mts

@@ -0,0 +1,72 @@
+import { A as HrefRouteDefinition, st as RouteParams } from "./app-BWriseLj.mjs";
+import * as _$preact from "preact";
+import { ComponentChildren } from "preact";
+
+//#region src/runtime-errors.d.ts
+type PrachtRuntimeDiagnosticPhase = "match" | "middleware" | "loader" | "action" | "render" | "api";
+interface PrachtRuntimeDiagnostics {
+  phase: PrachtRuntimeDiagnosticPhase;
+  routeId?: string;
+  routePath?: string;
+  routeFile?: string;
+  loaderFile?: string;
+  shellFile?: string;
+  middlewareFiles?: string[];
+  status: number;
+}
+interface SerializedRouteError {
+  message: string;
+  name: string;
+  status: number;
+  diagnostics?: PrachtRuntimeDiagnostics;
+}
+//#endregion
+//#region src/runtime-context.d.ts
+interface PrachtHydrationState<TData = unknown> {
+  url: string;
+  routeId: string;
+  data: TData;
+  error?: SerializedRouteError | null;
+  pending?: boolean;
+}
+interface StartAppOptions<TData = unknown> {
+  initialData?: TData;
+}
+declare global {
+  var __PRACHT_ROUTE_DEFINITIONS__: readonly HrefRouteDefinition[] | undefined;
+  interface Window {
+    __PRACHT_STATE__?: PrachtHydrationState;
+  }
+}
+interface PrachtRuntimeValue {
+  data: unknown;
+  params: RouteParams;
+  routeId: string;
+  routes?: readonly HrefRouteDefinition[];
+  url: string;
+  setData: (data: unknown) => void;
+}
+declare function PrachtRuntimeProvider<TData>({
+  children,
+  data,
+  params,
+  routeId,
+  routes,
+  stateVersion,
+  url
+}: {
+  children: ComponentChildren;
+  data: TData;
+  params?: RouteParams;
+  routeId: string;
+  routes?: readonly HrefRouteDefinition[];
+  stateVersion?: number;
+  url: string;
+}): _$preact.VNode<_$preact.Attributes & {
+  value: PrachtRuntimeValue | undefined;
+  children?: ComponentChildren;
+}>;
+declare function startApp<TData = unknown>(options?: StartAppOptions<TData>): TData | undefined;
+declare function readHydrationState<TData = unknown>(): PrachtHydrationState<TData> | undefined;
+//#endregion
+export { startApp as a, SerializedRouteError as c, readHydrationState as i, PrachtRuntimeProvider as n, PrachtRuntimeDiagnosticPhase as o, StartAppOptions as r, PrachtRuntimeDiagnostics as s, PrachtHydrationState as t };