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

package/dist/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.
  *
@@ -250,7 +250,7 @@ function createHashHistory(options = {}) {
       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
@@ -313,7 +313,7 @@ function warning(cond, message) {
   }
 }
 function createKey$1() {
-  return Math.random().toString(36).substr(2, 8);
+  return Math.random().toString(36).substring(2, 10);
 }
 
 /**
@@ -371,13 +371,13 @@ function parsePath(path) {
   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;
@@ -1237,25 +1237,6 @@ const normalizeSearch = search => !search || search === "?" ? "" : search.starts
  * @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 = (data, 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), {
-    ...responseInit,
-    headers
-  });
-};
 class DataWithResponseInit {
   type = "DataWithResponseInit";
   constructor(data, init) {
@@ -1275,6 +1256,10 @@ function data(data, init) {
     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".
@@ -1458,7 +1443,7 @@ const validMutationMethodsArr = ["POST", "PUT", "PATCH", "DELETE"];
 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",
@@ -1596,25 +1581,12 @@ function createRouter(init) {
     // 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;
@@ -1700,10 +1672,6 @@ function createRouter(init) {
   // 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;
@@ -2145,7 +2113,7 @@ function createRouter(init) {
     // 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))) {
@@ -2249,15 +2217,12 @@ function createRouter(init) {
           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) {
@@ -2383,15 +2348,12 @@ function createRouter(init) {
           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) {
@@ -2516,13 +2478,12 @@ function createRouter(init) {
       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(([id]) => !matchesToLoad.some(m => m.route.id === id)).forEach(([routeId, error]) => {
-        errors = Object.assign(errors || {}, {
-          [routeId]: error
-        });
-      });
+      errors = {
+        ...state.errors,
+        ...errors
+      };
     }
     let updatedFetchers = markFetchRedirectsDone();
     let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
@@ -2642,10 +2603,7 @@ function createRouter(init) {
       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;
@@ -2825,10 +2783,7 @@ function createRouter(init) {
       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;
@@ -3014,7 +2969,7 @@ function createRouter(init) {
       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,
@@ -3027,8 +2982,6 @@ function createRouter(init) {
     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 => {
@@ -3243,16 +3196,6 @@ function createRouter(init) {
       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
@@ -3329,12 +3272,26 @@ function createRouter(init) {
     };
   }
   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",
@@ -3348,7 +3305,7 @@ function createRouter(init) {
         // 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];
         }
       }
@@ -3528,7 +3485,7 @@ function createStaticHandler$1(routes, opts) {
       };
     }
     let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
-    if (isResponse$2(result)) {
+    if (isResponse(result)) {
       return result;
     }
 
@@ -3601,7 +3558,7 @@ function createStaticHandler$1(routes, opts) {
       });
     }
     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;
@@ -3630,7 +3587,7 @@ function createStaticHandler$1(routes, opts) {
         return _result;
       }
       let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
-      return isResponse$2(result) ? result : {
+      return isResponse(result) ? result : {
         ...result,
         actionData: null,
         actionHeaders: {}
@@ -3639,7 +3596,7 @@ function createStaticHandler$1(routes, opts) {
       // 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;
         }
@@ -3647,7 +3604,7 @@ function createStaticHandler$1(routes, opts) {
       }
       // Redirects are always returned since they don't propagate to catch
       // boundaries
-      if (isRedirectResponse$1(e)) {
+      if (isRedirectResponse(e)) {
         return e;
       }
       throw e;
@@ -3807,12 +3764,12 @@ function createStaticHandler$1(routes, opts) {
         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;
@@ -4041,26 +3998,34 @@ function normalizeNavigateOptions(isFetcher, path, opts) {
   };
 }
 
-// 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 = false) {
+  let index = matches.findIndex(m => m.route.id === boundaryId);
+  if (index >= 0) {
+    return matches.slice(0, includeBoundary ? index + 1 : index);
   }
-  return boundaryMatches;
+  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
@@ -4078,13 +4043,8 @@ function getMatchesToLoad(history, state, matches, submission, location, isIniti
     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
@@ -4118,10 +4078,11 @@ function getMatchesToLoad(history, state, matches, submission, location, isIniti
   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);
@@ -4187,6 +4148,32 @@ function getMatchesToLoad(history, state, matches, submission, location, isIniti
   });
   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]
@@ -4220,34 +4207,6 @@ function shouldRevalidateLoader(loaderMatch, arg) {
   }
   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) {
   let childrenToPatch;
   if (routeId) {
@@ -4516,7 +4475,7 @@ async function convertDataStrategyResultToDataResult(dataStrategyResult) {
     result,
     type
   } = dataStrategyResult;
-  if (isResponse$2(result)) {
+  if (isResponse(result)) {
     let data;
     try {
       let contentType = result.headers.get("Content-Type");
@@ -4852,9 +4811,7 @@ function getInternalRouterError(status, {
   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";
@@ -4915,14 +4872,11 @@ function isHashChangeOnly(a, b) {
   // /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;
@@ -4933,16 +4887,14 @@ function isRedirectResult(result) {
 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());
@@ -5884,7 +5836,7 @@ var DataRouterStateHook$1 = /*#__PURE__*/function (DataRouterStateHook) {
   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.useContext(DataRouterContext);
@@ -6375,8 +6327,8 @@ function RouterProvider({
   let fetcherData = React.useRef(new Map());
   let setState = React.useCallback((newState, {
     deletedFetchers,
-    flushSync: flushSync,
-    viewTransitionOpts: viewTransitionOpts
+    flushSync,
+    viewTransitionOpts
   }) => {
     deletedFetchers.forEach(key => fetcherData.current.delete(key));
     newState.fetchers.forEach((fetcher, key) => {
@@ -7266,7 +7218,56 @@ function invariant$1(value, message) {
  * @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.
@@ -7323,7 +7324,7 @@ function getKeyedLinksForMatches(matches, routeModules, manifest) {
   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?.links?.() || []];
@@ -7403,8 +7404,12 @@ function isHtmlLinkDescriptor(object) {
 }
 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" ? {
     ...link,
@@ -7418,7 +7423,6 @@ async function getKeyedPrefetchLinks(matches, manifest, routeModules) {
 
 // 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;
@@ -7432,42 +7436,44 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
       currentMatches[index].route.path?.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) {
-      let routeChoice = match.route.shouldRevalidate({
-        currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
-        currentParams: currentMatches[0]?.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) {
+        let routeChoice = match.route.shouldRevalidate({
+          currentUrl: new URL(location.pathname + location.search + location.hash, window.origin),
+          currentParams: currentMatches[0]?.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);
@@ -7482,6 +7488,7 @@ function getModuleLinkHrefs(matches, manifestPatch) {
 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);
@@ -7520,13 +7527,6 @@ function dedupeLinkDescriptors(descriptors, preloads) {
   }, []);
 }
 
-// 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
@@ -7564,13 +7564,6 @@ function createHtml(html) {
   };
 }
 
-/**
- * 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
@@ -7707,7 +7700,7 @@ async function singleFetchActionStrategy(request, matches) {
     });
     return result;
   });
-  if (isResponse$1(result.result) || isRouteErrorResponse(result.result)) {
+  if (isResponse(result.result) || isRouteErrorResponse(result.result)) {
     return {
       [actionMatch.route.id]: result
     };
@@ -7752,6 +7745,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
   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) {
       // If we're not yet initialized and this is the initial load, respect
       // `shouldLoad` because we're only dealing with `clientLoader.hydrate`
@@ -7763,7 +7757,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
       // 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.id]?.shouldRevalidate) {
+      if (m.route.id in router.state.loaderData && manifestRoute && manifestRoute.hasLoader && routeModules[m.route.id]?.shouldRevalidate) {
         foundOptOutRoute = true;
         return;
       }
@@ -7771,8 +7765,8 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
 
     // 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 {
@@ -7791,7 +7785,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
     }
 
     // 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);
     }
 
@@ -8188,20 +8182,18 @@ function RemixRootDefaultHydrateFallback() {
   }));
 }
 
-// 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;
 }
@@ -8332,10 +8324,12 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
         ...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?.loaderData?.[route.id];
-      let initialError = initialState?.errors?.[route.id];
+      let hasInitialData = initialState && initialState.loaderData && route.id in initialState.loaderData;
+      let initialData = hasInitialData ? initialState?.loaderData?.[route.id] : undefined;
+      let hasInitialError = initialState && initialState.errors && route.id in initialState.errors;
+      let initialError = hasInitialError ? initialState?.errors?.[route.id] : undefined;
       let isHydrationRequest = needsRevalidation == null && (routeModule.clientLoader?.hydrate === true || !route.hasLoader);
       dataRoute.loader = async ({
         request,
@@ -8357,10 +8351,12 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
 
                 // 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
@@ -8449,9 +8445,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
             }
           });
         }
-        if (needsRevalidation) {
-          lazyRoute.shouldRevalidate = wrapShouldRevalidateForHdr(route.id, mod.shouldRevalidate, needsRevalidation);
-        }
         return {
           ...(lazyRoute.loader ? {
             loader: lazyRoute.loader
@@ -8460,7 +8453,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
             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()
@@ -8474,6 +8467,23 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     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({
+      ...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
@@ -8674,9 +8684,12 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
 
   // 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
@@ -8686,7 +8699,7 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
   // 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);
     }
   });
@@ -8710,8 +8723,6 @@ function debounce(callback, wait) {
   };
 }
 
-// TODO: Temporary shim until we figure out the way to handle typings in v7
-
 function useDataRouterContext$1() {
   let context = React.useContext(DataRouterContext);
   !context ? invariant$1(false, "You must render this element inside a <DataRouterContext.Provider> element")  : void 0;
@@ -8968,12 +8979,13 @@ function PrefetchPageLinksImpl({
     let routesParams = new Set();
     let foundOptOutRoute = false;
     nextMatches.forEach(m => {
-      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.id]?.shouldRevalidate) {
         foundOptOutRoute = true;
-      } else if (manifest.routes[m.route.id].hasClientLoader) {
+      } else if (manifestRoute.hasClientLoader) {
         foundOptOutRoute = true;
       } else {
         routesParams.add(m.route.id);
@@ -9244,7 +9256,7 @@ import(${JSON.stringify(manifest.entry.module)});`;
   }, []);
   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.createElement(React.Fragment, null, !enableFogOfWar ? /*#__PURE__*/React.createElement("link", {
@@ -9950,7 +9962,7 @@ var DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {
   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.useContext(DataRouterContext);
@@ -10939,7 +10951,7 @@ function ServerRouter({
     // 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];
     }
   }
@@ -11152,7 +11164,17 @@ const createCookie = (name, cookieOptions = {}) => {
         ...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 serialize(name, value === "" ? "" : await encodeCookieValue(value, secrets), {
@@ -11262,7 +11284,10 @@ function warnOnceAboutExpiresCookie(name, expires) {
 
 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;
   }, {});
 }
@@ -11391,29 +11416,6 @@ function matchServerRoutes(routes, pathname, basename) {
   }));
 }
 
-// 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 = (data, 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
@@ -11421,10 +11423,6 @@ function isRedirectResponse(response) {
  * 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) {
@@ -11485,18 +11483,23 @@ function stripRoutesParam(request) {
   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;
 }
@@ -11521,7 +11524,29 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
       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
     };
@@ -11598,13 +11623,15 @@ function getDocumentHeaders(build, context) {
     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
@@ -11901,13 +11928,6 @@ function encodeViaTurboStream(data, requestSignal, streamTimeout, serverMode) {
   });
 }
 
-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);
@@ -12034,15 +12054,18 @@ async function handleManifestRequest(build, routes, url) {
       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
@@ -12222,7 +12245,7 @@ async function handleResourceRequest(serverMode, build, staticHandler, routeId,
   }
 }
 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,
@@ -12501,5 +12524,5 @@ function deserializeErrors(errors) {
   return serialized;
 }
 
-export { Await, BrowserRouter, Form, HashRouter, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Action as NavigationType, Outlet, PrefetchPageLinks, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, ServerRouter, StaticRouter, StaticRouterProvider, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, FetchersContext as UNSAFE_FetchersContext, FrameworkContext as UNSAFE_FrameworkContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteContext as UNSAFE_RouteContext, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, ViewTransitionContext as UNSAFE_ViewTransitionContext, createBrowserHistory as UNSAFE_createBrowserHistory, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, createRouter as UNSAFE_createRouter, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getSingleFetchDataStrategy$1 as UNSAFE_getSingleFetchDataStrategy, invariant$2 as UNSAFE_invariant, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createPath, createRequestHandler, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, data, generatePath, isCookie, isRouteErrorResponse, isSession, json$1 as json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, HistoryRouter as unstable_HistoryRouter, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };
+export { Await, BrowserRouter, Form, HashRouter, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Action as NavigationType, Outlet, PrefetchPageLinks, Route, Router, RouterProvider, Routes, Scripts, ScrollRestoration, ServerRouter, StaticRouter, StaticRouterProvider, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, FetchersContext as UNSAFE_FetchersContext, FrameworkContext as UNSAFE_FrameworkContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteContext as UNSAFE_RouteContext, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, ViewTransitionContext as UNSAFE_ViewTransitionContext, createBrowserHistory as UNSAFE_createBrowserHistory, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, createRouter as UNSAFE_createRouter, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getSingleFetchDataStrategy$1 as UNSAFE_getSingleFetchDataStrategy, invariant$2 as UNSAFE_invariant, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createPath, createRequestHandler, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, data, generatePath, isCookie, isRouteErrorResponse, isSession, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, HistoryRouter as unstable_HistoryRouter, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };
 //# sourceMappingURL=react-router.development.js.map