react-router 8.4.0 → 8.5.0

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

@@ -1,5 +1,6 @@
 
 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";
@@ -556,6 +557,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 +569,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;
 }
@@ -816,6 +837,30 @@ 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;
@@ -979,6 +1024,461 @@ 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;
+}
+/**
+ * @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/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;
+}
+//#endregion
 //#region lib/router/instrumentation.d.ts
 type ServerInstrumentation = {
   handler?: InstrumentRequestHandlerFunction;
@@ -1390,6 +1890,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;
 }
@@ -1536,6 +2038,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;
 };
@@ -1751,6 +2257,31 @@ 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>);
@@ -1938,6 +2469,36 @@ 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
  */
@@ -1960,6 +2521,10 @@ 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;
@@ -1973,6 +2538,19 @@ 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.
@@ -2080,6 +2658,7 @@ 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.
  *
@@ -2087,168 +2666,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 +2684,7 @@ type RSCRouteConfigEntryBase = {
   links?: LinksFunction;
   loader?: LoaderFunction;
   meta?: MetaFunction;
+  middleware?: MiddlewareFunction<any>[];
   shouldRevalidate?: ShouldRevalidateFunction;
 };
 type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
@@ -2452,7 +2870,7 @@ declare function matchRSCServerRequest({
   onError,
   request,
   routes,
-  generateResponse
+  generateResponse: encodeResponse
 }: {
   allowedActionOrigins?: string[];
   createTemporaryReferenceSet: () => unknown;