@tanstack/router-core 1.171.24 → 1.171.25

package/dist/cjs/load-client.cjs

@@ -61,7 +61,7 @@ const SUCCESS = 0;
 const ERROR = 1;
 const NOT_FOUND = 2;
 const REDIRECTED = 3;
-const CANCELED = 4;
+const CANCELED_OUTCOME = [4];
 function isControl(result) {
 	return typeof result[0] === "number";
 }
@@ -95,24 +95,15 @@ function normalizeError(route, cause) {
 	}
 	return outcome;
 }
-function normalizeLaneError(route, cause, options) {
-	if (options[0].signal.aborted || !options[2]()) {
-		options[0].abort();
-		return [CANCELED];
-	}
-	return normalizeError(route, cause);
-}
-function navigateFrom(router, location) {
-	return (opts) => router.navigate({
-		...opts,
-		_fromLocation: location
-	});
+function normalizeLaneError(router, lane, route, cause, options) {
+	if (options[0].signal.aborted) return CANCELED_OUTCOME;
+	return materializeRedirect(router, lane, route, normalizeError(route, cause), options);
 }
 async function contextualize(router, lane, options, end, planSuccessfulLane, retainedEnd) {
 	const [location, matches] = lane;
 	const signal = options[0].signal;
-	const preload = !!options[4];
-	for (let index = options[7] ?? 0; index < end; index++) {
+	const preload = !!options[3];
+	for (let index = options[6] ?? 0; index < end; index++) {
 		const match = matches[index];
 		const route = getRoute(router, match);
 		match.abortController = options[0];
@@ -120,7 +111,10 @@ async function contextualize(router, lane, options, end, planSuccessfulLane, ret
 		const common = {
 			params: match.params,
 			location,
-			navigate: navigateFrom(router, location),
+			navigate: (opts) => router.navigate({
+				...opts,
+				_fromLocation: location
+			}),
 			buildLocation: router.buildLocation,
 			cause: preload ? "preload" : match.cause,
 			abortController: options[0],
@@ -143,16 +137,13 @@ async function contextualize(router, lane, options, end, planSuccessfulLane, ret
 			match.context = context;
 		} catch (cause) {
 			releaseFlight(router, match);
-			return [index, normalizeLaneError(route, cause, options)];
-		}
-		if (signal.aborted || !options[2]()) {
-			options[0].abort();
-			return [index, [CANCELED]];
+			return [index, normalizeLaneError(router, lane, route, cause, options)];
 		}
+		if (signal.aborted) return [index, CANCELED_OUTCOME];
 		const validationError = match.paramsError ?? match.searchError;
 		if (validationError !== void 0) {
 			releaseFlight(router, match);
-			return [index, normalizeLaneError(route, validationError, options)];
+			return [index, normalizeLaneError(router, lane, route, validationError, options)];
 		}
 		const beforeLoad = route.options.beforeLoad;
 		if (!beforeLoad) continue;
@@ -163,16 +154,15 @@ async function contextualize(router, lane, options, end, planSuccessfulLane, ret
 			...router.options.additionalContext
 		};
 		const previousStatus = match.status;
-		if (previousStatus === "success" && index >= retainedEnd) match.status = "pending";
-		options[8]?.();
+		if (index >= retainedEnd) {
+			match.status = "pending";
+			options[7]?.();
+		}
 		try {
 			setFetching(router, match, "beforeLoad", options[0]);
 			const result = await waitFor(beforeLoad(beforeLoadContext), signal);
-			if (!options[2]()) {
-				options[0].abort();
-				return [index, [CANCELED]];
-			}
-			const outcome = normalize(result, false, route.id);
+			if (signal.aborted) return [index, CANCELED_OUTCOME];
+			const outcome = materializeRedirect(router, lane, route, normalize(result, false, route.id), options);
 			if (outcome[0] !== SUCCESS) {
 				releaseFlight(router, match);
 				return [index, outcome];
@@ -183,9 +173,9 @@ async function contextualize(router, lane, options, end, planSuccessfulLane, ret
 			};
 		} catch (cause) {
 			releaseFlight(router, match);
-			return [index, normalizeLaneError(route, cause, options)];
+			return [index, normalizeLaneError(router, lane, route, cause, options)];
 		} finally {
-			if (previousStatus === "success" && match.status === "pending") match.status = "success";
+			if (match.status === "pending") match.status = previousStatus;
 			setFetching(router, match, false, options[0]);
 		}
 	}
@@ -195,7 +185,7 @@ function releaseOwnedFlight(router, match, flight) {
 	if (!flight || --flight[2]) return;
 	if (router._flights?.get(match.id) === flight) {
 		const current = router._tx;
-		if (current && !current[0].signal.aborted && !(process.env.NODE_ENV !== "production" && current[6]) && !current[3].includes(match) && current[3].some((candidate) => candidate.id === match.id) && current[3].some((candidate) => candidate.isFetching === "beforeLoad")) return;
+		if (current && !current[0].signal.aborted && !current[3].includes(match) && current[3].some((candidate) => candidate.id === match.id) && current[3].some((candidate) => candidate.isFetching === "beforeLoad")) return;
 		router._flights.delete(match.id);
 	}
 	return flight[1];
@@ -214,7 +204,7 @@ function transferMatchResources(router, previous, next, deferSameIdFlight) {
 	for (const match of previous) if (!next?.includes(match)) {
 		const flight = match._flight;
 		match._flight = void 0;
-		if (deferSameIdFlight && flight?.[2] === 1 && router._flights?.get(match.id) === flight && !(process.env.NODE_ENV !== "production" && router._tx?.[6]) && next?.some((candidate) => candidate.id === match.id)) flight[2] = 0;
+		if (deferSameIdFlight && flight?.[2] === 1 && router._flights?.get(match.id) === flight && next?.some((candidate) => candidate.id === match.id)) flight[2] = 0;
 		else {
 			const controller = releaseOwnedFlight(router, match, flight);
 			if (controller) abort.push(controller);
@@ -243,7 +233,10 @@ function getLoaderContext(router, lane, match, route, controller, parentMatchPro
 	return {
 		params: match.params,
 		location,
-		navigate: navigateFrom(router, location),
+		navigate: (opts) => router.navigate({
+			...opts,
+			_fromLocation: location
+		}),
 		cause: preload ? "preload" : match.cause,
 		abortController: controller,
 		preload,
@@ -254,9 +247,10 @@ function getLoaderContext(router, lane, match, route, controller, parentMatchPro
 		...router.options.additionalContext
 	};
 }
-async function loadResource(router, lane, match, route, loader, parentMatchPromise, preload, owner) {
+async function loadResource(router, lane, match, route, loader, parentMatchPromise, options) {
+	const owner = options[0];
 	const signal = owner.signal;
-	if (signal.aborted) return [CANCELED];
+	if (signal.aborted) return CANCELED_OUTCOME;
 	if (!loader) return [SUCCESS, void 0];
 	let flight = match._flight;
 	setFetching(router, match, "loader", owner);
@@ -264,7 +258,7 @@ async function loadResource(router, lane, match, route, loader, parentMatchPromi
 		if (!flight) {
 			const controller = new AbortController();
 			flight = [
-				Promise.resolve().then(() => loader(getLoaderContext(router, lane, match, route, controller, parentMatchPromise, preload))).then((value) => normalize(value, false, route.id), (cause) => normalize(cause, true, route.id)).then((result) => {
+				Promise.resolve().then(() => loader(getLoaderContext(router, lane, match, route, controller, parentMatchPromise, !!options[3]))).then((value) => normalize(value, false, route.id), (cause) => normalize(cause, true, route.id)).then((result) => {
 					if (result[0] !== SUCCESS && router._flights?.get(match.id) === flight) {
 						router._flights.delete(match.id);
 						if (!flight[2]) controller.abort();
@@ -278,11 +272,11 @@ async function loadResource(router, lane, match, route, loader, parentMatchPromi
 		}
 		match._flight = flight;
 		match.abortController = flight[1];
-		return await waitFor(flight[0], signal);
+		return materializeRedirect(router, lane, route, await waitFor(flight[0], signal), options);
 	} catch (cause) {
-		if (cause !== signal) throw cause;
+		if (cause !== signal || !signal.aborted) throw cause;
 		releaseFlight(router, match);
-		return [CANCELED];
+		return CANCELED_OUTCOME;
 	} finally {
 		setFetching(router, match, false, owner);
 	}
@@ -325,7 +319,7 @@ function getParentSnapshot(match, outcome) {
 function createLoaderTask(router, lane, index, tasks, semanticParent, options, retainedEnd) {
 	const match = lane[1][index];
 	const route = getRoute(router, match);
-	const preload = !!options[4];
+	const preload = !!options[3];
 	const plannedCacheMatch = router._cache.get(match.id);
 	let configured;
 	let reload = false;
@@ -334,20 +328,17 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options, r
 		if (match.status === "success") {
 			configured = route.options.shouldReload;
 			if (typeof configured === "function") configured = configured(getLoaderContext(router, lane, match, route, options[0], semanticParent, preload));
-			if (!options[2]()) {
-				options[0].abort();
-				reloadFailure = [CANCELED];
-			}
+			if (options[0].signal.aborted) reloadFailure = CANCELED_OUTCOME;
 		}
 		if (!reloadFailure) if (match.status !== "success") reload = true;
 		else {
-			const staleAge = options[4] || match.preload ? route.options.preloadStaleTime ?? router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? router.options.defaultStaleTime ?? 0;
-			reload = !!(match.invalid || configured || configured === void 0 && Date.now() - match.updatedAt >= staleAge && (options[6] || match.cause === "enter" || options[3].some((candidate) => candidate.routeId === match.routeId && candidate.id !== match.id)));
+			const staleAge = options[3] || match.preload ? route.options.preloadStaleTime ?? router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? router.options.defaultStaleTime ?? 0;
+			reload = !!(match.invalid || configured || configured === void 0 && Date.now() - match.updatedAt >= staleAge && (options[5] || match.cause === "enter" || options[2].some((candidate) => candidate.routeId === match.routeId && candidate.id !== match.id)));
 		}
 	} catch (cause) {
 		match.invalid = true;
 		releaseFlight(router, match);
-		reloadFailure = normalizeLaneError(route, cause, options);
+		reloadFailure = normalizeLaneError(router, lane, route, cause, options);
 	}
 	const routeLoader = route.options.loader;
 	const loader = typeof routeLoader === "function" ? routeLoader : routeLoader?.handler;
@@ -355,10 +346,11 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options, r
 	if (donor === match._flight || reloadFailure) donor = void 0;
 	else if (donor && !reload && !preload && configured === void 0) reload = true;
 	else if (!reload) donor = void 0;
-	const background = !!(routeLoader && reload && match.status === "success" && !preload && !options[5] && ((typeof routeLoader === "function" ? void 0 : routeLoader?.staleReloadMode) ?? router.options.defaultStaleReloadMode) !== "blocking");
+	const background = !!(routeLoader && reload && match.status === "success" && !preload && !options[4] && ((typeof routeLoader === "function" ? void 0 : routeLoader?.staleReloadMode) ?? router.options.defaultStaleReloadMode) !== "blocking");
 	const loaded = reload && (!preload || route.options.preload !== false);
 	const blocking = loaded && !background && (match.status !== "success" || !!routeLoader);
-	const onLazyReady = route.lazyFn && route._lazy !== true ? options[8] : void 0;
+	const onReady = index >= retainedEnd ? options[7] : void 0;
+	const onLazyReady = route.lazyFn && route._lazy !== true ? onReady : void 0;
 	if (loaded && !routeLoader) {
 		match.invalid = false;
 		match.updatedAt = Date.now();
@@ -368,24 +360,24 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options, r
 		const acceptedFlight = match._flight;
 		match._flight = donor;
 		releaseOwnedFlight(router, match, acceptedFlight)?.abort();
-		if (match.status === "success" && index >= retainedEnd) match.status = "pending";
-		options[8]?.();
+		if (index >= retainedEnd) match.status = "pending";
+		onReady?.();
 	}
 	if (!loaded) match.isFetching = false;
-	const outcome = (reloadFailure ? Promise.resolve(reloadFailure) : !blocking ? Promise.resolve([SUCCESS, match.loaderData]) : loadResource(router, lane, match, route, loader, semanticParent, preload, options[0])).then((result) => {
+	const outcome = (reloadFailure ? Promise.resolve(reloadFailure) : !blocking ? Promise.resolve([SUCCESS, match.loaderData]) : loadResource(router, lane, match, route, loader, semanticParent, options)).then((result) => {
 		if (blocking) {
 			settleInto(match, result, preload);
 			if (result[0] === SUCCESS) {
-				if (routeLoader && !options[0].signal.aborted && !(process.env.NODE_ENV !== "production" && !preload && router._tx?.[6])) cacheLoaderMatch(router, match, plannedCacheMatch);
-				match.status = "pending";
+				if (routeLoader && !options[0].signal.aborted) cacheLoaderMatch(router, match, plannedCacheMatch);
+				if (index >= retainedEnd) match.status = "pending";
 			}
 		}
 		return result;
 	});
-	const chunkFailure = waitFor(Promise.resolve().then(() => loadRouteChunk(route, void 0, onLazyReady)), options[0].signal).then(() => void 0, (cause) => [index, normalizeLaneError(route, cause, options)]).then((failure) => outcome.then((result) => {
-		if (blocking && !failure && result[0] === SUCCESS && match.status === "pending" && options[2]()) {
+	const chunkFailure = waitFor(Promise.resolve().then(() => loadRouteChunk(route, void 0, onLazyReady)), options[0].signal).then(() => void 0, (cause) => lane[1].some((candidate, candidateIndex) => candidateIndex <= index && (candidate.status === "error" || candidate.status === "notFound" || candidate._notFound)) ? void 0 : [index, normalizeLaneError(router, lane, route, cause, options)]).then((failure) => outcome.then((result) => {
+		if (blocking && !failure && result[0] === SUCCESS && match.status === "pending" && !options[0].signal.aborted) {
 			match.status = "success";
-			options[8]?.();
+			onReady?.();
 		}
 		return failure;
 	}));
@@ -403,7 +395,7 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options, r
 	};
 	match.invalid = false;
 	match.isFetching = "loader";
-	const backgroundOutcome = loadResource(router, lane, candidate, route, loader, semanticParent, false, options[0]).then((result) => {
+	const backgroundOutcome = loadResource(router, lane, candidate, route, loader, semanticParent, options).then((result) => {
 		match.isFetching = false;
 		settleInto(candidate, result, false);
 		return result;
@@ -422,11 +414,11 @@ async function getNotFoundBoundary(router, matches, indexed, signal, fallback =
 	if (index < 0) index = 0;
 	for (let i = index; i >= 0; i--) {
 		const route = getRoute(router, matches[i]);
-		const loading = loadRouteChunk(route, false);
-		if (loading) try {
-			await waitFor(loading, signal);
+		try {
+			const loading = loadRouteChunk(route, false);
+			if (loading) await waitFor(loading, signal);
 		} catch (cause) {
-			if (cause === signal) throw cause;
+			if (cause === signal && signal.aborted) throw cause;
 		}
 		if (route.options.notFoundComponent) return i;
 	}
@@ -460,7 +452,32 @@ async function settleTasks(tasks, serialFailure, redirectTasks, gate) {
 	}
 	return serialFailure ?? loaderFailure;
 }
-async function reduceLane(router, lane, tasks, controller, redirects, settlement, onReady) {
+function materializeRedirect(router, lane, route, outcome, options, failed) {
+	while (outcome[0] === REDIRECTED) {
+		const redirect = outcome[1];
+		if (redirect.options.reloadDocument ? options[3] : options[1] >= 20) return outcome;
+		try {
+			if (redirect.options.href && redirect.options.reloadDocument) {
+				router.resolveRedirect(redirect);
+				return outcome;
+			}
+			return [
+				REDIRECTED,
+				redirect,
+				router.buildLocation({
+					...redirect.options,
+					_fromLocation: lane[0],
+					_includeValidateSearch: true
+				})
+			];
+		} catch (cause) {
+			outcome = failed ? [ERROR, cause] : normalizeError(route, cause);
+			failed = true;
+		}
+	}
+	return outcome;
+}
+async function reduceLane(router, lane, tasks, controller, settlement, onReady) {
 	const matches = lane[1];
 	let failure = await settlement;
 	let redirectLimitExceeded = false;
@@ -489,7 +506,7 @@ async function reduceLane(router, lane, tasks, controller, redirects, settlement
 	}
 	if ((failure?.[1][0] ?? 0) >= REDIRECTED) {
 		const outcome = failure[1];
-		if (outcome[0] !== REDIRECTED || outcome[1].options.reloadDocument || redirects < 20) {
+		if (outcome[0] !== REDIRECTED || outcome[1].options.reloadDocument || outcome[2]) {
 			discardBackground(router, lane);
 			return outcome;
 		}
@@ -518,19 +535,18 @@ async function reduceLane(router, lane, tasks, controller, redirects, settlement
 			}
 		};
 		install();
+		if (!outcome) onReady?.();
 		const route = getRoute(router, match);
 		try {
 			await waitFor(outcome ? Promise.resolve().then(() => loadRouteChunk(route, kind === ERROR ? "errorComponent" : "notFoundComponent")) : Promise.all([loadRouteChunk(route), loadRouteChunk(route, "notFoundComponent")]), controller.signal);
 		} catch (cause) {
-			if (cause === controller.signal) {
+			if (cause === controller.signal && controller.signal.aborted) {
 				discardBackground(router, lane);
-				return [CANCELED];
+				return CANCELED_OUTCOME;
 			}
 		}
-		if (!outcome) {
-			match.status = "success";
-			onReady?.();
-		} else if (redirectLimitExceeded) {
+		if (!outcome) match.status = "success";
+		else if (redirectLimitExceeded) {
 			controller.abort();
 			await Promise.all([
 				...tasks.map((task) => task[1]),
@@ -564,7 +580,7 @@ async function projectLane(router, lane, signal, start = 0, end = lane[1].length
 			match.styles = head?.styles;
 			match.scripts = scripts;
 		} catch (cause) {
-			if (cause === signal) break;
+			if (cause === signal && signal.aborted) break;
 			console.error(cause);
 		}
 		if (match.status !== "success" || match._notFound) break;
@@ -573,63 +589,66 @@ async function projectLane(router, lane, signal, start = 0, end = lane[1].length
 }
 async function executeClientLane(router, location, matches, options) {
 	const matched = [location, matches];
-	const presented = router.stores.matches.get();
-	let plannedBoundary = matches.findIndex((match) => match._notFound);
-	if (router.options.notFoundMode !== "root" && plannedBoundary >= 0) {
-		const boundary = await getNotFoundBoundary(router, matched[1], void 0, options[0].signal, plannedBoundary);
-		if (boundary !== plannedBoundary) {
-			matches[plannedBoundary]._notFound = void 0;
-			matches[boundary]._notFound = true;
+	const signal = options[0].signal;
+	let reduced;
+	try {
+		const presented = router.stores.matches.get();
+		let plannedBoundary = matches.findIndex((match) => match._notFound);
+		if (router.options.notFoundMode !== "root" && plannedBoundary >= 0) {
+			const boundary = await getNotFoundBoundary(router, matched[1], void 0, signal, plannedBoundary);
+			if (boundary !== plannedBoundary) {
+				matches[plannedBoundary]._notFound = void 0;
+				matches[boundary]._notFound = true;
+			}
+			plannedBoundary = boundary;
 		}
-		plannedBoundary = boundary;
-	}
-	let end = plannedBoundary < 0 ? matches.length : plannedBoundary + 1;
-	let retainedEnd = 0;
-	while (retainedEnd < end && retainedEnd !== plannedBoundary) {
-		const match = matches[retainedEnd];
-		const committed = options[3][retainedEnd];
-		const visible = presented[retainedEnd];
-		if (committed?.id !== match.id || committed.status !== "success" || committed._notFound || match.preload || visible?.id !== match.id || visible.status !== "success" || visible._notFound) break;
-		retainedEnd++;
-	}
-	const tasks = [];
-	const start = options[7] ?? 0;
-	let semanticParent = start ? Promise.resolve(matched[1][start - 1]) : void 0;
-	const planSuccessfulLane = () => {
-		for (let index = start; index < end; index++) {
-			if (options[0].signal.aborted) break;
-			semanticParent = createLoaderTask(router, matched, index, tasks, semanticParent, options, retainedEnd);
+		let end = plannedBoundary < 0 ? matches.length : plannedBoundary + 1;
+		let retainedEnd = 0;
+		while (retainedEnd < end && retainedEnd !== plannedBoundary) {
+			const match = matches[retainedEnd];
+			const committed = options[2][retainedEnd];
+			const visible = presented[retainedEnd];
+			if (committed?.id !== match.id || committed.status !== "success" || committed._notFound || match.preload || visible?.id !== match.id || visible.status !== "success" || visible._notFound) break;
+			retainedEnd++;
 		}
-	};
-	const failure = await contextualize(router, matched, options, end, planSuccessfulLane, retainedEnd);
-	if (failure) {
-		options[5] = true;
-		end = failure[0];
-		if (failure[1][0] === NOT_FOUND) {
-			failure[2] = await getNotFoundBoundary(router, matched[1], failure, options[0].signal);
-			end = Math.min(end, failure[2] + 1);
-		} else if (failure[1][0] >= REDIRECTED) end = 0;
-		planSuccessfulLane();
-	}
-	if (options[2]() && !options[4]) {
-		const abort = [];
-		for (const [id, flight] of router._flights ?? []) if (!flight[2]) {
-			router._flights.delete(id);
-			abort.push(flight[1]);
+		const tasks = [];
+		const start = options[6] ?? 0;
+		let semanticParent = start ? Promise.resolve(matched[1][start - 1]) : void 0;
+		const planSuccessfulLane = () => {
+			for (let index = start; index < end; index++) {
+				if (signal.aborted) break;
+				semanticParent = createLoaderTask(router, matched, index, tasks, semanticParent, options, retainedEnd);
+			}
+		};
+		const failure = await contextualize(router, matched, options, end, planSuccessfulLane, retainedEnd);
+		if (failure) {
+			options[4] = true;
+			end = failure[0];
+			if (failure[1][0] === NOT_FOUND) {
+				const boundary = await getNotFoundBoundary(router, matched[1], failure, signal);
+				failure[2] = boundary;
+				end = Math.min(end, boundary + 1);
+			} else if (failure[1][0] >= REDIRECTED) end = 0;
+			planSuccessfulLane();
 		}
-		for (const controller of abort) controller.abort();
-	}
-	let reduced;
-	try {
-		const reduction = reduceLane(router, matched, tasks, options[0], options[1], settleTasks(tasks, failure, matched[2]), options[8]);
+		if (!signal.aborted && !options[3]) {
+			const abort = [];
+			for (const [id, flight] of router._flights ?? []) if (!flight[2]) {
+				router._flights.delete(id);
+				abort.push(flight[1]);
+			}
+			for (const controller of abort) controller.abort();
+		}
+		const reduction = reduceLane(router, matched, tasks, options[0], settleTasks(tasks, failure, matched[2]), options[7]);
 		if (matched[2]?.length) matched[3] = settleTasks(matched[2], void 0, void 0, reduction.then((foreground) => isControl(foreground) ? 0 : _getRenderedMatches(foreground[1]).length, () => 0));
 		reduced = await reduction;
 	} catch (cause) {
 		discardBackground(router, matched);
+		if (cause === signal && signal.aborted) return CANCELED_OUTCOME;
 		throw cause;
 	}
 	if (isControl(reduced)) return reduced;
-	return projectLane(router, reduced, options[0].signal, options[7] === reduced[1].length ? options[7] : 0);
+	return projectLane(router, reduced, signal, options[6] === reduced[1].length ? options[6] : 0);
 }
 /**
 * Waits for `pendingMs`, then presents the complete lane. Rendering applies the
@@ -639,90 +658,94 @@ async function executeClientLane(router, location, matches, options) {
 */
 function offerPending(router, tx) {
 	if (router._tx !== tx) return;
-	let session = router._pending;
-	let tookOver = false;
-	const sessionMatchId = session?.[0][3][session[1]]?.id;
-	if (session?.[0] !== tx) if (session && tx[3][session[1]]?.id === sessionMatchId) {
-		session[0] = tx;
-		tookOver = true;
-	} else {
-		clearTimeout(session?.[3]);
-		router._pending = session = void 0;
-	}
 	const matches = tx[3];
 	const presented = router.stores.matches.get();
-	let boundary = -1;
-	let delay;
-	let min;
-	let component;
-	let presentedPending = false;
+	let session = router._pending;
 	for (let index = 0; index < matches.length; index++) {
 		const match = matches[index];
-		const success = match.status === "success";
-		presentedPending = presented[index]?.id === match.id && presented[index]?.status === "pending";
+		const success = match.status === "success" && !match._notFound;
+		const presentedPending = presented[index]?.id === match.id && presented[index]?.status === "pending";
 		if (success && !presentedPending) continue;
 		const route = getRoute(router, match);
-		delay = success && presentedPending || match.invalid ? 0 : route.options.pendingMs ?? router.options.defaultPendingMs;
-		component = route.options.pendingComponent ?? router.options.defaultPendingComponent;
-		if (!component || typeof delay !== "number" || delay === Infinity) return;
-		boundary = index;
-		min = route.options.pendingMinMs ?? router.options.defaultPendingMinMs ?? 0;
-		break;
-	}
-	if (boundary < 0) return;
-	const matchId = matches[boundary].id;
-	if (!session || session[1] !== boundary || sessionMatchId !== matchId) {
-		clearTimeout(session?.[3]);
-		router._pending = session = [
+		const delay = success && presentedPending || match.invalid ? 0 : route.options.pendingMs ?? router.options.defaultPendingMs;
+		const component = route.options.pendingComponent ?? router.options.defaultPendingComponent;
+		if (!component || typeof delay !== "number" || delay === Infinity) {
+			if (session) {
+				session[0] = tx;
+				session[2] = 0;
+				session[4] = true;
+			}
+			return;
+		}
+		const min = route.options.pendingMinMs ?? router.options.defaultPendingMinMs ?? 0;
+		let tookOver = false;
+		if (session?.[1] === match.id) {
+			tookOver = session[0] !== tx;
+			session[0] = tx;
+		} else {
+			clearTimeout(session?.[3]);
+			router._pending = session = void 0;
+		}
+		if (!session) router._pending = session = [
 			tx,
-			boundary,
+			match.id,
 			presentedPending ? Date.now() + min : tx[4] + delay,
 			void 0,
-			presentedPending ? Promise.resolve(true) : void 0,
+			presentedPending || void 0,
 			component
 		];
-	}
-	if (session[4] && !tookOver && session[5] === component) return;
-	session[5] = component;
-	if (!session[4]) {
-		clearTimeout(session[3]);
-		const remaining = session[2] - Date.now();
-		if (remaining > 0) {
-			session[3] = setTimeout(() => offerPending(router, tx), remaining);
-			return;
+		if (session[4] && !tookOver && session[5] === component) return;
+		session[5] = component;
+		if (!session[4]) {
+			clearTimeout(session[3]);
+			const remaining = session[2] - Date.now();
+			if (remaining > 0) {
+				session[3] = setTimeout(() => offerPending(router, tx), remaining);
+				return;
+			}
+			session[2] = 0;
 		}
-		session[2] = 0;
+		const offered = matches.map((match) => ({
+			...match,
+			_flight: void 0
+		}));
+		offered[index].status = "pending";
+		const ack = session[4] = router.startTransition(() => router.stores.setMatches(offered), offered).then((rendered) => {
+			if (rendered && router._pending === session && session[4] === ack && !session[2]) session[2] = Date.now() + min;
+			return rendered;
+		});
+		return;
 	}
-	const offered = matches.map((match) => ({
-		...match,
-		_flight: void 0
-	}));
-	offered[boundary].status = "pending";
-	const ack = router.startTransition(() => router.stores.setMatches(offered), offered).then((rendered) => {
-		if (rendered && router._pending === session && session[4] === ack && !session[2]) session[2] = Date.now() + min;
-		return rendered;
-	});
-	session[4] = ack;
 }
 /**
-* Cancels pending UI timing when its load ends. The ownership check prevents
-* an older, superseded load from clearing pending UI that a newer load took over.
+* Cancels pending UI timing unless the current successor can take over the
+* same boundary that remains painted.
 */
 function finishPending(router, tx) {
 	const session = router._pending;
-	if (session?.[0] === tx) {
-		clearTimeout(session[3]);
+	if (router._tx === tx || !router._tx?.[3].some((match) => match.id === session?.[1])) {
+		clearTimeout(session?.[3]);
 		router._pending = void 0;
 	}
 }
+async function awaitPendingMinimum(router, tx) {
+	const session = router._pending;
+	if (!session) return;
+	clearTimeout(session[3]);
+	const remaining = session[2] - Date.now();
+	if (!session[4] || remaining <= 0 || !_getRenderedMatches(tx[3]).some((match) => match.id === session[1])) return;
+	let timer;
+	try {
+		await waitFor(new Promise((resolve) => {
+			timer = setTimeout(resolve, remaining);
+		}), tx[0].signal);
+	} catch {}
+	clearTimeout(timer);
+}
 function publishMatches(router, matches) {
 	router._committed = matches;
 	router.stores.setMatches(matches);
 }
-function discardLane(router, lane) {
-	transferMatchResources(router, lane[1]);
-	discardBackground(router, lane);
-}
 function commitMatches(router, tx, matches, resolvedPrefix) {
 	const previous = router._committed;
 	const previousCached = router._cache;
@@ -732,111 +755,29 @@ function commitMatches(router, tx, matches, resolvedPrefix) {
 	}
 	const cut = _getRenderedMatches(matches).length;
 	const cached = /* @__PURE__ */ new Map();
-	const now = Date.now();
-	for (const match of [...previous, ...previousCached.values()]) {
-		if (match.status !== "success" || matches.some((candidate, index) => candidate.id === match.id && (index < cut || candidate.status === "success"))) continue;
-		const route = getRoute(router, match);
-		if (!route.options.loader || now - match.updatedAt >= (match.preload ? route.options.preloadGcTime ?? router.options.defaultPreloadGcTime ?? 3e5 : route.options.gcTime ?? router.options.defaultGcTime ?? 3e5)) continue;
-		cached.set(match.id, previousCached.get(match.id) === match ? match : {
-			...match,
-			_flight: void 0,
-			isFetching: false,
-			context: {}
-		});
+	if (process.env.NODE_ENV === "production" || !tx[6]) {
+		const now = Date.now();
+		for (const match of [...previous, ...previousCached.values()]) {
+			if (match.status !== "success" || matches.some((candidate, index) => candidate.id === match.id && (index < cut || candidate.status === "success"))) continue;
+			const route = getRoute(router, match);
+			if (!route.options.loader || now - match.updatedAt >= (match.preload ? route.options.preloadGcTime ?? router.options.defaultPreloadGcTime ?? 3e5 : route.options.gcTime ?? router.options.defaultGcTime ?? 3e5)) continue;
+			cached.set(match.id, previousCached.get(match.id) === match ? match : {
+				...match,
+				_flight: void 0,
+				isFetching: false,
+				context: {}
+			});
+		}
 	}
 	tx[3] = [];
 	router._cache = cached;
 	publishMatches(router, matches);
 	transferMatchResources(router, [...previousCached.values(), ...previous], [...matches, ...cached.values()]);
-	require_router.runRouteLifecycle(router, previous, matches, () => router._tx === tx);
-}
-function commitRefreshMatches(router, tx, matches, checkpoint) {
-	const previous = router._committed;
-	const previousCached = router._cache;
-	for (const match of matches) match.preload = false;
-	const cached = /* @__PURE__ */ new Map();
-	tx[3] = [];
-	router._cache = cached;
-	checkpoint.previousMatches = previous;
-	checkpoint.previousCache = previousCached;
-	checkpoint.published = true;
-	publishMatches(router, matches);
-	if (!checkpoint.published || router._tx !== tx) return;
-	require_router.runRouteLifecycle(router, previous, matches, () => router._tx === tx);
-}
-function settlePublication(router, checkpoint) {
-	if (!checkpoint.published) return;
-	checkpoint.published = false;
-	transferMatchResources(router, [...checkpoint.previousCache.values(), ...checkpoint.previousMatches], [...router._cache.values(), ...router._committed]);
-}
-function rollbackPublication(router, tx, lane, checkpoint) {
-	if (!checkpoint.published || router._tx !== tx || router._committed !== lane[1]) {
-		settlePublication(router, checkpoint);
-		return false;
-	}
-	const discarded = [...router._cache.values(), ...router._committed];
-	const restored = [...checkpoint.previousCache.values(), ...checkpoint.previousMatches];
-	router._cache = checkpoint.previousCache;
-	router._committed = checkpoint.previousMatches;
-	checkpoint.published = false;
-	for (const match of discarded) if (!restored.includes(match) && match._flight && router._flights?.get(match.id) === match._flight) router._flights.delete(match.id);
-	finishPending(router, tx);
-	router.batch(() => {
-		router.stores.status.set("idle");
-		router.stores.setMatches(checkpoint.previousPresentation);
-	});
-	tx[0].abort();
-	transferMatchResources(router, discarded, restored);
-	discardBackground(router, lane);
-	if (router._tx === tx && router._commitPromise === checkpoint.commitPromise) {
-		router._commitPromise?.resolve();
-		router._commitPromise = void 0;
-	}
-	return true;
-}
-async function transitionRefresh(router, tx, lane, changeInfo) {
-	const refresh = tx[6];
-	const checkpoint = {
-		previousMatches: router._committed,
-		previousPresentation: refresh[0],
-		previousCache: router._cache,
-		commitPromise: router._commitPromise,
-		published: false
-	};
-	const commit = () => {
-		finishPending(router, tx);
-		refresh[2] = rollback;
-		commitRefreshMatches(router, tx, lane[1], checkpoint);
-		if (!checkpoint.published || router._tx !== tx) return;
-		router.emit({
-			type: "onLoad",
-			...changeInfo
-		});
-		if (router._tx === tx) router.emit({
-			type: "onBeforeRouteMount",
-			...changeInfo
-		});
-	};
-	const rollback = () => {
-		if (refresh[2] === rollback) refresh[2] = void 0;
-		const restored = rollbackPublication(router, tx, lane, checkpoint);
-		router._cancelTransition?.();
-		return restored;
-	};
-	try {
-		const rendered = await router.startTransition(commit, lane[1]);
-		if (refresh[2] === rollback) refresh[2] = void 0;
-		if (checkpoint.published) {
-			const handoff = refresh[1];
-			if (handoff && router._handoff === handoff) handoff[1]();
-			if (router._tx === tx) tx[6] = void 0;
-		}
-		settlePublication(router, checkpoint);
-		return rendered;
-	} catch (cause) {
-		if (rollback()) return;
-		throw cause;
+	if (process.env.NODE_ENV !== "production") {
+		const handoff = tx[6]?.[0];
+		if (handoff && router._handoff === handoff) handoff[1]();
 	}
+	require_router.runRouteLifecycle(router, previous, matches, tx);
 }
 async function awaitCurrent(router, owner) {
 	let current = router._tx;
@@ -846,28 +787,40 @@ async function awaitCurrent(router, owner) {
 		current = router._tx;
 	}
 }
-async function followRedirect(router, tx, redirect) {
-	await router.navigate({
-		...redirect.options,
+async function followRedirect(router, tx, outcome) {
+	const redirect = outcome[1];
+	const location = outcome[2];
+	if (!location) {
+		await router.navigate({
+			...redirect.options,
+			replace: true,
+			ignoreBlocker: true
+		});
+		return;
+	}
+	if (redirect.options.reloadDocument) {
+		await router.navigate({
+			href: location.publicHref,
+			reloadDocument: true,
+			replace: true,
+			ignoreBlocker: true
+		});
+		return;
+	}
+	location._redirects = tx[1] + 1;
+	router._pendingLocation = location;
+	const committed = router.commitLocation({
+		...location,
+		viewTransition: redirect.options.viewTransition,
 		replace: true,
-		ignoreBlocker: true,
-		_redirects: tx[1] + 1
+		resetScroll: redirect.options.resetScroll,
+		hashScrollIntoView: redirect.options.hashScrollIntoView,
+		ignoreBlocker: true
 	});
-}
-function restoreCommitted(router, tx) {
-	finishPending(router, tx);
-	tx[0].abort();
-	transferMatchResources(router, tx[3]);
-	tx[3] = [];
-	if (router._tx !== tx) return;
-	router.batch(() => {
-		router.stores.status.set("idle");
-		router.stores.setMatches(router._committed);
+	queueMicrotask(() => {
+		if (router._pendingLocation === location) router._pendingLocation = void 0;
 	});
-	if (router._tx === tx) {
-		router._commitPromise?.resolve();
-		router._commitPromise = void 0;
-	}
+	await committed;
 }
 async function runBackground(router, tx, base, tasks, settlement) {
 	const next = base.map((match) => ({ ...match }));
@@ -879,14 +832,14 @@ async function runBackground(router, tx, base, tasks, settlement) {
 	const lane = [tx[2], next];
 	let reduced;
 	try {
-		reduced = await reduceLane(router, lane, tasks, tx[0], tx[1], settlement);
+		reduced = await reduceLane(router, lane, tasks, tx[0], settlement);
 	} catch (cause) {
 		transferMatchResources(router, next);
 		throw cause;
 	}
 	if (isControl(reduced)) {
 		transferMatchResources(router, next);
-		if (reduced[0] === REDIRECTED && router._tx === tx && router._committed === base) await followRedirect(router, tx, reduced[1]);
+		if (reduced[0] === REDIRECTED && router._tx === tx && router._committed === base) await followRedirect(router, tx, reduced);
 		return;
 	}
 	const projected = await projectLane(router, reduced, tx[0].signal);
@@ -908,7 +861,6 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 	const options = [
 		tx[0],
 		tx[1],
-		() => router._tx === tx && !!tx[3].length,
 		router._committed,
 		void 0,
 		sync,
@@ -918,50 +870,30 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 	];
 	const result = await executeClientLane(router, tx[2], tx[3], options);
 	if (isControl(result)) {
-		if (result[0] === REDIRECTED && router._tx === tx) {
+		const follow = result[0] === REDIRECTED && router._tx === tx;
+		if (!follow || result[1].options.reloadDocument) finishPending(router, tx);
+		transferMatchResources(router, tx[3]);
+		tx[3] = [];
+		if (!follow) return;
+		if (router._tx !== tx) {
 			finishPending(router, tx);
-			transferMatchResources(router, tx[3]);
-			tx[3] = [];
-			if (router._tx === tx) {
-				if (process.env.NODE_ENV !== "production" && tx[6]) router._refreshNextLoad = true;
-				await followRedirect(router, tx, result[1]);
-			}
-		} else restoreCommitted(router, tx);
+			return;
+		}
+		if (process.env.NODE_ENV !== "production" && tx[6]) router._refreshNextLoad = true;
+		await followRedirect(router, tx, result);
 		return;
 	}
-	const pending = router._pending;
-	if (pending?.[0] === tx) {
-		/**
-		* Loading finished, so cancel any pending reveal. If the fallback rendered,
-		* wait out the rest of `pendingMinMs` before replacing it. If it never
-		* rendered, there is no minimum wait; if another load took it over, that
-		* load owns the deadline.
-		*/
-		clearTimeout(pending[3]);
-		if (pending[4]) {
-			const signal = tx[0].signal;
-			let rendered = false;
-			try {
-				rendered = await waitFor(pending[4], signal);
-			} catch (cause) {
-				if (cause !== signal) throw cause;
-			}
-			if (rendered && router._pending === pending && pending[0] === tx) {
-				const remaining = pending[2] - Date.now();
-				if (remaining > 0) {
-					try {
-						await waitFor(new Promise((resolve) => {
-							pending[3] = setTimeout(resolve, remaining);
-						}), signal);
-					} catch {}
-					clearTimeout(pending[3]);
-				}
-			}
-		}
+	if (router._tx !== tx) {
+		finishPending(router, tx);
+		transferMatchResources(router, result[1]);
+		discardBackground(router, result);
+		return;
 	}
+	await awaitPendingMinimum(router, tx);
 	if (router._tx !== tx) {
 		finishPending(router, tx);
-		discardLane(router, result);
+		transferMatchResources(router, result[1]);
+		discardBackground(router, result);
 		return;
 	}
 	const toLocation = tx[2];
@@ -969,7 +901,16 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 	const background = result[2];
 	await router.startViewTransition(async () => {
 		if (router._tx !== tx) {
-			discardLane(router, result);
+			finishPending(router, tx);
+			transferMatchResources(router, result[1]);
+			discardBackground(router, result);
+			return;
+		}
+		await awaitPendingMinimum(router, tx);
+		if (router._tx !== tx) {
+			finishPending(router, tx);
+			transferMatchResources(router, result[1]);
+			discardBackground(router, result);
 			return;
 		}
 		const commit = () => {
@@ -985,8 +926,8 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 				...changeInfo
 			});
 		};
-		const rendered = process.env.NODE_ENV !== "production" && tx[6] ? await transitionRefresh(router, tx, result, changeInfo) : await router.startTransition(commit, result[1]);
-		if (process.env.NODE_ENV !== "production" && tx[6] && rendered === void 0) return;
+		const rendered = await router.startTransition(commit, result[1]);
+		if (process.env.NODE_ENV !== "production" && tx[6]) tx[6] = void 0;
 		if (router._tx !== tx) {
 			discardBackground(router, result);
 			return;
@@ -1011,11 +952,7 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 }
 async function loadClientRoute(router, opts) {
 	let rematerialize = false;
-	if (process.env.NODE_ENV !== "production") {
-		router._tx?.[6]?.[2]?.();
-		rematerialize = !!router._refreshNextLoad || !!router._tx?.[6];
-	}
-	const refreshPresentation = rematerialize ? router.stores.matches.get() : void 0;
+	if (process.env.NODE_ENV !== "production") rematerialize = !!router._refreshNextLoad || !!router._tx?.[6];
 	const previousOwner = router._tx;
 	const resolvedLocation = router.stores.resolvedLocation.get();
 	const previousLocation = resolvedLocation ?? router.stores.location.get();
@@ -1047,31 +984,12 @@ async function loadClientRoute(router, opts) {
 		return;
 	}
 	const sameHref = previousLocation.href === location.href;
-	let matches;
 	let controller = preflight;
-	try {
-		matches = process.env.NODE_ENV !== "production" && rematerialize ? router.matchRoutes(location, {
-			_controller: preflight,
-			_rematerialize: true
-		}) : router.matchRoutes(location, { _controller: preflight });
-		acquireMatchResources(matches);
-	} catch (cause) {
-		preflight.abort();
-		if (!require_redirect.isRedirect(cause)) {
-			if (process.env.NODE_ENV !== "production" && rematerialize) router._refreshNextLoad = void 0;
-			await awaitCurrent(router);
-			router._commitPromise?.resolve();
-			router._commitPromise = void 0;
-			return;
-		}
-		await router.navigate({
-			...cause.options,
-			replace: true,
-			ignoreBlocker: true
-		});
-		await awaitCurrent(router, previousOwner);
-		return;
-	}
+	const matches = process.env.NODE_ENV !== "production" && rematerialize ? router.matchRoutes(location, {
+		_controller: preflight,
+		_rematerialize: true
+	}) : router.matchRoutes(location, { _controller: preflight });
+	acquireMatchResources(matches);
 	const resolvedPrefix = hydrationController ? handoff[1](matches) : void 0;
 	if (resolvedPrefix) controller = hydrationController;
 	else hydrationController?.abort();
@@ -1087,12 +1005,10 @@ async function loadClientRoute(router, opts) {
 		location,
 		matches,
 		Date.now(),
-		Promise.resolve().then(() => runClientTransaction(router, tx, sameHref, () => offerPending(router, tx), opts?.sync, resolvedPrefix)).catch(() => {
-			if (router._tx === tx) restoreCommitted(router, tx);
-		})
+		Promise.resolve().then(() => runClientTransaction(router, tx, sameHref, () => offerPending(router, tx), opts?.sync, resolvedPrefix)).then()
 	];
 	if (process.env.NODE_ENV !== "production" && rematerialize) {
-		tx[6] = [refreshPresentation, handoff];
+		tx[6] = [handoff];
 		router._refreshNextLoad = void 0;
 	}
 	router._tx = tx;
@@ -1114,15 +1030,11 @@ async function loadClientRoute(router, opts) {
 		router.stores.status.set("pending");
 		router.stores.location.set(location);
 	});
-	if (!resolvedLocation && !matches.some((match) => match._notFound)) offerPending(router, tx);
-	try {
-		await tx[5];
-	} finally {
-		await awaitCurrent(router, tx);
-	}
+	if (resolvedPrefix || !router._committed.length && !matches.some((match) => match._notFound)) offerPending(router, tx);
+	await tx[5];
+	await awaitCurrent(router, tx);
 }
 async function refreshClientRoute(router) {
-	router._tx?.[6]?.[2]?.();
 	const pending = router._tx;
 	if (pending && !pending[6] && router.stores.status.get() === "pending") {
 		await pending[5];
@@ -1133,10 +1045,9 @@ async function refreshClientRoute(router) {
 	router._refreshNextLoad = true;
 	await loadClientRoute(router, { sync: true });
 }
-async function preloadClientRoute(router, opts, redirects = 0) {
-	if (redirects > 20) return;
+async function preloadClientRoute(router, opts, redirects = 0, builtLocation) {
 	if (process.env.NODE_ENV !== "production" && (router._refreshNextLoad || router._tx?.[6])) return;
-	const location = opts._builtLocation ?? router.buildLocation(opts);
+	const location = builtLocation ?? router.buildLocation(opts);
 	const base = router._committed;
 	const controller = new AbortController();
 	let matches;
@@ -1156,7 +1067,6 @@ async function preloadClientRoute(router, opts, redirects = 0) {
 			result = await executeClientLane(router, location, matches, [
 				controller,
 				redirects,
-				() => true,
 				base,
 				true
 			]);
@@ -1166,10 +1076,7 @@ async function preloadClientRoute(router, opts, redirects = 0) {
 			controller.abort();
 		}
 		if (!isControl(result)) return result[1];
-		if (active && result[0] === REDIRECTED && !result[1].options.reloadDocument) return preloadClientRoute(router, {
-			...result[1].options,
-			_fromLocation: location
-		}, redirects + 1);
+		if (active && result[0] === REDIRECTED && !result[1].options.reloadDocument) return preloadClientRoute(router, result[1].options, redirects + 1, result[2]);
 	} catch (cause) {
 		if (!require_not_found.isNotFound(cause)) console.error(cause);
 	}
@@ -1290,7 +1197,10 @@ async function hydrate(router) {
 					params: match.params,
 					context: parentContext,
 					location,
-					navigate: navigateFrom(router, location),
+					navigate: (opts) => router.navigate({
+						...opts,
+						_fromLocation: location
+					}),
 					buildLocation: router.buildLocation,
 					cause: match.cause,
 					abortController: controller,