@react-router/dev 0.0.0-experimental-df6bc686c → 0.0.0-experimental-759a11a62

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-df6bc686c
+ * @react-router/dev v0.0.0-experimental-759a11a62
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -57,7 +57,8 @@ var import_picocolors3 = __toESM(require("picocolors"));
 
 // typegen/index.ts
 var import_node_fs2 = __toESM(require("fs"));
-var Path4 = __toESM(require("pathe"));
+var import_dedent2 = __toESM(require("dedent"));
+var Path3 = __toESM(require("pathe"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
 // config/config.ts
@@ -371,7 +372,6 @@ async function resolveConfig({
     basename: basename2,
     buildDirectory: userBuildDirectory,
     buildEnd,
-    future: userFuture,
     prerender,
     serverBuildFile,
     serverBundles,
@@ -444,8 +444,7 @@ async function resolveConfig({
     );
   }
   let future = {
-    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false,
-    unstable_splitRouteModules: userFuture?.unstable_splitRouteModules ?? false
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
@@ -626,125 +625,54 @@ function findEntry(dir, basename2, options) {
 
 // typegen/generate.ts
 var import_dedent = __toESM(require("dedent"));
-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");
+function generate(route) {
   return import_dedent.default`
     // React Router generated types for route:
     // ${route.file}
 
-    import type * as T from "react-router/route-module"
-
-    ${parentTypeImports}
+    import type { RouteExports, Routes } from "react-router/types";
 
-    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
+    type RouteId = "${route.id}"
+    export type Info = Routes[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>
-    }
+    type Exports = RouteExports[RouteId];
 
     export namespace Route {
-      export type LinkDescriptors = T.LinkDescriptors
-      export type LinksFunction = () => LinkDescriptors
+      export type LinkDescriptors = Exports["links"]["return"];
+      export type LinksFunction = () => LinkDescriptors;
 
-      export type MetaArgs = T.CreateMetaArgs<Info>
-      export type MetaDescriptors = T.MetaDescriptors
-      export type MetaFunction = (args: MetaArgs) => MetaDescriptors
+      export type MetaArgs = Exports["meta"]["args"];
+      export type MetaDescriptors = Exports["meta"]["return"];
+      export type MetaFunction = (args: MetaArgs) => MetaDescriptors;
 
-      export type HeadersArgs = T.HeadersArgs
-      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
+      export type HeadersArgs = Exports["headers"]["args"];
+      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit;
 
-      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 LoaderArgs = Exports["loader"]["args"];
+      export type ClientLoaderArgs = Exports["clientLoader"]["args"];
+      export type ActionArgs = Exports["action"]["args"];
+      export type ClientActionArgs = Exports["clientAction"]["args"];
 
-      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
-      export type ComponentProps = T.CreateComponentProps<Info>
-      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
+      export type HydrateFallbackProps = Exports["HydrateFallback"]["args"];
+      export type ComponentProps = Exports["default"]["args"];
+      export type ErrorBoundaryProps = Exports["ErrorBoundary"]["args"];
     }
   `;
 }
-var noExtension = (path7) => Path3.join(Path3.dirname(path7), Pathe2.filename(path7));
-function getRouteLineage(routes, route) {
-  const result = [];
-  while (route) {
-    result.push(route);
-    if (!route.parentId) break;
-    route = routes[route.parentId];
-  }
-  result.reverse();
-  return result;
-}
-function formatParamProperties(urlpath) {
-  const params = parseParams(urlpath);
-  const properties = Object.entries(params).map(([name, values]) => {
-    if (values.length === 1) {
-      const isOptional = values[0];
-      return isOptional ? `"${name}"?: string` : `"${name}": string`;
-    }
-    const items = values.map(
-      (isOptional) => isOptional ? "string | undefined" : "string"
-    );
-    return `"${name}": [${items.join(", ")}]`;
-  });
-  return properties.join("; ");
+
+// 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 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;
+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/index.ts
@@ -786,16 +714,97 @@ async function createContext2({
     config
   };
 }
+function asJS(path7) {
+  return path7.replace(/\.(js|ts)x?$/, ".js");
+}
+function formatRoute(ctx, { id, path: path7, file, parentId }) {
+  const modulePath = Path3.relative(
+    ctx.rootDirectory,
+    Path3.join(ctx.config.appDirectory, file)
+  );
+  return [
+    `"${id}": {`,
+    `  parentId: ${JSON.stringify(parentId)}`,
+    `  path: ${JSON.stringify(path7)}`,
+    `  module: typeof import("${asJS(modulePath)}")`,
+    `}`
+  ].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((route) => formatRoute(ctx, route)).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(ctx, route);
-    import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
+    const content = generate(route);
+    import_node_fs2.default.mkdirSync(Path3.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");
@@ -1161,609 +1170,8 @@ 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_dedent2 = __toESM(require("dedent"));
+var import_dedent3 = __toESM(require("dedent"));
 var vmod = create("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
@@ -1774,7 +1182,7 @@ var plugin = {
   },
   async load(id) {
     if (id !== vmod.resolvedId) return;
-    return import_dedent2.default`
+    return import_dedent3.default`
       import { createElement as h } from "react";
       import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
 
@@ -1901,20 +1309,8 @@ 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;
@@ -1943,35 +1339,23 @@ var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
   let rootRelativeFilePath = vite2.normalizePath(
     path6.relative(ctx.rootDirectory, absoluteFilePath)
   );
-  let entryChunk = viteManifest[rootRelativeFilePath];
+  let entryChunk = viteManifest[rootRelativeFilePath + BUILD_CLIENT_ROUTE_QUERY_STRING] ?? viteManifest[rootRelativeFilePath];
   if (!entryChunk) {
-    return void 0;
+    let knownManifestKeys = Object.keys(viteManifest).map((key) => '"' + key + '"').join(", ");
+    throw new Error(
+      `No manifest entry found for "${rootRelativeFilePath}". Known manifest keys: ${knownManifestKeys}`
+    );
   }
   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);
-  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 prependedAssetChunks = prependedAssetFilePaths.map(
+    (filePath) => resolveChunk(ctx, viteManifest, filePath)
+  );
   let chunks = resolveDependantChunks(viteManifest, [
     ...prependedAssetChunks,
-    entryChunk,
-    ...routeModuleChunks
+    entryChunk
   ]);
   return {
     module: `${ctx.publicPath}${entryChunk.file}`,
@@ -2008,10 +1392,6 @@ 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]) => {
@@ -2025,7 +1405,7 @@ var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
   );
   return Object.fromEntries(entries);
 };
-var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
+var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteFile) => {
   if (!viteChildCompiler) {
     throw new Error("Vite child compiler not found");
   }
@@ -2045,19 +1425,9 @@ var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile)
     moduleGraph.ensureEntryFromUrl(url2, ssr)
   ]);
   let transformed = await pluginContainer.transform(code, id, { ssr });
-  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);
+  let [, exports2] = (0, import_es_module_lexer.parse)(transformed.code);
+  let exportNames = exports2.map((e) => e.n);
+  return exportNames;
 };
 var getServerBundleBuildConfig = (viteUserConfig) => {
   if (!("__reactRouterServerBundleBuildConfig" in viteUserConfig) || !viteUserConfig.__reactRouterServerBundleBuildConfig) {
@@ -2077,7 +1447,7 @@ var defaultEntriesDir = path6.resolve(
   "config",
   "defaults"
 );
-var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path6.join(defaultEntriesDir, filename3));
+var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path6.join(defaultEntriesDir, filename2));
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => ({});
 var reactRouterVitePlugin = () => {
@@ -2088,7 +1458,6 @@ var reactRouterVitePlugin = () => {
   let viteConfig;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
-  let cache = /* @__PURE__ */ new Map();
   let reactRouterConfigLoader;
   let typegenWatcherPromise;
   let logger;
@@ -2228,31 +1597,13 @@ var reactRouterVitePlugin = () => {
       viteChildCompiler,
       ctx
     );
-    let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
     for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
-      let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
+      let routeFilePath = 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,
@@ -2261,33 +1612,18 @@ var reactRouterVitePlugin = () => {
         caseSensitive: route.caseSensitive,
         hasAction: sourceExports.includes("action"),
         hasLoader: sourceExports.includes("loader"),
-        hasClientAction,
-        hasClientLoader,
+        hasClientAction: sourceExports.includes("clientAction"),
+        hasClientLoader: sourceExports.includes("clientLoader"),
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         ...getReactRouterManifestBuildAssets(
           ctx,
           viteManifest,
-          `${routeFile}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
+          routeFilePath,
           // 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;
@@ -2328,52 +1664,25 @@ 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: routeModulePath,
-        // Route chunks are a build-time optimization
-        clientActionModule: void 0,
-        clientLoaderModule: void 0,
-        hydrateFallbackModule: void 0,
+        module: combineURLs(
+          ctx.publicPath,
+          resolveFileUrl(
+            ctx,
+            resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+          )
+        ),
         hasAction: sourceExports.includes("action"),
         hasLoader: sourceExports.includes("loader"),
-        hasClientAction,
-        hasClientLoader,
+        hasClientAction: sourceExports.includes("clientAction"),
+        hasClientLoader: sourceExports.includes("clientLoader"),
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         imports: []
       };
@@ -2406,13 +1715,8 @@ var reactRouterVitePlugin = () => {
         let viteClientConditions = [
           ...vite2.defaultClientConditions ?? []
         ];
-        let packageRoot = path6.dirname(
-          require.resolve("@react-router/dev/package.json")
-        );
-        let { moduleSyncEnabled } = await import(`file:///${path6.join(packageRoot, "module-sync-enabled/index.mjs")}`);
         let viteServerConditions = [
-          ...vite2.defaultServerConditions ?? [],
-          ...moduleSyncEnabled ? ["module-sync"] : []
+          ...vite2.defaultServerConditions ?? []
         ];
         logger = vite2.createLogger(viteUserConfig.logLevel, {
           prefix: "[react-router]"
@@ -2526,28 +1830,12 @@ var reactRouterVitePlugin = () => {
                   preserveEntrySignatures: "exports-only",
                   input: [
                     ctx.entryClientFilePath,
-                    ...Object.values(
-                      ctx.reactRouterConfig.routes
-                    ).flatMap((route) => {
-                      let routeFilePath = path6.resolve(
+                    ...Object.values(ctx.reactRouterConfig.routes).map(
+                      (route) => `${path6.resolve(
                         ctx.reactRouterConfig.appDirectory,
                         route.file
-                      );
-                      let isRootRoute = route.file === ctx.reactRouterConfig.routes.root.file;
-                      let code = fse.readFileSync(
-                        routeFilePath,
-                        "utf-8"
-                      );
-                      return [
-                        `${routeFilePath}${BUILD_CLIENT_ROUTE_QUERY_STRING}`,
-                        ...ctx.reactRouterConfig.future.unstable_splitRouteModules && !isRootRoute ? routeChunkExportNames.map(
-                          (exportName) => code.includes(exportName) ? getRouteChunkModuleId(
-                            routeFilePath,
-                            exportName
-                          ) : null
-                        ) : []
-                      ].filter(isNonNullable);
-                    })
+                      )}${BUILD_CLIENT_ROUTE_QUERY_STRING}`
+                    )
                   ]
                 }
               } : {
@@ -2815,59 +2103,10 @@ 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",
-      async transform(code, id, options) {
+      enforce: "pre",
+      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);
@@ -2876,53 +2115,12 @@ var reactRouterVitePlugin = () => {
           ctx,
           routeModuleId
         );
-        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(", ");
+        let reexports = sourceExports.filter(
+          (exportName) => options?.ssr && SERVER_ONLY_ROUTE_EXPORTS.includes(exportName) || CLIENT_ROUTE_EXPORTS.includes(exportName)
+        ).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 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",
@@ -2977,7 +2175,8 @@ var reactRouterVitePlugin = () => {
         let importerShort = vite2.normalizePath(
           path6.relative(ctx.rootDirectory, importer)
         );
-        if (isRoute(ctx.reactRouterConfig, importer)) {
+        let isRoute = getRoute(ctx.reactRouterConfig, importer);
+        if (isRoute) {
           let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(
             (xport) => `\`${xport}\``
           ).join(", ");
@@ -3016,10 +2215,10 @@ var reactRouterVitePlugin = () => {
         let clientFileRE = /\.client(\.[cm]?[jt]sx?)?$/;
         let clientDirRE = /\/\.client\//;
         if (clientFileRE.test(id) || clientDirRE.test(id)) {
-          let exports2 = getExportNames(code);
+          let exports2 = (0, import_es_module_lexer.parse)(code)[1];
           return {
             code: exports2.map(
-              (name) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`
+              ({ n: name }) => name === "default" ? "export default undefined;" : `export const ${name} = undefined;`
             ).join("\n"),
             map: null
           };
@@ -3030,25 +2229,17 @@ 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 exportNames = getExportNames(code);
-          let serverOnlyExports = exportNames.filter(
-            (exp) => SERVER_ONLY_ROUTE_EXPORTS.includes(exp)
-          );
+          let serverOnlyExports = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).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 = exportNames.some(
-              (exp) => exp === "HydrateFallback"
-            );
+            let hasHydrateFallback = (0, import_es_module_lexer.parse)(code)[1].map((exp) => exp.n).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);
@@ -3126,9 +2317,6 @@ 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,
@@ -3159,7 +2347,6 @@ 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,
@@ -3169,12 +2356,9 @@ var reactRouterVitePlugin = () => {
           if (!oldRouteMetadata || [
             "hasLoader",
             "hasClientLoader",
-            "clientLoaderModule",
             "hasAction",
             "hasClientAction",
-            "clientActionModule",
-            "hasErrorBoundary",
-            "hydrateFallbackModule"
+            "hasErrorBoundary"
           ].some((key) => oldRouteMetadata[key] !== newRouteMetadata[key])) {
             invalidateVirtualModules(server);
           }
@@ -3292,30 +2476,13 @@ function getRoute(pluginConfig, file) {
   );
   return route;
 }
-function isRoute(pluginConfig, file) {
-  return Boolean(getRoute(pluginConfig, file));
-}
-async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteFile) {
-  let routeFile = route.file;
+async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
   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,
@@ -3329,11 +2496,14 @@ async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteF
         resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
       )
     ),
-    module: `${moduleUrl}?import`,
+    module: combineURLs(
+      ctx.publicPath,
+      `${resolveFileUrl(
+        ctx,
+        resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
+      )}?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"),
@@ -3582,73 +2752,6 @@ 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