@react-router/dev 0.0.0-experimental-6b51a129b → 0.0.0-experimental-345f1da12

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-6b51a129b
+ * @react-router/dev v0.0.0-experimental-345f1da12
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -46,8 +46,8 @@ module.exports = __toCommonJS(vite_exports);
 
 // vite/plugin.ts
 var import_node_crypto = require("crypto");
-var path4 = __toESM(require("path"));
-var url2 = __toESM(require("url"));
+var path6 = __toESM(require("path"));
+var url = __toESM(require("url"));
 var fse = __toESM(require("fs-extra"));
 var babel = __toESM(require("@babel/core"));
 var import_react_router2 = require("react-router");
@@ -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
@@ -70,6 +71,9 @@ var import_server = require("vite-node/server");
 var import_client = require("vite-node/client");
 var import_source_map = require("vite-node/source-map");
 
+// vite/vite.ts
+var import_pathe2 = __toESM(require("pathe"));
+
 // invariant.ts
 function invariant(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
@@ -80,20 +84,41 @@ function invariant(value, message) {
   }
 }
 
-// vite/import-vite-esm-sync.ts
+// config/is-react-router-repo.ts
+var import_pathe = __toESM(require("pathe"));
+function isReactRouterRepo() {
+  let serverRuntimePath = import_pathe.default.dirname(
+    require.resolve("@react-router/node/package.json")
+  );
+  let serverRuntimeParentDir = import_pathe.default.basename(
+    import_pathe.default.resolve(serverRuntimePath, "..")
+  );
+  return serverRuntimeParentDir === "packages";
+}
+
+// vite/vite.ts
 var vite;
-async function preloadViteEsm() {
-  vite = await import("vite");
+var viteImportSpecifier = isReactRouterRepo() ? (
+  // Support testing against different versions of Vite by ensuring that Vite
+  // is resolved from the current working directory when running within this
+  // repo. If we don't do this, Vite will always be imported relative to this
+  // file, which means that it will always resolve to Vite 6.
+  `file:///${import_pathe2.default.normalize(
+    require.resolve("vite/package.json", { paths: [process.cwd()] })
+  ).replace("package.json", "dist/node/index.js")}`
+) : "vite";
+async function preloadVite() {
+  vite = await import(viteImportSpecifier);
 }
-function importViteEsmSync() {
-  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+function getVite() {
+  invariant(vite, "getVite() called before preloadVite()");
   return vite;
 }
 
 // vite/vite-node.ts
 async function createContext(viteConfig = {}) {
-  await preloadViteEsm();
-  const vite2 = importViteEsmSync();
+  await preloadVite();
+  const vite2 = getVite();
   const devServer = await vite2.createServer(
     vite2.mergeConfig(
       {
@@ -119,18 +144,18 @@ async function createContext(viteConfig = {}) {
   const runner = new import_client.ViteNodeRunner({
     root: devServer.config.root,
     base: devServer.config.base,
-    fetchModule(id2) {
-      return server.fetchModule(id2);
+    fetchModule(id) {
+      return server.fetchModule(id);
     },
-    resolveId(id2, importer) {
-      return server.resolveId(id2, importer);
+    resolveId(id, importer) {
+      return server.resolveId(id, importer);
     }
   });
   return { devServer, server, runner };
 }
 
 // config/config.ts
-var import_pathe = __toESM(require("pathe"));
+var import_pathe3 = __toESM(require("pathe"));
 var import_chokidar = __toESM(require("chokidar"));
 var import_picocolors = __toESM(require("picocolors"));
 var import_pick2 = __toESM(require("lodash/pick"));
@@ -184,7 +209,7 @@ function validateRouteConfig({
         `Route config in "${routeConfigFile}" is invalid.`,
         root ? `${root}` : [],
         nested ? Object.entries(nested).map(
-          ([path5, message]) => `Path: routes.${path5}
+          ([path7, message]) => `Path: routes.${path7}
 ${message}`
         ) : []
       ].flat().join("\n\n")
@@ -195,24 +220,24 @@ ${message}`
 function configRoutesToRouteManifest(appDirectory, routes, rootId = "root") {
   let routeManifest = {};
   function walk(route, parentId) {
-    let id2 = route.id || createRouteId(route.file);
+    let id = route.id || createRouteId(route.file);
     let manifestItem = {
-      id: id2,
+      id,
       parentId,
       file: Path.isAbsolute(route.file) ? Path.relative(appDirectory, route.file) : route.file,
       path: route.path,
       index: route.index,
       caseSensitive: route.caseSensitive
     };
-    if (routeManifest.hasOwnProperty(id2)) {
+    if (routeManifest.hasOwnProperty(id)) {
       throw new Error(
-        `Unable to define routes with duplicate route id: "${id2}"`
+        `Unable to define routes with duplicate route id: "${id}"`
       );
     }
-    routeManifest[id2] = manifestItem;
+    routeManifest[id] = manifestItem;
     if (route.children) {
       for (let child of route.children) {
-        walk(child, id2);
+        walk(child, id);
       }
     }
   }
@@ -366,13 +391,13 @@ async function resolveConfig({
       "The `prerender` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths"
     );
   }
-  let appDirectory = import_pathe.default.resolve(root, userAppDirectory || "app");
-  let buildDirectory = import_pathe.default.resolve(root, userBuildDirectory);
+  let appDirectory = import_pathe3.default.resolve(root, userAppDirectory || "app");
+  let buildDirectory = import_pathe3.default.resolve(root, userBuildDirectory);
   let rootRouteFile = findEntry(appDirectory, "root");
   if (!rootRouteFile) {
-    let rootRouteDisplayPath = import_pathe.default.relative(
+    let rootRouteDisplayPath = import_pathe3.default.relative(
       root,
-      import_pathe.default.join(appDirectory, "root.tsx")
+      import_pathe3.default.join(appDirectory, "root.tsx")
     );
     return err(
       `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
@@ -384,15 +409,15 @@ async function resolveConfig({
   let routeConfigFile = findEntry(appDirectory, "routes");
   try {
     if (!routeConfigFile) {
-      let routeConfigDisplayPath = import_pathe.default.relative(
+      let routeConfigDisplayPath = import_pathe3.default.relative(
         root,
-        import_pathe.default.join(appDirectory, "routes.ts")
+        import_pathe3.default.join(appDirectory, "routes.ts")
       );
       return err(`Route config file not found at "${routeConfigDisplayPath}".`);
     }
     setAppDirectory(appDirectory);
     let routeConfigExport = (await viteNodeContext.runner.executeFile(
-      import_pathe.default.join(appDirectory, routeConfigFile)
+      import_pathe3.default.join(appDirectory, routeConfigFile)
     )).default;
     let routeConfig = await routeConfigExport;
     let result = validateRouteConfig({
@@ -412,7 +437,7 @@ async function resolveConfig({
         import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
         "",
         error.loc?.file && error.loc?.column && error.frame ? [
-          import_pathe.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          import_pathe3.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
           error.frame.trim?.()
         ] : error.stack
       ].flat().join("\n")
@@ -484,8 +509,8 @@ async function createConfigLoader({
         );
         fsWatcher.on("all", async (...args) => {
           let [event, rawFilepath] = args;
-          let filepath = import_pathe.default.normalize(rawFilepath);
-          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe.default.normalize(appDirectory));
+          let filepath = import_pathe3.default.normalize(rawFilepath);
+          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
           let configCodeUpdated = Boolean(
             viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
           );
@@ -531,8 +556,8 @@ async function resolveEntryFiles({
   reactRouterConfig
 }) {
   let { appDirectory } = reactRouterConfig;
-  let defaultsDirectory = import_pathe.default.resolve(
-    import_pathe.default.dirname(require.resolve("@react-router/dev/package.json")),
+  let defaultsDirectory = import_pathe3.default.resolve(
+    import_pathe3.default.dirname(require.resolve("@react-router/dev/package.json")),
     "dist",
     "config",
     "defaults"
@@ -570,11 +595,11 @@ async function resolveEntryFiles({
     }
     entryServerFile = `entry.server.node.tsx`;
   }
-  let entryClientFilePath = userEntryClientFile ? import_pathe.default.resolve(reactRouterConfig.appDirectory, userEntryClientFile) : import_pathe.default.resolve(defaultsDirectory, entryClientFile);
-  let entryServerFilePath = userEntryServerFile ? import_pathe.default.resolve(reactRouterConfig.appDirectory, userEntryServerFile) : import_pathe.default.resolve(defaultsDirectory, entryServerFile);
+  let entryClientFilePath = userEntryClientFile ? import_pathe3.default.resolve(reactRouterConfig.appDirectory, userEntryClientFile) : import_pathe3.default.resolve(defaultsDirectory, entryClientFile);
+  let entryServerFilePath = userEntryServerFile ? import_pathe3.default.resolve(reactRouterConfig.appDirectory, userEntryServerFile) : import_pathe3.default.resolve(defaultsDirectory, entryServerFile);
   return { entryClientFilePath, entryServerFilePath };
 }
-var ssrExternals = isInReactRouterMonorepo() ? [
+var ssrExternals = isReactRouterRepo() ? [
   // This is only needed within this repo because these packages
   // are linked to a directory outside of node_modules so Vite
   // treats them as internal code by default.
@@ -587,21 +612,12 @@ var ssrExternals = isInReactRouterMonorepo() ? [
   "@react-router/node",
   "@react-router/serve"
 ] : void 0;
-function isInReactRouterMonorepo() {
-  let serverRuntimePath = import_pathe.default.dirname(
-    require.resolve("@react-router/node/package.json")
-  );
-  let serverRuntimeParentDir = import_pathe.default.basename(
-    import_pathe.default.resolve(serverRuntimePath, "..")
-  );
-  return serverRuntimeParentDir === "packages";
-}
 var entryExts = [".js", ".jsx", ".ts", ".tsx"];
 function findEntry(dir, basename2, options) {
   for (let ext of entryExts) {
-    let file = import_pathe.default.resolve(dir, basename2 + ext);
+    let file = import_pathe3.default.resolve(dir, basename2 + ext);
     if (import_node_fs.default.existsSync(file)) {
-      return options?.absolute ?? false ? file : import_pathe.default.relative(dir, file);
+      return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
     }
   }
   return void 0;
@@ -609,129 +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 MiddlewareArgs = T.CreateServerMiddlewareArgs<Info>
-      export type MiddlewareNextFunction = T.ServerMiddlewareNextFunction
-      export type ClientMiddlewareArgs = T.CreateClientMiddlewareArgs<Info>
-      export type ClientMiddlewareNextFunction = T.ClientMiddlewareNextFunction
-      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 = (path5) => Path3.join(Path3.dirname(path5), Pathe2.filename(path5));
-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
@@ -773,16 +714,93 @@ 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(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");
@@ -816,7 +834,7 @@ function fromNodeRequest(nodeReq, nodeRes) {
     nodeReq.originalUrl,
     "Expected `nodeReq.originalUrl` to be defined"
   );
-  let url3 = new URL(nodeReq.originalUrl, origin);
+  let url2 = new URL(nodeReq.originalUrl, origin);
   let controller = new AbortController();
   let init = {
     method: nodeReq.method,
@@ -829,7 +847,7 @@ function fromNodeRequest(nodeReq, nodeRes) {
     init.body = (0, import_node.createReadableStreamFromReadable)(nodeReq);
     init.duplex = "half";
   }
-  return new Request(url3.href, init);
+  return new Request(url2.href, init);
 }
 async function toNodeRequest(res, nodeRes) {
   nodeRes.statusCode = res.status;
@@ -854,17 +872,17 @@ async function toNodeRequest(res, nodeRes) {
 }
 
 // vite/styles.ts
-var path3 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 var import_react_router = require("react-router");
 
 // vite/resolve-file-url.ts
-var path2 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var resolveFileUrl = ({ rootDirectory }, filePath) => {
-  let vite2 = importViteEsmSync();
-  let relativePath = path2.relative(rootDirectory, filePath);
-  let isWithinRoot = !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
+  let vite2 = getVite();
+  let relativePath = path4.relative(rootDirectory, filePath);
+  let isWithinRoot = !relativePath.startsWith("..") && !path4.isAbsolute(relativePath);
   if (!isWithinRoot) {
-    return path2.posix.join("/@fs", vite2.normalizePath(filePath));
+    return path4.posix.join("/@fs", vite2.normalizePath(filePath));
   }
   return "/" + vite2.normalizePath(relativePath);
 };
@@ -875,8 +893,8 @@ var cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
 var isCssFile = (file) => cssFileRegExp.test(file);
 var isCssModulesFile = (file) => cssModulesRegExp.test(file);
 var cssUrlParamsWithoutSideEffects = ["url", "inline", "raw", "inline-css"];
-var isCssUrlWithoutSideEffects = (url3) => {
-  let queryString = url3.split("?")[1];
+var isCssUrlWithoutSideEffects = (url2) => {
+  let queryString = url2.split("?")[1];
   if (!queryString) {
     return false;
   }
@@ -884,24 +902,27 @@ var isCssUrlWithoutSideEffects = (url3) => {
   for (let paramWithoutSideEffects of cssUrlParamsWithoutSideEffects) {
     if (
       // Parameter is blank and not explicitly set, i.e. "?url", not "?url="
-      params.get(paramWithoutSideEffects) === "" && !url3.includes(`?${paramWithoutSideEffects}=`) && !url3.includes(`&${paramWithoutSideEffects}=`)
+      params.get(paramWithoutSideEffects) === "" && !url2.includes(`?${paramWithoutSideEffects}=`) && !url2.includes(`&${paramWithoutSideEffects}=`)
     ) {
       return true;
     }
   }
   return false;
 };
+var injectQuery = (url2, query) => url2.includes("?") ? url2.replace("?", `?${query}&`) : `${url2}?${query}`;
 var getStylesForFiles = async ({
   viteDevServer,
   rootDirectory,
   cssModulesManifest,
   files
 }) => {
+  let vite2 = getVite();
+  let viteMajor = parseInt(vite2.version.split(".")[0], 10);
   let styles = {};
   let deps = /* @__PURE__ */ new Set();
   try {
     for (let file of files) {
-      let normalizedPath = path3.resolve(rootDirectory, file).replace(/\\/g, "/");
+      let normalizedPath = path5.resolve(rootDirectory, file).replace(/\\/g, "/");
       let node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
       if (!node) {
         try {
@@ -925,7 +946,15 @@ var getStylesForFiles = async ({
   for (let dep of deps) {
     if (dep.file && isCssFile(dep.file) && !isCssUrlWithoutSideEffects(dep.url)) {
       try {
-        let css = isCssModulesFile(dep.file) ? cssModulesManifest[dep.file] : (await viteDevServer.ssrLoadModule(dep.url)).default;
+        let css = isCssModulesFile(dep.file) ? cssModulesManifest[dep.file] : (await viteDevServer.ssrLoadModule(
+          // We need the ?inline query in Vite v6 when loading CSS in SSR
+          // since it does not expose the default export for CSS in a
+          // server environment. This is to align with non-SSR
+          // environments. For backwards compatibility with v5 we keep
+          // using the URL without ?inline query because the HMR code was
+          // relying on the implicit SSR-client module graph relationship.
+          viteMajor >= 6 ? injectQuery(dep.url, "inline") : dep.url
+        )).default;
         if (css === void 0) {
           throw new Error();
         }
@@ -949,8 +978,8 @@ var findDeps = async (vite2, node, deps) => {
       await findDeps(vite2, node2, deps);
     }
   }
-  async function addFromUrl(url3) {
-    let node2 = await vite2.moduleGraph.getModuleByUrl(url3);
+  async function addFromUrl(url2) {
+    let node2 = await vite2.moduleGraph.getModuleByUrl(url2);
     if (node2) {
       await addFromNode(node2);
     }
@@ -958,7 +987,7 @@ var findDeps = async (vite2, node, deps) => {
   if (node.ssrTransformResult) {
     if (node.ssrTransformResult.deps) {
       node.ssrTransformResult.deps.forEach(
-        (url3) => branches.push(addFromUrl(url3))
+        (url2) => branches.push(addFromUrl(url2))
       );
     }
   } else {
@@ -992,15 +1021,15 @@ var getStylesForUrl = async ({
   entryClientFilePath,
   cssModulesManifest,
   build,
-  url: url3
+  url: url2
 }) => {
-  if (url3 === void 0 || url3.includes("?_data=")) {
+  if (url2 === void 0 || url2.includes("?_data=")) {
     return void 0;
   }
   let routes = createRoutes(build.routes);
-  let appPath = path3.relative(process.cwd(), reactRouterConfig.appDirectory);
-  let documentRouteFiles = (0, import_react_router.matchRoutes)(routes, url3, build.basename)?.map(
-    (match) => path3.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
+  let appPath = path5.relative(process.cwd(), reactRouterConfig.appDirectory);
+  let documentRouteFiles = (0, import_react_router.matchRoutes)(routes, url2, build.basename)?.map(
+    (match) => path5.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
   ) ?? [];
   let styles = await getStylesForFiles({
     viteDevServer,
@@ -1008,7 +1037,7 @@ var getStylesForUrl = async ({
     cssModulesManifest,
     files: [
       // Always include the client entry file when crawling the module graph for CSS
-      path3.relative(rootDirectory, entryClientFilePath),
+      path5.relative(rootDirectory, entryClientFilePath),
       // Then include any styles from the matched routes
       ...documentRouteFiles
     ]
@@ -1016,10 +1045,15 @@ var getStylesForUrl = async ({
   return styles;
 };
 
-// vite/vmod.ts
-var id = (name) => `virtual:react-router/${name}`;
-var resolve3 = (id2) => `\0${id2}`;
-var url = (id2) => `/@id/__x00__${id2}`;
+// vite/virtual-module.ts
+function create(name) {
+  let id = `virtual:react-router/${name}`;
+  return {
+    id,
+    resolvedId: `\0${id}`,
+    url: `/@id/__x00__${id}`
+  };
+}
 
 // vite/combine-urls.ts
 function combineURLs(baseURL, relativeURL) {
@@ -1033,10 +1067,10 @@ var removeExports = (ast, exportsToRemove) => {
   let exportsFiltered = false;
   let markedForRemoval = /* @__PURE__ */ new Set();
   traverse(ast, {
-    ExportDeclaration(path5) {
-      if (path5.node.type === "ExportNamedDeclaration") {
-        if (path5.node.specifiers.length) {
-          path5.node.specifiers = path5.node.specifiers.filter((specifier) => {
+    ExportDeclaration(path7) {
+      if (path7.node.type === "ExportNamedDeclaration") {
+        if (path7.node.specifiers.length) {
+          path7.node.specifiers = path7.node.specifiers.filter((specifier) => {
             if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
               if (exportsToRemove.includes(specifier.exported.name)) {
                 exportsFiltered = true;
@@ -1045,12 +1079,12 @@ var removeExports = (ast, exportsToRemove) => {
             }
             return true;
           });
-          if (path5.node.specifiers.length === 0) {
-            markedForRemoval.add(path5);
+          if (path7.node.specifiers.length === 0) {
+            markedForRemoval.add(path7);
           }
         }
-        if (path5.node.declaration?.type === "VariableDeclaration") {
-          let declaration = path5.node.declaration;
+        if (path7.node.declaration?.type === "VariableDeclaration") {
+          let declaration = path7.node.declaration;
           declaration.declarations = declaration.declarations.filter(
             (declaration2) => {
               if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
@@ -1064,37 +1098,37 @@ var removeExports = (ast, exportsToRemove) => {
             }
           );
           if (declaration.declarations.length === 0) {
-            markedForRemoval.add(path5);
+            markedForRemoval.add(path7);
           }
         }
-        if (path5.node.declaration?.type === "FunctionDeclaration") {
-          let id2 = path5.node.declaration.id;
-          if (id2 && exportsToRemove.includes(id2.name)) {
-            markedForRemoval.add(path5);
+        if (path7.node.declaration?.type === "FunctionDeclaration") {
+          let id = path7.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path7);
           }
         }
-        if (path5.node.declaration?.type === "ClassDeclaration") {
-          let id2 = path5.node.declaration.id;
-          if (id2 && exportsToRemove.includes(id2.name)) {
-            markedForRemoval.add(path5);
+        if (path7.node.declaration?.type === "ClassDeclaration") {
+          let id = path7.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path7);
           }
         }
       }
-      if (path5.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
-        markedForRemoval.add(path5);
+      if (path7.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
+        markedForRemoval.add(path7);
       }
     }
   });
   if (markedForRemoval.size > 0 || exportsFiltered) {
-    for (let path5 of markedForRemoval) {
-      path5.remove();
+    for (let path7 of markedForRemoval) {
+      path7.remove();
     }
     (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
   }
 };
-function validateDestructuredExports(id2, exportsToRemove) {
-  if (id2.type === "ArrayPattern") {
-    for (let element of id2.elements) {
+function validateDestructuredExports(id, exportsToRemove) {
+  if (id.type === "ArrayPattern") {
+    for (let element of id.elements) {
       if (!element) {
         continue;
       }
@@ -1109,8 +1143,8 @@ function validateDestructuredExports(id2, exportsToRemove) {
       }
     }
   }
-  if (id2.type === "ObjectPattern") {
-    for (let property of id2.properties) {
+  if (id.type === "ObjectPattern") {
+    for (let property of id.properties) {
       if (!property) {
         continue;
       }
@@ -1133,18 +1167,18 @@ function invalidDestructureError(name) {
 }
 
 // vite/with-props.ts
-var import_dedent2 = __toESM(require("dedent"));
-var vmodId = id("with-props");
+var import_dedent3 = __toESM(require("dedent"));
+var vmod = create("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
   name: "react-router-with-props",
   enforce: "pre",
-  resolveId(id2) {
-    if (id2 === vmodId) return resolve3(vmodId);
+  resolveId(id) {
+    if (id === vmod.id) return vmod.resolvedId;
   },
-  async load(id2) {
-    if (id2 !== resolve3(vmodId)) return;
-    return import_dedent2.default`
+  async load(id) {
+    if (id !== vmod.resolvedId) return;
+    return import_dedent3.default`
       import { createElement as h } from "react";
       import { useActionData, useLoaderData, useMatches, useParams, useRouteError } from "react-router";
 
@@ -1185,44 +1219,44 @@ var plugin = {
 };
 var transform = (ast) => {
   const hocs = [];
-  function getHocUid(path5, hocName) {
-    const uid = path5.scope.generateUidIdentifier(hocName);
+  function getHocUid(path7, hocName) {
+    const uid = path7.scope.generateUidIdentifier(hocName);
     hocs.push([hocName, uid]);
     return uid;
   }
   traverse(ast, {
-    ExportDeclaration(path5) {
-      if (path5.isExportDefaultDeclaration()) {
-        const declaration = path5.get("declaration");
+    ExportDeclaration(path7) {
+      if (path7.isExportDefaultDeclaration()) {
+        const declaration = path7.get("declaration");
         const expr = declaration.isExpression() ? declaration.node : declaration.isFunctionDeclaration() ? toFunctionExpression(declaration.node) : void 0;
         if (expr) {
-          const uid = getHocUid(path5, "withComponentProps");
+          const uid = getHocUid(path7, "withComponentProps");
           declaration.replaceWith(t.callExpression(uid, [expr]));
         }
         return;
       }
-      if (path5.isExportNamedDeclaration()) {
-        const decl = path5.get("declaration");
+      if (path7.isExportNamedDeclaration()) {
+        const decl = path7.get("declaration");
         if (decl.isVariableDeclaration()) {
           decl.get("declarations").forEach((varDeclarator) => {
-            const id2 = varDeclarator.get("id");
+            const id = varDeclarator.get("id");
             const init = varDeclarator.get("init");
             const expr = init.node;
             if (!expr) return;
-            if (!id2.isIdentifier()) return;
-            const { name } = id2.node;
+            if (!id.isIdentifier()) return;
+            const { name } = id.node;
             if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
-            const uid = getHocUid(path5, `with${name}Props`);
+            const uid = getHocUid(path7, `with${name}Props`);
             init.replaceWith(t.callExpression(uid, [expr]));
           });
           return;
         }
         if (decl.isFunctionDeclaration()) {
-          const { id: id2 } = decl.node;
-          if (!id2) return;
-          const { name } = id2;
+          const { id } = decl.node;
+          if (!id) return;
+          const { name } = id;
           if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
-          const uid = getHocUid(path5, `with${name}Props`);
+          const uid = getHocUid(path7, `with${name}Props`);
           decl.replaceWith(
             t.variableDeclaration("const", [
               t.variableDeclarator(
@@ -1241,7 +1275,7 @@ var transform = (ast) => {
         hocs.map(
           ([name, identifier]) => t.importSpecifier(identifier, t.identifier(name))
         ),
-        t.stringLiteral(vmodId)
+        t.stringLiteral(vmod.id)
       )
     );
   }
@@ -1257,11 +1291,10 @@ function toFunctionExpression(decl) {
 }
 
 // vite/plugin.ts
-var SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "middleware", "headers"];
+var SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "headers"];
 var CLIENT_ROUTE_EXPORTS = [
   "clientAction",
   "clientLoader",
-  "clientMiddleware",
   "default",
   "ErrorBoundary",
   "handle",
@@ -1271,27 +1304,23 @@ var CLIENT_ROUTE_EXPORTS = [
   "meta",
   "shouldRevalidate"
 ];
-var ROUTE_ENTRY_QUERY_STRING = "?route-entry=1";
-var isRouteEntry = (id2) => {
-  return id2.endsWith(ROUTE_ENTRY_QUERY_STRING);
-};
-var serverBuildId = id("server-build");
-var serverManifestId = id("server-manifest");
-var browserManifestId = id("browser-manifest");
-var hmrRuntimeId = id("hmr-runtime");
-var injectHmrRuntimeId = id("inject-hmr-runtime");
+var BUILD_CLIENT_ROUTE_QUERY_STRING = "?__react-router-build-client-route";
+var virtualHmrRuntime = create("hmr-runtime");
+var virtualInjectHmrRuntime = create("inject-hmr-runtime");
 var resolveRelativeRouteFilePath = (route, reactRouterConfig) => {
-  let vite2 = importViteEsmSync();
+  let vite2 = getVite();
   let file = route.file;
-  let fullPath = path4.resolve(reactRouterConfig.appDirectory, file);
+  let fullPath = path6.resolve(reactRouterConfig.appDirectory, file);
   return vite2.normalizePath(fullPath);
 };
-var vmods = [serverBuildId, serverManifestId, browserManifestId];
+var virtual = {
+  serverBuild: create("server-build"),
+  serverManifest: create("server-manifest"),
+  browserManifest: create("browser-manifest")
+};
 var invalidateVirtualModules = (viteDevServer) => {
-  vmods.forEach((vmod) => {
-    let mod = viteDevServer.moduleGraph.getModuleById(
-      resolve3(vmod)
-    );
+  Object.values(virtual).forEach((vmod2) => {
+    let mod = viteDevServer.moduleGraph.getModuleById(vmod2.resolvedId);
     if (mod) {
       viteDevServer.moduleGraph.invalidateModule(mod);
     }
@@ -1302,11 +1331,11 @@ var getHash = (source, maxLength) => {
   return typeof maxLength === "number" ? hash.slice(0, maxLength) : hash;
 };
 var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
-  let vite2 = importViteEsmSync();
+  let vite2 = getVite();
   let rootRelativeFilePath = vite2.normalizePath(
-    path4.relative(ctx.rootDirectory, absoluteFilePath)
+    path6.relative(ctx.rootDirectory, absoluteFilePath)
   );
-  let entryChunk = viteManifest[rootRelativeFilePath + ROUTE_ENTRY_QUERY_STRING] ?? viteManifest[rootRelativeFilePath];
+  let entryChunk = viteManifest[rootRelativeFilePath + BUILD_CLIENT_ROUTE_QUERY_STRING] ?? viteManifest[rootRelativeFilePath];
   if (!entryChunk) {
     let knownManifestKeys = Object.keys(viteManifest).map((key) => '"' + key + '"').join(", ");
     throw new Error(
@@ -1356,7 +1385,7 @@ function dedupe(array2) {
   return [...new Set(array2)];
 }
 var writeFileSafe = async (file, contents) => {
-  await fse.ensureDir(path4.dirname(file));
+  await fse.ensureDir(path6.dirname(file));
   await fse.writeFile(file, contents);
 };
 var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
@@ -1378,20 +1407,20 @@ var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteF
   }
   let ssr = true;
   let { pluginContainer, moduleGraph } = viteChildCompiler;
-  let routePath = path4.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
-  let url3 = resolveFileUrl(ctx, routePath);
+  let routePath = path6.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
+  let url2 = resolveFileUrl(ctx, routePath);
   let resolveId = async () => {
-    let result = await pluginContainer.resolveId(url3, void 0, { ssr });
-    if (!result) throw new Error(`Could not resolve module ID for ${url3}`);
+    let result = await pluginContainer.resolveId(url2, void 0, { ssr });
+    if (!result) throw new Error(`Could not resolve module ID for ${url2}`);
     return result.id;
   };
-  let [id2, code] = await Promise.all([
+  let [id, code] = await Promise.all([
     resolveId(),
     readRouteFile?.() ?? fse.readFile(routePath, "utf-8"),
     // pluginContainer.transform(...) fails if we don't do this first:
-    moduleGraph.ensureEntryFromUrl(url3, ssr)
+    moduleGraph.ensureEntryFromUrl(url2, ssr)
   ]);
-  let transformed = await pluginContainer.transform(code, id2, { 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;
@@ -1402,19 +1431,19 @@ var getServerBundleBuildConfig = (viteUserConfig) => {
   }
   return viteUserConfig.__reactRouterServerBundleBuildConfig;
 };
-var getServerBuildDirectory = (ctx) => path4.join(
+var getServerBuildDirectory = (ctx) => path6.join(
   ctx.reactRouterConfig.buildDirectory,
   "server",
   ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
 );
-var getClientBuildDirectory = (reactRouterConfig) => path4.join(reactRouterConfig.buildDirectory, "client");
-var defaultEntriesDir = path4.resolve(
-  path4.dirname(require.resolve("@react-router/dev/package.json")),
+var getClientBuildDirectory = (reactRouterConfig) => path6.join(reactRouterConfig.buildDirectory, "client");
+var defaultEntriesDir = path6.resolve(
+  path6.dirname(require.resolve("@react-router/dev/package.json")),
   "dist",
   "config",
   "defaults"
 );
-var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path4.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 = () => {
@@ -1496,12 +1525,14 @@ var reactRouterVitePlugin = () => {
         resolveFileUrl(
           ctx,
           resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
-        ) + ROUTE_ENTRY_QUERY_STRING
+        )
       )};`;
     }).join("\n")}
-      export { default as assets } from ${JSON.stringify(serverManifestId)};
+      export { default as assets } from ${JSON.stringify(
+      virtual.serverManifest.id
+    )};
       export const assetsBuildDirectory = ${JSON.stringify(
-      path4.relative(
+      path6.relative(
         ctx.rootDirectory,
         getClientBuildDirectory(ctx.reactRouterConfig)
       )
@@ -1527,7 +1558,7 @@ var reactRouterVitePlugin = () => {
   };
   let loadViteManifest = async (directory) => {
     let manifestContents = await fse.readFile(
-      path4.resolve(directory, ".vite", "manifest.json"),
+      path6.resolve(directory, ".vite", "manifest.json"),
       "utf-8"
     );
     return JSON.parse(manifestContents);
@@ -1563,7 +1594,7 @@ var reactRouterVitePlugin = () => {
       ctx
     );
     for (let [key, route] of Object.entries(ctx.reactRouterConfig.routes)) {
-      let routeFilePath = path4.join(
+      let routeFilePath = path6.join(
         ctx.reactRouterConfig.appDirectory,
         route.file
       );
@@ -1598,18 +1629,18 @@ var reactRouterVitePlugin = () => {
     }
     let fingerprintedValues = { entry, routes: browserRoutes };
     let version = getHash(JSON.stringify(fingerprintedValues), 8);
-    let manifestPath = path4.posix.join(
+    let manifestPath = path6.posix.join(
       viteConfig.build.assetsDir,
       `manifest-${version}.js`
     );
-    let url3 = `${ctx.publicPath}${manifestPath}`;
-    let nonFingerprintedValues = { url: url3, version };
+    let url2 = `${ctx.publicPath}${manifestPath}`;
+    let nonFingerprintedValues = { url: url2, version };
     let reactRouterBrowserManifest = {
       ...fingerprintedValues,
       ...nonFingerprintedValues
     };
     await writeFileSafe(
-      path4.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
+      path6.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
       `window.__reactRouterManifest=${JSON.stringify(
         reactRouterBrowserManifest
       )};`
@@ -1639,10 +1670,10 @@ var reactRouterVitePlugin = () => {
         caseSensitive: route.caseSensitive,
         module: combineURLs(
           ctx.publicPath,
-          `${resolveFileUrl(
+          resolveFileUrl(
             ctx,
             resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
-          )}${ROUTE_ENTRY_QUERY_STRING}`
+          )
         ),
         hasAction: sourceExports.includes("action"),
         hasLoader: sourceExports.includes("loader"),
@@ -1654,12 +1685,9 @@ var reactRouterVitePlugin = () => {
     }
     return {
       version: String(Math.random()),
-      url: combineURLs(ctx.publicPath, url(browserManifestId)),
+      url: combineURLs(ctx.publicPath, virtual.browserManifest.url),
       hmr: {
-        runtime: combineURLs(
-          ctx.publicPath,
-          url(injectHmrRuntimeId)
-        )
+        runtime: combineURLs(ctx.publicPath, virtualInjectHmrRuntime.url)
       },
       entry: {
         module: combineURLs(
@@ -1675,11 +1703,17 @@ var reactRouterVitePlugin = () => {
     {
       name: "react-router",
       config: async (_viteUserConfig, _viteConfigEnv) => {
-        await preloadViteEsm();
-        let vite2 = importViteEsmSync();
+        await preloadVite();
+        let vite2 = getVite();
         viteUserConfig = _viteUserConfig;
         viteConfigEnv = _viteConfigEnv;
         viteCommand = viteConfigEnv.command;
+        let viteClientConditions = [
+          ...vite2.defaultClientConditions ?? []
+        ];
+        let viteServerConditions = [
+          ...vite2.defaultServerConditions ?? []
+        ];
         logger = vite2.createLogger(viteUserConfig.logLevel, {
           prefix: "[react-router]"
         });
@@ -1729,15 +1763,15 @@ var reactRouterVitePlugin = () => {
           ssr: {
             external: ssrExternals,
             resolve: {
-              conditions: viteCommand === "build" ? [] : ["development"],
-              externalConditions: viteCommand === "build" ? [] : ["development"]
+              conditions: viteCommand === "build" ? viteServerConditions : ["development", ...viteServerConditions],
+              externalConditions: viteCommand === "build" ? viteServerConditions : ["development", ...viteServerConditions]
             }
           },
           optimizeDeps: {
             entries: ctx.reactRouterConfig.future.unstable_optimizeDeps ? [
               ctx.entryClientFilePath,
               ...Object.values(ctx.reactRouterConfig.routes).map(
-                (route) => path4.join(ctx.reactRouterConfig.appDirectory, route.file)
+                (route) => path6.join(ctx.reactRouterConfig.appDirectory, route.file)
               )
             ] : [],
             include: [
@@ -1771,7 +1805,7 @@ var reactRouterVitePlugin = () => {
               "react-router/dom",
               "react-router-dom"
             ],
-            conditions: viteCommand === "build" ? [] : ["development"]
+            conditions: viteCommand === "build" ? viteClientConditions : ["development", ...viteClientConditions]
           },
           base: viteUserConfig.base,
           // When consumer provides an allow list for files that can be read by
@@ -1793,10 +1827,10 @@ var reactRouterVitePlugin = () => {
                   input: [
                     ctx.entryClientFilePath,
                     ...Object.values(ctx.reactRouterConfig.routes).map(
-                      (route) => `${path4.resolve(
+                      (route) => `${path6.resolve(
                         ctx.reactRouterConfig.appDirectory,
                         route.file
-                      )}${ROUTE_ENTRY_QUERY_STRING}`
+                      )}${BUILD_CLIENT_ROUTE_QUERY_STRING}`
                     )
                   ]
                 }
@@ -1815,7 +1849,7 @@ var reactRouterVitePlugin = () => {
                 rollupOptions: {
                   ...baseRollupOptions,
                   preserveEntrySignatures: "exports-only",
-                  input: viteUserConfig.build?.rollupOptions?.input ?? serverBuildId,
+                  input: viteUserConfig.build?.rollupOptions?.input ?? virtual.serverBuild.id,
                   output: {
                     entryFileNames: ctx.reactRouterConfig.serverBuildFile,
                     format: ctx.reactRouterConfig.serverModuleFormat
@@ -1842,7 +1876,7 @@ var reactRouterVitePlugin = () => {
             "The React Router Vite plugin requires the use of a Vite config file"
           );
         }
-        let vite2 = importViteEsmSync();
+        let vite2 = getVite();
         let childCompilerConfigFile = await vite2.loadConfigFromFile(
           {
             command: viteConfig.command,
@@ -1878,15 +1912,15 @@ var reactRouterVitePlugin = () => {
           envFile: false,
           plugins: [
             ...(childCompilerConfigFile.config.plugins ?? []).flat().filter(
-              (plugin2) => typeof plugin2 === "object" && plugin2 !== null && "name" in plugin2 && plugin2.name !== "react-router" && plugin2.name !== "react-router-route-exports" && plugin2.name !== "react-router-hmr-updates"
+              (plugin2) => typeof plugin2 === "object" && plugin2 !== null && "name" in plugin2 && plugin2.name !== "react-router" && plugin2.name !== "react-router:route-exports" && plugin2.name !== "react-router:hmr-updates"
             )
           ]
         });
         await viteChildCompiler.pluginContainer.buildStart({});
       },
-      async transform(code, id2) {
-        if (isCssModulesFile(id2)) {
-          cssModulesManifest[id2] = code;
+      async transform(code, id) {
+        if (isCssModulesFile(id)) {
+          cssModulesManifest[id] = code;
         }
       },
       buildStart() {
@@ -1910,7 +1944,7 @@ var reactRouterVitePlugin = () => {
         (0, import_react_router2.unstable_setDevServerHooks)({
           // Give the request handler access to the critical CSS in dev to avoid a
           // flash of unstyled content since Vite injects CSS file contents via JS
-          getCriticalCss: async (build, url3) => {
+          getCriticalCss: async (build, url2) => {
             return getStylesForUrl({
               rootDirectory: ctx.rootDirectory,
               entryClientFilePath: ctx.entryClientFilePath,
@@ -1918,7 +1952,7 @@ var reactRouterVitePlugin = () => {
               viteDevServer,
               cssModulesManifest,
               build,
-              url: url3
+              url: url2
             });
           },
           // If an error is caught within the request handler, let Vite fix the
@@ -1966,7 +2000,7 @@ var reactRouterVitePlugin = () => {
             viteDevServer.middlewares.use(async (req, res, next) => {
               try {
                 let build = await viteDevServer.ssrLoadModule(
-                  serverBuildId
+                  virtual.serverBuild.id
                 );
                 let handler = (0, import_react_router2.createRequestHandler)(build, "development");
                 let nodeHandler = async (nodeReq, nodeRes) => {
@@ -2001,8 +2035,8 @@ var reactRouterVitePlugin = () => {
           let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
           let movedAssetPaths = [];
           for (let ssrAssetPath of ssrAssetPaths) {
-            let src = path4.join(serverBuildDirectory, ssrAssetPath);
-            let dest = path4.join(clientBuildDirectory, ssrAssetPath);
+            let src = path6.join(serverBuildDirectory, ssrAssetPath);
+            let dest = path6.join(clientBuildDirectory, ssrAssetPath);
             if (!fse.existsSync(dest)) {
               await fse.move(src, dest);
               movedAssetPaths.push(dest);
@@ -2015,7 +2049,7 @@ var reactRouterVitePlugin = () => {
           );
           await Promise.all(
             ssrCssPaths.map(
-              (cssPath) => fse.remove(path4.join(serverBuildDirectory, cssPath))
+              (cssPath) => fse.remove(path6.join(serverBuildDirectory, cssPath))
             )
           );
           if (movedAssetPaths.length) {
@@ -2024,7 +2058,7 @@ var reactRouterVitePlugin = () => {
                 "",
                 `${import_picocolors3.default.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`,
                 ...movedAssetPaths.map(
-                  (movedAssetPath) => import_picocolors3.default.dim(path4.relative(ctx.rootDirectory, movedAssetPath))
+                  (movedAssetPath) => import_picocolors3.default.dim(path6.relative(ctx.rootDirectory, movedAssetPath))
                 ),
                 ""
               ].join("\n")
@@ -2066,12 +2100,12 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-route-entry",
+      name: "react-router:build-client-route",
       enforce: "pre",
-      async transform(_code, id2, options) {
-        if (!isRouteEntry(id2)) return;
-        let routeModuleId = id2.replace(ROUTE_ENTRY_QUERY_STRING, "");
-        let routeFileName = path4.basename(routeModuleId);
+      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);
         let sourceExports = await getRouteModuleExports(
           viteChildCompiler,
           ctx,
@@ -2084,23 +2118,24 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-virtual-modules",
+      name: "react-router:virtual-modules",
       enforce: "pre",
-      resolveId(id2) {
-        if (vmods.includes(id2)) return resolve3(id2);
+      resolveId(id) {
+        const vmod2 = Object.values(virtual).find((vmod3) => vmod3.id === id);
+        if (vmod2) return vmod2.resolvedId;
       },
-      async load(id2) {
-        switch (id2) {
-          case resolve3(serverBuildId): {
+      async load(id) {
+        switch (id) {
+          case virtual.serverBuild.resolvedId: {
             return await getServerEntry();
           }
-          case resolve3(serverManifestId): {
+          case virtual.serverManifest.resolvedId: {
             let reactRouterManifest = ctx.isSsrBuild ? await ctx.getReactRouterServerManifest() : await getReactRouterManifestForDev();
             return `export default ${(0, import_jsesc.default)(reactRouterManifest, {
               es6: true
             })};`;
           }
-          case resolve3(browserManifestId): {
+          case virtual.browserManifest.resolvedId: {
             if (viteCommand === "build") {
               throw new Error("This module only exists in development");
             }
@@ -2114,15 +2149,15 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-dot-server",
+      name: "react-router:dot-server",
       enforce: "pre",
-      async resolveId(id2, importer, options) {
+      async resolveId(id, importer, options) {
         let isOptimizeDeps = viteCommand === "serve" && options?.scan === true;
         if (isOptimizeDeps || options?.ssr) return;
-        let isResolving = options?.custom?.["react-router-dot-server"] ?? false;
+        let isResolving = options?.custom?.["react-router:dot-server"] ?? false;
         if (isResolving) return;
-        options.custom = { ...options.custom, "react-router-dot-server": true };
-        let resolved = await this.resolve(id2, importer, options);
+        options.custom = { ...options.custom, "react-router:dot-server": true };
+        let resolved = await this.resolve(id, importer, options);
         if (!resolved) return;
         let serverFileRE = /\.server(\.[cm]?[jt]sx?)?$/;
         let serverDirRE = /\/\.server\//;
@@ -2132,9 +2167,9 @@ var reactRouterVitePlugin = () => {
         if (viteCommand !== "build" && importer.endsWith(".html")) {
           return;
         }
-        let vite2 = importViteEsmSync();
+        let vite2 = getVite();
         let importerShort = vite2.normalizePath(
-          path4.relative(ctx.rootDirectory, importer)
+          path6.relative(ctx.rootDirectory, importer)
         );
         let isRoute = getRoute(ctx.reactRouterConfig, importer);
         if (isRoute) {
@@ -2145,12 +2180,12 @@ var reactRouterVitePlugin = () => {
             [
               import_picocolors3.default.red(`Server-only module referenced by client`),
               "",
-              `    '${id2}' imported by route '${importerShort}'`,
+              `    '${id}' imported by route '${importerShort}'`,
               "",
               `  React Router automatically removes server-code from these exports:`,
               `    ${serverOnlyExports}`,
               "",
-              `  But other route exports in '${importerShort}' depend on '${id2}'.`,
+              `  But other route exports in '${importerShort}' depend on '${id}'.`,
               "",
               "  See https://remix.run/docs/en/main/guides/vite#splitting-up-client-and-server-code",
               ""
@@ -2161,7 +2196,7 @@ var reactRouterVitePlugin = () => {
           [
             import_picocolors3.default.red(`Server-only module referenced by client`),
             "",
-            `    '${id2}' imported by '${importerShort}'`,
+            `    '${id}' imported by '${importerShort}'`,
             "",
             "  See https://remix.run/docs/en/main/guides/vite#splitting-up-client-and-server-code",
             ""
@@ -2170,12 +2205,12 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-dot-client",
-      async transform(code, id2, options) {
+      name: "react-router:dot-client",
+      async transform(code, id, options) {
         if (!options?.ssr) return;
         let clientFileRE = /\.client(\.[cm]?[jt]sx?)?$/;
         let clientDirRE = /\/\.client\//;
-        if (clientFileRE.test(id2) || clientDirRE.test(id2)) {
+        if (clientFileRE.test(id) || clientDirRE.test(id)) {
           let exports2 = (0, import_es_module_lexer.parse)(code)[1];
           return {
             code: exports2.map(
@@ -2188,9 +2223,9 @@ var reactRouterVitePlugin = () => {
     },
     plugin,
     {
-      name: "react-router-route-exports",
-      async transform(code, id2, options) {
-        let route = getRoute(ctx.reactRouterConfig, id2);
+      name: "react-router:route-exports",
+      async transform(code, id, options) {
+        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));
@@ -2207,7 +2242,7 @@ var reactRouterVitePlugin = () => {
             }
           }
         }
-        let [filepath] = id2.split("?");
+        let [filepath] = id.split("?");
         let ast = (0, import_parser.parse)(code, { sourceType: "module" });
         if (!options?.ssr) {
           removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
@@ -2215,22 +2250,23 @@ var reactRouterVitePlugin = () => {
         transform(ast);
         return generate2(ast, {
           sourceMaps: true,
-          filename: id2,
+          filename: id,
           sourceFileName: filepath
         });
       }
     },
     {
-      name: "react-router-inject-hmr-runtime",
+      name: "react-router:inject-hmr-runtime",
       enforce: "pre",
-      resolveId(id2) {
-        if (id2 === injectHmrRuntimeId)
-          return resolve3(injectHmrRuntimeId);
+      resolveId(id) {
+        if (id === virtualInjectHmrRuntime.id) {
+          return virtualInjectHmrRuntime.resolvedId;
+        }
       },
-      async load(id2) {
-        if (id2 !== resolve3(injectHmrRuntimeId)) return;
+      async load(id) {
+        if (id !== virtualInjectHmrRuntime.resolvedId) return;
         return [
-          `import RefreshRuntime from "${hmrRuntimeId}"`,
+          `import RefreshRuntime from "${virtualHmrRuntime.id}"`,
           "RefreshRuntime.injectIntoGlobalHook(window)",
           "window.$RefreshReg$ = () => {}",
           "window.$RefreshSig$ = () => (type) => type",
@@ -2239,17 +2275,17 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-hmr-runtime",
+      name: "react-router:hmr-runtime",
       enforce: "pre",
-      resolveId(id2) {
-        if (id2 === hmrRuntimeId) return resolve3(hmrRuntimeId);
+      resolveId(id) {
+        if (id === virtualHmrRuntime.id) return virtualHmrRuntime.resolvedId;
       },
-      async load(id2) {
-        if (id2 !== resolve3(hmrRuntimeId)) return;
-        let reactRefreshDir = path4.dirname(
+      async load(id) {
+        if (id !== virtualHmrRuntime.resolvedId) return;
+        let reactRefreshDir = path6.dirname(
           require.resolve("react-refresh/package.json")
         );
-        let reactRefreshRuntimePath = path4.join(
+        let reactRefreshRuntimePath = path6.join(
           reactRefreshDir,
           "cjs/react-refresh-runtime.development.js"
         );
@@ -2265,11 +2301,11 @@ var reactRouterVitePlugin = () => {
       }
     },
     {
-      name: "react-router-react-refresh-babel",
-      async transform(code, id2, options) {
+      name: "react-router:react-refresh-babel",
+      async transform(code, id, options) {
         if (viteCommand !== "serve") return;
-        if (id2.includes("/node_modules/")) return;
-        let [filepath] = id2.split("?");
+        if (id.includes("/node_modules/")) return;
+        let [filepath] = id.split("?");
         let extensionsRE = /\.(jsx?|tsx?|mdx?)$/;
         if (!extensionsRE.test(filepath)) return;
         let devRuntime = "react/jsx-dev-runtime";
@@ -2277,13 +2313,10 @@ var reactRouterVitePlugin = () => {
         let isJSX = filepath.endsWith("x");
         let useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
         if (!useFastRefresh) return;
-        if (isRouteEntry(id2)) {
-          return { code: addRefreshWrapper(ctx.reactRouterConfig, code, id2) };
-        }
         let result = await babel.transformAsync(code, {
           babelrc: false,
           configFile: false,
-          filename: id2,
+          filename: id,
           sourceFileName: filepath,
           parserOpts: {
             sourceType: "module",
@@ -2296,18 +2329,18 @@ var reactRouterVitePlugin = () => {
         code = result.code;
         let refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
         if (refreshContentRE.test(code)) {
-          code = addRefreshWrapper(ctx.reactRouterConfig, code, id2);
+          code = addRefreshWrapper(ctx.reactRouterConfig, code, id);
         }
         return { code, map: result.map };
       }
     },
     {
-      name: "react-router-hmr-updates",
+      name: "react-router:hmr-updates",
       async handleHotUpdate({ server, file, modules, read }) {
         let route = getRoute(ctx.reactRouterConfig, file);
         let hmrEventData = { route: null };
         if (route) {
-          let serverManifest = (await server.ssrLoadModule(serverManifestId)).default;
+          let serverManifest = (await server.ssrLoadModule(virtual.serverManifest.id)).default;
           let oldRouteMetadata = serverManifest.routes[route.id];
           let newRouteMetadata = await getRouteMetadata(
             ctx,
@@ -2333,39 +2366,69 @@ var reactRouterVitePlugin = () => {
         });
         return modules;
       }
+    },
+    {
+      name: "react-router-server-change-trigger-client-hmr",
+      // This hook is only available in Vite v6+ so this is a no-op in v5.
+      // Previously the server and client modules were shared in a single module
+      // graph. This meant that changes to server code automatically resulted in
+      // client HMR updates. In Vite v6+ these module graphs are separate from
+      // each other so we need to manually trigger client HMR updates if server
+      // code has changed.
+      hotUpdate({ server, modules }) {
+        if (this.environment.name !== "ssr" && modules.length <= 0) {
+          return;
+        }
+        let clientModules = uniqueNodes(
+          modules.flatMap(
+            (mod) => getParentClientNodes(server.environments.client.moduleGraph, mod)
+          )
+        );
+        for (let clientModule of clientModules) {
+          server.environments.client.reloadModule(clientModule);
+        }
+      }
     }
   ];
 };
-function addRefreshWrapper(reactRouterConfig, code, id2) {
-  let route = getRoute(reactRouterConfig, id2);
-  let acceptExports = route || isRouteEntry(id2) ? [
+function getParentClientNodes(clientModuleGraph, module2) {
+  if (!module2.id) {
+    return [];
+  }
+  let clientModule = clientModuleGraph.getModuleById(module2.id);
+  if (clientModule) {
+    return [clientModule];
+  }
+  return [...module2.importers].flatMap(
+    (importer) => getParentClientNodes(clientModuleGraph, importer)
+  );
+}
+function uniqueNodes(nodes) {
+  let nodeUrls = /* @__PURE__ */ new Set();
+  let unique = [];
+  for (let node of nodes) {
+    if (nodeUrls.has(node.url)) {
+      continue;
+    }
+    nodeUrls.add(node.url);
+    unique.push(node);
+  }
+  return unique;
+}
+function addRefreshWrapper(reactRouterConfig, code, id) {
+  let route = getRoute(reactRouterConfig, id);
+  let acceptExports = route ? [
     "clientAction",
     "clientLoader",
-    "clientMiddleware",
     "handle",
     "meta",
     "links",
     "shouldRevalidate"
   ] : [];
-  return "\n\n" + withCommentBoundaries(
-    "REACT REFRESH HEADER",
-    REACT_REFRESH_HEADER.replaceAll("__SOURCE__", JSON.stringify(id2))
-  ) + "\n\n" + withCommentBoundaries("REACT REFRESH BODY", code) + "\n\n" + withCommentBoundaries(
-    "REACT REFRESH FOOTER",
-    REACT_REFRESH_FOOTER.replaceAll("__SOURCE__", JSON.stringify(id2)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(route?.id))
-  ) + "\n";
-}
-function withCommentBoundaries(label, text) {
-  let begin = `// [BEGIN] ${label} `;
-  begin += "-".repeat(80 - begin.length);
-  let end = `// [END] ${label} `;
-  end += "-".repeat(80 - end.length);
-  return `${begin}
-${text}
-${end}`;
+  return REACT_REFRESH_HEADER.replaceAll("__SOURCE__", JSON.stringify(id)) + code + REACT_REFRESH_FOOTER.replaceAll("__SOURCE__", JSON.stringify(id)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(route?.id));
 }
 var REACT_REFRESH_HEADER = `
-import RefreshRuntime from "${hmrRuntimeId}";
+import RefreshRuntime from "${virtualHmrRuntime.id}";
 
 const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
 let prevRefreshReg;
@@ -2384,7 +2447,7 @@ if (import.meta.hot && !inWebWorker) {
     RefreshRuntime.register(type, __SOURCE__ + " " + id)
   };
   window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-}`.trim();
+}`.replaceAll("\n", "");
 var REACT_REFRESH_FOOTER = `
 if (import.meta.hot && !inWebWorker) {
   window.$RefreshReg$ = prevRefreshReg;
@@ -2398,11 +2461,11 @@ if (import.meta.hot && !inWebWorker) {
       if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
     });
   });
-}`.trim();
+}`;
 function getRoute(pluginConfig, file) {
-  let vite2 = importViteEsmSync();
+  let vite2 = getVite();
   let routePath = vite2.normalizePath(
-    path4.relative(pluginConfig.appDirectory, file)
+    path6.relative(pluginConfig.appDirectory, file)
   );
   let route = Object.values(pluginConfig.routes).find(
     (r) => vite2.normalizePath(r.file) === routePath
@@ -2424,7 +2487,7 @@ async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
     caseSensitive: route.caseSensitive,
     url: combineURLs(
       ctx.publicPath,
-      "/" + path4.relative(
+      "/" + path6.relative(
         ctx.rootDirectory,
         resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
       )
@@ -2447,11 +2510,11 @@ async function getRouteMetadata(ctx, viteChildCompiler, route, readRouteFile) {
   return info;
 }
 async function getPrerenderBuildAndHandler(viteConfig, reactRouterConfig, serverBuildDirectory) {
-  let serverBuildPath = path4.join(
+  let serverBuildPath = path6.join(
     serverBuildDirectory,
     reactRouterConfig.serverBuildFile
   );
-  let build = await import(url2.pathToFileURL(serverBuildPath).toString());
+  let build = await import(url.pathToFileURL(serverBuildPath).toString());
   let { createRequestHandler: createHandler } = await import("react-router");
   return {
     build,
@@ -2469,9 +2532,9 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
   let html = await response.text();
   validatePrerenderedResponse(response, html, "SPA Mode", "/");
   validatePrerenderedHtml(html, "SPA Mode");
-  await fse.writeFile(path4.join(clientBuildDirectory, "index.html"), html);
+  await fse.writeFile(path6.join(clientBuildDirectory, "index.html"), html);
   viteConfig.logger.info(
-    "SPA Mode: index.html has been written to your " + import_picocolors3.default.bold(path4.relative(process.cwd(), clientBuildDirectory)) + " directory"
+    "SPA Mode: index.html has been written to your " + import_picocolors3.default.bold(path6.relative(process.cwd(), clientBuildDirectory)) + " directory"
   );
 }
 async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, clientBuildDirectory) {
@@ -2501,14 +2564,14 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     // build time or runtime
     "X-React-Router-Prerender": "yes"
   };
-  for (let path5 of routesToPrerender) {
-    let matches = (0, import_react_router2.matchRoutes)(routes, path5);
+  for (let path7 of routesToPrerender) {
+    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path7}/`.replace(/^\/\/+/, "/"));
     let hasLoaders = matches?.some((m) => m.route.loader);
     let data;
     if (hasLoaders) {
       data = await prerenderData(
         handler,
-        path5,
+        path7,
         clientBuildDirectory,
         reactRouterConfig,
         viteConfig,
@@ -2521,7 +2584,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     if (isResourceRoute) {
       await prerenderResourceRoute(
         handler,
-        path5,
+        path7,
         clientBuildDirectory,
         reactRouterConfig,
         viteConfig,
@@ -2530,7 +2593,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     } else {
       await prerenderRoute(
         handler,
-        path5,
+        path7,
         clientBuildDirectory,
         reactRouterConfig,
         viteConfig,
@@ -2587,9 +2650,9 @@ async function prerenderData(handler, prerenderPath, clientBuildDirectory, react
   let response = await handler(request);
   let data = await response.text();
   validatePrerenderedResponse(response, data, "Prerender", normalizedPath);
-  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path4.dirname(outfile));
+  let outdir = path6.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path6.join(outdir, ...normalizedPath.split("/"));
+  await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, data);
   viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
   return data;
@@ -2606,9 +2669,9 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
   if (!reactRouterConfig.ssr) {
     validatePrerenderedHtml(html, "Prerender");
   }
-  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path4.join(outdir, ...normalizedPath.split("/"), "index.html");
-  await fse.ensureDir(path4.dirname(outfile));
+  let outdir = path6.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path6.join(outdir, ...normalizedPath.split("/"), "index.html");
+  await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, html);
   viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
@@ -2618,9 +2681,9 @@ async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirecto
   let response = await handler(request);
   let text = await response.text();
   validatePrerenderedResponse(response, text, "Prerender", normalizedPath);
-  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path4.dirname(outfile));
+  let outdir = path6.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path6.join(outdir, ...normalizedPath.split("/"));
+  await fse.ensureDir(path6.dirname(outfile));
   await fse.outputFile(outfile, text);
   viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
@@ -2629,17 +2692,17 @@ async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig,
     /\/\/+/g,
     "/"
   );
-  let outdir = path4.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path4.dirname(outfile));
+  let outdir = path6.relative(process.cwd(), clientBuildDirectory);
+  let outfile = path6.join(outdir, ...normalizedPath.split("/"));
+  await fse.ensureDir(path6.dirname(outfile));
   let manifestData = JSON.stringify(build.assets.routes);
   await fse.outputFile(outfile, manifestData);
   viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
-function validatePrerenderedResponse(response, html, prefix, path5) {
+function validatePrerenderedResponse(response, html, prefix, path7) {
   if (response.status !== 200) {
     throw new Error(
-      `${prefix}: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path5}\` path.
+      `${prefix}: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${path7}\` path.
 ${html}`
     );
   }
@@ -2674,8 +2737,6 @@ function createPrerenderRoutes(manifest, parentId = "", routesByParentId = group
       loader: route.module.loader ? () => null : void 0,
       action: void 0,
       handle: route.module.handle
-      // middleware is not necessary here since we just need to know which
-      // routes have loaders so we know what paths to prerender
     };
     return route.index ? {
       index: true,