react-router 7.2.0 → 7.3.0-pre.0

package/dist/production/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v7.2.0
+ * react-router v7.3.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -15,6 +15,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -36,6 +39,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
 // index.ts
 var react_router_exports = {};
@@ -121,6 +127,8 @@ __export(react_router_exports, {
   replace: () => replace,
   resolvePath: () => resolvePath,
   unstable_HistoryRouter: () => HistoryRouter,
+  unstable_RouterContextProvider: () => unstable_RouterContextProvider,
+  unstable_createContext: () => unstable_createContext,
   unstable_setDevServerHooks: () => setDevServerHooks,
   unstable_usePrompt: () => usePrompt,
   useActionData: () => useActionData,
@@ -496,6 +504,33 @@ function getUrlBasedHistory(getLocation, createHref2, validateLocation, options
 }
 
 // lib/router/utils.ts
+function unstable_createContext(defaultValue) {
+  return { defaultValue };
+}
+var _map;
+var unstable_RouterContextProvider = class {
+  constructor(init) {
+    __privateAdd(this, _map, /* @__PURE__ */ new Map());
+    if (init) {
+      for (let [context, value] of init) {
+        this.set(context, value);
+      }
+    }
+  }
+  get(context) {
+    if (__privateGet(this, _map).has(context)) {
+      return __privateGet(this, _map).get(context);
+    }
+    if (context.defaultValue !== void 0) {
+      return context.defaultValue;
+    }
+    throw new Error("No value found for context");
+  }
+  set(context, value) {
+    __privateGet(this, _map).set(context, value);
+  }
+};
+_map = new WeakMap();
 var immutableRouteKeys = /* @__PURE__ */ new Set([
   "lazy",
   "caseSensitive",
@@ -1053,9 +1088,9 @@ function createRouter(init) {
   );
   let inFlightDataRoutes;
   let basename = init.basename || "/";
-  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
-  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+  let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
   let future = {
+    unstable_middleware: false,
     ...init.future
   };
   let unlistenHistory = null;
@@ -1067,7 +1102,7 @@ function createRouter(init) {
   let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
   let initialMatchesIsFOW = false;
   let initialErrors = null;
-  if (initialMatches == null && !patchRoutesOnNavigationImpl) {
+  if (initialMatches == null && !init.patchRoutesOnNavigation) {
     let error = getInternalRouterError(404, {
       pathname: init.history.location.pathname
     });
@@ -1498,6 +1533,9 @@ function createRouter(init) {
       pendingNavigationController.signal,
       opts && opts.submission
     );
+    let scopedContext = new unstable_RouterContextProvider(
+      init.unstable_getContext ? await init.unstable_getContext() : void 0
+    );
     let pendingActionResult;
     if (opts && opts.pendingError) {
       pendingActionResult = [
@@ -1510,6 +1548,7 @@ function createRouter(init) {
         location,
         opts.submission,
         matches,
+        scopedContext,
         fogOfWar.active,
         { replace: opts.replace, flushSync }
       );
@@ -1550,6 +1589,7 @@ function createRouter(init) {
       request,
       location,
       matches,
+      scopedContext,
       fogOfWar.active,
       loadingNavigation,
       opts && opts.submission,
@@ -1570,7 +1610,7 @@ function createRouter(init) {
       errors
     });
   }
-  async function handleAction(request, location, submission, matches, isFogOfWar, opts = {}) {
+  async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, opts = {}) {
     interruptActiveLoads();
     let navigation = getSubmittingNavigation(location, submission);
     updateState({ navigation }, { flushSync: opts.flushSync === true });
@@ -1626,13 +1666,21 @@ function createRouter(init) {
     } else {
       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 };
       }
@@ -1670,7 +1718,7 @@ function createRouter(init) {
       pendingActionResult: [actionMatch.route.id, result]
     };
   }
-  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult) {
+  async function handleLoaders(request, location, matches, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult) {
     let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
     let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
     let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
@@ -1780,11 +1828,11 @@ function createRouter(init) {
       );
     }
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      state,
       matches,
       matchesToLoad,
       revalidatingFetchers,
-      request
+      request,
+      scopedContext
     );
     if (request.signal.aborted) {
       return { shortCircuited: true };
@@ -1892,6 +1940,9 @@ function createRouter(init) {
       return;
     }
     let match = getTargetMatch(matches, path);
+    let scopedContext = new unstable_RouterContextProvider(
+      init.unstable_getContext ? await init.unstable_getContext() : void 0
+    );
     let preventScrollReset = (opts && opts.preventScrollReset) === true;
     if (submission && isMutationMethod(submission.formMethod)) {
       await handleFetcherAction(
@@ -1900,6 +1951,7 @@ function createRouter(init) {
         path,
         match,
         matches,
+        scopedContext,
         fogOfWar.active,
         flushSync,
         preventScrollReset,
@@ -1914,13 +1966,14 @@ function createRouter(init) {
       path,
       match,
       matches,
+      scopedContext,
       fogOfWar.active,
       flushSync,
       preventScrollReset,
       submission
     );
   }
-  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
+  async function handleFetcherAction(key, routeId, path, match, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
     interruptActiveLoads();
     fetchLoadMatches.delete(key);
     function detectAndHandle405Error(m) {
@@ -1953,7 +2006,8 @@ function createRouter(init) {
       let discoverResult = await discoverRoutes(
         requestMatches,
         path,
-        fetchRequest.signal
+        fetchRequest.signal,
+        key
       );
       if (discoverResult.type === "aborted") {
         return;
@@ -1980,10 +2034,10 @@ function createRouter(init) {
     let originatingLoadId = incrementingLoadId;
     let actionResults = await callDataStrategy(
       "action",
-      state,
       fetchRequest,
       [match],
       requestMatches,
+      scopedContext,
       key
     );
     let actionResult = actionResults[match.route.id];
@@ -2067,11 +2121,11 @@ function createRouter(init) {
       abortPendingFetchRevalidations
     );
     let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(
-      state,
       matches,
       matchesToLoad,
       revalidatingFetchers,
-      revalidationRequest
+      revalidationRequest,
+      scopedContext
     );
     if (abortController.signal.aborted) {
       return;
@@ -2138,7 +2192,7 @@ function createRouter(init) {
       isRevalidationRequired = false;
     }
   }
-  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
+  async function handleFetcherLoader(key, routeId, path, match, matches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
     let existingFetcher = state.fetchers.get(key);
     updateFetcherState(
       key,
@@ -2158,7 +2212,8 @@ function createRouter(init) {
       let discoverResult = await discoverRoutes(
         matches,
         path,
-        fetchRequest.signal
+        fetchRequest.signal,
+        key
       );
       if (discoverResult.type === "aborted") {
         return;
@@ -2182,10 +2237,10 @@ function createRouter(init) {
     let originatingLoadId = incrementingLoadId;
     let results = await callDataStrategy(
       "loader",
-      state,
       fetchRequest,
       [match],
       matches,
+      scopedContext,
       key
     );
     let result = results[match.route.id];
@@ -2287,20 +2342,21 @@ function createRouter(init) {
       });
     }
   }
-  async function callDataStrategy(type, state2, request, matchesToLoad, matches, fetcherKey) {
+  async function callDataStrategy(type, request, matchesToLoad, matches, scopedContext, fetcherKey) {
     let results;
     let dataResults = {};
     try {
       results = await callDataStrategyImpl(
         dataStrategyImpl,
         type,
-        state2,
         request,
         matchesToLoad,
         matches,
         fetcherKey,
         manifest,
-        mapRouteProperties2
+        mapRouteProperties2,
+        scopedContext,
+        future.unstable_middleware
       );
     } catch (e) {
       matchesToLoad.forEach((m) => {
@@ -2332,13 +2388,13 @@ function createRouter(init) {
     }
     return dataResults;
   }
-  async function callLoadersAndMaybeResolveData(state2, matches, matchesToLoad, fetchersToLoad, request) {
+  async function callLoadersAndMaybeResolveData(matches, matchesToLoad, fetchersToLoad, request, scopedContext) {
     let loaderResultsPromise = callDataStrategy(
       "loader",
-      state2,
       request,
       matchesToLoad,
       matches,
+      scopedContext,
       null
     );
     let fetcherResultsPromise = Promise.all(
@@ -2346,10 +2402,10 @@ function createRouter(init) {
         if (f.matches && f.match && f.controller) {
           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];
@@ -2571,7 +2627,7 @@ function createRouter(init) {
     return null;
   }
   function checkFogOfWar(matches, routesToUse, pathname) {
-    if (patchRoutesOnNavigationImpl) {
+    if (init.patchRoutesOnNavigation) {
       if (!matches) {
         let fogMatches = matchRoutesImpl(
           routesToUse,
@@ -2594,8 +2650,8 @@ function createRouter(init) {
     }
     return { active: false, matches: null };
   }
-  async function discoverRoutes(matches, pathname, signal) {
-    if (!patchRoutesOnNavigationImpl) {
+  async function discoverRoutes(matches, pathname, signal, fetcherKey) {
+    if (!init.patchRoutesOnNavigation) {
       return { type: "success", matches };
     }
     let partialMatches = matches;
@@ -2604,10 +2660,11 @@ function createRouter(init) {
       let routesToUse = inFlightDataRoutes || dataRoutes;
       let localManifest = manifest;
       try {
-        await patchRoutesOnNavigationImpl({
+        await init.patchRoutesOnNavigation({
           signal,
           path: pathname,
           matches: partialMatches,
+          fetcherKey,
           patch: (routeId, children) => {
             if (signal.aborted) return;
             patchRoutesImpl(
@@ -2726,17 +2783,21 @@ function createStaticHandler(routes, opts) {
   );
   async function query(request, {
     requestContext,
+    filterMatchesToLoad,
     skipLoaderErrorBubbling,
-    dataStrategy
+    skipRevalidation,
+    dataStrategy,
+    unstable_respond: respond
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
+    requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
     if (!isValidMethod(method) && method !== "HEAD") {
       let error = getInternalRouterError(405, { method });
       let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
-      return {
+      let staticContext = {
         basename,
         location,
         matches: methodNotAllowedMatches,
@@ -2749,10 +2810,11 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
+      return respond ? respond(staticContext) : staticContext;
     } else if (!matches) {
       let error = getInternalRouterError(404, { pathname: location.pathname });
       let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
-      return {
+      let staticContext = {
         basename,
         location,
         matches: notFoundMatches,
@@ -2765,6 +2827,90 @@ function createStaticHandler(routes, opts) {
         loaderHeaders: {},
         actionHeaders: {}
       };
+      return respond ? respond(staticContext) : staticContext;
+    }
+    if (respond && matches.some((m) => m.route.unstable_middleware)) {
+      invariant(
+        requestContext instanceof unstable_RouterContextProvider,
+        "When using middleware in `staticHandler.query()`, any provided `requestContext` must bean instance of `unstable_RouterContextProvider`"
+      );
+      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,
+            // If we're calling middleware then it must be enabled so we can cast
+            // this to the proper type knowing it's not an `AppLoadContext`
+            context: requestContext
+          },
+          lowestLoadingIdx,
+          true,
+          async () => {
+            let result2 = await queryImpl(
+              request,
+              location,
+              matches,
+              requestContext,
+              dataStrategy || null,
+              skipLoaderErrorBubbling === true,
+              null,
+              filterMatchesToLoad || null,
+              skipRevalidation === true
+            );
+            if (isResponse(result2)) {
+              return result2;
+            }
+            renderedStaticContext = { location, basename, ...result2 };
+            let res = await respond(renderedStaticContext);
+            return res;
+          },
+          async (e) => {
+            if (isResponse(e.error)) {
+              return e.error;
+            }
+            if (renderedStaticContext) {
+              if (e.routeId in renderedStaticContext.loaderData) {
+                renderedStaticContext.loaderData[e.routeId] = void 0;
+              }
+              return respond(
+                getStaticContextFromError(
+                  dataRoutes,
+                  renderedStaticContext,
+                  e.error,
+                  findNearestBoundary(matches, e.routeId).route.id
+                )
+              );
+            } else {
+              let loaderIdx = matches.findIndex((m) => m.route.loader);
+              let boundary = loaderIdx >= 0 ? findNearestBoundary(matches, matches[loaderIdx].route.id) : findNearestBoundary(matches);
+              return respond({
+                matches,
+                location,
+                basename,
+                loaderData: {},
+                actionData: null,
+                errors: {
+                  [boundary.route.id]: e.error
+                },
+                statusCode: isRouteErrorResponse(e.error) ? e.error.status : 500,
+                actionHeaders: {},
+                loaderHeaders: {}
+              });
+            }
+          }
+        );
+        invariant(isResponse(response), "Expected a response in query()");
+        return response;
+      } catch (e) {
+        if (isResponse(e)) {
+          return e;
+        }
+        throw e;
+      }
     }
     let result = await queryImpl(
       request,
@@ -2773,7 +2919,9 @@ function createStaticHandler(routes, opts) {
       requestContext,
       dataStrategy || null,
       skipLoaderErrorBubbling === true,
-      null
+      null,
+      filterMatchesToLoad || null,
+      skipRevalidation === true
     );
     if (isResponse(result)) {
       return result;
@@ -2783,12 +2931,14 @@ function createStaticHandler(routes, opts) {
   async function queryRoute(request, {
     routeId,
     requestContext,
-    dataStrategy
+    dataStrategy,
+    unstable_respond: respond
   } = {}) {
     let url = new URL(request.url);
     let method = request.method;
     let location = createLocation("", createPath(url), null, "default");
     let matches = matchRoutes(dataRoutes, location, basename);
+    requestContext = requestContext != null ? requestContext : new unstable_RouterContextProvider();
     if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
       throw getInternalRouterError(405, { method });
     } else if (!matches) {
@@ -2803,6 +2953,56 @@ function createStaticHandler(routes, opts) {
     } else if (!match) {
       throw getInternalRouterError(404, { pathname: location.pathname });
     }
+    if (respond && matches.some((m) => m.route.unstable_middleware)) {
+      invariant(
+        requestContext instanceof unstable_RouterContextProvider,
+        "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must bean instance of `unstable_RouterContextProvider`"
+      );
+      let response = await runMiddlewarePipeline(
+        {
+          request,
+          matches,
+          params: matches[0].params,
+          // If we're calling middleware then it must be enabled so we can cast
+          // this to the proper type knowing it's not an `AppLoadContext`
+          context: requestContext
+        },
+        matches.length - 1,
+        true,
+        async () => {
+          let result2 = await queryImpl(
+            request,
+            location,
+            matches,
+            requestContext,
+            dataStrategy || null,
+            false,
+            match,
+            null,
+            false
+          );
+          if (isResponse(result2)) {
+            return respond(result2);
+          }
+          let error2 = result2.errors ? Object.values(result2.errors)[0] : void 0;
+          if (error2 !== void 0) {
+            throw error2;
+          }
+          let value = result2.actionData ? Object.values(result2.actionData)[0] : Object.values(result2.loaderData)[0];
+          return typeof value === "string" ? new Response(value) : Response.json(value);
+        },
+        (e) => {
+          if (isResponse(e.error)) {
+            return respond(e.error);
+          }
+          return new Response(String(e.error), {
+            status: 500,
+            statusText: "Unexpected Server Error"
+          });
+        }
+      );
+      return response;
+    }
     let result = await queryImpl(
       request,
       location,
@@ -2810,7 +3010,9 @@ function createStaticHandler(routes, opts) {
       requestContext,
       dataStrategy || null,
       false,
-      match
+      match,
+      null,
+      false
     );
     if (isResponse(result)) {
       return result;
@@ -2827,7 +3029,7 @@ function createStaticHandler(routes, opts) {
     }
     return void 0;
   }
-  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
+  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
     invariant(
       request.signal,
       "query()/queryRoute() requests must contain an AbortController signal"
@@ -2841,7 +3043,9 @@ function createStaticHandler(routes, opts) {
           requestContext,
           dataStrategy,
           skipLoaderErrorBubbling,
-          routeMatch != null
+          routeMatch != null,
+          filterMatchesToLoad,
+          skipRevalidation
         );
         return result2;
       }
@@ -2851,7 +3055,8 @@ function createStaticHandler(routes, opts) {
         requestContext,
         dataStrategy,
         skipLoaderErrorBubbling,
-        routeMatch
+        routeMatch,
+        filterMatchesToLoad
       );
       return isResponse(result) ? result : {
         ...result,
@@ -2871,7 +3076,7 @@ function createStaticHandler(routes, opts) {
       throw e;
     }
   }
-  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
+  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest, filterMatchesToLoad, skipRevalidation) {
     let result;
     if (!actionMatch.route.action && !actionMatch.route.lazy) {
       let error = getInternalRouterError(405, {
@@ -2925,6 +3130,36 @@ function createStaticHandler(routes, opts) {
         actionHeaders: {}
       };
     }
+    if (skipRevalidation) {
+      if (isErrorResult(result)) {
+        let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
+        return {
+          statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
+          actionData: null,
+          actionHeaders: {
+            ...result.headers ? { [actionMatch.route.id]: result.headers } : {}
+          },
+          matches,
+          loaderData: {},
+          errors: {
+            [boundaryMatch.route.id]: result.error
+          },
+          loaderHeaders: {}
+        };
+      } else {
+        return {
+          actionData: {
+            [actionMatch.route.id]: result.data
+          },
+          actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {},
+          matches,
+          loaderData: {},
+          errors: null,
+          statusCode: result.statusCode || 200,
+          loaderHeaders: {}
+        };
+      }
+    }
     let loaderRequest = new Request(request.url, {
       headers: request.headers,
       redirect: request.redirect,
@@ -2932,17 +3167,18 @@ function createStaticHandler(routes, opts) {
     });
     if (isErrorResult(result)) {
       let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
-      let context2 = await loadRouteData(
+      let handlerContext2 = await loadRouteData(
         loaderRequest,
         matches,
         requestContext,
         dataStrategy,
         skipLoaderErrorBubbling,
         null,
+        filterMatchesToLoad,
         [boundaryMatch.route.id, result]
       );
       return {
-        ...context2,
+        ...handlerContext2,
         statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
         actionData: null,
         actionHeaders: {
@@ -2950,16 +3186,17 @@ function createStaticHandler(routes, opts) {
         }
       };
     }
-    let context = await loadRouteData(
+    let handlerContext = await loadRouteData(
       loaderRequest,
       matches,
       requestContext,
       dataStrategy,
       skipLoaderErrorBubbling,
-      null
+      null,
+      filterMatchesToLoad
     );
     return {
-      ...context,
+      ...handlerContext,
       actionData: {
         [actionMatch.route.id]: result.data
       },
@@ -2968,7 +3205,7 @@ function createStaticHandler(routes, opts) {
       actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
     };
   }
-  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
+  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, pendingActionResult) {
     let isRouteRequest = routeMatch != null;
     if (isRouteRequest && !routeMatch?.route.loader && !routeMatch?.route.lazy) {
       throw getInternalRouterError(400, {
@@ -2979,7 +3216,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
+      (m) => (m.route.loader || m.route.lazy) && (!filterMatchesToLoad || filterMatchesToLoad(m))
     );
     if (matchesToLoad.length === 0) {
       return {
@@ -3008,7 +3245,7 @@ function createStaticHandler(routes, opts) {
     if (request.signal.aborted) {
       throwStaticHandlerAbortedError(request, isRouteRequest);
     }
-    let context = processRouteLoaderData(
+    let handlerContext = processRouteLoaderData(
       matches,
       results,
       pendingActionResult,
@@ -3020,11 +3257,11 @@ function createStaticHandler(routes, opts) {
     );
     matches.forEach((match) => {
       if (!executedLoaders.has(match.route.id)) {
-        context.loaderData[match.route.id] = null;
+        handlerContext.loaderData[match.route.id] = null;
       }
     });
     return {
-      ...context,
+      ...handlerContext,
       matches
     };
   }
@@ -3032,14 +3269,15 @@ function createStaticHandler(routes, opts) {
     let results = await callDataStrategyImpl(
       dataStrategy || defaultDataStrategy,
       type,
-      null,
       request,
       matchesToLoad,
       matches,
       null,
       manifest,
       mapRouteProperties2,
-      requestContext
+      requestContext,
+      false
+      // middleware not done via dataStrategy in the static handler
     );
     let dataResults = {};
     await Promise.all(
@@ -3072,15 +3310,15 @@ function createStaticHandler(routes, opts) {
     queryRoute
   };
 }
-function getStaticContextFromError(routes, context, error) {
-  let newContext = {
-    ...context,
+function getStaticContextFromError(routes, handlerContext, error, boundaryId) {
+  let errorBoundaryId = boundaryId || handlerContext._deepestRenderedBoundaryId || routes[0].id;
+  return {
+    ...handlerContext,
     statusCode: isRouteErrorResponse(error) ? error.status : 500,
     errors: {
-      [context._deepestRenderedBoundaryId || routes[0].id]: error
+      [errorBoundaryId]: error
     }
   };
-  return newContext;
 }
 function throwStaticHandlerAbortedError(request, isRouteRequest) {
   if (request.signal.reason !== void 0) {
@@ -3473,20 +3711,143 @@ async function loadLazyRouteModule(route, mapRouteProperties2, manifest) {
     lazy: void 0
   });
 }
-async function defaultDataStrategy({
-  matches
-}) {
-  let matchesToLoad = matches.filter((m) => m.shouldLoad);
+async function defaultDataStrategy(args) {
+  let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
+  let keyedResults = {};
   let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
-  return results.reduce(
-    (acc, result, i) => Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
-    {}
+  results.forEach((result, i) => {
+    keyedResults[matchesToLoad[i].route.id] = result;
+  });
+  return keyedResults;
+}
+async function defaultDataStrategyWithMiddleware(args) {
+  if (!args.matches.some((m) => m.route.unstable_middleware)) {
+    return defaultDataStrategy(args);
+  }
+  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) => {
+      Object.assign(keyedResults, await defaultDataStrategy(args));
+    },
+    (e, keyedResults) => {
+      Object.assign(keyedResults, {
+        [e.routeId]: { type: "error", result: e.error }
+      });
+    }
   );
+  return results;
 }
-async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties2, requestContext) {
+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.unstable_middleware ? m.route.unstable_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;
+    }
+    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 nextResult = void 0;
+  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) {
+      nextResult = result;
+      return nextResult;
+    }
+  };
+  try {
+    let result = await middleware(
+      {
+        request: args.request,
+        params: args.params,
+        context: args.context
+      },
+      next
+    );
+    if (nextCalled) {
+      if (result === void 0) {
+        return nextResult;
+      } else {
+        return result;
+      }
+    } else {
+      return 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, enableMiddleware) {
   let loadRouteDefinitionsPromises = matches.map(
     (m) => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties2, manifest) : void 0
   );
+  if (enableMiddleware) {
+    await Promise.all(loadRouteDefinitionsPromises);
+  }
   let dsMatches = matches.map((match, i) => {
     let loadRoutePromise = loadRouteDefinitionsPromises[i];
     let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
@@ -3500,7 +3861,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
         match,
         loadRoutePromise,
         handlerOverride,
-        requestContext
+        scopedContext
       ) : Promise.resolve({ type: "data" /* data */, result: void 0 });
     };
     return {
@@ -3514,7 +3875,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
     request,
     params: matches[0].params,
     fetcherKey,
-    context: requestContext
+    context: scopedContext
   });
   try {
     await Promise.all(loadRouteDefinitionsPromises);
@@ -3522,7 +3883,7 @@ async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matc
   }
   return results;
 }
-async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
+async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, scopedContext) {
   let result;
   let onReject;
   let runHandler = (handler) => {
@@ -3542,7 +3903,7 @@ async function callLoaderOrAction(type, request, match, loadRoutePromise, handle
         {
           request,
           params: match.params,
-          context: staticContext
+          context: scopedContext
         },
         ...ctx !== void 0 ? [ctx] : []
       );
@@ -4855,6 +5216,7 @@ function mapRouteProperties(route) {
 function createMemoryRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
+    unstable_getContext: opts?.unstable_getContext,
     future: opts?.future,
     history: createMemoryHistory({
       initialEntries: opts?.initialEntries,
@@ -5810,55 +6172,103 @@ function StreamTransfer({
     )));
   }
 }
-function getSingleFetchDataStrategy(manifest, routeModules, ssr, getRouter) {
-  return async ({ request, matches, fetcherKey }) => {
+function middlewareErrorHandler(e, keyedResults) {
+  Object.assign(keyedResults, {
+    [e.routeId]: { type: "error", result: e.error }
+  });
+}
+function getSingleFetchDataStrategy(manifest, routeModules, ssr, basename, getRouter) {
+  return async (args) => {
+    let { request, matches, fetcherKey } = args;
     if (request.method !== "GET") {
-      return singleFetchActionStrategy(request, matches);
+      return runMiddlewarePipeline(
+        args,
+        matches.findIndex((m) => m.shouldLoad),
+        false,
+        async (keyedResults) => {
+          let results = await singleFetchActionStrategy(
+            request,
+            matches,
+            basename
+          );
+          Object.assign(keyedResults, results);
+        },
+        middlewareErrorHandler
+      );
     }
     if (!ssr) {
       let foundRevalidatingServerLoader = matches.some(
         (m) => m.shouldLoad && manifest.routes[m.route.id]?.hasLoader && !manifest.routes[m.route.id]?.hasClientLoader
       );
       if (!foundRevalidatingServerLoader) {
-        let matchesToLoad = matches.filter((m) => m.shouldLoad);
-        let url = stripIndexParam(singleFetchUrl(request.url));
-        let init = await createRequestInit(request);
-        let results = {};
-        await Promise.all(
-          matchesToLoad.map(
-            (m) => m.resolve(async (handler) => {
-              try {
-                let result = manifest.routes[m.route.id]?.hasClientLoader ? await fetchSingleLoader(handler, url, init, m.route.id) : await handler();
-                results[m.route.id] = { type: "data", result };
-              } catch (e) {
-                results[m.route.id] = { type: "error", result: e };
-              }
-            })
-          )
+        let tailIdx = [...matches].reverse().findIndex((m) => m.shouldLoad);
+        let lowestLoadingIndex2 = tailIdx < 0 ? 0 : matches.length - 1 - tailIdx;
+        return runMiddlewarePipeline(
+          args,
+          lowestLoadingIndex2,
+          false,
+          async (keyedResults) => {
+            let results = await nonSsrStrategy(
+              manifest,
+              request,
+              matches,
+              basename
+            );
+            Object.assign(keyedResults, results);
+          },
+          middlewareErrorHandler
         );
-        return results;
       }
     }
     if (fetcherKey) {
-      return singleFetchLoaderFetcherStrategy(request, matches);
+      return runMiddlewarePipeline(
+        args,
+        matches.findIndex((m) => m.shouldLoad),
+        false,
+        async (keyedResults) => {
+          let results = await singleFetchLoaderFetcherStrategy(
+            request,
+            matches,
+            basename
+          );
+          Object.assign(keyedResults, results);
+        },
+        middlewareErrorHandler
+      );
     }
-    return singleFetchLoaderNavigationStrategy(
+    let lowestLoadingIndex = getLowestLoadingIndex(
       manifest,
       routeModules,
-      ssr,
       getRouter(),
-      request,
       matches
     );
+    return runMiddlewarePipeline(
+      args,
+      lowestLoadingIndex,
+      false,
+      async (keyedResults) => {
+        let results = await singleFetchLoaderNavigationStrategy(
+          manifest,
+          routeModules,
+          ssr,
+          getRouter(),
+          request,
+          matches,
+          basename
+        );
+        Object.assign(keyedResults, results);
+      },
+      middlewareErrorHandler
+    );
   };
 }
-async function singleFetchActionStrategy(request, matches) {
+async function singleFetchActionStrategy(request, matches, basename) {
   let actionMatch = matches.find((m) => m.shouldLoad);
   invariant2(actionMatch, "No action match found");
   let actionStatus = void 0;
   let result = await actionMatch.resolve(async (handler) => {
     let result2 = await handler(async () => {
-      let url = singleFetchUrl(request.url);
+      let url = singleFetchUrl(request.url, basename);
       let init = await createRequestInit(request);
       let { data: data2, status } = await fetchAndDecode(url, init);
       actionStatus = status;
@@ -5879,13 +6289,46 @@ async function singleFetchActionStrategy(request, matches) {
     }
   };
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router, request, matches) {
+async function nonSsrStrategy(manifest, request, matches, basename) {
+  let matchesToLoad = matches.filter((m) => m.shouldLoad);
+  let url = stripIndexParam(singleFetchUrl(request.url, basename));
+  let init = await createRequestInit(request);
+  let results = {};
+  await Promise.all(
+    matchesToLoad.map(
+      (m) => m.resolve(async (handler) => {
+        try {
+          let result = manifest.routes[m.route.id]?.hasClientLoader ? await fetchSingleLoader(handler, url, init, m.route.id) : await handler();
+          results[m.route.id] = { type: "data", result };
+        } catch (e) {
+          results[m.route.id] = { type: "error", result: e };
+        }
+      })
+    )
+  );
+  return results;
+}
+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, ssr, router, request, matches, basename) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
   let routeDfds = matches.map(() => createDeferred2());
   let routesLoadedPromise = Promise.all(routeDfds.map((d) => d.promise));
   let singleFetchDfd = createDeferred2();
-  let url = stripIndexParam(singleFetchUrl(request.url));
+  let url = stripIndexParam(singleFetchUrl(request.url, basename));
   let init = await createRequestInit(request);
   let results = {};
   let resolvePromise = Promise.all(
@@ -5897,7 +6340,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
           if (!router.state.initialized) {
             return;
           }
-          if (m.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && routeModules[m.route.id]?.shouldRevalidate) {
+          if (isOptedOut(manifestRoute, routeModules[m.route.id], m, router)) {
             foundOptOutRoute = true;
             return;
           }
@@ -5960,11 +6403,11 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr,
   await resolvePromise;
   return results;
 }
-async function singleFetchLoaderFetcherStrategy(request, matches) {
+async function singleFetchLoaderFetcherStrategy(request, matches, basename) {
   let fetcherMatch = matches.find((m) => m.shouldLoad);
   invariant2(fetcherMatch, "No fetcher match found");
   let result = await fetcherMatch.resolve(async (handler) => {
-    let url = stripIndexParam(singleFetchUrl(request.url));
+    let url = stripIndexParam(singleFetchUrl(request.url, basename));
     let init = await createRequestInit(request);
     return fetchSingleLoader(handler, url, init, fetcherMatch.route.id);
   });
@@ -5992,7 +6435,7 @@ function stripIndexParam(url) {
   }
   return url;
 }
-function singleFetchUrl(reqUrl) {
+function singleFetchUrl(reqUrl, basename) {
   let url = typeof reqUrl === "string" ? new URL(
     reqUrl,
     // This can be called during the SSR flow via PrefetchPageLinksImpl so
@@ -6001,6 +6444,8 @@ function singleFetchUrl(reqUrl) {
   ) : reqUrl;
   if (url.pathname === "/") {
     url.pathname = "_root.data";
+  } else if (basename && stripBasename(url.pathname, basename) === "/") {
+    url.pathname = `${basename.replace(/\/$/, "")}/_root.data`;
   } else {
     url.pathname = `${url.pathname.replace(/\/$/, "")}.data`;
   }
@@ -6297,8 +6742,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 action/shouldRevalidate on these routes since they're
-      // for a static render
+      // We don't need middleware/action/shouldRevalidate on these routes since
+      // they're for a static render
     };
     let children = createServerRoutes(
       manifest,
@@ -6392,6 +6837,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
       Object.assign(dataRoute, {
         ...dataRoute,
         ...getRouteComponents(route, routeModule, isSpaMode),
+        unstable_middleware: routeModule.unstable_clientMiddleware,
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
           routeModule,
@@ -6405,7 +6851,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
       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 }, singleFetch) => {
+      dataRoute.loader = async ({ request, params, context }, singleFetch) => {
         try {
           let result = await prefetchStylesAndCallHandler(async () => {
             invariant2(
@@ -6418,6 +6864,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
             return routeModule.clientLoader({
               request,
               params,
+              context,
               async serverLoader() {
                 preventInvalidServerHandlerCall("loader", route);
                 if (isHydrationRequest) {
@@ -6442,7 +6889,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         routeModule,
         isSpaMode
       );
-      dataRoute.action = ({ request, params }, singleFetch) => {
+      dataRoute.action = ({ request, params, context }, singleFetch) => {
         return prefetchStylesAndCallHandler(async () => {
           invariant2(
             routeModule,
@@ -6457,6 +6904,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
           return routeModule.clientAction({
             request,
             params,
+            context,
             async serverAction() {
               preventInvalidServerHandlerCall("action", route);
               return fetchServerAction(singleFetch);
@@ -6466,7 +6914,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
       };
     } else {
       if (!route.hasClientLoader) {
-        dataRoute.loader = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
+        dataRoute.loader = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
           return fetchServerLoader(singleFetch);
         });
       } else if (route.clientLoaderModule) {
@@ -6487,7 +6935,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         };
       }
       if (!route.hasClientAction) {
-        dataRoute.action = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
+        dataRoute.action = (_, singleFetch) => prefetchStylesAndCallHandler(() => {
           if (isSpaMode) {
             throw noActionDefinedError("clientAction", route.id);
           }
@@ -6545,6 +6993,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSp
         return {
           ...lazyRoute.loader ? { loader: lazyRoute.loader } : {},
           ...lazyRoute.action ? { action: lazyRoute.action } : {},
+          unstable_middleware: mod.unstable_clientMiddleware,
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
@@ -6617,6 +7066,7 @@ async function loadRouteModuleWithBlockingLinks(route, routeModules) {
   return {
     Component: getRouteModuleComponent(routeModule),
     ErrorBoundary: routeModule.ErrorBoundary,
+    unstable_clientMiddleware: routeModule.unstable_clientMiddleware,
     clientAction: routeModule.clientAction,
     clientLoader: routeModule.clientLoader,
     handle: routeModule.handle,
@@ -6672,12 +7122,13 @@ function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMo
   if (!isFogOfWarEnabled(ssr)) {
     return void 0;
   }
-  return async ({ path, patch, signal }) => {
+  return async ({ path, patch, signal, fetcherKey }) => {
     if (discoveredPaths.has(path)) {
       return;
     }
     await fetchAndApplyManifestPatches(
       [path],
+      fetcherKey ? window.location.href : path,
       manifest,
       routeModules,
       ssr,
@@ -6718,6 +7169,7 @@ function useFogOFWarDiscovery(router, manifest, routeModules, ssr, isSpaMode) {
       try {
         await fetchAndApplyManifestPatches(
           lazyPaths,
+          null,
           manifest,
           routeModules,
           ssr,
@@ -6741,7 +7193,8 @@ function useFogOFWarDiscovery(router, manifest, routeModules, ssr, isSpaMode) {
     return () => observer.disconnect();
   }, [ssr, isSpaMode, manifest, routeModules, router]);
 }
-async function fetchAndApplyManifestPatches(paths, manifest, routeModules, ssr, isSpaMode, basename, patchRoutes, signal) {
+var MANIFEST_VERSION_STORAGE_KEY = "react-router-manifest-version";
+async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, routeModules, ssr, isSpaMode, basename, patchRoutes, signal) {
   let manifestPath = `${basename != null ? basename : "/"}/__manifest`.replace(
     /\/+/g,
     "/"
@@ -6758,9 +7211,26 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, ssr,
     let res = await fetch(url, { signal });
     if (!res.ok) {
       throw new Error(`${res.status} ${res.statusText}`);
+    } else if (res.status === 204 && res.headers.has("X-Remix-Reload-Document")) {
+      if (!errorReloadPath) {
+        console.warn(
+          "Detected a manifest version mismatch during eager route discovery. The next navigation/fetch to an undiscovered route will result in a new document navigation to sync up with the latest manifest."
+        );
+        return;
+      }
+      if (sessionStorage.getItem(MANIFEST_VERSION_STORAGE_KEY) === manifest.version) {
+        console.error(
+          "Unable to discover routes due to manifest version mismatch."
+        );
+        return;
+      }
+      sessionStorage.setItem(MANIFEST_VERSION_STORAGE_KEY, manifest.version);
+      window.location.href = errorReloadPath;
+      throw new Error("Detected manifest version mismatch, reloading...");
     } else if (res.status >= 400) {
       throw new Error(await res.text());
     }
+    sessionStorage.removeItem(MANIFEST_VERSION_STORAGE_KEY);
     serverPatches = await res.json();
   } catch (e) {
     if (signal?.aborted) return;
@@ -6914,7 +7384,7 @@ function Links() {
     () => getKeyedLinksForMatches(matches, routeModules, manifest),
     [matches, routeModules, manifest]
   );
-  return /* @__PURE__ */ React9.createElement(React9.Fragment, null, criticalCss ? /* @__PURE__ */ React9.createElement("style", { dangerouslySetInnerHTML: { __html: criticalCss } }) : null, keyedLinks.map(
+  return /* @__PURE__ */ React9.createElement(React9.Fragment, null, typeof criticalCss === "string" ? /* @__PURE__ */ React9.createElement("style", { dangerouslySetInnerHTML: { __html: criticalCss } }) : null, typeof criticalCss === "object" ? /* @__PURE__ */ React9.createElement("link", { rel: "stylesheet", href: criticalCss.href }) : null, keyedLinks.map(
     ({ key, link }) => isPageLinkDescriptor(link) ? /* @__PURE__ */ React9.createElement(PrefetchPageLinks, { key, ...link }) : /* @__PURE__ */ React9.createElement("link", { key, ...link })
   ));
 }
@@ -6957,6 +7427,7 @@ function PrefetchPageLinksImpl({
 }) {
   let location = useLocation();
   let { manifest, routeModules } = useFrameworkContext();
+  let { basename } = useDataRouterContext2();
   let { loaderData, matches } = useDataRouterStateContext();
   let newMatchesForData = React9.useMemo(
     () => getNewMatchesForLinks(
@@ -7002,7 +7473,7 @@ function PrefetchPageLinksImpl({
     if (routesParams.size === 0) {
       return [];
     }
-    let url = singleFetchUrl(page);
+    let url = singleFetchUrl(page, basename);
     if (foundOptOutRoute && routesParams.size > 0) {
       url.searchParams.set(
         "_routes",
@@ -7011,6 +7482,7 @@ function PrefetchPageLinksImpl({
     }
     return [url.pathname + url.search];
   }, [
+    basename,
     loaderData,
     location,
     manifest,
@@ -7264,13 +7736,14 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.2.0";
+    window.__reactRouterVersion = "7.3.0-pre.0";
   }
 } catch (e) {
 }
 function createBrowserRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
+    unstable_getContext: opts?.unstable_getContext,
     future: opts?.future,
     history: createBrowserHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -7284,6 +7757,7 @@ function createBrowserRouter(routes, opts) {
 function createHashRouter(routes, opts) {
   return createRouter({
     basename: opts?.basename,
+    unstable_getContext: opts?.unstable_getContext,
     future: opts?.future,
     history: createHashHistory({ window: opts?.window }),
     hydrationData: opts?.hydrationData || parseHydrationData(),
@@ -8242,6 +8716,7 @@ function createStaticRouter(routes, context, opts = {}) {
     },
     get future() {
       return {
+        unstable_middleware: false,
         ...opts?.future
       };
     },
@@ -8404,7 +8879,7 @@ function ServerRouter({
 
 // lib/dom/ssr/routes-test-stub.tsx
 var React13 = __toESM(require("react"));
-function createRoutesStub(routes, context = {}) {
+function createRoutesStub(routes, unstable_getContext) {
   return function RoutesTestStub({
     initialEntries,
     initialIndex,
@@ -8415,7 +8890,9 @@ function createRoutesStub(routes, context = {}) {
     let remixContextRef = React13.useRef();
     if (routerRef.current == null) {
       remixContextRef.current = {
-        future: {},
+        future: {
+          unstable_middleware: future?.unstable_middleware === true
+        },
         manifest: {
           routes: {},
           entry: { imports: [], module: "" },
@@ -8427,13 +8904,14 @@ function createRoutesStub(routes, context = {}) {
         isSpaMode: false
       };
       let patched = processRoutes(
-        // @ts-expect-error loader/action context types don't match :/
+        // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
+        // types compared to `AgnosticRouteObject`
         convertRoutesToDataRoutes(routes, (r) => r),
-        context,
         remixContextRef.current.manifest,
         remixContextRef.current.routeModules
       );
       routerRef.current = createMemoryRouter(patched, {
+        unstable_getContext,
         initialEntries,
         initialIndex,
         hydrationData
@@ -8442,14 +8920,13 @@ function createRoutesStub(routes, context = {}) {
     return /* @__PURE__ */ React13.createElement(FrameworkContext.Provider, { value: remixContextRef.current }, /* @__PURE__ */ React13.createElement(RouterProvider, { router: routerRef.current }));
   };
 }
-function processRoutes(routes, context, manifest, routeModules, parentId) {
+function processRoutes(routes, 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,
@@ -8457,8 +8934,8 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
       Component: route.Component,
       HydrateFallback: route.HydrateFallback,
       ErrorBoundary: route.ErrorBoundary,
-      action: action ? (args) => action({ ...args, context }) : void 0,
-      loader: loader ? (args) => loader({ ...args, context }) : void 0,
+      action: route.action,
+      loader: route.loader,
       handle: route.handle,
       shouldRevalidate: route.shouldRevalidate
     };
@@ -8493,7 +8970,6 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
     if (route.children) {
       newRoute.children = processRoutes(
         route.children,
-        context,
         manifest,
         routeModules,
         newRoute.id
@@ -8854,6 +9330,7 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
       hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
       id: route.id,
       path: route.path,
+      unstable_middleware: route.module.unstable_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) => {
@@ -8999,27 +9476,46 @@ function prependCookies(parentHeaders, childHeaders) {
 }
 
 // lib/server-runtime/single-fetch.ts
+var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([100, 101, 204, 205, 304]);
 var SINGLE_FETCH_REDIRECT_STATUS = 202;
-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 respond2 = function(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
+      });
+    };
+    var respond = respond2;
     let handlerRequest = new Request(handlerUrl, {
       method: request.method,
       body: request.body,
@@ -9030,12 +9526,14 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
       skipLoaderErrorBubbling: true,
-      dataStrategy: getSingleFetchDataStrategy2({
-        isActionDataRequest: true
-      })
+      skipRevalidation: true,
+      unstable_respond: respond2
     });
-    if (isResponse(result)) {
-      return {
+    if (!isResponse(result)) {
+      result = respond2(result);
+    }
+    if (isRedirectResponse(result)) {
+      return generateSingleFetchResponse(request, build, serverMode, {
         result: getSingleFetchRedirect(
           result.status,
           result.headers,
@@ -9043,65 +9541,83 @@ 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);
     }
-    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
-    };
+    return result;
   } catch (error) {
     handleError(error);
-    return {
+    return generateSingleFetchResponse(request, build, serverMode, {
       result: { error },
       headers: new Headers(),
       status: 500
-    };
+    });
   }
 }
 async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
   try {
+    let respond2 = function(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
+      });
+    };
+    var respond = respond2;
     let handlerRequest = new Request(handlerUrl, {
       headers: request.headers,
       signal: request.signal
     });
-    let loadRouteIds = new URL(request.url).searchParams.get("_routes")?.split(",") || void 0;
+    let routesParam = new URL(request.url).searchParams.get("_routes");
+    let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
+      filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
       skipLoaderErrorBubbling: true,
-      dataStrategy: getSingleFetchDataStrategy2({
-        loadRouteIds
-      })
+      unstable_respond: respond2
     });
-    if (isResponse(result)) {
-      return {
+    if (!isResponse(result)) {
+      result = respond2(result);
+    }
+    if (isRedirectResponse(result)) {
+      return generateSingleFetchResponse(request, build, serverMode, {
         result: {
           [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
             result.status,
@@ -9111,57 +9627,42 @@ 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);
     }
-    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
-    };
+    return result;
   } catch (error) {
     handleError(error);
-    return {
+    return generateSingleFetchResponse(request, build, serverMode, {
       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");
   if (basename) {
@@ -9223,7 +9724,6 @@ 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);
@@ -9253,8 +9753,11 @@ var createRequestHandler = (build, mode) => {
   let serverMode;
   let staticHandler;
   let errorHandler;
-  return async function requestHandler(request, loadContext = {}) {
+  return async function requestHandler(request, initialContext) {
     _build = typeof build === "function" ? await build() : build;
+    let loadContext = _build.future.unstable_middleware ? new unstable_RouterContextProvider(
+      initialContext
+    ) : initialContext || {};
     if (typeof build === "function") {
       let derived = derive(_build, mode);
       routes = derived.routes;
@@ -9269,8 +9772,14 @@ var createRequestHandler = (build, mode) => {
       errorHandler = derived.errorHandler;
     }
     let url = new URL(request.url);
-    let normalizedPath = url.pathname.replace(/\.data$/, "").replace(/^\/_root$/, "/");
-    if (normalizedPath !== "/" && normalizedPath.endsWith("/")) {
+    let normalizedBasename = _build.basename || "/";
+    let normalizedPath = url.pathname;
+    if (stripBasename(normalizedPath, normalizedBasename) === "/_root.data") {
+      normalizedPath = normalizedBasename;
+    } else if (normalizedPath.endsWith(".data")) {
+      normalizedPath = normalizedPath.replace(/\.data$/, "");
+    }
+    if (stripBasename(normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
       normalizedPath = normalizedPath.slice(0, -1);
     }
     let params = {};
@@ -9310,10 +9819,7 @@ var createRequestHandler = (build, mode) => {
         }
       }
     }
-    let manifestUrl = `${_build.basename ?? "/"}/__manifest`.replace(
-      /\/+/g,
-      "/"
-    );
+    let manifestUrl = `${normalizedBasename}/__manifest`.replace(/\/+/g, "/");
     if (url.pathname === manifestUrl) {
       try {
         let res = await handleManifestRequest(_build, routes, url);
@@ -9378,9 +9884,10 @@ var createRequestHandler = (build, mode) => {
           );
         }
       }
-    } else if (matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) {
+    } else if (!request.headers.has("X-React-Router-SPA-Mode") && matches && matches[matches.length - 1].route.module.default == null && matches[matches.length - 1].route.module.ErrorBoundary == null) {
       response = await handleResourceRequest(
         serverMode,
+        _build,
         staticHandler,
         matches.slice(-1)[0].route.id,
         request,
@@ -9388,7 +9895,13 @@ var createRequestHandler = (build, mode) => {
         handleError
       );
     } else {
-      let criticalCss = mode === "development" /* Development */ ? await getDevServerHooks()?.getCriticalCss?.(_build, url.pathname) : void 0;
+      let { pathname } = url;
+      let criticalCss = void 0;
+      if (_build.getCriticalCss) {
+        criticalCss = await _build.getCriticalCss({ pathname });
+      } else if (mode === "development" /* Development */ && getDevServerHooks()?.getCriticalCss) {
+        criticalCss = await getDevServerHooks()?.getCriticalCss?.(pathname);
+      }
       response = await handleDocumentRequest(
         serverMode,
         _build,
@@ -9410,6 +9923,14 @@ var createRequestHandler = (build, mode) => {
   };
 };
 async function handleManifestRequest(build, routes, url) {
+  if (build.assets.version !== url.searchParams.get("version")) {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "X-Remix-Reload-Document": "true"
+      }
+    });
+  }
   let patches = {};
   if (url.searchParams.has("p")) {
     for (let path of url.searchParams.getAll("p")) {
@@ -9433,7 +9954,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 { result, headers, status } = request.method !== "GET" ? await singleFetchAction(
+  let response = request.method !== "GET" ? await singleFetchAction(
     build,
     serverMode,
     staticHandler,
@@ -9450,133 +9971,66 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
     loadContext,
     handleError
   );
-  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
-    }
-  );
+  return response;
 }
 async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, criticalCss) {
   let isSpaMode = request.headers.has("X-React-Router-SPA-Mode");
-  let context;
   try {
-    context = await staticHandler.query(request, {
-      requestContext: loadContext
+    let response = await staticHandler.query(request, {
+      requestContext: loadContext,
+      unstable_respond: build.future.unstable_middleware ? (ctx) => renderHtml(ctx, isSpaMode) : void 0
     });
+    return isResponse(response) ? response : renderHtml(response, isSpaMode);
   } catch (error) {
     handleError(error);
     return new Response(null, { status: 500 });
   }
-  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,
-      ssr: build.ssr,
-      isSpaMode
-    }),
-    serverHandoffStream: encodeViaTurboStream(
-      state,
-      request.signal,
-      build.entry.module.streamTimeout,
-      serverMode
-    ),
-    renderMeta: {},
-    future: build.future,
-    ssr: build.ssr,
-    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) {
-      }
+  async function renderHtml(context, isSpaMode2) {
+    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 });
     }
-    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 state2 = {
+    let state = {
       loaderData: context.loaderData,
       actionData: context.actionData,
       errors: serializeErrors2(context.errors, serverMode)
     };
-    entryContext = {
-      ...entryContext,
+    let entryContext = {
+      manifest: build.assets,
+      routeModules: createEntryRouteModules(build.routes),
       staticHandlerContext: context,
+      criticalCss,
       serverHandoffString: createServerHandoffString({
         basename: build.basename,
+        criticalCss,
         future: build.future,
         ssr: build.ssr,
-        isSpaMode
+        isSpaMode: isSpaMode2
       }),
       serverHandoffStream: encodeViaTurboStream(
-        state2,
+        state,
         request.signal,
         build.entry.module.streamTimeout,
         serverMode
       ),
-      renderMeta: {}
+      renderMeta: {},
+      future: build.future,
+      ssr: build.ssr,
+      isSpaMode: isSpaMode2,
+      serializeError: (err) => serializeError(err, serverMode)
     };
+    let handleDocumentRequestFunction = build.entry.module.default;
     try {
       return await handleDocumentRequestFunction(
         request,
@@ -9585,17 +10039,71 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
         entryContext,
         loadContext
       );
-    } catch (error2) {
-      handleError(error2);
-      return returnLastResortErrorResponse(error2, serverMode);
+    } 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,
+          ssr: build.ssr,
+          isSpaMode: isSpaMode2
+        }),
+        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);
+      }
     }
   }
 }
-async function handleResourceRequest(serverMode, staticHandler, routeId, request, loadContext, handleError) {
+async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
   try {
     let response = await staticHandler.queryRoute(request, {
       routeId,
-      requestContext: loadContext
+      requestContext: loadContext,
+      unstable_respond: build.future.unstable_middleware ? (ctx) => ctx : void 0
     });
     if (isResponse(response)) {
       return response;
@@ -9615,6 +10123,13 @@ 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);
   }
@@ -9931,6 +10446,8 @@ function deserializeErrors2(errors) {
   replace,
   resolvePath,
   unstable_HistoryRouter,
+  unstable_RouterContextProvider,
+  unstable_createContext,
   unstable_setDevServerHooks,
   unstable_usePrompt,
   useActionData,