@react-router/dev 7.13.2 → 7.14.0

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.13.2
+ * @react-router/dev v7.14.0
  *
  * 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({
@@ -1193,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
@@ -1230,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 };
@@ -2526,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;
     }
   };
 }
@@ -3042,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;
@@ -3466,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
@@ -3526,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
@@ -3789,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;
@@ -3823,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;
         }
@@ -3977,7 +4028,7 @@ var reactRouterVitePlugin = () => {
       async buildEnd() {
         await viteChildCompiler?.close();
         await reactRouterConfigLoader.close();
-        let typegenWatcher = await typegenWatcherPromise;
+        let typegenWatcher = await typegenWatcherPromise2;
         await typegenWatcher?.close();
       }
     },
@@ -4408,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 [];
         }
@@ -4603,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",
@@ -5629,6 +5679,7 @@ 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"));
 
@@ -5685,39 +5736,27 @@ 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,
+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);
+}
+var SERVER_ROUTE_EXPORTS = [
+  ...SERVER_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 SERVER_ROUTE_EXPORTS_SET = new Set(SERVER_ROUTE_EXPORTS);
+function isServerRouteExport(name) {
+  return SERVER_ROUTE_EXPORTS_SET.has(name);
 }
-var CLIENT_COMPONENT_EXPORTS = [
-  ...COMMON_COMPONENT_EXPORTS,
-  "default"
-];
 var CLIENT_NON_COMPONENT_EXPORTS2 = [
   "clientAction",
   "clientLoader",
@@ -5727,20 +5766,25 @@ var CLIENT_NON_COMPONENT_EXPORTS2 = [
   "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
+  "default",
+  "ErrorBoundary",
+  "HydrateFallback",
+  "Layout"
 ];
 var CLIENT_ROUTE_EXPORTS_SET = new Set(CLIENT_ROUTE_EXPORTS2);
 function isClientRouteExport(name) {
   return CLIENT_ROUTE_EXPORTS_SET.has(name);
 }
+var mutuallyExclusiveRouteExports = /* @__PURE__ */ new Map([
+  ["ErrorBoundary", "ServerErrorBoundary"],
+  ["HydrateFallback", "ServerHydrateFallback"],
+  ["Layout", "ServerLayout"],
+  ["default", "ServerComponent"]
+]);
 var ROUTE_EXPORTS = [
-  ...SERVER_ONLY_ROUTE_EXPORTS2,
+  ...SERVER_ROUTE_EXPORTS,
   ...CLIENT_ROUTE_EXPORTS2
 ];
 var ROUTE_EXPORTS_SET = new Set(ROUTE_EXPORTS);
@@ -5794,63 +5838,57 @@ async function createVirtualRouteModuleCode({
   viteEnvironment
 }) {
   const isReactServer = hasReactServerCondition(viteEnvironment);
-  const { staticExports, isServerFirstRoute, hasClientExports } = parseRouteExports(routeSource);
+  const { staticExports, hasClientExports } = parseRouteExports(routeSource);
+  for (const exportName of staticExports) {
+    if (mutuallyExclusiveRouteExports.has(exportName)) {
+      const conflictingExport = mutuallyExclusiveRouteExports.get(exportName);
+      if (staticExports.includes(conflictingExport)) {
+        throw new Error(
+          `Route module cannot export both "${exportName}" and "${conflictingExport}". Please choose one or the other.`
+        );
+      }
+    }
+  }
   const clientModuleId = getVirtualClientModuleId(id);
   const serverModuleId = getVirtualServerModuleId(id);
   let code = "";
-  if (isServerFirstRoute) {
-    if (staticExports.some(isServerFirstComponentExport)) {
-      code += `import React from "react";
+  if (isReactServer && staticExports.some(isServerComponentExport)) {
+    code += `import React from "react";
 `;
-    }
-    for (const staticExport of staticExports) {
-      if (isClientNonComponentExport(staticExport)) {
-        code += `export { ${staticExport} } from "${clientModuleId}";
-`;
-      } 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}";
+  }
+  for (const staticExport of staticExports) {
+    if (isReactServer && isServerComponentExport(staticExport)) {
+      code += `import { ${staticExport} as ${staticExport}WithoutCss } from "${serverModuleId}";
 `;
-        code += `export ${staticExport === "ServerComponent" ? "default " : " "}function ${staticExport}(props) {
+      code += `export ${staticExport === "ServerComponent" ? "default " : " "}function ${staticExport.replace(/^Server/, "")}(props) {
 `;
-        code += `  return React.createElement(React.Fragment, null,
+      code += `  return React.createElement(React.Fragment, null,
 `;
-        code += `    import.meta.viteRsc.loadCss(),
+      code += `    import.meta.viteRsc.loadCss(),
 `;
-        code += `    React.createElement(${staticExport}WithoutCss, props),
+      code += `    React.createElement(${staticExport}WithoutCss, props),
 `;
-        code += `  );
+      code += `  );
 `;
-        code += `}
+      code += `}
 `;
-      } else if (isReactServer && isRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${serverModuleId}";
+    } else if (isReactServer && isServerRouteExport(staticExport)) {
+      code += `export { ${staticExport} } from "${serverModuleId}";
 `;
-      } else if (isCustomRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${isReactServer ? serverModuleId : clientModuleId}";
+    } else if (isClientRouteExport(staticExport)) {
+      code += `export { ${staticExport} } from "${clientModuleId}";
 `;
-      }
-    }
-    if (viteCommand === "serve" && !hasClientExports) {
-      code += `export { __ensureClientRouteModuleForHMR } from "${clientModuleId}";
+    } else if (isCustomRouteExport(staticExport)) {
+      code += `export { ${staticExport} } from "${isReactServer ? serverModuleId : clientModuleId}";
 `;
     }
-  } else {
-    for (const staticExport of staticExports) {
-      if (isClientRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${clientModuleId}";
-`;
-      } else if (isReactServer && isServerOnlyRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${serverModuleId}";
-`;
-      } else if (isCustomRouteExport(staticExport)) {
-        code += `export { ${staticExport} } from "${isReactServer ? serverModuleId : clientModuleId}";
-`;
-      }
-    }
   }
-  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary")) {
+  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary") && !staticExports.includes("ServerErrorBoundary")) {
     code += `export { ErrorBoundary } from "${clientModuleId}";
+`;
+  }
+  if (viteCommand === "serve" && !hasClientExports) {
+    code += `export { __ensureClientRouteModuleForHMR } from "${clientModuleId}";
 `;
   }
   return code;
@@ -5869,23 +5907,18 @@ function createVirtualServerRouteModuleCode({
       ].join("\n")
     );
   }
-  const { staticExports, isServerFirstRoute } = parseRouteExports(routeSource);
+  const { staticExports } = parseRouteExports(routeSource);
   const clientModuleId = getVirtualClientModuleId(id);
   const serverRouteModuleAst = import_parser.parse(routeSource, {
     sourceType: "module"
   });
-  removeExports(
-    serverRouteModuleAst,
-    isServerFirstRoute ? CLIENT_NON_COMPONENT_EXPORTS2 : CLIENT_ROUTE_EXPORTS2
-  );
+  removeExports(serverRouteModuleAst, 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}";
+  for (const staticExport of staticExports) {
+    if (isClientRouteExport(staticExport)) {
+      generatorResult.code += "\n";
+      generatorResult.code += `export { ${staticExport} } from "${clientModuleId}";
 `;
-      }
     }
   }
   return generatorResult;
@@ -5896,15 +5929,14 @@ function createVirtualClientRouteModuleCode({
   rootRouteFile,
   viteCommand
 }) {
-  const { staticExports, isServerFirstRoute, hasClientExports } = parseRouteExports(routeSource);
-  const exportsToRemove = isServerFirstRoute ? [...SERVER_ONLY_ROUTE_EXPORTS2, ...CLIENT_COMPONENT_EXPORTS] : SERVER_ONLY_ROUTE_EXPORTS2;
+  const { staticExports, hasClientExports } = parseRouteExports(routeSource);
   const clientRouteModuleAst = import_parser.parse(routeSource, {
     sourceType: "module"
   });
-  removeExports(clientRouteModuleAst, exportsToRemove);
+  removeExports(clientRouteModuleAst, SERVER_ROUTE_EXPORTS);
   const generatorResult = generate(clientRouteModuleAst);
   generatorResult.code = '"use client";' + generatorResult.code;
-  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary")) {
+  if (isRootRouteFile({ id, rootRouteFile }) && !staticExports.includes("ErrorBoundary") && !staticExports.includes("ServerErrorBoundary")) {
     const hasRootLayout = staticExports.includes("Layout");
     generatorResult.code += `
 import { createElement as __rr_createElement } from "react";
@@ -5918,7 +5950,7 @@ import { createElement as __rr_createElement } from "react";
     generatorResult.code += `}
 `;
   }
-  if (viteCommand === "serve" && isServerFirstRoute && !hasClientExports) {
+  if (viteCommand === "serve" && !hasClientExports) {
     generatorResult.code += `
 export const __ensureClientRouteModuleForHMR = true;`;
   }
@@ -5927,15 +5959,9 @@ export const __ensureClientRouteModuleForHMR = true;`;
 function parseRouteExports(code) {
   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) {
@@ -5962,12 +5988,14 @@ function isRootRouteFile({
 }
 
 // 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;
@@ -5990,24 +6018,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)
@@ -6023,6 +6048,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);
@@ -6065,9 +6091,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.
@@ -6089,10 +6122,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: {
@@ -6214,6 +6255,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();
       }
@@ -6236,12 +6321,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,
@@ -6258,7 +6343,7 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
       async buildEnd() {
         (await typegenWatcherPromise)?.close();
       }
-    },
+    } : null,
     {
       name: "react-router/rsc/virtual-route-config",
       resolveId(id) {
@@ -6304,6 +6389,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",
@@ -6453,11 +6555,105 @@ ${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"),
   basename: create("unstable_rsc/basename"),
@@ -6535,6 +6731,15 @@ if (import.meta.hot && !inWebWorker) {
     });
   });
 }`;
+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 concurrency;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   reactRouter,