@react-router/dev 7.0.0-pre.4 → 7.0.0-pre.6

package/dist/cli/index.js

@@ -1,5 +1,6 @@
+#!/usr/bin/env node
 /**
- * @react-router/dev v7.0.0-pre.4
+ * @react-router/dev v7.0.0-pre.6
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -54,35 +55,14 @@ var init_invariant = __esm({
   }
 });
 
-// vite/babel.ts
-var import_parser, t, traverse, generate;
-var init_babel = __esm({
-  "vite/babel.ts"() {
-    "use strict";
-    import_parser = require("@babel/parser");
-    t = __toESM(require("@babel/types"));
-    traverse = require("@babel/traverse").default;
-    generate = require("@babel/generator").default;
-  }
-});
-
-// vite/node-adapter.ts
-var import_node_events, import_node_stream, import_set_cookie_parser, import_node;
-var init_node_adapter = __esm({
-  "vite/node-adapter.ts"() {
-    "use strict";
-    import_node_events = require("events");
-    import_node_stream = require("stream");
-    import_set_cookie_parser = require("set-cookie-parser");
-    import_node = require("@react-router/node");
-    init_invariant();
-  }
-});
-
 // vite/import-vite-esm-sync.ts
 async function preloadViteEsm() {
   vite = await import("vite");
 }
+function importViteEsmSync() {
+  invariant(vite, "importViteEsmSync() called before preloadViteEsm()");
+  return vite;
+}
 var vite;
 var init_import_vite_esm_sync = __esm({
   "vite/import-vite-esm-sync.ts"() {
@@ -91,61 +71,132 @@ var init_import_vite_esm_sync = __esm({
   }
 });
 
-// vite/resolve-file-url.ts
-var path;
-var init_resolve_file_url = __esm({
-  "vite/resolve-file-url.ts"() {
+// 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 };
+}
+var import_server, import_client, import_source_map;
+var init_vite_node = __esm({
+  "vite/vite-node.ts"() {
     "use strict";
-    path = __toESM(require("path"));
+    import_server = require("vite-node/server");
+    import_client = require("vite-node/client");
+    import_source_map = require("vite-node/source-map");
     init_import_vite_esm_sync();
   }
 });
 
-// vite/styles.ts
-var path2, import_react_router, cssFileRegExp, cssModulesRegExp;
-var init_styles = __esm({
-  "vite/styles.ts"() {
-    "use strict";
-    path2 = __toESM(require("path"));
-    import_react_router = require("react-router");
-    init_resolve_file_url();
-    cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-    cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+// config/routes.ts
+function setAppDirectory(directory) {
+  globalThis.__reactRouterAppDirectory = directory;
+}
+function validateRouteConfig({
+  routeConfigFile,
+  routeConfig
+}) {
+  if (!routeConfig) {
+    return {
+      valid: false,
+      message: `Route config must be the default export in "${routeConfigFile}".`
+    };
   }
-});
-
-// vite/vmod.ts
-var id;
-var init_vmod = __esm({
-  "vite/vmod.ts"() {
-    "use strict";
-    id = (name) => `virtual:react-router/${name}`;
+  if (!Array.isArray(routeConfig)) {
+    return {
+      valid: false,
+      message: `Route config in "${routeConfigFile}" must be an array.`
+    };
   }
-});
-
-// vite/combine-urls.ts
-var init_combine_urls = __esm({
-  "vite/combine-urls.ts"() {
-    "use strict";
+  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(
+          ([path8, message]) => `Path: routes.${path8}
+${message}`
+        ) : []
+      ].flat().join("\n\n")
+    };
   }
-});
-
-// vite/remove-exports.ts
-var import_babel_dead_code_elimination;
-var init_remove_exports = __esm({
-  "vite/remove-exports.ts"() {
-    "use strict";
-    import_babel_dead_code_elimination = require("babel-dead-code-elimination");
-    init_babel();
+  return { valid: true };
+}
+function configRoutesToRouteManifest(appDirectory, routes2, 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);
+      }
+    }
   }
-});
-
-// config/routes.ts
-var import_node_path, v, import_pick, routeConfigEntrySchema, resolvedRouteConfigSchema;
+  for (let route of routes2) {
+    walk(route, rootId);
+  }
+  return routeManifest;
+}
+function createRouteId(file) {
+  return Path.normalize(stripFileExtension(file));
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+var Path, v, import_pick, routeConfigEntrySchema, resolvedRouteConfigSchema;
 var init_routes = __esm({
   "config/routes.ts"() {
     "use strict";
-    import_node_path = require("path");
+    Path = __toESM(require("pathe"));
     v = __toESM(require("valibot"));
     import_pick = __toESM(require("lodash/pick"));
     init_invariant();
@@ -173,21 +224,285 @@ var init_detectPackageManager = __esm({
   }
 });
 
-// vite/config.ts
-var import_node_child_process, import_node_path2, import_fs_extra, import_picocolors, import_pick2, import_omit, import_package_json, branchRouteProperties, configRouteToBranchRoute;
+// config/config.ts
+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`);
+      }
+      let configModule = await viteNodeContext.runner.executeFile(
+        reactRouterConfigFile
+      );
+      if (configModule.default === void 0) {
+        return err(`${reactRouterConfigFile} must provide a default export`);
+      }
+      if (typeof configModule.default !== "object") {
+        return err(`${reactRouterConfigFile} must export a config`);
+      }
+      reactRouterUserConfig = configModule.default;
+    } catch (error) {
+      return err(`Error loading ${reactRouterConfigFile}: ${error}`);
+    }
+  }
+  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 (!preset.reactRouterConfig) {
+        return null;
+      }
+      let configPreset = (0, import_omit.default)(
+        await preset.reactRouterConfig({ reactRouterUserConfig }),
+        excludedConfigPresetKeys
+      );
+      return configPreset;
+    })
+  )).filter(function isNotNull(value) {
+    return value !== null;
+  });
+  let defaults = {
+    basename: "/",
+    buildDirectory: "build",
+    serverBuildFile: "index.js",
+    serverModuleFormat: "esm",
+    ssr: true
+  };
+  let {
+    appDirectory: userAppDirectory,
+    basename: basename2,
+    buildDirectory: userBuildDirectory,
+    buildEnd,
+    prerender,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr
+  } = {
+    ...defaults,
+    // Default values should be completely overridden by user/preset config, not merged
+    ...mergeReactRouterConfig(...presets, reactRouterUserConfig)
+  };
+  if (!ssr && serverBundles) {
+    serverBundles = void 0;
+  }
+  let isValidPrerenderConfig = prerender == null || typeof prerender === "boolean" || Array.isArray(prerender) || typeof prerender === "function";
+  if (!isValidPrerenderConfig) {
+    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"
+    );
+  }
+  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_pathe.default.relative(
+      root,
+      import_pathe.default.join(appDirectory, "root.tsx")
+    );
+    return err(
+      `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_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 viteNodeContext.runner.executeFile(
+      import_pathe.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_pathe.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+          error.frame.trim?.()
+        ] : error.stack
+      ].flat().join("\n")
+    );
+  }
+  let future = {
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false
+  };
+  let reactRouterConfig = deepFreeze({
+    appDirectory,
+    basename: basename2,
+    buildDirectory,
+    buildEnd,
+    future,
+    prerender,
+    routes: routes2,
+    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();
+    }
+  };
+}
+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";
+}
+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;
+}
+var import_node_fs, import_node_child_process, import_package_json, import_pathe, import_chokidar, import_picocolors, import_pick2, import_omit, import_cloneDeep, import_isEqual, excludedConfigPresetKeys, branchRouteProperties, configRouteToBranchRoute, mergeReactRouterConfig, deepFreeze, ssrExternals, entryExts;
 var init_config = __esm({
-  "vite/config.ts"() {
+  "config/config.ts"() {
     "use strict";
+    import_node_fs = __toESM(require("fs"));
     import_node_child_process = require("child_process");
-    import_node_path2 = __toESM(require("path"));
-    import_fs_extra = __toESM(require("fs-extra"));
+    import_package_json = __toESM(require("@npmcli/package-json"));
+    init_vite_node();
+    import_pathe = __toESM(require("pathe"));
+    import_chokidar = __toESM(require("chokidar"));
     import_picocolors = __toESM(require("picocolors"));
     import_pick2 = __toESM(require("lodash/pick"));
     import_omit = __toESM(require("lodash/omit"));
-    import_package_json = __toESM(require("@npmcli/package-json"));
+    import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+    import_isEqual = __toESM(require("lodash/isEqual"));
     init_routes();
     init_detectPackageManager();
-    init_import_vite_esm_sync();
+    excludedConfigPresetKeys = ["presets"];
     branchRouteProperties = [
       "id",
       "path",
@@ -195,33 +510,339 @@ var init_config = __esm({
       "index"
     ];
     configRouteToBranchRoute = (configRoute) => (0, import_pick2.default)(configRoute, branchRouteProperties);
+    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, {});
+    };
+    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;
+    };
+    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;
+    entryExts = [".js", ".jsx", ".ts", ".tsx"];
   }
 });
 
-// vite/with-props.ts
-var import_dedent, vmodId;
-var init_with_props = __esm({
-  "vite/with-props.ts"() {
+// 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/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 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>
+    }
+  `;
+}
+function getRouteLineage(routes2, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes2[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;
+}
+var import_dedent, Path3, Pathe2, noExtension;
+var init_generate = __esm({
+  "typegen/generate.ts"() {
     "use strict";
     import_dedent = __toESM(require("dedent"));
-    init_babel();
-    init_vmod();
-    vmodId = id("with-props");
+    Path3 = __toESM(require("pathe"));
+    Pathe2 = __toESM(require("pathe/utils"));
+    init_paths();
+    noExtension = (path8) => Path3.join(Path3.dirname(path8), Pathe2.filename(path8));
   }
 });
 
-// vite/vite-node.ts
-var import_server, import_client, import_source_map;
-var init_vite_node = __esm({
-  "vite/vite-node.ts"() {
+// 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_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);
+  });
+}
+var import_node_fs2, Path4, import_picocolors2;
+var init_typegen = __esm({
+  "typegen/index.ts"() {
     "use strict";
-    import_server = require("vite-node/server");
-    import_client = require("vite-node/client");
-    import_source_map = require("vite-node/source-map");
+    import_node_fs2 = __toESM(require("fs"));
+    Path4 = __toESM(require("pathe"));
+    import_picocolors2 = __toESM(require("picocolors"));
+    init_config();
+    init_generate();
+    init_paths();
+  }
+});
+
+// vite/babel.ts
+var import_parser, t, traverse, generate2;
+var init_babel = __esm({
+  "vite/babel.ts"() {
+    "use strict";
+    import_parser = require("@babel/parser");
+    t = __toESM(require("@babel/types"));
+    traverse = require("@babel/traverse").default;
+    generate2 = require("@babel/generator").default;
+  }
+});
+
+// vite/node-adapter.ts
+var import_node_events, import_node_stream, import_set_cookie_parser, import_node;
+var init_node_adapter = __esm({
+  "vite/node-adapter.ts"() {
+    "use strict";
+    import_node_events = require("events");
+    import_node_stream = require("stream");
+    import_set_cookie_parser = require("set-cookie-parser");
+    import_node = require("@react-router/node");
+    init_invariant();
+  }
+});
+
+// vite/resolve-file-url.ts
+var path2;
+var init_resolve_file_url = __esm({
+  "vite/resolve-file-url.ts"() {
+    "use strict";
+    path2 = __toESM(require("path"));
     init_import_vite_esm_sync();
   }
 });
 
+// vite/styles.ts
+var path3, import_react_router, cssFileRegExp, cssModulesRegExp;
+var init_styles = __esm({
+  "vite/styles.ts"() {
+    "use strict";
+    path3 = __toESM(require("path"));
+    import_react_router = require("react-router");
+    init_resolve_file_url();
+    cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+    cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
+  }
+});
+
+// vite/vmod.ts
+var id;
+var init_vmod = __esm({
+  "vite/vmod.ts"() {
+    "use strict";
+    id = (name) => `virtual:react-router/${name}`;
+  }
+});
+
+// vite/combine-urls.ts
+var init_combine_urls = __esm({
+  "vite/combine-urls.ts"() {
+    "use strict";
+  }
+});
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination;
+var init_remove_exports = __esm({
+  "vite/remove-exports.ts"() {
+    "use strict";
+    import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+    init_babel();
+  }
+});
+
+// vite/with-props.ts
+var import_dedent2, vmodId;
+var init_with_props = __esm({
+  "vite/with-props.ts"() {
+    "use strict";
+    import_dedent2 = __toESM(require("dedent"));
+    init_babel();
+    init_vmod();
+    vmodId = id("with-props");
+  }
+});
+
 // vite/plugin.ts
 async function resolveViteConfig({
   configFile,
@@ -262,40 +883,41 @@ async function loadPluginContext({
     ".mjs"
   ]);
   if (!configFile) {
-    console.error(import_picocolors2.default.red("Vite config file not found"));
+    console.error(import_picocolors3.default.red("Vite config file not found"));
     process.exit(1);
   }
   let viteConfig = await resolveViteConfig({ configFile, root });
   let ctx = await extractPluginContext(viteConfig);
   if (!ctx) {
     console.error(
-      import_picocolors2.default.red("React Router Vite plugin not found in Vite config")
+      import_picocolors3.default.red("React Router Vite plugin not found in Vite config")
     );
     process.exit(1);
   }
   return ctx;
 }
-function findConfig(dir, basename3, extensions) {
+function findConfig(dir, basename2, extensions) {
   for (let ext of extensions) {
-    let name = basename3 + ext;
+    let name = basename2 + ext;
     let file = path4.join(dir, name);
-    if (fse2.existsSync(file)) return file;
+    if (fse.existsSync(file)) return file;
   }
   return void 0;
 }
-var import_node_crypto, path4, url, fse2, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors2, serverBuildId, serverManifestId, browserManifestId, hmrRuntimeId, injectHmrRuntimeId, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER, REACT_REFRESH_FOOTER;
+var import_node_crypto, path4, url, fse, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors3, serverBuildId, serverManifestId, browserManifestId, hmrRuntimeId, injectHmrRuntimeId, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER, REACT_REFRESH_FOOTER;
 var init_plugin = __esm({
   "vite/plugin.ts"() {
     "use strict";
     import_node_crypto = require("crypto");
     path4 = __toESM(require("path"));
     url = __toESM(require("url"));
-    fse2 = __toESM(require("fs-extra"));
+    fse = __toESM(require("fs-extra"));
     babel = __toESM(require("@babel/core"));
     import_react_router2 = require("react-router");
     import_es_module_lexer = require("es-module-lexer");
     import_jsesc = __toESM(require("jsesc"));
-    import_picocolors2 = __toESM(require("picocolors"));
+    import_picocolors3 = __toESM(require("picocolors"));
+    init_typegen();
     init_invariant();
     init_babel();
     init_node_adapter();
@@ -307,7 +929,6 @@ var init_plugin = __esm({
     init_import_vite_esm_sync();
     init_config();
     init_with_props();
-    init_vite_node();
     serverBuildId = id("server-build");
     serverManifestId = id("server-manifest");
     browserManifestId = id("browser-manifest");
@@ -324,7 +945,7 @@ var init_plugin = __esm({
       "config",
       "defaults"
     );
-    defaultEntries = fse2.readdirSync(defaultEntriesDir).map((filename2) => path4.join(defaultEntriesDir, filename2));
+    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path4.join(defaultEntriesDir, filename3));
     invariant(defaultEntries.length > 0, "No default entries found");
     REACT_REFRESH_HEADER = `
 import RefreshRuntime from "${hmrRuntimeId}";
@@ -365,13 +986,13 @@ if (import.meta.hot && !inWebWorker) {
 });
 
 // vite/profiler.ts
-var import_node_fs, import_node_path3, import_picocolors3, getSession, start, profileCount, stop;
+var import_node_fs3, import_node_path, import_picocolors4, getSession, start, profileCount, stop;
 var init_profiler = __esm({
   "vite/profiler.ts"() {
     "use strict";
-    import_node_fs = __toESM(require("fs"));
-    import_node_path3 = __toESM(require("path"));
-    import_picocolors3 = __toESM(require("picocolors"));
+    import_node_fs3 = __toESM(require("fs"));
+    import_node_path = __toESM(require("path"));
+    import_picocolors4 = __toESM(require("picocolors"));
     getSession = () => global.__reactRouter_profile_session;
     start = async (callback) => {
       let inspector = await import("inspector").then((r) => r.default);
@@ -386,13 +1007,13 @@ var init_profiler = __esm({
       let session = getSession();
       if (!session) return;
       return new Promise((res, rej) => {
-        session.post("Profiler.stop", (err, { profile }) => {
-          if (err) return rej(err);
-          let outPath = import_node_path3.default.resolve(`./react-router-${profileCount++}.cpuprofile`);
-          import_node_fs.default.writeFileSync(outPath, JSON.stringify(profile));
+        session.post("Profiler.stop", (err2, { profile }) => {
+          if (err2) return rej(err2);
+          let outPath = import_node_path.default.resolve(`./react-router-${profileCount++}.cpuprofile`);
+          import_node_fs3.default.writeFileSync(outPath, JSON.stringify(profile));
           log(
-            import_picocolors3.default.yellow(
-              `CPU profile written to ${import_picocolors3.default.white(import_picocolors3.default.dim(outPath))}`
+            import_picocolors4.default.yellow(
+              `CPU profile written to ${import_picocolors4.default.white(import_picocolors4.default.dim(outPath))}`
             )
           );
           global.__reactRouter_profile_session = void 0;
@@ -449,12 +1070,12 @@ async function getServerBuilds(ctx) {
     };
   }
   let { normalizePath } = await import("vite");
-  let resolvedAppDirectory = import_node_path4.default.resolve(rootDirectory, appDirectory);
+  let resolvedAppDirectory = import_node_path2.default.resolve(rootDirectory, appDirectory);
   let rootRelativeRoutes = Object.fromEntries(
     Object.entries(routes2).map(([id2, route]) => {
-      let filePath = import_node_path4.default.join(resolvedAppDirectory, route.file);
+      let filePath = import_node_path2.default.join(resolvedAppDirectory, route.file);
       let rootRelativeFilePath = normalizePath(
-        import_node_path4.default.relative(rootDirectory, filePath)
+        import_node_path2.default.relative(rootDirectory, filePath)
       );
       return [id2, { ...route, file: rootRelativeFilePath }];
     })
@@ -473,7 +1094,7 @@ async function getServerBuilds(ctx) {
           (route2) => configRouteToBranchRoute({
             ...route2,
             // Ensure absolute paths are passed to the serverBundles function
-            file: import_node_path4.default.join(resolvedAppDirectory, route2.file)
+            file: import_node_path2.default.join(resolvedAppDirectory, route2.file)
           })
         )
       });
@@ -486,16 +1107,16 @@ async function getServerBuilds(ctx) {
         );
       }
       buildManifest.routeIdToServerBundleId[route.id] = serverBundleId;
-      let relativeServerBundleDirectory = import_node_path4.default.relative(
+      let relativeServerBundleDirectory = import_node_path2.default.relative(
         rootDirectory,
-        import_node_path4.default.join(serverBuildDirectory, serverBundleId)
+        import_node_path2.default.join(serverBuildDirectory, serverBundleId)
       );
       let serverBuildConfig = serverBundleBuildConfigById.get(serverBundleId);
       if (!serverBuildConfig) {
         buildManifest.serverBundles[serverBundleId] = {
           id: serverBundleId,
           file: normalizePath(
-            import_node_path4.default.join(relativeServerBundleDirectory, serverBuildFile)
+            import_node_path2.default.join(relativeServerBundleDirectory, serverBuildFile)
           )
         };
         serverBuildConfig = {
@@ -526,15 +1147,15 @@ async function getServerBuilds(ctx) {
 async function cleanBuildDirectory(viteConfig, ctx) {
   let buildDirectory = ctx.reactRouterConfig.buildDirectory;
   let isWithinRoot = () => {
-    let relativePath = import_node_path4.default.relative(ctx.rootDirectory, buildDirectory);
-    return !relativePath.startsWith("..") && !import_node_path4.default.isAbsolute(relativePath);
+    let relativePath = import_node_path2.default.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !import_node_path2.default.isAbsolute(relativePath);
   };
   if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
-    await import_fs_extra2.default.remove(buildDirectory);
+    await import_fs_extra.default.remove(buildDirectory);
   }
 }
 function getViteManifestPaths(ctx, serverBuilds) {
-  let buildRelative = (pathname) => import_node_path4.default.resolve(ctx.reactRouterConfig.buildDirectory, pathname);
+  let buildRelative = (pathname) => import_node_path2.default.resolve(ctx.reactRouterConfig.buildDirectory, pathname);
   let viteManifestPaths = [
     "client/.vite/manifest.json",
     ...serverBuilds.map(({ serverBundleBuildConfig }) => {
@@ -562,7 +1183,7 @@ async function build(root, {
   const ctx = await extractPluginContext(viteConfig);
   if (!ctx) {
     console.error(
-      import_picocolors4.default.red("React Router Vite plugin not found in Vite config")
+      import_picocolors5.default.red("React Router Vite plugin not found in Vite config")
     );
     process.exit(1);
   }
@@ -596,15 +1217,15 @@ async function build(root, {
   let viteManifestPaths = getViteManifestPaths(ctx, serverBuilds);
   await Promise.all(
     viteManifestPaths.map(async (viteManifestPath) => {
-      let manifestExists = await import_fs_extra2.default.pathExists(viteManifestPath);
+      let manifestExists = await import_fs_extra.default.pathExists(viteManifestPath);
       if (!manifestExists) return;
       if (!ctx.viteManifestEnabled) {
-        await import_fs_extra2.default.remove(viteManifestPath);
+        await import_fs_extra.default.remove(viteManifestPath);
       }
-      let viteDir = import_node_path4.default.dirname(viteManifestPath);
-      let viteDirFiles = await import_fs_extra2.default.readdir(viteDir);
+      let viteDir = import_node_path2.default.dirname(viteManifestPath);
+      let viteDirFiles = await import_fs_extra.default.readdir(viteDir);
       if (viteDirFiles.length === 0) {
-        await import_fs_extra2.default.remove(viteDir);
+        await import_fs_extra.default.remove(viteDir);
       }
     })
   );
@@ -614,13 +1235,13 @@ async function build(root, {
     viteConfig
   });
 }
-var import_node_path4, import_fs_extra2, import_picocolors4;
+var import_node_path2, import_fs_extra, import_picocolors5;
 var init_build = __esm({
   "vite/build.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("path"));
-    import_fs_extra2 = __toESM(require("fs-extra"));
-    import_picocolors4 = __toESM(require("picocolors"));
+    import_node_path2 = __toESM(require("path"));
+    import_fs_extra = __toESM(require("fs-extra"));
+    import_picocolors5 = __toESM(require("picocolors"));
     init_plugin();
     init_config();
     init_invariant();
@@ -658,7 +1279,7 @@ async function dev(root, {
   });
   if (!server.config.plugins.find((plugin2) => plugin2.name === "react-router")) {
     console.error(
-      import_picocolors5.default.red("React Router Vite plugin not found in Vite config")
+      import_picocolors6.default.red("React Router Vite plugin not found in Vite config")
     );
     process.exit(1);
   }
@@ -681,11 +1302,11 @@ async function dev(root, {
   ];
   server.bindCLIShortcuts({ print: true, customShortcuts });
 }
-var import_picocolors5;
+var import_picocolors6;
 var init_dev = __esm({
   "vite/dev.ts"() {
     "use strict";
-    import_picocolors5 = __toESM(require("picocolors"));
+    import_picocolors6 = __toESM(require("picocolors"));
     init_import_vite_esm_sync();
     init_profiler();
   }
@@ -694,34 +1315,14 @@ var init_dev = __esm({
 // cli/run.ts
 var import_arg = __toESM(require("arg"));
 var import_semver = __toESM(require("semver"));
-
-// colors.ts
-var import_chalk = __toESM(require("chalk"));
-var useColor = import_chalk.default.supportsColor && !process.env.NO_COLOR;
-var identity = (x) => x;
-var safe = (style) => useColor ? style : identity;
-var heading = safe(import_chalk.default.underline);
-var arg = safe(import_chalk.default.yellowBright);
-var error = safe(import_chalk.default.red);
-var warning = safe(import_chalk.default.yellow);
-var hint = safe(import_chalk.default.blue);
-var logoBlue = safe(import_chalk.default.blueBright);
-var logoGreen = safe(import_chalk.default.greenBright);
-var logoYellow = safe(import_chalk.default.yellowBright);
-var logoPink = safe(import_chalk.default.magentaBright);
-var logoRed = safe(import_chalk.default.redBright);
-var bold = safe(import_chalk.default.bold);
-var blue = safe(import_chalk.default.blue);
-var cyan = safe(import_chalk.default.cyan);
-var gray = safe(import_chalk.default.gray);
-var red = safe(import_chalk.default.red);
-var yellow = safe(import_chalk.default.yellow);
+var import_picocolors8 = __toESM(require("picocolors"));
 
 // cli/commands.ts
 var path7 = __toESM(require("path"));
-var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
 var import_package_json2 = __toESM(require("@npmcli/package-json"));
 var import_exit_hook = __toESM(require("exit-hook"));
+var import_picocolors7 = __toESM(require("picocolors"));
 
 // config/format.ts
 function formatRoutes(routeManifest, format) {
@@ -802,106 +1403,8 @@ function transpile(tsx, options = {}) {
 
 // cli/commands.ts
 init_profiler();
-
-// typescript/typegen.ts
-var import_node_fs2 = __toESM(require("fs"));
-var import_chokidar = __toESM(require("chokidar"));
-var import_dedent2 = __toESM(require("dedent"));
-var Path = __toESM(require("pathe"));
-var Pathe = __toESM(require("pathe/utils"));
-init_routes();
-init_vite_node();
-init_config();
-init_plugin();
-function getDirectory(ctx) {
-  return Path.join(ctx.rootDirectory, ".react-router/types");
-}
-function getPath(ctx, route) {
-  return Path.join(
-    getDirectory(ctx),
-    Path.basename(ctx.appDirectory),
-    Path.dirname(route.file),
-    "+types." + Pathe.filename(route.file) + ".d.ts"
-  );
-}
-async function writeAll(ctx) {
-  import_node_fs2.default.rmSync(getDirectory(ctx), { recursive: true, force: true });
-  Object.values(ctx.routes).forEach((route) => {
-    if (!import_node_fs2.default.existsSync(Path.join(ctx.appDirectory, route.file))) return;
-    const typesPath = getPath(ctx, route);
-    const content = getModule(ctx.routes, route);
-    import_node_fs2.default.mkdirSync(Path.dirname(typesPath), { recursive: true });
-    import_node_fs2.default.writeFileSync(typesPath, content);
-  });
-}
-function getModule(routes2, route) {
-  return import_dedent2.default`
-    // React Router generated types for route:
-    // ${route.file}
-
-    import * as T from "react-router/types"
-
-    export type Params = {${formattedParamsProperties(routes2, route)}}
-
-    type Route = typeof import("./${Pathe.filename(route.file)}")
-
-    export type LoaderData = T.CreateLoaderData<Route>
-    export type ActionData = T.CreateActionData<Route>
-
-    export type LoaderArgs = T.CreateServerLoaderArgs<Params>
-    export type ClientLoaderArgs = T.CreateClientLoaderArgs<Params, Route>
-    export type ActionArgs = T.CreateServerActionArgs<Params>
-    export type ClientActionArgs = T.CreateClientActionArgs<Params, Route>
-
-    export type HydrateFallbackProps = T.CreateHydrateFallbackProps<Params>
-    export type ComponentProps = T.CreateComponentProps<Params, LoaderData, ActionData>
-    export type ErrorBoundaryProps = T.CreateErrorBoundaryProps<Params, LoaderData, ActionData>
-  `;
-}
-function formattedParamsProperties(routes2, route) {
-  const urlpath = routeLineage(routes2, route).map((route2) => route2.path).join("/");
-  const params = parseParams(urlpath);
-  const indent = "  ".repeat(3);
-  const properties = Object.entries(params).map(([name, values]) => {
-    if (values.length === 1) {
-      const isOptional = values[0];
-      return indent + (isOptional ? `${name}?: string` : `${name}: string`);
-    }
-    const items = values.map(
-      (isOptional) => isOptional ? "string | undefined" : "string"
-    );
-    return indent + `${name}: [${items.join(", ")}]`;
-  });
-  const body = properties.length === 0 ? "" : "\n" + properties.join("\n") + "\n";
-  return body;
-}
-function routeLineage(routes2, route) {
-  const result = [];
-  while (route) {
-    result.push(route);
-    if (!route.parentId) break;
-    route = routes2[route.parentId];
-  }
-  result.reverse();
-  return result;
-}
-function parseParams(urlpath) {
-  const result = {};
-  let segments = urlpath.split("/");
-  segments.filter((s) => s.startsWith(":")).forEach((param) => {
-    param = param.slice(1);
-    let isOptional = param.endsWith("?");
-    if (isOptional) {
-      param = param.slice(0, -1);
-    }
-    result[param] ??= [];
-    result[param].push(isOptional);
-    return;
-  });
-  return result;
-}
-
-// cli/commands.ts
+init_typegen();
+init_import_vite_esm_sync();
 async function routes(reactRouterRoot, flags = {}) {
   let ctx = await loadPluginContext({
     root: reactRouterRoot,
@@ -909,7 +1412,7 @@ async function routes(reactRouterRoot, flags = {}) {
   });
   if (!ctx) {
     console.error(
-      red("React Router Vite plugin not found in Vite config")
+      import_picocolors7.default.red("React Router Vite plugin not found in Vite config")
     );
     process.exit(1);
   }
@@ -963,14 +1466,14 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
     let entriesArray = Array.from(entries);
     let list = conjunctionListFormat.format(entriesArray);
     console.error(
-      error(`Invalid entry file. Valid entry files are ${list}`)
+      import_picocolors7.default.red(`Invalid entry file. Valid entry files are ${list}`)
     );
     return;
   }
   let pkgJson = await import_package_json2.default.load(rootDirectory);
   let deps = pkgJson.content.dependencies ?? {};
   if (!deps["@react-router/node"]) {
-    console.error(error(`No default server entry detected.`));
+    console.error(import_picocolors7.default.red(`No default server entry detected.`));
     return;
   }
   let defaultsDirectory = path7.resolve(
@@ -995,12 +1498,12 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
       cwd: rootDirectory,
       filename: isServerEntry ? defaultEntryServer : defaultEntryClient
     });
-    await import_fs_extra3.default.writeFile(outputFile2, javascript, "utf-8");
+    await import_fs_extra2.default.writeFile(outputFile2, javascript, "utf-8");
   } else {
-    await import_fs_extra3.default.writeFile(outputFile2, contents, "utf-8");
+    await import_fs_extra2.default.writeFile(outputFile2, contents, "utf-8");
   }
   console.log(
-    blue(
+    import_picocolors7.default.blue(
       `Entry file ${entry} created at ${path7.relative(
         rootDirectory,
         outputFile2
@@ -1011,43 +1514,48 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
 async function checkForEntry(rootDirectory, appDirectory, entries2) {
   for (let entry of entries2) {
     let entryPath = path7.resolve(appDirectory, entry);
-    let exists = await import_fs_extra3.default.pathExists(entryPath);
+    let exists = await import_fs_extra2.default.pathExists(entryPath);
     if (exists) {
-      let relative5 = path7.relative(rootDirectory, entryPath);
-      console.error(error(`Entry file ${relative5} already exists.`));
+      let relative8 = path7.relative(rootDirectory, entryPath);
+      console.error(import_picocolors7.default.red(`Entry file ${relative8} already exists.`));
       return process.exit(1);
     }
   }
 }
 async function createServerEntry(rootDirectory, appDirectory, inputFile) {
   await checkForEntry(rootDirectory, appDirectory, serverEntries);
-  let contents = await import_fs_extra3.default.readFile(inputFile, "utf-8");
+  let contents = await import_fs_extra2.default.readFile(inputFile, "utf-8");
   return contents;
 }
 async function createClientEntry(rootDirectory, appDirectory, inputFile) {
   await checkForEntry(rootDirectory, appDirectory, clientEntries);
-  let contents = await import_fs_extra3.default.readFile(inputFile, "utf-8");
+  let contents = await import_fs_extra2.default.readFile(inputFile, "utf-8");
   return contents;
 }
-async function typegen(root) {
-  let ctx = await loadPluginContext({ root });
-  await writeAll({
-    rootDirectory: root,
-    appDirectory: ctx.reactRouterConfig.appDirectory,
-    routes: ctx.reactRouterConfig.routes
-  });
+async function typegen(root, flags) {
+  root ??= process.cwd();
+  if (flags.watch) {
+    await preloadViteEsm();
+    const vite2 = importViteEsmSync();
+    const logger = vite2.createLogger("info", { prefix: "[react-router]" });
+    await watch(root, { logger });
+    await new Promise(() => {
+    });
+    return;
+  }
+  await run(root);
 }
 
 // cli/run.ts
 var helpText = `
-${logoBlue("react-router")}
+${import_picocolors8.default.blueBright("react-router")}
 
-  ${heading("Usage")}:
-    $ react-router build [${arg("projectDir")}]
-    $ react-router dev [${arg("projectDir")}]
-    $ react-router routes [${arg("projectDir")}]
+  ${import_picocolors8.default.underline("Usage")}:
+    $ react-router build [${import_picocolors8.default.yellowBright("projectDir")}]
+    $ react-router dev [${import_picocolors8.default.yellowBright("projectDir")}]
+    $ react-router routes [${import_picocolors8.default.yellowBright("projectDir")}]
 
-  ${heading("Options")}:
+  ${import_picocolors8.default.underline("Options")}:
     --help, -h          Print this help message and exit
     --version, -v       Print the CLI version and exit
     --no-color          Disable ANSI colors in console output
@@ -1080,23 +1588,25 @@ ${logoBlue("react-router")}
   \`reveal\` Options:
     --config, -c        Use specified Vite config file (string)
     --no-typescript     Generate plain JavaScript files
+  \`typegen\` Options:
+    --watch             Automatically regenerate types whenever route config (\`routes.ts\`) or route modules change
 
-  ${heading("Build your project")}:
+  ${import_picocolors8.default.underline("Build your project")}:
 
     $ react-router build
 
-  ${heading("Run your project locally in development")}:
+  ${import_picocolors8.default.underline("Run your project locally in development")}:
 
     $ react-router dev
 
-  ${heading("Show all routes in your app")}:
+  ${import_picocolors8.default.underline("Show all routes in your app")}:
 
     $ react-router routes
     $ react-router routes my-app
     $ react-router routes --json
     $ react-router routes --config vite.react-router.config.ts
 
-  ${heading("Reveal the used entry point")}:
+  ${import_picocolors8.default.underline("Reveal the used entry point")}:
 
     $ react-router reveal entry.client
     $ react-router reveal entry.server
@@ -1104,20 +1614,21 @@ ${logoBlue("react-router")}
     $ react-router reveal entry.server --no-typescript
     $ react-router reveal entry.server --config vite.react-router.config.ts
 
-  ${heading("Generate types for route modules")}:
+  ${import_picocolors8.default.underline("Generate types for route modules")}:
 
    $ react-router typegen
+   $ react-router typegen --watch
 `;
-async function run(argv = process.argv.slice(2)) {
+async function run2(argv = process.argv.slice(2)) {
   let versions = process.versions;
   let MINIMUM_NODE_VERSION = 20;
   if (versions && versions.node && import_semver.default.major(versions.node) < MINIMUM_NODE_VERSION) {
-    throw new Error(
-      `\uFE0F\u{1F6A8} Oops, Node v${versions.node} detected. react-router requires a Node version greater than ${MINIMUM_NODE_VERSION}.`
+    console.warn(
+      `\uFE0F\u26A0\uFE0F Oops, Node v${versions.node} detected. react-router requires a Node version greater than ${MINIMUM_NODE_VERSION}.`
     );
   }
-  let isBooleanFlag = (arg3) => {
-    let index = argv.indexOf(arg3);
+  let isBooleanFlag = (arg2) => {
+    let index = argv.indexOf(arg2);
     let nextArg = argv[index + 1];
     return !nextArg || nextArg.startsWith("-");
   };
@@ -1150,7 +1661,8 @@ async function run(argv = process.argv.slice(2)) {
       "--strictPort": Boolean,
       "--profile": Boolean,
       "--sourcemapClient": isBooleanFlag("--sourcemapClient") ? Boolean : String,
-      "--sourcemapServer": isBooleanFlag("--sourcemapServer") ? Boolean : String
+      "--sourcemapServer": isBooleanFlag("--sourcemapServer") ? Boolean : String,
+      "--watch": Boolean
     },
     {
       argv
@@ -1191,7 +1703,7 @@ async function run(argv = process.argv.slice(2)) {
       await dev2(input[1], flags);
       break;
     case "typegen":
-      await typegen(input[1]);
+      await typegen(input[1], flags);
       break;
     default:
       await dev2(input[0], flags);
@@ -1199,12 +1711,12 @@ async function run(argv = process.argv.slice(2)) {
 }
 
 // cli/index.ts
-run().then(
+run2().then(
   () => {
     process.exit(0);
   },
-  (error2) => {
-    if (error2) console.error(error2);
+  (error) => {
+    if (error) console.error(error);
     process.exit(1);
   }
 );