fix(build): honor configured prerender output roots

Author: james-elicx

packages/cloudflare/src/deploy.ts

@@ -1992,6 +1992,7 @@ export async function deploy(options: DeployOptions): Promise<void> {
       root: info.root,
       concurrency: options.prerenderConcurrency,
       nextConfig,
+      routeRootConfig: viteConfigMetadata.routeRootConfig,
     });
     ranPrerender = true;
   }

packages/vinext/src/build/inject-pregenerated-paths.ts

@@ -18,10 +18,10 @@ const VINEXT_PREGEN_RE = new RegExp(
 export function injectPregeneratedConcretePaths(
   root: string,
   workerEntry = path.resolve(root, "dist", "server", "index.js"),
+  serverOutputDir = path.resolve(root, "dist", "server"),
 ): void {
-  const manifestDir = path.resolve(root, "dist", "server");
   const runtimeDir = path.dirname(workerEntry);
-  const manifest = readPrerenderManifest(path.join(manifestDir, "vinext-prerender.json"));
+  const manifest = readPrerenderManifest(path.join(serverOutputDir, "vinext-prerender.json"));
   const table = manifest?.pregeneratedConcretePaths ?? [];
 
   // Response-stage entries can be deployed independently of index.js. Keep the
@@ -30,14 +30,14 @@ export function injectPregeneratedConcretePaths(
   // The file is emitted during the server build; writing it after prerendering
   // updates the artifact without rebuilding or coupling core to a host
   // transport.
-  const runtimeModule = path.join(runtimeDir, PREGENERATED_CONCRETE_PATHS_MODULE);
-  fs.mkdirSync(runtimeDir, { recursive: true });
-  fs.writeFileSync(
-    runtimeModule,
+  const runtimeModuleCode =
     table.length > 0
       ? `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = ${JSON.stringify(table)};\n`
-      : "delete globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;\n",
-  );
+      : "delete globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;\n";
+  for (const outputDir of new Set([serverOutputDir, runtimeDir])) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(path.join(outputDir, PREGENERATED_CONCRETE_PATHS_MODULE), runtimeModuleCode);
+  }
 
   if (!fs.existsSync(workerEntry)) {
     if (table.length > 0) globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = table;

packages/vinext/src/build/run-prerender.ts

@@ -38,6 +38,7 @@ import { rememberCurrentServerEntryImportMtime, startProdServer } from "../serve
 import { enterPrerenderPhase } from "./prerender-phase.js";
 import { PHASE_PRODUCTION_BUILD } from "vinext/shims/constants";
 import { resolveBuiltRscEntryPath } from "./server-entry.js";
+import type { VinextRouteRootConfig } from "../config/prerender.js";
 
 // ─── Progress UI ──────────────────────────────────────────────────────────────
 
@@ -107,6 +108,8 @@ type RunPrerenderOptions = {
    * Intended for tests that build to a custom outDir.
    */
   rscBundlePath?: string;
+  /** Build output roots captured from the vinext Vite plugin. */
+  routeRootConfig?: VinextRouteRootConfig | null;
   /**
    * Maximum number of routes rendered in parallel.
    * Defaults to prerenderApp/prerenderPages internal defaults when omitted.
@@ -167,7 +170,10 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
   // The manifest lands in dist/server/ alongside the server bundle so it's
   // cleaned with the rest of vinext's build output on rebuild and co-located
   // with server artifacts.
-  const manifestDir = path.join(root, "dist", "server");
+  const manifestDir = path.resolve(
+    root,
+    options.routeRootConfig?.rscOutDir ?? path.join("dist", "server"),
+  );
   const rscBundlePath = options.rscBundlePath ?? resolveBuiltRscEntryPath(manifestDir);
   // The emitted entry may live below dist/server (for example entries/app.js).
   // Build metadata and prerender artifacts remain rooted at dist/server.
@@ -221,7 +227,7 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
   const outDir =
     mode === "export"
       ? path.join(root, "dist", "client")
-      : path.join(root, "dist", "server", "prerendered-routes");
+      : path.join(manifestDir, "prerendered-routes");
 
   // For hybrid builds (both app/ and pages/ present), start a single shared
   // prod server and pass it to both phases. This avoids spinning up two servers
@@ -311,8 +317,7 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
         ...(sharedProdServer
           ? { _prodServer: sharedProdServer, _prerenderSecret: sharedPrerenderSecret }
           : {
-              pagesBundlePath:
-                options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js"),
+              pagesBundlePath: options.pagesBundlePath ?? path.join(manifestDir, "entry.js"),
             }),
         onProgress: ({ total, route }) => {
           if (pagesTotal === 0) {
@@ -383,7 +388,7 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
     );
   }
 
-  injectPregeneratedConcretePaths(root, rscBundlePath);
+  injectPregeneratedConcretePaths(root, rscBundlePath, manifestDir);
   if (fs.existsSync(rscBundlePath)) {
     rememberCurrentServerEntryImportMtime(rscBundlePath);
   }

packages/vinext/src/cli.ts

@@ -736,6 +736,7 @@ async function buildApp() {
       root,
       concurrency: parsed.prerenderConcurrency,
       nextConfig: resolvedNextConfig,
+      routeRootConfig: buildConfigMetadata.routeRootConfig,
     });
     await emitPrerenderPathManifest({
       root,

tests/deploy-prerender-config.test.ts

@@ -264,6 +264,29 @@ describe("deploy prerender config wiring", () => {
     );
   });
 
+  it("passes configured build output roots to deploy prerendering", async () => {
+    writeProject("true");
+    const viteConfigPath = path.join(tmpDir, "vite.config.ts");
+    fs.writeFileSync(
+      viteConfigPath,
+      fs
+        .readFileSync(viteConfigPath, "utf-8")
+        .replace(
+          "vinext({ prerender: true",
+          'vinext({ rscOutDir: "build/application", prerender: true',
+        ),
+    );
+    const { deploy } = await import("../packages/cloudflare/src/deploy.js");
+
+    await deploy({ root: tmpDir, skipBuild: true });
+
+    expect(runPrerenderMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        routeRootConfig: expect.objectContaining({ rscOutDir: "build/application" }),
+      }),
+    );
+  });
+
   it("loads Vite config even when the prerender-all flag already decides prerendering", async () => {
     writeProject("true");
     fs.appendFileSync(

tests/inject-pregenerated-paths.test.ts

@@ -204,6 +204,12 @@ describe("injectPregeneratedConcretePaths", () => {
     expect(
       fs.existsSync(path.join(path.dirname(entryPath), PREGENERATED_CONCRETE_PATHS_MODULE)),
     ).toBe(true);
+    expect(
+      fs.readFileSync(
+        path.join(tmpDir, "dist/server", PREGENERATED_CONCRETE_PATHS_MODULE),
+        "utf-8",
+      ),
+    ).toContain("/blog/post-a");
     const applicationEntry: unknown = await import(
       `${pathToFileURL(entryPath).href}?t=${Date.now()}`
     );

tests/run-prerender-concurrency.test.ts

@@ -141,4 +141,44 @@ describe("runPrerender concurrency", () => {
       fs.rmSync(root, { recursive: true, force: true });
     }
   });
+
+  it("resolves App artifacts from the configured RSC output root", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "vinext-run-prerender-custom-rsc-"));
+    const serverDir = path.join(root, "build", "application");
+    const applicationEntry = path.join(serverDir, "entries", "application-entry.js");
+    fs.mkdirSync(path.join(root, "app"));
+    fs.mkdirSync(path.join(serverDir, ".vite"), { recursive: true });
+    fs.mkdirSync(path.dirname(applicationEntry), { recursive: true });
+    fs.writeFileSync(path.join(serverDir, "BUILD_ID"), "custom-build\n");
+    fs.writeFileSync(applicationEntry, "export {};\n");
+    fs.writeFileSync(
+      path.join(serverDir, ".vite", "manifest.json"),
+      JSON.stringify({
+        "virtual:vinext-rsc-entry": {
+          file: "entries/application-entry.js",
+          isDynamicEntry: true,
+        },
+      }),
+    );
+
+    try {
+      const { runPrerender } = await import("../packages/vinext/src/build/run-prerender.js");
+
+      await runPrerender({
+        root,
+        routeRootConfig: { rscOutDir: "build/application" },
+      });
+
+      expect(prerenderAppMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          rscBundlePath: applicationEntry,
+          serverDir,
+          outDir: path.join(serverDir, "prerendered-routes"),
+          config: expect.objectContaining({ buildId: "custom-build" }),
+        }),
+      );
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
 });