react-router 7.7.1 → 7.8.0-pre.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # `react-router`
 
+## 7.8.0-pre.0
+
+### Minor Changes
+
+- Add `nonce` prop to `Links` & `PrefetchPageLinks` ([#14048](https://github.com/remix-run/react-router/pull/14048))
+- Add `loaderData` arguments/properties alongside existing `data` arguments/properties to provide consistency and clarity between `loaderData` and `actionData` across the board ([#14047](https://github.com/remix-run/react-router/pull/14047))
+  - Updated types: `Route.MetaArgs`, `Route.MetaMatch`, `MetaArgs`, `MetaMatch`, `Route.ComponentProps.matches`, `UIMatch`
+  - `@deprecated` warnings have been added to the existing `data` properties to point users to new `loaderData` properties, in preparation for removing the `data` properties in a future major release
+
+### Patch Changes
+
+- [UNSTABLE] Ensure resource route errors go through `handleError` w/middleware enabled ([#14078](https://github.com/remix-run/react-router/pull/14078))
+- Prevent _"Did not find corresponding fetcher result"_ console error when navigating during a `fetcher.submit` revalidation ([#14114](https://github.com/remix-run/react-router/pull/14114))
+- Switch Lazy Route Discovery manifest URL generation to usea standalone `URLSearchParams` instance instead of `URL.searchParams` to avoid a major performance bottleneck in Chrome ([#14084](https://github.com/remix-run/react-router/pull/14084))
+- [UNSTABLE] Propagate returned Response from server middleware if next wasn't called ([#14093](https://github.com/remix-run/react-router/pull/14093))
+- [UNSTABLE] Allow server middlewares to return `data()` values which will be converted into a `Response` ([#14093](https://github.com/remix-run/react-router/pull/14093))
+- [UNSTABLE] Update middleware error handling so that the `next` function never throws and instead handles any middleware errors at the proper `ErrorBoundary` and returns the `Response` up through the ancestor `next` function ([#14118](https://github.com/remix-run/react-router/pull/14118))
+- - [UNSTABLE] When middleware is enabled, make the `context` parameter read-only (via `Readonly<unstable_RouterContextProvider>`) so that TypeScript will not allow you to write arbitrary fields to it in loaders, actions, or middleware. ([#14097](https://github.com/remix-run/react-router/pull/14097))
+- [UNSTABLE] Rename and alter the signature/functionality of the `unstable_respond` API in `staticHandler.query`/`staticHandler.queryRoute` ([#14103](https://github.com/remix-run/react-router/pull/14103))
+  - The API has been renamed to `unstable_generateMiddlewareResponse` for clarity
+  - The main functional change is that instead of running the loaders/actions before calling `unstable_respond` and handing you the result, we now pass a `query`/`queryRoute` function as a parameter and you execute the loaders/actions inside your callback, giving you full access to pre-processing and error handling
+  - The `query` version of the API now has a signature of `(query: (r: Request) => Promise<StaticHandlerContext | Response>) => Promise<Response>`
+  - The `queryRoute` version of the API now has a signature of `(queryRoute: (r: Request) => Promise<Response>) => Promise<Response>`
+  - This allows for more advanced usages such as running logic before/after calling `query` and direct error handling of errors thrown from query
+  - ⚠️ This is a breaking change if you've adopted the `staticHandler` `unstable_respond` API
+
+  ```tsx
+  let response = await staticHandler.query(request, {
+    requestContext: new unstable_RouterContextProvider(),
+    async unstable_generateMiddlewareResponse(query) {
+      try {
+        // At this point we've run middleware top-down so we need to call the
+        // handlers and generate the Response to bubble back up the middleware
+        let result = await query(request);
+        if (isResponse(result)) {
+          return result; // Redirects, etc.
+        }
+        return await generateHtmlResponse(result);
+      } catch (error: unknown) {
+        return generateErrorResponse(error);
+      }
+    },
+  });
+  ```
+
+- [UNSTABLE] Convert internal middleware implementations to use the new `unstable_generateMiddlewareResponse` API ([#14103](https://github.com/remix-run/react-router/pull/14103))
+- Adjust internal RSC usage of `React.use` to avoid Webpack compilation errors when using React 18 ([#14113](https://github.com/remix-run/react-router/pull/14113))
+- [UNSTABLE] Change `getLoadContext` signature (`type GetLoadContextFunction`) when `future.unstable_middleware` is enabled so that it returns an `unstable_RouterContextProvider` instance instead of a `Map` used to contruct the instance internally ([#14097](https://github.com/remix-run/react-router/pull/14097))
+  - This also removes the `type unstable_InitialContext` export
+  - ⚠️ This is a breaking change if you have adopted middleware and are using a custom server with a `getLoadContext` function
+
+- Remove dependency on `@types/node` in TypeScript declaration files ([#14059](https://github.com/remix-run/react-router/pull/14059))
+- Fix types for `UIMatch` to reflect that the `loaderData`/`data` properties may be `undefined` ([#12206](https://github.com/remix-run/react-router/pull/12206))
+  - When an `ErrorBoundary` is being rendered, not all active matches will have loader data available, since it may have been their `loader` that threw to trigger the boundary
+  - The `UIMatch.data` type was not correctly handing this and would always reflect the presence of data, leading to the unexpected runtime errors when an `ErrorBoundary` was rendered
+  - ⚠️ This may cause some type errors to show up in your code for unguarded `match.data` accesses - you should properly guard for `undefined` values in those scenarios.
+
+  ```tsx
+  // app/root.tsx
+  export function loader() {
+    someFunctionThatThrows(); // ❌ Throws an Error
+    return { title: "My Title" };
+  }
+
+  export function Layout({ children }: { children: React.ReactNode }) {
+    let matches = useMatches();
+    let rootMatch = matches[0] as UIMatch<Awaited<ReturnType<typeof loader>>>;
+    //  ^ rootMatch.data is incorrectly typed here, so TypeScript does not
+    //    complain if you do the following which throws an error at runtime:
+    let { title } = rootMatch.data; // 💥
+
+    return <html>...</html>;
+  }
+  ```
+
+- [UNSTABLE] Run client middleware on client navigations even if no loaders exist ([#14106](https://github.com/remix-run/react-router/pull/14106))
+- [UNSTABLE] Change the `unstable_getContext` signature on `RouterProvider`/`HydratedRouter`/`unstable_RSCHydratedRouter` so that it returns an `unstable_RouterContextProvider` instance instead of a `Map` used to contruct the instance internally ([#14097](https://github.com/remix-run/react-router/pull/14097))
+  - ⚠️ This is a breaking change if you have adopted the `unstable_getContext` prop
+
+- Fix RSC Data Mode issue where routes that return `false` from `shouldRevalidate` would be replaced by an `<Outlet />` ([#14071](https://github.com/remix-run/react-router/pull/14071))
+
 ## 7.7.1
 
 ### Patch Changes
@@ -604,7 +685,6 @@
   ```
 
   Similar to server-side requests, a fresh `context` will be created per navigation (or `fetcher` call). If you have initial data you'd like to populate in the context for every request, you can provide an `unstable_getContext` function at the root of your app:
-
   - Library mode - `createBrowserRouter(routes, { unstable_getContext })`
   - Framework mode - `<HydratedRouter unstable_getContext>`
 
@@ -792,7 +872,6 @@ _No changes_
 - Remove `future.v7_normalizeFormMethod` future flag ([#11697](https://github.com/remix-run/react-router/pull/11697))
 
 - For Remix consumers migrating to React Router, the `crypto` global from the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) is now required when using cookie and session APIs. This means that the following APIs are provided from `react-router` rather than platform-specific packages: ([#11837](https://github.com/remix-run/react-router/pull/11837))
-
   - `createCookie`
   - `createCookieSessionStorage`
   - `createMemorySessionStorage`
@@ -801,7 +880,6 @@ _No changes_
   For consumers running older versions of Node, the `installGlobals` function from `@remix-run/node` has been updated to define `globalThis.crypto`, using [Node's `require('node:crypto').webcrypto` implementation.](https://nodejs.org/api/webcrypto.html)
 
   Since platform-specific packages no longer need to implement this API, the following low-level APIs have been removed:
-
   - `createCookieFactory`
   - `createSessionStorageFactory`
   - `createCookieSessionStorageFactory`
@@ -957,7 +1035,6 @@ _No changes_
   ```
 
   This initial implementation targets type inference for:
-
   - `Params` : Path parameters from your routing config in `routes.ts` including file-based routing
   - `LoaderData` : Loader data from `loader` and/or `clientLoader` within your route module
   - `ActionData` : Action data from `action` and/or `clientAction` within your route module
@@ -972,7 +1049,6 @@ _No changes_
   ```
 
   Check out our docs for more:
-
   - [_Explanations > Type Safety_](https://reactrouter.com/dev/guides/explanation/type-safety)
   - [_How-To > Setting up type safety_](https://reactrouter.com/dev/guides/how-to/setting-up-type-safety)
 

package/dist/development/browser-z32v5KVN.d.mts

@@ -0,0 +1,46 @@
+declare global {
+    interface Window {
+        __FLIGHT_DATA: any[];
+    }
+}
+/**
+ * Get the prerendered [RSC](https://react.dev/reference/rsc/server-components)
+ * stream for hydration. Usually passed directly to your
+ * `react-server-dom-xyz/client`'s `createFromReadableStream`.
+ *
+ * @example
+ * import { startTransition, StrictMode } from "react";
+ * import { hydrateRoot } from "react-dom/client";
+ * import {
+ *   unstable_getRSCStream as getRSCStream,
+ *   unstable_RSCHydratedRouter as RSCHydratedRouter,
+ * } from "react-router";
+ * import type { unstable_RSCPayload as RSCPayload } from "react-router";
+ *
+ * createFromReadableStream(getRSCStream()).then(
+ *   (payload: RSCServerPayload) => {
+ *     startTransition(async () => {
+ *       hydrateRoot(
+ *         document,
+ *         <StrictMode>
+ *           <RSCHydratedRouter {...props} />
+ *         </StrictMode>,
+ *         {
+ *           // Options
+ *         }
+ *       );
+ *     });
+ *   }
+ * );
+ *
+ * @name unstable_getRSCStream
+ * @public
+ * @category RSC
+ * @mode data
+ * @returns A [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+ * that contains the [RSC](https://react.dev/reference/rsc/server-components)
+ * data for hydration.
+ */
+declare function getRSCStream(): ReadableStream;
+
+export { getRSCStream as g };

package/dist/{production/chunk-K3SBCRK4.mjs → development/chunk-HSC5IU24.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.7.1
+ * react-router v7.8.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -57,7 +57,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-IZ57JD2V.mjs";
+} from "./chunk-SC4OUYO4.mjs";
 
 // lib/dom/ssr/server.tsx
 import * as React from "react";
@@ -772,42 +772,6 @@ var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
 ]);
 async function singleFetchAction(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
   try {
-    let respond2 = function(context) {
-      let headers = getDocumentHeaders(context, build);
-      if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: getSingleFetchRedirect(
-            context.statusCode,
-            headers,
-            build.basename
-          ),
-          headers,
-          status: SINGLE_FETCH_REDIRECT_STATUS
-        });
-      }
-      if (context.errors) {
-        Object.values(context.errors).forEach((err) => {
-          if (!isRouteErrorResponse(err) || err.error) {
-            handleError(err);
-          }
-        });
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let singleFetchResult;
-      if (context.errors) {
-        singleFetchResult = { error: Object.values(context.errors)[0] };
-      } else {
-        singleFetchResult = {
-          data: Object.values(context.actionData || {})[0]
-        };
-      }
-      return generateSingleFetchResponse(request, build, serverMode, {
-        result: singleFetchResult,
-        headers,
-        status: context.statusCode
-      });
-    };
-    var respond = respond2;
     let handlerRequest = new Request(handlerUrl, {
       method: request.method,
       body: request.body,
@@ -819,10 +783,22 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       requestContext: loadContext,
       skipLoaderErrorBubbling: true,
       skipRevalidation: true,
-      unstable_respond: respond2
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(handlerRequest);
+          return handleQueryResult(innerResult);
+        } catch (error) {
+          return handleQueryError(error);
+        }
+      } : void 0
     });
+    return handleQueryResult(result);
+  } catch (error) {
+    return handleQueryError(error);
+  }
+  function handleQueryResult(result) {
     if (!isResponse(result)) {
-      result = respond2(result);
+      result = staticContextToResponse(result);
     }
     if (isRedirectResponse(result)) {
       return generateSingleFetchResponse(request, build, serverMode, {
@@ -836,7 +812,8 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       });
     }
     return result;
-  } catch (error) {
+  }
+  function handleQueryError(error) {
     handleError(error);
     return generateSingleFetchResponse(request, build, serverMode, {
       result: { error },
@@ -844,92 +821,137 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
       status: 500
     });
   }
-}
-async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
-  try {
-    let respond2 = function(context) {
-      let headers = getDocumentHeaders(context, build);
-      if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
-        return generateSingleFetchResponse(request, build, serverMode, {
-          result: {
-            [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
-              context.statusCode,
-              headers,
-              build.basename
-            )
-          },
-          headers,
-          status: SINGLE_FETCH_REDIRECT_STATUS
-        });
-      }
-      if (context.errors) {
-        Object.values(context.errors).forEach((err) => {
-          if (!isRouteErrorResponse(err) || err.error) {
-            handleError(err);
-          }
-        });
-        context.errors = sanitizeErrors(context.errors, serverMode);
-      }
-      let results = {};
-      let loadedMatches = new Set(
-        context.matches.filter(
-          (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
-        ).map((m) => m.route.id)
-      );
-      if (context.errors) {
-        for (let [id, error] of Object.entries(context.errors)) {
-          results[id] = { error };
-        }
-      }
-      for (let [id, data2] of Object.entries(context.loaderData)) {
-        if (!(id in results) && loadedMatches.has(id)) {
-          results[id] = { data: data2 };
-        }
-      }
+  function staticContextToResponse(context) {
+    let headers = getDocumentHeaders(context, build);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
       return generateSingleFetchResponse(request, build, serverMode, {
-        result: results,
+        result: getSingleFetchRedirect(
+          context.statusCode,
+          headers,
+          build.basename
+        ),
         headers,
-        status: context.statusCode
+        status: SINGLE_FETCH_REDIRECT_STATUS
       });
-    };
-    var respond = respond2;
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
+      });
+      context.errors = sanitizeErrors(context.errors, serverMode);
+    }
+    let singleFetchResult;
+    if (context.errors) {
+      singleFetchResult = { error: Object.values(context.errors)[0] };
+    } else {
+      singleFetchResult = {
+        data: Object.values(context.actionData || {})[0]
+      };
+    }
+    return generateSingleFetchResponse(request, build, serverMode, {
+      result: singleFetchResult,
+      headers,
+      status: context.statusCode
+    });
+  }
+}
+async function singleFetchLoaders(build, serverMode, staticHandler, request, handlerUrl, loadContext, handleError) {
+  let routesParam = new URL(request.url).searchParams.get("_routes");
+  let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
+  try {
     let handlerRequest = new Request(handlerUrl, {
       headers: request.headers,
       signal: request.signal
     });
-    let routesParam = new URL(request.url).searchParams.get("_routes");
-    let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
     let result = await staticHandler.query(handlerRequest, {
       requestContext: loadContext,
       filterMatchesToLoad: (m) => !loadRouteIds || loadRouteIds.has(m.route.id),
       skipLoaderErrorBubbling: true,
-      unstable_respond: respond2
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(handlerRequest);
+          return handleQueryResult(innerResult);
+        } catch (error) {
+          return handleQueryError(error);
+        }
+      } : void 0
     });
-    if (!isResponse(result)) {
-      result = respond2(result);
-    }
-    if (isRedirectResponse(result)) {
+    return handleQueryResult(result);
+  } catch (error) {
+    return handleQueryError(error);
+  }
+  function handleQueryResult(result) {
+    let response = isResponse(result) ? result : staticContextToResponse(result);
+    if (isRedirectResponse(response)) {
       return generateSingleFetchResponse(request, build, serverMode, {
         result: {
           [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
-            result.status,
-            result.headers,
+            response.status,
+            response.headers,
             build.basename
           )
         },
-        headers: result.headers,
+        headers: response.headers,
         status: SINGLE_FETCH_REDIRECT_STATUS
       });
     }
-    return result;
-  } catch (error) {
+    return response;
+  }
+  function handleQueryError(error) {
     handleError(error);
     return generateSingleFetchResponse(request, build, serverMode, {
-      result: { root: { error } },
+      result: { error },
       headers: new Headers(),
       status: 500
     });
   }
+  function staticContextToResponse(context) {
+    let headers = getDocumentHeaders(context, build);
+    if (isRedirectStatusCode(context.statusCode) && headers.has("Location")) {
+      return generateSingleFetchResponse(request, build, serverMode, {
+        result: {
+          [SingleFetchRedirectSymbol]: getSingleFetchRedirect(
+            context.statusCode,
+            headers,
+            build.basename
+          )
+        },
+        headers,
+        status: SINGLE_FETCH_REDIRECT_STATUS
+      });
+    }
+    if (context.errors) {
+      Object.values(context.errors).forEach((err) => {
+        if (!isRouteErrorResponse(err) || err.error) {
+          handleError(err);
+        }
+      });
+      context.errors = sanitizeErrors(context.errors, serverMode);
+    }
+    let results = {};
+    let loadedMatches = new Set(
+      context.matches.filter(
+        (m) => loadRouteIds ? loadRouteIds.has(m.route.id) : m.route.loader != null
+      ).map((m) => m.route.id)
+    );
+    if (context.errors) {
+      for (let [id, error] of Object.entries(context.errors)) {
+        results[id] = { error };
+      }
+    }
+    for (let [id, data2] of Object.entries(context.loaderData)) {
+      if (!(id in results) && loadedMatches.has(id)) {
+        results[id] = { data: data2 };
+      }
+    }
+    return generateSingleFetchResponse(request, build, serverMode, {
+      result: results,
+      headers,
+      status: context.statusCode
+    });
+  }
 }
 function generateSingleFetchResponse(request, build, serverMode, {
   result,
@@ -1074,23 +1096,14 @@ var createRequestHandler = (build, mode) => {
       });
     };
     if (_build.future.unstable_middleware) {
-      if (initialContext == null) {
-        loadContext = new unstable_RouterContextProvider();
-      } else {
-        try {
-          loadContext = new unstable_RouterContextProvider(
-            initialContext
-          );
-        } catch (e) {
-          let error = new Error(
-            `Unable to create initial \`unstable_RouterContextProvider\` instance. Please confirm you are returning an instance of \`Map<unstable_routerContext, unknown>\` from your \`getLoadContext\` function.
-
-Error: ${e instanceof Error ? e.toString() : e}`
-          );
-          handleError(error);
-          return returnLastResortErrorResponse(error, serverMode);
-        }
+      if (initialContext && !(initialContext instanceof unstable_RouterContextProvider)) {
+        let error = new Error(
+          "Invalid `context` value provided to `handleRequest`. When middleware is enabled you must return an instance of `unstable_RouterContextProvider` from your `getLoadContext` function."
+        );
+        handleError(error);
+        return returnLastResortErrorResponse(error, serverMode);
       }
+      loadContext = initialContext || new unstable_RouterContextProvider();
     } else {
       loadContext = initialContext || {};
     }
@@ -1304,19 +1317,30 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
 }
 async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, isSpaMode, criticalCss) {
   try {
-    let response = await staticHandler.query(request, {
+    let result = await staticHandler.query(request, {
       requestContext: loadContext,
-      unstable_respond: build.future.unstable_middleware ? (ctx) => renderHtml(ctx, isSpaMode) : void 0
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (query) => {
+        try {
+          let innerResult = await query(request);
+          if (!isResponse(innerResult)) {
+            innerResult = await renderHtml(innerResult, isSpaMode);
+          }
+          return innerResult;
+        } catch (error) {
+          handleError(error);
+          return new Response(null, { status: 500 });
+        }
+      } : void 0
     });
-    return isResponse(response) ? response : renderHtml(response, isSpaMode);
+    if (!isResponse(result)) {
+      result = await renderHtml(result, isSpaMode);
+    }
+    return result;
   } catch (error) {
     handleError(error);
     return new Response(null, { status: 500 });
   }
   async function renderHtml(context, isSpaMode2) {
-    if (isResponse(context)) {
-      return context;
-    }
     let headers = getDocumentHeaders(context, build);
     if (SERVER_NO_BODY_STATUS_CODES.has(context.statusCode)) {
       return new Response(null, { status: context.statusCode, headers });
@@ -1428,27 +1452,38 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
 }
 async function handleResourceRequest(serverMode, build, staticHandler, routeId, request, loadContext, handleError) {
   try {
-    let response = await staticHandler.queryRoute(request, {
+    let result = await staticHandler.queryRoute(request, {
       routeId,
       requestContext: loadContext,
-      unstable_respond: build.future.unstable_middleware ? (ctx) => ctx : void 0
+      unstable_generateMiddlewareResponse: build.future.unstable_middleware ? async (queryRoute) => {
+        try {
+          let innerResult = await queryRoute(request);
+          return handleQueryRouteResult(innerResult);
+        } catch (error) {
+          return handleQueryRouteError(error);
+        }
+      } : void 0
     });
-    if (isResponse(response)) {
-      return response;
+    return handleQueryRouteResult(result);
+  } catch (error) {
+    return handleQueryRouteError(error);
+  }
+  function handleQueryRouteResult(result) {
+    if (isResponse(result)) {
+      return result;
     }
-    if (typeof response === "string") {
-      return new Response(response);
+    if (typeof result === "string") {
+      return new Response(result);
     }
-    return Response.json(response);
-  } catch (error) {
+    return Response.json(result);
+  }
+  function handleQueryRouteError(error) {
     if (isResponse(error)) {
       error.headers.set("X-Remix-Catch", "yes");
       return error;
     }
     if (isRouteErrorResponse(error)) {
-      if (error) {
-        handleError(error);
-      }
+      handleError(error);
       return errorResponseToJson(error, serverMode);
     }
     if (error instanceof Error && error.message === "Expected a response from queryRoute") {
@@ -2440,6 +2475,14 @@ function escapeScript(script) {
 }
 
 // lib/rsc/server.ssr.tsx
+var REACT_USE = "use";
+var useImpl = React5[REACT_USE];
+function useSafe(promise) {
+  if (useImpl) {
+    return useImpl(promise);
+  }
+  throw new Error("React Router v7 requires React 19+ for RSC features.");
+}
 async function routeRSCServerRequest({
   request,
   fetchServer,
@@ -2494,7 +2537,7 @@ async function routeRSCServerRequest({
   }
 }
 function RSCStaticRouter({ getPayload }) {
-  const payload = React5.use(getPayload());
+  const payload = useSafe(getPayload());
   if (payload.type === "redirect") {
     throw new Response(null, {
       status: payload.status,