react-router 8.4.0 → 8.5.1

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # `react-router`
 
+## v8.5.1
+
+### Patch Changes
+
+- Fix `URIError: URI malformed` when an API-only (`ssr: "unstable_api-only"`) server or an `ssr: false` dev server receives a URL path with a malformed percent-encoding ([#15649](https://github.com/remix-run/react-router/pull/15649))
+- Bound server route manifest processing for paths with expensive route expansion ([#15703](https://github.com/remix-run/react-router/pull/15703))
+  - Fall back to initial route discovery during server rendering and RSC document/data requests
+  - Account for the number and depth of candidate branches when using regex matching
+- Encode commas within paths sent to the lazy route discovery manifest endpoint so routes with commas in their paths are discovered correctly ([#15640](https://github.com/remix-run/react-router/pull/15640))
+- Fix fetcher revalidation errors bubbling to the root error boundary instead of the nearest boundary above the route that owns the fetcher ([#15676](https://github.com/remix-run/react-router/pull/15676))
+- Avoid duplicate history entries when posting a `<Form>` to the current URL with an encoded `action` ([#15679](https://github.com/remix-run/react-router/pull/15679))
+  - Replace the current history entry when the `action` contains characters that get percent-encoded, such as spaces or non-ASCII characters
+- Fix an unhandled promise rejection when the browser skips a `viewTransition` navigation, for example in a hidden tab ([#15582](https://github.com/remix-run/react-router/pull/15582))
+- Bubble rejected `lazy.Component` imports on loader-less routes to the nearest error boundary ([#15658](https://github.com/remix-run/react-router/pull/15658))
+  - Render the error boundary instead of a blank page
+- Preserve pending fetcher mutation revalidation when an older navigation or background reload completes to prevent stale loader data ([#15686](https://github.com/remix-run/react-router/pull/15686))
+  - Keep newer fetcher loads cancellable and preserve them when earlier revalidations finish or abort, preventing older responses from overwriting fresh fetcher data
+- Retry rejected `lazy` route imports instead of caching failures permanently ([#15689](https://github.com/remix-run/react-router/pull/15689))
+- Revalidate loader data when a fetcher action redirect is not followed ([#15557](https://github.com/remix-run/react-router/pull/15557))
+  - Revalidate when an action redirect is ignored because a newer navigation started or the fetcher unmounted while the action was running
+  - Include shared parent loaders when another navigation completed while the action was running
+  - Continue to respect `shouldRevalidate`
+  - Return fetchers to `idle` when a revalidation completes a pending navigation started by another fetcher's redirect
+- Avoid adding an incompatible `document.startViewTransition()` overload to the global `Document` type ([#15680](https://github.com/remix-run/react-router/pull/15680))
+  - Allow transition results to be assigned to the DOM `ViewTransition` type
+- Fix duplicate headers when throwing a redirect from an RSC server function ([#15667](https://github.com/remix-run/react-router/pull/15667))
+- Skip `deleteData` in `destroySession` when the session has no ID ([#15639](https://github.com/remix-run/react-router/pull/15639))
+  - Avoid failures when destroying a session without a cookie on storage that rejects an empty key
+- Surface the host's 404 response when a SPA fallback route has no prerendered data ([#15646](https://github.com/remix-run/react-router/pull/15646))
+  - Request single-fetch `.data` files for hydrating routes with a server `loader` in an `ssr: false` app with a `prerender` config
+  - Avoid the internal "No result found for routeId" error for non-prerendered parameterized paths served via the SPA fallback
+- Improve turbo-stream decoding validation and object property handling ([18e1fbd](https://github.com/remix-run/react-router/commit/18e1fbd))
+
+### Unstable Changes
+
+⚠️  _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
+
+- Add an opt-in `<Await unstable_promise={promise}>` implementation based on React's `use()` API ([#15678](https://github.com/remix-run/react-router/pull/15678))
+  - Use `React.use` instead of React Router's internal promise tracking
+  - Accept promise-like values and retain `errorElement`, `useAsyncValue`, and `useAsyncError` support
+  - Handle only promise rejections with `errorElement` when using `unstable_promise`, allowing child render errors to bubble to the nearest React error boundary
+  - Track streamed promises during decoding so settled server content stays visible during hydration updates with either Await API or direct `React.use()`
+
+## v8.5.0
+
+### Minor Changes
+
+- Deprecate React Router's view transition APIs in favor of React's `<ViewTransition>` component, available in React 19.3 and later ([#15493](https://github.com/remix-run/react-router/pull/15493))
+  - Deprecate the `viewTransition` props/options, `useViewTransitionState`, and `NavLink`'s `isTransitioning` render prop and `transitioning` class
+  - Preserve existing behavior, including support for older React versions
+  - See the [migration guide](https://reactrouter.com/how-to/view-transitions) for a navigation example and compatibility considerations
+
+### Patch Changes
+
+- Fix `<Await>` failing to server render promises decoded from an RSC payload, which caused the Suspense boundary to switch to client rendering ([#15597](https://github.com/remix-run/react-router/pull/15597))
+- Declare `@types/react` and `@types/react-dom` as optional peer dependencies so the shipped type definitions resolve React types under strict (non-hoisted) node_modules layouts ([#15528](https://github.com/remix-run/react-router/pull/15528))
+- Fix the `unstable_useRouterState` documentation example to call the imported alias ([#15535](https://github.com/remix-run/react-router/pull/15535))
+- Render the `HydrateFallback` of a route discovered through `patchRoutesOnNavigation` during initial hydration ([#15537](https://github.com/remix-run/react-router/pull/15537))
+  - Routes discovered during initial hydration are now exposed in `state.matches` while their loaders run, so `<RouterProvider>` renders down to the discovered route's `HydrateFallback` instead of rendering nothing
+- Fix router state recovery when updates occur before `RouterProvider` subscribes, including when other subscribers are already attached, and report current client errors once without replaying server errors during hydration ([#15637](https://github.com/remix-run/react-router/pull/15637))
+- Fix `matchPath` not treating a static segment as optional when it contains characters outside `[\w-]` ([#15425](https://github.com/remix-run/react-router/pull/15425))
+- Fix an RSC server crash when a client aborts a document request while the HTML stream waits for the RSC payload ([#15612](https://github.com/remix-run/react-router/pull/15612))
+- Stop revalidating a fetcher after `fetcher.reset()`, so its cleared data no longer comes back on the next revalidation ([#15633](https://github.com/remix-run/react-router/pull/15633))
+
+### Unstable Changes
+
+⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
+
+- Add an `unstable_fetch` prop to `<HydratedRouter>` to customize JavaScript-issued manifest and server data requests in conventional Framework Mode ([#15586](https://github.com/remix-run/react-router/pull/15586))
+  - The function receives the intended request as well as context identifying the type of request
+  - Data request context includes `navigationType` (`"PUSH"`, `"REPLACE"`, or `"POP"` for navigation-initiated requests, including reloaded fetchers; `null` otherwise)
+    - Data strategies receive equivalent metadata through `unstable_initiator` and `unstable_navigationType`
+  - The custom fetch context is a discriminated union, so narrowing `type` to `"navigation"` guarantees a non-null `navigationType`, while other data requests have a `null` `navigationType`
+    - Fetchers reloaded after an initialization redirect retain the `"initialization"` type and include their fetcher key
+  - Like other router initialization options, the implementation is captured when the singleton router is created and thus subsequent prop changes are ignored
+  - Browser-managed data prefetches from `<Link prefetch>` use native `<link rel="prefetch">` elements and do not call the custom implementation
+  - Use the callback for custom fetch options, custom headers, safe request retries, or response header inspection
+  - Return response bodies unchanged so React Router can decode its manifest and Turbo Stream data protocols
+- Support API-only Framework Mode with runtime server data loading, actions, revalidation, and lazy route discovery ([#15601](https://github.com/remix-run/react-router/pull/15601))
+  - Hydrate prerendered pages from build-time data and fetch server loader data when hydrating a SPA fallback
+  - Preserve normal loader revalidation and server-action support for eagerly loaded and lazily discovered routes, and honor loader opt-outs when making server data requests
+- Add `unstable_useRouteDiscovery` for application-controlled route discovery in conventional Framework Mode ([#15602](https://github.com/remix-run/react-router/pull/15602))
+  - Discover selected destinations or load the running client's full route manifest without loading route modules
+  - Compose manifest-mismatch handlers, with shared recovery and cancellation that preserves application state
+  - Keep full-manifest failures catchable without rendering error boundaries, whether mismatch handlers use the hook or event's `loadAllRoutes()`
+  - Cancel pending revalidation alongside a canceled navigation, retaining existing data and settling interrupted fetchers before restoring Back/Forward history
+  - Enable `future.unstable_customRouteDiscovery` to opt in
+    - Apps without the flag retain existing discovery behavior
+  - Call `event.defaultBehavior()` from a custom mismatch handler to explicitly run built-in recovery
+- Return middleware short-circuit responses as-is for document requests in RSC modes, including resource routes, instead of decoding non-RSC bodies as Flight ([#15628](https://github.com/remix-run/react-router/pull/15628))
+  - Include server middleware in both eager and lazy RSC route configuration types
+  - Preserve HTML rendering for cached Flight responses returned by middleware, and pass through raw responses that replace the result of `next()`
+
 ## v8.4.0
 
 ### Minor Changes
@@ -25,7 +118,7 @@
 
 ### Unstable Changes
 
-⚠️  _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
+⚠️ _[Unstable features](https://reactrouter.com/community/api-development-strategy#unstable-flags) are not recommended for production use_
 
 - Add a Data Mode `future.unstable_routePatternMatching` flag for more efficient route matching powered by `@remix-run/route-pattern` ([#15298](https://github.com/remix-run/react-router/pull/15298))
   - Add an `unstable_validateParams` route field to reject invalid parameter values and continue matching

package/dist/development/dom-export.d.ts

@@ -1,7 +1,8 @@
 
 import { RouterProvider, RouterProviderProps } from "./lib/dom-export/dom-router-provider.js";
+import { RouterFetch, RouterFetchContext } from "./lib/dom/ssr/single-fetch.js";
 import { DecodeActionFunction, DecodeFormStateFunction, DecodeReplyFunction, RSCManifestPayload, RSCPayload, RSCRenderPayload } from "./lib/rsc/server.rsc.js";
 import { RSCHydratedRouter, createCallServer } from "./lib/rsc/browser.js";
 import { HydratedRouter, HydratedRouterProps } from "./lib/dom-export/hydrated-router.js";
 import { getRSCStream } from "./lib/rsc/html-stream/browser.js";
-export { HydratedRouter, type HydratedRouterProps, RouterProvider, type RouterProviderProps, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, createCallServer as unstable_createCallServer, getRSCStream as unstable_getRSCStream };
+export { HydratedRouter, type HydratedRouterProps, RouterProvider, type RouterProviderProps, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, type RouterFetch as unstable_RouterFetch, type RouterFetchContext as unstable_RouterFetchContext, createCallServer as unstable_createCallServer, getRSCStream as unstable_getRSCStream };

package/dist/development/dom-export.js

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

package/dist/development/index-react-server-client.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -10,8 +10,8 @@
  */
 "use client";
 import { AwaitContextProvider } from "./lib/context.js";
-import { MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, WithComponentProps, WithErrorBoundaryProps, WithHydrateFallbackProps } from "./lib/components.js";
 import { Links, Meta } from "./lib/dom/ssr/components.js";
+import { MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, WithComponentProps, WithErrorBoundaryProps, WithHydrateFallbackProps } from "./lib/components.js";
 import { BrowserRouter, Form, HashRouter, HistoryRouter, Link, NavLink, ScrollRestoration } from "./lib/dom/lib.js";
 import { StaticRouter, StaticRouterProvider } from "./lib/dom/server.js";
 export { BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, StaticRouter, StaticRouterProvider, AwaitContextProvider as UNSAFE_AwaitContextProvider, WithComponentProps as UNSAFE_WithComponentProps, WithErrorBoundaryProps as UNSAFE_WithErrorBoundaryProps, WithHydrateFallbackProps as UNSAFE_WithHydrateFallbackProps, HistoryRouter as unstable_HistoryRouter };

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

@@ -352,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;
   /**
@@ -556,6 +563,11 @@ interface DataStrategyMatch extends RouteMatch<string, DataRouteObject> {
    */
   resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
+/**
+ * The operation that initiated a data strategy execution. Static handler
+ * executions use `"static"`.
+ */
+type DataStrategyInitiator = "initialization" | "navigation" | "fetcher" | "revalidation" | "static";
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
   /**
    * Matches for this route extended with Data strategy APIs
@@ -563,8 +575,23 @@ interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctio
   matches: DataStrategyMatch[];
   runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
   /**
-   * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
-   * for navigational executions
+   * The operation that initiated this data strategy execution
+   *
+   * This field is experimental and subject to breaking changes.
+   */
+  unstable_initiator: DataStrategyInitiator;
+  /**
+   * The history action (`"PUSH"`, `"REPLACE"`, or `"POP"`) for a navigation-
+   * initiated execution, including fetchers reloaded by that navigation.
+   * `null` for initialization, fetcher, revalidation, and static executions.
+   *
+   * This field is experimental and subject to breaking changes.
+   */
+  unstable_navigationType: Action | null;
+  /**
+   * The key of the fetcher targeted by this data strategy execution, otherwise
+   * `null`. Fetchers reloaded during a navigation or revalidation retain that
+   * `unstable_initiator` while providing their key here.
    */
   fetcherKey: string | null;
 }
@@ -979,6 +1006,204 @@ type ErrorResponse = {
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 //#endregion
+//#region lib/components.d.ts
+interface AwaitResolveRenderFunction<Resolve = any> {
+  (data: Awaited<Resolve>): React.ReactNode;
+}
+/**
+ * @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.
+   *
+   * ```tsx [2]
+   * <Await resolve={reviewsPromise}>
+   *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
+   * </Await>
+   * ```
+   *
+   * When using React elements, {@link useAsyncValue} will provide the
+   * resolved value:
+   *
+   * ```tsx [2]
+   * <Await resolve={reviewsPromise}>
+   *   <Reviews />
+   * </Await>
+   *
+   * function Reviews() {
+   *   const resolvedReviews = useAsyncValue();
+   *   return <div>...</div>;
+   * }
+   * ```
+   */
+  children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
+  /**
+   * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+   * rejects.
+   *
+   * ```tsx
+   * <Await
+   *   errorElement={<div>Oops</div>}
+   *   resolve={reviewsPromise}
+   * >
+   *   <Reviews />
+   * </Await>
+   * ```
+   *
+   * To provide a more contextual error, you can use the {@link useAsyncError} in a
+   * child component
+   *
+   * ```tsx
+   * <Await
+   *   errorElement={<ReviewsError />}
+   *   resolve={reviewsPromise}
+   * >
+   *   <Reviews />
+   * </Await>
+   *
+   * function ReviewsError() {
+   *   const error = useAsyncError();
+   *   return <div>Error loading reviews: {error.message}</div>;
+   * }
+   * ```
+   *
+   * If you do not provide an `errorElement`, the rejected value will bubble up
+   * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
+   * and be accessible via the {@link useRouteError} hook.
+   */
+  errorElement?: React.ReactNode;
+  /**
+   * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+   * returned from a [`loader`](../../start/framework/route-module#loader) to be
+   * resolved and rendered.
+   *
+   * ```tsx
+   * import { Await, useLoaderData } from "react-router";
+   *
+   * export async function loader() {
+   *   let reviews = getReviews(); // not awaited
+   *   let book = await getBook();
+   *   return {
+   *     book,
+   *     reviews, // this is a promise
+   *   };
+   * }
+   *
+   * export default function Book() {
+   *   const {
+   *     book,
+   *     reviews, // this is the same promise
+   *   } = useLoaderData();
+   *
+   *   return (
+   *     <div>
+   *       <h1>{book.title}</h1>
+   *       <p>{book.description}</p>
+   *       <React.Suspense fallback={<ReviewsSkeleton />}>
+   *         <Await
+   *           // and is the promise we pass to Await
+   *           resolve={reviews}
+   *         >
+   *           <Reviews />
+   *         </Await>
+   *       </React.Suspense>
+   *     </div>
+   *   );
+   * }
+   * ```
+   */
+  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";
+ *
+ * export async function loader() {
+ *   // not awaited
+ *   const reviews = getReviews();
+ *   // awaited (blocks the transition)
+ *   const book = await fetch("/api/book").then((res) => res.json());
+ *   return { book, reviews };
+ * }
+ *
+ * function Book() {
+ *   const { book, reviews } = useLoaderData();
+ *   return (
+ *     <div>
+ *       <h1>{book.title}</h1>
+ *       <p>{book.description}</p>
+ *       <React.Suspense fallback={<ReviewsSkeleton />}>
+ *         <Await
+ *           resolve={reviews}
+ *           errorElement={
+ *             <div>Could not load reviews 😬</div>
+ *           }
+ *           children={(resolvedReviews) => (
+ *             <Reviews items={resolvedReviews} />
+ *           )}
+ *         />
+ *       </React.Suspense>
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Components
+ * @mode framework
+ * @mode data
+ * @param props Props
+ * @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>(props: AwaitProps<Resolve> | AwaitPromiseProps<Resolve>): React.JSX.Element;
+//#endregion
 //#region lib/router/instrumentation.d.ts
 type ServerInstrumentation = {
   handler?: InstrumentRequestHandlerFunction;
@@ -1390,6 +1615,8 @@ type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "e
  * Future flags to toggle new feature behavior
  */
 interface FutureConfig {
+  /** @internal Enables application-controlled Framework route discovery. */
+  unstable_customRouteDiscovery?: boolean;
   /** Enables route-pattern matching after calling `unstable_preloadRoutePattern()`. */
   unstable_routePatternMatching?: boolean;
 }
@@ -1435,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
@@ -1536,6 +1765,10 @@ type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
   replace?: boolean;
   state?: any;
   fromRouteId?: string;
+  /**
+   * @deprecated Use React's `<ViewTransition>` component instead. See the
+   * [migration guide](https://reactrouter.com/how-to/view-transitions).
+   */
   viewTransition?: boolean;
   mask?: To;
 };
@@ -2087,168 +2320,6 @@ type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
  */
 type RouteHandle = unknown;
 //#endregion
-//#region lib/components.d.ts
-interface AwaitResolveRenderFunction<Resolve = any> {
-  (data: Awaited<Resolve>): React.ReactNode;
-}
-/**
- * @category Types
- */
-interface AwaitProps<Resolve> {
-  /**
-   * When using a function, the resolved value is provided as the parameter.
-   *
-   * ```tsx [2]
-   * <Await resolve={reviewsPromise}>
-   *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
-   * </Await>
-   * ```
-   *
-   * When using React elements, {@link useAsyncValue} will provide the
-   * resolved value:
-   *
-   * ```tsx [2]
-   * <Await resolve={reviewsPromise}>
-   *   <Reviews />
-   * </Await>
-   *
-   * function Reviews() {
-   *   const resolvedReviews = useAsyncValue();
-   *   return <div>...</div>;
-   * }
-   * ```
-   */
-  children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
-  /**
-   * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-   * rejects.
-   *
-   * ```tsx
-   * <Await
-   *   errorElement={<div>Oops</div>}
-   *   resolve={reviewsPromise}
-   * >
-   *   <Reviews />
-   * </Await>
-   * ```
-   *
-   * To provide a more contextual error, you can use the {@link useAsyncError} in a
-   * child component
-   *
-   * ```tsx
-   * <Await
-   *   errorElement={<ReviewsError />}
-   *   resolve={reviewsPromise}
-   * >
-   *   <Reviews />
-   * </Await>
-   *
-   * function ReviewsError() {
-   *   const error = useAsyncError();
-   *   return <div>Error loading reviews: {error.message}</div>;
-   * }
-   * ```
-   *
-   * If you do not provide an `errorElement`, the rejected value will bubble up
-   * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
-   * and be accessible via the {@link useRouteError} hook.
-   */
-  errorElement?: React.ReactNode;
-  /**
-   * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-   * returned from a [`loader`](../../start/framework/route-module#loader) to be
-   * resolved and rendered.
-   *
-   * ```tsx
-   * import { Await, useLoaderData } from "react-router";
-   *
-   * export async function loader() {
-   *   let reviews = getReviews(); // not awaited
-   *   let book = await getBook();
-   *   return {
-   *     book,
-   *     reviews, // this is a promise
-   *   };
-   * }
-   *
-   * export default function Book() {
-   *   const {
-   *     book,
-   *     reviews, // this is the same promise
-   *   } = useLoaderData();
-   *
-   *   return (
-   *     <div>
-   *       <h1>{book.title}</h1>
-   *       <p>{book.description}</p>
-   *       <React.Suspense fallback={<ReviewsSkeleton />}>
-   *         <Await
-   *           // and is the promise we pass to Await
-   *           resolve={reviews}
-   *         >
-   *           <Reviews />
-   *         </Await>
-   *       </React.Suspense>
-   *     </div>
-   *   );
-   * }
-   * ```
-   */
-  resolve: 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)
- *
- * @example
- * import { Await, useLoaderData } from "react-router";
- *
- * export async function loader() {
- *   // not awaited
- *   const reviews = getReviews();
- *   // awaited (blocks the transition)
- *   const book = await fetch("/api/book").then((res) => res.json());
- *   return { book, reviews };
- * }
- *
- * function Book() {
- *   const { book, reviews } = useLoaderData();
- *   return (
- *     <div>
- *       <h1>{book.title}</h1>
- *       <p>{book.description}</p>
- *       <React.Suspense fallback={<ReviewsSkeleton />}>
- *         <Await
- *           resolve={reviews}
- *           errorElement={
- *             <div>Could not load reviews 😬</div>
- *           }
- *           children={(resolvedReviews) => (
- *             <Reviews items={resolvedReviews} />
- *           )}
- *         />
- *       </React.Suspense>
- *     </div>
- *   );
- * }
- *
- * @public
- * @category Components
- * @mode framework
- * @mode data
- * @param props Props
- * @param {AwaitProps.children} props.children n/a
- * @param {AwaitProps.errorElement} props.errorElement n/a
- * @param {AwaitProps.resolve} props.resolve n/a
- * @returns React element for the rendered awaited value
- */
-declare function Await$1<Resolve>({
-  children,
-  errorElement,
-  resolve
-}: AwaitProps<Resolve>): React.JSX.Element;
-//#endregion
 //#region lib/rsc/server.rsc.d.ts
 declare function getRequest(): Request;
 declare const redirect: typeof redirect$1;
@@ -2267,6 +2338,7 @@ type RSCRouteConfigEntryBase = {
   links?: LinksFunction;
   loader?: LoaderFunction;
   meta?: MetaFunction;
+  middleware?: MiddlewareFunction<any>[];
   shouldRevalidate?: ShouldRevalidateFunction;
 };
 type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
@@ -2452,7 +2524,7 @@ declare function matchRSCServerRequest({
   onError,
   request,
   routes,
-  generateResponse
+  generateResponse: encodeResponse
 }: {
   allowedActionOrigins?: string[];
   createTemporaryReferenceSet: () => unknown;