react-router 7.1.5 → 7.2.0-pre.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # `react-router`
 
+## 7.2.0-pre.0
+
+### Patch Changes
+
+- Don't apply Single Fetch revalidation de-optimization when in SPA mode since there is no server HTTP request ([#12948](https://github.com/remix-run/react-router/pull/12948))
+- Add unstable support for splitting route modules in framework mode via `future.unstable_splitRouteModules` ([#11871](https://github.com/remix-run/react-router/pull/11871))
+- Align dev server behavior with static file server behavior when `ssr:false` is set ([#12948](https://github.com/remix-run/react-router/pull/12948))
+
+  - When no `prerender` config exists, only SSR down to the root `HydrateFallback` (SPA Mode)
+  - When a `prerender` config exists but the current path is not prerendered, only SSR down to the root `HydrateFallback` (SPA Fallback)
+  - Return a 404 on `.data` requests to non-pre-rendered paths
+
+- Improve prefetch performance of CSS side effects in framework mode ([#12889](https://github.com/remix-run/react-router/pull/12889))
+- Disable Lazy Route Discovery for all `ssr:false` apps and not just "SPA Mode" because there is no runtime server to serve the search-param-configured `__manifest` requests ([#12894](https://github.com/remix-run/react-router/pull/12894))
+
+  - We previously only disabled this for "SPA Mode" which is `ssr:false` and no `prerender` config but we realized it should apply to all `ssr:false` apps, including those prerendering multiple pages
+  - In those `prerender` scenarios we would prerender the `/__manifest` file assuming the static file server would serve it but that makes some unneccesary assumptions about the static file server behaviors
+
+- Properly handle interrupted manifest requests in lazy route discovery ([#12915](https://github.com/remix-run/react-router/pull/12915))
+
 ## 7.1.5
 
 ### Patch Changes
@@ -83,7 +103,7 @@ _No changes_
   - Collapse `@remix-run/server-runtime` into `react-router`
   - Collapse `@remix-run/testing` into `react-router`
 
-- Remove single\_fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
+- Remove single_fetch future flag. ([#11522](https://github.com/remix-run/react-router/pull/11522))
 
 - Drop support for Node 16, React Router SSR now requires Node 18 or higher ([#11391](https://github.com/remix-run/react-router/pull/11391))
 

package/dist/development/{chunk-IR6S3I6Y.mjs → chunk-HLU4BUUT.mjs}

@@ -1,5 +1,5 @@
 /**
- * react-router v7.1.5
+ * react-router v7.2.0-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -2459,6 +2459,7 @@ function createRouter(init) {
       let localManifest = manifest;
       try {
         await patchRoutesOnNavigationImpl({
+          signal,
           path: pathname,
           matches: partialMatches,
           patch: (routeId, children) => {
@@ -5359,14 +5360,23 @@ function getKeyedLinksForMatches(matches, routeModules, manifest) {
       module?.links?.() || []
     ];
   }).flat(2);
-  let preloads = getCurrentPageModulePreloadHrefs(matches, manifest);
+  let preloads = getModuleLinkHrefs(matches, manifest);
   return dedupeLinkDescriptors(descriptors, preloads);
 }
+function getRouteCssDescriptors(route) {
+  if (!route.css) return [];
+  return route.css.map((href) => ({ rel: "stylesheet", href }));
+}
+async function prefetchRouteCss(route) {
+  if (!route.css) return;
+  let descriptors = getRouteCssDescriptors(route);
+  await Promise.all(descriptors.map(prefetchStyleLink));
+}
 async function prefetchStyleLinks(route, routeModule) {
   if (!route.css && !routeModule.links || !isPreloadSupported()) return;
   let descriptors = [];
   if (route.css) {
-    descriptors.push(...route.css.map((href) => ({ rel: "stylesheet", href })));
+    descriptors.push(...getRouteCssDescriptors(route));
   }
   if (routeModule.links) {
     descriptors.push(...routeModule.links());
@@ -5382,13 +5392,15 @@ async function prefetchStyleLinks(route, routeModule) {
       });
     }
   }
-  let matchingLinks = styleLinks.filter(
-    (link) => (!link.media || window.matchMedia(link.media).matches) && !document.querySelector(`link[rel="stylesheet"][href="${link.href}"]`)
-  );
-  await Promise.all(matchingLinks.map(prefetchStyleLink));
+  await Promise.all(styleLinks.map(prefetchStyleLink));
 }
 async function prefetchStyleLink(descriptor) {
   return new Promise((resolve) => {
+    if (descriptor.media && !window.matchMedia(descriptor.media).matches || document.querySelector(
+      `link[rel="stylesheet"][href="${descriptor.href}"]`
+    )) {
+      return resolve();
+    }
     let link = document.createElement("link");
     Object.assign(link, descriptor);
     function removeLink() {
@@ -5483,25 +5495,21 @@ function getNewMatchesForLinks(page, nextMatches, currentMatches, manifest, loca
   }
   return [];
 }
-function getModuleLinkHrefs(matches, manifestPatch) {
-  return dedupeHrefs(
-    matches.map((match) => {
-      let route = manifestPatch.routes[match.route.id];
-      if (!route) return [];
-      let hrefs = [route.module];
-      if (route.imports) {
-        hrefs = hrefs.concat(route.imports);
-      }
-      return hrefs;
-    }).flat(1)
-  );
-}
-function getCurrentPageModulePreloadHrefs(matches, manifest) {
+function getModuleLinkHrefs(matches, manifest, { includeHydrateFallback } = {}) {
   return dedupeHrefs(
     matches.map((match) => {
       let route = manifest.routes[match.route.id];
       if (!route) return [];
       let hrefs = [route.module];
+      if (route.clientActionModule) {
+        hrefs = hrefs.concat(route.clientActionModule);
+      }
+      if (route.clientLoaderModule) {
+        hrefs = hrefs.concat(route.clientLoaderModule);
+      }
+      if (includeHydrateFallback && route.hydrateFallbackModule) {
+        hrefs = hrefs.concat(route.hydrateFallbackModule);
+      }
       if (route.imports) {
         hrefs = hrefs.concat(route.imports);
       }
@@ -5656,17 +5664,31 @@ function StreamTransfer({
     )));
   }
 }
-function getSingleFetchDataStrategy(manifest, routeModules, getRouter) {
+function getSingleFetchDataStrategy(manifest, routeModules, ssr, getRouter) {
   return async ({ request, matches, fetcherKey }) => {
     if (request.method !== "GET") {
       return singleFetchActionStrategy(request, matches);
     }
+    if (!ssr) {
+      let foundLoaderBelowRoot = matches.some(
+        (m) => m.route.id !== "root" && manifest.routes[m.route.id]?.hasLoader
+      );
+      if (!foundLoaderBelowRoot) {
+        let matchesToLoad = matches.filter((m) => m.shouldLoad);
+        let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
+        return results.reduce(
+          (acc, result, i) => Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
+          {}
+        );
+      }
+    }
     if (fetcherKey) {
       return singleFetchLoaderFetcherStrategy(request, matches);
     }
     return singleFetchLoaderNavigationStrategy(
       manifest,
       routeModules,
+      ssr,
       getRouter(),
       request,
       matches
@@ -5700,7 +5722,7 @@ async function singleFetchActionStrategy(request, matches) {
     }
   };
 }
-async function singleFetchLoaderNavigationStrategy(manifest, routeModules, router, request, matches) {
+async function singleFetchLoaderNavigationStrategy(manifest, routeModules, ssr, router, request, matches) {
   let routesParams = /* @__PURE__ */ new Set();
   let foundOptOutRoute = false;
   let routeDfds = matches.map(() => createDeferred2());
@@ -5766,7 +5788,7 @@ async function singleFetchLoaderNavigationStrategy(manifest, routeModules, route
     singleFetchDfd.resolve({});
   } else {
     try {
-      if (foundOptOutRoute && routesParams.size > 0) {
+      if (ssr && foundOptOutRoute && routesParams.size > 0) {
         url.searchParams.set(
           "_routes",
           matches.filter((m) => routesParams.has(m.route.id)).map((m) => m.route.id).join(",")
@@ -6134,11 +6156,12 @@ function createServerRoutes(manifest, routeModules, future, isSpaMode, parentId
     return dataRoute;
   });
 }
-function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest, routeModulesCache, initialState, future, isSpaMode) {
+function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest, routeModulesCache, initialState, ssr, isSpaMode) {
   return createClientRoutes(
     manifest,
     routeModulesCache,
     initialState,
+    ssr,
     isSpaMode,
     "",
     groupRoutesByParentId(manifest),
@@ -6147,14 +6170,14 @@ function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation, manifest
 }
 function preventInvalidServerHandlerCall(type, route, isSpaMode) {
   if (isSpaMode) {
-    let fn2 = type === "action" ? "serverAction()" : "serverLoader()";
-    let msg2 = `You cannot call ${fn2} in SPA Mode (routeId: "${route.id}")`;
-    console.error(msg2);
-    throw new ErrorResponseImpl(400, "Bad Request", new Error(msg2), true);
+    let fn = type === "action" ? "serverAction()" : "serverLoader()";
+    let msg = `You cannot call ${fn} in SPA Mode (routeId: "${route.id}")`;
+    console.error(msg);
+    throw new ErrorResponseImpl(400, "Bad Request", new Error(msg), true);
   }
-  let fn = type === "action" ? "serverAction()" : "serverLoader()";
-  let msg = `You are trying to call ${fn} on a route that does not have a server ${type} (routeId: "${route.id}")`;
   if (type === "loader" && !route.hasLoader || type === "action" && !route.hasAction) {
+    let fn = type === "action" ? "serverAction()" : "serverLoader()";
+    let msg = `You are trying to call ${fn} on a route that does not have a server ${type} (routeId: "${route.id}")`;
     console.error(msg);
     throw new ErrorResponseImpl(400, "Bad Request", new Error(msg), true);
   }
@@ -6165,7 +6188,7 @@ function noActionDefinedError(type, routeId) {
   console.error(msg);
   throw new ErrorResponseImpl(405, "Method Not Allowed", new Error(msg), true);
 }
-function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode, parentId = "", routesByParentId = groupRoutesByParentId(manifest), needsRevalidation) {
+function createClientRoutes(manifest, routeModulesCache, initialState, ssr, isSpaMode, parentId = "", routesByParentId = groupRoutesByParentId(manifest), needsRevalidation) {
   return (routesByParentId[parentId] || []).map((route) => {
     let routeModule = routeModulesCache[route.id];
     function fetchServerHandler(singleFetch) {
@@ -6185,6 +6208,21 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       }
       return fetchServerHandler(singleFetch);
     }
+    function prefetchModule(modulePath) {
+      import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        modulePath
+      );
+    }
+    function prefetchRouteModuleChunks(route2) {
+      if (route2.clientActionModule) {
+        prefetchModule(route2.clientActionModule);
+      }
+      if (route2.clientLoaderModule) {
+        prefetchModule(route2.clientLoaderModule);
+      }
+    }
     async function prefetchStylesAndCallHandler(handler) {
       let cachedModule = routeModulesCache[route.id];
       let linkPrefetchPromise = cachedModule ? prefetchStyleLinks(route, cachedModule) : Promise.resolve();
@@ -6206,7 +6244,8 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
         handle: routeModule.handle,
         shouldRevalidate: getShouldRevalidateFunction(
           routeModule,
-          route.id,
+          route,
+          ssr,
           needsRevalidation
         )
       });
@@ -6223,7 +6262,6 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
               "No `routeModule` available for critical-route loader"
             );
             if (!routeModule.clientLoader) {
-              if (isSpaMode) return null;
               return fetchServerLoader(singleFetch);
             }
             return routeModule.clientLoader({
@@ -6278,9 +6316,24 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     } else {
       if (!route.hasClientLoader) {
         dataRoute.loader = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
-          if (isSpaMode) return Promise.resolve(null);
           return fetchServerLoader(singleFetch);
         });
+      } else if (route.clientLoaderModule) {
+        dataRoute.loader = async (args, singleFetch) => {
+          invariant2(route.clientLoaderModule);
+          let { clientLoader } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientLoaderModule
+          );
+          return clientLoader({
+            ...args,
+            async serverLoader() {
+              preventInvalidServerHandlerCall("loader", route, isSpaMode);
+              return fetchServerLoader(singleFetch);
+            }
+          });
+        };
       }
       if (!route.hasClientAction) {
         dataRoute.action = ({ request }, singleFetch) => prefetchStylesAndCallHandler(() => {
@@ -6289,12 +6342,34 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           }
           return fetchServerAction(singleFetch);
         });
+      } else if (route.clientActionModule) {
+        dataRoute.action = async (args, singleFetch) => {
+          invariant2(route.clientActionModule);
+          prefetchRouteModuleChunks(route);
+          let { clientAction } = await import(
+            /* @vite-ignore */
+            /* webpackIgnore: true */
+            route.clientActionModule
+          );
+          return clientAction({
+            ...args,
+            async serverAction() {
+              preventInvalidServerHandlerCall("action", route, isSpaMode);
+              return fetchServerAction(singleFetch);
+            }
+          });
+        };
       }
       dataRoute.lazy = async () => {
-        let mod = await loadRouteModuleWithBlockingLinks(
+        if (route.clientLoaderModule || route.clientActionModule) {
+          await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        let modPromise = loadRouteModuleWithBlockingLinks(
           route,
           routeModulesCache
         );
+        prefetchRouteModuleChunks(route);
+        let mod = await modPromise;
         let lazyRoute = { ...mod };
         if (mod.clientLoader) {
           let clientLoader = mod.clientLoader;
@@ -6322,7 +6397,8 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
           hasErrorBoundary: lazyRoute.hasErrorBoundary,
           shouldRevalidate: getShouldRevalidateFunction(
             lazyRoute,
-            route.id,
+            route,
+            ssr,
             needsRevalidation
           ),
           handle: lazyRoute.handle,
@@ -6337,6 +6413,7 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
       manifest,
       routeModulesCache,
       initialState,
+      ssr,
       isSpaMode,
       route.id,
       routesByParentId,
@@ -6346,15 +6423,18 @@ function createClientRoutes(manifest, routeModulesCache, initialState, isSpaMode
     return dataRoute;
   });
 }
-function getShouldRevalidateFunction(route, routeId, needsRevalidation) {
+function getShouldRevalidateFunction(route, manifestRoute, ssr, needsRevalidation) {
   if (needsRevalidation) {
     return wrapShouldRevalidateForHdr(
-      routeId,
+      manifestRoute.id,
       route.shouldRevalidate,
       needsRevalidation
     );
   }
-  if (route.shouldRevalidate) {
+  if (!ssr && manifestRoute.id === "root" && manifestRoute.hasLoader && !manifestRoute.hasClientLoader) {
+    return () => false;
+  }
+  if (ssr && route.shouldRevalidate) {
     let fn = route.shouldRevalidate;
     return (opts) => fn({ ...opts, defaultShouldRevalidate: true });
   }
@@ -6371,8 +6451,13 @@ function wrapShouldRevalidateForHdr(routeId, routeShouldRevalidate, needsRevalid
   };
 }
 async function loadRouteModuleWithBlockingLinks(route, routeModules) {
-  let routeModule = await loadRouteModule(route, routeModules);
-  await prefetchStyleLinks(route, routeModule);
+  let routeModulePromise = loadRouteModule(route, routeModules);
+  let prefetchRouteCssPromise = prefetchRouteCss(route);
+  let routeModule = await routeModulePromise;
+  await Promise.all([
+    prefetchRouteCssPromise,
+    prefetchStyleLinks(route, routeModule)
+  ]);
   return {
     Component: getRouteModuleComponent(routeModule),
     ErrorBoundary: routeModule.ErrorBoundary,
@@ -6400,8 +6485,8 @@ var nextPaths = /* @__PURE__ */ new Set();
 var discoveredPathsMaxSize = 1e3;
 var discoveredPaths = /* @__PURE__ */ new Set();
 var URL_LIMIT = 7680;
-function isFogOfWarEnabled(isSpaMode) {
-  return !isSpaMode;
+function isFogOfWarEnabled(ssr) {
+  return ssr === true;
 }
 function getPartialManifest(manifest, router) {
   let routeIds = new Set(router.state.matches.map((m) => m.route.id));
@@ -6427,11 +6512,11 @@ function getPartialManifest(manifest, router) {
     routes: initialRoutes
   };
 }
-function getPatchRoutesOnNavigationFunction(manifest, routeModules, isSpaMode, basename) {
-  if (!isFogOfWarEnabled(isSpaMode)) {
+function getPatchRoutesOnNavigationFunction(manifest, routeModules, ssr, isSpaMode, basename) {
+  if (!isFogOfWarEnabled(ssr)) {
     return void 0;
   }
-  return async ({ path, patch }) => {
+  return async ({ path, patch, signal }) => {
     if (discoveredPaths.has(path)) {
       return;
     }
@@ -6439,15 +6524,17 @@ function getPatchRoutesOnNavigationFunction(manifest, routeModules, isSpaMode, b
       [path],
       manifest,
       routeModules,
+      ssr,
       isSpaMode,
       basename,
-      patch
+      patch,
+      signal
     );
   };
 }
-function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
+function useFogOFWarDiscovery(router, manifest, routeModules, ssr, isSpaMode) {
   React8.useEffect(() => {
-    if (!isFogOfWarEnabled(isSpaMode) || navigator.connection?.saveData === true) {
+    if (!isFogOfWarEnabled(ssr) || navigator.connection?.saveData === true) {
       return;
     }
     function registerElement(el) {
@@ -6477,6 +6564,7 @@ function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
           lazyPaths,
           manifest,
           routeModules,
+          ssr,
           isSpaMode,
           router.basename,
           router.patchRoutes
@@ -6495,9 +6583,9 @@ function useFogOFWarDiscovery(router, manifest, routeModules, isSpaMode) {
       attributeFilter: ["data-discover", "href", "action"]
     });
     return () => observer.disconnect();
-  }, [isSpaMode, manifest, routeModules, router]);
+  }, [ssr, isSpaMode, manifest, routeModules, router]);
 }
-async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpaMode, basename, patchRoutes) {
+async function fetchAndApplyManifestPatches(paths, manifest, routeModules, ssr, isSpaMode, basename, patchRoutes, signal) {
   let manifestPath = `${basename != null ? basename : "/"}/__manifest`.replace(
     /\/+/g,
     "/"
@@ -6509,13 +6597,19 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
     nextPaths.clear();
     return;
   }
-  let res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`${res.status} ${res.statusText}`);
-  } else if (res.status >= 400) {
-    throw new Error(await res.text());
+  let serverPatches;
+  try {
+    let res = await fetch(url, { signal });
+    if (!res.ok) {
+      throw new Error(`${res.status} ${res.statusText}`);
+    } else if (res.status >= 400) {
+      throw new Error(await res.text());
+    }
+    serverPatches = await res.json();
+  } catch (e) {
+    if (signal?.aborted) return;
+    throw e;
   }
-  let serverPatches = await res.json();
   let knownRoutes = new Set(Object.keys(manifest.routes));
   let patches = Object.values(serverPatches).reduce((acc, route) => {
     if (route && !knownRoutes.has(route.id)) {
@@ -6534,7 +6628,7 @@ async function fetchAndApplyManifestPatches(paths, manifest, routeModules, isSpa
   parentIds.forEach(
     (parentId) => patchRoutes(
       parentId || null,
-      createClientRoutes(patches, routeModules, null, isSpaMode, parentId)
+      createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId)
     )
   );
 }
@@ -6883,10 +6977,10 @@ function isValidMetaTag(tagName) {
 }
 var isHydrated = false;
 function Scripts(props) {
-  let { manifest, serverHandoffString, isSpaMode, renderMeta } = useFrameworkContext();
+  let { manifest, serverHandoffString, isSpaMode, ssr, renderMeta } = useFrameworkContext();
   let { router, static: isStatic, staticContext } = useDataRouterContext2();
   let { matches: routerMatches } = useDataRouterStateContext();
-  let enableFogOfWar = isFogOfWarEnabled(isSpaMode);
+  let enableFogOfWar = isFogOfWarEnabled(ssr);
   if (renderMeta) {
     renderMeta.didRenderScripts = true;
   }
@@ -6898,11 +6992,44 @@ function Scripts(props) {
     let streamScript = "window.__reactRouterContext.stream = new ReadableStream({start(controller){window.__reactRouterContext.streamController = controller;}}).pipeThrough(new TextEncoderStream());";
     let contextScript = staticContext ? `window.__reactRouterContext = ${serverHandoffString};${streamScript}` : " ";
     let routeModulesScript = !isStatic ? " " : `${manifest.hmr?.runtime ? `import ${JSON.stringify(manifest.hmr.runtime)};` : ""}${!enableFogOfWar ? `import ${JSON.stringify(manifest.url)}` : ""};
-${matches.map(
-      (match, index) => `import * as route${index} from ${JSON.stringify(
-        manifest.routes[match.route.id].module
-      )};`
-    ).join("\n")}
+${matches.map((match, routeIndex) => {
+      let routeVarName = `route${routeIndex}`;
+      let manifestEntry = manifest.routes[match.route.id];
+      invariant2(manifestEntry, `Route ${match.route.id} not found in manifest`);
+      let {
+        clientActionModule,
+        clientLoaderModule,
+        hydrateFallbackModule,
+        module
+      } = manifestEntry;
+      let chunks = [
+        ...clientActionModule ? [
+          {
+            module: clientActionModule,
+            varName: `${routeVarName}_clientAction`
+          }
+        ] : [],
+        ...clientLoaderModule ? [
+          {
+            module: clientLoaderModule,
+            varName: `${routeVarName}_clientLoader`
+          }
+        ] : [],
+        ...hydrateFallbackModule ? [
+          {
+            module: hydrateFallbackModule,
+            varName: `${routeVarName}_HydrateFallback`
+          }
+        ] : [],
+        { module, varName: `${routeVarName}_main` }
+      ];
+      if (chunks.length === 1) {
+        return `import * as ${routeVarName} from ${JSON.stringify(module)};`;
+      }
+      let chunkImportsSnippet = chunks.map((chunk) => `import * as ${chunk.varName} from "${chunk.module}";`).join("\n");
+      let mergedChunksSnippet = `const ${routeVarName} = {${chunks.map((chunk) => `...${chunk.varName}`).join(",")}};`;
+      return [chunkImportsSnippet, mergedChunksSnippet].join("\n");
+    }).join("\n")}
   ${enableFogOfWar ? (
       // Inline a minimal manifest with the SSR matches
       `window.__reactRouterManifest = ${JSON.stringify(
@@ -6933,11 +7060,11 @@ import(${JSON.stringify(manifest.entry.module)});`;
       }
     ));
   }, []);
-  let routePreloads = matches.map((match) => {
-    let route = manifest.routes[match.route.id];
-    return route ? (route.imports || []).concat([route.module]) : [];
-  }).flat(1);
-  let preloads = isHydrated ? [] : manifest.entry.imports.concat(routePreloads);
+  let preloads = isHydrated ? [] : manifest.entry.imports.concat(
+    getModuleLinkHrefs(matches, manifest, {
+      includeHydrateFallback: true
+    })
+  );
   return isHydrated ? null : /* @__PURE__ */ React9.createElement(React9.Fragment, null, !enableFogOfWar ? /* @__PURE__ */ React9.createElement(
     "link",
     {
@@ -6981,7 +7108,7 @@ function mergeRefs(...refs) {
 var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
 try {
   if (isBrowser) {
-    window.__reactRouterVersion = "7.1.5";
+    window.__reactRouterVersion = "7.2.0-pre.0";
   }
 } catch (e) {
 }
@@ -8093,6 +8220,7 @@ function ServerRouter({
         criticalCss,
         serverHandoffString,
         future: context.future,
+        ssr: context.ssr,
         isSpaMode: context.isSpaMode,
         serializeError: context.serializeError,
         renderMeta: context.renderMeta
@@ -8139,6 +8267,7 @@ function createRoutesStub(routes, context = {}) {
           version: ""
         },
         routeModules: {},
+        ssr: false,
         isSpaMode: false
       };
       let patched = processRoutes(
@@ -8190,8 +8319,11 @@ function processRoutes(routes, context, manifest, routeModules, parentId) {
       hasClientAction: false,
       hasClientLoader: false,
       hasErrorBoundary: route.ErrorBoundary != null,
-      module: "build/stub-path-to-module.js"
-      // any need for this?
+      // any need for these?
+      module: "build/stub-path-to-module.js",
+      clientActionModule: void 0,
+      clientLoaderModule: void 0,
+      hydrateFallbackModule: void 0
     };
     manifest.routes[newRoute.id] = entryRoute;
     routeModules[route.id] = {
@@ -8981,6 +9113,10 @@ var createRequestHandler = (build, mode) => {
       errorHandler = derived.errorHandler;
     }
     let url = new URL(request.url);
+    let normalizedPath = url.pathname.replace(/\.data$/, "").replace(/^\/_root$/, "/");
+    if (normalizedPath !== "/" && normalizedPath.endsWith("/")) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
     let params = {};
     let handleError = (error) => {
       if (mode === "development" /* Development */) {
@@ -8992,6 +9128,32 @@ var createRequestHandler = (build, mode) => {
         request
       });
     };
+    if (!_build.ssr) {
+      if (_build.prerender.length === 0) {
+        request.headers.set("X-React-Router-SPA-Mode", "yes");
+      } else if (!_build.prerender.includes(normalizedPath) && !_build.prerender.includes(normalizedPath + "/")) {
+        if (url.pathname.endsWith(".data")) {
+          errorHandler(
+            new ErrorResponseImpl(
+              404,
+              "Not Found",
+              `Refusing to SSR the path \`${normalizedPath}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`
+            ),
+            {
+              context: loadContext,
+              params,
+              request
+            }
+          );
+          return new Response("Not Found", {
+            status: 404,
+            statusText: "Not Found"
+          });
+        } else {
+          request.headers.set("X-React-Router-SPA-Mode", "yes");
+        }
+      }
+    }
     let manifestUrl = `${_build.basename ?? "/"}/__manifest`.replace(
       /\/+/g,
       "/"
@@ -9012,7 +9174,7 @@ var createRequestHandler = (build, mode) => {
     let response;
     if (url.pathname.endsWith(".data")) {
       let handlerUrl = new URL(request.url);
-      handlerUrl.pathname = handlerUrl.pathname.replace(/\.data$/, "").replace(/^\/_root$/, "/");
+      handlerUrl.pathname = normalizedPath;
       let singleFetchMatches = matchServerRoutes(
         routes,
         handlerUrl.pathname,
@@ -9152,6 +9314,7 @@ async function handleSingleFetchRequest(serverMode, build, staticHandler, reques
   );
 }
 async function handleDocumentRequest(serverMode, build, staticHandler, request, loadContext, handleError, criticalCss) {
+  let isSpaMode = request.headers.has("X-React-Router-SPA-Mode");
   let context;
   try {
     context = await staticHandler.query(request, {
@@ -9190,7 +9353,8 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
       basename: build.basename,
       criticalCss,
       future: build.future,
-      isSpaMode: build.isSpaMode
+      ssr: build.ssr,
+      isSpaMode
     }),
     serverHandoffStream: encodeViaTurboStream(
       state,
@@ -9200,7 +9364,8 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
     ),
     renderMeta: {},
     future: build.future,
-    isSpaMode: build.isSpaMode,
+    ssr: build.ssr,
+    isSpaMode,
     serializeError: (err) => serializeError(err, serverMode)
   };
   let handleDocumentRequestFunction = build.entry.module.default;
@@ -9245,7 +9410,8 @@ async function handleDocumentRequest(serverMode, build, staticHandler, request,
       serverHandoffString: createServerHandoffString({
         basename: build.basename,
         future: build.future,
-        isSpaMode: build.isSpaMode
+        ssr: build.ssr,
+        isSpaMode
       }),
       serverHandoffStream: encodeViaTurboStream(
         state2,