boltdocs 3.2.1 → 3.3.0

package/dist/router-CZBxMRAH.js

@@ -0,0 +1,987 @@
+/**
+ * Boltdocs - https://boltdocs.vercel.app
+ * Copyright (c) 2026 Jesus Alcala
+ * Licensed under the MIT License.
+ */
+import React, { createContext, startTransition, use, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+//#region src/client/router/utils.ts
+function normalizeBasename(basename) {
+	if (!basename || basename === "/") return "/";
+	return basename.replace(/\/$/, "") || "/";
+}
+function hasBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return true;
+	if (path === normalized) return true;
+	return path.startsWith(`${normalized}/`);
+}
+function stripBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return path;
+	if (!hasBasename(path, normalized)) return path;
+	const stripped = path.slice(normalized.length);
+	return stripped.startsWith("/") ? stripped : `/${stripped}`;
+}
+function addBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return path;
+	if (hasBasename(path, normalized)) return path;
+	if (path.startsWith("/")) return `${normalized}${path}`;
+	return `${normalized}/${path}`;
+}
+
+//#endregion
+//#region src/client/router/context.tsx
+function getActiveLocale() {
+	if (typeof globalThis === "undefined") return void 0;
+	const instance = globalThis[Symbol.for("__BDOCS_BOLTDOCS_INSTANCE__")];
+	if (instance && typeof instance === "object" && "currentLocale" in instance && typeof instance.currentLocale === "string") return instance.currentLocale;
+	if (typeof window === "undefined") return void 0;
+	try {
+		const raw = window.localStorage.getItem("boltdocs-user-preferences");
+		if (!raw) return void 0;
+		const preferences = JSON.parse(raw);
+		return typeof preferences.locale === "string" ? preferences.locale : void 0;
+	} catch {
+		return;
+	}
+}
+const defaultNavigate = () => {};
+const defaultLocation = {
+	pathname: "/",
+	search: "",
+	hash: ""
+};
+const g$1 = typeof globalThis !== "undefined" ? globalThis : {};
+function getGlobalContext(key, create) {
+	const existing = g$1[key];
+	if (existing) return existing;
+	const context = create();
+	g$1[key] = context;
+	return context;
+}
+const LocationContext = getGlobalContext("__BOLTDOCS_LOCATION_CONTEXT__", () => createContext(defaultLocation));
+const NavigateContext = getGlobalContext("__BOLTDOCS_NAVIGATE_CONTEXT__", () => createContext(defaultNavigate));
+const PrefetchContext = getGlobalContext("__BOLTDOCS_PREFETCH_CONTEXT__", () => createContext(async () => {}));
+const RouteDataContext = getGlobalContext("__BOLTDOCS_ROUTE_DATA_CONTEXT__", () => createContext(null));
+const MatchesContext = getGlobalContext("__BOLTDOCS_MATCHES_CONTEXT__", () => createContext([]));
+function normalizeComparablePath(pathname) {
+	if (pathname.length <= 1) return pathname || "/";
+	return pathname.replace(/\/$/, "") || "/";
+}
+function dispatchNavigationStart(location) {
+	if (typeof window === "undefined") return;
+	window.dispatchEvent(new CustomEvent("boltdocs:navigation-start", { detail: location }));
+}
+function scheduleLocationUpdate(setLocation, nextLocation, viewTransitions) {
+	setTimeout(() => {
+		const enabled = typeof viewTransitions === "boolean" ? viewTransitions : viewTransitions?.enabled === true;
+		const startViewTransition = document.startViewTransition;
+		if (enabled && startViewTransition) {
+			const types = typeof viewTransitions === "object" ? viewTransitions.types : void 0;
+			startViewTransition.call(document, {
+				update: () => setLocation(nextLocation),
+				...types?.length ? { types } : {}
+			});
+			return;
+		}
+		setLocation(nextLocation);
+	}, 0);
+}
+function getLocationFromWindow() {
+	if (typeof window === "undefined") return defaultLocation;
+	return {
+		pathname: window.location.pathname || "/",
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+}
+const LocationProvider = ({ pathname: propPathname, children, loaderData = null, matches = [], basename, defaultLocale, prefetch: prefetchProp, viewTransitions }) => {
+	const [location, setLocation] = useState(() => {
+		if (typeof window !== "undefined") return getLocationFromWindow();
+		return propPathname ? {
+			pathname: propPathname,
+			search: "",
+			hash: ""
+		} : defaultLocation;
+	});
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const handlePopState = () => {
+			const nextLocation = getLocationFromWindow();
+			scheduleLocationUpdate(setLocation, nextLocation, viewTransitions);
+			dispatchNavigationStart(nextLocation);
+		};
+		window.addEventListener("popstate", handlePopState);
+		return () => window.removeEventListener("popstate", handlePopState);
+	}, [viewTransitions]);
+	const prefetched = useRef(/* @__PURE__ */ new Set());
+	const fallbackPrefetch = useCallback(async (to) => {
+		if (typeof window === "undefined" || !to || prefetched.current.has(to)) return;
+		prefetched.current.add(to);
+	}, []);
+	const prefetch = prefetchProp ?? fallbackPrefetch;
+	const navigate = useCallback((to, options) => {
+		if (typeof window === "undefined") return;
+		if (!to) return;
+		const normalizedBasename = normalizeBasename(basename);
+		if (/^https?:\/\//i.test(to) || to.startsWith("//")) {
+			window.location.href = to;
+			return;
+		}
+		if (to.startsWith("#")) {
+			const newUrl = new URL(to, window.location.href);
+			const nextLocation = {
+				pathname: window.location.pathname,
+				search: window.location.search,
+				hash: newUrl.hash
+			};
+			if (nextLocation.pathname === window.location.pathname && nextLocation.search === window.location.search && nextLocation.hash === window.location.hash) {
+				if (options?.state !== void 0) if (options.replace) window.history.replaceState(options.state, "", newUrl.href);
+				else window.history.pushState(options.state, "", newUrl.href);
+				return;
+			}
+			if (options?.replace) window.history.replaceState(options.state ?? null, "", newUrl.href);
+			else window.history.pushState(options?.state ?? null, "", newUrl.href);
+			scheduleLocationUpdate(setLocation, nextLocation, options?.viewTransition === false ? false : viewTransitions);
+			dispatchNavigationStart(nextLocation);
+			return;
+		}
+		const resolvedUrl = new URL(to, window.location.href);
+		if (resolvedUrl.origin !== window.location.origin) {
+			window.location.href = to;
+			return;
+		}
+		let finalPath = resolvedUrl.pathname + resolvedUrl.search + resolvedUrl.hash;
+		if (normalizedBasename !== "/" && !hasBasename(resolvedUrl.pathname, normalizedBasename)) {
+			const activeLocale = getActiveLocale();
+			if (activeLocale && defaultLocale && activeLocale !== defaultLocale && !finalPath.startsWith(`/${activeLocale}/`) && finalPath !== `/${activeLocale}`) finalPath = `/${activeLocale}${finalPath === "/" ? "" : finalPath}`;
+		} else if (normalizedBasename !== "/") finalPath = addBasename(finalPath, normalizedBasename);
+		const finalUrl = new URL(finalPath, window.location.href);
+		if (normalizeComparablePath(finalUrl.pathname) === normalizeComparablePath(window.location.pathname) && finalUrl.search === window.location.search && finalUrl.hash === window.location.hash) {
+			if (options?.state !== void 0) if (options.replace) window.history.replaceState(options.state, "", finalPath);
+			else window.history.pushState(options.state, "", finalPath);
+			return;
+		}
+		if (options?.replace) window.history.replaceState(options?.state ?? null, "", finalPath);
+		else window.history.pushState(options?.state ?? null, "", finalPath);
+		const nextLocation = {
+			pathname: finalUrl.pathname,
+			search: finalUrl.search,
+			hash: finalUrl.hash
+		};
+		scheduleLocationUpdate(setLocation, nextLocation, options?.viewTransition === false ? false : viewTransitions);
+		dispatchNavigationStart(nextLocation);
+	}, [
+		basename,
+		defaultLocale,
+		viewTransitions
+	]);
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const normalizedBasename = normalizeBasename(basename);
+		const handleClick = (e) => {
+			if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
+			let target = e.target;
+			while (target && target.nodeName !== "A") target = target.parentElement;
+			if (!target || target.nodeName !== "A") return;
+			const anchor = target;
+			const href = anchor.getAttribute("href");
+			if (!href || anchor.target === "_blank" || anchor.hasAttribute("download") || href.startsWith("#")) return;
+			if (/^https?:\/\//i.test(href) || href.startsWith("//")) return;
+			let resolvedPathname;
+			try {
+				const resolved = new URL(href, document.baseURI || window.location.href);
+				if (resolved.origin !== window.location.origin) return;
+				resolvedPathname = resolved.pathname;
+			} catch {
+				return;
+			}
+			const isUnderBasename = normalizedBasename === "/" || hasBasename(resolvedPathname, normalizedBasename);
+			const currentIsUnderBasename = normalizedBasename === "/" || hasBasename(window.location.pathname, normalizedBasename);
+			if (!isUnderBasename && currentIsUnderBasename) return;
+			e.preventDefault();
+			navigate(href);
+		};
+		document.addEventListener("click", handleClick);
+		return () => document.removeEventListener("click", handleClick);
+	}, [navigate, basename]);
+	return /* @__PURE__ */ jsx(LocationContext.Provider, {
+		value: location,
+		children: /* @__PURE__ */ jsx(NavigateContext.Provider, {
+			value: navigate,
+			children: /* @__PURE__ */ jsx(PrefetchContext.Provider, {
+				value: prefetch,
+				children: /* @__PURE__ */ jsx(RouteDataContext.Provider, {
+					value: loaderData,
+					children: /* @__PURE__ */ jsx(MatchesContext.Provider, {
+						value: matches,
+						children
+					})
+				})
+			})
+		})
+	});
+};
+
+//#endregion
+//#region src/client/router/hooks.ts
+function useLocation() {
+	return use(LocationContext);
+}
+function useNavigate() {
+	return use(NavigateContext);
+}
+function usePrefetch() {
+	return use(PrefetchContext);
+}
+function useRouteData() {
+	return use(RouteDataContext);
+}
+/** Alias for useRouteData — parity with react-router-dom's useLoaderData */
+function useLoaderData() {
+	return use(RouteDataContext);
+}
+function useMatches() {
+	return use(MatchesContext);
+}
+
+//#endregion
+//#region src/client/router/outlet.tsx
+const g = typeof globalThis !== "undefined" ? globalThis : {};
+const existingOutletContext = g.__BOLTDOCS_OUTLET_CONTEXT__;
+const OutletContext = existingOutletContext ?? createContext(null);
+if (!existingOutletContext) g.__BOLTDOCS_OUTLET_CONTEXT__ = OutletContext;
+const Outlet = () => {
+	return /* @__PURE__ */ jsx(Fragment$1, { children: use(OutletContext) });
+};
+
+//#endregion
+//#region src/client/router/renderer.tsx
+function normalizePath(path) {
+	if (!path) return "/";
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	if (normalized.length > 1 && normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+function splitRoutePath(path) {
+	return normalizePath(path).replace(/^\//, "").split("/").filter((segment) => segment && segment !== ".");
+}
+const preparedRouteCache = /* @__PURE__ */ new WeakMap();
+const routeMatchCache = /* @__PURE__ */ new WeakMap();
+const routeSegmentsCache = /* @__PURE__ */ new WeakMap();
+function getRouteSegments(route) {
+	let segments = routeSegmentsCache.get(route);
+	if (!segments) {
+		segments = route.path ? splitRoutePath(route.path) : [];
+		routeSegmentsCache.set(route, segments);
+	}
+	return segments;
+}
+function getPreparedRoutes(routes) {
+	const cached = preparedRouteCache.get(routes);
+	if (cached) return cached;
+	const prepared = routes.map((route, index) => ({
+		route,
+		index,
+		segments: getRouteSegments(route),
+		score: routeScore(route),
+		children: route.children ? getPreparedRoutes(route.children) : void 0
+	})).sort((a, b) => b.score - a.score || a.index - b.index).map(({ route, segments, score, children }) => ({
+		route,
+		segments,
+		score,
+		children
+	}));
+	preparedRouteCache.set(routes, prepared);
+	return prepared;
+}
+function matchRoutePath(preparedRoute, target) {
+	const route = preparedRoute.route;
+	if (route.index || route.path === "" || route.path === ".") return target.length === 0 ? {
+		consumed: 0,
+		exact: true,
+		wildcard: false,
+		params: {}
+	} : null;
+	if (!route.path) return {
+		consumed: 0,
+		exact: !route.children?.length && target.length === 0,
+		wildcard: false,
+		params: {}
+	};
+	const routeSegments = preparedRoute.segments;
+	if (routeSegments.length === 0) return target.length === 0 ? {
+		consumed: 0,
+		exact: true,
+		wildcard: false,
+		params: {}
+	} : null;
+	let consumed = 0;
+	const params = {};
+	for (const segment of routeSegments) {
+		if (segment === "*") {
+			params["*"] = target.slice(consumed).join("/");
+			return {
+				consumed: target.length,
+				exact: true,
+				wildcard: true,
+				params
+			};
+		}
+		const targetSegment = target[consumed];
+		if (targetSegment === void 0) return null;
+		if (segment.startsWith(":")) params[segment.slice(1)] = targetSegment;
+		else if (segment !== targetSegment) return null;
+		consumed++;
+	}
+	return {
+		consumed,
+		exact: consumed === target.length,
+		wildcard: false,
+		params
+	};
+}
+function routeScore(route) {
+	if (route.index || route.path === "" || route.path === ".") return 1e3;
+	if (route.path === "*") return -1e3;
+	if (!route.path) return 0;
+	return splitRoutePath(route.path).reduce((score, segment) => {
+		if (segment === "*") return score - 100;
+		if (segment.startsWith(":")) return score + 10;
+		return score + 100;
+	}, 0);
+}
+function matchRouteBranchInternal(routes, target) {
+	for (const preparedRoute of routes) {
+		const route = preparedRoute.route;
+		const match = matchRoutePath(preparedRoute, target);
+		if (!match) continue;
+		const remaining = target.slice(match.consumed);
+		if (preparedRoute.children?.length) {
+			const childBranch = matchRouteBranchInternal(preparedRoute.children, remaining);
+			if (childBranch.length > 0) return [{
+				route,
+				params: match.params
+			}, ...childBranch.map((child) => ({
+				route: child.route,
+				params: {
+					...match.params,
+					...child.params
+				}
+			}))];
+			if (!match.exact) continue;
+		}
+		if (match.exact || match.wildcard) return [{
+			route,
+			params: match.params
+		}];
+	}
+	return [];
+}
+function getTargetSegments(pathname, basename) {
+	const normalizedPathname = normalizePath(pathname);
+	const targets = [splitRoutePath(normalizedPathname)];
+	const normalizedBasename = normalizeBasename(basename);
+	if (normalizedBasename !== "/" && hasBasename(normalizedPathname, normalizedBasename)) targets.push(splitRoutePath(stripBasename(normalizedPathname, normalizedBasename)));
+	return targets;
+}
+function matchRouteBranchWithParams(routes, pathname, basename) {
+	const cacheKey = `${normalizePath(pathname)}\u0000${normalizeBasename(basename)}`;
+	let matches = routeMatchCache.get(routes);
+	if (!matches) {
+		matches = /* @__PURE__ */ new Map();
+		routeMatchCache.set(routes, matches);
+	}
+	const cached = matches.get(cacheKey);
+	if (cached) return cached;
+	const preparedRoutes = getPreparedRoutes(routes);
+	for (const target of getTargetSegments(pathname, basename)) {
+		const branch = matchRouteBranchInternal(preparedRoutes, target);
+		if (branch.length > 0) {
+			cacheRouteEntry(matches, cacheKey, branch);
+			return branch;
+		}
+	}
+	cacheRouteEntry(matches, cacheKey, []);
+	return [];
+}
+function matchRouteBranch(routes, pathname, basename) {
+	return matchRouteBranchWithParams(routes, pathname, basename).map((match) => match.route);
+}
+const resolvedLazyCache = /* @__PURE__ */ new WeakMap();
+const pendingLazyCache = /* @__PURE__ */ new WeakMap();
+const routeCacheScopes = /* @__PURE__ */ new WeakMap();
+let nextRouteCacheScope = 0;
+const prefetchCache = /* @__PURE__ */ new Map();
+const loaderDataCache = /* @__PURE__ */ new Map();
+const MAX_ROUTE_CACHE_ENTRIES = 128;
+const MAX_ACTIVE_PREFETCHES = 2;
+const MAX_PENDING_PREFETCHES = 16;
+const ROUTE_RESOLUTION_TIMEOUT_MS = 4500;
+const ROUTE_LOADER_TIMEOUT_MS = 4500;
+const PREFETCH_SKIPPED = Symbol("prefetch-skipped");
+function withTimeout(promise, timeoutMs, message) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+function createPrefetchQueue() {
+	let activePrefetches = 0;
+	const pendingPrefetches = [];
+	const drain = () => {
+		while (activePrefetches < MAX_ACTIVE_PREFETCHES && pendingPrefetches.length > 0) {
+			const task = pendingPrefetches.shift();
+			if (!task) break;
+			activePrefetches++;
+			task.run().then(task.resolve, task.reject).finally(() => {
+				activePrefetches--;
+				drain();
+			});
+		}
+	};
+	return {
+		enqueue(run) {
+			if (pendingPrefetches.length >= MAX_PENDING_PREFETCHES) return PREFETCH_SKIPPED;
+			return new Promise((resolve, reject) => {
+				pendingPrefetches.push({
+					run,
+					resolve,
+					reject
+				});
+				drain();
+			});
+		},
+		clear() {
+			for (const task of pendingPrefetches.splice(0)) task.resolve();
+		}
+	};
+}
+function getRouteCacheScope(routes) {
+	let scope = routeCacheScopes.get(routes);
+	if (scope === void 0) {
+		scope = ++nextRouteCacheScope;
+		routeCacheScopes.set(routes, scope);
+	}
+	return scope;
+}
+function cacheRouteEntry(cache, key, value) {
+	if (cache.size >= MAX_ROUTE_CACHE_ENTRIES) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+	cache.set(key, value);
+}
+async function resolveRouteBranch(branch) {
+	const resolved = [];
+	for (const route of branch) {
+		if (!route.element && !route.Component && route.lazy) try {
+			let result = resolvedLazyCache.get(route);
+			if (!result) {
+				let pending = pendingLazyCache.get(route);
+				if (!pending) {
+					pending = route.lazy();
+					pendingLazyCache.set(route, pending);
+				}
+				try {
+					result = await withTimeout(pending, ROUTE_RESOLUTION_TIMEOUT_MS, "Timed out while loading a documentation route");
+				} finally {
+					pendingLazyCache.delete(route);
+				}
+				resolvedLazyCache.set(route, result);
+			}
+			resolved.push({
+				...route,
+				...result
+			});
+			continue;
+		} catch (err) {
+			console.error("[RouteRenderer] Error resolving lazy route:", err);
+		}
+		resolved.push(route);
+	}
+	return resolved;
+}
+function asLoaderData(value) {
+	return value !== null && typeof value === "object" ? value : null;
+}
+function getLoaderDataKey(routeScope, pathname, search = "") {
+	return `${routeScope}:${pathname}${search}`;
+}
+function loadRouteData(key, matches, resolvedBranch, request) {
+	const cached = loaderDataCache.get(key);
+	if (cached) return cached;
+	const pending = withTimeout(Promise.all(resolvedBranch.map(async (route, index) => {
+		if (!route?.loader) return null;
+		try {
+			return asLoaderData(await route.loader({
+				request,
+				params: matches[index].params
+			}));
+		} catch (err) {
+			console.error("[RouteRenderer] loader error:", err);
+			throw err;
+		}
+	})).then((values) => {
+		const merged = {};
+		for (const value of values) if (value) Object.assign(merged, value);
+		return merged;
+	}), ROUTE_LOADER_TIMEOUT_MS, "Timed out while loading documentation data");
+	cacheRouteEntry(loaderDataCache, key, pending);
+	pending.catch(() => loaderDataCache.delete(key));
+	return pending;
+}
+function RouteContent({ routes, initialPathname, resolvedBranch: initialResolvedBranch, basename, hasLoaderData }) {
+	const location = useLocation();
+	const currentPathname = location.pathname || initialPathname || "/";
+	const currentSearch = location.search || "";
+	const currentHash = location.hash || "";
+	const routeMatches = useMemo(() => matchRouteBranchWithParams(routes, currentPathname, basename), [
+		routes,
+		currentPathname,
+		basename
+	]);
+	const matchedBranch = useMemo(() => routeMatches.map((match) => match.route), [routeMatches]);
+	const isFirstRenderRef = useRef(true);
+	const isInitialNavigation = currentPathname === initialPathname && isFirstRenderRef.current;
+	const usesInitialResolvedBranch = !!initialResolvedBranch && isInitialNavigation;
+	const initialBranch = useMemo(() => usesInitialResolvedBranch ? initialResolvedBranch : matchedBranch, [
+		matchedBranch,
+		usesInitialResolvedBranch,
+		initialResolvedBranch
+	]);
+	const initialLoaderData = asLoaderData(use(RouteDataContext));
+	const initialDataAvailable = isInitialNavigation && hasLoaderData === true;
+	const needsAsyncWork = initialBranch.some((route) => !usesInitialResolvedBranch && !route.element && !route.Component && !!route.lazy || !!route.loader && !initialDataAvailable);
+	const routeScope = getRouteCacheScope(routes);
+	const navigationKey = `${routeScope}\u0000${currentPathname}\u0000${currentSearch}`;
+	const outerData = initialDataAvailable ? initialLoaderData : null;
+	const outerDataRef = useRef(outerData);
+	outerDataRef.current = outerData;
+	const navigationIdRef = useRef(0);
+	const committedNavigationRef = useRef("");
+	const [resolved, setResolved] = useState(!needsAsyncWork ? {
+		branch: initialBranch,
+		key: navigationKey,
+		pathname: currentPathname,
+		search: currentSearch,
+		loaderData: outerData
+	} : null);
+	const routeNeedsAsyncWork = needsAsyncWork && resolved?.key !== navigationKey;
+	useEffect(() => {
+		isFirstRenderRef.current = false;
+	}, []);
+	useEffect(() => {
+		if (!routeNeedsAsyncWork) return;
+		const navigationId = ++navigationIdRef.current;
+		let cancelled = false;
+		const matches = routeMatches;
+		const branch = matchedBranch;
+		const requestUrl = typeof window !== "undefined" ? new URL(`${currentPathname}${currentSearch}`, window.location.origin).href : `http://localhost${currentPathname}${currentSearch}`;
+		resolveRouteBranch(branch).then(async (resolvedBranch) => {
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			let loaderData;
+			try {
+				loaderData = await loadRouteData(getLoaderDataKey(routeScope, currentPathname, currentSearch), matches, resolvedBranch, new Request(requestUrl));
+			} catch {
+				loaderData = {
+					...outerDataRef.current || {},
+					__loaderError: true
+				};
+			}
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			startTransition(() => {
+				setResolved({
+					branch: resolvedBranch,
+					key: navigationKey,
+					pathname: currentPathname,
+					search: currentSearch,
+					loaderData
+				});
+			});
+		}).catch((error) => {
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			console.warn("[RouteRenderer] navigation error:", error);
+			startTransition(() => {
+				setResolved({
+					branch,
+					key: navigationKey,
+					pathname: currentPathname,
+					search: currentSearch,
+					loaderData: {
+						...outerDataRef.current || {},
+						__routeError: true
+					}
+				});
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		currentPathname,
+		currentSearch,
+		routeMatches,
+		matchedBranch,
+		routeNeedsAsyncWork,
+		navigationKey,
+		routeScope
+	]);
+	const hasResolvedCurrentRoute = resolved?.key === navigationKey;
+	const hasRenderableBranch = useCallback((candidate) => candidate.some((route) => route.element || route.Component), []);
+	const previousBranch = resolved?.branch;
+	const lastRenderableBranchRef = useRef([]);
+	const branch = usesInitialResolvedBranch ? hasResolvedCurrentRoute ? resolved.branch : initialBranch : !routeNeedsAsyncWork || hasResolvedCurrentRoute ? hasResolvedCurrentRoute ? resolved.branch : initialBranch : hasRenderableBranch(previousBranch || []) ? previousBranch || [] : hasRenderableBranch(lastRenderableBranchRef.current) ? lastRenderableBranchRef.current : matchedBranch;
+	if (hasResolvedCurrentRoute && hasRenderableBranch(branch)) lastRenderableBranchRef.current = branch;
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const commitKey = `${currentPathname}${currentSearch}${currentHash}`;
+		if (committedNavigationRef.current === commitKey) return;
+		if (routeNeedsAsyncWork && !hasResolvedCurrentRoute) return;
+		if (!hasRenderableBranch(branch)) return;
+		committedNavigationRef.current = commitKey;
+		window.dispatchEvent(new CustomEvent("boltdocs:route-commit", { detail: {
+			pathname: currentPathname,
+			search: currentSearch,
+			hash: currentHash
+		} }));
+	}, [
+		branch,
+		currentHash,
+		currentPathname,
+		currentSearch,
+		hasRenderableBranch,
+		hasResolvedCurrentRoute,
+		routeNeedsAsyncWork
+	]);
+	if (branch.length === 0) return null;
+	let currentElement = null;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const route = branch[i];
+		let element = route.element;
+		if (!element && route.Component) {
+			const Comp = route.Component;
+			element = /* @__PURE__ */ jsx(Comp, {}, route.path ?? `${route.index ? "index" : "route"}-${route.locale ?? "none"}`);
+		}
+		if (!element) continue;
+		if (currentElement === null) currentElement = element;
+		else {
+			let wrappedElement = element;
+			if (React.isValidElement(element)) {
+				const el = element;
+				const existingChildren = el.props.children;
+				wrappedElement = React.cloneElement(el, { children: existingChildren ?? /* @__PURE__ */ jsx(Outlet, {}) });
+			}
+			currentElement = /* @__PURE__ */ jsx(OutletContext.Provider, {
+				value: currentElement,
+				children: wrappedElement
+			});
+		}
+	}
+	const finalData = hasResolvedCurrentRoute && resolved.loaderData ? resolved.loaderData : outerData;
+	return /* @__PURE__ */ jsx(RouteDataContext.Provider, {
+		value: finalData,
+		children: currentElement
+	});
+}
+const RouteRenderer = ({ routes, pathname, loaderData, resolvedBranch, basename, defaultLocale, hasLoaderData = false, prefetch: prefetchProp, viewTransitions }) => {
+	const prefetchQueueRef = useRef(null);
+	if (!prefetchQueueRef.current) prefetchQueueRef.current = createPrefetchQueue();
+	const prefetchQueue = prefetchQueueRef.current;
+	useEffect(() => {
+		return () => prefetchQueue.clear();
+	}, [prefetchQueue]);
+	const prefetch = useCallback(async (to) => {
+		if (typeof window === "undefined" || !to) return;
+		const target = new URL(to, window.location.href);
+		if (target.origin !== window.location.origin || target.hash) return;
+		const key = `${getRouteCacheScope(routes)}:${target.pathname}${target.search}`;
+		const cached = prefetchCache.get(key);
+		if (cached) return cached;
+		const pending = prefetchQueue.enqueue(async () => {
+			const matches = matchRouteBranchWithParams(routes, target.pathname, basename);
+			if (matches.length === 0) return;
+			const branch = await resolveRouteBranch(matches.map((match) => match.route));
+			await loadRouteData(getLoaderDataKey(getRouteCacheScope(routes), target.pathname, target.search), matches, branch, new Request(target.href));
+		});
+		if (pending === PREFETCH_SKIPPED) return;
+		cacheRouteEntry(prefetchCache, key, pending);
+		try {
+			await pending;
+		} catch (error) {
+			prefetchCache.delete(key);
+			throw error;
+		}
+	}, [
+		routes,
+		basename,
+		prefetchQueue
+	]);
+	return /* @__PURE__ */ jsx(LocationProvider, {
+		pathname,
+		loaderData,
+		basename,
+		defaultLocale,
+		prefetch: prefetchProp || prefetch,
+		viewTransitions,
+		children: /* @__PURE__ */ jsx(RouteContent, {
+			routes,
+			initialPathname: pathname,
+			resolvedBranch,
+			basename,
+			hasLoaderData
+		})
+	});
+};
+
+//#endregion
+//#region src/client/router/url-contract.ts
+function normalizeUrlBase(base) {
+	if (!base || base === "/") return "/";
+	return (base.startsWith("/") ? base : `/${base}`).replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function normalizeUrlPath(path) {
+	if (!path) return "/";
+	const normalized = `/${path}`.replace(/\/+/g, "/");
+	if (normalized.length > 1 && normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+function hasUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/") return true;
+	return normalizedPath === normalizedBase || normalizedPath.startsWith(`${normalizedBase}/`);
+}
+function stripUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/") return normalizedPath;
+	if (!hasUrlBase(normalizedPath, normalizedBase)) return normalizedPath;
+	return normalizeUrlPath(normalizedPath.slice(normalizedBase.length) || "/");
+}
+function addUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/" || hasUrlBase(normalizedPath, normalizedBase)) return normalizedPath;
+	return normalizeUrlPath(`${normalizedBase}/${normalizedPath}`);
+}
+function getConfiguredLocales(config) {
+	if (!config.i18n) return [];
+	return Array.isArray(config.i18n.locales) ? [...config.i18n.locales] : Object.keys(config.i18n.locales);
+}
+function getConfiguredVersions(config) {
+	return config.versions?.versions.map((version) => version.path) || [];
+}
+function getVersionPrefixSegments(config) {
+	const prefix = config.versions?.prefix;
+	if (!prefix) return [];
+	return normalizeUrlPath(prefix).split("/").filter(Boolean);
+}
+function getVersionSegments(version, config) {
+	if (!version || !config.versions || !isConfiguredVersion(version, config)) return [];
+	return [...getVersionPrefixSegments(config), version];
+}
+function isConfiguredLocale(value, config) {
+	return !!value && getConfiguredLocales(config).includes(value);
+}
+function isConfiguredVersion(value, config) {
+	return !!value && getConfiguredVersions(config).includes(value);
+}
+function matchConfiguredVersion(parts, start, config) {
+	const prefix = getVersionPrefixSegments(config);
+	const versionIndex = start + prefix.length;
+	if (!prefix.every((segment, index) => parts[start + index] === segment) || !isConfiguredVersion(parts[versionIndex], config)) return { nextIndex: start };
+	return {
+		version: parts[versionIndex],
+		nextIndex: versionIndex + 1
+	};
+}
+function splitUrlReference(to) {
+	const firstDelimiter = to.search(/[?#]/);
+	if (firstDelimiter < 0) return {
+		pathname: to,
+		search: "",
+		hash: ""
+	};
+	const pathname = to.slice(0, firstDelimiter);
+	const suffix = to.slice(firstDelimiter);
+	const hashIndex = suffix.indexOf("#");
+	if (hashIndex < 0) return {
+		pathname,
+		search: suffix,
+		hash: ""
+	};
+	return {
+		pathname,
+		search: suffix.slice(0, hashIndex),
+		hash: suffix.slice(hashIndex)
+	};
+}
+function stripSiteProtocol(to) {
+	if (!to.startsWith("site:")) return {
+		value: to,
+		siteProtocol: false
+	};
+	return {
+		value: to.slice(5) || "/",
+		siteProtocol: true
+	};
+}
+/** Returns true for URI schemes such as `mailto:`, `tel:`, or `data:`. */
+function hasUriScheme(value) {
+	return /^[a-z][a-z\d+.-]*:/i.test(value);
+}
+function normalizeSuffix(value, prefix) {
+	if (!value) return "";
+	return value.startsWith(prefix) ? value : `${prefix}${value}`;
+}
+function getRouteHint(pathname, routes) {
+	if (!routes) return void 0;
+	const normalized = normalizeUrlPath(pathname);
+	return routes.find((route) => normalizeUrlPath(route.path) === normalized);
+}
+function getCollectionFromPath(pathname, config) {
+	const parts = normalizeUrlPath(pathname).split("/").filter(Boolean);
+	const locales = getConfiguredLocales(config);
+	const collectionNames = Array.isArray(config.collections) ? config.collections : Object.keys(config.collections?.labels || {});
+	const collections = new Set(collectionNames);
+	let index = 0;
+	const versionMatch = matchConfiguredVersion(parts, index, config);
+	const version = versionMatch.version;
+	index = versionMatch.nextIndex;
+	let locale;
+	if (locales.includes(parts[index] || "")) {
+		locale = parts[index];
+		index++;
+	}
+	const collection = parts[index];
+	if (!collection || !collections.has(collection)) return { remainder: parts };
+	return {
+		collection,
+		locale,
+		version,
+		remainder: parts.slice(index + 1)
+	};
+}
+function classifyUrlPath(pathname, config, options = {}) {
+	if (options.kind) return options.kind;
+	const normalizedPath = normalizeUrlPath(pathname);
+	const hint = getRouteHint(normalizedPath, options.routes);
+	if (hint?.kind) return hint.kind;
+	if (hint?.collection) return "collection";
+	if (getCollectionFromPath(normalizedPath, config).collection) return "collection";
+	if (hasUrlBase(normalizedPath, config.base)) return "doc";
+	return "external";
+}
+function parseUrlReference(to, config, options = {}) {
+	const { value, siteProtocol } = stripSiteProtocol(to);
+	const split = splitUrlReference(value);
+	const pathname = normalizeUrlPath(split.pathname || "/");
+	const hadBase = hasUrlBase(pathname, config.base);
+	const kind = classifyUrlPath(pathname, config, options);
+	if (kind === "doc") {
+		const parts = stripUrlBase(pathname, config.base).split("/").filter(Boolean);
+		let index = 0;
+		const versionMatch = matchConfiguredVersion(parts, index, config);
+		const version = versionMatch.version;
+		index = versionMatch.nextIndex;
+		const locale = isConfiguredLocale(parts[index], config) ? parts[index] : void 0;
+		if (locale) index++;
+		return {
+			pathname,
+			routePath: normalizeUrlPath(parts.slice(index).join("/")),
+			search: split.search,
+			hash: split.hash,
+			kind,
+			locale,
+			version,
+			siteProtocol,
+			hadBase
+		};
+	}
+	if (kind === "collection") {
+		const collection = getCollectionFromPath(pathname, config);
+		return {
+			pathname,
+			routePath: normalizeUrlPath(collection.remainder.join("/")),
+			search: split.search,
+			hash: split.hash,
+			kind,
+			locale: collection.locale,
+			version: collection.version,
+			collection: collection.collection,
+			siteProtocol,
+			hadBase
+		};
+	}
+	const parts = pathname.split("/").filter(Boolean);
+	const locale = isConfiguredLocale(parts[0], config) ? parts[0] : void 0;
+	return {
+		pathname,
+		routePath: normalizeUrlPath((locale ? parts.slice(1) : parts).join("/")),
+		search: split.search,
+		hash: split.hash,
+		kind,
+		locale,
+		siteProtocol,
+		hadBase
+	};
+}
+function buildUrl(options, config) {
+	const routePath = normalizeUrlPath(options.path || "/");
+	const locale = options.locale && options.locale !== config.i18n?.defaultLocale ? options.locale : void 0;
+	const search = normalizeSuffix(options.search, "?");
+	const hash = normalizeSuffix(options.hash, "#");
+	let pathname;
+	if (options.kind === "doc") pathname = normalizeUrlPath([
+		normalizeUrlBase(config.base) === "/" ? void 0 : normalizeUrlBase(config.base).slice(1),
+		...getVersionSegments(options.version, config),
+		locale,
+		routePath === "/" ? void 0 : routePath.slice(1)
+	].filter(Boolean).join("/"));
+	else if (options.kind === "collection") {
+		if (!options.collection) throw new Error("A collection route requires a collection name");
+		pathname = normalizeUrlPath([
+			normalizeUrlBase(config.base) === "/" ? void 0 : normalizeUrlBase(config.base).slice(1),
+			...getVersionSegments(options.version, config),
+			locale,
+			options.collection,
+			routePath === "/" ? void 0 : routePath.slice(1)
+		].filter(Boolean).join("/"));
+	} else pathname = normalizeUrlPath([locale, routePath === "/" ? void 0 : routePath.slice(1)].filter(Boolean).join("/"));
+	return `${pathname}${search}${hash}`;
+}
+function resolveUrlReference(to, config, options = {}) {
+	const { value, siteProtocol } = stripSiteProtocol(to);
+	if (hasUriScheme(value) || /^(?:https?:)?\/\//i.test(value)) return to;
+	if (value.startsWith("#") || value.startsWith("?")) return siteProtocol ? value : to;
+	const parsed = parseUrlReference(value, config, options);
+	const kind = options.kind || parsed.kind;
+	const locale = options.locale ?? parsed.locale;
+	const version = options.version ?? parsed.version;
+	const derived = getCollectionFromPath(stripUrlBase(parsed.pathname, config.base), config);
+	const collection = parsed.collection ?? derived.collection;
+	const routePath = derived.collection && !parsed.collection ? normalizeUrlPath(derived.remainder.join("/")) : parsed.routePath;
+	return buildUrl({
+		kind: collection || parsed.kind === "collection" ? "collection" : kind,
+		path: routePath,
+		locale,
+		version,
+		collection,
+		search: parsed.search,
+		hash: parsed.hash,
+		hadBase: parsed.hadBase
+	}, config);
+}
+
+//#endregion
+export { useRouteData as A, normalizeBasename as B, Outlet as C, useMatches as D, useLocation as E, PrefetchContext as F, RouteDataContext as I, defaultNavigate as L, LocationProvider as M, MatchesContext as N, useNavigate as O, NavigateContext as P, addBasename as R, resolveRouteBranch as S, useLoaderData as T, stripBasename as V, stripSiteProtocol as _, getConfiguredVersions as a, matchRouteBranch as b, hasUriScheme as c, isConfiguredVersion as d, normalizeUrlBase as f, splitUrlReference as g, resolveUrlReference as h, getConfiguredLocales as i, LocationContext as j, usePrefetch as k, hasUrlBase as l, parseUrlReference as m, buildUrl as n, getVersionPrefixSegments as o, normalizeUrlPath as p, classifyUrlPath as r, getVersionSegments as s, addUrlBase as t, isConfiguredLocale as u, stripUrlBase as v, OutletContext as w, matchRouteBranchWithParams as x, RouteRenderer as y, hasBasename as z };