diff --git a/.changeset/angry-students-pay.md b/.changeset/angry-students-pay.md
new file mode 100644
index 0000000000..82db27596d
--- /dev/null
+++ b/.changeset/angry-students-pay.md
@@ -0,0 +1,13 @@
+---
+"@react-router/dev": minor
+"react-router": minor
+---
+
+Added a new `react-router.config.ts` `routeDiscovery` option to configure Lazy Route Discovery behavior.
+
+- By default, Lazy Route Discovery is enabled and makes manifest requests to the `/__manifest` path:
+  - `routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" }`
+- You can modify the manifest path used:
+  - `routeDiscovery: { mode: "lazy", manifestPath: "/custom-manifest" }`
+- Or you can disable this feature entirely and include all routes in the manifest on initial document load:
+  - `routeDiscovery: { mode: "initial" }`
diff --git a/integration/fog-of-war-test.ts b/integration/fog-of-war-test.ts
index 9dda94a4c1..e5e9bc8fe1 100644
--- a/integration/fog-of-war-test.ts
+++ b/integration/fog-of-war-test.ts
@@ -1,4 +1,5 @@
 import { test, expect } from "@playwright/test";
+import { PassThrough } from "node:stream";
 
 import {
   createAppFixture,
@@ -6,6 +7,7 @@ import {
   js,
 } from "./helpers/create-fixture.js";
 import { PlaywrightFixture } from "./helpers/playwright-fixture.js";
+import { reactRouterConfig } from "./helpers/vite.js";
 
 function getFiles() {
   return {
@@ -118,6 +120,10 @@ test.describe("Fog of War", () => {
     let res = await fixture.requestDocument("/");
     let html = await res.text();
 
+    expect(html).toContain("window.__reactRouterManifest = {");
+    expect(html).not.toContain(
+      '<link rel="modulepreload" href="/assets/manifest-'
+    );
     expect(html).toContain('"root": {');
     expect(html).toContain('"routes/_index": {');
     expect(html).not.toContain('"routes/a"');
@@ -1402,4 +1408,218 @@ test.describe("Fog of War", () => {
     await app.clickLink("/a");
     await page.waitForSelector("#a-index");
   });
+
+  test("allows configuration of the manifest path", async ({ page }) => {
+    let fixture = await createFixture({
+      files: {
+        ...getFiles(),
+        "react-router.config.ts": reactRouterConfig({
+          routeDiscovery: { mode: "lazy", manifestPath: "/custom-manifest" },
+        }),
+      },
+    });
+    let appFixture = await createAppFixture(fixture);
+    let app = new PlaywrightFixture(appFixture, page);
+
+    let wrongManifestRequests: string[] = [];
+    let manifestRequests: string[] = [];
+    page.on("request", (req) => {
+      if (req.url().includes("/__manifest")) {
+        wrongManifestRequests.push(req.url());
+      }
+      if (req.url().includes("/custom-manifest")) {
+        manifestRequests.push(req.url());
+      }
+    });
+
+    await app.goto("/", true);
+    expect(
+      await page.evaluate(() =>
+        Object.keys((window as any).__reactRouterManifest.routes)
+      )
+    ).toEqual(["root", "routes/_index", "routes/a"]);
+    expect(manifestRequests).toEqual([
+      expect.stringMatching(/\/custom-manifest\?p=%2F&p=%2Fa&version=/),
+    ]);
+    manifestRequests = [];
+
+    await app.clickLink("/a");
+    await page.waitForSelector("#a");
+    expect(await app.getHtml("#a")).toBe(`<h1 id="a">A: A LOADER</h1>`);
+    // Wait for eager discovery to kick off
+    await new Promise((r) => setTimeout(r, 500));
+    expect(manifestRequests).toEqual([
+      expect.stringMatching(/\/custom-manifest\?p=%2Fa%2Fb&version=/),
+    ]);
+
+    expect(wrongManifestRequests).toEqual([]);
+  });
+
+  test.describe("routeDiscovery=initial", () => {
+    test("loads full manifest on initial load", async ({ page }) => {
+      let fixture = await createFixture({
+        files: {
+          ...getFiles(),
+          "react-router.config.ts": reactRouterConfig({
+            routeDiscovery: { mode: "initial" },
+          }),
+          "app/entry.client.tsx": js`
+            import { HydratedRouter } from "react-router/dom";
+            import { startTransition, StrictMode } from "react";
+            import { hydrateRoot } from "react-dom/client";
+            startTransition(() => {
+              hydrateRoot(
+                document,
+                <StrictMode>
+                  <HydratedRouter discover={"none"} />
+                </StrictMode>
+              );
+            });
+          `,
+        },
+      });
+      let appFixture = await createAppFixture(fixture);
+
+      let manifestRequests: string[] = [];
+      page.on("request", (req) => {
+        if (req.url().includes("/__manifest")) {
+          manifestRequests.push(req.url());
+        }
+      });
+
+      let app = new PlaywrightFixture(appFixture, page);
+      let res = await fixture.requestDocument("/");
+      let html = await res.text();
+
+      expect(html).not.toContain("window.__reactRouterManifest = {");
+      expect(html).toContain(
+        '<link rel="modulepreload" href="/assets/manifest-'
+      );
+
+      // Linking to A succeeds
+      await app.goto("/", true);
+      expect(
+        await page.evaluate(() =>
+          Object.keys((window as any).__reactRouterManifest.routes)
+        )
+      ).toEqual([
+        "root",
+        "routes/_index",
+        "routes/a",
+        "routes/a.b",
+        "routes/a.b.c",
+      ]);
+
+      await app.clickLink("/a");
+      await page.waitForSelector("#a");
+      expect(await app.getHtml("#a")).toBe(`<h1 id="a">A: A LOADER</h1>`);
+      expect(manifestRequests).toEqual([]);
+    });
+
+    test("defaults to `routeDiscovery=initial` when `ssr:false` is set", async ({
+      page,
+    }) => {
+      let fixture = await createFixture({
+        spaMode: true,
+        files: {
+          "react-router.config.ts": reactRouterConfig({
+            ssr: false,
+          }),
+          "app/root.tsx": js`
+            import * as React from "react";
+            import { Link, Links, Meta, Outlet, Scripts } from "react-router";
+            export default function Root() {
+              let [showLink, setShowLink] = React.useState(false);
+              return (
+                <html lang="en">
+                  <head>
+                    <Meta />
+                    <Links />
+                  </head>
+                  <body>
+                    <Link to="/">Home</Link><br/>
+                    <Link to="/a">/a</Link><br/>
+                    <Outlet />
+                    <Scripts />
+                  </body>
+                </html>
+              );
+            }
+          `,
+          "app/routes/_index.tsx": js`
+            export default function Index() {
+              return <h1 id="index">Index</h1>
+            }
+          `,
+
+          "app/routes/a.tsx": js`
+            export function clientLoader({ request }) {
+              return { message: "A LOADER" };
+            }
+            export default function Index({ loaderData }) {
+              return <h1 id="a">A: {loaderData.message}</h1>
+            }
+          `,
+        },
+      });
+      let appFixture = await createAppFixture(fixture);
+
+      let manifestRequests: string[] = [];
+      page.on("request", (req) => {
+        if (req.url().includes("/__manifest")) {
+          manifestRequests.push(req.url());
+        }
+      });
+
+      let app = new PlaywrightFixture(appFixture, page);
+      let res = await fixture.requestDocument("/");
+      let html = await res.text();
+
+      expect(html).toContain('"routeDiscovery":{"mode":"initial"}');
+
+      await app.goto("/", true);
+      await page.waitForSelector("#index");
+      await app.clickLink("/a");
+      await page.waitForSelector("#a");
+      expect(await app.getHtml("#a")).toBe(`<h1 id="a">A: A LOADER</h1>`);
+      expect(manifestRequests).toEqual([]);
+    });
+
+    test("Errors if you try to set routeDiscovery=lazy and ssr:false", async () => {
+      let ogConsole = console.error;
+      console.error = () => {};
+      let buildStdio = new PassThrough();
+      let err;
+      try {
+        await createFixture({
+          buildStdio,
+          spaMode: true,
+          files: {
+            ...getFiles(),
+            "react-router.config.ts": reactRouterConfig({
+              ssr: false,
+              routeDiscovery: { mode: "lazy" },
+            }),
+          },
+        });
+      } catch (e) {
+        err = e;
+      }
+
+      let chunks: Buffer[] = [];
+      let buildOutput = await new Promise<string>((resolve, reject) => {
+        buildStdio.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        buildStdio.on("error", (err) => reject(err));
+        buildStdio.on("end", () =>
+          resolve(Buffer.concat(chunks).toString("utf8"))
+        );
+      });
+
+      expect(err).toEqual(new Error("Build failed, check the output above"));
+      expect(buildOutput).toContain(
+        'Error: The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
+      );
+      console.error = ogConsole;
+    });
+  });
 });
diff --git a/integration/helpers/vite.ts b/integration/helpers/vite.ts
index 1330c291e1..d590d5cad7 100644
--- a/integration/helpers/vite.ts
+++ b/integration/helpers/vite.ts
@@ -31,6 +31,7 @@ export const reactRouterConfig = ({
   splitRouteModules,
   viteEnvironmentApi,
   middleware,
+  routeDiscovery,
 }: {
   ssr?: boolean;
   basename?: string;
@@ -41,12 +42,14 @@ export const reactRouterConfig = ({
   >["unstable_splitRouteModules"];
   viteEnvironmentApi?: boolean;
   middleware?: boolean;
+  routeDiscovery?: Config["routeDiscovery"];
 }) => {
   let config: Config = {
     ssr,
     basename,
     prerender,
     appDirectory,
+    routeDiscovery,
     future: {
       unstable_splitRouteModules: splitRouteModules,
       unstable_viteEnvironmentApi: viteEnvironmentApi,
diff --git a/integration/vite-presets-test.ts b/integration/vite-presets-test.ts
index 6128229996..bc3b9cfab9 100644
--- a/integration/vite-presets-test.ts
+++ b/integration/vite-presets-test.ts
@@ -29,7 +29,7 @@ const files = {
     export default {
       // Ensure user config takes precedence over preset config
       appDirectory: "app",
-      
+
       presets: [
         // Ensure user config is passed to reactRouterConfig hook
         {
@@ -221,6 +221,7 @@ test.describe("Vite / presets", async () => {
         "future",
         "prerender",
         "routes",
+        "routeDiscovery",
         "serverBuildFile",
         "serverBundles",
         "serverModuleFormat",
diff --git a/packages/react-router-dev/config/config.ts b/packages/react-router-dev/config/config.ts
index 999e19eec3..68e0e810c9 100644
--- a/packages/react-router-dev/config/config.ts
+++ b/packages/react-router-dev/config/config.ts
@@ -158,6 +158,24 @@ export type ReactRouterConfig = {
    * other platforms and tools.
    */
   presets?: Array<Preset>;
+  /**
+   * Control the "Lazy Route Discovery" behavior
+   *
+   * - `routeDiscovery.mode`: By default, this resolves to `lazy` which will
+   *   lazily discover routes as the user navigates around your application.
+   *   You can set this to `initial` to opt-out of this behavior and load all
+   *   routes with the initial HTML document load.
+   * - `routeDiscovery.manifestPath`: The path to serve the manifest file from.
+   *    Only applies to `mode: "lazy"` and defaults to `/__manifest`.
+   */
+  routeDiscovery?:
+    | {
+        mode: "lazy";
+        manifestPath?: string;
+      }
+    | {
+        mode: "initial";
+      };
   /**
    * The file name of the server build output. This file
    * should end in a `.js` extension and should be deployed to your server.
@@ -205,6 +223,17 @@ export type ResolvedReactRouterConfig = Readonly<{
    * function returning an array to dynamically generate URLs.
    */
   prerender: ReactRouterConfig["prerender"];
+  /**
+   * Control the "Lazy Route Discovery" behavior
+   *
+   * - `routeDiscovery.mode`: By default, this resolves to `lazy` which will
+   *   lazily discover routes as the user navigates around your application.
+   *   You can set this to `initial` to opt-out of this behavior and load all
+   *   routes with the initial HTML document load.
+   * - `routeDiscovery.manifestPath`: The path to serve the manifest file from.
+   *    Only applies to `mode: "lazy"` and defaults to `/__manifest`.
+   */
+  routeDiscovery: ReactRouterConfig["routeDiscovery"];
   /**
    * An object of all available routes, keyed by route id.
    */
@@ -388,19 +417,25 @@ async function resolveConfig({
     ssr: true,
   } as const satisfies Partial<ReactRouterConfig>;
 
+  let userAndPresetConfigs = mergeReactRouterConfig(
+    ...presets,
+    reactRouterUserConfig
+  );
+
   let {
     appDirectory: userAppDirectory,
     basename,
     buildDirectory: userBuildDirectory,
     buildEnd,
     prerender,
+    routeDiscovery: userRouteDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
     ssr,
   } = {
     ...defaults, // Default values should be completely overridden by user/preset config, not merged
-    ...mergeReactRouterConfig(...presets, reactRouterUserConfig),
+    ...userAndPresetConfigs,
   };
 
   if (!ssr && serverBundles) {
@@ -420,6 +455,36 @@ async function resolveConfig({
     );
   }
 
+  let routeDiscovery: ResolvedReactRouterConfig["routeDiscovery"];
+  if (userRouteDiscovery == null) {
+    if (ssr) {
+      routeDiscovery = {
+        mode: "lazy",
+        manifestPath: "/__manifest",
+      };
+    } else {
+      routeDiscovery = { mode: "initial" };
+    }
+  } else if (userRouteDiscovery.mode === "initial") {
+    routeDiscovery = userRouteDiscovery;
+  } else if (userRouteDiscovery.mode === "lazy") {
+    if (!ssr) {
+      return err(
+        'The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
+      );
+    }
+
+    let { manifestPath } = userRouteDiscovery;
+    if (manifestPath != null && !manifestPath.startsWith("/")) {
+      return err(
+        "The `routeDiscovery.manifestPath` config must be a root-relative " +
+          'pathname beginning with a slash (i.e., "/__manifest")'
+      );
+    }
+
+    routeDiscovery = userRouteDiscovery;
+  }
+
   let appDirectory = path.resolve(root, userAppDirectory || "app");
   let buildDirectory = path.resolve(root, userBuildDirectory);
 
@@ -512,11 +577,12 @@ async function resolveConfig({
     future,
     prerender,
     routes,
+    routeDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
     ssr,
-  });
+  } satisfies ResolvedReactRouterConfig);
 
   for (let preset of reactRouterUserConfig.presets ?? []) {
     await preset.reactRouterConfigResolved?.({ reactRouterConfig });
diff --git a/packages/react-router-dev/typegen/index.ts b/packages/react-router-dev/typegen/index.ts
index 342f27f808..a046345d31 100644
--- a/packages/react-router-dev/typegen/index.ts
+++ b/packages/react-router-dev/typegen/index.ts
@@ -161,6 +161,7 @@ const virtual = ts`
     export const isSpaMode: ServerBuild["isSpaMode"];
     export const prerender: ServerBuild["prerender"];
     export const publicPath: ServerBuild["publicPath"];
+    export const routeDiscovery: ServerBuild["routeDiscovery"];
     export const routes: ServerBuild["routes"];
     export const ssr: ServerBuild["ssr"];
     export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
diff --git a/packages/react-router-dev/vite/plugin.ts b/packages/react-router-dev/vite/plugin.ts
index 66c24acfd9..30d026efd5 100644
--- a/packages/react-router-dev/vite/plugin.ts
+++ b/packages/react-router-dev/vite/plugin.ts
@@ -742,6 +742,9 @@ export const reactRouterVitePlugin: ReactRouterVitePlugin = () => {
       export const ssr = ${ctx.reactRouterConfig.ssr};
       export const isSpaMode = ${isSpaMode};
       export const prerender = ${JSON.stringify(prerenderPaths)};
+      export const routeDiscovery = ${JSON.stringify(
+        ctx.reactRouterConfig.routeDiscovery
+      )};
       export const publicPath = ${JSON.stringify(ctx.publicPath)};
       export const entry = { module: entryServer };
       export const routes = {
diff --git a/packages/react-router/__tests__/dom/scroll-restoration-test.tsx b/packages/react-router/__tests__/dom/scroll-restoration-test.tsx
index 8576f535e1..9686a49b25 100644
--- a/packages/react-router/__tests__/dom/scroll-restoration-test.tsx
+++ b/packages/react-router/__tests__/dom/scroll-restoration-test.tsx
@@ -11,10 +11,10 @@ import {
   ScrollRestoration,
   createBrowserRouter,
 } from "../../index";
-import type { FrameworkContextObject } from "../../lib/dom/ssr/entry";
 import { createMemoryRouter, redirect } from "react-router";
 import { FrameworkContext, Scripts } from "../../lib/dom/ssr/components";
 import "@testing-library/jest-dom/extend-expect";
+import { mockFrameworkContext } from "../utils/framework";
 
 describe(`ScrollRestoration`, () => {
   it("restores the scroll position for a page when re-visited", () => {
@@ -207,23 +207,7 @@ describe(`ScrollRestoration`, () => {
       window.scrollTo = scrollTo;
     });
 
-    let context: FrameworkContextObject = {
-      routeModules: { root: { default: () => null } },
-      manifest: {
-        routes: {
-          root: {
-            hasLoader: false,
-            hasAction: false,
-            hasErrorBoundary: false,
-            id: "root",
-            module: "root.js",
-          },
-        },
-        entry: { imports: [], module: "" },
-        url: "",
-        version: "",
-      },
-    };
+    let context = mockFrameworkContext();
 
     it("should render a <script> tag", () => {
       let router = createMemoryRouter([
diff --git a/packages/react-router/__tests__/dom/ssr/components-test.tsx b/packages/react-router/__tests__/dom/ssr/components-test.tsx
index 2335b987e5..4a806bec87 100644
--- a/packages/react-router/__tests__/dom/ssr/components-test.tsx
+++ b/packages/react-router/__tests__/dom/ssr/components-test.tsx
@@ -14,6 +14,7 @@ import { FrameworkContext } from "../../../lib/dom/ssr/components";
 import invariant from "../../../lib/dom/ssr/invariant";
 import { ServerRouter } from "../../../lib/dom/ssr/server";
 import "@testing-library/jest-dom/extend-expect";
+import { mockEntryContext, mockFrameworkContext } from "../../utils/framework";
 
 const setIntentEvents = ["focus", "mouseEnter", "touchStart"] as const;
 type PrefetchEventHandlerProps = {
@@ -24,7 +25,7 @@ function itPrefetchesPageLinks<
   Props extends { to: any; prefetch?: any } & PrefetchEventHandlerProps
 >(Component: React.ComponentType<Props>) {
   describe('prefetch="intent"', () => {
-    let context = {
+    let context = mockFrameworkContext({
       routeModules: { idk: { default: () => null } },
       manifest: {
         routes: {
@@ -40,8 +41,7 @@ function itPrefetchesPageLinks<
         url: "",
         version: "",
       },
-      future: {},
-    };
+    });
 
     beforeEach(() => {
       jest.useFakeTimers();
@@ -159,7 +159,7 @@ describe("<ServerRouter>", () => {
       "Expected a context"
     );
 
-    let context = {
+    let context = mockEntryContext({
       manifest: {
         routes: {
           root: {
@@ -197,9 +197,7 @@ describe("<ServerRouter>", () => {
         },
         empty: { default: {} },
       },
-      staticHandlerContext,
-      future: {},
-    };
+    });
 
     jest.spyOn(console, "warn").mockImplementation(() => {});
     jest.spyOn(console, "error");
@@ -218,54 +216,55 @@ describe("<ServerRouter>", () => {
 
 describe("<HydratedRouter>", () => {
   it("handles empty default export objects from the compiler", async () => {
-    window.__reactRouterContext = {
-      url: "/",
-      future: {},
-    };
-    window.__reactRouterRouteModules = {
-      root: {
-        default: () => {
-          return (
-            <>
-              <h1>Root</h1>
-              <Outlet />
-            </>
-          );
+    let context = mockFrameworkContext({
+      manifest: {
+        routes: {
+          root: {
+            hasLoader: false,
+            hasAction: false,
+            hasErrorBoundary: false,
+            id: "root",
+            module: "root.js",
+            path: "/",
+          },
+          empty: {
+            hasLoader: false,
+            hasAction: false,
+            hasErrorBoundary: false,
+            id: "empty",
+            module: "empty.js",
+            index: true,
+            parentId: "root",
+          },
         },
+        entry: { imports: [], module: "" },
+        url: "",
+        version: "",
       },
-      empty: { default: {} },
-    };
-    window.__reactRouterManifest = {
-      routes: {
+      routeModules: {
         root: {
-          hasLoader: false,
-          hasAction: false,
-          hasErrorBoundary: false,
-          id: "root",
-          module: "root.js",
-          path: "/",
-        },
-        empty: {
-          hasLoader: false,
-          hasAction: false,
-          hasErrorBoundary: false,
-          id: "empty",
-          module: "empty.js",
-          index: true,
-          parentId: "root",
+          default: () => {
+            return (
+              <>
+                <h1>Root</h1>
+                <Outlet />
+              </>
+            );
+          },
         },
+        empty: { default: {} },
       },
-      entry: { imports: [], module: "" },
-      url: "",
-      version: "",
-    };
+    });
+    window.__reactRouterContext = context;
+    window.__reactRouterRouteModules = context.routeModules;
+    window.__reactRouterManifest = context.manifest;
     window.__reactRouterContext!.stream = new ReadableStream({
       start(controller) {
         window.__reactRouterContext!.streamController = controller;
       },
     }).pipeThrough(new TextEncoderStream());
     window.__reactRouterContext!.streamController.enqueue(
-      // ts-expect-error
+      // @ts-expect-error
       '[{"1":2,"6":4,"7":4},"loaderData",{"3":4,"5":4},"root",null,"empty","actionData","errors"]\n'
     );
     window.__reactRouterContext!.streamController.close();
diff --git a/packages/react-router/__tests__/server-runtime/data-test.ts b/packages/react-router/__tests__/server-runtime/data-test.ts
index 653c62d31b..bf196b458f 100644
--- a/packages/react-router/__tests__/server-runtime/data-test.ts
+++ b/packages/react-router/__tests__/server-runtime/data-test.ts
@@ -1,6 +1,6 @@
 import { decodeViaTurboStream } from "../../lib/dom/ssr/single-fetch";
-import type { ServerBuild } from "../../lib/server-runtime/build";
 import { createRequestHandler } from "../../lib/server-runtime/server";
+import { mockServerBuild } from "./utils";
 
 describe("loaders", () => {
   // so that HTML/Fetch requests are the same, and so redirects don't hang on to
@@ -11,20 +11,13 @@ describe("loaders", () => {
     };
 
     let routeId = "routes/random";
-    let build = {
-      routes: {
-        [routeId]: {
-          id: routeId,
-          path: "/random",
-          module: {
-            loader,
-          },
-        },
+    let build = mockServerBuild({
+      [routeId]: {
+        path: "/random",
+        default: {},
+        loader,
       },
-      entry: { module: {} },
-      prerender: [],
-      future: {},
-    } as unknown as ServerBuild;
+    });
 
     let handler = createRequestHandler(build);
 
diff --git a/packages/react-router/__tests__/server-runtime/handle-error-test.ts b/packages/react-router/__tests__/server-runtime/handle-error-test.ts
index dfb751373d..dc5b399e81 100644
--- a/packages/react-router/__tests__/server-runtime/handle-error-test.ts
+++ b/packages/react-router/__tests__/server-runtime/handle-error-test.ts
@@ -1,33 +1,28 @@
-import type { ServerBuild } from "../../lib/server-runtime/build";
 import { createRequestHandler } from "../../lib/server-runtime/server";
 import { ErrorResponseImpl } from "../../lib/router/utils";
+import { mockServerBuild } from "./utils";
+import type { HandleDocumentRequestFunction } from "../../lib/server-runtime/build";
 
-function getHandler(routeModule = {}, entryServerModule = {}) {
-  let routeId = "root";
+function getHandler(
+  routeModule = {},
+  opts: {
+    handleDocumentRequest?: HandleDocumentRequestFunction;
+  } = {}
+) {
   let handleErrorSpy = jest.fn();
-  let build = {
-    routes: {
-      [routeId]: {
-        id: routeId,
+  let build = mockServerBuild(
+    {
+      root: {
         path: "/",
-        module: {
-          default() {},
-          ...routeModule,
-        },
-      },
-    },
-    entry: {
-      module: {
-        handleError: handleErrorSpy,
-        default() {
-          return new Response("<html><body>Dummy document</body></html>");
-        },
-        ...entryServerModule,
+        default() {},
+        ...routeModule,
       },
     },
-    future: {},
-    prerender: [],
-  } as unknown as ServerBuild;
+    {
+      handleError: handleErrorSpy,
+      handleDocumentRequest: opts.handleDocumentRequest,
+    }
+  );
 
   return {
     handler: createRequestHandler(build),
@@ -76,7 +71,7 @@ describe("handleError", () => {
 
     it("provides render-thrown Error", async () => {
       let { handler, handleErrorSpy } = getHandler(undefined, {
-        default() {
+        handleDocumentRequest() {
           throw new Error("Render error");
         },
       });
diff --git a/packages/react-router/__tests__/server-runtime/handler-test.ts b/packages/react-router/__tests__/server-runtime/handler-test.ts
index 7551b8deb2..1907308c16 100644
--- a/packages/react-router/__tests__/server-runtime/handler-test.ts
+++ b/packages/react-router/__tests__/server-runtime/handler-test.ts
@@ -1,25 +1,15 @@
 import { createRequestHandler } from "../../lib/server-runtime/server";
+import { mockServerBuild } from "./utils";
 
 describe("createRequestHandler", () => {
   it("retains request headers when stripping body off for loaders", async () => {
-    let handler = createRequestHandler({
-      ssr: true,
-      routes: {
-        root: {
-          id: "routes/test",
-          path: "/test",
-          module: {
-            loader: ({ request }) =>
-              Response.json(request.headers.get("X-Foo")),
-          } as any,
-        },
+    let build = mockServerBuild({
+      root: {
+        path: "/test",
+        loader: ({ request }) => Response.json(request.headers.get("X-Foo")),
       },
-      assets: {} as any,
-      entry: { module: {} as any },
-      // @ts-expect-error
-      future: {},
-      prerender: [],
     });
+    let handler = createRequestHandler(build);
 
     let response = await handler(
       new Request("http://.../test", {
diff --git a/packages/react-router/__tests__/server-runtime/server-test.ts b/packages/react-router/__tests__/server-runtime/server-test.ts
index fa62752bb8..5e88c84f20 100644
--- a/packages/react-router/__tests__/server-runtime/server-test.ts
+++ b/packages/react-router/__tests__/server-runtime/server-test.ts
@@ -9,7 +9,6 @@ import {
 
 import { createRequestHandler } from "../../lib/server-runtime/server";
 import { ServerMode } from "../../lib/server-runtime/mode";
-import type { ServerBuild } from "../../lib/server-runtime/build";
 import { mockServerBuild } from "./utils";
 
 function spyConsole() {
@@ -29,43 +28,23 @@ function spyConsole() {
 
 describe("server", () => {
   let routeId = "root";
-  let build: ServerBuild = {
-    ssr: true,
-    entry: {
-      module: {
-        default: async (request) => {
-          return new Response(`${request.method}, ${request.url} COMPONENT`);
-        },
-      },
-    },
-    routes: {
+  let build = mockServerBuild(
+    {
       [routeId]: {
-        id: routeId,
         path: "",
-        module: {
-          action: ({ request }) =>
-            new Response(`${request.method} ${request.url} ACTION`),
-          loader: ({ request }) =>
-            new Response(`${request.method} ${request.url} LOADER`),
-          default: () => "COMPONENT",
-        },
+        action: ({ request }) =>
+          new Response(`${request.method} ${request.url} ACTION`),
+        loader: ({ request }) =>
+          new Response(`${request.method} ${request.url} LOADER`),
+        default: () => "COMPONENT",
       },
     },
-    assets: {
-      routes: {
-        [routeId]: {
-          hasAction: true,
-          hasErrorBoundary: false,
-          hasLoader: true,
-          id: routeId,
-          module: routeId,
-          path: "",
-        },
+    {
+      handleDocumentRequest(request) {
+        return new Response(`${request.method}, ${request.url} COMPONENT`);
       },
-    },
-    future: {},
-    prerender: [],
-  } as unknown as ServerBuild;
+    }
+  );
 
   describe("createRequestHandler", () => {
     let spy = spyConsole();
@@ -116,57 +95,21 @@ describe("server", () => {
     });
 
     it("accepts proper values from getLoadContext (without middleware)", async () => {
-      let handler = createRequestHandler({
-        ssr: true,
-        entry: {
-          module: {
-            default: async (request) => {
-              return new Response(
-                `${request.method}, ${request.url} COMPONENT`
-              );
-            },
-          },
-        },
-        routes: {
+      let build = mockServerBuild(
+        {
           root: {
-            id: "root",
             path: "",
-            module: {
-              loader: ({ context }) => context.foo,
-              default: () => "COMPONENT",
-            },
+            loader: ({ context }) => context.foo,
+            default: () => "COMPONENT",
           },
         },
-        assets: {
-          routes: {
-            root: {
-              clientActionModule: undefined,
-              clientLoaderModule: undefined,
-              clientMiddlewareModule: undefined,
-              hasAction: true,
-              hasClientAction: false,
-              hasClientLoader: false,
-              hasClientMiddleware: false,
-              hasErrorBoundary: false,
-              hasLoader: true,
-              hydrateFallbackModule: undefined,
-              id: routeId,
-              module: routeId,
-              path: "",
-            },
+        {
+          handleDocumentRequest(request) {
+            return new Response(`${request.method}, ${request.url} COMPONENT`);
           },
-          entry: { imports: [], module: "" },
-          url: "",
-          version: "",
-        },
-        future: {
-          unstable_middleware: false,
-        },
-        prerender: [],
-        publicPath: "/",
-        assetsBuildDirectory: "/",
-        isSpaMode: false,
-      });
+        }
+      );
+      let handler = createRequestHandler(build);
       let response = await handler(
         new Request("http://localhost:3000/_root.data"),
         {
@@ -179,57 +122,21 @@ describe("server", () => {
 
     it("accepts proper values from getLoadContext (with middleware)", async () => {
       let fooContext = unstable_createContext<string>();
-      let handler = createRequestHandler({
-        ssr: true,
-        entry: {
-          module: {
-            default: async (request) => {
-              return new Response(
-                `${request.method}, ${request.url} COMPONENT`
-              );
-            },
-          },
-        },
-        routes: {
+      let build = mockServerBuild(
+        {
           root: {
-            id: "root",
             path: "",
-            module: {
-              loader: ({ context }) => context.get(fooContext),
-              default: () => "COMPONENT",
-            },
+            loader: ({ context }) => context.get(fooContext),
+            default: () => "COMPONENT",
           },
         },
-        assets: {
-          routes: {
-            root: {
-              clientActionModule: undefined,
-              clientLoaderModule: undefined,
-              clientMiddlewareModule: undefined,
-              hasAction: true,
-              hasClientAction: false,
-              hasClientLoader: false,
-              hasClientMiddleware: false,
-              hasErrorBoundary: false,
-              hasLoader: true,
-              hydrateFallbackModule: undefined,
-              id: routeId,
-              module: routeId,
-              path: "",
-            },
+        {
+          handleDocumentRequest(request) {
+            return new Response(`${request.method}, ${request.url} COMPONENT`);
           },
-          entry: { imports: [], module: "" },
-          url: "",
-          version: "",
-        },
-        future: {
-          unstable_middleware: true,
-        },
-        prerender: [],
-        publicPath: "/",
-        assetsBuildDirectory: "/",
-        isSpaMode: false,
-      });
+        }
+      );
+      let handler = createRequestHandler(build);
       let response = await handler(
         new Request("http://localhost:3000/_root.data"),
         // @ts-expect-error In apps the expected type is handled via the Future interface
@@ -241,59 +148,25 @@ describe("server", () => {
 
     it("errors if an invalid value is returned from getLoadContext (with middleware)", async () => {
       let handleErrorSpy = jest.fn();
-      let handler = createRequestHandler({
-        ssr: true,
-        entry: {
-          module: {
-            handleError: handleErrorSpy,
-            default: async (request) => {
-              return new Response(
-                `${request.method}, ${request.url} COMPONENT`
-              );
-            },
-          },
-        },
-        routes: {
+      let build = mockServerBuild(
+        {
           root: {
-            id: "root",
             path: "",
-            module: {
-              loader: ({ context }) => context.foo,
-              default: () => "COMPONENT",
-            },
+            loader: ({ context }) => context.foo,
+            default: () => "COMPONENT",
           },
         },
-        assets: {
-          routes: {
-            root: {
-              clientActionModule: undefined,
-              clientLoaderModule: undefined,
-              clientMiddlewareModule: undefined,
-              hasAction: true,
-              hasClientAction: false,
-              hasClientLoader: false,
-              hasClientMiddleware: false,
-              hasErrorBoundary: false,
-              hasLoader: true,
-              hydrateFallbackModule: undefined,
-              id: routeId,
-              module: routeId,
-              path: "",
-            },
+        {
+          future: {
+            unstable_middleware: true,
           },
-          entry: { imports: [], module: "" },
-          url: "",
-          version: "",
-        },
-        future: {
-          unstable_middleware: true,
-        },
-        prerender: [],
-        publicPath: "/",
-        assetsBuildDirectory: "/",
-        isSpaMode: false,
-      });
-
+          handleError: handleErrorSpy,
+          handleDocumentRequest(request) {
+            return new Response(`${request.method}, ${request.url} COMPONENT`);
+          },
+        }
+      );
+      let handler = createRequestHandler(build);
       let response = await handler(
         new Request("http://localhost:3000/_root.data"),
         {
@@ -2220,31 +2093,27 @@ describe("shared server runtime", () => {
     let indexLoader = jest.fn(() => {
       return "index";
     });
-    let build = mockServerBuild({
-      root: {
-        default: {},
-        loader: rootLoader,
-        ErrorBoundary: {},
-      },
-      "routes/_index": {
-        parentId: "root",
-        default: {},
-        loader: indexLoader,
+    let build = mockServerBuild(
+      {
+        root: {
+          default: {},
+          loader: rootLoader,
+          ErrorBoundary: {},
+        },
+        "routes/_index": {
+          parentId: "root",
+          default: {},
+          loader: indexLoader,
+        },
       },
-    });
-
-    build.entry.module.default = jest.fn(
-      async (
-        request,
-        responseStatusCode,
-        responseHeaders,
-        entryContext,
-        loadContext
-      ) =>
-        new Response(JSON.stringify(loadContext), {
-          status: responseStatusCode,
-          headers: responseHeaders,
-        })
+      {
+        handleDocumentRequest(request, responseStatusCode, responseHeaders) {
+          return new Response(JSON.stringify(loadContext), {
+            status: responseStatusCode,
+            headers: responseHeaders,
+          });
+        },
+      }
     );
 
     let handler = createRequestHandler(build, ServerMode.Development);
diff --git a/packages/react-router/__tests__/server-runtime/utils.ts b/packages/react-router/__tests__/server-runtime/utils.ts
index 6a9e5508fd..a97a012fd7 100644
--- a/packages/react-router/__tests__/server-runtime/utils.ts
+++ b/packages/react-router/__tests__/server-runtime/utils.ts
@@ -1,17 +1,18 @@
 import prettier from "prettier";
 
+import type { FutureConfig } from "../../lib/dom/ssr/entry";
 import type {
-  ActionFunction,
-  HandleErrorFunction,
-  HeadersFunction,
-  LoaderFunction,
-} from "../../lib/server-runtime";
-import type { FutureConfig } from "../../lib/server-runtime/entry";
-import type {
-  EntryRoute,
   ServerRoute,
   ServerRouteManifest,
 } from "../../lib/server-runtime/routes";
+import type {
+  HandleDocumentRequestFunction,
+  HandleErrorFunction,
+  ServerBuild,
+} from "../../lib/server-runtime/build";
+import type { HeadersFunction } from "../../lib/dom/ssr/routeModules";
+import type { EntryRoute } from "../../lib/dom/ssr/routes";
+import type { ActionFunction, LoaderFunction } from "../../lib/router/utils";
 
 export function mockServerBuild(
   routes: Record<
@@ -30,14 +31,24 @@ export function mockServerBuild(
   opts: {
     future?: Partial<FutureConfig>;
     handleError?: HandleErrorFunction;
+    handleDocumentRequest?: HandleDocumentRequestFunction;
   } = {}
-) {
+): ServerBuild {
   return {
     ssr: true,
     future: {
+      unstable_middleware: false,
+      unstable_subResourceIntegrity: false,
       ...opts.future,
     },
     prerender: [],
+    isSpaMode: false,
+    routeDiscovery: {
+      mode: "lazy",
+      manifestPath: "/__manifest",
+    },
+    assetsBuildDirectory: "",
+    publicPath: "",
     assets: {
       entry: {
         imports: [""],
@@ -48,6 +59,13 @@ export function mockServerBuild(
           hasAction: !!config.action,
           hasErrorBoundary: !!config.ErrorBoundary,
           hasLoader: !!config.loader,
+          hasClientAction: false,
+          hasClientLoader: false,
+          hasClientMiddleware: false,
+          clientActionModule: undefined,
+          clientLoaderModule: undefined,
+          clientMiddlewareModule: undefined,
+          hydrateFallbackModule: undefined,
           id,
           module: "",
           index: config.index,
@@ -64,19 +82,15 @@ export function mockServerBuild(
     },
     entry: {
       module: {
-        default: jest.fn(
-          async (
-            request,
-            responseStatusCode,
-            responseHeaders,
-            entryContext,
-            loadContext
-          ) =>
-            new Response(null, {
-              status: responseStatusCode,
-              headers: responseHeaders,
-            })
-        ),
+        default:
+          opts.handleDocumentRequest ||
+          jest.fn(
+            async (request, responseStatusCode, responseHeaders) =>
+              new Response(null, {
+                status: responseStatusCode,
+                headers: responseHeaders,
+              })
+          ),
         handleDataRequest: jest.fn(async (response) => response),
         handleError: opts.handleError,
       },
diff --git a/packages/react-router/__tests__/utils/framework.ts b/packages/react-router/__tests__/utils/framework.ts
new file mode 100644
index 0000000000..2df84ff8b2
--- /dev/null
+++ b/packages/react-router/__tests__/utils/framework.ts
@@ -0,0 +1,71 @@
+import type {
+  EntryContext,
+  FrameworkContextObject,
+} from "../../lib/dom/ssr/entry";
+
+export function mockFrameworkContext(
+  overrides?: Partial<FrameworkContextObject>
+): FrameworkContextObject {
+  return {
+    routeModules: { root: { default: () => null } },
+    manifest: {
+      routes: {
+        root: {
+          id: "root",
+          module: "root.js",
+          hasClientMiddleware: false,
+          hasLoader: false,
+          hasClientLoader: false,
+          hasAction: false,
+          hasClientAction: false,
+          hasErrorBoundary: false,
+          clientActionModule: undefined,
+          clientLoaderModule: undefined,
+          clientMiddlewareModule: undefined,
+          hydrateFallbackModule: undefined,
+        },
+      },
+      entry: { imports: [], module: "" },
+      url: "",
+      version: "",
+    },
+    future: {
+      unstable_middleware: false,
+      unstable_subResourceIntegrity: false,
+    },
+    ssr: true,
+    isSpaMode: false,
+    routeDiscovery: {
+      mode: "lazy",
+      manifestPath: "/__manifest",
+    },
+    ...overrides,
+  };
+}
+
+export function mockEntryContext(
+  overrides?: Partial<EntryContext>
+): EntryContext {
+  return {
+    ...mockFrameworkContext(overrides),
+    staticHandlerContext: {
+      location: {
+        pathname: "/",
+        search: "",
+        hash: "",
+        state: null,
+        key: "default",
+      },
+      basename: "",
+      loaderData: {},
+      actionData: null,
+      errors: null,
+      matches: [],
+      statusCode: 200,
+      actionHeaders: {},
+      loaderHeaders: {},
+    },
+    serverHandoffStream: undefined,
+    ...overrides,
+  };
+}
diff --git a/packages/react-router/lib/dom-export/hydrated-router.tsx b/packages/react-router/lib/dom-export/hydrated-router.tsx
index 40a70add34..e4faad01b8 100644
--- a/packages/react-router/lib/dom-export/hydrated-router.tsx
+++ b/packages/react-router/lib/dom-export/hydrated-router.tsx
@@ -185,6 +185,7 @@ function createHydratedRouter({
       ssrInfo.manifest,
       ssrInfo.routeModules,
       ssrInfo.context.ssr,
+      ssrInfo.context.routeDiscovery,
       ssrInfo.context.isSpaMode,
       ssrInfo.context.basename
     ),
@@ -270,6 +271,7 @@ export function HydratedRouter(props: HydratedRouterProps) {
     ssrInfo.manifest,
     ssrInfo.routeModules,
     ssrInfo.context.ssr,
+    ssrInfo.context.routeDiscovery,
     ssrInfo.context.isSpaMode
   );
 
@@ -289,6 +291,7 @@ export function HydratedRouter(props: HydratedRouterProps) {
           criticalCss,
           ssr: ssrInfo.context.ssr,
           isSpaMode: ssrInfo.context.isSpaMode,
+          routeDiscovery: ssrInfo.context.routeDiscovery,
         }}
       >
         <RemixErrorBoundary location={location}>
diff --git a/packages/react-router/lib/dom/global.ts b/packages/react-router/lib/dom/global.ts
index c6e3f5b58b..d781dce03d 100644
--- a/packages/react-router/lib/dom/global.ts
+++ b/packages/react-router/lib/dom/global.ts
@@ -1,22 +1,12 @@
 import type { HydrationState, Router as DataRouter } from "../router/router";
-import type { AssetsManifest, CriticalCss, FutureConfig } from "./ssr/entry";
+import type { ServerHandoff } from "../server-runtime/serverHandoff";
+import type { AssetsManifest } from "./ssr/entry";
 import type { RouteModules } from "./ssr/routeModules";
 
-export type WindowReactRouterContext = {
-  basename?: string;
-  state: HydrationState;
-  criticalCss?: CriticalCss;
-  future: FutureConfig;
-  ssr: boolean;
-  isSpaMode: boolean;
+export type WindowReactRouterContext = ServerHandoff & {
+  state: HydrationState; // Deserialized via the stream
   stream: ReadableStream<Uint8Array> | undefined;
   streamController: ReadableStreamDefaultController<Uint8Array>;
-  // The number of active deferred keys rendered on the server
-  a?: number;
-  dev?: {
-    port?: number;
-    hmrRuntime?: string;
-  };
 };
 
 export interface ViewTransition {
diff --git a/packages/react-router/lib/dom/ssr/components.tsx b/packages/react-router/lib/dom/ssr/components.tsx
index 0f4e39c7e9..e2ae70d049 100644
--- a/packages/react-router/lib/dom/ssr/components.tsx
+++ b/packages/react-router/lib/dom/ssr/components.tsx
@@ -643,11 +643,17 @@ export type ScriptsProps = Omit<
   @category Components
  */
 export function Scripts(props: ScriptsProps) {
-  let { manifest, serverHandoffString, isSpaMode, ssr, renderMeta } =
-    useFrameworkContext();
+  let {
+    manifest,
+    serverHandoffString,
+    isSpaMode,
+    renderMeta,
+    routeDiscovery,
+    ssr,
+  } = useFrameworkContext();
   let { router, static: isStatic, staticContext } = useDataRouterContext();
   let { matches: routerMatches } = useDataRouterStateContext();
-  let enableFogOfWar = isFogOfWarEnabled(ssr);
+  let enableFogOfWar = isFogOfWarEnabled(routeDiscovery, ssr);
 
   // Let <ServerRouter> know that we hydrated and we should render the single
   // fetch streaming scripts
diff --git a/packages/react-router/lib/dom/ssr/entry.ts b/packages/react-router/lib/dom/ssr/entry.ts
index 995cf50b0d..063729cd63 100644
--- a/packages/react-router/lib/dom/ssr/entry.ts
+++ b/packages/react-router/lib/dom/ssr/entry.ts
@@ -3,6 +3,7 @@ import type { StaticHandlerContext } from "../../router/router";
 import type { EntryRoute } from "./routes";
 import type { RouteModules } from "./routeModules";
 import type { RouteManifest } from "../../router/utils";
+import type { ServerBuild } from "../../server-runtime/build";
 
 type SerializedError = {
   message: string;
@@ -18,6 +19,7 @@ export interface FrameworkContextObject {
   future: FutureConfig;
   ssr: boolean;
   isSpaMode: boolean;
+  routeDiscovery: ServerBuild["routeDiscovery"];
   serializeError?(error: Error): SerializedError;
   renderMeta?: {
     didRenderScripts?: boolean;
diff --git a/packages/react-router/lib/dom/ssr/fog-of-war.ts b/packages/react-router/lib/dom/ssr/fog-of-war.ts
index c929bf1c13..930daf99b4 100644
--- a/packages/react-router/lib/dom/ssr/fog-of-war.ts
+++ b/packages/react-router/lib/dom/ssr/fog-of-war.ts
@@ -7,6 +7,7 @@ import type { AssetsManifest } from "./entry";
 import type { RouteModules } from "./routeModules";
 import type { EntryRoute } from "./routes";
 import { createClientRoutes } from "./routes";
+import type { ServerBuild } from "../../server-runtime/build";
 
 declare global {
   interface Navigator {
@@ -26,8 +27,11 @@ const discoveredPaths = new Set<string>();
 // https://stackoverflow.com/a/417184
 const URL_LIMIT = 7680;
 
-export function isFogOfWarEnabled(ssr: boolean) {
-  return ssr === true;
+export function isFogOfWarEnabled(
+  routeDiscovery: ServerBuild["routeDiscovery"],
+  ssr: boolean
+) {
+  return routeDiscovery.mode === "lazy" && ssr === true;
 }
 
 export function getPartialManifest(
@@ -72,10 +76,11 @@ export function getPatchRoutesOnNavigationFunction(
   manifest: AssetsManifest,
   routeModules: RouteModules,
   ssr: boolean,
+  routeDiscovery: ServerBuild["routeDiscovery"],
   isSpaMode: boolean,
   basename: string | undefined
 ): PatchRoutesOnNavigationFunction | undefined {
-  if (!isFogOfWarEnabled(ssr)) {
+  if (!isFogOfWarEnabled(routeDiscovery, ssr)) {
     return undefined;
   }
 
@@ -91,6 +96,7 @@ export function getPatchRoutesOnNavigationFunction(
       ssr,
       isSpaMode,
       basename,
+      routeDiscovery.manifestPath,
       patch,
       signal
     );
@@ -102,11 +108,15 @@ export function useFogOFWarDiscovery(
   manifest: AssetsManifest,
   routeModules: RouteModules,
   ssr: boolean,
+  routeDiscovery: ServerBuild["routeDiscovery"],
   isSpaMode: boolean
 ) {
   React.useEffect(() => {
     // Don't prefetch if not enabled or if the user has `saveData` enabled
-    if (!isFogOfWarEnabled(ssr) || navigator.connection?.saveData === true) {
+    if (
+      !isFogOfWarEnabled(routeDiscovery, ssr) ||
+      navigator.connection?.saveData === true
+    ) {
       return;
     }
 
@@ -157,6 +167,7 @@ export function useFogOFWarDiscovery(
           ssr,
           isSpaMode,
           router.basename,
+          routeDiscovery.manifestPath,
           router.patchRoutes
         );
       } catch (e) {
@@ -181,7 +192,20 @@ export function useFogOFWarDiscovery(
     });
 
     return () => observer.disconnect();
-  }, [ssr, isSpaMode, manifest, routeModules, router]);
+  }, [ssr, isSpaMode, manifest, routeModules, router, routeDiscovery]);
+}
+
+export function getManifestPath(
+  _manifestPath: string | undefined,
+  basename: string | undefined
+) {
+  let manifestPath = _manifestPath || "/__manifest";
+
+  if (basename == null) {
+    return manifestPath;
+  }
+
+  return `${basename}${manifestPath}`.replace(/\/+/g, "/");
 }
 
 const MANIFEST_VERSION_STORAGE_KEY = "react-router-manifest-version";
@@ -194,14 +218,14 @@ export async function fetchAndApplyManifestPatches(
   ssr: boolean,
   isSpaMode: boolean,
   basename: string | undefined,
+  manifestPath: string,
   patchRoutes: DataRouter["patchRoutes"],
   signal?: AbortSignal
 ): Promise<void> {
-  let manifestPath = `${basename != null ? basename : "/"}/__manifest`.replace(
-    /\/+/g,
-    "/"
+  let url = new URL(
+    getManifestPath(manifestPath, basename),
+    window.location.origin
   );
-  let url = new URL(manifestPath, window.location.origin);
   paths.sort().forEach((path) => url.searchParams.append("p", path));
   url.searchParams.set("version", manifest.version);
 
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 1ab169f25d..5307012aa7 100644
--- a/packages/react-router/lib/dom/ssr/routes-test-stub.tsx
+++ b/packages/react-router/lib/dom/ssr/routes-test-stub.tsx
@@ -113,6 +113,7 @@ export function createRoutesStub(
         routeModules: {},
         ssr: false,
         isSpaMode: false,
+        routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
       };
 
       // Update the routes to include context in the loader/action and populate
diff --git a/packages/react-router/lib/dom/ssr/server.tsx b/packages/react-router/lib/dom/ssr/server.tsx
index 7b54e4a37e..befc1b0125 100644
--- a/packages/react-router/lib/dom/ssr/server.tsx
+++ b/packages/react-router/lib/dom/ssr/server.tsx
@@ -82,6 +82,7 @@ export function ServerRouter({
           future: context.future,
           ssr: context.ssr,
           isSpaMode: context.isSpaMode,
+          routeDiscovery: context.routeDiscovery,
           serializeError: context.serializeError,
           renderMeta: context.renderMeta,
         }}
diff --git a/packages/react-router/lib/server-runtime/build.ts b/packages/react-router/lib/server-runtime/build.ts
index 1fd78abdb7..c12b4ab60e 100644
--- a/packages/react-router/lib/server-runtime/build.ts
+++ b/packages/react-router/lib/server-runtime/build.ts
@@ -37,6 +37,10 @@ export interface ServerBuild {
    */
   isSpaMode: boolean;
   prerender: string[];
+  routeDiscovery: {
+    mode: "lazy" | "initial";
+    manifestPath: string;
+  };
 }
 
 export interface HandleDocumentRequestFunction {
diff --git a/packages/react-router/lib/server-runtime/server.ts b/packages/react-router/lib/server-runtime/server.ts
index 5cba00bcd4..e6e9cd74ba 100644
--- a/packages/react-router/lib/server-runtime/server.ts
+++ b/packages/react-router/lib/server-runtime/server.ts
@@ -22,6 +22,7 @@ import type { RouteMatch } from "./routeMatching";
 import { matchServerRoutes } from "./routeMatching";
 import type { ServerRoute } from "./routes";
 import { createStaticHandlerDataRoutes, createRoutes } from "./routes";
+import type { ServerHandoff } from "./serverHandoff";
 import { createServerHandoffString } from "./serverHandoff";
 import { getDevServerHooks } from "./dev";
 import {
@@ -40,6 +41,7 @@ import type {
 } from "../dom/ssr/single-fetch";
 import { SingleFetchRedirectSymbol } from "../dom/ssr/single-fetch";
 import type { MiddlewareEnabled } from "../types/future";
+import { getManifestPath } from "../dom/ssr/fog-of-war";
 
 export type RequestHandler = (
   request: Request,
@@ -198,7 +200,10 @@ export const createRequestHandler: CreateRequestHandlerFunction = (
     }
 
     // Manifest request for fog of war
-    let manifestUrl = `${normalizedBasename}/__manifest`.replace(/\/+/g, "/");
+    let manifestUrl = getManifestPath(
+      _build.routeDiscovery.manifestPath,
+      normalizedBasename
+    );
     if (url.pathname === manifestUrl) {
       try {
         let res = await handleManifestRequest(_build, routes, url);
@@ -474,17 +479,21 @@ async function handleDocumentRequest(
       actionData: context.actionData,
       errors: serializeErrors(context.errors, serverMode),
     };
+    let baseServerHandoff: ServerHandoff = {
+      basename: build.basename,
+      future: build.future,
+      routeDiscovery: build.routeDiscovery,
+      ssr: build.ssr,
+      isSpaMode,
+    };
     let entryContext: EntryContext = {
       manifest: build.assets,
       routeModules: createEntryRouteModules(build.routes),
       staticHandlerContext: context,
       criticalCss,
       serverHandoffString: createServerHandoffString({
-        basename: build.basename,
+        ...baseServerHandoff,
         criticalCss,
-        future: build.future,
-        ssr: build.ssr,
-        isSpaMode,
       }),
       serverHandoffStream: encodeViaTurboStream(
         state,
@@ -495,6 +504,7 @@ async function handleDocumentRequest(
       renderMeta: {},
       future: build.future,
       ssr: build.ssr,
+      routeDiscovery: build.routeDiscovery,
       isSpaMode,
       serializeError: (err) => serializeError(err, serverMode),
     };
@@ -554,12 +564,7 @@ async function handleDocumentRequest(
       entryContext = {
         ...entryContext,
         staticHandlerContext: context,
-        serverHandoffString: createServerHandoffString({
-          basename: build.basename,
-          future: build.future,
-          ssr: build.ssr,
-          isSpaMode,
-        }),
+        serverHandoffString: createServerHandoffString(baseServerHandoff),
         serverHandoffStream: encodeViaTurboStream(
           state,
           request.signal,
diff --git a/packages/react-router/lib/server-runtime/serverHandoff.ts b/packages/react-router/lib/server-runtime/serverHandoff.ts
index 203b70bab4..ea24252c81 100644
--- a/packages/react-router/lib/server-runtime/serverHandoff.ts
+++ b/packages/react-router/lib/server-runtime/serverHandoff.ts
@@ -1,29 +1,19 @@
-import type { HydrationState } from "../router/router";
 import type { CriticalCss, FutureConfig } from "../dom/ssr/entry";
 import { escapeHtml } from "./markup";
+import type { ServerBuild } from "./build";
 
-type ValidateShape<T, Shape> =
-  // If it extends T
-  T extends Shape
-    ? // and there are no leftover props after removing the base
-      Exclude<keyof T, keyof Shape> extends never
-      ? // we are good
-        T
-      : // otherwise it's either too many or too few props
-        never
-    : never;
-
-// TODO: Remove Promises from serialization
-export function createServerHandoffString<T>(serverHandoff: {
-  // Don't allow StaticHandlerContext to be passed in verbatim, since then
-  // we'd end up including duplicate info
-  state?: ValidateShape<T, HydrationState>;
+export type ServerHandoff = {
   criticalCss?: CriticalCss;
   basename: string | undefined;
   future: FutureConfig;
   ssr: boolean;
   isSpaMode: boolean;
-}): string {
+  routeDiscovery: ServerBuild["routeDiscovery"];
+};
+
+export function createServerHandoffString(
+  serverHandoff: ServerHandoff
+): string {
   // Uses faster alternative of jsesc to escape data returned from the loaders.
   // This string is inserted directly into the HTML in the `<Scripts>` element.
   return escapeHtml(JSON.stringify(serverHandoff));