react-router 8.4.0 → 8.5.1

package/dist/production/lib/router/router.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -10,7 +10,7 @@
  */
 import { PROTOCOL_RELATIVE_URL_REGEX, normalizeProtocolRelativeUrl } from "./url.js";
 import { createBrowserURLImpl, createLocation, createPath, invariant, parsePath, warning } from "./history.js";
-import { ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";
+import { DiscoveryCancelledError, ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";
 import { consumeInstrumentationClientResultMetaReceiver, getRouteInstrumentationUpdates, instrumentClientSideRouter } from "./instrumentation.js";
 import { V6RegExMatcher } from "./matcher.js";
 import { getRoutePatternMatcher } from "./matcher-route-pattern.preload.js";
@@ -114,6 +114,7 @@ var DataRoutes = class {
 		}
 	}
 };
+const clientErrors = /* @__PURE__ */ new WeakMap();
 /**
 * Create a router and listen to history POP navigations
 */
@@ -142,7 +143,6 @@ function createRouter(init) {
 	let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
 	let unlistenHistory = null;
 	let subscribers = /* @__PURE__ */ new Set();
-	let bufferedInitialStateUpdate = null;
 	let savedScrollPositions = null;
 	let getScrollRestorationKey = null;
 	let getScrollPosition = null;
@@ -213,6 +213,8 @@ function createRouter(init) {
 		blockers: /* @__PURE__ */ new Map()
 	};
 	let pendingAction = "POP";
+	let pendingPopstateDelta = 0;
+	let pendingDiscoveryCancellation;
 	let pendingPopstateNavigationDfd = null;
 	let pendingPreventScrollReset = false;
 	let pendingNavigationController;
@@ -273,6 +275,7 @@ function createRouter(init) {
 				pendingPopstateNavigationDfd = null;
 				return;
 			}
+			if (future.unstable_customRouteDiscovery) pendingPopstateDelta += delta || 0;
 			return startNavigation(historyAction, location);
 		});
 		if (isBrowser) {
@@ -294,19 +297,16 @@ function createRouter(init) {
 	}
 	function subscribe(fn) {
 		subscribers.add(fn);
-		if (bufferedInitialStateUpdate) {
-			let { newErrors } = bufferedInitialStateUpdate;
-			bufferedInitialStateUpdate = null;
-			fn(state, {
-				deletedFetchers: [],
-				newErrors,
-				viewTransitionOpts: void 0,
-				flushSync: false
-			});
-		}
 		return () => subscribers.delete(fn);
 	}
 	function updateState(newState, opts = {}) {
+		let newErrors = newState.errors ?? null;
+		let cachedErrors = newErrors ? clientErrors.get(newErrors) : void 0;
+		if (cachedErrors !== void 0) newErrors = cachedErrors;
+		if (newState.errors !== void 0 || newState.initialized) {
+			if (state.errors) clientErrors.delete(state.errors);
+			if (newState.errors) clientErrors.set(newState.errors, newErrors);
+		}
 		if (newState.matches) newState.matches = newState.matches.map((m) => {
 			let route = manifest[m.route.id];
 			let matchRoute = m.route;
@@ -329,10 +329,9 @@ function createRouter(init) {
 		fetchersQueuedForDeletion.forEach((key) => {
 			if (!state.fetchers.has(key) && !fetchControllers.has(key)) unmountedFetchers.push(key);
 		});
-		if (subscribers.size === 0) bufferedInitialStateUpdate = { newErrors: newState.errors ?? null };
 		[...subscribers].forEach((subscriber) => subscriber(state, {
 			deletedFetchers: unmountedFetchers,
-			newErrors: newState.errors ?? null,
+			newErrors,
 			viewTransitionOpts: opts.viewTransitionOpts,
 			flushSync: opts.flushSync === true
 		}));
@@ -397,17 +396,22 @@ function createRouter(init) {
 			viewTransitionOpts,
 			flushSync: flushSync === true
 		});
-		pendingAction = "POP";
-		pendingPreventScrollReset = false;
-		pendingViewTransitionEnabled = false;
-		isUninterruptedRevalidation = false;
-		isRevalidationRequired = false;
+		resetPendingNavigation();
 		pendingPopstateNavigationDfd?.resolve();
 		pendingPopstateNavigationDfd = null;
 		pendingRevalidationDfd?.resolve();
 		pendingRevalidationDfd = null;
 	}
+	function resetPendingNavigation() {
+		pendingPopstateDelta = 0;
+		pendingAction = "POP";
+		pendingPreventScrollReset = false;
+		pendingViewTransitionEnabled = false;
+		isUninterruptedRevalidation = false;
+		isRevalidationRequired = fetchReloadIds.size > 0;
+	}
 	async function navigate(to, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		pendingPopstateNavigationDfd?.resolve();
 		pendingPopstateNavigationDfd = null;
 		if (typeof to === "number") {
@@ -442,8 +446,9 @@ function createRouter(init) {
 		validateNavigationTarget(to == null ? init.history.createHref(state.location) : typeof to === "string" ? to : createPath(to), init.history.createHref(nextLocation.mask || nextLocation), init.history.createURL("/"), "reject");
 		let userReplace = opts && opts.replace != null ? opts.replace : void 0;
 		let historyAction = "PUSH";
+		let currentPath = state.location.pathname + state.location.search;
 		if (userReplace === true) historyAction = "REPLACE";
-		else if (userReplace === false) {} else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) historyAction = "REPLACE";
+		else if (userReplace === false) {} else if (submission != null && isMutationMethod(submission.formMethod) && (submission.formAction === currentPath || nextLocation.pathname + nextLocation.search === currentPath)) historyAction = "REPLACE";
 		let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : void 0;
 		let flushSync = (opts && opts.flushSync) === true;
 		let blockerKey = shouldBlockNavigation({
@@ -484,22 +489,28 @@ function createRouter(init) {
 		});
 	}
 	function revalidate() {
+		if (pendingDiscoveryCancellation) return pendingDiscoveryCancellation.then(revalidate);
 		if (!pendingRevalidationDfd) pendingRevalidationDfd = createDeferred();
 		interruptActiveLoads();
 		updateState({ revalidation: "loading" });
 		let promise = pendingRevalidationDfd.promise;
 		if (state.navigation.state === "submitting") return promise;
 		if (state.navigation.state === "idle") {
-			startNavigation(state.historyAction, state.location, { startUninterruptedRevalidation: true });
+			startNavigation(state.historyAction, state.location, {
+				startUninterruptedRevalidation: true,
+				dataStrategyInitiator: "revalidation"
+			});
 			return promise;
 		}
 		startNavigation(pendingAction || state.historyAction, state.navigation.location, {
 			overrideNavigation: state.navigation,
+			dataStrategyInitiator: "revalidation",
 			enableViewTransition: pendingViewTransitionEnabled === true
 		});
 		return promise;
 	}
 	async function startNavigation(historyAction, location, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		pendingNavigationController && pendingNavigationController.abort();
 		pendingNavigationController = null;
 		pendingAction = historyAction;
@@ -535,6 +546,7 @@ function createRouter(init) {
 		} : void 0;
 		pendingNavigationController = new AbortController();
 		let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
+		let dataStrategyInitiator = opts?.initialHydration ? "initialization" : opts?.dataStrategyInitiator ?? "navigation";
 		let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
 		let pendingActionResult;
 		if (opts && opts.pendingError) pendingActionResult = [findNearestBoundary(matches).route.id, {
@@ -542,7 +554,7 @@ function createRouter(init) {
 			error: opts.pendingError
 		}];
 		else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
-			let actionResult = await handleAction(request, location, opts.submission, matches, historyAction, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
+			let actionResult = await handleAction(request, dataStrategyInitiator, location, opts.submission, matches, historyAction, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
 				replace: opts.replace,
 				flushSync
 			});
@@ -566,7 +578,7 @@ function createRouter(init) {
 			fogOfWar.active = false;
 			request = createClientSideRequest(init.history, request.url, request.signal);
 		}
-		let { shortCircuited, matches: updatedMatches, loaderData, errors, workingFetchers } = await handleLoaders(request, location, matches, historyAction, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
+		let { shortCircuited, matches: updatedMatches, loaderData, errors, workingFetchers } = await handleLoaders(request, dataStrategyInitiator, location, matches, historyAction, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
 		if (shortCircuited) return;
 		pendingNavigationController = null;
 		completeNavigation(location, {
@@ -577,13 +589,57 @@ function createRouter(init) {
 			...workingFetchers ? { fetchers: workingFetchers } : {}
 		});
 	}
-	async function handleAction(request, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
-		interruptActiveLoads();
+	function cancelDiscoveryNavigation() {
+		let cancellation = createDeferred();
+		pendingDiscoveryCancellation = cancellation.promise;
+		let delta = pendingPopstateDelta;
+		let popstateNavigationDfd = pendingPopstateNavigationDfd;
+		pendingPopstateNavigationDfd = null;
+		pendingNavigationController?.abort();
+		pendingNavigationController = null;
+		resetPendingNavigation();
+		pendingRevalidationDfd?.resolve();
+		pendingRevalidationDfd = null;
+		let blockers = new Map(state.blockers);
+		blockers.forEach((blocker, key) => {
+			if (blocker.state === "proceeding") blockers.set(key, IDLE_BLOCKER);
+		});
+		let fetchers = new Map(state.fetchers);
+		let didUpdateFetchers = markFetchRedirectsDone(fetchers);
+		fetchers.forEach((fetcher, key) => {
+			if (fetcher.state === "loading" && !fetchControllers.has(key)) {
+				fetchers.set(key, getDoneFetcher(fetcher.data));
+				didUpdateFetchers = true;
+			}
+		});
+		cancelledFetcherLoads.clear();
+		updateState({
+			navigation: IDLE_NAVIGATION,
+			revalidation: "idle",
+			blockers,
+			...didUpdateFetchers ? { fetchers } : {}
+		});
+		function finishCancellation() {
+			pendingDiscoveryCancellation = void 0;
+			popstateNavigationDfd?.resolve();
+			cancellation.resolve();
+		}
+		if (delta) {
+			unblockBlockerHistoryUpdate = finishCancellation;
+			init.history.go(-delta);
+		} else finishCancellation();
+		return cancellation.promise;
+	}
+	async function handleAction(request, dataStrategyInitiator, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
+		if (!future.unstable_customRouteDiscovery) interruptActiveLoads();
 		updateState({ navigation: getSubmittingNavigation(location, matches, historyAction, submission) }, { flushSync: opts.flushSync === true });
 		if (isFogOfWar) {
 			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
-			if (discoverResult.type === "aborted") return { shortCircuited: true };
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && request.signal.aborted || discoverResult.type === "aborted") return { shortCircuited: true };
+			else if (discoverResult.type === "cancelled") {
+				await cancelDiscoveryNavigation();
+				return { shortCircuited: true };
+			} else if (discoverResult.type === "error") {
 				if (discoverResult.partialMatches.length === 0) {
 					let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
 					return {
@@ -613,6 +669,7 @@ function createRouter(init) {
 				};
 			} else matches = discoverResult.matches;
 		}
+		if (future.unstable_customRouteDiscovery) interruptActiveLoads();
 		let result;
 		let actionMatch = getTargetMatch(matches, location);
 		if (!actionMatch.route.action && !actionMatch.route.lazy) result = {
@@ -624,7 +681,7 @@ function createRouter(init) {
 			})
 		};
 		else {
-			let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties, scopedContext), scopedContext, null);
+			let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties, scopedContext), scopedContext, null, dataStrategyInitiator, historyAction);
 			result = results[actionMatch.route.id];
 			if (!result) {
 				for (let match of matches) if (results[match.route.id]) {
@@ -638,7 +695,7 @@ function createRouter(init) {
 			let replace;
 			if (opts && opts.replace != null) replace = opts.replace;
 			else replace = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history) === state.location.pathname + state.location.search;
-			await startRedirectNavigation(request, result, true, {
+			await startRedirectNavigation(request, result, true, dataStrategyInitiator, {
 				submission,
 				replace
 			});
@@ -661,7 +718,7 @@ function createRouter(init) {
 			pendingActionResult: [actionMatch.route.id, result]
 		};
 	}
-	async function handleLoaders(request, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
+	async function handleLoaders(request, dataStrategyInitiator, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
 		let loadingNavigation = overrideNavigation || getLoadingNavigation(location, matches, historyAction, submission);
 		let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
 		let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
@@ -674,8 +731,11 @@ function createRouter(init) {
 				}, { flushSync });
 			}
 			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
-			if (discoverResult.type === "aborted") return { shortCircuited: true };
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && request.signal.aborted || discoverResult.type === "aborted") return { shortCircuited: true };
+			else if (discoverResult.type === "cancelled") {
+				await cancelDiscoveryNavigation();
+				return { shortCircuited: true };
+			} else if (discoverResult.type === "error") {
 				if (discoverResult.partialMatches.length === 0) {
 					let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
 					return {
@@ -697,7 +757,10 @@ function createRouter(init) {
 					loaderData: {},
 					errors: { [route.id]: error }
 				};
-			} else matches = discoverResult.matches;
+			} else {
+				matches = discoverResult.matches;
+				if (initialHydration && !request.signal.aborted) updateState({ matches });
+			}
 		}
 		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, init.history, state, matches, activeSubmission, location, initialHydration ? [] : hydrationRouteProperties, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, pendingActionResult, callSiteDefaultShouldRevalidate);
 		pendingNavigationLoadId = ++incrementingLoadId;
@@ -727,29 +790,37 @@ function createRouter(init) {
 			abortFetcher(rf.key);
 			if (rf.controller) fetchControllers.set(rf.key, rf.controller);
 		});
-		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.key));
+		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => {
+			if (fetchControllers.get(rf.key) === rf.controller) abortFetcher(rf.key);
+		});
 		if (pendingNavigationController) pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
-		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext);
+		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext, dataStrategyInitiator, historyAction);
 		if (request.signal.aborted) return { shortCircuited: true };
 		if (pendingNavigationController) pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
-		revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
+		revalidatingFetchers.forEach((rf) => {
+			if (fetchControllers.get(rf.key) === rf.controller) fetchControllers.delete(rf.key);
+		});
 		let redirect = findRedirect(loaderResults);
 		if (redirect) {
-			await startRedirectNavigation(request, redirect.result, true, { replace });
+			await startRedirectNavigation(request, redirect.result, true, dataStrategyInitiator, { replace });
 			return { shortCircuited: true };
 		}
 		redirect = findRedirect(fetcherResults);
 		if (redirect) {
 			fetchRedirectIds.add(redirect.key);
-			await startRedirectNavigation(request, redirect.result, true, { replace });
+			await startRedirectNavigation(request, redirect.result, true, dataStrategyInitiator, { replace });
 			return { shortCircuited: true };
 		}
 		let workingFetchers = new Map(state.fetchers);
 		let { loaderData, errors } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers);
-		if (initialHydration && state.errors) errors = {
-			...state.errors,
-			...errors
-		};
+		if (initialHydration && state.errors) {
+			let newClientErrors = errors ?? null;
+			errors = {
+				...state.errors,
+				...errors
+			};
+			clientErrors.set(errors, newClientErrors);
+		}
 		let didUpdateFetcherRedirects = markFetchRedirectsDone(workingFetchers);
 		let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId, workingFetchers);
 		let shouldUpdateFetchers = didUpdateFetcherRedirects || didAbortFetchLoads || revalidatingFetchers.length > 0;
@@ -775,6 +846,7 @@ function createRouter(init) {
 		return workingFetchers;
 	}
 	async function fetch(key, routeId, href, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		abortFetcher(key);
 		let flushSync = (opts && opts.flushSync) === true;
 		let instrumentationResultMetaReceiver = consumeInstrumentationClientResultMetaReceiver(router);
@@ -807,15 +879,22 @@ function createRouter(init) {
 		await handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission);
 	}
 	async function handleFetcherAction(key, routeId, path, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission, callSiteDefaultShouldRevalidate) {
-		interruptActiveLoads();
+		if (!future.unstable_customRouteDiscovery) interruptActiveLoads();
 		fetchLoadMatches.delete(key);
-		updateFetcherState(key, getSubmittingFetcher(submission, state.fetchers.get(key)), { flushSync });
+		let existingFetcher = state.fetchers.get(key);
+		updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), { flushSync });
 		let abortController = new AbortController();
+		if (future.unstable_customRouteDiscovery) fetchControllers.set(key, abortController);
 		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
 		if (isFogOfWar) {
 			let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
-			if (discoverResult.type === "aborted") return;
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && fetchRequest.signal.aborted || discoverResult.type === "aborted") return;
+			else if (discoverResult.type === "cancelled") {
+				fetchControllers.delete(key);
+				fetchLoadMatches.delete(key);
+				updateFetcherState(key, getDoneFetcher(existingFetcher?.data), { flushSync });
+				return;
+			} else if (discoverResult.type === "error") {
 				setFetcherError(key, routeId, discoverResult.error, { flushSync });
 				return;
 			} else if (!discoverResult.matches) {
@@ -832,10 +911,11 @@ function createRouter(init) {
 			}), { flushSync });
 			return;
 		}
+		if (future.unstable_customRouteDiscovery) interruptActiveLoads();
 		fetchControllers.set(key, abortController);
 		let originatingLoadId = incrementingLoadId;
 		let fetchMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, requestMatches, match, hydrationRouteProperties, scopedContext);
-		let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key);
+		let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key, "fetcher");
 		let actionResult = actionResults[match.route.id];
 		if (!actionResult) {
 			for (let match of fetchMatches) if (actionResults[match.route.id]) {
@@ -848,30 +928,39 @@ function createRouter(init) {
 			return;
 		}
 		if (fetchersQueuedForDeletion.has(key)) {
-			if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
+			if (isErrorResult(actionResult)) {
 				updateFetcherState(key, getDoneFetcher(void 0));
 				return;
 			}
-		} else {
 			if (isRedirectResult(actionResult)) {
+				isRevalidationRequired = true;
+				actionResult = {
+					type: "data",
+					data: void 0
+				};
+			}
+		} else {
+			if (isRedirectResult(actionResult)) if (pendingNavigationLoadId > originatingLoadId) {
+				isRevalidationRequired = true;
+				actionResult = {
+					type: "data",
+					data: void 0
+				};
+			} else {
 				fetchControllers.delete(key);
-				if (pendingNavigationLoadId > originatingLoadId) {
-					updateFetcherState(key, getDoneFetcher(void 0));
-					return;
-				} else {
-					fetchRedirectIds.add(key);
-					updateFetcherState(key, getLoadingFetcher(submission));
-					return startRedirectNavigation(fetchRequest, actionResult, false, {
-						fetcherSubmission: submission,
-						preventScrollReset
-					});
-				}
+				fetchRedirectIds.add(key);
+				updateFetcherState(key, getLoadingFetcher(submission));
+				return startRedirectNavigation(fetchRequest, actionResult, false, "fetcher", {
+					fetcherSubmission: submission,
+					preventScrollReset
+				});
 			}
 			if (isErrorResult(actionResult)) {
 				setFetcherError(key, routeId, actionResult.error);
 				return;
 			}
 		}
+		isRevalidationRequired = true;
 		let nextLocation = state.navigation.location || state.location;
 		let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
 		let matches = state.navigation.state !== "idle" ? dataRouteMatcher.match(state.navigation.location) : state.matches;
@@ -891,9 +980,11 @@ function createRouter(init) {
 			if (rf.controller) fetchControllers.set(staleKey, rf.controller);
 		});
 		updateState({ fetchers: workingFetchers });
-		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
+		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => {
+			if (fetchControllers.get(rf.key) === rf.controller) abortFetcher(rf.key);
+		});
 		abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
-		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, revalidationRequest, nextLocation, scopedContext);
+		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, revalidationRequest, nextLocation, scopedContext, "fetcher");
 		if (abortController.signal.aborted) {
 			if (fetchReloadIds.get(key) === loadId) fetchReloadIds.delete(key);
 			return;
@@ -901,7 +992,9 @@ function createRouter(init) {
 		abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
 		fetchReloadIds.delete(key);
 		fetchControllers.delete(key);
-		revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));
+		revalidatingFetchers.forEach((r) => {
+			if (fetchControllers.get(r.key) === r.controller) fetchControllers.delete(r.key);
+		});
 		let fetcherIsMounted = state.fetchers.has(key);
 		let getRedirectStateWithDoneFetcher = (s) => {
 			if (!fetcherIsMounted) return s;
@@ -915,13 +1008,13 @@ function createRouter(init) {
 		let redirect = findRedirect(loaderResults);
 		if (redirect) {
 			state = getRedirectStateWithDoneFetcher(state);
-			return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
+			return startRedirectNavigation(revalidationRequest, redirect.result, false, "fetcher", { preventScrollReset });
 		}
 		redirect = findRedirect(fetcherResults);
 		if (redirect) {
 			fetchRedirectIds.add(redirect.key);
 			state = getRedirectStateWithDoneFetcher(state);
-			return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
+			return startRedirectNavigation(revalidationRequest, redirect.result, false, "fetcher", { preventScrollReset });
 		}
 		let finalFetchers = new Map(state.fetchers);
 		if (fetcherIsMounted) finalFetchers.set(key, getDoneFetcher(actionResult.data));
@@ -930,6 +1023,7 @@ function createRouter(init) {
 		if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
 			invariant(pendingAction, "Expected pending action");
 			pendingNavigationController && pendingNavigationController.abort();
+			markFetchRedirectsDone(finalFetchers);
 			completeNavigation(state.navigation.location, {
 				matches,
 				loaderData,
@@ -942,7 +1036,7 @@ function createRouter(init) {
 				loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
 				fetchers: finalFetchers
 			});
-			isRevalidationRequired = false;
+			isRevalidationRequired = fetchReloadIds.size > 0;
 		}
 	}
 	async function handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission) {
@@ -950,11 +1044,17 @@ function createRouter(init) {
 		let existingFetcher = state.fetchers.get(key);
 		updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : void 0), { flushSync });
 		let abortController = new AbortController();
+		if (future.unstable_customRouteDiscovery) fetchControllers.set(key, abortController);
 		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
 		if (loadMatch.isDiscovering) {
 			let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
-			if (discoverResult.type === "aborted") return;
-			else if (discoverResult.type === "error") {
+			if (future.unstable_customRouteDiscovery && fetchRequest.signal.aborted || discoverResult.type === "aborted") return;
+			else if (discoverResult.type === "cancelled") {
+				fetchControllers.delete(key);
+				fetchLoadMatches.delete(key);
+				updateFetcherState(key, getDoneFetcher(existingFetcher?.data), { flushSync });
+				return;
+			} else if (discoverResult.type === "error") {
 				setFetcherError(key, routeId, discoverResult.error, { flushSync });
 				return;
 			} else if (!discoverResult.matches) {
@@ -968,7 +1068,7 @@ function createRouter(init) {
 		let match = getTargetMatch(matches, path);
 		fetchControllers.set(key, abortController);
 		let originatingLoadId = incrementingLoadId;
-		let results = await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, matches, match, hydrationRouteProperties, scopedContext), scopedContext, key);
+		let results = await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, matches, match, hydrationRouteProperties, scopedContext), scopedContext, key, "fetcher");
 		let result = results[match.route.id];
 		if (!result) {
 			for (let match of matches) if (results[match.route.id]) {
@@ -987,7 +1087,7 @@ function createRouter(init) {
 			return;
 		} else {
 			fetchRedirectIds.add(key);
-			await startRedirectNavigation(fetchRequest, result, false, { preventScrollReset });
+			await startRedirectNavigation(fetchRequest, result, false, "fetcher", { preventScrollReset });
 			return;
 		}
 		if (isErrorResult(result)) {
@@ -1015,7 +1115,7 @@ function createRouter(init) {
 	* actually touch history until we've processed redirects, so we just use
 	* the history action from the original navigation (PUSH or REPLACE).
 	*/
-	async function startRedirectNavigation(request, redirect, isNavigation, { submission, fetcherSubmission, preventScrollReset, replace } = {}) {
+	async function startRedirectNavigation(request, redirect, isNavigation, dataStrategyInitiator, { submission, fetcherSubmission, preventScrollReset, replace } = {}) {
 		if (!isNavigation) {
 			pendingPopstateNavigationDfd?.resolve();
 			pendingPopstateNavigationDfd = null;
@@ -1052,20 +1152,22 @@ function createRouter(init) {
 				formAction: location
 			},
 			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
-			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
+			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0,
+			dataStrategyInitiator
 		});
 		else await startNavigation(redirectNavigationType, redirectLocation, {
 			overrideNavigation: getLoadingNavigation(redirectLocation, [], redirectNavigationType, submission),
 			fetcherSubmission,
 			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
-			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
+			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0,
+			dataStrategyInitiator
 		});
 	}
-	async function callDataStrategy(request, path, matches, scopedContext, fetcherKey) {
+	async function callDataStrategy(request, path, matches, scopedContext, fetcherKey, initiator, navigationType = null) {
 		let results;
 		let dataResults = {};
 		try {
-			results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, false);
+			results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, initiator, scopedContext, false, navigationType);
 		} catch (e) {
 			matches.filter((m) => m.shouldLoad).forEach((m) => {
 				dataResults[m.route.id] = {
@@ -1092,11 +1194,11 @@ function createRouter(init) {
 		} else dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
 		return dataResults;
 	}
-	async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext) {
-		let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null);
+	async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext, initiator, navigationType = null) {
+		let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null, initiator, navigationType);
 		let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async (f) => {
 			if (f.matches && f.match && f.request && f.controller) {
-				let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key))[f.match.route.id];
+				let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key, initiator, navigationType))[f.match.route.id];
 				return { [f.key]: result };
 			} else return Promise.resolve({ [f.key]: {
 				type: "error",
@@ -1110,7 +1212,8 @@ function createRouter(init) {
 	}
 	function interruptActiveLoads() {
 		isRevalidationRequired = true;
-		fetchLoadMatches.forEach((_, key) => {
+		fetchLoadMatches.forEach((loadMatch, key) => {
+			if (future.unstable_customRouteDiscovery && loadMatch.isDiscovering) return;
 			if (fetchControllers.has(key)) cancelledFetcherLoads.add(key);
 			abortFetcher(key);
 		});
@@ -1136,6 +1239,8 @@ function createRouter(init) {
 	}
 	function resetFetcher(key, opts) {
 		abortFetcher(key, opts?.reason);
+		fetchLoadMatches.delete(key);
+		cancelledFetcherLoads.delete(key);
 		updateFetcherState(key, getDoneFetcher(null));
 	}
 	function deleteFetcher(fetchers, key) {
@@ -1308,6 +1413,10 @@ function createRouter(init) {
 					}
 				});
 			} catch (e) {
+				if (future.unstable_customRouteDiscovery) {
+					if (signal.aborted) return { type: "aborted" };
+					if (e instanceof DiscoveryCancelledError) return { type: "cancelled" };
+				}
 				return {
 					type: "error",
 					error: e,
@@ -1768,7 +1877,7 @@ function createStaticHandler(routes, opts) {
 		};
 	}
 	async function callDataStrategy(request, location, matches, isRouteRequest, requestContext, dataStrategy) {
-		let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, requestContext, true);
+		let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, "static", requestContext, true);
 		let dataResults = {};
 		await Promise.all(matches.map(async (match) => {
 			if (!(match.route.id in results)) return;
@@ -1787,6 +1896,9 @@ function createStaticHandler(routes, opts) {
 	}
 	return {
 		dataRoutes,
+		get _matchCost() {
+			return dataRouteMatcher instanceof V6RegExMatcher ? dataRouteMatcher.matchCost : void 0;
+		},
 		match,
 		query,
 		queryRoute
@@ -2172,6 +2284,9 @@ const loadLazyRouteProperty = ({ key, route, manifest, mapRouteProperties }) =>
 		}
 	})();
 	cache[key] = propertyPromise;
+	propertyPromise.catch(() => {
+		if (cache[key] === propertyPromise) delete cache[key];
+	});
 	return propertyPromise;
 };
 const lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
@@ -2213,7 +2328,9 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties, lazyRoutePrope
 			});
 		})();
 		lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-		lazyRoutePromise.catch(() => {});
+		lazyRoutePromise.catch(() => {
+			if (lazyRouteFunctionCache.get(routeToUpdate) === lazyRoutePromise) lazyRouteFunctionCache.delete(routeToUpdate);
+		});
 		return {
 			lazyRoutePromise,
 			lazyHandlerPromise: lazyRoutePromise
@@ -2409,7 +2526,7 @@ function getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, p
 		return getDataStrategyMatch(mapRouteProperties, manifest, request, path, getRoutePattern(matches), match, lazyRoutePropertiesToSkip, scopedContext, true, shouldRevalidateArgs);
 	});
 }
-async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, isStaticHandler) {
+async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, initiator, scopedContext, isStaticHandler, navigationType = null) {
 	if (matches.some((m) => m._lazyPromises?.middleware)) await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
 	let dataStrategyArgs = {
 		request,
@@ -2417,7 +2534,9 @@ async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fe
 		pattern: getRoutePattern(matches),
 		params: matches[0].params,
 		context: scopedContext,
-		matches
+		matches,
+		unstable_initiator: initiator,
+		unstable_navigationType: initiator === "navigation" ? navigationType : null
 	};
 	let runClientMiddleware = isStaticHandler ? () => {
 		throw new Error("You cannot call `runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`");
@@ -2503,10 +2622,13 @@ async function callLoaderOrAction({ request, path, pattern, match, lazyHandlerPr
 					pathname,
 					routeId: match.route.id
 				});
-			} else return {
-				type: "data",
-				result: void 0
-			};
+			} else {
+				await lazyRoutePromise;
+				return {
+					type: "data",
+					result: void 0
+				};
+			}
 		}
 		else if (!handler) {
 			let url = new URL(request.url);
@@ -2701,12 +2823,12 @@ function processRouteLoaderData(matches, results, pendingActionResult, isStaticH
 function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers) {
 	let { loaderData, errors } = processRouteLoaderData(matches, results, pendingActionResult);
 	revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
-		let { key, match, controller } = rf;
+		let { key, routeId, controller } = rf;
 		if (controller && controller.signal.aborted) return;
 		let result = fetcherResults[key];
 		invariant(result, "Did not find corresponding fetcher result");
 		if (isErrorResult(result)) {
-			let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);
+			let boundaryMatch = findNearestBoundary(state.matches, routeId);
 			if (!(errors && errors[boundaryMatch.route.id])) errors = {
 				...errors,
 				[boundaryMatch.route.id]: result.error
@@ -3014,4 +3136,4 @@ function createDeferred() {
 	};
 }
 //#endregion
-export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, createDataRouteMatcher, createRouter, createStaticHandler, getStaticContextFromError, hasInvalidProtocol, isDataWithResponseInit, isMutationMethod, isRedirectResponse, isRedirectStatusCode, isResponse };
+export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, clientErrors, createDataRouteMatcher, createRouter, createStaticHandler, getStaticContextFromError, hasInvalidProtocol, isDataWithResponseInit, isMutationMethod, isRedirectResponse, isRedirectStatusCode, isResponse };