@tanstack/router-core 1.171.14 → 1.171.16-pre.0

package/dist/esm/router.js

@@ -1,4 +1,4 @@
-import { DEFAULT_PROTOCOL_ALLOWLIST, createControlledPromise, decodePath, deepEqual, encodePathLikeUrl, findLast, functionalUpdate, hasKeys, isDangerousProtocol, last, nullReplaceEqualDeep, replaceEqualDeep } from "./utils.js";
+import { DEFAULT_PROTOCOL_ALLOWLIST, decodePath, deepEqual, encodePathLikeUrl, findLast, functionalUpdate, hasKeys, isDangerousProtocol, last, nullReplaceEqualDeep, replaceEqualDeep } from "./utils.js";
 import { createLRUCache } from "./lru-cache.js";
 import { buildRouteBranch, findFlatMatch, findRouteMatch, findSingleMatch, processRouteMasks, processRouteTree } from "./new-process-route-tree.js";
 import { cleanPath, compileDecodeCharMap, interpolatePath, resolvePath, trimPath, trimPathRight } from "./path.js";
@@ -6,13 +6,16 @@ import { isNotFound } from "./not-found.js";
 import { setupScrollRestoration } from "./scroll-restoration.js";
 import { defaultParseSearch, defaultStringifySearch } from "./searchParams.js";
 import { rootRouteId } from "./root.js";
-import { isRedirect, redirect } from "./redirect.js";
-import { loadMatches, loadRouteChunk, routeNeedsPreload } from "./load-matches.js";
+import { isRedirect } from "./redirect.js";
+import { loadClientRoute, loadRouteChunk, preloadClientRoute, refreshClientRoute, replaceRouteChunk, transferMatchResources } from "./load-client.js";
 import { composeRewrites, executeRewriteInput, executeRewriteOutput, rewriteBasepath } from "./rewrite.js";
 import { createRouterStores } from "./stores.js";
 import { createBrowserHistory, parseHref } from "@tanstack/history";
-import { isServer } from "@tanstack/router-core/isServer";
+import { isServer, loadServerRoute } from "@tanstack/router-core/isServer";
 //#region src/router.ts
+function routeNeedsLoad(route) {
+	return route.options.loader || route.options.beforeLoad || route.lazyFn || route.options.component?.preload || route.options.pendingComponent?.preload;
+}
 /**
 * Convert an unknown error into a minimal, serializable object.
 * Includes name and message (and stack in development).
@@ -39,17 +42,33 @@ const trailingSlashOptions = {
 * 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
+		fromLocation: resolvedLocation,
+		toLocation: location,
+		pathChanged: resolvedLocation?.pathname !== location.pathname,
+		hrefChanged: resolvedLocation?.href !== location.href,
+		hashChanged: resolvedLocation?.hash !== location.hash
 	};
 }
-const locationHistoryActions = /* @__PURE__ */ new WeakMap();
+/**
+* Return only state owned by the application, excluding volatile history
+* bookkeeping. Mask payloads (`__tempLocation`/`__tempKey`) are kept: they
+* distinguish otherwise-identical locations.
+*/
+function _getUserHistoryState({ key: _key, __TSR_key: _tsrKey, __TSR_index: _tsrIndex, __hashScrollIntoViewOptions: _hashScroll, ...state }) {
+	return state;
+}
+/** Run route lifecycle callbacks in leave/enter/stay phases. */
+function runRouteLifecycle(router, previous, matches, isCurrent) {
+	for (const match of previous) {
+		if (isCurrent?.() === false) return;
+		if (!matches.some((candidate) => candidate.routeId === match.routeId)) router.routesById[match.routeId].options.onLeave?.(match);
+	}
+	for (const match of matches) {
+		if (isCurrent?.() === false) return;
+		router.routesById[match.routeId].options[previous.some((candidate) => candidate.routeId === match.routeId) ? "onStay" : "onEnter"]?.(match);
+	}
+}
 /**
 * Core, framework-agnostic router engine that powers TanStack Router.
 *
@@ -66,12 +85,15 @@ var RouterCore = class {
 	constructor(options, getStoreConfig) {
 		this.tempLocationKey = `${Math.round(Math.random() * 1e7)}`;
 		this._scroll = { next: true };
-		this.shouldViewTransition = void 0;
-		this.isViewTransitionTypesSupported = void 0;
 		this.subscribers = /* @__PURE__ */ new Set();
+		this._cache = /* @__PURE__ */ new Map();
+		this._committed = [];
 		this.routeBranchCache = /* @__PURE__ */ new WeakMap();
 		this.lightweightCache = /* @__PURE__ */ new WeakMap();
-		this.startTransition = (fn) => fn();
+		this.startTransition = async (fn) => {
+			fn();
+			return false;
+		};
 		this.update = (newOptions) => {
 			if (process.env.NODE_ENV !== "production") {
 				if (newOptions.notFoundRoute) console.warn("The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info.");
@@ -84,7 +106,7 @@ var RouterCore = class {
 				...prevOptions,
 				...newOptions
 			};
-			this.isServer = this.options.isServer ?? typeof document === "undefined";
+			this.isServer = this.options.isServer ?? 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) {
@@ -115,10 +137,9 @@ var RouterCore = class {
 			if (!this.stores && this.latestLocation) {
 				const config = this.getStoreConfig(this);
 				this.batch = config.batch;
-				this.stores = createRouterStores(getInitialRouterState(this.latestLocation), config);
+				this.stores = createRouterStores(this.latestLocation, config);
 				if (!(isServer ?? this.isServer)) setupScrollRestoration(this);
 			}
-			let needsLocationUpdate = false;
 			const nextBasepath = this.options.basepath ?? "/";
 			const nextRewriteOption = this.options.rewrite;
 			if (basepathWasUnset || prevBasepath !== nextBasepath || prevRewriteOption !== nextRewriteOption) {
@@ -129,10 +150,8 @@ var RouterCore = class {
 				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 (this.stores) this.stores.location.set(this.latestLocation);
 			}
-			if (needsLocationUpdate && this.stores) this.stores.location.set(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);
@@ -155,9 +174,11 @@ var RouterCore = class {
 			};
 		};
 		this.emit = (routerEvent) => {
-			this.subscribers.forEach((listener) => {
-				if (listener.eventType === routerEvent.type) listener.fn(routerEvent);
-			});
+			for (const listener of this.subscribers) if (listener.eventType === routerEvent.type) try {
+				listener.fn(routerEvent);
+			} catch (e) {
+				console.error(e);
+			}
 		};
 		this.parseLocation = (locationToParse, previousLocation) => {
 			const parse = ({ pathname, search, hash, href, state }) => {
@@ -221,33 +242,18 @@ var RouterCore = class {
 			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.pendingIds.get().forEach((matchId) => {
-				this.cancelMatch(matchId);
-			});
-			this.stores.matchesId.get().forEach((matchId) => {
-				if (this.stores.pendingMatchStores.has(matchId)) return;
-				const match = this.stores.matchStores.get(matchId)?.get();
-				if (!match) return;
-				if (match.status === "pending" || match.isFetching === "loader") this.cancelMatch(matchId);
-			});
+			const routeParams = Object.create(null);
+			const match = findRouteMatch(trimPathRight(pathname), this.processedTree, true);
+			if (match) Object.assign(routeParams, match.rawParams);
+			return {
+				matchedRoutes: match?.branch || [this.routesById["__root__"]],
+				routeParams,
+				foundRoute: match?.route
+			};
 		};
 		this.buildLocation = (opts) => {
 			const build = (dest = {}) => {
-				const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
+				const currentLocation = dest._fromLocation || this._pendingLocation || this.latestLocation;
 				const lightweightResult = this.matchRoutesLightweight(currentLocation);
 				if (dest.from && process.env.NODE_ENV !== "production" && dest._isNavigate) {
 					const allFromMatches = this.getMatchedRoutes(dest.from).matchedRoutes;
@@ -265,7 +271,7 @@ var RouterCore = class {
 				const fromParams = Object.assign(Object.create(null), lightweightResult.params);
 				const sourcePath = destTo?.charCodeAt(0) === 47 ? "/" : this.resolvePathWithBase(defaultedFromPath, ".");
 				const nextTo = destTo ? this.resolvePathWithBase(sourcePath, destTo) : sourcePath;
-				const nextParams = dest.params === false || dest.params === null ? Object.create(null) : (dest.params ?? true) === true ? fromParams : Object.assign(fromParams, functionalUpdate(dest.params, fromParams));
+				const nextParams = resolveNextParams(dest.params, fromParams);
 				const destRoute = this.routesByPath[trimPathRight(nextTo)];
 				let destRoutes;
 				if (destRoute) destRoutes = this.getRouteBranch(destRoute);
@@ -304,12 +310,7 @@ var RouterCore = class {
 					});
 					nextSearch = validatedSearch;
 				}
-				nextSearch = applySearchMiddleware({
-					search: nextSearch,
-					dest,
-					destRoutes,
-					_includeValidateSearch: opts._includeValidateSearch
-				});
+				nextSearch = applySearchMiddleware(nextSearch, dest, destRoutes, 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;
@@ -354,7 +355,7 @@ var RouterCore = class {
 						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));
+							const nextParams = resolveNextParams(maskParams, params);
 							maskedDest = {
 								from: opts.from,
 								...maskProps,
@@ -375,29 +376,18 @@ var RouterCore = class {
 		};
 		this.commitLocation = async ({ viewTransition, ignoreBlocker, ...next }) => {
 			let historyAction;
-			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;
+			const isSameLocation = trimPathRight(this.latestLocation.href) === trimPathRight(next.href) && deepEqual(_getUserHistoryState(next.state), _getUserHistoryState(this.latestLocation.state));
+			const previousCommitPromise = this._commitPromise;
+			let resolve;
+			const commitPromise = new Promise((done) => {
+				resolve = done;
 			});
-			if (isSameUrl && isSameState()) this.load();
+			commitPromise.resolve = () => {
+				resolve();
+				previousCommitPromise?.resolve();
+			};
+			this._commitPromise = commitPromise;
+			if (isSameLocation) this.load({ _dedupe: true });
 			else {
 				let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
 				if (maskedLocation) {
@@ -425,12 +415,12 @@ var RouterCore = class {
 				this.shouldViewTransition = viewTransition;
 				historyAction = next.replace ? "REPLACE" : "PUSH";
 				this.history[historyAction === "REPLACE" ? "replace" : "push"](nextHistory.publicHref, nextHistory.state, { ignoreBlocker });
+				if (!this.history.subscribers.size) this.load({ action: { type: historyAction } });
 			}
 			this._scroll.next = next.resetScroll ?? true;
-			if (!this.history.subscribers.size) this.load(historyAction ? { action: { type: historyAction } } : void 0);
-			return this.commitLocationPromise;
+			return this._commitPromise;
 		};
-		this.buildAndCommitLocation = ({ replace, resetScroll, hashScrollIntoView, viewTransition, ignoreBlocker, href, ...rest } = {}) => {
+		this.buildAndCommitLocation = ({ replace, resetScroll, hashScrollIntoView, viewTransition, ignoreBlocker, _redirects, href, ...rest } = {}) => {
 			if (href) {
 				const currentIndex = this.history.location.state.__TSR_index;
 				const parsed = parseHref(href, { __TSR_index: replace ? currentIndex : currentIndex + 1 });
@@ -443,7 +433,8 @@ var RouterCore = class {
 				...rest,
 				_includeValidateSearch: true
 			});
-			this.pendingBuiltLocation = location;
+			if (_redirects) location._redirects = _redirects;
+			this._pendingLocation = location;
 			const commitPromise = this.commitLocation({
 				...location,
 				viewTransition,
@@ -453,7 +444,7 @@ var RouterCore = class {
 				ignoreBlocker
 			});
 			queueMicrotask(() => {
-				if (this.pendingBuiltLocation === location) this.pendingBuiltLocation = void 0;
+				if (this._pendingLocation === location) this._pendingLocation = void 0;
 			});
 			return commitPromise;
 		};
@@ -499,217 +490,63 @@ var RouterCore = class {
 				_isNavigate: true
 			});
 		};
-		this.beforeLoad = () => {
-			this.cancelMatches();
-			this.updateLatestLocation();
-			if (isServer ?? this.isServer) {
-				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.cachedMatches.get().filter((d) => !pendingMatches.some((e) => e.id === d.id));
-			this.batch(() => {
-				this.stores.status.set("pending");
-				this.stores.statusCode.set(200);
-				this.stores.isLoading.set(true);
-				this.stores.location.set(this.latestLocation);
-				this.stores.setPending(pendingMatches);
-				this.stores.setCached(nextCachedMatches);
-			});
-		};
 		this.load = async (opts) => {
-			const historyAction = opts?.action?.type;
-			let redirect;
-			let notFound;
-			let loadPromise;
-			const previousLocation = this.stores.resolvedLocation.get() ?? this.stores.location.get();
-			loadPromise = new Promise((resolve) => {
-				this.startTransition(async () => {
-					try {
-						this.beforeLoad();
-						if (historyAction) locationHistoryActions.set(this.latestLocation, historyAction);
-						else locationHistoryActions.delete(this.latestLocation);
-						const next = this.latestLocation;
-						const locationChangeInfo = getLocationChangeInfo(next, this.stores.resolvedLocation.get());
-						if (!this.stores.redirect.get()) 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.pendingMatches.get(),
-							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.pendingMatches.get();
-											const mountPending = pendingMatches.length;
-											const currentMatches = this.stores.matches.get();
-											exitingMatches = mountPending ? currentMatches.filter((match) => !this.stores.pendingMatchStores.has(match.id)) : null;
-											const pendingRouteIds = /* @__PURE__ */ new Set();
-											for (const s of this.stores.pendingMatchStores.values()) if (s.routeId) pendingRouteIds.add(s.routeId);
-											const activeRouteIds = /* @__PURE__ */ new Set();
-											for (const s of this.stores.matchStores.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.set(false);
-											this.stores.loadedAt.set(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.setMatches(pendingMatches);
-												this.stores.setPending([]);
-												this.stores.setCached([...this.stores.cachedMatches.get(), ...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;
-							if (!(isServer ?? this.isServer)) this.navigate({
-								...redirect.options,
-								replace: true,
-								ignoreBlocker: true
-							});
-						} else if (isNotFound(err)) notFound = err;
-						const nextStatusCode = redirect ? redirect.status : notFound ? 404 : this.stores.matches.get().some((d) => d.status === "error") ? 500 : 200;
-						this.batch(() => {
-							this.stores.statusCode.set(nextStatusCode);
-							this.stores.redirect.set(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.matches.get().some((d) => d.status === "error")) newStatusCode = 500;
-			if (newStatusCode !== void 0) this.stores.statusCode.set(newStatusCode);
+			if (isServer ?? this.isServer) return loadServerRoute(this, opts);
+			this.updateLatestLocation();
+			if (opts?.action) this._scroll.hash = opts.action.type === "PUSH" || opts.action.type === "REPLACE";
+			await loadClientRoute(this, opts);
 		};
 		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") {
+			if (shouldViewTransition && !(isServer ?? typeof document === "undefined") && typeof document.startViewTransition === "function") {
 				let startViewTransitionParams;
-				if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) {
+				if (typeof shouldViewTransition === "object" && window.CSS?.supports?.("selector(:active-view-transition-type(a))")) {
 					const next = this.latestLocation;
 					const prevLocation = this.stores.resolvedLocation.get();
 					const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types(getLocationChangeInfo(next, prevLocation)) : shouldViewTransition.types;
-					if (resolvedViewTransitionTypes === false) {
-						fn();
-						return;
-					}
+					if (resolvedViewTransitionTypes === false) return fn();
 					startViewTransitionParams = {
 						update: fn,
 						types: resolvedViewTransitionTypes
 					};
 				} else startViewTransitionParams = fn;
-				document.startViewTransition(startViewTransitionParams);
-			} else fn();
-		};
-		this.updateMatch = (id, updater) => {
-			this.startTransition(() => {
-				const pendingMatch = this.stores.pendingMatchStores.get(id);
-				if (pendingMatch) {
-					pendingMatch.set(updater);
-					return;
-				}
-				const activeMatch = this.stores.matchStores.get(id);
-				if (activeMatch) {
-					activeMatch.set(updater);
-					return;
-				}
-				const cachedMatch = this.stores.cachedMatchStores.get(id);
-				if (cachedMatch) {
-					const next = updater(cachedMatch.get());
-					if (next.status === "redirected") {
-						if (this.stores.cachedMatchStores.delete(id)) this.stores.cachedIds.set((prev) => prev.filter((matchId) => matchId !== id));
-					} else cachedMatch.set(next);
-				}
-			});
-		};
-		this.getMatch = (matchId) => {
-			return this.stores.cachedMatchStores.get(matchId)?.get() ?? this.stores.pendingMatchStores.get(matchId)?.get() ?? this.stores.matchStores.get(matchId)?.get();
+				return document.startViewTransition(startViewTransitionParams).updateCallbackDone;
+			}
+			return fn();
 		};
 		this.invalidate = (opts) => {
+			const committedMatches = this._committed;
+			const filter = opts?.filter;
+			const invalidIds = filter ? new Set([...committedMatches, ...this._cache.values()].filter((match) => filter(match)).map((match) => match.id)) : void 0;
 			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
-				};
+				if (!invalidIds || invalidIds.has(d.id)) {
+					const route = this.routesById[d.routeId];
+					const next = {
+						...d,
+						invalid: true,
+						...(opts?.forcePending || d.status === "error" || d.status === "notFound") && routeNeedsLoad(route) ? {
+							status: "pending",
+							error: void 0
+						} : void 0
+					};
+					d._flight = void 0;
+					return next;
+				}
 				return d;
 			};
-			this.batch(() => {
-				this.stores.setMatches(this.stores.matches.get().map(invalidate));
-				this.stores.setCached(this.stores.cachedMatches.get().map(invalidate));
-				this.stores.setPending(this.stores.pendingMatches.get().map(invalidate));
-			});
+			const committed = committedMatches.map(invalidate);
+			this._committed = committed;
+			const cache = /* @__PURE__ */ new Map();
+			for (const [id, match] of this._cache) cache.set(id, invalidate(match));
+			this._cache = cache;
 			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);
+				const href = (redirect.options._builtLocation ?? this.buildLocation(redirect.options)).publicHref || "/";
 				redirect.options.href = href;
 				redirect.headers.set("Location", href);
 			} else if (locationHeader) try {
@@ -725,60 +562,26 @@ var RouterCore = class {
 			return redirect;
 		};
 		this.clearCache = (opts) => {
+			const cached = this._cache;
+			const preloads = this._preloads;
 			const filter = opts?.filter;
-			if (filter !== void 0) this.stores.setCached(this.stores.cachedMatches.get().filter((m) => !filter(m)));
-			else this.stores.setCached([]);
-		};
-		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 });
+			const retained = /* @__PURE__ */ new Map();
+			const discarded = [];
+			for (const [id, match] of cached) if (filter && !filter(match)) retained.set(id, match);
+			else discarded.push(match);
+			const retainedPreloads = /* @__PURE__ */ new Map();
+			const discardedPreloads = [];
+			for (const [href, preload] of preloads ?? []) if (!filter || preload[0].some(filter)) {
+				discardedPreloads.push(preload);
+				discarded.push(...preload[0]);
+			} else retainedPreloads.set(href, preload);
+			this._cache = retained;
+			this._preloads = retainedPreloads;
+			transferMatchResources(this, discarded);
+			for (const preload of discardedPreloads) preload[1].abort();
 		};
 		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.get(), ...this.stores.pendingIds.get()]);
-			const loadedMatchIds = new Set([...activeMatchIds, ...this.stores.cachedIds.get()]);
-			const matchesToCache = matches.filter((match) => !loadedMatchIds.has(match.id));
-			if (matchesToCache.length) {
-				const cachedMatches = this.stores.cachedMatches.get();
-				this.stores.setCached([...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.preloadRoute = (opts) => preloadClientRoute(this, opts);
 		this.matchRoute = (location, opts) => {
 			const matchLocation = {
 				...location,
@@ -787,8 +590,9 @@ var RouterCore = class {
 				leaveParams: true
 			};
 			const next = this.buildLocation(matchLocation);
-			if (opts?.pending && this.stores.status.get() !== "pending") return false;
-			const baseLocation = (opts?.pending === void 0 ? !this.stores.isLoading.get() : opts.pending) ? this.latestLocation : this.stores.resolvedLocation.get() || this.stores.location.get();
+			const isPending = this.stores.status.get() === "pending";
+			if (opts?.pending && !isPending) return false;
+			const baseLocation = opts?.pending ?? !isPending ? this.latestLocation : this.stores.resolvedLocation.get() || this.stores.location.get();
 			const match = findSingleMatch(next.pathname, opts?.caseSensitive ?? false, opts?.fuzzy ?? false, baseLocation.pathname, this.processedTree);
 			if (!match) return false;
 			if (location.params) {
@@ -797,9 +601,6 @@ var RouterCore = class {
 			if (opts?.includeSearch ?? true) return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false;
 			return match.rawParams;
 		};
-		this.hasNotFoundMatch = () => {
-			return this.stores.matches.get().some((d) => d.status === "notFound" || d.globalNotFound);
-		};
 		this.getStoreConfig = getStoreConfig;
 		this.update({
 			defaultPreloadDelay: 50,
@@ -813,14 +614,11 @@ var RouterCore = class {
 			parseSearch: options.parseSearch ?? defaultParseSearch,
 			protocolAllowlist: options.protocolAllowlist ?? DEFAULT_PROTOCOL_ALLOWLIST
 		});
-		if (typeof document !== "undefined") self.__TSR_ROUTER__ = this;
+		if (!(isServer ?? typeof document === "undefined")) self.__TSR_ROUTER__ = this;
 	}
 	isShell() {
 		return !!this.options.isShell;
 	}
-	isPrerendering() {
-		return !!this.options.isPrerendering;
-	}
 	get state() {
 		return this.stores.__store.get();
 	}
@@ -842,12 +640,6 @@ var RouterCore = class {
 		}
 		return branch;
 	}
-	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 } = matchedRoutesResult;
@@ -855,10 +647,13 @@ var RouterCore = class {
 		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 _notFoundRouteId = 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.matchStores.values()) if (store.routeId) previousActiveMatchesByRouteId.set(store.routeId, store.get());
+		const committed = this._committed;
+		const previousAt = (route, index) => {
+			const match = committed[index];
+			return match?.routeId === route.id ? match : route === this.options.notFoundRoute ? committed.find((candidate) => candidate.routeId === route.id) : void 0;
+		};
 		for (let index = 0; index < matchedRoutes.length; index++) {
 			const route = matchedRoutes[index];
 			const parentMatch = matches[index - 1];
@@ -878,7 +673,6 @@ var RouterCore = class {
 						...parentStrictSearch,
 						...strictSearch
 					};
-					searchError = void 0;
 				} catch (err) {
 					let searchParamError = err;
 					if (!(err instanceof SearchParamError)) searchParamError = new SearchParamError(err.message, { cause: err });
@@ -888,8 +682,15 @@ var RouterCore = class {
 					searchError = searchParamError;
 				}
 			}
-			const loaderDeps = route.options.loaderDeps?.({ search: preMatchSearch }) ?? "";
-			const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
+			let loaderDeps = "";
+			let loaderDepsHash = "";
+			try {
+				loaderDeps = route.options.loaderDeps?.({ search: preMatchSearch }) ?? "";
+				loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) || "" : "";
+			} catch (cause) {
+				if (opts?.throwOnError) throw cause;
+				searchError ??= cause;
+			}
 			const { interpolatedPath, usedParams } = interpolatePath({
 				path: route.fullPath,
 				params: routeParams,
@@ -897,10 +698,10 @@ var RouterCore = class {
 				server: this.isServer
 			});
 			const matchId = route.id + interpolatedPath + loaderDepsHash;
-			const existingMatch = this.getMatch(matchId);
-			const previousMatch = previousActiveMatchesByRouteId.get(route.id);
+			const previousMatch = previousAt(route, index);
+			const existingMatch = process.env.NODE_ENV !== "production" && opts?._rematerialize ? void 0 : this._cache.get(matchId) ?? (previousMatch?.id === matchId ? previousMatch : void 0);
 			const strictParams = existingMatch?._strictParams ?? usedParams;
-			let paramsError = void 0;
+			let paramsError;
 			if (!existingMatch) try {
 				extractStrictParams(route, strictParams);
 			} catch (err) {
@@ -917,10 +718,11 @@ var RouterCore = class {
 				params: previousMatch?.params ?? routeParams,
 				_strictParams: strictParams,
 				search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : nullReplaceEqualDeep(existingMatch.search, preMatchSearch),
-				_strictSearch: strictMatchSearch
+				_strictSearch: strictMatchSearch,
+				searchError
 			};
 			else {
-				const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
+				const status = routeNeedsLoad(route) ? "pending" : "success";
 				match = {
 					id: matchId,
 					ssr: isServer ?? this.isServer ? void 0 : route.options.ssr,
@@ -932,83 +734,42 @@ var RouterCore = class {
 					updatedAt: Date.now(),
 					search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
 					_strictSearch: strictMatchSearch,
-					searchError: void 0,
+					searchError,
 					status,
 					isFetching: false,
 					error: void 0,
 					paramsError,
-					__routeContext: void 0,
-					_nonReactive: { loadPromise: createControlledPromise() },
-					__beforeLoadContext: void 0,
 					context: {},
-					abortController: new AbortController(),
-					fetchCount: 0,
+					abortController: opts?._controller ?? new AbortController(),
 					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
-			};
+			const _notFound = _notFoundRouteId === route.id;
+			if (match._notFound && !_notFound) match.error = void 0;
+			match._notFound = _notFound;
 			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
-				};
-			}
+			match.params = match.cause === "stay" ? nullReplaceEqualDeep(match.params, routeParams) : routeParams;
+			if (opts?._controller) match.context = {};
 		}
 		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.
+	* operations like AbortController, loaderDeps, and full match objects.
 	*/
 	matchRoutesLightweight(location) {
-		const lastStateMatchId = last(this.stores.matchesId.get());
+		const lastRouteId = last(this.stores.ids.get());
+		const lastStateMatch = lastRouteId ? this.stores.byRoute.get(lastRouteId).get() : void 0;
+		const lastStateMatchId = lastStateMatch?.id;
 		const cached = this.lightweightCache.get(location);
 		if (cached && cached[0] === lastStateMatchId) return cached[1];
 		const { matchedRoutes, routeParams } = this.getMatchedRoutes(location.pathname);
@@ -1017,7 +778,6 @@ var RouterCore = class {
 		for (const route of matchedRoutes) try {
 			Object.assign(accumulatedSearch, validateSearch(route.options.validateSearch, accumulatedSearch));
 		} catch {}
-		const lastStateMatch = lastStateMatchId && this.stores.matchStores.get(lastStateMatchId)?.get();
 		const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && lastStateMatch.pathname === location.pathname;
 		let params;
 		if (canReuseParams) params = lastStateMatch.params;
@@ -1038,6 +798,19 @@ var RouterCore = class {
 		return result;
 	}
 };
+/**
+* In non-production environments,
+* augment the RouterCore class with a `_refreshRoute` method
+* dedicated to HMR.
+*/
+if (process.env.NODE_ENV !== "production") {
+	RouterCore.prototype._replaceRouteChunk = replaceRouteChunk;
+	RouterCore.prototype._refreshRoute = async function() {
+		this._serverResult = void 0;
+		this.updateLatestLocation();
+		await refreshClientRoute(this);
+	};
+}
 /** Error thrown when search parameter validation fails. */
 var SearchParamError = class extends Error {};
 /** Error thrown when path parameter parsing/validation fails. */
@@ -1058,14 +831,11 @@ function lazyFn(fn, key) {
 /** 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
+		matches: []
 	};
 }
 function validateSearch(validateSearch, input) {
@@ -1080,35 +850,7 @@ function validateSearch(validateSearch, 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;
-	const match = findRouteMatch(trimmedPath, processedTree, true);
-	if (match) {
-		foundRoute = match.route;
-		Object.assign(routeParams, match.rawParams);
-	}
-	return {
-		matchedRoutes: match?.branch || [routesById["__root__"]],
-		routeParams,
-		foundRoute
-	};
-}
-/**
-* 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) {
-	let dest;
-	let includeValidateSearch;
+function applySearchMiddleware(search, dest, destRoutes, includeValidateSearch) {
 	const middlewares = [];
 	for (const route of destRoutes) {
 		const routeOptions = route.options;
@@ -1164,28 +906,28 @@ function buildMiddlewareChain(destRoutes) {
 			meta
 		});
 	};
-	return function middleware(search, nextDest, _includeValidateSearch) {
-		dest = nextDest;
-		includeValidateSearch = _includeValidateSearch;
-		return applyNext(0, search);
-	};
+	return applyNext(0, search);
 }
 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;
+	if (notFoundMode !== "root") {
+		let fallback;
+		for (let i = routes.length - 1; i >= 0; i--) {
+			const route = routes[i];
+			if (route.options.notFoundComponent) return route.id;
+			fallback ||= route.children && route.id;
+		}
+		if (fallback) return fallback;
 	}
 	return rootRouteId;
 }
+function resolveNextParams(spec, base) {
+	return spec === false || spec === null ? Object.create(null) : (spec ?? true) === true ? base : Object.assign(base, functionalUpdate(spec, base));
+}
 function extractStrictParams(route, accumulatedParams) {
 	const parseParams = route.options.params?.parse ?? route.options.parseParams;
-	if (parseParams) {
-		const result = parseParams(accumulatedParams);
-		if (result === false) throw new Error("Route params.parse returned false for a matched route");
-		Object.assign(accumulatedParams, result);
-	}
+	if (parseParams) Object.assign(accumulatedParams, parseParams(accumulatedParams));
 }
 //#endregion
-export { PathParamError, RouterCore, SearchParamError, defaultSerializeError, getInitialRouterState, getLocationChangeInfo, getMatchedRoutes, lazyFn, locationHistoryActions, trailingSlashOptions };
+export { PathParamError, RouterCore, SearchParamError, _getUserHistoryState, defaultSerializeError, getInitialRouterState, getLocationChangeInfo, lazyFn, runRouteLifecycle, trailingSlashOptions };
 
 //# sourceMappingURL=router.js.map