litzjs 0.0.0

package/dist/client.js

@@ -0,0 +1,1633 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_bindings = require("./bindings-B1P6pL93.js");
+const require_internal_transport = require("./internal-transport-DR0r68ff.js");
+let react = require("react");
+react = require_chunk.__toESM(react);
+let virtual_litzjs_route_manifest = require("virtual:litzjs:route-manifest");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/client/navigation.ts
+function isHashOnlyNavigation(currentUrl, nextUrl) {
+	return currentUrl.origin === nextUrl.origin && currentUrl.pathname === nextUrl.pathname && currentUrl.search === nextUrl.search && currentUrl.hash !== nextUrl.hash;
+}
+function shouldInterceptLinkNavigation(options) {
+	if (options.button !== 0 || options.metaKey || options.altKey || options.ctrlKey || options.shiftKey) return false;
+	if (options.target && options.target !== "_self") return false;
+	if (options.download) return false;
+	if (options.nextUrl.origin !== options.currentUrl.origin) return false;
+	if (isHashOnlyNavigation(options.currentUrl, options.nextUrl)) return false;
+	return true;
+}
+function toNavigationHref(url) {
+	return url.pathname + url.search + url.hash;
+}
+function shouldPrefetchLink(options) {
+	return shouldInterceptLinkNavigation({
+		button: 0,
+		metaKey: false,
+		altKey: false,
+		ctrlKey: false,
+		shiftKey: false,
+		target: options.target,
+		download: options.download,
+		currentUrl: options.currentUrl,
+		nextUrl: options.nextUrl
+	});
+}
+function applySearchParams(currentUrl, updates) {
+	const nextUrl = new URL(currentUrl.href);
+	const nextSearch = new URLSearchParams(currentUrl.search);
+	for (const [key, value] of Object.entries(updates)) {
+		nextSearch.delete(key);
+		if (value == null) continue;
+		if (Array.isArray(value)) {
+			for (const entry of value) nextSearch.append(key, entry);
+			continue;
+		}
+		nextSearch.set(key, value);
+	}
+	nextUrl.search = nextSearch.toString();
+	return {
+		changed: nextUrl.search !== currentUrl.search,
+		href: toNavigationHref(nextUrl)
+	};
+}
+//#endregion
+//#region src/client/link.tsx
+function createLinkComponent(dependencies) {
+	return function LitzLink(props) {
+		const navigate = dependencies.useNavigate();
+		const { href, replace = false, onClick, onMouseEnter, onFocus, onTouchStart, target, download, rel, ...rest } = props;
+		return react.createElement("a", {
+			...rest,
+			href,
+			target,
+			download,
+			rel,
+			onMouseEnter(event) {
+				onMouseEnter?.(event);
+				if (event.defaultPrevented) return;
+				dependencies.prefetchRouteModuleForHref(href, target, download);
+			},
+			onFocus(event) {
+				onFocus?.(event);
+				if (event.defaultPrevented) return;
+				dependencies.prefetchRouteModuleForHref(href, target, download);
+			},
+			onTouchStart(event) {
+				onTouchStart?.(event);
+				if (event.defaultPrevented) return;
+				dependencies.prefetchRouteModuleForHref(href, target, download);
+			},
+			onClick(event) {
+				onClick?.(event);
+				if (event.defaultPrevented) return;
+				const nextUrl = new URL(href, window.location.href);
+				const currentUrl = new URL(window.location.href);
+				if (!shouldInterceptLinkNavigation({
+					button: event.button,
+					metaKey: event.metaKey,
+					altKey: event.altKey,
+					ctrlKey: event.ctrlKey,
+					shiftKey: event.shiftKey,
+					target,
+					download,
+					currentUrl,
+					nextUrl
+				})) return;
+				event.preventDefault();
+				navigate(toNavigationHref(nextUrl), { replace });
+			}
+		});
+	};
+}
+//#endregion
+//#region src/client/result-headers.ts
+const PUBLIC_RESULT_HEADER_NAMES = new Set([
+	"content-type",
+	"x-litzjs-kind",
+	"x-litzjs-revalidate",
+	"x-litzjs-status",
+	"x-litzjs-view-id"
+]);
+function createPublicResultHeaders(headers) {
+	const publicHeaders = new Headers();
+	headers.forEach((value, key) => {
+		const normalizedKey = key.toLowerCase();
+		if (PUBLIC_RESULT_HEADER_NAMES.has(normalizedKey) || normalizedKey.startsWith("x-litzjs-public-")) publicHeaders.append(key, value);
+	});
+	return publicHeaders;
+}
+//#endregion
+//#region src/client/transport.tsx
+async function parseLoaderResponse(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	const publicHeaders = createPublicResultHeaders(response.headers);
+	if (contentType.includes("text/x-component")) return createViewResult(response, publicHeaders);
+	const body = await response.json();
+	if (body.kind === "data") return {
+		kind: "data",
+		status: response.status,
+		headers: publicHeaders,
+		stale: false,
+		data: body.data,
+		render() {
+			return null;
+		}
+	};
+	if (body.kind === "error") throw createRouteLikeError(response.status, publicHeaders, body);
+	if (body.kind === "fault") throw createRouteLikeError(response.status, publicHeaders, body);
+	if (body.kind === "redirect") throw createRedirectSignal(response.status, publicHeaders, body);
+	throw new Error(`Unsupported loader response kind "${body.kind}".`);
+}
+async function parseActionResponse(response) {
+	const contentType = response.headers.get("content-type") ?? "";
+	const publicHeaders = createPublicResultHeaders(response.headers);
+	if (contentType.includes("text/x-component")) return createViewResult(response, publicHeaders);
+	const body = await response.json();
+	switch (body.kind) {
+		case "data": return {
+			kind: "data",
+			status: response.status,
+			headers: publicHeaders,
+			data: body.data
+		};
+		case "invalid": return {
+			kind: "invalid",
+			status: response.status,
+			headers: publicHeaders,
+			fields: body.fields,
+			formError: body.formError,
+			data: body.data
+		};
+		case "redirect": return {
+			kind: "redirect",
+			status: response.status,
+			headers: publicHeaders,
+			location: body.location,
+			replace: body.replace ?? false
+		};
+		case "error": return {
+			kind: "error",
+			status: response.status,
+			headers: publicHeaders,
+			message: body.message,
+			code: body.code,
+			data: body.data
+		};
+		case "fault": return {
+			kind: "fault",
+			status: response.status,
+			headers: publicHeaders,
+			message: body.message,
+			digest: body.digest
+		};
+		default: throw new Error(`Unsupported action response kind "${String(body.kind)}".`);
+	}
+}
+async function createViewResult(response, publicHeaders = createPublicResultHeaders(response.headers)) {
+	if (!response.body) throw new Error("Flight response body is missing.");
+	const { createFromReadableStream } = await import("@vitejs/plugin-rsc/browser");
+	const node = await createFromReadableStream(response.body);
+	return {
+		kind: "view",
+		status: Number(response.headers.get("x-litz-status") ?? response.status),
+		headers: publicHeaders,
+		stale: false,
+		node,
+		render() {
+			return node;
+		}
+	};
+}
+function isRouteLikeError(value) {
+	return typeof value === "object" && value !== null && "kind" in value && (value.kind === "error" || value.kind === "fault");
+}
+function isRedirectSignal(value) {
+	return typeof value === "object" && value !== null && "kind" in value && value.kind === "redirect";
+}
+function getRevalidateTargets(headers) {
+	const value = headers.get("x-litz-revalidate");
+	if (!value) return [];
+	return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function createRouteLikeError(status, headers, body) {
+	return {
+		kind: body.kind,
+		status,
+		headers,
+		message: body.message,
+		code: "code" in body ? body.code : void 0,
+		digest: "digest" in body ? body.digest : void 0,
+		data: "data" in body ? body.data : void 0
+	};
+}
+function createRedirectSignal(status, headers, body) {
+	return {
+		kind: "redirect",
+		status,
+		headers,
+		location: body.location,
+		replace: body.replace ?? false
+	};
+}
+//#endregion
+//#region src/client/resources.tsx
+const RESOURCE_STORE_LIMIT = 200;
+const resourceStore = /* @__PURE__ */ new Map();
+const resourceFormComponentCache = /* @__PURE__ */ new Map();
+const resourceComponentCache = /* @__PURE__ */ new Map();
+let resourceLocationContext = null;
+let resourceStatusContext = null;
+let resourceDataContext = null;
+let resourceActionsContext = null;
+function createRuntimeContext$1(name) {
+	const createContext = react.createContext;
+	if (!createContext) throw new Error(`${name} is not available in this environment.`);
+	return createContext(null);
+}
+function getResourceLocationContext() {
+	resourceLocationContext ??= createRuntimeContext$1("Litz resource location");
+	return resourceLocationContext;
+}
+function getResourceStatusContext() {
+	resourceStatusContext ??= createRuntimeContext$1("Litz resource status");
+	return resourceStatusContext;
+}
+function getResourceDataContext() {
+	resourceDataContext ??= createRuntimeContext$1("Litz resource data");
+	return resourceDataContext;
+}
+function getResourceActionsContext() {
+	resourceActionsContext ??= createRuntimeContext$1("Litz resource actions");
+	return resourceActionsContext;
+}
+function requireActiveResourceSlice(resourcePath, value) {
+	if (!value) throw new Error(`Resource "${resourcePath}" is being used outside its resource component.`);
+	if (value.id !== resourcePath) throw new Error(`Resource "${resourcePath}" is not the active resource. Active resource is "${value.id}".`);
+	return value;
+}
+function ResourceRuntimeProvider(props) {
+	const ResourceLocationContext = getResourceLocationContext();
+	const ResourceStatusContext = getResourceStatusContext();
+	const ResourceDataContext = getResourceDataContext();
+	const ResourceActionsContext = getResourceActionsContext();
+	const locationValue = react.useMemo(() => ({
+		id: props.value.id,
+		params: props.value.params,
+		search: props.value.search,
+		setSearch: props.value.setSearch
+	}), [
+		props.value.id,
+		props.value.params,
+		props.value.search,
+		props.value.setSearch
+	]);
+	const statusValue = react.useMemo(() => ({
+		id: props.value.id,
+		status: props.value.status,
+		pending: props.value.pending
+	}), [
+		props.value.id,
+		props.value.pending,
+		props.value.status
+	]);
+	const dataValue = react.useMemo(() => ({
+		id: props.value.id,
+		loaderResult: props.value.loaderResult,
+		actionResult: props.value.actionResult,
+		data: props.value.data,
+		view: props.value.view
+	}), [
+		props.value.actionResult,
+		props.value.data,
+		props.value.id,
+		props.value.loaderResult,
+		props.value.view
+	]);
+	const actionsValue = react.useMemo(() => ({
+		id: props.value.id,
+		submit: props.value.submit,
+		reload: props.value.reload,
+		retry: props.value.retry
+	}), [
+		props.value.id,
+		props.value.reload,
+		props.value.retry,
+		props.value.submit
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResourceLocationContext.Provider, {
+		value: locationValue,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResourceStatusContext.Provider, {
+			value: statusValue,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResourceDataContext.Provider, {
+				value: dataValue,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResourceActionsContext.Provider, {
+					value: actionsValue,
+					children: props.children
+				})
+			})
+		})
+	});
+}
+function useRequiredResourceLocation(resourcePath) {
+	return requireActiveResourceSlice(resourcePath, react.useContext(getResourceLocationContext()));
+}
+function useRequiredResourceStatus(resourcePath) {
+	return requireActiveResourceSlice(resourcePath, react.useContext(getResourceStatusContext()));
+}
+function useRequiredResourceData(resourcePath) {
+	return requireActiveResourceSlice(resourcePath, react.useContext(getResourceDataContext()));
+}
+function useRequiredResourceActions(resourcePath) {
+	return requireActiveResourceSlice(resourcePath, react.useContext(getResourceActionsContext()));
+}
+function createResourceFormComponent(resourcePath) {
+	const cached = resourceFormComponentCache.get(resourcePath);
+	if (cached) return cached;
+	const MemoizedLitzResourceForm = react.memo(function LitzResourceForm(props) {
+		const actions = useRequiredResourceActions(resourcePath);
+		const { children, onSubmit, replace, revalidate, ...rest } = props;
+		const submitRef = react.useRef((payload, options) => actions.submit(payload, options));
+		react.useEffect(() => {
+			submitRef.current = (payload, options) => actions.submit(payload, options);
+		}, [actions.submit]);
+		const action = react.useCallback(async (formData) => {
+			await submitRef.current(formData, {
+				replace,
+				revalidate
+			});
+		}, [replace, revalidate]);
+		return react.createElement("form", {
+			...rest,
+			action,
+			onSubmit
+		}, children);
+	});
+	MemoizedLitzResourceForm.displayName = `LitzResourceForm(${resourcePath})`;
+	resourceFormComponentCache.set(resourcePath, MemoizedLitzResourceForm);
+	return MemoizedLitzResourceForm;
+}
+function createResourceComponent(resourcePath, Component) {
+	const cached = resourceComponentCache.get(resourcePath);
+	if (cached) return cached;
+	const MemoizedLitzResourceComponent = react.memo(function LitzResourceComponent(props) {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResourceRuntimeProvider, {
+			value: useResourceRuntime(resourcePath, props),
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, { ...props })
+		});
+	});
+	MemoizedLitzResourceComponent.displayName = `LitzResource(${resourcePath})`;
+	resourceComponentCache.set(resourcePath, MemoizedLitzResourceComponent);
+	return MemoizedLitzResourceComponent;
+}
+function useResourceRuntime(resourcePath, request) {
+	const params = react.useMemo(() => request?.params ?? {}, [request?.params]);
+	const incomingSearchKey = react.useMemo(() => createUrlSearchParams(request?.search).toString(), [request?.search]);
+	const [searchState, setSearchState] = react.useState(() => createUrlSearchParams(request?.search));
+	react.useEffect(() => {
+		setSearchState((current) => current.toString() === incomingSearchKey ? current : createUrlSearchParams(request?.search));
+	}, [incomingSearchKey, request?.search]);
+	const preparedRequest = react.useMemo(() => prepareResourceRequest(resourcePath, {
+		params,
+		search: searchState
+	}), [
+		params,
+		resourcePath,
+		searchState
+	]);
+	const snapshot = react.useSyncExternalStore(react.useCallback((listener) => subscribe(preparedRequest.key, listener), [preparedRequest.key]), react.useCallback(() => getEntry(preparedRequest.key).snapshot, [preparedRequest.key]), react.useCallback(() => getEntry(preparedRequest.key).snapshot, [preparedRequest.key]));
+	const reloadImpl = react.useCallback(async (mode = "loading") => {
+		await performPreparedResourceRequest(resourcePath, "loader", preparedRequest, void 0, mode);
+	}, [preparedRequest, resourcePath]);
+	react.useEffect(() => {
+		if (!snapshot.pending && !snapshot.loaderResult && !snapshot.failure) reloadImpl("loading");
+	}, [
+		reloadImpl,
+		snapshot.failure,
+		snapshot.loaderResult,
+		snapshot.pending
+	]);
+	const setSearch = react.useCallback((updates) => {
+		const result = applySearchParams(new URL(`https://litz.local/?${searchState.toString()}`), updates);
+		if (!result.changed) return;
+		const nextUrl = new URL(result.href);
+		react.startTransition(() => {
+			setSearchState(new URLSearchParams(nextUrl.search));
+		});
+	}, [searchState]);
+	const submit = react.useCallback(async (payload, options) => {
+		const formData = require_internal_transport.createFormDataPayload(payload);
+		options?.onBeforeSubmit?.(formData);
+		const result = await performPreparedResourceRequest(resourcePath, "action", preparedRequest, formData, "submitting");
+		if (!result || !("kind" in result)) return;
+		if (result.kind === "error" || result.kind === "fault") {
+			options?.onError?.(result);
+			return;
+		}
+		options?.onSuccess?.(result);
+	}, [preparedRequest, resourcePath]);
+	const reload = react.useCallback(() => {
+		reloadImpl(snapshot.loaderResult ? "revalidating" : "loading");
+	}, [reloadImpl, snapshot.loaderResult]);
+	const retry = react.useCallback(() => {
+		reloadImpl(snapshot.loaderResult ? "revalidating" : "loading");
+	}, [reloadImpl, snapshot.loaderResult]);
+	if (snapshot.failure) throw snapshot.failure;
+	return react.useMemo(() => ({
+		id: resourcePath,
+		params,
+		search: searchState,
+		setSearch,
+		status: snapshot.status,
+		pending: snapshot.pending,
+		loaderResult: snapshot.loaderResult,
+		actionResult: snapshot.actionResult,
+		data: snapshot.data,
+		view: snapshot.view,
+		submit,
+		reload,
+		retry
+	}), [
+		params,
+		reload,
+		resourcePath,
+		retry,
+		searchState,
+		setSearch,
+		snapshot.actionResult,
+		snapshot.data,
+		snapshot.loaderResult,
+		snapshot.pending,
+		snapshot.status,
+		snapshot.view,
+		submit
+	]);
+}
+async function performPreparedResourceRequest(resourcePath, operation, preparedRequest, payload, mode = "loading") {
+	const { key, normalizedRequest } = preparedRequest;
+	const entry = getEntry(key);
+	if (entry.inFlight) return entry.inFlight;
+	entry.snapshot = {
+		...entry.snapshot,
+		status: mode,
+		pending: true,
+		failure: void 0
+	};
+	notify(entry);
+	entry.inFlight = (async () => {
+		try {
+			const response = operation === "action" ? await fetch("/_litz/resource", {
+				method: "POST",
+				...require_internal_transport.createInternalActionRequestInit({
+					path: resourcePath,
+					operation,
+					request: {
+						params: normalizedRequest.params,
+						search: normalizedRequest.search
+					}
+				}, payload)
+			}) : await fetch("/_litz/resource", {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					accept: require_internal_transport.LITZ_RESULT_ACCEPT
+				},
+				body: JSON.stringify({
+					path: resourcePath,
+					operation,
+					request: {
+						params: normalizedRequest.params,
+						search: normalizedRequest.search
+					}
+				})
+			});
+			if (operation === "loader") {
+				const loaderResult = await parseLoaderResponse(response);
+				entry.snapshot = {
+					...entry.snapshot,
+					loaderResult,
+					data: loaderResult.kind === "data" ? loaderResult.data : null,
+					view: loaderResult.kind === "view" ? loaderResult.node : null,
+					status: "idle",
+					pending: false,
+					failure: void 0
+				};
+				return loaderResult;
+			}
+			const actionResult = await parseActionResponse(response);
+			if (actionResult.kind === "redirect") {
+				entry.snapshot = {
+					...entry.snapshot,
+					actionResult,
+					status: "idle",
+					pending: false,
+					failure: void 0
+				};
+				performClientRedirect(actionResult.location, actionResult.replace);
+				return actionResult;
+			}
+			if (actionResult.kind === "fault") {
+				entry.snapshot = {
+					...entry.snapshot,
+					actionResult,
+					status: "error",
+					pending: false,
+					failure: actionResult
+				};
+				throw actionResult;
+			}
+			entry.snapshot = {
+				...entry.snapshot,
+				actionResult,
+				data: actionResult.kind === "data" ? actionResult.data : null,
+				view: actionResult.kind === "view" ? actionResult.node : null,
+				status: actionResult.kind === "error" ? "error" : "idle",
+				pending: false,
+				failure: void 0
+			};
+			return actionResult;
+		} catch (error) {
+			if (isRedirectSignal(error)) {
+				performClientRedirect(error.location, error.replace);
+				entry.snapshot = {
+					...entry.snapshot,
+					status: "idle",
+					pending: false,
+					failure: void 0
+				};
+				return;
+			}
+			entry.snapshot = {
+				...entry.snapshot,
+				status: isRouteLikeError(error) ? "error" : "error",
+				pending: false,
+				failure: error
+			};
+			throw error;
+		} finally {
+			entry.inFlight = void 0;
+			notify(entry);
+			cleanupResourceEntry(key, entry);
+		}
+	})();
+	return entry.inFlight;
+}
+function createUrlSearchParams(search) {
+	if (!search) return new URLSearchParams();
+	if (search instanceof URLSearchParams) return new URLSearchParams(search);
+	return new URLSearchParams(search);
+}
+function normalizeResourceRequest(request) {
+	return {
+		params: request?.params ?? {},
+		search: Object.fromEntries(createUrlSearchParams(request?.search).entries())
+	};
+}
+function prepareResourceRequest(resourcePath, request) {
+	const normalizedRequest = normalizeResourceRequest(request);
+	return {
+		key: createResourceCacheKey(resourcePath, normalizedRequest),
+		normalizedRequest
+	};
+}
+function createResourceCacheKey(resourcePath, normalizedRequest) {
+	return JSON.stringify({
+		path: resourcePath,
+		params: sortRecord$1(normalizedRequest.params),
+		search: sortRecord$1(normalizedRequest.search)
+	});
+}
+function sortRecord$1(value) {
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+function subscribe(key, listener) {
+	const entry = getEntry(key);
+	entry.listeners.add(listener);
+	return () => {
+		entry.listeners.delete(listener);
+		cleanupResourceEntry(key, entry);
+	};
+}
+function getInitialSnapshot() {
+	return {
+		loaderResult: null,
+		actionResult: null,
+		data: null,
+		view: null,
+		status: "idle",
+		pending: false
+	};
+}
+function getEntry(key) {
+	let entry = resourceStore.get(key);
+	if (!entry) {
+		entry = {
+			snapshot: getInitialSnapshot(),
+			listeners: /* @__PURE__ */ new Set()
+		};
+		resourceStore.set(key, entry);
+		pruneResourceStore();
+	}
+	return entry;
+}
+function notify(entry) {
+	for (const listener of entry.listeners) listener();
+}
+function cleanupResourceEntry(key, entry) {
+	if (entry.listeners.size > 0 || entry.inFlight || entry.snapshot.pending) return;
+	resourceStore.delete(key);
+}
+function pruneResourceStore() {
+	if (resourceStore.size <= RESOURCE_STORE_LIMIT) return;
+	for (const [key, entry] of resourceStore) {
+		if (resourceStore.size <= RESOURCE_STORE_LIMIT) return;
+		cleanupResourceEntry(key, entry);
+	}
+}
+function performClientRedirect(href, replace) {
+	if (typeof window === "undefined") return;
+	if (replace) window.history.replaceState(null, "", href);
+	else window.history.pushState(null, "", href);
+	window.dispatchEvent(new PopStateEvent("popstate"));
+}
+//#endregion
+//#region src/client/route-transition.ts
+function resolveRouteModuleLoadState(options) {
+	if (!options.matched) return {
+		kind: "not-found",
+		loadedRoute: null,
+		displayLocation: options.nextLocation,
+		pageState: options.createEmptyPageState()
+	};
+	if (options.cachedRoute) return {
+		kind: "cached",
+		loadedRoute: options.cachedRoute,
+		displayLocation: options.nextLocation,
+		pageState: options.createBootstrapPageState(options.cachedRoute)
+	};
+	if (options.previousRoute) return { kind: "preserve-current" };
+	return {
+		kind: "reset-before-load",
+		loadedRoute: null,
+		displayLocation: options.nextLocation,
+		pageState: options.createEmptyPageState()
+	};
+}
+function resolveLoadedRouteState(options) {
+	return {
+		loadedRoute: options.loadedRoute,
+		displayLocation: options.nextLocation,
+		pageState: options.createBootstrapPageState(options.loadedRoute)
+	};
+}
+//#endregion
+//#region src/client/route-host-state.tsx
+function useResolvedRouteState(options) {
+	const createEmptyPageState = options.createEmptyPageState;
+	const createBootstrapPageState = options.createBootstrapPageState;
+	const getCachedRoute = options.getCachedRoute;
+	const setCachedRoute = options.setCachedRoute;
+	const [displayLocation, setDisplayLocation] = react.useState(() => options.location);
+	const [renderedRoute, setRenderedRoute] = react.useState(null);
+	const [pageState, setPageState] = react.useState(() => createEmptyPageState());
+	const renderedRouteRef = react.useRef(null);
+	react.useEffect(() => {
+		renderedRouteRef.current = renderedRoute;
+	}, [renderedRoute]);
+	react.useLayoutEffect(() => {
+		let cancelled = false;
+		async function loadRouteModule() {
+			const routeState = resolveRouteModuleLoadState({
+				matched: Boolean(options.matched),
+				cachedRoute: options.matched ? getCachedRoute(options.matched.entry.id) : null,
+				previousRoute: renderedRouteRef.current,
+				nextLocation: options.location,
+				createEmptyPageState: () => createEmptyPageState(),
+				createBootstrapPageState: (route) => createBootstrapPageState(route)
+			});
+			if (routeState.kind === "not-found") {
+				setRenderedRoute(routeState.loadedRoute);
+				setDisplayLocation(routeState.displayLocation);
+				setPageState(routeState.pageState);
+				return;
+			}
+			if (routeState.kind === "cached") {
+				setPageState(routeState.pageState);
+				setRenderedRoute(routeState.loadedRoute);
+				setDisplayLocation(routeState.displayLocation);
+				return;
+			}
+			if (routeState.kind === "reset-before-load") {
+				setRenderedRoute(routeState.loadedRoute);
+				setDisplayLocation(routeState.displayLocation);
+				setPageState(routeState.pageState);
+			}
+			const matchedEntry = options.matched?.entry;
+			if (!matchedEntry) return;
+			const loaded = await matchedEntry.load();
+			if (cancelled) return;
+			if (!loaded.route) throw new Error(`Route module "${matchedEntry.id}" does not export "route".`);
+			setCachedRoute(matchedEntry.id, loaded.route);
+			const loadedRouteState = resolveLoadedRouteState({
+				loadedRoute: loaded.route,
+				nextLocation: options.location,
+				createBootstrapPageState: (route) => createBootstrapPageState(route)
+			});
+			setPageState(loadedRouteState.pageState);
+			setRenderedRoute(loadedRouteState.loadedRoute);
+			setDisplayLocation(loadedRouteState.displayLocation);
+		}
+		loadRouteModule();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		createBootstrapPageState,
+		createEmptyPageState,
+		getCachedRoute,
+		options.location,
+		options.matched,
+		setCachedRoute
+	]);
+	return {
+		displayLocation,
+		renderedRoute,
+		pageState,
+		setPageState
+	};
+}
+//#endregion
+//#region src/client/route-runtime.tsx
+let routeLocationContext = null;
+let routeStatusContext = null;
+let routeDataContext = null;
+let routeActionsContext = null;
+const routeFormComponentCache = /* @__PURE__ */ new Map();
+function createRuntimeContext(name) {
+	const createContext = react.createContext;
+	if (!createContext) throw new Error(`${name} is not available in this environment.`);
+	return createContext(null);
+}
+function getRouteLocationContext() {
+	routeLocationContext ??= createRuntimeContext("Litz route location");
+	return routeLocationContext;
+}
+function getRouteStatusContext() {
+	routeStatusContext ??= createRuntimeContext("Litz route status");
+	return routeStatusContext;
+}
+function getRouteDataContext() {
+	routeDataContext ??= createRuntimeContext("Litz route data");
+	return routeDataContext;
+}
+function getRouteActionsContext() {
+	routeActionsContext ??= createRuntimeContext("Litz route actions");
+	return routeActionsContext;
+}
+function requireActiveRouteSlice(routeId, value) {
+	if (!value) throw new Error(`Route "${routeId}" is being used outside the Litz runtime.`);
+	if (value.id !== routeId) throw new Error(`Route "${routeId}" is not the active route. Active route is "${value.id}".`);
+	return value;
+}
+function RouteRuntimeProvider(props) {
+	const RouteLocationContext = getRouteLocationContext();
+	const RouteStatusContext = getRouteStatusContext();
+	const RouteDataContext = getRouteDataContext();
+	const RouteActionsContext = getRouteActionsContext();
+	const locationValue = react.useMemo(() => ({
+		id: props.value.id,
+		params: props.value.params,
+		search: props.value.search,
+		setSearch: props.value.setSearch
+	}), [
+		props.value.id,
+		props.value.params,
+		props.value.search,
+		props.value.setSearch
+	]);
+	const statusValue = react.useMemo(() => ({
+		id: props.value.id,
+		status: props.value.status,
+		pending: props.value.pending
+	}), [
+		props.value.id,
+		props.value.pending,
+		props.value.status
+	]);
+	const dataValue = react.useMemo(() => ({
+		id: props.value.id,
+		loaderResult: props.value.loaderResult,
+		actionResult: props.value.actionResult,
+		data: props.value.data,
+		view: props.value.view
+	}), [
+		props.value.actionResult,
+		props.value.data,
+		props.value.id,
+		props.value.loaderResult,
+		props.value.view
+	]);
+	const actionsValue = react.useMemo(() => ({
+		id: props.value.id,
+		submit: props.value.submit,
+		reload: props.value.reload,
+		retry: props.value.retry
+	}), [
+		props.value.id,
+		props.value.reload,
+		props.value.retry,
+		props.value.submit
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteLocationContext.Provider, {
+		value: locationValue,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteStatusContext.Provider, {
+			value: statusValue,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteDataContext.Provider, {
+				value: dataValue,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteActionsContext.Provider, {
+					value: actionsValue,
+					children: props.children
+				})
+			})
+		})
+	});
+}
+function useRequiredRouteLocation(routeId) {
+	return requireActiveRouteSlice(routeId, react.useContext(getRouteLocationContext()));
+}
+function useRequiredRouteStatus(routeId) {
+	return requireActiveRouteSlice(routeId, react.useContext(getRouteStatusContext()));
+}
+function useRequiredRouteData(routeId) {
+	return requireActiveRouteSlice(routeId, react.useContext(getRouteDataContext()));
+}
+function useRequiredRouteActions(routeId) {
+	return requireActiveRouteSlice(routeId, react.useContext(getRouteActionsContext()));
+}
+function createRouteFormComponent(routeId) {
+	const cached = routeFormComponentCache.get(routeId);
+	if (cached) return cached;
+	const MemoizedLitzRouteForm = react.memo(function LitzRouteForm(props) {
+		const actions = useRequiredRouteActions(routeId);
+		const { children, onSubmit, replace, revalidate, ...rest } = props;
+		const submitRef = react.useRef((payload, options) => actions.submit(payload, options));
+		react.useEffect(() => {
+			submitRef.current = (payload, options) => actions.submit(payload, options);
+		}, [actions.submit]);
+		const action = react.useCallback(async (formData) => {
+			await submitRef.current(formData, {
+				replace,
+				revalidate
+			});
+		}, [replace, revalidate]);
+		return react.createElement("form", {
+			...rest,
+			action,
+			onSubmit
+		}, children);
+	});
+	MemoizedLitzRouteForm.displayName = `LitzRouteForm(${routeId})`;
+	routeFormComponentCache.set(routeId, MemoizedLitzRouteForm);
+	return MemoizedLitzRouteForm;
+}
+//#endregion
+//#region src/client/runtime.tsx
+async function fetchRouteLoader(path, request, target) {
+	return parseLoaderResponse(await fetch("/_litz/route", {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			accept: require_internal_transport.LITZ_RESULT_ACCEPT
+		},
+		body: JSON.stringify({
+			path,
+			target,
+			operation: "loader",
+			request: normalizeRequest(request)
+		})
+	}));
+}
+async function fetchRouteAction(path, request, payload) {
+	const actionRequest = require_internal_transport.createInternalActionRequestInit({
+		path,
+		operation: "action",
+		request: normalizeRequest(request)
+	}, payload);
+	return parseActionResponse(await fetch("/_litz/action", {
+		method: "POST",
+		headers: actionRequest.headers,
+		body: actionRequest.body
+	}));
+}
+function normalizeRequest(request) {
+	return {
+		params: request.params ?? {},
+		search: request.search instanceof URLSearchParams ? Object.fromEntries(request.search.entries()) : request.search ?? {}
+	};
+}
+//#endregion
+//#region src/client/index.ts
+require_bindings.installClientBindings({
+	usePathname,
+	useLocation,
+	useRequiredRouteLocation,
+	useRequiredRouteStatus,
+	useRequiredRouteData,
+	useRequiredRouteActions,
+	useRequiredResourceLocation,
+	useRequiredResourceStatus,
+	useRequiredResourceData,
+	useRequiredResourceActions,
+	useMatches,
+	createRouteFormComponent,
+	createResourceFormComponent,
+	createResourceComponent
+});
+const manifest = require_internal_transport.sortByPathSpecificity(virtual_litzjs_route_manifest.routeManifest);
+const exactManifestEntries = /* @__PURE__ */ new Map();
+const dynamicManifestEntries = [];
+const ROUTE_CACHE_LIMIT = 200;
+const ROUTE_MODULE_CACHE_LIMIT = Math.max(manifest.length, 1);
+let navigationContext = null;
+let locationContext = null;
+let matchesContext = null;
+const routeCache = /* @__PURE__ */ new Map();
+const routeModuleCache = /* @__PURE__ */ new Map();
+const routeModulePrefetchCache = /* @__PURE__ */ new Map();
+const layoutChainCache = /* @__PURE__ */ new WeakMap();
+const pathParamNamesCache = /* @__PURE__ */ new Map();
+for (const entry of manifest) if (entry.path.includes(":")) dynamicManifestEntries.push(entry);
+else exactManifestEntries.set(entry.path, entry);
+function getNavigationContext() {
+	if (!navigationContext) {
+		const createContext = react.createContext;
+		if (!createContext) throw new Error("Litz client navigation is not available in this environment.");
+		navigationContext = createContext(null);
+	}
+	return navigationContext;
+}
+function getMatchesContext() {
+	if (!matchesContext) {
+		const createContext = react.createContext;
+		if (!createContext) throw new Error("Litz client matches are not available in this environment.");
+		matchesContext = createContext([]);
+	}
+	return matchesContext;
+}
+function getLocationContext() {
+	if (!locationContext) {
+		const createContext = react.createContext;
+		if (!createContext) throw new Error("Litz client location is not available in this environment.");
+		locationContext = createContext(null);
+	}
+	return locationContext;
+}
+function mountApp(element, options) {
+	import("react-dom/client").then(({ createRoot }) => {
+		createRoot(element).render(react.createElement(LitzApp, {
+			component: options?.component,
+			layout: options?.layout
+		}));
+	});
+}
+function useNavigate() {
+	const context = react.useContext(getNavigationContext());
+	if (!context) throw new Error("useNavigate() must be used inside the Litz client runtime.");
+	return (href, options) => context.navigate(href, options);
+}
+function useMatches() {
+	return react.useContext(getMatchesContext());
+}
+function usePathname() {
+	const location = react.useContext(getLocationContext());
+	if (!location) throw new Error("usePathname() must be used inside the Litz client runtime.");
+	return location.pathname;
+}
+function useLocation() {
+	const location = react.useContext(getLocationContext());
+	if (!location) throw new Error("useLocation() must be used inside the Litz client runtime.");
+	return location;
+}
+const Link = createLinkComponent({
+	useNavigate,
+	prefetchRouteModuleForHref
+});
+function LitzApp(props) {
+	const [location, setLocation] = react.useState(() => window.location.href);
+	react.useEffect(() => {
+		function handlePopState() {
+			react.startTransition(() => {
+				setLocation(window.location.href);
+			});
+		}
+		window.addEventListener("popstate", handlePopState);
+		return () => window.removeEventListener("popstate", handlePopState);
+	}, []);
+	const navigate = react.useCallback((next, replace = false) => {
+		if (replace) window.history.replaceState(null, "", next);
+		else window.history.pushState(null, "", next);
+		react.startTransition(() => {
+			setLocation(window.location.href);
+		});
+	}, []);
+	const navigationValue = react.useMemo(() => ({ navigate(href, options) {
+		navigate(href, options?.replace);
+	} }), [navigate]);
+	const locationValue = react.useMemo(() => {
+		const url = new URL(location);
+		return {
+			href: location,
+			pathname: url.pathname,
+			search: new URLSearchParams(url.search),
+			hash: url.hash
+		};
+	}, [location]);
+	const routeHost = react.createElement(RouteHost, {
+		location,
+		navigate,
+		component: props.component
+	});
+	const content = props.layout ? react.createElement(props.layout.component, null, routeHost) : routeHost;
+	return react.createElement(getNavigationContext().Provider, { value: navigationValue }, react.createElement(getLocationContext().Provider, { value: locationValue }, content));
+}
+function RouteHost(props) {
+	const navigate = react.useCallback((next, replace) => {
+		props.navigate(next, replace);
+	}, [props.navigate]);
+	const url = react.useMemo(() => new URL(props.location), [props.location]);
+	const search = react.useMemo(() => new URLSearchParams(url.search), [url.search]);
+	const matched = react.useMemo(() => findMatch(url.pathname), [url.pathname]);
+	const createBootstrapPageStateForLocation = react.useCallback((route) => createBootstrapPageState(route, url.pathname, search), [search, url.pathname]);
+	const { displayLocation, renderedRoute, pageState, setPageState } = useResolvedRouteState({
+		matched,
+		location: props.location,
+		createEmptyPageState,
+		createBootstrapPageState: createBootstrapPageStateForLocation,
+		getCachedRoute: getCachedRouteModule,
+		setCachedRoute: setCachedRouteModule
+	});
+	const displayedUrl = react.useMemo(() => new URL(displayLocation), [displayLocation]);
+	const displayedSearch = react.useMemo(() => new URLSearchParams(displayedUrl.search), [displayedUrl.search]);
+	const activeRouteState = react.useMemo(() => {
+		if (!renderedRoute) return null;
+		const activeMatches = buildActiveMatches(renderedRoute, displayedUrl.pathname, displayedSearch);
+		return {
+			activeMatches,
+			loaderMatches: activeMatches.filter((entry) => Boolean(entry.options?.loader)),
+			baseRequest: {
+				params: extractRouteParams(renderedRoute.path, displayedUrl.pathname) ?? {},
+				search: displayedSearch
+			}
+		};
+	}, [
+		displayedSearch,
+		displayedUrl.pathname,
+		renderedRoute
+	]);
+	react.useEffect(() => {
+		if (!renderedRoute || !activeRouteState) return;
+		let cancelled = false;
+		const { loaderMatches, baseRequest } = activeRouteState;
+		const finalLoaderMatchId = loaderMatches[loaderMatches.length - 1]?.id;
+		const reload = async (mode = "loading") => {
+			if (loaderMatches.length === 0) {
+				if (!cancelled) setPageState((current) => ({
+					...current,
+					status: "idle",
+					pending: false,
+					errorInfo: void 0,
+					errorTargetId: void 0
+				}));
+				return;
+			}
+			setPageState((current) => applyCachedLoaderStateToPageState(current, loaderMatches, mode));
+			for (const entry of loaderMatches) try {
+				const loaderResult = await fetchRouteLoader(renderedRoute.path, baseRequest, entry.id);
+				if (cancelled) return;
+				setCachedLoaderResult(entry.cacheKey, withLoaderStaleState(loaderResult, false));
+				setPageState((current) => withMatchLoaderResult(current, entry.id, renderedRoute.id, loaderResult, entry.id === finalLoaderMatchId ? "idle" : current.status, entry.id === finalLoaderMatchId ? false : current.pending));
+			} catch (error) {
+				if (cancelled) return;
+				if (isRedirectSignal(error)) {
+					navigate(error.location, true);
+					return;
+				}
+				if (isRouteLikeError(error)) {
+					setPageState((current) => ({
+						...current,
+						status: "error",
+						pending: false,
+						errorInfo: error,
+						errorTargetId: entry.id
+					}));
+					return;
+				}
+				throw error;
+			}
+		};
+		reload();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		activeRouteState,
+		navigate,
+		renderedRoute
+	]);
+	const activeMatches = activeRouteState?.activeMatches ?? [];
+	const matchesValue = activeMatches;
+	const reloadImpl = react.useCallback((mode) => renderedRoute ? reloadCurrentRoute({
+		route: renderedRoute,
+		pathname: displayedUrl.pathname,
+		search: displayedSearch,
+		navigate,
+		setPageState,
+		mode
+	}) : Promise.resolve(), [
+		displayedSearch,
+		displayedUrl.pathname,
+		navigate,
+		renderedRoute,
+		setPageState
+	]);
+	if (!matched) return react.createElement(NotFoundPage);
+	if (!renderedRoute) return react.createElement(react.Fragment);
+	const content = renderMatchChain(renderedRoute, activeMatches, pageState, displayLocation, navigate, reloadImpl, setPageState);
+	return react.createElement(getMatchesContext().Provider, { value: matchesValue }, props.component ? react.createElement(props.component, null, content) : content);
+}
+function findMatch(pathname) {
+	const exactEntry = exactManifestEntries.get(pathname);
+	if (exactEntry) return {
+		entry: exactEntry,
+		params: {}
+	};
+	for (const entry of dynamicManifestEntries) {
+		const params = require_internal_transport.matchPathname(entry.path, pathname);
+		if (params) return {
+			entry,
+			params
+		};
+	}
+	return null;
+}
+function NotFoundPage() {
+	return react.createElement("main", null, react.createElement("h1", null, "Not Found"));
+}
+function createEmptyPageState() {
+	return {
+		matchStates: {},
+		actionResult: null,
+		nextResultSequence: 1,
+		latestDataResult: null,
+		latestViewResult: null,
+		status: "loading",
+		pending: true
+	};
+}
+function createBootstrapPageState(route, pathname, search) {
+	const matches = buildActiveMatches(route, pathname, search);
+	const matchStates = {};
+	let hasAnyLoader = false;
+	let hasCachedLoader = false;
+	let missingLoader = false;
+	let nextResultSequence = 1;
+	let latestDataResult = null;
+	let latestViewResult = null;
+	for (const match of matches) {
+		if (!match.options?.loader) continue;
+		hasAnyLoader = true;
+		const cached = getCachedLoaderResult(match.cacheKey);
+		if (cached) {
+			hasCachedLoader = true;
+			const staleCached = withLoaderStaleState(cached, true);
+			matchStates[match.id] = { loaderResult: staleCached };
+			if (match.id === route.id) {
+				if (staleCached.kind === "data") {
+					latestDataResult = {
+						sequence: nextResultSequence,
+						result: staleCached
+					};
+					nextResultSequence += 1;
+				} else if (staleCached.kind === "view") {
+					latestViewResult = {
+						sequence: nextResultSequence,
+						result: staleCached
+					};
+					nextResultSequence += 1;
+				}
+			}
+		} else {
+			missingLoader = true;
+			matchStates[match.id] = { loaderResult: null };
+		}
+	}
+	if (!hasAnyLoader) return {
+		matchStates,
+		actionResult: null,
+		nextResultSequence,
+		latestDataResult,
+		latestViewResult,
+		status: "idle",
+		pending: false
+	};
+	return {
+		matchStates,
+		actionResult: null,
+		nextResultSequence,
+		latestDataResult,
+		latestViewResult,
+		status: hasCachedLoader ? "revalidating" : "loading",
+		pending: missingLoader || hasCachedLoader
+	};
+}
+function withLatestDataResult(current, result) {
+	const sequence = current.nextResultSequence;
+	return {
+		...current,
+		nextResultSequence: sequence + 1,
+		latestDataResult: {
+			sequence,
+			result
+		}
+	};
+}
+function withLatestViewResult(current, result) {
+	const sequence = current.nextResultSequence;
+	return {
+		...current,
+		nextResultSequence: sequence + 1,
+		latestViewResult: {
+			sequence,
+			result
+		}
+	};
+}
+function applyCachedLoaderStateToPageState(current, matches, mode) {
+	const matchStates = { ...current.matchStates };
+	let hasResolvedLoader = false;
+	for (const match of matches) {
+		const cached = getCachedLoaderResult(match.cacheKey);
+		if (cached) {
+			matchStates[match.id] = { loaderResult: withLoaderStaleState(cached, true) };
+			hasResolvedLoader = true;
+		} else if (!matchStates[match.id]) matchStates[match.id] = { loaderResult: null };
+		else if (matchStates[match.id]?.loaderResult) hasResolvedLoader = true;
+	}
+	return {
+		...current,
+		matchStates,
+		status: hasResolvedLoader ? "revalidating" : mode,
+		pending: true,
+		errorInfo: void 0,
+		errorTargetId: void 0
+	};
+}
+function withMatchLoaderResult(current, matchId, routeId, loaderResult, status, pending) {
+	let nextState = {
+		...current,
+		matchStates: {
+			...current.matchStates,
+			[matchId]: { loaderResult }
+		},
+		status,
+		pending,
+		errorInfo: void 0,
+		errorTargetId: void 0
+	};
+	if (matchId === routeId) {
+		if (loaderResult.kind === "data") nextState = withLatestDataResult(nextState, loaderResult);
+		else if (loaderResult.kind === "view") nextState = withLatestViewResult(nextState, loaderResult);
+	}
+	return nextState;
+}
+async function reloadCurrentRoute(options) {
+	const loaderMatches = buildActiveMatches(options.route, options.pathname, options.search).filter((entry) => Boolean(entry.options?.loader));
+	if (loaderMatches.length === 0) {
+		options.setPageState((current) => ({
+			...current,
+			status: "idle",
+			pending: false,
+			errorInfo: void 0,
+			errorTargetId: void 0
+		}));
+		return;
+	}
+	options.setPageState((current) => applyCachedLoaderStateToPageState(current, loaderMatches, options.mode ?? "loading"));
+	const baseRequest = {
+		params: extractRouteParams(options.route.path, options.pathname) ?? {},
+		search: options.search
+	};
+	for (const entry of loaderMatches) try {
+		const loaderResult = await fetchRouteLoader(options.route.path, baseRequest, entry.id);
+		setCachedLoaderResult(entry.cacheKey, withLoaderStaleState(loaderResult, false));
+		options.setPageState((current) => withMatchLoaderResult(current, entry.id, options.route.id, loaderResult, entry === loaderMatches[loaderMatches.length - 1] ? "idle" : current.status, entry === loaderMatches[loaderMatches.length - 1] ? false : current.pending));
+	} catch (error) {
+		if (isRedirectSignal(error)) {
+			options.navigate(error.location, true);
+			return;
+		}
+		if (isRouteLikeError(error)) {
+			options.setPageState((current) => ({
+				...current,
+				status: "error",
+				pending: false,
+				errorInfo: error,
+				errorTargetId: entry.id
+			}));
+			return;
+		}
+		throw error;
+	}
+}
+function renderMatchChain(route, matches, pageState, location, navigate, reloadImpl, setPageState) {
+	const errorBoundaryIndex = findErrorBoundaryIndex(matches, pageState);
+	const pendingBoundaryIndex = errorBoundaryIndex === null ? findPendingBoundaryIndex(matches, pageState) : null;
+	if (errorBoundaryIndex === null && pendingBoundaryIndex === null && matches.some((match) => Boolean(match.options?.loader) && !pageState.matchStates[match.id]?.loaderResult)) return react.createElement(react.Fragment);
+	let node = null;
+	for (let index = matches.length - 1; index >= 0; index -= 1) {
+		const match = matches[index];
+		if (!match) continue;
+		let content;
+		if (errorBoundaryIndex !== null && index === errorBoundaryIndex) {
+			const ErrorComponent = match.options?.errorComponent ?? DefaultRouteErrorPage;
+			content = react.createElement(ErrorComponent, { error: pageState.errorInfo });
+		} else if (pendingBoundaryIndex !== null && index === pendingBoundaryIndex) content = react.createElement(match.options?.pendingComponent);
+		else if (errorBoundaryIndex !== null && index > errorBoundaryIndex) continue;
+		else if (pendingBoundaryIndex !== null && index > pendingBoundaryIndex) continue;
+		else if (match.kind === "route") content = react.createElement(match.component);
+		else content = react.createElement(match.component, null, node);
+		node = react.createElement(MatchRuntimeBoundary, {
+			key: match.id,
+			match,
+			route,
+			pageState,
+			location,
+			navigate,
+			reloadImpl,
+			setPageState
+		}, content);
+	}
+	return node ?? react.createElement(react.Fragment);
+}
+function findErrorBoundaryIndex(matches, pageState) {
+	if (!pageState.errorInfo || !pageState.errorTargetId) return null;
+	const targetIndex = matches.findIndex((match) => match.id === pageState.errorTargetId);
+	if (targetIndex === -1) return null;
+	for (let index = targetIndex; index >= 0; index -= 1) {
+		const match = matches[index];
+		if (match && match.options?.errorComponent) return index;
+	}
+	return targetIndex;
+}
+function findPendingBoundaryIndex(matches, pageState) {
+	if (!pageState.pending) return null;
+	const targetIndex = matches.findIndex((match) => Boolean(match.options?.loader) && !pageState.matchStates[match.id]?.loaderResult);
+	if (targetIndex === -1) return null;
+	for (let index = targetIndex; index >= 0; index -= 1) {
+		const match = matches[index];
+		if (match && match.options?.pendingComponent) return index;
+	}
+	return null;
+}
+function DefaultRouteErrorPage(props) {
+	return react.createElement("main", null, react.createElement("h1", null, "Route Error"), react.createElement("p", null, `${props.error.kind} ${props.error.status}: ${props.error.message}`));
+}
+function MatchRuntimeBoundary(props) {
+	const runtime = useMatchRuntime(props);
+	return react.createElement(RouteRuntimeProvider, { value: runtime }, props.children);
+}
+function useMatchRuntime(options) {
+	const { match, route, pageState, location, navigate, reloadImpl, setPageState } = options;
+	const loaderResult = pageState.matchStates[match.id]?.loaderResult ?? null;
+	const actionResult = match.kind === "route" ? pageState.actionResult : null;
+	const data = match.kind === "route" ? pageState.latestDataResult?.result.data ?? null : loaderResult?.kind === "data" ? loaderResult.data : null;
+	const view = match.kind === "route" ? pageState.latestViewResult?.result.node ?? null : loaderResult?.kind === "view" ? loaderResult.node : null;
+	const setSearch = react.useCallback((updates, submitOptions) => {
+		const result = applySearchParams(new URL(location), updates);
+		if (!result.changed) return;
+		navigate(result.href, submitOptions?.replace);
+	}, [location, navigate]);
+	const submit = react.useCallback(async (payload, submitOptions) => {
+		if (match.kind !== "route" || !route.options?.action) throw new Error(`Route "${match.path}" does not define an action.`);
+		const formData = require_internal_transport.createFormDataPayload(payload);
+		submitOptions?.onBeforeSubmit?.(formData);
+		setPageState((current) => ({
+			...current,
+			status: "submitting",
+			pending: true
+		}));
+		const result = await fetchRouteAction(route.path, {
+			params: match.params,
+			search: match.search
+		}, formData);
+		if (result?.kind === "redirect") {
+			navigate(result.location, submitOptions?.replace ?? result.replace);
+			return;
+		}
+		if (result?.kind === "view") setPageState((current) => withLatestViewResult({
+			...current,
+			actionResult: result,
+			status: "idle",
+			pending: false
+		}, result));
+		else if (result?.kind === "data") setPageState((current) => withLatestDataResult({
+			...current,
+			actionResult: result,
+			status: "idle",
+			pending: false
+		}, result));
+		else if (result) setPageState((current) => ({
+			...current,
+			actionResult: result,
+			status: result.kind === "error" || result.kind === "fault" ? "error" : "idle",
+			pending: false,
+			errorInfo: result.kind === "error" || result.kind === "fault" ? result : current.errorInfo,
+			errorTargetId: result.kind === "error" || result.kind === "fault" ? route.id : current.errorTargetId
+		}));
+		if (result && shouldRevalidateAfterSubmit(route, result.headers, submitOptions?.revalidate)) await reloadImpl("revalidating");
+		if (result?.kind === "error" || result?.kind === "fault") submitOptions?.onError?.(result);
+		else if (result) submitOptions?.onSuccess?.(result);
+	}, [
+		match,
+		navigate,
+		reloadImpl,
+		route,
+		setPageState
+	]);
+	const reload = react.useCallback(() => {
+		reloadImpl("revalidating");
+	}, [reloadImpl]);
+	const retry = react.useCallback(() => {
+		reloadImpl("loading");
+	}, [reloadImpl]);
+	return react.useMemo(() => ({
+		id: match.id,
+		params: match.params,
+		search: match.search,
+		setSearch,
+		status: pageState.status,
+		pending: pageState.pending,
+		loaderResult,
+		actionResult,
+		data,
+		view,
+		submit,
+		reload,
+		retry
+	}), [
+		actionResult,
+		data,
+		loaderResult,
+		match.id,
+		match.params,
+		match.search,
+		pageState.pending,
+		pageState.status,
+		reload,
+		retry,
+		setSearch,
+		submit,
+		view
+	]);
+}
+function getLayoutChain(layout) {
+	if (!layout) return [];
+	const cached = layoutChainCache.get(layout);
+	if (cached) return cached;
+	const chain = [...getLayoutChain(layout.options?.layout), layout];
+	layoutChainCache.set(layout, chain);
+	return chain;
+}
+function buildActiveMatches(route, pathname, search) {
+	const routeParams = extractRouteParams(route.path, pathname) ?? {};
+	const layouts = getLayoutChain(route.options?.layout);
+	const sortedSearch = sortRecord(Object.fromEntries(search.entries()));
+	return [...layouts.map((layout) => {
+		const params = extractRouteParams(layout.path, pathname) ?? filterParamsForPath(routeParams, layout.path);
+		return {
+			id: layout.id,
+			path: layout.path,
+			cacheKey: createRouteCacheKey(layout.path, params, sortedSearch),
+			kind: "layout",
+			component: layout.component,
+			options: layout.options,
+			params,
+			search
+		};
+	}), {
+		id: route.id,
+		path: route.path,
+		cacheKey: createRouteCacheKey(route.path, routeParams, sortedSearch),
+		kind: "route",
+		component: route.component,
+		options: route.options,
+		params: routeParams,
+		search
+	}];
+}
+function shouldRevalidateAfterSubmit(route, headers, revalidate) {
+	if (revalidate === false) return false;
+	if (revalidate === true) return true;
+	const targets = new Set(getRevalidateTargets(headers));
+	if (Array.isArray(revalidate)) for (const target of revalidate) targets.add(target);
+	if (targets.size === 0) return false;
+	return getActiveMatchPaths(route).some((path) => targets.has(path));
+}
+function extractRouteParams(pathPattern, pathname) {
+	return require_internal_transport.extractRouteLikeParams(pathPattern, pathname);
+}
+function filterParamsForPath(params, pathPattern) {
+	const names = getPathParamNames(pathPattern);
+	return Object.fromEntries(names.map((name) => [name, params[name]]).filter((entry) => entry[1] !== void 0));
+}
+function createRouteCacheKey(path, params, sortedSearch) {
+	return JSON.stringify({
+		path,
+		params: sortRecord(params),
+		search: sortedSearch
+	});
+}
+function getActiveMatchPaths(route) {
+	return [...getLayoutChain(route.options?.layout).map((layout) => layout.path), route.path];
+}
+function getPathParamNames(pathPattern) {
+	const cached = pathParamNamesCache.get(pathPattern);
+	if (cached) return cached;
+	const names = Array.from(pathPattern.matchAll(/:([A-Za-z0-9_]+)/g), (match) => match[1]).filter((name) => Boolean(name));
+	pathParamNamesCache.set(pathPattern, names);
+	return names;
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function getCachedLoaderResult(key) {
+	const cached = routeCache.get(key);
+	if (!cached) return;
+	routeCache.delete(key);
+	routeCache.set(key, cached);
+	return cached;
+}
+function setCachedLoaderResult(key, result) {
+	if (routeCache.has(key)) routeCache.delete(key);
+	routeCache.set(key, result);
+	while (routeCache.size > ROUTE_CACHE_LIMIT) {
+		const oldestKey = routeCache.keys().next().value;
+		if (oldestKey === void 0) return;
+		routeCache.delete(oldestKey);
+	}
+}
+function getCachedRouteModule(id) {
+	const cached = routeModuleCache.get(id);
+	if (!cached) return null;
+	routeModuleCache.delete(id);
+	routeModuleCache.set(id, cached);
+	return cached;
+}
+function setCachedRouteModule(id, route) {
+	if (routeModuleCache.has(id)) routeModuleCache.delete(id);
+	routeModuleCache.set(id, route);
+	while (routeModuleCache.size > ROUTE_MODULE_CACHE_LIMIT) {
+		const oldestKey = routeModuleCache.keys().next().value;
+		if (oldestKey === void 0) return;
+		routeModuleCache.delete(oldestKey);
+	}
+}
+function prefetchRouteModuleForHref(href, target, download) {
+	const currentUrl = new URL(window.location.href);
+	const nextUrl = new URL(href, currentUrl);
+	if (!shouldPrefetchLink({
+		target,
+		download,
+		currentUrl,
+		nextUrl
+	})) return;
+	const matched = findMatch(nextUrl.pathname);
+	if (!matched || routeModuleCache.has(matched.entry.id)) return;
+	if (routeModulePrefetchCache.get(matched.entry.id)) return;
+	const prefetch = matched.entry.load().then((loaded) => {
+		if (loaded.route) setCachedRouteModule(matched.entry.id, loaded.route);
+	}).catch(() => {}).finally(() => {
+		routeModulePrefetchCache.delete(matched.entry.id);
+	});
+	routeModulePrefetchCache.set(matched.entry.id, prefetch);
+}
+function withLoaderStaleState(result, stale) {
+	if (result.stale === stale) return result;
+	if (result.kind === "data") return {
+		...result,
+		stale
+	};
+	return {
+		...result,
+		stale,
+		render: result.render
+	};
+}
+//#endregion
+exports.Link = Link;
+exports.mountApp = mountApp;
+exports.useLocation = useLocation;
+exports.useMatches = useMatches;
+exports.useNavigate = useNavigate;
+exports.usePathname = usePathname;