react-router 0.0.0-experimental-c8b52c995 → 0.0.0-experimental-668b4f5c4

package/dist/development/{chunk-4K5PIBZY.mjs → chunk-FBGXXFNB.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-c8b52c995
+ * react-router v0.0.0-experimental-668b4f5c4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -949,6 +949,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(
@@ -1421,6 +1422,7 @@ function createRouter(init) {
         matches,
         scopedContext,
         fogOfWar.active,
+        opts && opts.initialHydration === true,
         { replace: opts.replace, flushSync }
       );
       if (actionResult.shortCircuited) {
@@ -1481,7 +1483,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 });
@@ -1535,11 +1537,19 @@ 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,
+        null,
         scopedContext,
         null
       );
@@ -1638,12 +1648,21 @@ function createRouter(init) {
       }
     }
     let routesToUse = inFlightDataRoutes || dataRoutes;
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let {
+      navigationMatches: dsMatches,
+      revalidatingFetchers,
+      shouldRevalidateArgs
+    } = getMatchesToLoad(
+      request,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       activeSubmission,
       location,
+      initialHydration ? [] : hydrationRouteProperties2,
       initialHydration === true,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -1655,7 +1674,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,
@@ -1699,9 +1718,9 @@ function createRouter(init) {
       );
     }
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
+      shouldRevalidateArgs,
       request,
       scopedContext
     );
@@ -1903,11 +1922,19 @@ 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,
+      null,
       scopedContext,
       key
     );
@@ -1956,12 +1983,21 @@ function createRouter(init) {
     fetchReloadIds.set(key, loadId);
     let loadFetcher = getLoadingFetcher(submission, actionResult.data);
     state.fetchers.set(key, loadFetcher);
-    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+    let {
+      navigationMatches: dsMatches,
+      revalidatingFetchers,
+      shouldRevalidateArgs
+    } = getMatchesToLoad(
+      revalidationRequest,
+      scopedContext,
+      mapRouteProperties2,
+      manifest,
       init.history,
       state,
       matches,
       submission,
       nextLocation,
+      hydrationRouteProperties2,
       false,
       isRevalidationRequired,
       cancelledFetcherLoads,
@@ -1992,9 +2028,9 @@ function createRouter(init) {
       abortPendingFetchRevalidations
     );
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      matches,
-      matchesToLoad,
+      dsMatches,
       revalidatingFetchers,
+      shouldRevalidateArgs,
       revalidationRequest,
       scopedContext
     );
@@ -2106,11 +2142,19 @@ 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,
+      null,
       scopedContext,
       key
     );
@@ -2213,23 +2257,20 @@ function createRouter(init) {
       });
     }
   }
-  async function callDataStrategy(type, request, matchesToLoad, matches, scopedContext, fetcherKey) {
+  async function callDataStrategy(request, matches, shouldRevalidateArgs, scopedContext, fetcherKey) {
     let results;
     let dataResults = {};
     try {
       results = await callDataStrategyImpl(
         dataStrategyImpl,
-        type,
         request,
-        matchesToLoad,
         matches,
+        shouldRevalidateArgs,
         fetcherKey,
-        manifest,
-        mapRouteProperties2,
         scopedContext
       );
     } catch (e) {
-      matchesToLoad.forEach((m) => {
+      matches.filter((m) => m.shouldLoad).forEach((m) => {
         dataResults[m.route.id] = {
           type: "error" /* error */,
           error: e
@@ -2258,23 +2299,21 @@ function createRouter(init) {
     }
     return dataResults;
   }
-  async function callLoadersAndMaybeResolveData(matches, matchesToLoad, fetchersToLoad, request, scopedContext) {
+  async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, shouldRevalidateArgs, request, scopedContext) {
     let loaderResultsPromise = callDataStrategy(
-      "loader",
       request,
-      matchesToLoad,
       matches,
+      shouldRevalidateArgs,
       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,
+            shouldRevalidateArgs,
             scopedContext,
             f.key
           );
@@ -2968,11 +3007,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
@@ -3090,11 +3136,46 @@ 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
@@ -3110,10 +3191,8 @@ function createStaticHandler(routes, opts) {
       };
     }
     let results = await callDataStrategy(
-      "loader",
       request,
-      matchesToLoad,
-      matches,
+      dsMatches,
       isRouteRequest,
       requestContext,
       dataStrategy
@@ -3129,7 +3208,7 @@ function createStaticHandler(routes, opts) {
       skipLoaderErrorBubbling
     );
     let executedLoaders = new Set(
-      matchesToLoad.map((match) => match.route.id)
+      dsMatches.filter((m) => m.shouldLoad).map((match) => match.route.id)
     );
     matches.forEach((match) => {
       if (!executedLoaders.has(match.route.id)) {
@@ -3141,16 +3220,13 @@ function createStaticHandler(routes, opts) {
       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,
+      null,
       requestContext
     );
     let dataResults = {};
@@ -3357,62 +3433,110 @@ 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 shouldRevalidateArgs = initialHydration ? null : {
+    currentUrl,
+    currentParams: state.matches[0]?.params || {},
+    nextUrl,
+    nextParams: matches[0].params,
+    ...submission,
+    actionResult,
+    actionStatus
+  };
+  let navigationMatches = 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);
-    }
-    if (isNewLoader(state.loaderData, state.matches[index], match)) {
-      return true;
-    }
-    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 : (
+    if (maxIdx != null && index > maxIdx) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        false
+      );
+    } else if (route.lazy) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        true
+      );
+    } else if (route.loader == null) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        false
+      );
+    } else if (initialHydration) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        shouldLoadRouteOnHydration(route, state.loaderData, state.errors)
+      );
+    } else if (isNewLoader(state.loaderData, state.matches[index], match)) {
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        true
+      );
+    } else {
+      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(currentRouteMatch, nextRouteMatch)
-      )
-    });
+        currentUrl.search !== nextUrl.search || isNewRouteInstance(state.matches[index], match)
+      );
+      invariant(
+        shouldRevalidateArgs,
+        "Expected shouldRevalidateArgs to be defined for fetcher"
+      );
+      let shouldLoad = shouldRevalidateLoader(match, {
+        ...shouldRevalidateArgs,
+        defaultShouldRevalidate
+      });
+      return getDataStrategyMatch(
+        mapRouteProperties2,
+        manifest,
+        request,
+        match,
+        lazyRoutePropertiesToSkip,
+        scopedContext,
+        shouldLoad,
+        (defaultOverride) => shouldRevalidateLoader(match, {
+          // We're not in initialHydration here so this will be defined
+          ...shouldRevalidateArgs,
+          defaultShouldRevalidate: typeof defaultOverride === "boolean" ? defaultOverride : defaultShouldRevalidate
+        })
+      );
+    }
   });
   let revalidatingFetchers = [];
   fetchLoadMatches.forEach((f, key) => {
@@ -3427,44 +3551,97 @@ 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
+    );
+    if (cancelledFetcherLoads.has(key)) {
       cancelledFetcherLoads.delete(key);
-      shouldRevalidate = true;
-    } else if (fetcher && fetcher.state !== "idle" && fetcher.data === void 0) {
-      shouldRevalidate = isRevalidationRequired;
-    } else {
-      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {
-        currentUrl,
-        currentParams: state.matches[state.matches.length - 1].params,
-        nextUrl,
-        nextParams: matches[matches.length - 1].params,
-        ...submission,
-        actionResult,
-        actionStatus,
-        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
-      });
-    }
-    if (shouldRevalidate) {
       revalidatingFetchers.push({
         key,
         routeId: f.routeId,
         path: f.path,
-        matches: fetcherMatches,
+        matches: getTargetedDataStrategyMatches(
+          mapRouteProperties2,
+          manifest,
+          fetchRequest,
+          fetcherMatches,
+          fetcherMatch,
+          lazyRoutePropertiesToSkip,
+          scopedContext
+        ),
         match: fetcherMatch,
-        controller: new AbortController()
+        request: fetchRequest,
+        controller: fetchController
       });
+    } else if (fetcher && fetcher.state !== "idle" && fetcher.data === void 0) {
+      if (isRevalidationRequired) {
+        revalidatingFetchers.push({
+          key,
+          routeId: f.routeId,
+          path: f.path,
+          matches: getTargetedDataStrategyMatches(
+            mapRouteProperties2,
+            manifest,
+            fetchRequest,
+            fetcherMatches,
+            fetcherMatch,
+            lazyRoutePropertiesToSkip,
+            scopedContext
+          ),
+          match: fetcherMatch,
+          request: fetchRequest,
+          controller: fetchController
+        });
+      }
+    } else {
+      let defaultShouldRevalidate = shouldSkipRevalidation ? false : isRevalidationRequired;
+      invariant(
+        shouldRevalidateArgs,
+        "Expected shouldRevalidateArgs to be defined for fetcher"
+      );
+      let shouldLoad = shouldRevalidateLoader(fetcherMatch, {
+        ...shouldRevalidateArgs,
+        defaultShouldRevalidate
+      });
+      if (shouldLoad) {
+        revalidatingFetchers.push({
+          key,
+          routeId: f.routeId,
+          path: f.path,
+          matches: getTargetedDataStrategyMatches(
+            mapRouteProperties2,
+            manifest,
+            fetchRequest,
+            fetcherMatches,
+            fetcherMatch,
+            lazyRoutePropertiesToSkip,
+            scopedContext
+          ),
+          match: fetcherMatch,
+          request: fetchRequest,
+          controller: fetchController
+        });
+      }
     }
   });
-  return [navigationMatches, revalidatingFetchers];
+  return {
+    navigationMatches,
+    revalidatingFetchers,
+    shouldRevalidateArgs
+  };
 }
 function shouldLoadRouteOnHydration(route, loaderData, errors) {
   if (route.lazy) {
@@ -3610,7 +3787,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) {
@@ -3668,6 +3845,8 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties2) {
       });
     })();
     lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
+    lazyRoutePromise2.catch(() => {
+    });
     return {
       lazyRoutePromise: lazyRoutePromise2,
       lazyHandlerPromise: lazyRoutePromise2
@@ -3677,6 +3856,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,
@@ -3690,7 +3872,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,
@@ -3828,59 +4014,107 @@ 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,
+    mapRouteProperties: mapRouteProperties2
+  });
+  let lazyRoutePromises = loadLazyRoute(
+    match.route,
+    isMutationMethod(request.method) ? "action" : "loader",
     manifest,
-    mapRouteProperties2
+    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_shouldCallHandler = () => shouldLoad) {
+  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,
+    shouldLoad,
+    unstable_shouldCallHandler(defaultShouldRevalidate) {
+      isUsingNewApi = true;
+      return unstable_shouldCallHandler(defaultShouldRevalidate);
+    },
+    _lazyPromises,
+    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) {
+  return matches.map((match) => {
+    if (match.route.id !== targetMatch.route.id) {
+      return {
+        ...match,
+        shouldLoad: false,
+        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
+    );
   });
+}
+async function callDataStrategyImpl(dataStrategyImpl, request, matches, shouldRevalidateArgs, fetcherKey, scopedContext) {
+  if (matches.some((m) => m._lazyPromises?.middleware)) {
+    await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
+  }
   let results = await dataStrategyImpl({
-    matches: dsMatches,
+    matches,
+    unstable_shouldRevalidateArgs: shouldRevalidateArgs,
     request,
     params: matches[0].params,
     fetcherKey,
     context: scopedContext
   });
-  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,
@@ -3890,6 +4124,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);
@@ -3923,7 +4159,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;
@@ -3944,9 +4180,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;
@@ -4181,7 +4417,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");
@@ -5219,6 +5455,10 @@ function mapRouteProperties(route) {
   }
   return updates;
 }
+var hydrationRouteProperties = [
+  "HydrateFallback",
+  "hydrateFallbackElement"
+];
 function createMemoryRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
@@ -5230,6 +5470,7 @@ function createMemoryRouter(routes, opts) {
     }),
     hydrationData: opts?.hydrationData,
     routes,
+    hydrationRouteProperties,
     mapRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation
@@ -6181,26 +6422,26 @@ function StreamTransfer({
 function handleMiddlewareError(error, routeId) {
   return { [routeId]: { type: "error", result: error } };
 }
-function getSingleFetchDataStrategy(manifest, routeModules, ssr, basename, getRouter) {
+function getSingleFetchDataStrategy(manifest, ssr, basename, getRouter) {
   return async (args) => {
     let { request, matches, fetcherKey } = args;
     if (request.method !== "GET") {
       return runMiddlewarePipeline(
         args,
         false,
-        () => singleFetchActionStrategy(request, matches, basename),
+        () => singleFetchActionStrategy(args, basename),
         handleMiddlewareError
       );
     }
     if (!ssr) {
       let foundRevalidatingServerLoader = matches.some(
-        (m) => m.shouldLoad && manifest.routes[m.route.id]?.hasLoader && !manifest.routes[m.route.id]?.hasClientLoader
+        (m) => m.unstable_shouldCallHandler() && manifest.routes[m.route.id]?.hasLoader && !manifest.routes[m.route.id]?.hasClientLoader
       );
       if (!foundRevalidatingServerLoader) {
         return runMiddlewarePipeline(
           args,
           false,
-          () => nonSsrStrategy(manifest, request, matches, basename),
+          () => nonSsrStrategy(args, manifest, basename),
           handleMiddlewareError
         );
       }
@@ -6217,20 +6458,18 @@ function getSingleFetchDataStrategy(manifest, routeModules, ssr, basename, getRo
       args,
       false,
       () => singleFetchLoaderNavigationStrategy(
+        args,
         manifest,
-        routeModules,
         ssr,
         getRouter(),
-        request,
-        matches,
         basename
       ),
       handleMiddlewareError
     );
   };
 }
-async function singleFetchActionStrategy(request, matches, basename) {
-  let actionMatch = matches.find((m) => m.shouldLoad);
+async function singleFetchActionStrategy({ request, matches }, basename) {
+  let actionMatch = matches.find((m) => m.unstable_shouldCallHandler());
   invariant2(actionMatch, "No action match found");
   let actionStatus = void 0;
   let result = await actionMatch.resolve(async (handler) => {
@@ -6256,8 +6495,8 @@ async function singleFetchActionStrategy(request, matches, basename) {
     }
   };
 }
-async function nonSsrStrategy(manifest, request, matches, basename) {
-  let matchesToLoad = matches.filter((m) => m.shouldLoad);
+async function nonSsrStrategy({ request, matches }, manifest, basename) {
+  let matchesToLoad = matches.filter((m) => m.unstable_shouldCallHandler());
   let url = stripIndexParam(singleFetchUrl(request.url, basename));
   let init = await createRequestInit(request);
   let results = {};
@@ -6275,7 +6514,11 @@ async function nonSsrStrategy(manifest, request, matches, basename) {
   );
   return results;
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router, request, matches, basename) {
+async function singleFetchLoaderNavigationStrategy({
+  request,
+  matches,
+  unstable_shouldRevalidateArgs: shouldRevalidateArgs
+}, manifest, ssr, router, basename) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
   let routeDfds = matches.map(() => createDeferred2());
@@ -6289,16 +6532,11 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
       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 defaultShouldRevalidate = !shouldRevalidateArgs || shouldRevalidateArgs.actionStatus == null || shouldRevalidateArgs.actionStatus < 400;
+        let shouldCall = m.unstable_shouldCallHandler(defaultShouldRevalidate);
+        if (!shouldCall) {
+          foundOptOutRoute || (foundOptOutRoute = manifestRoute?.hasLoader === true && m.route.id in router.state.loaderData && m.route.shouldRevalidate != null);
+          return;
         }
         if (manifestRoute && manifestRoute.hasClientLoader) {
           if (manifestRoute.hasLoader) {
@@ -6359,7 +6597,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
   return results;
 }
 async function singleFetchLoaderFetcherStrategy(request, matches, basename) {
-  let fetcherMatch = matches.find((m) => m.shouldLoad);
+  let fetcherMatch = 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));
@@ -7723,7 +7961,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "0.0.0-experimental-c8b52c995";
+    window.__reactRouterVersion = "0.0.0-experimental-668b4f5c4";
   }
 } catch (e) {
 }
@@ -7736,6 +7974,7 @@ function createBrowserRouter(routes, opts) {
     hydrationData: opts?.hydrationData || parseHydrationData(),
     routes,
     mapRouteProperties,
+    hydrationRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,
     window: opts?.window
@@ -7750,6 +7989,7 @@ function createHashRouter(routes, opts) {
     hydrationData: opts?.hydrationData || parseHydrationData(),
     routes,
     mapRouteProperties,
+    hydrationRouteProperties,
     dataStrategy: opts?.dataStrategy,
     patchRoutesOnNavigation: opts?.patchRoutesOnNavigation,
     window: opts?.window
@@ -9339,13 +9579,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;
@@ -10435,6 +10690,7 @@ export {
   useAsyncError,
   useBlocker,
   mapRouteProperties,
+  hydrationRouteProperties,
   createMemoryRouter,
   RouterProvider,
   MemoryRouter,