@react-router/dev 0.0.0-experimental-beaa4f52a → 0.0.0-experimental-a383e1e6e

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-beaa4f52a
+ * @react-router/dev v0.0.0-experimental-a383e1e6e
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -54,6 +54,7 @@ var import_react_router2 = require("react-router");
 var import_es_module_lexer = require("es-module-lexer");
 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"));
@@ -443,7 +444,8 @@ 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
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
@@ -692,8 +694,8 @@ function generate(ctx, route) {
       export type HeadersArgs = T.HeadersArgs
       export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
 
-      export type MiddlewareArgs = T.CreateServerMiddlewareArgs<Info>
-      export type ClientMiddlewareArgs = T.CreateClientMiddlewareArgs<Info>
+      export type unstable_MiddlewareArgs = T.CreateServerMiddlewareArgs<Info>
+      export type unstable_ClientMiddlewareArgs = T.CreateClientMiddlewareArgs<Info>
       export type LoaderArgs = T.CreateServerLoaderArgs<Info>
       export type ClientLoaderArgs = T.CreateClientLoaderArgs<Info>
       export type ActionArgs = T.CreateServerActionArgs<Info>
@@ -1161,6 +1163,611 @@ 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 generate2(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 generate2(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 vmod = create("with-props");
@@ -1286,23 +1893,43 @@ function toFunctionExpression(decl) {
 }
 
 // vite/plugin.ts
-var SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "middleware", "headers"];
-var CLIENT_ROUTE_EXPORTS = [
+var SERVER_ONLY_ROUTE_EXPORTS = [
+  "loader",
+  "action",
+  "unstable_middleware",
+  "headers"
+];
+var CLIENT_ONLY_NON_COMPONENT_EXPORTS = [
   "clientAction",
   "clientLoader",
-  "clientMiddleware",
-  "default",
-  "ErrorBoundary",
+  "unstable_clientMiddleware",
   "handle",
-  "HydrateFallback",
-  "Layout",
-  "links",
   "meta",
+  "links",
   "shouldRevalidate"
 ];
+var CLIENT_ROUTE_EXPORTS = [
+  ...CLIENT_ONLY_NON_COMPONENT_EXPORTS,
+  "default",
+  "ErrorBoundary",
+  "HydrateFallback",
+  "Layout"
+];
 var BUILD_CLIENT_ROUTE_QUERY_STRING = "?__react-router-build-client-route";
+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;
@@ -1331,23 +1958,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}`,
@@ -1384,6 +2023,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]) => {
@@ -1397,7 +2040,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");
   }
@@ -1417,9 +2060,19 @@ 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 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 getServerBundleBuildConfig = (viteUserConfig) => {
   if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
@@ -1450,6 +2103,7 @@ var reactRouterVitePlugin = () => {
   let viteConfig;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
+  let cache = /* @__PURE__ */ new Map();
   let reactRouterConfigLoader;
   let typegenWatcherPromise;
   let logger;
@@ -1535,7 +2189,8 @@ 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 publicPath = ${JSON.stringify(ctx.publicPath)};
       export const entry = { module: entryServer };
       export const routes = {
@@ -1589,13 +2244,31 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
+    let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
     for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
-      let routeFilePath = path6.join(
-        ctx.reactRouterConfig.appDirectory,
-        route.file
-      );
+      let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
       let sourceExports = routeManifestExports[key];
       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,
@@ -1604,18 +2277,33 @@ 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;
@@ -1656,25 +2344,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: []
       };
@@ -1825,14 +2540,40 @@ var reactRouterVitePlugin = () => {
                 rollupOptions: {
                   ...baseRollupOptions,
                   preserveEntrySignatures: "exports-only",
+                  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`;
+                    }
+                  },
                   input: [
                     ctx.entryClientFilePath,
-                    ...Object.values(ctx.reactRouterConfig.routes).map(
-                      (route) => `${path6.resolve(
+                    ...Object.values(
+                      ctx.reactRouterConfig.routes
+                    ).flatMap((route) => {
+                      let routeFilePath = path6.resolve(
                         ctx.reactRouterConfig.appDirectory,
                         route.file
-                      )}${BUILD_CLIENT_ROUTE_QUERY_STRING}`
-                    )
+                      );
+                      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);
+                    })
                   ]
                 }
               } : {
@@ -2102,10 +2843,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);
@@ -2114,12 +2904,59 @@ 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",
@@ -2174,8 +3011,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(", ");
@@ -2214,10 +3050,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
           };
@@ -2228,17 +3064,25 @@ 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) => 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.`;
             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.`;
               throw Error(message);
@@ -2316,6 +3160,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,
@@ -2346,6 +3193,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,
@@ -2355,9 +3203,12 @@ var reactRouterVitePlugin = () => {
           if (!oldRouteMetadata || [
             "hasLoader",
             "hasClientLoader",
+            "clientLoaderModule",
             "hasAction",
             "hasClientAction",
-            "hasErrorBoundary"
+            "clientActionModule",
+            "hasErrorBoundary",
+            "hydrateFallbackModule"
           ].some((key) => oldRouteMetadata[key] !== newRouteMetadata[key])) {
             invalidateVirtualModules(server);
           }
@@ -2420,15 +3271,7 @@ function uniqueNodes(nodes) {
 }
 function addRefreshWrapper(reactRouterConfig, code, id) {
   let route = getRoute(reactRouterConfig, id);
-  let acceptExports = route ? [
-    "clientAction",
-    "clientLoader",
-    "clientMiddleware",
-    "handle",
-    "meta",
-    "links",
-    "shouldRevalidate"
-  ] : [];
+  let acceptExports = route ? CLIENT_ONLY_NON_COMPONENT_EXPORTS : [];
   return REACT_REFRESH_HEADER.replaceAll("__SOURCE__", JSON.stringify(id)) + code + REACT_REFRESH_FOOTER.replaceAll("__SOURCE__", JSON.stringify(id)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(route?.id));
 }
 var REACT_REFRESH_HEADER = `
@@ -2476,13 +3319,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,
@@ -2496,14 +3356,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"),
@@ -2513,6 +3370,9 @@ async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
   };
   return info;
 }
+function isSpaModeEnabled(reactRouterConfig) {
+  return reactRouterConfig.ssr === false && (reactRouterConfig.prerender == null || reactRouterConfig.prerender === false || Array.isArray(reactRouterConfig.prerender) && reactRouterConfig.prerender.length === 1 && reactRouterConfig.prerender[0] === "/");
+}
 async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, serverBuildFile) {
   let serverBuildPath = path6.join(serverBuildDirectory, serverBuildFile);
   let build = await import(url.pathToFileURL(serverBuildPath).toString());
@@ -2607,12 +3467,6 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       );
     }
   }
-  await prerenderManifest(
-    build,
-    clientBuildDirectory,
-    reactRouterConfig,
-    viteConfig
-  );
 }
 function determineStaticPrerenderRoutes(routes, viteConfig, isBooleanUsage = false) {
   let paths = ["/"];
@@ -2688,18 +3542,6 @@ async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirecto
   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,
-    "/"
-  );
-  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(
@@ -2751,6 +3593,73 @@ function createPrerenderRoutes(manifest, parentId = "", routesByParentId = group
     };
   });
 }
+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")
+  );
+}
+function isNonNullable(x) {
+  return x != null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   reactRouter