@react-router/dev 7.13.0 → 7.13.1-pre.0

package/dist/vite.js

@@ -1,5 +1,5 @@
 /**
- * @react-router/dev v7.13.0
+ * @react-router/dev v7.13.1-pre.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -48,8 +48,8 @@ module.exports = __toCommonJS(vite_exports);
 // vite/plugin.ts
 var import_node_crypto = require("crypto");
 var import_node_fs2 = require("fs");
-var import_promises2 = require("fs/promises");
-var path6 = __toESM(require("path"));
+var import_promises3 = require("fs/promises");
+var path7 = __toESM(require("path"));
 var url = __toESM(require("url"));
 var babel = __toESM(require("@babel/core"));
 var import_react_router2 = require("react-router");
@@ -246,7 +246,7 @@ function validateRouteConfig({
         `Route config in "${routeConfigFile}" is invalid.`,
         root ? `${root}` : [],
         nested ? Object.entries(nested).map(
-          ([path9, message]) => `Path: routes.${path9}
+          ([path10, message]) => `Path: routes.${path10}
 ${message}`
         ) : []
       ].flat().join("\n\n")
@@ -431,7 +431,7 @@ async function resolveConfig({
     basename: basename3,
     buildDirectory: userBuildDirectory,
     buildEnd,
-    prerender,
+    prerender: prerender2,
     routeDiscovery: userRouteDiscovery,
     serverBuildFile,
     serverBundles,
@@ -445,15 +445,15 @@ async function resolveConfig({
   if (!ssr && serverBundles) {
     serverBundles = void 0;
   }
-  if (prerender) {
+  if (prerender2) {
     let isValidPrerenderPathsConfig = (p) => typeof p === "boolean" || typeof p === "function" || Array.isArray(p);
-    let isValidPrerenderConfig = isValidPrerenderPathsConfig(prerender) || typeof prerender === "object" && "paths" in prerender && isValidPrerenderPathsConfig(prerender.paths);
+    let isValidPrerenderConfig = isValidPrerenderPathsConfig(prerender2) || typeof prerender2 === "object" && "paths" in prerender2 && isValidPrerenderPathsConfig(prerender2.paths);
     if (!isValidPrerenderConfig) {
       return err(
         "The `prerender`/`prerender.paths` config must be a boolean, an array of string paths, or a function returning a boolean or array of string paths."
       );
     }
-    let isValidConcurrencyConfig = typeof prerender != "object" || !("unstable_concurrency" in prerender) || typeof prerender.unstable_concurrency === "number" && Number.isInteger(prerender.unstable_concurrency) && prerender.unstable_concurrency > 0;
+    let isValidConcurrencyConfig = typeof prerender2 != "object" || !("unstable_concurrency" in prerender2) || typeof prerender2.unstable_concurrency === "number" && Number.isInteger(prerender2.unstable_concurrency) && prerender2.unstable_concurrency > 0;
     if (!isValidConcurrencyConfig) {
       return err(
         "The `prerender.unstable_concurrency` config must be a positive integer if specified."
@@ -562,6 +562,7 @@ async function resolveConfig({
     unstable_optimizeDeps: userAndPresetConfigs.future?.unstable_optimizeDeps ?? false,
     unstable_subResourceIntegrity: userAndPresetConfigs.future?.unstable_subResourceIntegrity ?? false,
     unstable_trailingSlashAwareDataRequests: userAndPresetConfigs.future?.unstable_trailingSlashAwareDataRequests ?? false,
+    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
@@ -573,7 +574,7 @@ async function resolveConfig({
     buildDirectory,
     buildEnd,
     future,
-    prerender,
+    prerender: prerender2,
     routes,
     routeDiscovery,
     serverBuildFile,
@@ -640,11 +641,11 @@ async function createConfigLoader({
       if (!fsWatcher) {
         fsWatcher = import_chokidar.default.watch([root, appDirectory], {
           ignoreInitial: true,
-          ignored: (path9) => {
-            let dirname4 = import_pathe3.default.dirname(path9);
+          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
-            path9 !== root && // Watch the root directory itself
+            path10 !== root && // Watch the root directory itself
             dirname4 !== root;
           }
         });
@@ -928,7 +929,7 @@ function fullpath(lineage2) {
   if (lineage2.length === 1 && route?.id === "root") return "/";
   const isLayout = route && route.index !== true && route.path === void 0;
   if (isLayout) return void 0;
-  return "/" + lineage2.map((route2) => route2.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path9) => path9 !== void 0 && path9 !== "").join("/");
+  return "/" + lineage2.map((route2) => route2.path?.replace(/^\//, "")?.replace(/\/$/, "")).filter((path10) => path10 !== void 0 && path10 !== "").join("/");
 }
 
 // typegen/generate.ts
@@ -1108,8 +1109,8 @@ function routeModulesType(ctx) {
   );
 }
 function isInAppDirectory(ctx, routeFile) {
-  const path9 = Path3.resolve(ctx.config.appDirectory, routeFile);
-  return path9.startsWith(ctx.config.appDirectory);
+  const path10 = Path3.resolve(ctx.config.appDirectory, routeFile);
+  return path10.startsWith(ctx.config.appDirectory);
 }
 function getRouteAnnotations({
   ctx,
@@ -1221,21 +1222,21 @@ function getRouteAnnotations({
   return { filename: filename2, content };
 }
 function relativeImportSource(from, to) {
-  let path9 = Path3.relative(Path3.dirname(from), to);
-  let extension = Path3.extname(path9);
-  path9 = Path3.join(Path3.dirname(path9), Pathe.filename(path9));
-  if (!path9.startsWith("../")) path9 = "./" + path9;
+  let path10 = Path3.relative(Path3.dirname(from), to);
+  let extension = Path3.extname(path10);
+  path10 = Path3.join(Path3.dirname(path10), Pathe.filename(path10));
+  if (!path10.startsWith("../")) path10 = "./" + path10;
   if (!extension || /\.(js|ts)x?$/.test(extension)) {
     extension = ".js";
   }
-  return path9 + extension;
+  return path10 + extension;
 }
 function rootDirsPath(ctx, typesPath) {
   const rel = Path3.relative(typesDirectory(ctx), typesPath);
   return Path3.join(ctx.rootDirectory, rel);
 }
-function paramsType(path9) {
-  const params = parse2(path9);
+function paramsType(path10) {
+  const params = parse2(path10);
   return t2.tsTypeLiteral(
     Object.entries(params).map(([param, isRequired]) => {
       const property = t2.tsPropertySignature(
@@ -1504,11 +1505,11 @@ var getCssStringFromViteDevModuleCode = (code) => {
   let cssContent = void 0;
   const ast = import_parser.parse(code, { sourceType: "module" });
   traverse(ast, {
-    VariableDeclaration(path9) {
-      const declaration = path9.node.declarations[0];
+    VariableDeclaration(path10) {
+      const declaration = path10.node.declarations[0];
       if (declaration?.id?.type === "Identifier" && declaration.id.name === "__vite__css" && declaration.init?.type === "StringLiteral") {
         cssContent = declaration.init.value;
-        path9.stop();
+        path10.stop();
       }
     }
   });
@@ -1547,10 +1548,10 @@ var removeExports = (ast, exportsToRemove) => {
   let markedForRemoval = /* @__PURE__ */ new Set();
   let removedExportLocalNames = /* @__PURE__ */ new Set();
   traverse(ast, {
-    ExportDeclaration(path9) {
-      if (path9.node.type === "ExportNamedDeclaration") {
-        if (path9.node.specifiers.length) {
-          path9.node.specifiers = path9.node.specifiers.filter((specifier) => {
+    ExportDeclaration(path10) {
+      if (path10.node.type === "ExportNamedDeclaration") {
+        if (path10.node.specifiers.length) {
+          path10.node.specifiers = path10.node.specifiers.filter((specifier) => {
             if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier") {
               if (exportsToRemove.includes(specifier.exported.name)) {
                 exportsFiltered = true;
@@ -1562,12 +1563,12 @@ var removeExports = (ast, exportsToRemove) => {
             }
             return true;
           });
-          if (path9.node.specifiers.length === 0) {
-            markedForRemoval.add(path9);
+          if (path10.node.specifiers.length === 0) {
+            markedForRemoval.add(path10);
           }
         }
-        if (path9.node.declaration?.type === "VariableDeclaration") {
-          let declaration = path9.node.declaration;
+        if (path10.node.declaration?.type === "VariableDeclaration") {
+          let declaration = path10.node.declaration;
           declaration.declarations = declaration.declarations.filter(
             (declaration2) => {
               if (declaration2.id.type === "Identifier" && exportsToRemove.includes(declaration2.id.name)) {
@@ -1581,30 +1582,30 @@ var removeExports = (ast, exportsToRemove) => {
             }
           );
           if (declaration.declarations.length === 0) {
-            markedForRemoval.add(path9);
+            markedForRemoval.add(path10);
           }
         }
-        if (path9.node.declaration?.type === "FunctionDeclaration") {
-          let id = path9.node.declaration.id;
+        if (path10.node.declaration?.type === "FunctionDeclaration") {
+          let id = path10.node.declaration.id;
           if (id && exportsToRemove.includes(id.name)) {
-            markedForRemoval.add(path9);
+            markedForRemoval.add(path10);
           }
         }
-        if (path9.node.declaration?.type === "ClassDeclaration") {
-          let id = path9.node.declaration.id;
+        if (path10.node.declaration?.type === "ClassDeclaration") {
+          let id = path10.node.declaration.id;
           if (id && exportsToRemove.includes(id.name)) {
-            markedForRemoval.add(path9);
+            markedForRemoval.add(path10);
           }
         }
       }
-      if (path9.node.type === "ExportDefaultDeclaration") {
+      if (path10.node.type === "ExportDefaultDeclaration") {
         if (exportsToRemove.includes("default")) {
-          markedForRemoval.add(path9);
-          if (path9.node.declaration) {
-            if (path9.node.declaration.type === "Identifier") {
-              removedExportLocalNames.add(path9.node.declaration.name);
-            } else if ((path9.node.declaration.type === "FunctionDeclaration" || path9.node.declaration.type === "ClassDeclaration") && path9.node.declaration.id) {
-              removedExportLocalNames.add(path9.node.declaration.id.name);
+          markedForRemoval.add(path10);
+          if (path10.node.declaration) {
+            if (path10.node.declaration.type === "Identifier") {
+              removedExportLocalNames.add(path10.node.declaration.name);
+            } else if ((path10.node.declaration.type === "FunctionDeclaration" || path10.node.declaration.type === "ClassDeclaration") && path10.node.declaration.id) {
+              removedExportLocalNames.add(path10.node.declaration.id.name);
             }
           }
         }
@@ -1612,21 +1613,21 @@ var removeExports = (ast, exportsToRemove) => {
     }
   });
   traverse(ast, {
-    ExpressionStatement(path9) {
-      if (!path9.parentPath.isProgram()) {
+    ExpressionStatement(path10) {
+      if (!path10.parentPath.isProgram()) {
         return;
       }
-      if (path9.node.expression.type === "AssignmentExpression") {
-        const left = path9.node.expression.left;
+      if (path10.node.expression.type === "AssignmentExpression") {
+        const left = path10.node.expression.left;
         if (left.type === "MemberExpression" && left.object.type === "Identifier" && (exportsToRemove.includes(left.object.name) || removedExportLocalNames.has(left.object.name))) {
-          markedForRemoval.add(path9);
+          markedForRemoval.add(path10);
         }
       }
     }
   });
   if (markedForRemoval.size > 0 || exportsFiltered) {
-    for (let path9 of markedForRemoval) {
-      path9.remove();
+    for (let path10 of markedForRemoval) {
+      path10.remove();
     }
     (0, import_babel_dead_code_elimination.deadCodeElimination)(ast, previouslyReferencedIdentifiers);
   }
@@ -1709,28 +1710,28 @@ function codeToAst(code, cache, cacheKey) {
     )
   );
 }
-function assertNodePath(path9) {
+function assertNodePath(path10) {
   invariant(
-    path9 && !Array.isArray(path9),
-    `Expected a Path, but got ${Array.isArray(path9) ? "an array" : path9}`
+    path10 && !Array.isArray(path10),
+    `Expected a Path, but got ${Array.isArray(path10) ? "an array" : path10}`
   );
 }
-function assertNodePathIsStatement(path9) {
+function assertNodePathIsStatement(path10) {
   invariant(
-    path9 && !Array.isArray(path9) && t.isStatement(path9.node),
-    `Expected a Statement path, but got ${Array.isArray(path9) ? "an array" : path9?.node?.type}`
+    path10 && !Array.isArray(path10) && t.isStatement(path10.node),
+    `Expected a Statement path, but got ${Array.isArray(path10) ? "an array" : path10?.node?.type}`
   );
 }
-function assertNodePathIsVariableDeclarator(path9) {
+function assertNodePathIsVariableDeclarator(path10) {
   invariant(
-    path9 && !Array.isArray(path9) && t.isVariableDeclarator(path9.node),
-    `Expected an Identifier path, but got ${Array.isArray(path9) ? "an array" : path9?.node?.type}`
+    path10 && !Array.isArray(path10) && t.isVariableDeclarator(path10.node),
+    `Expected an Identifier path, but got ${Array.isArray(path10) ? "an array" : path10?.node?.type}`
   );
 }
-function assertNodePathIsPattern(path9) {
+function assertNodePathIsPattern(path10) {
   invariant(
-    path9 && !Array.isArray(path9) && t.isPattern(path9.node),
-    `Expected a Pattern path, but got ${Array.isArray(path9) ? "an array" : path9?.node?.type}`
+    path10 && !Array.isArray(path10) && t.isPattern(path10.node),
+    `Expected a Pattern path, but got ${Array.isArray(path10) ? "an array" : path10?.node?.type}`
   );
 }
 function getExportDependencies(code, cache, cacheKey) {
@@ -1766,8 +1767,8 @@ function getExportDependencies(code, cache, cacheKey) {
           }
           let isWithinExportDestructuring = Boolean(
             identifier.findParent(
-              (path9) => Boolean(
-                path9.isPattern() && path9.parentPath?.isVariableDeclarator() && path9.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()
+              (path10) => Boolean(
+                path10.isPattern() && path10.parentPath?.isVariableDeclarator() && path10.parentPath.parentPath?.parentPath?.isExportNamedDeclaration()
               )
             )
           );
@@ -1845,7 +1846,7 @@ function getExportDependencies(code, cache, cacheKey) {
             for (let specifier of node.specifiers) {
               if (t.isIdentifier(specifier.exported)) {
                 let name = specifier.exported.name;
-                let specifierPath = exportPath.get("specifiers").find((path9) => path9.node === specifier);
+                let specifierPath = exportPath.get("specifiers").find((path10) => path10.node === specifier);
                 invariant(
                   specifierPath,
                   `Expected to find specifier path for ${name}`
@@ -1862,22 +1863,22 @@ function getExportDependencies(code, cache, cacheKey) {
     }
   );
 }
-function getDependentIdentifiersForPath(path9, state) {
+function getDependentIdentifiersForPath(path10, state) {
   let { visited, identifiers } = state ?? {
     visited: /* @__PURE__ */ new Set(),
     identifiers: /* @__PURE__ */ new Set()
   };
-  if (visited.has(path9)) {
+  if (visited.has(path10)) {
     return identifiers;
   }
-  visited.add(path9);
-  path9.traverse({
-    Identifier(path10) {
-      if (identifiers.has(path10)) {
+  visited.add(path10);
+  path10.traverse({
+    Identifier(path11) {
+      if (identifiers.has(path11)) {
         return;
       }
-      identifiers.add(path10);
-      let binding = path10.scope.getBinding(path10.node.name);
+      identifiers.add(path11);
+      let binding = path11.scope.getBinding(path11.node.name);
       if (!binding) {
         return;
       }
@@ -1899,7 +1900,7 @@ function getDependentIdentifiersForPath(path9, state) {
       }
     }
   });
-  let topLevelStatement = getTopLevelStatementPathForPath(path9);
+  let topLevelStatement = getTopLevelStatementPathForPath(path10);
   let withinImportStatement = topLevelStatement.isImportDeclaration();
   let withinExportStatement = topLevelStatement.isExportDeclaration();
   if (!withinImportStatement && !withinExportStatement) {
@@ -1908,9 +1909,9 @@ function getDependentIdentifiersForPath(path9, state) {
       identifiers
     });
   }
-  if (withinExportStatement && path9.isIdentifier() && (t.isPattern(path9.parentPath.node) || // [foo]
-  t.isPattern(path9.parentPath.parentPath?.node))) {
-    let variableDeclarator = path9.findParent((p) => p.isVariableDeclarator());
+  if (withinExportStatement && path10.isIdentifier() && (t.isPattern(path10.parentPath.node) || // [foo]
+  t.isPattern(path10.parentPath.parentPath?.node))) {
+    let variableDeclarator = path10.findParent((p) => p.isVariableDeclarator());
     assertNodePath(variableDeclarator);
     getDependentIdentifiersForPath(variableDeclarator, {
       visited,
@@ -1919,16 +1920,16 @@ function getDependentIdentifiersForPath(path9, state) {
   }
   return identifiers;
 }
-function getTopLevelStatementPathForPath(path9) {
-  let ancestry = path9.getAncestry();
+function getTopLevelStatementPathForPath(path10) {
+  let ancestry = path10.getAncestry();
   let topLevelStatement = ancestry[ancestry.length - 2];
   assertNodePathIsStatement(topLevelStatement);
   return topLevelStatement;
 }
 function getTopLevelStatementsForPaths(paths) {
   let topLevelStatements = /* @__PURE__ */ new Set();
-  for (let path9 of paths) {
-    let topLevelStatement = getTopLevelStatementPathForPath(path9);
+  for (let path10 of paths) {
+    let topLevelStatement = getTopLevelStatementPathForPath(path10);
     topLevelStatements.add(topLevelStatement.node);
   }
   return topLevelStatements;
@@ -2322,24 +2323,24 @@ function isNamedComponentExport(name) {
 }
 var decorateComponentExportsWithProps = (ast) => {
   const hocs = [];
-  function getHocUid(path9, hocName) {
-    const uid = path9.scope.generateUidIdentifier(hocName);
+  function getHocUid(path10, hocName) {
+    const uid = path10.scope.generateUidIdentifier(hocName);
     hocs.push([hocName, uid]);
     return uid;
   }
   traverse(ast, {
-    ExportDeclaration(path9) {
-      if (path9.isExportDefaultDeclaration()) {
-        const declaration = path9.get("declaration");
+    ExportDeclaration(path10) {
+      if (path10.isExportDefaultDeclaration()) {
+        const declaration = path10.get("declaration");
         const expr = declaration.isExpression() ? declaration.node : declaration.isFunctionDeclaration() ? toFunctionExpression(declaration.node) : void 0;
         if (expr) {
-          const uid = getHocUid(path9, "UNSAFE_withComponentProps");
+          const uid = getHocUid(path10, "UNSAFE_withComponentProps");
           declaration.replaceWith(t.callExpression(uid, [expr]));
         }
         return;
       }
-      if (path9.isExportNamedDeclaration()) {
-        const decl = path9.get("declaration");
+      if (path10.isExportNamedDeclaration()) {
+        const decl = path10.get("declaration");
         if (decl.isVariableDeclaration()) {
           decl.get("declarations").forEach((varDeclarator) => {
             const id = varDeclarator.get("id");
@@ -2349,7 +2350,7 @@ var decorateComponentExportsWithProps = (ast) => {
             if (!id.isIdentifier()) return;
             const { name } = id.node;
             if (!isNamedComponentExport(name)) return;
-            const uid = getHocUid(path9, `UNSAFE_with${name}Props`);
+            const uid = getHocUid(path10, `UNSAFE_with${name}Props`);
             init.replaceWith(t.callExpression(uid, [expr]));
           });
           return;
@@ -2359,7 +2360,7 @@ var decorateComponentExportsWithProps = (ast) => {
           if (!id) return;
           const { name } = id;
           if (!isNamedComponentExport(name)) return;
-          const uid = getHocUid(path9, `UNSAFE_with${name}Props`);
+          const uid = getHocUid(path10, `UNSAFE_with${name}Props`);
           decl.replaceWith(
             t.variableDeclaration("const", [
               t.variableDeclarator(
@@ -2480,6 +2481,222 @@ function warnOnClientSourceMaps() {
   };
 }
 
+// vite/plugins/prerender.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+function normalizePrerenderRequest(input) {
+  if (typeof input === "string" || input instanceof Request) {
+    return { request: input, metadata: void 0 };
+  }
+  return { request: input.request, metadata: input.metadata };
+}
+function normalizePostProcessResult(result) {
+  if (Array.isArray(result)) {
+    return { files: result, requests: [] };
+  }
+  return { files: result.files, requests: result.requests ?? [] };
+}
+function prerender(options) {
+  const {
+    config,
+    requests,
+    postProcess = defaultPostProcess,
+    handleError = defaultHandleError,
+    logFile,
+    finalize
+  } = 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) {
+              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 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)
+                  );
+                  return attempt(url3);
+                }
+                handleError.call(
+                  pluginContext,
+                  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.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();
+              }
+            });
+          });
+        }
+      }
+    }
+  };
+}
+async function defaultPostProcess(request, response) {
+  const prerenderPath = new URL(request.url).pathname;
+  if (!response.ok) {
+    throw new Error(
+      `Prerender: Request failed for ${prerenderPath}: ${response.status} ${response.statusText}`
+    );
+  }
+  return [
+    {
+      path: `${prerenderPath}/index.html`,
+      contents: await response.text()
+    }
+  ];
+}
+function defaultHandleError(request, error) {
+  const prerenderPath = new URL(request.url).pathname;
+  if (request.signal?.aborted) {
+    throw new Error(
+      `Prerender: Request timed out for ${prerenderPath}: ${error.message}`
+    );
+  }
+  throw new Error(
+    `Prerender: Request failed for ${prerenderPath}: ${error.message}`
+  );
+}
+async function startPreviewServer(viteConfig) {
+  const vite2 = await import("vite");
+  try {
+    return await vite2.preview({
+      configFile: viteConfig.configFile,
+      logLevel: "silent",
+      preview: {
+        port: 0,
+        open: false
+      }
+    });
+  } catch (error) {
+    throw new Error("Prerender: Failed to start Vite preview server", {
+      cause: error
+    });
+  }
+}
+function getResolvedUrl(previewServer) {
+  const baseUrl = previewServer.resolvedUrls?.local[0];
+  if (!baseUrl) {
+    throw new Error(
+      "Prerender: No resolved URL is available from the Vite preview server"
+    );
+  }
+  return new URL(baseUrl);
+}
+
 // vite/plugin.ts
 function extractPluginContext(viteConfig) {
   return viteConfig["__reactRouterPluginContext"];
@@ -2541,8 +2758,8 @@ var virtualHmrRuntime = create("hmr-runtime");
 var virtualInjectHmrRuntime = create("inject-hmr-runtime");
 var normalizeRelativeFilePath = (file, reactRouterConfig) => {
   let vite2 = getVite();
-  let fullPath = path6.resolve(reactRouterConfig.appDirectory, file);
-  let relativePath = path6.relative(reactRouterConfig.appDirectory, fullPath);
+  let fullPath = path7.resolve(reactRouterConfig.appDirectory, file);
+  let relativePath = path7.relative(reactRouterConfig.appDirectory, fullPath);
   return vite2.normalizePath(relativePath).split("?")[0];
 };
 var virtual = {
@@ -2565,7 +2782,7 @@ var getHash = (source, maxLength) => {
 var resolveChunk = (ctx, viteManifest, absoluteFilePath) => {
   let vite2 = getVite();
   let rootRelativeFilePath = vite2.normalizePath(
-    path6.relative(ctx.rootDirectory, absoluteFilePath)
+    path7.relative(ctx.rootDirectory, absoluteFilePath)
   );
   let entryChunk = viteManifest[rootRelativeFilePath];
   if (!entryChunk) {
@@ -2656,7 +2873,7 @@ function resolveDependantChunks(viteManifest, entryChunks) {
 function getAllDynamicCssFiles(ctx, viteManifest) {
   let allDynamicCssFiles = /* @__PURE__ */ new Set();
   for (let route of Object.values(ctx.reactRouterConfig.routes)) {
-    let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
+    let routeFile = path7.join(ctx.reactRouterConfig.appDirectory, route.file);
     let entryChunk = resolveChunk(
       ctx,
       viteManifest,
@@ -2695,8 +2912,8 @@ function dedupe(array2) {
   return [...new Set(array2)];
 }
 var writeFileSafe = async (file, contents) => {
-  await (0, import_promises2.mkdir)(path6.dirname(file), { recursive: true });
-  await (0, import_promises2.writeFile)(file, contents);
+  await (0, import_promises3.mkdir)(path7.dirname(file), { recursive: true });
+  await (0, import_promises3.writeFile)(file, contents);
 };
 var getExportNames = (code) => {
   let [, exportSpecifiers] = (0, import_es_module_lexer.parse)(code);
@@ -2721,7 +2938,7 @@ var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile)
   }
   let ssr = true;
   let { pluginContainer, moduleGraph } = viteChildCompiler;
-  let routePath = path6.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
+  let routePath = path7.resolve(ctx.reactRouterConfig.appDirectory, routeFile);
   let url2 = resolveFileUrl(ctx, routePath);
   let resolveId = async () => {
     let result = await pluginContainer.resolveId(url2, void 0, { ssr });
@@ -2730,7 +2947,7 @@ var compileRouteFile = async (viteChildCompiler, ctx, routeFile, readRouteFile)
   };
   let [id, code] = await Promise.all([
     resolveId(),
-    readRouteFile?.() ?? (0, import_promises2.readFile)(routePath, "utf-8"),
+    readRouteFile?.() ?? (0, import_promises3.readFile)(routePath, "utf-8"),
     // pluginContainer.transform(...) fails if we don't do this first:
     moduleGraph.ensureEntryFromUrl(url2, ssr)
   ]);
@@ -2763,12 +2980,12 @@ var resolveEnvironmentBuildContext = ({
   };
   return resolvedBuildContext;
 };
-var getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path6.join(
+var getServerBuildDirectory = (reactRouterConfig, { serverBundleId } = {}) => path7.join(
   reactRouterConfig.buildDirectory,
   "server",
   ...serverBundleId ? [serverBundleId] : []
 );
-var getClientBuildDirectory = (reactRouterConfig) => path6.join(reactRouterConfig.buildDirectory, "client");
+var getClientBuildDirectory = (reactRouterConfig) => path7.join(reactRouterConfig.buildDirectory, "client");
 var getServerBundleRouteIds = (vitePluginContext, ctx) => {
   if (!ctx.buildManifest) {
     return void 0;
@@ -2786,14 +3003,14 @@ var getServerBundleRouteIds = (vitePluginContext, ctx) => {
   );
   return Object.keys(serverBundleRoutes);
 };
-var defaultEntriesDir = path6.resolve(
-  path6.dirname(require.resolve("@react-router/dev/package.json")),
+var defaultEntriesDir = path7.resolve(
+  path7.dirname(require.resolve("@react-router/dev/package.json")),
   "dist",
   "config",
   "defaults"
 );
 var defaultEntries = (0, import_node_fs2.readdirSync)(defaultEntriesDir).map(
-  (filename2) => path6.join(defaultEntriesDir, filename2)
+  (filename2) => path7.join(defaultEntriesDir, filename2)
 );
 invariant(defaultEntries.length > 0, "No default entries found");
 var reactRouterDevLoadContext = () => void 0;
@@ -2843,6 +3060,8 @@ var reactRouterVitePlugin = () => {
     firstLoad = false;
     ctx = {
       environmentBuildContext,
+      reactRouterManifest: null,
+      prerenderPaths: null,
       reactRouterConfig,
       rootDirectory,
       entryClientFilePath,
@@ -2867,6 +3086,12 @@ var reactRouterVitePlugin = () => {
       ctx.reactRouterConfig.ssr,
       routes
     );
+    if (!ctx.prerenderPaths) {
+      ctx.prerenderPaths = /* @__PURE__ */ new Set();
+    }
+    for (let path10 of prerenderPaths) {
+      ctx.prerenderPaths.add(path10);
+    }
     let isSpaMode = isSpaModeEnabled(ctx.reactRouterConfig);
     return `
     import * as entryServer from ${JSON.stringify(
@@ -2889,7 +3114,7 @@ var reactRouterVitePlugin = () => {
       virtual.serverManifest.id
     )};
       export const assetsBuildDirectory = ${JSON.stringify(
-      path6.relative(
+      path7.relative(
         ctx.rootDirectory,
         getClientBuildDirectory(ctx.reactRouterConfig)
       )
@@ -2929,8 +3154,8 @@ var reactRouterVitePlugin = () => {
     `;
   };
   let loadViteManifest = async (directory) => {
-    let manifestContents = await (0, import_promises2.readFile)(
-      path6.resolve(directory, ".vite", "manifest.json"),
+    let manifestContents = await (0, import_promises3.readFile)(
+      path7.resolve(directory, ".vite", "manifest.json"),
       "utf-8"
     );
     return JSON.parse(manifestContents);
@@ -2954,8 +3179,8 @@ var reactRouterVitePlugin = () => {
         const entryNormalizedPath = "parentPath" in entry && typeof entry.parentPath === "string" ? entry.parentPath : entry.path;
         let contents;
         try {
-          contents = await (0, import_promises2.readFile)(
-            path6.join(entryNormalizedPath, entry.name),
+          contents = await (0, import_promises3.readFile)(
+            path7.join(entryNormalizedPath, entry.name),
             "utf-8"
           );
         } catch (e) {
@@ -2964,9 +3189,9 @@ var reactRouterVitePlugin = () => {
         }
         let hash = (0, import_node_crypto.createHash)("sha384").update(contents).digest().toString("base64");
         let filepath = getVite().normalizePath(
-          path6.relative(
+          path7.relative(
             clientBuildDirectory,
-            path6.join(entryNormalizedPath, entry.name)
+            path7.join(entryNormalizedPath, entry.name)
           )
         );
         sriManifest[`${ctx2.publicPath}${filepath}`] = `sha384-${hash}`;
@@ -2999,7 +3224,7 @@ var reactRouterVitePlugin = () => {
     );
     let enforceSplitRouteModules = ctx.reactRouterConfig.future.v8_splitRouteModules === "enforce";
     for (let route of Object.values(ctx.reactRouterConfig.routes)) {
-      let routeFile = path6.join(ctx.reactRouterConfig.appDirectory, route.file);
+      let routeFile = path7.join(ctx.reactRouterConfig.appDirectory, route.file);
       let sourceExports = routeManifestExports[route.id];
       let hasClientAction = sourceExports.includes("clientAction");
       let hasClientLoader = sourceExports.includes("clientLoader");
@@ -3034,6 +3259,7 @@ var reactRouterVitePlugin = () => {
         hasClientAction,
         hasClientLoader,
         hasClientMiddleware,
+        hasDefaultExport: sourceExports.includes("default"),
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         ...getReactRouterManifestBuildAssets(
           ctx,
@@ -3071,7 +3297,7 @@ var reactRouterVitePlugin = () => {
     }
     let fingerprintedValues = { entry, routes: browserRoutes };
     let version = getHash(JSON.stringify(fingerprintedValues), 8);
-    let manifestPath = path6.posix.join(
+    let manifestPath = path7.posix.join(
       viteConfig2.build.assetsDir,
       `manifest-${version}.js`
     );
@@ -3083,7 +3309,7 @@ var reactRouterVitePlugin = () => {
       sri: void 0
     };
     await writeFileSafe(
-      path6.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
+      path7.join(getClientBuildDirectory(ctx.reactRouterConfig), manifestPath),
       `window.__reactRouterManifest=${JSON.stringify(
         reactRouterBrowserManifest
       )};`
@@ -3159,6 +3385,7 @@ var reactRouterVitePlugin = () => {
         hasClientAction,
         hasClientLoader,
         hasClientMiddleware,
+        hasDefaultExport: sourceExports.includes("default"),
         hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
         imports: []
       };
@@ -3541,31 +3768,61 @@ var reactRouterVitePlugin = () => {
         };
       },
       configurePreviewServer(previewServer) {
+        let cachedHandler = null;
+        async function getHandler() {
+          if (cachedHandler) return cachedHandler;
+          let serverBuildFiles = [];
+          let buildManifest = ctx.buildManifest ?? (ctx.reactRouterConfig.serverBundles ? await getBuildManifest({
+            reactRouterConfig: ctx.reactRouterConfig,
+            rootDirectory: ctx.rootDirectory
+          }) : null);
+          if (buildManifest?.serverBundles) {
+            for (let bundle of Object.values(buildManifest.serverBundles)) {
+              serverBuildFiles.push(
+                path7.resolve(ctx.rootDirectory, bundle.file)
+              );
+            }
+          } 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"));
+          }
+          cachedHandler = async (request, loadContext) => {
+            let response;
+            for (let handler of handlers) {
+              response = await handler(request, loadContext);
+              if (response.status !== 404) {
+                return response;
+              }
+            }
+            if (response) {
+              return response;
+            }
+            throw new Error("No handlers were found for the request.");
+          };
+          return cachedHandler;
+        }
         return () => {
           if (!ctx.reactRouterConfig.ssr) {
             return;
           }
           previewServer.middlewares.use(async (req, res, next) => {
             try {
-              let serverBuildDirectory = getServerBuildDirectory(
-                ctx.reactRouterConfig
-              );
-              let serverBuildFile = path6.resolve(
-                serverBuildDirectory,
-                "index.js"
+              let handler = await getHandler();
+              let request = await fromNodeRequest(req, res);
+              let response = await handler(
+                request,
+                await reactRouterDevLoadContext(request)
               );
-              let build = await import(url.pathToFileURL(serverBuildFile).href);
-              let handler = (0, import_react_router2.createRequestHandler)(build, "production");
-              let nodeHandler = async (nodeReq, nodeRes) => {
-                let req2 = await fromNodeRequest(nodeReq, nodeRes);
-                let res2 = await handler(
-                  req2,
-                  await reactRouterDevLoadContext(req2)
-                );
-                const { sendResponse } = await import("@remix-run/node-fetch-server");
-                await sendResponse(nodeRes, res2);
-              };
-              await nodeHandler(req, res);
+              const { sendResponse } = await import("@remix-run/node-fetch-server");
+              await sendResponse(res, response);
             } catch (error) {
               next(error);
             }
@@ -3592,19 +3849,19 @@ var reactRouterVitePlugin = () => {
           let removedAssetPaths = [];
           let copiedAssetPaths = [];
           for (let ssrAssetPath of ssrAssetPaths) {
-            let src = path6.join(serverBuildDirectory, ssrAssetPath);
-            let dest = path6.join(clientBuildDirectory, ssrAssetPath);
+            let src = path7.join(serverBuildDirectory, ssrAssetPath);
+            let dest = path7.join(clientBuildDirectory, ssrAssetPath);
             if (!userSsrEmitAssets) {
               if (!(0, import_node_fs2.existsSync)(dest)) {
-                await (0, import_promises2.mkdir)(path6.dirname(dest), { recursive: true });
-                await (0, import_promises2.rename)(src, dest);
+                await (0, import_promises3.mkdir)(path7.dirname(dest), { recursive: true });
+                await (0, import_promises3.rename)(src, dest);
                 movedAssetPaths.push(dest);
               } else {
-                await (0, import_promises2.rm)(src, { force: true, recursive: true });
+                await (0, import_promises3.rm)(src, { force: true, recursive: true });
                 removedAssetPaths.push(dest);
               }
             } else if (!(0, import_node_fs2.existsSync)(dest)) {
-              await (0, import_promises2.cp)(src, dest, { recursive: true });
+              await (0, import_promises3.cp)(src, dest, { recursive: true });
               copiedAssetPaths.push(dest);
             }
           }
@@ -3614,21 +3871,21 @@ var reactRouterVitePlugin = () => {
             );
             await Promise.all(
               ssrCssPaths.map(async (cssPath) => {
-                let src = path6.join(serverBuildDirectory, cssPath);
-                await (0, import_promises2.rm)(src, { force: true, recursive: true });
+                let src = path7.join(serverBuildDirectory, cssPath);
+                await (0, import_promises3.rm)(src, { force: true, recursive: true });
                 removedAssetPaths.push(src);
               })
             );
           }
           let cleanedAssetPaths = [...removedAssetPaths, ...movedAssetPaths];
           let handledAssetPaths = [...cleanedAssetPaths, ...copiedAssetPaths];
-          let cleanedAssetDirs = new Set(cleanedAssetPaths.map(path6.dirname));
+          let cleanedAssetDirs = new Set(cleanedAssetPaths.map(path7.dirname));
           await Promise.all(
             Array.from(cleanedAssetDirs).map(async (dir) => {
               try {
-                const files = await (0, import_promises2.readdir)(dir, { recursive: true });
+                const files = await (0, import_promises3.readdir)(dir, { recursive: true });
                 if (files.length === 0) {
-                  await (0, import_promises2.rm)(dir, { force: true, recursive: true });
+                  await (0, import_promises3.rm)(dir, { force: true, recursive: true });
                 }
               } catch {
               }
@@ -3644,7 +3901,7 @@ var reactRouterVitePlugin = () => {
                 [
                   `${import_picocolors4.default.green("\u2713")} ${message}`,
                   ...paths.map(
-                    (assetPath) => import_picocolors4.default.dim(path6.relative(ctx.rootDirectory, assetPath))
+                    (assetPath) => import_picocolors4.default.dim(path7.relative(ctx.rootDirectory, assetPath))
                   )
                 ].join("\n")
               );
@@ -3665,6 +3922,9 @@ var reactRouterVitePlugin = () => {
           if (handledAssetPaths.length) {
             viteConfig.logger.info("");
           }
+          if (future.unstable_previewServerPrerendering) {
+            return;
+          }
           process.env.IS_RR_BUILD_REQUEST = "yes";
           if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
             await handlePrerender(
@@ -3738,7 +3998,7 @@ var reactRouterVitePlugin = () => {
         );
         let isMainChunkExport = (name) => !chunkedExports.includes(name);
         let mainChunkReexports = sourceExports.filter(isMainChunkExport).join(", ");
-        let chunkBasePath = `./${path6.basename(id)}`;
+        let chunkBasePath = `./${path7.basename(id)}`;
         return [
           `export { ${mainChunkReexports} } from "${getRouteChunkModuleId(
             chunkBasePath,
@@ -3758,7 +4018,7 @@ var reactRouterVitePlugin = () => {
       async transform(code, id, options) {
         if (!id.endsWith(BUILD_CLIENT_ROUTE_QUERY_STRING)) return;
         let routeModuleId = id.replace(BUILD_CLIENT_ROUTE_QUERY_STRING, "");
-        let routeFileName = path6.basename(routeModuleId);
+        let routeFileName = path7.basename(routeModuleId);
         let sourceExports = await getRouteModuleExports(
           viteChildCompiler,
           ctx,
@@ -3838,6 +4098,7 @@ var reactRouterVitePlugin = () => {
               viteConfig,
               routeIds
             })).reactRouterServerManifest : await getReactRouterManifestForDev();
+            ctx.reactRouterManifest = reactRouterManifest;
             if (!ctx.reactRouterConfig.ssr) {
               invariant(viteConfig);
               validateSsrFalsePrerenderExports(
@@ -3885,7 +4146,7 @@ var reactRouterVitePlugin = () => {
         }
         let vite2 = getVite();
         let importerShort = vite2.normalizePath(
-          path6.relative(ctx.rootDirectory, importer)
+          path7.relative(ctx.rootDirectory, importer)
         );
         if (isRoute(ctx.reactRouterConfig, importer)) {
           let serverOnlyExports = SERVER_ONLY_ROUTE_EXPORTS.map(
@@ -4007,17 +4268,17 @@ var reactRouterVitePlugin = () => {
       },
       async load(id) {
         if (id !== virtualHmrRuntime.resolvedId) return;
-        let reactRefreshDir = path6.dirname(
+        let reactRefreshDir = path7.dirname(
           require.resolve("react-refresh/package.json")
         );
-        let reactRefreshRuntimePath = path6.join(
+        let reactRefreshRuntimePath = path7.join(
           reactRefreshDir,
           "cjs/react-refresh-runtime.development.js"
         );
         return [
           "const exports = {}",
-          await (0, import_promises2.readFile)(reactRefreshRuntimePath, "utf8"),
-          await (0, import_promises2.readFile)(require.resolve("./static/refresh-utils.mjs"), "utf8"),
+          await (0, import_promises3.readFile)(reactRefreshRuntimePath, "utf8"),
+          await (0, import_promises3.readFile)(require.resolve("./static/refresh-utils.mjs"), "utf8"),
           "export default exports"
         ].join("\n");
       }
@@ -4117,6 +4378,223 @@ var reactRouterVitePlugin = () => {
         }
       }
     },
+    prerender({
+      config() {
+        process.env.IS_RR_BUILD_REQUEST = "yes";
+        return {
+          // Required as viteConfig.environments.client.build.outDir is only available in Vite v6+
+          buildDirectory: getClientBuildDirectory(ctx.reactRouterConfig),
+          concurrency: getPrerenderConcurrencyConfig(ctx.reactRouterConfig)
+        };
+      },
+      async requests() {
+        invariant(viteConfig);
+        let { future } = ctx.reactRouterConfig;
+        if (future.v8_viteEnvironmentApi ? this.environment.name === "client" : !viteConfigEnv.isSsrBuild) {
+          return [];
+        }
+        if (!future.unstable_previewServerPrerendering) {
+          return [];
+        }
+        let requests = [];
+        if (isPrerenderingEnabled(ctx.reactRouterConfig)) {
+          invariant(ctx.prerenderPaths !== null, "Prerender paths missing");
+          invariant(
+            ctx.reactRouterManifest !== null,
+            "Prerender manifest missing"
+          );
+          let { reactRouterConfig, reactRouterManifest, prerenderPaths } = ctx;
+          assertPrerenderPathsMatchRoutes(
+            reactRouterConfig,
+            Array.from(prerenderPaths)
+          );
+          let buildRoutes = createPrerenderRoutes(reactRouterManifest.routes);
+          for (let prerenderPath of prerenderPaths) {
+            let matches = (0, import_react_router2.matchRoutes)(
+              buildRoutes,
+              `/${prerenderPath}/`.replace(/^\/\/+/, "/")
+            );
+            if (!matches) {
+              continue;
+            }
+            let leafRoute = matches[matches.length - 1].route;
+            let manifestRoute = reactRouterManifest.routes[leafRoute.id];
+            let isResourceRoute = manifestRoute && !manifestRoute.hasDefaultExport && !manifestRoute.hasErrorBoundary;
+            if (isResourceRoute) {
+              if (manifestRoute?.hasLoader) {
+                requests.push(
+                  // Prerender a .data file for turbo-stream consumption
+                  createDataRequest(
+                    prerenderPath,
+                    reactRouterConfig,
+                    [leafRoute.id],
+                    true
+                  ),
+                  // Prerender a raw file for external consumption
+                  createResourceRouteRequest(prerenderPath, reactRouterConfig)
+                );
+              } else {
+                viteConfig.logger.warn(
+                  `\u26A0\uFE0F Skipping prerendering for resource route without a loader: ${leafRoute.id}`
+                );
+              }
+            } else {
+              let hasLoaders = matches.some(
+                (m) => reactRouterManifest.routes[m.route.id]?.hasLoader
+              );
+              if (hasLoaders) {
+                requests.push(
+                  createDataRequest(prerenderPath, reactRouterConfig, null)
+                );
+              } else {
+                requests.push(
+                  createRouteRequest(prerenderPath, reactRouterConfig)
+                );
+              }
+            }
+          }
+        }
+        if (!ctx.reactRouterConfig.ssr) {
+          requests.push(createSpaModeRequest(ctx.reactRouterConfig));
+        }
+        return requests;
+      },
+      async postProcess(request, response, metadata) {
+        invariant(metadata);
+        if (metadata.type === "data") {
+          let pathname2 = new URL(request.url).pathname;
+          if (response.status !== 200 && response.status !== 202) {
+            throw new Error(
+              `Prerender (data): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${metadata.path}\` path.
+${pathname2}`,
+              { cause: response }
+            );
+          }
+          let data = await response.text();
+          return {
+            files: [
+              {
+                path: pathname2,
+                contents: data
+              }
+            ],
+            // After saving the .data file, request the HTML page.
+            // The data is passed along to be embedded in the response header.
+            requests: !metadata.isResourceRoute ? [createRouteRequest(metadata.path, ctx.reactRouterConfig, data)] : []
+          };
+        }
+        if (metadata.type === "resource") {
+          let pathname2 = new URL(request.url).pathname;
+          let contents = new Uint8Array(await response.arrayBuffer());
+          if (response.status !== 200) {
+            throw new Error(
+              `Prerender (resource): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${pathname2}\` path.
+${new TextDecoder().decode(contents)}`
+            );
+          }
+          return [
+            {
+              path: pathname2,
+              contents
+            }
+          ];
+        }
+        let html = await response.text();
+        if (metadata.type === "spa") {
+          if (response.status !== 200) {
+            throw new Error(
+              `SPA Mode: Received a ${response.status} status code from \`entry.server.tsx\` while prerendering your SPA Fallback HTML file.
+` + html
+            );
+          }
+          if (!html.includes("window.__reactRouterContext =") || !html.includes("window.__reactRouterRouteModules =")) {
+            throw new Error(
+              "SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`."
+            );
+          }
+          return [
+            {
+              path: "/__spa-fallback.html",
+              contents: html
+            }
+          ];
+        }
+        let pathname = new URL(request.url).pathname;
+        if (redirectStatusCodes.has(response.status)) {
+          let location = response.headers.get("Location");
+          let delay = response.status === 302 ? 2 : 0;
+          html = `<!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>${pathname}</code> to <code>${location}</code>
+  </a>
+</body>
+</html>`;
+        } else if (response.status !== 200) {
+          throw new Error(
+            `Prerender (html): Received a ${response.status} status code from \`entry.server.tsx\` while prerendering the \`${pathname}\` path.
+${html}`
+          );
+        }
+        return [
+          {
+            path: `${pathname}/index.html`,
+            contents: html
+          }
+        ];
+      },
+      logFile(outputPath, metadata) {
+        invariant(viteConfig);
+        invariant(metadata);
+        if (metadata.type === "spa") {
+          return;
+        }
+        viteConfig.logger.info(
+          `Prerender (${metadata.type}): ${metadata.path} -> ${import_picocolors4.default.bold(outputPath)}`
+        );
+      },
+      async finalize(buildDirectory) {
+        invariant(viteConfig);
+        let { ssr, future } = ctx.reactRouterConfig;
+        if (!ssr) {
+          let spaFallback = path7.join(buildDirectory, "__spa-fallback.html");
+          let index = path7.join(buildDirectory, "index.html");
+          let finalSpaPath;
+          if ((0, import_node_fs2.existsSync)(spaFallback) && !(0, import_node_fs2.existsSync)(index)) {
+            await (0, import_promises3.rename)(spaFallback, index);
+            finalSpaPath = index;
+          } else if ((0, import_node_fs2.existsSync)(spaFallback)) {
+            finalSpaPath = spaFallback;
+          }
+          if (finalSpaPath) {
+            let prettyPath = path7.relative(viteConfig.root, finalSpaPath);
+            if (ctx.prerenderPaths && ctx.prerenderPaths.size > 0) {
+              viteConfig.logger.info(
+                `Prerender (html): SPA Fallback -> ${import_picocolors4.default.bold(prettyPath)}`
+              );
+            } else {
+              viteConfig.logger.info(
+                `SPA Mode: Generated ${import_picocolors4.default.bold(prettyPath)}`
+              );
+            }
+          }
+          let serverBuildDirectory = future.v8_viteEnvironmentApi ? this.environment.config?.build?.outDir : ctx.environmentBuildContext?.options.build?.outDir ?? getServerBuildDirectory(ctx.reactRouterConfig);
+          viteConfig.logger.info(
+            [
+              "Removing the server build in",
+              import_picocolors4.default.green(serverBuildDirectory),
+              "due to ssr:false"
+            ].join(" ")
+          );
+          (0, import_node_fs2.rmSync)(serverBuildDirectory, { force: true, recursive: true });
+        }
+      }
+    }),
     validatePluginOrder(),
     warnOnClientSourceMaps()
   ];
@@ -4180,7 +4658,7 @@ if (import.meta.hot && !inWebWorker) {
 function getRoute(pluginConfig, file) {
   let vite2 = getVite();
   let routePath = vite2.normalizePath(
-    path6.relative(pluginConfig.appDirectory, file)
+    path7.relative(pluginConfig.appDirectory, file)
   );
   let route = Object.values(pluginConfig.routes).find(
     (r) => vite2.normalizePath(r.file) === routePath
@@ -4219,7 +4697,7 @@ async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteF
     caseSensitive: route.caseSensitive,
     url: combineURLs(
       ctx.publicPath,
-      "/" + path6.relative(
+      "/" + path7.relative(
         ctx.rootDirectory,
         resolveRelativeRouteFilePath(route, ctx.reactRouterConfig)
       )
@@ -4235,6 +4713,7 @@ async function getRouteMetadata(cache, ctx, viteChildCompiler, route, readRouteF
     hasLoader: sourceExports.includes("loader"),
     hasClientLoader: sourceExports.includes("clientLoader"),
     hasClientMiddleware: sourceExports.includes("clientMiddleware"),
+    hasDefaultExport: sourceExports.includes("default"),
     hasErrorBoundary: sourceExports.includes("ErrorBoundary"),
     imports: []
   };
@@ -4247,7 +4726,7 @@ function isSpaModeEnabled(reactRouterConfig) {
   return reactRouterConfig.ssr === false && !isPrerenderingEnabled(reactRouterConfig);
 }
 async function getPrerenderBuildAndHandler(viteConfig, serverBuildDirectory, serverBuildFile) {
-  let serverBuildPath = path6.join(serverBuildDirectory, serverBuildFile);
+  let serverBuildPath = path7.join(serverBuildDirectory, serverBuildFile);
   let build = await import(url.pathToFileURL(serverBuildPath).toString());
   let { createRequestHandler: createHandler } = await import("react-router");
   return {
@@ -4289,9 +4768,9 @@ async function handleSpaMode(viteConfig, reactRouterConfig, serverBuildDirectory
       "SPA Mode: Did you forget to include `<Scripts/>` in your root route? Your pre-rendered HTML cannot hydrate without `<Scripts />`."
     );
   }
-  await (0, import_promises2.writeFile)(path6.join(clientBuildDirectory, filename2), html);
-  let prettyDir = path6.relative(viteConfig.root, clientBuildDirectory);
-  let prettyPath = path6.join(prettyDir, filename2);
+  await (0, import_promises3.writeFile)(path7.join(clientBuildDirectory, filename2), html);
+  let prettyDir = path7.relative(viteConfig.root, clientBuildDirectory);
+  let prettyPath = path7.join(prettyDir, filename2);
   if (build.prerender.length > 0) {
     viteConfig.logger.info(
       `Prerender (html): SPA Fallback -> ${import_picocolors4.default.bold(prettyPath)}`
@@ -4307,17 +4786,17 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     serverBuildPath
   );
   let routes = createPrerenderRoutes(reactRouterConfig.routes);
-  for (let path9 of build.prerender) {
-    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path9}/`.replace(/^\/\/+/, "/"));
+  for (let path10 of build.prerender) {
+    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path10}/`.replace(/^\/\/+/, "/"));
     if (!matches) {
       throw new Error(
-        `Unable to prerender path because it does not match any routes: ${path9}`
+        `Unable to prerender path because it does not match any routes: ${path10}`
       );
     }
   }
   let buildRoutes = createPrerenderRoutes(build.routes);
-  let prerenderSinglePath = async (path9) => {
-    let matches = (0, import_react_router2.matchRoutes)(buildRoutes, `/${path9}/`.replace(/^\/\/+/, "/"));
+  let prerenderSinglePath = async (path10) => {
+    let matches = (0, import_react_router2.matchRoutes)(buildRoutes, `/${path10}/`.replace(/^\/\/+/, "/"));
     if (!matches) {
       return;
     }
@@ -4330,7 +4809,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       if (manifestRoute.loader) {
         await prerenderData(
           handler,
-          path9,
+          path10,
           [leafRoute.id],
           clientBuildDirectory,
           reactRouterConfig,
@@ -4338,7 +4817,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
         );
         await prerenderResourceRoute(
           handler,
-          path9,
+          path10,
           clientBuildDirectory,
           reactRouterConfig,
           viteConfig
@@ -4356,7 +4835,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       if (!isResourceRoute && hasLoaders) {
         data = await prerenderData(
           handler,
-          path9,
+          path10,
           null,
           clientBuildDirectory,
           reactRouterConfig,
@@ -4365,7 +4844,7 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
       }
       await prerenderRoute(
         handler,
-        path9,
+        path10,
         clientBuildDirectory,
         reactRouterConfig,
         viteConfig,
@@ -4378,9 +4857,9 @@ async function handlePrerender(viteConfig, reactRouterConfig, serverBuildDirecto
     }
   };
   let concurrency = 1;
-  let { prerender } = reactRouterConfig;
-  if (typeof prerender === "object" && "unstable_concurrency" in prerender) {
-    concurrency = prerender.unstable_concurrency ?? 1;
+  let { prerender: prerender2 } = reactRouterConfig;
+  if (typeof prerender2 === "object" && "unstable_concurrency" in prerender2) {
+    concurrency = prerender2.unstable_concurrency ?? 1;
   }
   const pMap = await import("p-map");
   await pMap.default(build.prerender, prerenderSinglePath, { concurrency });
@@ -4439,12 +4918,12 @@ async function prerenderData(handler, prerenderPath, onlyRoutes, clientBuildDire
 ${normalizedPath}`
     );
   }
-  let outfile = path6.join(clientBuildDirectory, ...normalizedPath.split("/"));
-  await (0, import_promises2.mkdir)(path6.dirname(outfile), { recursive: true });
-  await (0, import_promises2.writeFile)(outfile, data);
+  let outfile = path7.join(clientBuildDirectory, ...normalizedPath.split("/"));
+  await (0, import_promises3.mkdir)(path7.dirname(outfile), { recursive: true });
+  await (0, import_promises3.writeFile)(outfile, data);
   viteConfig.logger.info(
     `Prerender (data): ${prerenderPath} -> ${import_picocolors4.default.bold(
-      path6.relative(viteConfig.root, outfile)
+      path7.relative(viteConfig.root, outfile)
     )}`
   );
   return data;
@@ -4479,16 +4958,16 @@ async function prerenderRoute(handler, prerenderPath, clientBuildDirectory, reac
 ${html}`
     );
   }
-  let outfile = path6.join(
+  let outfile = path7.join(
     clientBuildDirectory,
     ...normalizedPath.split("/"),
     "index.html"
   );
-  await (0, import_promises2.mkdir)(path6.dirname(outfile), { recursive: true });
-  await (0, import_promises2.writeFile)(outfile, html);
+  await (0, import_promises3.mkdir)(path7.dirname(outfile), { recursive: true });
+  await (0, import_promises3.writeFile)(outfile, html);
   viteConfig.logger.info(
     `Prerender (html): ${prerenderPath} -> ${import_picocolors4.default.bold(
-      path6.relative(viteConfig.root, outfile)
+      path7.relative(viteConfig.root, outfile)
     )}`
   );
 }
@@ -4503,24 +4982,24 @@ async function prerenderResourceRoute(handler, prerenderPath, clientBuildDirecto
 ${content.toString("utf8")}`
     );
   }
-  let outfile = path6.join(clientBuildDirectory, ...normalizedPath.split("/"));
-  await (0, import_promises2.mkdir)(path6.dirname(outfile), { recursive: true });
-  await (0, import_promises2.writeFile)(outfile, content);
+  let outfile = path7.join(clientBuildDirectory, ...normalizedPath.split("/"));
+  await (0, import_promises3.mkdir)(path7.dirname(outfile), { recursive: true });
+  await (0, import_promises3.writeFile)(outfile, content);
   viteConfig.logger.info(
     `Prerender (resource): ${prerenderPath} -> ${import_picocolors4.default.bold(
-      path6.relative(viteConfig.root, outfile)
+      path7.relative(viteConfig.root, outfile)
     )}`
   );
 }
-async function getPrerenderPaths(prerender, ssr, routes, logWarning = false) {
-  if (prerender == null || prerender === false) {
+async function getPrerenderPaths(prerender2, ssr, routes, logWarning = false) {
+  if (prerender2 == null || prerender2 === false) {
     return [];
   }
   let pathsConfig;
-  if (typeof prerender === "object" && "paths" in prerender) {
-    pathsConfig = prerender.paths;
+  if (typeof prerender2 === "object" && "paths" in prerender2) {
+    pathsConfig = prerender2.paths;
   } else {
-    pathsConfig = prerender;
+    pathsConfig = prerender2;
   }
   if (pathsConfig === false) {
     return [];
@@ -4591,14 +5070,14 @@ async function validateSsrFalsePrerenderExports(viteConfig, ctx, manifest, viteC
   }
   let prerenderRoutes = createPrerenderRoutes(manifest.routes);
   let prerenderedRoutes = /* @__PURE__ */ new Set();
-  for (let path9 of prerenderPaths) {
+  for (let path10 of prerenderPaths) {
     let matches = (0, import_react_router2.matchRoutes)(
       prerenderRoutes,
-      `/${path9}/`.replace(/^\/\/+/, "/")
+      `/${path10}/`.replace(/^\/\/+/, "/")
     );
     invariant(
       matches,
-      `Unable to prerender path because it does not match any routes: ${path9}`
+      `Unable to prerender path because it does not match any routes: ${path10}`
     );
     matches.forEach((m) => prerenderedRoutes.add(m.route.id));
   }
@@ -4765,11 +5244,11 @@ function validateRouteChunks({
 async function cleanBuildDirectory(viteConfig, ctx) {
   let buildDirectory = ctx.reactRouterConfig.buildDirectory;
   let isWithinRoot = () => {
-    let relativePath = path6.relative(ctx.rootDirectory, buildDirectory);
-    return !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
+    let relativePath = path7.relative(ctx.rootDirectory, buildDirectory);
+    return !relativePath.startsWith("..") && !path7.isAbsolute(relativePath);
   };
   if (viteConfig.build.emptyOutDir ?? isWithinRoot()) {
-    await (0, import_promises2.rm)(buildDirectory, { force: true, recursive: true });
+    await (0, import_promises3.rm)(buildDirectory, { force: true, recursive: true });
   }
 }
 async function cleanViteManifests(environmentsOptions, ctx) {
@@ -4777,7 +5256,7 @@ async function cleanViteManifests(environmentsOptions, ctx) {
     ([environmentName, options]) => {
       let outDir = options.build?.outDir;
       invariant(outDir, `Expected build.outDir for ${environmentName}`);
-      return path6.join(outDir, ".vite/manifest.json");
+      return path7.join(outDir, ".vite/manifest.json");
     }
   );
   await Promise.all(
@@ -4785,12 +5264,12 @@ async function cleanViteManifests(environmentsOptions, ctx) {
       let manifestExists = (0, import_node_fs2.existsSync)(viteManifestPath);
       if (!manifestExists) return;
       if (!ctx.viteManifestEnabled) {
-        await (0, import_promises2.rm)(viteManifestPath, { force: true, recursive: true });
+        await (0, import_promises3.rm)(viteManifestPath, { force: true, recursive: true });
       }
-      let viteDir = path6.dirname(viteManifestPath);
-      let viteDirFiles = await (0, import_promises2.readdir)(viteDir, { recursive: true });
+      let viteDir = path7.dirname(viteManifestPath);
+      let viteDirFiles = await (0, import_promises3.readdir)(viteDir, { recursive: true });
       if (viteDirFiles.length === 0) {
-        await (0, import_promises2.rm)(viteDir, { force: true, recursive: true });
+        await (0, import_promises3.rm)(viteDir, { force: true, recursive: true });
       }
     })
   );
@@ -4805,12 +5284,12 @@ async function getBuildManifest({
   }
   let { normalizePath } = await import("vite");
   let serverBuildDirectory = getServerBuildDirectory(reactRouterConfig);
-  let resolvedAppDirectory = path6.resolve(rootDirectory, appDirectory);
+  let resolvedAppDirectory = path7.resolve(rootDirectory, appDirectory);
   let rootRelativeRoutes = Object.fromEntries(
     Object.entries(routes).map(([id, route]) => {
-      let filePath = path6.join(resolvedAppDirectory, route.file);
+      let filePath = path7.join(resolvedAppDirectory, route.file);
       let rootRelativeFilePath = normalizePath(
-        path6.relative(rootDirectory, filePath)
+        path7.relative(rootDirectory, filePath)
       );
       return [id, { ...route, file: rootRelativeFilePath }];
     })
@@ -4828,7 +5307,7 @@ async function getBuildManifest({
           (route2) => configRouteToBranchRoute({
             ...route2,
             // Ensure absolute paths are passed to the serverBundles function
-            file: path6.join(resolvedAppDirectory, route2.file)
+            file: path7.join(resolvedAppDirectory, route2.file)
           })
         )
       });
@@ -4852,10 +5331,10 @@ async function getBuildManifest({
       buildManifest.serverBundles[serverBundleId] ??= {
         id: serverBundleId,
         file: normalizePath(
-          path6.join(
-            path6.relative(
+          path7.join(
+            path7.relative(
               rootDirectory,
-              path6.join(serverBuildDirectory, serverBundleId)
+              path7.join(serverBuildDirectory, serverBundleId)
             ),
             reactRouterConfig.serverBuildFile
           )
@@ -4874,10 +5353,10 @@ function mergeEnvironmentOptions(base, ...overrides) {
 }
 async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
   let { serverBuildFile, serverModuleFormat } = ctx.reactRouterConfig;
-  let packageRoot = path6.dirname(
+  let packageRoot = path7.dirname(
     require.resolve("@react-router/dev/package.json")
   );
-  let { moduleSyncEnabled } = await import(`file:///${path6.join(packageRoot, "module-sync-enabled/index.mjs")}`);
+  let { moduleSyncEnabled } = await import(`file:///${path7.join(packageRoot, "module-sync-enabled/index.mjs")}`);
   let vite2 = getVite();
   function getBaseOptions({
     viteUserConfig
@@ -4956,7 +5435,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
             ctx.entryClientFilePath,
             ...Object.values(ctx.reactRouterConfig.routes).flatMap(
               (route) => {
-                let routeFilePath = path6.resolve(
+                let routeFilePath = path7.resolve(
                   ctx.reactRouterConfig.appDirectory,
                   route.file
                 );
@@ -4980,7 +5459,7 @@ async function getEnvironmentOptionsResolvers(ctx, viteCommand) {
               ) : null;
               let routeChunkSuffix = routeChunkName ? `-${(0, import_kebabCase.default)(routeChunkName)}` : "";
               let assetsDir = (ctx.reactRouterConfig.future.v8_viteEnvironmentApi ? viteUserConfig?.environments?.client?.build?.assetsDir : null) ?? viteUserConfig?.build?.assetsDir ?? "assets";
-              return path6.posix.join(
+              return path7.posix.join(
                 assetsDir,
                 `[name]${routeChunkSuffix}-[hash].js`
               );
@@ -5046,13 +5525,78 @@ async function asyncFlatten(arr) {
   } while (arr.some((v2) => v2?.then));
   return arr;
 }
+function assertPrerenderPathsMatchRoutes(config, prerenderPaths) {
+  let routes = createPrerenderRoutes(config.routes);
+  for (let path10 of prerenderPaths) {
+    let matches = (0, import_react_router2.matchRoutes)(routes, `/${path10}/`.replace(/^\/\/+/, "/"));
+    if (!matches) {
+      throw new Error(
+        `Unable to prerender path because it does not match any routes: ${path10}`
+      );
+    }
+  }
+}
+function getPrerenderConcurrencyConfig(reactRouterConfig) {
+  let concurrency = 1;
+  let { prerender: prerender2 } = reactRouterConfig;
+  if (typeof prerender2 === "object" && "unstable_concurrency" in prerender2) {
+    concurrency = prerender2.unstable_concurrency ?? 1;
+  }
+  return concurrency;
+}
+function createDataRequest(prerenderPath, reactRouterConfig, onlyRoutes, isResourceRoute) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath === "/" ? "/_root.data" : `${prerenderPath.replace(/\/$/, "")}.data`}`.replace(/\/\/+/g, "/");
+  let url2 = new URL(`http://localhost${normalizedPath}`);
+  if (onlyRoutes?.length) {
+    url2.searchParams.set("_routes", onlyRoutes.join(","));
+  }
+  return {
+    request: new Request(url2),
+    metadata: { type: "data", path: prerenderPath, isResourceRoute }
+  };
+}
+function createRouteRequest(prerenderPath, reactRouterConfig, data) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(
+    /\/\/+/g,
+    "/"
+  );
+  let headers = new Headers();
+  if (data) {
+    let encodedData = encodeURI(data);
+    if (encodedData.length < 8 * 1024) {
+      headers.set("X-React-Router-Prerender-Data", encodedData);
+    }
+  }
+  return {
+    request: new Request(`http://localhost${normalizedPath}`, { headers }),
+    metadata: { type: "html", path: prerenderPath }
+  };
+}
+function createResourceRouteRequest(prerenderPath, reactRouterConfig, requestInit) {
+  let normalizedPath = `${reactRouterConfig.basename}${prerenderPath}/`.replace(/\/\/+/g, "/").replace(/\/$/g, "");
+  return {
+    request: new Request(`http://localhost${normalizedPath}`, requestInit),
+    metadata: { type: "resource", path: prerenderPath }
+  };
+}
+function createSpaModeRequest(reactRouterConfig) {
+  return {
+    request: new Request(`http://localhost${reactRouterConfig.basename}`, {
+      headers: {
+        // Enable SPA mode in the server runtime and only render down to the root
+        "X-React-Router-SPA-Mode": "yes"
+      }
+    }),
+    metadata: { type: "spa", path: "/" }
+  };
+}
 
 // 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_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_pathe6 = __toESM(require("pathe"));
 
 // vite/rsc/virtual-route-config.ts
@@ -5763,8 +6307,8 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
         );
         return [
           "const exports = {}",
-          await (0, import_promises3.readFile)(reactRefreshRuntimePath, "utf8"),
-          await (0, import_promises3.readFile)(
+          await (0, import_promises4.readFile)(reactRefreshRuntimePath, "utf8"),
+          await (0, import_promises4.readFile)(
             require.resolve("./static/rsc-refresh-utils.mjs"),
             "utf8"
           ),
@@ -5826,7 +6370,7 @@ ${errors.map((x) => ` - ${x}`).join("\n")}
           const normalizedPath = import_pathe6.default.normalize(mod.file);
           const routeId = routeIdByFile?.get(normalizedPath);
           if (routeId !== void 0) {
-            const routeSource = await (0, import_promises3.readFile)(normalizedPath, "utf8");
+            const routeSource = await (0, import_promises4.readFile)(normalizedPath, "utf8");
             const virtualRouteModuleCode = (await server.environments.rsc.pluginContainer.transform(
               routeSource,
               `${normalizedPath}?route-module`