react-router 7.7.1 → 7.8.0-pre.1

package/dist/production/index.d.mts

@@ -1,18 +1,18 @@
-import { R as Router, y as RouteModules, D as DataStrategyFunction, T as To, z as NavigateOptions, B as BlockerFunction, E as Blocker, J as SerializeFrom, a as RelativeRoutingType, c as Location, K as ParamParseKey, O as Path, Q as PathPattern, V as PathMatch, U as UIMatch, W as Navigation, A as Action, h as Params, f as RouteObject, I as InitialEntry, H as HydrationState, b as IndexRouteObject, m as LoaderFunction, i as ActionFunction, M as MetaFunction, l as LinksFunction, N as NonIndexRouteObject, X as AppLoadContext, u as unstable_RouterContextProvider, Y as MiddlewareEnabled, Z as unstable_InitialContext, _ as Equal, e as RouterInit, $ as RouterState, P as PatchRoutesOnNavigationFunction, a0 as DataRouteObject, j as ClientLoaderFunction } from './route-data-CqEmXQub.mjs';
-export { ab as ActionFunctionArgs, C as ClientActionFunction, aH as ClientActionFunctionArgs, aI as ClientLoaderFunctionArgs, aF as DataRouteMatch, ac as DataStrategyFunctionArgs, ad as DataStrategyMatch, ae as DataStrategyResult, ag as ErrorResponse, a5 as Fetcher, ah as FormEncType, ai as FormMethod, aN as Future, a2 as GetScrollPositionFunction, a3 as GetScrollRestorationKeyFunction, aj as HTMLFormMethod, aJ as HeadersArgs, k as HeadersFunction, aM as HtmlLinkDescriptor, av as IDLE_BLOCKER, au as IDLE_FETCHER, at as IDLE_NAVIGATION, L as LazyRouteFunction, o as LinkDescriptor, ak as LoaderFunctionArgs, aK as MetaArgs, q as MetaDescriptor, a6 as NavigationStates, d as Navigator, aL as PageLinkDescriptor, aG as PatchRoutesOnNavigationFunctionArgs, am as PathParam, an as RedirectFunction, aa as RevalidationState, g as RouteMatch, a9 as RouterFetchOptions, a8 as RouterNavigateOptions, a7 as RouterSubscriber, S as ShouldRevalidateFunction, ap as ShouldRevalidateFunctionArgs, a1 as StaticHandler, a4 as StaticHandlerContext, aT as UNSAFE_DataRouterContext, aU as UNSAFE_DataRouterStateContext, af as UNSAFE_DataWithResponseInit, aS as UNSAFE_ErrorResponseImpl, aV as UNSAFE_FetchersContext, aW as UNSAFE_LocationContext, aX as UNSAFE_NavigationContext, aY as UNSAFE_RouteContext, aZ as UNSAFE_ViewTransitionContext, aP as UNSAFE_createBrowserHistory, aR as UNSAFE_createRouter, aQ as UNSAFE_invariant, ar as createPath, aw as data, ax as generatePath, ay as isRouteErrorResponse, az as matchPath, aA as matchRoutes, as as parsePath, aB as redirect, aC as redirectDocument, aD as replace, aE as resolvePath, al as unstable_MiddlewareFunction, ao as unstable_RouterContext, aO as unstable_SerializesTo, aq as unstable_createContext } from './route-data-CqEmXQub.mjs';
-import { a as RouteComponentType, H as HydrateFallbackType, E as ErrorBoundaryType } from './components-CjQijYga.mjs';
-export { f as Await, A as AwaitProps, I as IndexRouteProps, L as LayoutRouteProps, g as MemoryRouter, M as MemoryRouterOpts, b as MemoryRouterProps, h as Navigate, N as NavigateProps, i as Outlet, O as OutletProps, P as PathRouteProps, j as Route, c as RouteProps, k as Router, d as RouterProps, l as RouterProvider, R as RouterProviderProps, m as Routes, e as RoutesProps, W as UNSAFE_WithComponentProps, v as UNSAFE_WithErrorBoundaryProps, t as UNSAFE_WithHydrateFallbackProps, q as UNSAFE_hydrationRouteProperties, s as UNSAFE_mapRouteProperties, w as UNSAFE_withComponentProps, x as UNSAFE_withErrorBoundaryProps, u as UNSAFE_withHydrateFallbackProps, n as createMemoryRouter, o as createRoutesFromChildren, p as createRoutesFromElements, r as renderMatches } from './components-CjQijYga.mjs';
+import { R as Router, D as DataStrategyFunction, T as To, q as NavigateOptions, B as BlockerFunction, r as Blocker, a as RelativeRoutingType, c as Location, s as ParamParseKey, t as Path, v as PathPattern, w as PathMatch, U as UIMatch, x as Navigation, A as Action, h as Params, f as RouteObject, I as InitialEntry, H as HydrationState, b as IndexRouteObject, l as LoaderFunction, k as ActionFunction, N as NonIndexRouteObject, o as unstable_RouterContextProvider, M as MiddlewareEnabled, S as ShouldRevalidateFunction, e as RouterInit, y as RouterState, P as PatchRoutesOnNavigationFunction, z as DataRouteObject } from './context-DohQKLID.mjs';
+export { i as ActionFunctionArgs, m as DataRouteMatch, Y as DataStrategyFunctionArgs, Z as DataStrategyMatch, _ as DataStrategyResult, $ as ErrorResponse, K as Fetcher, a0 as FormEncType, a1 as FormMethod, an as Future, G as GetScrollPositionFunction, E as GetScrollRestorationKeyFunction, a2 as HTMLFormMethod, ac as IDLE_BLOCKER, ab as IDLE_FETCHER, aa as IDLE_NAVIGATION, L as LazyRouteFunction, j as LoaderFunctionArgs, O as NavigationStates, d as Navigator, am as PatchRoutesOnNavigationFunctionArgs, a3 as PathParam, a4 as RedirectFunction, X as RevalidationState, g as RouteMatch, W as RouterFetchOptions, V as RouterNavigateOptions, Q as RouterSubscriber, a6 as ShouldRevalidateFunctionArgs, C as StaticHandler, J as StaticHandlerContext, as as UNSAFE_DataRouterContext, at as UNSAFE_DataRouterStateContext, p as UNSAFE_DataWithResponseInit, ar as UNSAFE_ErrorResponseImpl, au as UNSAFE_FetchersContext, av as UNSAFE_LocationContext, aw as UNSAFE_NavigationContext, ax as UNSAFE_RouteContext, ay as UNSAFE_ViewTransitionContext, ao as UNSAFE_createBrowserHistory, aq as UNSAFE_createRouter, ap as UNSAFE_invariant, a8 as createPath, ad as data, ae as generatePath, af as isRouteErrorResponse, ag as matchPath, ah as matchRoutes, a9 as parsePath, ai as redirect, aj as redirectDocument, ak as replace, al as resolvePath, n as unstable_MiddlewareFunction, a5 as unstable_RouterContext, a7 as unstable_createContext } from './context-DohQKLID.mjs';
+import { a as RouteComponentType, H as HydrateFallbackType, E as ErrorBoundaryType } from './components-CuPfnyiZ.mjs';
+export { f as Await, A as AwaitProps, I as IndexRouteProps, L as LayoutRouteProps, g as MemoryRouter, M as MemoryRouterOpts, b as MemoryRouterProps, h as Navigate, N as NavigateProps, i as Outlet, O as OutletProps, P as PathRouteProps, j as Route, c as RouteProps, k as Router, d as RouterProps, l as RouterProvider, R as RouterProviderProps, m as Routes, e as RoutesProps, W as UNSAFE_WithComponentProps, v as UNSAFE_WithErrorBoundaryProps, t as UNSAFE_WithHydrateFallbackProps, q as UNSAFE_hydrationRouteProperties, s as UNSAFE_mapRouteProperties, w as UNSAFE_withComponentProps, x as UNSAFE_withErrorBoundaryProps, u as UNSAFE_withHydrateFallbackProps, n as createMemoryRouter, o as createRoutesFromChildren, p as createRoutesFromElements, r as renderMatches } from './components-CuPfnyiZ.mjs';
 import * as React from 'react';
 import React__default, { ReactElement } from 'react';
-import { A as AssetsManifest, E as EntryContext, F as FutureConfig, S as ServerBuild } from './index-react-server-client-KLg-U4nr.mjs';
-export { l as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, a0 as DiscoverBehavior, c as FetcherFormProps, h as FetcherSubmitFunction, G as FetcherSubmitOptions, i as FetcherWithComponents, q as Form, d as FormProps, a1 as HandleDataRequestFunction, a2 as HandleDocumentRequestFunction, a3 as HandleErrorFunction, m as HashRouter, H as HashRouterProps, a as HistoryRouterProps, n as Link, L as LinkProps, X as Links, W as Meta, p as NavLink, N as NavLinkProps, b as NavLinkRenderProps, P as ParamKeyValuePair, $ as PrefetchBehavior, Z as PrefetchPageLinks, Y as Scripts, _ as ScriptsProps, r as ScrollRestoration, e as ScrollRestorationProps, a4 as ServerEntryModule, f as SetURLSearchParams, T as StaticRouter, M as StaticRouterProps, V as StaticRouterProvider, O as StaticRouterProviderProps, g as SubmitFunction, I as SubmitOptions, J as SubmitTarget, a5 as UNSAFE_FrameworkContext, a6 as UNSAFE_createClientRoutes, a7 as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, a8 as UNSAFE_shouldHydrateRouteLoader, a9 as UNSAFE_useScrollRestoration, U as URLSearchParamsInit, j as createBrowserRouter, k as createHashRouter, K as createSearchParams, Q as createStaticHandler, R as createStaticRouter, o as unstable_HistoryRouter, z as unstable_usePrompt, y as useBeforeUnload, w as useFetcher, x as useFetchers, v as useFormAction, u as useLinkClickHandler, s as useSearchParams, t as useSubmit, C as useViewTransitionState } from './index-react-server-client-KLg-U4nr.mjs';
+import { c as RouteModules, d as SerializeFrom, e as MetaFunction, f as LinksFunction, A as AppLoadContext, E as Equal, g as ClientActionFunction, h as ClientLoaderFunction, H as HeadersFunction } from './route-data-CpB5xtMm.mjs';
+export { i as ClientActionFunctionArgs, j as ClientLoaderFunctionArgs, k as HeadersArgs, n as HtmlLinkDescriptor, L as LinkDescriptor, l as MetaArgs, M as MetaDescriptor, m as PageLinkDescriptor, u as unstable_SerializesTo } from './route-data-CpB5xtMm.mjs';
+import { A as AssetsManifest, E as EntryContext, F as FutureConfig, S as ServerBuild } from './index-react-server-client-CuajY2vy.mjs';
+export { l as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, a1 as DiscoverBehavior, c as FetcherFormProps, h as FetcherSubmitFunction, G as FetcherSubmitOptions, i as FetcherWithComponents, q as Form, d as FormProps, a2 as HandleDataRequestFunction, a3 as HandleDocumentRequestFunction, a4 as HandleErrorFunction, m as HashRouter, H as HashRouterProps, a as HistoryRouterProps, n as Link, L as LinkProps, X as Links, _ as LinksProps, W as Meta, p as NavLink, N as NavLinkProps, b as NavLinkRenderProps, P as ParamKeyValuePair, a0 as PrefetchBehavior, Z as PrefetchPageLinks, Y as Scripts, $ as ScriptsProps, r as ScrollRestoration, e as ScrollRestorationProps, a5 as ServerEntryModule, f as SetURLSearchParams, T as StaticRouter, M as StaticRouterProps, V as StaticRouterProvider, O as StaticRouterProviderProps, g as SubmitFunction, I as SubmitOptions, J as SubmitTarget, a6 as UNSAFE_FrameworkContext, a7 as UNSAFE_createClientRoutes, a8 as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, a9 as UNSAFE_shouldHydrateRouteLoader, aa as UNSAFE_useScrollRestoration, U as URLSearchParamsInit, j as createBrowserRouter, k as createHashRouter, K as createSearchParams, Q as createStaticHandler, R as createStaticRouter, o as unstable_HistoryRouter, z as unstable_usePrompt, y as useBeforeUnload, w as useFetcher, x as useFetchers, v as useFormAction, u as useLinkClickHandler, s as useSearchParams, t as useSubmit, C as useViewTransitionState } from './index-react-server-client-CuajY2vy.mjs';
 import { ParseOptions, SerializeOptions } from 'cookie';
 export { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions } from 'cookie';
 import { P as Pages } from './register-DiOIlEq5.mjs';
 export { a as Register } from './register-DiOIlEq5.mjs';
-import { R as RSCPayload, m as matchRSCServerRequest } from './browser-7LYX59NK.mjs';
-export { D as unstable_DecodeActionFunction, a as unstable_DecodeFormStateFunction, b as unstable_DecodeReplyFunction, L as unstable_LoadServerActionFunction, c as unstable_RSCManifestPayload, d as unstable_RSCMatch, e as unstable_RSCRenderPayload, j as unstable_RSCRouteConfig, i as unstable_RSCRouteConfigEntry, f as unstable_RSCRouteManifest, h as unstable_RSCRouteMatch, g as unstable_getRSCStream } from './browser-7LYX59NK.mjs';
-import 'node:async_hooks';
+export { g as unstable_getRSCStream } from './browser-z32v5KVN.mjs';
 
 declare const SingleFetchRedirectSymbol: unique symbol;
 declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined): DataStrategyFunction;
@@ -97,7 +97,7 @@ declare function useLocation(): Location;
  *
  * @public
  * @category Hooks
- * @returns The current {@link NavigationType} type (`"PUSH"`, `"REPLACE"`, or `"POP"`)
+ * @returns The current {@link NavigationType} (`"POP"`, `"PUSH"`, or `"REPLACE"`)
  */
 declare function useNavigationType(): Action;
 /**
@@ -231,7 +231,7 @@ declare function useNavigate(): NavigateFunction;
  * Often parent routes manage state or other values you want shared with child
  * routes. You can create your own [context provider](https://react.dev/learn/passing-data-deeply-with-context)
  * if you like, but this is such a common situation that it's built-into
- * `<Outlet />`.
+ * {@link Outlet | `<Outlet>`}.
  *
  * ```tsx
  * // Parent route
@@ -243,7 +243,7 @@ declare function useNavigate(): NavigateFunction;
  *
  * ```tsx
  * // Child route
- * import { useOutletContext } from "react-router-dom";
+ * import { useOutletContext } from "react-router";
  *
  * function Child() {
  *   const [count, setCount] = useOutletContext();
@@ -252,21 +252,23 @@ declare function useNavigate(): NavigateFunction;
  * }
  * ```
  *
- * If you're using TypeScript, we recommend the parent component provide a custom
- * hook for accessing the context value. This makes it easier for consumers to
- * get nice typings, control consumers, and know who's consuming the context value.
+ * If you're using TypeScript, we recommend the parent component provide a
+ * custom hook for accessing the context value. This makes it easier for
+ * consumers to get nice typings, control consumers, and know who's consuming
+ * the context value.
  *
  * Here's a more realistic example:
  *
- * ```tsx filename=src/routes/dashboard.tsx lines=[13,19]
- * import * as React from "react";
+ * ```tsx filename=src/routes/dashboard.tsx lines=[14,20]
+ * import { useState } from "react";
+ * import { Outlet, useOutletContext } from "react-router";
+ *
  * import type { User } from "./types";
- * import { Outlet, useOutletContext } from "react-router-dom";
  *
  * type ContextType = { user: User | null };
  *
  * export default function Dashboard() {
- *   const [user, setUser] = React.useState<User | null>(null);
+ *   const [user, setUser] = useState<User | null>(null);
  *
  *   return (
  *     <div>
@@ -726,22 +728,23 @@ declare function useAsyncError(): unknown;
  *   - `blocked` - the blocker has prevented a navigation
  *   - `proceeding` - the blocker is proceeding through from a blocked navigation
  * - **`location`**
- *   - When in a `blocked` state, this represents the {@link Location} to which we
- *     blocked a navigation. When in a `proceeding` state, this is the location
- *     being navigated to after a `blocker.proceed()` call.
+ *   - When in a `blocked` state, this represents the {@link Location} to which
+ *     we blocked a navigation. When in a `proceeding` state, this is the
+ *     location being navigated to after a `blocker.proceed()` call.
  * - **`proceed()`**
- *   - When in a `blocked` state, you may call `blocker.proceed()` to proceed to the
- *     blocked location.
+ *   - When in a `blocked` state, you may call `blocker.proceed()` to proceed to
+ *     the blocked location.
  * - **`reset()`**
- *   - When in a `blocked` state, you may call `blocker.reset()` to return the blocker
- *     back to an `unblocked` state and leave the user at the current location.
+ *   - When in a `blocked` state, you may call `blocker.reset()` to return the
+ *     blocker to an `unblocked` state and leave the user at the current
+ *     location.
  *
  * @example
  * // Boolean version
- * const blocker = useBlocker(value !== "");
+ * let blocker = useBlocker(value !== "");
  *
  * // Function version
- * const blocker = useBlocker(
+ * let blocker = useBlocker(
  *   ({ currentLocation, nextLocation, historyAction }) =>
  *     value !== "" &&
  *     currentLocation.pathname !== nextLocation.pathname
@@ -823,25 +826,37 @@ declare function useAsyncError(): unknown;
  */
 declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
 
+/**
+ * @category Types
+ */
 interface ServerRouterProps {
+    /**
+     * The entry context containing the manifest, route modules, and other data
+     * needed for rendering.
+     */
     context: EntryContext;
+    /**
+     * The URL of the request being handled.
+     */
     url: string | URL;
+    /**
+     * An optional `nonce` for [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP)
+     * compliance, used to allow inline scripts to run safely.
+     */
     nonce?: string;
 }
 /**
- * The server entry point for a React Router app in Framework Mode. This component
- * is used to generate the HTML in the response from the server.
- * See [`entry.server.tsx`](../api/framework-conventions/entry.server.tsx).
+ * The server entry point for a React Router app in Framework Mode. This
+ * component is used to generate the HTML in the response from the server. See
+ * [`entry.server.tsx`](../framework-conventions/entry.server.tsx).
  *
  * @public
  * @category Framework Routers
  * @mode framework
  * @param props Props
- * @param props.context The entry context containing the manifest, route modules,
- * and other data needed for rendering.
- * @param props.url The URL of the request being handled.
- * @param props.nonce An optional nonce for Content Security Policy (CSP) compliance,
- * used to allow inline scripts to run safely.
+ * @param {ServerRouterProps.context} props.context n/a
+ * @param {ServerRouterProps.nonce} props.nonce n/a
+ * @param {ServerRouterProps.url} props.url n/a
  * @returns A React element that represents the server-rendered application.
  */
 declare function ServerRouter({ context, url, nonce, }: ServerRouterProps): ReactElement;
@@ -956,7 +971,7 @@ type IsCookieFunction = (object: any) => object is Cookie;
  */
 declare const isCookie: IsCookieFunction;
 
-type RequestHandler = (request: Request, loadContext?: MiddlewareEnabled extends true ? unstable_InitialContext : AppLoadContext) => Promise<Response>;
+type RequestHandler = (request: Request, loadContext?: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext) => Promise<Response>;
 type CreateRequestHandlerFunction = (build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>), mode?: string) => RequestHandler;
 declare const createRequestHandler: CreateRequestHandlerFunction;
 
@@ -1153,6 +1168,188 @@ type ToArgs<Params extends Record<string, string | undefined>> = Equal<Params, {
  */
 declare function href<Path extends keyof Args>(path: Path, ...args: Args[Path]): string;
 
+type RSCRouteConfigEntryBase = {
+    action?: ActionFunction;
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: React.ComponentType<any>;
+    handle?: any;
+    headers?: HeadersFunction;
+    HydrateFallback?: React.ComponentType<any>;
+    Layout?: React.ComponentType<any>;
+    links?: LinksFunction;
+    loader?: LoaderFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
+    id: string;
+    path?: string;
+    Component?: React.ComponentType<any>;
+    lazy?: () => Promise<RSCRouteConfigEntryBase & ({
+        default?: React.ComponentType<any>;
+        Component?: never;
+    } | {
+        default?: never;
+        Component?: React.ComponentType<any>;
+    })>;
+} & ({
+    index: true;
+} | {
+    children?: RSCRouteConfigEntry[];
+});
+type RSCRouteConfig = Array<RSCRouteConfigEntry>;
+type RSCRouteManifest = {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    element?: React.ReactElement | false;
+    errorElement?: React.ReactElement;
+    handle?: any;
+    hasAction: boolean;
+    hasComponent: boolean;
+    hasErrorBoundary: boolean;
+    hasLoader: boolean;
+    hydrateFallbackElement?: React.ReactElement;
+    id: string;
+    index?: boolean;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    parentId?: string;
+    path?: string;
+    shouldRevalidate?: ShouldRevalidateFunction;
+};
+type RSCRouteMatch = RSCRouteManifest & {
+    params: Params;
+    pathname: string;
+    pathnameBase: string;
+};
+type RSCRenderPayload = {
+    type: "render";
+    actionData: Record<string, any> | null;
+    basename: string | undefined;
+    errors: Record<string, any> | null;
+    loaderData: Record<string, any>;
+    location: Location;
+    matches: RSCRouteMatch[];
+    patches?: RSCRouteManifest[];
+    nonce?: string;
+    formState?: unknown;
+};
+type RSCManifestPayload = {
+    type: "manifest";
+    patches: RSCRouteManifest[];
+};
+type RSCActionPayload = {
+    type: "action";
+    actionResult: Promise<unknown>;
+    rerender?: Promise<RSCRenderPayload | RSCRedirectPayload>;
+};
+type RSCRedirectPayload = {
+    type: "redirect";
+    status: number;
+    location: string;
+    replace: boolean;
+    reload: boolean;
+    actionResult?: Promise<unknown>;
+};
+type RSCPayload = RSCRenderPayload | RSCManifestPayload | RSCActionPayload | RSCRedirectPayload;
+type RSCMatch = {
+    statusCode: number;
+    headers: Headers;
+    payload: RSCPayload;
+};
+type DecodeActionFunction = (formData: FormData) => Promise<() => Promise<unknown>>;
+type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
+type DecodeReplyFunction = (reply: FormData | string, { temporaryReferences }: {
+    temporaryReferences: unknown;
+}) => Promise<unknown[]>;
+type LoadServerActionFunction = (id: string) => Promise<Function>;
+/**
+ * Matches the given routes to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ * and returns an [RSC](https://react.dev/reference/rsc/server-components)
+ * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * encoding an {@link unstable_RSCPayload} for consumption by an [RSC](https://react.dev/reference/rsc/server-components)
+ * enabled client router.
+ *
+ * @example
+ * import {
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeReply,
+ *   loadServerAction,
+ *   renderToReadableStream,
+ * } from "@vitejs/plugin-rsc/rsc";
+ * import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
+ *
+ * matchRSCServerRequest({
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeFormState,
+ *   decodeReply,
+ *   loadServerAction,
+ *   request,
+ *   routes: routes(),
+ *   generateResponse(match) {
+ *     return new Response(
+ *       renderToReadableStream(match.payload),
+ *       {
+ *         status: match.statusCode,
+ *         headers: match.headers,
+ *       }
+ *     );
+ *   },
+ * });
+ *
+ * @name unstable_matchRSCServerRequest
+ * @public
+ * @category RSC
+ * @mode data
+ * @param opts Options
+ * @param opts.basename The basename to use when matching the request.
+ * @param opts.createTemporaryReferenceSet A function that returns a temporary
+ * reference set for the request, used to track temporary references in the [RSC](https://react.dev/reference/rsc/server-components)
+ * stream.
+ * @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
+ * function, responsible for loading a server action.
+ * @param opts.decodeFormState A function responsible for decoding form state for
+ * progressively enhanceable forms with React's [`useActionState`](https://react.dev/reference/react/useActionState)
+ * using your `react-server-dom-xyz/server`'s `decodeFormState`.
+ * @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
+ * function, used to decode the server function's arguments and bind them to the
+ * implementation for invocation by the router.
+ * @param opts.generateResponse A function responsible for using your
+ * `renderToReadableStream` to generate a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * encoding the {@link unstable_RSCPayload}.
+ * @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
+ * `loadServerAction` function, used to load a server action by ID.
+ * @param opts.onError An optional error handler that will be called with any
+ * errors that occur during the request processing.
+ * @param opts.request The [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ * to match against.
+ * @param opts.requestContext An instance of {@link unstable_RouterContextProvider}
+ * that should be created per request, to be passed to [`action`](../../start/data/route-object#action)s,
+ * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
+ * @param opts.routes Your {@link unstable_RSCRouteConfigEntry | route definitions}.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that contains the [RSC](https://react.dev/reference/rsc/server-components)
+ * data for hydration.
+ */
+declare function matchRSCServerRequest({ createTemporaryReferenceSet, basename, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
+    createTemporaryReferenceSet: () => unknown;
+    basename?: string;
+    decodeReply?: DecodeReplyFunction;
+    decodeAction?: DecodeActionFunction;
+    decodeFormState?: DecodeFormStateFunction;
+    requestContext?: unstable_RouterContextProvider;
+    loadServerAction?: LoadServerActionFunction;
+    onError?: (error: unknown) => void;
+    request: Request;
+    routes: RSCRouteConfigEntry[];
+    generateResponse: (match: RSCMatch, { temporaryReferences, }: {
+        temporaryReferences: unknown;
+    }) => Response;
+}): Promise<Response>;
+
 type BrowserCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>, { temporaryReferences, }: {
     temporaryReferences: unknown;
 }) => Promise<unknown>;
@@ -1187,10 +1384,12 @@ type EncodeReplyFunction = (args: unknown[], options: {
  * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
  * `createFromReadableStream`. Used to decode payloads from the server.
  * @param opts.createTemporaryReferenceSet A function that creates a temporary
- * reference set for the RSC payload.
+ * reference set for the [RSC](https://react.dev/reference/rsc/server-components)
+ * payload.
  * @param opts.encodeReply Your `react-server-dom-xyz/client`'s `encodeReply`.
  * Used when sending payloads to the server.
- * @param opts.fetch Optional fetch implementation. Defaults to global `fetch`.
+ * @param opts.fetch Optional [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
+ * implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
  * @returns A function that can be used to call server actions.
  */
 declare function createCallServer({ createFromReadableStream, createTemporaryReferenceSet, encodeReply, fetch: fetchImplementation, }: {
@@ -1200,8 +1399,10 @@ declare function createCallServer({ createFromReadableStream, createTemporaryRef
     fetch?: (request: Request) => Promise<Response>;
 }): (id: string, args: unknown[]) => Promise<unknown>;
 /**
- * Props for the `unstable_RSCHydratedRouter` component.
+ * Props for the {@link unstable_RSCHydratedRouter} component.
+ *
  * @name unstable_RSCHydratedRouterProps
+ * @category Types
  */
 interface RSCHydratedRouterProps {
     /**
@@ -1210,27 +1411,29 @@ interface RSCHydratedRouterProps {
      */
     createFromReadableStream: BrowserCreateFromReadableStreamFunction;
     /**
-     * Optional fetch implementation.  Defaults to global `fetch`.
+     * Optional fetch implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
      */
     fetch?: (request: Request) => Promise<Response>;
     /**
-     * The decoded `RSCPayload` to hydrate.
+     * The decoded {@link unstable_RSCPayload} to hydrate.
      */
     payload: RSCPayload;
     /**
-     * `eager` or `lazy` - Determines if links are eagerly discovered, or delayed
-     * until clicked.
+     * `"eager"` or `"lazy"` - Determines if links are eagerly discovered, or
+     * delayed until clicked.
      */
     routeDiscovery?: "eager" | "lazy";
     /**
-     * A function that returns an `unstable_InitialContext` object
-     * (`Map<RouterContext, unknown>`), for use in client loaders, actions and
-     * middleware.
+     * A function that returns an {@link unstable_RouterContextProvider} instance
+     * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
+     * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
+     * This function is called to generate a fresh `context` instance on each
+     * navigation or fetcher call.
      */
     unstable_getContext?: RouterInit["unstable_getContext"];
 }
 /**
- * Hydrates a server rendered `RSCPayload` in the browser.
+ * Hydrates a server rendered {@link unstable_RSCPayload} in the browser.
  *
  * @example
  * import { startTransition, StrictMode } from "react";
@@ -1241,25 +1444,19 @@ interface RSCHydratedRouterProps {
  * } from "react-router";
  * import type { unstable_RSCPayload as RSCPayload } from "react-router";
  *
- * createFromReadableStream(getRSCStream()).then(
- *   (payload: RSCServerPayload) => {
- *     startTransition(async () => {
- *       hydrateRoot(
- *         document,
- *         <StrictMode>
- *           <RSCHydratedRouter
- *             createFromReadableStream={
- *               createFromReadableStream
- *             }
- *             payload={payload}
- *           />
- *         </StrictMode>,
- *         {
- *           formState: await getFormState(payload),
- *         }
- *       );
- *     });
- *   }
+ * createFromReadableStream(getRSCStream()).then((payload) =>
+ *   startTransition(async () => {
+ *     hydrateRoot(
+ *       document,
+ *       <StrictMode>
+ *         <RSCHydratedRouter
+ *           createFromReadableStream={createFromReadableStream}
+ *           payload={payload}
+ *         />
+ *       </StrictMode>,
+ *       { formState: await getFormState(payload) },
+ *     );
+ *   }),
  * );
  *
  * @name unstable_RSCHydratedRouter
@@ -1269,18 +1466,20 @@ interface RSCHydratedRouterProps {
  * @param props Props
  * @param {unstable_RSCHydratedRouterProps.createFromReadableStream} props.createFromReadableStream n/a
  * @param {unstable_RSCHydratedRouterProps.fetch} props.fetch n/a
+ * @param {unstable_RSCHydratedRouterProps.unstable_getContext} props.unstable_getContext n/a
  * @param {unstable_RSCHydratedRouterProps.payload} props.payload n/a
  * @param {unstable_RSCHydratedRouterProps.routeDiscovery} props.routeDiscovery n/a
- * @param {unstable_RSCHydratedRouterProps.unstable_getContext} props.unstable_getContext n/a
- * @returns A hydrated router that can be used to navigate and render routes.
+ * @returns A hydrated {@link DataRouter} that can be used to navigate and
+ * render routes.
  */
 declare function RSCHydratedRouter({ createFromReadableStream, fetch: fetchImplementation, payload, routeDiscovery, unstable_getContext, }: RSCHydratedRouterProps): React.JSX.Element;
 
 type SSRCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>) => Promise<unknown>;
 /**
- * Routes the incoming request to the RSC server and appropriately proxies the
- * server response for data / resource requests, or renders to HTML for a document
- * request.
+ * Routes the incoming [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ * to the [RSC](https://react.dev/reference/rsc/server-components) server and
+ * appropriately proxies the server response for data / resource requests, or
+ * renders to HTML for a document request.
  *
  * @example
  * import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
@@ -1314,15 +1513,17 @@ type SSRCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>) =>
  * @param opts Options
  * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
  * `createFromReadableStream` function, used to decode payloads from the server.
- * @param opts.fetchServer A function that forwards a `Request` to the RSC handler
- * and returns a `Promise<Response>` containing a serialized `RSCPayload`.
- * @param opts.renderHTML A function that renders the `RSCPayload` to HTML, usually
- * using a `<RSCStaticRouter>`.
- * @param opts.request The request to route.
+ * @param opts.fetchServer A function that forwards a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ * to the [RSC](https://react.dev/reference/rsc/server-components) handler
+ * and returns a `Promise<Response>` containing a serialized {@link unstable_RSCPayload}.
  * @param opts.hydrate Whether to hydrate the server response with the RSC payload.
  * Defaults to `true`.
- * @returns A `Response` that either contains the RSC payload for data requests, or
- * renders the HTML for document requests.
+ * @param opts.renderHTML A function that renders the {@link unstable_RSCPayload} to
+ * HTML, usually using a {@link unstable_RSCStaticRouter | `<RSCStaticRouter>`}.
+ * @param opts.request The request to route.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that either contains the [RSC](https://react.dev/reference/rsc/server-components)
+ * payload for data requests, or renders the HTML for document requests.
  */
 declare function routeRSCServerRequest({ request, fetchServer, createFromReadableStream, renderHTML, hydrate, }: {
     request: Request;
@@ -1332,19 +1533,21 @@ declare function routeRSCServerRequest({ request, fetchServer, createFromReadabl
     hydrate?: boolean;
 }): Promise<Response>;
 /**
- * Props for the `RSCStaticRouter` component.
+ * Props for the {@link unstable_RSCStaticRouter} component.
+ *
  * @name unstable_RSCStaticRouterProps
+ * @category Types
  */
 interface RSCStaticRouterProps {
     /**
-     * A function that starts decoding of the `RSCPayload`. Usually passed through
-     * from `routeRSCServerRequest`'s `renderHTML`.
+     * A function that starts decoding of the {@link unstable_RSCPayload}. Usually passed
+     * through from {@link unstable_routeRSCServerRequest}'s `renderHTML`.
      */
     getPayload: () => Promise<RSCPayload>;
 }
 /**
- * Pre-renders an `RSCPayload` to HTML. Usually used in `routeRSCServerRequest`'s
- * `renderHTML` callback.
+ * Pre-renders an {@link unstable_RSCPayload} to HTML. Usually used in
+ * {@link unstable_routeRSCServerRequest}'s `renderHTML` callback.
  *
  * @example
  * import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
@@ -1377,7 +1580,7 @@ interface RSCStaticRouterProps {
  * @mode data
  * @param props Props
  * @param {unstable_RSCStaticRouterProps.getPayload} props.getPayload n/a
- * @returns A React component that renders the `RSCPayload` as HTML.
+ * @returns A React component that renders the {@link unstable_RSCPayload} as HTML.
  */
 declare function RSCStaticRouter({ getPayload }: RSCStaticRouterProps): React.JSX.Element | null;
 
@@ -1421,6 +1624,11 @@ declare function getHydrationData(state: {
     hasHydrateFallback: boolean;
 }, location: Path, basename: string | undefined, isSpaMode: boolean): HydrationState;
 
+/**
+ * @module index
+ * @mergeModuleWith react-router
+ */
+
 declare const unstable_matchRSCServerRequest: typeof matchRSCServerRequest;
 
-export { ActionFunction, AppLoadContext, Blocker, BlockerFunction, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, DataRouteObject, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, RelativeRoutingType, type RequestHandler, RouteObject, RouterInit, RouterState, type RoutesTestStubProps, ServerBuild, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RSCDefaultRootErrorBoundary as UNSAFE_RSCDefaultRootErrorBoundary, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, href, isCookie, isSession, type BrowserCreateFromReadableStreamFunction as unstable_BrowserCreateFromReadableStreamFunction, type EncodeReplyFunction as unstable_EncodeReplyFunction, unstable_InitialContext, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCHydratedRouterProps as unstable_RSCHydratedRouterProps, RSCPayload as unstable_RSCPayload, RSCStaticRouter as unstable_RSCStaticRouter, type RSCStaticRouterProps as unstable_RSCStaticRouterProps, unstable_RouterContextProvider, type SSRCreateFromReadableStreamFunction as unstable_SSRCreateFromReadableStreamFunction, createCallServer as unstable_createCallServer, unstable_matchRSCServerRequest, routeRSCServerRequest as unstable_routeRSCServerRequest, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
+export { ActionFunction, AppLoadContext, Blocker, BlockerFunction, ClientActionFunction, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, DataRouteObject, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, HeadersFunction, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, RelativeRoutingType, type RequestHandler, RouteObject, RouterInit, RouterState, type RoutesTestStubProps, ServerBuild, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, ShouldRevalidateFunction, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RSCDefaultRootErrorBoundary as UNSAFE_RSCDefaultRootErrorBoundary, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, href, isCookie, isSession, type BrowserCreateFromReadableStreamFunction as unstable_BrowserCreateFromReadableStreamFunction, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, type EncodeReplyFunction as unstable_EncodeReplyFunction, type LoadServerActionFunction as unstable_LoadServerActionFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCHydratedRouterProps as unstable_RSCHydratedRouterProps, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCMatch as unstable_RSCMatch, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, type RSCRouteConfig as unstable_RSCRouteConfig, type RSCRouteConfigEntry as unstable_RSCRouteConfigEntry, type RSCRouteManifest as unstable_RSCRouteManifest, type RSCRouteMatch as unstable_RSCRouteMatch, RSCStaticRouter as unstable_RSCStaticRouter, type RSCStaticRouterProps as unstable_RSCStaticRouterProps, unstable_RouterContextProvider, type SSRCreateFromReadableStreamFunction as unstable_SSRCreateFromReadableStreamFunction, createCallServer as unstable_createCallServer, unstable_matchRSCServerRequest, routeRSCServerRequest as unstable_routeRSCServerRequest, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };