react-router 8.5.0 → 8.5.1

package/dist/production/index-react-server.d.ts

@@ -1,6 +1,5 @@
 
 import * as React from "react";
-import { ComponentType, ReactElement } from "react";
 import { CookieParseOptions, CookieParseOptions as CookieParseOptions$1, CookieSerializeOptions, CookieSerializeOptions as CookieSerializeOptions$1 } from "cookie-es";
 import { BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, StaticRouter, StaticRouterProvider, unstable_HistoryRouter } from "react-router/internal/react-server-client";
 import { ReactFormState } from "react-dom/client";
@@ -353,6 +352,13 @@ interface DataFunctionArgs<Context> {
    * In Framework mode, this is a normalized URL with React-Router-specific
    * implementation details removed (`.data` suffixes, `index`/`_routes` search
    * params). For the raw incoming URL, use `request.url`.
+   *
+   * This normalization preserves standard URL pathname encoding and casing.
+   * For example, a request to `/%61dmin.data` produces a `url.pathname` of
+   * `/%61dmin`. This is not a canonical representation of the matched route.
+   * For authorization, attach {@link https://reactrouter.com/how-to/middleware#authentication server middleware}
+   * to the protected route or a common ancestor instead of relying on literal
+   * pathname-prefix comparisons.
    */
   url: URL;
   /**
@@ -837,30 +843,6 @@ interface UIMatch<Data = unknown, Handle = unknown> {
    */
   handle: Handle;
 }
-interface RouteMeta<RouteObjectType extends RouteObject = RouteObject> {
-  relativePath: string;
-  caseSensitive: boolean;
-  childrenIndex: number;
-  route: RouteObjectType;
-  matcher?: RegExp;
-  compiledParams?: CompiledPathParam[];
-}
-/**
- * @private
- * PRIVATE - DO NOT USE
- *
- * A "branch" of routes that match a given route pattern.
- * This is an internal interface not intended for direct external usage.
- */
-interface RouteBranch<RouteObjectType extends RouteObject = RouteObject> {
-  path: string;
-  score: number;
-  routesMeta: RouteMeta<RouteObjectType>[];
-}
-type CompiledPathParam = {
-  paramName: string;
-  isOptional?: boolean;
-};
 declare class DataWithResponseInit<D> {
   type: string;
   data: D;
@@ -1025,18 +1007,6 @@ type ErrorResponse = {
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 //#endregion
 //#region lib/components.d.ts
-/**
- * Function signature for client side error handling for loader/actions errors
- * and rendering errors via `componentDidCatch`
- */
-interface ClientOnErrorFunction {
-  (error: unknown, info: {
-    location: Location$1;
-    params: Params;
-    pattern: string;
-    errorInfo?: React.ErrorInfo;
-  }): void;
-}
 interface AwaitResolveRenderFunction<Resolve = any> {
   (data: Awaited<Resolve>): React.ReactNode;
 }
@@ -1044,6 +1014,8 @@ interface AwaitResolveRenderFunction<Resolve = any> {
  * @category Types
  */
 interface AwaitProps<Resolve> {
+  /** Use either `resolve` or `unstable_promise`, never both. */
+  unstable_promise?: never;
   /**
    * When using a function, the resolved value is provided as the parameter.
    *
@@ -1145,11 +1117,46 @@ interface AwaitProps<Resolve> {
    */
   resolve: Resolve;
 }
+interface AwaitPromiseProps<Resolve> extends Omit<AwaitProps<Resolve>, "resolve" | "unstable_promise"> {
+  resolve?: never;
+  /**
+   * A promise (or value) to read using React's `use()` API in client components.
+   * Unlike `resolve` in client components, this accepts promise-like values
+   * without modifying the source promise.
+   *
+   * `errorElement` handles promise rejections. Errors thrown while rendering
+   * children bubble to the nearest React error boundary.
+   *
+   * ```tsx
+   * <Await unstable_promise={reviewsPromise} errorElement={<ReviewsError />}>
+   *   {(reviews) => <Reviews items={reviews} />}
+   * </Await>
+   * ```
+   *
+   * Pass exactly one of `unstable_promise` or `resolve`.
+   */
+  unstable_promise: Resolve;
+}
 /**
  * Used to render promise values with automatic error handling.
  *
  * **Note:** `<Await>` expects to be rendered inside a [`<React.Suspense>`](https://react.dev/reference/react/Suspense)
  *
+ * Pass `unstable_promise` instead of `resolve` to opt into React's
+ * [`use()`](https://react.dev/reference/react/use) implementation. With
+ * `unstable_promise`, `errorElement` handles promise rejections, while errors
+ * thrown by children bubble to the nearest React error boundary.
+ *
+ * In React Server Components, `resolve` already has this error-handling behavior:
+ * `errorElement` handles only input rejections, while child render errors
+ * propagate to the surrounding error boundary. Both props accept promise-like
+ * values without modifying the source promise. Both props treat a falsy
+ * `errorElement` as absent and propagate the rejection. Pass an empty fragment
+ * to handle a rejection without rendering any content.
+ *
+ * <docs-warning>The `unstable_promise` prop is experimental and may change in
+ * minor or patch releases.</docs-warning>
+ *
  * @example
  * import { Await, useLoaderData } from "react-router";
  *
@@ -1190,294 +1197,12 @@ interface AwaitProps<Resolve> {
  * @param {AwaitProps.children} props.children n/a
  * @param {AwaitProps.errorElement} props.errorElement n/a
  * @param {AwaitProps.resolve} props.resolve n/a
+ * @param props.unstable_promise A promise (or value) to read using React's `use()`
+ * API in client components. Accepts promise-like values without modifying the
+ * source promise. Pass exactly one of `unstable_promise` or `resolve`.
  * @returns React element for the rendered awaited value
  */
-declare function Await$1<Resolve>({
-  children,
-  errorElement,
-  resolve
-}: AwaitProps<Resolve>): React.JSX.Element;
-//#endregion
-//#region lib/server-runtime/serverHandoff.d.ts
-type ServerHandoff = {
-  criticalCss?: CriticalCss;
-  basename: string | undefined;
-  future: FutureConfig$1;
-  ssr: boolean;
-  isSpaMode: boolean;
-  unstable_apiOnly?: boolean;
-  unstable_apiServerOrigin?: string;
-  routeDiscovery: ServerBuild["routeDiscovery"];
-};
-//#endregion
-//#region lib/dom/global.d.ts
-type WindowReactRouterContext = ServerHandoff & {
-  state: HydrationState;
-  stream: ReadableStream<Uint8Array> | undefined;
-  streamController: ReadableStreamDefaultController<Uint8Array>;
-};
-interface ViewTransition {
-  finished: Promise<void>;
-  ready: Promise<void>;
-  updateCallbackDone: Promise<void>;
-  skipTransition(): void;
-}
-declare global {
-  var __staticRouterHydrationData: HydrationState | undefined;
-  var __reactRouterVersion: string;
-  interface Document {
-    startViewTransition(cb: () => Promise<void> | void): ViewTransition;
-  }
-  var __reactRouterContext: WindowReactRouterContext | undefined;
-  var __reactRouterManifest: AssetsManifest | undefined;
-  var __reactRouterRouteModules: RouteModules | undefined;
-  var __reactRouterDataRouter: Router$1 | undefined;
-  var __reactRouterHdrActive: boolean;
-  var $RefreshRuntime$: {
-    performReactRefresh: () => void;
-  } | undefined;
-}
-//#endregion
-//#region lib/dom/ssr/single-fetch.d.ts
-/**
- * Describes the operation that initiated an internal router request.
- *
- * Requests that reload fetchers as part of a navigation, revalidation, or
- * initialization redirect keep that initiating `type`. `fetcherKey` identifies
- * the fetcher being loaded, or is `null` when the request targets route loaders
- * or actions.
- *
- * `navigationType` is the history action (`"PUSH"`, `"REPLACE"`, or `"POP"`)
- * for navigation-initiated data requests, including reloaded fetchers. It is
- * `null` for initialization, fetcher, and revalidation requests. Manifest
- * requests have no navigation type.
- */
-type RouterFetchContext = {
-  type: "manifest";
-} | {
-  type: "navigation";
-  fetcherKey: string | null;
-  navigationType: Action;
-} | {
-  type: "initialization" | "fetcher" | "revalidation";
-  fetcherKey: string | null;
-  navigationType: null;
-};
-type RouterFetch = (request: Request, context: RouterFetchContext) => Promise<Response>;
-//#endregion
-//#region lib/dom/ssr/route-discovery.d.ts
-/** A discovery response from a different build. */
-type ManifestMismatchEvent = {
-  source: "eager" | "navigation" | "fetcher" | "imperative";
-  version: string;
-  reloadUrl: string | null;
-  loadAllRoutes(): Promise<void>;
-  stopPropagation(): void; /** Run built-in recovery for this source, at most once per mismatch event. */
-  defaultBehavior(): Promise<void>;
-};
-/** The result of imperative route discovery. */
-type DiscoveryResult = {
-  type: "success";
-} | {
-  type: "version-mismatch";
-} | {
-  type: "aborted";
-};
-/** Options for {@link unstable_useRouteDiscovery}. */
-type RouteDiscoveryOptions = {
-  onManifestMismatch?: (event: ManifestMismatchEvent) => void | Promise<void>;
-};
-type Registration = {
-  current: RouteDiscoveryOptions;
-};
-type DiscoveryState = "partial" | "loading" | "complete";
-type RouteDiscoverySsrInfo = {
-  manifest: AssetsManifest;
-  routeModules: RouteModules;
-  router: Router$1 | undefined;
-  context: Pick<WindowReactRouterContext, "ssr" | "routeDiscovery" | "isSpaMode" | "basename" | "unstable_apiServerOrigin" | "unstable_apiOnly">;
-};
-declare class RouteDiscoveryRuntime {
-  private ssrInfo;
-  readonly enabled: boolean;
-  readonly discoveredPaths: Set<string>;
-  readonly nextPaths: Set<string>;
-  state: DiscoveryState;
-  ready: boolean;
-  private registrations;
-  private listeners;
-  private fullLoadErrorListeners;
-  private fullLoad?;
-  private loadedManifest?;
-  private mismatch?;
-  private fetchImplementation;
-  private loadManifest;
-  onError?: ClientOnErrorFunction;
-  constructor(ssrInfo: RouteDiscoverySsrInfo, {
-    fetch: fetchImplementation,
-    loadManifest
-  }?: {
-    fetch?: RouterFetch;
-    loadManifest?: () => Promise<AssetsManifest>;
-  });
-  private get router();
-  private loadManifestAsset;
-  subscribe: (listener: () => void) => () => void;
-  private update;
-  markReady: () => void;
-  register(registration: Registration): () => void;
-  private isComplete;
-  loadAllRoutes: () => Promise<void>;
-  reportError(error: unknown): void;
-  private dispatchMismatch;
-  private requestUrl;
-  discoverRoutes: (paths: string[], options?: {
-    signal?: AbortSignal;
-  }) => Promise<DiscoveryResult>;
-  discover(paths: string[], source: ManifestMismatchEvent["source"], reloadUrl: string | null, signal?: AbortSignal, patch?: (routeId: string | null, children: RouteObject[], unstable_allowElementMutations?: boolean) => void): Promise<DiscoveryResult>;
-}
-//#endregion
-//#region lib/dom/ssr/entry.d.ts
-type SerializedError = {
-  message: string;
-  stack?: string;
-};
-interface FrameworkContextObject {
-  routeDiscoveryRuntime?: RouteDiscoveryRuntime;
-  routeDiscoveryState?: DiscoveryState;
-  manifest: AssetsManifest;
-  routeModules: RouteModules;
-  criticalCss?: CriticalCss;
-  serverHandoffString?: string;
-  future: FutureConfig$1;
-  ssr: boolean;
-  isSpaMode: boolean;
-  unstable_apiOnly?: boolean;
-  unstable_apiServerOrigin?: string;
-  routeDiscovery: ServerBuild["routeDiscovery"];
-  nonce?: string;
-  serializeError?(error: Error): SerializedError;
-  renderMeta?: {
-    didRenderScripts?: boolean;
-    streamCache?: Record<number, Promise<void> & {
-      result?: {
-        done: boolean;
-        value: string;
-      };
-      error?: unknown;
-    }>;
-  };
-}
-interface EntryContext extends FrameworkContextObject {
-  /**
-   * @deprecated This property was an internal implementation detail and was
-   * never intended for use in `entry.server.tsx`. It is always an empty array.
-   */
-  branches: RouteBranch<DataRouteObject>[];
-  staticHandlerContext: StaticHandlerContext;
-  serverHandoffStream?: ReadableStream<Uint8Array>;
-}
-interface FutureConfig$1 {
-  unstable_customRouteDiscovery?: boolean;
-}
-type CriticalCss = string | {
-  rel: "stylesheet";
-  href: string;
-};
-interface AssetsManifest {
-  entry: {
-    imports: string[];
-    module: string;
-  };
-  routes: RouteManifest<EntryRoute>;
-  url: string;
-  version: string;
-  hmr?: {
-    timestamp?: number;
-    runtime: string;
-  };
-  sri?: Record<string, string> | true;
-}
-//#endregion
-//#region lib/server-runtime/routes.d.ts
-type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-interface ServerRoute extends Route$1 {
-  children: ServerRoute[];
-  module: ServerRouteModule;
-}
-//#endregion
-//#region lib/server-runtime/build.d.ts
-type OptionalCriticalCss = CriticalCss | undefined;
-/**
- * The output of the compiler for the server build.
- */
-interface ServerBuild {
-  entry: {
-    module: ServerEntryModule;
-  };
-  routes: ServerRouteManifest;
-  assets: AssetsManifest;
-  basename?: string;
-  publicPath: string;
-  assetsBuildDirectory: string;
-  future: FutureConfig$1;
-  /**
-   * Whether runtime server requests are supported, including API-only builds.
-   */
-  ssr: boolean;
-  /**
-   * The origin to use for server requests in API-only mode.
-   * @internal
-   */
-  unstable_apiServerOrigin?: string;
-  /**
-   * Whether production document rendering is disabled while data and route
-   * discovery requests remain supported.
-   * @internal
-   */
-  unstable_apiOnly?: boolean;
-  unstable_getCriticalCss?: (args: {
-    pathname: string;
-  }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
-  /**
-   * @deprecated This is now done via a custom header during prerendering
-   */
-  isSpaMode: boolean;
-  prerender: string[];
-  routeDiscovery: {
-    mode: "lazy" | "initial";
-    manifestPath: string;
-  };
-  allowedActionOrigins?: string[] | false;
-}
-interface HandleDocumentRequestFunction {
-  (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: RouterContextProvider): Promise<Response> | Response;
-}
-interface HandleDataRequestFunction {
-  (response: Response, args: {
-    request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
-    context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
-    params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
-  }): Promise<Response> | Response;
-}
-interface HandleErrorFunction {
-  (error: unknown, args: {
-    request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
-    context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
-    params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
-  }): void;
-}
-/**
- * A module that serves as the entry point for a Remix app during server
- * rendering.
- */
-interface ServerEntryModule {
-  default: HandleDocumentRequestFunction;
-  handleDataRequest?: HandleDataRequestFunction;
-  handleError?: HandleErrorFunction;
-  instrumentations?: ServerInstrumentation[];
-  streamTimeout?: number;
-}
+declare function Await$1<Resolve>(props: AwaitProps<Resolve> | AwaitPromiseProps<Resolve>): React.JSX.Element;
 //#endregion
 //#region lib/router/instrumentation.d.ts
 type ServerInstrumentation = {
@@ -1937,6 +1662,8 @@ interface StaticHandler {
    * The set of data routes managed by this handler
    */
   dataRoutes: DataRouteObject[];
+  /** @private Estimated route metadata visits per regex match. */
+  readonly _matchCost?: number;
   /**
    * @private
    * PRIVATE - DO NOT USE
@@ -2257,31 +1984,6 @@ interface CreateStaticHandlerOptions {
  */
 declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
 //#endregion
-//#region lib/dom/ssr/routes.d.ts
-interface Route$1 {
-  index?: boolean;
-  caseSensitive?: boolean;
-  id: string;
-  parentId?: string;
-  path?: string;
-}
-interface EntryRoute extends Route$1 {
-  hasAction: boolean;
-  hasLoader: boolean;
-  hasClientAction: boolean;
-  hasClientLoader: boolean;
-  hasClientMiddleware: boolean;
-  hasErrorBoundary: boolean;
-  imports?: string[];
-  css?: string[];
-  module: string;
-  clientActionModule: string | undefined;
-  clientLoaderModule: string | undefined;
-  clientMiddlewareModule: string | undefined;
-  hydrateFallbackModule: string | undefined;
-  parentId?: string;
-}
-//#endregion
 //#region lib/router/links.d.ts
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
@@ -2469,36 +2171,6 @@ type ClientDataFunctionArgs<Params> = {
 type SerializeFrom<T> = T extends ((...args: infer Args) => unknown) ? Args extends [ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
 //#endregion
 //#region lib/dom/ssr/routeModules.d.ts
-interface RouteModules {
-  [routeId: string]: RouteModule | undefined;
-}
-/**
- * The shape of a route module shipped to the client
- */
-interface RouteModule {
-  clientAction?: ClientActionFunction;
-  clientLoader?: ClientLoaderFunction;
-  clientMiddleware?: MiddlewareFunction<Record<string, DataStrategyResult>>[];
-  ErrorBoundary?: ErrorBoundaryComponent;
-  HydrateFallback?: HydrateFallbackComponent;
-  Layout?: LayoutComponent;
-  default: RouteComponent;
-  handle?: RouteHandle;
-  links?: LinksFunction;
-  meta?: MetaFunction;
-  shouldRevalidate?: ShouldRevalidateFunction;
-}
-/**
- * The shape of a route module on the server
- */
-interface ServerRouteModule extends RouteModule {
-  action?: ActionFunction;
-  headers?: HeadersFunction | {
-    [name: string]: string;
-  };
-  loader?: LoaderFunction;
-  middleware?: MiddlewareFunction<Response>[];
-}
 /**
  * A function that handles data mutations for a route on the client
  */
@@ -2521,10 +2193,6 @@ type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<Load
 type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
   serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
 };
-/**
- * ErrorBoundary to display for this route
- */
-type ErrorBoundaryComponent = ComponentType;
 type HeadersArgs = {
   loaderHeaders: Headers;
   parentHeaders: Headers;
@@ -2538,19 +2206,6 @@ type HeadersArgs = {
 interface HeadersFunction {
   (args: HeadersArgs): Headers | HeadersInit;
 }
-/**
- * `<Route HydrateFallback>` component to render on initial loads
- * when client loaders are present
- */
-type HydrateFallbackComponent = ComponentType;
-/**
- * Optional, root-only `<Route Layout>` component to wrap the root content in.
- * Useful for defining the <html>/<head>/<body> document shell shared by the
- * Component, HydrateFallback, and ErrorBoundary
- */
-type LayoutComponent = ComponentType<{
-  children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
-}>;
 /**
  * A function that defines `<link>` tags to be inserted into the `<head>` of
  * the document on route transitions.
@@ -2658,7 +2313,6 @@ type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
 /**
  * A React component that is rendered for a route.
  */
-type RouteComponent = ComponentType<{}>;
 /**
  * An arbitrary object that is associated with a route.
  *

package/dist/production/index-react-server.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.5.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -1038,12 +1038,17 @@ var V6RegExMatcher = class {
 	#routes = [];
 	#branches = [];
 	#basename;
+	#matchCost = 0;
 	constructor(basename) {
 		this.#basename = basename;
 	}
 	update(routes) {
 		this.#routes = routes;
 		this.#branches = flattenAndRankRoutes(routes);
+		this.#matchCost = this.#branches.reduce((total, branch) => total + branch.routesMeta.length, 0);
+	}
+	get matchCost() {
+		return this.#matchCost;
 	}
 	match(locationArg, allowPartial = false) {
 		return matchRoutesImpl(this.#routes, locationArg, this.#basename, allowPartial, this.#branches);
@@ -1469,6 +1474,9 @@ function createStaticHandler(routes, opts) {
 	}
 	return {
 		dataRoutes,
+		get _matchCost() {
+			return dataRouteMatcher instanceof V6RegExMatcher ? dataRouteMatcher.matchCost : void 0;
+		},
 		match,
 		query,
 		queryRoute
@@ -1580,6 +1588,9 @@ const loadLazyRouteProperty = ({ key, route, manifest, mapRouteProperties }) =>
 		}
 	})();
 	cache[key] = propertyPromise;
+	propertyPromise.catch(() => {
+		if (cache[key] === propertyPromise) delete cache[key];
+	});
 	return propertyPromise;
 };
 const lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
@@ -1621,7 +1632,9 @@ function loadLazyRoute(route, type, manifest, mapRouteProperties, lazyRoutePrope
 			});
 		})();
 		lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
-		lazyRoutePromise.catch(() => {});
+		lazyRoutePromise.catch(() => {
+			if (lazyRouteFunctionCache.get(routeToUpdate) === lazyRoutePromise) lazyRouteFunctionCache.delete(routeToUpdate);
+		});
 		return {
 			lazyRoutePromise,
 			lazyHandlerPromise: lazyRoutePromise
@@ -1909,10 +1922,13 @@ async function callLoaderOrAction({ request, path, pattern, match, lazyHandlerPr
 					pathname,
 					routeId: match.route.id
 				});
-			} else return {
-				type: "data",
-				result: void 0
-			};
+			} else {
+				await lazyRoutePromise;
+				return {
+					type: "data",
+					result: void 0
+				};
+			}
 		}
 		else if (!handler) {
 			let url = new URL(request.url);
@@ -2242,6 +2258,12 @@ function getPathsWithAncestors(paths) {
 	});
 	return Array.from(result);
 }
+const MANIFEST_MATCH_COST_LIMIT = 5e4;
+const MANIFEST_MATCH_COST_SEGMENT_THRESHOLD = 10;
+function shouldUseInitialRouteDiscovery(pathname, matchCost = 0) {
+	let segmentCount = pathname.split("/").length - 1;
+	return Math.max(segmentCount - 1, 0) * pathname.length + 1 > 7680 || segmentCount > MANIFEST_MATCH_COST_SEGMENT_THRESHOLD && segmentCount * matchCost > MANIFEST_MATCH_COST_LIMIT;
+}
 //#endregion
 //#region lib/actions.ts
 function throwIfPotentialCSRFAttack(request, allowedActionOrigins) {
@@ -2337,12 +2359,15 @@ const replace = (...args) => {
 const cachedResolvePromise = React.cache(async (resolve) => {
 	return Promise.allSettled([resolve]).then((r) => r[0]);
 });
-const Await = (async ({ children, resolve, errorElement }) => {
-	let resolved = await cachedResolvePromise(resolve);
+const Await = (async (props) => {
+	invariant$1("resolve" in props !== "unstable_promise" in props, "<Await> requires exactly one of `resolve` or `unstable_promise`");
+	let { children, errorElement } = props;
+	let usePromise = "unstable_promise" in props;
+	let resolved = await cachedResolvePromise(usePromise ? props.unstable_promise : props.resolve);
 	if (resolved.status === "rejected" && !errorElement) throw resolved.reason;
 	if (resolved.status === "rejected") return React.createElement(UNSAFE_AwaitContextProvider, {
 		children: React.createElement(React.Fragment, null, errorElement),
-		value: {
+		value: usePromise ? resolved : {
 			_tracked: true,
 			_error: resolved.reason
 		}
@@ -2350,7 +2375,7 @@ const Await = (async ({ children, resolve, errorElement }) => {
 	const toRender = typeof children === "function" ? children(resolved.value) : children;
 	return React.createElement(UNSAFE_AwaitContextProvider, {
 		children: toRender,
-		value: {
+		value: usePromise ? resolved : {
 			_tracked: true,
 			_data: resolved.value
 		}
@@ -2667,7 +2692,7 @@ async function generateRenderResponse(request, staticHandler, basename, isDataRe
 					let result = await processServerAction(request, basename, decodeReply, loadServerAction, decodeAction, decodeFormState, onError, temporaryReferences).finally(() => {
 						ctx.runningAction = false;
 					});
-					if (isResponse(result)) return generateRedirectResponse(result, actionResult, basename, isDataRequest, generateResponse, temporaryReferences, ctx.redirect?.headers);
+					if (isResponse(result)) return generateRedirectResponse(result, actionResult, basename, isDataRequest, generateResponse, temporaryReferences, result === ctx.redirect ? void 0 : ctx.redirect?.headers);
 					skipRevalidation = result?.skipRevalidation ?? false;
 					actionResult = result?.actionResult;
 					formState = result?.formState;
@@ -2701,7 +2726,7 @@ function generateRedirectResponse(response, actionResult, basename, isDataReques
 		status: response.status,
 		actionResult
 	};
-	let headers = new Headers(sideEffectRedirectHeaders);
+	let headers = new Headers(sideEffectRedirectHeaders === response.headers ? void 0 : sideEffectRedirectHeaders);
 	for (const [key, value] of response.headers.entries()) headers.append(key, value);
 	headers.delete("Location");
 	headers.delete("X-Remix-Reload-Document");
@@ -2779,11 +2804,14 @@ async function getRenderPayload(baseRenderPayload, staticHandler, basename, rout
 			parentId
 		});
 	}));
+	let pathname = staticContext.location.pathname;
+	let useInitialRouteDiscovery = routeDiscovery?.mode === "initial" && !isDataRequest || shouldUseInitialRouteDiscovery(pathname, staticHandler._matchCost);
 	let patches;
-	if (routeDiscovery?.mode === "initial" && !isDataRequest) patches = getAllRoutePatches(routes, basename).then((patches) => patches.filter((patch) => !staticContext.matches.some((m) => m.route.id === patch.id)));
-	else patches = getAdditionalRoutePatches(getPathsWithAncestors([staticContext.location.pathname]), staticHandler, staticContext.matches.map((m) => m.route.id));
+	if (useInitialRouteDiscovery) patches = getAllRoutePatches(routes, basename).then((patches) => patches.filter((patch) => !staticContext.matches.some((m) => m.route.id === patch.id)));
+	else patches = getAdditionalRoutePatches(getPathsWithAncestors([pathname]).slice(0, -1), staticHandler, staticContext.matches.map((m) => m.route.id));
 	return {
 		...baseRenderPayload,
+		routeDiscovery: useInitialRouteDiscovery ? { mode: "initial" } : baseRenderPayload.routeDiscovery,
 		matches: await matchesPromise,
 		patches
 	};
@@ -3242,7 +3270,7 @@ function createSessionStorage({ cookie: cookieArg, createData, readData, updateD
 			return cookie.serialize(id, options);
 		},
 		async destroySession(session, options) {
-			await deleteData(session.id);
+			if (session.id) await deleteData(session.id);
 			return cookie.serialize("", {
 				...options,
 				maxAge: void 0,

package/dist/production/index.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.5.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *