@react-router/dev 0.0.0-experimental-345f1da12 → 0.0.0-experimental-d312c78a4

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-345f1da12
+ * @react-router/dev v0.0.0-experimental-d312c78a4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -57,8 +57,7 @@ var import_picocolors3 = __toESM(require("picocolors"));
 
 // typegen/index.ts
 var import_node_fs2 = __toESM(require("fs"));
-var import_dedent2 = __toESM(require("dedent"));
-var Path3 = __toESM(require("pathe"));
+var Path4 = __toESM(require("pathe"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
 // config/config.ts
@@ -372,6 +371,7 @@ async function resolveConfig({
     basename: basename2,
     buildDirectory: userBuildDirectory,
     buildEnd,
+    future: userFuture,
     prerender,
     serverBuildFile,
     serverBundles,
@@ -444,7 +444,8 @@ async function resolveConfig({
     );
   }
   let future = {
-    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false,
+    unstable_routeChunks: userFuture?.unstable_routeChunks ?? false
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
@@ -625,54 +626,125 @@ function findEntry(dir, basename2, options) {
 
 // typegen/generate.ts
 var import_dedent = __toESM(require("dedent"));
-function generate(route) {
+var Path3 = __toESM(require("pathe"));
+var Pathe2 = __toESM(require("pathe/utils"));
+
+// typegen/paths.ts
+var Path2 = __toESM(require("pathe"));
+var Pathe = __toESM(require("pathe/utils"));
+function getTypesDir(ctx) {
+  return Path2.join(ctx.rootDirectory, ".react-router/types");
+}
+function getTypesPath(ctx, route) {
+  return Path2.join(
+    getTypesDir(ctx),
+    Path2.relative(ctx.rootDirectory, ctx.config.appDirectory),
+    Path2.dirname(route.file),
+    "+types/" + Pathe.filename(route.file) + ".ts"
+  );
+}
+
+// typegen/generate.ts
+function generate(ctx, route) {
+  const lineage = getRouteLineage(ctx.config.routes, route);
+  const urlpath = lineage.map((route2) => route2.path).join("/");
+  const typesPath = getTypesPath(ctx, route);
+  const parents = lineage.slice(0, -1);
+  const parentTypeImports = parents.map((parent, i) => {
+    const rel = Path3.relative(
+      Path3.dirname(typesPath),
+      getTypesPath(ctx, parent)
+    );
+    const indent = i === 0 ? "" : "  ".repeat(2);
+    let source = noExtension(rel);
+    if (!source.startsWith("../")) source = "./" + source;
+    return `${indent}import type { Info as Parent${i} } from "${source}.js"`;
+  }).join("\n");
   return import_dedent.default`
     // React Router generated types for route:
     // ${route.file}
 
-    import type { RouteExports, Routes } from "react-router/types";
+    import type * as T from "react-router/route-module"
+
+    ${parentTypeImports}
 
-    type RouteId = "${route.id}"
-    export type Info = Routes[RouteId];
+    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
 
-    type Exports = RouteExports[RouteId];
+    export type Info = {
+      parents: [${parents.map((_, i) => `Parent${i}`).join(", ")}],
+      id: "${route.id}"
+      file: "${route.file}"
+      path: "${route.path}"
+      params: {${formatParamProperties(
+    urlpath
+  )}} & { [key: string]: string | undefined }
+      module: Module
+      loaderData: T.CreateLoaderData<Module>
+      actionData: T.CreateActionData<Module>
+    }
 
     export namespace Route {
-      export type LinkDescriptors = Exports["links"]["return"];
-      export type LinksFunction = () => LinkDescriptors;
+      export type LinkDescriptors = T.LinkDescriptors
+      export type LinksFunction = () => LinkDescriptors
 
-      export type MetaArgs = Exports["meta"]["args"];
-      export type MetaDescriptors = Exports["meta"]["return"];
-      export type MetaFunction = (args: MetaArgs) => MetaDescriptors;
+      export type MetaArgs = T.CreateMetaArgs<Info>
+      export type MetaDescriptors = T.MetaDescriptors
+      export type MetaFunction = (args: MetaArgs) => MetaDescriptors
 
-      export type HeadersArgs = Exports["headers"]["args"];
-      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit;
+      export type HeadersArgs = T.HeadersArgs
+      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
 
-      export type LoaderArgs = Exports["loader"]["args"];
-      export type ClientLoaderArgs = Exports["clientLoader"]["args"];
-      export type ActionArgs = Exports["action"]["args"];
-      export type ClientActionArgs = Exports["clientAction"]["args"];
+      export type LoaderArgs = T.CreateServerLoaderArgs<Info>
+      export type ClientLoaderArgs = T.CreateClientLoaderArgs<Info>
+      export type ActionArgs = T.CreateServerActionArgs<Info>
+      export type ClientActionArgs = T.CreateClientActionArgs<Info>
 
-      export type HydrateFallbackProps = Exports["HydrateFallback"]["args"];
-      export type ComponentProps = Exports["default"]["args"];
-      export type ErrorBoundaryProps = Exports["ErrorBoundary"]["args"];
+      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
+      export type ComponentProps = T.CreateComponentProps<Info>
+      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
     }
   `;
 }
-
-// typegen/paths.ts
-var Path2 = __toESM(require("pathe"));
-var Pathe = __toESM(require("pathe/utils"));
-function getTypesDir(ctx) {
-  return Path2.join(ctx.rootDirectory, ".react-router/types");
+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 getTypesPath(ctx, route) {
-  return Path2.join(
-    getTypesDir(ctx),
-    Path2.relative(ctx.rootDirectory, ctx.config.appDirectory),
-    Path2.dirname(route.file),
-    "+types/" + Pathe.filename(route.file) + ".ts"
-  );
+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(", ")}]`;
+  });
+  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
@@ -714,93 +786,16 @@ async function createContext2({
     config
   };
 }
-function asJS(path7) {
-  return path7.replace(/\.(js|ts)x?$/, ".js");
-}
-function formatRoute({ id, path: path7, file, parentId }) {
-  return [
-    `"${id}": {`,
-    `  parentId: ${JSON.stringify(parentId)}`,
-    `  path: ${JSON.stringify(path7)}`,
-    `  module: typeof import("./app/${asJS(file)}")`,
-    `}`
-  ].map((line) => `  ${line}`).join("\n");
-}
 async function writeAll(ctx) {
-  let routes = Object.values(ctx.config.routes);
-  let pathsToParams = /* @__PURE__ */ new Map();
-  for (let route of routes) {
-    if (route.path === void 0) continue;
-    let lineage = getRouteLineage(ctx.config.routes, route);
-    let path7 = lineage.filter((route2) => route2.path !== void 0).map((route2) => route2.path).join("/");
-    if (path7 === "") path7 = "/";
-    pathsToParams.set(path7, parseParams(path7));
-  }
-  let formattedPaths = `type Paths = {`;
-  for (let [path7, params] of pathsToParams.entries()) {
-    let formattedParams = Object.entries(params).map(
-      ([param, required]) => `"${param}"${required ? "" : "?"}: string`
-    );
-    let formattedEntry = `"${path7}": {${formattedParams.join(",")}},
-`;
-    formattedPaths += formattedEntry;
-  }
-  formattedPaths += `}`;
   const typegenDir = getTypesDir(ctx);
   import_node_fs2.default.rmSync(typegenDir, { recursive: true, force: true });
-  const newTypes = Path3.join(typegenDir, "routes.ts");
-  import_node_fs2.default.mkdirSync(Path3.dirname(newTypes), { recursive: true });
-  import_node_fs2.default.writeFileSync(
-    newTypes,
-    formattedPaths + `
-
-type Routes = {
-${routes.map(formatRoute).join("\n")}
-}
-
-` + import_dedent2.default`
-        declare module "react-router/types" {
-          interface Register {
-            paths: Paths
-            routes: Routes
-          }
-        }
-
-        export {}
-    `
-  );
   Object.values(ctx.config.routes).forEach((route) => {
     const typesPath = getTypesPath(ctx, route);
-    const content = generate(route);
-    import_node_fs2.default.mkdirSync(Path3.dirname(typesPath), { recursive: true });
+    const content = generate(ctx, route);
+    import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
     import_node_fs2.default.writeFileSync(typesPath, content);
   });
 }
-function getRouteLineage(routes, route) {
-  const result = [];
-  while (route) {
-    result.push(route);
-    if (!route.parentId) break;
-    route = routes[route.parentId];
-  }
-  result.reverse();
-  return result;
-}
-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 isRequired = match[2] === void 0;
-    result[param] ||= isRequired;
-    return;
-  });
-  const hasSplat = segments.at(-1) === "*";
-  if (hasSplat) result["*"] = true;
-  return result;
-}
 
 // vite/babel.ts
 var import_parser = require("@babel/parser");
@@ -1166,8 +1161,609 @@ 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 isWithinExportNamedDeclaration = Boolean(
+            identifier.findParent((path7) => path7.isExportNamedDeclaration())
+          );
+          if (isWithinExportNamedDeclaration) {
+            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_dedent3 = __toESM(require("dedent"));
+var import_dedent2 = __toESM(require("dedent"));
 var vmod = create("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
@@ -1178,7 +1774,7 @@ var plugin = {
   },
   async load(id) {
     if (id !== vmod.resolvedId) return;
-    return import_dedent3.default`
+    return import_dedent2.default`
       import { createElement as h } from "react";
       import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
 
@@ -1305,8 +1901,20 @@ var CLIENT_ROUTE_EXPORTS = [
   "shouldRevalidate"
 ];
 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;
@@ -1335,23 +1943,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}`,
@@ -1388,6 +2008,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]) => {
@@ -1401,7 +2025,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");
   }
@@ -1421,9 +2045,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) {
@@ -1443,7 +2077,7 @@ var defaultEntriesDir = path6.resolve(
   "config",
   "defaults"
 );
-var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path6.join(defaultEntriesDir, filename2));
+var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path6.join(defaultEntriesDir, filename3));
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => ({});
 var reactRouterVitePlugin = () => {
@@ -1454,6 +2088,7 @@ var reactRouterVitePlugin = () => {
   let viteConfig;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
+  let cache = /* @__PURE__ */ new Map();
   let reactRouterConfigLoader;
   let typegenWatcherPromise;
   let logger;
@@ -1593,13 +2228,31 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
+    let enforceRouteChunks = ctx.reactRouterConfig.future.unstable_routeChunks === "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 (enforceRouteChunks) {
+        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,
@@ -1608,18 +2261,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;
@@ -1660,25 +2328,52 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
+    let enforceRouteChunks = ctx.reactRouterConfig.future.unstable_routeChunks === "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 (enforceRouteChunks) {
+        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,
+        // Route chunks 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: []
       };
@@ -1826,12 +2521,28 @@ var reactRouterVitePlugin = () => {
                   preserveEntrySignatures: "exports-only",
                   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}`,
+                        ...!isRootRoute ? routeChunkExportNames.map(
+                          (exportName) => code.includes(exportName) ? getRouteChunkModuleId(
+                            routeFilePath,
+                            exportName
+                          ) : null
+                        ) : []
+                      ].filter(isNonNullable);
+                    })
                   ]
                 }
               } : {
@@ -2099,10 +2810,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,12 +2871,53 @@ 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:route-chunks",
+      async transform(code, id, options) {
+        if (options?.ssr) return;
+        if (!isRouteChunkModuleId(id)) return;
+        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: "Route chunks disabled" });
+        }
+        let enforceRouteChunks = ctx.reactRouterConfig.future.unstable_routeChunks === "enforce";
+        if (enforceRouteChunks && 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",
@@ -2171,8 +2972,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 +3011,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,14 +3028,19 @@ var reactRouterVitePlugin = () => {
         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));
+          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);
@@ -2313,6 +3118,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 +3151,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 +3161,12 @@ var reactRouterVitePlugin = () => {
           if (!oldRouteMetadata || [
             "hasLoader",
             "hasClientLoader",
+            "clientLoaderModule",
             "hasAction",
             "hasClientAction",
-            "hasErrorBoundary"
+            "clientActionModule",
+            "hasErrorBoundary",
+            "hydrateFallbackModule"
           ].some((key) => oldRouteMetadata[key] !== newRouteMetadata[key])) {
             invalidateVirtualModules(server);
           }
@@ -2472,13 +3284,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 +3321,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"),
@@ -2748,6 +3574,74 @@ 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_routeChunks) {
+    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_routeChunks) {
+    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(
+    [
+      `Route chunks error: ${normalizeRelativeFilePath(
+        id,
+        ctx.reactRouterConfig
+      )}`,
+      invalidChunks.map((name) => `- ${name}`).join("\n"),
+      `${plural ? `These exports were` : `This export was`} unable to be split into ${plural ? "their own chunks" : "its own chunk"} because ${plural ? "they reference" : "it references"} code in the same file that is used by other route module exports.`,
+      `If you need to share code between ${plural ? `these` : `this`} and other exports, you should extract the shared code into a separate module.`
+    ].join("\n\n")
+  );
+}
+function isNonNullable(x) {
+  return x != null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   reactRouter