@react-router/dev 0.0.0-experimental-902325fda → 0.0.0-experimental-004e483a8

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-902325fda
+ * @react-router/dev v0.0.0-experimental-004e483a8
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -59,6 +59,7 @@ var import_kebabCase = __toESM(require("lodash/kebabCase"));
 
 // typegen/index.ts
 var import_node_fs2 = __toESM(require("fs"));
+var import_dedent2 = __toESM(require("dedent"));
 var Path4 = __toESM(require("pathe"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
@@ -453,7 +454,8 @@ async function resolveConfig({
   }
   let future = {
     unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false,
-    unstable_splitRouteModules: reactRouterUserConfig.future?.unstable_splitRouteModules ?? false
+    unstable_splitRouteModules: reactRouterUserConfig.future?.unstable_splitRouteModules ?? false,
+    unstable_viteEnvironmentApi: reactRouterUserConfig.future?.unstable_viteEnvironmentApi ?? false
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
@@ -632,6 +634,19 @@ function findEntry(dir, basename2, options) {
   return void 0;
 }
 
+// vite/babel.ts
+var babel_exports = {};
+__export(babel_exports, {
+  generate: () => generate,
+  parse: () => import_parser.parse,
+  t: () => t,
+  traverse: () => traverse
+});
+var import_parser = require("@babel/parser");
+var t = __toESM(require("@babel/types"));
+var traverse = require("@babel/traverse").default;
+var generate = require("@babel/generator").default;
+
 // typegen/generate.ts
 var import_dedent = __toESM(require("dedent"));
 var Path3 = __toESM(require("pathe"));
@@ -653,7 +668,7 @@ function getTypesPath(ctx, route) {
 }
 
 // typegen/generate.ts
-function generate(ctx, route) {
+function generate2(ctx, route) {
   const lineage = getRouteLineage(ctx.config.routes, route);
   const urlpath = lineage.map((route2) => route2.path).join("/");
   const typesPath = getTypesPath(ctx, route);
@@ -799,17 +814,77 @@ async function writeAll(ctx) {
   import_node_fs2.default.rmSync(typegenDir, { recursive: true, force: true });
   Object.values(ctx.config.routes).forEach((route) => {
     const typesPath = getTypesPath(ctx, route);
-    const content = generate(ctx, route);
+    const content = generate2(ctx, route);
     import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
     import_node_fs2.default.writeFileSync(typesPath, content);
   });
+  const registerPath = Path4.join(typegenDir, "+register.ts");
+  import_node_fs2.default.writeFileSync(registerPath, register(ctx));
 }
+function register(ctx) {
+  const register2 = import_dedent2.default`
+    import "react-router";
 
-// vite/babel.ts
-var import_parser = require("@babel/parser");
-var t = __toESM(require("@babel/types"));
-var traverse = require("@babel/traverse").default;
-var generate2 = require("@babel/generator").default;
+    declare module "react-router" {
+      interface Register {
+        params: Params;
+      }
+    }
+  `;
+  const { t: t2 } = babel_exports;
+  const typeParams = t2.tsTypeAliasDeclaration(
+    t2.identifier("Params"),
+    null,
+    t2.tsTypeLiteral(
+      Object.values(ctx.config.routes).map((route) => {
+        const lineage = getRouteLineage2(ctx.config.routes, route);
+        const fullpath = lineage.map((route2) => route2.path).join("/");
+        const params = parseParams2(fullpath);
+        return t2.tsPropertySignature(
+          t2.stringLiteral(fullpath),
+          t2.tsTypeAnnotation(
+            t2.tsTypeLiteral(
+              Object.entries(params).map(([param, isRequired]) => {
+                const property = t2.tsPropertySignature(
+                  t2.stringLiteral(param),
+                  t2.tsTypeAnnotation(t2.tsStringKeyword())
+                );
+                property.optional = !isRequired;
+                return property;
+              })
+            )
+          )
+        );
+      })
+    )
+  );
+  return [register2, generate(typeParams).code].join("\n\n");
+}
+function parseParams2(fullpath) {
+  const result = {};
+  let segments = fullpath.split("/");
+  segments.forEach((segment) => {
+    const match = segment.match(/^:([\w-]+)(\?)?/);
+    if (!match) return;
+    const param = match[1];
+    const isRequired = match[2] === void 0;
+    result[param] ||= isRequired;
+    return;
+  });
+  const hasSplat = segments.at(-1) === "*";
+  if (hasSplat) result["*"] = true;
+  return result;
+}
+function getRouteLineage2(routes, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
 
 // vite/node-adapter.ts
 var import_node_events = require("events");
@@ -1597,7 +1672,7 @@ function getChunkedExport(code, exportName, generateOptions = {}, cache, cacheKe
         }
         throw new Error(`Unknown export node type: ${node.type}`);
       }).filter((node) => node !== null);
-      return generate2(ast, generateOptions);
+      return generate(ast, generateOptions);
     }
   );
 }
@@ -1713,7 +1788,7 @@ function omitChunkedExports(code, exportNames, generateOptions = {}, cache, cach
       if (ast.program.body.length === 0) {
         return void 0;
       }
-      return generate2(ast, generateOptions);
+      return generate(ast, generateOptions);
     }
   );
 }
@@ -1775,7 +1850,7 @@ function getRouteChunkNameFromModuleId(id) {
 }
 
 // vite/with-props.ts
-var import_dedent2 = __toESM(require("dedent"));
+var import_dedent3 = __toESM(require("dedent"));
 var vmod = create("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
@@ -1786,7 +1861,7 @@ var plugin = {
   },
   async load(id) {
     if (id !== vmod.resolvedId) return;
-    return import_dedent2.default`
+    return import_dedent3.default`
       import { createElement as h } from "react";
       import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
 
@@ -1806,8 +1881,6 @@ var plugin = {
         return function Wrapped() {
           const props = {
             params: useParams(),
-            loaderData: useLoaderData(),
-            actionData: useActionData(),
           };
           return h(HydrateFallback, props);
         };
@@ -1915,6 +1988,20 @@ var CLIENT_ROUTE_EXPORTS = [
   "shouldRevalidate"
 ];
 var BUILD_CLIENT_ROUTE_QUERY_STRING = "?__react-router-build-client-route";
+var SSR_BUNDLE_PREFIX = "ssrBundle_";
+function isSeverBundleEnvironmentName(name) {
+  return name.startsWith(SSR_BUNDLE_PREFIX);
+}
+function getServerEnvironmentEntries(record, buildManifest) {
+  return Object.entries(record).filter(
+    ([name]) => buildManifest.serverBundles ? isSeverBundleEnvironmentName(name) : name === "ssr"
+  );
+}
+function getServerEnvironmentValues(record, buildManifest) {
+  return getServerEnvironmentEntries(record, buildManifest).map(
+    ([, value]) => value
+  );
+}
 var isRouteEntryModuleId = (id) => {
   return id.endsWith(BUILD_CLIENT_ROUTE_QUERY_STRING);
 };
@@ -2083,7 +2170,7 @@ var resolveEnvironmentBuildContext = ({
   let buildContext = viteUserConfig.__reactRouterEnvironmentBuildContext;
   let resolvedBuildContext = {
     name: buildContext.name,
-    options: buildContext.resolveOptions({ viteCommand, viteUserConfig })
+    options: buildContext.resolveOptions({ viteUserConfig })
   };
   return resolvedBuildContext;
 };
@@ -2108,6 +2195,7 @@ var reactRouterVitePlugin = () => {
   let viteUserConfig;
   let viteConfigEnv;
   let viteConfig;
+  let buildManifest;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
   let cache = /* @__PURE__ */ new Map();
@@ -2168,11 +2256,6 @@ var reactRouterVitePlugin = () => {
       // Otherwise, all routes are imported as usual
       ctx.reactRouterConfig.routes
     );
-    let prerenderPaths = await getPrerenderPaths(
-      ctx.reactRouterConfig.prerender,
-      ctx.reactRouterConfig.ssr,
-      routes
-    );
     return `
     import * as entryServer from ${JSON.stringify(
       resolveFileUrl(ctx, ctx.entryServerFilePath)
@@ -2199,7 +2282,6 @@ var reactRouterVitePlugin = () => {
       export const future = ${JSON.stringify(ctx.reactRouterConfig.future)};
       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 = {
@@ -2432,14 +2514,6 @@ var reactRouterVitePlugin = () => {
         let viteClientConditions = [
           ...vite2.defaultClientConditions ?? []
         ];
-        let packageRoot = path6.dirname(
-          require.resolve("@react-router/dev/package.json")
-        );
-        let { moduleSyncEnabled } = await import(`file:///${path6.join(packageRoot, "module-sync-enabled/index.mjs")}`);
-        let viteServerConditions = [
-          ...vite2.defaultServerConditions ?? [],
-          ...moduleSyncEnabled ? ["module-sync"] : []
-        ];
         logger = vite2.createLogger(viteUserConfig.logLevel, {
           prefix: "[react-router]"
         });
@@ -2455,26 +2529,37 @@ var reactRouterVitePlugin = () => {
           watch: viteCommand === "serve"
         });
         await updatePluginContext();
+        buildManifest = await getBuildManifest(ctx);
         Object.assign(
           process.env,
           vite2.loadEnv(
             viteConfigEnv.mode,
-            ctx.rootDirectory,
+            viteUserConfig.envDir ?? ctx.rootDirectory,
             // We override default prefix of "VITE_" with a blank string since
             // we're targeting the server, so we want to load all environment
             // variables, not just those explicitly marked for the client
             ""
           )
         );
+        let environments = await getEnvironmentsOptions(
+          ctx,
+          buildManifest,
+          viteCommand,
+          { viteUserConfig }
+        );
+        let serverEnvironment = getServerEnvironmentValues(
+          environments,
+          buildManifest
+        )[0];
+        invariant(serverEnvironment);
+        let clientEnvironment = environments.client;
+        invariant(clientEnvironment);
         return {
           __reactRouterPluginContext: ctx,
           appType: viteCommand === "serve" && viteConfigEnv.mode === "production" && ctx.reactRouterConfig.ssr === false ? "spa" : "custom",
           ssr: {
-            external: ssrExternals,
-            resolve: {
-              conditions: viteCommand === "build" ? viteServerConditions : ["development", ...viteServerConditions],
-              externalConditions: viteCommand === "build" ? viteServerConditions : ["development", ...viteServerConditions]
-            }
+            external: serverEnvironment.resolve?.external,
+            resolve: serverEnvironment.resolve
           },
           optimizeDeps: {
             entries: ctx.reactRouterConfig.future.unstable_optimizeDeps ? [
@@ -2523,11 +2608,41 @@ 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,
-          build: ctx.environmentBuildContext?.options.build ?? (await getEnvironmentOptions(
-            ctx,
-            viteConfigEnv.isSsrBuild ? "ssr" : "client",
-            { viteCommand, viteUserConfig }
-          )).build
+          ...ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? {
+            environments,
+            build: {
+              // This isn't honored by the SSR environment config (which seems
+              // to be a Vite bug?) so we set it here too.
+              ssrEmitAssets: true
+            },
+            builder: {
+              sharedConfigBuild: true,
+              sharedPlugins: true,
+              async buildApp(builder) {
+                invariant(viteConfig);
+                invariant(buildManifest);
+                viteConfig.logger.info(
+                  "Using Vite Environment API (experimental)"
+                );
+                let { reactRouterConfig } = ctx;
+                await cleanBuildDirectory(viteConfig, ctx);
+                await builder.build(builder.environments.client);
+                let serverEnvironments = getServerEnvironmentValues(
+                  builder.environments,
+                  buildManifest
+                );
+                await Promise.all(serverEnvironments.map(builder.build));
+                await cleanViteManifests(environments, ctx);
+                await reactRouterConfig.buildEnd?.({
+                  buildManifest,
+                  reactRouterConfig,
+                  viteConfig
+                });
+              }
+            }
+          } : {
+            build: ctx.environmentBuildContext?.options.build ?? (viteConfigEnv.isSsrBuild ? serverEnvironment.build : clientEnvironment.build)
+          }
         };
       },
       async configResolved(resolvedViteConfig) {
@@ -2685,14 +2800,15 @@ 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 (!viteConfigEnv.isSsrBuild) {
+          let { future } = ctx.reactRouterConfig;
+          if (future.unstable_viteEnvironmentApi ? this.environment.name === "client" : !viteConfigEnv.isSsrBuild) {
             return;
           }
           invariant(viteConfig);
           let clientBuildDirectory = getClientBuildDirectory(
             ctx.reactRouterConfig
           );
-          let serverBuildDirectory = ctx.environmentBuildContext?.options.build.outDir ?? getServerBuildDirectory(ctx);
+          let serverBuildDirectory = future.unstable_viteEnvironmentApi ? this.environment.config?.build?.outDir : ctx.environmentBuildContext?.options.build?.outDir ?? getServerBuildDirectory(ctx);
           let ssrViteManifest = await loadViteManifest(serverBuildDirectory);
           let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
           let movedAssetPaths = [];
@@ -2726,7 +2842,7 @@ var reactRouterVitePlugin = () => {
               ].join("\n")
             );
           }
-          if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
+          if (ctx.reactRouterConfig.prerender != null && ctx.reactRouterConfig.prerender !== false) {
             await handlePrerender(
               viteConfig,
               ctx.reactRouterConfig,
@@ -3000,15 +3116,12 @@ var reactRouterVitePlugin = () => {
         if (!route) return;
         if (!options?.ssr && isSpaModeEnabled(ctx.reactRouterConfig)) {
           let exportNames = getExportNames(code);
-          let serverOnlyExports = exportNames.filter((exp) => {
-            if (route.id === "root" && exp === "loader") {
-              return false;
-            }
-            return SERVER_ONLY_ROUTE_EXPORTS.includes(exp);
-          });
+          let serverOnlyExports = exportNames.filter(
+            (exp) => 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://reactrouter.com/how-to/spa for more information.`;
+            let message = `SPA Mode: ${serverOnlyExports.length} invalid route export(s) in \`${route.file}\`: ${str}. See https://remix.run/guides/spa-mode for more information.`;
             throw Error(message);
           }
           if (route.id !== "root") {
@@ -3016,7 +3129,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://reactrouter.com/how-to/spa 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://remix.run/guides/spa-mode for more information.`;
               throw Error(message);
             }
           }
@@ -3027,7 +3140,7 @@ var reactRouterVitePlugin = () => {
           removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
         }
         transform(ast);
-        return generate2(ast, {
+        return generate(ast, {
           sourceMaps: true,
           filename: id,
           sourceFileName: filepath
@@ -3309,11 +3422,8 @@ 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);
+  return reactRouterConfig.ssr === false && (reactRouterConfig.prerender == null || reactRouterConfig.prerender === false || Array.isArray(reactRouterConfig.prerender) && reactRouterConfig.prerender.length === 1 && reactRouterConfig.prerender[0] === "/");
 }
 async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, serverBuildFile) {
   let serverBuildPath = path6.join(serverBuildDirectory, serverBuildFile);
@@ -3325,49 +3435,20 @@ async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, ser
   };
 }
 async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory, serverBuildFile, clientBuildDirectory) {
-  let { build, handler } = await getPrerenderBuildAndHandler(
+  let { handler } = await getPrerenderBuildAndHandler(
     viteConfig,
     serverBuildDirectory,
     serverBuildFile
   );
-  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 request = new Request(`http://localhost${reactRouterConfig.basename}`);
   let response = await handler(request);
   let html = await response.text();
-  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);
-  if (build.prerender.length > 0) {
-    viteConfig.logger.info(
-      `Prerender (html): SPA Fallback -> ${import_picocolors3.default.bold(prettyPath)}`
-    );
-  } else {
-    viteConfig.logger.info(`SPA Mode: Generated ${import_picocolors3.default.bold(prettyPath)}`);
-  }
+  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"
+  );
 }
 async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, serverBuildPath, clientBuildDirectory) {
   let { build, handler } = await getPrerenderBuildAndHandler(
@@ -3376,22 +3457,29 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     serverBuildPath
   );
   let routes = createPrerenderRoutes(build.routes);
-  let prerenderedRoutes = /* @__PURE__ */ new Set();
+  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 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 build.prerender) {
+  for (let path7 of routesToPrerender) {
     let matches = (0, import_react_router2.matchRoutes)(routes, `/${path7}/`.replace(/^\/\/+/, "/"));
-    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 hasLoaders = matches?.some((m) => m.route.loader);
     let data;
     if (hasLoaders) {
       data = await prerenderData(
@@ -3431,34 +3519,8 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       );
     }
   }
-  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 getStaticPrerenderPaths(routes) {
+function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = false) {
   let paths = ["/"];
   let paramRoutes = [];
   function recurse(subtree, prefix = "") {
@@ -3478,29 +3540,28 @@ function getStaticPrerenderPaths(routes) {
     }
   }
   recurse(routes);
-  return {
-    paths: paths.map((p) => p.replace(/\/\/+/g, "/").replace(/(.+)\/$/, "$1")),
-    paramRoutes
-  };
+  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"));
 }
 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();
-  if (response.status !== 200) {
-    throw new Error(
-      `Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path6}\` path.
-${normalizedPath}`
-    );
-  }
+  validatePrerenderedResponse(response, data, "Prerender", 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 (data): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
-  );
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
   return data;
 }
 async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
@@ -3511,65 +3572,42 @@ 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();
-  if (response.status !== 200) {
-    throw new Error(
-      `Prerender (html): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.
-${html}`
-    );
+  validatePrerenderedResponse(response, html, "Prerender", normalizedPath);
+  if (!reactRouterConfig.ssr) {
+    validatePrerenderedHtml(html, "Prerender");
   }
   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 (html): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
-  );
+  viteConfig.logger.info(`Prerender: Generated ${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();
-  if (response.status !== 200) {
-    throw new Error(
-      `Prerender (resource): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${normalizedPath}\` path.
-${text}`
-    );
-  }
+  validatePrerenderedResponse(response, text, "Prerender", 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, text);
-  viteConfig.logger.info(
-    `Prerender (resource): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
-  );
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
-async function getPrerenderPaths(prerender, ssr, routes) {
-  let prerenderPaths = [];
-  if (prerender != null && prerender !== false) {
-    let prerenderRoutes = createPrerenderRoutes(routes);
-    if (prerender === true) {
-      let { paths, paramRoutes } = getStaticPrerenderPaths(prerenderRoutes);
-      if (!ssr && 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 || ["/"];
-    }
+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}`
+    );
+  }
+}
+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 />\`.`
+    );
   }
-  return prerenderPaths;
 }
 function groupRoutesByParentId2(manifest) {
   let routes = {};
@@ -3587,16 +3625,19 @@ function groupRoutesByParentId2(manifest) {
 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
+      path: route.path,
+      loader: route.module.loader ? () => null : void 0,
+      action: void 0,
+      handle: route.module.handle
     };
-    if (route.index) {
-      return {
-        index: true,
-        ...commonRoute
-      };
-    }
-    return {
+    return route.index ? {
+      index: true,
+      ...commonRoute
+    } : {
+      caseSensitive: route.caseSensitive,
       children: createPrerenderRoutes(manifest, route.id, routesByParentId),
       ...commonRoute
     };
@@ -3715,6 +3756,39 @@ function validateRouteChunks({
     ].join("\n\n")
   );
 }
+async function cleanBuildDirectory(viteConfig, ctx) {
+  let buildDirectory = ctx.reactRouterConfig.buildDirectory;
+  let isWithinRoot = () => {
+    let relativePath = path6.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
+  };
+  if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
+    await fse.remove(buildDirectory);
+  }
+}
+async function cleanViteManifests(environmentsOptions, ctx) {
+  let viteManifestPaths = Object.entries(environmentsOptions).map(
+    ([environmentName, options]) => {
+      let outDir = options.build?.outDir;
+      invariant(outDir, `Expected build.outDir for ${environmentName}`);
+      return path6.join(outDir, ".vite/manifest.json");
+    }
+  );
+  await Promise.all(
+    viteManifestPaths.map(async (viteManifestPath) => {
+      let manifestExists = await fse.pathExists(viteManifestPath);
+      if (!manifestExists) return;
+      if (!ctx.viteManifestEnabled) {
+        await fse.remove(viteManifestPath);
+      }
+      let viteDir = path6.dirname(viteManifestPath);
+      let viteDirFiles = await fse.readdir(viteDir);
+      if (viteDirFiles.length === 0) {
+        await fse.remove(viteDir);
+      }
+    })
+  );
+}
 async function getBuildManifest(ctx) {
   let { routes, serverBundles, appDirectory } = ctx.reactRouterConfig;
   if (!serverBundles) {
@@ -3774,77 +3848,101 @@ async function getBuildManifest(ctx) {
   );
   return buildManifest;
 }
-function mergeBuildOptions(base, overrides) {
+function mergeEnvironmentOptions(base, ...overrides) {
   let vite2 = getVite();
-  return vite2.mergeConfig({ build: base }, { build: overrides }).build;
+  return overrides.reduce(
+    (merged, override) => vite2.mergeConfig(merged, override, false),
+    base
+  );
 }
-async function getEnvironmentOptionsResolvers(ctx, buildManifest) {
+async function getEnvironmentOptionsResolvers(ctx, buildManifest, viteCommand) {
   let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
-  function getBaseBuildOptions({
+  let packageRoot = path6.dirname(
+    require.resolve("@react-router/dev/package.json")
+  );
+  let { moduleSyncEnabled } = await import(`file:///${path6.join(packageRoot, "module-sync-enabled/index.mjs")}`);
+  let vite2 = getVite();
+  let viteServerConditions = [
+    ...vite2.defaultServerConditions ?? [],
+    ...moduleSyncEnabled ? ["module-sync"] : []
+  ];
+  function getBaseOptions({
     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);
+      build: {
+        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({
+  function getBaseServerOptions({
     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 conditions = viteCommand === "build" ? viteServerConditions : ["development", ...viteServerConditions];
+    return mergeEnvironmentOptions(getBaseOptions({ viteUserConfig }), {
+      resolve: {
+        external: ssrExternals,
+        conditions,
+        externalConditions: conditions
+      },
+      build: {
+        // 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 }), {
+    client: ({ viteUserConfig }) => mergeEnvironmentOptions(getBaseOptions({ viteUserConfig }), {
+      build: {
         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);
-            })
+            ...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 }) {
@@ -3856,19 +3954,19 @@ async function getEnvironmentOptionsResolvers(ctx, buildManifest) {
           }
         },
         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 }),
-          {
+      const serverBundleEnvironmentId = serverBundleId.replaceAll("-", "_");
+      const environmentName = `${SSR_BUNDLE_PREFIX}${serverBundleEnvironmentId}`;
+      environmentOptionsResolvers[environmentName] = ({ viteUserConfig }) => mergeEnvironmentOptions(
+        getBaseServerOptions({ viteUserConfig }),
+        {
+          build: {
             outDir: getServerBuildDirectory(ctx, { serverBundleId }),
             rollupOptions: {
               input: `${virtual.serverBuild.id}?route-ids=${Object.keys(
@@ -3876,30 +3974,43 @@ async function getEnvironmentOptionsResolvers(ctx, buildManifest) {
               ).join(",")}`
             }
           }
-        )
-      });
+        },
+        // Ensure server bundle environments extend the user's SSR
+        // environment config if it exists
+        viteUserConfig.environments?.ssr ?? {}
+      );
     }
   } else {
-    environmentOptionsResolvers.ssr = ({ viteUserConfig }) => ({
-      build: mergeBuildOptions(getBaseServerBuildOptions({ viteUserConfig }), {
+    environmentOptionsResolvers.ssr = ({ viteUserConfig }) => mergeEnvironmentOptions(getBaseServerOptions({ viteUserConfig }), {
+      build: {
         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(
+function resolveEnvironmentsOptions(environmentResolvers, resolverOptions) {
+  let environmentOptions = {};
+  for (let [environmentName, resolver] of Object.entries(
+    environmentResolvers
+  )) {
+    environmentOptions[environmentName] = resolver(resolverOptions);
+  }
+  return environmentOptions;
+}
+async function getEnvironmentsOptions(ctx, buildManifest, viteCommand, resolverOptions) {
+  let environmentOptionsResolvers = await getEnvironmentOptionsResolvers(
     ctx,
-    buildManifest
+    buildManifest,
+    viteCommand
+  );
+  return resolveEnvironmentsOptions(
+    environmentOptionsResolvers,
+    resolverOptions
   );
-  let resolver = environmentResolvers[environmentName];
-  invariant(resolver, `Missing environment resolver for ${environmentName}`);
-  return resolver(resolverOptions);
 }
 function isNonNullable(x) {
   return x != null;