@react-router/dev 0.0.0-experimental-567b27f71 → 0.0.0-experimental-58b44aa83

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v0.0.0-experimental-567b27f71
+ * @react-router/dev v0.0.0-experimental-58b44aa83
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -111,6 +111,14 @@ function getVite() {
   invariant(vite, "getVite() called before preloadVite()");
   return vite;
 }
+function defineCompilerOptions(options) {
+  let vite2 = getVite();
+  return parseInt(vite2.version.split(".")[0], 10) >= 8 ? { oxc: options.oxc } : { esbuild: options.esbuild };
+}
+function defineOptimizeDepsCompilerOptions(options) {
+  let vite2 = getVite();
+  return parseInt(vite2.version.split(".")[0], 10) >= 8 ? { rolldownOptions: options.rolldown } : { esbuildOptions: options.esbuild };
+}
 
 // vite/ssr-externals.ts
 var ssrExternals = isReactRouterRepo() ? [
@@ -566,7 +574,7 @@ async function resolveConfig({
     unstable_previewServerPrerendering: userAndPresetConfigs.future?.unstable_previewServerPrerendering ?? false,
     v8_middleware: userAndPresetConfigs.future?.v8_middleware ?? false,
     v8_splitRouteModules: userAndPresetConfigs.future?.v8_splitRouteModules ?? false,
-    v8_viteEnvironmentApi: userAndPresetConfigs.future?.v8_viteEnvironmentApi ?? false
+    v8_viteEnvironmentApi: (userAndPresetConfigs.future?.v8_viteEnvironmentApi || userAndPresetConfigs.future?.unstable_previewServerPrerendering) ?? false
   };
   let allowedActionOrigins = userAndPresetConfigs.allowedActionOrigins ?? false;
   let reactRouterConfig = deepFreeze({
@@ -642,13 +650,11 @@ async function createConfigLoader({
       if (!fsWatcher) {
         fsWatcher = import_chokidar.default.watch([root, appDirectory], {
           ignoreInitial: true,
-          ignored: (path10) => {
-            let dirname4 = import_pathe3.default.dirname(path10);
-            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
-            path10 !== root && // Watch the root directory itself
-            dirname4 !== root;
-          }
+          ignored: (path10) => isIgnoredByWatcher(path10, { root, appDirectory })
+        });
+        fsWatcher.on("error", (error) => {
+          let message = error instanceof Error ? error.message : String(error);
+          console.warn(import_picocolors.default.yellow(`File watcher error: ${message}`));
         });
         fsWatcher.on("all", async (...args) => {
           let [event, rawFilepath] = args;
@@ -857,6 +863,25 @@ function isEntryFileDependency(moduleGraph, entryFilepath, filepath, visited = /
   }
   return false;
 }
+function isIgnoredByWatcher(path10, { root, appDirectory }) {
+  let dirname4 = import_pathe3.default.dirname(path10);
+  let ignoredByPath = !dirname4.startsWith(appDirectory) && // Ensure we're only watching files outside of the app directory
+  // that are at the root level, not nested in subdirectories
+  path10 !== root && // Watch the root directory itself
+  dirname4 !== root;
+  if (ignoredByPath) {
+    return true;
+  }
+  try {
+    let stat = import_node_fs.default.statSync(path10, { throwIfNoEntry: false });
+    if (stat && !stat.isFile() && !stat.isDirectory()) {
+      return true;
+    }
+  } catch {
+    return true;
+  }
+  return false;
+}
 
 // typegen/context.ts
 async function createContext2({
@@ -1176,7 +1201,7 @@ function getRouteAnnotations({
         module: Module
       }>
     ` + "\n\n" + generate(matchesType).code + "\n\n" + import_dedent.default`
-      type Annotations = GetAnnotations<Info & { module: Module, matches: Matches }, ${ctx.rsc}>;
+      type Annotations = GetAnnotations<Info & { module: Module, matches: Matches }>;
 
       export namespace Route {
         // links
@@ -1213,11 +1238,20 @@ function getRouteAnnotations({
         // HydrateFallback
         export type HydrateFallbackProps = Annotations["HydrateFallbackProps"];
 
+        // ServerHydrateFallback
+        export type ServerHydrateFallbackProps = Annotations["ServerHydrateFallbackProps"];
+
         // Component
         export type ComponentProps = Annotations["ComponentProps"];
 
+        // ServerComponent
+        export type ServerComponentProps = Annotations["ServerComponentProps"];
+
         // ErrorBoundary
         export type ErrorBoundaryProps = Annotations["ErrorBoundaryProps"];
+
+        // ServerErrorBoundary
+        export type ServerErrorBoundaryProps = Annotations["ServerErrorBoundaryProps"];
       }
     `;
   return { filename: filename2, content };
@@ -2509,140 +2543,144 @@ function prerender(options) {
   let viteConfig;
   return {
     name: "prerender",
-    configResolved(resolvedConfig) {
-      viteConfig = resolvedConfig;
-    },
-    writeBundle: {
-      async handler() {
-        const pluginContext = this;
-        const rawRequests = typeof requests === "function" ? await requests.call(pluginContext) : requests;
-        const prerenderRequests = rawRequests.map(normalizePrerenderRequest);
-        if (prerenderRequests.length === 0) {
-          return;
-        }
-        const prerenderConfig = typeof config === "function" ? await config.call(pluginContext) : config;
-        const {
-          buildDirectory = viteConfig.environments.client.build.outDir,
-          concurrency = 1,
-          retryCount = 0,
-          retryDelay = 500,
-          maxRedirects = 0,
-          timeout = 1e4
-        } = prerenderConfig ?? {};
-        const previewServer = await startPreviewServer(viteConfig);
-        try {
-          const baseUrl = getResolvedUrl(previewServer);
-          async function prerenderRequest(input, metadata) {
-            let attemptCount = 0;
-            let redirectCount = 0;
-            const request = new Request(input);
-            const url2 = new URL(request.url);
-            if (url2.origin !== baseUrl.origin) {
-              url2.hostname = baseUrl.hostname;
-              url2.protocol = baseUrl.protocol;
-              url2.port = baseUrl.port;
-            }
-            async function attempt(url3) {
+    sharedDuringBuild: true,
+    config: {
+      order: "post",
+      handler({ builder: { buildApp } = {} }) {
+        return {
+          builder: {
+            async buildApp(builder) {
+              await buildApp?.(builder);
+              const rawRequests = typeof requests === "function" ? await requests() : requests;
+              const prerenderRequests = rawRequests.map(
+                normalizePrerenderRequest
+              );
+              if (prerenderRequests.length === 0) {
+                return;
+              }
+              const prerenderConfig = typeof config === "function" ? await config() : config;
+              const {
+                buildDirectory = viteConfig.environments.client.build.outDir,
+                concurrency = 1,
+                retryCount = 0,
+                retryDelay = 500,
+                maxRedirects = 0,
+                timeout = 1e4
+              } = prerenderConfig ?? {};
+              let ogIsBuildRequest = process.env.IS_RR_BUILD_REQUEST;
+              process.env.IS_RR_BUILD_REQUEST = "yes";
               try {
-                const signal = AbortSignal.timeout(timeout);
-                const prerenderReq = new Request(url3, request);
-                const response = await fetch(prerenderReq, {
-                  redirect: "manual",
-                  signal
-                });
-                if (response.status >= 300 && response.status < 400 && response.headers.has("location") && ++redirectCount <= maxRedirects) {
-                  const location = response.headers.get("location");
-                  const responseURL = new URL(response.url);
-                  const locationUrl = new URL(location, response.url);
-                  if (responseURL.origin !== locationUrl.origin) {
-                    return await postProcess.call(
-                      pluginContext,
-                      request,
-                      response,
-                      metadata
+                const previewServer = await startPreviewServer(viteConfig);
+                try {
+                  const baseUrl = getResolvedUrl(previewServer);
+                  async function prerenderRequest(input, metadata) {
+                    let attemptCount = 0;
+                    let redirectCount = 0;
+                    const request = new Request(input);
+                    const url2 = new URL(request.url);
+                    if (url2.origin !== baseUrl.origin) {
+                      url2.hostname = baseUrl.hostname;
+                      url2.protocol = baseUrl.protocol;
+                      url2.port = baseUrl.port;
+                    }
+                    async function attempt(url3) {
+                      try {
+                        const signal = AbortSignal.timeout(timeout);
+                        const prerenderReq = new Request(url3, request);
+                        const response = await fetch(prerenderReq, {
+                          redirect: "manual",
+                          signal
+                        });
+                        if (response.status >= 300 && response.status < 400 && response.headers.has("location") && ++redirectCount <= maxRedirects) {
+                          const location = response.headers.get("location");
+                          const responseURL = new URL(response.url);
+                          const locationUrl = new URL(location, response.url);
+                          if (responseURL.origin !== locationUrl.origin) {
+                            return await postProcess(
+                              request,
+                              response,
+                              metadata
+                            );
+                          }
+                          const redirectUrl = new URL(location, url3);
+                          return await attempt(redirectUrl);
+                        }
+                        if (response.status >= 500 && ++attemptCount <= retryCount) {
+                          await new Promise(
+                            (resolve6) => setTimeout(resolve6, retryDelay)
+                          );
+                          return attempt(url3);
+                        }
+                        return await postProcess(request, response, metadata);
+                      } catch (error) {
+                        if (++attemptCount <= retryCount) {
+                          await new Promise(
+                            (resolve6) => setTimeout(resolve6, retryDelay)
+                          );
+                          return attempt(url3);
+                        }
+                        handleError(
+                          request,
+                          error instanceof Error ? error : new Error(error?.toString() ?? "Unknown error"),
+                          metadata
+                        );
+                        return [];
+                      }
+                    }
+                    return attempt(url2);
+                  }
+                  async function prerender2(input, metadata) {
+                    const result = await prerenderRequest(input, metadata);
+                    const { files, requests: requests2 } = normalizePostProcessResult(result);
+                    for (const file of files) {
+                      await writePrerenderFile(file, metadata);
+                    }
+                    for (const followUp of requests2) {
+                      const normalized = normalizePrerenderRequest(followUp);
+                      await prerender2(normalized.request, normalized.metadata);
+                    }
+                  }
+                  async function writePrerenderFile(file, metadata) {
+                    const normalizedPath = file.path.startsWith("/") ? file.path.slice(1) : file.path;
+                    const outputPath = import_node_path.default.join(
+                      buildDirectory,
+                      ...normalizedPath.split("/")
                     );
+                    await (0, import_promises2.mkdir)(import_node_path.default.dirname(outputPath), { recursive: true });
+                    await (0, import_promises2.writeFile)(outputPath, file.contents);
+                    const relativePath = import_node_path.default.relative(
+                      viteConfig.root,
+                      outputPath
+                    );
+                    if (logFile) {
+                      logFile(relativePath, metadata);
+                    }
+                    return relativePath;
                   }
-                  const redirectUrl = new URL(location, url3);
-                  return await attempt(redirectUrl);
-                }
-                if (response.status >= 500 && ++attemptCount <= retryCount) {
-                  await new Promise(
-                    (resolve6) => setTimeout(resolve6, retryDelay)
-                  );
-                  return attempt(url3);
-                }
-                return await postProcess.call(
-                  pluginContext,
-                  request,
-                  response,
-                  metadata
-                );
-              } catch (error) {
-                if (++attemptCount <= retryCount) {
-                  await new Promise(
-                    (resolve6) => setTimeout(resolve6, retryDelay)
+                  const pMap = await import("p-map");
+                  await pMap.default(
+                    prerenderRequests,
+                    async ({ request, metadata }) => {
+                      await prerender2(request, metadata);
+                    },
+                    { concurrency }
                   );
-                  return attempt(url3);
+                  if (finalize) {
+                    await finalize(buildDirectory);
+                  }
+                } finally {
+                  await previewServer.close();
                 }
-                handleError.call(
-                  pluginContext,
-                  request,
-                  error instanceof Error ? error : new Error(error?.toString() ?? "Unknown error"),
-                  metadata
-                );
-                return [];
+              } finally {
+                process.env.IS_RR_BUILD_REQUEST = ogIsBuildRequest;
               }
             }
-            return attempt(url2);
           }
-          async function prerender2(input, metadata) {
-            const result = await prerenderRequest(input, metadata);
-            const { files, requests: requests2 } = normalizePostProcessResult(result);
-            for (const file of files) {
-              await writePrerenderFile(file, metadata);
-            }
-            for (const followUp of requests2) {
-              const normalized = normalizePrerenderRequest(followUp);
-              await prerender2(normalized.request, normalized.metadata);
-            }
-          }
-          async function writePrerenderFile(file, metadata) {
-            const normalizedPath = file.path.startsWith("/") ? file.path.slice(1) : file.path;
-            const outputPath = import_node_path.default.join(
-              buildDirectory,
-              ...normalizedPath.split("/")
-            );
-            await (0, import_promises2.mkdir)(import_node_path.default.dirname(outputPath), { recursive: true });
-            await (0, import_promises2.writeFile)(outputPath, file.contents);
-            const relativePath = import_node_path.default.relative(viteConfig.root, outputPath);
-            if (logFile) {
-              logFile.call(pluginContext, relativePath, metadata);
-            }
-            return relativePath;
-          }
-          const pMap = await import("p-map");
-          await pMap.default(
-            prerenderRequests,
-            async ({ request, metadata }) => {
-              await prerender2(request, metadata);
-            },
-            { concurrency }
-          );
-          if (finalize) {
-            await finalize.call(pluginContext, buildDirectory);
-          }
-        } finally {
-          await new Promise((resolve6, reject) => {
-            previewServer.httpServer.close((err2) => {
-              if (err2) {
-                reject(err2);
-              } else {
-                resolve6();
-              }
-            });
-          });
-        }
+        };
       }
+    },
+    configResolved(resolvedConfig) {
+      viteConfig = resolvedConfig;
     }
   };
 }
@@ -3025,7 +3063,7 @@ var reactRouterVitePlugin = () => {
   let viteChildCompiler = null;
   let cache = /* @__PURE__ */ new Map();
   let reactRouterConfigLoader;
-  let typegenWatcherPromise;
+  let typegenWatcherPromise2;
   let logger;
   let firstLoad = true;
   let ctx;
@@ -3449,7 +3487,7 @@ var reactRouterVitePlugin = () => {
         rootDirectory = viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
         let mode = viteConfigEnv.mode;
         if (viteCommand === "serve") {
-          typegenWatcherPromise = watch(rootDirectory, {
+          typegenWatcherPromise2 = watch(rootDirectory, {
             mode,
             rsc: false,
             // ignore `info` logs from typegen since they are redundant when Vite plugin logs are active
@@ -3509,10 +3547,18 @@ var reactRouterVitePlugin = () => {
               }) ? ["react-router-dom"] : []
             ]
           },
-          esbuild: {
-            jsx: "automatic",
-            jsxDev: viteCommand !== "build"
-          },
+          ...defineCompilerOptions({
+            oxc: {
+              jsx: {
+                runtime: "automatic",
+                development: viteCommand !== "build"
+              }
+            },
+            esbuild: {
+              jsx: "automatic",
+              jsxDev: viteCommand !== "build"
+            }
+          }),
           resolve: {
             dedupe: [
               // https://react.dev/warnings/invalid-hook-call-warning#duplicate-react
@@ -3772,32 +3818,51 @@ var reactRouterVitePlugin = () => {
         let cachedHandler = null;
         async function getHandler() {
           if (cachedHandler) return cachedHandler;
-          let serverBuildFiles = [];
+          let bundledHandlers = [];
           let buildManifest = ctx.buildManifest ?? (ctx.reactRouterConfig.serverBundles ? await getBuildManifest({
             reactRouterConfig: ctx.reactRouterConfig,
             rootDirectory: ctx.rootDirectory
           }) : null);
           if (buildManifest?.serverBundles) {
+            let routesByServerBundleId = getRoutesByServerBundleId(buildManifest);
             for (let bundle of Object.values(buildManifest.serverBundles)) {
-              serverBuildFiles.push(
-                path7.resolve(ctx.rootDirectory, bundle.file)
-              );
+              let build = await import(url.pathToFileURL(path7.resolve(ctx.rootDirectory, bundle.file)).href);
+              bundledHandlers.push({
+                handler: (0, import_react_router2.createRequestHandler)(build, "production"),
+                routes: createPrerenderRoutes(
+                  routesByServerBundleId[bundle.id] ?? {}
+                )
+              });
             }
           } else {
             let serverEntryPath = path7.resolve(
               getServerBuildDirectory(ctx.reactRouterConfig),
               "index.js"
             );
-            serverBuildFiles.push(serverEntryPath);
-          }
-          let handlers = [];
-          for (let file of serverBuildFiles) {
-            let build = await import(url.pathToFileURL(file).href);
-            handlers.push((0, import_react_router2.createRequestHandler)(build, "production"));
+            let build = await import(url.pathToFileURL(serverEntryPath).href);
+            bundledHandlers.push({
+              handler: (0, import_react_router2.createRequestHandler)(build, "production"),
+              routes: null
+            });
           }
           cachedHandler = async (request, loadContext) => {
             let response;
-            for (let handler of handlers) {
+            let handlersToTry = bundledHandlers;
+            if (buildManifest?.serverBundles) {
+              let pathname = new URL(request.url).pathname;
+              handlersToTry = bundledHandlers.map((entry, index) => ({
+                entry,
+                index,
+                matchDepth: (0, import_react_router2.matchRoutes)(
+                  entry.routes ?? [],
+                  pathname,
+                  ctx.reactRouterConfig.basename
+                )?.length ?? -1
+              })).sort(
+                (a, b) => b.matchDepth - a.matchDepth || a.index - b.index
+              ).map(({ entry }) => entry);
+            }
+            for (let { handler } of handlersToTry) {
               response = await handler(request, loadContext);
               if (response.status !== 404) {
                 return response;
@@ -3806,7 +3871,10 @@ var reactRouterVitePlugin = () => {
             if (response) {
               return response;
             }
-            throw new Error("No handlers were found for the request.");
+            let url2 = new URL(request.url);
+            throw new Error(
+              "No handlers were found for the request: " + url2.pathname + url2.search
+            );
           };
           return cachedHandler;
         }
@@ -3960,7 +4028,7 @@ var reactRouterVitePlugin = () => {
       async buildEnd() {
         await viteChildCompiler?.close();
         await reactRouterConfigLoader.close();
-        let typegenWatcher = await typegenWatcherPromise;
+        let typegenWatcher = await typegenWatcherPromise2;
         await typegenWatcher?.close();
       }
     },
@@ -4391,9 +4459,6 @@ var reactRouterVitePlugin = () => {
       async requests() {
         invariant(viteConfig);
         let { future } = ctx.reactRouterConfig;
-        if (future.v8_viteEnvironmentApi ? this.environment.name === "client" : !viteConfigEnv.isSsrBuild) {
-          return [];
-        }
         if (!future.unstable_previewServerPrerendering) {
           return [];
         }
@@ -4524,15 +4589,17 @@ ${new TextDecoder().decode(contents)}`
         if (redirectStatusCodes.has(response.status)) {
           let location = response.headers.get("Location");
           let delay = response.status === 302 ? 2 : 0;
+          let escapedLocation = escapeHtml(location ?? "");
+          let escapedPathname = escapeHtml(pathname);
           html = `<!doctype html>
 <head>
-<title>Redirecting to: ${location}</title>
-<meta http-equiv="refresh" content="${delay};url=${location}">
+<title>Redirecting to: ${escapedLocation}</title>
+<meta http-equiv="refresh" content="${delay};url=${escapedLocation}">
 <meta name="robots" content="noindex">
 </head>
 <body>
-	<a href="${location}">
-    Redirecting from <code>${pathname}</code> to <code>${location}</code>
+	<a href="${escapedLocation}">
+    Redirecting from <code>${escapedPathname}</code> to <code>${escapedLocation}</code>
   </a>
 </body>
 </html>`;
@@ -4584,7 +4651,9 @@ ${html}`
               );
             }
           }
-          let serverBuildDirectory = future.v8_viteEnvironmentApi ? this.environment.config?.build?.outDir : ctx.environmentBuildContext?.options.build?.outDir ?? getServerBuildDirectory(ctx.reactRouterConfig);
+          let serverBuildDirectory = getServerBuildDirectory(
+            ctx.reactRouterConfig
+          );
           viteConfig.logger.info(
             [
               "Removing the server build in",
@@ -4941,15 +5010,17 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
   if (redirectStatusCodes.has(response.status)) {
     let location = response.headers.get("Location");
     let delay = response.status === 302 ? 2 : 0;
+    let escapedLocation = escapeHtml(location ?? "");
+    let escapedNormalizedPath = escapeHtml(normalizedPath);
     html = `<!doctype html>
 <head>
-<title>Redirecting to: ${location}</title>
-<meta http-equiv="refresh" content="${delay};url=${location}">
+<title>Redirecting to: ${escapedLocation}</title>
+<meta http-equiv="refresh" content="${delay};url=${escapedLocation}">
 <meta name="robots" content="noindex">
 </head>
 <body>
-	<a href="${location}">
-    Redirecting from <code>${normalizedPath}</code> to <code>${location}</code>
+	<a href="${escapedLocation}">
+    Redirecting from <code>${escapedNormalizedPath}</code> to <code>${escapedLocation}</code>
   </a>
 </body>
 </html>`;
@@ -5591,23 +5662,113 @@ function createSpaModeRequest(reactRouterConfig) {
     metadata: { type: "spa", path: "/" }
   };
 }
+var ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+var ESCAPE_LOOKUP = {
+  "&": "\\u0026",
+  ">": "\\u003e",
+  "<": "\\u003c",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
+};
+function escapeHtml(html) {
+  return html.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+}
 
 // vite/rsc/plugin.ts
 var import_es_module_lexer3 = require("es-module-lexer");
 var Path5 = __toESM(require("pathe"));
-var babel2 = __toESM(require("@babel/core"));
 var import_picocolors5 = __toESM(require("picocolors"));
+var import_fs = require("fs");
 var import_promises4 = require("fs/promises");
 var import_pathe6 = __toESM(require("pathe"));
 
 // vite/rsc/virtual-route-config.ts
 var import_pathe5 = __toESM(require("pathe"));
+var js = String.raw;
 function createVirtualRouteConfig({
   appDirectory,
   routeConfig
 }) {
   let routeIdByFile = /* @__PURE__ */ new Map();
-  let code = "export default [";
+  let code = js`import * as React from "react";
+function frameworkRoute(lazy) {
+  return async () => {
+    const mod = await lazy();
+    let Component;
+    let Layout;
+    let ErrorBoundary;
+    let HydrateFallback;
+    if ("default" in mod && mod.default) {
+      if ("ServerComponent" in mod && mod.ServerComponent) {
+        throw new Error("Module cannot have both a default export and a ServerComponent export");
+      }
+      Component = mod.default;
+    } else if ("ServerComponent" in mod && mod.ServerComponent) {
+      Component = mod.ServerComponent;
+    }
+    if ("Layout" in mod && mod.Layout) {
+      if ("ServerLayout" in mod && mod.ServerLayout) {
+        throw new Error("Module cannot have both a Layout export and a ServerLayout export");
+      }
+      Layout = mod.Layout;
+    } else if ("ServerLayout" in mod && mod.ServerLayout) {
+      Layout = mod.ServerLayout;
+    }
+    if ("ErrorBoundary" in mod && mod.ErrorBoundary) {
+      if ("ServerErrorBoundary" in mod && mod.ServerErrorBoundary) {
+        throw new Error(
+          "Module cannot have both an ErrorBoundary export and a ServerErrorBoundary export",
+        );
+      }
+      ErrorBoundary = mod.ErrorBoundary;
+    } else if ("ServerErrorBoundary" in mod && mod.ServerErrorBoundary) {
+      ErrorBoundary = mod.ServerErrorBoundary;
+    }
+    if ("HydrateFallback" in mod && mod.HydrateFallback) {
+      if ("ServerHydrateFallback" in mod && mod.ServerHydrateFallback) {
+        throw new Error(
+          "Module cannot have both a HydrateFallback export and a ServerHydrateFallback export",
+        );
+      }
+      HydrateFallback = mod.HydrateFallback;
+    } else if ("ServerHydrateFallback" in mod && mod.ServerHydrateFallback) {
+      HydrateFallback = mod.ServerHydrateFallback;
+    }
+
+    const {
+      action,
+      clientAction,
+      clientLoader,
+      clientMiddleware,
+      handle,
+      headers,
+      links,
+      loader,
+      meta,
+      middleware,
+      shouldRevalidate,
+    } = mod;
+
+    return {
+      Component,
+      ErrorBoundary,
+      HydrateFallback,
+      Layout,
+      action,
+      clientAction,
+      clientLoader,
+      clientMiddleware,
+      handle,
+      headers,
+      links,
+      loader,
+      meta,
+      middleware,
+      shouldRevalidate,
+    };
+  };
+}
+export default [`;
   const closeRouteSymbol = Symbol("CLOSE_ROUTE");
   let stack = [
     ...routeConfig
@@ -5623,9 +5784,9 @@ function createVirtualRouteConfig({
     const routeFile = import_pathe5.default.resolve(appDirectory, route.file);
     const routeId = route.id || createRouteId2(route.file, appDirectory);
     routeIdByFile.set(routeFile, routeId);
-    code += `lazy: () => import(${JSON.stringify(
-      `${routeFile}?route-module`
-    )}),`;
+    code += `lazy: frameworkRoute(() => import(${JSON.stringify(
+      `${routeFile}`
+    )})),`;
     code += `id: ${JSON.stringify(routeId)},`;
     if (typeof route.path === "string") {
       code += `path: ${JSON.stringify(route.path)},`;
@@ -5653,289 +5814,323 @@ function createRouteId2(file, appDirectory) {
 
 // vite/rsc/virtual-route-modules.ts
 var import_es_module_lexer2 = require("es-module-lexer");
-var SERVER_ONLY_COMPONENT_EXPORTS = ["ServerComponent"];
-var SERVER_ONLY_ROUTE_EXPORTS2 = [
-  ...SERVER_ONLY_COMPONENT_EXPORTS,
-  "loader",
-  "action",
-  "middleware",
-  "headers"
-];
-var SERVER_ONLY_ROUTE_EXPORTS_SET = new Set(SERVER_ONLY_ROUTE_EXPORTS2);
-function isServerOnlyRouteExport(name) {
-  return SERVER_ONLY_ROUTE_EXPORTS_SET.has(name);
-}
-var COMMON_COMPONENT_EXPORTS = [
-  "ErrorBoundary",
-  "HydrateFallback",
-  "Layout"
-];
-var SERVER_FIRST_COMPONENT_EXPORTS = [
-  ...COMMON_COMPONENT_EXPORTS,
-  ...SERVER_ONLY_COMPONENT_EXPORTS
-];
-var SERVER_FIRST_COMPONENT_EXPORTS_SET = new Set(
-  SERVER_FIRST_COMPONENT_EXPORTS
-);
-function isServerFirstComponentExport(name) {
-  return SERVER_FIRST_COMPONENT_EXPORTS_SET.has(
-    name
-  );
-}
-var CLIENT_COMPONENT_EXPORTS = [
-  ...COMMON_COMPONENT_EXPORTS,
-  "default"
-];
-var CLIENT_NON_COMPONENT_EXPORTS2 = [
-  "clientAction",
-  "clientLoader",
-  "clientMiddleware",
-  "handle",
-  "meta",
-  "links",
-  "shouldRevalidate"
-];
-var CLIENT_NON_COMPONENT_EXPORTS_SET = new Set(CLIENT_NON_COMPONENT_EXPORTS2);
-function isClientNonComponentExport(name) {
-  return CLIENT_NON_COMPONENT_EXPORTS_SET.has(name);
-}
-var CLIENT_ROUTE_EXPORTS2 = [
-  ...CLIENT_NON_COMPONENT_EXPORTS2,
-  ...CLIENT_COMPONENT_EXPORTS
-];
-var CLIENT_ROUTE_EXPORTS_SET = new Set(CLIENT_ROUTE_EXPORTS2);
-function isClientRouteExport(name) {
-  return CLIENT_ROUTE_EXPORTS_SET.has(name);
-}
-var ROUTE_EXPORTS = [
-  ...SERVER_ONLY_ROUTE_EXPORTS2,
-  ...CLIENT_ROUTE_EXPORTS2
-];
-var ROUTE_EXPORTS_SET = new Set(ROUTE_EXPORTS);
-function isRouteExport(name) {
-  return ROUTE_EXPORTS_SET.has(name);
-}
-function isCustomRouteExport(name) {
-  return !isRouteExport(name);
-}
-function hasReactServerCondition(viteEnvironment) {
-  return viteEnvironment.config.resolve.conditions.includes("react-server");
-}
-function transformVirtualRouteModules({
-  id,
-  code,
-  viteCommand,
-  routeIdByFile,
-  rootRouteFile,
-  viteEnvironment
-}) {
-  if (isVirtualRouteModuleId(id) || routeIdByFile.has(id)) {
-    return createVirtualRouteModuleCode({
-      id,
-      code,
-      rootRouteFile,
-      viteCommand,
-      viteEnvironment
-    });
-  }
-  if (isVirtualServerRouteModuleId(id)) {
-    return createVirtualServerRouteModuleCode({
-      id,
-      code,
-      viteEnvironment
-    });
-  }
-  if (isVirtualClientRouteModuleId(id)) {
-    return createVirtualClientRouteModuleCode({
-      id,
-      code,
-      rootRouteFile,
-      viteCommand
-    });
-  }
-}
-async function createVirtualRouteModuleCode({
-  id,
-  code: routeSource,
-  rootRouteFile,
-  viteCommand,
-  viteEnvironment
+var ENSURE_CLIENT_ROUTE_MODULE_CHUNK_FOR_HMR = `
+import * as ___EnsureClientRouteModuleForHMR_REACT___ from "react";
+export function EnsureClientRouteModuleForHMR___() { return ___EnsureClientRouteModuleForHMR_REACT___.createElement(___EnsureClientRouteModuleForHMR_REACT___.Fragment, null) }
+`;
+function virtualRouteModulesPlugin({
+  environments: { client = ["client", "ssr"], server = ["rsc"] } = {},
+  isRouteModule,
+  isRootRouteModule,
+  transformToJs
 }) {
-  const isReactServer = hasReactServerCondition(viteEnvironment);
-  const { staticExports, isServerFirstRoute, hasClientExports } = parseRouteExports(routeSource);
-  const clientModuleId = getVirtualClientModuleId(id);
-  const serverModuleId = getVirtualServerModuleId(id);
-  let code = "";
-  if (isServerFirstRoute) {
-    if (staticExports.some(isServerFirstComponentExport)) {
-      code += `import React from "react";
+  let clientEnvironments = new Set(client);
+  let serverEnvironments = new Set(server);
+  let cache = /* @__PURE__ */ new Map();
+  async function createClientRouteEntry(id, code) {
+    let result = "";
+    let routeChunks = detectRouteChunks2(cache, id, code);
+    let { staticExports } = await parseRouteExports(code);
+    validateRouteModuleExports(staticExports);
+    let needsReactImport = false;
+    for (let exportName of staticExports) {
+      if (isServerRouteExport(exportName)) {
+        continue;
+      }
+      if ((exportName === "clientAction" || exportName === "clientLoader") && routeChunks.hasRouteChunkByExportName[exportName]) {
+        result += `export const ${exportName} = async (...args) => import("${createId(id, "client-route-module", exportName)}").then(mod => mod.${exportName}(...args));
+`;
+      } else if (exportName === "HydrateFallback") {
+        needsReactImport = true;
+        result += `export const ${exportName} = React.lazy(() => import("${createId(
+          id,
+          "client-route-module",
+          routeChunks.hasRouteChunkByExportName[exportName] ? exportName : "shared"
+        )}").then(mod => ({ default: mod.${exportName} })));
+`;
+      } else {
+        result += `export { ${exportName} } from "${createId(
+          id,
+          "client-route-module",
+          routeChunks.hasRouteChunkByExportName[exportName] ? exportName : "shared"
+        )}";
 `;
+      }
     }
-    for (const staticExport of staticExports) {
-      if (isClientNonComponentExport(staticExport)) {
-        code += `export { ${staticExport} } from "${clientModuleId}";
+    if (needsReactImport) {
+      result = `import * as React from "react";
+${result}`;
+    }
+    return {
+      code: '"use client";\n' + result
+    };
+  }
+  async function createServerRouteEntry(id, code, isRootRouteModule2) {
+    let result = "";
+    let routeChunks = detectRouteChunks2(cache, id, code);
+    let { staticExports } = await parseRouteExports(code);
+    validateRouteModuleExports(staticExports);
+    let needsReactImport = false;
+    for (let exportName of staticExports) {
+      if (isClientRouteExport(exportName)) {
+        result += `export { ${exportName} } from "${createId(
+          id,
+          "client-route-module",
+          routeChunks.hasRouteChunkByExportName[exportName] ? exportName : "shared"
+        )}";
 `;
-      } else if (isReactServer && isServerFirstComponentExport(staticExport) && // Layout wraps all other component exports so doesn't need CSS injected
-      staticExport !== "Layout") {
-        code += `import { ${staticExport} as ${staticExport}WithoutCss } from "${serverModuleId}";
+      } else if (isServerComponentExport(exportName)) {
+        needsReactImport = true;
+        result += `import { ${exportName} as ${exportName}WithoutCss } from "${createId(id, "server-route-module")}";
 `;
-        code += `export ${staticExport === "ServerComponent" ? "default " : " "}function ${staticExport}(props) {
+        result += `export function ${exportName}(props) {
 `;
-        code += `  return React.createElement(React.Fragment, null,
+        result += `  return React.createElement(React.Fragment, null,
 `;
-        code += `    import.meta.viteRsc.loadCss(),
+        result += `    import.meta.viteRsc.loadCss(),
 `;
-        code += `    React.createElement(${staticExport}WithoutCss, props),
+        result += `    React.createElement(EnsureClientRouteModuleForHMR___, null),
 `;
-        code += `  );
+        result += `    React.createElement(${exportName}WithoutCss, props),
 `;
-        code += `}
+        result += `  );
 `;
-      } else if (isReactServer && isRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${serverModuleId}";
+        result += `}
 `;
-      } else if (isCustomRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${isReactServer ? serverModuleId : clientModuleId}";
+      } else {
+        result += `export { ${exportName} } from "${createId(id, "server-route-module")}";
 `;
       }
     }
-    if (viteCommand === "serve" && !hasClientExports) {
-      code += `export { __ensureClientRouteModuleForHMR } from "${clientModuleId}";
-`;
+    if (needsReactImport) {
+      result = `import * as React from "react";
+import { EnsureClientRouteModuleForHMR___ } from "${createId(id, "client-route-module", "shared")}";
+
+${result}`;
     }
-  } else {
-    for (const staticExport of staticExports) {
-      if (isClientRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${clientModuleId}";
-`;
-      } else if (isReactServer && isServerOnlyRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${serverModuleId}";
+    if (isRootRouteModule2 && !staticExports.includes("ErrorBoundary") && !staticExports.includes("ServerErrorBoundary")) {
+      result += `export { ErrorBoundary } from "${createId(id, "client-route-module", "shared")}";
 `;
-      } else if (isCustomRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${isReactServer ? serverModuleId : clientModuleId}";
-`;
-      }
     }
+    return {
+      code: result
+    };
   }
-  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary")) {
-    code += `export { ErrorBoundary } from "${clientModuleId}";
-`;
-  }
-  return code;
-}
-function createVirtualServerRouteModuleCode({
-  id,
-  code: routeSource,
-  viteEnvironment
-}) {
-  if (!hasReactServerCondition(viteEnvironment)) {
-    throw new Error(
-      [
-        "Virtual server route module was loaded outside of the RSC environment.",
-        `Environment Name: ${viteEnvironment.name}`,
-        `Module ID: ${id}`
-      ].join("\n")
-    );
+  function createServerRouteModule(code) {
+    const ast = import_parser.parse(code, {
+      sourceType: "module"
+    });
+    removeExports(ast, CLIENT_ROUTE_EXPORTS2);
+    return generate(ast);
   }
-  const { staticExports, isServerFirstRoute } = parseRouteExports(routeSource);
-  const clientModuleId = getVirtualClientModuleId(id);
-  const serverRouteModuleAst = import_parser.parse(routeSource, {
-    sourceType: "module"
-  });
-  removeExports(
-    serverRouteModuleAst,
-    isServerFirstRoute ? CLIENT_NON_COMPONENT_EXPORTS2 : CLIENT_ROUTE_EXPORTS2
-  );
-  const generatorResult = generate(serverRouteModuleAst);
-  if (!isServerFirstRoute) {
-    for (const staticExport of staticExports) {
-      if (isClientRouteExport(staticExport)) {
-        generatorResult.code += "\n";
-        generatorResult.code += `export { ${staticExport} } from "${clientModuleId}";
-`;
-      }
+  async function createClientRouteModuleChunk(id, code, chunk, isRootRouteModule2) {
+    let routeChunks = detectRouteChunks2(cache, id, code);
+    const ast = import_parser.parse(code, {
+      sourceType: "module"
+    });
+    const { staticExports } = await parseRouteExports(code);
+    if (chunk === "shared") {
+      removeExports(ast, [
+        ...SERVER_ROUTE_EXPORTS,
+        ...routeChunks.chunkedExports
+      ]);
+    } else {
+      const toRemove = /* @__PURE__ */ new Set([...SERVER_ROUTE_EXPORTS, ...staticExports]);
+      toRemove.delete(chunk);
+      removeExports(ast, Array.from(toRemove));
     }
-  }
-  return generatorResult;
-}
-function createVirtualClientRouteModuleCode({
-  id,
-  code: routeSource,
-  rootRouteFile,
-  viteCommand
-}) {
-  const { staticExports, isServerFirstRoute, hasClientExports } = parseRouteExports(routeSource);
-  const exportsToRemove = isServerFirstRoute ? [...SERVER_ONLY_ROUTE_EXPORTS2, ...CLIENT_COMPONENT_EXPORTS] : SERVER_ONLY_ROUTE_EXPORTS2;
-  const clientRouteModuleAst = import_parser.parse(routeSource, {
-    sourceType: "module"
-  });
-  removeExports(clientRouteModuleAst, exportsToRemove);
-  const generatorResult = generate(clientRouteModuleAst);
-  generatorResult.code = '"use client";' + generatorResult.code;
-  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary")) {
-    const hasRootLayout = staticExports.includes("Layout");
-    generatorResult.code += `
+    const generated = generate(ast);
+    let result = '"use client";\n' + generated.code;
+    if (chunk === "shared") {
+      if (isRootRouteModule2 && !staticExports.includes("ErrorBoundary") && !staticExports.includes("ServerErrorBoundary")) {
+        const hasRootLayout = staticExports.includes("Layout") || staticExports.includes("ServerLayout");
+        result += `
 import { createElement as __rr_createElement } from "react";
 `;
-    generatorResult.code += `import { UNSAFE_RSCDefaultRootErrorBoundary } from "react-router";
+        result += `import { UNSAFE_RSCDefaultRootErrorBoundary } from "react-router";
 `;
-    generatorResult.code += `export function ErrorBoundary() {
+        result += `export function ErrorBoundary() {
 `;
-    generatorResult.code += `  return __rr_createElement(UNSAFE_RSCDefaultRootErrorBoundary, { hasRootLayout: ${hasRootLayout} });
+        result += `  return __rr_createElement(UNSAFE_RSCDefaultRootErrorBoundary, { hasRootLayout: ${hasRootLayout} });
 `;
-    generatorResult.code += `}
+        result += `}
 `;
+      }
+      result += ENSURE_CLIENT_ROUTE_MODULE_CHUNK_FOR_HMR;
+    }
+    result += `
+if (import.meta.hot) {
+`;
+    result += `  import.meta.hot.accept((mod) => {
+      if (!mod.default) {
+        __reactRouterDataRouter.revalidate();
+      }
+    });
+`;
+    result += `}
+`;
+    return {
+      code: result
+    };
   }
-  if (viteCommand === "serve" && isServerFirstRoute && !hasClientExports) {
-    generatorResult.code += `
-export const __ensureClientRouteModuleForHMR = true;`;
-  }
-  return generatorResult;
+  return {
+    name: "react-router-rsc-virtual-route-modules",
+    transform: {
+      order: "pre",
+      async handler(_code, id) {
+        const [filename2, ...rest] = id.split("?");
+        if (!isRouteModule(filename2)) {
+          return;
+        }
+        let isClientEnvironment = clientEnvironments.has(this.environment.name);
+        let isServerEnvironment = serverEnvironments.has(this.environment.name);
+        if (!isClientEnvironment && !isServerEnvironment) {
+          return;
+        }
+        let code = await transformToJs(_code, filename2);
+        let searchParams = rest.length > 0 ? new URLSearchParams(rest.join("?")) : null;
+        let clientRouteModuleType = searchParams?.get("client-route-module");
+        let isServerRouteModule = searchParams?.has("server-route-module");
+        if (clientRouteModuleType) {
+          return await createClientRouteModuleChunk(
+            id,
+            code,
+            clientRouteModuleType,
+            isRootRouteModule(filename2)
+          );
+        }
+        if (isServerRouteModule) {
+          return createServerRouteModule(code);
+        }
+        if (isClientEnvironment) {
+          return await createClientRouteEntry(id, code);
+        }
+        return await createServerRouteEntry(
+          id,
+          code,
+          isRootRouteModule(filename2)
+        );
+      }
+    }
+  };
 }
-function parseRouteExports(code) {
+function createId(id, type, value) {
+  let [base, ...rest] = id.split("?");
+  const searchParams = new URLSearchParams(rest.join("?"));
+  searchParams.delete("client-route-module");
+  searchParams.delete("server-route-module");
+  searchParams.set(type, value || "");
+  return `${base}?${searchParams.toString()}`;
+}
+async function parseRouteExports(code) {
+  await import_es_module_lexer2.init;
   const [, exportSpecifiers] = (0, import_es_module_lexer2.parse)(code);
   const staticExports = exportSpecifiers.map(({ n: name }) => name);
-  const isServerFirstRoute = staticExports.some(
-    (staticExport) => staticExport === "ServerComponent"
-  );
   return {
     staticExports,
-    isServerFirstRoute,
-    hasClientExports: staticExports.some(
-      isServerFirstRoute ? isClientNonComponentExport : isClientRouteExport
-    )
+    hasClientExports: staticExports.some(isClientRouteExport)
   };
 }
-function getVirtualClientModuleId(id) {
-  return `${id.split("?")[0]}?client-route-module`;
-}
-function getVirtualServerModuleId(id) {
-  return `${id.split("?")[0]}?server-route-module`;
+var CLIENT_NON_COMPONENT_EXPORTS2 = [
+  "clientAction",
+  "clientLoader",
+  "clientMiddleware",
+  "handle",
+  "meta",
+  "links",
+  "shouldRevalidate"
+];
+var CLIENT_ROUTE_EXPORTS2 = [
+  ...CLIENT_NON_COMPONENT_EXPORTS2,
+  "default",
+  "ErrorBoundary",
+  "HydrateFallback",
+  "Layout"
+];
+var CLIENT_ROUTE_EXPORTS_SET = new Set(CLIENT_ROUTE_EXPORTS2);
+function isClientRouteExport(name) {
+  return CLIENT_ROUTE_EXPORTS_SET.has(name);
 }
-function isVirtualRouteModuleId(id) {
-  return /(\?|&)route-module(&|$)/.test(id);
+var SERVER_COMPONENT_EXPORTS = [
+  "ServerComponent",
+  "ServerLayout",
+  "ServerHydrateFallback",
+  "ServerErrorBoundary"
+];
+var SERVER_COMPONENT_EXPORTS_SET = new Set(SERVER_COMPONENT_EXPORTS);
+function isServerComponentExport(name) {
+  return SERVER_COMPONENT_EXPORTS_SET.has(name);
 }
-function isVirtualClientRouteModuleId(id) {
-  return /(\?|&)client-route-module(&|$)/.test(id);
+var SERVER_ROUTE_EXPORTS = [
+  ...SERVER_COMPONENT_EXPORTS,
+  "loader",
+  "action",
+  "middleware",
+  "headers"
+];
+var SERVER_ROUTE_EXPORTS_SET = new Set(SERVER_ROUTE_EXPORTS);
+function isServerRouteExport(name) {
+  return SERVER_ROUTE_EXPORTS_SET.has(name);
 }
-function isVirtualServerRouteModuleId(id) {
-  return /(\?|&)server-route-module(&|$)/.test(id);
+var CLIENT_MODULE_CHUNKS = /* @__PURE__ */ new Set([
+  "clientAction",
+  "clientLoader",
+  "clientMiddleware",
+  "HydrateFallback"
+]);
+var MUTUALLY_EXCLUSIVE_ROUTE_EXPORTS = /* @__PURE__ */ new Map([
+  ["ErrorBoundary", "ServerErrorBoundary"],
+  ["HydrateFallback", "ServerHydrateFallback"],
+  ["Layout", "ServerLayout"],
+  ["default", "ServerComponent"]
+]);
+function validateRouteModuleExports(toValidate) {
+  let errors = [];
+  for (let [clientExport, serverExport] of MUTUALLY_EXCLUSIVE_ROUTE_EXPORTS) {
+    if (toValidate.includes(clientExport) && toValidate.includes(serverExport)) {
+      errors.push([clientExport, serverExport]);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `Invalid route module exports. The following pairs of exports are mutually exclusive and cannot be exported from the same module:
+` + errors.map(
+        ([clientExport, serverExport]) => `- ${clientExport} and ${serverExport}`
+      ).join("\n")
+    );
+  }
 }
-function isRootRouteFile({
-  id,
-  rootRouteFile
-}) {
-  const filePath = id.split("?")[0];
-  return filePath === rootRouteFile;
+function detectRouteChunks2(cache, id, code) {
+  function noRouteChunks() {
+    return {
+      chunkedExports: [],
+      hasRouteChunks: false,
+      hasRouteChunkByExportName: {
+        clientAction: false,
+        clientLoader: false,
+        clientMiddleware: false,
+        HydrateFallback: false
+      }
+    };
+  }
+  if (!Array.from(CLIENT_MODULE_CHUNKS).some(
+    (exportName) => code.includes(exportName)
+  )) {
+    return noRouteChunks();
+  }
+  let [filename2] = id.split("?");
+  return detectRouteChunks(code, cache, filename2);
 }
 
 // vite/rsc/plugin.ts
+var redirectStatusCodes2 = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var configLoaderPromise;
+var typegenWatcherPromise;
 function reactRouterRSCVitePlugin() {
   let runningWithinTheReactRouterMonoRepo = Boolean(
     arguments && arguments.length === 1 && typeof arguments[0] === "object" && arguments[0] && "__runningWithinTheReactRouterMonoRepo" in arguments[0] && arguments[0].__runningWithinTheReactRouterMonoRepo === true
   );
   let configLoader;
-  let typegenWatcherPromise;
   let viteCommand;
   let resolvedViteConfig;
   let routeIdByFile;
@@ -5950,6 +6145,25 @@ function reactRouterRSCVitePlugin() {
       newConfig.routes.root.file
     );
   }
+  function isRouteModule(id) {
+    if (routeIdByFile?.has(id)) {
+      return true;
+    }
+    return false;
+  }
+  function isRootRouteModule(id) {
+    return import_pathe6.default.normalize(id) === import_pathe6.default.normalize(rootRouteFile);
+  }
+  async function transformToJs(code, filename2) {
+    await preloadVite();
+    let vite2 = getVite();
+    return (await vite2.transformWithEsbuild(code, filename2, {
+      target: "esnext",
+      format: "esm",
+      jsx: "automatic",
+      jsxDev: viteCommand !== "build"
+    })).code;
+  }
   return [
     {
       name: "react-router/rsc",
@@ -5958,24 +6172,21 @@ function reactRouterRSCVitePlugin() {
         await preloadVite();
         viteCommand = command;
         const rootDirectory = getRootDirectory(viteUserConfig);
-        const watch2 = command === "serve";
+        const watch2 = command === "serve" && process.env.IS_RR_BUILD_REQUEST !== "yes";
         await loadDotenv({
           rootDirectory,
           viteUserConfig,
           mode
         });
-        configLoader = await createConfigLoader({
+        configLoaderPromise ??= createConfigLoader({
           rootDirectory,
           mode,
           watch: watch2,
           validateConfig: (userConfig) => {
             let errors = [];
             if (userConfig.buildEnd) errors.push("buildEnd");
-            if (userConfig.prerender) errors.push("prerender");
             if (userConfig.presets?.length) errors.push("presets");
-            if (userConfig.routeDiscovery) errors.push("routeDiscovery");
             if (userConfig.serverBundles) errors.push("serverBundles");
-            if (userConfig.ssr === false) errors.push("ssr: false");
             if (userConfig.future?.v8_middleware === false)
               errors.push("future.v8_middleware: false");
             if (userConfig.future?.v8_splitRouteModules)
@@ -5991,6 +6202,7 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
             }
           }
         });
+        configLoader = await configLoaderPromise;
         const configResult = await configLoader.getConfig();
         if (!configResult.ok) throw new Error(configResult.error);
         updateConfig(configResult.value);
@@ -6033,9 +6245,16 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
               entryClientFilePath: entries.client,
               reactRouterConfig: config
             }),
-            esbuildOptions: {
-              jsx: "automatic"
-            },
+            ...defineOptimizeDepsCompilerOptions({
+              rolldown: {
+                transform: {
+                  jsx: "react-jsx"
+                }
+              },
+              esbuild: {
+                jsx: "automatic"
+              }
+            }),
             include: [
               // Pre-bundle React dependencies to avoid React duplicates,
               // even if React dependencies are not direct dependencies.
@@ -6057,10 +6276,18 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
               "react-router > set-cookie-parser"
             ]
           },
-          esbuild: {
-            jsx: "automatic",
-            jsxDev: viteCommand !== "build"
-          },
+          ...defineCompilerOptions({
+            oxc: {
+              jsx: {
+                runtime: "automatic",
+                development: viteCommand !== "build"
+              }
+            },
+            esbuild: {
+              jsx: "automatic",
+              jsxDev: viteCommand !== "build"
+            }
+          }),
           environments: {
             client: {
               build: {
@@ -6126,27 +6353,6 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
                 ]
               }
             }
-          },
-          build: {
-            rollupOptions: {
-              // Copied from https://github.com/vitejs/vite-plugin-react/blob/c602225271d4acf462ba00f8d6d8a2e42492c5cd/packages/common/warning.ts
-              onwarn(warning, defaultHandler) {
-                if (warning.code === "MODULE_LEVEL_DIRECTIVE" && (warning.message.includes("use client") || warning.message.includes("use server"))) {
-                  return;
-                }
-                if (warning.code === "SOURCEMAP_ERROR" && warning.message.includes("resolve original location") && warning.pos === 0) {
-                  return;
-                }
-                if (viteUserConfig.build?.rollupOptions?.onwarn) {
-                  viteUserConfig.build.rollupOptions.onwarn(
-                    warning,
-                    defaultHandler
-                  );
-                } else {
-                  defaultHandler(warning);
-                }
-              }
-            }
           }
         };
       },
@@ -6182,6 +6388,50 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
           }
         );
       },
+      configurePreviewServer(previewServer) {
+        const clientBuildDirectory = getClientBuildDirectory2(config);
+        if ((config.prerender || config.ssr === false) && process.env.IS_RR_BUILD_REQUEST !== "yes") {
+          previewServer.middlewares.use(async (req, res, next) => {
+            try {
+              const htmlFileBase = ((req.url || "/") + (req.url?.endsWith("/") ? "" : "/") + "index.html").slice(1);
+              const htmlFilePath = import_pathe6.default.join(
+                clientBuildDirectory,
+                htmlFileBase
+              );
+              if ((0, import_fs.existsSync)(htmlFilePath)) {
+                res.setHeader("Content-Type", "text/html");
+                res.end(await (0, import_promises4.readFile)(htmlFilePath, "utf-8"));
+                return;
+              }
+              next();
+            } catch (error) {
+              next(error);
+            }
+          });
+          return () => {
+            if (config.ssr === false) {
+              previewServer.middlewares.use(async (req, res, next) => {
+                try {
+                  res.statusCode = 404;
+                  const url2 = new URL(req.url || "/", `http://localhost`);
+                  const htmlFilePath = import_pathe6.default.join(
+                    clientBuildDirectory,
+                    url2.pathname.endsWith(".rsc") ? "__spa-fallback.rsc" : "__spa-fallback.html"
+                  );
+                  if ((0, import_fs.existsSync)(htmlFilePath)) {
+                    res.setHeader("Content-Type", "text/html");
+                    res.end(await (0, import_promises4.readFile)(htmlFilePath, "utf-8"));
+                    return;
+                  }
+                  res.end();
+                } catch (error) {
+                  next(error);
+                }
+              });
+            }
+          };
+        }
+      },
       async buildEnd() {
         await configLoader.close();
       }
@@ -6204,12 +6454,12 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
         configureServer: logExperimentalNotice
       };
     })(),
-    {
+    process.env.IS_RR_BUILD_REQUEST !== "yes" ? {
       name: "react-router/rsc/typegen",
       async config(viteUserConfig, { command, mode }) {
         if (command === "serve") {
           const vite2 = await import("vite");
-          typegenWatcherPromise = watch(
+          typegenWatcherPromise ??= watch(
             getRootDirectory(viteUserConfig),
             {
               mode,
@@ -6226,7 +6476,7 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
       async buildEnd() {
         (await typegenWatcherPromise)?.close();
       }
-    },
+    } : null,
     {
       name: "react-router/rsc/virtual-route-config",
       resolveId(id) {
@@ -6245,20 +6495,15 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
         }
       }
     },
-    {
-      name: "react-router/rsc/virtual-route-modules",
-      transform(code, id) {
-        if (!routeIdByFile) return;
-        return transformVirtualRouteModules({
-          code,
-          id,
-          viteCommand,
-          routeIdByFile,
-          rootRouteFile,
-          viteEnvironment: this.environment
-        });
-      }
-    },
+    virtualRouteModulesPlugin({
+      environments: {
+        client: ["client", "ssr"],
+        server: ["rsc"]
+      },
+      isRouteModule,
+      isRootRouteModule,
+      transformToJs
+    }),
     {
       name: "react-router/rsc/virtual-basename",
       resolveId(id) {
@@ -6272,6 +6517,23 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
         }
       }
     },
+    {
+      name: "react-router/rsc/virtual-route-discovery",
+      resolveId(id) {
+        if (id === virtual2.routeDiscovery.id) {
+          return virtual2.routeDiscovery.resolvedId;
+        }
+      },
+      load(id) {
+        if (id === virtual2.routeDiscovery.resolvedId) {
+          return `export default ${JSON.stringify(
+            config.ssr === false ? {
+              mode: "initial"
+            } : config.routeDiscovery ?? { mode: "lazy" }
+          )};`;
+        }
+      }
+    },
     {
       name: "react-router/rsc/hmr/inject-runtime",
       enforce: "pre",
@@ -6283,121 +6545,129 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
       async load(id) {
         if (id !== virtual2.injectHmrRuntime.resolvedId) return;
         return viteCommand === "serve" ? [
-          `import RefreshRuntime from "${virtual2.hmrRuntime.id}"`,
-          "RefreshRuntime.injectIntoGlobalHook(window)",
-          "window.$RefreshReg$ = () => {}",
-          "window.$RefreshSig$ = () => (type) => type",
-          "window.__vite_plugin_react_preamble_installed__ = true"
+          `if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.on('rsc:update', () => {
+    __reactRouterDataRouter.revalidate()
+  })
+}`
         ].join("\n") : "";
       }
     },
-    {
-      name: "react-router/rsc/hmr/runtime",
-      enforce: "pre",
-      resolveId(id) {
-        if (id === virtual2.hmrRuntime.id) return virtual2.hmrRuntime.resolvedId;
-      },
-      async load(id) {
-        if (id !== virtual2.hmrRuntime.resolvedId) return;
-        const reactRefreshDir = import_pathe6.default.dirname(
-          require.resolve("react-refresh/package.json")
-        );
-        const reactRefreshRuntimePath = (0, import_pathe6.join)(
-          reactRefreshDir,
-          "cjs/react-refresh-runtime.development.js"
-        );
-        return [
-          "const exports = {}",
-          await (0, import_promises4.readFile)(reactRefreshRuntimePath, "utf8"),
-          await (0, import_promises4.readFile)(
-            require.resolve("./static/rsc-refresh-utils.mjs"),
-            "utf8"
-          ),
-          "export default exports"
-        ].join("\n");
-      }
-    },
-    {
-      name: "react-router/rsc/hmr/react-refresh",
-      async transform(code, id, options) {
-        if (viteCommand !== "serve") return;
-        if (id.includes("/node_modules/")) return;
-        const filepath = id.split("?")[0];
-        const extensionsRE = /\.(jsx?|tsx?|mdx?)$/;
-        if (!extensionsRE.test(filepath)) return;
-        const devRuntime = "react/jsx-dev-runtime";
-        const ssr = options?.ssr === true;
-        const isJSX = filepath.endsWith("x");
-        const useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
-        if (!useFastRefresh) return;
-        if (isVirtualClientRouteModuleId(id)) {
-          const routeId = routeIdByFile?.get(filepath);
-          return { code: addRefreshWrapper2({ routeId, code, id }) };
-        }
-        const result = await babel2.transformAsync(code, {
-          babelrc: false,
-          configFile: false,
-          filename: id,
-          sourceFileName: filepath,
-          parserOpts: {
-            sourceType: "module",
-            allowAwaitOutsideFunction: true
-          },
-          plugins: [[require("react-refresh/babel"), { skipEnvCheck: true }]],
-          sourceMaps: true
-        });
-        if (result === null) return;
-        code = result.code;
-        const refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
-        if (refreshContentRE.test(code)) {
-          code = addRefreshWrapper2({ code, id });
-        }
-        return { code, map: result.map };
-      }
-    },
-    {
-      name: "react-router/rsc/hmr/updates",
-      async hotUpdate({ server, file, modules }) {
-        if (this.environment.name !== "rsc") return;
-        const clientModules = server.environments.client.moduleGraph.getModulesByFile(file);
-        const vite2 = await import("vite");
-        const isServerOnlyChange = !clientModules || clientModules.size === 0 || // Handle CSS injected from server-first routes (with ?direct query
-        // string) since the client graph has a reference to the CSS
-        vite2.isCSSRequest(file) && Array.from(clientModules).some(
-          (mod) => mod.id?.includes("?direct")
-        );
-        for (const mod of getModulesWithImporters(modules)) {
-          if (!mod.file) continue;
-          const normalizedPath = import_pathe6.default.normalize(mod.file);
-          const routeId = routeIdByFile?.get(normalizedPath);
-          if (routeId !== void 0) {
-            const routeSource = await (0, import_promises4.readFile)(normalizedPath, "utf8");
-            const virtualRouteModuleCode = (await server.environments.rsc.pluginContainer.transform(
-              routeSource,
-              `${normalizedPath}?route-module`
-            )).code;
-            const { staticExports } = parseRouteExports(virtualRouteModuleCode);
-            const hasAction = staticExports.includes("action");
-            const hasComponent = staticExports.includes("default");
-            const hasErrorBoundary = staticExports.includes("ErrorBoundary");
-            const hasLoader = staticExports.includes("loader");
-            server.hot.send({
-              type: "custom",
-              event: "react-router:hmr",
-              data: {
-                routeId,
-                isServerOnlyChange,
-                hasAction,
-                hasComponent,
-                hasErrorBoundary,
-                hasLoader
-              }
-            });
-          }
-        }
-        return modules;
-      }
-    },
+    // {
+    //   name: "react-router/rsc/hmr/runtime",
+    //   enforce: "pre",
+    //   resolveId(id) {
+    //     if (id === virtual.hmrRuntime.id) return virtual.hmrRuntime.resolvedId;
+    //   },
+    //   async load(id) {
+    //     if (id !== virtual.hmrRuntime.resolvedId) return;
+    //     const reactRefreshDir = path.dirname(
+    //       require.resolve("react-refresh/package.json"),
+    //     );
+    //     const reactRefreshRuntimePath = join(
+    //       reactRefreshDir,
+    //       "cjs/react-refresh-runtime.development.js",
+    //     );
+    //     return [
+    //       "const exports = {}",
+    //       await readFile(reactRefreshRuntimePath, "utf8"),
+    //       await readFile(
+    //         require.resolve("./static/rsc-refresh-utils.mjs"),
+    //         "utf8",
+    //       ),
+    //       "export default exports",
+    //     ].join("\n");
+    //   },
+    // },
+    // {
+    //   name: "react-router/rsc/hmr/react-refresh",
+    //   async transform(code, id, options) {
+    //     if (viteCommand !== "serve") return;
+    //     if (id.includes("/node_modules/")) return;
+    //     const filepath = id.split("?")[0];
+    //     const extensionsRE = /\.(jsx?|tsx?|mdx?)$/;
+    //     if (!extensionsRE.test(filepath)) return;
+    //     const devRuntime = "react/jsx-dev-runtime";
+    //     const ssr = options?.ssr === true;
+    //     const isJSX = filepath.endsWith("x");
+    //     const useFastRefresh = !ssr && (isJSX || code.includes(devRuntime));
+    //     if (!useFastRefresh) return;
+    //     // if (isVirtualClientRouteModuleId(id)) {
+    //     //   const routeId = routeIdByFile?.get(filepath);
+    //     //   return { code: addRefreshWrapper({ routeId, code, id }) };
+    //     // }
+    //     const result = await babel.transformAsync(code, {
+    //       babelrc: false,
+    //       configFile: false,
+    //       filename: id,
+    //       sourceFileName: filepath,
+    //       parserOpts: {
+    //         sourceType: "module",
+    //         allowAwaitOutsideFunction: true,
+    //       },
+    //       plugins: [[require("react-refresh/babel"), { skipEnvCheck: true }]],
+    //       sourceMaps: true,
+    //     });
+    //     if (result === null) return;
+    //     code = result.code!;
+    //     const refreshContentRE = /\$Refresh(?:Reg|Sig)\$\(/;
+    //     if (refreshContentRE.test(code)) {
+    //       code = addRefreshWrapper({ code, id });
+    //     }
+    //     return { code, map: result.map };
+    //   },
+    // },
+    // {
+    //   name: "react-router/rsc/hmr/updates",
+    //   async hotUpdate(this, { server, file, modules }) {
+    //     if (this.environment.name !== "rsc") return;
+    //     const clientModules =
+    //       server.environments.client.moduleGraph.getModulesByFile(file);
+    //     const vite = await import("vite");
+    //     const isServerOnlyChange =
+    //       !clientModules ||
+    //       clientModules.size === 0 ||
+    //       // Handle CSS injected from server-first routes (with ?direct query
+    //       // string) since the client graph has a reference to the CSS
+    //       (vite.isCSSRequest(file) &&
+    //         Array.from(clientModules).some((mod) =>
+    //           mod.id?.includes("?direct"),
+    //         ));
+    //     for (const mod of getModulesWithImporters(modules)) {
+    //       if (!mod.file) continue;
+    //       const normalizedPath = path.normalize(mod.file);
+    //       const routeId = routeIdByFile?.get(normalizedPath);
+    //       if (routeId !== undefined) {
+    //         const routeSource = await readFile(normalizedPath, "utf8");
+    //         const virtualRouteModuleCode = (
+    //           await server.environments.rsc.pluginContainer.transform(
+    //             routeSource,
+    //             `${normalizedPath}?route-module`,
+    //           )
+    //         ).code;
+    //         const { staticExports } = parseRouteExports(virtualRouteModuleCode);
+    //         const hasAction = staticExports.includes("action");
+    //         const hasComponent = staticExports.includes("default");
+    //         const hasErrorBoundary = staticExports.includes("ErrorBoundary");
+    //         const hasLoader = staticExports.includes("loader");
+    //         server.hot.send({
+    //           type: "custom",
+    //           event: "react-router:hmr",
+    //           data: {
+    //             routeId,
+    //             isServerOnlyChange,
+    //             hasAction,
+    //             hasComponent,
+    //             hasErrorBoundary,
+    //             hasLoader,
+    //           },
+    //         });
+    //       }
+    //     }
+    //     return modules;
+    //   },
+    // },
     {
       name: "react-router/rsc/virtual-react-router-serve-config",
       resolveId(id) {
@@ -6421,13 +6691,107 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
       }
     },
     validatePluginOrder(),
-    warnOnClientSourceMaps()
+    warnOnClientSourceMaps(),
+    prerender({
+      config() {
+        return {
+          buildDirectory: getClientBuildDirectory2(config),
+          concurrency: getPrerenderConcurrencyConfig2(config)
+        };
+      },
+      logFile: (path10) => logger.info(`Prerendered ${import_picocolors5.default.bold(path10)}`),
+      async requests() {
+        const prerenderPaths = new Set(
+          await getPrerenderPaths(
+            config.prerender,
+            config.ssr,
+            config.routes,
+            true
+          )
+        );
+        let basename3 = !config.basename || config.basename === "/" ? "/" : config.basename.endsWith("/") ? config.basename : config.basename + "/";
+        if (config.ssr === false) {
+          prerenderPaths.add("/__spa-fallback.html");
+        }
+        return Array.from(prerenderPaths).map(
+          (prerenderPath) => `http://localhost${basename3}${prerenderPath.slice(1)}`
+        );
+      },
+      async postProcess(request, response, metadata) {
+        let url2 = new URL(request.url);
+        let isRedirect = redirectStatusCodes2.has(response.status);
+        if (!isRedirect && response.status !== 200 && response.status !== 202 && !(url2.pathname === "/__spa-fallback.html" && response.status === 404)) {
+          throw new Error(
+            `Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${url2.pathname}\` path.
+${url2.pathname}`,
+            { cause: response }
+          );
+        }
+        if (metadata?.manifest) {
+          return [
+            {
+              path: url2.pathname,
+              contents: await response.text()
+            }
+          ];
+        }
+        let isHtml = response.headers.get("content-type")?.includes("text/html");
+        let htmlResponse = isHtml ? isRedirect ? response : response.clone() : null;
+        let location = response.headers.get("Location");
+        let delay = response.status === 302 ? 2 : 0;
+        let redirectBody = isRedirect ? `<!doctype html>
+<head>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="${delay};url=${location}">
+<meta name="robots" content="noindex">
+</head>
+<body>
+	<a href="${location}">
+  Redirecting from <code>${url2.pathname}</code> to <code>${location}</code>
+</a>
+</body>
+</html>` : "";
+        let files = [
+          {
+            path: isHtml || redirectBody ? url2.pathname === "/__spa-fallback.html" ? "__spa-fallback.html" : (url2.pathname.endsWith("/") ? url2.pathname : url2.pathname + "/") + "index.html" : url2.pathname,
+            contents: redirectBody || (isHtml ? await response.text() : new Uint8Array(await response.arrayBuffer()))
+          }
+        ];
+        if (htmlResponse) {
+          let body = await htmlResponse.text();
+          let matches = Array.from(
+            body.matchAll(
+              /<script>\(self\.__FLIGHT_DATA\|\|=\[\]\)\.push\(("(?:[^"\\]|\\.)*")\)<\/script>/gim
+            )
+          );
+          if (matches.length) {
+            let rscData = "";
+            for (const match of matches) {
+              rscData += JSON.parse(match[1]);
+            }
+            files.push({
+              path: url2.pathname === "/" ? "_.rsc" : (url2.pathname === "/__spa-fallback.html" ? "__spa-fallback" : url2.pathname) + ".rsc",
+              contents: rscData
+            });
+          }
+        } else if (!url2.pathname.endsWith(".rsc")) {
+          let dataUrl = new URL(url2);
+          dataUrl.pathname += ".rsc";
+          return {
+            files,
+            requests: [dataUrl.href]
+          };
+        }
+        return files;
+      }
+    })
   ];
 }
 var virtual2 = {
   routeConfig: create("unstable_rsc/routes"),
+  routeDiscovery: create("unstable_rsc/route-discovery"),
   injectHmrRuntime: create("unstable_rsc/inject-hmr-runtime"),
-  hmrRuntime: create("unstable_rsc/runtime"),
+  // hmrRuntime: create("unstable_rsc/runtime"),
   basename: create("unstable_rsc/basename"),
   reactRouterServeConfig: create("unstable_rsc/react-router-serve-config")
 };
@@ -6444,65 +6808,15 @@ function invalidateVirtualModules2(viteDevServer) {
 function getRootDirectory(viteUserConfig) {
   return viteUserConfig.root ?? process.env.REACT_ROUTER_ROOT ?? process.cwd();
 }
-function getModulesWithImporters(modules) {
-  const visited = /* @__PURE__ */ new Set();
-  const result = /* @__PURE__ */ new Set();
-  function walk(module2) {
-    if (visited.has(module2)) return;
-    visited.add(module2);
-    result.add(module2);
-    for (const importer of module2.importers) {
-      walk(importer);
-    }
-  }
-  for (const module2 of modules) {
-    walk(module2);
+var getClientBuildDirectory2 = (reactRouterConfig) => import_pathe6.default.join(reactRouterConfig.buildDirectory, "client");
+function getPrerenderConcurrencyConfig2(reactRouterConfig) {
+  let concurrency = 1;
+  let { prerender: prerender2 } = reactRouterConfig;
+  if (typeof prerender2 === "object" && "unstable_concurrency" in prerender2) {
+    concurrency = prerender2.unstable_concurrency ?? 1;
   }
-  return result;
-}
-function addRefreshWrapper2({
-  routeId,
-  code,
-  id
-}) {
-  const acceptExports = routeId !== void 0 ? CLIENT_NON_COMPONENT_EXPORTS2 : [];
-  return REACT_REFRESH_HEADER2.replaceAll("__SOURCE__", JSON.stringify(id)) + code + REACT_REFRESH_FOOTER2.replaceAll("__SOURCE__", JSON.stringify(id)).replaceAll("__ACCEPT_EXPORTS__", JSON.stringify(acceptExports)).replaceAll("__ROUTE_ID__", JSON.stringify(routeId));
+  return concurrency;
 }
-var REACT_REFRESH_HEADER2 = `
-import RefreshRuntime from "${virtual2.hmrRuntime.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", "");
-var REACT_REFRESH_FOOTER2 = `
-if (import.meta.hot && !inWebWorker) {
-  window.$RefreshReg$ = prevRefreshReg;
-  window.$RefreshSig$ = prevRefreshSig;
-  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
-    RefreshRuntime.registerExportsForReactRefresh(__SOURCE__, currentExports);
-    import.meta.hot.accept((nextExports) => {
-      if (!nextExports) return;
-      __ROUTE_ID__ && window.__reactRouterRouteModuleUpdates.set(__ROUTE_ID__, nextExports);
-      const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(currentExports, nextExports, __ACCEPT_EXPORTS__);
-      if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
-    });
-  });
-}`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   reactRouter,