react-router 7.7.1 → 7.8.0-pre.0

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

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import * as React from 'react';
 export { Await, 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 { ParseOptions, SerializeOptions } from 'cookie';
@@ -228,35 +227,123 @@ type Submission = {
     json: undefined;
     text: string;
 };
+/**
+ * A context instance used as the key for the `get`/`set` methods of a
+ * {@link unstable_RouterContextProvider}. Accepts an optional default
+ * value to be returned if no value has been set.
+ */
 interface unstable_RouterContext<T = unknown> {
     defaultValue?: T;
 }
 /**
- * Creates a context object that may be used to store and retrieve arbitrary values.
+ * Creates a type-safe {@link unstable_RouterContext} object that can be used to
+ * * store and retrieve arbitrary values in [`action`](../../start/framework/route-module#action)s,
+ * * [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
+ * * Similar to React's [`createContext`](https://react.dev/reference/react/createContext),
+ * * but specifically designed for React Router's request/response lifecycle.
+ *
+ * <docs-warning>Enable this API with the `future.unstable_middleware` flag.</docs-warning>
+ *
+ * If a `defaultValue` is provided, it will be returned from `context.get()`
+ * when no value has been set for the context. Otherwise, reading this context
+ * when no value has been set will throw an error.
+ *
+ * ```tsx filename=app/context.ts
+ * import { unstable_createContext } from "react-router";
+ *
+ * // Create a context for user data
+ * export const userContext =
+ *   unstable_createContext<User | null>(null);
+ * ```
+ *
+ * ```tsx filename=app/middleware/auth.ts
+ * import { getUserFromSession } from "~/auth.server";
+ * import { userContext } from "~/context";
+ *
+ * export const authMiddleware = async ({
+ *   context,
+ *   request,
+ * }) => {
+ *   const user = await getUserFromSession(request);
+ *   context.set(userContext, user);
+ * };
+ * ```
  *
- * If a `defaultValue` is provided, it will be returned from `context.get()` when no value has been
- * set for the context. Otherwise reading this context when no value has been set will throw an
- * error.
+ * ```tsx filename=app/routes/profile.tsx
+ * import { userContext } from "~/context";
  *
- * @param defaultValue The default value for the context
- * @returns A context object
+ * export async function loader({
+ *   context,
+ * }: Route.LoaderArgs) {
+ *   const user = context.get(userContext);
+ *
+ *   if (!user) {
+ *     throw new Response("Unauthorized", { status: 401 });
+ *   }
+ *
+ *   return { user };
+ * }
+ * ```
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
+ * @param defaultValue An optional default value for the context. This value
+ * will be returned if no value has been set for this context.
+ * @returns A {@link unstable_RouterContext} object that can be used with
+ * `context.get()` and `context.set()` in [`action`](../../start/framework/route-module#action)s,
+ * [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
  */
 declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
 /**
- * A Map of RouterContext objects to their initial values - used to populate a
- * fresh `context` value per request/navigation/fetch
- */
-type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
-/**
- * Provides methods for writing/reading values in application context in a typesafe way.
+ * Provides methods for writing/reading values in application context in a
+ * type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
+ *
+ * @example
+ * import {
+ *   unstable_createContext,
+ *   unstable_RouterContextProvider
+ * } from "react-router";
+ *
+ * const userContext = unstable_createContext<User | null>(null);
+ * const contextProvider = new unstable_RouterContextProvider();
+ * contextProvider.set(userContext, getUser());
+ * const user = contextProvider.get(userContext);
+ * //    ^ User
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
  */
 declare class unstable_RouterContextProvider {
     #private;
-    constructor(init?: unstable_InitialContext);
+    /**
+     * Create a new `unstable_RouterContextProvider` instance
+     * @param init An optional initial context map to populate the provider with
+     */
+    constructor(init?: Map<unstable_RouterContext, unknown>);
+    /**
+     * Access a value from the context. If no value has been set for the context,
+     * it will return the context's `defaultValue` if provided, or throw an error
+     * if no `defaultValue` was set.
+     * @param context The context to get the value for
+     * @returns The value for the context, or the context's `defaultValue` if no
+     * value was set
+     */
     get<T>(context: unstable_RouterContext<T>): T;
+    /**
+     * Set a value for the context. If the context already has a value set, this
+     * will overwrite it.
+     *
+     * @param context The context to set the value for
+     * @param value The value to set for the context
+     * @returns {void}
+     */
     set<C extends unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
 }
-type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
+type DefaultContext = MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : any;
 /**
  * @private
  * Arguments passed to route loader/action functions.  Same for now but we keep
@@ -278,7 +365,7 @@ interface DataFunctionArgs<Context> {
      *   params.teamId;
      *   //        ^ string
      * }
-     **/
+     */
     params: Params;
     /**
      * This is the context passed in to your server adapter's getLoadContext() function.
@@ -300,7 +387,7 @@ interface unstable_MiddlewareNextFunction<Result = unknown> {
  * a `next` function as the second parameter which will call downstream handlers
  * and then complete middlewares from the bottom-up
  */
-type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<unstable_RouterContextProvider>>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -406,34 +493,39 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         route: Promise<void> | undefined;
     };
     /**
-     * A boolean value indicating whether this route handler should be called in this pass.
+     * A boolean value indicating whether this route handler should be called in
+     * this pass.
      *
-     * The `matches` array always includes _all_ matched routes even when only _some_
-     * route handlers need to be called so that things like middleware can be implemented.
+     * The `matches` array always includes _all_ matched routes even when only
+     * _some_ route handlers need to be called so that things like middleware can
+     * be implemented.
      *
-     * `shouldLoad` is usually only interesting if you are skipping the route handler
-     * entirely and implementing custom handler logic - since it lets you determine
-     * if that custom logic should run for this route or not.
+     * `shouldLoad` is usually only interesting if you are skipping the route
+     * handler entirely and implementing custom handler logic - since it lets you
+     * determine if that custom logic should run for this route or not.
      *
      * For example:
      *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
      *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
      *    will have `shouldLoad=true` because the data for `parent` and `child` is
      *    already loaded
-     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
-     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
-     *  - After the `action`, `dataStrategy` will be called again for the `loader`
-     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
-     *   `shouldRevalidate` implementations)
+     *  - If you are on `/parent/child/a` and you submit to `a`'s [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+     *    then only `a` will have `shouldLoad=true` for the action execution of
+     *    `dataStrategy`
+     *  - After the [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+     *    `dataStrategy` will be called again for the [`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no
+     *    custom `shouldRevalidate` implementations)
      */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
     /**
      * An async function that will resolve any `route.lazy` implementations and
-     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
      *
-     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     * - Calling `match.resolve` does not mean you're calling the
+     *   [`action`](https://reactrouter.com/docs/start/data/route-object#action)/[`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
      *   (the "handler") - `resolve` will only call the `handler` internally if
      *   needed _and_ if you don't pass your own `handlerOverride` function parameter
      * - It is safe to call `match.resolve` for all matches, even if they have
@@ -588,7 +680,28 @@ interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticData
 /**
  * Matches the given routes to a location and returns the match data.
  *
+ * @example
+ * import { matchRoutes } from "react-router";
+ *
+ * let routes = [{
+ *   path: "/",
+ *   Component: Root,
+ *   children: [{
+ *     path: "dashboard",
+ *     Component: Dashboard,
+ *   }]
+ * }];
+ *
+ * matchRoutes(routes, "/dashboard"); // [rootMatch, dashboardMatch]
+ *
+ * @public
  * @category Utils
+ * @param routes The array of route objects to match against.
+ * @param locationArg The location to match against, either a string path or a
+ * partial {@link Location} object
+ * @param basename Optional base path to strip from the location before matching.
+ * Defaults to `/`.
+ * @returns An array of matched routes, or `null` if no matches were found.
  */
 declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
 interface UIMatch<Data = unknown, Handle = unknown> {
@@ -596,11 +709,26 @@ interface UIMatch<Data = unknown, Handle = unknown> {
     pathname: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
-     **/
+     */
     params: AgnosticRouteMatch["params"];
-    /** The return value from the matched route's loader or clientLoader */
-    data: Data;
-    /** The {@link https://reactrouter.com/start/framework/route-module#handle handle object} exported from the matched route module */
+    /**
+     * The return value from the matched route's loader or clientLoader. This might
+     * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+     * an error and we're currently displaying an `ErrorBoundary`.
+     *
+     * @deprecated Use `UIMatch.loaderData` instead
+     */
+    data: Data | undefined;
+    /**
+     * The return value from the matched route's loader or clientLoader. This might
+     * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+     * an error and we're currently displaying an `ErrorBoundary`.
+     */
+    loaderData: Data | undefined;
+    /**
+     * The {@link https://reactrouter.com/start/framework/route-module#handle handle object}
+     * exported from the matched route module
+     */
     handle: Handle;
 }
 declare class DataWithResponseInit<D> {
@@ -610,35 +738,116 @@ declare class DataWithResponseInit<D> {
     constructor(data: D, init?: ResponseInit);
 }
 /**
- * Create "responses" that contain `status`/`headers` without forcing
- * serialization into an actual `Response` - used by Remix single fetch
+ * Create "responses" that contain `headers`/`status` without forcing
+ * serialization into an actual [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ *
+ * @example
+ * import { data } from "react-router";
  *
+ * export async function action({ request }: Route.ActionArgs) {
+ *   let formData = await request.formData();
+ *   let item = await createItem(formData);
+ *   return data(item, {
+ *     headers: { "X-Custom-Header": "value" }
+ *     status: 201,
+ *   });
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param data The data to be included in the response.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A {@link DataWithResponseInit} instance containing the data and
+ * response init.
  */
 declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
 type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
 /**
- * A redirect response. Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+ * Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+ *
+ * @example
+ * import { redirect } from "react-router";
  *
+ * export async function loader({ request }: Route.LoaderArgs) {
+ *   if (!isLoggedIn(request))
+ *     throw redirect("/login");
+ *   }
+ *
+ *   // ...
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirect$1: RedirectFunction;
 /**
- * A redirect response that will force a document reload to the new location.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that will force a document reload to the new location. Sets the status code
+ * and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
  *
+ * ```tsx filename=routes/logout.tsx
+ * import { redirectDocument } from "react-router";
+ *
+ * import { destroySession } from "../sessions.server";
+ *
+ * export async function action({ request }: Route.ActionArgs) {
+ *   let session = await getSession(request.headers.get("Cookie"));
+ *   return redirectDocument("/", {
+ *     headers: { "Set-Cookie": await destroySession(session) }
+ *   });
+ * }
+ * ```
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirectDocument$1: RedirectFunction;
 /**
- * A redirect response that will perform a `history.replaceState` instead of a
- * `history.pushState` for client-side navigation redirects.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that will perform a [`history.replaceState`](https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState)
+ * instead of a [`history.pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState)
+ * for client-side navigation redirects. Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+ *
+ * @example
+ * import { replace } from "react-router";
+ *
+ * export async function loader() {
+ *   return replace("/new-location");
+ * }
  *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const replace$1: RedirectFunction;
 
@@ -916,7 +1125,7 @@ interface RouterInit {
     routes: AgnosticRouteObject[];
     history: History;
     basename?: string;
-    unstable_getContext?: () => MaybePromise<unstable_InitialContext>;
+    unstable_getContext?: () => MaybePromise<unstable_RouterContextProvider>;
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -951,14 +1160,13 @@ interface StaticHandler {
         skipLoaderErrorBubbling?: boolean;
         skipRevalidation?: boolean;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (staticContext: StaticHandlerContext) => MaybePromise<Response>;
-        unstable_stream?: (context: unstable_RouterContextProvider, query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
     }): Promise<StaticHandlerContext | Response>;
     queryRoute(request: Request, opts?: {
         routeId?: string;
         requestContext?: unknown;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (res: Response) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
     }): Promise<any>;
 }
 type ViewTransitionOpts = {
@@ -1334,7 +1542,13 @@ type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">
 });
 interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
     /**
-     * The absolute path of the page to prefetch.
+     * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
+     * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+     * element
+     */
+    nonce?: string | undefined;
+    /**
+     * The absolute path of the page to prefetch, e.g. `/absolute/path`.
      */
     page: string;
 }
@@ -1397,7 +1611,7 @@ type ClientDataFunctionArgs<Params> = {
      * from your route middlewares.  You may pass in initial context values in your
      * `<HydratedRouter unstable_getContext>` prop
      */
-    context: unstable_RouterContextProvider;
+    context: Readonly<unstable_RouterContextProvider>;
 };
 type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
     ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
@@ -1450,7 +1664,9 @@ interface LinksFunction {
 interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
     id: RouteId;
     pathname: DataRouteMatch["pathname"];
+    /** @deprecated Use `MetaMatch.loaderData` instead */
     data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
+    loaderData: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
     handle?: RouteHandle;
     params: DataRouteMatch["params"];
     meta: MetaDescriptor[];
@@ -1460,7 +1676,9 @@ type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoad
     [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
 }[keyof MatchLoaders]>;
 interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    /** @deprecated Use `MetaArgs.loaderData` instead */
     data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
+    loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
     params: Params;
     location: Location;
     matches: MetaMatches<MatchLoaders>;
@@ -1555,12 +1773,6 @@ type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
  */
 type RouteHandle = unknown;
 
-type ServerContext = {
-    redirect?: Response;
-};
-declare global {
-    var ___reactRouterServerStorage___: AsyncLocalStorage<ServerContext> | undefined;
-}
 declare const redirect: typeof redirect$1;
 declare const redirectDocument: typeof redirectDocument$1;
 declare const replace: typeof replace$1;
@@ -1661,8 +1873,11 @@ type DecodeReplyFunction = (reply: FormData | string, { temporaryReferences }: {
 }) => Promise<unknown[]>;
 type LoadServerActionFunction = (id: string) => Promise<Function>;
 /**
- * Matches the given routes to a Request and returns a RSC Response encoding an
- * `RSCPayload` for consumption by a RSC enabled client router.
+ * 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 {
@@ -1699,27 +1914,33 @@ type LoadServerActionFunction = (id: string) => Promise<Function>;
  * @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.decodeFormState A function responsible for decoding form state for
- * progressively enhanceable forms with `useActionState` using your
- * `react-server-dom-xyz/server`'s `decodeFormState`.
  * @param opts.generateResponse A function responsible for using your
- * `renderToReadableStream` to generate a Response encoding the `RSCPayload`.
+ * `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.request The request to match against.
- * @param opts.requestContext An instance of `unstable_RouterContextProvider`
- * that should be created per request, to be passed to loaders, actions and middleware.
- * @param opts.routes Your route definitions.
- * @param opts.createTemporaryReferenceSet A function that returns a temporary
- * reference set for the request, used to track temporary references in the RSC stream.
  * @param opts.onError An optional error handler that will be called with any
  * errors that occur during the request processing.
- * @returns A Response that contains the RSC data for hydration.
+ * @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;