@react-router/dev 0.0.0-experimental-e988dc602 → 0.0.0-experimental-00e730ed0

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * @react-router/dev v0.0.0-experimental-e988dc602
+ * @react-router/dev v0.0.0-experimental-00e730ed0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -125,13 +125,15 @@ var init_ssr_externals = __esm({
 // vite/vite-node.ts
 async function createContext({
   root,
-  mode
+  mode,
+  customLogger
 }) {
   await preloadVite();
   const vite2 = getVite();
   const devServer = await vite2.createServer({
     root,
     mode,
+    customLogger,
     server: {
       preTransformRequests: false,
       hmr: false,
@@ -143,6 +145,15 @@ 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: []
@@ -205,7 +216,7 @@ function validateRouteConfig({
         `Route config in "${routeConfigFile}" is invalid.`,
         root ? `${root}` : [],
         nested ? Object.entries(nested).map(
-          ([path9, message]) => `Path: routes.${path9}
+          ([path8, message]) => `Path: routes.${path8}
 ${message}`
         ) : []
       ].flat().join("\n\n")
@@ -290,7 +301,8 @@ function err(error) {
 async function resolveConfig({
   root,
   viteNodeContext,
-  reactRouterConfigFile
+  reactRouterConfigFile,
+  skipRoutes
 }) {
   let reactRouterUserConfig = {};
   if (reactRouterConfigFile) {
@@ -339,12 +351,17 @@ async function resolveConfig({
     serverModuleFormat: "esm",
     ssr: true
   };
+  let userAndPresetConfigs = mergeReactRouterConfig(
+    ...presets,
+    reactRouterUserConfig
+  );
   let {
     appDirectory: userAppDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory: userBuildDirectory,
     buildEnd,
     prerender,
+    routeDiscovery: userRouteDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
@@ -352,7 +369,7 @@ async function resolveConfig({
   } = {
     ...defaults,
     // Default values should be completely overridden by user/preset config, not merged
-    ...mergeReactRouterConfig(...presets, reactRouterUserConfig)
+    ...userAndPresetConfigs
   };
   if (!ssr && serverBundles) {
     serverBundles = void 0;
@@ -363,6 +380,32 @@ 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");
@@ -375,45 +418,50 @@ async function resolveConfig({
       `Could not find a root route module in the app directory as "${rootRouteDisplayPath}"`
     );
   }
-  let routes2 = {
-    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);
-    }
+  let routes2 = {};
+  if (!skipRoutes) {
     routes2 = {
-      ...routes2,
-      ...configRoutesToRouteManifest(appDirectory, routeConfig)
+      root: { path: "", id: "root", file: rootRouteFile }
     };
-  } 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 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);
+      }
+      routes2 = {
+        ...routes2,
+        ...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,
@@ -424,12 +472,13 @@ async function resolveConfig({
   };
   let reactRouterConfig = deepFreeze({
     appDirectory,
-    basename: basename2,
+    basename: basename3,
     buildDirectory,
     buildEnd,
     future,
     prerender,
     routes: routes2,
+    routeDiscovery,
     serverBuildFile,
     serverBundles,
     serverModuleFormat,
@@ -442,24 +491,35 @@ async function resolveConfig({
 }
 async function createConfigLoader({
   rootDirectory: root,
-  watch: watch2
+  watch: watch2,
+  mode,
+  skipRoutes
 }) {
-  root = root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
+  root = import_pathe3.default.normalize(root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd());
+  let vite2 = await import("vite");
   let viteNodeContext = await createContext({
     root,
-    mode: watch2 ? "development" : "production"
-  });
-  let reactRouterConfigFile = findEntry(root, "react-router.config", {
-    absolute: true
+    mode,
+    // Filter out any info level logs from vite-node
+    customLogger: vite2.createLogger("warn", {
+      prefix: "[react-router]"
+    })
   });
-  let getConfig = () => resolveConfig({ root, viteNodeContext, reactRouterConfigFile });
+  let reactRouterConfigFile;
+  let updateReactRouterConfigFile = () => {
+    reactRouterConfigFile = findEntry(root, "react-router.config", {
+      absolute: true
+    });
+  };
+  updateReactRouterConfigFile();
+  let getConfig = () => resolveConfig({ root, viteNodeContext, reactRouterConfigFile, skipRoutes });
   let appDirectory;
   let initialConfigResult = await getConfig();
   if (!initialConfigResult.ok) {
     throw new Error(initialConfigResult.error);
   }
-  appDirectory = initialConfigResult.value.appDirectory;
-  let lastConfig = initialConfigResult.value;
+  appDirectory = import_pathe3.default.normalize(initialConfigResult.value.appDirectory);
+  let currentConfig = initialConfigResult.value;
   let fsWatcher;
   let changeHandlers = [];
   return {
@@ -472,41 +532,71 @@ async function createConfigLoader({
       }
       changeHandlers.push(handler);
       if (!fsWatcher) {
-        fsWatcher = import_chokidar.default.watch(
-          [
-            ...reactRouterConfigFile ? [reactRouterConfigFile] : [],
-            appDirectory
-          ],
-          { ignoreInitial: true }
-        );
+        fsWatcher = import_chokidar.default.watch([root, appDirectory], {
+          ignoreInitial: true,
+          ignored: (path8) => {
+            let dirname5 = import_pathe3.default.dirname(path8);
+            return !dirname5.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
+            // that are at the root level, not nested in subdirectories
+            path8 !== root && // Watch the root directory itself
+            dirname5 !== root;
+          }
+        });
         fsWatcher.on("all", async (...args) => {
           let [event, rawFilepath] = args;
           let filepath = import_pathe3.default.normalize(rawFilepath);
-          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
-          let configCodeUpdated = Boolean(
+          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(
             viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
           );
-          if (configCodeUpdated || appFileAddedOrRemoved) {
-            viteNodeContext.devServer?.moduleGraph.invalidateAll();
-            viteNodeContext.runner?.moduleCache.clear();
+          if (!moduleGraphChanged && !appFileAddedOrRemoved) {
+            return;
           }
-          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;
-            }
+          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;
           }
         });
       }
@@ -523,23 +613,73 @@ async function createConfigLoader({
     }
   };
 }
-async function loadConfig({ rootDirectory }) {
+async function loadConfig({
+  rootDirectory,
+  mode,
+  skipRoutes
+}) {
   let configLoader = await createConfigLoader({
     rootDirectory,
+    mode,
+    skipRoutes,
     watch: false
   });
   let config = await configLoader.getConfig();
   await configLoader.close();
   return config;
 }
-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);
+function omitRoutes(config) {
+  return {
+    ...config,
+    routes: {}
+  };
+}
+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;
   }
-  return void 0;
+}
+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;
+    }
+  }
+  return false;
 }
 var import_node_fs, import_node_child_process, import_package_json, import_pathe3, import_chokidar, import_picocolors, import_pick2, import_omit, import_cloneDeep, import_isEqual, excludedConfigPresetKeys, mergeReactRouterConfig, deepFreeze, entryExts;
 var init_config = __esm({
@@ -640,6 +780,31 @@ var init_profiler = __esm({
   }
 });
 
+// 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
+  };
+}
+var init_context = __esm({
+  "typegen/context.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
 // vite/babel.ts
 var babel_exports = {};
 __export(babel_exports, {
@@ -659,27 +824,6 @@ var init_babel = __esm({
   }
 });
 
-// typegen/paths.ts
-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"
-  );
-}
-var Path2, Pathe;
-var init_paths = __esm({
-  "typegen/paths.ts"() {
-    "use strict";
-    Path2 = __toESM(require("pathe"));
-    Pathe = __toESM(require("pathe/utils"));
-  }
-});
-
 // typegen/params.ts
 function parse2(fullpath2) {
   const result = {};
@@ -715,7 +859,7 @@ function lineage(routes2, route) {
 }
 function fullpath(lineage2) {
   if (lineage2.length === 1 && lineage2[0].id === "root") return "/";
-  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path9) => path9 !== void 0 && path9 !== "").join("/");
+  return "/" + lineage2.map((route) => route.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path8) => path8 !== void 0 && path8 !== "").join("/");
 }
 var init_route = __esm({
   "typegen/route.ts"() {
@@ -724,220 +868,358 @@ var init_route = __esm({
 });
 
 // typegen/generate.ts
-function generate2(ctx, route) {
+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
+
+    import "react-router";
+
+    declare module "react-router" {
+      interface Future {
+        unstable_middleware: ${ctx.config.future.unstable_middleware}
+      }
+    }
+  `;
+  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
+
+    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"];
+    }
+  `;
+  return { filename: filename2, content };
+}
+function generatePages(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+pages.ts");
+  const fullpaths = /* @__PURE__ */ new Set();
+  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 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"
+
+      declare module "react-router" {
+        interface Register {
+          pages: Pages
+        }
+      }
+    ` + "\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"),
+    null,
+    t2.tsTypeLiteral(
+      Object.values(ctx.config.routes).map((route) => {
+        return t2.tsPropertySignature(
+          t2.stringLiteral(route.id),
+          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)))
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+  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 fullpath2 = fullpath(lineage2);
-  const typesPath = getTypesPath(ctx, route);
   const parents = lineage2.slice(0, -1);
-  const parentTypeImports = parents.map((parent, i) => {
+  return parents.map((parent, i) => {
     const rel = Path3.relative(
       Path3.dirname(typesPath),
-      getTypesPath(ctx, parent)
+      getRouteModuleAnnotationsFilepath(ctx, parent)
     );
-    const indent = i === 0 ? "" : "  ".repeat(2);
     let source = noExtension(rel);
     if (!source.startsWith("../")) source = "./" + source;
-    return `${indent}import type { Info as Parent${i} } from "${source}.js"`;
-  }).join("\n");
-  return import_dedent.default`
-    // React Router generated types for route:
-    // ${route.file}
-
-    import type * as T from "react-router/route-module"
-
-    ${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>
-    }
-  `;
+    const name = `Parent${i}`;
+    return {
+      name,
+      import: `import type { unstable_Props as ${name} } from "${source}.js"`
+    };
+  });
 }
-function formatParamProperties(fullpath2) {
-  const params = parse2(fullpath2);
-  const properties = Object.entries(params).map(
-    ([name, isRequired]) => isRequired ? `"${name}": string` : `"${name}"?: string`
+function noExtension(path8) {
+  return Path3.join(Path3.dirname(path8), Pathe.filename(path8));
+}
+function paramsType(path8) {
+  const params = parse2(path8);
+  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;
+    })
   );
-  return properties.join("; ");
 }
-var import_dedent, Path3, Pathe2, noExtension;
+var import_dedent, Path3, Pathe, t2;
 var init_generate = __esm({
   "typegen/generate.ts"() {
     "use strict";
     import_dedent = __toESM(require("dedent"));
     Path3 = __toESM(require("pathe"));
-    Pathe2 = __toESM(require("pathe/utils"));
-    init_paths();
+    Pathe = __toESM(require("pathe/utils"));
+    init_babel();
     init_params();
     init_route();
-    noExtension = (path9) => Path3.join(Path3.dirname(path9), Pathe2.filename(path9));
+    ({ t: t2 } = babel_exports);
   }
 });
 
 // typegen/index.ts
-async function run(rootDirectory) {
-  const ctx = await createContext2({ rootDirectory, watch: false });
-  await writeAll(ctx);
-}
-async function watch(rootDirectory, { logger } = {}) {
-  const ctx = await createContext2({ rootDirectory, watch: true });
-  await writeAll(ctx);
-  logger?.info(import_picocolors3.default.green("generated types"), { timestamp: true, clear: true });
-  ctx.configLoader.onChange(async ({ result, routeConfigChanged }) => {
-    if (!result.ok) {
-      logger?.error(import_picocolors3.default.red(result.error), { timestamp: true, clear: true });
-      return;
-    }
-    ctx.config = result.value;
-    if (routeConfigChanged) {
-      await writeAll(ctx);
-      logger?.info(import_picocolors3.default.green("regenerated types"), {
-        timestamp: true,
-        clear: true
-      });
-    }
-  });
-  return {
-    close: async () => await ctx.configLoader.close()
-  };
+async function clearRouteModuleAnnotations(ctx) {
+  await import_promises.default.rm(
+    Path4.join(typesDirectory(ctx), Path4.basename(ctx.config.appDirectory)),
+    { recursive: true, force: 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 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 writeAll(ctx) {
-  const typegenDir = getTypesDir(ctx);
-  import_node_fs3.default.rmSync(typegenDir, { recursive: true, force: true });
-  Object.values(ctx.config.routes).forEach((route) => {
-    const typesPath = getTypesPath(ctx, route);
-    const content = generate2(ctx, route);
-    import_node_fs3.default.mkdirSync(Path4.dirname(typesPath), { recursive: true });
-    import_node_fs3.default.writeFileSync(typesPath, content);
-  });
-  const registerPath = Path4.join(typegenDir, "+register.ts");
-  import_node_fs3.default.writeFileSync(registerPath, register(ctx));
-  const virtualPath = Path4.join(typegenDir, "+virtual.d.ts");
-  import_node_fs3.default.writeFileSync(virtualPath, virtual);
+async function run(rootDirectory, { mode }) {
+  const ctx = await createContext2({ rootDirectory, mode, watch: false });
+  await import_promises.default.rm(typesDirectory(ctx), { recursive: true, force: true });
+  await write(
+    generateFuture(ctx),
+    generatePages(ctx),
+    generateRoutes(ctx),
+    generateServerBuild(ctx),
+    ...generateRouteModuleAnnotations(ctx)
+  );
 }
-function register(ctx) {
-  const register2 = import_dedent2.default`
-    import "react-router";
-
-    declare module "react-router" {
-      interface Register {
-        params: Params;
-      }
-    }
-  `;
-  const { t: t2 } = babel_exports;
-  const indexPaths = new Set(
-    Object.values(ctx.config.routes).filter((route) => route.index).map((route) => route.path)
+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)
   );
-  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(fullpath2),
-          t2.tsTypeAnnotation(
-            t2.tsTypeLiteral(
-              Object.entries(params).map(([param, isRequired]) => {
-                const property = t2.tsPropertySignature(
-                  t2.stringLiteral(param),
-                  t2.tsTypeAnnotation(t2.tsStringKeyword())
-                );
-                property.optional = !isRequired;
-                return property;
-              })
-            )
-          )
+  logger?.info((0, import_picocolors3.green)("generated types"), { timestamp: true, clear: true });
+  ctx.configLoader.onChange(
+    async ({ result, configChanged, routeConfigChanged }) => {
+      if (!result.ok) {
+        logger?.error((0, import_picocolors3.red)(result.error), { timestamp: true, clear: true });
+        return;
+      }
+      ctx.config = result.value;
+      if (configChanged) {
+        await write(generateFuture(ctx));
+        logger?.info((0, import_picocolors3.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+      if (routeConfigChanged) {
+        await clearRouteModuleAnnotations(ctx);
+        await write(
+          generatePages(ctx),
+          generateRoutes(ctx),
+          ...generateRouteModuleAnnotations(ctx)
         );
-      }).filter((x) => x !== void 0)
-    )
+        logger?.info((0, import_picocolors3.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+    }
   );
-  return [register2, generate(typeParams).code].join("\n\n");
+  return {
+    close: async () => await ctx.configLoader.close()
+  };
 }
-var import_node_fs3, import_dedent2, Path4, import_picocolors3, virtual;
+var import_promises, Path4, import_picocolors3;
 var init_typegen = __esm({
   "typegen/index.ts"() {
     "use strict";
-    import_node_fs3 = __toESM(require("fs"));
-    import_dedent2 = __toESM(require("dedent"));
+    import_promises = __toESM(require("fs/promises"));
     Path4 = __toESM(require("pathe"));
-    import_picocolors3 = __toESM(require("picocolors"));
-    init_config();
-    init_babel();
+    import_picocolors3 = require("picocolors");
+    init_context();
     init_generate();
-    init_paths();
-    init_params();
-    init_route();
-    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"];
-  }
-`;
   }
 });
 
@@ -955,23 +1237,24 @@ var init_node_adapter = __esm({
 });
 
 // vite/resolve-file-url.ts
-var path5;
+var path4;
 var init_resolve_file_url = __esm({
   "vite/resolve-file-url.ts"() {
     "use strict";
-    path5 = __toESM(require("path"));
+    path4 = __toESM(require("path"));
     init_vite();
   }
 });
 
 // vite/styles.ts
-var path6, import_react_router, cssFileRegExp, cssModulesRegExp;
+var path5, import_react_router, cssFileRegExp, cssModulesRegExp;
 var init_styles = __esm({
   "vite/styles.ts"() {
     "use strict";
-    path6 = __toESM(require("path"));
+    path5 = __toESM(require("path"));
     import_react_router = require("react-router");
     init_resolve_file_url();
+    init_babel();
     cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
     cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
   }
@@ -1065,11 +1348,11 @@ var init_route_chunks = __esm({
 });
 
 // vite/with-props.ts
-var import_dedent3, vmod;
+var import_dedent2, vmod;
 var init_with_props = __esm({
   "vite/with-props.ts"() {
     "use strict";
-    import_dedent3 = __toESM(require("dedent"));
+    import_dedent2 = __toESM(require("dedent"));
     init_babel();
     init_virtual_module();
     vmod = create("with-props");
@@ -1118,8 +1401,8 @@ function getServerBundleIds(ctx) {
 async function cleanBuildDirectory(viteConfig, ctx) {
   let buildDirectory = ctx.reactRouterConfig.buildDirectory;
   let isWithinRoot = () => {
-    let relativePath = path7.relative(ctx.rootDirectory, buildDirectory);
-    return !relativePath.startsWith("..") && !path7.isAbsolute(relativePath);
+    let relativePath = path6.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
   };
   if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
     await fse.remove(buildDirectory);
@@ -1130,7 +1413,7 @@ async function cleanViteManifests(environmentsOptions, ctx) {
     ([environmentName, options]) => {
       let outDir = options.build?.outDir;
       invariant(outDir, `Expected build.outDir for ${environmentName}`);
-      return path7.join(outDir, ".vite/manifest.json");
+      return path6.join(outDir, ".vite/manifest.json");
     }
   );
   await Promise.all(
@@ -1140,7 +1423,7 @@ async function cleanViteManifests(environmentsOptions, ctx) {
       if (!ctx.viteManifestEnabled) {
         await fse.remove(viteManifestPath);
       }
-      let viteDir = path7.dirname(viteManifestPath);
+      let viteDir = path6.dirname(viteManifestPath);
       let viteDirFiles = await fse.readdir(viteDir);
       if (viteDirFiles.length === 0) {
         await fse.remove(viteDir);
@@ -1157,10 +1440,10 @@ function mergeEnvironmentOptions(base, ...overrides) {
 }
 async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
   let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
-  let packageRoot = path7.dirname(
+  let packageRoot = path6.dirname(
     require.resolve("@react-router/dev/package.json")
   );
-  let { moduleSyncEnabled } = await import(`file:///${path7.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 ?? [],
@@ -1217,7 +1500,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) ?? virtual2.serverBuild.id,
+          input: (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig.environments?.ssr?.build?.rollupOptions?.input : viteUserConfig.build?.rollupOptions?.input) ?? virtual.serverBuild.id,
           output: {
             entryFileNames: serverBuildFile,
             format: serverModuleFormat
@@ -1234,7 +1517,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
             ctx.entryClientFilePath,
             ...Object.values(ctx.reactRouterConfig.routes).flatMap(
               (route) => {
-                let routeFilePath = path7.resolve(
+                let routeFilePath = path6.resolve(
                   ctx.reactRouterConfig.appDirectory,
                   route.file
                 );
@@ -1257,8 +1540,9 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
                 ""
               ) : null;
               let routeChunkSuffix = routeChunkName ? `-${(0, import_kebabCase.default)(routeChunkName)}` : "";
-              return path7.posix.join(
-                (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig?.environments?.client?.build?.assetsDir : viteUserConfig?.build?.assetsDir) ?? "assets",
+              let assetsDir = (ctx.reactRouterConfig.future.unstable_viteEnvironmentApi ? viteUserConfig?.environments?.client?.build?.assetsDir : null) ?? viteUserConfig?.build?.assetsDir ?? "assets";
+              return path6.posix.join(
+                assetsDir,
                 `[name]${routeChunkSuffix}-[hash].js`
               );
             }
@@ -1293,9 +1577,6 @@ 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) {
@@ -1310,13 +1591,13 @@ function resolveEnvironmentsOptions(environmentResolvers, resolverOptions) {
 function isNonNullable(x) {
   return x != null;
 }
-var import_node_crypto, fs4, path7, url, fse, babel2, import_react_router2, import_es_module_lexer, import_pick3, import_jsesc, import_picocolors4, import_kebabCase, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS, BUILD_CLIENT_ROUTE_QUERY_STRING, SSR_BUNDLE_PREFIX, CSS_DEV_HELPER_ENVIRONMENT_NAME, virtualHmrRuntime, virtualInjectHmrRuntime, virtual2, getServerBuildDirectory, getClientBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
+var import_node_crypto, fs4, path6, url, fse, babel2, import_react_router2, import_es_module_lexer, import_pick3, import_jsesc, import_picocolors4, import_kebabCase, import_tinyglobby, CLIENT_NON_COMPONENT_EXPORTS, CLIENT_ROUTE_EXPORTS, BUILD_CLIENT_ROUTE_QUERY_STRING, SSR_BUNDLE_PREFIX, virtualHmrRuntime, virtualInjectHmrRuntime, virtual, getServerBuildDirectory, getClientBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
 var init_plugin = __esm({
   "vite/plugin.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
     fs4 = __toESM(require("fs"));
-    path7 = __toESM(require("path"));
+    path6 = __toESM(require("path"));
     url = __toESM(require("url"));
     fse = __toESM(require("fs-extra"));
     babel2 = __toESM(require("@babel/core"));
@@ -1326,6 +1607,7 @@ var init_plugin = __esm({
     import_jsesc = __toESM(require("jsesc"));
     import_picocolors4 = __toESM(require("picocolors"));
     import_kebabCase = __toESM(require("lodash/kebabCase"));
+    import_tinyglobby = require("tinyglobby");
     init_typegen();
     init_invariant();
     init_babel();
@@ -1358,27 +1640,26 @@ var init_plugin = __esm({
     ];
     BUILD_CLIENT_ROUTE_QUERY_STRING = "?__react-router-build-client-route";
     SSR_BUNDLE_PREFIX = "ssrBundle_";
-    CSS_DEV_HELPER_ENVIRONMENT_NAME = "__react_router_css_dev_helper__";
     virtualHmrRuntime = create("hmr-runtime");
     virtualInjectHmrRuntime = create("inject-hmr-runtime");
-    virtual2 = {
+    virtual = {
       serverBuild: create("server-build"),
       serverManifest: create("server-manifest"),
       browserManifest: create("browser-manifest")
     };
-    getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path7.join(
+    getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path6.join(
       reactRouterConfig.buildDirectory,
       "server",
       ...serverBundleId ? [serverBundleId] : []
     );
-    getClientBuildDirectory = (reactRouterConfig) => path7.join(reactRouterConfig.buildDirectory, "client");
-    defaultEntriesDir = path7.resolve(
-      path7.dirname(require.resolve("@react-router/dev/package.json")),
+    getClientBuildDirectory = (reactRouterConfig) => path6.join(reactRouterConfig.buildDirectory, "client");
+    defaultEntriesDir = path6.resolve(
+      path6.dirname(require.resolve("@react-router/dev/package.json")),
       "dist",
       "config",
       "defaults"
     );
-    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path7.join(defaultEntriesDir, filename3));
+    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename2) => path6.join(defaultEntriesDir, filename2));
     invariant(defaultEntries.length > 0, "No default entries found");
     REACT_REFRESH_HEADER = `
 import RefreshRuntime from "${virtualHmrRuntime.id}";
@@ -1412,7 +1693,13 @@ __export(build_exports, {
 async function build(root, viteBuildOptions) {
   await preloadVite();
   let vite2 = getVite();
-  let configResult = await loadConfig({ rootDirectory: root });
+  let configResult = await loadConfig({
+    rootDirectory: root,
+    mode: viteBuildOptions.mode ?? "production",
+    // In this scope we only need future flags, so we can skip evaluating
+    // routes.ts until we're within the Vite build context
+    skipRoutes: true
+  });
   if (!configResult.ok) {
     throw new Error(configResult.error);
   }
@@ -1652,7 +1939,7 @@ var import_semver = __toESM(require("semver"));
 var import_picocolors8 = __toESM(require("picocolors"));
 
 // cli/commands.ts
-var path8 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_package_json2 = __toESM(require("@npmcli/package-json"));
 var import_exit_hook = __toESM(require("exit-hook"));
@@ -1738,9 +2025,12 @@ function transpile(tsx, options = {}) {
 init_profiler();
 init_typegen();
 init_vite();
-async function routes(reactRouterRoot, flags = {}) {
-  let rootDirectory = reactRouterRoot ?? process.cwd();
-  let configResult = await loadConfig({ rootDirectory });
+async function routes(rootDirectory, flags = {}) {
+  rootDirectory = resolveRootDirectory(rootDirectory, flags);
+  let configResult = await loadConfig({
+    rootDirectory,
+    mode: flags.mode ?? "production"
+  });
   if (!configResult.ok) {
     console.error(import_picocolors7.default.red(configResult.error));
     process.exit(1);
@@ -1749,9 +2039,7 @@ async function routes(reactRouterRoot, flags = {}) {
   console.log(formatRoutes(configResult.value.routes, format));
 }
 async function build2(root, options = {}) {
-  if (!root) {
-    root = process.env.REACT_ROUTER_ROOT || process.cwd();
-  }
+  root = resolveRootDirectory(root, options);
   let { build: build3 } = await Promise.resolve().then(() => (init_build(), build_exports));
   if (options.profile) {
     await start();
@@ -1768,6 +2056,7 @@ async function dev2(root, options = {}) {
     await start();
   }
   (0, import_exit_hook.default)(() => stop(console.info));
+  root = resolveRootDirectory(root, options);
   await dev3(root, options);
   await new Promise(() => {
   });
@@ -1779,14 +2068,17 @@ var conjunctionListFormat = new Intl.ListFormat("en", {
   style: "long",
   type: "conjunction"
 });
-async function generateEntry(entry, reactRouterRoot, flags = {}) {
+async function generateEntry(entry, rootDirectory, flags = {}) {
   if (!entry) {
-    await generateEntry("entry.client", reactRouterRoot, flags);
-    await generateEntry("entry.server", reactRouterRoot, flags);
+    await generateEntry("entry.client", rootDirectory, flags);
+    await generateEntry("entry.server", rootDirectory, flags);
     return;
   }
-  let rootDirectory = reactRouterRoot ?? process.cwd();
-  let configResult = await loadConfig({ rootDirectory });
+  rootDirectory = resolveRootDirectory(rootDirectory, flags);
+  let configResult = await loadConfig({
+    rootDirectory,
+    mode: flags.mode ?? "production"
+  });
   if (!configResult.ok) {
     console.error(import_picocolors7.default.red(configResult.error));
     return;
@@ -1806,14 +2098,14 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
     console.error(import_picocolors7.default.red(`No default server entry detected.`));
     return;
   }
-  let defaultsDirectory = path8.resolve(
-    path8.dirname(require.resolve("@react-router/dev/package.json")),
+  let defaultsDirectory = path7.resolve(
+    path7.dirname(require.resolve("@react-router/dev/package.json")),
     "dist",
     "config",
     "defaults"
   );
-  let defaultEntryClient = path8.resolve(defaultsDirectory, "entry.client.tsx");
-  let defaultEntryServer = path8.resolve(
+  let defaultEntryClient = path7.resolve(defaultsDirectory, "entry.client.tsx");
+  let defaultEntryServer = path7.resolve(
     defaultsDirectory,
     `entry.server.node.tsx`
   );
@@ -1822,7 +2114,7 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
   let useTypeScript = flags.typescript ?? true;
   let outputExtension = useTypeScript ? "tsx" : "jsx";
   let outputEntry = `${entry}.${outputExtension}`;
-  let outputFile2 = path8.resolve(appDirectory, outputEntry);
+  let outputFile2 = path7.resolve(appDirectory, outputEntry);
   if (!useTypeScript) {
     let javascript = transpile(contents, {
       cwd: rootDirectory,
@@ -1834,20 +2126,26 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
   }
   console.log(
     import_picocolors7.default.blue(
-      `Entry file ${entry} created at ${path8.relative(
+      `Entry file ${entry} created at ${path7.relative(
         rootDirectory,
         outputFile2
       )}.`
     )
   );
 }
+function resolveRootDirectory(root, flags) {
+  if (root) {
+    return path7.resolve(root);
+  }
+  return process.env.REACT_ROUTER_ROOT || (flags?.config ? path7.dirname(path7.resolve(flags.config)) : process.cwd());
+}
 async function checkForEntry(rootDirectory, appDirectory, entries2) {
   for (let entry of entries2) {
-    let entryPath = path8.resolve(appDirectory, entry);
+    let entryPath = path7.resolve(appDirectory, entry);
     let exists = await import_fs_extra.default.pathExists(entryPath);
     if (exists) {
-      let relative8 = path8.relative(rootDirectory, entryPath);
-      console.error(import_picocolors7.default.red(`Entry file ${relative8} already exists.`));
+      let relative7 = path7.relative(rootDirectory, entryPath);
+      console.error(import_picocolors7.default.red(`Entry file ${relative7} already exists.`));
       return process.exit(1);
     }
   }
@@ -1863,17 +2161,22 @@ async function createClientEntry(rootDirectory, appDirectory, inputFile) {
   return contents;
 }
 async function typegen(root, flags) {
-  root ??= process.cwd();
+  root = resolveRootDirectory(root, flags);
   if (flags.watch) {
     await preloadVite();
     const vite2 = getVite();
     const logger = vite2.createLogger("info", { prefix: "[react-router]" });
-    await watch(root, { logger });
+    await watch(root, {
+      mode: flags.mode ?? "development",
+      logger
+    });
     await new Promise(() => {
     });
     return;
   }
-  await run(root);
+  await run(root, {
+    mode: flags.mode ?? "production"
+  });
 }
 
 // cli/run.ts