react-router 7.13.1 → 7.13.2-pre.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # `react-router`
 
+## 7.13.2-pre.0
+
+### Patch Changes
+
+- Fix clientLoader.hydrate when an ancestor route is also hydrating a clientLoader ([#14835](https://github.com/remix-run/react-router/pull/14835))
+- Fix type error when passing Framework Mode route components using `Route.ComponentProps` to `createRoutesStub` ([#14892](https://github.com/remix-run/react-router/pull/14892))
+- Fix percent encoding in relative path navigation ([#14786](https://github.com/remix-run/react-router/pull/14786))
+- Add `future.unstable_passThroughRequests` flag ([#14775](https://github.com/remix-run/react-router/pull/14775))
+
+  By default, React Router normalizes the `request.url` passed to your `loader`, `action`, and `middleware` functions by removing React Router's internal implementation details (`.data` suffixes, `index` + `_routes` query params).
+
+  Enabling this flag removes that normalization and passes the raw HTTP `request` instance to your handlers. This provides a few benefits:
+  - Reduces server-side overhead by eliminating multiple `new Request()` calls on the critical path
+  - Allows you to distinguish document from data requests in your handlers base don the presence of a `.data` suffix (useful for observability purposes)
+
+  If you were previously relying on the normalization of `request.url`, you can switch to use the new sibling `unstable_url` parameter which contains a `URL` instance representing the normalized location:
+
+  ```tsx
+  // ❌ Before: you could assume there was no `.data` suffix in `request.url`
+  export async function loader({ request }: Route.LoaderArgs) {
+    let url = new URL(request.url);
+    if (url.pathname === "/path") {
+      // This check will fail with the flag enabled because the `.data` suffix will
+      // exist on data requests
+    }
+  }
+
+  // ✅ After: use `unstable_url` for normalized routing logic and `request.url`
+  // for raw routing logic
+  export async function loader({ request, unstable_url }: Route.LoaderArgs) {
+    if (unstable_url.pathname === "/path") {
+      // This will always have the `.data` suffix stripped
+    }
+
+    // And now you can distinguish between document versus data requests
+    let isDataRequest = new URL(request.url).pathname.endsWith(".data");
+  }
+  ```
+
+- Internal refactor to consolidate framework-agnostic/React-specific route type layers - no public API changes ([#14765](https://github.com/remix-run/react-router/pull/14765))
+- Sync protocol validation to rsc flows ([#14882](https://github.com/remix-run/react-router/pull/14882))
+- Add a new `unstable_url: URL` parameter to route handler methods (`loader`, `action`, `middleware`, etc.) representing the normalized URL the application is navigating to or fetching, with React Router implementation details removed (`.data`suffix, `index`/`_routes` query params) ([#14775](https://github.com/remix-run/react-router/pull/14775))
+
+  This is being added alongside the new `future.unstable_passthroughRequests` future flag so that users still have a way to access the normalized URL when that flag is enabled and non-normalized `request`'s are being passed to your handlers. When adopting this flag, you will only need to start leveraging this new parameter if you are relying on the normalization of `request.url` in your application code.
+
+  If you don't have the flag enabled, then `unstable_url` will match `request.url`.
+
 ## 7.13.1
 
 ### Patch Changes
@@ -12,9 +59,9 @@
 
 - Fix matchPath optional params matching without a "/" separator. ([#14689](https://github.com/remix-run/react-router/pull/14689))
   - matchPath("/users/:id?", "/usersblah") now returns null.
-  - matchPath("/test\_route/:part?", "/test\_route\_more") now returns null.
+  - matchPath("/test_route/:part?", "/test_route_more") now returns null.
 
-- add RSC unstable\_getRequest ([#14758](https://github.com/remix-run/react-router/pull/14758))
+- add RSC unstable_getRequest ([#14758](https://github.com/remix-run/react-router/pull/14758))
 
 - Fix `HydrateFallback` rendering during initial lazy route discovery with matching splat route ([#14740](https://github.com/remix-run/react-router/pull/14740))
 
@@ -60,7 +107,6 @@
   ```
 
   Notes:
-
   - The masked location, if present, will be available on `useLocation().unstable_mask` so you can detect whether you are currently masked or not.
   - Masked URLs only work for SPA use cases, and will be removed from `history.state` during SSR.
   - This provides a first-class API to mask URLs in Data Mode to achieve the same behavior you could do in Declarative Mode via [manual `backgroundLocation` management](https://github.com/remix-run/react-router/tree/main/examples/modal).
@@ -106,25 +152,25 @@
 
   | URL `/a/b/c` | **HTTP pathname** | **`request` pathname\`** |
   | ------------ | ----------------- | ------------------------ |
-  | **Document** | `/a/b/c`          | `/a/b/c` ✅               |
-  | **Data**     | `/a/b/c.data`     | `/a/b/c` ✅               |
+  | **Document** | `/a/b/c`          | `/a/b/c` ✅              |
+  | **Data**     | `/a/b/c.data`     | `/a/b/c` ✅              |
 
   | URL `/a/b/c/` | **HTTP pathname** | **`request` pathname\`** |
   | ------------- | ----------------- | ------------------------ |
-  | **Document**  | `/a/b/c/`         | `/a/b/c/` ✅              |
+  | **Document**  | `/a/b/c/`         | `/a/b/c/` ✅             |
   | **Data**      | `/a/b/c.data`     | `/a/b/c` ⚠️              |
 
   With this flag enabled, these pathnames will be made consistent though a new `_.data` format for client-side `.data` requests:
 
   | URL `/a/b/c` | **HTTP pathname** | **`request` pathname\`** |
   | ------------ | ----------------- | ------------------------ |
-  | **Document** | `/a/b/c`          | `/a/b/c` ✅               |
-  | **Data**     | `/a/b/c.data`     | `/a/b/c` ✅               |
+  | **Document** | `/a/b/c`          | `/a/b/c` ✅              |
+  | **Data**     | `/a/b/c.data`     | `/a/b/c` ✅              |
 
   | URL `/a/b/c/` | **HTTP pathname**  | **`request` pathname\`** |
   | ------------- | ------------------ | ------------------------ |
-  | **Document**  | `/a/b/c/`          | `/a/b/c/` ✅              |
-  | **Data**      | `/a/b/c/_.data` ⬅️ | `/a/b/c/` ✅              |
+  | **Document**  | `/a/b/c/`          | `/a/b/c/` ✅             |
+  | **Data**      | `/a/b/c/_.data` ⬅️ | `/a/b/c/` ✅             |
 
   This a bug fix but we are putting it behind an opt-in flag because it has the potential to be a "breaking bug fix" if you are relying on the URL format for any other application or caching logic.
 
@@ -151,14 +197,12 @@
 - \[UNSTABLE] Add a new `unstable_defaultShouldRevalidate` flag to various APIs to allow opt-ing out of standard revalidation behaviors. ([#14542](https://github.com/remix-run/react-router/pull/14542))
 
   If active routes include a `shouldRevalidate` function, then your value will be passed as `defaultShouldRevalidate` in those function so that the route always has the final revalidation determination.
-
   - `<Form method="post" unstable_defaultShouldRevalidate={false}>`
   - `submit(data, { method: "post", unstable_defaultShouldRevalidate: false })`
   - `<fetcher.Form method="post" unstable_defaultShouldRevalidate={false}>`
   - `fetcher.submit(data, { method: "post", unstable_defaultShouldRevalidate: false })`
 
   This is also available on non-submission APIs that may trigger revalidations due to changing search params:
-
   - `<Link to="/" unstable_defaultShouldRevalidate={false}>`
   - `navigate("/?foo=bar", { unstable_defaultShouldRevalidate: false })`
   - `setSearchParams(params, { unstable_defaultShouldRevalidate: false })`
@@ -181,7 +225,6 @@
   - ⚠️ This is a breaking change if you have begun using `fetcher.unstable_reset()`
 
 - Stabilize the `dataStrategy` `match.shouldRevalidateArgs`/`match.shouldCallHandler()` APIs. ([#14592](https://github.com/remix-run/react-router/pull/14592))
-
   - The `match.shouldLoad` API is now marked deprecated in favor of these more powerful alternatives
 
   - If you're using this API in a custom `dataStrategy` today, you can swap to the new API at your convenience:
@@ -310,7 +353,6 @@
 - Ensure action handlers run for routes with middleware even if no loader is present ([#14443](https://github.com/remix-run/react-router/pull/14443))
 
 - Add `unstable_instrumentations` API to allow users to add observablity to their apps by instrumenting route loaders, actions, middlewares, lazy, as well as server-side request handlers and client side navigations/fetches ([#14412](https://github.com/remix-run/react-router/pull/14412))
-
   - Framework Mode:
     - `entry.server.tsx`: `export const unstable_instrumentations = [...]`
     - `entry.client.tsx`: `<HydratedRouter unstable_instrumentations={[...]} />`
@@ -472,7 +514,6 @@
 - Stabilize middleware and context APIs. ([#14215](https://github.com/remix-run/react-router/pull/14215))
 
   We have removed the `unstable_` prefix from the following APIs and they are now considered stable and ready for production use:
-
   - [`RouterContextProvider`](https://reactrouter.com/api/utils/RouterContextProvider)
   - [`createContext`](https://reactrouter.com/api/utils/createContext)
   - `createBrowserRouter` [`getContext`](https://reactrouter.com/api/data-routers/createBrowserRouter#optsgetcontext) option
@@ -499,7 +540,7 @@
 
 - \[UNSTABLE] Add `<RouterProvider unstable_onError>`/`<HydratedRouter unstable_onError>` prop for client side error reporting ([#14162](https://github.com/remix-run/react-router/pull/14162))
 
-- server action revalidation opt out via $SKIP\_REVALIDATION field ([#14154](https://github.com/remix-run/react-router/pull/14154))
+- server action revalidation opt out via $SKIP_REVALIDATION field ([#14154](https://github.com/remix-run/react-router/pull/14154))
 
 - Properly escape interpolated param values in `generatePath()` ([#13530](https://github.com/remix-run/react-router/pull/13530))
 
@@ -548,7 +589,6 @@
 - 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.
@@ -582,7 +622,6 @@
 - \[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>`
@@ -1228,7 +1267,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>`
 
@@ -1416,7 +1454,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`
@@ -1425,7 +1462,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`
@@ -1581,7 +1617,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
@@ -1596,7 +1631,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/{production/browser-DzsJABDQ.d.mts → development/browser-Bfn3xw9E.d.ts}

@@ -1,5 +1,6 @@
 import * as React from 'react';
-import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction, e as RouterInit } from './router-cLsU7kHk.mjs';
+import { R as RouterInit } from './instrumentation-BYr6ff5D.js';
+import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction } from './routeModules-CA7kSxJJ.js';
 
 declare function getRequest(): Request;
 type RSCRouteConfigEntryBase = {

package/dist/development/{browser-DzsJABDQ.d.mts → browser-Di6-vSl-.d.mts}

@@ -1,5 +1,6 @@
 import * as React from 'react';
-import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction, e as RouterInit } from './router-cLsU7kHk.mjs';
+import { R as RouterInit } from './context-phCt_zmH.mjs';
+import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction } from './routeModules-BRrCYrSL.mjs';
 
 declare function getRequest(): Request;
 type RSCRouteConfigEntryBase = {

package/dist/development/{chunk-KSEWV2VO.js → chunk-FXJW44AE.js}

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }/**
- * react-router v7.13.1
+ * react-router v7.13.2-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -14,7 +14,7 @@
 
 
 
-var _chunkXOLAXE2Zjs = require('./chunk-XOLAXE2Z.js');
+var _chunkWO3PXTPVjs = require('./chunk-WO3PXTPV.js');
 
 // lib/dom/ssr/hydration.tsx
 function getHydrationData({
@@ -29,12 +29,12 @@ function getHydrationData({
     ...state,
     loaderData: { ...state.loaderData }
   };
-  let initialMatches = _chunkXOLAXE2Zjs.matchRoutes.call(void 0, routes, location, basename);
+  let initialMatches = _chunkWO3PXTPVjs.matchRoutes.call(void 0, routes, location, basename);
   if (initialMatches) {
     for (let match of initialMatches) {
       let routeId = match.route.id;
       let routeInfo = getRouteInfo(routeId);
-      if (_chunkXOLAXE2Zjs.shouldHydrateRouteLoader.call(void 0, 
+      if (_chunkWO3PXTPVjs.shouldHydrateRouteLoader.call(void 0, 
         routeId,
         routeInfo.clientLoader,
         routeInfo.hasLoader,
@@ -112,7 +112,7 @@ function RSCDefaultRootErrorBoundaryImpl({
       }
     }
   );
-  if (_chunkXOLAXE2Zjs.isRouteErrorResponse.call(void 0, error)) {
+  if (_chunkWO3PXTPVjs.isRouteErrorResponse.call(void 0, error)) {
     return /* @__PURE__ */ _react2.default.createElement(
       ErrorWrapper,
       {
@@ -120,7 +120,7 @@ function RSCDefaultRootErrorBoundaryImpl({
         title: "Unhandled Thrown Response!"
       },
       /* @__PURE__ */ _react2.default.createElement("h1", { style: { fontSize: "24px" } }, error.status, " ", error.statusText),
-      _chunkXOLAXE2Zjs.ENABLE_DEV_WARNINGS ? heyDeveloper : null
+      _chunkWO3PXTPVjs.ENABLE_DEV_WARNINGS ? heyDeveloper : null
     );
   }
   let errorInstance;
@@ -146,7 +146,7 @@ function RSCDefaultRootErrorBoundaryImpl({
 function RSCDefaultRootErrorBoundary({
   hasRootLayout
 }) {
-  let error = _chunkXOLAXE2Zjs.useRouteError.call(void 0, );
+  let error = _chunkWO3PXTPVjs.useRouteError.call(void 0, );
   if (hasRootLayout === void 0) {
     throw new Error("Missing 'hasRootLayout' prop");
   }

package/dist/{production/chunk-TXB4YXR2.mjs → development/chunk-JEVMZMTG.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.13.1
+ * react-router v7.13.2-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -51,7 +51,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-RJCJ3EYF.mjs";
+} from "./chunk-WM3TIFYP.mjs";
 
 // lib/dom/ssr/server.tsx
 import * as React from "react";
@@ -137,6 +137,7 @@ function createRoutesStub(routes, _context) {
     if (routerRef.current == null) {
       frameworkContextRef.current = {
         future: {
+          unstable_passThroughRequests: future?.unstable_passThroughRequests === true,
           unstable_subResourceIntegrity: future?.unstable_subResourceIntegrity === true,
           v8_middleware: future?.v8_middleware === true,
           unstable_trailingSlashAwareDataRequests: future?.unstable_trailingSlashAwareDataRequests === true
@@ -154,7 +155,7 @@ function createRoutesStub(routes, _context) {
       };
       let patched = processRoutes(
         // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
-        // types compared to `AgnosticRouteObject`
+        // types compared to `RouteObject`
         convertRoutesToDataRoutes(routes, (r) => r),
         _context !== void 0 ? _context : future?.v8_middleware ? new RouterContextProvider() : {},
         frameworkContextRef.current.manifest,
@@ -505,9 +506,10 @@ function matchServerRoutes(routes, pathname, basename) {
 }
 
 // lib/server-runtime/data.ts
-async function callRouteHandler(handler, args) {
+async function callRouteHandler(handler, args, future) {
   let result = await handler({
-    request: stripRoutesParam(stripIndexParam(args.request)),
+    request: future.unstable_passThroughRequests ? args.request : stripRoutesParam(stripIndexParam(args.request)),
+    unstable_url: args.unstable_url,
     params: args.params,
     context: args.context,
     unstable_pattern: args.unstable_pattern
@@ -656,10 +658,14 @@ function createStaticHandlerDataRoutes(manifest, future, parentId = "", routesBy
             return result.data;
           }
         }
-        let val = await callRouteHandler(route.module.loader, args);
+        let val = await callRouteHandler(
+          route.module.loader,
+          args,
+          future
+        );
         return val;
       } : void 0,
-      action: route.module.action ? (args) => callRouteHandler(route.module.action, args) : void 0,
+      action: route.module.action ? (args) => callRouteHandler(route.module.action, args, future) : void 0,
       handle: route.module.handle
     };
     return route.index ? {
@@ -838,6 +844,41 @@ function parseHostHeader(headers) {
   } : void 0;
 }
 
+// lib/server-runtime/urls.ts
+function getNormalizedPath(request, basename, future) {
+  basename = basename || "/";
+  let url = new URL(request.url);
+  let pathname = url.pathname;
+  if (future?.unstable_trailingSlashAwareDataRequests) {
+    if (pathname.endsWith("/_.data")) {
+      pathname = pathname.replace(/_\.data$/, "");
+    } else {
+      pathname = pathname.replace(/\.data$/, "");
+    }
+  } else {
+    if (stripBasename(pathname, basename) === "/_root.data") {
+      pathname = basename;
+    } else if (pathname.endsWith(".data")) {
+      pathname = pathname.replace(/\.data$/, "");
+    }
+    if (stripBasename(pathname, basename) !== "/" && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+  }
+  let searchParams = new URLSearchParams(url.search);
+  searchParams.delete("_routes");
+  let search = searchParams.toString();
+  if (search) {
+    search = `?${search}`;
+  }
+  return {
+    pathname,
+    search,
+    // No hashes on the server
+    hash: ""
+  };
+}
+
 // lib/server-runtime/single-fetch.ts
 var SERVER_NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([
   ...NO_BODY_STATUS_CODES,
@@ -853,7 +894,7 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
     } catch (e) {
       return handleQueryError(new Error("Bad Request"), 400);
     }
-    let handlerRequest = new Request(handlerUrl, {
+    let handlerRequest = build.future.unstable_passThroughRequests ? request : new Request(handlerUrl, {
       method: request.method,
       body: request.body,
       headers: request.headers,
@@ -871,7 +912,8 @@ async function singleFetchAction(build, serverMode, staticHandler, request, hand
         } catch (error) {
           return handleQueryError(error);
         }
-      } : void 0
+      } : void 0,
+      unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
     });
     return handleQueryResult(result);
   } catch (error) {
@@ -920,7 +962,7 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
   let routesParam = new URL(request.url).searchParams.get("_routes");
   let loadRouteIds = routesParam ? new Set(routesParam.split(",")) : null;
   try {
-    let handlerRequest = new Request(handlerUrl, {
+    let handlerRequest = build.future.unstable_passThroughRequests ? request : new Request(handlerUrl, {
       headers: request.headers,
       signal: request.signal
     });
@@ -935,7 +977,8 @@ async function singleFetchLoaders(build, serverMode, staticHandler, request, han
         } catch (error) {
           return handleQueryError(error);
         }
-      } : void 0
+      } : void 0,
+      unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
     });
     return handleQueryResult(result);
   } catch (error) {
@@ -1132,36 +1175,23 @@ function derive(build, mode) {
     } else {
       loadContext = initialContext || {};
     }
-    let url = new URL(request.url);
-    let normalizedBasename = build.basename || "/";
-    let normalizedPath = url.pathname;
-    if (build.future.unstable_trailingSlashAwareDataRequests) {
-      if (normalizedPath.endsWith("/_.data")) {
-        normalizedPath = normalizedPath.replace(/_.data$/, "");
-      } else {
-        normalizedPath = normalizedPath.replace(/\.data$/, "");
-      }
-    } else {
-      if (stripBasename(normalizedPath, normalizedBasename) === "/_root.data") {
-        normalizedPath = normalizedBasename;
-      } else if (normalizedPath.endsWith(".data")) {
-        normalizedPath = normalizedPath.replace(/\.data$/, "");
-      }
-      if (stripBasename(normalizedPath, normalizedBasename) !== "/" && normalizedPath.endsWith("/")) {
-        normalizedPath = normalizedPath.slice(0, -1);
-      }
-    }
+    let requestUrl = new URL(request.url);
+    let normalizedPathname = getNormalizedPath(
+      request,
+      build.basename,
+      build.future
+    ).pathname;
     let isSpaMode = getBuildTimeHeader(request, "X-React-Router-SPA-Mode") === "yes";
     if (!build.ssr) {
-      let decodedPath = decodeURI(normalizedPath);
-      if (normalizedBasename !== "/") {
-        let strippedPath = stripBasename(decodedPath, normalizedBasename);
+      let decodedPath = decodeURI(normalizedPathname);
+      if (build.basename && build.basename !== "/") {
+        let strippedPath = stripBasename(decodedPath, build.basename);
         if (strippedPath == null) {
           errorHandler(
             new ErrorResponseImpl(
               404,
               "Not Found",
-              `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${normalizedBasename}\``
+              `Refusing to prerender the \`${decodedPath}\` path because it does not start with the basename \`${build.basename}\``
             ),
             {
               context: loadContext,
@@ -1179,7 +1209,7 @@ function derive(build, mode) {
       if (build.prerender.length === 0) {
         isSpaMode = true;
       } else if (!build.prerender.includes(decodedPath) && !build.prerender.includes(decodedPath + "/")) {
-        if (url.pathname.endsWith(".data")) {
+        if (requestUrl.pathname.endsWith(".data")) {
           errorHandler(
             new ErrorResponseImpl(
               404,
@@ -1203,28 +1233,26 @@ function derive(build, mode) {
     }
     let manifestUrl = getManifestPath(
       build.routeDiscovery.manifestPath,
-      normalizedBasename
+      build.basename
     );
-    if (url.pathname === manifestUrl) {
+    if (requestUrl.pathname === manifestUrl) {
       try {
-        let res = await handleManifestRequest(build, routes, url);
+        let res = await handleManifestRequest(build, routes, requestUrl);
         return res;
       } catch (e) {
         handleError(e);
         return new Response("Unknown Server Error", { status: 500 });
       }
     }
-    let matches = matchServerRoutes(routes, normalizedPath, build.basename);
+    let matches = matchServerRoutes(routes, normalizedPathname, build.basename);
     if (matches && matches.length > 0) {
       Object.assign(params, matches[0].params);
     }
     let response;
-    if (url.pathname.endsWith(".data")) {
-      let handlerUrl = new URL(request.url);
-      handlerUrl.pathname = normalizedPath;
+    if (requestUrl.pathname.endsWith(".data")) {
       let singleFetchMatches = matchServerRoutes(
         routes,
-        handlerUrl.pathname,
+        normalizedPathname,
         build.basename
       );
       response = await handleSingleFetchRequest(
@@ -1232,7 +1260,7 @@ function derive(build, mode) {
         build,
         staticHandler,
         request,
-        handlerUrl,
+        normalizedPathname,
         loadContext,
         handleError
       );
@@ -1270,7 +1298,7 @@ function derive(build, mode) {
         handleError
       );
     } else {
-      let { pathname } = url;
+      let { pathname } = requestUrl;
       let criticalCss = void 0;
       if (build.unstable_getCriticalCss) {
         criticalCss = await build.unstable_getCriticalCss({ pathname });
@@ -1383,7 +1411,9 @@ async function handleManifestRequest(build, routes, url) {
   }
   return new Response("Invalid Request", { status: 400 });
 }
-async function handleSingleFetchRequest(serverMode, build, staticHandler, request, handlerUrl, loadContext, handleError) {
+async function handleSingleFetchRequest(serverMode, build, staticHandler, request, normalizedPath, loadContext, handleError) {
+  let handlerUrl = new URL(request.url);
+  handlerUrl.pathname = normalizedPath;
   let response = request.method !== "GET" ? await singleFetchAction(
     build,
     serverMode,
@@ -1429,7 +1459,8 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
           handleError(error);
           return new Response(null, { status: 500 });
         }
-      } : void 0
+      } : void 0,
+      unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
     });
     if (!isResponse(result)) {
       result = await renderHtml(result, isSpaMode);
@@ -1561,7 +1592,8 @@ async function handleResourceRequest(serverMode, build, staticHandler, routeId,
         } catch (error) {
           return handleQueryRouteError(error);
         }
-      } : void 0
+      } : void 0,
+      unstable_normalizePath: (r) => getNormalizedPath(r, build.basename, build.future)
     });
     return handleQueryRouteResult(result);
   } catch (error) {
@@ -2388,7 +2420,9 @@ function RSCStaticRouter({ getPayload }) {
       // flags that drive runtime behavior they'll need to be proxied through.
       v8_middleware: false,
       unstable_subResourceIntegrity: false,
-      unstable_trailingSlashAwareDataRequests: true
+      unstable_trailingSlashAwareDataRequests: true,
+      // always on for RSC
+      unstable_passThroughRequests: true
       // always on for RSC
     },
     isSpaMode: false,