@remix-run/router 1.15.3 → 1.16.0-pre.0

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.15.3
+ * @remix-run/router v1.16.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -579,6 +579,10 @@
    * Result from a loader or action - potentially successful or unsuccessful
    */
 
+  /**
+   * Result from a loader or action called via dataStrategy
+   */
+
   /**
    * Users can specify either lowercase or uppercase form methods on `<Form>`,
    * useSubmit(), `<fetcher.Form>`, etc.
@@ -1595,11 +1599,6 @@
   /**
    * Identified fetcher.load() calls that need to be revalidated
    */
-  /**
-   * Wrapper object to allow us to throw any response out from callLoaderOrAction
-   * for queryRouter while preserving whether or not it was thrown or returned
-   * from the loader/action
-   */
   const validMutationMethodsArr = ["post", "put", "patch", "delete"];
   const validMutationMethods = new Set(validMutationMethodsArr);
   const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
@@ -1671,13 +1670,15 @@
     let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
     let inFlightDataRoutes;
     let basename = init.basename || "/";
+    let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;
     // Config driven behavior flags
     let future = _extends({
       v7_fetcherPersist: false,
       v7_normalizeFormMethod: false,
       v7_partialHydration: false,
       v7_prependBasename: false,
-      v7_relativeSplatPath: false
+      v7_relativeSplatPath: false,
+      unstable_skipActionErrorRevalidation: false
     }, init.future);
     // Cleanup function for history
     let unlistenHistory = null;
@@ -1731,9 +1732,13 @@
       let errors = init.hydrationData ? init.hydrationData.errors : null;
       let isRouteInitialized = m => {
         // No loader, nothing to initialize
-        if (!m.route.loader) return true;
+        if (!m.route.loader) {
+          return true;
+        }
         // Explicitly opting-in to running on hydration
-        if (m.route.loader.hydrate === true) return false;
+        if (typeof m.route.loader === "function" && m.route.loader.hydrate === true) {
+          return false;
+        }
         // Otherwise, initialized if hydrated with data or an error
         return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;
       };
@@ -2274,34 +2279,31 @@
       // Create a controller/Request for this navigation
       pendingNavigationController = new AbortController();
       let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
-      let pendingActionData;
-      let pendingError;
+      let pendingActionResult;
       if (opts && opts.pendingError) {
         // If we have a pendingError, it means the user attempted a GET submission
         // with binary FormData so assign here and skip to handleLoaders.  That
         // way we handle calling loaders above the boundary etc.  It's not really
         // different from an actionError in that sense.
-        pendingError = {
-          [findNearestBoundary(matches).route.id]: opts.pendingError
-        };
+        pendingActionResult = [findNearestBoundary(matches).route.id, {
+          type: ResultType.error,
+          error: opts.pendingError
+        }];
       } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
         // Call action if we received an action submission
-        let actionOutput = await handleAction(request, location, opts.submission, matches, {
+        let actionResult = await handleAction(request, location, opts.submission, matches, {
           replace: opts.replace,
           flushSync
         });
-        if (actionOutput.shortCircuited) {
+        if (actionResult.shortCircuited) {
           return;
         }
-        pendingActionData = actionOutput.pendingActionData;
-        pendingError = actionOutput.pendingActionError;
+        pendingActionResult = actionResult.pendingActionResult;
         loadingNavigation = getLoadingNavigation(location, opts.submission);
         flushSync = false;
 
         // Create a GET request for the loaders
-        request = new Request(request.url, {
-          signal: request.signal
-        });
+        request = createClientSideRequest(init.history, request.url, request.signal);
       }
 
       // Call loaders
@@ -2309,7 +2311,7 @@
         shortCircuited,
         loaderData,
         errors
-      } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionData, pendingError);
+      } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
       if (shortCircuited) {
         return;
       }
@@ -2320,9 +2322,7 @@
       pendingNavigationController = null;
       completeNavigation(location, _extends({
         matches
-      }, pendingActionData ? {
-        actionData: pendingActionData
-      } : {}, {
+      }, getActionDataForCommit(pendingActionResult), {
         loaderData,
         errors
       }));
@@ -2357,7 +2357,8 @@
           })
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+        let results = await callDataStrategy("action", request, [actionMatch], matches);
+        result = results[0];
         if (request.signal.aborted) {
           return {
             shortCircuited: true
@@ -2372,9 +2373,10 @@
           // If the user didn't explicity indicate replace behavior, replace if
           // we redirected to the exact same location we're currently at to avoid
           // double back-buttons
-          replace = result.location === state.location.pathname + state.location.search;
+          let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename);
+          replace = location === state.location.pathname + state.location.search;
         }
-        await startRedirectNavigation(state, result, {
+        await startRedirectNavigation(request, result, {
           submission,
           replace
         });
@@ -2382,6 +2384,11 @@
           shortCircuited: true
         };
       }
+      if (isDeferredResult(result)) {
+        throw getInternalRouterError(400, {
+          type: "defer-action"
+        });
+      }
       if (isErrorResult(result)) {
         // Store off the pending error - we use it to determine which loaders
         // to call and will commit it when we complete the navigation
@@ -2395,28 +2402,17 @@
           pendingAction = Action.Push;
         }
         return {
-          // Send back an empty object we can use to clear out any prior actionData
-          pendingActionData: {},
-          pendingActionError: {
-            [boundaryMatch.route.id]: result.error
-          }
+          pendingActionResult: [boundaryMatch.route.id, result]
         };
       }
-      if (isDeferredResult(result)) {
-        throw getInternalRouterError(400, {
-          type: "defer-action"
-        });
-      }
       return {
-        pendingActionData: {
-          [actionMatch.route.id]: result.data
-        }
+        pendingActionResult: [actionMatch.route.id, result]
       };
     }
 
     // Call all applicable loaders for the given matches, handling redirects,
     // errors, etc.
-    async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionData, pendingError) {
+    async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
       // Figure out the right navigation we want to use for data loading
       let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
 
@@ -2424,7 +2420,7 @@
       // we have it on the loading navigation so use that if available
       let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
       let routesToUse = inFlightDataRoutes || dataRoutes;
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError);
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.unstable_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
 
       // Cancel pending deferreds for no-longer-matched routes or routes we're
       // about to reload.  Note that if this is an action reload we would have
@@ -2439,10 +2435,10 @@
           matches,
           loaderData: {},
           // Commit pending error if we're short circuiting
-          errors: pendingError || null
-        }, pendingActionData ? {
-          actionData: pendingActionData
-        } : {}, updatedFetchers ? {
+          errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+            [pendingActionResult[0]]: pendingActionResult[1].error
+          } : null
+        }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {
           fetchers: new Map(state.fetchers)
         } : {}), {
           flushSync
@@ -2464,12 +2460,24 @@
           let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
           state.fetchers.set(rf.key, revalidatingFetcher);
         });
-        let actionData = pendingActionData || state.actionData;
+        let actionData;
+        if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+          // This is cast to `any` currently because `RouteData`uses any and it
+          // would be a breaking change to use any.
+          // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+          actionData = {
+            [pendingActionResult[0]]: pendingActionResult[1].data
+          };
+        } else if (state.actionData) {
+          if (Object.keys(state.actionData).length === 0) {
+            actionData = null;
+          } else {
+            actionData = state.actionData;
+          }
+        }
         updateState(_extends({
           navigation: loadingNavigation
-        }, actionData ? Object.keys(actionData).length === 0 ? {
-          actionData: null
-        } : {
+        }, actionData !== undefined ? {
           actionData
         } : {}, revalidatingFetchers.length > 0 ? {
           fetchers: new Map(state.fetchers)
@@ -2495,7 +2503,6 @@
         pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
       }
       let {
-        results,
         loaderResults,
         fetcherResults
       } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);
@@ -2514,7 +2521,7 @@
       revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
 
       // If any loaders returned a redirect Response, start a new REPLACE navigation
-      let redirect = findRedirect(results);
+      let redirect = findRedirect([...loaderResults, ...fetcherResults]);
       if (redirect) {
         if (redirect.idx >= matchesToLoad.length) {
           // If this redirect came from a fetcher make sure we mark it in
@@ -2523,7 +2530,7 @@
           let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
           fetchRedirectIds.add(fetcherKey);
         }
-        await startRedirectNavigation(state, redirect.result, {
+        await startRedirectNavigation(request, redirect.result, {
           replace
         });
         return {
@@ -2535,7 +2542,7 @@
       let {
         loaderData,
         errors
-      } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds);
+      } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
 
       // Wire up subscribers to update loaderData as promises settle
       activeDeferreds.forEach((deferredData, routeId) => {
@@ -2645,7 +2652,8 @@
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let actionResult = await callLoaderOrAction("action", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+      let actionResults = await callDataStrategy("action", fetchRequest, [match], requestMatches);
+      let actionResult = actionResults[0];
       if (fetchRequest.signal.aborted) {
         // We can delete this so long as we weren't aborted by our own fetcher
         // re-submit which would have put _new_ controller is in fetchControllers
@@ -2677,7 +2685,7 @@
           } else {
             fetchRedirectIds.add(key);
             updateFetcherState(key, getLoadingFetcher(submission));
-            return startRedirectNavigation(state, actionResult, {
+            return startRedirectNavigation(fetchRequest, actionResult, {
               fetcherSubmission: submission
             });
           }
@@ -2706,10 +2714,7 @@
       fetchReloadIds.set(key, loadId);
       let loadFetcher = getLoadingFetcher(submission, actionResult.data);
       state.fetchers.set(key, loadFetcher);
-      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, {
-        [match.route.id]: actionResult.data
-      }, undefined // No need to send through errors since we short circuit above
-      );
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.unstable_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
 
       // Put all revalidating fetchers into the loading state, except for the
       // current fetcher which we want to keep in it's current loading state which
@@ -2732,7 +2737,6 @@
       let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
       abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
       let {
-        results,
         loaderResults,
         fetcherResults
       } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
@@ -2743,7 +2747,7 @@
       fetchReloadIds.delete(key);
       fetchControllers.delete(key);
       revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
-      let redirect = findRedirect(results);
+      let redirect = findRedirect([...loaderResults, ...fetcherResults]);
       if (redirect) {
         if (redirect.idx >= matchesToLoad.length) {
           // If this redirect came from a fetcher make sure we mark it in
@@ -2752,7 +2756,7 @@
           let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;
           fetchRedirectIds.add(fetcherKey);
         }
-        return startRedirectNavigation(state, redirect.result);
+        return startRedirectNavigation(revalidationRequest, redirect.result);
       }
 
       // Process and commit output from loaders
@@ -2806,7 +2810,8 @@
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
-      let result = await callLoaderOrAction("loader", fetchRequest, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+      let results = await callDataStrategy("loader", fetchRequest, [match], matches);
+      let result = results[0];
 
       // Deferred isn't supported for fetcher loads, await everything and treat it
       // as a normal load.  resolveDeferredData will return undefined if this
@@ -2841,7 +2846,7 @@
           return;
         } else {
           fetchRedirectIds.add(key);
-          await startRedirectNavigation(state, result);
+          await startRedirectNavigation(fetchRequest, result);
           return;
         }
       }
@@ -2876,26 +2881,28 @@
      * actually touch history until we've processed redirects, so we just use
      * the history action from the original navigation (PUSH or REPLACE).
      */
-    async function startRedirectNavigation(state, redirect, _temp2) {
+    async function startRedirectNavigation(request, redirect, _temp2) {
       let {
         submission,
         fetcherSubmission,
         replace
       } = _temp2 === void 0 ? {} : _temp2;
-      if (redirect.revalidate) {
+      if (redirect.response.headers.has("X-Remix-Revalidate")) {
         isRevalidationRequired = true;
       }
-      let redirectLocation = createLocation(state.location, redirect.location, {
+      let location = redirect.response.headers.get("Location");
+      invariant(location, "Expected a Location header on the redirect Response");
+      location = normalizeRedirectLocation(location, new URL(request.url), basename);
+      let redirectLocation = createLocation(state.location, location, {
         _isRedirect: true
       });
-      invariant(redirectLocation, "Expected a location on the redirect navigation");
       if (isBrowser) {
         let isDocumentReload = false;
-        if (redirect.reloadDocument) {
+        if (redirect.response.headers.has("X-Remix-Reload-Document")) {
           // Hard reload if the response contained X-Remix-Reload-Document
           isDocumentReload = true;
-        } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {
-          const url = init.history.createURL(redirect.location);
+        } else if (ABSOLUTE_URL_REGEX.test(location)) {
+          const url = init.history.createURL(location);
           isDocumentReload =
           // Hard reload if it's an absolute URL to a new origin
           url.origin !== routerWindow.location.origin ||
@@ -2904,9 +2911,9 @@
         }
         if (isDocumentReload) {
           if (replace) {
-            routerWindow.location.replace(redirect.location);
+            routerWindow.location.replace(location);
           } else {
-            routerWindow.location.assign(redirect.location);
+            routerWindow.location.assign(location);
           }
           return;
         }
@@ -2932,10 +2939,10 @@
       // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
       // redirected location
       let activeSubmission = submission || fetcherSubmission;
-      if (redirectPreserveMethodStatusCodes.has(redirect.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
+      if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
         await startNavigation(redirectHistoryAction, redirectLocation, {
           submission: _extends({}, activeSubmission, {
-            formAction: redirect.location
+            formAction: location
           }),
           // Preserve this flag across redirects
           preventScrollReset: pendingPreventScrollReset
@@ -2953,28 +2960,47 @@
         });
       }
     }
+
+    // Utility wrapper for calling dataStrategy client-side without having to
+    // pass around the manifest, mapRouteProperties, etc.
+    async function callDataStrategy(type, request, matchesToLoad, matches) {
+      try {
+        let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);
+        return await Promise.all(results.map((result, i) => {
+          if (isRedirectHandlerResult(result)) {
+            let response = result.result;
+            return {
+              type: ResultType.redirect,
+              response: normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)
+            };
+          }
+          return convertHandlerResultToDataResult(result);
+        }));
+      } catch (e) {
+        // If the outer dataStrategy method throws, just return the error for all
+        // matches - and it'll naturally bubble to the root
+        return matchesToLoad.map(() => ({
+          type: ResultType.error,
+          error: e
+        }));
+      }
+    }
     async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {
-      // Call all navigation loaders and revalidating fetcher loaders in parallel,
-      // then slice off the results into separate arrays so we can handle them
-      // accordingly
-      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath)), ...fetchersToLoad.map(f => {
+      let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy("loader", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {
         if (f.matches && f.match && f.controller) {
-          return callLoaderOrAction("loader", createClientSideRequest(init.history, f.path, f.controller.signal), f.match, f.matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);
+          let fetcherRequest = createClientSideRequest(init.history, f.path, f.controller.signal);
+          return callDataStrategy("loader", fetcherRequest, [f.match], f.matches).then(r => r[0]);
         } else {
-          let error = {
+          return Promise.resolve({
             type: ResultType.error,
             error: getInternalRouterError(404, {
               pathname: f.path
             })
-          };
-          return error;
+          });
         }
       })]);
-      let loaderResults = results.slice(0, matchesToLoad.length);
-      let fetcherResults = results.slice(matchesToLoad.length);
       await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);
       return {
-        results,
         loaderResults,
         fetcherResults
       };
@@ -3324,10 +3350,25 @@
      * redirect response is returned or thrown from any action/loader.  We
      * propagate that out and return the raw Response so the HTTP server can
      * return it directly.
+     *
+     * - `opts.loadRouteIds` is an optional array of routeIds to run only a subset of
+     *   loaders during a query() call
+     * - `opts.requestContext` is an optional server context that will be passed
+     *   to actions/loaders in the `context` parameter
+     * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
+     *   the bubbling of errors which allows single-fetch-type implementations
+     *   where the client will handle the bubbling and we may need to return data
+     *   for the handling route
+     * - `opts.skipLoaders` is an optional parameter that will prevent loaders
+     *   from running after an action
      */
     async function query(request, _temp3) {
       let {
-        requestContext
+        loadRouteIds,
+        requestContext,
+        skipLoaderErrorBubbling,
+        skipLoaders,
+        unstable_dataStrategy
       } = _temp3 === void 0 ? {} : _temp3;
       let url = new URL(request.url);
       let method = request.method;
@@ -3380,7 +3421,7 @@
           activeDeferreds: null
         };
       }
-      let result = await queryImpl(request, location, matches, requestContext);
+      let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, loadRouteIds || null, skipLoaderErrorBubbling === true, skipLoaders === true, null);
       if (isResponse(result)) {
         return result;
       }
@@ -3413,6 +3454,12 @@
      * serialize the error as they see fit while including the proper response
      * code.  Examples here are 404 and 405 errors that occur prior to reaching
      * any user-defined loaders.
+     *
+     * - `opts.routeId` allows you to specify the specific route handler to call.
+     *   If not provided the handler will determine the proper route by matching
+     *   against `request.url`
+     * - `opts.requestContext` is an optional server context that will be passed
+     *    to actions/loaders in the `context` parameter
      */
     async function queryRoute(request, _temp4) {
       let {
@@ -3446,7 +3493,7 @@
           pathname: location.pathname
         });
       }
-      let result = await queryImpl(request, location, matches, requestContext, match);
+      let result = await queryImpl(request, location, matches, requestContext, null, null, false, false, match);
       if (isResponse(result)) {
         return result;
       }
@@ -3473,27 +3520,27 @@
       }
       return undefined;
     }
-    async function queryImpl(request, location, matches, requestContext, routeMatch) {
+    async function queryImpl(request, location, matches, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, skipLoaders, routeMatch) {
       invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
       try {
         if (isMutationMethod(request.method.toLowerCase())) {
-          let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, routeMatch != null);
+          let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, skipLoaders, routeMatch != null);
           return result;
         }
-        let result = await loadRouteData(request, matches, requestContext, routeMatch);
+        let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, routeMatch);
         return isResponse(result) ? result : _extends({}, result, {
           actionData: null,
           actionHeaders: {}
         });
       } catch (e) {
-        // If the user threw/returned a Response in callLoaderOrAction, we throw
-        // it to bail out and then return or throw here based on whether the user
-        // returned or threw
-        if (isQueryRouteResponse(e)) {
+        // If the user threw/returned a Response in callLoaderOrAction for a
+        // `queryRoute` call, we throw the `HandlerResult` to bail out early
+        // and then return or throw the raw Response here accordingly
+        if (isHandlerResult(e) && isResponse(e.result)) {
           if (e.type === ResultType.error) {
-            throw e.response;
+            throw e.result;
           }
-          return e.response;
+          return e.result;
         }
         // Redirects are always returned since they don't propagate to catch
         // boundaries
@@ -3503,7 +3550,7 @@
         throw e;
       }
     }
-    async function submit(request, matches, actionMatch, requestContext, isRouteRequest) {
+    async function submit(request, matches, actionMatch, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, skipLoaders, isRouteRequest) {
       let result;
       if (!actionMatch.route.action && !actionMatch.route.lazy) {
         let error = getInternalRouterError(405, {
@@ -3519,11 +3566,8 @@
           error
         };
       } else {
-        result = await callLoaderOrAction("action", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {
-          isStaticRequest: true,
-          isRouteRequest,
-          requestContext
-        });
+        let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);
+        result = results[0];
         if (request.signal.aborted) {
           throwStaticHandlerAbortedError(request, isRouteRequest, future);
         }
@@ -3534,9 +3578,9 @@
         // can get back on the "throw all redirect responses" train here should
         // this ever happen :/
         throw new Response(null, {
-          status: result.status,
+          status: result.response.status,
           headers: {
-            Location: result.location
+            Location: result.response.headers.get("Location")
           }
         });
       }
@@ -3573,43 +3617,75 @@
           activeDeferreds: null
         };
       }
+
+      // Create a GET request for the loaders
+      let loaderRequest = new Request(request.url, {
+        headers: request.headers,
+        redirect: request.redirect,
+        signal: request.signal
+      });
       if (isErrorResult(result)) {
         // Store off the pending error - we use it to determine which loaders
         // to call and will commit it when we complete the navigation
-        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
-        let context = await loadRouteData(request, matches, requestContext, undefined, {
-          [boundaryMatch.route.id]: result.error
-        });
+        let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
+        let statusCode = isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500;
+        let actionHeaders = _extends({}, result.headers ? {
+          [actionMatch.route.id]: result.headers
+        } : {});
+        if (skipLoaders) {
+          return {
+            matches,
+            loaderData: {},
+            actionData: {},
+            errors: {
+              [boundaryMatch.route.id]: result.error
+            },
+            statusCode,
+            loaderHeaders: {},
+            actionHeaders,
+            activeDeferreds: null
+          };
+        }
+        let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
 
         // action status codes take precedence over loader status codes
         return _extends({}, context, {
-          statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,
+          statusCode,
           actionData: null,
-          actionHeaders: _extends({}, result.headers ? {
-            [actionMatch.route.id]: result.headers
-          } : {})
+          actionHeaders
         });
       }
-
-      // Create a GET request for the loaders
-      let loaderRequest = new Request(request.url, {
-        headers: request.headers,
-        redirect: request.redirect,
-        signal: request.signal
-      });
-      let context = await loadRouteData(loaderRequest, matches, requestContext);
-      return _extends({}, context, result.statusCode ? {
-        statusCode: result.statusCode
-      } : {}, {
+      let actionHeaders = result.headers ? {
+        [actionMatch.route.id]: result.headers
+      } : {};
+      if (skipLoaders) {
+        return {
+          matches,
+          loaderData: {},
+          actionData: {
+            [actionMatch.route.id]: result.data
+          },
+          errors: null,
+          statusCode: result.statusCode || 200,
+          loaderHeaders: {},
+          actionHeaders,
+          activeDeferreds: null
+        };
+      }
+      let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, null);
+      return _extends({}, context, {
         actionData: {
           [actionMatch.route.id]: result.data
-        },
-        actionHeaders: _extends({}, result.headers ? {
+        }
+      }, result.statusCode ? {
+        statusCode: result.statusCode
+      } : {}, {
+        actionHeaders: result.headers ? {
           [actionMatch.route.id]: result.headers
-        } : {})
+        } : {}
       });
     }
-    async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {
+    async function loadRouteData(request, matches, requestContext, unstable_dataStrategy, loadRouteIds, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
       let isRouteRequest = routeMatch != null;
 
       // Short circuit if we have no loaders to run (queryRoute())
@@ -3620,8 +3696,11 @@
           routeId: routeMatch == null ? void 0 : routeMatch.route.id
         });
       }
-      let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);
+      let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
       let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
+      if (loadRouteIds) {
+        matchesToLoad = matchesToLoad.filter(m => loadRouteIds.includes(m.route.id));
+      }
 
       // Short circuit if we have no loaders to run (query())
       if (matchesToLoad.length === 0) {
@@ -3631,24 +3710,22 @@
           loaderData: matches.reduce((acc, m) => Object.assign(acc, {
             [m.route.id]: null
           }), {}),
-          errors: pendingActionError || null,
+          errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+            [pendingActionResult[0]]: pendingActionResult[1].error
+          } : null,
           statusCode: 200,
           loaderHeaders: {},
           activeDeferreds: null
         };
       }
-      let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction("loader", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {
-        isStaticRequest: true,
-        isRouteRequest,
-        requestContext
-      }))]);
+      let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy);
       if (request.signal.aborted) {
         throwStaticHandlerAbortedError(request, isRouteRequest, future);
       }
 
       // Process and commit output from loaders
       let activeDeferreds = new Map();
-      let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds);
+      let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
 
       // Add a null for any non-loader matches for proper revalidation on the client
       let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
@@ -3662,6 +3739,25 @@
         activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
       });
     }
+
+    // Utility wrapper for calling dataStrategy server-side without having to
+    // pass around the manifest, mapRouteProperties, etc.
+    async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy) {
+      let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);
+      return await Promise.all(results.map((result, i) => {
+        if (isRedirectHandlerResult(result)) {
+          let response = result.result;
+          // Throw redirects and let the server handle them with an HTTP redirect
+          throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);
+        }
+        if (isResponse(result.result) && isRouteRequest) {
+          // For SSR single-route requests, we want to hand Responses back
+          // directly without unwrapping
+          throw result;
+        }
+        return convertHandlerResultToDataResult(result);
+      }));
+    }
     return {
       dataRoutes,
       query,
@@ -3882,14 +3978,20 @@
     }
     return boundaryMatches;
   }
-  function getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError) {
-    let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;
+  function getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+    let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
     let currentUrl = history.createURL(state.location);
     let nextUrl = history.createURL(location);
 
     // Pick navigation matches that are net-new or qualify for revalidation
-    let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;
-    let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);
+    let boundaryId = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;
+    let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;
+
+    // Don't revalidate loaders by default after action 4xx/5xx responses
+    // when the flag is enabled.  They can still opt-into revalidation via
+    // `shouldRevalidate` via `actionResult`
+    let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;
+    let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
     let navigationMatches = boundaryMatches.filter((match, index) => {
       let {
         route
@@ -3902,7 +4004,7 @@
         return false;
       }
       if (isInitialLoad) {
-        if (route.loader.hydrate) {
+        if (typeof route.loader !== "function" || route.loader.hydrate) {
           return true;
         }
         return state.loaderData[route.id] === undefined && (
@@ -3928,11 +4030,10 @@
         nextParams: nextRouteMatch.params
       }, submission, {
         actionResult,
-        defaultShouldRevalidate:
+        unstable_actionStatus: actionStatus,
+        defaultShouldRevalidate: shouldSkipRevalidation ? false :
         // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
-        isRevalidationRequired ||
-        // Clicked the same link, resubmitted a GET form
-        currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
+        isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
         // Search params affect all loaders
         currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
       }));
@@ -3994,7 +4095,8 @@
           nextParams: matches[matches.length - 1].params
         }, submission, {
           actionResult,
-          defaultShouldRevalidate: isRevalidationRequired
+          unstable_actionStatus: actionStatus,
+          defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
         }));
       }
       if (shouldRevalidate) {
@@ -4096,24 +4198,92 @@
       lazy: undefined
     }));
   }
-  async function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, v7_relativeSplatPath, opts) {
-    if (opts === void 0) {
-      opts = {};
-    }
-    let resultType;
+
+  // Default implementation of `dataStrategy` which fetches all loaders in parallel
+  function defaultDataStrategy(opts) {
+    return Promise.all(opts.matches.map(m => m.resolve()));
+  }
+  async function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext) {
+    let routeIdsToLoad = matchesToLoad.reduce((acc, m) => acc.add(m.route.id), new Set());
+    let loadedMatches = new Set();
+
+    // Send all matches here to allow for a middleware-type implementation.
+    // handler will be a no-op for unneeded routes and we filter those results
+    // back out below.
+    let results = await dataStrategyImpl({
+      matches: matches.map(match => {
+        let shouldLoad = routeIdsToLoad.has(match.route.id);
+        // `resolve` encapsulates the route.lazy, executing the
+        // loader/action, and mapping return values/thrown errors to a
+        // HandlerResult.  Users can pass a callback to take fine-grained control
+        // over the execution of the loader/action
+        let resolve = handlerOverride => {
+          loadedMatches.add(match.route.id);
+          return shouldLoad ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) : Promise.resolve({
+            type: ResultType.data,
+            result: undefined
+          });
+        };
+        return _extends({}, match, {
+          shouldLoad,
+          resolve
+        });
+      }),
+      request,
+      params: matches[0].params,
+      context: requestContext
+    });
+
+    // Throw if any loadRoute implementations not called since they are what
+    // ensures a route is fully loaded
+    matches.forEach(m => invariant(loadedMatches.has(m.route.id), "`match.resolve()` was not called for route id \"" + m.route.id + "\". " + "You must call `match.resolve()` on every match passed to " + "`dataStrategy` to ensure all routes are properly loaded."));
+
+    // Filter out any middleware-only matches for which we didn't need to run handlers
+    return results.filter((_, i) => routeIdsToLoad.has(matches[i].route.id));
+  }
+
+  // Default logic for calling a loader/action is the user has no specified a dataStrategy
+  async function callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, staticContext) {
     let result;
     let onReject;
     let runHandler = handler => {
       // Setup a promise we can race against so that abort signals short circuit
       let reject;
+      // This will never resolve so safe to type it as Promise<HandlerResult> to
+      // satisfy the function return value
       let abortPromise = new Promise((_, r) => reject = r);
       onReject = () => reject();
       request.signal.addEventListener("abort", onReject);
-      return Promise.race([handler({
-        request,
-        params: match.params,
-        context: opts.requestContext
-      }), abortPromise]);
+      let actualHandler = ctx => {
+        if (typeof handler !== "function") {
+          return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
+        }
+        return handler({
+          request,
+          params: match.params,
+          context: staticContext
+        }, ...(ctx !== undefined ? [ctx] : []));
+      };
+      let handlerPromise;
+      if (handlerOverride) {
+        handlerPromise = handlerOverride(ctx => actualHandler(ctx));
+      } else {
+        handlerPromise = (async () => {
+          try {
+            let val = await actualHandler();
+            return {
+              type: "data",
+              result: val
+            };
+          } catch (e) {
+            return {
+              type: "error",
+              result: e
+            };
+          }
+        })();
+      }
+      return Promise.race([handlerPromise, abortPromise]);
     };
     try {
       let handler = match.route[type];
@@ -4121,23 +4291,23 @@
         if (handler) {
           // Run statically defined handler in parallel with lazy()
           let handlerError;
-          let values = await Promise.all([
+          let [value] = await Promise.all([
           // If the handler throws, don't let it immediately bubble out,
           // since we need to let the lazy() execution finish so we know if this
           // route has a boundary that can handle the error
           runHandler(handler).catch(e => {
             handlerError = e;
           }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);
-          if (handlerError) {
+          if (handlerError !== undefined) {
             throw handlerError;
           }
-          result = values[0];
+          result = value;
         } else {
           // Load lazy route module, then run any returned handler
           await loadLazyRouteModule(match.route, mapRouteProperties, manifest);
           handler = match.route[type];
           if (handler) {
-            // Handler still run even if we got interrupted to maintain consistency
+            // Handler still runs even if we got interrupted to maintain consistency
             // with un-abortable behavior of handler execution on non-lazy or
             // previously-lazy-loaded routes
             result = await runHandler(handler);
@@ -4154,7 +4324,7 @@
             // hit the invariant below that errors on returning undefined.
             return {
               type: ResultType.data,
-              data: undefined
+              result: undefined
             };
           }
         }
@@ -4167,65 +4337,29 @@
       } else {
         result = await runHandler(handler);
       }
-      invariant(result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
+      invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
     } catch (e) {
-      resultType = ResultType.error;
-      result = e;
+      // We should already be catching and converting normal handler executions to
+      // HandlerResults and returning them, so anything that throws here is an
+      // unexpected error we still need to wrap
+      return {
+        type: ResultType.error,
+        result: e
+      };
     } finally {
       if (onReject) {
         request.signal.removeEventListener("abort", onReject);
       }
     }
+    return result;
+  }
+  async function convertHandlerResultToDataResult(handlerResult) {
+    let {
+      result,
+      type,
+      status
+    } = handlerResult;
     if (isResponse(result)) {
-      let status = result.status;
-
-      // Process redirects
-      if (redirectStatusCodes.has(status)) {
-        let location = result.headers.get("Location");
-        invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
-
-        // Support relative routing in internal redirects
-        if (!ABSOLUTE_URL_REGEX.test(location)) {
-          location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location, v7_relativeSplatPath);
-        } else if (!opts.isStaticRequest) {
-          // Strip off the protocol+origin for same-origin + same-basename absolute
-          // redirects. If this is a static request, we can let it go back to the
-          // browser as-is
-          let currentUrl = new URL(request.url);
-          let url = location.startsWith("//") ? new URL(currentUrl.protocol + location) : new URL(location);
-          let isSameBasename = stripBasename(url.pathname, basename) != null;
-          if (url.origin === currentUrl.origin && isSameBasename) {
-            location = url.pathname + url.search + url.hash;
-          }
-        }
-
-        // Don't process redirects in the router during static requests requests.
-        // Instead, throw the Response and let the server handle it with an HTTP
-        // redirect.  We also update the Location header in place in this flow so
-        // basename and relative routing is taken into account
-        if (opts.isStaticRequest) {
-          result.headers.set("Location", location);
-          throw result;
-        }
-        return {
-          type: ResultType.redirect,
-          status,
-          location,
-          revalidate: result.headers.get("X-Remix-Revalidate") !== null,
-          reloadDocument: result.headers.get("X-Remix-Reload-Document") !== null
-        };
-      }
-
-      // For SSR single-route requests, we want to hand Responses back directly
-      // without unwrapping.  We do this with the QueryRouteResponse wrapper
-      // interface so we can know whether it was returned or thrown
-      if (opts.isRouteRequest) {
-        let queryRouteResponse = {
-          type: resultType === ResultType.error ? ResultType.error : ResultType.data,
-          response: result
-        };
-        throw queryRouteResponse;
-      }
       let data;
       try {
         let contentType = result.headers.get("Content-Type");
@@ -4246,10 +4380,11 @@
           error: e
         };
       }
-      if (resultType === ResultType.error) {
+      if (type === ResultType.error) {
         return {
-          type: resultType,
-          error: new ErrorResponseImpl(status, result.statusText, data),
+          type: ResultType.error,
+          error: new ErrorResponseImpl(result.status, result.statusText, data),
+          statusCode: result.status,
           headers: result.headers
         };
       }
@@ -4260,10 +4395,11 @@
         headers: result.headers
       };
     }
-    if (resultType === ResultType.error) {
+    if (type === ResultType.error) {
       return {
-        type: resultType,
-        error: result
+        type: ResultType.error,
+        error: result,
+        statusCode: isRouteErrorResponse(result) ? result.status : status
       };
     }
     if (isDeferredData(result)) {
@@ -4277,10 +4413,35 @@
     }
     return {
       type: ResultType.data,
-      data: result
+      data: result,
+      statusCode: status
     };
   }
 
+  // Support relative routing in internal redirects
+  function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
+    let location = response.headers.get("Location");
+    invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
+    if (!ABSOLUTE_URL_REGEX.test(location)) {
+      let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
+      location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
+      response.headers.set("Location", location);
+    }
+    return response;
+  }
+  function normalizeRedirectLocation(location, currentUrl, basename) {
+    if (ABSOLUTE_URL_REGEX.test(location)) {
+      // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+      let normalizedLocation = location;
+      let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
+      let isSameBasename = stripBasename(url.pathname, basename) != null;
+      if (url.origin === currentUrl.origin && isSameBasename) {
+        return url.pathname + url.search + url.hash;
+      }
+    }
+    return location;
+  }
+
   // Utility method for creating the Request instances for loaders/actions during
   // client-side navigations and fetches.  During SSR we will always have a
   // Request instance from the static handler (query/queryRoute)
@@ -4331,35 +4492,39 @@
     }
     return formData;
   }
-  function processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {
+  function processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
     // Fill in loaderData/errors from our loaders
     let loaderData = {};
     let errors = null;
     let statusCode;
     let foundError = false;
     let loaderHeaders = {};
+    let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
 
     // Process loader results into state.loaderData/state.errors
     results.forEach((result, index) => {
       let id = matchesToLoad[index].route.id;
       invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
       if (isErrorResult(result)) {
-        // Look upwards from the matched route for the closest ancestor
-        // error boundary, defaulting to the root match
-        let boundaryMatch = findNearestBoundary(matches, id);
         let error = result.error;
         // If we have a pending action error, we report it at the highest-route
         // that throws a loader error, and then clear it out to indicate that
         // it was consumed
-        if (pendingError) {
-          error = Object.values(pendingError)[0];
+        if (pendingError !== undefined) {
+          error = pendingError;
           pendingError = undefined;
         }
         errors = errors || {};
-
-        // Prefer higher error values if lower errors bubble to the same boundary
-        if (errors[boundaryMatch.route.id] == null) {
-          errors[boundaryMatch.route.id] = error;
+        if (skipLoaderErrorBubbling) {
+          errors[id] = error;
+        } else {
+          // Look upwards from the matched route for the closest ancestor error
+          // boundary, defaulting to the root match.  Prefer higher error values
+          // if lower errors bubble to the same boundary
+          let boundaryMatch = findNearestBoundary(matches, id);
+          if (errors[boundaryMatch.route.id] == null) {
+            errors[boundaryMatch.route.id] = error;
+          }
         }
 
         // Clear our any prior loaderData for the throwing route
@@ -4378,17 +4543,24 @@
         if (isDeferredResult(result)) {
           activeDeferreds.set(id, result.deferredData);
           loaderData[id] = result.deferredData.data;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
+            statusCode = result.statusCode;
+          }
+          if (result.headers) {
+            loaderHeaders[id] = result.headers;
+          }
         } else {
           loaderData[id] = result.data;
-        }
-
-        // Error status codes always override success status codes, but if all
-        // loaders are successful we take the deepest status code.
-        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
-          statusCode = result.statusCode;
-        }
-        if (result.headers) {
-          loaderHeaders[id] = result.headers;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.statusCode && result.statusCode !== 200 && !foundError) {
+            statusCode = result.statusCode;
+          }
+          if (result.headers) {
+            loaderHeaders[id] = result.headers;
+          }
         }
       }
     });
@@ -4396,9 +4568,11 @@
     // If we didn't consume the pending action error (i.e., all loaders
     // resolved), then consume it here.  Also clear out any loaderData for the
     // throwing route
-    if (pendingError) {
-      errors = pendingError;
-      loaderData[Object.keys(pendingError)[0]] = undefined;
+    if (pendingError !== undefined && pendingActionResult) {
+      errors = {
+        [pendingActionResult[0]]: pendingError
+      };
+      loaderData[pendingActionResult[0]] = undefined;
     }
     return {
       loaderData,
@@ -4407,11 +4581,12 @@
       loaderHeaders
     };
   }
-  function processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {
+  function processLoaderData(state, matches, matchesToLoad, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
     let {
       loaderData,
       errors
-    } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds);
+    } = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
+    );
 
     // Process results from our revalidating fetchers
     for (let index = 0; index < revalidatingFetchers.length; index++) {
@@ -4473,6 +4648,19 @@
     }
     return mergedLoaderData;
   }
+  function getActionDataForCommit(pendingActionResult) {
+    if (!pendingActionResult) {
+      return {};
+    }
+    return isErrorResult(pendingActionResult[1]) ? {
+      // Clear out prior actionData on errors
+      actionData: {}
+    } : {
+      actionData: {
+        [pendingActionResult[0]]: pendingActionResult[1].data
+      }
+    };
+  }
 
   // Find the nearest error boundary, looking upwards from the leaf route (or the
   // route specified by routeId) for the closest ancestor error boundary,
@@ -4568,6 +4756,12 @@
     // /page#hash -> /page
     return false;
   }
+  function isHandlerResult(result) {
+    return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
+  }
+  function isRedirectHandlerResult(result) {
+    return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
+  }
   function isDeferredResult(result) {
     return result.type === ResultType.deferred;
   }
@@ -4592,9 +4786,6 @@
     let location = result.headers.get("Location");
     return status >= 300 && status <= 399 && location != null;
   }
-  function isQueryRouteResponse(obj) {
-    return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);
-  }
   function isValidMethod(method) {
     return validRequestMethods.has(method.toLowerCase());
   }