react-router 7.5.0 → 7.5.1

package/dist/development/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.5.0
+ * react-router v7.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -91,6 +91,7 @@ __export(react_router_exports, {
   UNSAFE_deserializeErrors: () => deserializeErrors2,
   UNSAFE_getPatchRoutesOnNavigationFunction: () => getPatchRoutesOnNavigationFunction,
   UNSAFE_getSingleFetchDataStrategy: () => getSingleFetchDataStrategy,
+  UNSAFE_hydrationRouteProperties: () => hydrationRouteProperties,
   UNSAFE_invariant: () => invariant,
   UNSAFE_mapRouteProperties: () => mapRouteProperties,
   UNSAFE_shouldHydrateRouteLoader: () => shouldHydrateRouteLoader,
@@ -1097,6 +1098,7 @@ function createRouter(init) {
     init.routes.length > 0,
     "You must provide a non-empty routes array to createRouter"
   );
+  let hydrationRouteProperties2 = init.hydrationRouteProperties || [];
   let mapRouteProperties2 = init.mapRouteProperties || defaultMapRouteProperties;
   let manifest = {};
   let dataRoutes = convertRoutesToDataRoutes(
@@ -1569,6 +1571,7 @@ function createRouter(init) {
         matches,
         scopedContext,
         fogOfWar.active,
+        opts && opts.initialHydration === true,
         { replace: opts.replace, flushSync }
       );
       if (actionResult.shortCircuited) {
@@ -1629,7 +1632,7 @@ function createRouter(init) {
       errors
     });
   }
-  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, opts = {}) {
+  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, initialHydration, opts = {}) {
     interruptActiveLoads();
     let navigation = getSubmittingNavigation(location, submission);
     updateState({ navigation }, { flushSync: opts.flushSync === true });
@@ -1683,11 +1686,18 @@ function createRouter(init) {
         })
       };
     } else {
-      let results = await callDataStrategy(
-        "action",
+      let dsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
         request,
-        [actionMatch],
         matches,
+        actionMatch,
+        initialHydration ? [] : hydrationRouteProperties2,
+        scopedContext
+      );
+      let results = await callDataStrategy(
+        request,
+        dsMatches,
         scopedContext,
         null
       );
@@ -1786,12 +1796,17 @@ function createRouter(init) {
       }
     }
     let routesToUse = inFlightDataRoutes || dataRoutes;
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let { dsMatches, revalidatingFetchers } = getMatchesToLoad(
+      request,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       activeSubmission,
       location,
+      initialHydration ? [] : hydrationRouteProperties2,
       initialHydration === true,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -1803,7 +1818,7 @@ function createRouter(init) {
       pendingActionResult
     );
     pendingNavigationLoadId = ++incrementingLoadId;
-    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+    if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && revalidatingFetchers.length === 0) {
       let updatedFetchers2 = markFetchRedirectsDone();
       completeNavigation(
         location,
@@ -1847,8 +1862,7 @@ function createRouter(init) {
       );
     }
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
       request,
       scopedContext
@@ -2051,11 +2065,18 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let actionResults = await callDataStrategy(
-      "action",
+    let fetchMatches = getTargetedDataStrategyMatches(
+      mapRouteProperties2,
+      manifest,
       fetchRequest,
-      [match],
       requestMatches,
+      match,
+      hydrationRouteProperties2,
+      scopedContext
+    );
+    let actionResults = await callDataStrategy(
+      fetchRequest,
+      fetchMatches,
       scopedContext,
       key
     );
@@ -2104,12 +2125,17 @@ function createRouter(init) {
     fetchReloadIds.set(key, loadId);
     let loadFetcher = getLoadingFetcher(submission, actionResult.data);
     state.fetchers.set(key, loadFetcher);
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let { dsMatches, revalidatingFetchers } = getMatchesToLoad(
+      revalidationRequest,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       submission,
       nextLocation,
+      hydrationRouteProperties2,
       false,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -2140,8 +2166,7 @@ function createRouter(init) {
       abortPendingFetchRevalidations
     );
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
       revalidationRequest,
       scopedContext
@@ -2254,11 +2279,18 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let results = await callDataStrategy(
-      "loader",
+    let dsMatches = getTargetedDataStrategyMatches(
+      mapRouteProperties2,
+      manifest,
       fetchRequest,
-      [match],
       matches,
+      match,
+      hydrationRouteProperties2,
+      scopedContext
+    );
+    let results = await callDataStrategy(
+      fetchRequest,
+      dsMatches,
       scopedContext,
       key
     );
@@ -2361,23 +2393,20 @@ function createRouter(init) {
       });
     }
   }
-  async function callDataStrategy(type, request, matchesToLoad, matches, scopedContext, fetcherKey) {
+  async function callDataStrategy(request, matches, scopedContext, fetcherKey) {
     let results;
     let dataResults = {};
     try {
       results = await callDataStrategyImpl(
         dataStrategyImpl,
-        type,
         request,
-        matchesToLoad,
         matches,
         fetcherKey,
-        manifest,
-        mapRouteProperties2,
-        scopedContext
+        scopedContext,
+        false
       );
     } catch (e) {
-      matchesToLoad.forEach((m) => {
+      matches.filter((m) => m.shouldLoad).forEach((m) => {
         dataResults[m.route.id] = {
           type: "error" /* error */,
           error: e
@@ -2406,22 +2435,18 @@ function createRouter(init) {
     }
     return dataResults;
   }
-  async function callLoadersAndMaybeResolveData(matches, matchesToLoad, fetchersToLoad, request, scopedContext) {
+  async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, scopedContext) {
     let loaderResultsPromise = callDataStrategy(
-      "loader",
       request,
-      matchesToLoad,
       matches,
       scopedContext,
       null
     );
     let fetcherResultsPromise = Promise.all(
       fetchersToLoad.map(async (f) => {
-        if (f.matches && f.match && f.controller) {
+        if (f.matches && f.match && f.request && f.controller) {
           let results = await callDataStrategy(
-            "loader",
-            createClientSideRequest(init.history, f.path, f.controller.signal),
-            [f.match],
+            f.request,
             f.matches,
             scopedContext,
             f.key
@@ -3116,11 +3141,18 @@ function createStaticHandler(routes, opts) {
         error
       };
     } else {
-      let results = await callDataStrategy(
-        "action",
+      let dsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
         request,
-        [actionMatch],
         matches,
+        actionMatch,
+        [],
+        requestContext
+      );
+      let results = await callDataStrategy(
+        request,
+        dsMatches,
         isRouteRequest,
         requestContext,
         dataStrategy
@@ -3238,18 +3270,49 @@ function createStaticHandler(routes, opts) {
         routeId: routeMatch?.route.id
       });
     }
-    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
-    let matchesToLoad = requestMatches.filter(
-      (m) => (m.route.loader || m.route.lazy) && (!filterMatchesToLoad || filterMatchesToLoad(m))
-    );
-    if (matchesToLoad.length === 0) {
+    let dsMatches;
+    if (routeMatch) {
+      dsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
+        request,
+        matches,
+        routeMatch,
+        [],
+        requestContext
+      );
+    } else {
+      let maxIdx = pendingActionResult && isErrorResult(pendingActionResult[1]) ? (
+        // Up to but not including the boundary
+        matches.findIndex((m) => m.route.id === pendingActionResult[0]) - 1
+      ) : void 0;
+      dsMatches = matches.map((match, index) => {
+        if (maxIdx != null && index > maxIdx) {
+          return getDataStrategyMatch(
+            mapRouteProperties2,
+            manifest,
+            request,
+            match,
+            [],
+            requestContext,
+            false
+          );
+        }
+        return getDataStrategyMatch(
+          mapRouteProperties2,
+          manifest,
+          request,
+          match,
+          [],
+          requestContext,
+          (match.route.loader || match.route.lazy) != null && (!filterMatchesToLoad || filterMatchesToLoad(match))
+        );
+      });
+    }
+    if (!dataStrategy && !dsMatches.some((m) => m.shouldLoad)) {
       return {
         matches,
-        // Add a null for all matched routes for proper revalidation on the client
-        loaderData: matches.reduce(
-          (acc, m) => Object.assign(acc, { [m.route.id]: null }),
-          {}
-        ),
+        loaderData: {},
         errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
           [pendingActionResult[0]]: pendingActionResult[1].error
         } : null,
@@ -3258,10 +3321,8 @@ function createStaticHandler(routes, opts) {
       };
     }
     let results = await callDataStrategy(
-      "loader",
       request,
-      matchesToLoad,
-      matches,
+      dsMatches,
       isRouteRequest,
       requestContext,
       dataStrategy
@@ -3276,30 +3337,19 @@ function createStaticHandler(routes, opts) {
       true,
       skipLoaderErrorBubbling
     );
-    let executedLoaders = new Set(
-      matchesToLoad.map((match) => match.route.id)
-    );
-    matches.forEach((match) => {
-      if (!executedLoaders.has(match.route.id)) {
-        handlerContext.loaderData[match.route.id] = null;
-      }
-    });
     return {
       ...handlerContext,
       matches
     };
   }
-  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+  async function callDataStrategy(request, matches, isRouteRequest, requestContext, dataStrategy) {
     let results = await callDataStrategyImpl(
       dataStrategy || defaultDataStrategy,
-      type,
       request,
-      matchesToLoad,
       matches,
       null,
-      manifest,
-      mapRouteProperties2,
-      requestContext
+      requestContext,
+      true
     );
     let dataResults = {};
     await Promise.all(
@@ -3505,62 +3555,78 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
   parsedPath.search = `?${searchParams}`;
   return { path: createPath(parsedPath), submission };
 }
-function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary = false) {
-  let index = matches.findIndex((m) => m.route.id === boundaryId);
-  if (index >= 0) {
-    return matches.slice(0, includeBoundary ? index + 1 : index);
-  }
-  return matches;
-}
-function getMatchesToLoad(history, state, matches, submission, location, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+function getMatchesToLoad(request, scopedContext, mapRouteProperties2, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
   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);
-  let boundaryMatches = matches;
+  let maxIdx;
   if (initialHydration && state.errors) {
-    boundaryMatches = getLoaderMatchesUntilBoundary(
-      matches,
-      Object.keys(state.errors)[0],
-      true
-    );
+    let boundaryId = Object.keys(state.errors)[0];
+    maxIdx = matches.findIndex((m) => m.route.id === boundaryId);
   } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
-    boundaryMatches = getLoaderMatchesUntilBoundary(
-      matches,
-      pendingActionResult[0]
-    );
+    let boundaryId = pendingActionResult[0];
+    maxIdx = matches.findIndex((m) => m.route.id === boundaryId) - 1;
   }
   let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : void 0;
   let shouldSkipRevalidation = actionStatus && actionStatus >= 400;
-  let navigationMatches = boundaryMatches.filter((match, index) => {
+  let baseShouldRevalidateArgs = {
+    currentUrl,
+    currentParams: state.matches[0]?.params || {},
+    nextUrl,
+    nextParams: matches[0].params,
+    ...submission,
+    actionResult,
+    actionStatus
+  };
+  let dsMatches = matches.map((match, index) => {
     let { route } = match;
-    if (route.lazy) {
-      return true;
-    }
-    if (route.loader == null) {
-      return false;
-    }
-    if (initialHydration) {
-      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
+    let forceShouldLoad = null;
+    if (maxIdx != null && index > maxIdx) {
+      forceShouldLoad = false;
+    } else if (route.lazy) {
+      forceShouldLoad = true;
+    } else if (route.loader == null) {
+      forceShouldLoad = false;
+    } else if (initialHydration) {
+      forceShouldLoad = shouldLoadRouteOnHydration(
+        route,
+        state.loaderData,
+        state.errors
+      );
+    } else if (isNewLoader(state.loaderData, state.matches[index], match)) {
+      forceShouldLoad = true;
     }
-    if (isNewLoader(state.loaderData, state.matches[index], match)) {
-      return true;
+    if (forceShouldLoad !== null) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        forceShouldLoad
+      );
     }
-    let currentRouteMatch = state.matches[index];
-    let nextRouteMatch = match;
-    return shouldRevalidateLoader(match, {
-      currentUrl,
-      currentParams: currentRouteMatch.params,
-      nextUrl,
-      nextParams: nextRouteMatch.params,
-      ...submission,
-      actionResult,
-      actionStatus,
-      defaultShouldRevalidate: shouldSkipRevalidation ? false : (
-        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
-        isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
-        currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
-      )
-    });
+    let defaultShouldRevalidate = shouldSkipRevalidation ? false : (
+      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search || // Search params affect all loaders
+      currentUrl.search !== nextUrl.search || isNewRouteInstance(state.matches[index], match)
+    );
+    let shouldRevalidateArgs = {
+      ...baseShouldRevalidateArgs,
+      defaultShouldRevalidate
+    };
+    let shouldLoad = shouldRevalidateLoader(match, shouldRevalidateArgs);
+    return getDataStrategyMatch(
+      mapRouteProperties2,
+      manifest,
+      request,
+      match,
+      lazyRoutePropertiesToSkip,
+      scopedContext,
+      shouldLoad,
+      shouldRevalidateArgs
+    );
   });
   let revalidatingFetchers = [];
   fetchLoadMatches.forEach((f, key) => {
@@ -3575,44 +3641,77 @@ function getMatchesToLoad(history, state, matches, submission, location, initial
         path: f.path,
         matches: null,
         match: null,
+        request: null,
         controller: null
       });
       return;
     }
+    if (fetchRedirectIds.has(key)) {
+      return;
+    }
     let fetcher = state.fetchers.get(key);
     let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
-    let shouldRevalidate = false;
-    if (fetchRedirectIds.has(key)) {
-      shouldRevalidate = false;
-    } else if (cancelledFetcherLoads.has(key)) {
+    let fetchController = new AbortController();
+    let fetchRequest = createClientSideRequest(
+      history,
+      f.path,
+      fetchController.signal
+    );
+    let fetcherDsMatches = null;
+    if (cancelledFetcherLoads.has(key)) {
       cancelledFetcherLoads.delete(key);
-      shouldRevalidate = true;
+      fetcherDsMatches = getTargetedDataStrategyMatches(
+        mapRouteProperties2,
+        manifest,
+        fetchRequest,
+        fetcherMatches,
+        fetcherMatch,
+        lazyRoutePropertiesToSkip,
+        scopedContext
+      );
     } else if (fetcher && fetcher.state !== "idle" && fetcher.data === void 0) {
-      shouldRevalidate = isRevalidationRequired;
+      if (isRevalidationRequired) {
+        fetcherDsMatches = getTargetedDataStrategyMatches(
+          mapRouteProperties2,
+          manifest,
+          fetchRequest,
+          fetcherMatches,
+          fetcherMatch,
+          lazyRoutePropertiesToSkip,
+          scopedContext
+        );
+      }
     } else {
-      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {
-        currentUrl,
-        currentParams: state.matches[state.matches.length - 1].params,
-        nextUrl,
-        nextParams: matches[matches.length - 1].params,
-        ...submission,
-        actionResult,
-        actionStatus,
+      let shouldRevalidateArgs = {
+        ...baseShouldRevalidateArgs,
         defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
-      });
+      };
+      if (shouldRevalidateLoader(fetcherMatch, shouldRevalidateArgs)) {
+        fetcherDsMatches = getTargetedDataStrategyMatches(
+          mapRouteProperties2,
+          manifest,
+          fetchRequest,
+          fetcherMatches,
+          fetcherMatch,
+          lazyRoutePropertiesToSkip,
+          scopedContext,
+          shouldRevalidateArgs
+        );
+      }
     }
-    if (shouldRevalidate) {
+    if (fetcherDsMatches) {
       revalidatingFetchers.push({
         key,
         routeId: f.routeId,
         path: f.path,
-        matches: fetcherMatches,
+        matches: fetcherDsMatches,
         match: fetcherMatch,
-        controller: new AbortController()
+        request: fetchRequest,
+        controller: fetchController
       });
     }
   });
-  return [navigationMatches, revalidatingFetchers];
+  return { dsMatches, revalidatingFetchers };
 }
 function shouldLoadRouteOnHydration(route, loaderData, errors) {
   if (route.lazy) {
@@ -3758,7 +3857,7 @@ var loadLazyRouteProperty = ({
   return propertyPromise;
 };
 var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
-function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
+function loadLazyRoute(route, type, manifest, mapRouteProperties2, lazyRoutePropertiesToSkip) {
   let routeToUpdate = manifest[route.id];
   invariant(routeToUpdate, "No route found in manifest");
   if (!route.lazy) {
@@ -3816,6 +3915,8 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
       });
     })();
     lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    lazyRoutePromise2.catch(() => {
+    });
     return {
       lazyRoutePromise: lazyRoutePromise2,
       lazyHandlerPromise: lazyRoutePromise2
@@ -3825,6 +3926,9 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
   let lazyPropertyPromises = [];
   let lazyHandlerPromise = void 0;
   for (let key of lazyKeys) {
+    if (lazyRoutePropertiesToSkip && lazyRoutePropertiesToSkip.includes(key)) {
+      continue;
+    }
     let promise = loadLazyRouteProperty({
       key,
       route,
@@ -3838,7 +3942,11 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
       }
     }
   }
-  let lazyRoutePromise = Promise.all(lazyPropertyPromises).then(() => {
+  let lazyRoutePromise = lazyPropertyPromises.length > 0 ? Promise.all(lazyPropertyPromises).then(() => {
+  }) : void 0;
+  lazyRoutePromise?.catch(() => {
+  });
+  lazyHandlerPromise?.catch(() => {
   });
   return {
     lazyRoutePromise,
@@ -3976,59 +4084,145 @@ async function callRouteMiddleware(args, middlewares, propagateResult, middlewar
     throw error;
   }
 }
-async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext) {
-  let loadMiddlewarePromise = loadLazyMiddlewareForMatches(
-    matches,
+function getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip) {
+  let lazyMiddlewarePromise = loadLazyRouteProperty({
+    key: "unstable_middleware",
+    route: match.route,
     manifest,
-    mapRouteProperties2
+    mapRouteProperties: mapRouteProperties2
+  });
+  let lazyRoutePromises = loadLazyRoute(
+    match.route,
+    isMutationMethod(request.method) ? "action" : "loader",
+    manifest,
+    mapRouteProperties2,
+    lazyRoutePropertiesToSkip
   );
-  let lazyRoutePromises = matches.map(
-    (m) => loadLazyRoute(m.route, type, manifest, mapRouteProperties2)
+  return {
+    middleware: lazyMiddlewarePromise,
+    route: lazyRoutePromises.lazyRoutePromise,
+    handler: lazyRoutePromises.lazyHandlerPromise
+  };
+}
+function getDataStrategyMatch(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip, scopedContext, shouldLoad, unstable_shouldRevalidateArgs = null) {
+  let isUsingNewApi = false;
+  let _lazyPromises = getDataStrategyMatchLazyPromises(
+    mapRouteProperties2,
+    manifest,
+    request,
+    match,
+    lazyRoutePropertiesToSkip
   );
-  if (loadMiddlewarePromise) {
-    await loadMiddlewarePromise;
-  }
-  let dsMatches = matches.map((match, i) => {
-    let { lazyRoutePromise, lazyHandlerPromise } = lazyRoutePromises[i];
-    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
-    let resolve = async (handlerOverride) => {
-      if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
-        shouldLoad = true;
-      }
-      return shouldLoad ? callLoaderOrAction({
-        type,
-        request,
-        match,
-        lazyHandlerPromise,
-        lazyRoutePromise,
-        handlerOverride,
-        scopedContext
-      }) : Promise.resolve({ type: "data" /* data */, result: void 0 });
-    };
-    return {
-      ...match,
-      shouldLoad,
-      resolve
-    };
+  return {
+    ...match,
+    _lazyPromises,
+    shouldLoad,
+    unstable_shouldRevalidateArgs,
+    unstable_shouldCallHandler(defaultShouldRevalidate) {
+      isUsingNewApi = true;
+      if (!unstable_shouldRevalidateArgs) {
+        return shouldLoad;
+      }
+      if (typeof defaultShouldRevalidate === "boolean") {
+        return shouldRevalidateLoader(match, {
+          ...unstable_shouldRevalidateArgs,
+          defaultShouldRevalidate
+        });
+      }
+      return shouldRevalidateLoader(match, unstable_shouldRevalidateArgs);
+    },
+    resolve(handlerOverride) {
+      if (isUsingNewApi || shouldLoad || handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+        return callLoaderOrAction({
+          request,
+          match,
+          lazyHandlerPromise: _lazyPromises?.handler,
+          lazyRoutePromise: _lazyPromises?.route,
+          handlerOverride,
+          scopedContext
+        });
+      }
+      return Promise.resolve({ type: "data" /* data */, result: void 0 });
+    }
+  };
+}
+function getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, matches, targetMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs = null) {
+  return matches.map((match) => {
+    if (match.route.id !== targetMatch.route.id) {
+      return {
+        ...match,
+        shouldLoad: false,
+        unstable_shouldRevalidateArgs: shouldRevalidateArgs,
+        unstable_shouldCallHandler: () => false,
+        _lazyPromises: getDataStrategyMatchLazyPromises(
+          mapRouteProperties2,
+          manifest,
+          request,
+          match,
+          lazyRoutePropertiesToSkip
+        ),
+        resolve: () => Promise.resolve({ type: "data", result: void 0 })
+      };
+    }
+    return getDataStrategyMatch(
+      mapRouteProperties2,
+      manifest,
+      request,
+      match,
+      lazyRoutePropertiesToSkip,
+      scopedContext,
+      true,
+      shouldRevalidateArgs
+    );
   });
-  let results = await dataStrategyImpl({
-    matches: dsMatches,
+}
+async function callDataStrategyImpl(dataStrategyImpl, request, matches, fetcherKey, scopedContext, isStaticHandler) {
+  if (matches.some((m) => m._lazyPromises?.middleware)) {
+    await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
+  }
+  let dataStrategyArgs = {
     request,
     params: matches[0].params,
+    context: scopedContext,
+    matches
+  };
+  let unstable_runClientMiddleware = isStaticHandler ? () => {
+    throw new Error(
+      "You cannot call `unstable_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`"
+    );
+  } : (cb) => {
+    let typedDataStrategyArgs = dataStrategyArgs;
+    return runMiddlewarePipeline(
+      typedDataStrategyArgs,
+      false,
+      () => cb({
+        ...typedDataStrategyArgs,
+        fetcherKey,
+        unstable_runClientMiddleware: () => {
+          throw new Error(
+            "Cannot call `unstable_runClientMiddleware()` from within an `unstable_runClientMiddleware` handler"
+          );
+        }
+      }),
+      (error, routeId) => ({
+        [routeId]: { type: "error", result: error }
+      })
+    );
+  };
+  let results = await dataStrategyImpl({
+    ...dataStrategyArgs,
     fetcherKey,
-    context: scopedContext
+    unstable_runClientMiddleware
   });
-  let allLazyRoutePromises = lazyRoutePromises.flatMap(
-    (promiseMap) => Object.values(promiseMap).filter(isNonNullable)
-  );
   try {
-    await Promise.all(allLazyRoutePromises);
+    await Promise.all(
+      matches.flatMap((m) => [m._lazyPromises?.handler, m._lazyPromises?.route])
+    );
   } catch (e) {
   }
   return results;
 }
 async function callLoaderOrAction({
-  type,
   request,
   match,
   lazyHandlerPromise,
@@ -4038,6 +4232,8 @@ async function callLoaderOrAction({
 }) {
   let result;
   let onReject;
+  let isAction = isMutationMethod(request.method);
+  let type = isAction ? "action" : "loader";
   let runHandler = (handler) => {
     let reject;
     let abortPromise = new Promise((_, r) => reject = r);
@@ -4071,7 +4267,7 @@ async function callLoaderOrAction({
     return Promise.race([handlerPromise, abortPromise]);
   };
   try {
-    let handler = match.route[type];
+    let handler = isAction ? match.route.action : match.route.loader;
     if (lazyHandlerPromise || lazyRoutePromise) {
       if (handler) {
         let handlerError;
@@ -4092,9 +4288,9 @@ async function callLoaderOrAction({
         result = value;
       } else {
         await lazyHandlerPromise;
-        handler = match.route[type];
-        if (handler) {
-          [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
+        let handler2 = isAction ? match.route.action : match.route.loader;
+        if (handler2) {
+          [result] = await Promise.all([runHandler(handler2), lazyRoutePromise]);
         } else if (type === "action") {
           let url = new URL(request.url);
           let pathname = url.pathname + url.search;
@@ -4329,7 +4525,7 @@ function processLoaderData(state, matches, results, pendingActionResult, revalid
     results,
     pendingActionResult
   );
-  revalidatingFetchers.forEach((rf) => {
+  revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
     let { key, match, controller } = rf;
     let result = fetcherResults[key];
     invariant(result, "Did not find corresponding fetcher result");
@@ -5367,6 +5563,10 @@ function mapRouteProperties(route) {
   }
   return updates;
 }
+var hydrationRouteProperties = [
+  "HydrateFallback",
+  "hydrateFallbackElement"
+];
 function createMemoryRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
@@ -5378,6 +5578,7 @@ function createMemoryRouter(routes, opts) {
     }),
     hydrationData: opts?.hydrationData,
     routes,
+    hydrationRouteProperties,
     mapRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation
@@ -6260,6 +6461,7 @@ async function createRequestInit(request) {
 
 // lib/dom/ssr/single-fetch.tsx
 var SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
+var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205]);
 function StreamTransfer({
   context,
   identifier,
@@ -6326,71 +6528,54 @@ function StreamTransfer({
     )));
   }
 }
-function handleMiddlewareError(error, routeId) {
-  return { [routeId]: { type: "error", result: error } };
+function getSingleFetchDataStrategy(getRouter, getRouteInfo, ssr, basename) {
+  let dataStrategy = getSingleFetchDataStrategyImpl(
+    getRouter,
+    getRouteInfo,
+    fetchAndDecodeViaTurboStream,
+    ssr,
+    basename
+  );
+  return async (args) => args.unstable_runClientMiddleware(dataStrategy);
 }
-function getSingleFetchDataStrategy(manifest, routeModules, ssr, basename, getRouter) {
+function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode, ssr, basename) {
   return async (args) => {
     let { request, matches, fetcherKey } = args;
+    let router = getRouter();
     if (request.method !== "GET") {
-      return runMiddlewarePipeline(
-        args,
-        false,
-        () => singleFetchActionStrategy(request, matches, basename),
-        handleMiddlewareError
-      );
+      return singleFetchActionStrategy(args, fetchAndDecode, basename);
     }
-    if (!ssr) {
-      let foundRevalidatingServerLoader = matches.some(
-        (m) => m.shouldLoad && manifest.routes[m.route.id]?.hasLoader && !manifest.routes[m.route.id]?.hasClientLoader
-      );
-      if (!foundRevalidatingServerLoader) {
-        return runMiddlewarePipeline(
-          args,
-          false,
-          () => nonSsrStrategy(manifest, request, matches, basename),
-          handleMiddlewareError
-        );
-      }
+    let foundRevalidatingServerLoader = matches.some((m) => {
+      let { hasLoader, hasClientLoader } = getRouteInfo(m.route.id);
+      return m.unstable_shouldCallHandler() && hasLoader && !hasClientLoader;
+    });
+    if (!ssr && !foundRevalidatingServerLoader) {
+      return nonSsrStrategy(args, getRouteInfo, fetchAndDecode, basename);
     }
     if (fetcherKey) {
-      return runMiddlewarePipeline(
-        args,
-        false,
-        () => singleFetchLoaderFetcherStrategy(request, matches, basename),
-        handleMiddlewareError
-      );
+      return singleFetchLoaderFetcherStrategy(args, fetchAndDecode, basename);
     }
-    return runMiddlewarePipeline(
+    return singleFetchLoaderNavigationStrategy(
       args,
-      false,
-      () => singleFetchLoaderNavigationStrategy(
-        manifest,
-        routeModules,
-        ssr,
-        getRouter(),
-        request,
-        matches,
-        basename
-      ),
-      handleMiddlewareError
+      router,
+      getRouteInfo,
+      fetchAndDecode,
+      ssr,
+      basename
     );
   };
 }
-async function singleFetchActionStrategy(request, matches, basename) {
-  let actionMatch = matches.find((m) => m.shouldLoad);
+async function singleFetchActionStrategy(args, fetchAndDecode, basename) {
+  let actionMatch = args.matches.find((m) => m.unstable_shouldCallHandler());
   invariant2(actionMatch, "No action match found");
   let actionStatus = void 0;
   let result = await actionMatch.resolve(async (handler) => {
     let result2 = await handler(async () => {
-      let url = singleFetchUrl(request.url, basename);
-      let init = await createRequestInit(request);
-      let { data: data2, status } = await fetchAndDecode(url, init);
-      actionStatus = status;
-      return unwrapSingleFetchResult(
-        data2,
+      let { data: data2, status } = await fetchAndDecode(args, basename, [
         actionMatch.route.id
-      );
+      ]);
+      actionStatus = status;
+      return unwrapSingleFetchResult(data2, actionMatch.route.id);
     });
     return result2;
   });
@@ -6404,16 +6589,21 @@ async function singleFetchActionStrategy(request, matches, basename) {
     }
   };
 }
-async function nonSsrStrategy(manifest, request, matches, basename) {
-  let matchesToLoad = matches.filter((m) => m.shouldLoad);
-  let url = stripIndexParam(singleFetchUrl(request.url, basename));
-  let init = await createRequestInit(request);
+async function nonSsrStrategy(args, getRouteInfo, fetchAndDecode, basename) {
+  let matchesToLoad = args.matches.filter(
+    (m) => m.unstable_shouldCallHandler()
+  );
   let results = {};
   await Promise.all(
     matchesToLoad.map(
       (m) => m.resolve(async (handler) => {
         try {
-          let result = manifest.routes[m.route.id]?.hasClientLoader ? await fetchSingleLoader(handler, url, init, m.route.id) : await handler();
+          let { hasClientLoader } = getRouteInfo(m.route.id);
+          let routeId = m.route.id;
+          let result = hasClientLoader ? await handler(async () => {
+            let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+            return unwrapSingleFetchResult(data2, routeId);
+          }) : await handler();
           results[m.route.id] = { type: "data", result };
         } catch (e) {
           results[m.route.id] = { type: "error", result: e };
@@ -6423,81 +6613,63 @@ async function nonSsrStrategy(manifest, request, matches, basename) {
   );
   return results;
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router, request, matches, basename) {
+async function singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, fetchAndDecode, ssr, basename) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
-  let routeDfds = matches.map(() => createDeferred2());
-  let routesLoadedPromise = Promise.all(routeDfds.map((d) => d.promise));
+  let routeDfds = args.matches.map(() => createDeferred2());
   let singleFetchDfd = createDeferred2();
-  let url = stripIndexParam(singleFetchUrl(request.url, basename));
-  let init = await createRequestInit(request);
   let results = {};
   let resolvePromise = Promise.all(
-    matches.map(
+    args.matches.map(
       async (m, i) => m.resolve(async (handler) => {
         routeDfds[i].resolve();
-        let manifestRoute = manifest.routes[m.route.id];
-        if (!m.shouldLoad) {
-          if (!router.state.initialized) {
-            return;
-          }
-          if (m.route.id in router.state.loaderData && manifestRoute && m.route.shouldRevalidate) {
-            if (manifestRoute.hasLoader) {
-              foundOptOutRoute = true;
-            }
-            return;
-          }
+        let routeId = m.route.id;
+        let { hasLoader, hasClientLoader, hasShouldRevalidate } = getRouteInfo(routeId);
+        let defaultShouldRevalidate = !m.unstable_shouldRevalidateArgs || m.unstable_shouldRevalidateArgs.actionStatus == null || m.unstable_shouldRevalidateArgs.actionStatus < 400;
+        let shouldCall = m.unstable_shouldCallHandler(defaultShouldRevalidate);
+        if (!shouldCall) {
+          foundOptOutRoute || (foundOptOutRoute = m.unstable_shouldRevalidateArgs != null && // This is a revalidation,
+          hasLoader && // for a route with a server loader,
+          hasShouldRevalidate === true);
+          return;
         }
-        if (manifestRoute && manifestRoute.hasClientLoader) {
-          if (manifestRoute.hasLoader) {
+        if (hasClientLoader) {
+          if (hasLoader) {
             foundOptOutRoute = true;
           }
           try {
-            let result = await fetchSingleLoader(
-              handler,
-              url,
-              init,
-              m.route.id
-            );
-            results[m.route.id] = { type: "data", result };
+            let result = await handler(async () => {
+              let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+              return unwrapSingleFetchResult(data2, routeId);
+            });
+            results[routeId] = { type: "data", result };
           } catch (e) {
-            results[m.route.id] = { type: "error", result: e };
+            results[routeId] = { type: "error", result: e };
           }
           return;
         }
-        if (manifestRoute && manifestRoute.hasLoader) {
-          routesParams.add(m.route.id);
+        if (hasLoader) {
+          routesParams.add(routeId);
         }
         try {
           let result = await handler(async () => {
             let data2 = await singleFetchDfd.promise;
-            return unwrapSingleFetchResults(data2, m.route.id);
+            return unwrapSingleFetchResult(data2, routeId);
           });
-          results[m.route.id] = {
-            type: "data",
-            result
-          };
+          results[routeId] = { type: "data", result };
         } catch (e) {
-          results[m.route.id] = {
-            type: "error",
-            result: e
-          };
+          results[routeId] = { type: "error", result: e };
         }
       })
     )
   );
-  await routesLoadedPromise;
+  await Promise.all(routeDfds.map((d) => d.promise));
   if ((!router.state.initialized || routesParams.size === 0) && !window.__reactRouterHdrActive) {
     singleFetchDfd.resolve({});
   } else {
+    let targetRoutes = ssr && foundOptOutRoute && routesParams.size > 0 ? [...routesParams.keys()] : void 0;
     try {
-      if (ssr && foundOptOutRoute && routesParams.size > 0) {
-        url.searchParams.set(
-          "_routes",
-          matches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
-        );
-      }
-      let data2 = await fetchAndDecode(url, init);
+      let data2 = await fetchAndDecode(args, basename, targetRoutes);
       singleFetchDfd.resolve(data2.data);
     } catch (e) {
       singleFetchDfd.reject(e);
@@ -6506,24 +6678,18 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
   await resolvePromise;
   return results;
 }
-async function singleFetchLoaderFetcherStrategy(request, matches, basename) {
-  let fetcherMatch = matches.find((m) => m.shouldLoad);
+async function singleFetchLoaderFetcherStrategy(args, fetchAndDecode, basename) {
+  let fetcherMatch = args.matches.find((m) => m.unstable_shouldCallHandler());
   invariant2(fetcherMatch, "No fetcher match found");
-  let result = await fetcherMatch.resolve(async (handler) => {
-    let url = stripIndexParam(singleFetchUrl(request.url, basename));
-    let init = await createRequestInit(request);
-    return fetchSingleLoader(handler, url, init, fetcherMatch.route.id);
-  });
+  let routeId = fetcherMatch.route.id;
+  let result = await fetcherMatch.resolve(
+    async (handler) => handler(async () => {
+      let { data: data2 } = await fetchAndDecode(args, basename, [routeId]);
+      return unwrapSingleFetchResult(data2, routeId);
+    })
+  );
   return { [fetcherMatch.route.id]: result };
 }
-function fetchSingleLoader(handler, url, init, routeId) {
-  return handler(async () => {
-    let singleLoaderUrl = new URL(url);
-    singleLoaderUrl.searchParams.set("_routes", routeId);
-    let { data: data2 } = await fetchAndDecode(singleLoaderUrl, init);
-    return unwrapSingleFetchResults(data2, routeId);
-  });
-}
 function stripIndexParam(url) {
   let indexValues = url.searchParams.getAll("index");
   url.searchParams.delete("index");
@@ -6554,23 +6720,51 @@ function singleFetchUrl(reqUrl, basename) {
   }
   return url;
 }
-async function fetchAndDecode(url, init) {
-  let res = await fetch(url, init);
+async function fetchAndDecodeViaTurboStream(args, basename, targetRoutes) {
+  let { request } = args;
+  let url = singleFetchUrl(request.url, basename);
+  if (request.method === "GET") {
+    url = stripIndexParam(url);
+    if (targetRoutes) {
+      url.searchParams.set("_routes", targetRoutes.join(","));
+    }
+  }
+  let res = await fetch(url, await createRequestInit(request));
   if (res.status === 404 && !res.headers.has("X-Remix-Response")) {
     throw new ErrorResponseImpl(404, "Not Found", true);
   }
-  const NO_BODY_STATUS_CODES2 = /* @__PURE__ */ new Set([100, 101, 204, 205]);
-  if (NO_BODY_STATUS_CODES2.has(res.status)) {
-    if (!init.method || init.method === "GET") {
-      return { status: res.status, data: {} };
-    } else {
-      return { status: res.status, data: { data: void 0 } };
+  if (NO_BODY_STATUS_CODES.has(res.status)) {
+    let routes = {};
+    if (targetRoutes && request.method !== "GET") {
+      routes[targetRoutes[0]] = { data: void 0 };
     }
+    return {
+      status: res.status,
+      data: { routes }
+    };
   }
   invariant2(res.body, "No response body to decode");
   try {
     let decoded = await decodeViaTurboStream(res.body, window);
-    return { status: res.status, data: decoded.value };
+    let data2;
+    if (request.method === "GET") {
+      let typed = decoded.value;
+      if (SingleFetchRedirectSymbol in typed) {
+        data2 = { redirect: typed[SingleFetchRedirectSymbol] };
+      } else {
+        data2 = { routes: typed };
+      }
+    } else {
+      let typed = decoded.value;
+      let routeId = targetRoutes?.[0];
+      invariant2(routeId, "No routeId found for single fetch call decoding");
+      if ("redirect" in typed) {
+        data2 = { redirect: typed };
+      } else {
+        data2 = { routes: { [routeId]: typed } };
+      }
+    }
+    return { status: res.status, data: data2 };
   } catch (e) {
     throw new Error("Unable to decode turbo-stream response");
   }
@@ -6608,30 +6802,30 @@ function decodeViaTurboStream(body, global2) {
     ]
   });
 }
-function unwrapSingleFetchResults(results, routeId) {
-  let redirect2 = results[SingleFetchRedirectSymbol];
-  if (redirect2) {
-    return unwrapSingleFetchResult(redirect2, routeId);
-  }
-  return results[routeId] !== void 0 ? unwrapSingleFetchResult(results[routeId], routeId) : null;
-}
 function unwrapSingleFetchResult(result, routeId) {
-  if ("error" in result) {
-    throw result.error;
-  } else if ("redirect" in result) {
-    let headers = {};
-    if (result.revalidate) {
-      headers["X-Remix-Revalidate"] = "yes";
-    }
-    if (result.reload) {
-      headers["X-Remix-Reload-Document"] = "yes";
-    }
-    if (result.replace) {
-      headers["X-Remix-Replace"] = "yes";
-    }
-    throw redirect(result.redirect, { status: result.status, headers });
-  } else if ("data" in result) {
-    return result.data;
+  if ("redirect" in result) {
+    let {
+      redirect: location,
+      revalidate,
+      reload,
+      replace: replace2,
+      status
+    } = result.redirect;
+    throw redirect(location, {
+      status,
+      headers: {
+        // Three R's of redirecting (lol Veep)
+        ...revalidate ? { "X-Remix-Revalidate": "yes" } : null,
+        ...reload ? { "X-Remix-Reload-Document": "yes" } : null,
+        ...replace2 ? { "X-Remix-Replace": "yes" } : null
+      }
+    });
+  }
+  let routeResult = result.routes[routeId];
+  if ("error" in routeResult) {
+    throw routeResult.error;
+  } else if ("data" in routeResult) {
+    return routeResult.data;
   } else {
     throw new Error(`No response found for routeId "${routeId}"`);
   }
@@ -6943,6 +7137,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         unstable_middleware: routeModule.unstable_clientMiddleware,
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
+          dataRoute.path,
           routeModule,
           route,
           ssr,
@@ -7095,6 +7290,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         shouldRevalidate: async () => {
           let lazyRoute = await getLazyRoute();
           return getShouldRevalidateFunction(
+            dataRoute.path,
             lazyRoute,
             route,
             ssr,
@@ -7122,7 +7318,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
     return dataRoute;
   });
 }
-function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidation) {
+function getShouldRevalidateFunction(path, route, manifestRoute, ssr, needsRevalidation) {
   if (needsRevalidation) {
     return wrapShouldRevalidateForHdr(
       manifestRoute.id,
@@ -7131,11 +7327,16 @@ function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidatio
     );
   }
   if (!ssr && manifestRoute.hasLoader && !manifestRoute.hasClientLoader) {
+    let myParams = path ? compilePath(path)[1].map((p) => p.paramName) : [];
+    const didParamsChange = (opts) => myParams.some((p) => opts.currentParams[p] !== opts.nextParams[p]);
     if (route.shouldRevalidate) {
       let fn = route.shouldRevalidate;
-      return (opts) => fn({ ...opts, defaultShouldRevalidate: false });
+      return (opts) => fn({
+        ...opts,
+        defaultShouldRevalidate: didParamsChange(opts)
+      });
     } else {
-      return () => false;
+      return (opts) => didParamsChange(opts);
     }
   }
   if (ssr && route.shouldRevalidate) {
@@ -7864,7 +8065,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.5.0";
+    window.__reactRouterVersion = "7.5.1";
   }
 } catch (e) {
 }
@@ -7877,6 +8078,7 @@ function createBrowserRouter(routes, opts) {
     hydrationData: opts?.hydrationData || parseHydrationData(),
     routes,
     mapRouteProperties,
+    hydrationRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,
     window: opts?.window
@@ -7891,6 +8093,7 @@ function createHashRouter(routes, opts) {
     hydrationData: opts?.hydrationData || parseHydrationData(),
     routes,
     mapRouteProperties,
+    hydrationRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,
     window: opts?.window
@@ -9480,13 +9683,28 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
           });
           let decoded = await decodeViaTurboStream(stream, global);
           let data2 = decoded.value;
-          invariant3(
-            data2 && route.id in data2,
-            "Unable to decode prerendered data"
-          );
-          let result = data2[route.id];
-          invariant3("data" in result, "Unable to process prerendered data");
-          return result.data;
+          if (data2 && SingleFetchRedirectSymbol in data2) {
+            let result = data2[SingleFetchRedirectSymbol];
+            let init = { status: result.status };
+            if (result.reload) {
+              throw redirectDocument(result.redirect, init);
+            } else if (result.replace) {
+              throw replace(result.redirect, init);
+            } else {
+              throw redirect(result.redirect, init);
+            }
+          } else {
+            invariant3(
+              data2 && route.id in data2,
+              "Unable to decode prerendered data"
+            );
+            let result = data2[route.id];
+            invariant3(
+              "data" in result,
+              "Unable to process prerendered data"
+            );
+            return result.data;
+          }
         }
         let val = await callRouteHandler(route.module.loader, args);
         return val;
@@ -9607,8 +9825,11 @@ function prependCookies(parentHeaders, childHeaders) {
 }
 
 // lib/server-runtime/single-fetch.ts
-var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205, 304]);
 var SINGLE_FETCH_REDIRECT_STATUS = 202;
+var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
+  ...NO_BODY_STATUS_CODES,
+  304
+]);
 async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
   try {
     let respond2 = function(context) {
@@ -9777,7 +9998,7 @@ function generateSingleFetchResponse(request, build, serverMode, {
 }) {
   let resultHeaders = new Headers(headers);
   resultHeaders.set("X-Remix-Response", "yes");
-  if (NO_BODY_STATUS_CODES.has(status)) {
+  if (SERVER_NO_BODY_STATUS_CODES.has(status)) {
     return new Response(null, { status, headers: resultHeaders });
   }
   resultHeaders.set("Content-Type", "text/x-script");
@@ -9886,9 +10107,6 @@ var createRequestHandler = (build, mode) => {
   let errorHandler;
   return async function requestHandler(request, initialContext) {
     _build = typeof build === "function" ? await build() : build;
-    let loadContext = _build.future.unstable_middleware ? new unstable_RouterContextProvider(
-      initialContext
-    ) : initialContext || {};
     if (typeof build === "function") {
       let derived = derive(_build, mode);
       routes = derived.routes;
@@ -9902,18 +10120,8 @@ var createRequestHandler = (build, mode) => {
       staticHandler = derived.staticHandler;
       errorHandler = derived.errorHandler;
     }
-    let url = new URL(request.url);
-    let normalizedBasename = _build.basename || "/";
-    let normalizedPath = url.pathname;
-    if (stripBasename(normalizedPath, normalizedBasename) === "/_root.data") {
-      normalizedPath = normalizedBasename;
-    } else if (normalizedPath.endsWith(".data")) {
-      normalizedPath = normalizedPath.replace(/\.data$/, "");
-    }
-    if (stripBasename(normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
-      normalizedPath = normalizedPath.slice(0, -1);
-    }
     let params = {};
+    let loadContext;
     let handleError = (error) => {
       if (mode === "development" /* Development */) {
         getDevServerHooks()?.processRequestError?.(error);
@@ -9924,6 +10132,38 @@ var createRequestHandler = (build, mode) => {
         request
       });
     };
+    if (_build.future.unstable_middleware) {
+      if (initialContext == null) {
+        loadContext = new unstable_RouterContextProvider();
+      } else {
+        try {
+          loadContext = new unstable_RouterContextProvider(
+            initialContext
+          );
+        } catch (e) {
+          let error = new Error(
+            `Unable to create initial \`unstable_RouterContextProvider\` instance. Please confirm you are returning an instance of \`Map<unstable_routerContext, unknown>\` from your \`getLoadContext\` function.
+
+Error: ${e instanceof Error ? e.toString() : e}`
+          );
+          handleError(error);
+          return returnLastResortErrorResponse(error, serverMode);
+        }
+      }
+    } else {
+      loadContext = initialContext || {};
+    }
+    let url = new URL(request.url);
+    let normalizedBasename = _build.basename || "/";
+    let normalizedPath = url.pathname;
+    if (stripBasename(normalizedPath, normalizedBasename) === "/_root.data") {
+      normalizedPath = normalizedBasename;
+    } else if (normalizedPath.endsWith(".data")) {
+      normalizedPath = normalizedPath.replace(/\.data$/, "");
+    }
+    if (stripBasename(normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
     if (!_build.ssr) {
       if (_build.prerender.length === 0) {
         request.headers.set("X-React-Router-SPA-Mode", "yes");
@@ -10132,7 +10372,7 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
       return context;
     }
     let headers = getDocumentHeaders(build, context);
-    if (NO_BODY_STATUS_CODES.has(context.statusCode)) {
+    if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
       return new Response(null, { status: context.statusCode, headers });
     }
     if (context.errors) {
@@ -10552,6 +10792,7 @@ function deserializeErrors2(errors) {
   UNSAFE_deserializeErrors,
   UNSAFE_getPatchRoutesOnNavigationFunction,
   UNSAFE_getSingleFetchDataStrategy,
+  UNSAFE_hydrationRouteProperties,
   UNSAFE_invariant,
   UNSAFE_mapRouteProperties,
   UNSAFE_shouldHydrateRouteLoader,