Update docs and typegen

Author: brophdawg11

docs/how-to/middleware.md

@@ -276,32 +276,34 @@ const route = {
 };
 ```
 
-However, there may be some cases where you want to do some post-processing based on the result of the loaders/action. In lieu of a `Response`, client middleware bubbles up a `Record<string, DataStrategy>` object because it is implemented as part of the default [`dataStrategy`] internally. This allows you to take conditional action in your middleware based on the outcome of the executed `loader`/`action` functions.
+There may be _some_ cases where you want to do some post-processing based on the result of the loaders/action. In lieu of a `Response`, client middleware bubbles up the value returned from the active [`dataStrategy`](../api/data-routers/createBrowserRouter#optsdatastrategy) (`Record<string, DataStrategyResult>` - keyed by route id). This allows you to take conditional action in your middleware based on the outcome of the executed `loader`/`action` functions.
 
 Here's an example of the [CMS Redirect on 404][cms-redirect] use case implemented as a client side middleware:
 
 ```tsx
 async function cmsFallbackMiddleware({ request }, next) {
   const results = await next();
 
-  // Check if we got a 404 from any of our routes
-  let is404 =
-    isRouteErrorResponse(r.result) &&
-    r.result.status === 404;
-  if (Object.values(results).some((r) => is404(r))) {
-    // Check CMS for a redirect
+  // Check if we got a 404 from any of our routes and if so, look for a
+  // redirect in our CMS
+  const found404 = Object.values(results).some(
+    (r) =>
+      isRouteErrorResponse(r.result) &&
+      r.result.status === 404,
+  );
+  if (found404) {
     const cmsRedirect = await checkCMSRedirects(
       request.url,
     );
     if (cmsRedirect) {
       throw redirect(cmsRedirect, 302);
     }
   }
-
-  return results;
 }
 ```
 
+<docs-warning>In a server middleware, you shouldn't be messing with the `Response` body and should only be reading status/headers and setting headers. Similarly, this value should be considered read-only in client middleware because it represents the "body" or "data" for the resulting navigation which should be driven by loaders/actions - not middleware. This also means that in client middleware, there's usually no need to return the results even if you needed to capture it from `await next()`;</docs-warning>
+
 ### When Middleware Runs
 
 It is very important to understand _when_ your middlewares will run to make sure your application is behaving as you intend.

packages/react-router/lib/types/route-module-annotations.ts

@@ -1,7 +1,10 @@
 import type { MetaDescriptor } from "../dom/ssr/routeModules";
 import type { Location } from "../router/history";
 import type { LinkDescriptor } from "../router/links";
-import type { unstable_MiddlewareNextFunction } from "../router/utils";
+import type {
+  DataStrategyResult,
+  unstable_MiddlewareNextFunction,
+} from "../router/utils";
 
 import type {
   ClientDataFunctionArgs,
@@ -82,8 +85,8 @@ type CreateServerMiddlewareFunction<T extends RouteInfo> = (
 
 type CreateClientMiddlewareFunction<T extends RouteInfo> = (
   args: ClientDataFunctionArgs<T["params"]>,
-  next: unstable_MiddlewareNextFunction<undefined>,
-) => MaybePromise<void>;
+  next: unstable_MiddlewareNextFunction<Record<string, DataStrategyResult>>,
+) => MaybePromise<Record<string, DataStrategyResult> | void>;
 
 type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<
   T["params"]