@react-router/dev 0.0.0-experimental-b7b187661 → 0.0.0-experimental-e988dc602

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-b7b187661
+ * @react-router/dev v0.0.0-experimental-e988dc602
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -47,7 +47,7 @@ module.exports = __toCommonJS(vite_exports);
 // vite/plugin.ts
 var import_node_crypto = require("crypto");
 var fs3 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var url = __toESM(require("url"));
 var fse = __toESM(require("fs-extra"));
 var babel = __toESM(require("@babel/core"));
@@ -59,9 +59,10 @@ var import_picocolors3 = __toESM(require("picocolors"));
 var import_kebabCase = __toESM(require("lodash/kebabCase"));
 
 // typegen/index.ts
-var import_promises = __toESM(require("fs/promises"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_dedent2 = __toESM(require("dedent"));
 var Path4 = __toESM(require("pathe"));
-var import_picocolors2 = require("picocolors");
+var import_picocolors2 = __toESM(require("picocolors"));
 
 // config/config.ts
 var import_node_fs = __toESM(require("fs"));
@@ -135,15 +136,13 @@ var ssrExternals = isReactRouterRepo() ? [
 // vite/vite-node.ts
 async function createContext({
   root,
-  mode,
-  customLogger
+  mode
 }) {
   await preloadVite();
   const vite2 = getVite();
   const devServer = await vite2.createServer({
     root,
     mode,
-    customLogger,
     server: {
       preTransformRequests: false,
       hmr: false,
@@ -155,15 +154,6 @@ async function createContext({
     optimizeDeps: {
       noDiscovery: true
     },
-    css: {
-      // This empty PostCSS config object prevents the PostCSS config file from
-      // being loaded. We don't need it in a React Router config context, and
-      // there's also an issue in Vite 5 when using a .ts PostCSS config file in
-      // an ESM project: https://github.com/vitejs/vite/issues/15869. Consumers
-      // can work around this in their own Vite config file, but they can't
-      // configure this internal usage of vite-node.
-      postcss: {}
-    },
     configFile: false,
     envFile: false,
     plugins: []
@@ -241,7 +231,7 @@ function validateRouteConfig({
         `Route config in "${routeConfigFile}" is invalid.`,
         root ? `${root}` : [],
         nested ? Object.entries(nested).map(
-          ([path6, message]) => `Path: routes.${path6}
+          ([path7, message]) => `Path: routes.${path7}
 ${message}`
         ) : []
       ].flat().join("\n\n")
@@ -357,8 +347,7 @@ function err(error) {
 async function resolveConfig({
   root,
   viteNodeContext,
-  reactRouterConfigFile,
-  skipRoutes
+  reactRouterConfigFile
 }) {
   let reactRouterUserConfig = {};
   if (reactRouterConfigFile) {
@@ -407,17 +396,12 @@ async function resolveConfig({
     serverModuleFormat: "esm",
     ssr: true
   };
-  let userAndPresetConfigs = mergeReactRouterConfig(
-    ...presets,
-    reactRouterUserConfig
-  );
   let {
     appDirectory: userAppDirectory,
-    basename: basename3,
+    basename: basename2,
     buildDirectory: userBuildDirectory,
     buildEnd,
     prerender,
-    routeDiscovery: userRouteDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
@@ -425,7 +409,7 @@ async function resolveConfig({
   } = {
     ...defaults,
     // Default values should be completely overridden by user/preset config, not merged
-    ...userAndPresetConfigs
+    ...mergeReactRouterConfig(...presets, reactRouterUserConfig)
   };
   if (!ssr && serverBundles) {
     serverBundles = void 0;
@@ -436,32 +420,6 @@ 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 routeDiscovery;
-  if (userRouteDiscovery == null) {
-    if (ssr) {
-      routeDiscovery = {
-        mode: "lazy",
-        manifestPath: "/__manifest"
-      };
-    } else {
-      routeDiscovery = { mode: "initial" };
-    }
-  } else if (userRouteDiscovery.mode === "initial") {
-    routeDiscovery = userRouteDiscovery;
-  } else if (userRouteDiscovery.mode === "lazy") {
-    if (!ssr) {
-      return err(
-        'The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
-      );
-    }
-    let { manifestPath } = userRouteDiscovery;
-    if (manifestPath != null && !manifestPath.startsWith("/")) {
-      return err(
-        'The `routeDiscovery.manifestPath` config must be a root-relative pathname beginning with a slash (i.e., "/__manifest")'
-      );
-    }
-    routeDiscovery = userRouteDiscovery;
-  }
   let appDirectory = import_pathe3.default.resolve(root, userAppDirectory || "app");
   let buildDirectory = import_pathe3.default.resolve(root, userBuildDirectory);
   let rootRouteFile = findEntry(appDirectory, "root");
@@ -474,50 +432,45 @@ async function resolveConfig({
       `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
     );
   }
-  let routes = {};
-  if (!skipRoutes) {
-    routes = {
-      root: { path: "", id: "root", file: rootRouteFile }
-    };
-    let routeConfigFile = findEntry(appDirectory, "routes");
-    try {
-      if (!routeConfigFile) {
-        let routeConfigDisplayPath = import_pathe3.default.relative(
-          root,
-          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_pathe3.default.join(appDirectory, routeConfigFile)
-      )).default;
-      let routeConfig = await routeConfigExport;
-      let result = validateRouteConfig({
-        routeConfigFile,
-        routeConfig
-      });
-      if (!result.valid) {
-        return err(result.message);
-      }
-      routes = {
-        ...routes,
-        ...configRoutesToRouteManifest(appDirectory, routeConfig)
-      };
-    } catch (error) {
-      return err(
-        [
-          import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
-          "",
-          error.loc?.file && error.loc?.column && error.frame ? [
-            import_pathe3.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
-            error.frame.trim?.()
-          ] : error.stack
-        ].flat().join("\n")
+  let routes = {
+    root: { path: "", id: "root", file: rootRouteFile }
+  };
+  let routeConfigFile = findEntry(appDirectory, "routes");
+  try {
+    if (!routeConfigFile) {
+      let routeConfigDisplayPath = import_pathe3.default.relative(
+        root,
+        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_pathe3.default.join(appDirectory, routeConfigFile)
+    )).default;
+    let routeConfig = await routeConfigExport;
+    let result = validateRouteConfig({
+      routeConfigFile,
+      routeConfig
+    });
+    if (!result.valid) {
+      return err(result.message);
+    }
+    routes = {
+      ...routes,
+      ...configRoutesToRouteManifest(appDirectory, routeConfig)
+    };
+  } catch (error) {
+    return err(
+      [
+        import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
+        "",
+        error.loc?.file && error.loc?.column && error.frame ? [
+          import_pathe3.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          error.frame.trim?.()
+        ] : error.stack
+      ].flat().join("\n")
+    );
   }
   let future = {
     unstable_middleware: reactRouterUserConfig.future?.unstable_middleware ?? false,
@@ -528,13 +481,12 @@ async function resolveConfig({
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
-    basename: basename3,
+    basename: basename2,
     buildDirectory,
     buildEnd,
     future,
     prerender,
     routes,
-    routeDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
@@ -547,35 +499,24 @@ async function resolveConfig({
 }
 async function createConfigLoader({
   rootDirectory: root,
-  watch: watch2,
-  mode,
-  skipRoutes
+  watch: watch2
 }) {
-  root = import_pathe3.default.normalize(root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd());
-  let vite2 = await import("vite");
+  root = root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
   let viteNodeContext = await createContext({
     root,
-    mode,
-    // Filter out any info level logs from vite-node
-    customLogger: vite2.createLogger("warn", {
-      prefix: "[react-router]"
-    })
+    mode: watch2 ? "development" : "production"
   });
-  let reactRouterConfigFile;
-  let updateReactRouterConfigFile = () => {
-    reactRouterConfigFile = findEntry(root, "react-router.config", {
-      absolute: true
-    });
-  };
-  updateReactRouterConfigFile();
-  let getConfig = () => resolveConfig({ root, viteNodeContext, reactRouterConfigFile, skipRoutes });
+  let reactRouterConfigFile = findEntry(root, "react-router.config", {
+    absolute: true
+  });
+  let getConfig = () => resolveConfig({ root, viteNodeContext, reactRouterConfigFile });
   let appDirectory;
   let initialConfigResult = await getConfig();
   if (!initialConfigResult.ok) {
     throw new Error(initialConfigResult.error);
   }
-  appDirectory = import_pathe3.default.normalize(initialConfigResult.value.appDirectory);
-  let currentConfig = initialConfigResult.value;
+  appDirectory = initialConfigResult.value.appDirectory;
+  let lastConfig = initialConfigResult.value;
   let fsWatcher;
   let changeHandlers = [];
   return {
@@ -588,71 +529,41 @@ async function createConfigLoader({
       }
       changeHandlers.push(handler);
       if (!fsWatcher) {
-        fsWatcher = import_chokidar.default.watch([root, appDirectory], {
-          ignoreInitial: true,
-          ignored: (path6) => {
-            let dirname4 = import_pathe3.default.dirname(path6);
-            return !dirname4.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
-            // that are at the root level, not nested in subdirectories
-            path6 !== root && // Watch the root directory itself
-            dirname4 !== root;
-          }
-        });
+        fsWatcher = import_chokidar.default.watch(
+          [
+            ...reactRouterConfigFile ? [reactRouterConfigFile] : [],
+            appDirectory
+          ],
+          { ignoreInitial: true }
+        );
         fsWatcher.on("all", async (...args) => {
           let [event, rawFilepath] = args;
           let filepath = import_pathe3.default.normalize(rawFilepath);
-          let fileAddedOrRemoved = event === "add" || event === "unlink";
-          let appFileAddedOrRemoved = fileAddedOrRemoved && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
-          let rootRelativeFilepath = import_pathe3.default.relative(root, filepath);
-          let configFileAddedOrRemoved = fileAddedOrRemoved && isEntryFile("react-router.config", rootRelativeFilepath);
-          if (configFileAddedOrRemoved) {
-            updateReactRouterConfigFile();
-          }
-          let moduleGraphChanged = configFileAddedOrRemoved || Boolean(
+          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
+          let configCodeUpdated = Boolean(
             viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
           );
-          if (!moduleGraphChanged && !appFileAddedOrRemoved) {
-            return;
+          if (configCodeUpdated || appFileAddedOrRemoved) {
+            viteNodeContext.devServer?.moduleGraph.invalidateAll();
+            viteNodeContext.runner?.moduleCache.clear();
           }
-          viteNodeContext.devServer?.moduleGraph.invalidateAll();
-          viteNodeContext.runner?.moduleCache.clear();
-          let result = await getConfig();
-          let prevAppDirectory = appDirectory;
-          appDirectory = import_pathe3.default.normalize(
-            (result.value ?? currentConfig).appDirectory
-          );
-          if (appDirectory !== prevAppDirectory) {
-            fsWatcher.unwatch(prevAppDirectory);
-            fsWatcher.add(appDirectory);
-          }
-          let configCodeChanged = configFileAddedOrRemoved || reactRouterConfigFile !== void 0 && isEntryFileDependency(
-            viteNodeContext.devServer.moduleGraph,
-            reactRouterConfigFile,
-            filepath
-          );
-          let routeConfigFile = !skipRoutes ? findEntry(appDirectory, "routes", {
-            absolute: true
-          }) : void 0;
-          let routeConfigCodeChanged = routeConfigFile !== void 0 && isEntryFileDependency(
-            viteNodeContext.devServer.moduleGraph,
-            routeConfigFile,
-            filepath
-          );
-          let configChanged = result.ok && !(0, import_isEqual.default)(omitRoutes(currentConfig), omitRoutes(result.value));
-          let routeConfigChanged = result.ok && !(0, import_isEqual.default)(currentConfig?.routes, result.value.routes);
-          for (let handler2 of changeHandlers) {
-            handler2({
-              result,
-              configCodeChanged,
-              routeConfigCodeChanged,
-              configChanged,
-              routeConfigChanged,
-              path: filepath,
-              event
-            });
-          }
-          if (result.ok) {
-            currentConfig = result.value;
+          if (appFileAddedOrRemoved || configCodeUpdated) {
+            let result = await getConfig();
+            let configChanged = result.ok && !(0, import_isEqual.default)(lastConfig, result.value);
+            let routeConfigChanged = result.ok && !(0, import_isEqual.default)(lastConfig?.routes, result.value.routes);
+            for (let handler2 of changeHandlers) {
+              handler2({
+                result,
+                configCodeUpdated,
+                configChanged,
+                routeConfigChanged,
+                path: filepath,
+                event
+              });
+            }
+            if (result.ok) {
+              lastConfig = result.value;
+            }
           }
         });
       }
@@ -684,18 +595,7 @@ async function resolveEntryFiles({
   let userEntryServerFile = findEntry(appDirectory, "entry.server");
   let entryServerFile;
   let entryClientFile = userEntryClientFile || "entry.client.tsx";
-  let packageJsonPath = findEntry(rootDirectory, "package", {
-    extensions: [".json"],
-    absolute: true,
-    walkParents: true
-  });
-  if (!packageJsonPath) {
-    throw new Error(
-      `Could not find package.json in ${rootDirectory} or any of its parent directories`
-    );
-  }
-  let packageJsonDirectory = import_pathe3.default.dirname(packageJsonPath);
-  let pkgJson = await import_package_json.default.load(packageJsonDirectory);
+  let pkgJson = await import_package_json.default.load(rootDirectory);
   let deps = pkgJson.content.dependencies ?? {};
   if (userEntryServerFile) {
     entryServerFile = userEntryServerFile;
@@ -718,7 +618,7 @@ async function resolveEntryFiles({
       await pkgJson.save();
       let packageManager = detectPackageManager() ?? "npm";
       (0, import_node_child_process.execSync)(`${packageManager} install`, {
-        cwd: packageJsonDirectory,
+        cwd: rootDirectory,
         stdio: "inherit"
       });
     }
@@ -728,85 +628,17 @@ async function resolveEntryFiles({
   let entryServerFilePath = userEntryServerFile ? import_pathe3.default.resolve(reactRouterConfig.appDirectory, userEntryServerFile) : import_pathe3.default.resolve(defaultsDirectory, entryServerFile);
   return { entryClientFilePath, entryServerFilePath };
 }
-function omitRoutes(config) {
-  return {
-    ...config,
-    routes: {}
-  };
-}
 var entryExts = [".js", ".jsx", ".ts", ".tsx"];
-function isEntryFile(entryBasename, filename2) {
-  return entryExts.some((ext) => filename2 === `${entryBasename}${ext}`);
-}
-function findEntry(dir, basename3, options) {
-  let currentDir = import_pathe3.default.resolve(dir);
-  let { root } = import_pathe3.default.parse(currentDir);
-  while (true) {
-    for (let ext of options?.extensions ?? entryExts) {
-      let file = import_pathe3.default.resolve(currentDir, basename3 + ext);
-      if (import_node_fs.default.existsSync(file)) {
-        return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
-      }
-    }
-    if (!options?.walkParents) {
-      return void 0;
-    }
-    let parentDir = import_pathe3.default.dirname(currentDir);
-    if (currentDir === root || parentDir === currentDir) {
-      return void 0;
-    }
-    currentDir = parentDir;
-  }
-}
-function isEntryFileDependency(moduleGraph, entryFilepath, filepath, visited = /* @__PURE__ */ new Set()) {
-  entryFilepath = import_pathe3.default.normalize(entryFilepath);
-  filepath = import_pathe3.default.normalize(filepath);
-  if (visited.has(filepath)) {
-    return false;
-  }
-  visited.add(filepath);
-  if (filepath === entryFilepath) {
-    return true;
-  }
-  let mod = moduleGraph.getModuleById(filepath);
-  if (!mod) {
-    return false;
-  }
-  for (let importer of mod.importers) {
-    if (!importer.id) {
-      continue;
-    }
-    if (importer.id === entryFilepath || isEntryFileDependency(moduleGraph, entryFilepath, importer.id, visited)) {
-      return true;
+function findEntry(dir, basename2, options) {
+  for (let ext of entryExts) {
+    let file = import_pathe3.default.resolve(dir, basename2 + ext);
+    if (import_node_fs.default.existsSync(file)) {
+      return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
     }
   }
-  return false;
+  return void 0;
 }
 
-// typegen/context.ts
-async function createContext2({
-  rootDirectory,
-  watch: watch2,
-  mode
-}) {
-  const configLoader = await createConfigLoader({ rootDirectory, mode, watch: watch2 });
-  const configResult = await configLoader.getConfig();
-  if (!configResult.ok) {
-    throw new Error(configResult.error);
-  }
-  const config = configResult.value;
-  return {
-    configLoader,
-    rootDirectory,
-    config
-  };
-}
-
-// typegen/generate.ts
-var import_dedent = __toESM(require("dedent"));
-var Path3 = __toESM(require("pathe"));
-var Pathe = __toESM(require("pathe/utils"));
-
 // vite/babel.ts
 var babel_exports = {};
 __export(babel_exports, {
@@ -820,6 +652,26 @@ var t = __toESM(require("@babel/types"));
 var traverse = require("@babel/traverse").default;
 var generate = require("@babel/generator").default;
 
+// typegen/generate.ts
+var import_dedent = __toESM(require("dedent"));
+var Path3 = __toESM(require("pathe"));
+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/params.ts
 function parse2(fullpath2) {
   const result = {};
@@ -850,330 +702,194 @@ function lineage(routes, route) {
 }
 function fullpath(lineage2) {
   if (lineage2.length === 1 && lineage2[0].id === "root") return "/";
-  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path6) => path6 !== void 0 && path6 !== "").join("/");
+  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path7) => path7 !== void 0 && path7 !== "").join("/");
 }
 
 // typegen/generate.ts
-function typesDirectory(ctx) {
-  return Path3.join(ctx.rootDirectory, ".react-router/types");
-}
-function generateFuture(ctx) {
-  const filename2 = Path3.join(typesDirectory(ctx), "+future.ts");
-  const content = import_dedent.default`
-    // Generated by React Router
+function generate2(ctx, route) {
+  const lineage2 = lineage(ctx.config.routes, route);
+  const fullpath2 = fullpath(lineage2);
+  const typesPath = getTypesPath(ctx, route);
+  const parents = lineage2.slice(0, -1);
+  const parentTypeImports = parents.map((parent, i) => {
+    const rel = Path3.relative(
+      Path3.dirname(typesPath),
+      getTypesPath(ctx, parent)
+    );
+    const indent = i === 0 ? "" : "  ".repeat(2);
+    let source = noExtension(rel);
+    if (!source.startsWith("../")) source = "./" + source;
+    return `${indent}import type { Info as Parent${i} } from "${source}.js"`;
+  }).join("\n");
+  return import_dedent.default`
+    // React Router generated types for route:
+    // ${route.file}
 
-    import "react-router";
+    import type * as T from "react-router/route-module"
 
-    declare module "react-router" {
-      interface Future {
-        unstable_middleware: ${ctx.config.future.unstable_middleware}
-      }
+    ${parentTypeImports}
+
+    type Module = typeof import("../${Pathe2.filename(route.file)}.js")
+
+    export type Info = {
+      parents: [${parents.map((_, i) => `Parent${i}`).join(", ")}],
+      id: "${route.id}"
+      file: "${route.file}"
+      path: "${route.path}"
+      params: {${formatParamProperties(
+    fullpath2
+  )}} & { [key: string]: string | undefined }
+      module: Module
+      loaderData: T.CreateLoaderData<Module>
+      actionData: T.CreateActionData<Module>
+    }
+
+    export namespace Route {
+      export type LinkDescriptors = T.LinkDescriptors
+      export type LinksFunction = () => LinkDescriptors
+
+      export type MetaArgs = T.CreateMetaArgs<Info>
+      export type MetaDescriptors = T.MetaDescriptors
+      export type MetaFunction = (args: MetaArgs) => MetaDescriptors
+
+      export type HeadersArgs = T.HeadersArgs
+      export type HeadersFunction = (args: HeadersArgs) => Headers | HeadersInit
+
+      export type unstable_MiddlewareFunction = T.CreateServerMiddlewareFunction<Info>
+      export type unstable_ClientMiddlewareFunction = T.CreateClientMiddlewareFunction<Info>
+      export type LoaderArgs = T.CreateServerLoaderArgs<Info>
+      export type ClientLoaderArgs = T.CreateClientLoaderArgs<Info>
+      export type ActionArgs = T.CreateServerActionArgs<Info>
+      export type ClientActionArgs = T.CreateClientActionArgs<Info>
+
+      export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Info>
+      export type ComponentProps = T.CreateComponentProps<Info>
+      export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Info>
     }
   `;
-  return { filename: filename2, content };
 }
-function generateServerBuild(ctx) {
-  const filename2 = Path3.join(typesDirectory(ctx), "+server-build.d.ts");
-  const content = import_dedent.default`
-    // Generated by React Router
+var noExtension = (path7) => Path3.join(Path3.dirname(path7), Pathe2.filename(path7));
+function formatParamProperties(fullpath2) {
+  const params = parse2(fullpath2);
+  const properties = Object.entries(params).map(
+    ([name, isRequired]) => isRequired ? `"${name}": string` : `"${name}"?: string`
+  );
+  return properties.join("; ");
+}
 
-    declare module "virtual:react-router/server-build" {
-      import { ServerBuild } from "react-router";
-      export const assets: ServerBuild["assets"];
-      export const assetsBuildDirectory: ServerBuild["assetsBuildDirectory"];
-      export const basename: ServerBuild["basename"];
-      export const entry: ServerBuild["entry"];
-      export const future: ServerBuild["future"];
-      export const isSpaMode: ServerBuild["isSpaMode"];
-      export const prerender: ServerBuild["prerender"];
-      export const publicPath: ServerBuild["publicPath"];
-      export const routeDiscovery: ServerBuild["routeDiscovery"];
-      export const routes: ServerBuild["routes"];
-      export const ssr: ServerBuild["ssr"];
-      export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
+// typegen/index.ts
+async function watch(rootDirectory, { logger } = {}) {
+  const ctx = await createContext2({ rootDirectory, watch: true });
+  await writeAll(ctx);
+  logger?.info(import_picocolors2.default.green("generated types"), { timestamp: true, clear: true });
+  ctx.configLoader.onChange(async ({ result, routeConfigChanged }) => {
+    if (!result.ok) {
+      logger?.error(import_picocolors2.default.red(result.error), { timestamp: true, clear: true });
+      return;
     }
-  `;
-  return { filename: filename2, content };
+    ctx.config = result.value;
+    if (routeConfigChanged) {
+      await writeAll(ctx);
+      logger?.info(import_picocolors2.default.green("regenerated types"), {
+        timestamp: true,
+        clear: true
+      });
+    }
+  });
+  return {
+    close: async () => await ctx.configLoader.close()
+  };
 }
-var { t: t2 } = babel_exports;
-function generatePages(ctx) {
-  const filename2 = Path3.join(typesDirectory(ctx), "+pages.ts");
-  const fullpaths = /* @__PURE__ */ new Set();
+async function createContext2({
+  rootDirectory,
+  watch: watch2
+}) {
+  const configLoader = await createConfigLoader({ rootDirectory, watch: watch2 });
+  const configResult = await configLoader.getConfig();
+  if (!configResult.ok) {
+    throw new Error(configResult.error);
+  }
+  const config = configResult.value;
+  return {
+    configLoader,
+    rootDirectory,
+    config
+  };
+}
+async function writeAll(ctx) {
+  const typegenDir = getTypesDir(ctx);
+  import_node_fs2.default.rmSync(typegenDir, { recursive: true, force: true });
   Object.values(ctx.config.routes).forEach((route) => {
-    if (route.id !== "root" && !route.path) return;
-    const lineage2 = lineage(ctx.config.routes, route);
-    const fullpath2 = fullpath(lineage2);
-    fullpaths.add(fullpath2);
+    const typesPath = getTypesPath(ctx, route);
+    const content = generate2(ctx, route);
+    import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
+    import_node_fs2.default.writeFileSync(typesPath, content);
   });
-  const pagesType = t2.tsTypeAliasDeclaration(
-    t2.identifier("Pages"),
-    null,
-    t2.tsTypeLiteral(
-      Array.from(fullpaths).map((fullpath2) => {
-        return t2.tsPropertySignature(
-          t2.stringLiteral(fullpath2),
-          t2.tsTypeAnnotation(
-            t2.tsTypeLiteral([
-              t2.tsPropertySignature(
-                t2.identifier("params"),
-                t2.tsTypeAnnotation(paramsType(fullpath2))
-              )
-            ])
-          )
-        );
-      })
-    )
-  );
-  const content = import_dedent.default`
-      // Generated by React Router
-
-      import "react-router"
+  const registerPath = Path4.join(typegenDir, "+register.ts");
+  import_node_fs2.default.writeFileSync(registerPath, register(ctx));
+  const virtualPath = Path4.join(typegenDir, "+virtual.d.ts");
+  import_node_fs2.default.writeFileSync(virtualPath, virtual);
+}
+function register(ctx) {
+  const register2 = import_dedent2.default`
+    import "react-router";
 
-      declare module "react-router" {
-        interface Register {
-          pages: Pages
-        }
+    declare module "react-router" {
+      interface Register {
+        params: Params;
       }
-    ` + "\n\n" + generate(pagesType).code;
-  return { filename: filename2, content };
-}
-function generateRoutes(ctx) {
-  const filename2 = Path3.join(typesDirectory(ctx), "+routes-pre.ts");
-  const routesType = t2.tsTypeAliasDeclaration(
-    t2.identifier("routesPre"),
+    }
+  `;
+  const { t: t2 } = babel_exports;
+  const indexPaths = new Set(
+    Object.values(ctx.config.routes).filter((route) => route.index).map((route) => route.path)
+  );
+  const typeParams = t2.tsTypeAliasDeclaration(
+    t2.identifier("Params"),
     null,
     t2.tsTypeLiteral(
       Object.values(ctx.config.routes).map((route) => {
+        if (route.id !== "root" && !route.path) return void 0;
+        if (!route.index && indexPaths.has(route.path)) return void 0;
+        const lineage2 = lineage(ctx.config.routes, route);
+        const fullpath2 = fullpath(lineage2);
+        const params = parse2(fullpath2);
         return t2.tsPropertySignature(
-          t2.stringLiteral(route.id),
+          t2.stringLiteral(fullpath2),
           t2.tsTypeAnnotation(
-            t2.tsTypeLiteral([
-              t2.tsPropertySignature(
-                t2.identifier("parentId"),
-                t2.tsTypeAnnotation(
-                  route.parentId ? t2.tsLiteralType(t2.stringLiteral(route.parentId)) : t2.tsUndefinedKeyword()
-                )
-              ),
-              t2.tsPropertySignature(
-                t2.identifier("path"),
-                t2.tsTypeAnnotation(
-                  route.path ? t2.tsLiteralType(t2.stringLiteral(route.path)) : t2.tsUndefinedKeyword()
-                )
-              ),
-              t2.tsPropertySignature(
-                t2.identifier("params"),
-                t2.tsTypeAnnotation(paramsType(route.path ?? ""))
-              ),
-              t2.tsPropertySignature(
-                t2.identifier("index"),
-                t2.tsTypeAnnotation(
-                  t2.tsLiteralType(t2.booleanLiteral(route.index ?? false))
-                )
-              ),
-              t2.tsPropertySignature(
-                t2.identifier("file"),
-                t2.tsTypeAnnotation(t2.tsLiteralType(t2.stringLiteral(route.file)))
-              )
-            ])
+            t2.tsTypeLiteral(
+              Object.entries(params).map(([param, isRequired]) => {
+                const property = t2.tsPropertySignature(
+                  t2.stringLiteral(param),
+                  t2.tsTypeAnnotation(t2.tsStringKeyword())
+                );
+                property.optional = !isRequired;
+                return property;
+              })
+            )
           )
         );
-      })
+      }).filter((x) => x !== void 0)
     )
   );
-  const content = import_dedent.default`
-      // Generated by React Router
-
-      import "react-router"
-
-      declare module "react-router" {
-        interface Register {
-          routesPre: routesPre
-        }
-      }
-    ` + "\n\n" + generate(routesType).code;
-  return { filename: filename2, content };
-}
-function generateRouteModuleAnnotations(ctx) {
-  return Object.values(ctx.config.routes).filter((route) => isRouteInAppDirectory(ctx, route)).map((route) => {
-    const filename2 = getRouteModuleAnnotationsFilepath(ctx, route);
-    const parents = getParents(ctx, route);
-    const content = import_dedent.default`
-        // Generated by React Router
-
-        import type {
-          Params,
-          RouteModuleAnnotations,
-          CreateLoaderData,
-          CreateActionData,
-        } from "react-router/internal";
-
-        ${parents.map((parent) => parent.import).join("\n" + "  ".repeat(3))}
-        type Parents = [${parents.map((parent) => parent.name).join(", ")}]
-
-        type Id = "${route.id}"
-        type Module = typeof import("../${Pathe.filename(route.file)}.js")
-
-        export type unstable_Props = {
-          params: Params[Id]
-          loaderData: CreateLoaderData<Module>
-          actionData: CreateActionData<Module>
-        }
-
-        type Annotations = RouteModuleAnnotations<unstable_Props & {
-          parents: Parents,
-          module: Module,
-        }>;
-
-        export namespace Route {
-          // links
-          export type LinkDescriptors = Annotations["LinkDescriptors"];
-          export type LinksFunction = Annotations["LinksFunction"];
-
-          // meta
-          export type MetaArgs = Annotations["MetaArgs"];
-          export type MetaDescriptors = Annotations["MetaDescriptors"];
-          export type MetaFunction = Annotations["MetaFunction"];
-
-          // headers
-          export type HeadersArgs = Annotations["HeadersArgs"];
-          export type HeadersFunction = Annotations["HeadersFunction"];
-
-          // unstable_middleware
-          export type unstable_MiddlewareFunction = Annotations["unstable_MiddlewareFunction"];
-
-          // unstable_clientMiddleware
-          export type unstable_ClientMiddlewareFunction = Annotations["unstable_ClientMiddlewareFunction"];
-
-          // loader
-          export type LoaderArgs = Annotations["LoaderArgs"];
-
-          // clientLoader
-          export type ClientLoaderArgs = Annotations["ClientLoaderArgs"];
-
-          // action
-          export type ActionArgs = Annotations["ActionArgs"];
-
-          // clientAction
-          export type ClientActionArgs = Annotations["ClientActionArgs"];
-
-          // HydrateFallback
-          export type HydrateFallbackProps = Annotations["HydrateFallbackProps"];
-
-          // Component
-          export type ComponentProps = Annotations["ComponentProps"];
-
-          // ErrorBoundary
-          export type ErrorBoundaryProps = Annotations["ErrorBoundaryProps"];
-        }
-      `;
-    return { filename: filename2, content };
-  });
-}
-function isRouteInAppDirectory(ctx, route) {
-  const absoluteRoutePath = Path3.resolve(ctx.config.appDirectory, route.file);
-  return absoluteRoutePath.startsWith(ctx.config.appDirectory);
-}
-function getRouteModuleAnnotationsFilepath(ctx, route) {
-  return Path3.join(
-    typesDirectory(ctx),
-    Path3.relative(ctx.rootDirectory, ctx.config.appDirectory),
-    Path3.dirname(route.file),
-    "+types/" + Pathe.filename(route.file) + ".ts"
-  );
-}
-function getParents(ctx, route) {
-  const typesPath = getRouteModuleAnnotationsFilepath(ctx, route);
-  const lineage2 = lineage(ctx.config.routes, route);
-  const parents = lineage2.slice(0, -1);
-  return parents.map((parent, i) => {
-    const rel = Path3.relative(
-      Path3.dirname(typesPath),
-      getRouteModuleAnnotationsFilepath(ctx, parent)
-    );
-    let source = noExtension(rel);
-    if (!source.startsWith("../")) source = "./" + source;
-    const name = `Parent${i}`;
-    return {
-      name,
-      import: `import type { unstable_Props as ${name} } from "${source}.js"`
-    };
-  });
-}
-function noExtension(path6) {
-  return Path3.join(Path3.dirname(path6), Pathe.filename(path6));
-}
-function paramsType(path6) {
-  const params = parse2(path6);
-  return t2.tsTypeLiteral(
-    Object.entries(params).map(([param, isRequired]) => {
-      const property = t2.tsPropertySignature(
-        t2.stringLiteral(param),
-        t2.tsTypeAnnotation(t2.tsStringKeyword())
-      );
-      property.optional = !isRequired;
-      return property;
-    })
-  );
-}
-
-// typegen/index.ts
-async function clearRouteModuleAnnotations(ctx) {
-  await import_promises.default.rm(
-    Path4.join(typesDirectory(ctx), Path4.basename(ctx.config.appDirectory)),
-    { recursive: true, force: true }
-  );
-}
-async function write(...files) {
-  return Promise.all(
-    files.map(async ({ filename: filename2, content }) => {
-      await import_promises.default.mkdir(Path4.dirname(filename2), { recursive: true });
-      await import_promises.default.writeFile(filename2, content);
-    })
-  );
-}
-async function watch(rootDirectory, { mode, logger }) {
-  const ctx = await createContext2({ rootDirectory, mode, watch: true });
-  await import_promises.default.rm(typesDirectory(ctx), { recursive: true, force: true });
-  await write(
-    generateFuture(ctx),
-    generatePages(ctx),
-    generateRoutes(ctx),
-    generateServerBuild(ctx),
-    ...generateRouteModuleAnnotations(ctx)
-  );
-  logger?.info((0, import_picocolors2.green)("generated types"), { timestamp: true, clear: true });
-  ctx.configLoader.onChange(
-    async ({ result, configChanged, routeConfigChanged }) => {
-      if (!result.ok) {
-        logger?.error((0, import_picocolors2.red)(result.error), { timestamp: true, clear: true });
-        return;
-      }
-      ctx.config = result.value;
-      if (configChanged) {
-        await write(generateFuture(ctx));
-        logger?.info((0, import_picocolors2.green)("regenerated types"), {
-          timestamp: true,
-          clear: true
-        });
-      }
-      if (routeConfigChanged) {
-        await clearRouteModuleAnnotations(ctx);
-        await write(
-          generatePages(ctx),
-          generateRoutes(ctx),
-          ...generateRouteModuleAnnotations(ctx)
-        );
-        logger?.info((0, import_picocolors2.green)("regenerated types"), {
-          timestamp: true,
-          clear: true
-        });
-      }
-    }
-  );
-  return {
-    close: async () => await ctx.configLoader.close()
-  };
+  return [register2, generate(typeParams).code].join("\n\n");
 }
+var virtual = import_dedent2.default`
+  declare module "virtual:react-router/server-build" {
+    import { ServerBuild } from "react-router";
+    export const assets: ServerBuild["assets"];
+    export const assetsBuildDirectory: ServerBuild["assetsBuildDirectory"];
+    export const basename: ServerBuild["basename"];
+    export const entry: ServerBuild["entry"];
+    export const future: ServerBuild["future"];
+    export const isSpaMode: ServerBuild["isSpaMode"];
+    export const prerender: ServerBuild["prerender"];
+    export const publicPath: ServerBuild["publicPath"];
+    export const routes: ServerBuild["routes"];
+    export const ssr: ServerBuild["ssr"];
+    export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
+  }
+`;
 
 // vite/node-adapter.ts
 var import_node_events = require("events");
@@ -1229,9 +945,7 @@ function fromNodeRequest(nodeReq, nodeRes) {
 }
 async function toNodeRequest(res, nodeRes) {
   nodeRes.statusCode = res.status;
-  if (!nodeRes.req || nodeRes.req.httpVersionMajor < 2) {
-    nodeRes.statusMessage = res.statusText;
-  }
+  nodeRes.statusMessage = res.statusText;
   let cookiesStrings = [];
   for (let [name, value] of res.headers) {
     if (name === "set-cookie") {
@@ -1252,17 +966,17 @@ async function toNodeRequest(res, nodeRes) {
 }
 
 // vite/styles.ts
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 var import_react_router = require("react-router");
 
 // vite/resolve-file-url.ts
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var resolveFileUrl = ({ rootDirectory }, filePath) => {
   let vite2 = getVite();
-  let relativePath = path3.relative(rootDirectory, filePath);
-  let isWithinRoot = !relativePath.startsWith("..") && !path3.isAbsolute(relativePath);
+  let relativePath = path4.relative(rootDirectory, filePath);
+  let isWithinRoot = !relativePath.startsWith("..") && !path4.isAbsolute(relativePath);
   if (!isWithinRoot) {
-    return path3.posix.join("/@fs", vite2.normalizePath(filePath));
+    return path4.posix.join("/@fs", vite2.normalizePath(filePath));
   }
   return "/" + vite2.normalizePath(relativePath);
 };
@@ -1299,7 +1013,7 @@ var getStylesForFiles = async ({
   let deps = /* @__PURE__ */ new Set();
   try {
     for (let file of files) {
-      let normalizedPath = path4.resolve(rootDirectory, file).replace(/\\/g, "/");
+      let normalizedPath = path5.resolve(rootDirectory, file).replace(/\\/g, "/");
       let node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
       if (!node) {
         try {
@@ -1400,9 +1114,9 @@ var getStylesForPathname = async ({
     return void 0;
   }
   let routesWithChildren = createRoutesWithChildren(reactRouterConfig.routes);
-  let appPath = path4.relative(process.cwd(), reactRouterConfig.appDirectory);
+  let appPath = path5.relative(process.cwd(), reactRouterConfig.appDirectory);
   let documentRouteFiles = (0, import_react_router.matchRoutes)(routesWithChildren, pathname, reactRouterConfig.basename)?.map(
-    (match) => path4.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
+    (match) => path5.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
   ) ?? [];
   let styles = await getStylesForFiles({
     viteDevServer,
@@ -1410,27 +1124,13 @@ var getStylesForPathname = async ({
     loadCssContents,
     files: [
       // Always include the client entry file when crawling the module graph for CSS
-      path4.relative(rootDirectory, entryClientFilePath),
+      path5.relative(rootDirectory, entryClientFilePath),
       // Then include any styles from the matched routes
       ...documentRouteFiles
     ]
   });
   return styles;
 };
-var getCssStringFromViteDevModuleCode = (code) => {
-  let cssContent = void 0;
-  const ast = import_parser.parse(code, { sourceType: "module" });
-  traverse(ast, {
-    VariableDeclaration(path6) {
-      const declaration = path6.node.declarations[0];
-      if (declaration?.id?.type === "Identifier" && declaration.id.name === "__vite__css" && declaration.init?.type === "StringLiteral") {
-        cssContent = declaration.init.value;
-        path6.stop();
-      }
-    }
-  });
-  return cssContent;
-};
 
 // vite/virtual-module.ts
 function create(name) {
@@ -1454,10 +1154,10 @@ var removeExports = (ast, exportsToRemove) => {
   let exportsFiltered = false;
   let markedForRemoval = /* @__PURE__ */ new Set();
   traverse(ast, {
-    ExportDeclaration(path6) {
-      if (path6.node.type === "ExportNamedDeclaration") {
-        if (path6.node.specifiers.length) {
-          path6.node.specifiers = path6.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;
@@ -1466,12 +1166,12 @@ var removeExports = (ast, exportsToRemove) => {
             }
             return true;
           });
-          if (path6.node.specifiers.length === 0) {
-            markedForRemoval.add(path6);
+          if (path7.node.specifiers.length === 0) {
+            markedForRemoval.add(path7);
           }
         }
-        if (path6.node.declaration?.type === "VariableDeclaration") {
-          let declaration = path6.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)) {
@@ -1485,30 +1185,30 @@ var removeExports = (ast, exportsToRemove) => {
             }
           );
           if (declaration.declarations.length === 0) {
-            markedForRemoval.add(path6);
+            markedForRemoval.add(path7);
           }
         }
-        if (path6.node.declaration?.type === "FunctionDeclaration") {
-          let id = path6.node.declaration.id;
+        if (path7.node.declaration?.type === "FunctionDeclaration") {
+          let id = path7.node.declaration.id;
           if (id && exportsToRemove.includes(id.name)) {
-            markedForRemoval.add(path6);
+            markedForRemoval.add(path7);
           }
         }
-        if (path6.node.declaration?.type === "ClassDeclaration") {
-          let id = path6.node.declaration.id;
+        if (path7.node.declaration?.type === "ClassDeclaration") {
+          let id = path7.node.declaration.id;
           if (id && exportsToRemove.includes(id.name)) {
-            markedForRemoval.add(path6);
+            markedForRemoval.add(path7);
           }
         }
       }
-      if (path6.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
-        markedForRemoval.add(path6);
+      if (path7.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
+        markedForRemoval.add(path7);
       }
     }
   });
   if (markedForRemoval.size > 0 || exportsFiltered) {
-    for (let path6 of markedForRemoval) {
-      path6.remove();
+    for (let path7 of markedForRemoval) {
+      path7.remove();
     }
     (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
   }
@@ -1579,28 +1279,28 @@ function codeToAst(code, cache, cacheKey) {
     )
   );
 }
-function assertNodePath(path6) {
+function assertNodePath(path7) {
   invariant(
-    path6 && !Array.isArray(path6),
-    `Expected a Path, but got ${Array.isArray(path6) ? "an array" : path6}`
+    path7 && !Array.isArray(path7),
+    `Expected a Path, but got ${Array.isArray(path7) ? "an array" : path7}`
   );
 }
-function assertNodePathIsStatement(path6) {
+function assertNodePathIsStatement(path7) {
   invariant(
-    path6 && !Array.isArray(path6) && t.isStatement(path6.node),
-    `Expected a Statement path, but got ${Array.isArray(path6) ? "an array" : path6?.node?.type}`
+    path7 && !Array.isArray(path7) && t.isStatement(path7.node),
+    `Expected a Statement path, but got ${Array.isArray(path7) ? "an array" : path7?.node?.type}`
   );
 }
-function assertNodePathIsVariableDeclarator(path6) {
+function assertNodePathIsVariableDeclarator(path7) {
   invariant(
-    path6 && !Array.isArray(path6) && t.isVariableDeclarator(path6.node),
-    `Expected an Identifier path, but got ${Array.isArray(path6) ? "an array" : path6?.node?.type}`
+    path7 && !Array.isArray(path7) && t.isVariableDeclarator(path7.node),
+    `Expected an Identifier path, but got ${Array.isArray(path7) ? "an array" : path7?.node?.type}`
   );
 }
-function assertNodePathIsPattern(path6) {
+function assertNodePathIsPattern(path7) {
   invariant(
-    path6 && !Array.isArray(path6) && t.isPattern(path6.node),
-    `Expected a Pattern path, but got ${Array.isArray(path6) ? "an array" : path6?.node?.type}`
+    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) {
@@ -1636,8 +1336,8 @@ function getExportDependencies(code, cache, cacheKey) {
           }
           let isWithinExportDestructuring = Boolean(
             identifier.findParent(
-              (path6) => Boolean(
-                path6.isPattern() && path6.parentPath?.isVariableDeclarator() && path6.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()
+              (path7) => Boolean(
+                path7.isPattern() && path7.parentPath?.isVariableDeclarator() && path7.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()
               )
             )
           );
@@ -1715,7 +1415,7 @@ function getExportDependencies(code, cache, cacheKey) {
             for (let specifier of node.specifiers) {
               if (t.isIdentifier(specifier.exported)) {
                 let name = specifier.exported.name;
-                let specifierPath = exportPath.get("specifiers").find((path6) => path6.node === specifier);
+                let specifierPath = exportPath.get("specifiers").find((path7) => path7.node === specifier);
                 invariant(
                   specifierPath,
                   `Expected to find specifier path for ${name}`
@@ -1732,22 +1432,22 @@ function getExportDependencies(code, cache, cacheKey) {
     }
   );
 }
-function getDependentIdentifiersForPath(path6, state) {
+function getDependentIdentifiersForPath(path7, state) {
   let { visited, identifiers } = state ?? {
     visited: /* @__PURE__ */ new Set(),
     identifiers: /* @__PURE__ */ new Set()
   };
-  if (visited.has(path6)) {
+  if (visited.has(path7)) {
     return identifiers;
   }
-  visited.add(path6);
-  path6.traverse({
-    Identifier(path7) {
-      if (identifiers.has(path7)) {
+  visited.add(path7);
+  path7.traverse({
+    Identifier(path8) {
+      if (identifiers.has(path8)) {
         return;
       }
-      identifiers.add(path7);
-      let binding = path7.scope.getBinding(path7.node.name);
+      identifiers.add(path8);
+      let binding = path8.scope.getBinding(path8.node.name);
       if (!binding) {
         return;
       }
@@ -1769,7 +1469,7 @@ function getDependentIdentifiersForPath(path6, state) {
       }
     }
   });
-  let topLevelStatement = getTopLevelStatementPathForPath(path6);
+  let topLevelStatement = getTopLevelStatementPathForPath(path7);
   let withinImportStatement = topLevelStatement.isImportDeclaration();
   let withinExportStatement = topLevelStatement.isExportDeclaration();
   if (!withinImportStatement && !withinExportStatement) {
@@ -1778,9 +1478,9 @@ function getDependentIdentifiersForPath(path6, state) {
       identifiers
     });
   }
-  if (withinExportStatement && path6.isIdentifier() && (t.isPattern(path6.parentPath.node) || // [foo]
-  t.isPattern(path6.parentPath.parentPath?.node))) {
-    let variableDeclarator = path6.findParent((p) => p.isVariableDeclarator());
+  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,
@@ -1789,16 +1489,16 @@ function getDependentIdentifiersForPath(path6, state) {
   }
   return identifiers;
 }
-function getTopLevelStatementPathForPath(path6) {
-  let ancestry = path6.getAncestry();
+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 path6 of paths) {
-    let topLevelStatement = getTopLevelStatementPathForPath(path6);
+  for (let path7 of paths) {
+    let topLevelStatement = getTopLevelStatementPathForPath(path7);
     topLevelStatements.add(topLevelStatement.node);
   }
   return topLevelStatements;
@@ -2161,7 +1861,7 @@ function getRouteChunkNameFromModuleId(id) {
 }
 
 // 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 = {
@@ -2172,7 +1872,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";
 
@@ -2215,24 +1915,24 @@ var plugin = {
 };
 var transform = (ast) => {
   const hocs = [];
-  function getHocUid(path6, hocName) {
-    const uid = path6.scope.generateUidIdentifier(hocName);
+  function getHocUid(path7, hocName) {
+    const uid = path7.scope.generateUidIdentifier(hocName);
     hocs.push([hocName, uid]);
     return uid;
   }
   traverse(ast, {
-    ExportDeclaration(path6) {
-      if (path6.isExportDefaultDeclaration()) {
-        const declaration = path6.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(path6, "withComponentProps");
+          const uid = getHocUid(path7, "withComponentProps");
           declaration.replaceWith(t.callExpression(uid, [expr]));
         }
         return;
       }
-      if (path6.isExportNamedDeclaration()) {
-        const decl = path6.get("declaration");
+      if (path7.isExportNamedDeclaration()) {
+        const decl = path7.get("declaration");
         if (decl.isVariableDeclaration()) {
           decl.get("declarations").forEach((varDeclarator) => {
             const id = varDeclarator.get("id");
@@ -2242,7 +1942,7 @@ var transform = (ast) => {
             if (!id.isIdentifier()) return;
             const { name } = id.node;
             if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
-            const uid = getHocUid(path6, `with${name}Props`);
+            const uid = getHocUid(path7, `with${name}Props`);
             init.replaceWith(t.callExpression(uid, [expr]));
           });
           return;
@@ -2252,7 +1952,7 @@ var transform = (ast) => {
           if (!id) return;
           const { name } = id;
           if (!NAMED_COMPONENT_EXPORTS.includes(name)) return;
-          const uid = getHocUid(path6, `with${name}Props`);
+          const uid = getHocUid(path7, `with${name}Props`);
           decl.replaceWith(
             t.variableDeclaration("const", [
               t.variableDeclarator(
@@ -2317,6 +2017,7 @@ var SSR_BUNDLE_PREFIX = "ssrBundle_";
 function isSsrBundleEnvironmentName(name) {
   return name.startsWith(SSR_BUNDLE_PREFIX);
 }
+var CSS_DEV_HELPER_ENVIRONMENT_NAME = "__react_router_css_dev_helper__";
 function getServerEnvironmentEntries(ctx, record) {
   return Object.entries(record).filter(
     ([name]) => ctx.buildManifest?.serverBundles ? isSsrBundleEnvironmentName(name) : name === "ssr"
@@ -2332,7 +2033,7 @@ var isRouteVirtualModule = (id) => {
   return isRouteEntryModuleId(id) || isRouteChunkModuleId(id);
 };
 var isServerBuildVirtualModuleId = (id) => {
-  return id.split("?")[0] === virtual.serverBuild.id;
+  return id.split("?")[0] === virtual2.serverBuild.id;
 };
 var getServerBuildFile = (viteManifest) => {
   let serverBuildIds = Object.keys(viteManifest).filter(
@@ -2352,23 +2053,23 @@ var virtualHmrRuntime = create("hmr-runtime");
 var virtualInjectHmrRuntime = create("inject-hmr-runtime");
 var normalizeRelativeFilePath = (file, reactRouterConfig) => {
   let vite2 = getVite();
-  let fullPath = path5.resolve(reactRouterConfig.appDirectory, file);
-  let relativePath = path5.relative(reactRouterConfig.appDirectory, fullPath);
+  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;
-  let fullPath = path5.resolve(reactRouterConfig.appDirectory, file);
+  let fullPath = path6.resolve(reactRouterConfig.appDirectory, file);
   return vite2.normalizePath(fullPath);
 };
-var virtual = {
+var virtual2 = {
   serverBuild: create("server-build"),
   serverManifest: create("server-manifest"),
   browserManifest: create("browser-manifest")
 };
 var invalidateVirtualModules = (viteDevServer) => {
-  Object.values(virtual).forEach((vmod2) => {
+  Object.values(virtual2).forEach((vmod2) => {
     let mod = viteDevServer.moduleGraph.getModuleById(vmod2.resolvedId);
     if (mod) {
       viteDevServer.moduleGraph.invalidateModule(mod);
@@ -2382,7 +2083,7 @@ var getHash = (source, maxLength) => {
 var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
   let vite2 = getVite();
   let rootRelativeFilePath = vite2.normalizePath(
-    path5.relative(ctx.rootDirectory, absoluteFilePath)
+    path6.relative(ctx.rootDirectory, absoluteFilePath)
   );
   let entryChunk = viteManifest[rootRelativeFilePath];
   if (!entryChunk) {
@@ -2446,7 +2147,7 @@ function dedupe(array2) {
   return [...new Set(array2)];
 }
 var writeFileSafe = async (file, contents) => {
-  await fse.ensureDir(path5.dirname(file));
+  await fse.ensureDir(path6.dirname(file));
   await fse.writeFile(file, contents);
 };
 var getExportNames = (code) => {
@@ -2472,7 +2173,7 @@ var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile)
   }
   let ssr = true;
   let { pluginContainer, moduleGraph } = viteChildCompiler;
-  let routePath = path5.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
+  let routePath = path6.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
   let url2 = resolveFileUrl(ctx, routePath);
   let resolveId = async () => {
     let result = await pluginContainer.resolveId(url2, void 0, { ssr });
@@ -2514,12 +2215,12 @@ var resolveEnvironmentBuildContext = ({
   };
   return resolvedBuildContext;
 };
-var getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path5.join(
+var getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path6.join(
   reactRouterConfig.buildDirectory,
   "server",
   ...serverBundleId ? [serverBundleId] : []
 );
-var getClientBuildDirectory = (reactRouterConfig) => path5.join(reactRouterConfig.buildDirectory, "client");
+var getClientBuildDirectory = (reactRouterConfig) => path6.join(reactRouterConfig.buildDirectory, "client");
 var getServerBundleRouteIds = (vitePluginContext, ctx) => {
   if (!ctx.buildManifest) {
     return void 0;
@@ -2537,13 +2238,14 @@ var getServerBundleRouteIds = (vitePluginContext, ctx) => {
   );
   return Object.keys(serverBundleRoutes);
 };
-var defaultEntriesDir = path5.resolve(
-  path5.dirname(require.resolve("@react-router/dev/package.json")),
+var injectQuery = (url2, query) => url2.includes("?") ? url2.replace("?", `?${query}&`) : `${url2}?${query}`;
+var defaultEntriesDir = path6.resolve(
+  path6.dirname(require.resolve("@react-router/dev/package.json")),
   "dist",
   "config",
   "defaults"
 );
-var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path5.join(defaultEntriesDir, filename2));
+var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path6.join(defaultEntriesDir, filename3));
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => void 0;
 var reactRouterVitePlugin = () => {
@@ -2639,10 +2341,10 @@ var reactRouterVitePlugin = () => {
       }
     }).join("\n")}
       export { default as assets } from ${JSON.stringify(
-      virtual.serverManifest.id
+      virtual2.serverManifest.id
     )};
       export const assetsBuildDirectory = ${JSON.stringify(
-      path5.relative(
+      path6.relative(
         ctx.rootDirectory,
         getClientBuildDirectory(ctx.reactRouterConfig)
       )
@@ -2652,9 +2354,6 @@ var reactRouterVitePlugin = () => {
       export const ssr = ${ctx.reactRouterConfig.ssr};
       export const isSpaMode = ${isSpaMode};
       export const prerender = ${JSON.stringify(prerenderPaths)};
-      export const routeDiscovery = ${JSON.stringify(
-      ctx.reactRouterConfig.routeDiscovery
-    )};
       export const publicPath = ${JSON.stringify(ctx.publicPath)};
       export const entry = { module: entryServer };
       export const routes = {
@@ -2681,7 +2380,7 @@ var reactRouterVitePlugin = () => {
   };
   let loadViteManifest = async (directory) => {
     let manifestContents = await fse.readFile(
-      path5.resolve(directory, ".vite", "manifest.json"),
+      path6.resolve(directory, ".vite", "manifest.json"),
       "utf-8"
     );
     return JSON.parse(manifestContents);
@@ -2712,7 +2411,7 @@ var reactRouterVitePlugin = () => {
         let contents;
         try {
           contents = await fse.readFile(
-            path5.join(entry.path, entry.name),
+            path6.join(entry.path, entry.name),
             "utf-8"
           );
         } catch (e) {
@@ -2721,7 +2420,7 @@ var reactRouterVitePlugin = () => {
         }
         let hash = (0, import_node_crypto.createHash)("sha384").update(contents).digest().toString("base64");
         let filepath = getVite().normalizePath(
-          path5.relative(clientBuildDirectory, path5.join(entry.path, entry.name))
+          path6.relative(clientBuildDirectory, path6.join(entry.path, entry.name))
         );
         sriManifest[`${ctx2.publicPath}${filepath}`] = `sha384-${hash}`;
       }
@@ -2748,7 +2447,7 @@ var reactRouterVitePlugin = () => {
     );
     let enforceSplitRouteModules = ctx.reactRouterConfig.future.unstable_splitRouteModules === "enforce";
     for (let route of Object.values(ctx.reactRouterConfig.routes)) {
-      let routeFile = path5.join(ctx.reactRouterConfig.appDirectory, route.file);
+      let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
       let sourceExports = routeManifestExports[route.id];
       let isRootRoute = route.parentId === void 0;
       let hasClientAction = sourceExports.includes("clientAction");
@@ -2824,7 +2523,7 @@ var reactRouterVitePlugin = () => {
     }
     let fingerprintedValues = { entry, routes: browserRoutes };
     let version = getHash(JSON.stringify(fingerprintedValues), 8);
-    let manifestPath = path5.posix.join(
+    let manifestPath = path6.posix.join(
       viteConfig.build.assetsDir,
       `manifest-${version}.js`
     );
@@ -2836,7 +2535,7 @@ var reactRouterVitePlugin = () => {
       sri: void 0
     };
     await writeFileSafe(
-      path5.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
+      path6.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
       `window.__reactRouterManifest=${JSON.stringify(
         reactRouterBrowserManifest
       )};`
@@ -2921,7 +2620,7 @@ var reactRouterVitePlugin = () => {
     let sri = void 0;
     let reactRouterManifestForDev = {
       version: String(Math.random()),
-      url: combineURLs(ctx.publicPath, virtual.browserManifest.url),
+      url: combineURLs(ctx.publicPath, virtual2.browserManifest.url),
       hmr: {
         runtime: combineURLs(ctx.publicPath, virtualInjectHmrRuntime.url)
       },
@@ -2946,17 +2645,31 @@ var reactRouterVitePlugin = () => {
     if (dep.file && isCssModulesFile(dep.file)) {
       return cssModulesManifest[dep.file];
     }
-    let transformedCssCode = (await viteDevServer.transformRequest(dep.url))?.code;
+    const vite2 = getVite();
+    const viteMajor = parseInt(vite2.version.split(".")[0], 10);
+    const url2 = viteMajor >= 6 ? (
+      // 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.
+      injectQuery(dep.url, "inline")
+    ) : dep.url;
+    let cssMod;
+    if (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi) {
+      const cssDevHelperEnvironment = viteDevServer.environments[CSS_DEV_HELPER_ENVIRONMENT_NAME];
+      invariant(cssDevHelperEnvironment, "Missing CSS dev helper environment");
+      invariant(vite2.isRunnableDevEnvironment(cssDevHelperEnvironment));
+      cssMod = await cssDevHelperEnvironment.runner.import(url2);
+    } else {
+      cssMod = await viteDevServer.ssrLoadModule(url2);
+    }
     invariant(
-      transformedCssCode,
+      typeof cssMod === "object" && cssMod !== null && "default" in cssMod && typeof cssMod.default === "string",
       `Failed to load CSS for ${dep.file ?? dep.url}`
     );
-    let cssString = getCssStringFromViteDevModuleCode(transformedCssCode);
-    invariant(
-      typeof cssString === "string",
-      `Failed to extract CSS for ${dep.file ?? dep.url}`
-    );
-    return cssString;
+    return cssMod.default;
   };
   return [
     {
@@ -2974,17 +2687,14 @@ var reactRouterVitePlugin = () => {
           prefix: "[react-router]"
         });
         rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
-        let mode = viteConfigEnv.mode;
         if (viteCommand === "serve") {
           typegenWatcherPromise = watch(rootDirectory, {
-            mode,
             // ignore `info` logs from typegen since they are redundant when Vite plugin logs are active
             logger: vite2.createLogger("warn", { prefix: "[react-router]" })
           });
         }
         reactRouterConfigLoader = await createConfigLoader({
           rootDirectory,
-          mode,
           watch: viteCommand === "serve"
         });
         await updatePluginContext();
@@ -3242,8 +2952,7 @@ var reactRouterVitePlugin = () => {
         reactRouterConfigLoader.onChange(
           async ({
             result,
-            configCodeChanged,
-            routeConfigCodeChanged,
+            configCodeUpdated,
             configChanged,
             routeConfigChanged
           }) => {
@@ -3255,13 +2964,19 @@ var reactRouterVitePlugin = () => {
               });
               return;
             }
-            let message = configChanged ? "Config changed." : routeConfigChanged ? "Route config changed." : configCodeChanged ? "Config saved." : routeConfigCodeChanged ? " Route config saved." : "Config saved";
-            logger.info(import_picocolors3.default.green(message), {
-              clear: true,
-              timestamp: true
-            });
+            if (routeConfigChanged) {
+              logger.info(import_picocolors3.default.green("Route config changed."), {
+                clear: true,
+                timestamp: true
+              });
+            } else if (configCodeUpdated) {
+              logger.info(import_picocolors3.default.green("Config updated."), {
+                clear: true,
+                timestamp: true
+              });
+            }
             await updatePluginContext();
-            if (configChanged || routeConfigChanged) {
+            if (configChanged) {
               invalidateVirtualModules(viteDevServer);
             }
           }
@@ -3302,11 +3017,11 @@ var reactRouterVitePlugin = () => {
                     return;
                   }
                   build = await ssrEnvironment.runner.import(
-                    virtual.serverBuild.id
+                    virtual2.serverBuild.id
                   );
                 } else {
                   build = await viteDevServer.ssrLoadModule(
-                    virtual.serverBuild.id
+                    virtual2.serverBuild.id
                   );
                 }
                 let handler = (0, import_react_router2.createRequestHandler)(build, "development");
@@ -3343,8 +3058,8 @@ var reactRouterVitePlugin = () => {
           let ssrAssetPaths = getViteManifestAssetPaths(ssrViteManifest);
           let movedAssetPaths = [];
           for (let ssrAssetPath of ssrAssetPaths) {
-            let src = path5.join(serverBuildDirectory, ssrAssetPath);
-            let dest = path5.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);
@@ -3357,7 +3072,7 @@ var reactRouterVitePlugin = () => {
           );
           await Promise.all(
             ssrCssPaths.map(
-              (cssPath) => fse.remove(path5.join(serverBuildDirectory, cssPath))
+              (cssPath) => fse.remove(path6.join(serverBuildDirectory, cssPath))
             )
           );
           if (movedAssetPaths.length) {
@@ -3366,13 +3081,12 @@ 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(path5.relative(ctx.rootDirectory, movedAssetPath))
+                  (movedAssetPath) => import_picocolors3.default.dim(path6.relative(ctx.rootDirectory, movedAssetPath))
                 ),
                 ""
               ].join("\n")
             );
           }
-          process.env.IS_RR_BUILD_REQUEST = "yes";
           if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
             await handlePrerender(
               viteConfig,
@@ -3445,7 +3159,7 @@ var reactRouterVitePlugin = () => {
         );
         let isMainChunkExport = (name) => !chunkedExports.includes(name);
         let mainChunkReexports = sourceExports.filter(isMainChunkExport).join(", ");
-        let chunkBasePath = `./${path5.basename(id)}`;
+        let chunkBasePath = `./${path6.basename(id)}`;
         return [
           `export { ${mainChunkReexports} } from "${getRouteChunkModuleId(
             chunkBasePath,
@@ -3465,7 +3179,7 @@ var reactRouterVitePlugin = () => {
       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 = path5.basename(routeModuleId);
+        let routeFileName = path6.basename(routeModuleId);
         let sourceExports = await getRouteModuleExports(
           viteChildCompiler,
           ctx,
@@ -3531,16 +3245,16 @@ var reactRouterVitePlugin = () => {
       name: "react-router:virtual-modules",
       enforce: "pre",
       resolveId(id) {
-        const vmod2 = Object.values(virtual).find((vmod3) => vmod3.id === id);
+        const vmod2 = Object.values(virtual2).find((vmod3) => vmod3.id === id);
         if (vmod2) return vmod2.resolvedId;
       },
       async load(id) {
         switch (id) {
-          case virtual.serverBuild.resolvedId: {
+          case virtual2.serverBuild.resolvedId: {
             let routeIds = getServerBundleRouteIds(this, ctx);
             return await getServerEntry({ routeIds });
           }
-          case virtual.serverManifest.resolvedId: {
+          case virtual2.serverManifest.resolvedId: {
             let routeIds = getServerBundleRouteIds(this, ctx);
             let reactRouterManifest = viteCommand === "build" ? (await generateReactRouterManifestsForBuild({
               routeIds
@@ -3558,7 +3272,7 @@ var reactRouterVitePlugin = () => {
               es6: true
             })};`;
           }
-          case virtual.browserManifest.resolvedId: {
+          case virtual2.browserManifest.resolvedId: {
             if (viteCommand === "build") {
               throw new Error("This module only exists in development");
             }
@@ -3592,7 +3306,7 @@ var reactRouterVitePlugin = () => {
         }
         let vite2 = getVite();
         let importerShort = vite2.normalizePath(
-          path5.relative(ctx.rootDirectory, importer)
+          path6.relative(ctx.rootDirectory, importer)
         );
         if (isRoute(ctx.reactRouterConfig, importer)) {
           let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(
@@ -3715,10 +3429,10 @@ var reactRouterVitePlugin = () => {
       },
       async load(id) {
         if (id !== virtualHmrRuntime.resolvedId) return;
-        let reactRefreshDir = path5.dirname(
+        let reactRefreshDir = path6.dirname(
           require.resolve("react-refresh/package.json")
         );
-        let reactRefreshRuntimePath = path5.join(
+        let reactRefreshRuntimePath = path6.join(
           reactRefreshDir,
           "cjs/react-refresh-runtime.development.js"
         );
@@ -3899,7 +3613,7 @@ if (import.meta.hot && !inWebWorker) {
 function getRoute(pluginConfig, file) {
   let vite2 = getVite();
   let routePath = vite2.normalizePath(
-    path5.relative(pluginConfig.appDirectory, file)
+    path6.relative(pluginConfig.appDirectory, file)
   );
   let route = Object.values(pluginConfig.routes).find(
     (r) => vite2.normalizePath(r.file) === routePath
@@ -3938,7 +3652,7 @@ async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteF
     caseSensitive: route.caseSensitive,
     url: combineURLs(
       ctx.publicPath,
-      "/" + path5.relative(
+      "/" + path6.relative(
         ctx.rootDirectory,
         resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
       )
@@ -3966,7 +3680,7 @@ function isSpaModeEnabled(reactRouterConfig) {
   return reactRouterConfig.ssr === false && !isPrerenderingEnabled(reactRouterConfig);
 }
 async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, serverBuildFile) {
-  let serverBuildPath = path5.join(serverBuildDirectory, serverBuildFile);
+  let serverBuildPath = path6.join(serverBuildDirectory, serverBuildFile);
   let build = await import(url.pathToFileURL(serverBuildPath).toString());
   let { createRequestHandler: createHandler } = await import("react-router");
   return {
@@ -3989,16 +3703,16 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
   let response = await handler(request);
   let html = await response.text();
   let isPrerenderSpaFallback = build.prerender.includes("/");
-  let filename2 = isPrerenderSpaFallback ? "__spa-fallback.html" : "index.html";
+  let filename3 = isPrerenderSpaFallback ? "__spa-fallback.html" : "index.html";
   if (response.status !== 200) {
     if (isPrerenderSpaFallback) {
       throw new Error(
-        `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename2}\` file.
+        `Prerender: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
 ` + html
       );
     } else {
       throw new Error(
-        `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename2}\` file.
+        `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your \`${filename3}\` file.
 ` + html
       );
     }
@@ -4008,9 +3722,9 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
       "SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`."
     );
   }
-  await fse.writeFile(path5.join(clientBuildDirectory, filename2), html);
-  let prettyDir = path5.relative(process.cwd(), clientBuildDirectory);
-  let prettyPath = path5.join(prettyDir, filename2);
+  await fse.writeFile(path6.join(clientBuildDirectory, filename3), html);
+  let prettyDir = path6.relative(process.cwd(), clientBuildDirectory);
+  let prettyPath = path6.join(prettyDir, filename3);
   if (build.prerender.length > 0) {
     viteConfig.logger.info(
       `Prerender (html): SPA Fallback -> ${import_picocolors3.default.bold(prettyPath)}`
@@ -4026,17 +3740,22 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     serverBuildPath
   );
   let routes = createPrerenderRoutes(reactRouterConfig.routes);
-  for (let path6 of build.prerender) {
-    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path6}/`.replace(/^\/\/+/, "/"));
+  for (let path7 of build.prerender) {
+    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path7}/`.replace(/^\/\/+/, "/"));
     if (!matches) {
       throw new Error(
-        `Unable to prerender path because it does not match any routes: ${path6}`
+        `Unable to prerender path because it does not match any routes: ${path7}`
       );
     }
   }
   let buildRoutes = createPrerenderRoutes(build.routes);
-  for (let path6 of build.prerender) {
-    let matches = (0, import_react_router2.matchRoutes)(buildRoutes, `/${path6}/`.replace(/^\/\/+/, "/"));
+  let headers = {
+    // Header that can be used in the loader to know if you're running at
+    // build time or runtime
+    "X-React-Router-Prerender": "yes"
+  };
+  for (let path7 of build.prerender) {
+    let matches = (0, import_react_router2.matchRoutes)(buildRoutes, `/${path7}/`.replace(/^\/\/+/, "/"));
     if (!matches) {
       continue;
     }
@@ -4049,18 +3768,20 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       if (manifestRoute.loader) {
         await prerenderData(
           handler,
-          path6,
+          path7,
           [leafRoute.id],
           clientBuildDirectory,
           reactRouterConfig,
-          viteConfig
+          viteConfig,
+          { headers }
         );
         await prerenderResourceRoute(
           handler,
-          path6,
+          path7,
           clientBuildDirectory,
           reactRouterConfig,
-          viteConfig
+          viteConfig,
+          { headers }
         );
       } else {
         viteConfig.logger.warn(
@@ -4075,24 +3796,26 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       if (!isResourceRoute && hasLoaders) {
         data = await prerenderData(
           handler,
-          path6,
+          path7,
           null,
           clientBuildDirectory,
           reactRouterConfig,
-          viteConfig
+          viteConfig,
+          { headers }
         );
       }
       await prerenderRoute(
         handler,
-        path6,
+        path7,
         clientBuildDirectory,
         reactRouterConfig,
         viteConfig,
         data ? {
           headers: {
+            ...headers,
             "X-React-Router-Prerender-Data": encodeURI(data)
           }
-        } : void 0
+        } : { headers }
       );
     }
   }
@@ -4137,9 +3860,9 @@ async function prerenderData(handler, prerenderPath, onlyRoutes, clientBuildDire
 ${normalizedPath}`
     );
   }
-  let outdir = path5.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path5.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path5.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 (data): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
@@ -4176,9 +3899,9 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
 ${html}`
     );
   }
-  let outdir = path5.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path5.join(outdir, ...normalizedPath.split("/"), "index.html");
-  await fse.ensureDir(path5.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 (html): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
@@ -4195,9 +3918,9 @@ async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirecto
 ${content.toString("utf8")}`
     );
   }
-  let outdir = path5.relative(process.cwd(), clientBuildDirectory);
-  let outfile = path5.join(outdir, ...normalizedPath.split("/"));
-  await fse.ensureDir(path5.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, content);
   viteConfig.logger.info(
     `Prerender (resource): ${prerenderPath} -> ${import_picocolors3.default.bold(outfile)}`
@@ -4273,14 +3996,14 @@ async function validateSsrFalsePrerenderExports(viteConfig, ctx, manifest, viteC
   }
   let prerenderRoutes = createPrerenderRoutes(manifest.routes);
   let prerenderedRoutes = /* @__PURE__ */ new Set();
-  for (let path6 of prerenderPaths) {
+  for (let path7 of prerenderPaths) {
     let matches = (0, import_react_router2.matchRoutes)(
       prerenderRoutes,
-      `/${path6}/`.replace(/^\/\/+/, "/")
+      `/${path7}/`.replace(/^\/\/+/, "/")
     );
     invariant(
       matches,
-      `Unable to prerender path because it does not match any routes: ${path6}`
+      `Unable to prerender path because it does not match any routes: ${path7}`
     );
     matches.forEach((m) => prerenderedRoutes.add(m.route.id));
   }
@@ -4447,8 +4170,8 @@ function validateRouteChunks({
 async function cleanBuildDirectory(viteConfig, ctx) {
   let buildDirectory = ctx.reactRouterConfig.buildDirectory;
   let isWithinRoot = () => {
-    let relativePath = path5.relative(ctx.rootDirectory, buildDirectory);
-    return !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
+    let relativePath = path6.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
   };
   if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
     await fse.remove(buildDirectory);
@@ -4459,7 +4182,7 @@ async function cleanViteManifests(environmentsOptions, ctx) {
     ([environmentName, options]) => {
       let outDir = options.build?.outDir;
       invariant(outDir, `Expected build.outDir for ${environmentName}`);
-      return path5.join(outDir, ".vite/manifest.json");
+      return path6.join(outDir, ".vite/manifest.json");
     }
   );
   await Promise.all(
@@ -4469,7 +4192,7 @@ async function cleanViteManifests(environmentsOptions, ctx) {
       if (!ctx.viteManifestEnabled) {
         await fse.remove(viteManifestPath);
       }
-      let viteDir = path5.dirname(viteManifestPath);
+      let viteDir = path6.dirname(viteManifestPath);
       let viteDirFiles = await fse.readdir(viteDir);
       if (viteDirFiles.length === 0) {
         await fse.remove(viteDir);
@@ -4487,12 +4210,12 @@ async function getBuildManifest({
   }
   let { normalizePath } = await import("vite");
   let serverBuildDirectory = getServerBuildDirectory(reactRouterConfig);
-  let resolvedAppDirectory = path5.resolve(rootDirectory, appDirectory);
+  let resolvedAppDirectory = path6.resolve(rootDirectory, appDirectory);
   let rootRelativeRoutes = Object.fromEntries(
     Object.entries(routes).map(([id, route]) => {
-      let filePath = path5.join(resolvedAppDirectory, route.file);
+      let filePath = path6.join(resolvedAppDirectory, route.file);
       let rootRelativeFilePath = normalizePath(
-        path5.relative(rootDirectory, filePath)
+        path6.relative(rootDirectory, filePath)
       );
       return [id, { ...route, file: rootRelativeFilePath }];
     })
@@ -4510,7 +4233,7 @@ async function getBuildManifest({
           (route2) => configRouteToBranchRoute({
             ...route2,
             // Ensure absolute paths are passed to the serverBundles function
-            file: path5.join(resolvedAppDirectory, route2.file)
+            file: path6.join(resolvedAppDirectory, route2.file)
           })
         )
       });
@@ -4534,10 +4257,10 @@ async function getBuildManifest({
       buildManifest.serverBundles[serverBundleId] ??= {
         id: serverBundleId,
         file: normalizePath(
-          path5.join(
-            path5.relative(
+          path6.join(
+            path6.relative(
               rootDirectory,
-              path5.join(serverBuildDirectory, serverBundleId)
+              path6.join(serverBuildDirectory, serverBundleId)
             ),
             reactRouterConfig.serverBuildFile
           )
@@ -4556,10 +4279,10 @@ function mergeEnvironmentOptions(base, ...overrides) {
 }
 async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
   let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
-  let packageRoot = path5.dirname(
+  let packageRoot = path6.dirname(
     require.resolve("@react-router/dev/package.json")
   );
-  let { moduleSyncEnabled } = await import(`file:///${path5.join(packageRoot, "module-sync-enabled/index.mjs")}`);
+  let { moduleSyncEnabled } = await import(`file:///${path6.join(packageRoot, "module-sync-enabled/index.mjs")}`);
   let vite2 = getVite();
   let viteServerConditions = [
     ...vite2.defaultServerConditions ?? [],
@@ -4616,7 +4339,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
         copyPublicDir: false,
         // Assets in the public directory are only used by the client
         rollupOptions: {
-          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual.serverBuild.id,
+          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual2.serverBuild.id,
           output: {
             entryFileNames: serverBuildFile,
             format: serverModuleFormat
@@ -4633,7 +4356,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
             ctx.entryClientFilePath,
             ...Object.values(ctx.reactRouterConfig.routes).flatMap(
               (route) => {
-                let routeFilePath = path5.resolve(
+                let routeFilePath = path6.resolve(
                   ctx.reactRouterConfig.appDirectory,
                   route.file
                 );
@@ -4656,9 +4379,8 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
                 ""
               ) : null;
               let routeChunkSuffix = routeChunkName ? `-${(0, import_kebabCase.default)(routeChunkName)}` : "";
-              let assetsDir = (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig?.environments?.client?.build?.assetsDir : null) ?? viteUserConfig?.build?.assetsDir ?? "assets";
-              return path5.posix.join(
-                assetsDir,
+              return path6.posix.join(
+                (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig?.environments?.client?.build?.assetsDir : viteUserConfig?.build?.assetsDir) ?? "assets",
                 `[name]${routeChunkSuffix}-[hash].js`
               );
             }
@@ -4693,6 +4415,9 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
       }
     });
   }
+  if (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi && viteCommand === "serve") {
+    environmentOptionsResolvers[CSS_DEV_HELPER_ENVIRONMENT_NAME] = () => ({});
+  }
   return environmentOptionsResolvers;
 }
 function resolveEnvironmentsOptions(environmentResolvers, resolverOptions) {