react-router 0.0.0-experimental-beaa4f52a → 0.0.0-experimental-df0f1dfda

package/dist/development/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-beaa4f52a
+ * react-router v0.0.0-experimental-df0f1dfda
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1052,7 +1052,6 @@ function createRouter(init) {
   );
   let inFlightDataRoutes;
   let basename = init.basename || "/";
-  let routerContext = typeof init.context !== "undefined" ? init.context : {};
   let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
   let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
   let future = {
@@ -1065,6 +1064,7 @@ function createRouter(init) {
   let getScrollPosition = null;
   let initialScrollRestored = init.hydrationData != null;
   let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
+  let initialMatchesIsFOW = false;
   let initialErrors = null;
   if (initialMatches == null && !patchRoutesOnNavigationImpl) {
     let error = getInternalRouterError(404, {
@@ -1094,6 +1094,7 @@ function createRouter(init) {
       init.history.location.pathname
     );
     if (fogOfWar.active && fogOfWar.matches) {
+      initialMatchesIsFOW = true;
       initialMatches = fogOfWar.matches;
     }
   } else if (initialMatches.some((m) => m.route.lazy)) {
@@ -1459,7 +1460,10 @@ function createRouter(init) {
     pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
     let routesToUse = inFlightDataRoutes || dataRoutes;
     let loadingNavigation = opts && opts.overrideNavigation;
-    let matches = matchRoutes(routesToUse, location, basename);
+    let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? (
+      // `matchRoutes()` has already been called if we're in here via `router.initialize()`
+      state.matches
+    ) : matchRoutes(routesToUse, location, basename);
     let flushSync = (opts && opts.flushSync) === true;
     let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
     if (fogOfWar.active && fogOfWar.matches) {
@@ -1493,7 +1497,6 @@ function createRouter(init) {
       pendingNavigationController.signal,
       opts && opts.submission
     );
-    let scopedContext = { ...routerContext };
     let pendingActionResult;
     if (opts && opts.pendingError) {
       pendingActionResult = [
@@ -1506,7 +1509,6 @@ function createRouter(init) {
         location,
         opts.submission,
         matches,
-        scopedContext,
         fogOfWar.active,
         { replace: opts.replace, flushSync }
       );
@@ -1547,7 +1549,6 @@ function createRouter(init) {
       request,
       location,
       matches,
-      scopedContext,
       fogOfWar.active,
       loadingNavigation,
       opts && opts.submission,
@@ -1568,7 +1569,7 @@ function createRouter(init) {
       errors
     });
   }
-  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, opts = {}) {
+  async function handleAction(request, location, submission, matches, isFogOfWar, opts = {}) {
     interruptActiveLoads();
     let navigation = getSubmittingNavigation(location, submission);
     updateState({ navigation }, { flushSync: opts.flushSync === true });
@@ -1622,23 +1623,15 @@ function createRouter(init) {
         })
       };
     } else {
-      let results = await callRouterDataStrategy(
+      let results = await callDataStrategy(
         "action",
+        state,
         request,
         [actionMatch],
         matches,
-        scopedContext,
         null
       );
       result = results[actionMatch.route.id];
-      if (!result) {
-        for (let match of matches) {
-          if (results[match.route.id]) {
-            result = results[match.route.id];
-            break;
-          }
-        }
-      }
       if (request.signal.aborted) {
         return { shortCircuited: true };
       }
@@ -1676,7 +1669,7 @@ function createRouter(init) {
       pendingActionResult: [actionMatch.route.id, result]
     };
   }
-  async function handleLoaders(request, location, matches, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult) {
+  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult) {
     let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
     let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
     let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
@@ -1786,11 +1779,11 @@ function createRouter(init) {
       );
     }
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
+      state,
       matches,
       matchesToLoad,
       revalidatingFetchers,
-      request,
-      scopedContext
+      request
     );
     if (request.signal.aborted) {
       return { shortCircuited: true };
@@ -1898,7 +1891,6 @@ function createRouter(init) {
       return;
     }
     let match = getTargetMatch(matches, path);
-    let scopedContext = { ...routerContext };
     let preventScrollReset = (opts && opts.preventScrollReset) === true;
     if (submission && isMutationMethod(submission.formMethod)) {
       await handleFetcherAction(
@@ -1907,7 +1899,6 @@ function createRouter(init) {
         path,
         match,
         matches,
-        scopedContext,
         fogOfWar.active,
         flushSync,
         preventScrollReset,
@@ -1922,14 +1913,13 @@ function createRouter(init) {
       path,
       match,
       matches,
-      scopedContext,
       fogOfWar.active,
       flushSync,
       preventScrollReset,
       submission
     );
   }
-  async function handleFetcherAction(key, routeId, path, match, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
+  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
     interruptActiveLoads();
     fetchLoadMatches.delete(key);
     function detectAndHandle405Error(m) {
@@ -1987,12 +1977,12 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let actionResults = await callRouterDataStrategy(
+    let actionResults = await callDataStrategy(
       "action",
+      state,
       fetchRequest,
       [match],
       requestMatches,
-      scopedContext,
       key
     );
     let actionResult = actionResults[match.route.id];
@@ -2076,11 +2066,11 @@ function createRouter(init) {
       abortPendingFetchRevalidations
     );
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
+      state,
       matches,
       matchesToLoad,
       revalidatingFetchers,
-      revalidationRequest,
-      scopedContext
+      revalidationRequest
     );
     if (abortController.signal.aborted) {
       return;
@@ -2147,7 +2137,7 @@ function createRouter(init) {
       isRevalidationRequired = false;
     }
   }
-  async function handleFetcherLoader(key, routeId, path, match, matches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
+  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
     let existingFetcher = state.fetchers.get(key);
     updateFetcherState(
       key,
@@ -2189,12 +2179,12 @@ function createRouter(init) {
     }
     fetchControllers.set(key, abortController);
     let originatingLoadId = incrementingLoadId;
-    let results = await callRouterDataStrategy(
+    let results = await callDataStrategy(
       "loader",
+      state,
       fetchRequest,
       [match],
       matches,
-      scopedContext,
       key
     );
     let result = results[match.route.id];
@@ -2296,20 +2286,20 @@ function createRouter(init) {
       });
     }
   }
-  async function callRouterDataStrategy(type, request, matchesToLoad, matches, scopedContext, fetcherKey) {
+  async function callDataStrategy(type, state2, request, matchesToLoad, matches, fetcherKey) {
     let results;
     let dataResults = {};
     try {
       results = await callDataStrategyImpl(
         dataStrategyImpl,
         type,
+        state2,
         request,
         matchesToLoad,
         matches,
         fetcherKey,
         manifest,
-        mapRouteProperties2,
-        scopedContext
+        mapRouteProperties2
       );
     } catch (e) {
       matchesToLoad.forEach((m) => {
@@ -2341,24 +2331,24 @@ function createRouter(init) {
     }
     return dataResults;
   }
-  async function callLoadersAndMaybeResolveData(matches, matchesToLoad, fetchersToLoad, request, scopedContext) {
-    let loaderResultsPromise = callRouterDataStrategy(
+  async function callLoadersAndMaybeResolveData(state2, matches, matchesToLoad, fetchersToLoad, request) {
+    let loaderResultsPromise = callDataStrategy(
       "loader",
+      state2,
       request,
       matchesToLoad,
       matches,
-      scopedContext,
       null
     );
     let fetcherResultsPromise = Promise.all(
       fetchersToLoad.map(async (f) => {
         if (f.matches && f.match && f.controller) {
-          let results = await callRouterDataStrategy(
+          let results = await callDataStrategy(
             "loader",
+            state2,
             createClientSideRequest(init.history, f.path, f.controller.signal),
             [f.match],
             f.matches,
-            scopedContext,
             f.key
           );
           let result = results[f.match.route.id];
@@ -2734,21 +2724,17 @@ function createStaticHandler(routes, opts) {
   );
   async function query(request, {
     requestContext,
-    filterMatchesToLoad,
     skipLoaderErrorBubbling,
-    skipRevalidation,
-    dataStrategy,
-    respond
+    dataStrategy
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
-    let staticContext;
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, { method });
       let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
-      staticContext = {
+      return {
         basename,
         location,
         matches: methodNotAllowedMatches,
@@ -2764,7 +2750,7 @@ function createStaticHandler(routes, opts) {
     } else if (!matches) {
       let error = getInternalRouterError(404, { pathname: location.pathname });
       let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
-      staticContext = {
+      return {
         basename,
         location,
         matches: notFoundMatches,
@@ -2777,118 +2763,25 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
-    } else if (respond) {
-      try {
-        let tailIdx = [...matches].reverse().findIndex((m) => !filterMatchesToLoad || filterMatchesToLoad(m));
-        let lowestLoadingIdx = tailIdx < 0 ? 0 : matches.length - 1 - tailIdx;
-        let renderedStaticContext;
-        let response = await runMiddlewarePipeline(
-          {
-            request,
-            matches,
-            params: matches[0].params,
-            context: requestContext
-          },
-          lowestLoadingIdx,
-          true,
-          async () => {
-            let result = await callQueryHandlers(
-              request,
-              location,
-              matches,
-              requestContext,
-              dataStrategy || defaultDataStrategyWithoutMiddleware,
-              skipLoaderErrorBubbling === true,
-              null,
-              filterMatchesToLoad || null,
-              skipRevalidation === true
-            );
-            if (isResponse(result)) {
-              return result;
-            }
-            renderedStaticContext = {
-              location,
-              basename,
-              ...result
-            };
-            let res = await respond(renderedStaticContext);
-            return res;
-          },
-          async (e) => {
-            if (isResponse(e.error)) {
-              return e.error;
-            }
-            let boundary = findNearestBoundary(matches, e.routeId);
-            let errorContext;
-            if (renderedStaticContext) {
-              if (e.routeId in renderedStaticContext.loaderData) {
-                renderedStaticContext.loaderData[e.routeId] = void 0;
-              }
-              errorContext = getStaticContextFromError(
-                dataRoutes,
-                renderedStaticContext,
-                e.error,
-                boundary.route.id
-              );
-            } else {
-              errorContext = {
-                matches,
-                location,
-                basename,
-                loaderData: {},
-                actionData: null,
-                errors: {
-                  [boundary.route.id]: e.error
-                },
-                statusCode: isRouteErrorResponse(e.error) ? e.error.status : 500,
-                actionHeaders: {},
-                loaderHeaders: {}
-              };
-            }
-            let res = await respond(errorContext);
-            return res;
-          }
-        );
-        invariant(isResponse(response), "Expected a response in query()");
-        return response;
-      } catch (e) {
-        if (isResponse(e)) {
-          return e;
-        }
-        throw e;
-      }
-    } else {
-      let result = await callQueryHandlers(
-        request,
-        location,
-        matches,
-        requestContext,
-        dataStrategy || null,
-        skipLoaderErrorBubbling === true,
-        null,
-        filterMatchesToLoad || null,
-        skipRevalidation === true
-      );
-      if (isResponse(result)) {
-        return result;
-      }
-      staticContext = {
-        location,
-        basename,
-        ...result
-      };
     }
-    if (respond) {
-      let res = await respond(staticContext);
-      return res;
+    let result = await queryImpl(
+      request,
+      location,
+      matches,
+      requestContext,
+      dataStrategy || null,
+      skipLoaderErrorBubbling === true,
+      null
+    );
+    if (isResponse(result)) {
+      return result;
     }
-    return staticContext;
+    return { location, basename, ...result };
   }
   async function queryRoute(request, {
     routeId,
     requestContext,
-    dataStrategy,
-    respond
+    dataStrategy
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
@@ -2908,77 +2801,31 @@ function createStaticHandler(routes, opts) {
     } else if (!match) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
-    if (respond) {
-      let response = await runMiddlewarePipeline(
-        {
-          request,
-          matches,
-          params: matches[0].params,
-          context: requestContext
-        },
-        matches.length - 1,
-        true,
-        async () => {
-          let result = await callQueryHandlers(
-            request,
-            location,
-            matches,
-            requestContext,
-            dataStrategy || defaultDataStrategyWithoutMiddleware,
-            false,
-            match,
-            null,
-            false
-          );
-          if (isResponse(result)) {
-            return respond(result);
-          }
-          let error = result.errors ? Object.values(result.errors)[0] : void 0;
-          if (error !== void 0) {
-            throw error;
-          }
-          throw new Error("Expected a response from queryRoute");
-        },
-        (e) => {
-          if (isResponse(e.error)) {
-            return respond(e.error);
-          }
-          return new Response(String(e.error), {
-            status: 500,
-            statusText: "Unexpected Server Error"
-          });
-        }
-      );
-      return response;
-    } else {
-      let result = await callQueryHandlers(
-        request,
-        location,
-        matches,
-        requestContext,
-        dataStrategy || null,
-        false,
-        match,
-        null,
-        false
-      );
-      if (isResponse(result)) {
-        return result;
-      }
-      let error = result.errors ? Object.values(result.errors)[0] : void 0;
-      if (error !== void 0) {
-        throw error;
-      }
-      if (result.actionData) {
-        return Object.values(result.actionData)[0];
-      }
-      if (result.loaderData) {
-        return Object.values(result.loaderData)[0];
-      }
-      return void 0;
+    let result = await queryImpl(
+      request,
+      location,
+      matches,
+      requestContext,
+      dataStrategy || null,
+      false,
+      match
+    );
+    if (isResponse(result)) {
+      return result;
+    }
+    let error = result.errors ? Object.values(result.errors)[0] : void 0;
+    if (error !== void 0) {
+      throw error;
+    }
+    if (result.actionData) {
+      return Object.values(result.actionData)[0];
     }
+    if (result.loaderData) {
+      return Object.values(result.loaderData)[0];
+    }
+    return void 0;
   }
-  async function callQueryHandlers(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
+  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
     invariant(
       request.signal,
       "query()/queryRoute() requests must contain an AbortController signal"
@@ -2992,9 +2839,7 @@ function createStaticHandler(routes, opts) {
           requestContext,
           dataStrategy,
           skipLoaderErrorBubbling,
-          routeMatch != null,
-          filterMatchesToLoad,
-          skipRevalidation
+          routeMatch != null
         );
         return result2;
       }
@@ -3004,8 +2849,7 @@ function createStaticHandler(routes, opts) {
         requestContext,
         dataStrategy,
         skipLoaderErrorBubbling,
-        routeMatch,
-        filterMatchesToLoad
+        routeMatch
       );
       return isResponse(result) ? result : {
         ...result,
@@ -3025,7 +2869,7 @@ function createStaticHandler(routes, opts) {
       throw e;
     }
   }
-  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest, filterMatchesToLoad, skipRevalidation) {
+  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
     let result;
     if (!actionMatch.route.action && !actionMatch.route.lazy) {
       let error = getInternalRouterError(405, {
@@ -3041,7 +2885,7 @@ function createStaticHandler(routes, opts) {
         error
       };
     } else {
-      let results = await callStaticHandlerDataStrategy(
+      let results = await callDataStrategy(
         "action",
         request,
         [actionMatch],
@@ -3079,36 +2923,6 @@ function createStaticHandler(routes, opts) {
         actionHeaders: {}
       };
     }
-    if (skipRevalidation) {
-      if (isErrorResult(result)) {
-        let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
-        return {
-          matches,
-          loaderData: {},
-          actionData: null,
-          errors: {
-            [boundaryMatch.route.id]: result.error
-          },
-          statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
-          loaderHeaders: {},
-          actionHeaders: {
-            ...result.headers ? { [actionMatch.route.id]: result.headers } : {}
-          }
-        };
-      } else {
-        return {
-          matches,
-          loaderData: {},
-          actionData: {
-            [actionMatch.route.id]: result.data
-          },
-          errors: null,
-          statusCode: result.statusCode || 200,
-          loaderHeaders: {},
-          actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
-        };
-      }
-    }
     let loaderRequest = new Request(request.url, {
       headers: request.headers,
       redirect: request.redirect,
@@ -3116,18 +2930,17 @@ function createStaticHandler(routes, opts) {
     });
     if (isErrorResult(result)) {
       let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
-      let handlerContext2 = await loadRouteData(
+      let context2 = await loadRouteData(
         loaderRequest,
         matches,
         requestContext,
         dataStrategy,
         skipLoaderErrorBubbling,
         null,
-        filterMatchesToLoad,
         [boundaryMatch.route.id, result]
       );
       return {
-        ...handlerContext2,
+        ...context2,
         statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
         actionData: null,
         actionHeaders: {
@@ -3135,17 +2948,16 @@ function createStaticHandler(routes, opts) {
         }
       };
     }
-    let handlerContext = await loadRouteData(
+    let context = await loadRouteData(
       loaderRequest,
       matches,
       requestContext,
       dataStrategy,
       skipLoaderErrorBubbling,
-      null,
-      filterMatchesToLoad
+      null
     );
     return {
-      ...handlerContext,
+      ...context,
       actionData: {
         [actionMatch.route.id]: result.data
       },
@@ -3154,7 +2966,7 @@ function createStaticHandler(routes, opts) {
       actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
     };
   }
-  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, pendingActionResult) {
+  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
     let isRouteRequest = routeMatch != null;
     if (isRouteRequest && !routeMatch?.route.loader && !routeMatch?.route.lazy) {
       throw getInternalRouterError(400, {
@@ -3165,7 +2977,7 @@ function createStaticHandler(routes, opts) {
     }
     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))
+      (m) => m.route.loader || m.route.lazy
     );
     if (matchesToLoad.length === 0) {
       return {
@@ -3182,7 +2994,7 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {}
       };
     }
-    let results = await callStaticHandlerDataStrategy(
+    let results = await callDataStrategy(
       "loader",
       request,
       matchesToLoad,
@@ -3194,7 +3006,7 @@ function createStaticHandler(routes, opts) {
     if (request.signal.aborted) {
       throwStaticHandlerAbortedError(request, isRouteRequest);
     }
-    let handlerContext = processRouteLoaderData(
+    let context = processRouteLoaderData(
       matches,
       results,
       pendingActionResult,
@@ -3206,18 +3018,19 @@ function createStaticHandler(routes, opts) {
     );
     matches.forEach((match) => {
       if (!executedLoaders.has(match.route.id)) {
-        handlerContext.loaderData[match.route.id] = null;
+        context.loaderData[match.route.id] = null;
       }
     });
     return {
-      ...handlerContext,
+      ...context,
       matches
     };
   }
-  async function callStaticHandlerDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
     let results = await callDataStrategyImpl(
       dataStrategy || defaultDataStrategy,
       type,
+      null,
       request,
       matchesToLoad,
       matches,
@@ -3257,15 +3070,15 @@ function createStaticHandler(routes, opts) {
     queryRoute
   };
 }
-function getStaticContextFromError(routes, handlerContext, error, boundaryId) {
-  let errorBoundaryId = boundaryId || handlerContext._deepestRenderedBoundaryId || routes[0].id;
-  return {
-    ...handlerContext,
+function getStaticContextFromError(routes, context, error) {
+  let newContext = {
+    ...context,
     statusCode: isRouteErrorResponse(error) ? error.status : 500,
     errors: {
-      [errorBoundaryId]: error
+      [context._deepestRenderedBoundaryId || routes[0].id]: error
     }
   };
+  return newContext;
 }
 function throwStaticHandlerAbortedError(request, isRouteRequest) {
   if (request.signal.reason !== void 0) {
@@ -3658,141 +3471,20 @@ async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
     lazy: void 0
   });
 }
-async function defaultDataStrategyWithoutMiddleware(args) {
-  let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
-  let keyedResults = {};
+async function defaultDataStrategy({
+  matches
+}) {
+  let matchesToLoad = matches.filter((m) => m.shouldLoad);
   let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
-  results.forEach((result, i) => {
-    keyedResults[matchesToLoad[i].route.id] = result;
-  });
-  return keyedResults;
-}
-async function defaultDataStrategy(args) {
-  let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
-  let lastIndex = args.matches.length - 1;
-  for (let i = lastIndex; i >= 0; i--) {
-    if (args.matches[i].shouldLoad) {
-      lastIndex = i;
-      break;
-    }
-  }
-  let results = await runMiddlewarePipeline(
-    args,
-    lastIndex,
-    false,
-    async (keyedResults) => {
-      let results2 = await Promise.all(matchesToLoad.map((m) => m.resolve()));
-      results2.forEach((result, i) => {
-        keyedResults[matchesToLoad[i].route.id] = result;
-      });
-    },
-    (e, keyedResults) => {
-      Object.assign(keyedResults, {
-        [e.routeId]: { type: "error", result: e.error }
-      });
-    }
+  return results.reduce(
+    (acc, result, i) => Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
+    {}
   );
-  return results;
-}
-async function runMiddlewarePipeline({
-  request,
-  params,
-  context,
-  matches
-}, lastIndex, propagateResult, handler, errorHandler) {
-  let middlewareState = {
-    keyedResults: {},
-    propagateResult
-  };
-  try {
-    let result = await callRouteMiddleware(
-      matches.slice(0, lastIndex + 1).flatMap(
-        (m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []
-      ),
-      0,
-      { request, params, context },
-      middlewareState,
-      handler
-    );
-    return middlewareState.propagateResult ? result : middlewareState.keyedResults;
-  } catch (e) {
-    if (!(e instanceof MiddlewareError)) {
-      throw e;
-    }
-    if (propagateResult && isResponse(e.error)) {
-      throw e.error;
-    }
-    let result = await errorHandler(e, middlewareState.keyedResults);
-    return middlewareState.propagateResult ? result : middlewareState.keyedResults;
-  }
 }
-var MiddlewareError = class {
-  constructor(routeId, error) {
-    this.routeId = routeId;
-    this.error = error;
-  }
-};
-async function callRouteMiddleware(middlewares, idx, args, middlewareState, handler) {
-  let { request } = args;
-  if (request.signal.aborted) {
-    if (request.signal.reason) {
-      throw request.signal.reason;
-    }
-    throw new Error(
-      `Request aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`
-    );
-  }
-  let tuple = middlewares[idx];
-  if (!tuple) {
-    let result = await handler(middlewareState.keyedResults);
-    return result;
-  }
-  let [routeId, middleware] = tuple;
-  let nextCalled = false;
-  let next = async () => {
-    if (nextCalled) {
-      throw new Error("You may only call `next()` once per middleware");
-    }
-    nextCalled = true;
-    let result = await callRouteMiddleware(
-      middlewares,
-      idx + 1,
-      args,
-      middlewareState,
-      handler
-    );
-    if (middlewareState.propagateResult) {
-      return result;
-    }
-  };
-  try {
-    let result = await middleware({
-      request: args.request,
-      params: args.params,
-      context: args.context,
-      next
-    });
-    return nextCalled ? result : next();
-  } catch (e) {
-    if (e instanceof MiddlewareError) {
-      throw e;
-    }
-    throw new MiddlewareError(routeId, e);
-  }
-}
-async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, scopedContext) {
+async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, requestContext) {
   let loadRouteDefinitionsPromises = matches.map(
     (m) => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties2, manifest) : void 0
   );
-  let lazyMiddlewarePromises = matches.map(
-    (m, i) => m.route.lazy && !("middleware" in m.route) ? (
-      // Swallow the error here, let it bubble up from resolve()
-      loadRouteDefinitionsPromises[i].catch((e) => e)
-    ) : null
-  ).filter((p) => p != null);
-  if (lazyMiddlewarePromises.length > 0) {
-    await Promise.all(lazyMiddlewarePromises);
-  }
   let dsMatches = matches.map((match, i) => {
     let loadRoutePromise = loadRouteDefinitionsPromises[i];
     let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
@@ -3806,7 +3498,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
         match,
         loadRoutePromise,
         handlerOverride,
-        scopedContext
+        requestContext
       ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
@@ -3820,7 +3512,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
     request,
     params: matches[0].params,
     fetcherKey,
-    context: scopedContext
+    context: requestContext
   });
   try {
     await Promise.all(loadRouteDefinitionsPromises);
@@ -3828,7 +3520,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLo
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
+async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3848,7 +3540,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
         {
           request,
           params: match.params,
-          context: scopedContext
+          context: staticContext
         },
         ...ctx !== void 0 ? [ctx] : []
       );
@@ -3955,14 +3647,20 @@ async function convertDataStrategyResultToDataResult(dataStrategyResult) {
         return {
           type: "error" /* error */,
           error: result.data,
-          statusCode: result.init?.status
+          statusCode: result.init?.status,
+          headers: result.init?.headers ? new Headers(result.init.headers) : void 0
         };
       }
-      result = new ErrorResponseImpl(
-        result.init?.status || 500,
-        void 0,
-        result.data
-      );
+      return {
+        type: "error" /* error */,
+        error: new ErrorResponseImpl(
+          result.init?.status || 500,
+          void 0,
+          result.data
+        ),
+        statusCode: isRouteErrorResponse(result) ? result.status : void 0,
+        headers: result.init?.headers ? new Headers(result.init.headers) : void 0
+      };
     }
     return {
       type: "error" /* error */,
@@ -4699,7 +4397,7 @@ Please change the parent <Route path="${parentPath}"> to <Route path="${parentPa
     let segments = pathname.replace(/^\//, "").split("/");
     remainingPathname = "/" + segments.slice(parentSegments.length).join("/");
   }
-  let matches = matchRoutes(routes, { pathname: remainingPathname });
+  let matches = dataRouterState && dataRouterState.matches && dataRouterState.matches.length > 0 ? dataRouterState.matches : matchRoutes(routes, { pathname: remainingPathname });
   if (ENABLE_DEV_WARNINGS) {
     warning(
       parentRoute || matches != null,
@@ -5155,7 +4853,6 @@ function mapRouteProperties(route) {
 function createMemoryRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    context: opts?.context,
     future: opts?.future,
     history: createMemoryHistory({
       initialEntries: opts?.initialEntries,
@@ -5807,7 +5504,7 @@ function getKeyedLinksForMatches(matches, routeModules, manifest) {
       module2?.links?.() || []
     ];
   }).flat(2);
-  let preloads = getCurrentPageModulePreloadHrefs(matches, manifest);
+  let preloads = getModuleLinkHrefs(matches, manifest);
   return dedupeLinkDescriptors(descriptors, preloads);
 }
 async function prefetchStyleLinks(route, routeModule) {
@@ -5931,25 +5628,21 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
   }
   return [];
 }
-function getModuleLinkHrefs(matches, manifestPatch) {
-  return dedupeHrefs(
-    matches.map((match) => {
-      let route = manifestPatch.routes[match.route.id];
-      if (!route) return [];
-      let hrefs = [route.module];
-      if (route.imports) {
-        hrefs = hrefs.concat(route.imports);
-      }
-      return hrefs;
-    }).flat(1)
-  );
-}
-function getCurrentPageModulePreloadHrefs(matches, manifest) {
+function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
   return dedupeHrefs(
     matches.map((match) => {
       let route = manifest.routes[match.route.id];
       if (!route) return [];
       let hrefs = [route.module];
+      if (route.clientActionModule) {
+        hrefs = hrefs.concat(route.clientActionModule);
+      }
+      if (route.clientLoaderModule) {
+        hrefs = hrefs.concat(route.clientLoaderModule);
+      }
+      if (includeHydrateFallback && route.hydrateFallbackModule) {
+        hrefs = hrefs.concat(route.hydrateFallbackModule);
+      }
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
       }
@@ -6104,63 +5797,21 @@ function StreamTransfer({
     )));
   }
 }
-function middlewareErrorHandler(e, keyedResults) {
-  Object.assign(keyedResults, {
-    [e.routeId]: { type: "error", result: e.error }
-  });
-}
 function getSingleFetchDataStrategy(manifest, routeModules, getRouter) {
-  return async (args) => {
-    let { request, matches, fetcherKey } = args;
+  return async ({ request, matches, fetcherKey }) => {
     if (request.method !== "GET") {
-      return runMiddlewarePipeline(
-        args,
-        matches.findIndex((m) => m.shouldLoad),
-        false,
-        async (keyedResults) => {
-          let results = await singleFetchActionStrategy(request, matches);
-          Object.assign(keyedResults, results);
-        },
-        middlewareErrorHandler
-      );
+      return singleFetchActionStrategy(request, matches);
     }
     if (fetcherKey) {
-      return runMiddlewarePipeline(
-        args,
-        matches.findIndex((m) => m.shouldLoad),
-        false,
-        async (keyedResults) => {
-          let results = await singleFetchLoaderFetcherStrategy(
-            request,
-            matches
-          );
-          Object.assign(keyedResults, results);
-        },
-        middlewareErrorHandler
-      );
+      return singleFetchLoaderFetcherStrategy(request, matches);
     }
-    let lowestLoadingIndex = getLowestLoadingIndex(
+    return singleFetchLoaderNavigationStrategy(
       manifest,
       routeModules,
       getRouter(),
+      request,
       matches
     );
-    return runMiddlewarePipeline(
-      args,
-      lowestLoadingIndex,
-      false,
-      async (keyedResults) => {
-        let results = await singleFetchLoaderNavigationStrategy(
-          manifest,
-          routeModules,
-          getRouter(),
-          request,
-          matches
-        );
-        Object.assign(keyedResults, results);
-      },
-      middlewareErrorHandler
-    );
   };
 }
 async function singleFetchActionStrategy(request, matches) {
@@ -6190,20 +5841,6 @@ async function singleFetchActionStrategy(request, matches) {
     }
   };
 }
-function isOptedOut(manifestRoute, routeModule, match, router) {
-  return match.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && routeModule && routeModule.shouldRevalidate;
-}
-function getLowestLoadingIndex(manifest, routeModules, router, matches) {
-  let tailIdx = [...matches].reverse().findIndex(
-    (m) => m.shouldLoad || !isOptedOut(
-      manifest.routes[m.route.id],
-      routeModules[m.route.id],
-      m,
-      router
-    )
-  );
-  return tailIdx < 0 ? 0 : matches.length - 1 - tailIdx;
-}
 async function singleFetchLoaderNavigationStrategy(manifest, routeModules, router, request, matches) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
@@ -6222,7 +5859,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
           if (!router.state.initialized) {
             return;
           }
-          if (isOptedOut(manifestRoute, routeModules[m.route.id], m, router)) {
+          if (m.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && routeModules[m.route.id]?.shouldRevalidate) {
             foundOptOutRoute = true;
             return;
           }
@@ -6622,8 +6259,8 @@ function createServerRoutes(manifest, routeModules, future, isSpaMode, parentId
       // render, so just give it a no-op function so we can render down to the
       // proper fallback
       loader: route.hasLoader || route.hasClientLoader ? () => null : void 0
-      // We don't need middleware/action/shouldRevalidate on these routes since
-      // they're for a static render
+      // We don't need action/shouldRevalidate on these routes since they're
+      // for a static render
     };
     let children = createServerRoutes(
       manifest,
@@ -6689,6 +6326,21 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       }
       return fetchServerHandler(singleFetch);
     }
+    function prefetchModule(modulePath) {
+      import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        modulePath
+      );
+    }
+    function prefetchRouteModuleChunks(route2) {
+      if (route2.clientActionModule) {
+        prefetchModule(route2.clientActionModule);
+      }
+      if (route2.clientLoaderModule) {
+        prefetchModule(route2.clientLoaderModule);
+      }
+    }
     async function prefetchStylesAndCallHandler(handler) {
       let cachedModule = routeModulesCache[route.id];
       let linkPrefetchPromise = cachedModule ? prefetchStyleLinks(route, cachedModule) : Promise.resolve();
@@ -6707,7 +6359,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       Object.assign(dataRoute, {
         ...dataRoute,
         ...getRouteComponents(route, routeModule, isSpaMode),
-        middleware: routeModule.clientMiddleware,
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
           routeModule,
@@ -6720,7 +6371,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       let hasInitialError = initialState && initialState.errors && route.id in initialState.errors;
       let initialError = hasInitialError ? initialState?.errors?.[route.id] : void 0;
       let isHydrationRequest = needsRevalidation == null && (routeModule.clientLoader?.hydrate === true || !route.hasLoader);
-      dataRoute.loader = async ({ request, params, context }, singleFetch) => {
+      dataRoute.loader = async ({ request, params }, singleFetch) => {
         try {
           let result = await prefetchStylesAndCallHandler(async () => {
             invariant2(
@@ -6734,7 +6385,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
             return routeModule.clientLoader({
               request,
               params,
-              context,
               async serverLoader() {
                 preventInvalidServerHandlerCall("loader", route, isSpaMode);
                 if (isHydrationRequest) {
@@ -6759,7 +6409,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
         routeModule,
         isSpaMode
       );
-      dataRoute.action = ({ request, params, context }, singleFetch) => {
+      dataRoute.action = ({ request, params }, singleFetch) => {
         return prefetchStylesAndCallHandler(async () => {
           invariant2(
             routeModule,
@@ -6774,7 +6424,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           return routeModule.clientAction({
             request,
             params,
-            context,
             async serverAction() {
               preventInvalidServerHandlerCall("action", route, isSpaMode);
               return fetchServerAction(singleFetch);
@@ -6784,26 +6433,64 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       };
     } else {
       if (!route.hasClientLoader) {
-        dataRoute.loader = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
+        dataRoute.loader = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
           if (isSpaMode) return Promise.resolve(null);
           return fetchServerLoader(singleFetch);
         });
+      } else if (route.clientLoaderModule) {
+        dataRoute.loader = async (args, singleFetch) => {
+          invariant2(route.clientLoaderModule);
+          let { clientLoader } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientLoaderModule
+          );
+          return clientLoader({
+            ...args,
+            async serverLoader() {
+              preventInvalidServerHandlerCall("loader", route, isSpaMode);
+              return fetchServerLoader(singleFetch);
+            }
+          });
+        };
       }
       if (!route.hasClientAction) {
-        dataRoute.action = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
+        dataRoute.action = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
           if (isSpaMode) {
             throw noActionDefinedError("clientAction", route.id);
           }
           return fetchServerAction(singleFetch);
         });
+      } else if (route.clientActionModule) {
+        dataRoute.action = async (args, singleFetch) => {
+          invariant2(route.clientActionModule);
+          prefetchRouteModuleChunks(route);
+          let { clientAction } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientActionModule
+          );
+          return clientAction({
+            ...args,
+            async serverAction() {
+              preventInvalidServerHandlerCall("action", route, isSpaMode);
+              return fetchServerAction(singleFetch);
+            }
+          });
+        };
       }
       dataRoute.lazy = async () => {
-        let mod = await loadRouteModuleWithBlockingLinks(
+        if (route.clientLoaderModule || route.clientActionModule) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        let modPromise = loadRouteModuleWithBlockingLinks(
           route,
           routeModulesCache
         );
+        prefetchRouteModuleChunks(route);
+        let mod = await modPromise;
         let lazyRoute = { ...mod };
-        if (mod.clientLoader) {
+        if (mod.clientLoader && !route.clientLoaderModule) {
           let clientLoader = mod.clientLoader;
           lazyRoute.loader = (args, singleFetch) => clientLoader({
             ...args,
@@ -6813,7 +6500,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
             }
           });
         }
-        if (mod.clientAction) {
+        if (mod.clientAction && !route.clientActionModule) {
           let clientAction = mod.clientAction;
           lazyRoute.action = (args, singleFetch) => clientAction({
             ...args,
@@ -6826,7 +6513,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
         return {
           ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
           ...lazyRoute.action ? { action: lazyRoute.action } : {},
-          middleware: mod.clientMiddleware,
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
@@ -6884,7 +6570,6 @@ async function loadRouteModuleWithBlockingLinks(route, routeModules) {
   return {
     Component: getRouteModuleComponent(routeModule),
     ErrorBoundary: routeModule.ErrorBoundary,
-    clientMiddleware: routeModule.clientMiddleware,
     clientAction: routeModule.clientAction,
     clientLoader: routeModule.clientLoader,
     handle: routeModule.handle,
@@ -7407,11 +7092,44 @@ function Scripts(props) {
     let streamScript = "window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());";
     let contextScript = staticContext ? `window.__reactRouterContext = ${serverHandoffString};${streamScript}` : " ";
     let routeModulesScript = !isStatic ? " " : `${manifest.hmr?.runtime ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
-${matches.map(
-      (match, index) => `import * as route${index} from ${JSON.stringify(
-        manifest.routes[match.route.id].module
-      )};`
-    ).join("\n")}
+${matches.map((match, routeIndex) => {
+      let routeVarName = `route${routeIndex}`;
+      let manifestEntry = manifest.routes[match.route.id];
+      invariant2(manifestEntry, `Route ${match.route.id} not found in manifest`);
+      let {
+        clientActionModule,
+        clientLoaderModule,
+        hydrateFallbackModule,
+        module: module2
+      } = manifestEntry;
+      let chunks = [
+        ...clientActionModule ? [
+          {
+            module: clientActionModule,
+            varName: `${routeVarName}_clientAction`
+          }
+        ] : [],
+        ...clientLoaderModule ? [
+          {
+            module: clientLoaderModule,
+            varName: `${routeVarName}_clientLoader`
+          }
+        ] : [],
+        ...hydrateFallbackModule ? [
+          {
+            module: hydrateFallbackModule,
+            varName: `${routeVarName}_HydrateFallback`
+          }
+        ] : [],
+        { module: module2, varName: `${routeVarName}_main` }
+      ];
+      if (chunks.length === 1) {
+        return `import * as ${routeVarName} from ${JSON.stringify(module2)};`;
+      }
+      let chunkImportsSnippet = chunks.map((chunk) => `import * as ${chunk.varName} from "${chunk.module}";`).join("\n");
+      let mergedChunksSnippet = `const ${routeVarName} = {${chunks.map((chunk) => `...${chunk.varName}`).join(",")}};`;
+      return [chunkImportsSnippet, mergedChunksSnippet].join("\n");
+    }).join("\n")}
   ${enableFogOfWar ? (
       // Inline a minimal manifest with the SSR matches
       `window.__reactRouterManifest = ${JSON.stringify(
@@ -7442,11 +7160,11 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let routePreloads = matches.map((match) => {
-    let route = manifest.routes[match.route.id];
-    return route ? (route.imports || []).concat([route.module]) : [];
-  }).flat(1);
-  let preloads = isHydrated ? [] : manifest.entry.imports.concat(routePreloads);
+  let preloads = isHydrated ? [] : manifest.entry.imports.concat(
+    getModuleLinkHrefs(matches, manifest, {
+      includeHydrateFallback: true
+    })
+  );
   return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
     "link",
     {
@@ -7490,14 +7208,13 @@ 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-beaa4f52a";
+    window.__reactRouterVersion = "0.0.0-experimental-df0f1dfda";
   }
 } catch (e) {
 }
 function createBrowserRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    context: opts?.context,
     future: opts?.future,
     history: createBrowserHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -7511,7 +7228,6 @@ function createBrowserRouter(routes, opts) {
 function createHashRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
-    context: opts?.context,
     future: opts?.future,
     history: createHashHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -8653,14 +8369,13 @@ function createRoutesStub(routes, context = {}) {
         isSpaMode: false
       };
       let patched = processRoutes(
-        // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
-        // types compared to `AgnosticRouteObject`
+        // @ts-expect-error loader/action context types don't match :/
         convertRoutesToDataRoutes(routes, (r) => r),
+        context,
         remixContextRef.current.manifest,
         remixContextRef.current.routeModules
       );
       routerRef.current = createMemoryRouter(patched, {
-        context,
         initialEntries,
         initialIndex,
         hydrationData
@@ -8669,13 +8384,14 @@ function createRoutesStub(routes, context = {}) {
     return /* @__PURE__ */ React13.createElement(FrameworkContext.Provider, { value: remixContextRef.current }, /* @__PURE__ */ React13.createElement(RouterProvider, { router: routerRef.current }));
   };
 }
-function processRoutes(routes, manifest, routeModules, parentId) {
+function processRoutes(routes, context, manifest, routeModules, parentId) {
   return routes.map((route) => {
     if (!route.id) {
       throw new Error(
         "Expected a route.id in @remix-run/testing processRoutes() function"
       );
     }
+    let { loader, action } = route;
     let newRoute = {
       id: route.id,
       path: route.path,
@@ -8683,8 +8399,8 @@ function processRoutes(routes, manifest, routeModules, parentId) {
       Component: route.Component,
       HydrateFallback: route.HydrateFallback,
       ErrorBoundary: route.ErrorBoundary,
-      action: route.action,
-      loader: route.loader,
+      action: action ? (args) => action({ ...args, context }) : void 0,
+      loader: loader ? (args) => loader({ ...args, context }) : void 0,
       handle: route.handle,
       shouldRevalidate: route.shouldRevalidate
     };
@@ -8701,8 +8417,11 @@ function processRoutes(routes, manifest, routeModules, parentId) {
       hasClientAction: false,
       hasClientLoader: false,
       hasErrorBoundary: route.ErrorBoundary != null,
-      module: "build/stub-path-to-module.js"
-      // any need for this?
+      // any need for these?
+      module: "build/stub-path-to-module.js",
+      clientActionModule: void 0,
+      clientLoaderModule: void 0,
+      hydrateFallbackModule: void 0
     };
     manifest.routes[newRoute.id] = entryRoute;
     routeModules[route.id] = {
@@ -8716,6 +8435,7 @@ function processRoutes(routes, manifest, routeModules, parentId) {
     if (route.children) {
       newRoute.children = processRoutes(
         route.children,
+        context,
         manifest,
         routeModules,
         newRoute.id
@@ -9076,7 +8796,6 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
       hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
       id: route.id,
       path: route.path,
-      middleware: route.module.middleware,
       // Need to use RR's version in the param typed here to permit the optional
       // context even though we know it'll always be provided in remix
       loader: route.module.loader ? async (args) => {
@@ -9212,15 +8931,35 @@ function prependCookies(parentHeaders, childHeaders) {
   let parentSetCookieString = parentHeaders.get("Set-Cookie");
   if (parentSetCookieString) {
     let cookies = (0, import_set_cookie_parser.splitCookiesString)(parentSetCookieString);
+    let childCookies = new Set(childHeaders.getSetCookie());
     cookies.forEach((cookie) => {
-      childHeaders.append("Set-Cookie", cookie);
+      if (!childCookies.has(cookie)) {
+        childHeaders.append("Set-Cookie", cookie);
+      }
     });
   }
 }
 
 // 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;
+function getSingleFetchDataStrategy2({
+  isActionDataRequest,
+  loadRouteIds
+} = {}) {
+  return async ({ request, matches }) => {
+    if (isActionDataRequest && request.method === "GET") {
+      return {};
+    }
+    let matchesToLoad = loadRouteIds ? matches.filter((m) => loadRouteIds.includes(m.route.id)) : matches;
+    let results = await Promise.all(
+      matchesToLoad.map((match) => match.resolve())
+    );
+    return results.reduce(
+      (acc, result, i) => Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
+      {}
+    );
+  };
+}
 async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
   try {
     let handlerRequest = new Request(handlerUrl, {
@@ -9233,46 +8972,12 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
       skipLoaderErrorBubbling: true,
-      skipRevalidation: true,
-      async respond(context) {
-        let headers = getDocumentHeaders(build, context);
-        if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-          return generateSingleFetchResponse(request, build, serverMode, {
-            result: getSingleFetchRedirect(
-              context.statusCode,
-              headers,
-              build.basename
-            ),
-            headers,
-            status: SINGLE_FETCH_REDIRECT_STATUS
-          });
-        }
-        if (context.errors) {
-          Object.values(context.errors).forEach((err) => {
-            if (!isRouteErrorResponse(err) || err.error) {
-              handleError(err);
-            }
-          });
-          context.errors = sanitizeErrors(context.errors, serverMode);
-        }
-        let singleFetchResult;
-        if (context.errors) {
-          singleFetchResult = { error: Object.values(context.errors)[0] };
-        } else {
-          singleFetchResult = {
-            data: Object.values(context.actionData || {})[0]
-          };
-        }
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: singleFetchResult,
-          headers,
-          status: context.statusCode
-        });
-      }
+      dataStrategy: getSingleFetchDataStrategy2({
+        isActionDataRequest: true
+      })
     });
-    invariant3(isResponse(result), "Expected a Response from query()");
-    if (isRedirectResponse(result)) {
-      return generateSingleFetchResponse(request, build, serverMode, {
+    if (isResponse(result)) {
+      return {
         result: getSingleFetchRedirect(
           result.status,
           result.headers,
@@ -9280,16 +8985,47 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
         ),
         headers: result.headers,
         status: SINGLE_FETCH_REDIRECT_STATUS
+      };
+    }
+    let context = result;
+    let headers = getDocumentHeaders(build, context);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
+      return {
+        result: getSingleFetchRedirect(
+          context.statusCode,
+          headers,
+          build.basename
+        ),
+        headers,
+        status: SINGLE_FETCH_REDIRECT_STATUS
+      };
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
       });
+      context.errors = sanitizeErrors(context.errors, serverMode);
     }
-    return result;
+    let singleFetchResult;
+    if (context.errors) {
+      singleFetchResult = { error: Object.values(context.errors)[0] };
+    } else {
+      singleFetchResult = { data: Object.values(context.actionData || {})[0] };
+    }
+    return {
+      result: singleFetchResult,
+      headers,
+      status: context.statusCode
+    };
   } catch (error) {
     handleError(error);
-    return generateSingleFetchResponse(request, build, serverMode, {
+    return {
       result: { error },
       headers: new Headers(),
       status: 500
-    });
+    };
   }
 }
 async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
@@ -9298,61 +9034,16 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
       headers: request.headers,
       signal: request.signal
     });
-    let routesParam = new URL(request.url).searchParams.get("_routes");
-    let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
+    let loadRouteIds = new URL(request.url).searchParams.get("_routes")?.split(",") || void 0;
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
-      filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
       skipLoaderErrorBubbling: true,
-      async respond(context) {
-        let headers = getDocumentHeaders(build, context);
-        if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-          return generateSingleFetchResponse(request, build, serverMode, {
-            result: {
-              [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
-                context.statusCode,
-                headers,
-                build.basename
-              )
-            },
-            headers,
-            status: SINGLE_FETCH_REDIRECT_STATUS
-          });
-        }
-        if (context.errors) {
-          Object.values(context.errors).forEach((err) => {
-            if (!isRouteErrorResponse(err) || err.error) {
-              handleError(err);
-            }
-          });
-          context.errors = sanitizeErrors(context.errors, serverMode);
-        }
-        let results = {};
-        let loadedMatches = new Set(
-          context.matches.filter(
-            (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
-          ).map((m) => m.route.id)
-        );
-        if (context.errors) {
-          for (let [id, error] of Object.entries(context.errors)) {
-            results[id] = { error };
-          }
-        }
-        for (let [id, data2] of Object.entries(context.loaderData)) {
-          if (!(id in results) && loadedMatches.has(id)) {
-            results[id] = { data: data2 };
-          }
-        }
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: results,
-          headers,
-          status: context.statusCode
-        });
-      }
+      dataStrategy: getSingleFetchDataStrategy2({
+        loadRouteIds
+      })
     });
-    invariant3(isResponse(result), "Expected a Response from query()");
-    if (isRedirectResponse(result)) {
-      return generateSingleFetchResponse(request, build, serverMode, {
+    if (isResponse(result)) {
+      return {
         result: {
           [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
             result.status,
@@ -9362,41 +9053,56 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
         },
         headers: result.headers,
         status: SINGLE_FETCH_REDIRECT_STATUS
+      };
+    }
+    let context = result;
+    let headers = getDocumentHeaders(build, context);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
+      return {
+        result: {
+          [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
+            context.statusCode,
+            headers,
+            build.basename
+          )
+        },
+        headers,
+        status: SINGLE_FETCH_REDIRECT_STATUS
+      };
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
       });
+      context.errors = sanitizeErrors(context.errors, serverMode);
     }
-    return result;
+    let results = {};
+    let loadedMatches = loadRouteIds ? context.matches.filter(
+      (m) => m.route.loader && loadRouteIds.includes(m.route.id)
+    ) : context.matches;
+    loadedMatches.forEach((m) => {
+      let { id } = m.route;
+      if (context.errors && context.errors.hasOwnProperty(id)) {
+        results[id] = { error: context.errors[id] };
+      } else if (context.loaderData.hasOwnProperty(id)) {
+        results[id] = { data: context.loaderData[id] };
+      }
+    });
+    return {
+      result: results,
+      headers,
+      status: context.statusCode
+    };
   } catch (error) {
     handleError(error);
-    return generateSingleFetchResponse(request, build, serverMode, {
+    return {
       result: { root: { error } },
       headers: new Headers(),
       status: 500
-    });
-  }
-}
-function generateSingleFetchResponse(request, build, serverMode, {
-  result,
-  headers,
-  status
-}) {
-  let resultHeaders = new Headers(headers);
-  resultHeaders.set("X-Remix-Response", "yes");
-  if (NO_BODY_STATUS_CODES.has(status)) {
-    return new Response(null, { status, headers: resultHeaders });
+    };
   }
-  resultHeaders.set("Content-Type", "text/x-script");
-  return new Response(
-    encodeViaTurboStream(
-      result,
-      request.signal,
-      build.entry.module.streamTimeout,
-      serverMode
-    ),
-    {
-      status: status || 200,
-      headers: resultHeaders
-    }
-  );
 }
 function getSingleFetchRedirect(status, headers, basename) {
   let redirect2 = headers.get("Location");
@@ -9459,6 +9165,7 @@ function encodeViaTurboStream(data2, requestSignal, streamTimeout, serverMode) {
 }
 
 // lib/server-runtime/server.ts
+var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205, 304]);
 function derive(build, mode) {
   let routes = createRoutes(build.routes);
   let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
@@ -9638,7 +9345,7 @@ async function handleManifestRequest(build, routes, url) {
   return new Response("Invalid Request", { status: 400 });
 }
 async function handleSingleFetchRequest(serverMode, build, staticHandler, request, handlerUrl, loadContext, handleError) {
-  let response = request.method !== "GET" ? await singleFetchAction(
+  let { result, headers, status } = request.method !== "GET" ? await singleFetchAction(
     build,
     serverMode,
     staticHandler,
@@ -9655,67 +9362,129 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
     loadContext,
     handleError
   );
-  return response;
+  let resultHeaders = new Headers(headers);
+  resultHeaders.set("X-Remix-Response", "yes");
+  if (NO_BODY_STATUS_CODES.has(status)) {
+    return new Response(null, { status, headers: resultHeaders });
+  }
+  resultHeaders.set("Content-Type", "text/x-script");
+  return new Response(
+    encodeViaTurboStream(
+      result,
+      request.signal,
+      build.entry.module.streamTimeout,
+      serverMode
+    ),
+    {
+      status: status || 200,
+      headers: resultHeaders
+    }
+  );
 }
 async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, criticalCss) {
+  let context;
   try {
-    let response = await staticHandler.query(request, {
-      requestContext: loadContext,
-      respond: renderHtml
+    context = await staticHandler.query(request, {
+      requestContext: loadContext
     });
-    invariant3(
-      isResponse(response),
-      "Expected a Response to be returned from query"
-    );
-    return response;
   } catch (error) {
     handleError(error);
     return new Response(null, { status: 500 });
   }
-  async function renderHtml(context) {
-    if (isResponse(context)) {
-      return context;
-    }
-    let headers = getDocumentHeaders(build, context);
-    if (NO_BODY_STATUS_CODES.has(context.statusCode)) {
-      return new Response(null, { status: context.statusCode, headers });
+  if (isResponse(context)) {
+    return context;
+  }
+  let headers = getDocumentHeaders(build, context);
+  if (NO_BODY_STATUS_CODES.has(context.statusCode)) {
+    return new Response(null, { status: context.statusCode, headers });
+  }
+  if (context.errors) {
+    Object.values(context.errors).forEach((err) => {
+      if (!isRouteErrorResponse(err) || err.error) {
+        handleError(err);
+      }
+    });
+    context.errors = sanitizeErrors(context.errors, serverMode);
+  }
+  let state = {
+    loaderData: context.loaderData,
+    actionData: context.actionData,
+    errors: serializeErrors2(context.errors, serverMode)
+  };
+  let entryContext = {
+    manifest: build.assets,
+    routeModules: createEntryRouteModules(build.routes),
+    staticHandlerContext: context,
+    criticalCss,
+    serverHandoffString: createServerHandoffString({
+      basename: build.basename,
+      criticalCss,
+      future: build.future,
+      isSpaMode: build.isSpaMode
+    }),
+    serverHandoffStream: encodeViaTurboStream(
+      state,
+      request.signal,
+      build.entry.module.streamTimeout,
+      serverMode
+    ),
+    renderMeta: {},
+    future: build.future,
+    isSpaMode: build.isSpaMode,
+    serializeError: (err) => serializeError(err, serverMode)
+  };
+  let handleDocumentRequestFunction = build.entry.module.default;
+  try {
+    return await handleDocumentRequestFunction(
+      request,
+      context.statusCode,
+      headers,
+      entryContext,
+      loadContext
+    );
+  } catch (error) {
+    handleError(error);
+    let errorForSecondRender = error;
+    if (isResponse(error)) {
+      try {
+        let data2 = await unwrapResponse(error);
+        errorForSecondRender = new ErrorResponseImpl(
+          error.status,
+          error.statusText,
+          data2
+        );
+      } catch (e) {
+      }
     }
+    context = getStaticContextFromError(
+      staticHandler.dataRoutes,
+      context,
+      errorForSecondRender
+    );
     if (context.errors) {
-      Object.values(context.errors).forEach((err) => {
-        if (!isRouteErrorResponse(err) || err.error) {
-          handleError(err);
-        }
-      });
       context.errors = sanitizeErrors(context.errors, serverMode);
     }
-    let state = {
+    let state2 = {
       loaderData: context.loaderData,
       actionData: context.actionData,
       errors: serializeErrors2(context.errors, serverMode)
     };
-    let entryContext = {
-      manifest: build.assets,
-      routeModules: createEntryRouteModules(build.routes),
+    entryContext = {
+      ...entryContext,
       staticHandlerContext: context,
-      criticalCss,
       serverHandoffString: createServerHandoffString({
         basename: build.basename,
-        criticalCss,
         future: build.future,
         isSpaMode: build.isSpaMode
       }),
       serverHandoffStream: encodeViaTurboStream(
-        state,
+        state2,
         request.signal,
         build.entry.module.streamTimeout,
         serverMode
       ),
-      renderMeta: {},
-      future: build.future,
-      isSpaMode: build.isSpaMode,
-      serializeError: (err) => serializeError(err, serverMode)
+      renderMeta: {}
     };
-    let handleDocumentRequestFunction = build.entry.module.default;
     try {
       return await handleDocumentRequestFunction(
         request,
@@ -9724,61 +9493,9 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
         entryContext,
         loadContext
       );
-    } catch (error) {
-      handleError(error);
-      let errorForSecondRender = error;
-      if (isResponse(error)) {
-        try {
-          let data2 = await unwrapResponse(error);
-          errorForSecondRender = new ErrorResponseImpl(
-            error.status,
-            error.statusText,
-            data2
-          );
-        } catch (e) {
-        }
-      }
-      context = getStaticContextFromError(
-        staticHandler.dataRoutes,
-        context,
-        errorForSecondRender
-      );
-      if (context.errors) {
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let state2 = {
-        loaderData: context.loaderData,
-        actionData: context.actionData,
-        errors: serializeErrors2(context.errors, serverMode)
-      };
-      entryContext = {
-        ...entryContext,
-        staticHandlerContext: context,
-        serverHandoffString: createServerHandoffString({
-          basename: build.basename,
-          future: build.future,
-          isSpaMode: build.isSpaMode
-        }),
-        serverHandoffStream: encodeViaTurboStream(
-          state2,
-          request.signal,
-          build.entry.module.streamTimeout,
-          serverMode
-        ),
-        renderMeta: {}
-      };
-      try {
-        return await handleDocumentRequestFunction(
-          request,
-          context.statusCode,
-          headers,
-          entryContext,
-          loadContext
-        );
-      } catch (error2) {
-        handleError(error2);
-        return returnLastResortErrorResponse(error2, serverMode);
-      }
+    } catch (error2) {
+      handleError(error2);
+      return returnLastResortErrorResponse(error2, serverMode);
     }
   }
 }
@@ -9786,16 +9503,15 @@ async function handleResourceRequest(serverMode, staticHandler, routeId, request
   try {
     let response = await staticHandler.queryRoute(request, {
       routeId,
-      requestContext: loadContext,
-      async respond(ctx) {
-        return ctx;
-      }
+      requestContext: loadContext
     });
-    invariant3(
-      isResponse(response),
-      "Expected a Response to be returned from resource route handler"
-    );
-    return response;
+    if (isResponse(response)) {
+      return response;
+    }
+    if (typeof response === "string") {
+      return new Response(response);
+    }
+    return Response.json(response);
   } catch (error) {
     if (isResponse(error)) {
       error.headers.set("X-Remix-Catch", "yes");
@@ -9807,13 +9523,6 @@ async function handleResourceRequest(serverMode, staticHandler, routeId, request
       }
       return errorResponseToJson(error, serverMode);
     }
-    if (error instanceof Error && error.message === "Expected a response from queryRoute") {
-      let newError = new Error(
-        "Expected a Response to be returned from resource route handler"
-      );
-      handleError(newError);
-      return returnLastResortErrorResponse(newError, serverMode);
-    }
     handleError(error);
     return returnLastResortErrorResponse(error, serverMode);
   }