@react-router/dev 0.0.0-experimental-f20b6b7b0 → 0.0.0-experimental-39630069d

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-f20b6b7b0
+ * @react-router/dev v0.0.0-experimental-39630069d
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -48,13 +48,28 @@ module.exports = __toCommonJS(vite_exports);
 var import_node_crypto = require("crypto");
 var path4 = __toESM(require("path"));
 var url2 = __toESM(require("url"));
-var fse2 = __toESM(require("fs-extra"));
+var fse = __toESM(require("fs-extra"));
 var babel = __toESM(require("@babel/core"));
 var import_react_router2 = require("react-router");
 var import_es_module_lexer = require("es-module-lexer");
 var import_jsesc = __toESM(require("jsesc"));
+var import_picocolors3 = __toESM(require("picocolors"));
+
+// typegen/index.ts
+var import_node_fs2 = __toESM(require("fs"));
+var Path4 = __toESM(require("pathe"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
+// config/config.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_child_process = require("child_process");
+var import_package_json = __toESM(require("@npmcli/package-json"));
+
+// vite/vite-node.ts
+var import_server = require("vite-node/server");
+var import_client = require("vite-node/client");
+var import_source_map = require("vite-node/source-map");
+
 // invariant.ts
 function invariant(value, message) {
   if (value === false || value === null || typeof value === "undefined") {
@@ -65,82 +80,6 @@ function invariant(value, message) {
   }
 }
 
-// vite/babel.ts
-var import_parser = require("@babel/parser");
-var t = __toESM(require("@babel/types"));
-var traverse = require("@babel/traverse").default;
-var generate = require("@babel/generator").default;
-
-// vite/node-adapter.ts
-var import_node_events = require("events");
-var import_node_stream = require("stream");
-var import_set_cookie_parser = require("set-cookie-parser");
-var import_node = require("@react-router/node");
-function fromNodeHeaders(nodeHeaders) {
-  let headers = new Headers();
-  for (let [key, values] of Object.entries(nodeHeaders)) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (let value of values) {
-          headers.append(key, value);
-        }
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  return headers;
-}
-function fromNodeRequest(nodeReq, nodeRes) {
-  let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
-  invariant(
-    nodeReq.originalUrl,
-    "Expected `nodeReq.originalUrl` to be defined"
-  );
-  let url3 = new URL(nodeReq.originalUrl, origin);
-  let controller = new AbortController();
-  let init = {
-    method: nodeReq.method,
-    headers: fromNodeHeaders(nodeReq.headers),
-    signal: controller.signal
-  };
-  nodeRes.on("finish", () => controller = null);
-  nodeRes.on("close", () => controller?.abort());
-  if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
-    init.body = (0, import_node.createReadableStreamFromReadable)(nodeReq);
-    init.duplex = "half";
-  }
-  return new Request(url3.href, init);
-}
-async function toNodeRequest(res, nodeRes) {
-  nodeRes.statusCode = res.status;
-  nodeRes.statusMessage = res.statusText;
-  let cookiesStrings = [];
-  for (let [name, value] of res.headers) {
-    if (name === "set-cookie") {
-      cookiesStrings.push(...(0, import_set_cookie_parser.splitCookiesString)(value));
-    } else nodeRes.setHeader(name, value);
-  }
-  if (cookiesStrings.length) {
-    nodeRes.setHeader("set-cookie", cookiesStrings);
-  }
-  if (res.body) {
-    let responseBody = res.body;
-    let readable = import_node_stream.Readable.from(responseBody);
-    readable.pipe(nodeRes);
-    await (0, import_node_events.once)(readable, "end");
-  } else {
-    nodeRes.end();
-  }
-}
-
-// vite/styles.ts
-var path2 = __toESM(require("path"));
-var import_react_router = require("react-router");
-
-// vite/resolve-file-url.ts
-var path = __toESM(require("path"));
-
 // vite/import-vite-esm-sync.ts
 var vite;
 async function preloadViteEsm() {
@@ -151,464 +90,241 @@ function importViteEsmSync() {
   return vite;
 }
 
-// vite/resolve-file-url.ts
-var resolveFileUrl = ({ rootDirectory }, filePath) => {
-  let vite2 = importViteEsmSync();
-  let relativePath = path.relative(rootDirectory, filePath);
-  let isWithinRoot = !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
-  if (!isWithinRoot) {
-    return path.posix.join("/@fs", vite2.normalizePath(filePath));
-  }
-  return "/" + vite2.normalizePath(relativePath);
-};
+// vite/vite-node.ts
+async function createContext(viteConfig = {}) {
+  await preloadViteEsm();
+  const vite2 = importViteEsmSync();
+  const devServer = await vite2.createServer(
+    vite2.mergeConfig(
+      {
+        server: {
+          preTransformRequests: false,
+          hmr: false
+        },
+        optimizeDeps: {
+          noDiscovery: true
+        },
+        configFile: false,
+        envFile: false,
+        plugins: []
+      },
+      viteConfig
+    )
+  );
+  await devServer.pluginContainer.buildStart({});
+  const server = new import_server.ViteNodeServer(devServer);
+  (0, import_source_map.installSourcemapsSupport)({
+    getSourceMap: (source) => server.getSourceMap(source)
+  });
+  const runner = new import_client.ViteNodeRunner({
+    root: devServer.config.root,
+    base: devServer.config.base,
+    fetchModule(id2) {
+      return server.fetchModule(id2);
+    },
+    resolveId(id2, importer) {
+      return server.resolveId(id2, importer);
+    }
+  });
+  return { devServer, server, runner };
+}
 
-// vite/styles.ts
-var cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-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];
-  if (!queryString) {
-    return false;
+// config/config.ts
+var import_pathe = __toESM(require("pathe"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_pick2 = __toESM(require("lodash/pick"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+
+// config/routes.ts
+var Path = __toESM(require("pathe"));
+var v = __toESM(require("valibot"));
+var import_pick = __toESM(require("lodash/pick"));
+function setAppDirectory(directory) {
+  globalThis.__reactRouterAppDirectory = directory;
+}
+var routeConfigEntrySchema = v.pipe(
+  v.custom((value) => {
+    return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
+  }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
+  v.object({
+    id: v.optional(v.string()),
+    path: v.optional(v.string()),
+    index: v.optional(v.boolean()),
+    caseSensitive: v.optional(v.boolean()),
+    file: v.string(),
+    children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
+  })
+);
+var resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
+function validateRouteConfig({
+  routeConfigFile,
+  routeConfig
+}) {
+  if (!routeConfig) {
+    return {
+      valid: false,
+      message: `Route config must be the default export in "${routeConfigFile}".`
+    };
   }
-  let params = new URLSearchParams(queryString);
-  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}=`)
-    ) {
-      return true;
-    }
+  if (!Array.isArray(routeConfig)) {
+    return {
+      valid: false,
+      message: `Route config in "${routeConfigFile}" must be an array.`
+    };
   }
-  return false;
-};
-var getStylesForFiles = async ({
-  viteDevServer,
-  rootDirectory,
-  cssModulesManifest,
-  files
-}) => {
-  let styles = {};
-  let deps = /* @__PURE__ */ new Set();
-  try {
-    for (let file of files) {
-      let normalizedPath = path2.resolve(rootDirectory, file).replace(/\\/g, "/");
-      let node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
-      if (!node) {
-        try {
-          await viteDevServer.transformRequest(
-            resolveFileUrl({ rootDirectory }, normalizedPath)
-          );
-        } catch (err) {
-          console.error(err);
-        }
-        node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
-      }
-      if (!node) {
-        console.log(`Could not resolve module for file: ${file}`);
-        continue;
-      }
-      await findDeps(viteDevServer, node, deps);
-    }
-  } catch (err) {
-    console.error(err);
+  let { issues } = v.safeParse(resolvedRouteConfigSchema, routeConfig);
+  if (issues?.length) {
+    let { root, nested } = v.flatten(issues);
+    return {
+      valid: false,
+      message: [
+        `Route config in "${routeConfigFile}" is invalid.`,
+        root ? `${root}` : [],
+        nested ? Object.entries(nested).map(
+          ([path5, message]) => `Path: routes.${path5}
+${message}`
+        ) : []
+      ].flat().join("\n\n")
+    };
   }
-  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;
-        if (css === void 0) {
-          throw new Error();
-        }
-        styles[dep.url] = css;
-      } catch {
-        console.warn(`Could not load ${dep.file}`);
+  return { valid: true };
+}
+function configRoutesToRouteManifest(appDirectory, routes, rootId = "root") {
+  let routeManifest = {};
+  function walk(route, parentId) {
+    let id2 = route.id || createRouteId(route.file);
+    let manifestItem = {
+      id: id2,
+      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)) {
+      throw new Error(
+        `Unable to define routes with duplicate route id: "${id2}"`
+      );
+    }
+    routeManifest[id2] = manifestItem;
+    if (route.children) {
+      for (let child of route.children) {
+        walk(child, id2);
       }
     }
   }
-  return Object.entries(styles).map(([fileName, css], i) => [
-    `
-/* ${fileName.replace(/\/\*/g, "/\\*").replace(/\*\//g, "*\\/")} */`,
-    css
-  ]).flat().join("\n") || void 0;
-};
-var findDeps = async (vite2, node, deps) => {
-  let branches = [];
-  async function addFromNode(node2) {
-    if (!deps.has(node2)) {
-      deps.add(node2);
-      await findDeps(vite2, node2, deps);
-    }
-  }
-  async function addFromUrl(url3) {
-    let node2 = await vite2.moduleGraph.getModuleByUrl(url3);
-    if (node2) {
-      await addFromNode(node2);
-    }
-  }
-  if (node.ssrTransformResult) {
-    if (node.ssrTransformResult.deps) {
-      node.ssrTransformResult.deps.forEach(
-        (url3) => branches.push(addFromUrl(url3))
-      );
-    }
-  } else {
-    node.importedModules.forEach((node2) => branches.push(addFromNode(node2)));
+  for (let route of routes) {
+    walk(route, rootId);
   }
-  await Promise.all(branches);
-};
-var groupRoutesByParentId = (manifest) => {
-  let routes = {};
-  Object.values(manifest).forEach((route) => {
-    if (route) {
-      let parentId = route.parentId || "";
-      if (!routes[parentId]) {
-        routes[parentId] = [];
-      }
-      routes[parentId].push(route);
-    }
-  });
-  return routes;
-};
-var createRoutes = (manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) => {
-  return (routesByParentId[parentId] || []).map((route) => ({
-    ...route,
-    children: createRoutes(manifest, route.id, routesByParentId)
-  }));
-};
-var getStylesForUrl = async ({
-  viteDevServer,
-  rootDirectory,
-  reactRouterConfig,
-  entryClientFilePath,
-  cssModulesManifest,
-  build,
-  url: url3
-}) => {
-  if (url3 === void 0 || url3.includes("?_data=")) {
+  return routeManifest;
+}
+function createRouteId(file) {
+  return Path.normalize(stripFileExtension(file));
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+
+// cli/detectPackageManager.ts
+var detectPackageManager = () => {
+  let { npm_config_user_agent } = process.env;
+  if (!npm_config_user_agent) return void 0;
+  try {
+    let pkgManager = npm_config_user_agent.split("/")[0];
+    if (pkgManager === "npm") return "npm";
+    if (pkgManager === "pnpm") return "pnpm";
+    if (pkgManager === "yarn") return "yarn";
+    if (pkgManager === "bun") return "bun";
+    return void 0;
+  } catch {
     return void 0;
   }
-  let routes = createRoutes(build.routes);
-  let appPath = path2.relative(process.cwd(), reactRouterConfig.appDirectory);
-  let documentRouteFiles = (0, import_react_router.matchRoutes)(routes, url3, build.basename)?.map(
-    (match) => path2.resolve(appPath, reactRouterConfig.routes[match.route.id].file)
-  ) ?? [];
-  let styles = await getStylesForFiles({
-    viteDevServer,
-    rootDirectory,
-    cssModulesManifest,
-    files: [
-      // Always include the client entry file when crawling the module graph for CSS
-      path2.relative(rootDirectory, entryClientFilePath),
-      // Then include any styles from the matched routes
-      ...documentRouteFiles
-    ]
-  });
-  return styles;
 };
 
-// vite/vmod.ts
-var id = (name) => `virtual:react-router/${name}`;
-var resolve2 = (id2) => `\0${id2}`;
-var url = (id2) => `/@id/__x00__${id2}`;
-
-// vite/combine-urls.ts
-function combineURLs(baseURL, relativeURL) {
-  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
-}
-
-// vite/remove-exports.ts
-var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
-var removeExports = (ast, exportsToRemove) => {
-  let previouslyReferencedIdentifiers = (0, import_babel_dead_code_elimination.findReferencedIdentifiers)(ast);
-  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) => {
-            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
-              if (exportsToRemove.includes(specifier.exported.name)) {
-                exportsFiltered = true;
-                return false;
-              }
-            }
-            return true;
-          });
-          if (path5.node.specifiers.length === 0) {
-            markedForRemoval.add(path5);
-          }
-        }
-        if (path5.node.declaration?.type === "VariableDeclaration") {
-          let declaration = path5.node.declaration;
-          declaration.declarations = declaration.declarations.filter(
-            (declaration2) => {
-              if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
-                exportsFiltered = true;
-                return false;
-              }
-              if (declaration2.id.type === "ArrayPattern" || declaration2.id.type === "ObjectPattern") {
-                validateDestructuredExports(declaration2.id, exportsToRemove);
-              }
-              return true;
-            }
-          );
-          if (declaration.declarations.length === 0) {
-            markedForRemoval.add(path5);
-          }
-        }
-        if (path5.node.declaration?.type === "FunctionDeclaration") {
-          let id2 = path5.node.declaration.id;
-          if (id2 && exportsToRemove.includes(id2.name)) {
-            markedForRemoval.add(path5);
-          }
+// config/config.ts
+var excludedConfigPresetKeys = ["presets"];
+var mergeReactRouterConfig = (...configs) => {
+  let reducer = (configA, configB) => {
+    let mergeRequired = (key) => configA[key] !== void 0 && configB[key] !== void 0;
+    return {
+      ...configA,
+      ...configB,
+      ...mergeRequired("buildEnd") ? {
+        buildEnd: async (...args) => {
+          await Promise.all([
+            configA.buildEnd?.(...args),
+            configB.buildEnd?.(...args)
+          ]);
         }
-        if (path5.node.declaration?.type === "ClassDeclaration") {
-          let id2 = path5.node.declaration.id;
-          if (id2 && exportsToRemove.includes(id2.name)) {
-            markedForRemoval.add(path5);
-          }
+      } : {},
+      ...mergeRequired("future") ? {
+        future: {
+          ...configA.future,
+          ...configB.future
         }
-      }
-      if (path5.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
-        markedForRemoval.add(path5);
-      }
+      } : {},
+      ...mergeRequired("presets") ? {
+        presets: [...configA.presets ?? [], ...configB.presets ?? []]
+      } : {}
+    };
+  };
+  return configs.reduce(reducer, {});
+};
+var deepFreeze = (o) => {
+  Object.freeze(o);
+  let oIsFunction = typeof o === "function";
+  let hasOwnProp = Object.prototype.hasOwnProperty;
+  Object.getOwnPropertyNames(o).forEach(function(prop) {
+    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
+      deepFreeze(o[prop]);
     }
   });
-  if (markedForRemoval.size > 0 || exportsFiltered) {
-    for (let path5 of markedForRemoval) {
-      path5.remove();
-    }
-    (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
-  }
+  return o;
 };
-function validateDestructuredExports(id2, exportsToRemove) {
-  if (id2.type === "ArrayPattern") {
-    for (let element of id2.elements) {
-      if (!element) {
-        continue;
-      }
-      if (element.type === "Identifier" && exportsToRemove.includes(element.name)) {
-        throw invalidDestructureError(element.name);
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+async function resolveConfig({
+  root,
+  viteNodeContext,
+  reactRouterConfigFile
+}) {
+  let reactRouterUserConfig = {};
+  if (reactRouterConfigFile) {
+    try {
+      if (!import_node_fs.default.existsSync(reactRouterConfigFile)) {
+        return err(`${reactRouterConfigFile} no longer exists`);
       }
-      if (element.type === "RestElement" && element.argument.type === "Identifier" && exportsToRemove.includes(element.argument.name)) {
-        throw invalidDestructureError(element.argument.name);
+      let configModule = await viteNodeContext.runner.executeFile(
+        reactRouterConfigFile
+      );
+      if (configModule.default === void 0) {
+        return err(`${reactRouterConfigFile} must provide a default export`);
       }
-      if (element.type === "ArrayPattern" || element.type === "ObjectPattern") {
-        validateDestructuredExports(element, exportsToRemove);
+      if (typeof configModule.default !== "object") {
+        return err(`${reactRouterConfigFile} must export a config`);
       }
+      reactRouterUserConfig = configModule.default;
+    } catch (error) {
+      return err(`Error loading ${reactRouterConfigFile}: ${error}`);
     }
   }
-  if (id2.type === "ObjectPattern") {
-    for (let property of id2.properties) {
-      if (!property) {
-        continue;
-      }
-      if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
-        if (property.value.type === "Identifier" && exportsToRemove.includes(property.value.name)) {
-          throw invalidDestructureError(property.value.name);
-        }
-        if (property.value.type === "ArrayPattern" || property.value.type === "ObjectPattern") {
-          validateDestructuredExports(property.value, exportsToRemove);
-        }
+  reactRouterUserConfig = deepFreeze((0, import_cloneDeep.default)(reactRouterUserConfig));
+  let presets = (await Promise.all(
+    (reactRouterUserConfig.presets ?? []).map(async (preset) => {
+      if (!preset.name) {
+        throw new Error(
+          "React Router presets must have a `name` property defined."
+        );
       }
-      if (property.type === "RestElement" && property.argument.type === "Identifier" && exportsToRemove.includes(property.argument.name)) {
-        throw invalidDestructureError(property.argument.name);
-      }
-    }
-  }
-}
-function invalidDestructureError(name) {
-  return new Error(`Cannot remove destructured export "${name}"`);
-}
-
-// vite/config.ts
-var import_node_child_process = require("child_process");
-var import_node_path2 = __toESM(require("path"));
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_picocolors = __toESM(require("picocolors"));
-var import_pick2 = __toESM(require("lodash/pick"));
-var import_omit = __toESM(require("lodash/omit"));
-var import_package_json = __toESM(require("@npmcli/package-json"));
-
-// config/routes.ts
-var import_node_path = require("path");
-var v = __toESM(require("valibot"));
-var import_pick = __toESM(require("lodash/pick"));
-function setAppDirectory(directory) {
-  globalThis.__reactRouterAppDirectory = directory;
-}
-var routeConfigEntrySchema = v.pipe(
-  v.custom((value) => {
-    return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
-  }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
-  v.object({
-    id: v.optional(v.string()),
-    path: v.optional(v.string()),
-    index: v.optional(v.boolean()),
-    caseSensitive: v.optional(v.boolean()),
-    file: v.string(),
-    children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
-  })
-);
-var resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
-function validateRouteConfig({
-  routeConfigFile,
-  routeConfig
-}) {
-  if (!routeConfig) {
-    return {
-      valid: false,
-      message: `No "routes" export defined in "${routeConfigFile}.`
-    };
-  }
-  if (!Array.isArray(routeConfig)) {
-    return {
-      valid: false,
-      message: `Route config in "${routeConfigFile}" must be an array.`
-    };
-  }
-  let { issues } = v.safeParse(resolvedRouteConfigSchema, routeConfig);
-  if (issues?.length) {
-    let { root, nested } = v.flatten(issues);
-    return {
-      valid: false,
-      message: [
-        `Route config in "${routeConfigFile}" is invalid.`,
-        root ? `${root}` : [],
-        nested ? Object.entries(nested).map(
-          ([path5, message]) => `Path: routes.${path5}
-${message}`
-        ) : []
-      ].flat().join("\n\n")
-    };
-  }
-  return { valid: true };
-}
-function configRoutesToRouteManifest(routes, rootId = "root") {
-  let routeManifest = {};
-  function walk(route, parentId) {
-    let id2 = route.id || createRouteId(route.file);
-    let manifestItem = {
-      id: id2,
-      parentId,
-      file: route.file,
-      path: route.path,
-      index: route.index,
-      caseSensitive: route.caseSensitive
-    };
-    if (routeManifest.hasOwnProperty(id2)) {
-      throw new Error(
-        `Unable to define routes with duplicate route id: "${id2}"`
-      );
-    }
-    routeManifest[id2] = manifestItem;
-    if (route.children) {
-      for (let child of route.children) {
-        walk(child, id2);
-      }
-    }
-  }
-  for (let route of routes) {
-    walk(route, rootId);
-  }
-  return routeManifest;
-}
-function createRouteId(file) {
-  return normalizeSlashes(stripFileExtension(file));
-}
-function normalizeSlashes(file) {
-  return file.split(import_node_path.win32.sep).join("/");
-}
-function stripFileExtension(file) {
-  return file.replace(/\.[a-z0-9]+$/i, "");
-}
-
-// cli/detectPackageManager.ts
-var detectPackageManager = () => {
-  let { npm_config_user_agent } = process.env;
-  if (!npm_config_user_agent) return void 0;
-  try {
-    let pkgManager = npm_config_user_agent.split("/")[0];
-    if (pkgManager === "npm") return "npm";
-    if (pkgManager === "pnpm") return "pnpm";
-    if (pkgManager === "yarn") return "yarn";
-    if (pkgManager === "bun") return "bun";
-    return void 0;
-  } catch {
-    return void 0;
-  }
-};
-
-// vite/config.ts
-var excludedConfigPresetKeys = ["presets"];
-var mergeReactRouterConfig = (...configs) => {
-  let reducer = (configA, configB) => {
-    let mergeRequired = (key) => configA[key] !== void 0 && configB[key] !== void 0;
-    return {
-      ...configA,
-      ...configB,
-      ...mergeRequired("buildEnd") ? {
-        buildEnd: async (...args) => {
-          await Promise.all([
-            configA.buildEnd?.(...args),
-            configB.buildEnd?.(...args)
-          ]);
-        }
-      } : {},
-      ...mergeRequired("future") ? {
-        future: {
-          ...configA.future,
-          ...configB.future
-        }
-      } : {},
-      ...mergeRequired("presets") ? {
-        presets: [...configA.presets ?? [], ...configB.presets ?? []]
-      } : {}
-    };
-  };
-  return configs.reduce(reducer, {});
-};
-var deepFreeze = (o) => {
-  Object.freeze(o);
-  let oIsFunction = typeof o === "function";
-  let hasOwnProp = Object.prototype.hasOwnProperty;
-  Object.getOwnPropertyNames(o).forEach(function(prop) {
-    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
-      deepFreeze(o[prop]);
-    }
-  });
-  return o;
-};
-function resolvePublicPath(viteUserConfig) {
-  return viteUserConfig.base ?? "/";
-}
-var isFirstLoad = true;
-var lastValidRoutes = {};
-async function resolveReactRouterConfig({
-  rootDirectory,
-  reactRouterUserConfig,
-  routeConfigChanged,
-  viteUserConfig,
-  viteCommand,
-  routesViteNodeContext
-}) {
-  let vite2 = importViteEsmSync();
-  let logger = vite2.createLogger(viteUserConfig.logLevel, {
-    prefix: "[react-router]"
-  });
-  let presets = (await Promise.all(
-    (reactRouterUserConfig.presets ?? []).map(async (preset) => {
-      if (!preset.name) {
-        throw new Error(
-          "React Router presets must have a `name` property defined."
-        );
-      }
-      if (!preset.reactRouterConfig) {
-        return null;
+      if (!preset.reactRouterConfig) {
+        return null;
       }
       let configPreset = (0, import_omit.default)(
         await preset.reactRouterConfig({ reactRouterUserConfig }),
@@ -642,194 +358,786 @@ async function resolveReactRouterConfig({
     ...mergeReactRouterConfig(...presets, reactRouterUserConfig)
   };
   if (!ssr && serverBundles) {
-    console.warn(
-      import_picocolors.default.yellow(
-        import_picocolors.default.bold("\u26A0\uFE0F  SPA Mode: ") + "the `serverBundles` config is invalid with `ssr:false` and will be ignored`"
-      )
-    );
     serverBundles = void 0;
   }
   let isValidPrerenderConfig = prerender == null || typeof prerender === "boolean" || Array.isArray(prerender) || typeof prerender === "function";
   if (!isValidPrerenderConfig) {
-    logger.error(
-      import_picocolors.default.red(
-        "The `prerender` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths"
-      )
-    );
-    process.exit(1);
-  }
-  let appDirectory = import_node_path2.default.resolve(rootDirectory, userAppDirectory || "app");
-  let buildDirectory = import_node_path2.default.resolve(rootDirectory, userBuildDirectory);
-  let publicPath = resolvePublicPath(viteUserConfig);
-  if (basename2 !== "/" && viteCommand === "serve" && !viteUserConfig.server?.middlewareMode && !basename2.startsWith(publicPath)) {
-    logger.error(
-      import_picocolors.default.red(
-        "When using the React Router `basename` and the Vite `base` config, the `basename` config must begin with `base` for the default Vite dev server."
-      )
+    return err(
+      "The `prerender` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths"
     );
-    process.exit(1);
   }
+  let appDirectory = import_pathe.default.resolve(root, userAppDirectory || "app");
+  let buildDirectory = import_pathe.default.resolve(root, userBuildDirectory);
   let rootRouteFile = findEntry(appDirectory, "root");
   if (!rootRouteFile) {
-    let rootRouteDisplayPath = import_node_path2.default.relative(
-      rootDirectory,
-      import_node_path2.default.join(appDirectory, "root.tsx")
+    let rootRouteDisplayPath = import_pathe.default.relative(
+      root,
+      import_pathe.default.join(appDirectory, "root.tsx")
     );
-    logger.error(
-      import_picocolors.default.red(
-        `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
-      )
+    return err(
+      `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
     );
-    process.exit(1);
   }
   let routes = {
     root: { path: "", id: "root", file: rootRouteFile }
   };
   let routeConfigFile = findEntry(appDirectory, "routes");
-  class FriendlyError extends Error {
-  }
   try {
     if (!routeConfigFile) {
-      let routeConfigDisplayPath = vite2.normalizePath(
-        import_node_path2.default.relative(rootDirectory, import_node_path2.default.join(appDirectory, "routes.ts"))
-      );
-      throw new FriendlyError(
-        `Route config file not found at "${routeConfigDisplayPath}".`
+      let routeConfigDisplayPath = import_pathe.default.relative(
+        root,
+        import_pathe.default.join(appDirectory, "routes.ts")
       );
+      return err(`Route config file not found at "${routeConfigDisplayPath}".`);
     }
     setAppDirectory(appDirectory);
-    let routeConfigExport = (await routesViteNodeContext.runner.executeFile(
-      import_node_path2.default.join(appDirectory, routeConfigFile)
-    )).routes;
+    let routeConfigExport = (await viteNodeContext.runner.executeFile(
+      import_pathe.default.join(appDirectory, routeConfigFile)
+    )).default;
     let routeConfig = await routeConfigExport;
     let result = validateRouteConfig({
       routeConfigFile,
       routeConfig
     });
     if (!result.valid) {
-      throw new FriendlyError(result.message);
-    }
-    routes = { ...routes, ...configRoutesToRouteManifest(routeConfig) };
-    lastValidRoutes = routes;
-    if (routeConfigChanged) {
-      logger.info(import_picocolors.default.green("Route config changed."), {
-        clear: true,
-        timestamp: true
-      });
+      return err(result.message);
     }
+    routes = {
+      ...routes,
+      ...configRoutesToRouteManifest(appDirectory, routeConfig)
+    };
   } catch (error) {
-    logger.error(
-      error instanceof FriendlyError ? import_picocolors.default.red(error.message) : [
+    return err(
+      [
         import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
         "",
         error.loc?.file && error.loc?.column && error.frame ? [
-          import_node_path2.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          import_pathe.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
           error.frame.trim?.()
         ] : error.stack
-      ].flat().join("\n") + "\n",
-      {
-        error,
-        clear: !isFirstLoad,
-        timestamp: !isFirstLoad
+      ].flat().join("\n")
+    );
+  }
+  let future = {
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false
+  };
+  let reactRouterConfig = deepFreeze({
+    appDirectory,
+    basename: basename2,
+    buildDirectory,
+    buildEnd,
+    future,
+    prerender,
+    routes,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr
+  });
+  for (let preset of reactRouterUserConfig.presets ?? []) {
+    await preset.reactRouterConfigResolved?.({ reactRouterConfig });
+  }
+  return ok(reactRouterConfig);
+}
+async function createConfigLoader({
+  rootDirectory: root,
+  watch: watch2
+}) {
+  root = root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
+  let viteNodeContext = await createContext({
+    root,
+    mode: watch2 ? "development" : "production",
+    server: !watch2 ? { watch: null } : {},
+    ssr: {
+      external: ssrExternals
+    }
+  });
+  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 = initialConfigResult.value.appDirectory;
+  let lastConfig = initialConfigResult.value;
+  let fsWatcher;
+  let changeHandlers = [];
+  return {
+    getConfig,
+    onChange: (handler) => {
+      if (!watch2) {
+        throw new Error(
+          "onChange is not supported when watch mode is disabled"
+        );
+      }
+      changeHandlers.push(handler);
+      if (!fsWatcher) {
+        fsWatcher = import_chokidar.default.watch(
+          [
+            ...reactRouterConfigFile ? [reactRouterConfigFile] : [],
+            appDirectory
+          ],
+          { ignoreInitial: true }
+        );
+        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 configCodeUpdated = Boolean(
+            viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
+          );
+          if (configCodeUpdated || appFileAddedOrRemoved) {
+            viteNodeContext.devServer?.moduleGraph.invalidateAll();
+            viteNodeContext.runner?.moduleCache.clear();
+          }
+          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;
+            }
+          }
+        });
+      }
+      return () => {
+        changeHandlers = changeHandlers.filter(
+          (changeHandler) => changeHandler !== handler
+        );
+      };
+    },
+    close: async () => {
+      changeHandlers = [];
+      await viteNodeContext.devServer.close();
+      await fsWatcher?.close();
+    }
+  };
+}
+async function resolveEntryFiles({
+  rootDirectory,
+  reactRouterConfig
+}) {
+  let { appDirectory } = reactRouterConfig;
+  let defaultsDirectory = import_pathe.default.resolve(
+    import_pathe.default.dirname(require.resolve("@react-router/dev/package.json")),
+    "dist",
+    "config",
+    "defaults"
+  );
+  let userEntryClientFile = findEntry(appDirectory, "entry.client");
+  let userEntryServerFile = findEntry(appDirectory, "entry.server");
+  let entryServerFile;
+  let entryClientFile = userEntryClientFile || "entry.client.tsx";
+  let pkgJson = await import_package_json.default.load(rootDirectory);
+  let deps = pkgJson.content.dependencies ?? {};
+  if (userEntryServerFile) {
+    entryServerFile = userEntryServerFile;
+  } else {
+    if (!deps["@react-router/node"]) {
+      throw new Error(
+        `Could not determine server runtime. Please install @react-router/node, or provide a custom entry.server.tsx/jsx file in your app directory.`
+      );
+    }
+    if (!deps["isbot"]) {
+      console.log(
+        "adding `isbot@5` to your package.json, you should commit this change"
+      );
+      pkgJson.update({
+        dependencies: {
+          ...pkgJson.content.dependencies,
+          isbot: "^5"
+        }
+      });
+      await pkgJson.save();
+      let packageManager = detectPackageManager() ?? "npm";
+      (0, import_node_child_process.execSync)(`${packageManager} install`, {
+        cwd: rootDirectory,
+        stdio: "inherit"
+      });
+    }
+    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);
+  return { entryClientFilePath, entryServerFilePath };
+}
+var ssrExternals = isInReactRouterMonorepo() ? [
+  // 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.
+  "react-router",
+  "react-router-dom",
+  "@react-router/architect",
+  "@react-router/cloudflare",
+  "@react-router/dev",
+  "@react-router/express",
+  "@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);
+    if (import_node_fs.default.existsSync(file)) {
+      return options?.absolute ?? false ? file : import_pathe.default.relative(dir, file);
+    }
+  }
+  return void 0;
+}
+
+// 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}"`;
+  }).join("\n");
+  return import_dedent.default`
+    // React Router generated types for route:
+    // ${route.file}
+
+    import type * as T from "react-router/route-module"
+
+    ${parentTypeImports}
+
+    type Module = typeof import("../${Pathe2.filename(route.file)}")
+
+    export type Info = {
+      parents: [${parents.map((_, i) => `Parent${i}`).join(", ")}],
+      id: "${route.id}"
+      file: "${route.file}"
+      path: "${route.path}"
+      params: {${formatParamProperties(urlpath)}}
+      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 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>
+    }
+  `;
+}
+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("; ");
+}
+function parseParams(urlpath) {
+  const result = {};
+  let segments = urlpath.split("/");
+  segments.forEach((segment) => {
+    const match = segment.match(/^:([\w-]+)(\?)?/);
+    if (!match) return;
+    const param = match[1];
+    const isOptional = match[2] !== void 0;
+    result[param] ??= [];
+    result[param].push(isOptional);
+    return;
+  });
+  const hasSplat = segments.at(-1) === "*";
+  if (hasSplat) result["*"] = [false];
+  return result;
+}
+
+// typegen/index.ts
+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;
+    }
+    ctx.config = result.value;
+    if (routeConfigChanged) {
+      await writeAll(ctx);
+      logger?.info(import_picocolors2.default.green("regenerated types"), {
+        timestamp: true,
+        clear: true
+      });
+    }
+  });
+}
+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) => {
+    const typesPath = getTypesPath(ctx, route);
+    const content = generate(ctx, route);
+    import_node_fs2.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
+    import_node_fs2.default.writeFileSync(typesPath, content);
+  });
+}
+
+// vite/babel.ts
+var import_parser = require("@babel/parser");
+var t = __toESM(require("@babel/types"));
+var traverse = require("@babel/traverse").default;
+var generate2 = require("@babel/generator").default;
+
+// vite/node-adapter.ts
+var import_node_events = require("events");
+var import_node_stream = require("stream");
+var import_set_cookie_parser = require("set-cookie-parser");
+var import_node = require("@react-router/node");
+function fromNodeHeaders(nodeHeaders) {
+  let headers = new Headers();
+  for (let [key, values] of Object.entries(nodeHeaders)) {
+    if (values) {
+      if (Array.isArray(values)) {
+        for (let value of values) {
+          headers.append(key, value);
+        }
+      } else {
+        headers.set(key, values);
+      }
+    }
+  }
+  return headers;
+}
+function fromNodeRequest(nodeReq, nodeRes) {
+  let origin = nodeReq.headers.origin && "null" !== nodeReq.headers.origin ? nodeReq.headers.origin : `http://${nodeReq.headers.host}`;
+  invariant(
+    nodeReq.originalUrl,
+    "Expected `nodeReq.originalUrl` to be defined"
+  );
+  let url3 = new URL(nodeReq.originalUrl, origin);
+  let controller = new AbortController();
+  let init = {
+    method: nodeReq.method,
+    headers: fromNodeHeaders(nodeReq.headers),
+    signal: controller.signal
+  };
+  nodeRes.on("finish", () => controller = null);
+  nodeRes.on("close", () => controller?.abort());
+  if (nodeReq.method !== "GET" && nodeReq.method !== "HEAD") {
+    init.body = (0, import_node.createReadableStreamFromReadable)(nodeReq);
+    init.duplex = "half";
+  }
+  return new Request(url3.href, init);
+}
+async function toNodeRequest(res, nodeRes) {
+  nodeRes.statusCode = res.status;
+  nodeRes.statusMessage = res.statusText;
+  let cookiesStrings = [];
+  for (let [name, value] of res.headers) {
+    if (name === "set-cookie") {
+      cookiesStrings.push(...(0, import_set_cookie_parser.splitCookiesString)(value));
+    } else nodeRes.setHeader(name, value);
+  }
+  if (cookiesStrings.length) {
+    nodeRes.setHeader("set-cookie", cookiesStrings);
+  }
+  if (res.body) {
+    let responseBody = res.body;
+    let readable = import_node_stream.Readable.from(responseBody);
+    readable.pipe(nodeRes);
+    await (0, import_node_events.once)(readable, "end");
+  } else {
+    nodeRes.end();
+  }
+}
+
+// vite/styles.ts
+var path3 = __toESM(require("path"));
+var import_react_router = require("react-router");
+
+// vite/resolve-file-url.ts
+var path2 = __toESM(require("path"));
+var resolveFileUrl = ({ rootDirectory }, filePath) => {
+  let vite2 = importViteEsmSync();
+  let relativePath = path2.relative(rootDirectory, filePath);
+  let isWithinRoot = !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
+  if (!isWithinRoot) {
+    return path2.posix.join("/@fs", vite2.normalizePath(filePath));
+  }
+  return "/" + vite2.normalizePath(relativePath);
+};
+
+// vite/styles.ts
+var cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+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];
+  if (!queryString) {
+    return false;
+  }
+  let params = new URLSearchParams(queryString);
+  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}=`)
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+var getStylesForFiles = async ({
+  viteDevServer,
+  rootDirectory,
+  cssModulesManifest,
+  files
+}) => {
+  let styles = {};
+  let deps = /* @__PURE__ */ new Set();
+  try {
+    for (let file of files) {
+      let normalizedPath = path3.resolve(rootDirectory, file).replace(/\\/g, "/");
+      let node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
+      if (!node) {
+        try {
+          await viteDevServer.transformRequest(
+            resolveFileUrl({ rootDirectory }, normalizedPath)
+          );
+        } catch (err2) {
+          console.error(err2);
+        }
+        node = await viteDevServer.moduleGraph.getModuleById(normalizedPath);
+      }
+      if (!node) {
+        console.log(`Could not resolve module for file: ${file}`);
+        continue;
+      }
+      await findDeps(viteDevServer, node, deps);
+    }
+  } catch (err2) {
+    console.error(err2);
+  }
+  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;
+        if (css === void 0) {
+          throw new Error();
+        }
+        styles[dep.url] = css;
+      } catch {
+        console.warn(`Could not load ${dep.file}`);
+      }
+    }
+  }
+  return Object.entries(styles).map(([fileName, css], i) => [
+    `
+/* ${fileName.replace(/\/\*/g, "/\\*").replace(/\*\//g, "*\\/")} */`,
+    css
+  ]).flat().join("\n") || void 0;
+};
+var findDeps = async (vite2, node, deps) => {
+  let branches = [];
+  async function addFromNode(node2) {
+    if (!deps.has(node2)) {
+      deps.add(node2);
+      await findDeps(vite2, node2, deps);
+    }
+  }
+  async function addFromUrl(url3) {
+    let node2 = await vite2.moduleGraph.getModuleByUrl(url3);
+    if (node2) {
+      await addFromNode(node2);
+    }
+  }
+  if (node.ssrTransformResult) {
+    if (node.ssrTransformResult.deps) {
+      node.ssrTransformResult.deps.forEach(
+        (url3) => branches.push(addFromUrl(url3))
+      );
+    }
+  } else {
+    node.importedModules.forEach((node2) => branches.push(addFromNode(node2)));
+  }
+  await Promise.all(branches);
+};
+var groupRoutesByParentId = (manifest) => {
+  let routes = {};
+  Object.values(manifest).forEach((route) => {
+    if (route) {
+      let parentId = route.parentId || "";
+      if (!routes[parentId]) {
+        routes[parentId] = [];
+      }
+      routes[parentId].push(route);
+    }
+  });
+  return routes;
+};
+var createRoutes = (manifest, parentId = "", routesByParentId = groupRoutesByParentId(manifest)) => {
+  return (routesByParentId[parentId] || []).map((route) => ({
+    ...route,
+    children: createRoutes(manifest, route.id, routesByParentId)
+  }));
+};
+var getStylesForUrl = async ({
+  viteDevServer,
+  rootDirectory,
+  reactRouterConfig,
+  entryClientFilePath,
+  cssModulesManifest,
+  build,
+  url: url3
+}) => {
+  if (url3 === void 0 || url3.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 styles = await getStylesForFiles({
+    viteDevServer,
+    rootDirectory,
+    cssModulesManifest,
+    files: [
+      // Always include the client entry file when crawling the module graph for CSS
+      path3.relative(rootDirectory, entryClientFilePath),
+      // Then include any styles from the matched routes
+      ...documentRouteFiles
+    ]
+  });
+  return styles;
+};
+
+// vite/vmod.ts
+var id = (name) => `virtual:react-router/${name}`;
+var resolve3 = (id2) => `\0${id2}`;
+var url = (id2) => `/@id/__x00__${id2}`;
+
+// vite/combine-urls.ts
+function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+}
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+var removeExports = (ast, exportsToRemove) => {
+  let previouslyReferencedIdentifiers = (0, import_babel_dead_code_elimination.findReferencedIdentifiers)(ast);
+  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) => {
+            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
+              if (exportsToRemove.includes(specifier.exported.name)) {
+                exportsFiltered = true;
+                return false;
+              }
+            }
+            return true;
+          });
+          if (path5.node.specifiers.length === 0) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "VariableDeclaration") {
+          let declaration = path5.node.declaration;
+          declaration.declarations = declaration.declarations.filter(
+            (declaration2) => {
+              if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
+                exportsFiltered = true;
+                return false;
+              }
+              if (declaration2.id.type === "ArrayPattern" || declaration2.id.type === "ObjectPattern") {
+                validateDestructuredExports(declaration2.id, exportsToRemove);
+              }
+              return true;
+            }
+          );
+          if (declaration.declarations.length === 0) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "FunctionDeclaration") {
+          let id2 = path5.node.declaration.id;
+          if (id2 && exportsToRemove.includes(id2.name)) {
+            markedForRemoval.add(path5);
+          }
+        }
+        if (path5.node.declaration?.type === "ClassDeclaration") {
+          let id2 = path5.node.declaration.id;
+          if (id2 && exportsToRemove.includes(id2.name)) {
+            markedForRemoval.add(path5);
+          }
+        }
+      }
+      if (path5.node.type === "ExportDefaultDeclaration" && exportsToRemove.includes("default")) {
+        markedForRemoval.add(path5);
       }
-    );
-    if (isFirstLoad) {
-      process.exit(1);
     }
-    routes = lastValidRoutes;
-  }
-  let future = {};
-  let reactRouterConfig = deepFreeze({
-    appDirectory,
-    basename: basename2,
-    buildDirectory,
-    buildEnd,
-    future,
-    prerender,
-    routes,
-    serverBuildFile,
-    serverBundles,
-    serverModuleFormat,
-    ssr
   });
-  for (let preset of reactRouterUserConfig.presets ?? []) {
-    await preset.reactRouterConfigResolved?.({ reactRouterConfig });
+  if (markedForRemoval.size > 0 || exportsFiltered) {
+    for (let path5 of markedForRemoval) {
+      path5.remove();
+    }
+    (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
   }
-  isFirstLoad = false;
-  return reactRouterConfig;
-}
-async function resolveEntryFiles({
-  rootDirectory,
-  reactRouterConfig
-}) {
-  let { appDirectory } = reactRouterConfig;
-  let defaultsDirectory = import_node_path2.default.resolve(
-    import_node_path2.default.dirname(require.resolve("@react-router/dev/package.json")),
-    "dist",
-    "config",
-    "defaults"
-  );
-  let userEntryClientFile = findEntry(appDirectory, "entry.client");
-  let userEntryServerFile = findEntry(appDirectory, "entry.server");
-  let entryServerFile;
-  let entryClientFile = userEntryClientFile || "entry.client.tsx";
-  let pkgJson = await import_package_json.default.load(rootDirectory);
-  let deps = pkgJson.content.dependencies ?? {};
-  if (userEntryServerFile) {
-    entryServerFile = userEntryServerFile;
-  } else {
-    if (!deps["@react-router/node"]) {
-      throw new Error(
-        `Could not determine server runtime. Please install @react-router/node, or provide a custom entry.server.tsx/jsx file in your app directory.`
-      );
+};
+function validateDestructuredExports(id2, exportsToRemove) {
+  if (id2.type === "ArrayPattern") {
+    for (let element of id2.elements) {
+      if (!element) {
+        continue;
+      }
+      if (element.type === "Identifier" && exportsToRemove.includes(element.name)) {
+        throw invalidDestructureError(element.name);
+      }
+      if (element.type === "RestElement" && element.argument.type === "Identifier" && exportsToRemove.includes(element.argument.name)) {
+        throw invalidDestructureError(element.argument.name);
+      }
+      if (element.type === "ArrayPattern" || element.type === "ObjectPattern") {
+        validateDestructuredExports(element, exportsToRemove);
+      }
     }
-    if (!deps["isbot"]) {
-      console.log(
-        "adding `isbot@5` to your package.json, you should commit this change"
-      );
-      pkgJson.update({
-        dependencies: {
-          ...pkgJson.content.dependencies,
-          isbot: "^5"
+  }
+  if (id2.type === "ObjectPattern") {
+    for (let property of id2.properties) {
+      if (!property) {
+        continue;
+      }
+      if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+        if (property.value.type === "Identifier" && exportsToRemove.includes(property.value.name)) {
+          throw invalidDestructureError(property.value.name);
         }
-      });
-      await pkgJson.save();
-      let packageManager = detectPackageManager() ?? "npm";
-      (0, import_node_child_process.execSync)(`${packageManager} install`, {
-        cwd: rootDirectory,
-        stdio: "inherit"
-      });
+        if (property.value.type === "ArrayPattern" || property.value.type === "ObjectPattern") {
+          validateDestructuredExports(property.value, exportsToRemove);
+        }
+      }
+      if (property.type === "RestElement" && property.argument.type === "Identifier" && exportsToRemove.includes(property.argument.name)) {
+        throw invalidDestructureError(property.argument.name);
+      }
     }
-    entryServerFile = `entry.server.node.tsx`;
   }
-  let entryClientFilePath = userEntryClientFile ? import_node_path2.default.resolve(reactRouterConfig.appDirectory, userEntryClientFile) : import_node_path2.default.resolve(defaultsDirectory, entryClientFile);
-  let entryServerFilePath = userEntryServerFile ? import_node_path2.default.resolve(reactRouterConfig.appDirectory, userEntryServerFile) : import_node_path2.default.resolve(defaultsDirectory, entryServerFile);
-  return { entryClientFilePath, entryServerFilePath };
 }
-var entryExts = [".js", ".jsx", ".ts", ".tsx"];
-function findEntry(dir, basename2) {
-  for (let ext of entryExts) {
-    let file = import_node_path2.default.resolve(dir, basename2 + ext);
-    if (import_fs_extra.default.existsSync(file)) return import_node_path2.default.relative(dir, file);
-  }
-  return void 0;
+function invalidDestructureError(name) {
+  return new Error(`Cannot remove destructured export "${name}"`);
 }
 
 // vite/with-props.ts
-var import_dedent = __toESM(require("dedent"));
+var import_dedent2 = __toESM(require("dedent"));
 var vmodId = id("with-props");
 var NAMED_COMPONENT_EXPORTS = ["HydrateFallback", "ErrorBoundary"];
 var plugin = {
   name: "react-router-with-props",
   enforce: "pre",
   resolveId(id2) {
-    if (id2 === vmodId) return resolve2(vmodId);
+    if (id2 === vmodId) return resolve3(vmodId);
   },
   async load(id2) {
-    if (id2 !== resolve2(vmodId)) return;
-    return import_dedent.default`
+    if (id2 !== resolve3(vmodId)) return;
+    return import_dedent2.default`
       import { createElement as h } from "react";
-      import { useActionData, useLoaderData, useParams } from "react-router";
+      import { useActionData, useLoaderData, useMatches, useParams } from "react-router";
 
       export function withComponentProps(Component) {
         return function Wrapped() {
@@ -837,6 +1145,7 @@ var plugin = {
             params: useParams(),
             loaderData: useLoaderData(),
             actionData: useActionData(),
+            matches: useMatches(),
           };
           return h(Component, props);
         };
@@ -937,48 +1246,6 @@ function toFunctionExpression(decl) {
   );
 }
 
-// vite/vite-node.ts
-var import_server = require("vite-node/server");
-var import_client = require("vite-node/client");
-var import_source_map = require("vite-node/source-map");
-async function createContext(viteConfig = {}) {
-  await preloadViteEsm();
-  const vite2 = importViteEsmSync();
-  const devServer = await vite2.createServer(
-    vite2.mergeConfig(
-      {
-        server: {
-          preTransformRequests: false,
-          hmr: false
-        },
-        optimizeDeps: {
-          noDiscovery: true
-        },
-        configFile: false,
-        envFile: false,
-        plugins: []
-      },
-      viteConfig
-    )
-  );
-  await devServer.pluginContainer.buildStart({});
-  const server = new import_server.ViteNodeServer(devServer);
-  (0, import_source_map.installSourcemapsSupport)({
-    getSourceMap: (source) => server.getSourceMap(source)
-  });
-  const runner = new import_client.ViteNodeRunner({
-    root: devServer.config.root,
-    base: devServer.config.base,
-    fetchModule(id2) {
-      return server.fetchModule(id2);
-    },
-    resolveId(id2, importer) {
-      return server.resolveId(id2, importer);
-    }
-  });
-  return { devServer, server, runner };
-}
-
 // vite/plugin.ts
 var SERVER_ONLY_ROUTE_EXPORTS = ["loader", "action", "headers"];
 var CLIENT_ROUTE_EXPORTS = [
@@ -1012,7 +1279,7 @@ var vmods = [serverBuildId, serverManifestId, browserManifestId];
 var invalidateVirtualModules = (viteDevServer) => {
   vmods.forEach((vmod) => {
     let mod = viteDevServer.moduleGraph.getModuleById(
-      resolve2(vmod)
+      resolve3(vmod)
     );
     if (mod) {
       viteDevServer.moduleGraph.invalidateModule(mod);
@@ -1078,8 +1345,8 @@ function dedupe(array2) {
   return [...new Set(array2)];
 }
 var writeFileSafe = async (file, contents) => {
-  await fse2.ensureDir(path4.dirname(file));
-  await fse2.writeFile(file, contents);
+  await fse.ensureDir(path4.dirname(file));
+  await fse.writeFile(file, contents);
 };
 var getRouteManifestModuleExports = async (viteChildCompiler, ctx) => {
   let entries = await Promise.all(
@@ -1109,7 +1376,7 @@ var getRouteModuleExports = async (viteChildCompiler, ctx, routeFile, readRouteF
   };
   let [id2, code] = await Promise.all([
     resolveId(),
-    readRouteFile?.() ?? fse2.readFile(routePath, "utf-8"),
+    readRouteFile?.() ?? fse.readFile(routePath, "utf-8"),
     // pluginContainer.transform(...) fails if we don't do this first:
     moduleGraph.ensureEntryFromUrl(url3, ssr)
   ]);
@@ -1136,68 +1403,53 @@ var defaultEntriesDir = path4.resolve(
   "config",
   "defaults"
 );
-var defaultEntries = fse2.readdirSync(defaultEntriesDir).map((filename) => path4.join(defaultEntriesDir, filename));
+var defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path4.join(defaultEntriesDir, filename3));
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => ({});
-var deepFreeze2 = (o) => {
-  Object.freeze(o);
-  let oIsFunction = typeof o === "function";
-  let hasOwnProp = Object.prototype.hasOwnProperty;
-  Object.getOwnPropertyNames(o).forEach(function(prop) {
-    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
-      deepFreeze2(o[prop]);
-    }
-  });
-  return o;
-};
-var reactRouterVitePlugin = (_config) => {
-  let reactRouterUserConfig = _config ?? {};
-  reactRouterUserConfig = deepFreeze2(reactRouterUserConfig);
+var reactRouterVitePlugin = () => {
+  let rootDirectory;
   let viteCommand;
   let viteUserConfig;
   let viteConfigEnv;
   let viteConfig;
   let cssModulesManifest = {};
   let viteChildCompiler = null;
-  let routesViteNodeContext = null;
-  let ssrExternals = isInReactRouterMonorepo() ? [
-    // 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.
-    "react-router",
-    "react-router-dom",
-    "@react-router/architect",
-    "@react-router/cloudflare",
-    "@react-router/dev",
-    "@react-router/express",
-    "@react-router/node",
-    "@react-router/serve"
-  ] : void 0;
+  let reactRouterConfigLoader;
+  let logger;
+  let firstLoad = true;
   let ctx;
-  let updatePluginContext = async ({
-    routeConfigChanged = false
-  } = {}) => {
-    let rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
-    invariant(routesViteNodeContext);
-    let reactRouterConfig = await resolveReactRouterConfig({
-      rootDirectory,
-      reactRouterUserConfig,
-      routeConfigChanged,
-      viteUserConfig,
-      viteCommand,
-      routesViteNodeContext
-    });
+  let updatePluginContext = async () => {
+    let reactRouterConfig;
+    let reactRouterConfigResult = await reactRouterConfigLoader.getConfig();
+    if (reactRouterConfigResult.ok) {
+      reactRouterConfig = reactRouterConfigResult.value;
+    } else {
+      logger.error(reactRouterConfigResult.error);
+      if (firstLoad) {
+        process.exit(1);
+      }
+      return;
+    }
     let { entryClientFilePath, entryServerFilePath } = await resolveEntryFiles({
       rootDirectory,
       reactRouterConfig
     });
-    let publicPath = resolvePublicPath(viteUserConfig);
+    let publicPath = viteUserConfig.base ?? "/";
+    if (reactRouterConfig.basename !== "/" && viteCommand === "serve" && !viteUserConfig.server?.middlewareMode && !reactRouterConfig.basename.startsWith(publicPath)) {
+      logger.error(
+        import_picocolors3.default.red(
+          "When using the React Router `basename` and the Vite `base` config, the `basename` config must begin with `base` for the default Vite dev server."
+        )
+      );
+      process.exit(1);
+    }
     let viteManifestEnabled = viteUserConfig.build?.manifest === true;
     let ssrBuildCtx = viteConfigEnv.isSsrBuild && viteCommand === "build" ? {
       isSsrBuild: true,
       getReactRouterServerManifest: async () => (await generateReactRouterManifestsForBuild()).reactRouterServerManifest,
       serverBundleBuildConfig: getServerBundleBuildConfig(viteUserConfig)
     } : { isSsrBuild: false };
+    firstLoad = false;
     ctx = {
       reactRouterConfig,
       rootDirectory,
@@ -1262,7 +1514,7 @@ var reactRouterVitePlugin = (_config) => {
       };`;
   };
   let loadViteManifest = async (directory) => {
-    let manifestContents = await fse2.readFile(
+    let manifestContents = await fse.readFile(
       path4.resolve(directory, ".vite", "manifest.json"),
       "utf-8"
     );
@@ -1271,7 +1523,7 @@ var reactRouterVitePlugin = (_config) => {
   let hasDependency = (name) => {
     try {
       return Boolean(require.resolve(name, { paths: [ctx.rootDirectory] }));
-    } catch (err) {
+    } catch (err2) {
       return false;
     }
   };
@@ -1416,15 +1668,19 @@ var reactRouterVitePlugin = (_config) => {
         viteUserConfig = _viteUserConfig;
         viteConfigEnv = _viteConfigEnv;
         viteCommand = viteConfigEnv.command;
-        routesViteNodeContext = await createContext({
-          root: viteUserConfig.root,
-          mode: viteConfigEnv.mode,
-          server: {
-            watch: viteCommand === "build" ? null : void 0
-          },
-          ssr: {
-            external: ssrExternals
-          }
+        logger = vite2.createLogger(viteUserConfig.logLevel, {
+          prefix: "[react-router]"
+        });
+        rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
+        if (viteCommand === "serve") {
+          watch(rootDirectory, {
+            // 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,
+          watch: viteCommand === "serve"
         });
         await updatePluginContext();
         Object.assign(
@@ -1459,9 +1715,19 @@ var reactRouterVitePlugin = (_config) => {
           __reactRouterPluginContext: ctx,
           appType: viteCommand === "serve" && viteConfigEnv.mode === "production" && ctx.reactRouterConfig.ssr === false ? "spa" : "custom",
           ssr: {
-            external: ssrExternals
+            external: ssrExternals,
+            resolve: {
+              conditions: viteCommand === "build" ? [] : ["development"],
+              externalConditions: viteCommand === "build" ? [] : ["development"]
+            }
           },
           optimizeDeps: {
+            entries: ctx.reactRouterConfig.future.unstable_optimizeDeps ? [
+              ctx.entryClientFilePath,
+              ...Object.values(ctx.reactRouterConfig.routes).map(
+                (route) => path4.join(ctx.reactRouterConfig.appDirectory, route.file)
+              )
+            ] : [],
             include: [
               // Pre-bundle React dependencies to avoid React duplicates,
               // even if React dependencies are not direct dependencies.
@@ -1492,7 +1758,8 @@ var reactRouterVitePlugin = (_config) => {
               "react-router",
               "react-router/dom",
               "react-router-dom"
-            ]
+            ],
+            conditions: viteCommand === "build" ? [] : ["development"]
           },
           base: viteUserConfig.base,
           // When consumer provides an allow list for files that can be read by
@@ -1614,8 +1881,8 @@ var reactRouterVitePlugin = (_config) => {
         invariant(viteConfig);
         if (viteCommand === "build" && viteConfig.mode === "production" && !viteConfig.build.ssr && viteConfig.build.sourcemap) {
           viteConfig.logger.warn(
-            import_picocolors2.default.yellow(
-              "\n" + import_picocolors2.default.bold("  \u26A0\uFE0F  Source maps are enabled in production\n") + [
+            import_picocolors3.default.yellow(
+              "\n" + import_picocolors3.default.bold("  \u26A0\uFE0F  Source maps are enabled in production\n") + [
                 "This makes your server code publicly",
                 "visible in the browser. This is highly",
                 "discouraged! If you insist, ensure that",
@@ -1650,31 +1917,38 @@ var reactRouterVitePlugin = (_config) => {
             }
           }
         });
-        viteDevServer.watcher.on("all", async (eventName, rawFilepath) => {
-          let { normalizePath } = importViteEsmSync();
-          let filepath = normalizePath(rawFilepath);
-          let appFileAddedOrRemoved = (eventName === "add" || eventName === "unlink") && filepath.startsWith(
-            normalizePath(ctx.reactRouterConfig.appDirectory)
-          );
-          invariant(viteConfig?.configFile);
-          let viteConfigChanged = eventName === "change" && filepath === normalizePath(viteConfig.configFile);
-          let routeConfigChanged = Boolean(
-            routesViteNodeContext?.devServer?.moduleGraph.getModuleById(
-              filepath
-            )
-          );
-          if (routeConfigChanged || appFileAddedOrRemoved) {
-            routesViteNodeContext?.devServer?.moduleGraph.invalidateAll();
-            routesViteNodeContext?.runner?.moduleCache.clear();
-          }
-          if (appFileAddedOrRemoved || viteConfigChanged || routeConfigChanged) {
-            let lastReactRouterConfig = ctx.reactRouterConfig;
-            await updatePluginContext({ routeConfigChanged });
-            if (!isEqualJson(lastReactRouterConfig, ctx.reactRouterConfig)) {
+        reactRouterConfigLoader.onChange(
+          async ({
+            result,
+            configCodeUpdated,
+            configChanged,
+            routeConfigChanged
+          }) => {
+            if (!result.ok) {
+              invalidateVirtualModules(viteDevServer);
+              logger.error(result.error, {
+                clear: true,
+                timestamp: true
+              });
+              return;
+            }
+            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) {
               invalidateVirtualModules(viteDevServer);
             }
           }
-        });
+        );
         return () => {
           if (!viteDevServer.config.server.middlewareMode) {
             viteDevServer.middlewares.use(async (req, res, next) => {
@@ -1717,11 +1991,11 @@ var reactRouterVitePlugin = (_config) => {
           for (let ssrAssetPath of ssrAssetPaths) {
             let src = path4.join(serverBuildDirectory, ssrAssetPath);
             let dest = path4.join(clientBuildDirectory, ssrAssetPath);
-            if (!fse2.existsSync(dest)) {
-              await fse2.move(src, dest);
+            if (!fse.existsSync(dest)) {
+              await fse.move(src, dest);
               movedAssetPaths.push(dest);
             } else {
-              await fse2.remove(src);
+              await fse.remove(src);
             }
           }
           let ssrCssPaths = Object.values(ssrViteManifest).flatMap(
@@ -1729,16 +2003,16 @@ var reactRouterVitePlugin = (_config) => {
           );
           await Promise.all(
             ssrCssPaths.map(
-              (cssPath) => fse2.remove(path4.join(serverBuildDirectory, cssPath))
+              (cssPath) => fse.remove(path4.join(serverBuildDirectory, cssPath))
             )
           );
           if (movedAssetPaths.length) {
             viteConfig.logger.info(
               [
                 "",
-                `${import_picocolors2.default.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from React Router server build to client assets.`,
+                `${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_picocolors2.default.dim(path4.relative(ctx.rootDirectory, movedAssetPath))
+                  (movedAssetPath) => import_picocolors3.default.dim(path4.relative(ctx.rootDirectory, movedAssetPath))
                 ),
                 ""
               ].join("\n")
@@ -1751,7 +2025,8 @@ var reactRouterVitePlugin = (_config) => {
               serverBuildDirectory,
               clientBuildDirectory
             );
-          } else if (!ctx.reactRouterConfig.ssr) {
+          }
+          if (!ctx.reactRouterConfig.ssr) {
             await handleSpaMode(
               viteConfig,
               ctx.reactRouterConfig,
@@ -1763,17 +2038,17 @@ var reactRouterVitePlugin = (_config) => {
             viteConfig.logger.info(
               [
                 "Removing the server build in",
-                import_picocolors2.default.green(serverBuildDirectory),
+                import_picocolors3.default.green(serverBuildDirectory),
                 "due to ssr:false"
               ].join(" ")
             );
-            fse2.removeSync(serverBuildDirectory);
+            fse.removeSync(serverBuildDirectory);
           }
         }
       },
       async buildEnd() {
         await viteChildCompiler?.close();
-        await routesViteNodeContext?.devServer?.close();
+        await reactRouterConfigLoader.close();
       }
     },
     {
@@ -1798,20 +2073,20 @@ var reactRouterVitePlugin = (_config) => {
       name: "react-router-virtual-modules",
       enforce: "pre",
       resolveId(id2) {
-        if (vmods.includes(id2)) return resolve2(id2);
+        if (vmods.includes(id2)) return resolve3(id2);
       },
       async load(id2) {
         switch (id2) {
-          case resolve2(serverBuildId): {
+          case resolve3(serverBuildId): {
             return await getServerEntry();
           }
-          case resolve2(serverManifestId): {
+          case resolve3(serverManifestId): {
             let reactRouterManifest = ctx.isSsrBuild ? await ctx.getReactRouterServerManifest() : await getReactRouterManifestForDev();
             return `export default ${(0, import_jsesc.default)(reactRouterManifest, {
               es6: true
             })};`;
           }
-          case resolve2(browserManifestId): {
+          case resolve3(browserManifestId): {
             if (viteCommand === "build") {
               throw new Error("This module only exists in development");
             }
@@ -1854,7 +2129,7 @@ var reactRouterVitePlugin = (_config) => {
           ).join(", ");
           throw Error(
             [
-              import_picocolors2.default.red(`Server-only module referenced by client`),
+              import_picocolors3.default.red(`Server-only module referenced by client`),
               "",
               `    '${id2}' imported by route '${importerShort}'`,
               "",
@@ -1870,7 +2145,7 @@ var reactRouterVitePlugin = (_config) => {
         }
         throw Error(
           [
-            import_picocolors2.default.red(`Server-only module referenced by client`),
+            import_picocolors3.default.red(`Server-only module referenced by client`),
             "",
             `    '${id2}' imported by '${importerShort}'`,
             "",
@@ -1924,7 +2199,7 @@ var reactRouterVitePlugin = (_config) => {
           removeExports(ast, SERVER_ONLY_ROUTE_EXPORTS);
         }
         transform(ast);
-        return generate(ast, {
+        return generate2(ast, {
           sourceMaps: true,
           filename: id2,
           sourceFileName: filepath
@@ -1936,10 +2211,10 @@ var reactRouterVitePlugin = (_config) => {
       enforce: "pre",
       resolveId(id2) {
         if (id2 === injectHmrRuntimeId)
-          return resolve2(injectHmrRuntimeId);
+          return resolve3(injectHmrRuntimeId);
       },
       async load(id2) {
-        if (id2 !== resolve2(injectHmrRuntimeId)) return;
+        if (id2 !== resolve3(injectHmrRuntimeId)) return;
         return [
           `import RefreshRuntime from "${hmrRuntimeId}"`,
           "RefreshRuntime.injectIntoGlobalHook(window)",
@@ -1953,10 +2228,10 @@ var reactRouterVitePlugin = (_config) => {
       name: "react-router-hmr-runtime",
       enforce: "pre",
       resolveId(id2) {
-        if (id2 === hmrRuntimeId) return resolve2(hmrRuntimeId);
+        if (id2 === hmrRuntimeId) return resolve3(hmrRuntimeId);
       },
       async load(id2) {
-        if (id2 !== resolve2(hmrRuntimeId)) return;
+        if (id2 !== resolve3(hmrRuntimeId)) return;
         let reactRefreshDir = path4.dirname(
           require.resolve("react-refresh/package.json")
         );
@@ -1966,8 +2241,8 @@ var reactRouterVitePlugin = (_config) => {
         );
         return [
           "const exports = {}",
-          await fse2.readFile(reactRefreshRuntimePath, "utf8"),
-          await fse2.readFile(
+          await fse.readFile(reactRefreshRuntimePath, "utf8"),
+          await fse.readFile(
             require.resolve("./static/refresh-utils.cjs"),
             "utf8"
           ),
@@ -2047,18 +2322,6 @@ var reactRouterVitePlugin = (_config) => {
     }
   ];
 };
-function isInReactRouterMonorepo() {
-  let serverRuntimePath = path4.dirname(
-    require.resolve("@react-router/node/package.json")
-  );
-  let serverRuntimeParentDir = path4.basename(
-    path4.resolve(serverRuntimePath, "..")
-  );
-  return serverRuntimeParentDir === "packages";
-}
-function isEqualJson(v1, v2) {
-  return JSON.stringify(v1) === JSON.stringify(v2);
-}
 function addRefreshWrapper(reactRouterConfig, code, id2) {
   let route = getRoute(reactRouterConfig, id2);
   let acceptExports = route || isRouteEntry(id2) ? [
@@ -2191,9 +2454,9 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
   let html = await response.text();
   validatePrerenderedResponse(response, html, "SPA Mode", "/");
   validatePrerenderedHtml(html, "SPA Mode");
-  await fse2.writeFile(path4.join(clientBuildDirectory, "index.html"), html);
+  await fse.writeFile(path4.join(clientBuildDirectory, "index.html"), html);
   viteConfig.logger.info(
-    "SPA Mode: index.html has been written to your " + import_picocolors2.default.bold(path4.relative(process.cwd(), clientBuildDirectory)) + " directory"
+    "SPA Mode: index.html has been written to your " + import_picocolors3.default.bold(path4.relative(process.cwd(), clientBuildDirectory)) + " directory"
   );
 }
 async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirectory, clientBuildDirectory) {
@@ -2311,9 +2574,9 @@ async function prerenderData(handler, prerenderPath, clientBuildDirectory, react
   validatePrerenderedResponse(response, data, "Prerender", normalizedPath);
   let outdir = path4.relative(process.cwd(), clientBuildDirectory);
   let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse2.ensureDir(path4.dirname(outfile));
-  await fse2.outputFile(outfile, data);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+  await fse.ensureDir(path4.dirname(outfile));
+  await fse.outputFile(outfile, data);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
   return data;
 }
 async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
@@ -2330,9 +2593,9 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
   }
   let outdir = path4.relative(process.cwd(), clientBuildDirectory);
   let outfile = path4.join(outdir, ...normalizedPath.split("/"), "index.html");
-  await fse2.ensureDir(path4.dirname(outfile));
-  await fse2.outputFile(outfile, html);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+  await fse.ensureDir(path4.dirname(outfile));
+  await fse.outputFile(outfile, html);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
 async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirectory, reactRouterConfig, viteConfig, requestInit) {
   let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(/\/\/+/g, "/").replace(/\/$/g, "");
@@ -2342,9 +2605,9 @@ async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirecto
   validatePrerenderedResponse(response, text, "Prerender", normalizedPath);
   let outdir = path4.relative(process.cwd(), clientBuildDirectory);
   let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse2.ensureDir(path4.dirname(outfile));
-  await fse2.outputFile(outfile, text);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+  await fse.ensureDir(path4.dirname(outfile));
+  await fse.outputFile(outfile, text);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
 async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig, viteConfig) {
   let normalizedPath = `${reactRouterConfig.basename}/__manifest`.replace(
@@ -2353,10 +2616,10 @@ async function prerenderManifest(build, clientBuildDirectory, reactRouterConfig,
   );
   let outdir = path4.relative(process.cwd(), clientBuildDirectory);
   let outfile = path4.join(outdir, ...normalizedPath.split("/"));
-  await fse2.ensureDir(path4.dirname(outfile));
+  await fse.ensureDir(path4.dirname(outfile));
   let manifestData = JSON.stringify(build.assets.routes);
-  await fse2.outputFile(outfile, manifestData);
-  viteConfig.logger.info(`Prerender: Generated ${import_picocolors2.default.bold(outfile)}`);
+  await fse.outputFile(outfile, manifestData);
+  viteConfig.logger.info(`Prerender: Generated ${import_picocolors3.default.bold(outfile)}`);
 }
 function validatePrerenderedResponse(response, html, prefix, path5) {
   if (response.status !== 200) {