@react-router/dev 0.0.0-experimental-df0f1dfda → 0.0.0-experimental-fde52e515

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-df0f1dfda
+ * @react-router/dev v0.0.0-experimental-fde52e515
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -52,8 +52,10 @@ var fse = __toESM(require("fs-extra"));
 var babel = __toESM(require("@babel/core"));
 var import_react_router2 = require("react-router");
 var import_es_module_lexer = require("es-module-lexer");
+var import_pick3 = __toESM(require("lodash/pick"));
 var import_jsesc = __toESM(require("jsesc"));
 var import_picocolors3 = __toESM(require("picocolors"));
+var import_kebabCase = __toESM(require("lodash/kebabCase"));
 
 // typegen/index.ts
 var import_node_fs2 = __toESM(require("fs"));
@@ -270,6 +272,13 @@ var detectPackageManager = () => {
 
 // config/config.ts
 var excludedConfigPresetKeys = ["presets"];
+var branchRouteProperties = [
+  "id",
+  "path",
+  "file",
+  "index"
+];
+var configRouteToBranchRoute = (configRoute) => (0, import_pick2.default)(configRoute, branchRouteProperties);
 var mergeReactRouterConfig = (...configs) => {
   let reducer = (configA, configB) => {
     let mergeRequired = (key) => configA[key] !== void 0 && configB[key] !== void 0;
@@ -1797,6 +1806,8 @@ var plugin = {
         return function Wrapped() {
           const props = {
             params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
           };
           return h(HydrateFallback, props);
         };
@@ -2062,16 +2073,24 @@ var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteF
   );
   return getExportNames(code);
 };
-var getServerBundleBuildConfig = (viteUserConfig) => {
-  if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
+var resolveEnvironmentBuildContext = ({
+  viteCommand,
+  viteUserConfig
+}) => {
+  if (!("__reactRouterEnvironmentBuildContext" in viteUserConfig) || !viteUserConfig.__reactRouterEnvironmentBuildContext) {
     return null;
   }
-  return viteUserConfig.__reactRouterServerBundleBuildConfig;
+  let buildContext = viteUserConfig.__reactRouterEnvironmentBuildContext;
+  let resolvedBuildContext = {
+    name: buildContext.name,
+    options: buildContext.resolveOptions({ viteCommand, viteUserConfig })
+  };
+  return resolvedBuildContext;
 };
-var getServerBuildDirectory = (ctx) => path6.join(
+var getServerBuildDirectory = (ctx, { serverBundleId } = {}) => path6.join(
   ctx.reactRouterConfig.buildDirectory,
   "server",
-  ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
+  ...serverBundleId ? [serverBundleId] : []
 );
 var getClientBuildDirectory = (reactRouterConfig) => path6.join(reactRouterConfig.buildDirectory, "client");
 var defaultEntriesDir = path6.resolve(
@@ -2123,36 +2142,36 @@ var reactRouterVitePlugin = () => {
       process.exit(1);
     }
     let viteManifestEnabled = viteUserConfig.build?.manifest === true;
-    let ssrBuildCtx = viteConfigEnv.isSsrBuild && viteCommand === "build" ? {
-      isSsrBuild: true,
-      getReactRouterServerManifest: async () => (await generateReactRouterManifestsForBuild()).reactRouterServerManifest,
-      serverBundleBuildConfig: getServerBundleBuildConfig(viteUserConfig)
-    } : { isSsrBuild: false };
+    let environmentBuildContext = viteCommand === "build" ? resolveEnvironmentBuildContext({ viteCommand, viteUserConfig }) : null;
     firstLoad = false;
     ctx = {
+      environmentBuildContext,
       reactRouterConfig,
       rootDirectory,
       entryClientFilePath,
       entryServerFilePath,
       publicPath,
-      viteManifestEnabled,
-      ...ssrBuildCtx
+      viteManifestEnabled
     };
   };
   let pluginIndex = (pluginName) => {
     invariant(viteConfig);
     return viteConfig.plugins.findIndex((plugin2) => plugin2.name === pluginName);
   };
-  let getServerEntry = async () => {
+  let getServerEntry = async ({ routeIds }) => {
     invariant(viteConfig, "viteconfig required to generate the server entry");
-    let routes = ctx.serverBundleBuildConfig ? (
+    let routes = routeIds ? (
       // For server bundle builds, the server build should only import the
       // routes for this bundle rather than importing all routes
-      ctx.serverBundleBuildConfig.routes
+      (0, import_pick3.default)(ctx.reactRouterConfig.routes, routeIds)
     ) : (
       // Otherwise, all routes are imported as usual
       ctx.reactRouterConfig.routes
     );
+    let prerenderPaths = await getPrerenderPaths(
+      ctx.reactRouterConfig.prerender,
+      routes
+    );
     return `
     import * as entryServer from ${JSON.stringify(
       resolveFileUrl(ctx, ctx.entryServerFilePath)
@@ -2167,7 +2186,7 @@ var reactRouterVitePlugin = () => {
       )};`;
     }).join("\n")}
       export { default as assets } from ${JSON.stringify(
-      virtual.serverManifest.id
+      `${virtual.serverManifest.id}${routeIds ? `?route-ids=${routeIds.join(",")}` : ""}`
     )};
       export const assetsBuildDirectory = ${JSON.stringify(
       path6.relative(
@@ -2177,7 +2196,9 @@ var reactRouterVitePlugin = () => {
     )};
       export const basename = ${JSON.stringify(ctx.reactRouterConfig.basename)};
       export const future = ${JSON.stringify(ctx.reactRouterConfig.future)};
-      export const isSpaMode = ${!ctx.reactRouterConfig.ssr && ctx.reactRouterConfig.prerender == null};
+      export const ssr = ${ctx.reactRouterConfig.ssr};
+      export const isSpaMode = ${isSpaModeEnabled(ctx.reactRouterConfig)};
+      export const prerender = ${JSON.stringify(prerenderPaths)};
       export const publicPath = ${JSON.stringify(ctx.publicPath)};
       export const entry = { module: entryServer };
       export const routes = {
@@ -2215,7 +2236,9 @@ var reactRouterVitePlugin = () => {
     );
     return /* @__PURE__ */ new Set([...cssUrlPaths, ...chunkAssetPaths]);
   };
-  let generateReactRouterManifestsForBuild = async () => {
+  let generateReactRouterManifestsForBuild = async ({
+    routeIds
+  }) => {
     invariant(viteConfig);
     let viteManifest = await loadViteManifest(
       getClientBuildDirectory(ctx.reactRouterConfig)
@@ -2232,9 +2255,9 @@ var reactRouterVitePlugin = () => {
       ctx
     );
     let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
-    for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
+    for (let route of Object.values(ctx.reactRouterConfig.routes)) {
       let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
-      let sourceExports = routeManifestExports[key];
+      let sourceExports = routeManifestExports[route.id];
       let isRootRoute = route.parentId === void 0;
       let hasClientAction = sourceExports.includes("clientAction");
       let hasClientLoader = sourceExports.includes("clientLoader");
@@ -2292,10 +2315,9 @@ var reactRouterVitePlugin = () => {
           getRouteChunkModuleId(routeFile, "HydrateFallback")
         ) : void 0
       };
-      browserRoutes[key] = routeManifestEntry;
-      let serverBundleRoutes = ctx.serverBundleBuildConfig?.routes;
-      if (!serverBundleRoutes || serverBundleRoutes[key]) {
-        serverRoutes[key] = routeManifestEntry;
+      browserRoutes[route.id] = routeManifestEntry;
+      if (!routeIds || routeIds.includes(route.id)) {
+        serverRoutes[route.id] = routeManifestEntry;
       }
     }
     let fingerprintedValues = { entry, routes: browserRoutes };
@@ -2443,23 +2465,6 @@ var reactRouterVitePlugin = () => {
             ""
           )
         );
-        let baseRollupOptions = {
-          // Silence Rollup "use client" warnings
-          // Adapted from https://github.com/vitejs/vite-plugin-react/pull/144
-          onwarn(warning, defaultHandler) {
-            if (warning.code === "MODULE_LEVEL_DIRECTIVE" && warning.message.includes("use client")) {
-              return;
-            }
-            if (viteUserConfig.build?.rollupOptions?.onwarn) {
-              viteUserConfig.build.rollupOptions.onwarn(
-                warning,
-                defaultHandler
-              );
-            } else {
-              defaultHandler(warning);
-            }
-          }
-        };
         return {
           __reactRouterPluginContext: ctx,
           appType: viteCommand === "serve" && viteConfigEnv.mode === "production" && ctx.reactRouterConfig.ssr === false ? "spa" : "custom",
@@ -2517,73 +2522,11 @@ var reactRouterVitePlugin = () => {
           // will throw an error that the file is not allowed to be read.
           // https://vitejs.dev/config/server-options#server-fs-allow
           server: viteUserConfig.server?.fs?.allow ? { fs: { allow: defaultEntries } } : void 0,
-          // Vite config options for building
-          ...viteCommand === "build" ? {
-            build: {
-              cssMinify: viteUserConfig.build?.cssMinify ?? true,
-              ...!viteConfigEnv.isSsrBuild ? {
-                manifest: true,
-                outDir: getClientBuildDirectory(ctx.reactRouterConfig),
-                rollupOptions: {
-                  ...baseRollupOptions,
-                  preserveEntrySignatures: "exports-only",
-                  input: [
-                    ctx.entryClientFilePath,
-                    ...Object.values(
-                      ctx.reactRouterConfig.routes
-                    ).flatMap((route) => {
-                      let routeFilePath = path6.resolve(
-                        ctx.reactRouterConfig.appDirectory,
-                        route.file
-                      );
-                      let isRootRoute = route.file === ctx.reactRouterConfig.routes.root.file;
-                      let code = fse.readFileSync(
-                        routeFilePath,
-                        "utf-8"
-                      );
-                      return [
-                        `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
-                        ...ctx.reactRouterConfig.future.unstable_splitRouteModules && !isRootRoute ? routeChunkExportNames.map(
-                          (exportName) => code.includes(exportName) ? getRouteChunkModuleId(
-                            routeFilePath,
-                            exportName
-                          ) : null
-                        ) : []
-                      ].filter(isNonNullable);
-                    })
-                  ]
-                }
-              } : {
-                // We move SSR-only assets to client assets. Note that the
-                // SSR build can also emit code-split JS files (e.g. by
-                // dynamic import) under the same assets directory
-                // regardless of "ssrEmitAssets" option, so we also need to
-                // keep these JS files have to be kept as-is.
-                ssrEmitAssets: true,
-                copyPublicDir: false,
-                // Assets in the public directory are only used by the client
-                manifest: true,
-                // We need the manifest to detect SSR-only assets
-                outDir: getServerBuildDirectory(ctx),
-                rollupOptions: {
-                  ...baseRollupOptions,
-                  preserveEntrySignatures: "exports-only",
-                  input: viteUserConfig.build?.rollupOptions?.input ?? virtual.serverBuild.id,
-                  output: {
-                    entryFileNames: ctx.reactRouterConfig.serverBuildFile,
-                    format: ctx.reactRouterConfig.serverModuleFormat
-                  }
-                }
-              }
-            }
-          } : void 0,
-          // Vite config options for SPA preview mode
-          ...viteCommand === "serve" && ctx.reactRouterConfig.ssr === false ? {
-            build: {
-              manifest: true,
-              outDir: getClientBuildDirectory(ctx.reactRouterConfig)
-            }
-          } : void 0
+          build: ctx.environmentBuildContext?.options.build ?? (await getEnvironmentOptions(
+            ctx,
+            viteConfigEnv.isSsrBuild ? "ssr" : "client",
+            { viteCommand, viteUserConfig }
+          )).build
         };
       },
       async configResolved(resolvedViteConfig) {
@@ -2599,8 +2542,7 @@ var reactRouterVitePlugin = () => {
         let childCompilerConfigFile = await vite2.loadConfigFromFile(
           {
             command: viteConfig.command,
-            mode: viteConfig.mode,
-            isSsrBuild: ctx.isSsrBuild
+            mode: viteConfig.mode
           },
           viteConfig.configFile
         );
@@ -2742,14 +2684,14 @@ var reactRouterVitePlugin = () => {
         // After the SSR build is finished, we inspect the Vite manifest for
         // the SSR build and move server-only assets to client assets directory
         async handler() {
-          if (!ctx.isSsrBuild) {
+          if (!viteConfigEnv.isSsrBuild) {
             return;
           }
           invariant(viteConfig);
           let clientBuildDirectory = getClientBuildDirectory(
             ctx.reactRouterConfig
           );
-          let serverBuildDirectory = getServerBuildDirectory(ctx);
+          let serverBuildDirectory = ctx.environmentBuildContext?.options.build.outDir ?? getServerBuildDirectory(ctx);
           let ssrViteManifest = await loadViteManifest(serverBuildDirectory);
           let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
           let movedAssetPaths = [];
@@ -2783,7 +2725,7 @@ var reactRouterVitePlugin = () => {
               ].join("\n")
             );
           }
-          if (ctx.reactRouterConfig.prerender != null && ctx.reactRouterConfig.prerender !== false) {
+          if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
             await handlePrerender(
               viteConfig,
               ctx.reactRouterConfig,
@@ -2938,16 +2880,25 @@ var reactRouterVitePlugin = () => {
       name: "react-router:virtual-modules",
       enforce: "pre",
       resolveId(id) {
-        const vmod2 = Object.values(virtual).find((vmod3) => vmod3.id === id);
-        if (vmod2) return vmod2.resolvedId;
+        let [baseId, queryString] = id.split("?");
+        const vmod2 = Object.values(virtual).find((vmod3) => vmod3.id === baseId);
+        if (vmod2)
+          return vmod2.resolvedId + (queryString ? `?${queryString}` : "");
       },
       async load(id) {
-        switch (id) {
+        let [baseId, queryString] = id.split("?");
+        switch (baseId) {
           case virtual.serverBuild.resolvedId: {
-            return await getServerEntry();
+            let searchParams = new URLSearchParams(queryString);
+            let routeIds = searchParams.get("route-ids")?.split(",") || void 0;
+            return await getServerEntry({ routeIds });
           }
           case virtual.serverManifest.resolvedId: {
-            let reactRouterManifest = ctx.isSsrBuild ? await ctx.getReactRouterServerManifest() : await getReactRouterManifestForDev();
+            let searchParams = new URLSearchParams(queryString);
+            let routeIds = searchParams.get("route-ids")?.split(",") || void 0;
+            let reactRouterManifest = viteCommand === "build" ? (await generateReactRouterManifestsForBuild({
+              routeIds
+            })).reactRouterServerManifest : await getReactRouterManifestForDev();
             return `export default ${(0, import_jsesc.default)(reactRouterManifest, {
               es6: true
             })};`;
@@ -3046,14 +2997,17 @@ var reactRouterVitePlugin = () => {
         }
         let route = getRoute(ctx.reactRouterConfig, id);
         if (!route) return;
-        if (!options?.ssr && !ctx.reactRouterConfig.ssr) {
+        if (!options?.ssr && isSpaModeEnabled(ctx.reactRouterConfig)) {
           let exportNames = getExportNames(code);
-          let serverOnlyExports = exportNames.filter(
-            (exp) => SERVER_ONLY_ROUTE_EXPORTS.includes(exp)
-          );
+          let serverOnlyExports = exportNames.filter((exp) => {
+            if (route.id === "root" && exp === "loader") {
+              return false;
+            }
+            return SERVER_ONLY_ROUTE_EXPORTS.includes(exp);
+          });
           if (serverOnlyExports.length > 0) {
             let str = serverOnlyExports.map((e) => `\`${e}\``).join(", ");
-            let message = `SPA Mode: ${serverOnlyExports.length} invalid route export(s) in \`${route.file}\`: ${str}. See https://remix.run/guides/spa-mode for more information.`;
+            let message = `SPA Mode: ${serverOnlyExports.length} invalid route export(s) in \`${route.file}\`: ${str}. See https://reactrouter.com/how-to/spa for more information.`;
             throw Error(message);
           }
           if (route.id !== "root") {
@@ -3061,7 +3015,7 @@ var reactRouterVitePlugin = () => {
               (exp) => exp === "HydrateFallback"
             );
             if (hasHydrateFallback) {
-              let message = `SPA Mode: Invalid \`HydrateFallback\` export found in \`${route.file}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://remix.run/guides/spa-mode for more information.`;
+              let message = `SPA Mode: Invalid \`HydrateFallback\` export found in \`${route.file}\`. \`HydrateFallback\` is only permitted on the root route in SPA Mode. See https://reactrouter.com/how-to/spa for more information.`;
               throw Error(message);
             }
           }
@@ -3354,6 +3308,12 @@ async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteF
   };
   return info;
 }
+function isPrerenderingEnabled(reactRouterConfig) {
+  return reactRouterConfig.prerender != null && reactRouterConfig.prerender !== false;
+}
+function isSpaModeEnabled(reactRouterConfig) {
+  return reactRouterConfig.ssr === false && !isPrerenderingEnabled(reactRouterConfig);
+}
 async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, serverBuildFile) {
   let serverBuildPath = path6.join(serverBuildDirectory, serverBuildFile);
   let build = await import(url.pathToFileURL(serverBuildPath).toString());
@@ -3364,20 +3324,44 @@ async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, ser
   };
 }
 async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory, serverBuildFile, clientBuildDirectory) {
-  let { handler } = await getPrerenderBuildAndHandler(
+  let { build, handler } = await getPrerenderBuildAndHandler(
     viteConfig,
     serverBuildDirectory,
     serverBuildFile
   );
-  let request = new Request(`http://localhost${reactRouterConfig.basename}`);
+  let request = new Request(`http://localhost${reactRouterConfig.basename}`, {
+    headers: {
+      // Enable SPA mode in the server runtime and only render down to the root
+      "X-React-Router-SPA-Mode": "yes"
+    }
+  });
   let response = await handler(request);
   let html = await response.text();
-  validatePrerenderedResponse(response, html, "SPA Mode", "/");
-  validatePrerenderedHtml(html, "SPA Mode");
-  await fse.writeFile(path6.join(clientBuildDirectory, "index.html"), html);
-  viteConfig.logger.info(
-    "SPA Mode: index.html has been written to your " + import_picocolors3.default.bold(path6.relative(process.cwd(), clientBuildDirectory)) + " directory"
-  );
+  let isPrerenderSpaFallback = build.prerender.includes("/");
+  let filename3 = isPrerenderSpaFallback ? "__spa-fallback__.html" : "index.html";
+  if (response.status !== 200) {
+    if (isPrerenderSpaFallback) {
+      throw new Error(
+        `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
+` + html
+      );
+    } else {
+      throw new Error(
+        `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
+` + html
+      );
+    }
+  }
+  if (!html.includes("window.__reactRouterContext =") || !html.includes("window.__reactRouterRouteModules =")) {
+    throw new Error(
+      "SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`."
+    );
+  }
+  await fse.writeFile(path6.join(clientBuildDirectory, filename3), html);
+  let prettyDir = path6.relative(process.cwd(), clientBuildDirectory);
+  let prettyPath = path6.join(prettyDir, filename3);
+  let prefix = isPrerenderSpaFallback ? "Prerender" : "SPA Mode";
+  viteConfig.logger.info(`${prefix}: Generated \`${prettyPath}\``);
 }
 async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, serverBuildPath, clientBuildDirectory) {
   let { build, handler } = await getPrerenderBuildAndHandler(
@@ -3386,29 +3370,22 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     serverBuildPath
   );
   let routes = createPrerenderRoutes(build.routes);
-  let routesToPrerender;
-  if (typeof reactRouterConfig.prerender === "boolean") {
-    invariant(reactRouterConfig.prerender, "Expected prerender:true");
-    routesToPrerender = determineStaticPrerenderRoutes(
-      routes,
-      viteConfig,
-      true
-    );
-  } else if (typeof reactRouterConfig.prerender === "function") {
-    routesToPrerender = await reactRouterConfig.prerender({
-      getStaticPaths: () => determineStaticPrerenderRoutes(routes, viteConfig, false)
-    });
-  } else {
-    routesToPrerender = reactRouterConfig.prerender || ["/"];
-  }
+  let prerenderedRoutes = /* @__PURE__ */ new Set();
   let headers = {
     // Header that can be used in the loader to know if you're running at
     // build time or runtime
     "X-React-Router-Prerender": "yes"
   };
-  for (let path7 of routesToPrerender) {
+  for (let path7 of build.prerender) {
     let matches = (0, import_react_router2.matchRoutes)(routes, `/${path7}/`.replace(/^\/\/+/, "/"));
-    let hasLoaders = matches?.some((m) => m.route.loader);
+    invariant(
+      matches,
+      `Unable to prerender path because it does not match any routes: ${path7}`
+    );
+    matches.forEach((m) => prerenderedRoutes.add(m.route.id));
+    let hasLoaders = matches.some(
+      (m) => build.assets.routes[m.route.id]?.hasLoader
+    );
     let data;
     if (hasLoaders) {
       data = await prerenderData(
@@ -3448,14 +3425,34 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       );
     }
   }
-  await prerenderManifest(
-    build,
-    clientBuildDirectory,
-    reactRouterConfig,
-    viteConfig
-  );
+  if (reactRouterConfig.ssr === false) {
+    let errors = [];
+    for (let [routeId, route] of Object.entries(build.routes)) {
+      let invalidApis = [];
+      if (route) {
+        if (route.module.headers) invalidApis.push("headers");
+        if (route.module.action) invalidApis.push("action");
+        if (invalidApis.length > 0) {
+          errors.push(
+            `Prerender: ${invalidApis.length} invalid route export(s) in \`${route.id}\` when prerendering with \`ssr:false\`: ${invalidApis.join(", ")}.  See https://reactrouter.com/how-to/spa for more information.`
+          );
+        }
+        if (route.module.loader && !prerenderedRoutes.has(routeId)) {
+          errors.push(
+            `Prerender: 1 invalid route export in \`${route.id}\` when using \`ssr:false\` with \`prerender\` because the route is never prerendered so the loader will never be called.  See https://reactrouter.com/how-to/spa for more information.`
+          );
+        }
+      }
+    }
+    if (errors.length > 0) {
+      viteConfig.logger.error(errors.join("\n"));
+      throw new Error(
+        "Invalid route exports found when prerendering with `ssr:false`"
+      );
+    }
+  }
 }
-function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = false) {
+function getStaticPrerenderPaths(routes) {
   let paths = ["/"];
   let paramRoutes = [];
   function recurse(subtree, prefix = "") {
@@ -3475,28 +3472,29 @@ function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = fal
     }
   }
   recurse(routes);
-  if (isBooleanUsage && paramRoutes.length > 0) {
-    viteConfig.logger.warn(
-      [
-        "\u26A0\uFE0F Paths with dynamic/splat params cannot be prerendered when using `prerender: true`.",
-        "You may want to use the `prerender()` API to prerender the following paths:",
-        ...paramRoutes.map((p) => "  - " + p)
-      ].join("\n")
-    );
-  }
-  return paths.map((p) => p.replace(/\/\/+/g, "/").replace(/(.+)\/$/, "$1"));
+  return {
+    paths: paths.map((p) => p.replace(/\/\/+/g, "/").replace(/(.+)\/$/, "$1")),
+    paramRoutes
+  };
 }
 async function prerenderData(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
   let normalizedPath = `${reactRouterConfig.basename}${prerenderPath === "/" ? "/_root.data" : `${prerenderPath.replace(/\/$/, "")}.data`}`.replace(/\/\/+/g, "/");
   let request = new Request(`http://localhost${normalizedPath}`, requestInit);
   let response = await handler(request);
   let data = await response.text();
-  validatePrerenderedResponse(response, data, "Prerender", normalizedPath);
+  if (response.status !== 200) {
+    throw new Error(
+      `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path6}\` path.
+${normalizedPath}`
+    );
+  }
   let outdir = path6.relative(process.cwd(), clientBuildDirectory);
   let outfile = path6.join(outdir, ...normalizedPath.split("/"));
   await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, data);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
+  viteConfig.logger.info(
+    `Prerender Data: ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
+  );
   return data;
 }
 async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
@@ -3507,54 +3505,83 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
   let request = new Request(`http://localhost${normalizedPath}`, requestInit);
   let response = await handler(request);
   let html = await response.text();
-  validatePrerenderedResponse(response, html, "Prerender", normalizedPath);
-  if (!reactRouterConfig.ssr) {
-    validatePrerenderedHtml(html, "Prerender");
+  if (response.status !== 200) {
+    throw new Error(
+      `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.
+${html}`
+    );
   }
   let outdir = path6.relative(process.cwd(), clientBuildDirectory);
   let outfile = path6.join(outdir, ...normalizedPath.split("/"), "index.html");
   await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, html);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
+  viteConfig.logger.info(
+    `Prerender: ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
+  );
 }
 async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
   let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(/\/\/+/g, "/").replace(/\/$/g, "");
   let request = new Request(`http://localhost${normalizedPath}`, requestInit);
   let response = await handler(request);
   let text = await response.text();
-  validatePrerenderedResponse(response, text, "Prerender", normalizedPath);
+  if (response.status !== 200) {
+    throw new Error(
+      `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.
+${text}`
+    );
+  }
   let outdir = path6.relative(process.cwd(), clientBuildDirectory);
   let outfile = path6.join(outdir, ...normalizedPath.split("/"));
   await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, text);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
-}
-async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig, viteConfig) {
-  let normalizedPath = `${reactRouterConfig.basename}/__manifest`.replace(
-    /\/\/+/g,
-    "/"
+  viteConfig.logger.info(
+    `Prerender: ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
   );
-  let outdir = path6.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path6.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path6.dirname(outfile));
-  let manifestData = JSON.stringify(build.assets.routes);
-  await fse.outputFile(outfile, manifestData);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
-function validatePrerenderedResponse(response, html, prefix, path7) {
-  if (response.status !== 200) {
-    throw new Error(
-      `${prefix}: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path7}\` path.
-${html}`
-    );
+async function getPrerenderPaths(prerender, routes) {
+  let prerenderPaths = [];
+  if (prerender != null && prerender !== false) {
+    let prerenderRoutes = createPrerenderRoutes(routes);
+    if (prerender === true) {
+      let { paths, paramRoutes } = getStaticPrerenderPaths(prerenderRoutes);
+      if (paramRoutes.length > 0) {
+        console.warn(
+          import_picocolors3.default.yellow(
+            [
+              "\u26A0\uFE0F Paths with dynamic/splat params cannot be prerendered when using `prerender: true`. You may want to use the `prerender()` API to prerender the following paths:",
+              ...paramRoutes.map((p) => "  - " + p)
+            ].join("\n")
+          )
+        );
+      }
+      prerenderPaths = paths;
+    } else if (typeof prerender === "function") {
+      prerenderPaths = await prerender({
+        getStaticPaths: () => getStaticPrerenderPaths(prerenderRoutes).paths
+      });
+    } else {
+      prerenderPaths = prerender || ["/"];
+    }
   }
+  return prerenderPaths;
 }
-function validatePrerenderedHtml(html, prefix) {
-  if (!html.includes("window.__reactRouterContext =") || !html.includes("window.__reactRouterRouteModules =")) {
-    throw new Error(
-      `${prefix}: Did you forget to include <Scripts/> in your root route? Your pre-rendered HTML files cannot hydrate without \`<Scripts />\`.`
-    );
-  }
+function createPrerenderRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId2(manifest)) {
+  return (routesByParentId[parentId] || []).map((route) => {
+    let commonRoute = {
+      id: route.id,
+      path: route.path
+    };
+    if (route.index) {
+      return {
+        index: true,
+        ...commonRoute
+      };
+    }
+    return {
+      children: createPrerenderRoutes(manifest, route.id, routesByParentId),
+      ...commonRoute
+    };
+  });
 }
 function groupRoutesByParentId2(manifest) {
   let routes = {};
@@ -3569,26 +3596,54 @@ function groupRoutesByParentId2(manifest) {
   });
   return routes;
 }
-function createPrerenderRoutes(manifest, parentId = "", routesByParentId = groupRoutesByParentId2(manifest)) {
-  return (routesByParentId[parentId] || []).map((route) => {
-    let commonRoute = {
-      // Always include root due to default boundaries
-      hasErrorBoundary: route.id === "root" || route.module.ErrorBoundary != null,
-      id: route.id,
-      path: route.path,
-      loader: route.module.loader ? () => null : void 0,
-      action: void 0,
-      handle: route.module.handle
-    };
-    return route.index ? {
-      index: true,
-      ...commonRoute
-    } : {
-      caseSensitive: route.caseSensitive,
-      children: createPrerenderRoutes(manifest, route.id, routesByParentId),
-      ...commonRoute
-    };
-  });
+function getAddressableRoutes(routes) {
+  let nonAddressableIds = /* @__PURE__ */ new Set();
+  for (let id in routes) {
+    let route = routes[id];
+    if (route.index) {
+      invariant(
+        route.parentId,
+        `Expected index route "${route.id}" to have "parentId" set`
+      );
+      nonAddressableIds.add(route.parentId);
+    }
+    if (typeof route.path !== "string" && !route.index) {
+      nonAddressableIds.add(id);
+    }
+  }
+  return Object.values(routes).filter(
+    (route) => !nonAddressableIds.has(route.id)
+  );
+}
+function getRouteBranch(routes, routeId) {
+  let branch = [];
+  let currentRouteId = routeId;
+  while (currentRouteId) {
+    let route = routes[currentRouteId];
+    invariant(route, `Missing route for ${currentRouteId}`);
+    branch.push(route);
+    currentRouteId = route.parentId;
+  }
+  return branch.reverse();
+}
+function hasServerBundles(buildManifest) {
+  return Object.keys(buildManifest.serverBundles ?? {}).length > 0;
+}
+function getRoutesByServerBundleId(buildManifest) {
+  if (!buildManifest.routeIdToServerBundleId) {
+    return {};
+  }
+  let routesByServerBundleId = {};
+  for (let [routeId, serverBundleId] of Object.entries(
+    buildManifest.routeIdToServerBundleId
+  )) {
+    routesByServerBundleId[serverBundleId] ??= {};
+    let branch = getRouteBranch(buildManifest.routes, routeId);
+    for (let route of branch) {
+      routesByServerBundleId[serverBundleId][route.id] = route;
+    }
+  }
+  return routesByServerBundleId;
 }
 var resolveRouteFileCode = async (ctx, input) => {
   if (typeof input === "string") return input;
@@ -3654,6 +3709,192 @@ function validateRouteChunks({
     ].join("\n\n")
   );
 }
+async function getBuildManifest(ctx) {
+  let { routes, serverBundles, appDirectory } = ctx.reactRouterConfig;
+  if (!serverBundles) {
+    return { routes };
+  }
+  let { normalizePath } = await import("vite");
+  let serverBuildDirectory = getServerBuildDirectory(ctx);
+  let resolvedAppDirectory = path6.resolve(ctx.rootDirectory, appDirectory);
+  let rootRelativeRoutes = Object.fromEntries(
+    Object.entries(routes).map(([id, route]) => {
+      let filePath = path6.join(resolvedAppDirectory, route.file);
+      let rootRelativeFilePath = normalizePath(
+        path6.relative(ctx.rootDirectory, filePath)
+      );
+      return [id, { ...route, file: rootRelativeFilePath }];
+    })
+  );
+  let buildManifest = {
+    serverBundles: {},
+    routeIdToServerBundleId: {},
+    routes: rootRelativeRoutes
+  };
+  await Promise.all(
+    getAddressableRoutes(routes).map(async (route) => {
+      let branch = getRouteBranch(routes, route.id);
+      let serverBundleId = await serverBundles({
+        branch: branch.map(
+          (route2) => configRouteToBranchRoute({
+            ...route2,
+            // Ensure absolute paths are passed to the serverBundles function
+            file: path6.join(resolvedAppDirectory, route2.file)
+          })
+        )
+      });
+      if (typeof serverBundleId !== "string") {
+        throw new Error(`The "serverBundles" function must return a string`);
+      }
+      if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) {
+        throw new Error(
+          `The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.`
+        );
+      }
+      buildManifest.routeIdToServerBundleId[route.id] = serverBundleId;
+      buildManifest.serverBundles[serverBundleId] ??= {
+        id: serverBundleId,
+        file: normalizePath(
+          path6.join(
+            path6.relative(
+              ctx.rootDirectory,
+              path6.join(serverBuildDirectory, serverBundleId)
+            ),
+            ctx.reactRouterConfig.serverBuildFile
+          )
+        )
+      };
+    })
+  );
+  return buildManifest;
+}
+function mergeBuildOptions(base, overrides) {
+  let vite2 = getVite();
+  return vite2.mergeConfig({ build: base }, { build: overrides }).build;
+}
+async function getEnvironmentOptionsResolvers(ctx, buildManifest) {
+  let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
+  function getBaseBuildOptions({
+    viteUserConfig
+  }) {
+    return {
+      cssMinify: viteUserConfig.build?.cssMinify ?? true,
+      manifest: true,
+      // The manifest is enabled for all builds to detect SSR-only assets
+      rollupOptions: {
+        preserveEntrySignatures: "exports-only",
+        // Silence Rollup "use client" warnings
+        // Adapted from https://github.com/vitejs/vite-plugin-react/pull/144
+        onwarn(warning, defaultHandler) {
+          if (warning.code === "MODULE_LEVEL_DIRECTIVE" && warning.message.includes("use client")) {
+            return;
+          }
+          let userHandler = viteUserConfig.build?.rollupOptions?.onwarn;
+          if (userHandler) {
+            userHandler(warning, defaultHandler);
+          } else {
+            defaultHandler(warning);
+          }
+        }
+      }
+    };
+  }
+  function getBaseServerBuildOptions({
+    viteUserConfig
+  }) {
+    return mergeBuildOptions(getBaseBuildOptions({ viteUserConfig }), {
+      // We move SSR-only assets to client assets. Note that the
+      // SSR build can also emit code-split JS files (e.g. by
+      // dynamic import) under the same assets directory
+      // regardless of "ssrEmitAssets" option, so we also need to
+      // keep these JS files have to be kept as-is.
+      ssrEmitAssets: true,
+      copyPublicDir: false,
+      // Assets in the public directory are only used by the client
+      rollupOptions: {
+        output: {
+          entryFileNames: serverBuildFile,
+          format: serverModuleFormat
+        }
+      }
+    });
+  }
+  let environmentOptionsResolvers = {
+    client: ({ viteUserConfig }) => ({
+      build: mergeBuildOptions(getBaseBuildOptions({ viteUserConfig }), {
+        rollupOptions: {
+          input: [
+            ctx.entryClientFilePath,
+            ...Object.values(ctx.reactRouterConfig.routes).flatMap((route) => {
+              let routeFilePath = path6.resolve(
+                ctx.reactRouterConfig.appDirectory,
+                route.file
+              );
+              let isRootRoute = route.file === ctx.reactRouterConfig.routes.root.file;
+              let code = fse.readFileSync(routeFilePath, "utf-8");
+              return [
+                `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
+                ...ctx.reactRouterConfig.future.unstable_splitRouteModules && !isRootRoute ? routeChunkExportNames.map(
+                  (exportName) => code.includes(exportName) ? getRouteChunkModuleId(routeFilePath, exportName) : null
+                ) : []
+              ].filter(isNonNullable);
+            })
+          ],
+          output: {
+            entryFileNames({ moduleIds }) {
+              let routeChunkModuleId = moduleIds.find(isRouteChunkModuleId);
+              let routeChunkName = routeChunkModuleId ? getRouteChunkNameFromModuleId(routeChunkModuleId) : null;
+              let routeChunkSuffix = routeChunkName ? `-${(0, import_kebabCase.default)(routeChunkName)}` : "";
+              return `assets/[name]${routeChunkSuffix}-[hash].js`;
+            }
+          }
+        },
+        outDir: getClientBuildDirectory(ctx.reactRouterConfig)
+      })
+    })
+  };
+  if (hasServerBundles(buildManifest)) {
+    for (let [serverBundleId, routes] of Object.entries(
+      getRoutesByServerBundleId(buildManifest)
+    )) {
+      environmentOptionsResolvers[`ssr-bundle-${serverBundleId}`] = ({
+        viteUserConfig
+      }) => ({
+        build: mergeBuildOptions(
+          getBaseServerBuildOptions({ viteUserConfig }),
+          {
+            outDir: getServerBuildDirectory(ctx, { serverBundleId }),
+            rollupOptions: {
+              input: `${virtual.serverBuild.id}?route-ids=${Object.keys(
+                routes
+              ).join(",")}`
+            }
+          }
+        )
+      });
+    }
+  } else {
+    environmentOptionsResolvers.ssr = ({ viteUserConfig }) => ({
+      build: mergeBuildOptions(getBaseServerBuildOptions({ viteUserConfig }), {
+        outDir: getServerBuildDirectory(ctx),
+        rollupOptions: {
+          input: viteUserConfig.build?.rollupOptions?.input ?? virtual.serverBuild.id
+        }
+      })
+    });
+  }
+  return environmentOptionsResolvers;
+}
+async function getEnvironmentOptions(ctx, environmentName, resolverOptions) {
+  let buildManifest = await getBuildManifest(ctx);
+  let environmentResolvers = await getEnvironmentOptionsResolvers(
+    ctx,
+    buildManifest
+  );
+  let resolver = environmentResolvers[environmentName];
+  invariant(resolver, `Missing environment resolver for ${environmentName}`);
+  return resolver(resolverOptions);
+}
 function isNonNullable(x) {
   return x != null;
 }