react-router 8.3.1 → 8.5.0

package/dist/development/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";
@@ -50,7 +51,7 @@ interface Path {
  * An entry in a history stack. A location contains information about the
  * URL path, as well as possibly some arbitrary state and a key.
  */
-interface Location<State = any> extends Path {
+interface Location$1<State = any> extends Path {
   /**
    * A value of arbitrary data associated with this location.
    */
@@ -79,7 +80,7 @@ interface Update {
   /**
    * The new location.
    */
-  location: Location;
+  location: Location$1;
   /**
    * The delta between this location and the former location in the history stack
    */
@@ -113,7 +114,7 @@ interface History {
   /**
    * The current location. This value is mutable.
    */
-  readonly location: Location;
+  readonly location: Location$1;
   /**
    * Returns a valid href for the given `to` value that may be used as
    * the value of an <a href> attribute.
@@ -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;
 }
@@ -597,7 +618,7 @@ interface MapRoutePropertiesFunction {
  * onto the route. Either they're meaningful to the router, or they'll get
  * ignored.
  */
-type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children" | "unstable_validateParams";
 /**
  * Keys we cannot change from within a lazy() function. We spread all other keys
  * onto the route. Either they're meaningful to the router, or they'll get
@@ -655,6 +676,11 @@ type BaseRouteObject = {
    * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
    */
   shouldRevalidate?: ShouldRevalidateFunction;
+  /**
+   * A map of route param names to regular expressions used to validate params
+   * after a route-pattern match.
+   */
+  unstable_validateParams?: Record<string, RegExp>;
   /**
    * The route handle.
    */
@@ -791,7 +817,7 @@ interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}
  * Defaults to `/`.
  * @returns An array of matched routes, or `null` if no matches were found.
  */
-declare function matchRoutes<RouteObjectType extends RouteObject = RouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): RouteMatch<string, RouteObjectType>[] | null;
+declare function matchRoutes<RouteObjectType extends RouteObject = RouteObject>(routes: RouteObjectType[], locationArg: Partial<Location$1> | string, basename?: string): RouteMatch<string, RouteObjectType>[] | null;
 interface UIMatch<Data = unknown, Handle = unknown> {
   id: string;
   pathname: string;
@@ -998,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;
@@ -1143,9 +1624,10 @@ interface Router$1 {
    * @private
    * PRIVATE - DO NOT USE
    *
-   * Return the route branches for this router instance
+   * Match routes against a location using the router's configured route
+   * matching implementation.
    */
-  get branches(): RouteBranch<DataRouteObject>[] | undefined;
+  match(locationArg: Partial<Location$1> | string): DataRouteMatch[] | null;
   /**
    * @private
    * PRIVATE - DO NOT USE
@@ -1230,7 +1712,7 @@ interface Router$1 {
    * Utility function to create an href for the given location
    * @param location
    */
-  createHref(location: Location | URL): string;
+  createHref(location: Location$1 | URL): string;
   /**
    * @private
    * PRIVATE - DO NOT USE
@@ -1346,7 +1828,7 @@ interface RouterState {
   /**
    * The current location reflected by the router
    */
-  location: Location;
+  location: Location$1;
   /**
    * The current set of route matches
    */
@@ -1407,7 +1889,12 @@ type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "e
 /**
  * Future flags to toggle new feature behavior
  */
-interface FutureConfig {}
+interface FutureConfig {
+  /** @internal Enables application-controlled Framework route discovery. */
+  unstable_customRouteDiscovery?: boolean;
+  /** Enables route-pattern matching after calling `unstable_preloadRoutePattern()`. */
+  unstable_routePatternMatching?: boolean;
+}
 /**
  * Initialization options for createRouter
  */
@@ -1439,6 +1926,8 @@ interface StaticHandlerContext {
   loaderHeaders: Record<string, Headers>;
   actionHeaders: Record<string, Headers>;
   _deepestRenderedBoundaryId?: string | null;
+  /** @private */
+  _match: StaticHandler["match"];
 }
 /**
  * A StaticHandler instance manages a singular SSR navigation/fetch event
@@ -1452,10 +1941,10 @@ interface StaticHandler {
    * @private
    * PRIVATE - DO NOT USE
    *
-   * The route branches derived from the data routes, used for internal route
-   * matching in Framework Mode
+   * Match routes against a location using the handler's configured route
+   * matching implementation.
    */
-  _internalRouteBranches: RouteBranch<DataRouteObject>[];
+  match(locationArg: Partial<Location$1> | string): DataRouteMatch[] | null;
   /**
    * Perform a query for a given request - executing all matched route
    * loaders/actions.  Used for document requests.
@@ -1503,8 +1992,8 @@ interface StaticHandler {
   }): Promise<any>;
 }
 type ViewTransitionOpts = {
-  currentLocation: Location;
-  nextLocation: Location;
+  currentLocation: Location$1;
+  nextLocation: Location$1;
 };
 /**
  * Subscriber function signature for changes to router state
@@ -1522,7 +2011,7 @@ interface RouterSubscriber {
  * for a given location
  */
 interface GetScrollRestorationKeyFunction {
-  (location: Location, matches: UIMatch[]): string | null;
+  (location: Location$1, matches: UIMatch[]): string | null;
 }
 /**
  * Function signature for determining the current scroll position
@@ -1549,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;
 };
@@ -1604,7 +2097,7 @@ type NavigationStates = {
   };
   Loading: {
     state: "loading";
-    location: Location;
+    location: Location$1;
     matches: DataRouteMatch[];
     historyAction: Action;
     formMethod: Submission["formMethod"] | undefined;
@@ -1616,7 +2109,7 @@ type NavigationStates = {
   };
   Submitting: {
     state: "submitting";
-    location: Location;
+    location: Location$1;
     matches: DataRouteMatch[];
     historyAction: Action;
     formMethod: Submission["formMethod"];
@@ -1706,7 +2199,7 @@ interface BlockerBlocked {
   state: "blocked";
   reset: () => void;
   proceed: () => void;
-  location: Location;
+  location: Location$1;
 }
 interface BlockerUnblocked {
   state: "unblocked";
@@ -1718,12 +2211,12 @@ interface BlockerProceeding {
   state: "proceeding";
   reset: undefined;
   proceed: undefined;
-  location: Location;
+  location: Location$1;
 }
 type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
 type BlockerFunction = (args: {
-  currentLocation: Location;
-  nextLocation: Location;
+  currentLocation: Location$1;
+  nextLocation: Location$1;
   historyAction: Action;
 }) => boolean;
 interface CreateStaticHandlerOptions {
@@ -1764,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>);
@@ -1951,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
  */
@@ -1973,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;
@@ -1986,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.
@@ -2008,7 +2573,7 @@ type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoad
 interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
   loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
   params: Params;
-  location: Location;
+  location: Location$1;
   matches: MetaMatches<MatchLoaders>;
   error?: unknown;
 }
@@ -2093,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.
  *
@@ -2100,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;
@@ -2280,6 +2684,7 @@ type RSCRouteConfigEntryBase = {
   links?: LinksFunction;
   loader?: LoaderFunction;
   meta?: MetaFunction;
+  middleware?: MiddlewareFunction<any>[];
   shouldRevalidate?: ShouldRevalidateFunction;
 };
 type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
@@ -2329,7 +2734,7 @@ type RSCRenderPayload = {
   clientVersion?: string;
   errors: Record<string, any> | null;
   loaderData: Record<string, any>;
-  location: Location;
+  location: Location$1;
   routeDiscovery: RouteDiscovery;
   matches: RSCRouteMatch[];
   patches?: Promise<RSCRouteManifest[]>;
@@ -2377,6 +2782,13 @@ type RouteDiscovery = {
  * encoding an {@link unstable_RSCPayload} for consumption by an [RSC](https://react.dev/reference/rsc/server-components)
  * enabled client router.
  *
+ * Treat every React Server Function as a public endpoint. Server Functions are
+ * not inherently associated with a route. Any route middleware that runs is
+ * selected from the URL used to call a Server Function, but the client controls
+ * both the Server Function identifier and the URL. Perform all access control
+ * checks within each Server Function, or use a route action for
+ * middleware-driven access control.
+ *
  * @example
  * import {
  *   createTemporaryReferenceSet,
@@ -2458,7 +2870,7 @@ declare function matchRSCServerRequest({
   onError,
   request,
   routes,
-  generateResponse
+  generateResponse: encodeResponse
 }: {
   allowedActionOrigins?: string[];
   createTemporaryReferenceSet: () => unknown;