diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4136bb01ee..cd04244c69 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ We manage release notes in this file instead of the paginated Github Releases Pa
   <summary>Table of Contents</summary>
 
 - [React Router Releases](#react-router-releases)
+  - [v7.16.0](#v7160)
   - [v7.15.1](#v7151)
   - [v7.15.0](#v7150)
     - [Stabilizations](#stabilizations)
@@ -173,6 +174,44 @@ We manage release notes in this file instead of the paginated Github Releases Pa
 
 </details>
 
+## v7.16.0
+
+Date: 2026-05-28
+
+### What's Changed
+
+#### Stabilized `future.v8_trailingSlashAwareDataRequests`
+
+We've stabilized this flag in preparation for the upcoming v8 release. Unless you are doing specific path-inspection on `.data` requests or have specific CDN/caching/pre-rendering logic around `.data` requests, this should largely be a zero-code-change adoptions. Please see the [docs](https://reactrouter.com/upgrading/future#futurev8_trailingslashawaredatarequests) for more info.
+
+#### Pre-v8 Future Flag Warnings
+
+In preparation for the upcoming v8 release, `7.16.0` begins logging console warnings during builds for future flags that you have not enabled yet. If you have all future flags enabled, the v8 upgrade should be mostly non-breaking (short of some underlying dependency minimum versions bumps - React 19, Node 22.12, Vite 7). You can suppress these warnings until you are ready top adopt flags by setting an explicit `false` in your `react-router.config.ts`.
+
+### Minor Changes
+
+- `react-router` - Stabilize `future.unstable_trailingSlashAwareDataRequests` as `future.v8_trailingSlashAwareDataRequests` ([#15098](https://github.com/remix-run/react-router/pull/15098))
+- `@react-router/dev` - Log future flag warnings for upcoming React Router v8 flags ([#15029](https://github.com/remix-run/react-router/pull/15029))
+  - `v8_middleware`, `v8_splitRouteModules`, `v8_viteEnvironmentApi`, `v8_passThroughRequests`, `v8_trailingSlashAwareDataRequests`
+
+### Patch Changes
+
+- `react-router` - Disable manifest path when lazy route discovery is disabled ([#15068](https://github.com/remix-run/react-router/pull/15068))
+- `react-router` - Fix browser URL creation to use the configured history `window` instead of the global `window` ([#15066](https://github.com/remix-run/react-router/pull/15066))
+  - Pass the history/router window through to `createBrowserURLImpl` so custom window contexts keep the correct URL origin.
+- `react-router` - Fix `useNavigation()` return type to preserve discriminated union across navigation states ([#15095](https://github.com/remix-run/react-router/pull/15095))
+- `react-router` - Widen `MetaDescriptor` `script:ld+json` type from `LdJsonObject` to `LdJsonObject | LdJsonObject[]` to permit multiple JSON-LD schemas in a single `<script type="application/ld+json">` tag emitted by `<Meta />` ([#15082](https://github.com/remix-run/react-router/pull/15082))
+- `react-router-dom` - Remove stale/invalid `unpkg` field from `package.json` ([#15075](https://github.com/remix-run/react-router/pull/15075))
+  - This was removed from other packages with the release of v7 but missed in the `react-router-dom` re-export package
+- `@react-router/express` - Ignore writes after Express responses close ([#15107](https://github.com/remix-run/react-router/pull/15107))
+  - Avoid surfacing client disconnects as adapter errors when the response stream has already been destroyed or ended
+- `@react-router/node` - Honor Node writable backpressure in `writeReadableStreamToWritable` and `writeAsyncIterableToWritable` ([#15071](https://github.com/remix-run/react-router/pull/15071))
+  - Await `'drain'` when `writable.write()` returns `false` instead of letting chunks accumulate in the writable's internal buffer
+  - Reject (rather than hang) if the writable errors or closes mid-stream
+- `@react-router/serve` - Normalize `assetsBuildDirectory` path separators in `react-router-serve` so Windows-built server artifacts can serve `/assets/*` correctly when run on Linux ([#14982](https://github.com/remix-run/react-router/pull/14982))
+
+**Full Changelog**: [`v7.15.1...v7.16.0`](https://github.com/remix-run/react-router/compare/react-router@7.15.1...react-router@7.16.0)
+
 ## v7.15.1
 
 Date: 2026-05-14
diff --git a/contributors.yml b/contributors.yml
index d1fb4af96a..66160fc8dc 100644
--- a/contributors.yml
+++ b/contributors.yml
@@ -94,6 +94,7 @@
 - codeape2
 - coolport
 - coryhouse
+- csamuel
 - ctnelson1997
 - cvbuelow
 - dadamssg
@@ -164,6 +165,7 @@
 - harucn
 - HelpMe-Pls
 - HenriqueLimas
+- henryqdineen
 - hernanif1
 - HeyyyNeo
 - hi-ogawa
@@ -174,6 +176,7 @@
 - hsbtr
 - hyesungoh
 - iamnishanth
+- ianduvall
 - ianflynnwork
 - IbraRouisDev
 - igniscyan
@@ -202,6 +205,7 @@
 - jb-1980
 - jclarkin
 - jdufresne
+- jeevan6996
 - jenseng
 - JeraldVin
 - JesusTheHun
diff --git a/docs/api/hooks/useNavigation.md b/docs/api/hooks/useNavigation.md
index f8b8c976ee..d02ab9fabd 100644
--- a/docs/api/hooks/useNavigation.md
+++ b/docs/api/hooks/useNavigation.md
@@ -41,7 +41,7 @@ function SomeComponent() {
 ## Signature
 
 ```tsx
-function useNavigation(): Omit<Navigation, "matches" | "historyAction">
+function useNavigation(): UseNavigationResult
 ```
 
 ## Returns
diff --git a/docs/upgrading/future.md b/docs/upgrading/future.md
index 4f2fb63c7b..5124615305 100644
--- a/docs/upgrading/future.md
+++ b/docs/upgrading/future.md
@@ -182,6 +182,59 @@ export async function loader({
 }
 ```
 
+## `future.v8_trailingSlashAwareDataRequests`
+
+[MODES: framework]
+
+<br/>
+<br/>
+
+**Background**
+
+React Router serves Framework mode data requests from `.data` URLs. Previously, data requests for routes with and without trailing slashes could map to the same `.data` URL because trailing slashes were not considered during URL generation. This flag preserves trailing slash semantics for data request URLs to avoid ambiguity when your app distinguishes between trailing-slash and non-trailing-slash URLs.
+
+Currently, your HTTP and `request` pathnames would be as follows for `/a/b/c` and `/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` ✅             |
+
+| URL `/a/b/c/` | **HTTP pathname** | **`request` pathname`** |
+| ------------- | ----------------- | ----------------------- |
+| **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` ✅             |
+
+| URL `/a/b/c/` | **HTTP pathname**  | **`request` pathname`** |
+| ------------- | ------------------ | ----------------------- |
+| **Document**  | `/a/b/c/`          | `/a/b/c/` ✅            |
+| **Data**      | `/a/b/c/_.data` ⬅️ | `/a/b/c/` ✅            |
+
+This flag also aligns the root data request to match this behavior by changing it from `/_root.data` to `/_.data`.
+
+👉 **Enable the Flag**
+
+```ts filename=react-router.config.ts
+import type { Config } from "@react-router/dev/config";
+
+export default {
+  future: {
+    v8_trailingSlashAwareDataRequests: true,
+  },
+} satisfies Config;
+```
+
+**Update your Code**
+
+If you have custom app, CDN, cache, or rewrite logic that matches `.data` request URLs, update it to handle the new trailing-slash-aware `/_.data` format.
+
 ## Unstable Future Flags (Optional)
 
 We document some [unstable] flags here as a reference for folks contributing to the project via beta testing, but they are not generally recommended for production use and may having breaking changes patch/minor releases - adopt with caution!
diff --git a/integration/cli-test.ts b/integration/cli-test.ts
index 366dfa71c4..77b99c5eae 100644
--- a/integration/cli-test.ts
+++ b/integration/cli-test.ts
@@ -112,7 +112,17 @@ test.describe("cli", () => {
   test("routes", async () => {
     const cwd = await createProject();
     let { stdout, stderr, status } = run(["routes"], { cwd });
-    expect(stdout.toString().trim()).toBe(dedent`
+
+    // Filter out future flag warnings for the format:
+    // ⚠️  Future Flag Warning: Route module splitting behavior is changing in React Router v8.
+    //     You can use the `future.v8_splitRouteModules` flag to opt in early.
+    //     -> https://reactrouter.com/upgrading/future-flags#v8_splitRouteModules
+    let filteredStdOut = stdout.toString().split("\n");
+    while (filteredStdOut[0]?.includes("Future Flag Warning:")) {
+      filteredStdOut.splice(0, 3);
+    }
+
+    expect(filteredStdOut.join("\n").trim()).toBe(dedent`
       <Routes>
         <Route file="root.tsx">
           <Route index file="routes/_index.tsx" />
diff --git a/integration/fetcher-layout-test.ts b/integration/fetcher-layout-test.ts
index 09397ce5bb..3b40a528a7 100644
--- a/integration/fetcher-layout-test.ts
+++ b/integration/fetcher-layout-test.ts
@@ -255,7 +255,7 @@ test("fetcher calls layout route loader when at parameterized route", async ({
   expect(dataElement.text()).toBe("layout loader data");
 });
 
-test("fetcher calls parameterized route route action", async ({ page }) => {
+test("fetcher calls parameterized route action", async ({ page }) => {
   let app = new PlaywrightFixture(appFixture, page);
   await app.goto("/layout-action/foo");
   await app.clickElement("#param-fetcher");
@@ -266,7 +266,7 @@ test("fetcher calls parameterized route route action", async ({ page }) => {
   expect(dataElement.text()).toBe("foo");
 });
 
-test("fetcher calls parameterized route route loader", async ({ page }) => {
+test("fetcher calls parameterized route loader", async ({ page }) => {
   let app = new PlaywrightFixture(appFixture, page);
   await app.goto("/layout-loader/foo");
   await app.clickElement("#param-fetcher");
diff --git a/integration/single-fetch-test.ts b/integration/single-fetch-test.ts
index 614ab84272..5ad237e568 100644
--- a/integration/single-fetch-test.ts
+++ b/integration/single-fetch-test.ts
@@ -4567,7 +4567,7 @@ test.describe("single-fetch", () => {
     expect(await app.getHtml("h1")).toMatch("It worked!");
   });
 
-  test("always uses /{path}.data without future.unstable_trailingSlashAwareDataRequests flag", async ({
+  test("always uses /{path}.data without future.v8_trailingSlashAwareDataRequests flag", async ({
     page,
   }) => {
     let fixture = await createFixture({
@@ -4659,7 +4659,7 @@ test.describe("single-fetch", () => {
     requests = [];
   });
 
-  test("uses {path}.data or {path}/_.data depending on trailing slash with future.unstable_trailingSlashAwareDataRequests flag", async ({
+  test("uses {path}.data or {path}/_.data depending on trailing slash with future.v8_trailingSlashAwareDataRequests flag", async ({
     page,
   }) => {
     let fixture = await createFixture({
@@ -4667,7 +4667,7 @@ test.describe("single-fetch", () => {
         ...files,
         "react-router.config.ts": reactRouterConfig({
           future: {
-            unstable_trailingSlashAwareDataRequests: true,
+            v8_trailingSlashAwareDataRequests: true,
           },
         }),
         "app/routes/_index.tsx": js`
diff --git a/integration/vite-presets-test.ts b/integration/vite-presets-test.ts
index a15aa2bd68..6dd6d43064 100644
--- a/integration/vite-presets-test.ts
+++ b/integration/vite-presets-test.ts
@@ -246,7 +246,7 @@ test.describe("Vite / presets", async () => {
       // Ensure future flags from presets are properly merged
       expect(buildEndArgsMeta.futureFlags).toEqual({
         unstable_optimizeDeps: true,
-        unstable_trailingSlashAwareDataRequests: false,
+        v8_trailingSlashAwareDataRequests: false,
         unstable_previewServerPrerendering: false,
         v8_middleware: true,
         v8_passThroughRequests: false,
diff --git a/packages/create-react-router/CHANGELOG.md b/packages/create-react-router/CHANGELOG.md
index d2660654de..d6f143fbd4 100644
--- a/packages/create-react-router/CHANGELOG.md
+++ b/packages/create-react-router/CHANGELOG.md
@@ -1,5 +1,11 @@
 # `create-react-router`
 
+## v7.16.0
+
+### Patch Changes
+
+- _No changes_
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/create-react-router/package.json b/packages/create-react-router/package.json
index d07d29d524..0028d930f1 100644
--- a/packages/create-react-router/package.json
+++ b/packages/create-react-router/package.json
@@ -1,6 +1,6 @@
 {
   "name": "create-react-router",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Create a new React Router app",
   "homepage": "https://reactrouter.com",
   "bugs": {
diff --git a/packages/react-router-architect/CHANGELOG.md b/packages/react-router-architect/CHANGELOG.md
index 70e3b9f2b9..e3acd09f5e 100644
--- a/packages/react-router-architect/CHANGELOG.md
+++ b/packages/react-router-architect/CHANGELOG.md
@@ -1,5 +1,13 @@
 # `@react-router/architect`
 
+## v7.16.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+  - [`@react-router/node@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/node@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-architect/package.json b/packages/react-router-architect/package.json
index c4e00cc399..5b39f8953b 100644
--- a/packages/react-router-architect/package.json
+++ b/packages/react-router-architect/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/architect",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Architect server request handler for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-cloudflare/CHANGELOG.md b/packages/react-router-cloudflare/CHANGELOG.md
index 9c4c30b91d..73fe51a5d1 100644
--- a/packages/react-router-cloudflare/CHANGELOG.md
+++ b/packages/react-router-cloudflare/CHANGELOG.md
@@ -1,5 +1,12 @@
 # `@react-router/cloudflare`
 
+## v7.16.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-cloudflare/package.json b/packages/react-router-cloudflare/package.json
index 2c7ec7d471..400e2c8e84 100644
--- a/packages/react-router-cloudflare/package.json
+++ b/packages/react-router-cloudflare/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/cloudflare",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Cloudflare platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-dev/CHANGELOG.md b/packages/react-router-dev/CHANGELOG.md
index e3670fd2bd..47d75c2079 100644
--- a/packages/react-router-dev/CHANGELOG.md
+++ b/packages/react-router-dev/CHANGELOG.md
@@ -1,5 +1,22 @@
 # `@react-router/dev`
 
+## v7.16.0
+
+### Minor Changes
+
+- Stabilize `future.unstable_trailingSlashAwareDataRequests` as `future.v8_trailingSlashAwareDataRequests` ([#15098](https://github.com/remix-run/react-router/pull/15098))
+  - The unstable flag is no longer supported and will error during config resolution
+
+- Log future flag warnings for upcoming React Router v8 flags ([#15029](https://github.com/remix-run/react-router/pull/15029))
+  - `v8_middleware`, `v8_splitRouteModules`, `v8_viteEnvironmentApi`, `v8_passThroughRequests`, `v8_trailingSlashAwareDataRequests`
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+  - [`@react-router/node@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/node@7.16.0)
+  - [`@react-router/serve@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/serve@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-dev/__tests__/future-flags-test.ts b/packages/react-router-dev/__tests__/future-flags-test.ts
new file mode 100644
index 0000000000..03b87ce3ed
--- /dev/null
+++ b/packages/react-router-dev/__tests__/future-flags-test.ts
@@ -0,0 +1,66 @@
+import { logFutureFlagWarnings } from "../config/config";
+
+describe("logFutureFlagWarnings", () => {
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("warns about all stable v8_ flags when none are set", () => {
+    logFutureFlagWarnings({});
+
+    expect(logSpy).toHaveBeenCalledTimes(5);
+    expect(logSpy.mock.calls[0][0]).toContain("v8_middleware");
+    expect(logSpy.mock.calls[1][0]).toContain("v8_splitRouteModules");
+    expect(logSpy.mock.calls[2][0]).toContain("v8_viteEnvironmentApi");
+    expect(logSpy.mock.calls[3][0]).toContain("v8_passThroughRequests");
+    expect(logSpy.mock.calls[4][0]).toContain(
+      "v8_trailingSlashAwareDataRequests",
+    );
+  });
+
+  it("does not warn about flags that are already opted in (true)", () => {
+    logFutureFlagWarnings({
+      v8_middleware: true,
+      v8_splitRouteModules: true,
+      v8_viteEnvironmentApi: true,
+      v8_passThroughRequests: true,
+      v8_trailingSlashAwareDataRequests: true,
+    });
+
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("does not warn about flags that are explicitly opted out (false)", () => {
+    logFutureFlagWarnings({
+      v8_middleware: false,
+      v8_splitRouteModules: false,
+      v8_viteEnvironmentApi: false,
+      v8_passThroughRequests: false,
+      v8_trailingSlashAwareDataRequests: false,
+    });
+
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("only warns about flags that are not yet set", () => {
+    logFutureFlagWarnings({
+      v8_middleware: true,
+      v8_passThroughRequests: false,
+    });
+
+    // Only v8_splitRouteModules, v8_viteEnvironmentApi, and
+    // v8_trailingSlashAwareDataRequests are missing
+    expect(logSpy).toHaveBeenCalledTimes(3);
+    expect(logSpy.mock.calls[0][0]).toContain("v8_splitRouteModules");
+    expect(logSpy.mock.calls[1][0]).toContain("v8_viteEnvironmentApi");
+    expect(logSpy.mock.calls[2][0]).toContain(
+      "v8_trailingSlashAwareDataRequests",
+    );
+  });
+});
diff --git a/packages/react-router-dev/config/config.ts b/packages/react-router-dev/config/config.ts
index 52d1ff1f1d..104fdf2551 100644
--- a/packages/react-router-dev/config/config.ts
+++ b/packages/react-router-dev/config/config.ts
@@ -87,7 +87,7 @@ type ValidateConfigFunction = (config: ReactRouterConfig) => string | void;
 interface FutureConfig {
   unstable_optimizeDeps: boolean;
   v8_passThroughRequests: boolean;
-  unstable_trailingSlashAwareDataRequests: boolean;
+  v8_trailingSlashAwareDataRequests: boolean;
   /**
    * Prerender with Vite Preview server
    */
@@ -702,6 +702,11 @@ async function resolveConfig({
         "The `future.unstable_passThroughRequests` flag has been stabilized as `future.v8_passThroughRequests`",
       );
     }
+    if ("unstable_trailingSlashAwareDataRequests" in futureConfig) {
+      return err(
+        "The `future.unstable_trailingSlashAwareDataRequests` flag has been stabilized as `future.v8_trailingSlashAwareDataRequests`",
+      );
+    }
     if ("unstable_subResourceIntegrity" in futureConfig) {
       return err(
         "The `future.unstable_subResourceIntegrity` flag has been stabilized and moved to a top-level `config.subResourceIntegrity` field",
@@ -714,9 +719,8 @@ async function resolveConfig({
       userAndPresetConfigs.future?.unstable_optimizeDeps ?? false,
     v8_passThroughRequests:
       userAndPresetConfigs.future?.v8_passThroughRequests ?? false,
-    unstable_trailingSlashAwareDataRequests:
-      userAndPresetConfigs.future?.unstable_trailingSlashAwareDataRequests ??
-      false,
+    v8_trailingSlashAwareDataRequests:
+      userAndPresetConfigs.future?.v8_trailingSlashAwareDataRequests ?? false,
     unstable_previewServerPrerendering:
       userAndPresetConfigs.future?.unstable_previewServerPrerendering ?? false,
     v8_middleware: userAndPresetConfigs.future?.v8_middleware ?? false,
@@ -753,9 +757,54 @@ async function resolveConfig({
     await preset.reactRouterConfigResolved?.({ reactRouterConfig });
   }
 
+  logFutureFlagWarnings(userAndPresetConfigs.future || {});
+
   return ok(reactRouterConfig);
 }
 
+function logFutureFlagWarning(flag: string, message: string): void {
+  console.log(
+    colors.yellow(
+      `  ⚠️  Future Flag Warning: ${message}\n` +
+        `     You can use the \`future.${flag}\` flag to opt in early.\n` +
+        `     -> https://reactrouter.com/upgrading/future-flags#${flag}`,
+    ),
+  );
+}
+
+export function logFutureFlagWarnings(future: Partial<FutureConfig>): void {
+  if (future.v8_middleware === undefined) {
+    logFutureFlagWarning(
+      "v8_middleware",
+      "Route middleware support is changing in React Router v8.",
+    );
+  }
+  if (future.v8_splitRouteModules === undefined) {
+    logFutureFlagWarning(
+      "v8_splitRouteModules",
+      "Route module splitting behavior is changing in React Router v8.",
+    );
+  }
+  if (future.v8_viteEnvironmentApi === undefined) {
+    logFutureFlagWarning(
+      "v8_viteEnvironmentApi",
+      "Vite Environment API usage is changing in React Router v8.",
+    );
+  }
+  if (future.v8_passThroughRequests === undefined) {
+    logFutureFlagWarning(
+      "v8_passThroughRequests",
+      "Request handling behavior is changing in React Router v8.",
+    );
+  }
+  if (future.v8_trailingSlashAwareDataRequests === undefined) {
+    logFutureFlagWarning(
+      "v8_trailingSlashAwareDataRequests",
+      "Data request URL formats are changing in React Router v8.",
+    );
+  }
+}
+
 type ChokidarEventName = ChokidarEmitArgs[0];
 
 type ChangeHandler = (args: {
diff --git a/packages/react-router-dev/package.json b/packages/react-router-dev/package.json
index 73b3786aba..48c2a4e782 100644
--- a/packages/react-router-dev/package.json
+++ b/packages/react-router-dev/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/dev",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Dev tools and CLI for React Router",
   "homepage": "https://reactrouter.com",
   "bugs": {
diff --git a/packages/react-router-dev/vite/plugin.ts b/packages/react-router-dev/vite/plugin.ts
index 14fbacb8e4..25281a6a50 100644
--- a/packages/react-router-dev/vite/plugin.ts
+++ b/packages/react-router-dev/vite/plugin.ts
@@ -3312,7 +3312,7 @@ async function prerenderData(
   requestInit?: RequestInit,
 ) {
   let dataRequestPath: string;
-  if (reactRouterConfig.future.unstable_trailingSlashAwareDataRequests) {
+  if (reactRouterConfig.future.v8_trailingSlashAwareDataRequests) {
     if (prerenderPath.endsWith("/")) {
       dataRequestPath = `${prerenderPath}_.data`;
     } else {
diff --git a/packages/react-router-dom/CHANGELOG.md b/packages/react-router-dom/CHANGELOG.md
index 1d2f456bc6..a1bda8bdee 100644
--- a/packages/react-router-dom/CHANGELOG.md
+++ b/packages/react-router-dom/CHANGELOG.md
@@ -1,5 +1,13 @@
 # react-router-dom
 
+## v7.16.0
+
+### Patch Changes
+
+- Remove stale/invalid `unpkg` field from `package.json`. This was removed from other packages with the release of v7 but missed in the `react-router-dom` re-export package ([#15075](https://github.com/remix-run/react-router/pull/15075))
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-dom/package.json b/packages/react-router-dom/package.json
index fd24333062..1a6f69a153 100644
--- a/packages/react-router-dom/package.json
+++ b/packages/react-router-dom/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-router-dom",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Declarative routing for React web applications",
   "keywords": [
     "react",
@@ -19,7 +19,6 @@
   "author": "Remix Software <hello@remix.run>",
   "sideEffects": false,
   "main": "./dist/main.js",
-  "unpkg": "./dist/umd/react-router-dom.production.min.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
diff --git a/packages/react-router-express/CHANGELOG.md b/packages/react-router-express/CHANGELOG.md
index fcf70d9e0a..3e33abf188 100644
--- a/packages/react-router-express/CHANGELOG.md
+++ b/packages/react-router-express/CHANGELOG.md
@@ -1,5 +1,16 @@
 # `@react-router/express`
 
+## v7.16.0
+
+### Patch Changes
+
+- Ignore writes after Express responses close ([#15107](https://github.com/remix-run/react-router/pull/15107))
+  - Avoid surfacing client disconnects as adapter errors when the response stream has already been destroyed or ended.
+
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+  - [`@react-router/node@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/node@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-express/__tests__/server-test.ts b/packages/react-router-express/__tests__/server-test.ts
index 39013b9704..feccbf5af8 100644
--- a/packages/react-router-express/__tests__/server-test.ts
+++ b/packages/react-router-express/__tests__/server-test.ts
@@ -1,4 +1,6 @@
 import { Readable } from "node:stream";
+import type { AddressInfo } from "node:net";
+import http from "node:http";
 import { createRequestHandler as createRemixRequestHandler } from "react-router";
 import { createReadableStreamFromReadable } from "@react-router/node";
 import express from "express";
@@ -150,6 +152,70 @@ describe("express createRequestHandler", () => {
         "third=three; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Path=/; HttpOnly; Secure; SameSite=Lax",
       ]);
     });
+
+    it("ignores response writes after the client disconnects", async () => {
+      let server: http.Server | undefined;
+      let errors: unknown[] = [];
+      let closeServerTimeout: ReturnType<typeof setTimeout> | undefined;
+      let handlerStarted!: () => void;
+      let handlerStartedPromise = new Promise<void>((resolve) => {
+        handlerStarted = resolve;
+      });
+
+      mockedCreateRequestHandler.mockImplementation(() => async (req) => {
+        handlerStarted();
+
+        await new Promise<void>((resolve) => {
+          req.signal.addEventListener("abort", () => resolve(), {
+            once: true,
+          });
+        });
+
+        let readable = Readable.from("hello world");
+        let stream = createReadableStreamFromReadable(readable);
+        closeServerTimeout = setTimeout(() => server?.close(), 25);
+        return new Response(stream, { status: 200 });
+      });
+
+      let app = createApp();
+      app.use(
+        (
+          error: unknown,
+          _req: express.Request,
+          _res: express.Response,
+          _next: express.NextFunction,
+        ) => {
+          errors.push(error);
+          server?.close();
+        },
+      );
+
+      await new Promise<void>((resolve) => {
+        server = app.listen(0, "127.0.0.1", () => resolve());
+      });
+
+      let { port } = server.address() as AddressInfo;
+      let request = http.get({
+        host: "127.0.0.1",
+        port,
+        path: "/",
+      });
+
+      request.on("error", () => {});
+      await handlerStartedPromise;
+      request.destroy();
+
+      await new Promise<void>((resolve, reject) => {
+        server!.on("close", () => resolve());
+        setTimeout(
+          () => reject(new Error("Timed out waiting for server to close")),
+          1000,
+        );
+      });
+
+      clearTimeout(closeServerTimeout);
+      expect(errors).toEqual([]);
+    });
   });
 });
 
diff --git a/packages/react-router-express/package.json b/packages/react-router-express/package.json
index d1d032cf5a..108111516d 100644
--- a/packages/react-router-express/package.json
+++ b/packages/react-router-express/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/express",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Express server request handler for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-express/server.ts b/packages/react-router-express/server.ts
index e6238b1fa1..16e98ba443 100644
--- a/packages/react-router-express/server.ts
+++ b/packages/react-router-express/server.ts
@@ -139,6 +139,11 @@ export async function sendRemixResponse(
   res: express.Response,
   nodeResponse: Response,
 ): Promise<void> {
+  if (isResponseClosed(res)) {
+    await nodeResponse.body?.cancel();
+    return;
+  }
+
   res.statusMessage = nodeResponse.statusText;
   res.status(nodeResponse.status);
 
@@ -151,8 +156,20 @@ export async function sendRemixResponse(
   }
 
   if (nodeResponse.body) {
-    await writeReadableStreamToWritable(nodeResponse.body, res);
+    try {
+      await writeReadableStreamToWritable(nodeResponse.body, res);
+    } catch (error) {
+      if (isResponseClosed(res)) {
+        return;
+      }
+
+      throw error;
+    }
   } else {
     res.end();
   }
 }
+
+function isResponseClosed(res: express.Response): boolean {
+  return res.destroyed || res.writableEnded;
+}
diff --git a/packages/react-router-fs-routes/CHANGELOG.md b/packages/react-router-fs-routes/CHANGELOG.md
index 41576ed098..3053e177b2 100644
--- a/packages/react-router-fs-routes/CHANGELOG.md
+++ b/packages/react-router-fs-routes/CHANGELOG.md
@@ -1,5 +1,12 @@
 # `@react-router/fs-routes`
 
+## v7.16.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`@react-router/dev@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/dev@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-fs-routes/package.json b/packages/react-router-fs-routes/package.json
index d708724e0f..015656d848 100644
--- a/packages/react-router-fs-routes/package.json
+++ b/packages/react-router-fs-routes/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/fs-routes",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "File system routing conventions for React Router, for use within routes.ts",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-node/CHANGELOG.md b/packages/react-router-node/CHANGELOG.md
index cb83fd3916..530222ab0c 100644
--- a/packages/react-router-node/CHANGELOG.md
+++ b/packages/react-router-node/CHANGELOG.md
@@ -1,5 +1,16 @@
 # `@react-router/node`
 
+## v7.16.0
+
+### Patch Changes
+
+- Honor Node writable backpressure in `writeReadableStreamToWritable` and `writeAsyncIterableToWritable` ([#15071](https://github.com/remix-run/react-router/pull/15071))
+  - Await `'drain'` when `writable.write()` returns `false` instead of letting chunks accumulate in the writable's internal buffer.
+  - Reject (rather than hang) if the writable errors or closes mid-stream.
+
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-node/__tests__/stream-test.ts b/packages/react-router-node/__tests__/stream-test.ts
new file mode 100644
index 0000000000..459e80ad88
--- /dev/null
+++ b/packages/react-router-node/__tests__/stream-test.ts
@@ -0,0 +1,140 @@
+/**
+ * @jest-environment node
+ */
+
+import { Writable } from "node:stream";
+
+import {
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable,
+} from "../stream";
+
+function createBackpressureSamplingWritable(
+  highWaterMark: number,
+  writeDelayMs: number,
+) {
+  let writable: Writable = new Writable({
+    highWaterMark,
+    write(_chunk, _encoding, callback) {
+      setTimeout(callback, writeDelayMs);
+    },
+  });
+
+  let maxBufferedLength = 0;
+  let originalWrite = writable.write.bind(writable);
+  writable.write = function (chunk: any, ...rest: any[]) {
+    let result = originalWrite(chunk, ...rest);
+    maxBufferedLength = Math.max(maxBufferedLength, writable.writableLength);
+    return result;
+  } as typeof writable.write;
+
+  return {
+    writable,
+    getMaxBufferedLength: () => maxBufferedLength,
+  };
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout>;
+  let timeoutPromise = new Promise<never>((_, reject) => {
+    timeout = setTimeout(() => reject(new Error("Timed out")), ms);
+  });
+
+  return Promise.race([promise, timeoutPromise]).finally(() =>
+    clearTimeout(timeout),
+  );
+}
+
+describe("writeReadableStreamToWritable", () => {
+  it("respects writable backpressure", async () => {
+    let highWaterMark = 16;
+    let chunkSize = 8;
+    let numChunks = 100;
+    let { writable, getMaxBufferedLength } = createBackpressureSamplingWritable(
+      highWaterMark,
+      5,
+    );
+
+    let readable = new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (let i = 0; i < numChunks; i++) {
+          controller.enqueue(new Uint8Array(chunkSize));
+        }
+        controller.close();
+      },
+    });
+
+    await writeReadableStreamToWritable(readable, writable);
+
+    expect(getMaxBufferedLength()).toBeLessThanOrEqual(
+      highWaterMark + chunkSize,
+    );
+  });
+
+  it("rejects if the writable errors while waiting for the next chunk", async () => {
+    let writableError = new Error("Writable failed");
+    let writable = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      },
+    });
+    let readable = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array(1));
+      },
+    });
+
+    let writePromise = writeReadableStreamToWritable(readable, writable);
+
+    setTimeout(() => writable.destroy(writableError), 10);
+
+    await expect(withTimeout(writePromise, 100)).rejects.toThrow(
+      "Writable failed",
+    );
+  });
+});
+
+describe("writeAsyncIterableToWritable", () => {
+  it("respects writable backpressure", async () => {
+    let highWaterMark = 16;
+    let chunkSize = 8;
+    let numChunks = 100;
+    let { writable, getMaxBufferedLength } = createBackpressureSamplingWritable(
+      highWaterMark,
+      5,
+    );
+
+    async function* chunks() {
+      for (let i = 0; i < numChunks; i++) {
+        yield new Uint8Array(chunkSize);
+      }
+    }
+
+    await writeAsyncIterableToWritable(chunks(), writable);
+
+    expect(getMaxBufferedLength()).toBeLessThanOrEqual(
+      highWaterMark + chunkSize,
+    );
+  });
+
+  it("rejects if the writable closes while waiting for the next chunk", async () => {
+    let writable = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      },
+    });
+
+    async function* chunks() {
+      yield new Uint8Array(1);
+      await new Promise<never>(() => {});
+    }
+
+    let writePromise = writeAsyncIterableToWritable(chunks(), writable);
+
+    setTimeout(() => writable.destroy(), 10);
+
+    await expect(withTimeout(writePromise, 100)).rejects.toThrow(
+      "Writable closed before stream finished",
+    );
+  });
+});
diff --git a/packages/react-router-node/package.json b/packages/react-router-node/package.json
index 9b1251a58e..9125ff2ca8 100644
--- a/packages/react-router-node/package.json
+++ b/packages/react-router-node/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/node",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Node.js platform abstractions for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-node/stream.ts b/packages/react-router-node/stream.ts
index 806dd25e68..ae155121b1 100644
--- a/packages/react-router-node/stream.ts
+++ b/packages/react-router-node/stream.ts
@@ -7,39 +7,169 @@ export async function writeReadableStreamToWritable(
 ) {
   let reader = stream.getReader();
   let flushable = writable as { flush?: Function };
+  let writableError = monitorWritableError(writable);
 
   try {
     while (true) {
-      let { done, value } = await reader.read();
+      writableError.throwIfClosed();
+
+      let { done, value } = await writableError.race(reader.read());
 
       if (done) {
         writable.end();
         break;
       }
 
-      writable.write(value);
+      writableError.throwIfClosed();
+
+      let canContinueWriting = writable.write(value);
       if (typeof flushable.flush === "function") {
         flushable.flush();
       }
+
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
   } catch (error: unknown) {
+    try {
+      reader.cancel(error).catch(() => {});
+    } catch {
+      // Ignore cancellation errors so we preserve the original write failure.
+    }
     writable.destroy(error as Error);
     throw error;
+  } finally {
+    writableError.cleanup();
+    try {
+      reader.releaseLock();
+    } catch {
+      // Ignore release errors so we preserve the original write failure.
+    }
   }
 }
 
+interface WritableErrorMonitor {
+  cleanup(): void;
+  race<T>(promise: Promise<T>): Promise<T>;
+  throwIfClosed(): void;
+}
+
+function monitorWritableError(writable: Writable): WritableErrorMonitor {
+  let settled = false;
+  let writableError: Error | undefined;
+  let rejectWritableError!: (error: Error) => void;
+  let writableErrorPromise = new Promise<never>((_, reject) => {
+    rejectWritableError = reject;
+  });
+  writableErrorPromise.catch(() => {});
+
+  function cleanup() {
+    writable.off("error", onError);
+    writable.off("close", onClose);
+  }
+
+  function reject(error: Error) {
+    if (settled) {
+      return;
+    }
+
+    settled = true;
+    writableError = error;
+    cleanup();
+    rejectWritableError(error);
+  }
+
+  function onError(error: Error) {
+    reject(error);
+  }
+
+  function onClose() {
+    reject(new Error("Writable closed before stream finished"));
+  }
+
+  writable.once("error", onError);
+  writable.once("close", onClose);
+
+  return {
+    cleanup,
+    race<T>(promise: Promise<T>) {
+      return Promise.race([promise, writableErrorPromise]);
+    },
+    throwIfClosed() {
+      if (writableError) {
+        throw writableError;
+      }
+
+      if (writable.destroyed || writable.writableEnded) {
+        throw new Error("Cannot write to a destroyed or ended writable stream");
+      }
+    },
+  };
+}
+
+function waitForDrain(
+  writable: Writable,
+  writableError: WritableErrorMonitor,
+): Promise<void> {
+  let cleanup = () => {};
+  let drainPromise = new Promise<void>((resolve) => {
+    function onDrain() {
+      cleanup();
+      resolve();
+    }
+
+    cleanup = function cleanup() {
+      writable.off("drain", onDrain);
+    };
+
+    writable.once("drain", onDrain);
+  });
+
+  return writableError.race(drainPromise).finally(cleanup);
+}
+
 export async function writeAsyncIterableToWritable(
   iterable: AsyncIterable<Uint8Array>,
   writable: Writable,
 ) {
+  let writableError = monitorWritableError(writable);
+  let iterator = iterable[Symbol.asyncIterator]();
+  let completed = false;
+
   try {
-    for await (let chunk of iterable) {
-      writable.write(chunk);
+    while (true) {
+      writableError.throwIfClosed();
+
+      let { done, value: chunk } = await writableError.race(iterator.next());
+
+      if (done) {
+        completed = true;
+        break;
+      }
+
+      writableError.throwIfClosed();
+
+      let canContinueWriting = writable.write(chunk);
+
+      if (!canContinueWriting) {
+        await waitForDrain(writable, writableError);
+      }
     }
+
     writable.end();
   } catch (error: any) {
+    if (!completed) {
+      try {
+        Promise.resolve(iterator.return?.()).catch(() => {});
+      } catch {
+        // Ignore return errors so we preserve the original write failure.
+      }
+    }
     writable.destroy(error);
     throw error;
+  } finally {
+    writableError.cleanup();
   }
 }
 
diff --git a/packages/react-router-remix-routes-option-adapter/CHANGELOG.md b/packages/react-router-remix-routes-option-adapter/CHANGELOG.md
index c1f94e351c..f2a02f3a79 100644
--- a/packages/react-router-remix-routes-option-adapter/CHANGELOG.md
+++ b/packages/react-router-remix-routes-option-adapter/CHANGELOG.md
@@ -1,5 +1,12 @@
 # `@react-router/remix-config-routes-adapter`
 
+## v7.16.0
+
+### Patch Changes
+
+- Updated dependencies:
+  - [`@react-router/dev@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/dev@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-remix-routes-option-adapter/package.json b/packages/react-router-remix-routes-option-adapter/package.json
index e64868b444..6bfecb2d2f 100644
--- a/packages/react-router-remix-routes-option-adapter/package.json
+++ b/packages/react-router-remix-routes-option-adapter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/remix-routes-option-adapter",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Adapter for Remix's \"routes\" config option, for use within routes.ts",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router-serve/CHANGELOG.md b/packages/react-router-serve/CHANGELOG.md
index af5e8c2b9a..df8197c2c3 100644
--- a/packages/react-router-serve/CHANGELOG.md
+++ b/packages/react-router-serve/CHANGELOG.md
@@ -1,5 +1,15 @@
 # `@react-router/serve`
 
+## v7.16.0
+
+### Patch Changes
+
+- Normalize `assetsBuildDirectory` path separators in `react-router-serve` so Windows-built server artifacts can serve `/assets/*` correctly when run on Linux. ([#14982](https://github.com/remix-run/react-router/pull/14982))
+- Updated dependencies:
+  - [`react-router@7.16.0`](https://github.com/remix-run/react-router/releases/tag/react-router@7.16.0)
+  - [`@react-router/express@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/express@7.16.0)
+  - [`@react-router/node@7.16.0`](https://github.com/remix-run/react-router/releases/tag/@react-router/node@7.16.0)
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router-serve/cli.ts b/packages/react-router-serve/cli.ts
index a8d7144838..10ff635292 100644
--- a/packages/react-router-serve/cli.ts
+++ b/packages/react-router-serve/cli.ts
@@ -88,7 +88,7 @@ async function run() {
   if ((isRSCBuild = isRSCServerBuild(buildModule))) {
     const config = {
       publicPath: "/",
-      assetsBuildDirectory: "../client",
+      assetsBuildDirectory: path.join("..", "client"),
       ...(buildModule.unstable_reactRouterServeConfig || {}),
     };
     build = {
diff --git a/packages/react-router-serve/package.json b/packages/react-router-serve/package.json
index de0c4f7c1c..1bff505da3 100644
--- a/packages/react-router-serve/package.json
+++ b/packages/react-router-serve/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@react-router/serve",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Production application server for React Router",
   "bugs": {
     "url": "https://github.com/remix-run/react-router/issues"
diff --git a/packages/react-router/CHANGELOG.md b/packages/react-router/CHANGELOG.md
index df0d2788db..f257fda000 100644
--- a/packages/react-router/CHANGELOG.md
+++ b/packages/react-router/CHANGELOG.md
@@ -1,5 +1,22 @@
 # `react-router`
 
+## v7.16.0
+
+### Minor Changes
+
+- Stabilize `future.unstable_trailingSlashAwareDataRequests` as `future.v8_trailingSlashAwareDataRequests` ([#15098](https://github.com/remix-run/react-router/pull/15098))
+
+### Patch Changes
+
+- Disable manifest path when lazy route dicovery is disabled ([#15068](https://github.com/remix-run/react-router/pull/15068))
+
+- Fix browser URL creation to use the configured history window instead of the global window. ([#15066](https://github.com/remix-run/react-router/pull/15066))
+  - Pass the history/router window through to `createBrowserURLImpl` so custom window contexts keep the correct URL origin.
+
+- Fix `useNavigation()` return type to preserve discriminated union across navigation states ([#15095](https://github.com/remix-run/react-router/pull/15095))
+
+- Widen `MetaDescriptor` `script:ld+json` type from `LdJsonObject` to `LdJsonObject | LdJsonObject[]` to permit multiple JSON-LD schemas in a single `<script type="application/ld+json">` tag emitted by `<Meta />` ([#15082](https://github.com/remix-run/react-router/pull/15082))
+
 ## v7.15.1
 
 ### Patch Changes
diff --git a/packages/react-router/__tests__/dom/ssr/meta-test.tsx b/packages/react-router/__tests__/dom/ssr/meta-test.tsx
index 3e5783b28f..82e96f126d 100644
--- a/packages/react-router/__tests__/dom/ssr/meta-test.tsx
+++ b/packages/react-router/__tests__/dom/ssr/meta-test.tsx
@@ -279,6 +279,48 @@ describe("meta", () => {
     );
   });
 
+  it("{ 'script:ld+json': [...] } adds a <script type='application/ld+json' /> with an array of objects", () => {
+    let jsonLd = [
+      {
+        "@context": "http://schema.org",
+        "@type": "Organization",
+        name: "Acme Inc.",
+        url: "https://acme.example.com",
+      },
+      {
+        "@context": "http://schema.org",
+        "@type": "BreadcrumbList",
+        itemListElement: [
+          {
+            "@type": "ListItem",
+            position: 1,
+            name: "Home",
+            item: "https://acme.example.com",
+          },
+        ],
+      },
+    ];
+
+    let RoutesStub = createRoutesStub([
+      {
+        path: "/",
+        meta: () => [
+          {
+            "script:ld+json": jsonLd,
+          },
+        ],
+        Component: Meta,
+      },
+    ]);
+
+    let { container } = render(<RoutesStub />);
+
+    let scriptTagContents =
+      container.querySelector('script[type="application/ld+json"]')
+        ?.innerHTML || "{}";
+    expect(JSON.parse(scriptTagContents)).toEqual(jsonLd);
+  });
+
   it("{ tagName: 'link' } adds a <link />", () => {
     let RoutesStub = createRoutesStub([
       {
diff --git a/packages/react-router/__tests__/generatePath-test.tsx b/packages/react-router/__tests__/generatePath-test.tsx
index 3bf3a18433..c0bad0d374 100644
--- a/packages/react-router/__tests__/generatePath-test.tsx
+++ b/packages/react-router/__tests__/generatePath-test.tsx
@@ -141,7 +141,7 @@ describe("generatePath", () => {
     });
   });
 
-  it("throws only on on missing named parameters, but not missing splat params", () => {
+  it("throws only on missing named parameters, but not missing splat params", () => {
     expect(() => generatePath(":foo")).toThrow();
     expect(() => generatePath("/:foo")).toThrow();
     expect(() => generatePath("*")).not.toThrow();
diff --git a/packages/react-router/__tests__/router/browser-test.ts b/packages/react-router/__tests__/router/browser-test.ts
index b994d0f1bf..748d851f8e 100644
--- a/packages/react-router/__tests__/router/browser-test.ts
+++ b/packages/react-router/__tests__/router/browser-test.ts
@@ -4,6 +4,7 @@ import {
   type BrowserHistory,
   createBrowserHistory,
 } from "../../lib/router/history";
+import { JSDOM } from "jsdom";
 
 import InitialLocationDefaultKey from "./TestSequences/InitialLocationDefaultKey";
 import Listen from "./TestSequences/Listen";
@@ -59,6 +60,15 @@ describe("a browser history", () => {
     expect(unencodedHref).toEqual("/#abc");
   });
 
+  it("uses the configured window when creating URLs", () => {
+    const customWindow = new JSDOM(`<!DOCTYPE html>`, {
+      url: "https://example.com/",
+    }).window as unknown as Window;
+    const customHistory = createBrowserHistory({ window: customWindow });
+
+    expect(customHistory.createURL("/test").origin).toBe("https://example.com");
+  });
+
   describe("listen", () => {
     it("does not immediately call listeners", () => {
       Listen(history);
diff --git a/packages/react-router/__tests__/server-runtime/server-test.ts b/packages/react-router/__tests__/server-runtime/server-test.ts
index 725c49792e..10a28d06e2 100644
--- a/packages/react-router/__tests__/server-runtime/server-test.ts
+++ b/packages/react-router/__tests__/server-runtime/server-test.ts
@@ -2081,6 +2081,122 @@ describe("shared server runtime", () => {
     });
   });
 
+  describe("manifest requests", () => {
+    test("returns manifest patches", async () => {
+      let build = mockServerBuild({
+        root: {
+          default: {},
+        },
+        "routes/a": {
+          path: "a",
+        },
+        "routes/a.b": {
+          path: "a/b",
+        },
+      });
+      let handler = createRequestHandler(build, ServerMode.Test);
+
+      let request = new Request(
+        `${baseUrl}/__manifest?paths=%2Fa&version=${build.assets.version}`,
+      );
+
+      let result = await handler(request);
+      expect(result.status).toBe(200);
+      expect(await result.json()).toEqual({
+        "routes/a": {
+          hasAction: false,
+          hasClientAction: false,
+          hasClientLoader: false,
+          hasClientMiddleware: false,
+          hasErrorBoundary: false,
+          hasLoader: false,
+          id: "routes/a",
+          module: "",
+          path: "a",
+        },
+      });
+    });
+
+    test("returns nested manifest patches", async () => {
+      let build = mockServerBuild({
+        root: {
+          default: {},
+        },
+        "routes/a": {
+          path: "a",
+        },
+        "routes/a.b": {
+          path: "b",
+          parentId: "routes/a",
+        },
+      });
+      let handler = createRequestHandler(build, ServerMode.Test);
+
+      let request = new Request(
+        `${baseUrl}/__manifest?paths=%2Fa%2Fb&version=${build.assets.version}`,
+      );
+
+      let result = await handler(request);
+      expect(result.status).toBe(200);
+      expect(await result.json()).toEqual({
+        "routes/a": {
+          hasAction: false,
+          hasClientAction: false,
+          hasClientLoader: false,
+          hasClientMiddleware: false,
+          hasErrorBoundary: false,
+          hasLoader: false,
+          id: "routes/a",
+          module: "",
+          path: "a",
+        },
+        "routes/a.b": {
+          hasAction: false,
+          hasClientAction: false,
+          hasClientLoader: false,
+          hasClientMiddleware: false,
+          hasErrorBoundary: false,
+          hasLoader: false,
+          id: "routes/a.b",
+          parentId: "routes/a",
+          module: "",
+          path: "b",
+        },
+      });
+    });
+
+    test("disabled when route discovery is disabled", async () => {
+      let build = mockServerBuild(
+        {
+          root: {
+            default: {},
+          },
+          "routes/a": {
+            path: "a",
+          },
+          "routes/a.b": {
+            path: "a/b",
+          },
+        },
+        {
+          routeDiscovery: {
+            mode: "initial",
+            manifestPath: "",
+          },
+        },
+      );
+      let handler = createRequestHandler(build, ServerMode.Test);
+
+      let request = new Request(
+        `${baseUrl}/__manifest?paths=%2Fa&version=${build.assets.version}`,
+      );
+
+      let result = await handler(request);
+      expect(result.status).toBe(404);
+      expect(await result.text()).toBe("");
+    });
+  });
+
   test("provides load context to server entrypoint", async () => {
     let rootLoader = jest.fn(() => {
       return "root";
diff --git a/packages/react-router/__tests__/server-runtime/utils.ts b/packages/react-router/__tests__/server-runtime/utils.ts
index fb5759a4fd..51fe758889 100644
--- a/packages/react-router/__tests__/server-runtime/utils.ts
+++ b/packages/react-router/__tests__/server-runtime/utils.ts
@@ -37,6 +37,7 @@ export function mockServerBuild(
     handleError?: HandleErrorFunction;
     handleDocumentRequest?: HandleDocumentRequestFunction;
     instrumentations?: ServerInstrumentation[];
+    routeDiscovery?: ServerBuild["routeDiscovery"];
   } = {},
 ): ServerBuild {
   return {
@@ -47,7 +48,7 @@ export function mockServerBuild(
     },
     prerender: [],
     isSpaMode: false,
-    routeDiscovery: {
+    routeDiscovery: opts.routeDiscovery || {
       mode: "lazy",
       manifestPath: "/__manifest",
     },
diff --git a/packages/react-router/lib/dom-export/hydrated-router.tsx b/packages/react-router/lib/dom-export/hydrated-router.tsx
index a27ac7fbc3..a85a5e6c55 100644
--- a/packages/react-router/lib/dom-export/hydrated-router.tsx
+++ b/packages/react-router/lib/dom-export/hydrated-router.tsx
@@ -196,7 +196,7 @@ function createHydratedRouter({
       ssrInfo.routeModules,
       ssrInfo.context.ssr,
       ssrInfo.context.basename,
-      ssrInfo.context.future.unstable_trailingSlashAwareDataRequests,
+      ssrInfo.context.future.v8_trailingSlashAwareDataRequests,
     ),
     patchRoutesOnNavigation: getPatchRoutesOnNavigationFunction(
       () => router,
diff --git a/packages/react-router/lib/dom/server.tsx b/packages/react-router/lib/dom/server.tsx
index a7decf3237..84bdbf5a93 100644
--- a/packages/react-router/lib/dom/server.tsx
+++ b/packages/react-router/lib/dom/server.tsx
@@ -419,6 +419,7 @@ export function createStaticRouter(
       return {
         v8_middleware: false,
         v8_passThroughRequests: false,
+        v8_trailingSlashAwareDataRequests: false,
         ...opts?.future,
       };
     },
diff --git a/packages/react-router/lib/dom/ssr/components.tsx b/packages/react-router/lib/dom/ssr/components.tsx
index a6474b8cc2..c322141cd8 100644
--- a/packages/react-router/lib/dom/ssr/components.tsx
+++ b/packages/react-router/lib/dom/ssr/components.tsx
@@ -409,7 +409,7 @@ function RSCPrefetchPageLinksImpl({
     let url = singleFetchUrl(
       page,
       basename,
-      future.unstable_trailingSlashAwareDataRequests,
+      future.v8_trailingSlashAwareDataRequests,
       "rsc",
     );
 
@@ -430,7 +430,7 @@ function RSCPrefetchPageLinksImpl({
     return [url.pathname + url.search];
   }, [
     basename,
-    future.unstable_trailingSlashAwareDataRequests,
+    future.v8_trailingSlashAwareDataRequests,
     page,
     location,
     nextMatches,
@@ -520,7 +520,7 @@ function PrefetchPageLinksImpl({
     let url = singleFetchUrl(
       page,
       basename,
-      future.unstable_trailingSlashAwareDataRequests,
+      future.v8_trailingSlashAwareDataRequests,
       "data",
     );
     // When one or more routes have opted out, we add a _routes param to
@@ -539,7 +539,7 @@ function PrefetchPageLinksImpl({
     return [url.pathname + url.search];
   }, [
     basename,
-    future.unstable_trailingSlashAwareDataRequests,
+    future.v8_trailingSlashAwareDataRequests,
     loaderData,
     location,
     manifest,
diff --git a/packages/react-router/lib/dom/ssr/entry.ts b/packages/react-router/lib/dom/ssr/entry.ts
index 25b9677c0b..8169141ca3 100644
--- a/packages/react-router/lib/dom/ssr/entry.ts
+++ b/packages/react-router/lib/dom/ssr/entry.ts
@@ -50,7 +50,7 @@ export interface EntryContext extends FrameworkContextObject {
 
 export interface FutureConfig {
   v8_passThroughRequests: boolean;
-  unstable_trailingSlashAwareDataRequests: boolean;
+  v8_trailingSlashAwareDataRequests: boolean;
   v8_middleware: boolean;
 }
 
diff --git a/packages/react-router/lib/dom/ssr/routeModules.ts b/packages/react-router/lib/dom/ssr/routeModules.ts
index 43a79a8ece..360a7bec21 100644
--- a/packages/react-router/lib/dom/ssr/routeModules.ts
+++ b/packages/react-router/lib/dom/ssr/routeModules.ts
@@ -248,7 +248,7 @@ export type MetaDescriptor =
   | { name: string; content: string }
   | { property: string; content: string }
   | { httpEquiv: string; content: string }
-  | { "script:ld+json": LdJsonObject }
+  | { "script:ld+json": LdJsonObject | LdJsonObject[] }
   | { tagName: "meta" | "link"; [name: string]: string }
   | { [name: string]: unknown };
 
diff --git a/packages/react-router/lib/dom/ssr/routes-test-stub.tsx b/packages/react-router/lib/dom/ssr/routes-test-stub.tsx
index 66f0c5c3cf..36e17568a7 100644
--- a/packages/react-router/lib/dom/ssr/routes-test-stub.tsx
+++ b/packages/react-router/lib/dom/ssr/routes-test-stub.tsx
@@ -128,8 +128,8 @@ export function createRoutesStub(
         future: {
           v8_passThroughRequests: future?.v8_passThroughRequests === true,
           v8_middleware: future?.v8_middleware === true,
-          unstable_trailingSlashAwareDataRequests:
-            future?.unstable_trailingSlashAwareDataRequests === true,
+          v8_trailingSlashAwareDataRequests:
+            future?.v8_trailingSlashAwareDataRequests === true,
         },
         manifest: {
           routes: {},
diff --git a/packages/react-router/lib/hooks.tsx b/packages/react-router/lib/hooks.tsx
index 9cd81ae763..fb01bff674 100644
--- a/packages/react-router/lib/hooks.tsx
+++ b/packages/react-router/lib/hooks.tsx
@@ -24,7 +24,6 @@ import type {
   RelativeRoutingType,
   Router as DataRouter,
   RevalidationState,
-  Navigation,
   NavigationStates,
 } from "./router/router";
 import { IDLE_BLOCKER } from "./router/router";
@@ -1451,6 +1450,16 @@ export function useRouteId() {
   return useCurrentRouteId(DataRouterStateHook.UseRouteId);
 }
 
+// Omit the fields from each navigation state individually to preserve the discriminated union
+type UseNavigationResult =
+  UseNavigationResultStates[keyof UseNavigationResultStates];
+
+type UseNavigationResultStates = {
+  Idle: Omit<NavigationStates["Idle"], "matches" | "historyAction">;
+  Loading: Omit<NavigationStates["Loading"], "matches" | "historyAction">;
+  Submitting: Omit<NavigationStates["Submitting"], "matches" | "historyAction">;
+};
+
 /**
  * Returns the current {@link Navigation}, defaulting to an "idle" navigation
  * when no navigation is in progress. You can use this to render pending UI
@@ -1473,9 +1482,9 @@ export function useRouteId() {
  * @mode data
  * @returns The current {@link Navigation} object
  */
-export function useNavigation(): Omit<Navigation, "matches" | "historyAction"> {
+export function useNavigation(): UseNavigationResult {
   let state = useDataRouterState(DataRouterStateHook.UseNavigation);
-  return React.useMemo<Omit<Navigation, "matches" | "historyAction">>(() => {
+  return React.useMemo<UseNavigationResult>(() => {
     let { matches, historyAction, ...rest } = state.navigation;
     return rest;
   }, [state.navigation]);
diff --git a/packages/react-router/lib/router/history.ts b/packages/react-router/lib/router/history.ts
index 29821d3bcf..46254b02c8 100644
--- a/packages/react-router/lib/router/history.ts
+++ b/packages/react-router/lib/router/history.ts
@@ -729,7 +729,7 @@ function getUrlBasedHistory(
   }
 
   function createURL(to: To): URL {
-    return createBrowserURLImpl(to);
+    return createBrowserURLImpl(window, to);
   }
 
   let history: History = {
@@ -774,16 +774,20 @@ function getUrlBasedHistory(
   return history;
 }
 
-export function createBrowserURLImpl(to: To, isAbsolute = false): URL {
+export function createBrowserURLImpl(
+  windowImpl: Window,
+  to: To,
+  isAbsolute = false,
+): URL {
   let base = "http://localhost";
-  if (typeof window !== "undefined") {
+  if (windowImpl) {
     // window.location.origin is "null" (the literal string value) in Firefox
     // under certain conditions, notably when serving from a local HTML file
     // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
     base =
-      window.location.origin !== "null"
-        ? window.location.origin
-        : window.location.href;
+      windowImpl.location.origin !== "null"
+        ? windowImpl.location.origin
+        : windowImpl.location.href;
   }
 
   invariant(base, "No window.location.(origin|href) available to create URL");
diff --git a/packages/react-router/lib/router/router.ts b/packages/react-router/lib/router/router.ts
index 90a98040ec..713e3dba62 100644
--- a/packages/react-router/lib/router/router.ts
+++ b/packages/react-router/lib/router/router.ts
@@ -3228,7 +3228,7 @@ export function createRouter(init: RouterInit): Router {
       } else if (isAbsoluteUrl(location)) {
         // We skip `history.createURL` here for absolute URLs because we don't
         // want to inherit the current `window.location` base URL
-        const url = createBrowserURLImpl(location, true);
+        const url = createBrowserURLImpl(routerWindow, location, true);
         isDocumentReload =
           // Hard reload if it's an absolute URL to a new origin
           url.origin !== routerWindow.location.origin ||
diff --git a/packages/react-router/lib/rsc/browser.tsx b/packages/react-router/lib/rsc/browser.tsx
index 4c2ee5a7d2..b3f841088d 100644
--- a/packages/react-router/lib/rsc/browser.tsx
+++ b/packages/react-router/lib/rsc/browser.tsx
@@ -840,7 +840,7 @@ export function RSCHydratedRouter({
       // These flags have no runtime impact so can always be false.  If we add
       // flags that drive runtime behavior they'll need to be proxied through.
       v8_middleware: false,
-      unstable_trailingSlashAwareDataRequests: true, // always on for RSC
+      v8_trailingSlashAwareDataRequests: true, // always on for RSC
       v8_passThroughRequests: true, // always on for RSC
     },
     isSpaMode: false,
diff --git a/packages/react-router/lib/rsc/server.ssr.tsx b/packages/react-router/lib/rsc/server.ssr.tsx
index eca9b8ce02..a082abf9f3 100644
--- a/packages/react-router/lib/rsc/server.ssr.tsx
+++ b/packages/react-router/lib/rsc/server.ssr.tsx
@@ -584,7 +584,7 @@ export function RSCStaticRouter({ getPayload }: RSCStaticRouterProps) {
       // These flags have no runtime impact so can always be false.  If we add
       // flags that drive runtime behavior they'll need to be proxied through.
       v8_middleware: false,
-      unstable_trailingSlashAwareDataRequests: true, // always on for RSC
+      v8_trailingSlashAwareDataRequests: true, // always on for RSC
       v8_passThroughRequests: true, // always on for RSC
     },
     isSpaMode: false,
diff --git a/packages/react-router/lib/server-runtime/server.ts b/packages/react-router/lib/server-runtime/server.ts
index 40ab71d101..9c756c5260 100644
--- a/packages/react-router/lib/server-runtime/server.ts
+++ b/packages/react-router/lib/server-runtime/server.ts
@@ -191,7 +191,10 @@ function derive(build: ServerBuild, mode?: string) {
       build.routeDiscovery.manifestPath,
       build.basename,
     );
-    if (requestUrl.pathname === manifestUrl) {
+    if (
+      build.routeDiscovery.mode === "lazy" &&
+      requestUrl.pathname === manifestUrl
+    ) {
       try {
         let res = await handleManifestRequest(
           build,
diff --git a/packages/react-router/lib/server-runtime/urls.ts b/packages/react-router/lib/server-runtime/urls.ts
index f71cc97719..39341d1ac7 100644
--- a/packages/react-router/lib/server-runtime/urls.ts
+++ b/packages/react-router/lib/server-runtime/urls.ts
@@ -13,7 +13,7 @@ export function getNormalizedPath(
   let pathname = url.pathname;
 
   // Strip .data suffix
-  if (future?.unstable_trailingSlashAwareDataRequests) {
+  if (future?.v8_trailingSlashAwareDataRequests) {
     if (pathname.endsWith("/_.data")) {
       // Handle trailing slash URLs: /about/_.data -> /about/
       pathname = pathname.replace(/_\.data$/, "");
diff --git a/packages/react-router/package.json b/packages/react-router/package.json
index 7498538c17..8b0708645a 100644
--- a/packages/react-router/package.json
+++ b/packages/react-router/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-router",
-  "version": "7.15.1",
+  "version": "7.16.0",
   "description": "Declarative routing for React",
   "keywords": [
     "react",