docs-i18n 0.12.0 → 0.13.0

package/admin/dist/server/server.js

@@ -1,2421 +1,12 @@
 import { i as __toESM, r as __require, t as __commonJSMin } from "./assets/chunk-CNvmzFzq.js";
 import { l as require_react, n as routerContext, r as require_jsx_runtime, t as useRouter } from "./assets/useRouter-BXJvr8to.js";
-import { A as decodePath, B as replaceEqualDeep, C as processRouteMasks, D as DEFAULT_PROTOCOL_ALLOWLIST, E as invariant, F as isDangerousProtocol, L as isPromise, M as encodePathLikeUrl, N as escapeHtml, O as arraysEqual, P as functionalUpdate, R as last, S as findSingleMatch, T as createLRUCache, _ as trimPath, a as matchContext, b as findFlatMatch, c as rootRouteId, d as compileDecodeCharMap, g as resolvePath, j as deepEqual, k as createControlledPromise, l as isNotFound, m as joinPaths, n as require_react_dom, o as ClientOnly, p as interpolatePath, r as useStore, t as getServerFnById, u as cleanPath, w as processRouteTree, x as findRouteMatch, y as trimPathRight, z as nullReplaceEqualDeep } from "./assets/__tanstack-start-server-fn-resolver-D1Ni2lpa.js";
-import { n as getAuth } from "./assets/auth.server-BLVDnTCZ.js";
+import { A as decodePath, E as invariant, T as createLRUCache, a as matchContext, c as rootRouteId, l as isNotFound, n as require_react_dom, t as getServerFnById } from "./assets/__tanstack-start-server-fn-resolver-SG4WUVWE.js";
+import { c as ErrorComponent, g as executeRewriteInput, p as createMemoryHistory, r as SafeFragment, s as CatchBoundary, t as Match, u as resolveManifestAssetLink } from "./assets/Match-BeWrYoSG.js";
+import { a as createNullProtoObject, c as TSS_CONTENT_TYPE_FRAMED_VERSIONED, d as X_TSS_RAW_RESPONSE, f as X_TSS_SERIALIZED, h as isResolvedRedirect, i as runWithStartContext, l as TSS_FORMDATA_CONTEXT, m as isRedirect, n as flattenMiddlewares, o as safeObjectMerge, p as mergeHeaders, r as getStartOptions, s as FrameType, u as TSS_SERVER_FUNCTION } from "./assets/createServerFn-CAF9Kl7K.js";
+import { n as getResponse, r as requestHandler } from "./assets/request-response-Bj40K48O.js";
+import { n as getAuth, t as ensureMigrations } from "./assets/auth.server-C5kH0jex.js";
 import { ReadableStream as ReadableStream$1 } from "node:stream/web";
 import { PassThrough, Readable } from "node:stream";
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/scroll-restoration.js
-function getSafeSessionStorage() {
-	try {
-		if (typeof window !== "undefined" && typeof window.sessionStorage === "object") return window.sessionStorage;
-	} catch {}
-}
-/** SessionStorage key used to persist scroll restoration state. */
-/** SessionStorage key used to store scroll positions across navigations. */
-/** SessionStorage key used to store scroll positions across navigations. */
-var storageKey = "tsr-scroll-restoration-v1_3";
-function createScrollRestorationCache() {
-	const safeSessionStorage = getSafeSessionStorage();
-	if (!safeSessionStorage) return null;
-	const persistedState = safeSessionStorage.getItem(storageKey);
-	let state = persistedState ? JSON.parse(persistedState) : {};
-	return {
-		state,
-		set: (updater) => {
-			state = functionalUpdate(updater, state) || state;
-			try {
-				safeSessionStorage.setItem(storageKey, JSON.stringify(state));
-			} catch {
-				console.warn("[ts-router] Could not persist scroll restoration state to sessionStorage.");
-			}
-		}
-	};
-}
-createScrollRestorationCache();
-/**
-* The default `getKey` function for `useScrollRestoration`.
-* It returns the `key` from the location state or the `href` of the location.
-*
-* The `location.href` is used as a fallback to support the use case where the location state is not available like the initial render.
-*/
-/**
-* Default scroll restoration cache key: location state key or full href.
-*/
-var defaultGetScrollRestorationKey = (location) => {
-	return location.state.__TSR_key || location.href;
-};
-function restoreScroll({ storageKey, key, behavior, shouldScrollRestoration, scrollToTopSelectors, location }) {
-	let byKey;
-	try {
-		byKey = JSON.parse(sessionStorage.getItem(storageKey) || "{}");
-	} catch (error) {
-		console.error(error);
-		return;
-	}
-	const resolvedKey = key || window.history.state?.__TSR_key;
-	const elementEntries = byKey[resolvedKey];
-	scroll: {
-		if (shouldScrollRestoration && elementEntries && Object.keys(elementEntries).length > 0) {
-			for (const elementSelector in elementEntries) {
-				const entry = elementEntries[elementSelector];
-				if (elementSelector === "window") window.scrollTo({
-					top: entry.scrollY,
-					left: entry.scrollX,
-					behavior
-				});
-				else if (elementSelector) {
-					const element = document.querySelector(elementSelector);
-					if (element) {
-						element.scrollLeft = entry.scrollX;
-						element.scrollTop = entry.scrollY;
-					}
-				}
-			}
-			break scroll;
-		}
-		const hash = (location ?? window.location).hash.split("#", 2)[1];
-		if (hash) {
-			const hashScrollIntoViewOptions = window.history.state?.__hashScrollIntoViewOptions ?? true;
-			if (hashScrollIntoViewOptions) {
-				const el = document.getElementById(hash);
-				if (el) el.scrollIntoView(hashScrollIntoViewOptions);
-			}
-			break scroll;
-		}
-		const scrollOptions = {
-			top: 0,
-			left: 0,
-			behavior
-		};
-		window.scrollTo(scrollOptions);
-		if (scrollToTopSelectors) for (const selector of scrollToTopSelectors) {
-			if (selector === "window") continue;
-			const element = typeof selector === "function" ? selector() : document.querySelector(selector);
-			if (element) element.scrollTo(scrollOptions);
-		}
-	}
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/qss.js
-/**
-* Program is a reimplementation of the `qss` package:
-* Copyright (c) Luke Edwards luke.edwards05@gmail.com, MIT License
-* https://github.com/lukeed/qss/blob/master/license.md
-*
-* This reimplementation uses modern browser APIs
-* (namely URLSearchParams) and TypeScript while still
-* maintaining the original functionality and interface.
-*
-* Update: this implementation has also been mangled to
-* fit exactly our use-case (single value per key in encoding).
-*/
-/**
-* Encodes an object into a query string.
-* @param obj - The object to encode into a query string.
-* @param stringify - An optional custom stringify function.
-* @returns The encoded query string.
-* @example
-* ```
-* // Example input: encode({ token: 'foo', key: 'value' })
-* // Expected output: "token=foo&key=value"
-* ```
-*/
-function encode(obj, stringify = String) {
-	const result = new URLSearchParams();
-	for (const key in obj) {
-		const val = obj[key];
-		if (val !== void 0) result.set(key, stringify(val));
-	}
-	return result.toString();
-}
-/**
-* Converts a string value to its appropriate type (string, number, boolean).
-* @param mix - The string value to convert.
-* @returns The converted value.
-* @example
-* // Example input: toValue("123")
-* // Expected output: 123
-*/
-function toValue(str) {
-	if (!str) return "";
-	if (str === "false") return false;
-	if (str === "true") return true;
-	return +str * 0 === 0 && +str + "" === str ? +str : str;
-}
-/**
-* Decodes a query string into an object.
-* @param str - The query string to decode.
-* @returns The decoded key-value pairs in an object format.
-* @example
-* // Example input: decode("token=foo&key=value")
-* // Expected output: { "token": "foo", "key": "value" }
-*/
-function decode(str) {
-	const searchParams = new URLSearchParams(str);
-	const result = Object.create(null);
-	for (const [key, value] of searchParams.entries()) {
-		const previousValue = result[key];
-		if (previousValue == null) result[key] = toValue(value);
-		else if (Array.isArray(previousValue)) previousValue.push(toValue(value));
-		else result[key] = [previousValue, toValue(value)];
-	}
-	return result;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/searchParams.js
-/** Default `parseSearch` that strips leading '?' and JSON-parses values. */
-var defaultParseSearch = parseSearchWith(JSON.parse);
-/** Default `stringifySearch` using JSON.stringify for complex values. */
-var defaultStringifySearch = stringifySearchWith(JSON.stringify, JSON.parse);
-/**
-* Build a `parseSearch` function using a provided JSON-like parser.
-*
-* The returned function strips a leading `?`, decodes values, and attempts to
-* JSON-parse string values using the given `parser`.
-*
-* @param parser Function to parse a string value (e.g. `JSON.parse`).
-* @returns A `parseSearch` function compatible with `Router` options.
-* @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization
-*/
-function parseSearchWith(parser) {
-	return (searchStr) => {
-		if (searchStr[0] === "?") searchStr = searchStr.substring(1);
-		const query = decode(searchStr);
-		for (const key in query) {
-			const value = query[key];
-			if (typeof value === "string") try {
-				query[key] = parser(value);
-			} catch (_err) {}
-		}
-		return query;
-	};
-}
-/**
-* Build a `stringifySearch` function using a provided serializer.
-*
-* Non-primitive values are serialized with `stringify`. If a `parser` is
-* supplied, string values that are parseable are re-serialized to ensure
-* symmetry with `parseSearch`.
-*
-* @param stringify Function to serialize a value (e.g. `JSON.stringify`).
-* @param parser Optional parser to detect parseable strings.
-* @returns A `stringifySearch` function compatible with `Router` options.
-* @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization
-*/
-function stringifySearchWith(stringify, parser) {
-	const hasParser = typeof parser === "function";
-	function stringifyValue(val) {
-		if (typeof val === "object" && val !== null) try {
-			return stringify(val);
-		} catch (_err) {}
-		else if (hasParser && typeof val === "string") try {
-			parser(val);
-			return stringify(val);
-		} catch (_err) {}
-		return val;
-	}
-	return (search) => {
-		const searchStr = encode(search, stringifyValue);
-		return searchStr ? `?${searchStr}` : "";
-	};
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/redirect.js
-/**
-* Create a redirect Response understood by TanStack Router.
-*
-* Use from route `loader`/`beforeLoad` or server functions to trigger a
-* navigation. If `throw: true` is set, the redirect is thrown instead of
-* returned. When an absolute `href` is supplied and `reloadDocument` is not
-* set, a full-document navigation is inferred.
-*
-* @param opts Options for the redirect. Common fields:
-* - `href`: absolute URL for external redirects; infers `reloadDocument`.
-* - `statusCode`: HTTP status code to use (defaults to 307).
-* - `headers`: additional headers to include on the Response.
-* - Standard navigation options like `to`, `params`, `search`, `replace`,
-*   and `reloadDocument` for internal redirects.
-* @returns A Response augmented with router navigation options.
-* @link https://tanstack.com/router/latest/docs/framework/react/api/router/redirectFunction
-*/
-function redirect(opts) {
-	opts.statusCode = opts.statusCode || opts.code || 307;
-	if (!opts._builtLocation && !opts.reloadDocument && typeof opts.href === "string") try {
-		new URL(opts.href);
-		opts.reloadDocument = true;
-	} catch {}
-	const headers = new Headers(opts.headers);
-	if (opts.href && headers.get("Location") === null) headers.set("Location", opts.href);
-	const response = new Response(null, {
-		status: opts.statusCode,
-		headers
-	});
-	response.options = opts;
-	if (opts.throw) throw response;
-	return response;
-}
-/** Check whether a value is a TanStack Router redirect Response. */
-/** Check whether a value is a TanStack Router redirect Response. */
-function isRedirect(obj) {
-	return obj instanceof Response && !!obj.options;
-}
-/** True if value is a redirect with a resolved `href` location. */
-/** True if value is a redirect with a resolved `href` location. */
-function isResolvedRedirect(obj) {
-	return isRedirect(obj) && !!obj.options.href;
-}
-/** Parse a serialized redirect object back into a redirect Response. */
-/** Parse a serialized redirect object back into a redirect Response. */
-function parseRedirect(obj) {
-	if (obj !== null && typeof obj === "object" && obj.isSerializedRedirect) return redirect(obj);
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/rewrite.js
-/** Compose multiple rewrite pairs into a single in/out rewrite. */
-/** Compose multiple rewrite pairs into a single in/out rewrite. */
-function composeRewrites(rewrites) {
-	return {
-		input: ({ url }) => {
-			for (const rewrite of rewrites) url = executeRewriteInput(rewrite, url);
-			return url;
-		},
-		output: ({ url }) => {
-			for (let i = rewrites.length - 1; i >= 0; i--) url = executeRewriteOutput(rewrites[i], url);
-			return url;
-		}
-	};
-}
-/** Create a rewrite pair that strips/adds a basepath on input/output. */
-/** Create a rewrite pair that strips/adds a basepath on input/output. */
-function rewriteBasepath(opts) {
-	const trimmedBasepath = trimPath(opts.basepath);
-	const normalizedBasepath = `/${trimmedBasepath}`;
-	const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
-	const checkBasepath = opts.caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
-	const checkBasepathWithSlash = opts.caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
-	return {
-		input: ({ url }) => {
-			const pathname = opts.caseSensitive ? url.pathname : url.pathname.toLowerCase();
-			if (pathname === checkBasepath) url.pathname = "/";
-			else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length);
-			return url;
-		},
-		output: ({ url }) => {
-			url.pathname = joinPaths([
-				"/",
-				trimmedBasepath,
-				url.pathname
-			]);
-			return url;
-		}
-	};
-}
-/** Execute a location input rewrite if provided. */
-/** Execute a location input rewrite if provided. */
-function executeRewriteInput(rewrite, url) {
-	const res = rewrite?.input?.({ url });
-	if (res) {
-		if (typeof res === "string") return new URL(res);
-		else if (res instanceof URL) return res;
-	}
-	return url;
-}
-/** Execute a location output rewrite if provided. */
-/** Execute a location output rewrite if provided. */
-function executeRewriteOutput(rewrite, url) {
-	const res = rewrite?.output?.({ url });
-	if (res) {
-		if (typeof res === "string") return new URL(res);
-		else if (res instanceof URL) return res;
-	}
-	return url;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/stores.js
-/** SSR non-reactive createMutableStore */
-function createNonReactiveMutableStore(initialValue) {
-	let value = initialValue;
-	return {
-		get state() {
-			return value;
-		},
-		setState(updater) {
-			value = updater(value);
-		}
-	};
-}
-/** SSR non-reactive createReadonlyStore */
-function createNonReactiveReadonlyStore(read) {
-	return { get state() {
-		return read();
-	} };
-}
-function createRouterStores(initialState, config) {
-	const { createMutableStore, createReadonlyStore, batch, init } = config;
-	const activeMatchStoresById = /* @__PURE__ */ new Map();
-	const pendingMatchStoresById = /* @__PURE__ */ new Map();
-	const cachedMatchStoresById = /* @__PURE__ */ new Map();
-	const status = createMutableStore(initialState.status);
-	const loadedAt = createMutableStore(initialState.loadedAt);
-	const isLoading = createMutableStore(initialState.isLoading);
-	const isTransitioning = createMutableStore(initialState.isTransitioning);
-	const location = createMutableStore(initialState.location);
-	const resolvedLocation = createMutableStore(initialState.resolvedLocation);
-	const statusCode = createMutableStore(initialState.statusCode);
-	const redirect = createMutableStore(initialState.redirect);
-	const matchesId = createMutableStore([]);
-	const pendingMatchesId = createMutableStore([]);
-	const cachedMatchesId = createMutableStore([]);
-	const activeMatchesSnapshot = createReadonlyStore(() => readPoolMatches(activeMatchStoresById, matchesId.state));
-	const pendingMatchesSnapshot = createReadonlyStore(() => readPoolMatches(pendingMatchStoresById, pendingMatchesId.state));
-	const cachedMatchesSnapshot = createReadonlyStore(() => readPoolMatches(cachedMatchStoresById, cachedMatchesId.state));
-	const firstMatchId = createReadonlyStore(() => matchesId.state[0]);
-	const hasPendingMatches = createReadonlyStore(() => matchesId.state.some((matchId) => {
-		return activeMatchStoresById.get(matchId)?.state.status === "pending";
-	}));
-	const matchRouteReactivity = createReadonlyStore(() => ({
-		locationHref: location.state.href,
-		resolvedLocationHref: resolvedLocation.state?.href,
-		status: status.state
-	}));
-	const __store = createReadonlyStore(() => ({
-		status: status.state,
-		loadedAt: loadedAt.state,
-		isLoading: isLoading.state,
-		isTransitioning: isTransitioning.state,
-		matches: activeMatchesSnapshot.state,
-		location: location.state,
-		resolvedLocation: resolvedLocation.state,
-		statusCode: statusCode.state,
-		redirect: redirect.state
-	}));
-	const matchStoreByRouteIdCache = createLRUCache(64);
-	function getMatchStoreByRouteId(routeId) {
-		let cached = matchStoreByRouteIdCache.get(routeId);
-		if (!cached) {
-			cached = createReadonlyStore(() => {
-				const ids = matchesId.state;
-				for (const id of ids) {
-					const matchStore = activeMatchStoresById.get(id);
-					if (matchStore && matchStore.routeId === routeId) return matchStore.state;
-				}
-			});
-			matchStoreByRouteIdCache.set(routeId, cached);
-		}
-		return cached;
-	}
-	const store = {
-		status,
-		loadedAt,
-		isLoading,
-		isTransitioning,
-		location,
-		resolvedLocation,
-		statusCode,
-		redirect,
-		matchesId,
-		pendingMatchesId,
-		cachedMatchesId,
-		activeMatchesSnapshot,
-		pendingMatchesSnapshot,
-		cachedMatchesSnapshot,
-		firstMatchId,
-		hasPendingMatches,
-		matchRouteReactivity,
-		activeMatchStoresById,
-		pendingMatchStoresById,
-		cachedMatchStoresById,
-		__store,
-		getMatchStoreByRouteId,
-		setActiveMatches,
-		setPendingMatches,
-		setCachedMatches
-	};
-	setActiveMatches(initialState.matches);
-	init?.(store);
-	function setActiveMatches(nextMatches) {
-		reconcileMatchPool(nextMatches, activeMatchStoresById, matchesId, createMutableStore, batch);
-	}
-	function setPendingMatches(nextMatches) {
-		reconcileMatchPool(nextMatches, pendingMatchStoresById, pendingMatchesId, createMutableStore, batch);
-	}
-	function setCachedMatches(nextMatches) {
-		reconcileMatchPool(nextMatches, cachedMatchStoresById, cachedMatchesId, createMutableStore, batch);
-	}
-	return store;
-}
-function readPoolMatches(pool, ids) {
-	const matches = [];
-	for (const id of ids) {
-		const matchStore = pool.get(id);
-		if (matchStore) matches.push(matchStore.state);
-	}
-	return matches;
-}
-function reconcileMatchPool(nextMatches, pool, idStore, createMutableStore, batch) {
-	const nextIds = nextMatches.map((d) => d.id);
-	const nextIdSet = new Set(nextIds);
-	batch(() => {
-		for (const id of pool.keys()) if (!nextIdSet.has(id)) pool.delete(id);
-		for (const nextMatch of nextMatches) {
-			const existing = pool.get(nextMatch.id);
-			if (!existing) {
-				const matchStore = createMutableStore(nextMatch);
-				matchStore.routeId = nextMatch.routeId;
-				pool.set(nextMatch.id, matchStore);
-				continue;
-			}
-			existing.routeId = nextMatch.routeId;
-			if (existing.state !== nextMatch) existing.setState(() => nextMatch);
-		}
-		if (!arraysEqual(idStore.state, nextIds)) idStore.setState(() => nextIds);
-	});
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/load-matches.js
-var triggerOnReady = (inner) => {
-	if (!inner.rendered) {
-		inner.rendered = true;
-		return inner.onReady?.();
-	}
-};
-var resolvePreload = (inner, matchId) => {
-	return !!(inner.preload && !inner.router.stores.activeMatchStoresById.has(matchId));
-};
-/**
-* Builds the accumulated context from router options and all matches up to (and optionally including) the given index.
-* Merges __routeContext and __beforeLoadContext from each match.
-*/
-var buildMatchContext = (inner, index, includeCurrentMatch = true) => {
-	const context = { ...inner.router.options.context ?? {} };
-	const end = includeCurrentMatch ? index : index - 1;
-	for (let i = 0; i <= end; i++) {
-		const innerMatch = inner.matches[i];
-		if (!innerMatch) continue;
-		const m = inner.router.getMatch(innerMatch.id);
-		if (!m) continue;
-		Object.assign(context, m.__routeContext, m.__beforeLoadContext);
-	}
-	return context;
-};
-var getNotFoundBoundaryIndex = (inner, err) => {
-	if (!inner.matches.length) return;
-	const requestedRouteId = err.routeId;
-	const matchedRootIndex = inner.matches.findIndex((m) => m.routeId === inner.router.routeTree.id);
-	const rootIndex = matchedRootIndex >= 0 ? matchedRootIndex : 0;
-	let startIndex = requestedRouteId ? inner.matches.findIndex((match) => match.routeId === requestedRouteId) : inner.firstBadMatchIndex ?? inner.matches.length - 1;
-	if (startIndex < 0) startIndex = rootIndex;
-	for (let i = startIndex; i >= 0; i--) {
-		const match = inner.matches[i];
-		if (inner.router.looseRoutesById[match.routeId].options.notFoundComponent) return i;
-	}
-	return requestedRouteId ? startIndex : rootIndex;
-};
-var handleRedirectAndNotFound = (inner, match, err) => {
-	if (!isRedirect(err) && !isNotFound(err)) return;
-	if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) throw err;
-	if (match) {
-		match._nonReactive.beforeLoadPromise?.resolve();
-		match._nonReactive.loaderPromise?.resolve();
-		match._nonReactive.beforeLoadPromise = void 0;
-		match._nonReactive.loaderPromise = void 0;
-		match._nonReactive.error = err;
-		inner.updateMatch(match.id, (prev) => ({
-			...prev,
-			status: isRedirect(err) ? "redirected" : prev.status === "pending" ? "success" : prev.status,
-			context: buildMatchContext(inner, match.index),
-			isFetching: false,
-			error: err
-		}));
-		if (isNotFound(err) && !err.routeId) err.routeId = match.routeId;
-		match._nonReactive.loadPromise?.resolve();
-	}
-	if (isRedirect(err)) {
-		inner.rendered = true;
-		err.options._fromLocation = inner.location;
-		err.redirectHandled = true;
-		err = inner.router.resolveRedirect(err);
-	}
-	throw err;
-};
-var shouldSkipLoader = (inner, matchId) => {
-	const match = inner.router.getMatch(matchId);
-	if (!match) return true;
-	if (match.ssr === false) return true;
-	return false;
-};
-var syncMatchContext = (inner, matchId, index) => {
-	const nextContext = buildMatchContext(inner, index);
-	inner.updateMatch(matchId, (prev) => {
-		return {
-			...prev,
-			context: nextContext
-		};
-	});
-};
-var handleSerialError = (inner, index, err, routerCode) => {
-	const { id: matchId, routeId } = inner.matches[index];
-	const route = inner.router.looseRoutesById[routeId];
-	if (err instanceof Promise) throw err;
-	err.routerCode = routerCode;
-	inner.firstBadMatchIndex ??= index;
-	handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
-	try {
-		route.options.onError?.(err);
-	} catch (errorHandlerErr) {
-		err = errorHandlerErr;
-		handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
-	}
-	inner.updateMatch(matchId, (prev) => {
-		prev._nonReactive.beforeLoadPromise?.resolve();
-		prev._nonReactive.beforeLoadPromise = void 0;
-		prev._nonReactive.loadPromise?.resolve();
-		return {
-			...prev,
-			error: err,
-			status: "error",
-			isFetching: false,
-			updatedAt: Date.now(),
-			abortController: new AbortController()
-		};
-	});
-	if (!inner.preload && !isRedirect(err) && !isNotFound(err)) inner.serialError ??= err;
-};
-var isBeforeLoadSsr = (inner, matchId, index, route) => {
-	const existingMatch = inner.router.getMatch(matchId);
-	const parentMatchId = inner.matches[index - 1]?.id;
-	const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
-	if (inner.router.isShell()) {
-		existingMatch.ssr = route.id === rootRouteId;
-		return;
-	}
-	if (parentMatch?.ssr === false) {
-		existingMatch.ssr = false;
-		return;
-	}
-	const parentOverride = (tempSsr) => {
-		if (tempSsr === true && parentMatch?.ssr === "data-only") return "data-only";
-		return tempSsr;
-	};
-	const defaultSsr = inner.router.options.defaultSsr ?? true;
-	if (route.options.ssr === void 0) {
-		existingMatch.ssr = parentOverride(defaultSsr);
-		return;
-	}
-	if (typeof route.options.ssr !== "function") {
-		existingMatch.ssr = parentOverride(route.options.ssr);
-		return;
-	}
-	const { search, params } = existingMatch;
-	const ssrFnContext = {
-		search: makeMaybe(search, existingMatch.searchError),
-		params: makeMaybe(params, existingMatch.paramsError),
-		location: inner.location,
-		matches: inner.matches.map((match) => ({
-			index: match.index,
-			pathname: match.pathname,
-			fullPath: match.fullPath,
-			staticData: match.staticData,
-			id: match.id,
-			routeId: match.routeId,
-			search: makeMaybe(match.search, match.searchError),
-			params: makeMaybe(match.params, match.paramsError),
-			ssr: match.ssr
-		}))
-	};
-	const tempSsr = route.options.ssr(ssrFnContext);
-	if (isPromise(tempSsr)) return tempSsr.then((ssr) => {
-		existingMatch.ssr = parentOverride(ssr ?? defaultSsr);
-	});
-	existingMatch.ssr = parentOverride(tempSsr ?? defaultSsr);
-};
-var setupPendingTimeout = (inner, matchId, route, match) => {
-	if (match._nonReactive.pendingTimeout !== void 0) return;
-	route.options.pendingMs ?? inner.router.options.defaultPendingMs;
-	if (!!(inner.onReady && false));
-};
-var preBeforeLoadSetup = (inner, matchId, route) => {
-	const existingMatch = inner.router.getMatch(matchId);
-	if (!existingMatch._nonReactive.beforeLoadPromise && !existingMatch._nonReactive.loaderPromise) return;
-	setupPendingTimeout(inner, matchId, route, existingMatch);
-	const then = () => {
-		const match = inner.router.getMatch(matchId);
-		if (match.preload && (match.status === "redirected" || match.status === "notFound")) handleRedirectAndNotFound(inner, match, match.error);
-	};
-	return existingMatch._nonReactive.beforeLoadPromise ? existingMatch._nonReactive.beforeLoadPromise.then(then) : then();
-};
-var executeBeforeLoad = (inner, matchId, index, route) => {
-	const match = inner.router.getMatch(matchId);
-	let prevLoadPromise = match._nonReactive.loadPromise;
-	match._nonReactive.loadPromise = createControlledPromise(() => {
-		prevLoadPromise?.resolve();
-		prevLoadPromise = void 0;
-	});
-	const { paramsError, searchError } = match;
-	if (paramsError) handleSerialError(inner, index, paramsError, "PARSE_PARAMS");
-	if (searchError) handleSerialError(inner, index, searchError, "VALIDATE_SEARCH");
-	setupPendingTimeout(inner, matchId, route, match);
-	const abortController = new AbortController();
-	let isPending = false;
-	const pending = () => {
-		if (isPending) return;
-		isPending = true;
-		inner.updateMatch(matchId, (prev) => ({
-			...prev,
-			isFetching: "beforeLoad",
-			fetchCount: prev.fetchCount + 1,
-			abortController
-		}));
-	};
-	const resolve = () => {
-		match._nonReactive.beforeLoadPromise?.resolve();
-		match._nonReactive.beforeLoadPromise = void 0;
-		inner.updateMatch(matchId, (prev) => ({
-			...prev,
-			isFetching: false
-		}));
-	};
-	if (!route.options.beforeLoad) {
-		inner.router.batch(() => {
-			pending();
-			resolve();
-		});
-		return;
-	}
-	match._nonReactive.beforeLoadPromise = createControlledPromise();
-	const context = {
-		...buildMatchContext(inner, index, false),
-		...match.__routeContext
-	};
-	const { search, params, cause } = match;
-	const preload = resolvePreload(inner, matchId);
-	const beforeLoadFnContext = {
-		search,
-		abortController,
-		params,
-		preload,
-		context,
-		location: inner.location,
-		navigate: (opts) => inner.router.navigate({
-			...opts,
-			_fromLocation: inner.location
-		}),
-		buildLocation: inner.router.buildLocation,
-		cause: preload ? "preload" : cause,
-		matches: inner.matches,
-		routeId: route.id,
-		...inner.router.options.additionalContext
-	};
-	const updateContext = (beforeLoadContext) => {
-		if (beforeLoadContext === void 0) {
-			inner.router.batch(() => {
-				pending();
-				resolve();
-			});
-			return;
-		}
-		if (isRedirect(beforeLoadContext) || isNotFound(beforeLoadContext)) {
-			pending();
-			handleSerialError(inner, index, beforeLoadContext, "BEFORE_LOAD");
-		}
-		inner.router.batch(() => {
-			pending();
-			inner.updateMatch(matchId, (prev) => ({
-				...prev,
-				__beforeLoadContext: beforeLoadContext
-			}));
-			resolve();
-		});
-	};
-	let beforeLoadContext;
-	try {
-		beforeLoadContext = route.options.beforeLoad(beforeLoadFnContext);
-		if (isPromise(beforeLoadContext)) {
-			pending();
-			return beforeLoadContext.catch((err) => {
-				handleSerialError(inner, index, err, "BEFORE_LOAD");
-			}).then(updateContext);
-		}
-	} catch (err) {
-		pending();
-		handleSerialError(inner, index, err, "BEFORE_LOAD");
-	}
-	updateContext(beforeLoadContext);
-};
-var handleBeforeLoad = (inner, index) => {
-	const { id: matchId, routeId } = inner.matches[index];
-	const route = inner.router.looseRoutesById[routeId];
-	const serverSsr = () => {
-		{
-			const maybePromise = isBeforeLoadSsr(inner, matchId, index, route);
-			if (isPromise(maybePromise)) return maybePromise.then(queueExecution);
-		}
-		return queueExecution();
-	};
-	const execute = () => executeBeforeLoad(inner, matchId, index, route);
-	const queueExecution = () => {
-		if (shouldSkipLoader(inner, matchId)) return;
-		const result = preBeforeLoadSetup(inner, matchId, route);
-		return isPromise(result) ? result.then(execute) : execute();
-	};
-	return serverSsr();
-};
-var executeHead = (inner, matchId, route) => {
-	const match = inner.router.getMatch(matchId);
-	if (!match) return;
-	if (!route.options.head && !route.options.scripts && !route.options.headers) return;
-	const assetContext = {
-		ssr: inner.router.options.ssr,
-		matches: inner.matches,
-		match,
-		params: match.params,
-		loaderData: match.loaderData
-	};
-	return Promise.all([
-		route.options.head?.(assetContext),
-		route.options.scripts?.(assetContext),
-		route.options.headers?.(assetContext)
-	]).then(([headFnContent, scripts, headers]) => {
-		return {
-			meta: headFnContent?.meta,
-			links: headFnContent?.links,
-			headScripts: headFnContent?.scripts,
-			headers,
-			scripts,
-			styles: headFnContent?.styles
-		};
-	});
-};
-var getLoaderContext = (inner, matchPromises, matchId, index, route) => {
-	const parentMatchPromise = matchPromises[index - 1];
-	const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId);
-	const context = buildMatchContext(inner, index);
-	const preload = resolvePreload(inner, matchId);
-	return {
-		params,
-		deps: loaderDeps,
-		preload: !!preload,
-		parentMatchPromise,
-		abortController,
-		context,
-		location: inner.location,
-		navigate: (opts) => inner.router.navigate({
-			...opts,
-			_fromLocation: inner.location
-		}),
-		cause: preload ? "preload" : cause,
-		route,
-		...inner.router.options.additionalContext
-	};
-};
-var runLoader = async (inner, matchPromises, matchId, index, route) => {
-	try {
-		const match = inner.router.getMatch(matchId);
-		try {
-			if (match.ssr === true) loadRouteChunk(route);
-			const routeLoader = route.options.loader;
-			const loader = typeof routeLoader === "function" ? routeLoader : routeLoader?.handler;
-			const loaderResult = loader?.(getLoaderContext(inner, matchPromises, matchId, index, route));
-			const loaderResultIsPromise = !!loader && isPromise(loaderResult);
-			if (!!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise)) inner.updateMatch(matchId, (prev) => ({
-				...prev,
-				isFetching: "loader"
-			}));
-			if (loader) {
-				const loaderData = loaderResultIsPromise ? await loaderResult : loaderResult;
-				handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), loaderData);
-				if (loaderData !== void 0) inner.updateMatch(matchId, (prev) => ({
-					...prev,
-					loaderData
-				}));
-			}
-			if (route._lazyPromise) await route._lazyPromise;
-			const pendingPromise = match._nonReactive.minPendingPromise;
-			if (pendingPromise) await pendingPromise;
-			if (route._componentsPromise) await route._componentsPromise;
-			inner.updateMatch(matchId, (prev) => ({
-				...prev,
-				error: void 0,
-				context: buildMatchContext(inner, index),
-				status: "success",
-				isFetching: false,
-				updatedAt: Date.now()
-			}));
-		} catch (e) {
-			let error = e;
-			if (error?.name === "AbortError") {
-				if (match.abortController.signal.aborted) {
-					match._nonReactive.loaderPromise?.resolve();
-					match._nonReactive.loaderPromise = void 0;
-					return;
-				}
-				inner.updateMatch(matchId, (prev) => ({
-					...prev,
-					status: prev.status === "pending" ? "success" : prev.status,
-					isFetching: false,
-					context: buildMatchContext(inner, index)
-				}));
-				return;
-			}
-			const pendingPromise = match._nonReactive.minPendingPromise;
-			if (pendingPromise) await pendingPromise;
-			if (isNotFound(e)) await route.options.notFoundComponent?.preload?.();
-			handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), e);
-			try {
-				route.options.onError?.(e);
-			} catch (onErrorError) {
-				error = onErrorError;
-				handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), onErrorError);
-			}
-			if (!isRedirect(error) && !isNotFound(error)) await loadRouteChunk(route, ["errorComponent"]);
-			inner.updateMatch(matchId, (prev) => ({
-				...prev,
-				error,
-				context: buildMatchContext(inner, index),
-				status: "error",
-				isFetching: false
-			}));
-		}
-	} catch (err) {
-		const match = inner.router.getMatch(matchId);
-		if (match) match._nonReactive.loaderPromise = void 0;
-		handleRedirectAndNotFound(inner, match, err);
-	}
-};
-var loadRouteMatch = async (inner, matchPromises, index) => {
-	async function handleLoader(preload, prevMatch, previousRouteMatchId, match, route) {
-		const age = Date.now() - prevMatch.updatedAt;
-		const staleAge = preload ? route.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
-		const shouldReloadOption = route.options.shouldReload;
-		const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchPromises, matchId, index, route)) : shouldReloadOption;
-		const { status, invalid } = match;
-		const staleMatchShouldReload = age >= staleAge && (!!inner.forceStaleReload || match.cause === "enter" || previousRouteMatchId !== void 0 && previousRouteMatchId !== match.id);
-		loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? staleMatchShouldReload));
-		if (preload && route.options.preload === false) {} else if (loaderShouldRunAsync && !inner.sync && shouldReloadInBackground) {
-			loaderIsRunningAsync = true;
-			(async () => {
-				try {
-					await runLoader(inner, matchPromises, matchId, index, route);
-					const match = inner.router.getMatch(matchId);
-					match._nonReactive.loaderPromise?.resolve();
-					match._nonReactive.loadPromise?.resolve();
-					match._nonReactive.loaderPromise = void 0;
-					match._nonReactive.loadPromise = void 0;
-				} catch (err) {
-					if (isRedirect(err)) await inner.router.navigate(err.options);
-				}
-			})();
-		} else if (status !== "success" || loaderShouldRunAsync) await runLoader(inner, matchPromises, matchId, index, route);
-		else syncMatchContext(inner, matchId, index);
-	}
-	const { id: matchId, routeId } = inner.matches[index];
-	let loaderShouldRunAsync = false;
-	let loaderIsRunningAsync = false;
-	const route = inner.router.looseRoutesById[routeId];
-	const routeLoader = route.options.loader;
-	const shouldReloadInBackground = ((typeof routeLoader === "function" ? void 0 : routeLoader?.staleReloadMode) ?? inner.router.options.defaultStaleReloadMode) !== "blocking";
-	if (shouldSkipLoader(inner, matchId)) {
-		if (!inner.router.getMatch(matchId)) return inner.matches[index];
-		syncMatchContext(inner, matchId, index);
-		return inner.router.getMatch(matchId);
-	} else {
-		const prevMatch = inner.router.getMatch(matchId);
-		const activeIdAtIndex = inner.router.stores.matchesId.state[index];
-		const previousRouteMatchId = (activeIdAtIndex && inner.router.stores.activeMatchStoresById.get(activeIdAtIndex) || null)?.routeId === routeId ? activeIdAtIndex : inner.router.stores.activeMatchesSnapshot.state.find((d) => d.routeId === routeId)?.id;
-		const preload = resolvePreload(inner, matchId);
-		if (prevMatch._nonReactive.loaderPromise) {
-			if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload && shouldReloadInBackground) return prevMatch;
-			await prevMatch._nonReactive.loaderPromise;
-			const match = inner.router.getMatch(matchId);
-			const error = match._nonReactive.error || match.error;
-			if (error) handleRedirectAndNotFound(inner, match, error);
-			if (match.status === "pending") await handleLoader(preload, prevMatch, previousRouteMatchId, match, route);
-		} else {
-			const nextPreload = preload && !inner.router.stores.activeMatchStoresById.has(matchId);
-			const match = inner.router.getMatch(matchId);
-			match._nonReactive.loaderPromise = createControlledPromise();
-			if (nextPreload !== match.preload) inner.updateMatch(matchId, (prev) => ({
-				...prev,
-				preload: nextPreload
-			}));
-			await handleLoader(preload, prevMatch, previousRouteMatchId, match, route);
-		}
-	}
-	const match = inner.router.getMatch(matchId);
-	if (!loaderIsRunningAsync) {
-		match._nonReactive.loaderPromise?.resolve();
-		match._nonReactive.loadPromise?.resolve();
-		match._nonReactive.loadPromise = void 0;
-	}
-	clearTimeout(match._nonReactive.pendingTimeout);
-	match._nonReactive.pendingTimeout = void 0;
-	if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = void 0;
-	match._nonReactive.dehydrated = void 0;
-	const nextIsFetching = loaderIsRunningAsync ? match.isFetching : false;
-	if (nextIsFetching !== match.isFetching || match.invalid !== false) {
-		inner.updateMatch(matchId, (prev) => ({
-			...prev,
-			isFetching: nextIsFetching,
-			invalid: false
-		}));
-		return inner.router.getMatch(matchId);
-	} else return match;
-};
-async function loadMatches(arg) {
-	const inner = arg;
-	const matchPromises = [];
-	let beforeLoadNotFound;
-	for (let i = 0; i < inner.matches.length; i++) {
-		try {
-			const beforeLoad = handleBeforeLoad(inner, i);
-			if (isPromise(beforeLoad)) await beforeLoad;
-		} catch (err) {
-			if (isRedirect(err)) throw err;
-			if (isNotFound(err)) beforeLoadNotFound = err;
-			else if (!inner.preload) throw err;
-			break;
-		}
-		if (inner.serialError) break;
-	}
-	const baseMaxIndexExclusive = inner.firstBadMatchIndex ?? inner.matches.length;
-	const boundaryIndex = beforeLoadNotFound && !inner.preload ? getNotFoundBoundaryIndex(inner, beforeLoadNotFound) : void 0;
-	const maxIndexExclusive = beforeLoadNotFound && inner.preload ? 0 : boundaryIndex !== void 0 ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive) : baseMaxIndexExclusive;
-	let firstNotFound;
-	let firstUnhandledRejection;
-	for (let i = 0; i < maxIndexExclusive; i++) matchPromises.push(loadRouteMatch(inner, matchPromises, i));
-	try {
-		await Promise.all(matchPromises);
-	} catch {
-		const settled = await Promise.allSettled(matchPromises);
-		for (const result of settled) {
-			if (result.status !== "rejected") continue;
-			const reason = result.reason;
-			if (isRedirect(reason)) throw reason;
-			if (isNotFound(reason)) firstNotFound ??= reason;
-			else firstUnhandledRejection ??= reason;
-		}
-		if (firstUnhandledRejection !== void 0) throw firstUnhandledRejection;
-	}
-	const notFoundToThrow = firstNotFound ?? (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : void 0);
-	let headMaxIndex = inner.serialError ? inner.firstBadMatchIndex ?? 0 : inner.matches.length - 1;
-	if (!notFoundToThrow && beforeLoadNotFound && inner.preload) return inner.matches;
-	if (notFoundToThrow) {
-		const renderedBoundaryIndex = getNotFoundBoundaryIndex(inner, notFoundToThrow);
-		if (renderedBoundaryIndex === void 0) invariant();
-		const boundaryMatch = inner.matches[renderedBoundaryIndex];
-		const boundaryRoute = inner.router.looseRoutesById[boundaryMatch.routeId];
-		const defaultNotFoundComponent = inner.router.options?.defaultNotFoundComponent;
-		if (!boundaryRoute.options.notFoundComponent && defaultNotFoundComponent) boundaryRoute.options.notFoundComponent = defaultNotFoundComponent;
-		notFoundToThrow.routeId = boundaryMatch.routeId;
-		const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id;
-		inner.updateMatch(boundaryMatch.id, (prev) => ({
-			...prev,
-			...boundaryIsRoot ? {
-				status: "success",
-				globalNotFound: true,
-				error: void 0
-			} : {
-				status: "notFound",
-				error: notFoundToThrow
-			},
-			isFetching: false
-		}));
-		headMaxIndex = renderedBoundaryIndex;
-		await loadRouteChunk(boundaryRoute, ["notFoundComponent"]);
-	} else if (!inner.preload) {
-		const rootMatch = inner.matches[0];
-		if (!rootMatch.globalNotFound) {
-			if (inner.router.getMatch(rootMatch.id)?.globalNotFound) inner.updateMatch(rootMatch.id, (prev) => ({
-				...prev,
-				globalNotFound: false,
-				error: void 0
-			}));
-		}
-	}
-	if (inner.serialError && inner.firstBadMatchIndex !== void 0) {
-		const errorRoute = inner.router.looseRoutesById[inner.matches[inner.firstBadMatchIndex].routeId];
-		await loadRouteChunk(errorRoute, ["errorComponent"]);
-	}
-	for (let i = 0; i <= headMaxIndex; i++) {
-		const { id: matchId, routeId } = inner.matches[i];
-		const route = inner.router.looseRoutesById[routeId];
-		try {
-			const headResult = executeHead(inner, matchId, route);
-			if (headResult) {
-				const head = await headResult;
-				inner.updateMatch(matchId, (prev) => ({
-					...prev,
-					...head
-				}));
-			}
-		} catch (err) {
-			console.error(`Error executing head for route ${routeId}:`, err);
-		}
-	}
-	const readyPromise = triggerOnReady(inner);
-	if (isPromise(readyPromise)) await readyPromise;
-	if (notFoundToThrow) throw notFoundToThrow;
-	if (inner.serialError && !inner.preload && !inner.onReady) throw inner.serialError;
-	return inner.matches;
-}
-function preloadRouteComponents(route, componentTypesToLoad) {
-	const preloads = componentTypesToLoad.map((type) => route.options[type]?.preload?.()).filter(Boolean);
-	if (preloads.length === 0) return void 0;
-	return Promise.all(preloads);
-}
-function loadRouteChunk(route, componentTypesToLoad = componentTypes) {
-	if (!route._lazyLoaded && route._lazyPromise === void 0) if (route.lazyFn) route._lazyPromise = route.lazyFn().then((lazyRoute) => {
-		const { id: _id, ...options } = lazyRoute.options;
-		Object.assign(route.options, options);
-		route._lazyLoaded = true;
-		route._lazyPromise = void 0;
-	});
-	else route._lazyLoaded = true;
-	const runAfterLazy = () => route._componentsLoaded ? void 0 : componentTypesToLoad === componentTypes ? (() => {
-		if (route._componentsPromise === void 0) {
-			const componentsPromise = preloadRouteComponents(route, componentTypes);
-			if (componentsPromise) route._componentsPromise = componentsPromise.then(() => {
-				route._componentsLoaded = true;
-				route._componentsPromise = void 0;
-			});
-			else route._componentsLoaded = true;
-		}
-		return route._componentsPromise;
-	})() : preloadRouteComponents(route, componentTypesToLoad);
-	return route._lazyPromise ? route._lazyPromise.then(runAfterLazy) : runAfterLazy();
-}
-function makeMaybe(value, error) {
-	if (error) return {
-		status: "error",
-		error
-	};
-	return {
-		status: "success",
-		value
-	};
-}
-function routeNeedsPreload(route) {
-	for (const componentType of componentTypes) if (route.options[componentType]?.preload) return true;
-	return false;
-}
-var componentTypes = [
-	"component",
-	"errorComponent",
-	"pendingComponent",
-	"notFoundComponent"
-];
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+history@1.161.6/node_modules/@tanstack/history/dist/esm/index.js
-var stateIndexKey = "__TSR_index";
-function createHistory(opts) {
-	let location = opts.getLocation();
-	const subscribers = /* @__PURE__ */ new Set();
-	const notify = (action) => {
-		location = opts.getLocation();
-		subscribers.forEach((subscriber) => subscriber({
-			location,
-			action
-		}));
-	};
-	const handleIndexChange = (action) => {
-		if (opts.notifyOnIndexChange ?? true) notify(action);
-		else location = opts.getLocation();
-	};
-	const tryNavigation = async ({ task, navigateOpts, ...actionInfo }) => {
-		if (navigateOpts?.ignoreBlocker ?? false) {
-			task();
-			return;
-		}
-		const blockers = opts.getBlockers?.() ?? [];
-		const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE";
-		if (typeof document !== "undefined" && blockers.length && isPushOrReplace) for (const blocker of blockers) {
-			const nextLocation = parseHref(actionInfo.path, actionInfo.state);
-			if (await blocker.blockerFn({
-				currentLocation: location,
-				nextLocation,
-				action: actionInfo.type
-			})) {
-				opts.onBlocked?.();
-				return;
-			}
-		}
-		task();
-	};
-	return {
-		get location() {
-			return location;
-		},
-		get length() {
-			return opts.getLength();
-		},
-		subscribers,
-		subscribe: (cb) => {
-			subscribers.add(cb);
-			return () => {
-				subscribers.delete(cb);
-			};
-		},
-		push: (path, state, navigateOpts) => {
-			const currentIndex = location.state[stateIndexKey];
-			state = assignKeyAndIndex(currentIndex + 1, state);
-			tryNavigation({
-				task: () => {
-					opts.pushState(path, state);
-					notify({ type: "PUSH" });
-				},
-				navigateOpts,
-				type: "PUSH",
-				path,
-				state
-			});
-		},
-		replace: (path, state, navigateOpts) => {
-			const currentIndex = location.state[stateIndexKey];
-			state = assignKeyAndIndex(currentIndex, state);
-			tryNavigation({
-				task: () => {
-					opts.replaceState(path, state);
-					notify({ type: "REPLACE" });
-				},
-				navigateOpts,
-				type: "REPLACE",
-				path,
-				state
-			});
-		},
-		go: (index, navigateOpts) => {
-			tryNavigation({
-				task: () => {
-					opts.go(index);
-					handleIndexChange({
-						type: "GO",
-						index
-					});
-				},
-				navigateOpts,
-				type: "GO"
-			});
-		},
-		back: (navigateOpts) => {
-			tryNavigation({
-				task: () => {
-					opts.back(navigateOpts?.ignoreBlocker ?? false);
-					handleIndexChange({ type: "BACK" });
-				},
-				navigateOpts,
-				type: "BACK"
-			});
-		},
-		forward: (navigateOpts) => {
-			tryNavigation({
-				task: () => {
-					opts.forward(navigateOpts?.ignoreBlocker ?? false);
-					handleIndexChange({ type: "FORWARD" });
-				},
-				navigateOpts,
-				type: "FORWARD"
-			});
-		},
-		canGoBack: () => location.state[stateIndexKey] !== 0,
-		createHref: (str) => opts.createHref(str),
-		block: (blocker) => {
-			if (!opts.setBlockers) return () => {};
-			const blockers = opts.getBlockers?.() ?? [];
-			opts.setBlockers([...blockers, blocker]);
-			return () => {
-				const blockers = opts.getBlockers?.() ?? [];
-				opts.setBlockers?.(blockers.filter((b) => b !== blocker));
-			};
-		},
-		flush: () => opts.flush?.(),
-		destroy: () => opts.destroy?.(),
-		notify
-	};
-}
-function assignKeyAndIndex(index, state) {
-	if (!state) state = {};
-	const key = createRandomKey();
-	return {
-		...state,
-		key,
-		__TSR_key: key,
-		[stateIndexKey]: index
-	};
-}
-/**
-* Create an in-memory history implementation.
-* Ideal for server rendering, tests, and non-DOM environments.
-* @link https://tanstack.com/router/latest/docs/framework/react/guide/history-types
-*/
-function createMemoryHistory(opts = { initialEntries: ["/"] }) {
-	const entries = opts.initialEntries;
-	let index = opts.initialIndex ? Math.min(Math.max(opts.initialIndex, 0), entries.length - 1) : entries.length - 1;
-	const states = entries.map((_entry, index) => assignKeyAndIndex(index, void 0));
-	const getLocation = () => parseHref(entries[index], states[index]);
-	let blockers = [];
-	const _getBlockers = () => blockers;
-	const _setBlockers = (newBlockers) => blockers = newBlockers;
-	return createHistory({
-		getLocation,
-		getLength: () => entries.length,
-		pushState: (path, state) => {
-			if (index < entries.length - 1) {
-				entries.splice(index + 1);
-				states.splice(index + 1);
-			}
-			states.push(state);
-			entries.push(path);
-			index = Math.max(entries.length - 1, 0);
-		},
-		replaceState: (path, state) => {
-			states[index] = state;
-			entries[index] = path;
-		},
-		back: () => {
-			index = Math.max(index - 1, 0);
-		},
-		forward: () => {
-			index = Math.min(index + 1, entries.length - 1);
-		},
-		go: (n) => {
-			index = Math.min(Math.max(index + n, 0), entries.length - 1);
-		},
-		createHref: (path) => path,
-		getBlockers: _getBlockers,
-		setBlockers: _setBlockers
-	});
-}
-/**
-* Sanitize a path to prevent open redirect vulnerabilities.
-* Removes control characters and collapses leading double slashes.
-*/
-function sanitizePath(path) {
-	let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
-	if (sanitized.startsWith("//")) sanitized = "/" + sanitized.replace(/^\/+/, "");
-	return sanitized;
-}
-function parseHref(href, state) {
-	const sanitizedHref = sanitizePath(href);
-	const hashIndex = sanitizedHref.indexOf("#");
-	const searchIndex = sanitizedHref.indexOf("?");
-	const addedKey = createRandomKey();
-	return {
-		href: sanitizedHref,
-		pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
-		hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
-		search: searchIndex > -1 ? sanitizedHref.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
-		state: state || {
-			[stateIndexKey]: 0,
-			key: addedKey,
-			__TSR_key: addedKey
-		}
-	};
-}
-function createRandomKey() {
-	return (Math.random() + 1).toString(36).substring(7);
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/router.js
-/**
-* Compute whether path, href or hash changed between previous and current
-* resolved locations.
-*/
-function getLocationChangeInfo(location, resolvedLocation) {
-	const fromLocation = resolvedLocation;
-	const toLocation = location;
-	return {
-		fromLocation,
-		toLocation,
-		pathChanged: fromLocation?.pathname !== toLocation.pathname,
-		hrefChanged: fromLocation?.href !== toLocation.href,
-		hashChanged: fromLocation?.hash !== toLocation.hash
-	};
-}
-/**
-* Core, framework-agnostic router engine that powers TanStack Router.
-*
-* Provides navigation, matching, loading, preloading, caching and event APIs
-* used by framework adapters (React/Solid). Prefer framework helpers like
-* `createRouter` in app code.
-*
-* @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterType
-*/
-var RouterCore = class {
-	/**
-	* @deprecated Use the `createRouter` function instead
-	*/
-	constructor(options, getStoreConfig) {
-		this.tempLocationKey = `${Math.round(Math.random() * 1e7)}`;
-		this.resetNextScroll = true;
-		this.shouldViewTransition = void 0;
-		this.isViewTransitionTypesSupported = void 0;
-		this.subscribers = /* @__PURE__ */ new Set();
-		this.isScrollRestoring = false;
-		this.isScrollRestorationSetup = false;
-		this.startTransition = (fn) => fn();
-		this.update = (newOptions) => {
-			const prevOptions = this.options;
-			const prevBasepath = this.basepath ?? prevOptions?.basepath ?? "/";
-			const basepathWasUnset = this.basepath === void 0;
-			const prevRewriteOption = prevOptions?.rewrite;
-			this.options = {
-				...prevOptions,
-				...newOptions
-			};
-			this.isServer = this.options.isServer ?? typeof document === "undefined";
-			this.protocolAllowlist = new Set(this.options.protocolAllowlist);
-			if (this.options.pathParamsAllowedCharacters) this.pathParamsDecoder = compileDecodeCharMap(this.options.pathParamsAllowedCharacters);
-			if (!this.history || this.options.history && this.options.history !== this.history) if (!this.options.history) {} else this.history = this.options.history;
-			this.origin = this.options.origin;
-			if (!this.origin) this.origin = "http://localhost";
-			if (this.history) this.updateLatestLocation();
-			if (this.options.routeTree !== this.routeTree) {
-				this.routeTree = this.options.routeTree;
-				let processRouteTreeResult;
-				if (globalThis.__TSR_CACHE__ && globalThis.__TSR_CACHE__.routeTree === this.routeTree) {
-					const cached = globalThis.__TSR_CACHE__;
-					this.resolvePathCache = cached.resolvePathCache;
-					processRouteTreeResult = cached.processRouteTreeResult;
-				} else {
-					this.resolvePathCache = createLRUCache(1e3);
-					processRouteTreeResult = this.buildRouteTree();
-					if (globalThis.__TSR_CACHE__ === void 0) globalThis.__TSR_CACHE__ = {
-						routeTree: this.routeTree,
-						processRouteTreeResult,
-						resolvePathCache: this.resolvePathCache
-					};
-				}
-				this.setRoutes(processRouteTreeResult);
-			}
-			if (!this.stores && this.latestLocation) {
-				const config = this.getStoreConfig(this);
-				this.batch = config.batch;
-				this.stores = createRouterStores(getInitialRouterState(this.latestLocation), config);
-			}
-			let needsLocationUpdate = false;
-			const nextBasepath = this.options.basepath ?? "/";
-			const nextRewriteOption = this.options.rewrite;
-			if (basepathWasUnset || prevBasepath !== nextBasepath || prevRewriteOption !== nextRewriteOption) {
-				this.basepath = nextBasepath;
-				const rewrites = [];
-				const trimmed = trimPath(nextBasepath);
-				if (trimmed && trimmed !== "/") rewrites.push(rewriteBasepath({ basepath: nextBasepath }));
-				if (nextRewriteOption) rewrites.push(nextRewriteOption);
-				this.rewrite = rewrites.length === 0 ? void 0 : rewrites.length === 1 ? rewrites[0] : composeRewrites(rewrites);
-				if (this.history) this.updateLatestLocation();
-				needsLocationUpdate = true;
-			}
-			if (needsLocationUpdate && this.stores) this.stores.location.setState(() => this.latestLocation);
-			if (typeof window !== "undefined" && "CSS" in window && typeof window.CSS?.supports === "function") this.isViewTransitionTypesSupported = window.CSS.supports("selector(:active-view-transition-type(a)");
-		};
-		this.updateLatestLocation = () => {
-			this.latestLocation = this.parseLocation(this.history.location, this.latestLocation);
-		};
-		this.buildRouteTree = () => {
-			const result = processRouteTree(this.routeTree, this.options.caseSensitive, (route, i) => {
-				route.init({ originalIndex: i });
-			});
-			if (this.options.routeMasks) processRouteMasks(this.options.routeMasks, result.processedTree);
-			return result;
-		};
-		this.subscribe = (eventType, fn) => {
-			const listener = {
-				eventType,
-				fn
-			};
-			this.subscribers.add(listener);
-			return () => {
-				this.subscribers.delete(listener);
-			};
-		};
-		this.emit = (routerEvent) => {
-			this.subscribers.forEach((listener) => {
-				if (listener.eventType === routerEvent.type) listener.fn(routerEvent);
-			});
-		};
-		this.parseLocation = (locationToParse, previousLocation) => {
-			const parse = ({ pathname, search, hash, href, state }) => {
-				if (!this.rewrite && !/[ \x00-\x1f\x7f\u0080-\uffff]/.test(pathname)) {
-					const parsedSearch = this.options.parseSearch(search);
-					const searchStr = this.options.stringifySearch(parsedSearch);
-					return {
-						href: pathname + searchStr + hash,
-						publicHref: href,
-						pathname: decodePath(pathname).path,
-						external: false,
-						searchStr,
-						search: nullReplaceEqualDeep(previousLocation?.search, parsedSearch),
-						hash: decodePath(hash.slice(1)).path,
-						state: replaceEqualDeep(previousLocation?.state, state)
-					};
-				}
-				const fullUrl = new URL(href, this.origin);
-				const url = executeRewriteInput(this.rewrite, fullUrl);
-				const parsedSearch = this.options.parseSearch(url.search);
-				const searchStr = this.options.stringifySearch(parsedSearch);
-				url.search = searchStr;
-				return {
-					href: url.href.replace(url.origin, ""),
-					publicHref: href,
-					pathname: decodePath(url.pathname).path,
-					external: !!this.rewrite && url.origin !== this.origin,
-					searchStr,
-					search: nullReplaceEqualDeep(previousLocation?.search, parsedSearch),
-					hash: decodePath(url.hash.slice(1)).path,
-					state: replaceEqualDeep(previousLocation?.state, state)
-				};
-			};
-			const location = parse(locationToParse);
-			const { __tempLocation, __tempKey } = location.state;
-			if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
-				const parsedTempLocation = parse(__tempLocation);
-				parsedTempLocation.state.key = location.state.key;
-				parsedTempLocation.state.__TSR_key = location.state.__TSR_key;
-				delete parsedTempLocation.state.__tempLocation;
-				return {
-					...parsedTempLocation,
-					maskedLocation: location
-				};
-			}
-			return location;
-		};
-		this.resolvePathWithBase = (from, path) => {
-			return resolvePath({
-				base: from,
-				to: cleanPath(path),
-				trailingSlash: this.options.trailingSlash,
-				cache: this.resolvePathCache
-			});
-		};
-		this.matchRoutes = (pathnameOrNext, locationSearchOrOpts, opts) => {
-			if (typeof pathnameOrNext === "string") return this.matchRoutesInternal({
-				pathname: pathnameOrNext,
-				search: locationSearchOrOpts
-			}, opts);
-			return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
-		};
-		this.getMatchedRoutes = (pathname) => {
-			return getMatchedRoutes({
-				pathname,
-				routesById: this.routesById,
-				processedTree: this.processedTree
-			});
-		};
-		this.cancelMatch = (id) => {
-			const match = this.getMatch(id);
-			if (!match) return;
-			match.abortController.abort();
-			clearTimeout(match._nonReactive.pendingTimeout);
-			match._nonReactive.pendingTimeout = void 0;
-		};
-		this.cancelMatches = () => {
-			this.stores.pendingMatchesId.state.forEach((matchId) => {
-				this.cancelMatch(matchId);
-			});
-			this.stores.matchesId.state.forEach((matchId) => {
-				if (this.stores.pendingMatchStoresById.has(matchId)) return;
-				const match = this.stores.activeMatchStoresById.get(matchId)?.state;
-				if (!match) return;
-				if (match.status === "pending" || match.isFetching === "loader") this.cancelMatch(matchId);
-			});
-		};
-		this.buildLocation = (opts) => {
-			const build = (dest = {}) => {
-				const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
-				const lightweightResult = this.matchRoutesLightweight(currentLocation);
-				if (dest.from && false);
-				const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
-				const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
-				const fromSearch = lightweightResult.search;
-				const fromParams = Object.assign(Object.create(null), lightweightResult.params);
-				const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
-				const nextParams = dest.params === false || dest.params === null ? Object.create(null) : (dest.params ?? true) === true ? fromParams : Object.assign(fromParams, functionalUpdate(dest.params, fromParams));
-				const destMatchResult = this.getMatchedRoutes(nextTo);
-				let destRoutes = destMatchResult.matchedRoutes;
-				if ((!destMatchResult.foundRoute || destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"]) && this.options.notFoundRoute) destRoutes = [...destRoutes, this.options.notFoundRoute];
-				if (Object.keys(nextParams).length > 0) for (const route of destRoutes) {
-					const fn = route.options.params?.stringify ?? route.options.stringifyParams;
-					if (fn) try {
-						Object.assign(nextParams, fn(nextParams));
-					} catch {}
-				}
-				const nextPathname = opts.leaveParams ? nextTo : decodePath(interpolatePath({
-					path: nextTo,
-					params: nextParams,
-					decoder: this.pathParamsDecoder,
-					server: this.isServer
-				}).interpolatedPath).path;
-				let nextSearch = fromSearch;
-				if (opts._includeValidateSearch && this.options.search?.strict) {
-					const validatedSearch = {};
-					destRoutes.forEach((route) => {
-						if (route.options.validateSearch) try {
-							Object.assign(validatedSearch, validateSearch(route.options.validateSearch, {
-								...validatedSearch,
-								...nextSearch
-							}));
-						} catch {}
-					});
-					nextSearch = validatedSearch;
-				}
-				nextSearch = applySearchMiddleware({
-					search: nextSearch,
-					dest,
-					destRoutes,
-					_includeValidateSearch: opts._includeValidateSearch
-				});
-				nextSearch = nullReplaceEqualDeep(fromSearch, nextSearch);
-				const searchStr = this.options.stringifySearch(nextSearch);
-				const hash = dest.hash === true ? currentLocation.hash : dest.hash ? functionalUpdate(dest.hash, currentLocation.hash) : void 0;
-				const hashStr = hash ? `#${hash}` : "";
-				let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
-				nextState = replaceEqualDeep(currentLocation.state, nextState);
-				const fullPath = `${nextPathname}${searchStr}${hashStr}`;
-				let href;
-				let publicHref;
-				let external = false;
-				if (this.rewrite) {
-					const url = new URL(fullPath, this.origin);
-					const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
-					href = url.href.replace(url.origin, "");
-					if (rewrittenUrl.origin !== this.origin) {
-						publicHref = rewrittenUrl.href;
-						external = true;
-					} else publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash;
-				} else {
-					href = encodePathLikeUrl(fullPath);
-					publicHref = href;
-				}
-				return {
-					publicHref,
-					href,
-					pathname: nextPathname,
-					search: nextSearch,
-					searchStr,
-					state: nextState,
-					hash: hash ?? "",
-					external,
-					unmaskOnReload: dest.unmaskOnReload
-				};
-			};
-			const buildWithMatches = (dest = {}, maskedDest) => {
-				const next = build(dest);
-				let maskedNext = maskedDest ? build(maskedDest) : void 0;
-				if (!maskedNext) {
-					const params = Object.create(null);
-					if (this.options.routeMasks) {
-						const match = findFlatMatch(next.pathname, this.processedTree);
-						if (match) {
-							Object.assign(params, match.rawParams);
-							const { from: _from, params: maskParams, ...maskProps } = match.route;
-							const nextParams = maskParams === false || maskParams === null ? Object.create(null) : (maskParams ?? true) === true ? params : Object.assign(params, functionalUpdate(maskParams, params));
-							maskedDest = {
-								from: opts.from,
-								...maskProps,
-								params: nextParams
-							};
-							maskedNext = build(maskedDest);
-						}
-					}
-				}
-				if (maskedNext) next.maskedLocation = maskedNext;
-				return next;
-			};
-			if (opts.mask) return buildWithMatches(opts, {
-				from: opts.from,
-				...opts.mask
-			});
-			return buildWithMatches(opts);
-		};
-		this.commitLocation = async ({ viewTransition, ignoreBlocker, ...next }) => {
-			const isSameState = () => {
-				const ignoredProps = [
-					"key",
-					"__TSR_key",
-					"__TSR_index",
-					"__hashScrollIntoViewOptions"
-				];
-				ignoredProps.forEach((prop) => {
-					next.state[prop] = this.latestLocation.state[prop];
-				});
-				const isEqual = deepEqual(next.state, this.latestLocation.state);
-				ignoredProps.forEach((prop) => {
-					delete next.state[prop];
-				});
-				return isEqual;
-			};
-			const isSameUrl = trimPathRight(this.latestLocation.href) === trimPathRight(next.href);
-			let previousCommitPromise = this.commitLocationPromise;
-			this.commitLocationPromise = createControlledPromise(() => {
-				previousCommitPromise?.resolve();
-				previousCommitPromise = void 0;
-			});
-			if (isSameUrl && isSameState()) this.load();
-			else {
-				let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
-				if (maskedLocation) {
-					nextHistory = {
-						...maskedLocation,
-						state: {
-							...maskedLocation.state,
-							__tempKey: void 0,
-							__tempLocation: {
-								...nextHistory,
-								search: nextHistory.searchStr,
-								state: {
-									...nextHistory.state,
-									__tempKey: void 0,
-									__tempLocation: void 0,
-									__TSR_key: void 0,
-									key: void 0
-								}
-							}
-						}
-					};
-					if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) nextHistory.state.__tempKey = this.tempLocationKey;
-				}
-				nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
-				this.shouldViewTransition = viewTransition;
-				this.history[next.replace ? "replace" : "push"](nextHistory.publicHref, nextHistory.state, { ignoreBlocker });
-			}
-			this.resetNextScroll = next.resetScroll ?? true;
-			if (!this.history.subscribers.size) this.load();
-			return this.commitLocationPromise;
-		};
-		this.buildAndCommitLocation = ({ replace, resetScroll, hashScrollIntoView, viewTransition, ignoreBlocker, href, ...rest } = {}) => {
-			if (href) {
-				const currentIndex = this.history.location.state.__TSR_index;
-				const parsed = parseHref(href, { __TSR_index: replace ? currentIndex : currentIndex + 1 });
-				const hrefUrl = new URL(parsed.pathname, this.origin);
-				rest.to = executeRewriteInput(this.rewrite, hrefUrl).pathname;
-				rest.search = this.options.parseSearch(parsed.search);
-				rest.hash = parsed.hash.slice(1);
-			}
-			const location = this.buildLocation({
-				...rest,
-				_includeValidateSearch: true
-			});
-			this.pendingBuiltLocation = location;
-			const commitPromise = this.commitLocation({
-				...location,
-				viewTransition,
-				replace,
-				resetScroll,
-				hashScrollIntoView,
-				ignoreBlocker
-			});
-			Promise.resolve().then(() => {
-				if (this.pendingBuiltLocation === location) this.pendingBuiltLocation = void 0;
-			});
-			return commitPromise;
-		};
-		this.navigate = async ({ to, reloadDocument, href, publicHref, ...rest }) => {
-			let hrefIsUrl = false;
-			if (href) try {
-				new URL(`${href}`);
-				hrefIsUrl = true;
-			} catch {}
-			if (hrefIsUrl && !reloadDocument) reloadDocument = true;
-			if (reloadDocument) {
-				if (to !== void 0 || !href) {
-					const location = this.buildLocation({
-						to,
-						...rest
-					});
-					href = href ?? location.publicHref;
-					publicHref = publicHref ?? location.publicHref;
-				}
-				const reloadHref = !hrefIsUrl && publicHref ? publicHref : href;
-				if (isDangerousProtocol(reloadHref, this.protocolAllowlist)) return Promise.resolve();
-				if (!rest.ignoreBlocker) {
-					const blockers = this.history.getBlockers?.() ?? [];
-					for (const blocker of blockers) if (blocker?.blockerFn) {
-						if (await blocker.blockerFn({
-							currentLocation: this.latestLocation,
-							nextLocation: this.latestLocation,
-							action: "PUSH"
-						})) return Promise.resolve();
-					}
-				}
-				if (rest.replace) window.location.replace(reloadHref);
-				else window.location.href = reloadHref;
-				return Promise.resolve();
-			}
-			return this.buildAndCommitLocation({
-				...rest,
-				href,
-				to,
-				_isNavigate: true
-			});
-		};
-		this.beforeLoad = () => {
-			this.cancelMatches();
-			this.updateLatestLocation();
-			{
-				const nextLocation = this.buildLocation({
-					to: this.latestLocation.pathname,
-					search: true,
-					params: true,
-					hash: true,
-					state: true,
-					_includeValidateSearch: true
-				});
-				if (this.latestLocation.publicHref !== nextLocation.publicHref) {
-					const href = this.getParsedLocationHref(nextLocation);
-					if (nextLocation.external) throw redirect({ href });
-					else throw redirect({
-						href,
-						_builtLocation: nextLocation
-					});
-				}
-			}
-			const pendingMatches = this.matchRoutes(this.latestLocation);
-			const nextCachedMatches = this.stores.cachedMatchesSnapshot.state.filter((d) => !pendingMatches.some((e) => e.id === d.id));
-			this.batch(() => {
-				this.stores.status.setState(() => "pending");
-				this.stores.statusCode.setState(() => 200);
-				this.stores.isLoading.setState(() => true);
-				this.stores.location.setState(() => this.latestLocation);
-				this.stores.setPendingMatches(pendingMatches);
-				this.stores.setCachedMatches(nextCachedMatches);
-			});
-		};
-		this.load = async (opts) => {
-			let redirect;
-			let notFound;
-			let loadPromise;
-			const previousLocation = this.stores.resolvedLocation.state ?? this.stores.location.state;
-			loadPromise = new Promise((resolve) => {
-				this.startTransition(async () => {
-					try {
-						this.beforeLoad();
-						const next = this.latestLocation;
-						const prevLocation = this.stores.resolvedLocation.state;
-						const locationChangeInfo = getLocationChangeInfo(next, prevLocation);
-						if (!this.stores.redirect.state) this.emit({
-							type: "onBeforeNavigate",
-							...locationChangeInfo
-						});
-						this.emit({
-							type: "onBeforeLoad",
-							...locationChangeInfo
-						});
-						await loadMatches({
-							router: this,
-							sync: opts?.sync,
-							forceStaleReload: previousLocation.href === next.href,
-							matches: this.stores.pendingMatchesSnapshot.state,
-							location: next,
-							updateMatch: this.updateMatch,
-							onReady: async () => {
-								this.startTransition(() => {
-									this.startViewTransition(async () => {
-										let exitingMatches = null;
-										let hookExitingMatches = null;
-										let hookEnteringMatches = null;
-										let hookStayingMatches = null;
-										this.batch(() => {
-											const pendingMatches = this.stores.pendingMatchesSnapshot.state;
-											const mountPending = pendingMatches.length;
-											const currentMatches = this.stores.activeMatchesSnapshot.state;
-											exitingMatches = mountPending ? currentMatches.filter((match) => !this.stores.pendingMatchStoresById.has(match.id)) : null;
-											const pendingRouteIds = /* @__PURE__ */ new Set();
-											for (const s of this.stores.pendingMatchStoresById.values()) if (s.routeId) pendingRouteIds.add(s.routeId);
-											const activeRouteIds = /* @__PURE__ */ new Set();
-											for (const s of this.stores.activeMatchStoresById.values()) if (s.routeId) activeRouteIds.add(s.routeId);
-											hookExitingMatches = mountPending ? currentMatches.filter((match) => !pendingRouteIds.has(match.routeId)) : null;
-											hookEnteringMatches = mountPending ? pendingMatches.filter((match) => !activeRouteIds.has(match.routeId)) : null;
-											hookStayingMatches = mountPending ? pendingMatches.filter((match) => activeRouteIds.has(match.routeId)) : currentMatches;
-											this.stores.isLoading.setState(() => false);
-											this.stores.loadedAt.setState(() => Date.now());
-											/**
-											* When committing new matches, cache any exiting matches that are still usable.
-											* Routes that resolved with `status: 'error'` or `status: 'notFound'` are
-											* deliberately excluded from `cachedMatches` so that subsequent invalidations
-											* or reloads re-run their loaders instead of reusing the failed/not-found data.
-											*/
-											if (mountPending) {
-												this.stores.setActiveMatches(pendingMatches);
-												this.stores.setPendingMatches([]);
-												this.stores.setCachedMatches([...this.stores.cachedMatchesSnapshot.state, ...exitingMatches.filter((d) => d.status !== "error" && d.status !== "notFound" && d.status !== "redirected")]);
-												this.clearExpiredCache();
-											}
-										});
-										for (const [matches, hook] of [
-											[hookExitingMatches, "onLeave"],
-											[hookEnteringMatches, "onEnter"],
-											[hookStayingMatches, "onStay"]
-										]) {
-											if (!matches) continue;
-											for (const match of matches) this.looseRoutesById[match.routeId].options[hook]?.(match);
-										}
-									});
-								});
-							}
-						});
-					} catch (err) {
-						if (isRedirect(err)) redirect = err;
-						else if (isNotFound(err)) notFound = err;
-						const nextStatusCode = redirect ? redirect.status : notFound ? 404 : this.stores.activeMatchesSnapshot.state.some((d) => d.status === "error") ? 500 : 200;
-						this.batch(() => {
-							this.stores.statusCode.setState(() => nextStatusCode);
-							this.stores.redirect.setState(() => redirect);
-						});
-					}
-					if (this.latestLoadPromise === loadPromise) {
-						this.commitLocationPromise?.resolve();
-						this.latestLoadPromise = void 0;
-						this.commitLocationPromise = void 0;
-					}
-					resolve();
-				});
-			});
-			this.latestLoadPromise = loadPromise;
-			await loadPromise;
-			while (this.latestLoadPromise && loadPromise !== this.latestLoadPromise) await this.latestLoadPromise;
-			let newStatusCode = void 0;
-			if (this.hasNotFoundMatch()) newStatusCode = 404;
-			else if (this.stores.activeMatchesSnapshot.state.some((d) => d.status === "error")) newStatusCode = 500;
-			if (newStatusCode !== void 0) this.stores.statusCode.setState(() => newStatusCode);
-		};
-		this.startViewTransition = (fn) => {
-			const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition;
-			this.shouldViewTransition = void 0;
-			if (shouldViewTransition && typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
-				let startViewTransitionParams;
-				if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) {
-					const next = this.latestLocation;
-					const prevLocation = this.stores.resolvedLocation.state;
-					const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types(getLocationChangeInfo(next, prevLocation)) : shouldViewTransition.types;
-					if (resolvedViewTransitionTypes === false) {
-						fn();
-						return;
-					}
-					startViewTransitionParams = {
-						update: fn,
-						types: resolvedViewTransitionTypes
-					};
-				} else startViewTransitionParams = fn;
-				document.startViewTransition(startViewTransitionParams);
-			} else fn();
-		};
-		this.updateMatch = (id, updater) => {
-			this.startTransition(() => {
-				const pendingMatch = this.stores.pendingMatchStoresById.get(id);
-				if (pendingMatch) {
-					pendingMatch.setState(updater);
-					return;
-				}
-				const activeMatch = this.stores.activeMatchStoresById.get(id);
-				if (activeMatch) {
-					activeMatch.setState(updater);
-					return;
-				}
-				const cachedMatch = this.stores.cachedMatchStoresById.get(id);
-				if (cachedMatch) {
-					const next = updater(cachedMatch.state);
-					if (next.status === "redirected") {
-						if (this.stores.cachedMatchStoresById.delete(id)) this.stores.cachedMatchesId.setState((prev) => prev.filter((matchId) => matchId !== id));
-					} else cachedMatch.setState(() => next);
-				}
-			});
-		};
-		this.getMatch = (matchId) => {
-			return this.stores.cachedMatchStoresById.get(matchId)?.state ?? this.stores.pendingMatchStoresById.get(matchId)?.state ?? this.stores.activeMatchStoresById.get(matchId)?.state;
-		};
-		this.invalidate = (opts) => {
-			const invalidate = (d) => {
-				if (opts?.filter?.(d) ?? true) return {
-					...d,
-					invalid: true,
-					...opts?.forcePending || d.status === "error" || d.status === "notFound" ? {
-						status: "pending",
-						error: void 0
-					} : void 0
-				};
-				return d;
-			};
-			this.batch(() => {
-				this.stores.setActiveMatches(this.stores.activeMatchesSnapshot.state.map(invalidate));
-				this.stores.setCachedMatches(this.stores.cachedMatchesSnapshot.state.map(invalidate));
-				this.stores.setPendingMatches(this.stores.pendingMatchesSnapshot.state.map(invalidate));
-			});
-			this.shouldViewTransition = false;
-			return this.load({ sync: opts?.sync });
-		};
-		this.getParsedLocationHref = (location) => {
-			return location.publicHref || "/";
-		};
-		this.resolveRedirect = (redirect) => {
-			const locationHeader = redirect.headers.get("Location");
-			if (!redirect.options.href || redirect.options._builtLocation) {
-				const location = redirect.options._builtLocation ?? this.buildLocation(redirect.options);
-				const href = this.getParsedLocationHref(location);
-				redirect.options.href = href;
-				redirect.headers.set("Location", href);
-			} else if (locationHeader) try {
-				const url = new URL(locationHeader);
-				if (this.origin && url.origin === this.origin) {
-					const href = url.pathname + url.search + url.hash;
-					redirect.options.href = href;
-					redirect.headers.set("Location", href);
-				}
-			} catch {}
-			if (redirect.options.href && !redirect.options._builtLocation && isDangerousProtocol(redirect.options.href, this.protocolAllowlist)) throw new Error("Redirect blocked: unsafe protocol");
-			if (!redirect.headers.get("Location")) redirect.headers.set("Location", redirect.options.href);
-			return redirect;
-		};
-		this.clearCache = (opts) => {
-			const filter = opts?.filter;
-			if (filter !== void 0) this.stores.setCachedMatches(this.stores.cachedMatchesSnapshot.state.filter((m) => !filter(m)));
-			else this.stores.setCachedMatches([]);
-		};
-		this.clearExpiredCache = () => {
-			const now = Date.now();
-			const filter = (d) => {
-				const route = this.looseRoutesById[d.routeId];
-				if (!route.options.loader) return true;
-				const gcTime = (d.preload ? route.options.preloadGcTime ?? this.options.defaultPreloadGcTime : route.options.gcTime ?? this.options.defaultGcTime) ?? 300 * 1e3;
-				if (d.status === "error") return true;
-				return now - d.updatedAt >= gcTime;
-			};
-			this.clearCache({ filter });
-		};
-		this.loadRouteChunk = loadRouteChunk;
-		this.preloadRoute = async (opts) => {
-			const next = opts._builtLocation ?? this.buildLocation(opts);
-			let matches = this.matchRoutes(next, {
-				throwOnError: true,
-				preload: true,
-				dest: opts
-			});
-			const activeMatchIds = new Set([...this.stores.matchesId.state, ...this.stores.pendingMatchesId.state]);
-			const loadedMatchIds = new Set([...activeMatchIds, ...this.stores.cachedMatchesId.state]);
-			const matchesToCache = matches.filter((match) => !loadedMatchIds.has(match.id));
-			if (matchesToCache.length) {
-				const cachedMatches = this.stores.cachedMatchesSnapshot.state;
-				this.stores.setCachedMatches([...cachedMatches, ...matchesToCache]);
-			}
-			try {
-				matches = await loadMatches({
-					router: this,
-					matches,
-					location: next,
-					preload: true,
-					updateMatch: (id, updater) => {
-						if (activeMatchIds.has(id)) matches = matches.map((d) => d.id === id ? updater(d) : d);
-						else this.updateMatch(id, updater);
-					}
-				});
-				return matches;
-			} catch (err) {
-				if (isRedirect(err)) {
-					if (err.options.reloadDocument) return;
-					return await this.preloadRoute({
-						...err.options,
-						_fromLocation: next
-					});
-				}
-				if (!isNotFound(err)) console.error(err);
-				return;
-			}
-		};
-		this.matchRoute = (location, opts) => {
-			const matchLocation = {
-				...location,
-				to: location.to ? this.resolvePathWithBase(location.from || "", location.to) : void 0,
-				params: location.params || {},
-				leaveParams: true
-			};
-			const next = this.buildLocation(matchLocation);
-			if (opts?.pending && this.stores.status.state !== "pending") return false;
-			const baseLocation = (opts?.pending === void 0 ? !this.stores.isLoading.state : opts.pending) ? this.latestLocation : this.stores.resolvedLocation.state || this.stores.location.state;
-			const match = findSingleMatch(next.pathname, opts?.caseSensitive ?? false, opts?.fuzzy ?? false, baseLocation.pathname, this.processedTree);
-			if (!match) return false;
-			if (location.params) {
-				if (!deepEqual(match.rawParams, location.params, { partial: true })) return false;
-			}
-			if (opts?.includeSearch ?? true) return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false;
-			return match.rawParams;
-		};
-		this.hasNotFoundMatch = () => {
-			return this.stores.activeMatchesSnapshot.state.some((d) => d.status === "notFound" || d.globalNotFound);
-		};
-		this.getStoreConfig = getStoreConfig;
-		this.update({
-			defaultPreloadDelay: 50,
-			defaultPendingMs: 1e3,
-			defaultPendingMinMs: 500,
-			context: void 0,
-			...options,
-			caseSensitive: options.caseSensitive ?? false,
-			notFoundMode: options.notFoundMode ?? "fuzzy",
-			stringifySearch: options.stringifySearch ?? defaultStringifySearch,
-			parseSearch: options.parseSearch ?? defaultParseSearch,
-			protocolAllowlist: options.protocolAllowlist ?? DEFAULT_PROTOCOL_ALLOWLIST
-		});
-		if (typeof document !== "undefined") self.__TSR_ROUTER__ = this;
-	}
-	isShell() {
-		return !!this.options.isShell;
-	}
-	isPrerendering() {
-		return !!this.options.isPrerendering;
-	}
-	get state() {
-		return this.stores.__store.state;
-	}
-	setRoutes({ routesById, routesByPath, processedTree }) {
-		this.routesById = routesById;
-		this.routesByPath = routesByPath;
-		this.processedTree = processedTree;
-		const notFoundRoute = this.options.notFoundRoute;
-		if (notFoundRoute) {
-			notFoundRoute.init({ originalIndex: 99999999999 });
-			this.routesById[notFoundRoute.id] = notFoundRoute;
-		}
-	}
-	get looseRoutesById() {
-		return this.routesById;
-	}
-	getParentContext(parentMatch) {
-		return !parentMatch?.id ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
-	}
-	matchRoutesInternal(next, opts) {
-		const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
-		const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
-		let { matchedRoutes } = matchedRoutesResult;
-		let isGlobalNotFound = false;
-		if (foundRoute ? foundRoute.path !== "/" && routeParams["**"] : trimPathRight(next.pathname)) if (this.options.notFoundRoute) matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
-		else isGlobalNotFound = true;
-		const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
-		const matches = new Array(matchedRoutes.length);
-		const previousActiveMatchesByRouteId = /* @__PURE__ */ new Map();
-		for (const store of this.stores.activeMatchStoresById.values()) if (store.routeId) previousActiveMatchesByRouteId.set(store.routeId, store.state);
-		for (let index = 0; index < matchedRoutes.length; index++) {
-			const route = matchedRoutes[index];
-			const parentMatch = matches[index - 1];
-			let preMatchSearch;
-			let strictMatchSearch;
-			let searchError;
-			{
-				const parentSearch = parentMatch?.search ?? next.search;
-				const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
-				try {
-					const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
-					preMatchSearch = {
-						...parentSearch,
-						...strictSearch
-					};
-					strictMatchSearch = {
-						...parentStrictSearch,
-						...strictSearch
-					};
-					searchError = void 0;
-				} catch (err) {
-					let searchParamError = err;
-					if (!(err instanceof SearchParamError)) searchParamError = new SearchParamError(err.message, { cause: err });
-					if (opts?.throwOnError) throw searchParamError;
-					preMatchSearch = parentSearch;
-					strictMatchSearch = {};
-					searchError = searchParamError;
-				}
-			}
-			const loaderDeps = route.options.loaderDeps?.({ search: preMatchSearch }) ?? "";
-			const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
-			const { interpolatedPath, usedParams } = interpolatePath({
-				path: route.fullPath,
-				params: routeParams,
-				decoder: this.pathParamsDecoder,
-				server: this.isServer
-			});
-			const matchId = route.id + interpolatedPath + loaderDepsHash;
-			const existingMatch = this.getMatch(matchId);
-			const previousMatch = previousActiveMatchesByRouteId.get(route.id);
-			const strictParams = existingMatch?._strictParams ?? usedParams;
-			let paramsError = void 0;
-			if (!existingMatch) try {
-				extractStrictParams(route, usedParams, parsedParams, strictParams);
-			} catch (err) {
-				if (isNotFound(err) || isRedirect(err)) paramsError = err;
-				else paramsError = new PathParamError(err.message, { cause: err });
-				if (opts?.throwOnError) throw paramsError;
-			}
-			Object.assign(routeParams, strictParams);
-			const cause = previousMatch ? "stay" : "enter";
-			let match;
-			if (existingMatch) match = {
-				...existingMatch,
-				cause,
-				params: previousMatch?.params ?? routeParams,
-				_strictParams: strictParams,
-				search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : nullReplaceEqualDeep(existingMatch.search, preMatchSearch),
-				_strictSearch: strictMatchSearch
-			};
-			else {
-				const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
-				match = {
-					id: matchId,
-					ssr: void 0,
-					index,
-					routeId: route.id,
-					params: previousMatch?.params ?? routeParams,
-					_strictParams: strictParams,
-					pathname: interpolatedPath,
-					updatedAt: Date.now(),
-					search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
-					_strictSearch: strictMatchSearch,
-					searchError: void 0,
-					status,
-					isFetching: false,
-					error: void 0,
-					paramsError,
-					__routeContext: void 0,
-					_nonReactive: { loadPromise: createControlledPromise() },
-					__beforeLoadContext: void 0,
-					context: {},
-					abortController: new AbortController(),
-					fetchCount: 0,
-					cause,
-					loaderDeps: previousMatch ? replaceEqualDeep(previousMatch.loaderDeps, loaderDeps) : loaderDeps,
-					invalid: false,
-					preload: false,
-					links: void 0,
-					scripts: void 0,
-					headScripts: void 0,
-					meta: void 0,
-					staticData: route.options.staticData || {},
-					fullPath: route.fullPath
-				};
-			}
-			if (!opts?.preload) match.globalNotFound = globalNotFoundRouteId === route.id;
-			match.searchError = searchError;
-			const parentContext = this.getParentContext(parentMatch);
-			match.context = {
-				...parentContext,
-				...match.__routeContext,
-				...match.__beforeLoadContext
-			};
-			matches[index] = match;
-		}
-		for (let index = 0; index < matches.length; index++) {
-			const match = matches[index];
-			const route = this.looseRoutesById[match.routeId];
-			const existingMatch = this.getMatch(match.id);
-			const previousMatch = previousActiveMatchesByRouteId.get(match.routeId);
-			match.params = previousMatch ? nullReplaceEqualDeep(previousMatch.params, routeParams) : routeParams;
-			if (!existingMatch) {
-				const parentMatch = matches[index - 1];
-				const parentContext = this.getParentContext(parentMatch);
-				if (route.options.context) {
-					const contextFnContext = {
-						deps: match.loaderDeps,
-						params: match.params,
-						context: parentContext ?? {},
-						location: next,
-						navigate: (opts) => this.navigate({
-							...opts,
-							_fromLocation: next
-						}),
-						buildLocation: this.buildLocation,
-						cause: match.cause,
-						abortController: match.abortController,
-						preload: !!match.preload,
-						matches,
-						routeId: route.id
-					};
-					match.__routeContext = route.options.context(contextFnContext) ?? void 0;
-				}
-				match.context = {
-					...parentContext,
-					...match.__routeContext,
-					...match.__beforeLoadContext
-				};
-			}
-		}
-		return matches;
-	}
-	/**
-	* Lightweight route matching for buildLocation.
-	* Only computes fullPath, accumulated search, and params - skipping expensive
-	* operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
-	*/
-	matchRoutesLightweight(location) {
-		const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(location.pathname);
-		const lastRoute = last(matchedRoutes);
-		const accumulatedSearch = { ...location.search };
-		for (const route of matchedRoutes) try {
-			Object.assign(accumulatedSearch, validateSearch(route.options.validateSearch, accumulatedSearch));
-		} catch {}
-		const lastStateMatchId = last(this.stores.matchesId.state);
-		const lastStateMatch = lastStateMatchId && this.stores.activeMatchStoresById.get(lastStateMatchId)?.state;
-		const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && lastStateMatch.pathname === location.pathname;
-		let params;
-		if (canReuseParams) params = lastStateMatch.params;
-		else {
-			const strictParams = Object.assign(Object.create(null), routeParams);
-			for (const route of matchedRoutes) try {
-				extractStrictParams(route, routeParams, parsedParams ?? {}, strictParams);
-			} catch {}
-			params = strictParams;
-		}
-		return {
-			matchedRoutes,
-			fullPath: lastRoute.fullPath,
-			search: accumulatedSearch,
-			params
-		};
-	}
-};
-/** Error thrown when search parameter validation fails. */
-var SearchParamError = class extends Error {};
-/** Error thrown when path parameter parsing/validation fails. */
-var PathParamError = class extends Error {};
-/** Create an initial RouterState from a parsed location. */
-function getInitialRouterState(location) {
-	return {
-		loadedAt: 0,
-		isLoading: false,
-		isTransitioning: false,
-		status: "idle",
-		resolvedLocation: void 0,
-		location,
-		matches: [],
-		statusCode: 200
-	};
-}
-function validateSearch(validateSearch, input) {
-	if (validateSearch == null) return {};
-	if ("~standard" in validateSearch) {
-		const result = validateSearch["~standard"].validate(input);
-		if (result instanceof Promise) throw new SearchParamError("Async validation not supported");
-		if (result.issues) throw new SearchParamError(JSON.stringify(result.issues, void 0, 2), { cause: result });
-		return result.value;
-	}
-	if ("parse" in validateSearch) return validateSearch.parse(input);
-	if (typeof validateSearch === "function") return validateSearch(input);
-	return {};
-}
-/**
-* Build the matched route chain and extract params for a pathname.
-* Falls back to the root route if no specific route is found.
-*/
-function getMatchedRoutes({ pathname, routesById, processedTree }) {
-	const routeParams = Object.create(null);
-	const trimmedPath = trimPathRight(pathname);
-	let foundRoute = void 0;
-	let parsedParams = void 0;
-	const match = findRouteMatch(trimmedPath, processedTree, true);
-	if (match) {
-		foundRoute = match.route;
-		Object.assign(routeParams, match.rawParams);
-		parsedParams = Object.assign(Object.create(null), match.parsedParams);
-	}
-	return {
-		matchedRoutes: match?.branch || [routesById["__root__"]],
-		routeParams,
-		foundRoute,
-		parsedParams
-	};
-}
-/**
-* TODO: once caches are persisted across requests on the server,
-* we can cache the built middleware chain using `last(destRoutes)` as the key
-*/
-function applySearchMiddleware({ search, dest, destRoutes, _includeValidateSearch }) {
-	return buildMiddlewareChain(destRoutes)(search, dest, _includeValidateSearch ?? false);
-}
-function buildMiddlewareChain(destRoutes) {
-	const context = {
-		dest: null,
-		_includeValidateSearch: false,
-		middlewares: []
-	};
-	for (const route of destRoutes) {
-		if ("search" in route.options) {
-			if (route.options.search?.middlewares) context.middlewares.push(...route.options.search.middlewares);
-		} else if (route.options.preSearchFilters || route.options.postSearchFilters) {
-			const legacyMiddleware = ({ search, next }) => {
-				let nextSearch = search;
-				if ("preSearchFilters" in route.options && route.options.preSearchFilters) nextSearch = route.options.preSearchFilters.reduce((prev, next) => next(prev), search);
-				const result = next(nextSearch);
-				if ("postSearchFilters" in route.options && route.options.postSearchFilters) return route.options.postSearchFilters.reduce((prev, next) => next(prev), result);
-				return result;
-			};
-			context.middlewares.push(legacyMiddleware);
-		}
-		if (route.options.validateSearch) {
-			const validate = ({ search, next }) => {
-				const result = next(search);
-				if (!context._includeValidateSearch) return result;
-				try {
-					return {
-						...result,
-						...validateSearch(route.options.validateSearch, result) ?? void 0
-					};
-				} catch {
-					return result;
-				}
-			};
-			context.middlewares.push(validate);
-		}
-	}
-	const final = ({ search }) => {
-		const dest = context.dest;
-		if (!dest.search) return {};
-		if (dest.search === true) return search;
-		return functionalUpdate(dest.search, search);
-	};
-	context.middlewares.push(final);
-	const applyNext = (index, currentSearch, middlewares) => {
-		if (index >= middlewares.length) return currentSearch;
-		const middleware = middlewares[index];
-		const next = (newSearch) => {
-			return applyNext(index + 1, newSearch, middlewares);
-		};
-		return middleware({
-			search: currentSearch,
-			next
-		});
-	};
-	return function middleware(search, dest, _includeValidateSearch) {
-		context.dest = dest;
-		context._includeValidateSearch = _includeValidateSearch;
-		return applyNext(0, search, context.middlewares);
-	};
-}
-function findGlobalNotFoundRouteId(notFoundMode, routes) {
-	if (notFoundMode !== "root") for (let i = routes.length - 1; i >= 0; i--) {
-		const route = routes[i];
-		if (route.children) return route.id;
-	}
-	return rootRouteId;
-}
-function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
-	const parseParams = route.options.params?.parse ?? route.options.parseParams;
-	if (parseParams) if (route.options.skipRouteOnParseError) {
-		for (const key in referenceParams) if (key in parsedParams) accumulatedParams[key] = parsedParams[key];
-	} else {
-		const result = parseParams(accumulatedParams);
-		Object.assign(accumulatedParams, result);
-	}
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/manifest.js
-function getAssetCrossOrigin(assetCrossOrigin, kind) {
-	if (!assetCrossOrigin) return;
-	if (typeof assetCrossOrigin === "string") return assetCrossOrigin;
-	return assetCrossOrigin[kind];
-}
-function resolveManifestAssetLink(link) {
-	if (typeof link === "string") return {
-		href: link,
-		crossOrigin: void 0
-	};
-	return link;
-}
-//#endregion
 //#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/ssr/constants.js
 var GLOBAL_TSR = "$_TSR";
 var TSR_SCRIPT_BARRIER_ID = "$tsr-stream-barrier";
@@ -5179,925 +2770,80 @@ ni({
 		async async(e, r) {
 			return {
 				body: await r.parse(e.body && !e.bodyUsed ? await e.clone().arrayBuffer() : null),
-				options: await r.parse(h(e))
-			};
-		},
-		stream(e, r) {
-			return {
-				body: r.parse(e.body && !e.bodyUsed ? e.clone().body : null),
-				options: r.parse(h(e))
-			};
-		}
-	},
-	serialize(e, r) {
-		return "new Response(" + r.serialize(e.body) + "," + r.serialize(e.options) + ")";
-	},
-	deserialize(e, r) {
-		return new Response(r.deserialize(e.body), r.deserialize(e.options));
-	}
-});
-ni({
-	tag: "seroval-plugins/web/URL",
-	test(e) {
-		return typeof URL == "undefined" ? !1 : e instanceof URL;
-	},
-	parse: {
-		sync(e, r) {
-			return { value: r.parse(e.href) };
-		},
-		async async(e, r) {
-			return { value: await r.parse(e.href) };
-		},
-		stream(e, r) {
-			return { value: r.parse(e.href) };
-		}
-	},
-	serialize(e, r) {
-		return "new URL(" + r.serialize(e.value) + ")";
-	},
-	deserialize(e, r) {
-		return new URL(r.deserialize(e.value));
-	}
-});
-ni({
-	tag: "seroval-plugins/web/URLSearchParams",
-	test(e) {
-		return typeof URLSearchParams == "undefined" ? !1 : e instanceof URLSearchParams;
-	},
-	parse: {
-		sync(e, r) {
-			return { value: r.parse(e.toString()) };
-		},
-		async async(e, r) {
-			return { value: await r.parse(e.toString()) };
-		},
-		stream(e, r) {
-			return { value: r.parse(e.toString()) };
-		}
-	},
-	serialize(e, r) {
-		return "new URLSearchParams(" + r.serialize(e.value) + ")";
-	},
-	deserialize(e, r) {
-		return new URLSearchParams(r.deserialize(e.value));
-	}
-});
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/seroval-plugins.js
-var defaultSerovalPlugins = [
-	ShallowErrorPlugin,
-	RawStreamSSRPlugin,
-	p
-];
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/CatchBoundary.js
-var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
-var import_jsx_runtime = require_jsx_runtime();
-function CatchBoundary(props) {
-	const errorComponent = props.errorComponent ?? ErrorComponent;
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundaryImpl, {
-		getResetKey: props.getResetKey,
-		onCatch: props.onCatch,
-		children: ({ error, reset }) => {
-			if (error) return import_react.createElement(errorComponent, {
-				error,
-				reset
-			});
-			return props.children;
-		}
-	});
-}
-var CatchBoundaryImpl = class extends import_react.Component {
-	constructor(..._args) {
-		super(..._args);
-		this.state = { error: null };
-	}
-	static getDerivedStateFromProps(props) {
-		return { resetKey: props.getResetKey() };
-	}
-	static getDerivedStateFromError(error) {
-		return { error };
-	}
-	reset() {
-		this.setState({ error: null });
-	}
-	componentDidUpdate(prevProps, prevState) {
-		if (prevState.error && prevState.resetKey !== this.state.resetKey) this.reset();
-	}
-	componentDidCatch(error, errorInfo) {
-		if (this.props.onCatch) this.props.onCatch(error, errorInfo);
-	}
-	render() {
-		return this.props.children({
-			error: this.state.resetKey !== this.props.getResetKey() ? null : this.state.error,
-			reset: () => {
-				this.reset();
-			}
-		});
-	}
-};
-function ErrorComponent({ error }) {
-	const [show, setShow] = import_react.useState(false);
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
-		style: {
-			padding: ".5rem",
-			maxWidth: "100%"
-		},
-		children: [
-			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
-				style: {
-					display: "flex",
-					alignItems: "center",
-					gap: ".5rem"
-				},
-				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", {
-					style: { fontSize: "1rem" },
-					children: "Something went wrong!"
-				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", {
-					style: {
-						appearance: "none",
-						fontSize: ".6em",
-						border: "1px solid currentColor",
-						padding: ".1rem .2rem",
-						fontWeight: "bold",
-						borderRadius: ".25rem"
-					},
-					onClick: () => setShow((d) => !d),
-					children: show ? "Hide Error" : "Show Error"
-				})]
-			}),
-			/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { height: ".25rem" } }),
-			show ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", {
-				style: {
-					fontSize: ".7em",
-					border: "1px solid red",
-					borderRadius: ".25rem",
-					padding: ".3rem",
-					color: "red",
-					overflow: "auto"
-				},
-				children: error.message ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: error.message }) : null
-			}) }) : null
-		]
-	});
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/alien.js
-var ReactiveFlags = /* @__PURE__ */ ((ReactiveFlags2) => {
-	ReactiveFlags2[ReactiveFlags2["None"] = 0] = "None";
-	ReactiveFlags2[ReactiveFlags2["Mutable"] = 1] = "Mutable";
-	ReactiveFlags2[ReactiveFlags2["Watching"] = 2] = "Watching";
-	ReactiveFlags2[ReactiveFlags2["RecursedCheck"] = 4] = "RecursedCheck";
-	ReactiveFlags2[ReactiveFlags2["Recursed"] = 8] = "Recursed";
-	ReactiveFlags2[ReactiveFlags2["Dirty"] = 16] = "Dirty";
-	ReactiveFlags2[ReactiveFlags2["Pending"] = 32] = "Pending";
-	return ReactiveFlags2;
-})(ReactiveFlags || {});
-function createReactiveSystem({ update, notify, unwatched }) {
-	return {
-		link: link2,
-		unlink: unlink2,
-		propagate: propagate2,
-		checkDirty: checkDirty2,
-		shallowPropagate: shallowPropagate2
-	};
-	function link2(dep, sub, version) {
-		const prevDep = sub.depsTail;
-		if (prevDep !== void 0 && prevDep.dep === dep) return;
-		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
-		if (nextDep !== void 0 && nextDep.dep === dep) {
-			nextDep.version = version;
-			sub.depsTail = nextDep;
-			return;
-		}
-		const prevSub = dep.subsTail;
-		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
-		const newLink = sub.depsTail = dep.subsTail = {
-			version,
-			dep,
-			sub,
-			prevDep,
-			nextDep,
-			prevSub,
-			nextSub: void 0
-		};
-		if (nextDep !== void 0) nextDep.prevDep = newLink;
-		if (prevDep !== void 0) prevDep.nextDep = newLink;
-		else sub.deps = newLink;
-		if (prevSub !== void 0) prevSub.nextSub = newLink;
-		else dep.subs = newLink;
-	}
-	function unlink2(link3, sub = link3.sub) {
-		const dep = link3.dep;
-		const prevDep = link3.prevDep;
-		const nextDep = link3.nextDep;
-		const nextSub = link3.nextSub;
-		const prevSub = link3.prevSub;
-		if (nextDep !== void 0) nextDep.prevDep = prevDep;
-		else sub.depsTail = prevDep;
-		if (prevDep !== void 0) prevDep.nextDep = nextDep;
-		else sub.deps = nextDep;
-		if (nextSub !== void 0) nextSub.prevSub = prevSub;
-		else dep.subsTail = prevSub;
-		if (prevSub !== void 0) prevSub.nextSub = nextSub;
-		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
-		return nextDep;
-	}
-	function propagate2(link3) {
-		let next = link3.nextSub;
-		let stack;
-		top: do {
-			const sub = link3.sub;
-			let flags = sub.flags;
-			if (!(flags & 60)) sub.flags = flags | 32;
-			else if (!(flags & 12)) flags = 0;
-			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
-			else if (!(flags & 48) && isValidLink(link3, sub)) {
-				sub.flags = flags | 40;
-				flags &= 1;
-			} else flags = 0;
-			if (flags & 2) notify(sub);
-			if (flags & 1) {
-				const subSubs = sub.subs;
-				if (subSubs !== void 0) {
-					const nextSub = (link3 = subSubs).nextSub;
-					if (nextSub !== void 0) {
-						stack = {
-							value: next,
-							prev: stack
-						};
-						next = nextSub;
-					}
-					continue;
-				}
-			}
-			if ((link3 = next) !== void 0) {
-				next = link3.nextSub;
-				continue;
-			}
-			while (stack !== void 0) {
-				link3 = stack.value;
-				stack = stack.prev;
-				if (link3 !== void 0) {
-					next = link3.nextSub;
-					continue top;
-				}
-			}
-			break;
-		} while (true);
-	}
-	function checkDirty2(link3, sub) {
-		let stack;
-		let checkDepth = 0;
-		let dirty = false;
-		top: do {
-			const dep = link3.dep;
-			const flags = dep.flags;
-			if (sub.flags & 16) dirty = true;
-			else if ((flags & 17) === 17) {
-				if (update(dep)) {
-					const subs = dep.subs;
-					if (subs.nextSub !== void 0) shallowPropagate2(subs);
-					dirty = true;
-				}
-			} else if ((flags & 33) === 33) {
-				if (link3.nextSub !== void 0 || link3.prevSub !== void 0) stack = {
-					value: link3,
-					prev: stack
-				};
-				link3 = dep.deps;
-				sub = dep;
-				++checkDepth;
-				continue;
-			}
-			if (!dirty) {
-				const nextDep = link3.nextDep;
-				if (nextDep !== void 0) {
-					link3 = nextDep;
-					continue;
-				}
-			}
-			while (checkDepth--) {
-				const firstSub = sub.subs;
-				const hasMultipleSubs = firstSub.nextSub !== void 0;
-				if (hasMultipleSubs) {
-					link3 = stack.value;
-					stack = stack.prev;
-				} else link3 = firstSub;
-				if (dirty) {
-					if (update(sub)) {
-						if (hasMultipleSubs) shallowPropagate2(firstSub);
-						sub = link3.sub;
-						continue;
-					}
-					dirty = false;
-				} else sub.flags &= -33;
-				sub = link3.sub;
-				const nextDep = link3.nextDep;
-				if (nextDep !== void 0) {
-					link3 = nextDep;
-					continue top;
-				}
-			}
-			return dirty;
-		} while (true);
-	}
-	function shallowPropagate2(link3) {
-		do {
-			const sub = link3.sub;
-			const flags = sub.flags;
-			if ((flags & 48) === 32) {
-				sub.flags = flags | 16;
-				if ((flags & 6) === 2) notify(sub);
-			}
-		} while ((link3 = link3.nextSub) !== void 0);
-	}
-	function isValidLink(checkLink, sub) {
-		let link3 = sub.depsTail;
-		while (link3 !== void 0) {
-			if (link3 === checkLink) return true;
-			link3 = link3.prevDep;
-		}
-		return false;
-	}
-}
-var batchDepth = 0;
-var notifyIndex$1 = 0;
-var queuedLength = 0;
-var queued = [];
-var { link: link$1, unlink: unlink$1, propagate: propagate$1, checkDirty: checkDirty$1, shallowPropagate: shallowPropagate$1 } = createReactiveSystem({
-	update(node) {
-		if (node.depsTail !== void 0) return updateComputed(node);
-		else return updateSignal(node);
-	},
-	notify(effect2) {
-		let insertIndex = queuedLength;
-		let firstInsertedIndex = insertIndex;
-		do {
-			queued[insertIndex++] = effect2;
-			effect2.flags &= -3;
-			effect2 = effect2.subs?.sub;
-			if (effect2 === void 0 || !(effect2.flags & 2)) break;
-		} while (true);
-		queuedLength = insertIndex;
-		while (firstInsertedIndex < --insertIndex) {
-			const left = queued[firstInsertedIndex];
-			queued[firstInsertedIndex++] = queued[insertIndex];
-			queued[insertIndex] = left;
-		}
-	},
-	unwatched(node) {
-		if (!(node.flags & 1)) effectScopeOper.call(node);
-		else if (node.depsTail !== void 0) {
-			node.depsTail = void 0;
-			node.flags = 17;
-			purgeDeps$1(node);
-		}
-	}
-});
-function getBatchDepth() {
-	return batchDepth;
-}
-function startBatch() {
-	++batchDepth;
-}
-function endBatch() {
-	if (!--batchDepth) flush$1();
-}
-function updateComputed(c) {
-	c.depsTail = void 0;
-	c.flags = 5;
-	try {
-		const oldValue = c.value;
-		return oldValue !== (c.value = c.getter(oldValue));
-	} finally {
-		c.flags &= -5;
-		purgeDeps$1(c);
-	}
-}
-function updateSignal(s) {
-	s.flags = 1;
-	return s.currentValue !== (s.currentValue = s.pendingValue);
-}
-function run(e) {
-	const flags = e.flags;
-	if (flags & 16 || flags & 32 && checkDirty$1(e.deps, e)) {
-		e.depsTail = void 0;
-		e.flags = 6;
-		try {
-			e.fn();
-		} finally {
-			e.flags &= -5;
-			purgeDeps$1(e);
-		}
-	} else e.flags = 2;
-}
-function flush$1() {
-	try {
-		while (notifyIndex$1 < queuedLength) {
-			const effect2 = queued[notifyIndex$1];
-			queued[notifyIndex$1++] = void 0;
-			run(effect2);
-		}
-	} finally {
-		while (notifyIndex$1 < queuedLength) {
-			const effect2 = queued[notifyIndex$1];
-			queued[notifyIndex$1++] = void 0;
-			effect2.flags |= 10;
-		}
-		notifyIndex$1 = 0;
-		queuedLength = 0;
-	}
-}
-function effectScopeOper() {
-	this.depsTail = void 0;
-	this.flags = 0;
-	purgeDeps$1(this);
-	const sub = this.subs;
-	if (sub !== void 0) unlink$1(sub);
-}
-function purgeDeps$1(sub) {
-	const depsTail = sub.depsTail;
-	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
-	while (dep !== void 0) dep = unlink$1(dep, sub);
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/atom.js
-function toObserver(nextHandler, errorHandler, completionHandler) {
-	const isObserver = typeof nextHandler === "object";
-	const self = isObserver ? nextHandler : void 0;
-	return {
-		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
-		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
-	};
-}
-var queuedEffects = [];
-var cycle = 0;
-var { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
-	update(atom) {
-		return atom._update();
-	},
-	notify(effect2) {
-		queuedEffects[queuedEffectsLength++] = effect2;
-		effect2.flags &= ~ReactiveFlags.Watching;
-	},
-	unwatched(atom) {
-		if (atom.depsTail !== void 0) {
-			atom.depsTail = void 0;
-			atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-			purgeDeps(atom);
-		}
-	}
-});
-var notifyIndex = 0;
-var queuedEffectsLength = 0;
-var activeSub;
-function purgeDeps(sub) {
-	const depsTail = sub.depsTail;
-	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
-	while (dep !== void 0) dep = unlink(dep, sub);
-}
-function flush() {
-	if (getBatchDepth() > 0) return;
-	while (notifyIndex < queuedEffectsLength) {
-		const effect2 = queuedEffects[notifyIndex];
-		queuedEffects[notifyIndex++] = void 0;
-		effect2.notify();
-	}
-	notifyIndex = 0;
-	queuedEffectsLength = 0;
-}
-function createAtom(valueOrFn, options) {
-	const isComputed = typeof valueOrFn === "function";
-	const getter = valueOrFn;
-	const atom = {
-		_snapshot: isComputed ? void 0 : valueOrFn,
-		subs: void 0,
-		subsTail: void 0,
-		deps: void 0,
-		depsTail: void 0,
-		flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
-		get() {
-			if (activeSub !== void 0) link(atom, activeSub, cycle);
-			return atom._snapshot;
-		},
-		subscribe(observerOrFn) {
-			const obs = toObserver(observerOrFn);
-			const observed = { current: false };
-			const e = effect(() => {
-				atom.get();
-				if (!observed.current) observed.current = true;
-				else obs.next?.(atom._snapshot);
-			});
-			return { unsubscribe: () => {
-				e.stop();
-			} };
-		},
-		_update(getValue) {
-			const prevSub = activeSub;
-			const compare = options?.compare ?? Object.is;
-			if (isComputed) {
-				activeSub = atom;
-				++cycle;
-				atom.depsTail = void 0;
-			} else if (getValue === void 0) return false;
-			if (isComputed) atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
-			try {
-				const oldValue = atom._snapshot;
-				const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue;
-				if (oldValue === void 0 || !compare(oldValue, newValue)) {
-					atom._snapshot = newValue;
-					return true;
-				}
-				return false;
-			} finally {
-				activeSub = prevSub;
-				if (isComputed) atom.flags &= ~ReactiveFlags.RecursedCheck;
-				purgeDeps(atom);
-			}
-		}
-	};
-	if (isComputed) {
-		atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-		atom.get = function() {
-			const flags = atom.flags;
-			if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
-				if (atom._update()) {
-					const subs = atom.subs;
-					if (subs !== void 0) shallowPropagate(subs);
-				}
-			} else if (flags & ReactiveFlags.Pending) atom.flags = flags & ~ReactiveFlags.Pending;
-			if (activeSub !== void 0) link(atom, activeSub, cycle);
-			return atom._snapshot;
-		};
-	} else atom.set = function(valueOrFn2) {
-		if (atom._update(valueOrFn2)) {
-			const subs = atom.subs;
-			if (subs !== void 0) {
-				propagate(subs);
-				shallowPropagate(subs);
-				flush();
-			}
-		}
-	};
-	return atom;
-}
-function effect(fn) {
-	const run = () => {
-		const prevSub = activeSub;
-		activeSub = effectObj;
-		++cycle;
-		effectObj.depsTail = void 0;
-		effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-		try {
-			return fn();
-		} finally {
-			activeSub = prevSub;
-			effectObj.flags &= ~ReactiveFlags.RecursedCheck;
-			purgeDeps(effectObj);
-		}
-	};
-	const effectObj = {
-		deps: void 0,
-		depsTail: void 0,
-		subs: void 0,
-		subsTail: void 0,
-		flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
-		notify() {
-			const flags = this.flags;
-			if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) run();
-			else this.flags = ReactiveFlags.Watching;
-		},
-		stop() {
-			this.flags = ReactiveFlags.None;
-			this.depsTail = void 0;
-			purgeDeps(this);
-		}
-	};
-	run();
-	return effectObj;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/batch.js
-function batch(fn) {
-	try {
-		startBatch();
-		fn();
-	} finally {
-		endBatch();
-		flush();
-	}
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/not-found.js
-function CatchNotFound(props) {
-	const router = useRouter();
-	{
-		const resetKey = `not-found-${router.stores.location.state.pathname}-${router.stores.status.state}`;
-		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundary, {
-			getResetKey: () => resetKey,
-			onCatch: (error, errorInfo) => {
-				if (isNotFound(error)) props.onCatch?.(error, errorInfo);
-				else throw error;
-			},
-			errorComponent: ({ error }) => {
-				if (isNotFound(error)) return props.fallback?.(error);
-				else throw error;
-			},
-			children: props.children
-		});
-	}
-	const resetKey = `not-found-${useStore(router.stores.location, (location) => location.pathname)}-${useStore(router.stores.status, (status) => status)}`;
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundary, {
-		getResetKey: () => resetKey,
-		onCatch: (error, errorInfo) => {
-			if (isNotFound(error)) props.onCatch?.(error, errorInfo);
-			else throw error;
-		},
-		errorComponent: ({ error }) => {
-			if (isNotFound(error)) return props.fallback?.(error);
-			else throw error;
-		},
-		children: props.children
-	});
-}
-function DefaultGlobalNotFound() {
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: "Not Found" });
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/ScriptOnce.js
-/**
-* Server-only helper to emit a script tag exactly once during SSR.
-*/
-function ScriptOnce({ children }) {
-	const router = useRouter();
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
-		nonce: router.options.ssr?.nonce,
-		dangerouslySetInnerHTML: { __html: children + ";document.currentScript.remove()" }
-	});
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/SafeFragment.js
-function SafeFragment(props) {
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children });
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/renderRouteNotFound.js
-/**
-* Renders a not found component for a route when no matching route is found.
-*
-* @param router - The router instance containing the route configuration
-* @param route - The route that triggered the not found state
-* @param data - Additional data to pass to the not found component
-* @returns The rendered not found component or a default fallback component
-*/
-function renderRouteNotFound(router, route, data) {
-	if (!route.options.notFoundComponent) {
-		if (router.options.defaultNotFoundComponent) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(router.options.defaultNotFoundComponent, { ...data });
-		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultGlobalNotFound, {});
-	}
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(route.options.notFoundComponent, { ...data });
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
-function ScrollRestoration() {
-	const router = useRouter();
-	if (!router.isScrollRestoring || false) return null;
-	if (typeof router.options.scrollRestoration === "function") {
-		if (!router.options.scrollRestoration({ location: router.latestLocation })) return null;
-	}
-	const userKey = (router.options.getScrollRestorationKey || defaultGetScrollRestorationKey)(router.latestLocation);
-	const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0;
-	const restoreScrollOptions = {
-		storageKey,
-		shouldScrollRestoration: true
-	};
-	if (resolvedKey) restoreScrollOptions.key = resolvedKey;
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScriptOnce, { children: `(${restoreScroll.toString()})(${escapeHtml(JSON.stringify(restoreScrollOptions))})` });
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/Match.js
-var Match = import_react.memo(function MatchImpl({ matchId }) {
-	const router = useRouter();
-	{
-		const match = router.stores.activeMatchStoresById.get(matchId)?.state;
-		if (!match) invariant();
-		const routeId = match.routeId;
-		const parentRouteId = router.routesById[routeId].parentRoute?.id;
-		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchView, {
-			router,
-			matchId,
-			resetKey: router.stores.loadedAt.state,
-			matchState: {
-				routeId,
-				ssr: match.ssr,
-				_displayPending: match._displayPending,
-				parentRouteId
-			}
-		});
-	}
-	const matchStore = router.stores.activeMatchStoresById.get(matchId);
-	if (!matchStore) invariant();
-	const resetKey = useStore(router.stores.loadedAt, (loadedAt) => loadedAt);
-	const match = useStore(matchStore, (value) => value);
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchView, {
-		router,
-		matchId,
-		resetKey,
-		matchState: import_react.useMemo(() => {
-			const routeId = match.routeId;
-			const parentRouteId = router.routesById[routeId].parentRoute?.id;
+				options: await r.parse(h(e))
+			};
+		},
+		stream(e, r) {
 			return {
-				routeId,
-				ssr: match.ssr,
-				_displayPending: match._displayPending,
-				parentRouteId
+				body: r.parse(e.body && !e.bodyUsed ? e.clone().body : null),
+				options: r.parse(h(e))
 			};
-		}, [
-			match._displayPending,
-			match.routeId,
-			match.ssr,
-			router.routesById
-		])
-	});
-});
-function MatchView({ router, matchId, resetKey, matchState }) {
-	const route = router.routesById[matchState.routeId];
-	const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent;
-	const pendingElement = PendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PendingComponent, {}) : null;
-	const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent;
-	const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch;
-	const routeNotFoundComponent = route.isRoot ? route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component : route.options.notFoundComponent;
-	const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
-	const ResolvedSuspenseBoundary = (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (route.options.errorComponent?.preload || resolvedNoSsr)) ? import_react.Suspense : SafeFragment;
-	const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
-	const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(matchContext.Provider, {
-		value: matchId,
-		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedSuspenseBoundary, {
-			fallback: pendingElement,
-			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedCatchBoundary, {
-				getResetKey: () => resetKey,
-				errorComponent: routeErrorComponent || ErrorComponent,
-				onCatch: (error, errorInfo) => {
-					if (isNotFound(error)) throw error;
-					routeOnCatch?.(error, errorInfo);
-				},
-				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedNotFoundBoundary, {
-					fallback: (error) => {
-						if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot) throw error;
-						return import_react.createElement(routeNotFoundComponent, error);
-					},
-					children: resolvedNoSsr || matchState._displayPending ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClientOnly, {
-						fallback: pendingElement,
-						children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchInner, { matchId })
-					}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchInner, { matchId })
-				})
-			})
-		})
-	}), matchState.parentRouteId === "__root__" && router.options.scrollRestoration ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(OnRendered, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScrollRestoration, {})] }) : null] });
-}
-function OnRendered() {
-	const router = useRouter();
-	const prevLocationRef = import_react.useRef(void 0);
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
-		suppressHydrationWarning: true,
-		ref: (el) => {
-			if (el && (prevLocationRef.current === void 0 || prevLocationRef.current.href !== router.latestLocation.href)) {
-				router.emit({
-					type: "onRendered",
-					...getLocationChangeInfo(router.stores.location.state, router.stores.resolvedLocation.state)
-				});
-				prevLocationRef.current = router.latestLocation;
-			}
-		}
-	}, router.latestLocation.state.__TSR_key);
-}
-var MatchInner = import_react.memo(function MatchInnerImpl({ matchId }) {
-	const router = useRouter();
-	{
-		const match = router.stores.activeMatchStoresById.get(matchId)?.state;
-		if (!match) invariant();
-		const routeId = match.routeId;
-		const route = router.routesById[routeId];
-		const remountDeps = (router.routesById[routeId].options.remountDeps ?? router.options.defaultRemountDeps)?.({
-			routeId,
-			loaderDeps: match.loaderDeps,
-			params: match._strictParams,
-			search: match._strictSearch
-		});
-		const key = remountDeps ? JSON.stringify(remountDeps) : void 0;
-		const Comp = route.options.component ?? router.options.defaultComponent;
-		const out = Comp ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Comp, {}, key) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {});
-		if (match._displayPending) throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
-		if (match._forcePending) throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
-		if (match.status === "pending") throw router.getMatch(match.id)?._nonReactive.loadPromise;
-		if (match.status === "notFound") {
-			if (!isNotFound(match.error)) invariant();
-			return renderRouteNotFound(router, route, match.error);
-		}
-		if (match.status === "redirected") {
-			if (!isRedirect(match.error)) invariant();
-			throw router.getMatch(match.id)?._nonReactive.loadPromise;
-		}
-		if (match.status === "error") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)((route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
-			error: match.error,
-			reset: void 0,
-			info: { componentStack: "" }
-		});
-		return out;
-	}
-	const matchStore = router.stores.activeMatchStoresById.get(matchId);
-	if (!matchStore) invariant();
-	const match = useStore(matchStore, (value) => value);
-	const routeId = match.routeId;
-	const route = router.routesById[routeId];
-	const key = import_react.useMemo(() => {
-		const remountDeps = (router.routesById[routeId].options.remountDeps ?? router.options.defaultRemountDeps)?.({
-			routeId,
-			loaderDeps: match.loaderDeps,
-			params: match._strictParams,
-			search: match._strictSearch
-		});
-		return remountDeps ? JSON.stringify(remountDeps) : void 0;
-	}, [
-		routeId,
-		match.loaderDeps,
-		match._strictParams,
-		match._strictSearch,
-		router.options.defaultRemountDeps,
-		router.routesById
-	]);
-	const out = import_react.useMemo(() => {
-		const Comp = route.options.component ?? router.options.defaultComponent;
-		if (Comp) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Comp, {}, key);
-		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {});
-	}, [
-		key,
-		route.options.component,
-		router.options.defaultComponent
-	]);
-	if (match._displayPending) throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
-	if (match._forcePending) throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
-	if (match.status === "pending") {
-		if (route.options.pendingMinMs ?? router.options.defaultPendingMinMs) {
-			const routerMatch = router.getMatch(match.id);
-			if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {}
 		}
-		throw router.getMatch(match.id)?._nonReactive.loadPromise;
-	}
-	if (match.status === "notFound") {
-		if (!isNotFound(match.error)) invariant();
-		return renderRouteNotFound(router, route, match.error);
+	},
+	serialize(e, r) {
+		return "new Response(" + r.serialize(e.body) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Response(r.deserialize(e.body), r.deserialize(e.options));
 	}
-	if (match.status === "redirected") {
-		if (!isRedirect(match.error)) invariant();
-		throw router.getMatch(match.id)?._nonReactive.loadPromise;
+});
+ni({
+	tag: "seroval-plugins/web/URL",
+	test(e) {
+		return typeof URL == "undefined" ? !1 : e instanceof URL;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.href) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.href) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.href) };
+		}
+	},
+	serialize(e, r) {
+		return "new URL(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URL(r.deserialize(e.value));
 	}
-	if (match.status === "error") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)((route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
-		error: match.error,
-		reset: void 0,
-		info: { componentStack: "" }
-	});
-	return out;
 });
-/**
-* Render the next child match in the route tree. Typically used inside
-* a route component to render nested routes.
-*
-* @link https://tanstack.com/router/latest/docs/framework/react/api/router/outletComponent
-*/
-var Outlet = import_react.memo(function OutletImpl() {
-	const router = useRouter();
-	const matchId = import_react.useContext(matchContext);
-	let routeId;
-	let parentGlobalNotFound = false;
-	let childMatchId;
-	{
-		const matches = router.stores.activeMatchesSnapshot.state;
-		const parentIndex = matchId ? matches.findIndex((match) => match.id === matchId) : -1;
-		const parentMatch = parentIndex >= 0 ? matches[parentIndex] : void 0;
-		routeId = parentMatch?.routeId;
-		parentGlobalNotFound = parentMatch?.globalNotFound ?? false;
-		childMatchId = parentIndex >= 0 ? matches[parentIndex + 1]?.id : void 0;
-	}
-	const route = routeId ? router.routesById[routeId] : void 0;
-	const pendingElement = router.options.defaultPendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(router.options.defaultPendingComponent, {}) : null;
-	if (parentGlobalNotFound) {
-		if (!route) invariant();
-		return renderRouteNotFound(router, route, void 0);
-	}
-	if (!childMatchId) return null;
-	const nextMatch = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Match, { matchId: childMatchId });
-	if (routeId === "__root__") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, {
-		fallback: pendingElement,
-		children: nextMatch
-	});
-	return nextMatch;
+ni({
+	tag: "seroval-plugins/web/URLSearchParams",
+	test(e) {
+		return typeof URLSearchParams == "undefined" ? !1 : e instanceof URLSearchParams;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.toString()) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.toString()) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.toString()) };
+		}
+	},
+	serialize(e, r) {
+		return "new URLSearchParams(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URLSearchParams(r.deserialize(e.value));
+	}
 });
 //#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/seroval-plugins.js
+var defaultSerovalPlugins = [
+	ShallowErrorPlugin,
+	RawStreamSSRPlugin,
+	p
+];
+require_react();
+//#endregion
 //#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/Matches.js
+var import_jsx_runtime = require_jsx_runtime();
 /**
 * Internal component that renders the router's active match tree with
 * suspense, error, and not-found boundaries. Rendered by `RouterProvider`.
@@ -10016,7 +6762,7 @@ var require_react_dom_server_legacy_node_production = /* @__PURE__ */ __commonJS
 * LICENSE file in the root directory of this source tree.
 */
 var require_react_dom_server_node_production = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var util = __require("util"), crypto$1 = __require("crypto"), async_hooks = __require("async_hooks"), React = require_react(), ReactDOM = require_react_dom(), stream = __require("stream"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_SCOPE_TYPE = Symbol.for("react.scope"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"), REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+	var util = __require("util"), crypto = __require("crypto"), async_hooks = __require("async_hooks"), React = require_react(), ReactDOM = require_react_dom(), stream = __require("stream"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_SCOPE_TYPE = Symbol.for("react.scope"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"), REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 	function getIteratorFn(maybeIterable) {
 		if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
 		maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
@@ -12040,7 +8786,7 @@ var require_react_dom_server_node_production = /* @__PURE__ */ __commonJSMin(((e
 			null,
 			hookIndex
 		]);
-		componentKeyPath = crypto$1.createHash("md5");
+		componentKeyPath = crypto.createHash("md5");
 		componentKeyPath.update(permalink);
 		return "k" + componentKeyPath.digest("hex");
 	}
@@ -14541,66 +11287,6 @@ function getNormalizedURL(url, base) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.bun/cookie-es@2.0.0/node_modules/cookie-es/dist/index.mjs
-function splitSetCookieString(cookiesString) {
-	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c) => splitSetCookieString(c));
-	if (typeof cookiesString !== "string") return [];
-	const cookiesStrings = [];
-	let pos = 0;
-	let start;
-	let ch;
-	let lastComma;
-	let nextStart;
-	let cookiesSeparatorFound;
-	const skipWhitespace = () => {
-		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
-		return pos < cookiesString.length;
-	};
-	const notSpecialChar = () => {
-		ch = cookiesString.charAt(pos);
-		return ch !== "=" && ch !== ";" && ch !== ",";
-	};
-	while (pos < cookiesString.length) {
-		start = pos;
-		cookiesSeparatorFound = false;
-		while (skipWhitespace()) {
-			ch = cookiesString.charAt(pos);
-			if (ch === ",") {
-				lastComma = pos;
-				pos += 1;
-				skipWhitespace();
-				nextStart = pos;
-				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
-				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-					cookiesSeparatorFound = true;
-					pos = nextStart;
-					cookiesStrings.push(cookiesString.slice(start, lastComma));
-					start = pos;
-				} else pos = lastComma + 1;
-			} else pos += 1;
-		}
-		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
-	}
-	return cookiesStrings;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/ssr/headers.js
-function toHeadersInstance(init) {
-	if (init instanceof Headers) return init;
-	else if (Array.isArray(init)) return new Headers(init);
-	else if (typeof init === "object") return new Headers(init);
-	else return null;
-}
-function mergeHeaders(...headers) {
-	return headers.reduce((acc, header) => {
-		const headersInstance = toHeadersInstance(header);
-		if (!headersInstance) return acc;
-		for (const [key, value] of headersInstance.entries()) if (key === "set-cookie") splitSetCookieString(value).forEach((cookie) => acc.append("set-cookie", cookie));
-		else acc.set(key, value);
-		return acc;
-	}, new Headers());
-}
-//#endregion
 //#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/ssr/handlerCallback.js
 function defineHandlerCallback(handler) {
 	return handler;
@@ -14995,592 +11681,6 @@ var defaultStreamHandler = defineHandlerCallback(({ request, router, responseHea
 	children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StartServer, { router })
 }));
 //#endregion
-//#region ../../node_modules/.bun/rou3@0.8.1/node_modules/rou3/dist/index.mjs
-var NullProtoObj = /* @__PURE__ */ (() => {
-	const e = function() {};
-	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
-})();
-//#endregion
-//#region ../../node_modules/.bun/srvx@0.11.13/node_modules/srvx/dist/_chunks/_url.mjs
-function lazyInherit(target, source, sourceKey) {
-	for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
-		if (key === "constructor") continue;
-		const targetDesc = Object.getOwnPropertyDescriptor(target, key);
-		const desc = Object.getOwnPropertyDescriptor(source, key);
-		let modified = false;
-		if (desc.get) {
-			modified = true;
-			desc.get = targetDesc?.get || function() {
-				return this[sourceKey][key];
-			};
-		}
-		if (desc.set) {
-			modified = true;
-			desc.set = targetDesc?.set || function(value) {
-				this[sourceKey][key] = value;
-			};
-		}
-		if (!targetDesc?.value && typeof desc.value === "function") {
-			modified = true;
-			desc.value = function(...args) {
-				return this[sourceKey][key](...args);
-			};
-		}
-		if (modified) Object.defineProperty(target, key, desc);
-	}
-}
-var _needsNormRE = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
-/**
-* URL wrapper with fast paths to access to the following props:
-*
-*  - `url.pathname`
-*  - `url.search`
-*  - `url.searchParams`
-*  - `url.protocol`
-*
-* **NOTES:**
-*
-* - It is assumed that the input URL is **already encoded** and formatted from an HTTP request and contains no hash.
-* - Triggering the setters or getters on other props will deoptimize to full URL parsing.
-* - Changes to `searchParams` will be discarded as we don't track them.
-*/
-var FastURL = /* @__PURE__ */ (() => {
-	const NativeURL = globalThis.URL;
-	const FastURL = class URL {
-		#url;
-		#href;
-		#protocol;
-		#host;
-		#pathname;
-		#search;
-		#searchParams;
-		#pos;
-		constructor(url) {
-			if (typeof url === "string") if (url[0] === "/") this.#href = url;
-			else this.#url = new NativeURL(url);
-			else if (_needsNormRE.test(url.pathname)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
-			else {
-				this.#protocol = url.protocol;
-				this.#host = url.host;
-				this.#pathname = url.pathname;
-				this.#search = url.search;
-			}
-		}
-		static [Symbol.hasInstance](val) {
-			return val instanceof NativeURL;
-		}
-		get _url() {
-			if (this.#url) return this.#url;
-			this.#url = new NativeURL(this.href);
-			this.#href = void 0;
-			this.#protocol = void 0;
-			this.#host = void 0;
-			this.#pathname = void 0;
-			this.#search = void 0;
-			this.#searchParams = void 0;
-			this.#pos = void 0;
-			return this.#url;
-		}
-		get href() {
-			if (this.#url) return this.#url.href;
-			if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
-			return this.#href;
-		}
-		#getPos() {
-			if (!this.#pos) {
-				const url = this.href;
-				const protoIndex = url.indexOf("://");
-				const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
-				this.#pos = [
-					protoIndex,
-					pathnameIndex,
-					pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex)
-				];
-			}
-			return this.#pos;
-		}
-		get pathname() {
-			if (this.#url) return this.#url.pathname;
-			if (this.#pathname === void 0) {
-				const [, pathnameIndex, queryIndex] = this.#getPos();
-				if (pathnameIndex === -1) return this._url.pathname;
-				this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
-			}
-			return this.#pathname;
-		}
-		get search() {
-			if (this.#url) return this.#url.search;
-			if (this.#search === void 0) {
-				const [, pathnameIndex, queryIndex] = this.#getPos();
-				if (pathnameIndex === -1) return this._url.search;
-				const url = this.href;
-				this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
-			}
-			return this.#search;
-		}
-		get searchParams() {
-			if (this.#url) return this.#url.searchParams;
-			if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
-			return this.#searchParams;
-		}
-		get protocol() {
-			if (this.#url) return this.#url.protocol;
-			if (this.#protocol === void 0) {
-				const [protocolIndex] = this.#getPos();
-				if (protocolIndex === -1) return this._url.protocol;
-				this.#protocol = this.href.slice(0, protocolIndex + 1);
-			}
-			return this.#protocol;
-		}
-		toString() {
-			return this.href;
-		}
-		toJSON() {
-			return this.href;
-		}
-	};
-	lazyInherit(FastURL.prototype, NativeURL.prototype, "_url");
-	Object.setPrototypeOf(FastURL.prototype, NativeURL.prototype);
-	Object.setPrototypeOf(FastURL, NativeURL);
-	return FastURL;
-})();
-//#endregion
-//#region ../../node_modules/.bun/srvx@0.11.13/node_modules/srvx/dist/adapters/node.mjs
-/**
-* Fast Response for Node.js runtime
-*
-* It is faster because in most cases it doesn't create a full Response instance.
-*/
-var NodeResponse = /* @__PURE__ */ (() => {
-	const NativeResponse = globalThis.Response;
-	const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
-	class NodeResponse {
-		#body;
-		#init;
-		#headers;
-		#response;
-		constructor(body, init) {
-			this.#body = body;
-			this.#init = init;
-		}
-		static [Symbol.hasInstance](val) {
-			return val instanceof NativeResponse;
-		}
-		get status() {
-			return this.#response?.status || this.#init?.status || 200;
-		}
-		get statusText() {
-			return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
-		}
-		get headers() {
-			if (this.#response) return this.#response.headers;
-			if (this.#headers) return this.#headers;
-			const initHeaders = this.#init?.headers;
-			return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
-		}
-		get ok() {
-			if (this.#response) return this.#response.ok;
-			const status = this.status;
-			return status >= 200 && status < 300;
-		}
-		get _response() {
-			if (this.#response) return this.#response;
-			let body = this.#body;
-			if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
-				const stream = new PassThrough();
-				body.pipe(stream);
-				const abort = body.abort;
-				if (abort) stream.once("close", () => abort());
-				body = stream;
-			}
-			this.#response = new NativeResponse(body, this.#headers ? {
-				...this.#init,
-				headers: this.#headers
-			} : this.#init);
-			this.#init = void 0;
-			this.#headers = void 0;
-			this.#body = void 0;
-			return this.#response;
-		}
-		_toNodeResponse() {
-			const status = this.status;
-			const statusText = this.statusText;
-			let body;
-			let contentType;
-			let contentLength;
-			if (this.#response) body = this.#response.body;
-			else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
-			else if (typeof this.#body === "string") {
-				body = this.#body;
-				contentType = "text/plain; charset=UTF-8";
-				contentLength = Buffer.byteLength(this.#body);
-			} else if (this.#body instanceof ArrayBuffer) {
-				body = Buffer.from(this.#body);
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof Uint8Array) {
-				body = this.#body;
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof DataView) {
-				body = Buffer.from(this.#body.buffer);
-				contentLength = this.#body.byteLength;
-			} else if (this.#body instanceof Blob) {
-				body = this.#body.stream();
-				contentType = this.#body.type;
-				contentLength = this.#body.size;
-			} else if (typeof this.#body.pipe === "function") body = this.#body;
-			else body = this._response.body;
-			const headers = [];
-			const initHeaders = this.#init?.headers;
-			const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k, v]) => [k.toLowerCase(), v]) : void 0);
-			let hasContentTypeHeader;
-			let hasContentLength;
-			if (headerEntries) for (const [key, value] of headerEntries) {
-				if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
-				else headers.push([key, value]);
-				if (key === "content-type") hasContentTypeHeader = true;
-				else if (key === "content-length") hasContentLength = true;
-			}
-			if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
-			if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
-			this.#init = void 0;
-			this.#headers = void 0;
-			this.#response = void 0;
-			this.#body = void 0;
-			return {
-				status,
-				statusText,
-				headers,
-				body
-			};
-		}
-	}
-	lazyInherit(NodeResponse.prototype, NativeResponse.prototype, "_response");
-	Object.setPrototypeOf(NodeResponse, NativeResponse);
-	Object.setPrototypeOf(NodeResponse.prototype, NativeResponse.prototype);
-	return NodeResponse;
-})();
-//#endregion
-//#region ../../node_modules/.bun/h3@2.0.1-rc.16/node_modules/h3/dist/h3-ByfIX5Jk.mjs
-var kEventNS = "h3.internal.event.";
-var kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
-var kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
-var H3Event = class {
-	app;
-	req;
-	url;
-	context;
-	static __is_event__ = true;
-	constructor(req, context, app) {
-		this.context = context || req.context || new NullProtoObj();
-		this.req = req;
-		this.app = app;
-		const _url = req._url;
-		this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
-	}
-	get res() {
-		return this[kEventRes] ||= new H3EventResponse();
-	}
-	get runtime() {
-		return this.req.runtime;
-	}
-	waitUntil(promise) {
-		this.req.waitUntil?.(promise);
-	}
-	toString() {
-		return `[${this.req.method}] ${this.req.url}`;
-	}
-	toJSON() {
-		return this.toString();
-	}
-	get node() {
-		return this.req.runtime?.node;
-	}
-	get headers() {
-		return this.req.headers;
-	}
-	get path() {
-		return this.url.pathname + this.url.search;
-	}
-	get method() {
-		return this.req.method;
-	}
-};
-var H3EventResponse = class {
-	status;
-	statusText;
-	get headers() {
-		return this[kEventResHeaders] ||= new Headers();
-	}
-};
-var DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
-function sanitizeStatusMessage(statusMessage = "") {
-	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
-}
-function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
-	if (!statusCode) return defaultStatusCode;
-	if (typeof statusCode === "string") statusCode = +statusCode;
-	if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
-	return statusCode;
-}
-var HTTPError = class HTTPError extends Error {
-	get name() {
-		return "HTTPError";
-	}
-	status;
-	statusText;
-	headers;
-	cause;
-	data;
-	body;
-	unhandled;
-	static isError(input) {
-		return input instanceof Error && input?.name === "HTTPError";
-	}
-	static status(status, statusText, details) {
-		return new HTTPError({
-			...details,
-			statusText,
-			status
-		});
-	}
-	constructor(arg1, arg2) {
-		let messageInput;
-		let details;
-		if (typeof arg1 === "string") {
-			messageInput = arg1;
-			details = arg2;
-		} else details = arg1;
-		const status = sanitizeStatusCode(details?.status || (details?.cause)?.status || details?.status || details?.statusCode, 500);
-		const statusText = sanitizeStatusMessage(details?.statusText || (details?.cause)?.statusText || details?.statusText || details?.statusMessage);
-		const message = messageInput || details?.message || (details?.cause)?.message || details?.statusText || details?.statusMessage || [
-			"HTTPError",
-			status,
-			statusText
-		].filter(Boolean).join(" ");
-		super(message, { cause: details });
-		this.cause = details;
-		this.status = status;
-		this.statusText = statusText || void 0;
-		const rawHeaders = details?.headers || (details?.cause)?.headers;
-		this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
-		this.unhandled = details?.unhandled ?? (details?.cause)?.unhandled ?? void 0;
-		this.data = details?.data;
-		this.body = details?.body;
-	}
-	get statusCode() {
-		return this.status;
-	}
-	get statusMessage() {
-		return this.statusText;
-	}
-	toJSON() {
-		const unhandled = this.unhandled;
-		return {
-			status: this.status,
-			statusText: this.statusText,
-			unhandled,
-			message: unhandled ? "HTTPError" : this.message,
-			data: unhandled ? void 0 : this.data,
-			...unhandled ? void 0 : this.body
-		};
-	}
-};
-function isJSONSerializable(value, _type) {
-	if (value === null || value === void 0) return true;
-	if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
-	if (typeof value.toJSON === "function") return true;
-	if (Array.isArray(value)) return true;
-	if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
-	if (value instanceof NullProtoObj) return true;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-var kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
-var kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
-function toResponse(val, event, config = {}) {
-	if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
-	const response = prepareResponse(val, event, config);
-	if (typeof response?.then === "function") return toResponse(response, event, config);
-	const { onResponse } = config;
-	return onResponse ? Promise.resolve(onResponse(response, event)).then(() => response) : response;
-}
-var HTTPResponse = class {
-	#headers;
-	#init;
-	body;
-	constructor(body, init) {
-		this.body = body;
-		this.#init = init;
-	}
-	get status() {
-		return this.#init?.status || 200;
-	}
-	get statusText() {
-		return this.#init?.statusText || "OK";
-	}
-	get headers() {
-		return this.#headers ||= new Headers(this.#init?.headers);
-	}
-};
-function prepareResponse(val, event, config, nested) {
-	if (val === kHandled) return new NodeResponse(null);
-	if (val === kNotFound) val = new HTTPError({
-		status: 404,
-		message: `Cannot find any route matching [${event.req.method}] ${event.url}`
-	});
-	if (val && val instanceof Error) {
-		const isHTTPError = HTTPError.isError(val);
-		const error = isHTTPError ? val : new HTTPError(val);
-		if (!isHTTPError) {
-			error.unhandled = true;
-			if (val?.stack) error.stack = val.stack;
-		}
-		if (error.unhandled && !config.silent) console.error(error);
-		const { onError } = config;
-		return onError && !nested ? Promise.resolve(onError(error, event)).catch((error) => error).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
-	}
-	const preparedRes = event[kEventRes];
-	const preparedHeaders = preparedRes?.[kEventResHeaders];
-	event[kEventRes] = void 0;
-	if (!(val instanceof Response)) {
-		const res = prepareResponseBody(val, event, config);
-		const status = res.status || preparedRes?.status;
-		return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
-			status,
-			statusText: res.statusText || preparedRes?.statusText,
-			headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
-		});
-	}
-	if (!preparedHeaders || nested || !val.ok) return val;
-	try {
-		mergeHeaders$1(val.headers, preparedHeaders, val.headers);
-		return val;
-	} catch {
-		return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
-			status: val.status,
-			statusText: val.statusText,
-			headers: mergeHeaders$1(val.headers, preparedHeaders)
-		});
-	}
-}
-function mergeHeaders$1(base, overrides, target = new Headers(base)) {
-	for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
-	else target.set(name, value);
-	return target;
-}
-var frozen = (name) => (...args) => {
-	throw new Error(`Headers are frozen (${name} ${args.join(", ")})`);
-};
-var FrozenHeaders = class extends Headers {
-	set = frozen("set");
-	append = frozen("append");
-	delete = frozen("delete");
-};
-var emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
-var jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
-function prepareResponseBody(val, event, config) {
-	if (val === null || val === void 0) return {
-		body: "",
-		headers: emptyHeaders
-	};
-	const valType = typeof val;
-	if (valType === "string") return { body: val };
-	if (val instanceof Uint8Array) {
-		event.res.headers.set("content-length", val.byteLength.toString());
-		return { body: val };
-	}
-	if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
-	if (isJSONSerializable(val, valType)) return {
-		body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
-		headers: jsonHeaders
-	};
-	if (valType === "bigint") return {
-		body: val.toString(),
-		headers: jsonHeaders
-	};
-	if (val instanceof Blob) {
-		const headers = new Headers({
-			"content-type": val.type,
-			"content-length": val.size.toString()
-		});
-		let filename = val.name;
-		if (filename) {
-			filename = encodeURIComponent(filename);
-			headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
-		}
-		return {
-			body: val.stream(),
-			headers
-		};
-	}
-	if (valType === "symbol") return { body: val.toString() };
-	if (valType === "function") return { body: `${val.name}()` };
-	return { body: val };
-}
-function nullBody(method, status) {
-	return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
-}
-function errorResponse(error, debug) {
-	return new NodeResponse(JSON.stringify({
-		...error.toJSON(),
-		stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
-	}, void 0, debug ? 2 : void 0), {
-		status: error.status,
-		statusText: error.statusText,
-		headers: error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders)
-	});
-}
-new TextEncoder();
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-server-core@1.167.3/node_modules/@tanstack/start-server-core/dist/esm/request-response.js
-var GLOBAL_EVENT_STORAGE_KEY = Symbol.for("tanstack-start:event-storage");
-var globalObj$1 = globalThis;
-if (!globalObj$1[GLOBAL_EVENT_STORAGE_KEY]) globalObj$1[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
-var eventStorage = globalObj$1[GLOBAL_EVENT_STORAGE_KEY];
-function isPromiseLike(value) {
-	return typeof value.then === "function";
-}
-function getSetCookieValues(headers) {
-	const headersWithSetCookie = headers;
-	if (typeof headersWithSetCookie.getSetCookie === "function") return headersWithSetCookie.getSetCookie();
-	const value = headers.get("set-cookie");
-	return value ? [value] : [];
-}
-function mergeEventResponseHeaders(response, event) {
-	if (response.ok) return;
-	const eventSetCookies = getSetCookieValues(event.res.headers);
-	if (eventSetCookies.length === 0) return;
-	const responseSetCookies = getSetCookieValues(response.headers);
-	response.headers.delete("set-cookie");
-	for (const cookie of responseSetCookies) response.headers.append("set-cookie", cookie);
-	for (const cookie of eventSetCookies) response.headers.append("set-cookie", cookie);
-}
-function attachResponseHeaders(value, event) {
-	if (isPromiseLike(value)) return value.then((resolved) => {
-		if (resolved instanceof Response) mergeEventResponseHeaders(resolved, event);
-		return resolved;
-	});
-	if (value instanceof Response) mergeEventResponseHeaders(value, event);
-	return value;
-}
-function requestHandler(handler) {
-	return (request, requestOpts) => {
-		const h3Event = new H3Event(request);
-		return toResponse(attachResponseHeaders(eventStorage.run({ h3Event }, () => handler(request, requestOpts)), h3Event), h3Event);
-	};
-}
-function getH3Event() {
-	const event = eventStorage.getStore();
-	if (!event) throw new Error(`No StartEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`);
-	return event.h3Event;
-}
-function getRequest() {
-	return getH3Event().req;
-}
-function getResponse() {
-	return getH3Event().res;
-}
-//#endregion
 //#region ../../node_modules/.bun/@tanstack+start-server-core@1.167.3/node_modules/@tanstack/start-server-core/dist/esm/constants.js
 var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
 //#endregion
@@ -15598,7 +11698,7 @@ var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
 * the dev styles URL for route-scoped CSS collection.
 */
 async function getStartManifest(matchedRoutes) {
-	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-BgMVPPt2.js");
+	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-CZNmyv5h.js");
 	const startManifest = tsrStartManifest();
 	const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes["__root__"] || {};
 	rootRoute.assets = rootRoute.assets || [];
@@ -15623,264 +11723,6 @@ async function getStartManifest(matchedRoutes) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/constants.js
-var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
-var TSS_SERVER_FUNCTION = Symbol.for("TSS_SERVER_FUNCTION");
-var TSS_SERVER_FUNCTION_FACTORY = Symbol.for("TSS_SERVER_FUNCTION_FACTORY");
-var X_TSS_SERIALIZED = "x-tss-serialized";
-var X_TSS_RAW_RESPONSE = "x-tss-raw";
-/** Content-Type for multiplexed framed responses (RawStream support) */
-var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
-/**
-* Frame types for binary multiplexing protocol.
-*/
-var FrameType = {
-	JSON: 0,
-	CHUNK: 1,
-	END: 2,
-	ERROR: 3
-};
-/** Full Content-Type header value with version parameter */
-var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/safeObjectMerge.js
-function isSafeKey(key) {
-	return key !== "__proto__" && key !== "constructor" && key !== "prototype";
-}
-/**
-* Merge target and source into a new null-proto object, filtering dangerous keys.
-*/
-function safeObjectMerge(target, source) {
-	const result = Object.create(null);
-	if (target) {
-		for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
-	}
-	if (source && typeof source === "object") {
-		for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
-	}
-	return result;
-}
-/**
-* Create a null-prototype object, optionally copying from source.
-*/
-function createNullProtoObject(source) {
-	if (!source) return Object.create(null);
-	const obj = Object.create(null);
-	for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
-	return obj;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-storage-context@1.166.17/node_modules/@tanstack/start-storage-context/dist/esm/async-local-storage.js
-var GLOBAL_STORAGE_KEY = Symbol.for("tanstack-start:start-storage-context");
-var globalObj = globalThis;
-if (!globalObj[GLOBAL_STORAGE_KEY]) globalObj[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
-var startStorage = globalObj[GLOBAL_STORAGE_KEY];
-async function runWithStartContext(context, fn) {
-	return startStorage.run(context, fn);
-}
-function getStartContext(opts) {
-	const context = startStorage.getStore();
-	if (!context && opts?.throwIfNotFound !== false) throw new Error(`No Start context found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`);
-	return context;
-}
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/getStartOptions.js
-var getStartOptions = () => getStartContext().startOptions;
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/getStartContextServerOnly.js
-var getStartContextServerOnly = getStartContext;
-//#endregion
-//#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/createServerFn.js
-var createServerFn = (options, __opts) => {
-	const resolvedOptions = __opts || options || {};
-	if (typeof resolvedOptions.method === "undefined") resolvedOptions.method = "GET";
-	const res = {
-		options: resolvedOptions,
-		middleware: (middleware) => {
-			const newMiddleware = [...resolvedOptions.middleware || []];
-			middleware.map((m) => {
-				if (TSS_SERVER_FUNCTION_FACTORY in m) {
-					if (m.options.middleware) newMiddleware.push(...m.options.middleware);
-				} else newMiddleware.push(m);
-			});
-			const res = createServerFn(void 0, {
-				...resolvedOptions,
-				middleware: newMiddleware
-			});
-			res[TSS_SERVER_FUNCTION_FACTORY] = true;
-			return res;
-		},
-		inputValidator: (inputValidator) => {
-			return createServerFn(void 0, {
-				...resolvedOptions,
-				inputValidator
-			});
-		},
-		handler: (...args) => {
-			const [extractedFn, serverFn] = args;
-			const newOptions = {
-				...resolvedOptions,
-				extractedFn,
-				serverFn
-			};
-			const resolvedMiddleware = [...newOptions.middleware || [], serverFnBaseToMiddleware(newOptions)];
-			extractedFn.method = resolvedOptions.method;
-			return Object.assign(async (opts) => {
-				const result = await executeMiddleware$1(resolvedMiddleware, "client", {
-					...extractedFn,
-					...newOptions,
-					data: opts?.data,
-					headers: opts?.headers,
-					signal: opts?.signal,
-					fetch: opts?.fetch,
-					context: createNullProtoObject()
-				});
-				const redirect = parseRedirect(result.error);
-				if (redirect) throw redirect;
-				if (result.error) throw result.error;
-				return result.result;
-			}, {
-				...extractedFn,
-				method: resolvedOptions.method,
-				__executeServer: async (opts) => {
-					const startContext = getStartContextServerOnly();
-					const serverContextAfterGlobalMiddlewares = startContext.contextAfterGlobalMiddlewares;
-					return await executeMiddleware$1(resolvedMiddleware, "server", {
-						...extractedFn,
-						...opts,
-						serverFnMeta: extractedFn.serverFnMeta,
-						context: safeObjectMerge(serverContextAfterGlobalMiddlewares, opts.context),
-						request: startContext.request
-					}).then((d) => ({
-						result: d.result,
-						error: d.error,
-						context: d.sendContext
-					}));
-				}
-			});
-		}
-	};
-	const fun = (options) => {
-		return createServerFn(void 0, {
-			...resolvedOptions,
-			...options
-		});
-	};
-	return Object.assign(fun, res);
-};
-async function executeMiddleware$1(middlewares, env, opts) {
-	let flattenedMiddlewares = flattenMiddlewares([...getStartOptions()?.functionMiddleware || [], ...middlewares]);
-	if (env === "server") {
-		const startContext = getStartContextServerOnly({ throwIfNotFound: false });
-		if (startContext?.executedRequestMiddlewares) flattenedMiddlewares = flattenedMiddlewares.filter((m) => !startContext.executedRequestMiddlewares.has(m));
-	}
-	const callNextMiddleware = async (ctx) => {
-		const nextMiddleware = flattenedMiddlewares.shift();
-		if (!nextMiddleware) return ctx;
-		try {
-			if ("inputValidator" in nextMiddleware.options && nextMiddleware.options.inputValidator && env === "server") ctx.data = await execValidator(nextMiddleware.options.inputValidator, ctx.data);
-			let middlewareFn = void 0;
-			if (env === "client") {
-				if ("client" in nextMiddleware.options) middlewareFn = nextMiddleware.options.client;
-			} else if ("server" in nextMiddleware.options) middlewareFn = nextMiddleware.options.server;
-			if (middlewareFn) {
-				const userNext = async (userCtx = {}) => {
-					const result = await callNextMiddleware({
-						...ctx,
-						...userCtx,
-						context: safeObjectMerge(ctx.context, userCtx.context),
-						sendContext: safeObjectMerge(ctx.sendContext, userCtx.sendContext),
-						headers: mergeHeaders(ctx.headers, userCtx.headers),
-						_callSiteFetch: ctx._callSiteFetch,
-						fetch: ctx._callSiteFetch ?? userCtx.fetch ?? ctx.fetch,
-						result: userCtx.result !== void 0 ? userCtx.result : userCtx instanceof Response ? userCtx : ctx.result,
-						error: userCtx.error ?? ctx.error
-					});
-					if (result.error) throw result.error;
-					return result;
-				};
-				const result = await middlewareFn({
-					...ctx,
-					next: userNext
-				});
-				if (isRedirect(result)) return {
-					...ctx,
-					error: result
-				};
-				if (result instanceof Response) return {
-					...ctx,
-					result
-				};
-				if (!result) throw new Error("User middleware returned undefined. You must call next() or return a result in your middlewares.");
-				return result;
-			}
-			return callNextMiddleware(ctx);
-		} catch (error) {
-			return {
-				...ctx,
-				error
-			};
-		}
-	};
-	return callNextMiddleware({
-		...opts,
-		headers: opts.headers || {},
-		sendContext: opts.sendContext || {},
-		context: opts.context || createNullProtoObject(),
-		_callSiteFetch: opts.fetch
-	});
-}
-function flattenMiddlewares(middlewares, maxDepth = 100) {
-	const seen = /* @__PURE__ */ new Set();
-	const flattened = [];
-	const recurse = (middleware, depth) => {
-		if (depth > maxDepth) throw new Error(`Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`);
-		middleware.forEach((m) => {
-			if (m.options.middleware) recurse(m.options.middleware, depth + 1);
-			if (!seen.has(m)) {
-				seen.add(m);
-				flattened.push(m);
-			}
-		});
-	};
-	recurse(middlewares, 0);
-	return flattened;
-}
-async function execValidator(validator, input) {
-	if (validator == null) return {};
-	if ("~standard" in validator) {
-		const result = await validator["~standard"].validate(input);
-		if (result.issues) throw new Error(JSON.stringify(result.issues, void 0, 2));
-		return result.value;
-	}
-	if ("parse" in validator) return validator.parse(input);
-	if (typeof validator === "function") return validator(input);
-	throw new Error("Invalid validator type!");
-}
-function serverFnBaseToMiddleware(options) {
-	return {
-		"~types": void 0,
-		options: {
-			inputValidator: options.inputValidator,
-			client: async ({ next, sendContext, fetch, ...ctx }) => {
-				const payload = {
-					...ctx,
-					context: sendContext,
-					fetch
-				};
-				return next(await options.extractedFn?.(payload));
-			},
-			server: async ({ next, ...ctx }) => {
-				const result = await options.serverFn?.(ctx);
-				return next({
-					...ctx,
-					result
-				});
-			}
-		}
-	};
-}
-//#endregion
 //#region ../../node_modules/.bun/@tanstack+start-client-core@1.167.3/node_modules/@tanstack/start-client-core/dist/esm/getDefaultSerovalPlugins.js
 function getDefaultSerovalPlugins() {
 	return [...(getStartOptions()?.serializationAdapters)?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
@@ -16404,9 +12246,9 @@ var baseManifestPromise;
 */
 var cachedFinalManifestPromise;
 async function loadEntries() {
-	const routerEntry = await import("./assets/router-noqexgr0.js");
+	const routerEntry = await import("./assets/router-B4k1eDGl.js");
 	return {
-		startEntry: await import("./assets/start-BiybVoR2.js"),
+		startEntry: await import("./assets/start-BYRsG6Vf.js"),
 		routerEntry
 	};
 }
@@ -16762,10 +12604,11 @@ async function handleServerRoutes({ getRouter, request, url, executeRouter, cont
 * Custom server entry that wraps TanStack Start's default handler
 * to add better-auth API route handling at /api/auth/*.
 */
+await ensureMigrations();
 var startHandler = createStartHandler(defaultStreamHandler);
 var server_default = { async fetch(request) {
 	if (new URL(request.url).pathname.startsWith("/api/auth")) return getAuth().handler(request);
 	return startHandler(request);
 } };
 //#endregion
-export { batch as a, getAssetCrossOrigin as c, createNonReactiveMutableStore as d, server_default as default, createNonReactiveReadonlyStore as f, Outlet as i, resolveManifestAssetLink as l, TSS_SERVER_FUNCTION as n, createAtom as o, redirect as p, getRequest as r, toObserver as s, createServerFn as t, RouterCore as u };
+export { server_default as default };