react-router 8.3.1 → 8.5.0

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

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.1
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -10,8 +10,10 @@
  */
 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, flattenAndRankRoutes, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, matchRoutesImpl, 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";
 import { validateNavigationTarget } from "./navigation.js";
 //#region lib/router/router.ts
 const validMutationMethodsArr = [
@@ -61,18 +63,26 @@ const IDLE_BLOCKER = {
 };
 const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
 const ResetLoaderDataSymbol = Symbol("ResetLoaderData");
+function createDataRouteMatcher(future, basename) {
+	if (future.unstable_routePatternMatching) {
+		let RoutePatternMatcher = getRoutePatternMatcher();
+		invariant(RoutePatternMatcher, "You must call unstable_preloadRoutePattern() from \"react-router/route-pattern\" before enabling future.unstable_routePatternMatching.");
+		return new RoutePatternMatcher(basename);
+	}
+	return new V6RegExMatcher(basename);
+}
 /**
 * Encapsulates the stable and in-flight route trees together with their
 * pre-computed branch caches so the structures always stay in sync.
 */
 var DataRoutes = class {
 	#routes;
-	#branches;
 	#hmrRoutes;
-	#hmrBranches;
-	constructor(routes) {
+	#matcher;
+	constructor(routes, matcher) {
 		this.#routes = routes;
-		this.#branches = flattenAndRankRoutes(routes);
+		this.#matcher = matcher;
+		this.#matcher.update(routes);
 	}
 	/** The stable route tree */
 	get stableRoutes() {
@@ -82,33 +92,29 @@ var DataRoutes = class {
 	get activeRoutes() {
 		return this.#hmrRoutes ?? this.#routes;
 	}
-	/** Pre-computed branches */
-	get branches() {
-		return this.#hmrBranches ?? this.#branches;
-	}
 	get hasHMRRoutes() {
 		return this.#hmrRoutes != null;
 	}
 	/** Replace the stable route tree and recompute its branches */
 	setRoutes(routes) {
 		this.#routes = routes;
-		this.#branches = flattenAndRankRoutes(routes);
+		if (!this.#hmrRoutes) this.#matcher.update(routes);
 	}
 	/** Set a new in-flight route tree and recompute its branches */
 	setHmrRoutes(routes) {
 		this.#hmrRoutes = routes;
-		this.#hmrBranches = flattenAndRankRoutes(routes);
+		this.#matcher.update(routes);
 	}
 	/** Commit in-flight routes/branches to the stable slot and clear in-flight */
 	commitHmrRoutes() {
 		if (this.#hmrRoutes) {
 			this.#routes = this.#hmrRoutes;
-			this.#branches = this.#hmrBranches;
 			this.#hmrRoutes = void 0;
-			this.#hmrBranches = void 0;
+			this.#matcher.update(this.#routes);
 		}
 	}
 };
+const clientErrors = /* @__PURE__ */ new WeakMap();
 /**
 * Create a router and listen to history POP navigations
 */
@@ -128,20 +134,20 @@ function createRouter(init) {
 			};
 		};
 	}
-	let manifest = {};
-	let dataRoutes = new DataRoutes(convertRoutesToDataRoutes(init.routes, mapRouteProperties, void 0, manifest));
+	let future = { ...init.future };
 	let basename = init.basename || "/";
 	if (!basename.startsWith("/")) basename = `/${basename}`;
+	let dataRouteMatcher = createDataRouteMatcher(future, basename);
+	let manifest = {};
+	let dataRoutes = new DataRoutes(convertRoutesToDataRoutes(init.routes, mapRouteProperties, void 0, manifest), dataRouteMatcher);
 	let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
-	let future = { ...init.future };
 	let unlistenHistory = null;
 	let subscribers = /* @__PURE__ */ new Set();
-	let bufferedInitialStateUpdate = null;
 	let savedScrollPositions = null;
 	let getScrollRestorationKey = null;
 	let getScrollPosition = null;
 	let initialScrollRestored = init.hydrationData != null;
-	let initialMatches = matchRoutesImpl(dataRoutes.activeRoutes, init.history.location, basename, false, dataRoutes.branches);
+	let initialMatches = dataRouteMatcher.match(init.history.location);
 	let initialMatchesIsFOW = false;
 	let initialErrors = null;
 	let initialized;
@@ -155,13 +161,13 @@ function createRouter(init) {
 		initialErrors = { [route.id]: error };
 	} else {
 		if (initialMatches && !init.hydrationData) {
-			if (checkFogOfWar(initialMatches, dataRoutes.activeRoutes, init.history.location.pathname).active) initialMatches = null;
+			if (checkFogOfWar(initialMatches, init.history.location.pathname).active) initialMatches = null;
 		}
 		if (!initialMatches) {
 			initialized = false;
 			renderFallback = !initialized;
 			initialMatches = [];
-			let fogOfWar = checkFogOfWar(null, dataRoutes.activeRoutes, init.history.location.pathname);
+			let fogOfWar = checkFogOfWar(null, init.history.location.pathname);
 			if (fogOfWar.active && fogOfWar.matches) {
 				initialMatchesIsFOW = true;
 				initialMatches = fogOfWar.matches;
@@ -207,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;
@@ -267,6 +275,7 @@ function createRouter(init) {
 				pendingPopstateNavigationDfd = null;
 				return;
 			}
+			if (future.unstable_customRouteDiscovery) pendingPopstateDelta += delta || 0;
 			return startNavigation(historyAction, location);
 		});
 		if (isBrowser) {
@@ -288,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;
@@ -323,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
 		}));
@@ -352,7 +357,7 @@ function createRouter(init) {
 		if (isUninterruptedRevalidation) {} else if (pendingAction === "POP") {} else if (pendingAction === "PUSH") init.history.push(location, location.state);
 		else if (pendingAction === "REPLACE") init.history.replace(location, location.state);
 		let viewTransitionOpts;
-		if (pendingAction === "POP") {
+		if (pendingAction === "POP" && !isUninterruptedRevalidation && location !== state.location) {
 			let priorPaths = appliedViewTransitions.get(state.location.pathname);
 			if (priorPaths && priorPaths.has(location.pathname)) viewTransitionOpts = {
 				currentLocation: state.location,
@@ -391,17 +396,22 @@ function createRouter(init) {
 			viewTransitionOpts,
 			flushSync: flushSync === true
 		});
+		resetPendingNavigation();
+		pendingPopstateNavigationDfd?.resolve();
+		pendingPopstateNavigationDfd = null;
+		pendingRevalidationDfd?.resolve();
+		pendingRevalidationDfd = null;
+	}
+	function resetPendingNavigation() {
+		pendingPopstateDelta = 0;
 		pendingAction = "POP";
 		pendingPreventScrollReset = false;
 		pendingViewTransitionEnabled = false;
 		isUninterruptedRevalidation = false;
 		isRevalidationRequired = false;
-		pendingPopstateNavigationDfd?.resolve();
-		pendingPopstateNavigationDfd = null;
-		pendingRevalidationDfd?.resolve();
-		pendingRevalidationDfd = null;
 	}
 	async function navigate(to, opts) {
+		if (pendingDiscoveryCancellation) await pendingDiscoveryCancellation;
 		pendingPopstateNavigationDfd?.resolve();
 		pendingPopstateNavigationDfd = null;
 		if (typeof to === "number") {
@@ -478,22 +488,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;
@@ -501,14 +517,13 @@ function createRouter(init) {
 		saveScrollPosition(state.location, state.matches);
 		pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
 		pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
-		let routesToUse = dataRoutes.activeRoutes;
-		let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? state.matches : matchRoutesImpl(routesToUse, location, basename, false, dataRoutes.branches);
+		let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? state.matches : dataRouteMatcher.match(location);
 		let flushSync = (opts && opts.flushSync) === true;
 		if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
 			completeNavigation(location, { matches }, { flushSync });
 			return;
 		}
-		let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+		let fogOfWar = checkFogOfWar(matches, location.pathname);
 		if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
 		if (opts?.instrumentationNavigateMetaReceiver) {
 			let meta = getInstrumentationNavigateMeta(init.history, location, matches);
@@ -530,6 +545,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, {
@@ -537,7 +553,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
 			});
@@ -561,7 +577,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, {
@@ -572,13 +588,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 {
@@ -608,6 +668,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 = {
@@ -619,7 +680,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]) {
@@ -633,7 +694,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
 			});
@@ -656,7 +717,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;
@@ -669,8 +730,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 {
@@ -692,10 +756,12 @@ function createRouter(init) {
 					loaderData: {},
 					errors: { [route.id]: error }
 				};
-			} else matches = discoverResult.matches;
+			} else {
+				matches = discoverResult.matches;
+				if (initialHydration && !request.signal.aborted) updateState({ matches });
+			}
 		}
-		let routesToUse = dataRoutes.activeRoutes;
-		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, init.history, state, matches, activeSubmission, location, initialHydration ? [] : hydrationRouteProperties, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, init.patchRoutesOnNavigation != null, dataRoutes.branches, pendingActionResult, callSiteDefaultShouldRevalidate);
+		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;
 		if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.middleware && m.route.middleware.length > 0) && revalidatingFetchers.length === 0) {
 			let workingFetchers = new Map(state.fetchers);
@@ -725,27 +791,31 @@ function createRouter(init) {
 		});
 		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.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));
 		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;
@@ -771,13 +841,13 @@ 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);
-		let routesToUse = dataRoutes.activeRoutes;
 		let normalizedPath = normalizeTo(state.location, state.matches, basename, href, routeId, opts?.relative);
-		let matches = matchRoutesImpl(routesToUse, normalizedPath, basename, false, dataRoutes.branches);
-		let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+		let matches = dataRouteMatcher.match(normalizedPath);
+		let fogOfWar = checkFogOfWar(matches, normalizedPath);
 		if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
 		if (instrumentationResultMetaReceiver) instrumentationResultMetaReceiver(getInstrumentationNavigateMeta(init.history, normalizedPath, matches));
 		if (!matches) {
@@ -795,22 +865,31 @@ function createRouter(init) {
 			await handleFetcherAction(key, routeId, path, matches, scopedContext, fogOfWar.active, flushSync, preventScrollReset, submission, opts && opts.defaultShouldRevalidate);
 			return;
 		}
-		fetchLoadMatches.set(key, {
+		let loadMatch = {
 			routeId,
-			path
-		});
-		await handleFetcherLoader(key, routeId, path, matches, scopedContext, fogOfWar.active, flushSync, preventScrollReset, submission);
+			path,
+			isDiscovering: fogOfWar.active
+		};
+		fetchLoadMatches.set(key, loadMatch);
+		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) {
@@ -827,10 +906,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]) {
@@ -856,7 +936,7 @@ function createRouter(init) {
 				} else {
 					fetchRedirectIds.add(key);
 					updateFetcherState(key, getLoadingFetcher(submission));
-					return startRedirectNavigation(fetchRequest, actionResult, false, {
+					return startRedirectNavigation(fetchRequest, actionResult, false, "fetcher", {
 						fetcherSubmission: submission,
 						preventScrollReset
 					});
@@ -869,12 +949,11 @@ function createRouter(init) {
 		}
 		let nextLocation = state.navigation.location || state.location;
 		let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
-		let routesToUse = dataRoutes.activeRoutes;
-		let matches = state.navigation.state !== "idle" ? matchRoutesImpl(routesToUse, state.navigation.location, basename, false, dataRoutes.branches) : state.matches;
+		let matches = state.navigation.state !== "idle" ? dataRouteMatcher.match(state.navigation.location) : state.matches;
 		invariant(matches, "Didn't find any matches after fetcher action");
 		let loadId = ++incrementingLoadId;
 		fetchReloadIds.set(key, loadId);
-		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(revalidationRequest, scopedContext, mapRouteProperties, manifest, init.history, state, matches, submission, nextLocation, hydrationRouteProperties, false, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, init.patchRoutesOnNavigation != null, dataRoutes.branches, [match.route.id, actionResult], callSiteDefaultShouldRevalidate);
+		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(revalidationRequest, scopedContext, mapRouteProperties, manifest, init.history, state, matches, submission, nextLocation, hydrationRouteProperties, false, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, [match.route.id, actionResult], callSiteDefaultShouldRevalidate);
 		let loadFetcher = getLoadingFetcher(submission, actionResult.data);
 		let workingFetchers = new Map(state.fetchers);
 		workingFetchers.set(key, loadFetcher);
@@ -889,7 +968,7 @@ function createRouter(init) {
 		updateState({ fetchers: workingFetchers });
 		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => 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;
@@ -911,13 +990,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));
@@ -941,26 +1020,36 @@ function createRouter(init) {
 			isRevalidationRequired = false;
 		}
 	}
-	async function handleFetcherLoader(key, routeId, path, matches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
+	async function handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission) {
+		let { routeId, path } = loadMatch;
 		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 (isFogOfWar) {
+		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) {
 				setFetcherError(key, routeId, getInternalRouterError(404, { pathname: path }), { flushSync });
 				return;
-			} else matches = discoverResult.matches;
+			} else {
+				matches = discoverResult.matches;
+				loadMatch.isDiscovering = false;
+			}
 		}
 		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]) {
@@ -979,7 +1068,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)) {
@@ -1007,7 +1096,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;
@@ -1044,20 +1133,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] = {
@@ -1084,11 +1175,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",
@@ -1102,7 +1193,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);
 		});
@@ -1128,6 +1220,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) {
@@ -1264,16 +1358,15 @@ function createRouter(init) {
 		}
 		return null;
 	}
-	function checkFogOfWar(matches, routesToUse, pathname) {
+	function checkFogOfWar(matches, pathname) {
 		if (init.patchRoutesOnNavigation) {
-			let activeBranches = dataRoutes.branches;
 			if (!matches) return {
 				active: true,
-				matches: matchRoutesImpl(routesToUse, pathname, basename, true, activeBranches) || []
+				matches: dataRouteMatcher.match(pathname, true) || []
 			};
 			else if (Object.keys(matches[0].params).length > 0) return {
 				active: true,
-				matches: matchRoutesImpl(routesToUse, pathname, basename, true, activeBranches)
+				matches: dataRouteMatcher.match(pathname, true)
 			};
 		}
 		return {
@@ -1301,6 +1394,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,
@@ -1308,21 +1405,20 @@ function createRouter(init) {
 				};
 			}
 			if (signal.aborted) return { type: "aborted" };
-			let activeBranches = dataRoutes.branches;
-			let newMatches = matchRoutesImpl(dataRoutes.activeRoutes, pathname, basename, false, activeBranches);
+			let newMatches = dataRouteMatcher.match(pathname);
 			let newPartialMatches = null;
 			if (newMatches) if (Object.keys(newMatches[0].params).length === 0) return {
 				type: "success",
 				matches: newMatches
 			};
 			else {
-				newPartialMatches = matchRoutesImpl(dataRoutes.activeRoutes, pathname, basename, true, activeBranches);
+				newPartialMatches = dataRouteMatcher.match(pathname, true);
 				if (!(newPartialMatches && partialMatches.length < newPartialMatches.length && compareMatches(partialMatches, newPartialMatches.slice(0, partialMatches.length)))) return {
 					type: "success",
 					matches: newMatches
 				};
 			}
-			if (!newPartialMatches) newPartialMatches = matchRoutesImpl(dataRoutes.activeRoutes, pathname, basename, true, activeBranches);
+			if (!newPartialMatches) newPartialMatches = dataRouteMatcher.match(pathname, true);
 			if (!newPartialMatches || compareMatches(partialMatches, newPartialMatches)) return {
 				type: "success",
 				matches: null
@@ -1354,8 +1450,8 @@ function createRouter(init) {
 		get routes() {
 			return dataRoutes.stableRoutes;
 		},
-		get branches() {
-			return dataRoutes.branches;
+		match(locationArg) {
+			return dataRouteMatcher.match(locationArg);
 		},
 		get manifest() {
 			return manifest;
@@ -1424,7 +1520,7 @@ function createStaticHandler(routes, opts) {
 	let basename = (opts ? opts.basename : null) || "/";
 	let _mapRouteProperties = opts?.mapRouteProperties;
 	let mapRouteProperties = _mapRouteProperties ? _mapRouteProperties : () => ({});
-	({ ...opts?.future });
+	let dataRouteMatcher = createDataRouteMatcher({ ...opts?.future }, basename);
 	if (opts?.instrumentations) {
 		let instrumentations = opts.instrumentations;
 		mapRouteProperties = (route) => {
@@ -1435,7 +1531,8 @@ function createStaticHandler(routes, opts) {
 		};
 	}
 	let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, void 0, manifest);
-	let routeBranches = flattenAndRankRoutes(dataRoutes);
+	dataRouteMatcher.update(dataRoutes);
+	let match = (locationArg) => dataRouteMatcher.match(locationArg);
 	/**
 	* The query() method is intended for document requests, in which we want to
 	* call an optional action and potentially multiple loaders for all nested
@@ -1466,7 +1563,7 @@ function createStaticHandler(routes, opts) {
 		let normalizePathImpl = normalizePath || defaultNormalizePath;
 		let method = request.method;
 		let location = createLocation("", normalizePathImpl(request), null, "default");
-		let matches = matchRoutesImpl(dataRoutes, location, basename, false, routeBranches);
+		let matches = dataRouteMatcher.match(location);
 		requestContext = requestContext != null ? requestContext : new RouterContextProvider();
 		if (!isValidMethod(method) && method !== "HEAD") {
 			let error = getInternalRouterError(405, { method });
@@ -1480,7 +1577,8 @@ function createStaticHandler(routes, opts) {
 				errors: { [route.id]: error },
 				statusCode: error.status,
 				loaderHeaders: {},
-				actionHeaders: {}
+				actionHeaders: {},
+				_match: match
 			};
 			return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
 		} else if (!matches) {
@@ -1495,7 +1593,8 @@ function createStaticHandler(routes, opts) {
 				errors: { [route.id]: error },
 				statusCode: error.status,
 				loaderHeaders: {},
-				actionHeaders: {}
+				actionHeaders: {},
+				_match: match
 			};
 			return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
 		}
@@ -1518,7 +1617,8 @@ function createStaticHandler(routes, opts) {
 						renderedStaticContext = {
 							location,
 							basename,
-							...result
+							...result,
+							_match: match
 						};
 						return renderedStaticContext;
 					});
@@ -1544,7 +1644,8 @@ function createStaticHandler(routes, opts) {
 							errors: { [skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, matches.find((m) => m.route.id === routeId || m.route.loader)?.route.id || routeId).route.id]: error },
 							statusCode: isRouteErrorResponse(error) ? error.status : 500,
 							actionHeaders: {},
-							loaderHeaders: {}
+							loaderHeaders: {},
+							_match: match
 						};
 						return generateMiddlewareResponse(() => Promise.resolve(staticContext));
 					}
@@ -1561,7 +1662,8 @@ function createStaticHandler(routes, opts) {
 		return {
 			location,
 			basename,
-			...result
+			...result,
+			_match: match
 		};
 	}
 	/**
@@ -1594,7 +1696,7 @@ function createStaticHandler(routes, opts) {
 		let normalizePathImpl = normalizePath || defaultNormalizePath;
 		let method = request.method;
 		let location = createLocation("", normalizePathImpl(request), null, "default");
-		let matches = matchRoutesImpl(dataRoutes, location, basename, false, routeBranches);
+		let matches = dataRouteMatcher.match(location);
 		requestContext = requestContext != null ? requestContext : new RouterContextProvider();
 		if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") throw getInternalRouterError(405, { method });
 		else if (!matches) throw getInternalRouterError(404, { pathname: location.pathname });
@@ -1756,7 +1858,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;
@@ -1775,7 +1877,7 @@ function createStaticHandler(routes, opts) {
 	}
 	return {
 		dataRoutes,
-		_internalRouteBranches: routeBranches,
+		match,
 		query,
 		queryRoute
 	};
@@ -1936,7 +2038,7 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
 		submission
 	};
 }
-function getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, hasPatchRoutesOnNavigation, branches, pendingActionResult, callSiteDefaultShouldRevalidate) {
+function getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, pendingActionResult, callSiteDefaultShouldRevalidate) {
 	let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : void 0;
 	let currentUrl = history.createURL(state.location);
 	let nextUrl = history.createURL(location);
@@ -1986,12 +2088,11 @@ function getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest,
 	});
 	let revalidatingFetchers = [];
 	fetchLoadMatches.forEach((f, key) => {
-		if (initialHydration || !matches.some((m) => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key)) return;
+		if (initialHydration || !matches.some((m) => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key) || f.isDiscovering) return;
 		let fetcher = state.fetchers.get(key);
 		let isMidInitialLoad = fetcher && fetcher.state !== "idle" && fetcher.data === void 0;
-		let fetcherMatches = matchRoutesImpl(routesToUse, f.path, basename ?? "/", false, branches);
+		let fetcherMatches = dataRouteMatcher.match(f.path);
 		if (!fetcherMatches) {
-			if (hasPatchRoutesOnNavigation && isMidInitialLoad) return;
 			revalidatingFetchers.push({
 				key,
 				routeId: f.routeId,
@@ -2398,7 +2499,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,
@@ -2406,7 +2507,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`");
@@ -2717,12 +2820,16 @@ function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
 		merged[k] = v;
 		return merged;
 	}, {});
+	let preservedCount = 0;
 	for (let match of matches) {
 		let id = match.route.id;
-		if (!newLoaderData.hasOwnProperty(id) && loaderData.hasOwnProperty(id) && match.route.loader) mergedLoaderData[id] = loaderData[id];
+		if (!newLoaderData.hasOwnProperty(id) && loaderData.hasOwnProperty(id) && match.route.loader) {
+			mergedLoaderData[id] = loaderData[id];
+			preservedCount++;
+		}
 		if (errors && errors.hasOwnProperty(id)) break;
 	}
-	return mergedLoaderData;
+	return Object.keys(newLoaderData).length === 0 && preservedCount === Object.keys(loaderData).length ? loaderData : mergedLoaderData;
 }
 function getActionDataForCommit(pendingActionResult) {
 	if (!pendingActionResult) return {};
@@ -2999,4 +3106,4 @@ function createDeferred() {
 	};
 }
 //#endregion
-export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, 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 };