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

package/dist/cjs/load-client.cjs

@@ -1,4 +1,3 @@
-const require_utils = require("./utils.cjs");
 const require_not_found = require("./not-found.cjs");
 const require_redirect = require("./redirect.cjs");
 const require_ssr_match_id = require("./ssr/ssr-match-id.cjs");
@@ -11,14 +10,16 @@ function replaceRouteChunk(route, lazyFn) {
 function preloadComponent(route, type) {
 	return route.options[type]?.preload?.();
 }
-function loadComponents(route) {
+function loadComponents(route, onPendingReady) {
 	const component = preloadComponent(route, "component");
 	const pending = preloadComponent(route, "pendingComponent");
-	if (component && pending) return Promise.all([component, pending]).then(() => {});
-	return component ?? pending;
+	const pendingReady = onPendingReady && pending ? pending.then(onPendingReady) : pending;
+	if (onPendingReady && !pending) onPendingReady();
+	if (component && pendingReady) return Promise.all([component, pendingReady]).then(() => {});
+	return component ?? pendingReady;
 }
-function loadRouteChunk(route, componentType) {
-	const afterLazy = () => componentType === false ? void 0 : componentType ? preloadComponent(route, componentType) : loadComponents(route);
+function loadRouteChunk(route, componentType, onPendingReady) {
+	const afterLazy = () => componentType === false ? void 0 : componentType ? preloadComponent(route, componentType) : loadComponents(route, onPendingReady);
 	const current = route._lazy;
 	if (current) return current === true ? afterLazy() : current.then(afterLazy);
 	if (!route.lazyFn) return afterLazy();
@@ -107,7 +108,7 @@ function navigateFrom(router, location) {
 		_fromLocation: location
 	});
 }
-async function contextualize(router, lane, options, end) {
+async function contextualize(router, lane, options, end, planSuccessfulLane) {
 	const [location, matches] = lane;
 	const signal = options[0].signal;
 	const preload = !!options[4];
@@ -188,35 +189,21 @@ async function contextualize(router, lane, options, end) {
 			setFetching(router, match, false, options[0]);
 		}
 	}
+	planSuccessfulLane();
 }
-function releaseOwnedFlight(router, id, flight) {
+function releaseOwnedFlight(router, match, flight) {
 	if (!flight || --flight[2]) return;
-	if (router._flights?.get(id) === flight) router._flights.delete(id);
+	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;
+		router._flights.delete(match.id);
+	}
 	return flight[1];
 }
 function releaseFlight(router, match) {
 	const flight = match._flight;
 	match._flight = void 0;
-	releaseOwnedFlight(router, match.id, flight)?.abort();
-}
-function laneInputs(router, location) {
-	const masked = location.maskedLocation;
-	return [
-		router.routeTree,
-		router.options.context ?? {},
-		router.options.additionalContext,
-		require_router._getUserHistoryState(location.state),
-		location.search,
-		masked && [
-			masked.href,
-			require_router._getUserHistoryState(masked.state),
-			masked.search,
-			masked.unmaskOnReload
-		]
-	];
-}
-function samePreloadLane(preload, router, location, redirects) {
-	return preload[3] === router._committed && preload[5] === redirects && require_utils.deepEqual(preload[4], laneInputs(router, location)) && !preload[0].some((match) => getRoute(router, match).options.preload === false);
+	releaseOwnedFlight(router, match, flight)?.abort();
 }
 /**
 * Not passing in a `next` ownership recipient
@@ -227,14 +214,31 @@ function transferMatchResources(router, previous, next) {
 	for (const match of previous) if (!next?.includes(match)) {
 		const flight = match._flight;
 		match._flight = void 0;
-		const controller = releaseOwnedFlight(router, match.id, flight);
+		const controller = releaseOwnedFlight(router, match, flight);
 		if (controller) abort.push(controller);
 	}
 	for (const controller of abort) controller.abort();
 }
-function discardPreload(router, preload) {
-	preload[1].abort();
-	transferMatchResources(router, preload[0]);
+function transferPredecessorResources(router, previous, next) {
+	const abort = [];
+	for (const match of previous) if (!next.includes(match)) {
+		const flight = match._flight;
+		match._flight = void 0;
+		if (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;
+		else {
+			const controller = releaseOwnedFlight(router, match, flight);
+			if (controller) abort.push(controller);
+		}
+	}
+	for (const controller of abort) controller.abort();
+}
+function releaseUnownedFlights(router) {
+	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();
 }
 function acquireMatchResources(matches) {
 	for (const match of matches) {
@@ -273,38 +277,30 @@ async function loadResource(router, lane, match, route, loader, parentMatchPromi
 	if (signal.aborted) return [CANCELED];
 	if (!loader) return [SUCCESS, void 0];
 	let flight = match._flight;
-	let joined = !!flight;
 	setFetching(router, match, "loader", owner);
 	try {
-		for (;;) {
-			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) => {
-						return result[0] === ERROR && match._flight === flight ? normalizeError(route, result[1]) : result;
-					}),
-					controller,
-					1
-				];
-				(router._flights ??= /* @__PURE__ */ new Map()).set(match.id, flight);
-			}
-			match._flight = flight;
-			match.abortController = flight[1];
-			try {
-				const outcome = await waitFor(flight[0], signal);
-				if (!joined || outcome[0] === SUCCESS || outcome[0] === REDIRECTED) return outcome;
-			} catch (cause) {
-				if (cause === signal) {
-					releaseFlight(router, match);
-					return [CANCELED];
-				}
-				throw cause;
-			}
-			releaseFlight(router, match);
-			if (signal.aborted) return [CANCELED];
-			flight = void 0;
-			joined = false;
+		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) => {
+					if (result[0] !== SUCCESS && router._flights?.get(match.id) === flight) {
+						router._flights.delete(match.id);
+						if (!flight[2]) controller.abort();
+					}
+					return result[0] === ERROR && flight[2] ? normalizeError(route, result[1]) : result;
+				}),
+				controller,
+				1
+			];
+			(router._flights ??= /* @__PURE__ */ new Map()).set(match.id, flight);
 		}
+		match._flight = flight;
+		match.abortController = flight[1];
+		return await waitFor(flight[0], signal);
+	} catch (cause) {
+		if (cause !== signal) throw cause;
+		releaseFlight(router, match);
+		return [CANCELED];
 	} finally {
 		setFetching(router, match, false, owner);
 	}
@@ -349,10 +345,10 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options) {
 	const route = getRoute(router, match);
 	const preload = !!options[4];
 	const plannedCacheMatch = preload ? router._cache.get(match.id) : void 0;
+	let configured;
 	let reload = false;
 	let reloadFailure;
 	try {
-		let configured;
 		if (match.status === "success") {
 			configured = route.options.shouldReload;
 			if (typeof configured === "function") configured = configured(getLoaderContext(router, lane, match, route, options[0], semanticParent, preload));
@@ -373,20 +369,23 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options) {
 	}
 	const routeLoader = route.options.loader;
 	const loader = typeof routeLoader === "function" ? routeLoader : routeLoader?.handler;
+	let donor = (!preload || route.options.preload !== false) && routeLoader && !(process.env.NODE_ENV !== "production" && router._tx?.[6]) ? router._flights?.get(match.id) : void 0;
+	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 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;
 	if (loaded && !routeLoader) {
 		match.invalid = false;
 		match.updatedAt = Date.now();
 	}
-	let donor = loaded && routeLoader ? router._flights?.get(match.id) : void 0;
-	if (donor === match._flight) donor = void 0;
-	else if (donor) donor[2]++;
+	if (donor) donor[2]++;
 	if (blocking) {
 		const acceptedFlight = match._flight;
 		match._flight = donor;
-		releaseOwnedFlight(router, match.id, acceptedFlight)?.abort();
+		releaseOwnedFlight(router, match, acceptedFlight)?.abort();
 		if (match.status === "success") match.status = "pending";
 		options[8]?.();
 	}
@@ -395,15 +394,13 @@ function createLoaderTask(router, lane, index, tasks, semanticParent, options) {
 		if (blocking) {
 			settleInto(match, result, preload);
 			if (result[0] === SUCCESS) {
-				if (preload && routeLoader) cacheLoaderMatch(router, match, plannedCacheMatch);
+				if (preload && routeLoader && !options[0].signal.aborted) cacheLoaderMatch(router, match, plannedCacheMatch);
 				match.status = "pending";
 			}
 		}
 		return result;
 	});
-	const chunkFailure = waitFor(Promise.resolve().then(() => loadRouteChunk(route)), options[0].signal).then(() => {
-		options[8]?.();
-	}, (cause) => [index, normalizeLaneError(route, cause, options)]).then((failure) => outcome.then((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]()) {
 			match.status = "success";
 			options[8]?.();
@@ -603,20 +600,26 @@ async function executeClientLane(router, location, matches, options) {
 		plannedBoundary = boundary;
 	}
 	let end = plannedBoundary < 0 ? matches.length : plannedBoundary + 1;
-	const failure = await contextualize(router, matched, options, end);
-	if (failure) options[5] = true;
 	const tasks = [];
 	const start = options[7] ?? 0;
 	let semanticParent = start ? Promise.resolve(matched[1][start - 1]) : void 0;
-	end = failure?.[0] ?? end;
-	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] ?? 0) >= REDIRECTED) end = 0;
-	for (let index = start; index < end; index++) {
-		if (options[0].signal.aborted) break;
-		semanticParent = createLoaderTask(router, matched, index, tasks, semanticParent, options);
-	}
+	const planSuccessfulLane = () => {
+		for (let index = start; index < end; index++) {
+			if (options[0].signal.aborted) break;
+			semanticParent = createLoaderTask(router, matched, index, tasks, semanticParent, options);
+		}
+	};
+	const failure = await contextualize(router, matched, options, end, planSuccessfulLane);
+	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]) releaseUnownedFlights(router);
 	let reduced;
 	try {
 		const reduction = reduceLane(router, matched, tasks, options[0], options[1], settleTasks(tasks, failure, matched[2]), options[8]);
@@ -706,7 +709,7 @@ function offerPending(router, tx) {
 		_flight: void 0
 	}));
 	offered[boundary].status = "pending";
-	const ack = router.startTransition(() => router.stores.setMatches(offered), offered, true).then((rendered) => {
+	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;
 	});
@@ -803,16 +806,17 @@ function rollbackPublication(router, tx, lane, checkpoint) {
 	return true;
 }
 async function transitionRefresh(router, tx, lane, changeInfo) {
+	const refresh = tx[6];
 	const checkpoint = {
 		previousMatches: router._committed,
-		previousPresentation: tx[6]?.[0] ?? router.stores.matches.get(),
+		previousPresentation: refresh[0],
 		previousCache: router._cache,
 		commitPromise: router._commitPromise,
 		published: false
 	};
 	const commit = () => {
 		finishPending(router, tx);
-		router._rollbackRefresh = rollback;
+		refresh[2] = rollback;
 		commitRefreshMatches(router, tx, lane[1], checkpoint);
 		if (!checkpoint.published || router._tx !== tx) return;
 		router.emit({
@@ -825,16 +829,16 @@ async function transitionRefresh(router, tx, lane, changeInfo) {
 		});
 	};
 	const rollback = () => {
-		if (router._rollbackRefresh === rollback) router._rollbackRefresh = void 0;
+		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 (router._rollbackRefresh === rollback) router._rollbackRefresh = void 0;
+		if (refresh[2] === rollback) refresh[2] = void 0;
 		if (checkpoint.published) {
-			const handoff = tx[6]?.[1];
+			const handoff = refresh[1];
 			if (handoff && router._handoff === handoff) handoff[1]();
 			if (router._tx === tx) tx[6] = void 0;
 		}
@@ -911,7 +915,7 @@ async function runBackground(router, tx, base, tasks, settlement) {
 	publishMatches(router, projected[1]);
 	transferMatchResources(router, base, projected[1]);
 }
-async function runClientTransaction(router, tx, forceStaleReload, onReady, sync, resolvedPrefix, adopted, retained) {
+async function runClientTransaction(router, tx, forceStaleReload, onReady, sync, resolvedPrefix) {
 	const options = [
 		tx[0],
 		tx[1],
@@ -923,24 +927,7 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 		resolvedPrefix,
 		onReady
 	];
-	let result;
-	try {
-		result = adopted ? await adopted[2] : await executeClientLane(router, tx[2], tx[3], options);
-	} finally {
-		if (retained) discardPreload(router, retained);
-	}
-	if (adopted && router._tx === tx && (isControl(result) && result[0] === CANCELED || !isControl(result) && result[1].some((match) => match.status !== "success" || match._notFound))) {
-		const donors = tx[3];
-		tx[3] = [];
-		transferMatchResources(router, donors);
-		tx[0].abort();
-		if (router._tx !== tx) return;
-		const controller = new AbortController();
-		tx[0] = options[0] = controller;
-		tx[3] = router.matchRoutes(tx[2], { _controller: controller });
-		acquireMatchResources(tx[3]);
-		result = await executeClientLane(router, tx[2], tx[3], options);
-	}
+	const result = await executeClientLane(router, tx[2], tx[3], options);
 	if (isControl(result)) {
 		if (result[0] === REDIRECTED && router._tx === tx) {
 			finishPending(router, tx);
@@ -1036,7 +1023,7 @@ async function runClientTransaction(router, tx, forceStaleReload, onReady, sync,
 async function loadClientRoute(router, opts) {
 	let rematerialize = false;
 	if (process.env.NODE_ENV !== "production") {
-		router._rollbackRefresh?.();
+		router._tx?.[6]?.[2]?.();
 		rematerialize = !!router._refreshNextLoad || !!router._tx?.[6];
 	}
 	const refreshPresentation = rematerialize ? router.stores.matches.get() : void 0;
@@ -1046,10 +1033,6 @@ async function loadClientRoute(router, opts) {
 	const location = router.latestLocation;
 	const pendingLocation = router._pendingLocation;
 	const redirects = pendingLocation?.href === location.href ? pendingLocation._redirects ?? 0 : 0;
-	if (opts?._dedupe && !redirects && previousOwner && !rematerialize && previousOwner[2].href === location.href && router.stores.status.get() === "pending") {
-		await awaitCurrent(router);
-		return;
-	}
 	const handoff = router._handoff;
 	const hydrationController = rematerialize ? void 0 : handoff?.[0]();
 	const preflight = new AbortController();
@@ -1057,7 +1040,7 @@ async function loadClientRoute(router, opts) {
 	router._preflight = preflight;
 	if (!rematerialize && !hydrationController) handoff?.[1]();
 	previousPreflight?.abort();
-	if (preflight.signal.aborted || router._tx !== previousOwner) {
+	if (preflight.signal.aborted) {
 		await awaitCurrent(router, previousOwner);
 		return;
 	}
@@ -1066,71 +1049,44 @@ async function loadClientRoute(router, opts) {
 		type: "onBeforeNavigate",
 		...changeInfo
 	});
-	if (!preflight.signal.aborted && router._tx === previousOwner) router.emit({
+	if (!preflight.signal.aborted) router.emit({
 		type: "onBeforeLoad",
 		...changeInfo
 	});
-	if (preflight.signal.aborted || router._tx !== previousOwner) {
-		preflight.abort();
+	if (preflight.signal.aborted) {
 		await awaitCurrent(router, previousOwner);
 		return;
 	}
 	const sameHref = previousLocation.href === location.href;
-	let adopted = router._preloads?.get(location.href);
-	let retained;
-	if (rematerialize && adopted) {
-		router._preloads.delete(location.href);
-		discardPreload(router, adopted);
-		adopted = void 0;
-		if (preflight.signal.aborted || router._tx !== previousOwner) {
-			preflight.abort();
-			await awaitCurrent(router, previousOwner);
-			return;
-		}
-	}
-	if (adopted && (hydrationController || !samePreloadLane(adopted, router, pendingLocation?.href === location.href ? pendingLocation : location, redirects))) {
-		router._preloads.delete(location.href);
-		retained = adopted;
-		adopted = void 0;
-	}
 	let matches;
 	let controller = preflight;
-	let resolvedPrefix;
-	if (adopted) {
-		controller = adopted[1];
-		matches = adopted[0];
-		router._preloads.delete(location.href);
-	} else {
-		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 (retained) discardPreload(router, retained);
-			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);
+	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;
 		}
-		resolvedPrefix = hydrationController ? handoff[1](matches) : void 0;
-		if (resolvedPrefix) controller = hydrationController;
-		else hydrationController?.abort();
+		await router.navigate({
+			...cause.options,
+			replace: true,
+			ignoreBlocker: true
+		});
+		await awaitCurrent(router, previousOwner);
+		return;
 	}
-	if (router._preflight !== preflight || router._tx !== previousOwner) {
-		preflight.abort();
+	const resolvedPrefix = hydrationController ? handoff[1](matches) : void 0;
+	if (resolvedPrefix) controller = hydrationController;
+	else hydrationController?.abort();
+	if (preflight.signal.aborted) {
 		transferMatchResources(router, matches);
 		await awaitCurrent(router, previousOwner);
 		return;
@@ -1142,7 +1098,7 @@ async function loadClientRoute(router, opts) {
 		location,
 		matches,
 		Date.now(),
-		Promise.resolve().then(() => runClientTransaction(router, tx, sameHref, () => offerPending(router, tx), opts?.sync, resolvedPrefix, adopted, retained)).catch(() => {
+		Promise.resolve().then(() => runClientTransaction(router, tx, sameHref, () => offerPending(router, tx), opts?.sync, resolvedPrefix)).catch(() => {
 			if (router._tx === tx) restoreCommitted(router, tx);
 		})
 	];
@@ -1151,14 +1107,13 @@ async function loadClientRoute(router, opts) {
 		router._refreshNextLoad = void 0;
 	}
 	router._tx = tx;
-	if (!rematerialize && router._handoff === handoff) router._handoff = void 0;
 	if (previousOwner) {
 		for (const match of router.stores.matches.get()) {
 			if (router._tx !== tx) break;
 			if (match.isFetching) setFetching(router, match, false);
 		}
 		previousOwner[0].abort();
-		transferMatchResources(router, previousOwner[3]);
+		transferPredecessorResources(router, previousOwner[3], tx[3]);
 	}
 	if (router._tx !== tx) {
 		transferMatchResources(router, tx[3]);
@@ -1178,7 +1133,7 @@ async function loadClientRoute(router, opts) {
 	}
 }
 async function refreshClientRoute(router) {
-	router._rollbackRefresh?.();
+	router._tx?.[6]?.[2]?.();
 	const pending = router._tx;
 	if (pending && !pending[6] && router.stores.status.get() === "pending") {
 		await pending[5];
@@ -1189,72 +1144,45 @@ async function refreshClientRoute(router) {
 	router._refreshNextLoad = true;
 	await loadClientRoute(router, { sync: true });
 }
-function followPreloadRedirect(router, result, location, owner, redirects) {
-	if (result[0] === REDIRECTED && !result[1].options.reloadDocument && router._tx === owner) return preloadClientRoute(router, {
-		...result[1].options,
-		_fromLocation: location
-	}, redirects + 1);
-}
 async function preloadClientRoute(router, opts, redirects = 0) {
 	if (redirects > 20) return;
-	const owner = router._tx;
-	if (process.env.NODE_ENV !== "production" && (router._refreshNextLoad || owner?.[6])) return;
+	if (process.env.NODE_ENV !== "production" && (router._refreshNextLoad || router._tx?.[6])) return;
 	const location = opts._builtLocation ?? router.buildLocation(opts);
 	const base = router._committed;
 	const controller = new AbortController();
 	let matches;
-	let preload;
-	let replaced;
 	try {
-		const pending = router._preloads?.get(location.href);
-		if (pending) {
-			if (samePreloadLane(pending, router, location, redirects)) {
-				const result = await pending[2];
-				return isControl(result) ? followPreloadRedirect(router, result, location, owner, redirects) : result[1];
-			}
-			router._preloads.delete(location.href);
-			replaced = pending;
-		}
 		matches = router.matchRoutes(location, { _controller: controller });
 		acquireMatchResources(matches);
-		const promise = Promise.resolve().then(() => executeClientLane(router, location, matches, [
-			controller,
-			redirects,
-			() => true,
-			base,
-			true
-		])).finally(() => {
-			if (replaced) discardPreload(router, replaced);
-		});
-		preload = [
-			matches,
-			controller,
-			promise,
-			base,
-			laneInputs(router, location),
-			redirects
-		];
-		(router._preloads ??= /* @__PURE__ */ new Map()).set(location.href, preload);
-		const result = await promise;
-		if (router._preloads?.get(location.href) !== preload) return isControl(result) ? void 0 : result[1];
-		router._preloads.delete(location.href);
-		if (isControl(result)) {
-			controller.abort();
-			transferMatchResources(router, matches);
-			return followPreloadRedirect(router, result, location, owner, redirects);
-		}
-		transferMatchResources(router, result[1]);
-		controller.abort();
-		return result[1];
 	} catch (cause) {
-		if (!preload || router._preloads?.get(location.href) === preload) {
-			if (preload) router._preloads.delete(location.href);
+		controller.abort();
+		if (!require_not_found.isNotFound(cause)) console.error(cause);
+		return;
+	}
+	(router._preloads ??= /* @__PURE__ */ new Map()).set(controller, matches);
+	let active;
+	try {
+		let result;
+		try {
+			result = await executeClientLane(router, location, matches, [
+				controller,
+				redirects,
+				() => true,
+				base,
+				true
+			]);
+		} finally {
+			active = router._preloads.delete(controller);
+			transferMatchResources(router, matches);
 			controller.abort();
-			if (matches) transferMatchResources(router, matches);
 		}
-		if (router._tx !== owner) return;
+		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);
+	} catch (cause) {
 		if (!require_not_found.isNotFound(cause)) console.error(cause);
-		return;
 	}
 }
 async function hydrate(router) {
@@ -1269,32 +1197,30 @@ async function hydrate(router) {
 	const dehydratedRouter = tsr.router;
 	if (process.env.NODE_ENV !== "production" && !dehydratedRouter) throw new Error("Invariant failed: Expected to find a dehydrated data on window.$_TSR.router, but we did not. Please file an issue!");
 	router.ssr = { manifest: dehydratedRouter.manifest };
-	const nonce = document.querySelector("meta[property=\"csp-nonce\"]")?.content;
-	router.options.ssr = { nonce };
+	router.options.ssr = { nonce: document.querySelector("meta[property=\"csp-nonce\"]")?.content };
 	const dehydratedMatches = dehydratedRouter.matches;
 	const controller = new AbortController();
 	const previousPreflight = router._preflight;
 	router._preflight = controller;
 	previousPreflight?.abort();
-	const retire = (cause) => {
-		if (router._preflight === controller) router._preflight = void 0;
-		controller.abort(cause);
-		return false;
-	};
-	const isCurrent = () => !router._tx && router._preflight === controller && !controller.signal.aborted || retire();
+	const isCurrent = () => router._preflight === controller;
 	let location;
 	let candidates;
-	let handoffInputs;
+	let handoffHistoryHref;
+	let handoffHistoryState;
 	try {
 		await waitFor(router.options.hydrate?.(dehydratedRouter.dehydratedData), controller.signal);
 		if (!isCurrent()) return;
+		const historyLocation = router.history.location;
+		handoffHistoryHref = historyLocation.href;
+		handoffHistoryState = historyLocation.state;
 		router.updateLatestLocation();
 		location = router.latestLocation;
 		router.stores.location.set(location);
-		handoffInputs = laneInputs(router, location);
 		candidates = router.matchRoutes(location, { _controller: controller });
 	} catch (cause) {
-		retire(cause);
+		if (isCurrent()) router._preflight = void 0;
+		controller.abort(cause);
 		if (cause !== controller.signal) throw cause;
 	}
 	if (!isCurrent()) return;
@@ -1343,7 +1269,6 @@ async function hydrate(router) {
 		committed.push(candidate);
 		if (candidate.ssr === "data-only") pendingBoundary ??= index;
 	}
-	let verifiedContextEnd = verifiedAssetEnd;
 	if (!isTerminal && committed.length === shared && shared < candidates.length) pendingBoundary = shared;
 	const chunks = committed.map(async (match) => {
 		try {
@@ -1359,15 +1284,11 @@ async function hydrate(router) {
 	try {
 		while (chunkFailure < chunks.length && await waitFor(chunks[chunkFailure], controller.signal)) chunkFailure++;
 	} catch {
-		isCurrent();
 		return;
 	}
 	if (!isCurrent()) return;
-	if (chunkFailure < committed.length) {
-		verifiedContextEnd = Math.min(verifiedContextEnd, chunkFailure);
-		retryFrom(chunkFailure);
-	}
-	const contextEnd = Math.max(pendingBoundary === committed.length ? committed.length + 1 : committed.length, verifiedContextEnd);
+	if (chunkFailure < committed.length) retryFrom(chunkFailure);
+	const contextEnd = Math.max(pendingBoundary === committed.length ? committed.length + 1 : committed.length, chunkFailure < chunks.length ? chunkFailure : verifiedAssetEnd);
 	for (let index = 0; index < contextEnd; index++) {
 		const match = candidates[index];
 		const route = getRoute(router, match);
@@ -1411,7 +1332,7 @@ async function hydrate(router) {
 	let dataOnlyAssetEnd;
 	if (needsClientLoad && pendingBoundary !== void 0) {
 		const boundary = presented[pendingBoundary];
-		dataOnlyAssetEnd = boundary.status === "success" && boundary.ssr === "data-only" && boundary.error === void 0 && !boundary._notFound && verifiedAssetEnd > pendingBoundary + 1 ? verifiedAssetEnd : void 0;
+		dataOnlyAssetEnd = boundary.ssr === "data-only" && verifiedAssetEnd > pendingBoundary + 1 ? verifiedAssetEnd : void 0;
 		presented = presented.slice();
 		presented[pendingBoundary] = {
 			...boundary,
@@ -1420,19 +1341,22 @@ async function hydrate(router) {
 			_assetEnd: dataOnlyAssetEnd
 		};
 	}
-	const claim = () => needsClientLoad && !router._tx && router.latestLocation.state === location.state && require_utils.deepEqual(handoffInputs, laneInputs(router, router.latestLocation)) && router._committed === committedMatches && committedMatches.length && !controller.signal.aborted ? controller : void 0;
+	const claim = () => {
+		const historyLocation = router.history.location;
+		return needsClientLoad && !router._tx && historyLocation.href === handoffHistoryHref && historyLocation.state === handoffHistoryState && router._committed === committedMatches && committedMatches.length && !controller.signal.aborted ? controller : void 0;
+	};
 	const handoff = [claim, (matches) => {
 		if (router._handoff !== handoff) return;
+		router._handoff = void 0;
 		const prefix = committedMatches.length;
 		if (!matches || !claim() || committedMatches.some((match, index) => match.id !== matches[index]?.id)) {
-			router._handoff = void 0;
 			controller.abort();
 			return;
 		}
 		let handoffAssetEnd = dataOnlyAssetEnd;
 		if (handoffAssetEnd !== void 0) {
 			for (let index = prefix; index < handoffAssetEnd; index++) if (candidates[index]?.id !== matches[index]?.id) {
-				handoffAssetEnd = index > (pendingBoundary ?? -1) + 1 ? index : void 0;
+				handoffAssetEnd = index > pendingBoundary + 1 ? index : void 0;
 				break;
 			}
 		}
@@ -1465,6 +1389,5 @@ exports.loadRouteChunk = loadRouteChunk;
 exports.preloadClientRoute = preloadClientRoute;
 exports.refreshClientRoute = refreshClientRoute;
 exports.replaceRouteChunk = replaceRouteChunk;
-exports.transferMatchResources = transferMatchResources;
 
 //# sourceMappingURL=load-client.cjs.map