@react-router/dev 7.7.1-pre.0 → 7.8.0-pre.0

package/dist/internal.js

@@ -0,0 +1,1636 @@
+/**
+ * @react-router/dev v7.8.0-pre.0
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__: () => __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__
+});
+module.exports = __toCommonJS(internal_exports);
+
+// vite/rsc/plugin.ts
+var import_plugin_rsc = __toESM(require("@vitejs/plugin-rsc"));
+var import_plugin_react = __toESM(require("@vitejs/plugin-react"));
+var import_es_module_lexer2 = require("es-module-lexer");
+
+// vite/virtual-module.ts
+function create(name) {
+  let id = `virtual:react-router/${name}`;
+  return {
+    id,
+    resolvedId: `\0${id}`,
+    url: `/@id/__x00__${id}`
+  };
+}
+
+// typegen/index.ts
+var import_promises = __toESM(require("fs/promises"));
+var Path4 = __toESM(require("pathe"));
+var import_picocolors2 = require("picocolors");
+
+// config/config.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_child_process = require("child_process");
+var import_package_json = __toESM(require("@npmcli/package-json"));
+
+// vite/vite.ts
+var import_pathe2 = __toESM(require("pathe"));
+
+// 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);
+  }
+}
+
+// config/is-react-router-repo.ts
+var import_pathe = __toESM(require("pathe"));
+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";
+}
+
+// vite/vite.ts
+var vite;
+var 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";
+async function preloadVite() {
+  vite = await import(viteImportSpecifier);
+}
+function getVite() {
+  invariant(vite, "getVite() called before preloadVite()");
+  return vite;
+}
+
+// vite/ssr-externals.ts
+var 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;
+
+// vite/vite-node.ts
+async function createContext({
+  root,
+  mode,
+  customLogger
+}) {
+  await preloadVite();
+  const vite2 = getVite();
+  const [{ ViteNodeServer }, { ViteNodeRunner }, { installSourcemapsSupport }] = await Promise.all([
+    import("vite-node/server"),
+    import("vite-node/client"),
+    import("vite-node/source-map")
+  ]);
+  const devServer = await vite2.createServer({
+    root,
+    mode,
+    customLogger,
+    server: {
+      preTransformRequests: false,
+      hmr: false,
+      watch: null
+    },
+    ssr: {
+      external: ssrExternals
+    },
+    optimizeDeps: {
+      noDiscovery: true
+    },
+    css: {
+      // This empty PostCSS config object prevents the PostCSS config file from
+      // being loaded. We don't need it in a React Router config context, and
+      // there's also an issue in Vite 5 when using a .ts PostCSS config file in
+      // an ESM project: https://github.com/vitejs/vite/issues/15869. Consumers
+      // can work around this in their own Vite config file, but they can't
+      // configure this internal usage of vite-node.
+      postcss: {}
+    },
+    configFile: false,
+    envFile: false,
+    plugins: []
+  });
+  await devServer.pluginContainer.buildStart({});
+  const server = new ViteNodeServer(devServer);
+  installSourcemapsSupport({
+    getSourceMap: (source) => server.getSourceMap(source)
+  });
+  const runner = new 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 };
+}
+
+// config/config.ts
+var import_pathe3 = __toESM(require("pathe"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_picocolors = __toESM(require("picocolors"));
+var import_pick2 = __toESM(require("lodash/pick"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+var import_isEqual = __toESM(require("lodash/isEqual"));
+
+// config/routes.ts
+var Path = __toESM(require("pathe"));
+var v = __toESM(require("valibot"));
+var import_pick = __toESM(require("lodash/pick"));
+function setAppDirectory(directory) {
+  globalThis.__reactRouterAppDirectory = directory;
+}
+var routeConfigEntrySchema = v.pipe(
+  v.custom((value) => {
+    return !(typeof value === "object" && value !== null && "then" in value && "catch" in value);
+  }, "Invalid type: Expected object but received a promise. Did you forget to await?"),
+  v.object({
+    id: v.optional(
+      v.pipe(
+        v.string(),
+        v.notValue("root", "A route cannot use the reserved id 'root'.")
+      )
+    ),
+    path: v.optional(v.string()),
+    index: v.optional(v.boolean()),
+    caseSensitive: v.optional(v.boolean()),
+    file: v.string(),
+    children: v.optional(v.array(v.lazy(() => routeConfigEntrySchema)))
+  })
+);
+var resolvedRouteConfigSchema = v.array(routeConfigEntrySchema);
+function validateRouteConfig({
+  routeConfigFile,
+  routeConfig
+}) {
+  if (!routeConfig) {
+    return {
+      valid: false,
+      message: `Route config must be the default export in "${routeConfigFile}".`
+    };
+  }
+  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(
+          ([path4, message]) => `Path: routes.${path4}
+${message}`
+        ) : []
+      ].flat().join("\n\n")
+    };
+  }
+  return {
+    valid: true,
+    routeConfig
+  };
+}
+function configRoutesToRouteManifest(appDirectory, routes) {
+  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 routes) {
+    walk(route);
+  }
+  return routeManifest;
+}
+function createRouteId(file) {
+  return Path.normalize(stripFileExtension(file));
+}
+function stripFileExtension(file) {
+  return file.replace(/\.[a-z0-9]+$/i, "");
+}
+
+// config/config.ts
+var excludedConfigPresetKeys = ["presets"];
+var mergeReactRouterConfig = (...configs) => {
+  let reducer = (configA, configB) => {
+    let mergeRequired = (key) => configA[key] !== void 0 && configB[key] !== void 0;
+    return {
+      ...configA,
+      ...configB,
+      ...mergeRequired("buildEnd") ? {
+        buildEnd: async (...args) => {
+          await Promise.all([
+            configA.buildEnd?.(...args),
+            configB.buildEnd?.(...args)
+          ]);
+        }
+      } : {},
+      ...mergeRequired("future") ? {
+        future: {
+          ...configA.future,
+          ...configB.future
+        }
+      } : {},
+      ...mergeRequired("presets") ? {
+        presets: [...configA.presets ?? [], ...configB.presets ?? []]
+      } : {}
+    };
+  };
+  return configs.reduce(reducer, {});
+};
+var deepFreeze = (o) => {
+  Object.freeze(o);
+  let oIsFunction = typeof o === "function";
+  let hasOwnProp = Object.prototype.hasOwnProperty;
+  Object.getOwnPropertyNames(o).forEach(function(prop) {
+    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
+      deepFreeze(o[prop]);
+    }
+  });
+  return o;
+};
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+async function resolveConfig({
+  root,
+  viteNodeContext,
+  reactRouterConfigFile,
+  skipRoutes
+}) {
+  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 userAndPresetConfigs = mergeReactRouterConfig(
+    ...presets,
+    reactRouterUserConfig
+  );
+  let {
+    appDirectory: userAppDirectory,
+    basename: basename2,
+    buildDirectory: userBuildDirectory,
+    buildEnd,
+    prerender,
+    routeDiscovery: userRouteDiscovery,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr
+  } = {
+    ...defaults,
+    // Default values should be completely overridden by user/preset config, not merged
+    ...userAndPresetConfigs
+  };
+  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 routeDiscovery;
+  if (userRouteDiscovery == null) {
+    if (ssr) {
+      routeDiscovery = {
+        mode: "lazy",
+        manifestPath: "/__manifest"
+      };
+    } else {
+      routeDiscovery = { mode: "initial" };
+    }
+  } else if (userRouteDiscovery.mode === "initial") {
+    routeDiscovery = userRouteDiscovery;
+  } else if (userRouteDiscovery.mode === "lazy") {
+    if (!ssr) {
+      return err(
+        'The `routeDiscovery.mode` config cannot be set to "lazy" when setting `ssr:false`'
+      );
+    }
+    let { manifestPath } = userRouteDiscovery;
+    if (manifestPath != null && !manifestPath.startsWith("/")) {
+      return err(
+        'The `routeDiscovery.manifestPath` config must be a root-relative pathname beginning with a slash (i.e., "/__manifest")'
+      );
+    }
+    routeDiscovery = userRouteDiscovery;
+  }
+  let appDirectory = import_pathe3.default.resolve(root, userAppDirectory || "app");
+  let buildDirectory = import_pathe3.default.resolve(root, userBuildDirectory);
+  let rootRouteFile = findEntry(appDirectory, "root");
+  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 routes;
+  let routeConfig = [];
+  if (skipRoutes) {
+    routes = {};
+  } else {
+    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 result = validateRouteConfig({
+        routeConfigFile,
+        routeConfig: await routeConfigExport
+      });
+      if (!result.valid) {
+        return err(result.message);
+      }
+      routeConfig = [
+        {
+          id: "root",
+          path: "",
+          file: rootRouteFile,
+          children: result.routeConfig
+        }
+      ];
+      routes = configRoutesToRouteManifest(appDirectory, routeConfig);
+    } catch (error) {
+      return err(
+        [
+          import_picocolors.default.red(`Route config in "${routeConfigFile}" is invalid.`),
+          "",
+          error.loc?.file && error.loc?.column && error.frame ? [
+            import_pathe3.default.relative(appDirectory, error.loc.file) + ":" + error.loc.line + ":" + error.loc.column,
+            error.frame.trim?.()
+          ] : error.stack
+        ].flat().join("\n")
+      );
+    }
+  }
+  let future = {
+    unstable_middleware: reactRouterUserConfig.future?.unstable_middleware ?? false,
+    unstable_optimizeDeps: reactRouterUserConfig.future?.unstable_optimizeDeps ?? false,
+    unstable_splitRouteModules: reactRouterUserConfig.future?.unstable_splitRouteModules ?? false,
+    unstable_subResourceIntegrity: reactRouterUserConfig.future?.unstable_subResourceIntegrity ?? false,
+    unstable_viteEnvironmentApi: reactRouterUserConfig.future?.unstable_viteEnvironmentApi ?? false
+  };
+  let reactRouterConfig = deepFreeze({
+    appDirectory,
+    basename: basename2,
+    buildDirectory,
+    buildEnd,
+    future,
+    prerender,
+    routes,
+    routeDiscovery,
+    serverBuildFile,
+    serverBundles,
+    serverModuleFormat,
+    ssr,
+    unstable_routeConfig: routeConfig
+  });
+  for (let preset of reactRouterUserConfig.presets ?? []) {
+    await preset.reactRouterConfigResolved?.({ reactRouterConfig });
+  }
+  return ok(reactRouterConfig);
+}
+async function createConfigLoader({
+  rootDirectory: root,
+  watch: watch2,
+  mode,
+  skipRoutes
+}) {
+  root = import_pathe3.default.normalize(root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd());
+  let vite2 = await import("vite");
+  let viteNodeContext = await createContext({
+    root,
+    mode,
+    // Filter out any info level logs from vite-node
+    customLogger: vite2.createLogger("warn", {
+      prefix: "[react-router]"
+    })
+  });
+  let reactRouterConfigFile;
+  let updateReactRouterConfigFile = () => {
+    reactRouterConfigFile = findEntry(root, "react-router.config", {
+      absolute: true
+    });
+  };
+  updateReactRouterConfigFile();
+  let getConfig = () => resolveConfig({ root, viteNodeContext, reactRouterConfigFile, skipRoutes });
+  let appDirectory;
+  let initialConfigResult = await getConfig();
+  if (!initialConfigResult.ok) {
+    throw new Error(initialConfigResult.error);
+  }
+  appDirectory = import_pathe3.default.normalize(initialConfigResult.value.appDirectory);
+  let currentConfig = 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([root, appDirectory], {
+          ignoreInitial: true,
+          ignored: (path4) => {
+            let dirname4 = import_pathe3.default.dirname(path4);
+            return !dirname4.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
+            // that are at the root level, not nested in subdirectories
+            path4 !== root && // Watch the root directory itself
+            dirname4 !== root;
+          }
+        });
+        fsWatcher.on("all", async (...args) => {
+          let [event, rawFilepath] = args;
+          let filepath = import_pathe3.default.normalize(rawFilepath);
+          let fileAddedOrRemoved = event === "add" || event === "unlink";
+          let appFileAddedOrRemoved = fileAddedOrRemoved && filepath.startsWith(import_pathe3.default.normalize(appDirectory));
+          let rootRelativeFilepath = import_pathe3.default.relative(root, filepath);
+          let configFileAddedOrRemoved = fileAddedOrRemoved && isEntryFile("react-router.config", rootRelativeFilepath);
+          if (configFileAddedOrRemoved) {
+            updateReactRouterConfigFile();
+          }
+          let moduleGraphChanged = configFileAddedOrRemoved || Boolean(
+            viteNodeContext.devServer?.moduleGraph.getModuleById(filepath)
+          );
+          if (!moduleGraphChanged && !appFileAddedOrRemoved) {
+            return;
+          }
+          viteNodeContext.devServer?.moduleGraph.invalidateAll();
+          viteNodeContext.runner?.moduleCache.clear();
+          let result = await getConfig();
+          let prevAppDirectory = appDirectory;
+          appDirectory = import_pathe3.default.normalize(
+            (result.value ?? currentConfig).appDirectory
+          );
+          if (appDirectory !== prevAppDirectory) {
+            fsWatcher.unwatch(prevAppDirectory);
+            fsWatcher.add(appDirectory);
+          }
+          let configCodeChanged = configFileAddedOrRemoved || reactRouterConfigFile !== void 0 && isEntryFileDependency(
+            viteNodeContext.devServer.moduleGraph,
+            reactRouterConfigFile,
+            filepath
+          );
+          let routeConfigFile = !skipRoutes ? findEntry(appDirectory, "routes", {
+            absolute: true
+          }) : void 0;
+          let routeConfigCodeChanged = routeConfigFile !== void 0 && isEntryFileDependency(
+            viteNodeContext.devServer.moduleGraph,
+            routeConfigFile,
+            filepath
+          );
+          let configChanged = result.ok && !(0, import_isEqual.default)(omitRoutes(currentConfig), omitRoutes(result.value));
+          let routeConfigChanged = result.ok && !(0, import_isEqual.default)(currentConfig?.routes, result.value.routes);
+          for (let handler2 of changeHandlers) {
+            handler2({
+              result,
+              configCodeChanged,
+              routeConfigCodeChanged,
+              configChanged,
+              routeConfigChanged,
+              path: filepath,
+              event
+            });
+          }
+          if (result.ok) {
+            currentConfig = result.value;
+          }
+        });
+      }
+      return () => {
+        changeHandlers = changeHandlers.filter(
+          (changeHandler) => changeHandler !== handler
+        );
+      };
+    },
+    close: async () => {
+      changeHandlers = [];
+      await viteNodeContext.devServer.close();
+      await fsWatcher?.close();
+    }
+  };
+}
+function omitRoutes(config) {
+  return {
+    ...config,
+    routes: {}
+  };
+}
+var entryExts = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".mts"];
+function isEntryFile(entryBasename, filename2) {
+  return entryExts.some((ext) => filename2 === `${entryBasename}${ext}`);
+}
+function findEntry(dir, basename2, options) {
+  let currentDir = import_pathe3.default.resolve(dir);
+  let { root } = import_pathe3.default.parse(currentDir);
+  while (true) {
+    for (let ext of options?.extensions ?? entryExts) {
+      let file = import_pathe3.default.resolve(currentDir, basename2 + ext);
+      if (import_node_fs.default.existsSync(file)) {
+        return options?.absolute ?? false ? file : import_pathe3.default.relative(dir, file);
+      }
+    }
+    if (!options?.walkParents) {
+      return void 0;
+    }
+    let parentDir = import_pathe3.default.dirname(currentDir);
+    if (currentDir === root || parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function isEntryFileDependency(moduleGraph, entryFilepath, filepath, visited = /* @__PURE__ */ new Set()) {
+  entryFilepath = import_pathe3.default.normalize(entryFilepath);
+  filepath = import_pathe3.default.normalize(filepath);
+  if (visited.has(filepath)) {
+    return false;
+  }
+  visited.add(filepath);
+  if (filepath === entryFilepath) {
+    return true;
+  }
+  let mod = moduleGraph.getModuleById(filepath);
+  if (!mod) {
+    return false;
+  }
+  for (let importer of mod.importers) {
+    if (!importer.id) {
+      continue;
+    }
+    if (importer.id === entryFilepath || isEntryFileDependency(moduleGraph, entryFilepath, importer.id, visited)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// typegen/context.ts
+async function createContext2({
+  rootDirectory,
+  watch: watch2,
+  mode
+}) {
+  const configLoader = await createConfigLoader({ rootDirectory, mode, watch: watch2 });
+  const configResult = await configLoader.getConfig();
+  if (!configResult.ok) {
+    throw new Error(configResult.error);
+  }
+  const config = configResult.value;
+  return {
+    configLoader,
+    rootDirectory,
+    config
+  };
+}
+
+// typegen/generate.ts
+var import_dedent = __toESM(require("dedent"));
+var Path3 = __toESM(require("pathe"));
+var Pathe = __toESM(require("pathe/utils"));
+
+// vite/babel.ts
+var babel_exports = {};
+__export(babel_exports, {
+  generate: () => generate,
+  parse: () => import_parser.parse,
+  t: () => t,
+  traverse: () => traverse
+});
+var import_parser = require("@babel/parser");
+var t = __toESM(require("@babel/types"));
+var traverse = require("@babel/traverse").default;
+var generate = require("@babel/generator").default;
+
+// typegen/params.ts
+function parse2(fullpath2) {
+  const result = {};
+  let segments = fullpath2.split("/");
+  segments.forEach((segment) => {
+    const match = segment.match(/^:([\w-]+)(\?)?/);
+    if (!match) return;
+    const param = match[1];
+    const isRequired = match[2] === void 0;
+    result[param] ||= isRequired;
+    return;
+  });
+  const hasSplat = segments.at(-1) === "*";
+  if (hasSplat) result["*"] = true;
+  return result;
+}
+
+// typegen/route.ts
+function lineage(routes, route) {
+  const result = [];
+  while (route) {
+    result.push(route);
+    if (!route.parentId) break;
+    route = routes[route.parentId];
+  }
+  result.reverse();
+  return result;
+}
+function fullpath(lineage2) {
+  const route = lineage2.at(-1);
+  if (lineage2.length === 1 && route?.id === "root") return "/";
+  const isLayout = route && route.index !== true && route.path === void 0;
+  if (isLayout) return void 0;
+  return "/" + lineage2.map((route2) => route2.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path4) => path4 !== void 0 && path4 !== "").join("/");
+}
+
+// typegen/generate.ts
+function typesDirectory(ctx) {
+  return Path3.join(ctx.rootDirectory, ".react-router/types");
+}
+function generateFuture(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+future.ts");
+  const content = import_dedent.default`
+    // Generated by React Router
+
+    import "react-router";
+
+    declare module "react-router" {
+      interface Future {
+        unstable_middleware: ${ctx.config.future.unstable_middleware}
+      }
+    }
+  `;
+  return { filename: filename2, content };
+}
+function generateServerBuild(ctx) {
+  const filename2 = Path3.join(typesDirectory(ctx), "+server-build.d.ts");
+  const content = import_dedent.default`
+    // Generated by React Router
+
+    declare module "virtual:react-router/server-build" {
+      import { ServerBuild } from "react-router";
+      export const assets: ServerBuild["assets"];
+      export const assetsBuildDirectory: ServerBuild["assetsBuildDirectory"];
+      export const basename: ServerBuild["basename"];
+      export const entry: ServerBuild["entry"];
+      export const future: ServerBuild["future"];
+      export const isSpaMode: ServerBuild["isSpaMode"];
+      export const prerender: ServerBuild["prerender"];
+      export const publicPath: ServerBuild["publicPath"];
+      export const routeDiscovery: ServerBuild["routeDiscovery"];
+      export const routes: ServerBuild["routes"];
+      export const ssr: ServerBuild["ssr"];
+      export const unstable_getCriticalCss: ServerBuild["unstable_getCriticalCss"];
+    }
+  `;
+  return { filename: filename2, content };
+}
+var { t: t2 } = babel_exports;
+function generateRoutes(ctx) {
+  const fileToRoutes = /* @__PURE__ */ new Map();
+  const lineages = /* @__PURE__ */ new Map();
+  const allPages = /* @__PURE__ */ new Set();
+  const routeToPages = /* @__PURE__ */ new Map();
+  for (const route of Object.values(ctx.config.routes)) {
+    let routeIds = fileToRoutes.get(route.file);
+    if (!routeIds) {
+      routeIds = /* @__PURE__ */ new Set();
+      fileToRoutes.set(route.file, routeIds);
+    }
+    routeIds.add(route.id);
+    const lineage2 = lineage(ctx.config.routes, route);
+    lineages.set(route.id, lineage2);
+    const fullpath2 = fullpath(lineage2);
+    if (!fullpath2) continue;
+    const pages = expand(fullpath2);
+    pages.forEach((page) => allPages.add(page));
+    lineage2.forEach(({ id }) => {
+      let routePages = routeToPages.get(id);
+      if (!routePages) {
+        routePages = /* @__PURE__ */ new Set();
+        routeToPages.set(id, routePages);
+      }
+      pages.forEach((page) => routePages.add(page));
+    });
+  }
+  const routesTs = {
+    filename: Path3.join(typesDirectory(ctx), "+routes.ts"),
+    content: import_dedent.default`
+        // Generated by React Router
+
+        import "react-router"
+
+        declare module "react-router" {
+          interface Register {
+            pages: Pages
+            routeFiles: RouteFiles
+          }
+        }
+      ` + "\n\n" + generate(pagesType(allPages)).code + "\n\n" + generate(routeFilesType({ fileToRoutes, routeToPages })).code
+  };
+  const allAnnotations = Array.from(fileToRoutes.entries()).filter(([file]) => isInAppDirectory(ctx, file)).map(
+    ([file, routeIds]) => getRouteAnnotations({ ctx, file, routeIds, lineages })
+  );
+  return [routesTs, ...allAnnotations];
+}
+function pagesType(pages) {
+  return t2.tsTypeAliasDeclaration(
+    t2.identifier("Pages"),
+    null,
+    t2.tsTypeLiteral(
+      Array.from(pages).map((page) => {
+        return t2.tsPropertySignature(
+          t2.stringLiteral(page),
+          t2.tsTypeAnnotation(
+            t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("params"),
+                t2.tsTypeAnnotation(paramsType(page))
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+}
+function routeFilesType({
+  fileToRoutes,
+  routeToPages
+}) {
+  return t2.tsTypeAliasDeclaration(
+    t2.identifier("RouteFiles"),
+    null,
+    t2.tsTypeLiteral(
+      Array.from(fileToRoutes).map(
+        ([file, routeIds]) => t2.tsPropertySignature(
+          t2.stringLiteral(file),
+          t2.tsTypeAnnotation(
+            t2.tsUnionType(
+              Array.from(routeIds).map((routeId) => {
+                const pages = routeToPages.get(routeId) ?? /* @__PURE__ */ new Set();
+                return t2.tsTypeLiteral([
+                  t2.tsPropertySignature(
+                    t2.identifier("id"),
+                    t2.tsTypeAnnotation(
+                      t2.tsLiteralType(t2.stringLiteral(routeId))
+                    )
+                  ),
+                  t2.tsPropertySignature(
+                    t2.identifier("page"),
+                    t2.tsTypeAnnotation(
+                      pages ? t2.tsUnionType(
+                        Array.from(pages).map(
+                          (page) => t2.tsLiteralType(t2.stringLiteral(page))
+                        )
+                      ) : t2.tsNeverKeyword()
+                    )
+                  )
+                ]);
+              })
+            )
+          )
+        )
+      )
+    )
+  );
+}
+function isInAppDirectory(ctx, routeFile) {
+  const path4 = Path3.resolve(ctx.config.appDirectory, routeFile);
+  return path4.startsWith(ctx.config.appDirectory);
+}
+function getRouteAnnotations({
+  ctx,
+  file,
+  routeIds,
+  lineages
+}) {
+  const filename2 = Path3.join(
+    typesDirectory(ctx),
+    Path3.relative(ctx.rootDirectory, ctx.config.appDirectory),
+    Path3.dirname(file),
+    "+types",
+    Pathe.filename(file) + ".ts"
+  );
+  const matchesType = t2.tsTypeAliasDeclaration(
+    t2.identifier("Matches"),
+    null,
+    t2.tsUnionType(
+      Array.from(routeIds).map((routeId) => {
+        const lineage2 = lineages.get(routeId);
+        return t2.tsTupleType(
+          lineage2.map(
+            (route) => t2.tsTypeLiteral([
+              t2.tsPropertySignature(
+                t2.identifier("id"),
+                t2.tsTypeAnnotation(t2.tsLiteralType(t2.stringLiteral(route.id)))
+              ),
+              t2.tsPropertySignature(
+                t2.identifier("module"),
+                t2.tsTypeAnnotation(
+                  t2.tsTypeQuery(
+                    t2.tsImportType(
+                      t2.stringLiteral(
+                        relativeImportSource(
+                          rootDirsPath(ctx, filename2),
+                          Path3.resolve(ctx.config.appDirectory, route.file)
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            ])
+          )
+        );
+      })
+    )
+  );
+  const routeImportSource = relativeImportSource(
+    rootDirsPath(ctx, filename2),
+    Path3.resolve(ctx.config.appDirectory, file)
+  );
+  const content = import_dedent.default`
+      // Generated by React Router
+
+      import type { GetInfo, GetAnnotations } from "react-router/internal";
+
+      type Module = typeof import("${routeImportSource}")
+
+      type Info = GetInfo<{
+        file: "${file}",
+        module: Module
+      }>
+    ` + "\n\n" + generate(matchesType).code + "\n\n" + import_dedent.default`
+      type Annotations = GetAnnotations<Info & { module: Module, matches: Matches }>;
+
+      export namespace Route {
+        // links
+        export type LinkDescriptors = Annotations["LinkDescriptors"];
+        export type LinksFunction = Annotations["LinksFunction"];
+
+        // meta
+        export type MetaArgs = Annotations["MetaArgs"];
+        export type MetaDescriptors = Annotations["MetaDescriptors"];
+        export type MetaFunction = Annotations["MetaFunction"];
+
+        // headers
+        export type HeadersArgs = Annotations["HeadersArgs"];
+        export type HeadersFunction = Annotations["HeadersFunction"];
+
+        // unstable_middleware
+        export type unstable_MiddlewareFunction = Annotations["unstable_MiddlewareFunction"];
+
+        // unstable_clientMiddleware
+        export type unstable_ClientMiddlewareFunction = Annotations["unstable_ClientMiddlewareFunction"];
+
+        // loader
+        export type LoaderArgs = Annotations["LoaderArgs"];
+
+        // clientLoader
+        export type ClientLoaderArgs = Annotations["ClientLoaderArgs"];
+
+        // action
+        export type ActionArgs = Annotations["ActionArgs"];
+
+        // clientAction
+        export type ClientActionArgs = Annotations["ClientActionArgs"];
+
+        // HydrateFallback
+        export type HydrateFallbackProps = Annotations["HydrateFallbackProps"];
+
+        // Component
+        export type ComponentProps = Annotations["ComponentProps"];
+
+        // ErrorBoundary
+        export type ErrorBoundaryProps = Annotations["ErrorBoundaryProps"];
+      }
+    `;
+  return { filename: filename2, content };
+}
+function relativeImportSource(from, to) {
+  let path4 = Path3.relative(Path3.dirname(from), to);
+  let extension = Path3.extname(path4);
+  path4 = Path3.join(Path3.dirname(path4), Pathe.filename(path4));
+  if (!path4.startsWith("../")) path4 = "./" + path4;
+  if (!extension || /\.(js|ts)x?$/.test(extension)) {
+    extension = ".js";
+  }
+  return path4 + extension;
+}
+function rootDirsPath(ctx, typesPath) {
+  const rel = Path3.relative(typesDirectory(ctx), typesPath);
+  return Path3.join(ctx.rootDirectory, rel);
+}
+function paramsType(path4) {
+  const params = parse2(path4);
+  return t2.tsTypeLiteral(
+    Object.entries(params).map(([param, isRequired]) => {
+      const property = t2.tsPropertySignature(
+        t2.stringLiteral(param),
+        t2.tsTypeAnnotation(t2.tsStringKeyword())
+      );
+      property.optional = !isRequired;
+      return property;
+    })
+  );
+}
+function expand(fullpath2) {
+  function recurse(segments2, index) {
+    if (index === segments2.length) return [""];
+    const segment = segments2[index];
+    const isOptional = segment.endsWith("?");
+    const isDynamic = segment.startsWith(":");
+    const required = segment.replace(/\?$/, "");
+    const keep = !isOptional || isDynamic;
+    const kept = isDynamic ? segment : required;
+    const withoutSegment = recurse(segments2, index + 1);
+    const withSegment = withoutSegment.map((rest) => [kept, rest].join("/"));
+    if (keep) return withSegment;
+    return [...withoutSegment, ...withSegment];
+  }
+  const segments = fullpath2.split("/");
+  const expanded = /* @__PURE__ */ new Set();
+  for (let result of recurse(segments, 0)) {
+    if (result !== "/") result = result.replace(/\/$/, "");
+    expanded.add(result);
+  }
+  return expanded;
+}
+
+// typegen/index.ts
+async function clearRouteModuleAnnotations(ctx) {
+  await import_promises.default.rm(
+    Path4.join(typesDirectory(ctx), Path4.basename(ctx.config.appDirectory)),
+    { recursive: true, force: true }
+  );
+}
+async function write(...files) {
+  return Promise.all(
+    files.map(async ({ filename: filename2, content }) => {
+      await import_promises.default.mkdir(Path4.dirname(filename2), { recursive: true });
+      await import_promises.default.writeFile(filename2, content);
+    })
+  );
+}
+async function watch(rootDirectory, { mode, logger }) {
+  const ctx = await createContext2({ rootDirectory, mode, watch: true });
+  await import_promises.default.rm(typesDirectory(ctx), { recursive: true, force: true });
+  await write(
+    generateFuture(ctx),
+    generateServerBuild(ctx),
+    ...generateRoutes(ctx)
+  );
+  logger?.info((0, import_picocolors2.green)("generated types"), { timestamp: true, clear: true });
+  ctx.configLoader.onChange(
+    async ({ result, configChanged, routeConfigChanged }) => {
+      if (!result.ok) {
+        logger?.error((0, import_picocolors2.red)(result.error), { timestamp: true, clear: true });
+        return;
+      }
+      ctx.config = result.value;
+      if (configChanged) {
+        await write(generateFuture(ctx));
+        logger?.info((0, import_picocolors2.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+      if (routeConfigChanged) {
+        await clearRouteModuleAnnotations(ctx);
+        await write(...generateRoutes(ctx));
+        logger?.info((0, import_picocolors2.green)("regenerated types"), {
+          timestamp: true,
+          clear: true
+        });
+      }
+    }
+  );
+  return {
+    close: async () => await ctx.configLoader.close()
+  };
+}
+
+// vite/rsc/plugin.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// vite/rsc/virtual-route-config.ts
+var import_node_path = __toESM(require("path"));
+function createVirtualRouteConfigCode({
+  appDirectory,
+  routeConfig
+}) {
+  let code = "export default [";
+  const closeRouteSymbol = Symbol("CLOSE_ROUTE");
+  let stack = [
+    ...routeConfig
+  ];
+  while (stack.length > 0) {
+    const route = stack.pop();
+    if (!route) break;
+    if (route === closeRouteSymbol) {
+      code += "]},";
+      continue;
+    }
+    code += "{";
+    code += `lazy: () => import(${JSON.stringify(
+      `${import_node_path.default.resolve(appDirectory, route.file)}?route-module${route.id === "root" ? "&root-route=true" : ""}`
+    )}),`;
+    code += `id: ${JSON.stringify(
+      route.id || createRouteId2(route.file, appDirectory)
+    )},`;
+    if (typeof route.path === "string") {
+      code += `path: ${JSON.stringify(route.path)},`;
+    }
+    if (route.index) {
+      code += `index: true,`;
+    }
+    if (route.caseSensitive) {
+      code += `caseSensitive: true,`;
+    }
+    if (route.children) {
+      code += ["children:["];
+      stack.push(closeRouteSymbol);
+      stack.push(...[...route.children].reverse());
+    } else {
+      code += "},";
+    }
+  }
+  code += "];\n";
+  return code;
+}
+function createRouteId2(file, appDirectory) {
+  return import_node_path.default.relative(appDirectory, file).replace(/\\+/, "/").slice(0, -import_node_path.default.extname(file).length);
+}
+
+// vite/rsc/virtual-route-modules.ts
+var import_es_module_lexer = require("es-module-lexer");
+
+// vite/remove-exports.ts
+var import_babel_dead_code_elimination = require("babel-dead-code-elimination");
+var removeExports = (ast, exportsToRemove) => {
+  let previouslyReferencedIdentifiers = (0, import_babel_dead_code_elimination.findReferencedIdentifiers)(ast);
+  let exportsFiltered = false;
+  let markedForRemoval = /* @__PURE__ */ new Set();
+  let removedExportLocalNames = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    ExportDeclaration(path4) {
+      if (path4.node.type === "ExportNamedDeclaration") {
+        if (path4.node.specifiers.length) {
+          path4.node.specifiers = path4.node.specifiers.filter((specifier) => {
+            if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
+              if (exportsToRemove.includes(specifier.exported.name)) {
+                exportsFiltered = true;
+                if (specifier.local && specifier.local.name !== specifier.exported.name) {
+                  removedExportLocalNames.add(specifier.local.name);
+                }
+                return false;
+              }
+            }
+            return true;
+          });
+          if (path4.node.specifiers.length === 0) {
+            markedForRemoval.add(path4);
+          }
+        }
+        if (path4.node.declaration?.type === "VariableDeclaration") {
+          let declaration = path4.node.declaration;
+          declaration.declarations = declaration.declarations.filter(
+            (declaration2) => {
+              if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
+                exportsFiltered = true;
+                return false;
+              }
+              if (declaration2.id.type === "ArrayPattern" || declaration2.id.type === "ObjectPattern") {
+                validateDestructuredExports(declaration2.id, exportsToRemove);
+              }
+              return true;
+            }
+          );
+          if (declaration.declarations.length === 0) {
+            markedForRemoval.add(path4);
+          }
+        }
+        if (path4.node.declaration?.type === "FunctionDeclaration") {
+          let id = path4.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path4);
+          }
+        }
+        if (path4.node.declaration?.type === "ClassDeclaration") {
+          let id = path4.node.declaration.id;
+          if (id && exportsToRemove.includes(id.name)) {
+            markedForRemoval.add(path4);
+          }
+        }
+      }
+      if (path4.node.type === "ExportDefaultDeclaration") {
+        if (exportsToRemove.includes("default")) {
+          markedForRemoval.add(path4);
+          if (path4.node.declaration) {
+            if (path4.node.declaration.type === "Identifier") {
+              removedExportLocalNames.add(path4.node.declaration.name);
+            } else if ((path4.node.declaration.type === "FunctionDeclaration" || path4.node.declaration.type === "ClassDeclaration") && path4.node.declaration.id) {
+              removedExportLocalNames.add(path4.node.declaration.id.name);
+            }
+          }
+        }
+      }
+    }
+  });
+  traverse(ast, {
+    ExpressionStatement(path4) {
+      if (!path4.parentPath.isProgram()) {
+        return;
+      }
+      if (path4.node.expression.type === "AssignmentExpression") {
+        const left = path4.node.expression.left;
+        if (left.type === "MemberExpression" && left.object.type === "Identifier" && (exportsToRemove.includes(left.object.name) || removedExportLocalNames.has(left.object.name))) {
+          markedForRemoval.add(path4);
+        }
+      }
+    }
+  });
+  if (markedForRemoval.size > 0 || exportsFiltered) {
+    for (let path4 of markedForRemoval) {
+      path4.remove();
+    }
+    (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
+  }
+};
+function validateDestructuredExports(id, exportsToRemove) {
+  if (id.type === "ArrayPattern") {
+    for (let element of id.elements) {
+      if (!element) {
+        continue;
+      }
+      if (element.type === "Identifier" && exportsToRemove.includes(element.name)) {
+        throw invalidDestructureError(element.name);
+      }
+      if (element.type === "RestElement" && element.argument.type === "Identifier" && exportsToRemove.includes(element.argument.name)) {
+        throw invalidDestructureError(element.argument.name);
+      }
+      if (element.type === "ArrayPattern" || element.type === "ObjectPattern") {
+        validateDestructuredExports(element, exportsToRemove);
+      }
+    }
+  }
+  if (id.type === "ObjectPattern") {
+    for (let property of id.properties) {
+      if (!property) {
+        continue;
+      }
+      if (property.type === "ObjectProperty" && property.key.type === "Identifier") {
+        if (property.value.type === "Identifier" && exportsToRemove.includes(property.value.name)) {
+          throw invalidDestructureError(property.value.name);
+        }
+        if (property.value.type === "ArrayPattern" || property.value.type === "ObjectPattern") {
+          validateDestructuredExports(property.value, exportsToRemove);
+        }
+      }
+      if (property.type === "RestElement" && property.argument.type === "Identifier" && exportsToRemove.includes(property.argument.name)) {
+        throw invalidDestructureError(property.argument.name);
+      }
+    }
+  }
+}
+function invalidDestructureError(name) {
+  return new Error(`Cannot remove destructured export "${name}"`);
+}
+
+// vite/rsc/virtual-route-modules.ts
+var SERVER_ONLY_ROUTE_EXPORTS = [
+  "loader",
+  "action",
+  "unstable_middleware",
+  "headers",
+  "ServerComponent"
+];
+var COMPONENT_EXPORTS = [
+  "default",
+  "ErrorBoundary",
+  "HydrateFallback",
+  "Layout"
+];
+var CLIENT_NON_COMPONENT_EXPORTS = [
+  "clientAction",
+  "clientLoader",
+  "unstable_clientMiddleware",
+  "handle",
+  "meta",
+  "links",
+  "shouldRevalidate"
+];
+var CLIENT_NON_COMPONENT_EXPORTS_SET = new Set(CLIENT_NON_COMPONENT_EXPORTS);
+function isClientNonComponentExport(name) {
+  return CLIENT_NON_COMPONENT_EXPORTS_SET.has(name);
+}
+var CLIENT_ROUTE_EXPORTS = [
+  ...CLIENT_NON_COMPONENT_EXPORTS,
+  ...COMPONENT_EXPORTS
+];
+var CLIENT_ROUTE_EXPORTS_SET = new Set(CLIENT_ROUTE_EXPORTS);
+function isClientRouteExport(name) {
+  return CLIENT_ROUTE_EXPORTS_SET.has(name);
+}
+function transformVirtualRouteModules({
+  id,
+  code
+}) {
+  if (!id.includes("route-module")) {
+    return;
+  }
+  if (isVirtualRouteModuleId(id)) {
+    return createVirtualRouteModuleCode({ id, code });
+  }
+  if (isVirtualServerRouteModuleId(id)) {
+    return createVirtualServerRouteModuleCode({ id, code });
+  }
+  if (isVirtualClientRouteModuleId(id)) {
+    return createVirtualClientRouteModuleCode({ id, code });
+  }
+}
+async function createVirtualRouteModuleCode({
+  id,
+  code: routeSource
+}) {
+  const { staticExports, isServerFirstRoute } = parseRouteExports(routeSource);
+  const clientModuleId = getVirtualClientModuleId(id);
+  const serverModuleId = getVirtualServerModuleId(id);
+  let code = "";
+  if (isServerFirstRoute) {
+    for (const staticExport of staticExports) {
+      if (isClientNonComponentExport(staticExport)) {
+        code += `export { ${staticExport} } from "${clientModuleId}";
+`;
+      } else if (staticExport === "ServerComponent") {
+        code += `export { ServerComponent as default } from "${serverModuleId}";
+`;
+      } else {
+        code += `export { ${staticExport} } from "${serverModuleId}";
+`;
+      }
+    }
+  } else {
+    for (const staticExport of staticExports) {
+      if (isClientRouteExport(staticExport)) {
+        code += `export { ${staticExport} } from "${clientModuleId}";
+`;
+      } else {
+        code += `export { ${staticExport} } from "${serverModuleId}";
+`;
+      }
+    }
+  }
+  if (isRootRouteId(id) && !staticExports.includes("ErrorBoundary")) {
+    code += `export { ErrorBoundary } from "${clientModuleId}";
+`;
+  }
+  return code;
+}
+function createVirtualServerRouteModuleCode({
+  id,
+  code: routeSource
+}) {
+  const { staticExports, isServerFirstRoute } = parseRouteExports(routeSource);
+  const clientModuleId = getVirtualClientModuleId(id);
+  const serverRouteModuleAst = import_parser.parse(routeSource, {
+    sourceType: "module"
+  });
+  removeExports(
+    serverRouteModuleAst,
+    isServerFirstRoute ? CLIENT_NON_COMPONENT_EXPORTS : CLIENT_ROUTE_EXPORTS
+  );
+  const generatorResult = generate(serverRouteModuleAst);
+  if (!isServerFirstRoute) {
+    for (const staticExport of staticExports) {
+      if (isClientRouteExport(staticExport)) {
+        generatorResult.code += "\n";
+        generatorResult.code += `export { ${staticExport} } from "${clientModuleId}";
+`;
+      }
+    }
+  }
+  return generatorResult;
+}
+function createVirtualClientRouteModuleCode({
+  id,
+  code: routeSource
+}) {
+  const { staticExports, isServerFirstRoute } = parseRouteExports(routeSource);
+  const exportsToRemove = isServerFirstRoute ? [...SERVER_ONLY_ROUTE_EXPORTS, ...COMPONENT_EXPORTS] : SERVER_ONLY_ROUTE_EXPORTS;
+  const clientRouteModuleAst = import_parser.parse(routeSource, {
+    sourceType: "module"
+  });
+  removeExports(clientRouteModuleAst, exportsToRemove);
+  const generatorResult = generate(clientRouteModuleAst);
+  generatorResult.code = '"use client";' + generatorResult.code;
+  if (isRootRouteId(id) && !staticExports.includes("ErrorBoundary")) {
+    const hasRootLayout = staticExports.includes("Layout");
+    generatorResult.code += `
+import { createElement as __rr_createElement } from "react";
+`;
+    generatorResult.code += `import { UNSAFE_RSCDefaultRootErrorBoundary } from "react-router";
+`;
+    generatorResult.code += `export function ErrorBoundary() {
+`;
+    generatorResult.code += `  return __rr_createElement(UNSAFE_RSCDefaultRootErrorBoundary, { hasRootLayout: ${hasRootLayout} });
+`;
+    generatorResult.code += `}
+`;
+  }
+  return generatorResult;
+}
+function parseRouteExports(code) {
+  const [, exportSpecifiers] = (0, import_es_module_lexer.parse)(code);
+  const staticExports = exportSpecifiers.map(({ n: name }) => name);
+  return {
+    staticExports,
+    isServerFirstRoute: staticExports.some(
+      (staticExport) => staticExport === "ServerComponent"
+    )
+  };
+}
+function getVirtualClientModuleId(id) {
+  return `${id.split("?")[0]}?client-route-module${isRootRouteId(id) ? "&root-route=true" : ""}`;
+}
+function getVirtualServerModuleId(id) {
+  return `${id.split("?")[0]}?server-route-module${isRootRouteId(id) ? "&root-route=true" : ""}`;
+}
+function isRootRouteId(id) {
+  return /(\?|&)root-route=true(&|$)/.test(id);
+}
+function isVirtualRouteModuleId(id) {
+  return /(\?|&)route-module(&|$)/.test(id);
+}
+function isVirtualClientRouteModuleId(id) {
+  return /(\?|&)client-route-module(&|$)/.test(id);
+}
+function isVirtualServerRouteModuleId(id) {
+  return /(\?|&)server-route-module(&|$)/.test(id);
+}
+
+// vite/rsc/plugin.ts
+function reactRouterRSCVitePlugin() {
+  let configLoader;
+  let config;
+  let typegenWatcherPromise;
+  return [
+    {
+      name: "react-router/rsc/config",
+      async config(viteUserConfig, { command, mode }) {
+        await import_es_module_lexer2.init;
+        const rootDirectory = getRootDirectory(viteUserConfig);
+        const watch2 = command === "serve";
+        configLoader = await createConfigLoader({ rootDirectory, mode, watch: watch2 });
+        const configResult = await configLoader.getConfig();
+        if (!configResult.ok) throw new Error(configResult.error);
+        config = configResult.value;
+        return {
+          environments: {
+            client: { build: { outDir: "build/client" } },
+            rsc: { build: { outDir: "build/server" } },
+            ssr: { build: { outDir: "build/server/__ssr_build" } }
+          }
+        };
+      },
+      async buildEnd() {
+        await configLoader.close();
+      }
+    },
+    {
+      name: "react-router/rsc/typegen",
+      async config(viteUserConfig, { command, mode }) {
+        if (command === "serve") {
+          const vite2 = await import("vite");
+          typegenWatcherPromise = watch(
+            getRootDirectory(viteUserConfig),
+            {
+              mode,
+              // ignore `info` logs from typegen since they are
+              // redundant when Vite plugin logs are active
+              logger: vite2.createLogger("warn", {
+                prefix: "[react-router]"
+              })
+            }
+          );
+        }
+      },
+      async buildEnd() {
+        (await typegenWatcherPromise)?.close();
+      }
+    },
+    {
+      name: "react-router/rsc/virtual-route-config",
+      resolveId(id) {
+        if (id === virtual.routeConfig.id) {
+          return virtual.routeConfig.resolvedId;
+        }
+      },
+      load(id) {
+        if (id === virtual.routeConfig.resolvedId) {
+          return createVirtualRouteConfigCode({
+            appDirectory: config.appDirectory,
+            routeConfig: config.unstable_routeConfig
+          });
+        }
+      }
+    },
+    {
+      name: "react-router/rsc/virtual-route-modules",
+      transform(code, id) {
+        return transformVirtualRouteModules({ code, id });
+      }
+    },
+    (0, import_plugin_react.default)(),
+    (0, import_plugin_rsc.default)({ entries: getRscEntries() })
+  ];
+}
+var virtual = {
+  routeConfig: create("unstable_rsc/routes")
+};
+function getRootDirectory(viteUserConfig) {
+  return viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
+}
+function getRscEntries() {
+  const entriesDir = (0, import_path.join)(
+    getDevPackageRoot(),
+    "dist",
+    "config",
+    "default-rsc-entries"
+  );
+  return {
+    client: (0, import_path.join)(entriesDir, "entry.client.tsx"),
+    rsc: (0, import_path.join)(entriesDir, "entry.rsc.tsx"),
+    ssr: (0, import_path.join)(entriesDir, "entry.ssr.tsx")
+  };
+}
+function getDevPackageRoot() {
+  const currentDir = (0, import_path.dirname)(__dirname);
+  let dir = currentDir;
+  while (dir !== (0, import_path.dirname)(dir)) {
+    try {
+      const packageJsonPath = (0, import_path.join)(dir, "package.json");
+      (0, import_fs.readFileSync)(packageJsonPath, "utf-8");
+      return dir;
+    } catch {
+      dir = (0, import_path.dirname)(dir);
+    }
+  }
+  throw new Error("Could not find package.json");
+}
+
+// internal.ts
+var __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__ = {
+  unstable_reactRouterRSC: reactRouterRSCVitePlugin
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __INTERNAL_DO_NOT_USE_OR_YOU_WILL_GET_A_STRONGLY_WORDED_LETTER__
+});