react-router 7.0.0-pre.0 → 7.0.0-pre.2

package/dist/umd/react-router.development.js

@@ -1,5 +1,5 @@
 /**
- * React Router v7.0.0-pre.0
+ * React Router v7.0.0-pre.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -310,7 +310,7 @@
         pathname = "/",
         search = "",
         hash = ""
-      } = parsePath(window.location.hash.substr(1));
+      } = parsePath(window.location.hash.substring(1));
 
       // Hash URL should always have a leading / just like window.location.pathname
       // does, so if an app ends up at a route like /#something then we add a
@@ -373,7 +373,7 @@
     }
   }
   function createKey$1() {
-    return Math.random().toString(36).substr(2, 8);
+    return Math.random().toString(36).substring(2, 10);
   }
 
   /**
@@ -435,13 +435,13 @@
     if (path) {
       let hashIndex = path.indexOf("#");
       if (hashIndex >= 0) {
-        parsedPath.hash = path.substr(hashIndex);
-        path = path.substr(0, hashIndex);
+        parsedPath.hash = path.substring(hashIndex);
+        path = path.substring(0, hashIndex);
       }
       let searchIndex = path.indexOf("?");
       if (searchIndex >= 0) {
-        parsedPath.search = path.substr(searchIndex);
-        path = path.substr(0, searchIndex);
+        parsedPath.search = path.substring(searchIndex);
+        path = path.substring(0, searchIndex);
       }
       if (path) {
         parsedPath.pathname = path;
@@ -1335,27 +1335,6 @@
    * @private
    */
   const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
-  /**
-   * This is a shortcut for creating `application/json` responses. Converts `data`
-   * to JSON and sets the `Content-Type` header.
-   *
-   * @category Utils
-   */
-  const json$1 = function json(data, init) {
-    if (init === void 0) {
-      init = {};
-    }
-    let responseInit = typeof init === "number" ? {
-      status: init
-    } : init;
-    let headers = new Headers(responseInit.headers);
-    if (!headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json; charset=utf-8");
-    }
-    return new Response(JSON.stringify(data), _extends({}, responseInit, {
-      headers
-    }));
-  };
   class DataWithResponseInit {
     constructor(data, init) {
       this.type = "DataWithResponseInit";
@@ -1375,6 +1354,10 @@
       status: init
     } : init);
   }
+
+  // This is now only used by the Await component and will eventually probably
+  // go away in favor of the format used by `React.use`
+
   /**
    * A redirect response. Sets the status code and the `Location` header.
    * Defaults to "302 Found".
@@ -1563,7 +1546,7 @@
   const validMutationMethods = new Set(validMutationMethodsArr);
   const validRequestMethodsArr = ["GET", ...validMutationMethodsArr];
   const validRequestMethods = new Set(validRequestMethodsArr);
-  const redirectStatusCodes$1 = new Set([301, 302, 303, 307, 308]);
+  const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
   const redirectPreserveMethodStatusCodes = new Set([307, 308]);
   const IDLE_NAVIGATION = {
     state: "idle",
@@ -1699,25 +1682,12 @@
       // were marked for explicit hydration
       let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
       let errors = init.hydrationData ? init.hydrationData.errors : null;
-      let isRouteInitialized = m => {
-        // No loader, nothing to initialize
-        if (!m.route.loader) {
-          return true;
-        }
-        // Explicitly opting-in to running on hydration
-        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;
-      };
-
       // If errors exist, don't consider routes below the boundary
       if (errors) {
         let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
-        initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);
+        initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
       } else {
-        initialized = initialMatches.every(isRouteInitialized);
+        initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
       }
     }
     let router;
@@ -1803,10 +1773,6 @@
     // we don't need to update UI state if they change
     let blockerFunctions = new Map();
 
-    // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so
-    // that we only kick them off once for a given combo
-    let pendingPatchRoutes = new Map();
-
     // Flag to ignore the next history update, so we can revert the URL change on
     // a POP navigation that was blocked by the user without touching router state
     let unblockBlockerHistoryUpdate = undefined;
@@ -2247,7 +2213,7 @@
       // Short circuit if it's only a hash change and not a revalidation or
       // mutation submission.
       //
-      // Ignore on initial page loads because since the initial load will always
+      // Ignore on initial page loads because since the initial hydration will always
       // be "same hash".  For example, on /page#hash and submit a <Form method="post">
       // which will default to a navigation to /page
       if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
@@ -2354,15 +2320,12 @@
             shortCircuited: true
           };
         } else if (discoverResult.type === "error") {
-          let {
-            boundaryId,
-            error
-          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
           return {
             matches: discoverResult.partialMatches,
             pendingActionResult: [boundaryId, {
               type: ResultType.error,
-              error
+              error: discoverResult.error
             }]
           };
         } else if (!discoverResult.matches) {
@@ -2487,15 +2450,12 @@
             shortCircuited: true
           };
         } else if (discoverResult.type === "error") {
-          let {
-            boundaryId,
-            error
-          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
           return {
             matches: discoverResult.partialMatches,
             loaderData: {},
             errors: {
-              [boundaryId]: error
+              [boundaryId]: discoverResult.error
             }
           };
         } else if (!discoverResult.matches) {
@@ -2618,17 +2578,9 @@
         errors
       } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults);
 
-      // With "partial hydration", preserve SSR errors for routes that don't re-run
+      // Preserve SSR errors during partial hydration
       if (initialHydration && state.errors) {
-        Object.entries(state.errors).filter(_ref2 => {
-          let [id] = _ref2;
-          return !matchesToLoad.some(m => m.route.id === id);
-        }).forEach(_ref3 => {
-          let [routeId, error] = _ref3;
-          errors = Object.assign(errors || {}, {
-            [routeId]: error
-          });
-        });
+        errors = _extends({}, state.errors, errors);
       }
       let updatedFetchers = markFetchRedirectsDone();
       let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
@@ -2747,10 +2699,7 @@
         if (discoverResult.type === "aborted") {
           return;
         } else if (discoverResult.type === "error") {
-          let {
-            error
-          } = handleDiscoverRouteError(path, discoverResult);
-          setFetcherError(key, routeId, error, {
+          setFetcherError(key, routeId, discoverResult.error, {
             flushSync
           });
           return;
@@ -2930,10 +2879,7 @@
         if (discoverResult.type === "aborted") {
           return;
         } else if (discoverResult.type === "error") {
-          let {
-            error
-          } = handleDiscoverRouteError(path, discoverResult);
-          setFetcherError(key, routeId, error, {
+          setFetcherError(key, routeId, discoverResult.error, {
             flushSync
           });
           return;
@@ -3119,7 +3065,7 @@
         return dataResults;
       }
       for (let [routeId, result] of Object.entries(results)) {
-        if (isRedirectDataStrategyResultResult(result)) {
+        if (isRedirectDataStrategyResult(result)) {
           let response = result.result;
           dataResults[routeId] = {
             type: ResultType.redirect,
@@ -3132,8 +3078,6 @@
       return dataResults;
     }
     async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
-      state.matches;
-
       // Kick off loaders and fetchers in parallel
       let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
       let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
@@ -3306,12 +3250,12 @@
         blockers
       });
     }
-    function shouldBlockNavigation(_ref4) {
+    function shouldBlockNavigation(_ref2) {
       let {
         currentLocation,
         nextLocation,
         historyAction
-      } = _ref4;
+      } = _ref2;
       if (blockerFunctions.size === 0) {
         return;
       }
@@ -3355,16 +3299,6 @@
         error
       };
     }
-    function handleDiscoverRouteError(pathname, discoverResult) {
-      return {
-        boundaryId: findNearestBoundary(discoverResult.partialMatches).route.id,
-        error: getInternalRouterError(400, {
-          type: "route-discovery",
-          pathname,
-          message: discoverResult.error != null && "message" in discoverResult.error ? discoverResult.error : String(discoverResult.error)
-        })
-      };
-    }
 
     // Opt in to capturing and reporting scroll positions during navigations,
     // used by the <ScrollRestoration> component
@@ -3441,12 +3375,26 @@
       };
     }
     async function discoverRoutes(matches, pathname, signal) {
+      if (!patchRoutesOnNavigationImpl) {
+        return {
+          type: "success",
+          matches
+        };
+      }
       let partialMatches = matches;
       while (true) {
         let isNonHMR = inFlightDataRoutes == null;
         let routesToUse = inFlightDataRoutes || dataRoutes;
+        let localManifest = manifest;
         try {
-          await loadLazyRouteChildren(patchRoutesOnNavigationImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);
+          await patchRoutesOnNavigationImpl({
+            path: pathname,
+            matches: partialMatches,
+            patch: (routeId, children) => {
+              if (signal.aborted) return;
+              patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
+            }
+          });
         } catch (e) {
           return {
             type: "error",
@@ -3460,7 +3408,7 @@
           // trigger a re-run of memoized `router.routes` dependencies.
           // HMR will already update the identity and reflow when it lands
           // `inFlightDataRoutes` in `completeNavigation`
-          if (isNonHMR) {
+          if (isNonHMR && !signal.aborted) {
             dataRoutes = [...dataRoutes];
           }
         }
@@ -3641,7 +3589,7 @@
         };
       }
       let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
-      if (isResponse$2(result)) {
+      if (isResponse(result)) {
         return result;
       }
 
@@ -3714,7 +3662,7 @@
         });
       }
       let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
-      if (isResponse$2(result)) {
+      if (isResponse(result)) {
         return result;
       }
       let error = result.errors ? Object.values(result.errors)[0] : undefined;
@@ -3743,7 +3691,7 @@
           return result;
         }
         let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
-        return isResponse$2(result) ? result : _extends({}, result, {
+        return isResponse(result) ? result : _extends({}, result, {
           actionData: null,
           actionHeaders: {}
         });
@@ -3751,7 +3699,7 @@
         // If the user threw/returned a Response in callLoaderOrAction for a
         // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
         // and then return or throw the raw Response here accordingly
-        if (isDataStrategyResult(e) && isResponse$2(e.result)) {
+        if (isDataStrategyResult(e) && isResponse(e.result)) {
           if (e.type === ResultType.error) {
             throw e.result;
           }
@@ -3759,7 +3707,7 @@
         }
         // Redirects are always returned since they don't propagate to catch
         // boundaries
-        if (isRedirectResponse$1(e)) {
+        if (isRedirectResponse(e)) {
           return e;
         }
         throw e;
@@ -3913,12 +3861,12 @@
           return;
         }
         let result = results[match.route.id];
-        if (isRedirectDataStrategyResultResult(result)) {
+        if (isRedirectDataStrategyResult(result)) {
           let response = result.result;
           // Throw redirects and let the server handle them with an HTTP redirect
           throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename);
         }
-        if (isResponse$2(result.result) && isRouteRequest) {
+        if (isResponse(result.result) && isRouteRequest) {
           // For SSR single-route requests, we want to hand Responses back
           // directly without unwrapping
           throw result;
@@ -4058,8 +4006,8 @@
         }
         let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
         // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
-        Array.from(opts.body.entries()).reduce((acc, _ref5) => {
-          let [name, value] = _ref5;
+        Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+          let [name, value] = _ref3;
           return "" + acc + name + "=" + value + "\n";
         }, "") : String(opts.body);
         return {
@@ -4149,26 +4097,37 @@
     };
   }
 
-  // Filter out all routes below any caught error as they aren't going to
+  // Filter out all routes at/below any caught error as they aren't going to
   // render so we don't need to load them
-  function getLoaderMatchesUntilBoundary(matches, boundaryId) {
-    let boundaryMatches = matches;
-    if (boundaryId) {
-      let index = matches.findIndex(m => m.route.id === boundaryId);
-      if (index >= 0) {
-        boundaryMatches = matches.slice(0, index);
-      }
+  function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
+    if (includeBoundary === void 0) {
+      includeBoundary = false;
     }
-    return boundaryMatches;
+    let index = matches.findIndex(m => m.route.id === boundaryId);
+    if (index >= 0) {
+      return matches.slice(0, includeBoundary ? index + 1 : index);
+    }
+    return matches;
   }
-  function getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+  function getMatchesToLoad(history, state, matches, submission, location, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, 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 = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;
-    let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;
+    let boundaryMatches = matches;
+    if (initialHydration && state.errors) {
+      // On initial hydration, only consider matches up to _and including_ the boundary.
+      // This is inclusive to handle cases where a server loader ran successfully,
+      // a child server loader bubbled up to this route, but this route has
+      // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+      // we have a complete version of `loaderData`
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
+    } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+      // If an action threw an error, we call loaders up to, but not including the
+      // boundary
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
+    }
 
     // Don't revalidate loaders by default after action 4xx/5xx responses
     // when the flag is enabled.  They can still opt-into revalidation via
@@ -4186,13 +4145,8 @@
       if (route.loader == null) {
         return false;
       }
-      if (isInitialLoad) {
-        if (typeof route.loader !== "function" || route.loader.hydrate) {
-          return true;
-        }
-        return !state.loaderData.hasOwnProperty(route.id) && (
-        // Don't re-run if the loader ran and threw an error
-        !state.errors || state.errors[route.id] === undefined);
+      if (initialHydration) {
+        return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
       }
 
       // Always call the loader on new route instances
@@ -4226,10 +4180,11 @@
     let revalidatingFetchers = [];
     fetchLoadMatches.forEach((f, key) => {
       // Don't revalidate:
-      //  - on initial load (shouldn't be any fetchers then anyway)
-      //  - if fetcher no longer matches the URL
-      //  - if fetcher was unmounted
-      if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key)) {
+      //  - on initial hydration (shouldn't be any fetchers then anyway)
+      //  - if fetcher won't be present in the subsequent render
+      //    - no longer matches the URL (v7_fetcherPersist=false)
+      //    - was unmounted but persisted due to v7_fetcherPersist=true
+      if (initialHydration || !matches.some(m => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key)) {
         return;
       }
       let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
@@ -4295,6 +4250,32 @@
     });
     return [navigationMatches, revalidatingFetchers];
   }
+  function shouldLoadRouteOnHydration(route, loaderData, errors) {
+    // We dunno if we have a loader - gotta find out!
+    if (route.lazy) {
+      return true;
+    }
+
+    // No loader, nothing to initialize
+    if (!route.loader) {
+      return false;
+    }
+    let hasData = loaderData != null && loaderData[route.id] !== undefined;
+    let hasError = errors != null && errors[route.id] !== undefined;
+
+    // Don't run if we error'd during SSR
+    if (!hasData && hasError) {
+      return false;
+    }
+
+    // Explicitly opting-in to running on hydration
+    if (typeof route.loader === "function" && route.loader.hydrate === true) {
+      return true;
+    }
+
+    // Otherwise, run if we're not yet initialized with anything
+    return !hasData && !hasError;
+  }
   function isNewLoader(currentLoaderData, currentMatch, match) {
     let isNew =
     // [a] -> [a, b]
@@ -4328,34 +4309,6 @@
     }
     return arg.defaultShouldRevalidate;
   }
-
-  /**
-   * Idempotent utility to execute patchRoutesOnNavigation() to lazily load route
-   * definitions and update the routes/routeManifest
-   */
-  async function loadLazyRouteChildren(patchRoutesOnNavigationImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {
-    let key = [path, ...matches.map(m => m.route.id)].join("-");
-    try {
-      let pending = pendingRouteChildren.get(key);
-      if (!pending) {
-        pending = patchRoutesOnNavigationImpl({
-          path,
-          matches,
-          patch: (routeId, children) => {
-            if (!signal.aborted) {
-              patchRoutesImpl(routeId, children, routes, manifest, mapRouteProperties);
-            }
-          }
-        });
-        pendingRouteChildren.set(key, pending);
-      }
-      if (pending && isPromise(pending)) {
-        await pending;
-      }
-    } finally {
-      pendingRouteChildren.delete(key);
-    }
-  }
   function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
     var _childrenToPatch;
     let childrenToPatch;
@@ -4456,10 +4409,10 @@
   }
 
   // Default implementation of `dataStrategy` which fetches all loaders in parallel
-  async function defaultDataStrategy(_ref6) {
+  async function defaultDataStrategy(_ref4) {
     let {
       matches
-    } = _ref6;
+    } = _ref4;
     let matchesToLoad = matches.filter(m => m.shouldLoad);
     let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
     return results.reduce((acc, result, i) => Object.assign(acc, {
@@ -4624,7 +4577,7 @@
       result,
       type
     } = dataStrategyResult;
-    if (isResponse$2(result)) {
+    if (isResponse(result)) {
       let data;
       try {
         let contentType = result.headers.get("Content-Type");
@@ -4902,11 +4855,11 @@
   }
   function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
     // Start with all new entries that are not being reset
-    let mergedLoaderData = Object.entries(newLoaderData).filter(_ref7 => {
-      let [, v] = _ref7;
+    let mergedLoaderData = Object.entries(newLoaderData).filter(_ref5 => {
+      let [, v] = _ref5;
       return v !== ResetLoaderDataSymbol;
-    }).reduce((merged, _ref8) => {
-      let [k, v] = _ref8;
+    }).reduce((merged, _ref6) => {
+      let [k, v] = _ref6;
       merged[k] = v;
       return merged;
     }, {});
@@ -4973,9 +4926,7 @@
     let errorMessage = "Unknown @remix-run/router error";
     if (status === 400) {
       statusText = "Bad Request";
-      if (type === "route-discovery") {
-        errorMessage = "Unable to match URL \"" + pathname + "\" - the `patchRoutesOnNavigation()` " + ("function threw the following error:\n" + message);
-      } else if (method && pathname && routeId) {
+      if (method && pathname && routeId) {
         errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
       } else if (type === "invalid-body") {
         errorMessage = "Unable to encode submission body";
@@ -5035,14 +4986,11 @@
     // /page#hash -> /page
     return false;
   }
-  function isPromise(val) {
-    return typeof val === "object" && val != null && "then" in val;
-  }
   function isDataStrategyResult(result) {
     return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
   }
-  function isRedirectDataStrategyResultResult(result) {
-    return isResponse$2(result.result) && redirectStatusCodes$1.has(result.result.status);
+  function isRedirectDataStrategyResult(result) {
+    return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
   }
   function isErrorResult(result) {
     return result.type === ResultType.error;
@@ -5053,16 +5001,14 @@
   function isDataWithResponseInit(value) {
     return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
   }
-  function isResponse$2(value) {
+  function isResponse(value) {
     return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
   }
-  function isRedirectResponse$1(result) {
-    if (!isResponse$2(result)) {
-      return false;
-    }
-    let status = result.status;
-    let location = result.headers.get("Location");
-    return status >= 300 && status <= 399 && location != null;
+  function isRedirectStatusCode(statusCode) {
+    return redirectStatusCodes.has(statusCode);
+  }
+  function isRedirectResponse(result) {
+    return isResponse(result) && isRedirectStatusCode(result.status) && result.headers.has("Location");
   }
   function isValidMethod(method) {
     return validRequestMethods.has(method.toUpperCase());
@@ -6012,7 +5958,7 @@
     return DataRouterStateHook;
   }(DataRouterStateHook$1 || {});
   function getDataRouterConsoleError$1(hookName) {
-    return hookName + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+    return hookName + " must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.";
   }
   function useDataRouterContext$2(hookName) {
     let ctx = React__namespace.useContext(DataRouterContext);
@@ -6505,8 +6451,8 @@
     let setState = React__namespace.useCallback((newState, _ref2) => {
       let {
         deletedFetchers,
-        flushSync: flushSync,
-        viewTransitionOpts: viewTransitionOpts
+        flushSync,
+        viewTransitionOpts
       } = _ref2;
       deletedFetchers.forEach(key => fetcherData.current.delete(key));
       newState.fetchers.forEach((fetcher, key) => {
@@ -7408,7 +7354,56 @@
    * @see https://remix.run/route/meta
    */
 
-  // Loose copy from @react-router/server-runtime to avoid circular imports
+  /**
+   * A function that returns an array of data objects to use for rendering
+   * metadata HTML tags in a route. These tags are not rendered on descendant
+   * routes in the route hierarchy. In other words, they will only be rendered on
+   * the route in which they are exported.
+   *
+   * @param Loader - The type of the current route's loader function
+   * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+   * function type
+   *
+   * Note that parent route filepaths are relative to the `app/` directory.
+   *
+   * For example, if this meta function is for `/sales/customers/$customerId`:
+   *
+   * ```ts
+   * // app/root.tsx
+   * const loader = () => ({ hello: "world" })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales.tsx
+   * const loader = () => ({ salesCount: 1074 })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales/customers.tsx
+   * const loader = () => ({ customerCount: 74 })
+   * export type Loader = typeof loader
+   *
+   * // app/routes/sales/customers/$customersId.tsx
+   * import type { Loader as RootLoader } from "../../../root"
+   * import type { Loader as SalesLoader } from "../../sales"
+   * import type { Loader as CustomersLoader } from "../../sales/customers"
+   *
+   * const loader = () => ({ name: "Customer name" })
+   *
+   * const meta: MetaFunction<typeof loader, {
+   *  "root": RootLoader,
+   *  "routes/sales": SalesLoader,
+   *  "routes/sales/customers": CustomersLoader,
+   * }> = ({ data, matches }) => {
+   *   const { name } = data
+   *   //      ^? string
+   *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+   *   //      ^? number
+   *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+   *   //      ^? number
+   *   const { hello } = matches.find((match) => match.id === "root").data
+   *   //      ^? "world"
+   * }
+   * ```
+   */
 
   /**
    * A React component that is rendered for a route.
@@ -7465,7 +7460,7 @@
     let descriptors = matches.map(match => {
       let module = routeModules[match.route.id];
       let route = manifest.routes[match.route.id];
-      return [route.css ? route.css.map(href => ({
+      return [route && route.css ? route.css.map(href => ({
         rel: "stylesheet",
         href
       })) : [], (module == null || module.links == null ? void 0 : module.links()) || []];
@@ -7544,8 +7539,12 @@
   }
   async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
     let links = await Promise.all(matches.map(async match => {
-      let mod = await loadRouteModule(manifest.routes[match.route.id], routeModules);
-      return mod.links ? mod.links() : [];
+      let route = manifest.routes[match.route.id];
+      if (route) {
+        let mod = await loadRouteModule(route, routeModules);
+        return mod.links ? mod.links() : [];
+      }
+      return [];
     }));
     return dedupeLinkDescriptors(links.flat(1).filter(isHtmlLinkDescriptor).filter(link => link.rel === "stylesheet" || link.rel === "preload").map(link => link.rel === "stylesheet" ? _extends({}, link, {
       rel: "prefetch",
@@ -7557,7 +7556,6 @@
 
   // This is ridiculously identical to transition.ts `filterMatchesToLoad`
   function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, location, mode) {
-    let path = parsePathPatch(page);
     let isNew = (match, index) => {
       if (!currentMatches[index]) return true;
       return match.route.id !== currentMatches[index].route.id;
@@ -7572,43 +7570,45 @@
         ((_currentMatches$index = currentMatches[index].route.path) == null ? void 0 : _currentMatches$index.endsWith("*")) && currentMatches[index].params["*"] !== match.params["*"]
       );
     };
+    if (mode === "assets") {
+      return nextMatches.filter((match, index) => isNew(match, index) || matchPathChanged(match, index));
+    }
 
-    // NOTE: keep this mostly up-to-date w/ the transition data diff, but this
+    // NOTE: keep this mostly up-to-date w/ the router data diff, but this
     // version doesn't care about submissions
-    let newMatches = mode === "data" && location.search !== path.search ?
-    // this is really similar to stuff in transition.ts, maybe somebody smarter
+    // TODO: this is really similar to stuff in router.ts, maybe somebody smarter
     // than me (or in less of a hurry) can share some of it. You're the best.
-    nextMatches.filter((match, index) => {
-      let manifestRoute = manifest.routes[match.route.id];
-      if (!manifestRoute.hasLoader) {
-        return false;
-      }
-      if (isNew(match, index) || matchPathChanged(match, index)) {
-        return true;
-      }
-      if (match.route.shouldRevalidate) {
-        var _currentMatches$;
-        let routeChoice = match.route.shouldRevalidate({
-          currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
-          currentParams: ((_currentMatches$ = currentMatches[0]) == null ? void 0 : _currentMatches$.params) || {},
-          nextUrl: new URL(page, window.origin),
-          nextParams: match.params,
-          defaultShouldRevalidate: true
-        });
-        if (typeof routeChoice === "boolean") {
-          return routeChoice;
+    if (mode === "data") {
+      return nextMatches.filter((match, index) => {
+        let manifestRoute = manifest.routes[match.route.id];
+        if (!manifestRoute || !manifestRoute.hasLoader) {
+          return false;
         }
-      }
-      return true;
-    }) : nextMatches.filter((match, index) => {
-      let manifestRoute = manifest.routes[match.route.id];
-      return (mode === "assets" || manifestRoute.hasLoader) && (isNew(match, index) || matchPathChanged(match, index));
-    });
-    return newMatches;
+        if (isNew(match, index) || matchPathChanged(match, index)) {
+          return true;
+        }
+        if (match.route.shouldRevalidate) {
+          var _currentMatches$;
+          let routeChoice = match.route.shouldRevalidate({
+            currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
+            currentParams: ((_currentMatches$ = currentMatches[0]) == null ? void 0 : _currentMatches$.params) || {},
+            nextUrl: new URL(page, window.origin),
+            nextParams: match.params,
+            defaultShouldRevalidate: true
+          });
+          if (typeof routeChoice === "boolean") {
+            return routeChoice;
+          }
+        }
+        return true;
+      });
+    }
+    return [];
   }
   function getModuleLinkHrefs(matches, manifestPatch) {
     return dedupeHrefs(matches.map(match => {
       let route = manifestPatch.routes[match.route.id];
+      if (!route) return [];
       let hrefs = [route.module];
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
@@ -7623,6 +7623,7 @@
   function getCurrentPageModulePreloadHrefs(matches, manifest) {
     return dedupeHrefs(matches.map(match => {
       let route = manifest.routes[match.route.id];
+      if (!route) return [];
       let hrefs = [route.module];
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
@@ -7661,13 +7662,6 @@
     }, []);
   }
 
-  // https://github.com/remix-run/history/issues/897
-  function parsePathPatch(href) {
-    let path = parsePath(href);
-    if (path.search === undefined) path.search = "";
-    return path;
-  }
-
   // Detect if this browser supports <link rel="preload"> (or has it enabled).
   // Originally added to handle the firefox `network.preload` config:
   //   https://bugzilla.mozilla.org/show_bug.cgi?id=1847811
@@ -7705,13 +7699,6 @@
     };
   }
 
-  /**
-   * Data for a route that was returned from a `loader()`.
-   */
-
-  function isResponse$1(value) {
-    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-  }
   async function createRequestInit(request) {
     let init = {
       signal: request.signal
@@ -7850,7 +7837,7 @@
       });
       return result;
     });
-    if (isResponse$1(result.result) || isRouteErrorResponse(result.result)) {
+    if (isResponse(result.result) || isRouteErrorResponse(result.result)) {
       return {
         [actionMatch.route.id]: result
       };
@@ -7895,6 +7882,7 @@
     let results = {};
     let resolvePromise = Promise.all(matches.map(async (m, i) => m.resolve(async handler => {
       routeDfds[i].resolve();
+      let manifestRoute = manifest.routes[m.route.id];
       if (!m.shouldLoad) {
         var _routeModules$m$route;
         // If we're not yet initialized and this is the initial load, respect
@@ -7907,7 +7895,7 @@
         // Otherwise, we opt out if we currently have data, a `loader`, and a
         // `shouldRevalidate` function.  This implies that the user opted out
         // via `shouldRevalidate`
-        if (m.route.id in router.state.loaderData && manifest.routes[m.route.id].hasLoader && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
+        if (m.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
           foundOptOutRoute = true;
           return;
         }
@@ -7915,8 +7903,8 @@
 
       // When a route has a client loader, it opts out of the singular call and
       // calls it's server loader via `serverLoader()` using a `?_routes` param
-      if (manifest.routes[m.route.id].hasClientLoader) {
-        if (manifest.routes[m.route.id].hasLoader) {
+      if (manifestRoute && manifestRoute.hasClientLoader) {
+        if (manifestRoute.hasLoader) {
           foundOptOutRoute = true;
         }
         try {
@@ -7935,7 +7923,7 @@
       }
 
       // Load this route on the server if it has a loader
-      if (manifest.routes[m.route.id].hasLoader) {
+      if (manifestRoute && manifestRoute.hasLoader) {
         routesParams.add(m.route.id);
       }
 
@@ -8327,20 +8315,18 @@
     }));
   }
 
-  // NOTE: make sure to change the Route in server-runtime if you change this
-
-  // NOTE: make sure to change the EntryRoute in server-runtime if you change this
-
   // Create a map of routes by parentId to use recursively instead of
   // repeatedly filtering the manifest.
   function groupRoutesByParentId$1(manifest) {
     let routes = {};
     Object.values(manifest).forEach(route => {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
+      if (route) {
+        let parentId = route.parentId || "";
+        if (!routes[parentId]) {
+          routes[parentId] = [];
+        }
+        routes[parentId].push(route);
       }
-      routes[parentId].push(route);
     });
     return routes;
   }
@@ -8480,10 +8466,12 @@
         // Use critical path modules directly
         Object.assign(dataRoute, _extends({}, dataRoute, getRouteComponents(route, routeModule, isSpaMode), {
           handle: routeModule.handle,
-          shouldRevalidate: needsRevalidation ? wrapShouldRevalidateForHdr(route.id, routeModule.shouldRevalidate, needsRevalidation) : routeModule.shouldRevalidate
+          shouldRevalidate: getShouldRevalidateFunction(routeModule, route.id, needsRevalidation)
         }));
-        let initialData = initialState == null || (_initialState$loaderD = initialState.loaderData) == null ? void 0 : _initialState$loaderD[route.id];
-        let initialError = initialState == null || (_initialState$errors = initialState.errors) == null ? void 0 : _initialState$errors[route.id];
+        let hasInitialData = initialState && initialState.loaderData && route.id in initialState.loaderData;
+        let initialData = hasInitialData ? initialState == null || (_initialState$loaderD = initialState.loaderData) == null ? void 0 : _initialState$loaderD[route.id] : undefined;
+        let hasInitialError = initialState && initialState.errors && route.id in initialState.errors;
+        let initialError = hasInitialError ? initialState == null || (_initialState$errors = initialState.errors) == null ? void 0 : _initialState$errors[route.id] : undefined;
         let isHydrationRequest = needsRevalidation == null && (((_routeModule$clientLo = routeModule.clientLoader) == null ? void 0 : _routeModule$clientLo.hydrate) === true || !route.hasLoader);
         dataRoute.loader = async (_ref, singleFetch) => {
           let {
@@ -8506,10 +8494,12 @@
 
                   // On the first call, resolve with the server result
                   if (isHydrationRequest) {
-                    if (initialError !== undefined) {
+                    if (hasInitialData) {
+                      return initialData;
+                    }
+                    if (hasInitialError) {
                       throw initialError;
                     }
-                    return initialData;
                   }
 
                   // Call the server loader for client-side navigations
@@ -8595,16 +8585,13 @@
               }
             }));
           }
-          if (needsRevalidation) {
-            lazyRoute.shouldRevalidate = wrapShouldRevalidateForHdr(route.id, mod.shouldRevalidate, needsRevalidation);
-          }
           return _extends({}, lazyRoute.loader ? {
             loader: lazyRoute.loader
           } : {}, lazyRoute.action ? {
             action: lazyRoute.action
           } : {}, {
             hasErrorBoundary: lazyRoute.hasErrorBoundary,
-            shouldRevalidate: lazyRoute.shouldRevalidate,
+            shouldRevalidate: getShouldRevalidateFunction(lazyRoute, route.id, needsRevalidation),
             handle: lazyRoute.handle,
             // No need to wrap these in layout since the root route is never
             // loaded via route.lazy()
@@ -8618,6 +8605,22 @@
       return dataRoute;
     });
   }
+  function getShouldRevalidateFunction(route, routeId, needsRevalidation) {
+    // During HDR we force revalidation for updated routes
+    if (needsRevalidation) {
+      return wrapShouldRevalidateForHdr(routeId, route.shouldRevalidate, needsRevalidation);
+    }
+
+    // Single fetch revalidates by default, so override the RR default value which
+    // matches the multi-fetch behavior with `true`
+    if (route.shouldRevalidate) {
+      let fn = route.shouldRevalidate;
+      return opts => fn(_extends({}, opts, {
+        defaultShouldRevalidate: true
+      }));
+    }
+    return route.shouldRevalidate;
+  }
 
   // When an HMR / HDR update happens we opt out of all user-defined
   // revalidation logic and force a revalidation on the first call
@@ -8819,9 +8822,12 @@
 
     // Patch routes we don't know about yet into the manifest
     let knownRoutes = new Set(Object.keys(manifest.routes));
-    let patches = Object.values(serverPatches).reduce((acc, route) => !knownRoutes.has(route.id) ? Object.assign(acc, {
-      [route.id]: route
-    }) : acc, {});
+    let patches = Object.values(serverPatches).reduce((acc, route) => {
+      if (route && !knownRoutes.has(route.id)) {
+        acc[route.id] = route;
+      }
+      return acc;
+    }, {});
     Object.assign(manifest.routes, patches);
 
     // Track discovered paths so we don't have to fetch them again
@@ -8831,7 +8837,7 @@
     // in their new children
     let parentIds = new Set();
     Object.values(patches).forEach(patch => {
-      if (!patch.parentId || !patches[patch.parentId]) {
+      if (patch && (!patch.parentId || !patches[patch.parentId])) {
         parentIds.add(patch.parentId);
       }
     });
@@ -8861,9 +8867,6 @@
   const _excluded$2 = ["page"],
     _excluded2$1 = ["page", "matches"],
     _excluded3$1 = ["tagName"];
-
-  // TODO: Temporary shim until we figure out the way to handle typings in v7
-
   function useDataRouterContext$1() {
     let context = React__namespace.useContext(DataRouterContext);
     !context ? invariant$1(false, "You must render this element inside a <DataRouterContext.Provider> element")  : void 0;
@@ -9126,12 +9129,13 @@
       let foundOptOutRoute = false;
       nextMatches.forEach(m => {
         var _routeModules$m$route;
-        if (!manifest.routes[m.route.id].hasLoader) {
+        let manifestRoute = manifest.routes[m.route.id];
+        if (!manifestRoute || !manifestRoute.hasLoader) {
           return;
         }
         if (!newMatchesForData.some(m2 => m2.route.id === m.route.id) && m.route.id in loaderData && (_routeModules$m$route = routeModules[m.route.id]) != null && _routeModules$m$route.shouldRevalidate) {
           foundOptOutRoute = true;
-        } else if (manifest.routes[m.route.id].hasClientLoader) {
+        } else if (manifestRoute.hasClientLoader) {
           foundOptOutRoute = true;
         } else {
           routesParams.add(m.route.id);
@@ -9402,7 +9406,7 @@
     }, []);
     let routePreloads = matches.map(match => {
       let route = manifest.routes[match.route.id];
-      return (route.imports || []).concat([route.module]);
+      return route ? (route.imports || []).concat([route.module]) : [];
     }).flat(1);
     let preloads = isHydrated ? [] : manifest.entry.imports.concat(routePreloads);
     return isHydrated ? null : /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, !enableFogOfWar ? /*#__PURE__*/React__namespace.createElement("link", {
@@ -9442,7 +9446,6 @@
     _excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "viewTransition", "children"],
     _excluded3 = ["discover", "fetcherKey", "navigate", "reloadDocument", "replace", "state", "method", "action", "onSubmit", "relative", "preventScrollReset", "viewTransition"],
     _excluded4 = ["getKey", "storageKey"];
-
   ////////////////////////////////////////////////////////////////////////////////
   //#region Global Stuff
   ////////////////////////////////////////////////////////////////////////////////
@@ -10123,7 +10126,7 @@
     return DataRouterStateHook;
   }(DataRouterStateHook || {}); // Internal hooks
   function getDataRouterConsoleError(hookName) {
-    return hookName + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+    return hookName + " must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.";
   }
   function useDataRouterContext(hookName) {
     let ctx = React__namespace.useContext(DataRouterContext);
@@ -11120,7 +11123,7 @@
       // route opted into clientLoader hydration and either:
       // * gave us a HydrateFallback
       // * or doesn't have a server loader and we have no data to render
-      if (route && shouldHydrateRouteLoader(manifestRoute, route, context.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
+      if (route && manifestRoute && shouldHydrateRouteLoader(manifestRoute, route, context.isSpaMode) && (route.HydrateFallback || !manifestRoute.hasLoader)) {
         delete context.staticHandlerContext.loaderData[routeId];
       }
     }
@@ -11337,7 +11340,17 @@
       async parse(cookieHeader, parseOptions) {
         if (!cookieHeader) return null;
         let cookies = cookie.parse(cookieHeader, _extends({}, options, parseOptions));
-        return name in cookies ? cookies[name] === "" ? "" : await decodeCookieValue(cookies[name], secrets) : null;
+        if (name in cookies) {
+          let value = cookies[name];
+          if (typeof value === "string" && value !== "") {
+            let decoded = await decodeCookieValue(value, secrets);
+            return decoded;
+          } else {
+            return "";
+          }
+        } else {
+          return null;
+        }
       },
       async serialize(value, serializeOptions) {
         return cookie.serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), _extends({}, options, serializeOptions));
@@ -11444,7 +11457,10 @@
 
   function createEntryRouteModules(manifest) {
     return Object.keys(manifest).reduce((memo, routeId) => {
-      memo[routeId] = manifest[routeId].module;
+      let route = manifest[routeId];
+      if (route) {
+        memo[routeId] = route.module;
+      }
       return memo;
     }, {});
   }
@@ -11568,32 +11584,6 @@
     }));
   }
 
-  // must be a type since this is a subtype of response
-  // interfaces must conform to the types they extend
-
-  /**
-   * This is a shortcut for creating `application/json` responses. Converts `data`
-   * to JSON and sets the `Content-Type` header.
-   *
-   * @see https://remix.run/utils/json
-   */
-  const json = function json(data, init) {
-    if (init === void 0) {
-      init = {};
-    }
-    return json$1(data, init);
-  };
-  function isResponse(value) {
-    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-  }
-  const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
-  function isRedirectStatusCode(statusCode) {
-    return redirectStatusCodes.has(statusCode);
-  }
-  function isRedirectResponse(response) {
-    return isRedirectStatusCode(response.status);
-  }
-
   /**
    * An object of unknown type for route loaders and actions provided by the
    * server's `getLoadContext()` function.  This is defined as an empty interface
@@ -11601,10 +11591,6 @@
    * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
    */
 
-  /**
-   * Data for a route that was returned from a `loader()`.
-   */
-
   // Need to use RR's version here to permit the optional context even
   // though we know it'll always be provided in remix
   async function callRouteHandler(handler, args) {
@@ -11665,18 +11651,23 @@
     return new Request(url.href, init);
   }
 
-  // NOTE: make sure to change the Route in remix-react/react-router-dev if you change this
-
-  // NOTE: make sure to change the EntryRoute in react-router/react-router-dev if you change this
+  function invariant(value, message) {
+    if (value === false || value === null || typeof value === "undefined") {
+      console.error("The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose");
+      throw new Error(message);
+    }
+  }
 
   function groupRoutesByParentId(manifest) {
     let routes = {};
     Object.values(manifest).forEach(route => {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
+      if (route) {
+        let parentId = route.parentId || "";
+        if (!routes[parentId]) {
+          routes[parentId] = [];
+        }
+        routes[parentId].push(route);
       }
-      routes[parentId].push(route);
     });
     return routes;
   }
@@ -11712,7 +11703,29 @@
         path: route.path,
         // 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 ? args => callRouteHandler(route.module.loader, args) : undefined,
+        loader: route.module.loader ? async args => {
+          // If we're prerendering, use the data passed in from prerendering
+          // the .data route so we dom't call loaders twice
+          if (args.request.headers.has("X-React-Router-Prerender-Data")) {
+            let encoded = args.request.headers.get("X-React-Router-Prerender-Data");
+            !encoded ? invariant(false, "Missing prerendered data for route")  : void 0;
+            let uint8array = new TextEncoder().encode(encoded);
+            let stream = new ReadableStream({
+              start(controller) {
+                controller.enqueue(uint8array);
+                controller.close();
+              }
+            });
+            let decoded = await decodeViaTurboStream(stream, global);
+            let data = decoded.value;
+            !(data && route.id in data) ? invariant(false, "Unable to decode prerendered data")  : void 0;
+            let result = data[route.id];
+            !("data" in result) ? invariant(false, "Unable to process prerendered data")  : void 0;
+            return result.data;
+          }
+          let val = await callRouteHandler(route.module.loader, args);
+          return val;
+        } : undefined,
         action: route.module.action ? args => callRouteHandler(route.module.action, args) : undefined,
         handle: route.module.handle
       };
@@ -11787,13 +11800,15 @@
       let {
         id
       } = match.route;
-      let routeModule = build.routes[id].module;
+      let route = build.routes[id];
+      !route ? invariant(false, "Route with id \"" + id + "\" not found in build")  : void 0;
+      let routeModule = route.module;
       let loaderHeaders = context.loaderHeaders[id] || new Headers();
       let actionHeaders = context.actionHeaders[id] || new Headers();
 
       // Only expose errorHeaders to the leaf headers() function to
       // avoid duplication via parentHeaders
-      let includeErrorHeaders = errorHeaders != undefined && idx === matches.length - 1;
+      let includeErrorHeaders = errorHeaders != null && idx === matches.length - 1;
       // Only prepend cookies from errorHeaders at the leaf renderable route
       // when it's not the same as loaderHeaders/actionHeaders to avoid
       // duplicate cookies
@@ -12092,13 +12107,6 @@
     });
   }
 
-  function invariant(value, message) {
-    if (value === false || value === null || typeof value === "undefined") {
-      console.error("The following error is a bug in Remix; please open an issue! https://github.com/remix-run/remix/issues/new");
-      throw new Error(message);
-    }
-  }
-
   function derive(build, mode) {
     let routes = createRoutes(build.routes);
     let dataRoutes = createStaticHandlerDataRoutes(build.routes, build.future);
@@ -12232,15 +12240,18 @@
         if (matches) {
           for (let match of matches) {
             let routeId = match.route.id;
-            patches[routeId] = build.assets.routes[routeId];
+            let route = build.assets.routes[routeId];
+            if (route) {
+              patches[routeId] = route;
+            }
           }
         }
       }
-      return json(patches, {
+      return Response.json(patches, {
         headers: {
           "Cache-Control": "public, max-age=31536000, immutable"
         }
-      }); // Override the TypedResponse stuff from json()
+      });
     }
     return new Response("Invalid Request", {
       status: 400
@@ -12419,7 +12430,7 @@
     }
   }
   function errorResponseToJson(errorResponse, serverMode) {
-    return json$1(serializeError(
+    return Response.json(serializeError(
     // @ts-expect-error This is "private" from users but intended for internal use
     errorResponse.error || new Error("Unexpected Server Error"), serverMode), {
       status: errorResponse.status,
@@ -12776,7 +12787,6 @@
   exports.isCookie = isCookie;
   exports.isRouteErrorResponse = isRouteErrorResponse;
   exports.isSession = isSession;
-  exports.json = json$1;
   exports.matchPath = matchPath;
   exports.matchRoutes = matchRoutes;
   exports.parsePath = parsePath;