@react-router/dev 0.0.0-experimental-4d16b23b6 → 0.0.0-experimental-4d6793aa7

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * @react-router/dev v0.0.0-experimental-4d16b23b6
+ * @react-router/dev v0.0.0-experimental-4d6793aa7
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -9,1344 +9,37 @@
  *
  * @license MIT
  */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// invariant.ts
-function invariant(value, message) {
-  if (value === false || value === null || typeof value === "undefined") {
-    console.error(
-      "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
-    );
-    throw new Error(message);
-  }
-}
-var init_invariant = __esm({
-  "invariant.ts"() {
-    "use strict";
-  }
-});
-
-// config/is-react-router-repo.ts
-function isReactRouterRepo() {
-  let serverRuntimePath = import_pathe.default.dirname(
-    require.resolve("@react-router/node/package.json")
-  );
-  let serverRuntimeParentDir = import_pathe.default.basename(
-    import_pathe.default.resolve(serverRuntimePath, "..")
-  );
-  return serverRuntimeParentDir === "packages";
-}
-var import_pathe;
-var init_is_react_router_repo = __esm({
-  "config/is-react-router-repo.ts"() {
-    "use strict";
-    import_pathe = __toESM(require("pathe"));
-  }
-});
-
-// vite/vite.ts
-async function preloadVite() {
-  vite = await import(viteImportSpecifier);
-}
-function getVite() {
-  invariant(vite, "getVite() called before preloadVite()");
-  return vite;
-}
-var import_pathe2, vite, viteImportSpecifier;
-var init_vite = __esm({
-  "vite/vite.ts"() {
-    "use strict";
-    import_pathe2 = __toESM(require("pathe"));
-    init_invariant();
-    init_is_react_router_repo();
-    viteImportSpecifier = isReactRouterRepo() ? (
-      // Support testing against different versions of Vite by ensuring that Vite
-      // is resolved from the current working directory when running within this
-      // repo. If we don't do this, Vite will always be imported relative to this
-      // file, which means that it will always resolve to Vite 6.
-      `file:///${import_pathe2.default.normalize(
-        require.resolve("vite/package.json", { paths: [process.cwd()] })
-      ).replace("package.json", "dist/node/index.js")}`
-    ) : "vite";
-  }
-});
-
-// vite/vite-node.ts
-async function createContext(viteConfig = {}) {
-  await preloadVite();
-  const vite2 = getVite();
-  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(id) {
-      return server.fetchModule(id);
-    },
-    resolveId(id, importer) {
-      return server.resolveId(id, importer);
-    }
-  });
-  return { devServer, server, runner };
-}
-var import_server, import_client, import_source_map;
-var init_vite_node = __esm({
-  "vite/vite-node.ts"() {
-    "use strict";
-    import_server = require("vite-node/server");
-    import_client = require("vite-node/client");
-    import_source_map = require("vite-node/source-map");
-    init_vite();
-  }
-});
-
-// 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}".`
-    };
-  }
-  if (!Array.isArray(routeConfig)) {
-    return {
-      valid: false,
-      message: `Route config in "${routeConfigFile}" must be an array.`
-    };
-  }
-  let { issues } = v.safeParse(resolvedRouteConfigSchema, routeConfig);
-  if (issues?.length) {
-    let { root, nested } = v.flatten(issues);
-    return {
-      valid: false,
-      message: [
-        `Route config in "${routeConfigFile}" is invalid.`,
-        root ? `${root}` : [],
-        nested ? Object.entries(nested).map(
-          ([path10, message]) => `Path: routes.${path10}
-${message}`
-        ) : []
-      ].flat().join("\n\n")
-    };
-  }
-  return { valid: true };
-}
-function configRoutesToRouteManifest(appDirectory, routes2, rootId = "root") {
-  let routeManifest = {};
-  function walk(route, parentId) {
-    let id = route.id || createRouteId(route.file);
-    let manifestItem = {
-      id,
-      parentId,
-      file: Path.isAbsolute(route.file) ? Path.relative(appDirectory, route.file) : route.file,
-      path: route.path,
-      index: route.index,
-      caseSensitive: route.caseSensitive
-    };
-    if (routeManifest.hasOwnProperty(id)) {
-      throw new Error(
-        `Unable to define routes with duplicate route id: "${id}"`
-      );
-    }
-    routeManifest[id] = manifestItem;
-    if (route.children) {
-      for (let child of route.children) {
-        walk(child, id);
-      }
-    }
-  }
-  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";
-    Path = __toESM(require("pathe"));
-    v = __toESM(require("valibot"));
-    import_pick = __toESM(require("lodash/pick"));
-    init_invariant();
-    routeConfigEntrySchema = v.pipe(
-      v.custom((value) => {
-        return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
-      }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
-      v.object({
-        id: v.optional(v.string()),
-        path: v.optional(v.string()),
-        index: v.optional(v.boolean()),
-        caseSensitive: v.optional(v.boolean()),
-        file: v.string(),
-        children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
-      })
-    );
-    resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
-  }
-});
-
-// cli/detectPackageManager.ts
-var init_detectPackageManager = __esm({
-  "cli/detectPackageManager.ts"() {
-    "use strict";
-  }
-});
-
-// 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_pathe3.default.resolve(root, userAppDirectory || "app");
-  let buildDirectory = import_pathe3.default.resolve(root, userBuildDirectory);
-  let rootRouteFile = findEntry(appDirectory, "root");
-  if (!rootRouteFile) {
-    let rootRouteDisplayPath = import_pathe3.default.relative(
-      root,
-      import_pathe3.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_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_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_pathe3.default.normalize(rawFilepath);
-          let appFileAddedOrRemoved = appDirectory && (event === "add" || event === "unlink") && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
-          let configCodeUpdated = Boolean(
-            viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
-          );
-          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 findEntry(dir, basename2, options) {
-  for (let ext of entryExts) {
-    let file = import_pathe3.default.resolve(dir, basename2 + ext);
-    if (import_node_fs.default.existsSync(file)) {
-      return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
-    }
-  }
-  return void 0;
-}
-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, branchRouteProperties, configRouteToBranchRoute, mergeReactRouterConfig, deepFreeze, ssrExternals, entryExts;
-var init_config = __esm({
-  "config/config.ts"() {
-    "use strict";
-    import_node_fs = __toESM(require("fs"));
-    import_node_child_process = require("child_process");
-    import_package_json = __toESM(require("@npmcli/package-json"));
-    init_vite_node();
-    import_pathe3 = __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_cloneDeep = __toESM(require("lodash/cloneDeep"));
-    import_isEqual = __toESM(require("lodash/isEqual"));
-    init_routes();
-    init_detectPackageManager();
-    init_is_react_router_repo();
-    excludedConfigPresetKeys = ["presets"];
-    branchRouteProperties = [
-      "id",
-      "path",
-      "file",
-      "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 = isReactRouterRepo() ? [
-      // This is only needed within this repo because these packages
-      // are linked to a directory outside of node_modules so Vite
-      // treats them as internal code by default.
-      "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"];
-  }
-});
-
-// 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}.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(
-    urlpath
-  )}} & { [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 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"));
-    Path3 = __toESM(require("pathe"));
-    Pathe2 = __toESM(require("pathe/utils"));
-    init_paths();
-    noExtension = (path10) => Path3.join(Path3.dirname(path10), Pathe2.filename(path10));
-  }
-});
-
-// 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
-      });
-    }
-  });
-  return {
-    close: async () => await ctx.configLoader.close()
-  };
-}
-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_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 path4;
-var init_resolve_file_url = __esm({
-  "vite/resolve-file-url.ts"() {
-    "use strict";
-    path4 = __toESM(require("path"));
-    init_vite();
-  }
-});
-
-// vite/styles.ts
-var path5, import_react_router, cssFileRegExp, cssModulesRegExp;
-var init_styles = __esm({
-  "vite/styles.ts"() {
-    "use strict";
-    path5 = __toESM(require("path"));
-    import_react_router = require("react-router");
-    init_resolve_file_url();
-    init_vite();
-    cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
-    cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
-  }
-});
-
-// vite/virtual-module.ts
-function create(name) {
-  let id = `virtual:react-router/${name}`;
-  return {
-    id,
-    resolvedId: `\0${id}`,
-    url: `/@id/__x00__${id}`
-  };
-}
-var init_virtual_module = __esm({
-  "vite/virtual-module.ts"() {
-    "use strict";
-  }
-});
-
-// 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, vmod;
-var init_with_props = __esm({
-  "vite/with-props.ts"() {
-    "use strict";
-    import_dedent2 = __toESM(require("dedent"));
-    init_babel();
-    init_virtual_module();
-    vmod = create("with-props");
-  }
-});
-
-// vite/plugin.ts
-async function resolveViteConfig({
-  configFile,
-  mode,
-  root
-}) {
-  let vite2 = getVite();
-  let viteConfig = await vite2.resolveConfig(
-    { mode, configFile, root },
-    "build",
-    // command
-    "production",
-    // default mode
-    "production"
-    // default NODE_ENV
-  );
-  if (typeof viteConfig.build.manifest === "string") {
-    throw new Error("Custom Vite manifest paths are not supported");
-  }
-  return viteConfig;
-}
-async function extractPluginContext(viteConfig) {
-  return viteConfig["__reactRouterPluginContext"];
-}
-async function loadPluginContext({
-  configFile,
-  root
-}) {
-  if (!root) {
-    root = process.env.REACT_ROUTER_ROOT || process.cwd();
-  }
-  configFile = configFile ?? findConfig(root, "vite.config", [
-    ".ts",
-    ".cts",
-    ".mts",
-    ".js",
-    ".cjs",
-    ".mjs"
-  ]);
-  if (!configFile) {
-    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_picocolors3.default.red("React Router Vite plugin not found in Vite config")
-    );
-    process.exit(1);
-  }
-  return ctx;
-}
-function findConfig(dir, basename2, extensions) {
-  for (let ext of extensions) {
-    let name = basename2 + ext;
-    let file = path6.join(dir, name);
-    if (fse.existsSync(file)) return file;
-  }
-  return void 0;
-}
-var import_node_crypto, path6, url, fse, babel, import_react_router2, import_es_module_lexer, import_jsesc, import_picocolors3, virtualHmrRuntime, virtualInjectHmrRuntime, virtual, getServerBuildDirectory, defaultEntriesDir, defaultEntries, REACT_REFRESH_HEADER;
-var init_plugin = __esm({
-  "vite/plugin.ts"() {
-    "use strict";
-    import_node_crypto = require("crypto");
-    path6 = __toESM(require("path"));
-    url = __toESM(require("url"));
-    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_picocolors3 = __toESM(require("picocolors"));
-    init_typegen();
-    init_invariant();
-    init_babel();
-    init_node_adapter();
-    init_styles();
-    init_virtual_module();
-    init_resolve_file_url();
-    init_combine_urls();
-    init_remove_exports();
-    init_vite();
-    init_config();
-    init_with_props();
-    virtualHmrRuntime = create("hmr-runtime");
-    virtualInjectHmrRuntime = create("inject-hmr-runtime");
-    virtual = {
-      serverBuild: create("server-build"),
-      serverManifest: create("server-manifest"),
-      browserManifest: create("browser-manifest")
-    };
-    getServerBuildDirectory = (ctx) => path6.join(
-      ctx.reactRouterConfig.buildDirectory,
-      "server",
-      ...ctx.serverBundleBuildConfig ? [ctx.serverBundleBuildConfig.serverBundleId] : []
-    );
-    defaultEntriesDir = path6.resolve(
-      path6.dirname(require.resolve("@react-router/dev/package.json")),
-      "dist",
-      "config",
-      "defaults"
-    );
-    defaultEntries = fse.readdirSync(defaultEntriesDir).map((filename3) => path6.join(defaultEntriesDir, filename3));
-    invariant(defaultEntries.length > 0, "No default entries found");
-    REACT_REFRESH_HEADER = `
-import RefreshRuntime from "${virtualHmrRuntime.id}";
-
-const inWebWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;
-let prevRefreshReg;
-let prevRefreshSig;
-
-if (import.meta.hot && !inWebWorker) {
-  if (!window.__vite_plugin_react_preamble_installed__) {
-    throw new Error(
-      "React Router Vite plugin can't detect preamble. Something is wrong."
-    );
-  }
-
-  prevRefreshReg = window.$RefreshReg$;
-  prevRefreshSig = window.$RefreshSig$;
-  window.$RefreshReg$ = (type, id) => {
-    RefreshRuntime.register(type, __SOURCE__ + " " + id)
-  };
-  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-}`.replaceAll("\n", "");
-  }
-});
-
-// vite/profiler.ts
-var import_node_fs3, import_node_path, import_picocolors4, getSession, start, profileCount, stop;
-var init_profiler = __esm({
-  "vite/profiler.ts"() {
-    "use strict";
-    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);
-      let session = global.__reactRouter_profile_session = new inspector.Session();
-      session.connect();
-      session.post("Profiler.enable", () => {
-        session.post("Profiler.start", callback);
-      });
-    };
-    profileCount = 0;
-    stop = (log) => {
-      let session = getSession();
-      if (!session) return;
-      return new Promise((res, rej) => {
-        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_picocolors4.default.yellow(
-              `CPU profile written to ${import_picocolors4.default.white(import_picocolors4.default.dim(outPath))}`
-            )
-          );
-          global.__reactRouter_profile_session = void 0;
-          res();
-        });
-      });
-    };
-  }
-});
-
-// vite/build.ts
-var build_exports = {};
-__export(build_exports, {
-  build: () => build
-});
-function getAddressableRoutes(routes2) {
-  let nonAddressableIds = /* @__PURE__ */ new Set();
-  for (let id in routes2) {
-    let route = routes2[id];
-    if (route.index) {
-      invariant(
-        route.parentId,
-        `Expected index route "${route.id}" to have "parentId" set`
-      );
-      nonAddressableIds.add(route.parentId);
-    }
-    if (typeof route.path !== "string" && !route.index) {
-      nonAddressableIds.add(id);
-    }
-  }
-  return Object.values(routes2).filter(
-    (route) => !nonAddressableIds.has(route.id)
-  );
-}
-function getRouteBranch(routes2, routeId) {
-  let branch = [];
-  let currentRouteId = routeId;
-  while (currentRouteId) {
-    let route = routes2[currentRouteId];
-    invariant(route, `Missing route for ${currentRouteId}`);
-    branch.push(route);
-    currentRouteId = route.parentId;
-  }
-  return branch.reverse();
-}
-async function getServerBuilds(ctx) {
-  let { rootDirectory } = ctx;
-  const { routes: routes2, serverBuildFile, serverBundles, appDirectory } = ctx.reactRouterConfig;
-  let serverBuildDirectory = getServerBuildDirectory(ctx);
-  if (!serverBundles) {
-    return {
-      serverBuilds: [{ ssr: true }],
-      buildManifest: { routes: routes2 }
-    };
-  }
-  let { normalizePath } = await import("vite");
-  let resolvedAppDirectory = import_node_path2.default.resolve(rootDirectory, appDirectory);
-  let rootRelativeRoutes = Object.fromEntries(
-    Object.entries(routes2).map(([id, route]) => {
-      let filePath = import_node_path2.default.join(resolvedAppDirectory, route.file);
-      let rootRelativeFilePath = normalizePath(
-        import_node_path2.default.relative(rootDirectory, filePath)
-      );
-      return [id, { ...route, file: rootRelativeFilePath }];
-    })
-  );
-  let buildManifest = {
-    serverBundles: {},
-    routeIdToServerBundleId: {},
-    routes: rootRelativeRoutes
-  };
-  let serverBundleBuildConfigById = /* @__PURE__ */ new Map();
-  await Promise.all(
-    getAddressableRoutes(routes2).map(async (route) => {
-      let branch = getRouteBranch(routes2, route.id);
-      let serverBundleId = await serverBundles({
-        branch: branch.map(
-          (route2) => configRouteToBranchRoute({
-            ...route2,
-            // Ensure absolute paths are passed to the serverBundles function
-            file: import_node_path2.default.join(resolvedAppDirectory, route2.file)
-          })
-        )
-      });
-      if (typeof serverBundleId !== "string") {
-        throw new Error(`The "serverBundles" function must return a string`);
-      }
-      if (!/^[a-zA-Z0-9-_]+$/.test(serverBundleId)) {
-        throw new Error(
-          `The "serverBundles" function must only return strings containing alphanumeric characters, hyphens and underscores.`
-        );
-      }
-      buildManifest.routeIdToServerBundleId[route.id] = serverBundleId;
-      let relativeServerBundleDirectory = import_node_path2.default.relative(
-        rootDirectory,
-        import_node_path2.default.join(serverBuildDirectory, serverBundleId)
-      );
-      let serverBuildConfig = serverBundleBuildConfigById.get(serverBundleId);
-      if (!serverBuildConfig) {
-        buildManifest.serverBundles[serverBundleId] = {
-          id: serverBundleId,
-          file: normalizePath(
-            import_node_path2.default.join(relativeServerBundleDirectory, serverBuildFile)
-          )
-        };
-        serverBuildConfig = {
-          routes: {},
-          serverBundleId
-        };
-        serverBundleBuildConfigById.set(serverBundleId, serverBuildConfig);
-      }
-      for (let route2 of branch) {
-        serverBuildConfig.routes[route2.id] = route2;
-      }
-    })
-  );
-  let serverBuilds = Array.from(serverBundleBuildConfigById.values()).map(
-    (serverBundleBuildConfig) => {
-      let serverBuild = {
-        ssr: true,
-        serverBundleBuildConfig
-      };
-      return serverBuild;
-    }
-  );
-  return {
-    serverBuilds,
-    buildManifest
-  };
-}
-async function cleanBuildDirectory(viteConfig, ctx) {
-  let buildDirectory = ctx.reactRouterConfig.buildDirectory;
-  let isWithinRoot = () => {
-    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_extra.default.remove(buildDirectory);
-  }
-}
-function getViteManifestPaths(ctx, serverBuilds) {
-  let buildRelative = (pathname) => import_node_path2.default.resolve(ctx.reactRouterConfig.buildDirectory, pathname);
-  let viteManifestPaths = [
-    "client/.vite/manifest.json",
-    ...serverBuilds.map(({ serverBundleBuildConfig }) => {
-      let serverBundleId = serverBundleBuildConfig?.serverBundleId;
-      let serverBundlePath = serverBundleId ? serverBundleId + "/" : "";
-      return `server/${serverBundlePath}.vite/manifest.json`;
-    })
-  ].map((srcPath) => buildRelative(srcPath));
-  return viteManifestPaths;
-}
-async function build(root, {
-  assetsInlineLimit,
-  clearScreen,
-  config: configFile,
-  emptyOutDir,
-  force,
-  logLevel,
-  minify,
-  mode,
-  sourcemapClient,
-  sourcemapServer
-}) {
-  await preloadVite();
-  let viteConfig = await resolveViteConfig({ configFile, mode, root });
-  const ctx = await extractPluginContext(viteConfig);
-  if (!ctx) {
-    console.error(
-      import_picocolors5.default.red("React Router Vite plugin not found in Vite config")
-    );
-    process.exit(1);
-  }
-  let { reactRouterConfig } = ctx;
-  let vite2 = getVite();
-  async function viteBuild({
-    ssr,
-    serverBundleBuildConfig
-  }) {
-    await vite2.build({
-      root,
-      mode,
-      configFile,
-      build: {
-        assetsInlineLimit,
-        emptyOutDir,
-        minify,
-        ssr,
-        sourcemap: ssr ? sourcemapServer : sourcemapClient
-      },
-      optimizeDeps: { force },
-      clearScreen,
-      logLevel,
-      ...serverBundleBuildConfig ? { __reactRouterServerBundleBuildConfig: serverBundleBuildConfig } : {}
-    });
-  }
-  await cleanBuildDirectory(viteConfig, ctx);
-  await viteBuild({ ssr: false });
-  let { serverBuilds, buildManifest } = await getServerBuilds(ctx);
-  await Promise.all(serverBuilds.map(viteBuild));
-  let viteManifestPaths = getViteManifestPaths(ctx, serverBuilds);
-  await Promise.all(
-    viteManifestPaths.map(async (viteManifestPath) => {
-      let manifestExists = await import_fs_extra.default.pathExists(viteManifestPath);
-      if (!manifestExists) return;
-      if (!ctx.viteManifestEnabled) {
-        await import_fs_extra.default.remove(viteManifestPath);
-      }
-      let viteDir = import_node_path2.default.dirname(viteManifestPath);
-      let viteDirFiles = await import_fs_extra.default.readdir(viteDir);
-      if (viteDirFiles.length === 0) {
-        await import_fs_extra.default.remove(viteDir);
-      }
-    })
-  );
-  await reactRouterConfig.buildEnd?.({
-    buildManifest,
-    reactRouterConfig,
-    viteConfig
-  });
-}
-var import_node_path2, import_fs_extra, import_picocolors5;
-var init_build = __esm({
-  "vite/build.ts"() {
-    "use strict";
-    import_node_path2 = __toESM(require("path"));
-    import_fs_extra = __toESM(require("fs-extra"));
-    import_picocolors5 = __toESM(require("picocolors"));
-    init_plugin();
-    init_config();
-    init_invariant();
-    init_vite();
-  }
-});
-
-// vite/dev.ts
-var dev_exports = {};
-__export(dev_exports, {
-  dev: () => dev
-});
-async function dev(root, {
-  clearScreen,
-  config: configFile,
-  cors,
-  force,
-  host,
-  logLevel,
-  mode,
-  open,
-  port,
-  strictPort
-}) {
-  await preloadVite();
-  let vite2 = getVite();
-  let server = await vite2.createServer({
-    root,
-    mode,
-    configFile,
-    server: { open, cors, host, port, strictPort },
-    optimizeDeps: { force },
-    clearScreen,
-    logLevel
-  });
-  if (!server.config.plugins.find((plugin2) => plugin2.name === "react-router")) {
-    console.error(
-      import_picocolors6.default.red("React Router Vite plugin not found in Vite config")
-    );
-    process.exit(1);
-  }
-  await server.listen();
-  server.printUrls();
-  let customShortcuts = [
-    {
-      key: "p",
-      description: "start/stop the profiler",
-      async action(server2) {
-        if (getSession()) {
-          await stop(server2.config.logger.info);
-        } else {
-          await start(() => {
-            server2.config.logger.info("Profiler started");
-          });
-        }
-      }
-    }
-  ];
-  server.bindCLIShortcuts({ print: true, customShortcuts });
-}
-var import_picocolors6;
-var init_dev = __esm({
-  "vite/dev.ts"() {
-    "use strict";
-    import_picocolors6 = __toESM(require("picocolors"));
-    init_vite();
-    init_profiler();
-  }
-});
+import {
+  loadPluginContext,
+  run,
+  watch
+} from "../chunk-B25E3JGK.js";
+import "../chunk-B3M3SF27.js";
+import "../chunk-HICCFFJA.js";
+import {
+  start,
+  stop
+} from "../chunk-VTJ3CG32.js";
+import {
+  getVite,
+  preloadVite
+} from "../chunk-X234P535.js";
+import {
+  __require
+} from "../chunk-XJYIKBPH.js";
 
 // cli/run.ts
-var import_arg = __toESM(require("arg"));
-var import_semver = __toESM(require("semver"));
-var import_picocolors8 = __toESM(require("picocolors"));
+import url from "node:url";
+import arg from "arg";
+import semver from "semver";
+import colors2 from "picocolors";
 
 // cli/commands.ts
-var path9 = __toESM(require("path"));
-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"));
+import * as path from "node:path";
+import fse from "fs-extra";
+import PackageJson from "@npmcli/package-json";
+import exitHook from "exit-hook";
+import colors from "picocolors";
 
 // config/format.ts
 function formatRoutes(routeManifest, format) {
@@ -1404,31 +97,25 @@ function formatRoutesAsJsx(routeManifest) {
   return output;
 }
 
-// cli/commands.ts
-init_plugin();
-
 // cli/useJavascript.ts
-var babel2 = __toESM(require("@babel/core"));
-var import_plugin_syntax_jsx = __toESM(require("@babel/plugin-syntax-jsx"));
-var import_preset_typescript = __toESM(require("@babel/preset-typescript"));
-var import_prettier = __toESM(require("prettier"));
+import * as babel from "@babel/core";
+import babelPluginSyntaxJSX from "@babel/plugin-syntax-jsx";
+import babelPresetTypeScript from "@babel/preset-typescript";
+import prettier from "prettier";
 function transpile(tsx, options = {}) {
-  let mjs = babel2.transformSync(tsx, {
+  let mjs = babel.transformSync(tsx, {
     compact: false,
     cwd: options.cwd,
     filename: options.filename,
-    plugins: [import_plugin_syntax_jsx.default],
-    presets: [[import_preset_typescript.default, { jsx: "preserve" }]],
+    plugins: [babelPluginSyntaxJSX],
+    presets: [[babelPresetTypeScript, { jsx: "preserve" }]],
     retainLines: true
   });
   if (!mjs || !mjs.code) throw new Error("Could not parse TypeScript");
-  return import_prettier.default.format(mjs.code, { parser: "babel" });
+  return prettier.format(mjs.code, { parser: "babel" });
 }
 
 // cli/commands.ts
-init_profiler();
-init_typegen();
-init_vite();
 async function routes(reactRouterRoot, flags = {}) {
   let ctx = await loadPluginContext({
     root: reactRouterRoot,
@@ -1436,34 +123,34 @@ async function routes(reactRouterRoot, flags = {}) {
   });
   if (!ctx) {
     console.error(
-      import_picocolors7.default.red("React Router Vite plugin not found in Vite config")
+      colors.red("React Router Vite plugin not found in Vite config")
     );
     process.exit(1);
   }
   let format = flags.json ? "json" : "jsx";
   console.log(formatRoutes(ctx.reactRouterConfig.routes, format));
 }
-async function build2(root, options = {}) {
+async function build(root, options = {}) {
   if (!root) {
     root = process.env.REACT_ROUTER_ROOT || process.cwd();
   }
-  let { build: build3 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  let { build: build2 } = await import("../build-VA3X4T4U.js");
   if (options.profile) {
     await start();
   }
   try {
-    await build3(root, options);
+    await build2(root, options);
   } finally {
     await stop(console.info);
   }
 }
-async function dev2(root, options = {}) {
-  let { dev: dev3 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+async function dev(root, options = {}) {
+  let { dev: dev2 } = await import("../dev-SLPL2UHO.js");
   if (options.profile) {
     await start();
   }
-  (0, import_exit_hook.default)(() => stop(console.info));
-  await dev3(root, options);
+  exitHook(() => stop(console.info));
+  await dev2(root, options);
   await new Promise(() => {
   });
 }
@@ -1490,24 +177,24 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
     let entriesArray = Array.from(entries);
     let list = conjunctionListFormat.format(entriesArray);
     console.error(
-      import_picocolors7.default.red(`Invalid entry file. Valid entry files are ${list}`)
+      colors.red(`Invalid entry file. Valid entry files are ${list}`)
     );
     return;
   }
-  let pkgJson = await import_package_json2.default.load(rootDirectory);
+  let pkgJson = await PackageJson.load(rootDirectory);
   let deps = pkgJson.content.dependencies ?? {};
   if (!deps["@react-router/node"]) {
-    console.error(import_picocolors7.default.red(`No default server entry detected.`));
+    console.error(colors.red(`No default server entry detected.`));
     return;
   }
-  let defaultsDirectory = path9.resolve(
-    path9.dirname(require.resolve("@react-router/dev/package.json")),
+  let defaultsDirectory = path.resolve(
+    path.dirname(__require.resolve("@react-router/dev/package.json")),
     "dist",
     "config",
     "defaults"
   );
-  let defaultEntryClient = path9.resolve(defaultsDirectory, "entry.client.tsx");
-  let defaultEntryServer = path9.resolve(
+  let defaultEntryClient = path.resolve(defaultsDirectory, "entry.client.tsx");
+  let defaultEntryServer = path.resolve(
     defaultsDirectory,
     `entry.server.node.tsx`
   );
@@ -1516,52 +203,52 @@ async function generateEntry(entry, reactRouterRoot, flags = {}) {
   let useTypeScript = flags.typescript ?? true;
   let outputExtension = useTypeScript ? "tsx" : "jsx";
   let outputEntry = `${entry}.${outputExtension}`;
-  let outputFile2 = path9.resolve(appDirectory, outputEntry);
+  let outputFile = path.resolve(appDirectory, outputEntry);
   if (!useTypeScript) {
     let javascript = transpile(contents, {
       cwd: rootDirectory,
       filename: isServerEntry ? defaultEntryServer : defaultEntryClient
     });
-    await import_fs_extra2.default.writeFile(outputFile2, javascript, "utf-8");
+    await fse.writeFile(outputFile, javascript, "utf-8");
   } else {
-    await import_fs_extra2.default.writeFile(outputFile2, contents, "utf-8");
+    await fse.writeFile(outputFile, contents, "utf-8");
   }
   console.log(
-    import_picocolors7.default.blue(
-      `Entry file ${entry} created at ${path9.relative(
+    colors.blue(
+      `Entry file ${entry} created at ${path.relative(
         rootDirectory,
-        outputFile2
+        outputFile
       )}.`
     )
   );
 }
 async function checkForEntry(rootDirectory, appDirectory, entries2) {
   for (let entry of entries2) {
-    let entryPath = path9.resolve(appDirectory, entry);
-    let exists = await import_fs_extra2.default.pathExists(entryPath);
+    let entryPath = path.resolve(appDirectory, entry);
+    let exists = await fse.pathExists(entryPath);
     if (exists) {
-      let relative8 = path9.relative(rootDirectory, entryPath);
-      console.error(import_picocolors7.default.red(`Entry file ${relative8} already exists.`));
+      let relative2 = path.relative(rootDirectory, entryPath);
+      console.error(colors.red(`Entry file ${relative2} already exists.`));
       return process.exit(1);
     }
   }
 }
 async function createServerEntry(rootDirectory, appDirectory, inputFile) {
   await checkForEntry(rootDirectory, appDirectory, serverEntries);
-  let contents = await import_fs_extra2.default.readFile(inputFile, "utf-8");
+  let contents = await fse.readFile(inputFile, "utf-8");
   return contents;
 }
 async function createClientEntry(rootDirectory, appDirectory, inputFile) {
   await checkForEntry(rootDirectory, appDirectory, clientEntries);
-  let contents = await import_fs_extra2.default.readFile(inputFile, "utf-8");
+  let contents = await fse.readFile(inputFile, "utf-8");
   return contents;
 }
 async function typegen(root, flags) {
   root ??= process.cwd();
   if (flags.watch) {
     await preloadVite();
-    const vite2 = getVite();
-    const logger = vite2.createLogger("info", { prefix: "[react-router]" });
+    const vite = getVite();
+    const logger = vite.createLogger("info", { prefix: "[react-router]" });
     await watch(root, { logger });
     await new Promise(() => {
     });
@@ -1572,14 +259,14 @@ async function typegen(root, flags) {
 
 // cli/run.ts
 var helpText = `
-${import_picocolors8.default.blueBright("react-router")}
+${colors2.blueBright("react-router")}
 
-  ${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")}]
+  ${colors2.underline("Usage")}:
+    $ react-router build [${colors2.yellowBright("projectDir")}]
+    $ react-router dev [${colors2.yellowBright("projectDir")}]
+    $ react-router routes [${colors2.yellowBright("projectDir")}]
 
-  ${import_picocolors8.default.underline("Options")}:
+  ${colors2.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
@@ -1615,22 +302,22 @@ ${import_picocolors8.default.blueBright("react-router")}
   \`typegen\` Options:
     --watch             Automatically regenerate types whenever route config (\`routes.ts\`) or route modules change
 
-  ${import_picocolors8.default.underline("Build your project")}:
+  ${colors2.underline("Build your project")}:
 
     $ react-router build
 
-  ${import_picocolors8.default.underline("Run your project locally in development")}:
+  ${colors2.underline("Run your project locally in development")}:
 
     $ react-router dev
 
-  ${import_picocolors8.default.underline("Show all routes in your app")}:
+  ${colors2.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
 
-  ${import_picocolors8.default.underline("Reveal the used entry point")}:
+  ${colors2.underline("Reveal the used entry point")}:
 
     $ react-router reveal entry.client
     $ react-router reveal entry.server
@@ -1638,7 +325,7 @@ ${import_picocolors8.default.blueBright("react-router")}
     $ react-router reveal entry.server --no-typescript
     $ react-router reveal entry.server --config vite.react-router.config.ts
 
-  ${import_picocolors8.default.underline("Generate types for route modules")}:
+  ${colors2.underline("Generate types for route modules")}:
 
    $ react-router typegen
    $ react-router typegen --watch
@@ -1646,7 +333,7 @@ ${import_picocolors8.default.blueBright("react-router")}
 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) {
+  if (versions && versions.node && semver.major(versions.node) < 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}.`
     );
@@ -1656,7 +343,7 @@ async function run2(argv = process.argv.slice(2)) {
     let nextArg = argv[index + 1];
     return !nextArg || nextArg.startsWith("-");
   };
-  let args = (0, import_arg.default)(
+  let args = arg(
     {
       "--force": Boolean,
       "--help": Boolean,
@@ -1703,11 +390,11 @@ async function run2(argv = process.argv.slice(2)) {
     return;
   }
   if (flags.version) {
-    let version = require("../package.json").version;
+    let version = __require("../package.json").version;
     console.log(version);
     return;
   }
-  flags.interactive = flags.interactive ?? require.main === module;
+  flags.interactive = flags.interactive ?? import.meta.url === url.pathToFileURL(process.argv[1]).href;
   if (args["--no-typescript"]) {
     flags.typescript = false;
   }
@@ -1717,20 +404,20 @@ async function run2(argv = process.argv.slice(2)) {
       await routes(input[1], flags);
       break;
     case "build":
-      await build2(input[1], flags);
+      await build(input[1], flags);
       break;
     case "reveal": {
       await generateEntry(input[1], input[2], flags);
       break;
     }
     case "dev":
-      await dev2(input[1], flags);
+      await dev(input[1], flags);
       break;
     case "typegen":
       await typegen(input[1], flags);
       break;
     default:
-      await dev2(input[0], flags);
+      await dev(input[0], flags);
   }
 }