@react-router/dev 7.1.5 → 7.2.0-pre.1

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.1.5
+ * @react-router/dev v7.2.0-pre.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -52,11 +52,14 @@ 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"));
+var import_dedent2 = __toESM(require("dedent"));
 var Path4 = __toESM(require("pathe"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
@@ -270,6 +273,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;
@@ -443,7 +453,9 @@ async function resolveConfig({
     );
   }
   let future = {
-    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false,
+    unstable_splitRouteModules: reactRouterUserConfig.future?.unstable_splitRouteModules ?? false,
+    unstable_viteEnvironmentApi: reactRouterUserConfig.future?.unstable_viteEnvironmentApi ?? false
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
@@ -622,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"));
@@ -642,12 +667,45 @@ function getTypesPath(ctx, route) {
   );
 }
 
+// typegen/params.ts
+function parse2(fullpath2) {
+  const result = {};
+  let segments = fullpath2.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;
+}
+
+// typegen/route.ts
+function lineage(routes, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
+function fullpath(lineage2) {
+  if (lineage2.length === 1 && lineage2[0].id === "root") return "/";
+  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path7) => path7 !== void 0 && path7 !== "").join("/");
+}
+
 // typegen/generate.ts
-function generate(ctx, route) {
-  const lineage = getRouteLineage(ctx.config.routes, route);
-  const urlpath = lineage.map((route2) => route2.path).join("/");
+function generate2(ctx, route) {
+  const lineage2 = lineage(ctx.config.routes, route);
+  const fullpath2 = fullpath(lineage2);
   const typesPath = getTypesPath(ctx, route);
-  const parents = lineage.slice(0, -1);
+  const parents = lineage2.slice(0, -1);
   const parentTypeImports = parents.map((parent, i) => {
     const rel = Path3.relative(
       Path3.dirname(typesPath),
@@ -674,7 +732,7 @@ function generate(ctx, route) {
       file: "${route.file}"
       path: "${route.path}"
       params: {${formatParamProperties(
-    urlpath
+    fullpath2
   )}} & { [key: string]: string | undefined }
       module: Module
       loaderData: T.CreateLoaderData<Module>
@@ -704,46 +762,13 @@ function generate(ctx, route) {
   `;
 }
 var noExtension = (path7) => Path3.join(Path3.dirname(path7), Pathe2.filename(path7));
-function getRouteLineage(routes, route) {
-  const result = [];
-  while (route) {
-    result.push(route);
-    if (!route.parentId) break;
-    route = routes[route.parentId];
-  }
-  result.reverse();
-  return result;
-}
-function formatParamProperties(urlpath) {
-  const params = parseParams(urlpath);
-  const properties = Object.entries(params).map(([name, values]) => {
-    if (values.length === 1) {
-      const isOptional = values[0];
-      return isOptional ? `"${name}"?: string` : `"${name}": string`;
-    }
-    const items = values.map(
-      (isOptional) => isOptional ? "string | undefined" : "string"
-    );
-    return `"${name}": [${items.join(", ")}]`;
-  });
+function formatParamProperties(fullpath2) {
+  const params = parse2(fullpath2);
+  const properties = Object.entries(params).map(
+    ([name, isRequired]) => isRequired ? `"${name}": string` : `"${name}"?: string`
+  );
   return properties.join("; ");
 }
-function parseParams(urlpath) {
-  const result = {};
-  let segments = urlpath.split("/");
-  segments.forEach((segment) => {
-    const match = segment.match(/^:([\w-]+)(\?)?/);
-    if (!match) return;
-    const param = match[1];
-    const isOptional = match[2] !== void 0;
-    result[param] ??= [];
-    result[param].push(isOptional);
-    return;
-  });
-  const hasSplat = segments.at(-1) === "*";
-  if (hasSplat) result["*"] = [false];
-  return result;
-}
 
 // typegen/index.ts
 async function watch(rootDirectory, { logger } = {}) {
@@ -789,17 +814,53 @@ 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) => {
+        if (route.id !== "root" && !route.path) return void 0;
+        const lineage2 = lineage(ctx.config.routes, route);
+        const fullpath2 = fullpath(lineage2);
+        const params = parse2(fullpath2);
+        return t2.tsPropertySignature(
+          t2.stringLiteral(fullpath2),
+          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;
+              })
+            )
+          )
+        );
+      }).filter((x) => x !== void 0)
+    )
+  );
+  return [register2, generate(typeParams).code].join("\n\n");
+}
 
 // vite/node-adapter.ts
 var import_node_events = require("events");
@@ -1159,8 +1220,613 @@ function invalidDestructureError(name) {
   return new Error(`Cannot remove destructured export "${name}"`);
 }
 
+// vite/cache.ts
+function getOrSetFromCache(cache, key, version, getValue) {
+  if (!cache) {
+    return getValue();
+  }
+  let entry = cache.get(key);
+  if (entry?.version === version) {
+    return entry.value;
+  }
+  let value = getValue();
+  let newEntry = { value, version };
+  cache.set(key, newEntry);
+  return value;
+}
+
+// vite/route-chunks.ts
+function codeToAst(code, cache, cacheKey) {
+  return structuredClone(
+    getOrSetFromCache(
+      cache,
+      `${cacheKey}::codeToAst`,
+      code,
+      () => (0, import_parser.parse)(code, { sourceType: "module" })
+    )
+  );
+}
+function assertNodePath(path7) {
+  invariant(
+    path7 && !Array.isArray(path7),
+    `Expected a Path, but got ${Array.isArray(path7) ? "an array" : path7}`
+  );
+}
+function assertNodePathIsStatement(path7) {
+  invariant(
+    path7 && !Array.isArray(path7) && t.isStatement(path7.node),
+    `Expected a Statement path, but got ${Array.isArray(path7) ? "an array" : path7?.node?.type}`
+  );
+}
+function assertNodePathIsVariableDeclarator(path7) {
+  invariant(
+    path7 && !Array.isArray(path7) && t.isVariableDeclarator(path7.node),
+    `Expected an Identifier path, but got ${Array.isArray(path7) ? "an array" : path7?.node?.type}`
+  );
+}
+function assertNodePathIsPattern(path7) {
+  invariant(
+    path7 && !Array.isArray(path7) && t.isPattern(path7.node),
+    `Expected a Pattern path, but got ${Array.isArray(path7) ? "an array" : path7?.node?.type}`
+  );
+}
+function getExportDependencies(code, cache, cacheKey) {
+  return getOrSetFromCache(
+    cache,
+    `${cacheKey}::getExportDependencies`,
+    code,
+    () => {
+      let exportDependencies = /* @__PURE__ */ new Map();
+      let ast = codeToAst(code, cache, cacheKey);
+      function handleExport(exportName, exportPath, identifiersPath = exportPath) {
+        let identifiers = getDependentIdentifiersForPath(identifiersPath);
+        let topLevelStatements = /* @__PURE__ */ new Set([
+          exportPath.node,
+          ...getTopLevelStatementsForPaths(identifiers)
+        ]);
+        let topLevelNonModuleStatements = new Set(
+          Array.from(topLevelStatements).filter(
+            (statement) => !t.isImportDeclaration(statement) && !t.isExportDeclaration(statement)
+          )
+        );
+        let importedIdentifierNames = /* @__PURE__ */ new Set();
+        for (let identifier of identifiers) {
+          if (identifier.parentPath.parentPath?.isImportDeclaration()) {
+            importedIdentifierNames.add(identifier.node.name);
+          }
+        }
+        let exportedVariableDeclarators = /* @__PURE__ */ new Set();
+        for (let identifier of identifiers) {
+          if (identifier.parentPath.isVariableDeclarator() && identifier.parentPath.parentPath.parentPath?.isExportNamedDeclaration()) {
+            exportedVariableDeclarators.add(identifier.parentPath.node);
+            continue;
+          }
+          let isWithinExportDestructuring = Boolean(
+            identifier.findParent(
+              (path7) => Boolean(
+                path7.isPattern() && path7.parentPath?.isVariableDeclarator() && path7.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()
+              )
+            )
+          );
+          if (isWithinExportDestructuring) {
+            let currentPath = identifier;
+            while (currentPath) {
+              if (
+                // Check the identifier is within a variable declaration, and if
+                // so, ensure we're on the left-hand side of the expression
+                // since these identifiers are what make up the export names,
+                // e.g. export const { foo } = { foo: bar }; should pick up
+                // `foo` but not `bar`.
+                currentPath.parentPath?.isVariableDeclarator() && currentPath.parentKey === "id"
+              ) {
+                exportedVariableDeclarators.add(currentPath.parentPath.node);
+                break;
+              }
+              currentPath = currentPath.parentPath;
+            }
+          }
+        }
+        let dependencies = {
+          topLevelStatements,
+          topLevelNonModuleStatements,
+          importedIdentifierNames,
+          exportedVariableDeclarators
+        };
+        exportDependencies.set(exportName, dependencies);
+      }
+      traverse(ast, {
+        ExportDeclaration(exportPath) {
+          let { node } = exportPath;
+          if (t.isExportAllDeclaration(node)) {
+            return;
+          }
+          if (t.isExportDefaultDeclaration(node)) {
+            handleExport("default", exportPath);
+            return;
+          }
+          let { declaration } = node;
+          if (t.isVariableDeclaration(declaration)) {
+            let { declarations } = declaration;
+            for (let i = 0; i < declarations.length; i++) {
+              let declarator = declarations[i];
+              if (t.isIdentifier(declarator.id)) {
+                let declaratorPath = exportPath.get(
+                  `declaration.declarations.${i}`
+                );
+                assertNodePathIsVariableDeclarator(declaratorPath);
+                handleExport(declarator.id.name, exportPath, declaratorPath);
+                continue;
+              }
+              if (t.isPattern(declarator.id)) {
+                let exportedPatternPath = exportPath.get(
+                  `declaration.declarations.${i}.id`
+                );
+                assertNodePathIsPattern(exportedPatternPath);
+                let identifiers = getIdentifiersForPatternPath(exportedPatternPath);
+                for (let identifier of identifiers) {
+                  handleExport(identifier.node.name, exportPath, identifier);
+                }
+              }
+            }
+            return;
+          }
+          if (t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) {
+            invariant(
+              declaration.id,
+              "Expected exported function or class declaration to have a name when not the default export"
+            );
+            handleExport(declaration.id.name, exportPath);
+            return;
+          }
+          if (t.isExportNamedDeclaration(node)) {
+            for (let specifier of node.specifiers) {
+              if (t.isIdentifier(specifier.exported)) {
+                let name = specifier.exported.name;
+                let specifierPath = exportPath.get("specifiers").find((path7) => path7.node === specifier);
+                invariant(
+                  specifierPath,
+                  `Expected to find specifier path for ${name}`
+                );
+                handleExport(name, exportPath, specifierPath);
+              }
+            }
+            return;
+          }
+          throw new Error(`Unknown export node type: ${node.type}`);
+        }
+      });
+      return exportDependencies;
+    }
+  );
+}
+function getDependentIdentifiersForPath(path7, state) {
+  let { visited, identifiers } = state ?? {
+    visited: /* @__PURE__ */ new Set(),
+    identifiers: /* @__PURE__ */ new Set()
+  };
+  if (visited.has(path7)) {
+    return identifiers;
+  }
+  visited.add(path7);
+  path7.traverse({
+    Identifier(path8) {
+      if (identifiers.has(path8)) {
+        return;
+      }
+      identifiers.add(path8);
+      let binding = path8.scope.getBinding(path8.node.name);
+      if (!binding) {
+        return;
+      }
+      getDependentIdentifiersForPath(binding.path, { visited, identifiers });
+      for (let reference of binding.referencePaths) {
+        if (reference.isExportNamedDeclaration()) {
+          continue;
+        }
+        getDependentIdentifiersForPath(reference, {
+          visited,
+          identifiers
+        });
+      }
+      for (let constantViolation of binding.constantViolations) {
+        getDependentIdentifiersForPath(constantViolation, {
+          visited,
+          identifiers
+        });
+      }
+    }
+  });
+  let topLevelStatement = getTopLevelStatementPathForPath(path7);
+  let withinImportStatement = topLevelStatement.isImportDeclaration();
+  let withinExportStatement = topLevelStatement.isExportDeclaration();
+  if (!withinImportStatement && !withinExportStatement) {
+    getDependentIdentifiersForPath(topLevelStatement, {
+      visited,
+      identifiers
+    });
+  }
+  if (withinExportStatement && path7.isIdentifier() && (t.isPattern(path7.parentPath.node) || // [foo]
+  t.isPattern(path7.parentPath.parentPath?.node))) {
+    let variableDeclarator = path7.findParent((p) => p.isVariableDeclarator());
+    assertNodePath(variableDeclarator);
+    getDependentIdentifiersForPath(variableDeclarator, {
+      visited,
+      identifiers
+    });
+  }
+  return identifiers;
+}
+function getTopLevelStatementPathForPath(path7) {
+  let ancestry = path7.getAncestry();
+  let topLevelStatement = ancestry[ancestry.length - 2];
+  assertNodePathIsStatement(topLevelStatement);
+  return topLevelStatement;
+}
+function getTopLevelStatementsForPaths(paths) {
+  let topLevelStatements = /* @__PURE__ */ new Set();
+  for (let path7 of paths) {
+    let topLevelStatement = getTopLevelStatementPathForPath(path7);
+    topLevelStatements.add(topLevelStatement.node);
+  }
+  return topLevelStatements;
+}
+function getIdentifiersForPatternPath(patternPath, identifiers = /* @__PURE__ */ new Set()) {
+  function walk(currentPath) {
+    if (currentPath.isIdentifier()) {
+      identifiers.add(currentPath);
+      return;
+    }
+    if (currentPath.isObjectPattern()) {
+      let { properties } = currentPath.node;
+      for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        if (t.isObjectProperty(property)) {
+          let valuePath = currentPath.get(`properties.${i}.value`);
+          assertNodePath(valuePath);
+          walk(valuePath);
+        } else if (t.isRestElement(property)) {
+          let argumentPath = currentPath.get(`properties.${i}.argument`);
+          assertNodePath(argumentPath);
+          walk(argumentPath);
+        }
+      }
+    } else if (currentPath.isArrayPattern()) {
+      let { elements } = currentPath.node;
+      for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        if (element) {
+          let elementPath = currentPath.get(`elements.${i}`);
+          assertNodePath(elementPath);
+          walk(elementPath);
+        }
+      }
+    } else if (currentPath.isRestElement()) {
+      let argumentPath = currentPath.get("argument");
+      assertNodePath(argumentPath);
+      walk(argumentPath);
+    }
+  }
+  walk(patternPath);
+  return identifiers;
+}
+var getExportedName = (exported) => {
+  return t.isIdentifier(exported) ? exported.name : exported.value;
+};
+function setsIntersect(set1, set2) {
+  let smallerSet = set1;
+  let largerSet = set2;
+  if (set1.size > set2.size) {
+    smallerSet = set2;
+    largerSet = set1;
+  }
+  for (let element of smallerSet) {
+    if (largerSet.has(element)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasChunkableExport(code, exportName, cache, cacheKey) {
+  return getOrSetFromCache(
+    cache,
+    `${cacheKey}::hasChunkableExport::${exportName}`,
+    code,
+    () => {
+      let exportDependencies = getExportDependencies(code, cache, cacheKey);
+      let dependencies = exportDependencies.get(exportName);
+      if (!dependencies) {
+        return false;
+      }
+      for (let [currentExportName, currentDependencies] of exportDependencies) {
+        if (currentExportName === exportName) {
+          continue;
+        }
+        if (setsIntersect(
+          currentDependencies.topLevelNonModuleStatements,
+          dependencies.topLevelNonModuleStatements
+        )) {
+          return false;
+        }
+      }
+      if (dependencies.exportedVariableDeclarators.size > 1) {
+        return false;
+      }
+      if (dependencies.exportedVariableDeclarators.size > 0) {
+        for (let [
+          currentExportName,
+          currentDependencies
+        ] of exportDependencies) {
+          if (currentExportName === exportName) {
+            continue;
+          }
+          if (setsIntersect(
+            currentDependencies.exportedVariableDeclarators,
+            dependencies.exportedVariableDeclarators
+          )) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  );
+}
+function getChunkedExport(code, exportName, generateOptions = {}, cache, cacheKey) {
+  return getOrSetFromCache(
+    cache,
+    `${cacheKey}::getChunkedExport::${exportName}::${JSON.stringify(
+      generateOptions
+    )}`,
+    code,
+    () => {
+      if (!hasChunkableExport(code, exportName, cache, cacheKey)) {
+        return void 0;
+      }
+      let exportDependencies = getExportDependencies(code, cache, cacheKey);
+      let dependencies = exportDependencies.get(exportName);
+      invariant(dependencies, "Expected export to have dependencies");
+      let topLevelStatementsArray = Array.from(dependencies.topLevelStatements);
+      let exportedVariableDeclaratorsArray = Array.from(
+        dependencies.exportedVariableDeclarators
+      );
+      let ast = codeToAst(code, cache, cacheKey);
+      ast.program.body = ast.program.body.filter(
+        (node) => topLevelStatementsArray.some(
+          (statement) => t.isNodesEquivalent(node, statement)
+        )
+      ).map((node) => {
+        if (!t.isImportDeclaration(node)) {
+          return node;
+        }
+        if (dependencies.importedIdentifierNames.size === 0) {
+          return null;
+        }
+        node.specifiers = node.specifiers.filter(
+          (specifier) => dependencies.importedIdentifierNames.has(specifier.local.name)
+        );
+        invariant(
+          node.specifiers.length > 0,
+          "Expected import statement to have used specifiers"
+        );
+        return node;
+      }).map((node) => {
+        if (!t.isExportDeclaration(node)) {
+          return node;
+        }
+        if (t.isExportAllDeclaration(node)) {
+          return null;
+        }
+        if (t.isExportDefaultDeclaration(node)) {
+          return exportName === "default" ? node : null;
+        }
+        let { declaration } = node;
+        if (t.isVariableDeclaration(declaration)) {
+          declaration.declarations = declaration.declarations.filter(
+            (node2) => exportedVariableDeclaratorsArray.some(
+              (declarator) => t.isNodesEquivalent(node2, declarator)
+            )
+          );
+          if (declaration.declarations.length === 0) {
+            return null;
+          }
+          return node;
+        }
+        if (t.isFunctionDeclaration(node.declaration) || t.isClassDeclaration(node.declaration)) {
+          return node.declaration.id?.name === exportName ? node : null;
+        }
+        if (t.isExportNamedDeclaration(node)) {
+          if (node.specifiers.length === 0) {
+            return null;
+          }
+          node.specifiers = node.specifiers.filter(
+            (specifier) => getExportedName(specifier.exported) === exportName
+          );
+          if (node.specifiers.length === 0) {
+            return null;
+          }
+          return node;
+        }
+        throw new Error(`Unknown export node type: ${node.type}`);
+      }).filter((node) => node !== null);
+      return generate(ast, generateOptions);
+    }
+  );
+}
+function omitChunkedExports(code, exportNames, generateOptions = {}, cache, cacheKey) {
+  return getOrSetFromCache(
+    cache,
+    `${cacheKey}::omitChunkedExports::${exportNames.join(
+      ","
+    )}::${JSON.stringify(generateOptions)}`,
+    code,
+    () => {
+      const isChunkable = (exportName) => hasChunkableExport(code, exportName, cache, cacheKey);
+      const isOmitted = (exportName) => exportNames.includes(exportName) && isChunkable(exportName);
+      const isRetained = (exportName) => !isOmitted(exportName);
+      let exportDependencies = getExportDependencies(code, cache, cacheKey);
+      let allExportNames = Array.from(exportDependencies.keys());
+      let omittedExportNames = allExportNames.filter(isOmitted);
+      let retainedExportNames = allExportNames.filter(isRetained);
+      let omittedStatements = /* @__PURE__ */ new Set();
+      let omittedExportedVariableDeclarators = /* @__PURE__ */ new Set();
+      for (let omittedExportName of omittedExportNames) {
+        let dependencies = exportDependencies.get(omittedExportName);
+        invariant(
+          dependencies,
+          `Expected dependencies for ${omittedExportName}`
+        );
+        for (let statement of dependencies.topLevelNonModuleStatements) {
+          omittedStatements.add(statement);
+        }
+        for (let declarator of dependencies.exportedVariableDeclarators) {
+          omittedExportedVariableDeclarators.add(declarator);
+        }
+      }
+      let ast = codeToAst(code, cache, cacheKey);
+      let omittedStatementsArray = Array.from(omittedStatements);
+      let omittedExportedVariableDeclaratorsArray = Array.from(
+        omittedExportedVariableDeclarators
+      );
+      ast.program.body = ast.program.body.filter(
+        (node) => omittedStatementsArray.every(
+          (statement) => !t.isNodesEquivalent(node, statement)
+        )
+      ).map((node) => {
+        if (!t.isImportDeclaration(node)) {
+          return node;
+        }
+        if (node.specifiers.length === 0) {
+          return node;
+        }
+        node.specifiers = node.specifiers.filter((specifier) => {
+          let importedName = specifier.local.name;
+          for (let retainedExportName of retainedExportNames) {
+            let dependencies = exportDependencies.get(retainedExportName);
+            if (dependencies?.importedIdentifierNames?.has(importedName)) {
+              return true;
+            }
+          }
+          for (let omittedExportName of omittedExportNames) {
+            let dependencies = exportDependencies.get(omittedExportName);
+            if (dependencies?.importedIdentifierNames?.has(importedName)) {
+              return false;
+            }
+          }
+          return true;
+        });
+        if (node.specifiers.length === 0) {
+          return null;
+        }
+        return node;
+      }).map((node) => {
+        if (!t.isExportDeclaration(node)) {
+          return node;
+        }
+        if (t.isExportAllDeclaration(node)) {
+          return node;
+        }
+        if (t.isExportDefaultDeclaration(node)) {
+          return isOmitted("default") ? null : node;
+        }
+        if (t.isVariableDeclaration(node.declaration)) {
+          node.declaration.declarations = node.declaration.declarations.filter(
+            (node2) => omittedExportedVariableDeclaratorsArray.every(
+              (declarator) => !t.isNodesEquivalent(node2, declarator)
+            )
+          );
+          if (node.declaration.declarations.length === 0) {
+            return null;
+          }
+          return node;
+        }
+        if (t.isFunctionDeclaration(node.declaration) || t.isClassDeclaration(node.declaration)) {
+          invariant(
+            node.declaration.id,
+            "Expected exported function or class declaration to have a name when not the default export"
+          );
+          return isOmitted(node.declaration.id.name) ? null : node;
+        }
+        if (t.isExportNamedDeclaration(node)) {
+          if (node.specifiers.length === 0) {
+            return node;
+          }
+          node.specifiers = node.specifiers.filter((specifier) => {
+            const exportedName = getExportedName(specifier.exported);
+            return !isOmitted(exportedName);
+          });
+          if (node.specifiers.length === 0) {
+            return null;
+          }
+          return node;
+        }
+        throw new Error(`Unknown node type: ${node.type}`);
+      }).filter((node) => node !== null);
+      if (ast.program.body.length === 0) {
+        return void 0;
+      }
+      return generate(ast, generateOptions);
+    }
+  );
+}
+function detectRouteChunks(code, cache, cacheKey) {
+  const hasRouteChunkByExportName = Object.fromEntries(
+    routeChunkExportNames.map((exportName) => [
+      exportName,
+      hasChunkableExport(code, exportName, cache, cacheKey)
+    ])
+  );
+  const chunkedExports = Object.entries(hasRouteChunkByExportName).filter(([, isChunked]) => isChunked).map(([exportName]) => exportName);
+  const hasRouteChunks = chunkedExports.length > 0;
+  return {
+    hasRouteChunks,
+    hasRouteChunkByExportName,
+    chunkedExports
+  };
+}
+var routeChunkExportNames = [
+  "clientAction",
+  "clientLoader",
+  "HydrateFallback"
+];
+var mainChunkName = "main";
+var routeChunkNames = ["main", ...routeChunkExportNames];
+function getRouteChunkCode(code, chunkName, cache, cacheKey) {
+  if (chunkName === mainChunkName) {
+    return omitChunkedExports(code, routeChunkExportNames, {}, cache, cacheKey);
+  }
+  return getChunkedExport(code, chunkName, {}, cache, cacheKey);
+}
+var routeChunkQueryStringPrefix = "?route-chunk=";
+var routeChunkQueryStrings = {
+  main: `${routeChunkQueryStringPrefix}main`,
+  clientAction: `${routeChunkQueryStringPrefix}clientAction`,
+  clientLoader: `${routeChunkQueryStringPrefix}clientLoader`,
+  HydrateFallback: `${routeChunkQueryStringPrefix}HydrateFallback`
+};
+function getRouteChunkModuleId(filePath, chunkName) {
+  return `${filePath}${routeChunkQueryStrings[chunkName]}`;
+}
+function isRouteChunkModuleId(id) {
+  return Object.values(routeChunkQueryStrings).some(
+    (queryString) => id.endsWith(queryString)
+  );
+}
+function isRouteChunkName(name) {
+  return name === mainChunkName || routeChunkExportNames.includes(name);
+}
+function getRouteChunkNameFromModuleId(id) {
+  if (!isRouteChunkModuleId(id)) {
+    return null;
+  }
+  let chunkName = id.split(routeChunkQueryStringPrefix)[1].split("&")[0];
+  if (!isRouteChunkName(chunkName)) {
+    return null;
+  }
+  return chunkName;
+}
+
 // 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 = {
@@ -1171,7 +1837,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";
 
@@ -1191,6 +1857,8 @@ var plugin = {
         return function Wrapped() {
           const props = {
             params: useParams(),
+            loaderData: useLoaderData(),
+            actionData: useActionData(),
           };
           return h(HydrateFallback, props);
         };
@@ -1298,8 +1966,34 @@ 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);
+};
+var isRouteVirtualModule = (id) => {
+  return isRouteEntryModuleId(id) || isRouteChunkModuleId(id);
+};
 var virtualHmrRuntime = create("hmr-runtime");
 var virtualInjectHmrRuntime = create("inject-hmr-runtime");
+var normalizeRelativeFilePath = (file, reactRouterConfig) => {
+  let vite2 = getVite();
+  let fullPath = path6.resolve(reactRouterConfig.appDirectory, file);
+  let relativePath = path6.relative(reactRouterConfig.appDirectory, fullPath);
+  return vite2.normalizePath(relativePath).split("?")[0];
+};
 var resolveRelativeRouteFilePath = (route, reactRouterConfig) => {
   let vite2 = getVite();
   let file = route.file;
@@ -1328,23 +2022,35 @@ var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
   let rootRelativeFilePath = vite2.normalizePath(
     path6.relative(ctx.rootDirectory, absoluteFilePath)
   );
-  let entryChunk = viteManifest[rootRelativeFilePath + BUILD_CLIENT_ROUTE_QUERY_STRING] ?? viteManifest[rootRelativeFilePath];
+  let entryChunk = viteManifest[rootRelativeFilePath];
   if (!entryChunk) {
-    let knownManifestKeys = Object.keys(viteManifest).map((key) => '"' + key + '"').join(", ");
-    throw new Error(
-      `No manifest entry found for "${rootRelativeFilePath}". Known manifest keys: ${knownManifestKeys}`
-    );
+    return void 0;
   }
   return entryChunk;
 };
+var getPublicModulePathForEntry = (ctx, viteManifest, entryFilePath) => {
+  let entryChunk = resolveChunk(ctx, viteManifest, entryFilePath);
+  return entryChunk ? `${ctx.publicPath}${entryChunk.file}` : void 0;
+};
 var getReactRouterManifestBuildAssets = (ctx, viteManifest, entryFilePath, prependedAssetFilePaths = []) => {
   let entryChunk = resolveChunk(ctx, viteManifest, entryFilePath);
-  let prependedAssetChunks = prependedAssetFilePaths.map(
-    (filePath) => resolveChunk(ctx, viteManifest, filePath)
-  );
+  invariant(entryChunk, "Chunk not found");
+  let prependedAssetChunks = prependedAssetFilePaths.map((filePath) => {
+    let chunk = resolveChunk(ctx, viteManifest, filePath);
+    invariant(chunk, "Chunk not found");
+    return chunk;
+  });
+  let routeModuleChunks = routeChunkNames.map(
+    (routeChunkName) => resolveChunk(
+      ctx,
+      viteManifest,
+      getRouteChunkModuleId(entryFilePath.split("?")[0], routeChunkName)
+    )
+  ).filter(isNonNullable);
   let chunks = resolveDependantChunks(viteManifest, [
     ...prependedAssetChunks,
-    entryChunk
+    entryChunk,
+    ...routeModuleChunks
   ]);
   return {
     module: `${ctx.publicPath}${entryChunk.file}`,
@@ -1381,6 +2087,10 @@ var writeFileSafe = async (file, contents) => {
   await fse.ensureDir(path6.dirname(file));
   await fse.writeFile(file, contents);
 };
+var getExportNames = (code) => {
+  let [, exportSpecifiers] = (0, import_es_module_lexer.parse)(code);
+  return exportSpecifiers.map(({ n: name }) => name);
+};
 var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
   let entries = await Promise.all(
     Object.entries(ctx.reactRouterConfig.routes).map(async ([key, route]) => {
@@ -1394,7 +2104,7 @@ var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
   );
   return Object.fromEntries(entries);
 };
-var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
+var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
   if (!viteChildCompiler) {
     throw new Error("Vite child compiler not found");
   }
@@ -1414,20 +2124,38 @@ var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteF
     moduleGraph.ensureEntryFromUrl(url2, ssr)
   ]);
   let transformed = await pluginContainer.transform(code, id, { ssr });
-  let [, exports2] = (0, import_es_module_lexer.parse)(transformed.code);
-  let exportNames = exports2.map((e) => e.n);
-  return exportNames;
+  return transformed.code;
 };
-var getServerBundleBuildConfig = (viteUserConfig) => {
-  if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
+var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
+  if (!viteChildCompiler) {
+    throw new Error("Vite child compiler not found");
+  }
+  let code = await compileRouteFile(
+    viteChildCompiler,
+    ctx,
+    routeFile,
+    readRouteFile
+  );
+  return getExportNames(code);
+};
+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({ 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(
@@ -1445,8 +2173,10 @@ var reactRouterVitePlugin = () => {
   let viteUserConfig;
   let viteConfigEnv;
   let viteConfig;
+  let buildManifest;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
+  let cache = /* @__PURE__ */ new Map();
   let reactRouterConfigLoader;
   let typegenWatcherPromise;
   let logger;
@@ -1478,36 +2208,37 @@ 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,
+      ctx.reactRouterConfig.ssr,
+      routes
+    );
     return `
     import * as entryServer from ${JSON.stringify(
       resolveFileUrl(ctx, ctx.entryServerFilePath)
@@ -1522,7 +2253,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(
@@ -1532,7 +2263,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 = {
@@ -1570,7 +2303,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)
@@ -1586,13 +2321,31 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
-    for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
-      let routeFilePath = path6.join(
-        ctx.reactRouterConfig.appDirectory,
-        route.file
-      );
-      let sourceExports = routeManifestExports[key];
+    let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
+    for (let route of Object.values(ctx.reactRouterConfig.routes)) {
+      let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
+      let sourceExports = routeManifestExports[route.id];
       let isRootRoute = route.parentId === void 0;
+      let hasClientAction = sourceExports.includes("clientAction");
+      let hasClientLoader = sourceExports.includes("clientLoader");
+      let hasHydrateFallback = sourceExports.includes("HydrateFallback");
+      let { hasRouteChunkByExportName } = await detectRouteChunksIfEnabled(
+        cache,
+        ctx,
+        routeFile,
+        { routeFile, viteChildCompiler }
+      );
+      if (enforceSplitRouteModules) {
+        validateRouteChunks({
+          ctx,
+          id: route.file,
+          valid: {
+            clientAction: !hasClientAction || hasRouteChunkByExportName.clientAction,
+            clientLoader: !hasClientLoader || hasRouteChunkByExportName.clientLoader,
+            HydrateFallback: !hasHydrateFallback || hasRouteChunkByExportName.HydrateFallback
+          }
+        });
+      }
       let routeManifestEntry = {
         id: route.id,
         parentId: route.parentId,
@@ -1601,23 +2354,37 @@ var reactRouterVitePlugin = () => {
         caseSensitive: route.caseSensitive,
         hasAction: sourceExports.includes("action"),
         hasLoader: sourceExports.includes("loader"),
-        hasClientAction: sourceExports.includes("clientAction"),
-        hasClientLoader: sourceExports.includes("clientLoader"),
+        hasClientAction,
+        hasClientLoader,
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         ...getReactRouterManifestBuildAssets(
           ctx,
           viteManifest,
-          routeFilePath,
+          `${routeFile}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
           // If this is the root route, we also need to include assets from the
           // client entry file as this is a common way for consumers to import
           // global reset styles, etc.
           isRootRoute ? [ctx.entryClientFilePath] : []
-        )
+        ),
+        clientActionModule: hasRouteChunkByExportName.clientAction ? getPublicModulePathForEntry(
+          ctx,
+          viteManifest,
+          getRouteChunkModuleId(routeFile, "clientAction")
+        ) : void 0,
+        clientLoaderModule: hasRouteChunkByExportName.clientLoader ? getPublicModulePathForEntry(
+          ctx,
+          viteManifest,
+          getRouteChunkModuleId(routeFile, "clientLoader")
+        ) : void 0,
+        hydrateFallbackModule: hasRouteChunkByExportName.HydrateFallback ? getPublicModulePathForEntry(
+          ctx,
+          viteManifest,
+          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 };
@@ -1653,25 +2420,52 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
+    let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
     for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
+      let routeFile = route.file;
       let sourceExports = routeManifestExports[key];
+      let hasClientAction = sourceExports.includes("clientAction");
+      let hasClientLoader = sourceExports.includes("clientLoader");
+      let hasHydrateFallback = sourceExports.includes("HydrateFallback");
+      let routeModulePath = combineURLs(
+        ctx.publicPath,
+        `${resolveFileUrl(
+          ctx,
+          resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+        )}`
+      );
+      if (enforceSplitRouteModules) {
+        let { hasRouteChunkByExportName } = await detectRouteChunksIfEnabled(
+          cache,
+          ctx,
+          routeFile,
+          { routeFile, viteChildCompiler }
+        );
+        validateRouteChunks({
+          ctx,
+          id: route.file,
+          valid: {
+            clientAction: !hasClientAction || hasRouteChunkByExportName.clientAction,
+            clientLoader: !hasClientLoader || hasRouteChunkByExportName.clientLoader,
+            HydrateFallback: !hasHydrateFallback || hasRouteChunkByExportName.HydrateFallback
+          }
+        });
+      }
       routes[key] = {
         id: route.id,
         parentId: route.parentId,
         path: route.path,
         index: route.index,
         caseSensitive: route.caseSensitive,
-        module: combineURLs(
-          ctx.publicPath,
-          resolveFileUrl(
-            ctx,
-            resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
-          )
-        ),
+        module: routeModulePath,
+        // Split route modules are a build-time optimization
+        clientActionModule: void 0,
+        clientLoaderModule: void 0,
+        hydrateFallbackModule: void 0,
         hasAction: sourceExports.includes("action"),
         hasLoader: sourceExports.includes("loader"),
-        hasClientAction: sourceExports.includes("clientAction"),
-        hasClientLoader: sourceExports.includes("clientLoader"),
+        hasClientAction,
+        hasClientLoader,
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         imports: []
       };
@@ -1704,14 +2498,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]"
         });
@@ -1727,43 +2513,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 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);
-            }
-          }
-        };
+        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 ? [
@@ -1812,57 +2592,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,
-          // Vite config options for building
-          ...viteCommand === "build" ? {
+          ...ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? {
+            environments,
             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).map(
-                      (route) => `${path6.resolve(
-                        ctx.reactRouterConfig.appDirectory,
-                        route.file
-                      )}${BUILD_CLIENT_ROUTE_QUERY_STRING}`
-                    )
-                  ]
-                }
-              } : {
-                // 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
-                  }
-                }
+              // 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
+                });
               }
             }
-          } : 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 ?? (viteConfigEnv.isSsrBuild ? serverEnvironment.build : clientEnvironment.build)
+          }
         };
       },
       async configResolved(resolvedViteConfig) {
@@ -1878,8 +2642,7 @@ var reactRouterVitePlugin = () => {
         let childCompilerConfigFile = await vite2.loadConfigFromFile(
           {
             command: viteConfig.command,
-            mode: viteConfig.mode,
-            isSsrBuild: ctx.isSsrBuild
+            mode: viteConfig.mode
           },
           viteConfig.configFile
         );
@@ -2021,14 +2784,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 (!ctx.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 = 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 = [];
@@ -2062,7 +2826,7 @@ var reactRouterVitePlugin = () => {
               ].join("\n")
             );
           }
-          if (ctx.reactRouterConfig.prerender != null && ctx.reactRouterConfig.prerender !== false) {
+          if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
             await handlePrerender(
               viteConfig,
               ctx.reactRouterConfig,
@@ -2099,10 +2863,59 @@ var reactRouterVitePlugin = () => {
         await typegenWatcher?.close();
       }
     },
+    {
+      name: "react-router:route-chunks-index",
+      // This plugin provides the route module "index" since route modules can
+      // be chunked and may be made up of multiple smaller modules. This plugin
+      // primarily ensures code is never duplicated across a route module and
+      // its chunks. If we didn't have this plugin, any app that explicitly
+      // imports a route module would result in duplicate code since the app
+      // would contain code for both the unprocessed route module as well as its
+      // individual chunks. This is because, since they have different module
+      // IDs, they are treated as completely separate modules even though they
+      // all reference the same underlying file. This plugin addresses this by
+      // ensuring that any explicit imports of a route module resolve to a
+      // module that simply re-exports from its underlying chunks, if present.
+      async transform(code, id, options) {
+        if (viteCommand !== "build") return;
+        if (options?.ssr) {
+          return;
+        }
+        if (!isRoute(ctx.reactRouterConfig, id)) {
+          return;
+        }
+        if (isRouteVirtualModule(id)) {
+          return;
+        }
+        let { hasRouteChunks, chunkedExports } = await detectRouteChunksIfEnabled(cache, ctx, id, code);
+        if (!hasRouteChunks) {
+          return;
+        }
+        let sourceExports = await getRouteModuleExports(
+          viteChildCompiler,
+          ctx,
+          id
+        );
+        let isMainChunkExport = (name) => !chunkedExports.includes(name);
+        let mainChunkReexports = sourceExports.filter(isMainChunkExport).join(", ");
+        let chunkBasePath = `./${path6.basename(id)}`;
+        return [
+          `export { ${mainChunkReexports} } from "${getRouteChunkModuleId(
+            chunkBasePath,
+            "main"
+          )}";`,
+          ...chunkedExports.map(
+            (exportName) => `export { ${exportName} } from "${getRouteChunkModuleId(
+              chunkBasePath,
+              exportName
+            )}";`
+          )
+        ].filter(Boolean).join("\n");
+      }
+    },
     {
       name: "react-router:build-client-route",
-      enforce: "pre",
-      async transform(_code, id, options) {
+      async transform(code, id, options) {
         if (!id.endsWith(BUILD_CLIENT_ROUTE_QUERY_STRING)) return;
         let routeModuleId = id.replace(BUILD_CLIENT_ROUTE_QUERY_STRING, "");
         let routeFileName = path6.basename(routeModuleId);
@@ -2111,26 +2924,91 @@ var reactRouterVitePlugin = () => {
           ctx,
           routeModuleId
         );
-        let reexports = sourceExports.filter(
-          (exportName) => options?.ssr && SERVER_ONLY_ROUTE_EXPORTS.includes(exportName) || CLIENT_ROUTE_EXPORTS.includes(exportName)
-        ).join(", ");
+        let { chunkedExports = [] } = options?.ssr ? {} : await detectRouteChunksIfEnabled(cache, ctx, id, code);
+        let reexports = sourceExports.filter((exportName) => {
+          let isRouteEntryExport = options?.ssr && SERVER_ONLY_ROUTE_EXPORTS.includes(exportName) || CLIENT_ROUTE_EXPORTS.includes(exportName);
+          let isChunkedExport = chunkedExports.includes(
+            exportName
+          );
+          return isRouteEntryExport && !isChunkedExport;
+        }).join(", ");
         return `export { ${reexports} } from "./${routeFileName}";`;
       }
     },
+    {
+      name: "react-router:split-route-modules",
+      async transform(code, id, options) {
+        if (options?.ssr) return;
+        if (!isRouteChunkModuleId(id)) return;
+        invariant(
+          viteCommand === "build",
+          "Route modules are only split in build mode"
+        );
+        let chunkName = getRouteChunkNameFromModuleId(id);
+        if (!chunkName) {
+          throw new Error(`Invalid route chunk name "${chunkName}" in "${id}"`);
+        }
+        let chunk = await getRouteChunkIfEnabled(
+          cache,
+          ctx,
+          id,
+          chunkName,
+          code
+        );
+        let preventEmptyChunkSnippet = ({ reason }) => `Math.random()<0&&console.log(${JSON.stringify(reason)});`;
+        if (chunk === null) {
+          return preventEmptyChunkSnippet({
+            reason: "Split round modules disabled"
+          });
+        }
+        let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
+        if (enforceSplitRouteModules && chunkName === "main" && chunk) {
+          let exportNames = getExportNames(chunk.code);
+          validateRouteChunks({
+            ctx,
+            id,
+            valid: {
+              clientAction: !exportNames.includes("clientAction"),
+              clientLoader: !exportNames.includes("clientLoader"),
+              HydrateFallback: !exportNames.includes("HydrateFallback")
+            }
+          });
+        }
+        return chunk ?? preventEmptyChunkSnippet({ reason: `No ${chunkName} chunk` });
+      }
+    },
     {
       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();
+            if (!ctx.reactRouterConfig.ssr) {
+              invariant(viteConfig);
+              validateSsrFalsePrerenderExports(
+                viteConfig,
+                ctx,
+                reactRouterManifest,
+                viteChildCompiler
+              );
+            }
             return `export default ${(0, import_jsesc.default)(reactRouterManifest, {
               es6: true
             })};`;
@@ -2171,8 +3049,7 @@ var reactRouterVitePlugin = () => {
         let importerShort = vite2.normalizePath(
           path6.relative(ctx.rootDirectory, importer)
         );
-        let isRoute = getRoute(ctx.reactRouterConfig, importer);
-        if (isRoute) {
+        if (isRoute(ctx.reactRouterConfig, importer)) {
           let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(
             (xport) => `\`${xport}\``
           ).join(", ");
@@ -2211,10 +3088,10 @@ var reactRouterVitePlugin = () => {
         let clientFileRE = /\.client(\.[cm]?[jt]sx?)?$/;
         let clientDirRE = /\/\.client\//;
         if (clientFileRE.test(id) || clientDirRE.test(id)) {
-          let exports2 = (0, import_es_module_lexer.parse)(code)[1];
+          let exports2 = getExportNames(code);
           return {
             code: exports2.map(
-              ({ n: name }) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`
+              (name) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`
             ).join("\n"),
             map: null
           };
@@ -2225,19 +3102,30 @@ var reactRouterVitePlugin = () => {
     {
       name: "react-router:route-exports",
       async transform(code, id, options) {
+        if (isRouteChunkModuleId(id)) {
+          id = id.split("?")[0];
+        }
         let route = getRoute(ctx.reactRouterConfig, id);
         if (!route) return;
-        if (!options?.ssr && !ctx.reactRouterConfig.ssr) {
-          let serverOnlyExports = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).filter((exp) => SERVER_ONLY_ROUTE_EXPORTS.includes(exp));
+        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);
+          });
           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") {
-            let hasHydrateFallback = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).some((exp) => exp === "HydrateFallback");
+            let hasHydrateFallback = exportNames.some(
+              (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);
             }
           }
@@ -2248,7 +3136,7 @@ var reactRouterVitePlugin = () => {
           removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
         }
         transform(ast);
-        return generate2(ast, {
+        return generate(ast, {
           sourceMaps: true,
           filename: id,
           sourceFileName: filepath
@@ -2313,6 +3201,9 @@ var reactRouterVitePlugin = () => {
         let isJSX = filepath.endsWith("x");
         let useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
         if (!useFastRefresh) return;
+        if (isRouteVirtualModule(id)) {
+          return { code: addRefreshWrapper(ctx.reactRouterConfig, code, id) };
+        }
         let result = await babel.transformAsync(code, {
           babelrc: false,
           configFile: false,
@@ -2343,6 +3234,7 @@ var reactRouterVitePlugin = () => {
           let serverManifest = (await server.ssrLoadModule(virtual.serverManifest.id)).default;
           let oldRouteMetadata = serverManifest.routes[route.id];
           let newRouteMetadata = await getRouteMetadata(
+            cache,
             ctx,
             viteChildCompiler,
             route,
@@ -2352,9 +3244,12 @@ var reactRouterVitePlugin = () => {
           if (!oldRouteMetadata || [
             "hasLoader",
             "hasClientLoader",
+            "clientLoaderModule",
             "hasAction",
             "hasClientAction",
-            "hasErrorBoundary"
+            "clientActionModule",
+            "hasErrorBoundary",
+            "hydrateFallbackModule"
           ].some((key) => oldRouteMetadata[key] !== newRouteMetadata[key])) {
             invalidateVirtualModules(server);
           }
@@ -2472,13 +3367,30 @@ function getRoute(pluginConfig, file) {
   );
   return route;
 }
-async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
+function isRoute(pluginConfig, file) {
+  return Boolean(getRoute(pluginConfig, file));
+}
+async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteFile) {
+  let routeFile = route.file;
   let sourceExports = await getRouteModuleExports(
     viteChildCompiler,
     ctx,
     route.file,
     readRouteFile
   );
+  let { hasRouteChunkByExportName } = await detectRouteChunksIfEnabled(
+    cache,
+    ctx,
+    routeFile,
+    { routeFile, readRouteFile, viteChildCompiler }
+  );
+  let moduleUrl = combineURLs(
+    ctx.publicPath,
+    `${resolveFileUrl(
+      ctx,
+      resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+    )}`
+  );
   let info = {
     id: route.id,
     parentId: route.parentId,
@@ -2492,14 +3404,11 @@ async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
         resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
       )
     ),
-    module: combineURLs(
-      ctx.publicPath,
-      `${resolveFileUrl(
-        ctx,
-        resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
-      )}?import`
-    ),
+    module: `${moduleUrl}?import`,
     // Ensure the Vite dev server responds with a JS module
+    clientActionModule: hasRouteChunkByExportName.clientAction ? `${getRouteChunkModuleId(moduleUrl, "clientAction")}` : void 0,
+    clientLoaderModule: hasRouteChunkByExportName.clientLoader ? `${getRouteChunkModuleId(moduleUrl, "clientLoader")}` : void 0,
+    hydrateFallbackModule: hasRouteChunkByExportName.HydrateFallback ? `${getRouteChunkModuleId(moduleUrl, "HydrateFallback")}` : void 0,
     hasAction: sourceExports.includes("action"),
     hasClientAction: sourceExports.includes("clientAction"),
     hasLoader: sourceExports.includes("loader"),
@@ -2509,6 +3418,12 @@ async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
   };
   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());
@@ -2519,20 +3434,49 @@ 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);
+  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)}`);
+  }
 }
 async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, serverBuildPath, clientBuildDirectory) {
   let { build, handler } = await getPrerenderBuildAndHandler(
@@ -2541,53 +3485,62 @@ 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 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);
-    let data;
-    if (hasLoaders) {
-      data = await prerenderData(
-        handler,
-        path7,
-        clientBuildDirectory,
-        reactRouterConfig,
-        viteConfig,
-        { headers }
-      );
-    }
+    invariant(
+      matches,
+      `Unable to prerender path because it does not match any routes: ${path7}`
+    );
     let leafRoute = matches ? matches[matches.length - 1].route : null;
     let manifestRoute = leafRoute ? build.routes[leafRoute.id]?.module : null;
-    let isResourceRoute = manifestRoute && !manifestRoute.default && !manifestRoute.ErrorBoundary && manifestRoute.loader;
+    let isResourceRoute = manifestRoute && !manifestRoute.default && !manifestRoute.ErrorBoundary;
     if (isResourceRoute) {
-      await prerenderResourceRoute(
-        handler,
-        path7,
-        clientBuildDirectory,
-        reactRouterConfig,
-        viteConfig,
-        { headers }
-      );
+      invariant(leafRoute);
+      invariant(manifestRoute);
+      if (manifestRoute.loader) {
+        await prerenderData(
+          handler,
+          path7,
+          [leafRoute.id],
+          clientBuildDirectory,
+          reactRouterConfig,
+          viteConfig,
+          { headers }
+        );
+        await prerenderResourceRoute(
+          handler,
+          path7,
+          clientBuildDirectory,
+          reactRouterConfig,
+          viteConfig,
+          { headers }
+        );
+      } else {
+        viteConfig.logger.warn(
+          `\u26A0\uFE0F Skipping prerendering for resource route without a loader: ${leafRoute?.id}`
+        );
+      }
     } else {
+      let hasLoaders = matches.some(
+        (m) => build.assets.routes[m.route.id]?.hasLoader
+      );
+      let data;
+      if (!isResourceRoute && hasLoaders) {
+        data = await prerenderData(
+          handler,
+          path7,
+          null,
+          clientBuildDirectory,
+          reactRouterConfig,
+          viteConfig,
+          { headers }
+        );
+      }
       await prerenderRoute(
         handler,
         path7,
@@ -2603,14 +3556,8 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       );
     }
   }
-  await prerenderManifest(
-    build,
-    clientBuildDirectory,
-    reactRouterConfig,
-    viteConfig
-  );
 }
-function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = false) {
+function getStaticPrerenderPaths(routes) {
   let paths = ["/"];
   let paramRoutes = [];
   function recurse(subtree, prefix = "") {
@@ -2630,28 +3577,33 @@ 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) {
+async function prerenderData(handler, prerenderPath, onlyRoutes, 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 url2 = new URL(`http://localhost${normalizedPath}`);
+  if (onlyRoutes?.length) {
+    url2.searchParams.set("_routes", onlyRoutes.join(","));
+  }
+  let request = new Request(url2, requestInit);
   let response = await handler(request);
   let data = await response.text();
-  validatePrerenderedResponse(response, data, "Prerender", normalizedPath);
+  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}`
+    );
+  }
   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) {
@@ -2662,54 +3614,65 @@ 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 (html): 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 (html): ${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 (resource): 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 (resource): ${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}`
-    );
-  }
-}
-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 />\`.`
-    );
+async function getPrerenderPaths(prerender, ssr, routes, logWarning = false) {
+  let prerenderPaths = [];
+  if (prerender != null && prerender !== false) {
+    let prerenderRoutes = createPrerenderRoutes(routes);
+    if (prerender === true) {
+      let { paths, paramRoutes } = getStaticPrerenderPaths(prerenderRoutes);
+      if (logWarning && !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 || ["/"];
+    }
   }
+  return prerenderPaths;
 }
 function groupRoutesByParentId2(manifest) {
   let routes = {};
@@ -2727,24 +3690,445 @@ 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,
-      loader: route.module.loader ? () => null : void 0,
-      action: void 0,
-      handle: route.module.handle
+      path: route.path
     };
-    return route.index ? {
-      index: true,
-      ...commonRoute
-    } : {
-      caseSensitive: route.caseSensitive,
+    if (route.index) {
+      return {
+        index: true,
+        ...commonRoute
+      };
+    }
+    return {
       children: createPrerenderRoutes(manifest, route.id, routesByParentId),
       ...commonRoute
     };
   });
 }
+async function validateSsrFalsePrerenderExports(viteConfig, ctx, manifest, viteChildCompiler) {
+  let prerenderPaths = await getPrerenderPaths(
+    ctx.reactRouterConfig.prerender,
+    ctx.reactRouterConfig.ssr,
+    manifest.routes,
+    true
+  );
+  if (prerenderPaths.length === 0) {
+    return;
+  }
+  let prerenderRoutes = createPrerenderRoutes(manifest.routes);
+  let prerenderedRoutes = /* @__PURE__ */ new Set();
+  for (let path7 of prerenderPaths) {
+    let matches = (0, import_react_router2.matchRoutes)(
+      prerenderRoutes,
+      `/${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 errors = [];
+  let routeExports = await getRouteManifestModuleExports(
+    viteChildCompiler,
+    ctx
+  );
+  for (let [routeId, route] of Object.entries(manifest.routes)) {
+    let invalidApis = [];
+    invariant(route, "Expected a route object in validateSsrFalseExports");
+    let exports2 = routeExports[route.id];
+    if (exports2.includes("headers")) invalidApis.push("headers");
+    if (exports2.includes("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/pre-rendering for more information.`
+      );
+    }
+    if (exports2.includes("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/pre-rendering for more information.`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    viteConfig.logger.error(import_picocolors3.default.red(errors.join("\n")));
+    throw new Error(
+      "Invalid route exports found when prerendering with `ssr:false`"
+    );
+  }
+}
+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;
+  invariant(input.viteChildCompiler);
+  return await compileRouteFile(
+    input.viteChildCompiler,
+    ctx,
+    input.routeFile,
+    input.readRouteFile
+  );
+};
+async function detectRouteChunksIfEnabled(cache, ctx, id, input) {
+  function noRouteChunks() {
+    return {
+      chunkedExports: [],
+      hasRouteChunks: false,
+      hasRouteChunkByExportName: {
+        clientAction: false,
+        clientLoader: false,
+        HydrateFallback: false
+      }
+    };
+  }
+  if (!ctx.reactRouterConfig.future.unstable_splitRouteModules) {
+    return noRouteChunks();
+  }
+  if (normalizeRelativeFilePath(id, ctx.reactRouterConfig) === ctx.reactRouterConfig.routes.root.file) {
+    return noRouteChunks();
+  }
+  let code = await resolveRouteFileCode(ctx, input);
+  if (!routeChunkExportNames.some((exportName) => code.includes(exportName))) {
+    return noRouteChunks();
+  }
+  let cacheKey = normalizeRelativeFilePath(id, ctx.reactRouterConfig) + (typeof input === "string" ? "" : "?read");
+  return detectRouteChunks(code, cache, cacheKey);
+}
+async function getRouteChunkIfEnabled(cache, ctx, id, chunkName, input) {
+  if (!ctx.reactRouterConfig.future.unstable_splitRouteModules) {
+    return null;
+  }
+  let code = await resolveRouteFileCode(ctx, input);
+  let cacheKey = normalizeRelativeFilePath(id, ctx.reactRouterConfig) + (typeof input === "string" ? "" : "?read");
+  return getRouteChunkCode(code, chunkName, cache, cacheKey);
+}
+function validateRouteChunks({
+  ctx,
+  id,
+  valid
+}) {
+  let invalidChunks = Object.entries(valid).filter(([_, isValid]) => !isValid).map(([chunkName]) => chunkName);
+  if (invalidChunks.length === 0) {
+    return;
+  }
+  let plural = invalidChunks.length > 1;
+  throw new Error(
+    [
+      `Error splitting route module: ${normalizeRelativeFilePath(
+        id,
+        ctx.reactRouterConfig
+      )}`,
+      invalidChunks.map((name) => `- ${name}`).join("\n"),
+      `${plural ? "These exports" : "This export"} could not be split into ${plural ? "their own chunks" : "its own chunk"} because ${plural ? "they share" : "it shares"} code with other exports. You should extract any shared code into its own module and then import it within the route module.`
+    ].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) {
+    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 mergeEnvironmentOptions(base, ...overrides) {
+  let vite2 = getVite();
+  return overrides.reduce(
+    (merged, override) => vite2.mergeConfig(merged, override, false),
+    base
+  );
+}
+async function getEnvironmentOptionsResolvers(ctx, buildManifest, viteCommand) {
+  let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
+  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 {
+      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 getBaseServerOptions({
+    viteUserConfig
+  }) {
+    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 }) => 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);
+              }
+            )
+          ],
+          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)
+    )) {
+      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(
+                routes
+              ).join(",")}`
+            }
+          }
+        },
+        // Ensure server bundle environments extend the user's SSR
+        // environment config if it exists
+        viteUserConfig.environments?.ssr ?? {}
+      );
+    }
+  } else {
+    environmentOptionsResolvers.ssr = ({ viteUserConfig }) => mergeEnvironmentOptions(getBaseServerOptions({ viteUserConfig }), {
+      build: {
+        outDir: getServerBuildDirectory(ctx),
+        rollupOptions: {
+          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual.serverBuild.id
+        }
+      }
+    });
+  }
+  return environmentOptionsResolvers;
+}
+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,
+    viteCommand
+  );
+  return resolveEnvironmentsOptions(
+    environmentOptionsResolvers,
+    resolverOptions
+  );
+}
+function isNonNullable(x) {
+  return x != null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   reactRouter