fix(build): preserve nested server artifact roots

Author: james-elicx

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

@@ -1231,6 +1231,7 @@ async function startPathDiscoveryServer(options: {
       ? path.dirname(path.dirname(options.pagesBundlePath))
       : path.dirname(options.serverDir),
     rscEntryPath: options.rscBundlePath,
+    serverDir: options.serverDir,
     serverEntryPath: options.pagesBundlePath,
     noCompression: true,
     purpose: "prerender",
@@ -1247,14 +1248,19 @@ export async function emitPrerenderPathManifest(
 
   if (!appDir && !pagesDir) return null;
 
-  const rscServerDir = options.routeRootConfig?.rscOutDir
+  const configuredRscServerDir = options.routeRootConfig?.rscOutDir
     ? path.resolve(root, options.routeRootConfig.rscOutDir)
     : path.join(root, "dist", "server");
-  const defaultRscBundlePath = resolveBuiltRscEntryPath(rscServerDir);
+  const defaultRscBundlePath = resolveBuiltRscEntryPath(configuredRscServerDir);
   const rscBundlePath = options.rscBundlePath ?? defaultRscBundlePath;
+  const relativeRscEntryPath = path.relative(configuredRscServerDir, rscBundlePath);
+  const rscServerDir =
+    !relativeRscEntryPath.startsWith("../") && !path.isAbsolute(relativeRscEntryPath)
+      ? configuredRscServerDir
+      : path.dirname(rscBundlePath);
   const pagesBundlePath = options.pagesBundlePath ?? path.join(root, "dist", "server", "entry.js");
   const bundleServerDir = fs.existsSync(rscBundlePath)
-    ? path.dirname(rscBundlePath)
+    ? rscServerDir
     : path.dirname(pagesBundlePath);
   const manifestDir = path.join(root, "dist", "server");
   const config = options.nextConfig

packages/vinext/src/build/prerender-server-entry.ts

@@ -9,7 +9,8 @@
  * over IPC. The parent then load-balances per-route fetches across the pool.
  *
  * `VINEXT_PRERENDER`, `NEXT_PHASE`, `VINEXT_PRERENDER_OUTDIR`, and the optional
- * `VINEXT_PRERENDER_RSC_ENTRY_PATH` are passed via the fork env so they are set
+ * `VINEXT_PRERENDER_RSC_ENTRY_PATH`, and `VINEXT_PRERENDER_SERVER_DIR` are
+ * passed via the fork env so they are set
  * before any module loads (some server and user modules read the phase at
  * import time).
  */
@@ -19,6 +20,7 @@ import { NoOpCacheHandler, setCacheHandler } from "vinext/shims/cache-handler";
 async function main(): Promise<void> {
   const outDir = process.env.VINEXT_PRERENDER_OUTDIR;
   const rscEntryPath = process.env.VINEXT_PRERENDER_RSC_ENTRY_PATH;
+  const serverDir = process.env.VINEXT_PRERENDER_SERVER_DIR;
   if (!outDir) {
     throw new Error("[vinext] prerender server worker: VINEXT_PRERENDER_OUTDIR not set");
   }
@@ -33,6 +35,7 @@ async function main(): Promise<void> {
     host: "127.0.0.1",
     outDir,
     ...(rscEntryPath ? { rscEntryPath } : {}),
+    ...(serverDir ? { serverDir } : {}),
     noCompression: true,
     purpose: "prerender",
     silent: true,

packages/vinext/src/build/prerender-server-pool.ts

@@ -126,9 +126,9 @@ function isWorkerTransportError(err: unknown): boolean {
 export async function startPrerenderServerPool(
   outDir: string,
   size: number,
-  options: { entry?: string; rscEntryPath?: string } = {},
+  options: { entry?: string; rscEntryPath?: string; serverDir?: string } = {},
 ): Promise<PrerenderServerPool> {
-  const { entry = WORKER_ENTRY, rscEntryPath } = options;
+  const { entry = WORKER_ENTRY, rscEntryPath, serverDir } = options;
   const children: ChildProcess[] = [];
   let shuttingDown = false;
   let crash: { port?: number; code: number | null; signal: NodeJS.Signals | null } | null = null;
@@ -149,6 +149,7 @@ export async function startPrerenderServerPool(
           NEXT_PHASE: PHASE_PRODUCTION_BUILD,
           VINEXT_PRERENDER_OUTDIR: outDir,
           ...(rscEntryPath ? { VINEXT_PRERENDER_RSC_ENTRY_PATH: rscEntryPath } : {}),
+          ...(serverDir ? { VINEXT_PRERENDER_SERVER_DIR: serverDir } : {}),
         },
         // Inherit stdout/stderr so server-side errors surface; keep IPC.
         stdio: ["ignore", "inherit", "inherit", "ipc"],

packages/vinext/src/build/prerender.ts

@@ -98,9 +98,10 @@ async function startOptionalPrerenderServerPool(
   outDir: string,
   poolSize: number,
   rscEntryPath?: string,
+  serverDir?: string,
 ): Promise<PrerenderServerPool | null> {
   try {
-    return await startPrerenderServerPool(outDir, poolSize, { rscEntryPath });
+    return await startPrerenderServerPool(outDir, poolSize, { rscEntryPath, serverDir });
   } catch (e) {
     // The pool is a performance optimization layered over the already-running
     // in-process prerender server. Startup failure is still before any route has
@@ -1131,6 +1132,7 @@ export async function prerenderApp({
             host: "127.0.0.1",
             outDir: path.dirname(serverDir),
             rscEntryPath: rscBundlePath,
+            serverDir,
             noCompression: true,
             purpose: "prerender",
           });
@@ -1807,6 +1809,7 @@ export async function prerenderApp({
           path.dirname(serverDir),
           poolSize,
           rscBundlePath,
+          serverDir,
         );
         if (renderPool) renderPorts = renderPool.ports;
       }

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

@@ -190,7 +190,7 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
   // output aligned with the bundle it was generated from. (Spreading
   // `loadedConfig` above is required so this assignment does not mutate the
   // shared loaded config.)
-  const builtBuildId = readBuiltBuildId(serverDir);
+  const builtBuildId = readBuiltBuildId(manifestDir) ?? readBuiltBuildId(serverDir);
   if (builtBuildId) {
     config.buildId = builtBuildId;
   }
@@ -243,6 +243,7 @@ export async function runPrerender(options: RunPrerenderOptions): Promise<Preren
         host: "127.0.0.1",
         outDir: path.dirname(serverDir),
         rscEntryPath: rscBundlePath,
+        serverDir,
         noCompression: true,
         purpose: "prerender",
       });

packages/vinext/src/server/prod-server.ts

@@ -278,6 +278,8 @@ export type ProdServerOptions = {
   outDir?: string;
   /** Explicit App Router RSC entry path. Defaults to `<outDir>/server/index.js`. */
   rscEntryPath?: string;
+  /** Directory containing server manifests, sidecars, and prerender artifacts. */
+  serverDir?: string;
   /** Explicit Pages Router server entry path. Defaults to `<outDir>/server/entry.js`. */
   serverEntryPath?: string;
   /** Disable compression (default: false) */
@@ -1266,6 +1268,7 @@ export async function startProdServer(options: ProdServerOptions = {}) {
     host = "0.0.0.0",
     outDir = path.resolve("dist"),
     rscEntryPath: explicitRscEntryPath,
+    serverDir: explicitServerDir,
     serverEntryPath: explicitServerEntryPath,
     noCompression = false,
     purpose,
@@ -1276,14 +1279,17 @@ export async function startProdServer(options: ProdServerOptions = {}) {
   // Always resolve outDir to absolute to ensure dynamic import() works
   const resolvedOutDir = path.resolve(outDir);
   const clientDir = path.join(resolvedOutDir, "client");
+  const serverDir = explicitServerDir
+    ? path.resolve(explicitServerDir)
+    : path.join(resolvedOutDir, "server");
 
   // Detect build type
   const rscEntryPath = explicitRscEntryPath
     ? path.resolve(explicitRscEntryPath)
-    : path.join(resolvedOutDir, "server", "index.js");
+    : path.join(serverDir, "index.js");
   const serverEntryPath = explicitServerEntryPath
     ? path.resolve(explicitServerEntryPath)
-    : path.join(resolvedOutDir, "server", "entry.js");
+    : path.join(serverDir, "entry.js");
   const isAppRouter = fs.existsSync(rscEntryPath);
 
   if (!isAppRouter && !fs.existsSync(serverEntryPath)) {
@@ -1293,7 +1299,16 @@ export async function startProdServer(options: ProdServerOptions = {}) {
   }
 
   if (isAppRouter) {
-    return startAppRouterServer({ port, host, clientDir, rscEntryPath, compress, purpose, silent });
+    return startAppRouterServer({
+      port,
+      host,
+      clientDir,
+      serverDir,
+      rscEntryPath,
+      compress,
+      purpose,
+      silent,
+    });
   }
 
   return startPagesRouterServer({
@@ -1313,6 +1328,7 @@ type AppRouterServerOptions = {
   port: number;
   host: string;
   clientDir: string;
+  serverDir: string;
   rscEntryPath: string;
   compress: boolean;
   purpose?: ProdServerOptions["purpose"];
@@ -1547,11 +1563,11 @@ function installPagesClientAssets(options: {
  * 4. Stream the Web Response back (with optional compression)
  */
 async function startAppRouterServer(options: AppRouterServerOptions) {
-  const { port, host, clientDir, rscEntryPath, compress, purpose, silent } = options;
+  const { port, host, clientDir, serverDir, rscEntryPath, compress, purpose, silent } = options;
 
   // Load prerender secret written at build time by vinext:server-manifest plugin.
   // Used to authenticate internal /__vinext/prerender/* HTTP endpoints.
-  const prerenderSecret = readPrerenderSecret(path.dirname(rscEntryPath));
+  const prerenderSecret = readPrerenderSecret(serverDir);
 
   // Import the RSC handler. importServerEntryModule uses the bare file://
   // URL so lazy chunks that import the entry back resolve to the same module
@@ -1586,7 +1602,7 @@ async function startAppRouterServer(options: AppRouterServerOptions) {
       ? (rscModule.__imageConfig as ImageConfig)
       : undefined;
   if (imageConfig === undefined) {
-    const imageConfigPath = path.join(path.dirname(rscEntryPath), "image-config.json");
+    const imageConfigPath = path.join(serverDir, "image-config.json");
     if (fs.existsSync(imageConfigPath)) {
       try {
         imageConfig = JSON.parse(fs.readFileSync(imageConfigPath, "utf-8"));
@@ -1619,7 +1635,7 @@ async function startAppRouterServer(options: AppRouterServerOptions) {
   // any pre-rendered page is a cache HIT instead of a full re-render.
   const seedPrerenderedRoutes = resolveAppRouterPrerenderSeeder(rscModule);
   const seededRoutes = await runWithServerEntryRequire(rscEntryRequire, () =>
-    seedPrerenderedRoutes(path.dirname(rscEntryPath)),
+    seedPrerenderedRoutes(serverDir),
   );
   if (seededRoutes > 0) {
     console.log(

tests/prerender-entry.test.ts

@@ -48,6 +48,7 @@ describe("App prerender entry", () => {
       expect.objectContaining({
         outDir: path.join(root, "dist"),
         rscEntryPath: rscBundlePath,
+        serverDir,
       }),
     );
   });

tests/prerender-paths.test.ts

@@ -1843,12 +1843,12 @@ describe("prerender path manifest", () => {
     writeFile("package.json", JSON.stringify({ type: "module" }));
     writeFile("dist/server/BUILD_ID", "build-a\n");
     writeFile("dist/server/index.js", 'import "cloudflare:workers";\n');
-    writeFile("dist/server/application-entry.js", "export default {};\n");
+    writeFile("dist/server/entries/application-entry.js", "export default {};\n");
     writeFile(
       "dist/server/.vite/manifest.json",
       JSON.stringify({
         "virtual:vinext-rsc-entry": {
-          file: "application-entry.js",
+          file: "entries/application-entry.js",
           isDynamicEntry: true,
         },
       }),
@@ -1869,7 +1869,8 @@ describe("prerender path manifest", () => {
 
     expect(startProdServerMock).toHaveBeenCalledWith(
       expect.objectContaining({
-        rscEntryPath: toSlash(path.join(tmpDir, "dist/server/application-entry.js")),
+        rscEntryPath: toSlash(path.join(tmpDir, "dist/server/entries/application-entry.js")),
+        serverDir: toSlash(path.join(tmpDir, "dist/server")),
       }),
     );
   });

tests/prerender-server-pool.test.ts

@@ -77,12 +77,14 @@ describe("prerender server pool sizing", () => {
       if (
         process.env.VINEXT_PRERENDER !== "1" ||
         process.env.NEXT_PHASE !== "phase-production-build" ||
-        process.env.VINEXT_PRERENDER_RSC_ENTRY_PATH !== "application-entry.js"
+        process.env.VINEXT_PRERENDER_RSC_ENTRY_PATH !== "application-entry.js" ||
+        process.env.VINEXT_PRERENDER_SERVER_DIR !== "server-artifacts"
       ) {
         process.send({ type: "error", error: JSON.stringify({
           VINEXT_PRERENDER: process.env.VINEXT_PRERENDER,
           NEXT_PHASE: process.env.NEXT_PHASE,
           VINEXT_PRERENDER_RSC_ENTRY_PATH: process.env.VINEXT_PRERENDER_RSC_ENTRY_PATH,
+          VINEXT_PRERENDER_SERVER_DIR: process.env.VINEXT_PRERENDER_SERVER_DIR,
         }) });
       } else {
         process.send({ type: "ready", port: 4125 });
@@ -94,6 +96,7 @@ describe("prerender server pool sizing", () => {
       const pool = await startPrerenderServerPool(dir, 1, {
         entry,
         rscEntryPath: "application-entry.js",
+        serverDir: "server-artifacts",
       });
       await pool.close();
     } finally {

tests/prod-server-logs.test.ts

@@ -101,6 +101,47 @@ describe("startProdServer logging", () => {
     ]);
   });
 
+  it("keeps nested App entries authenticated against the server artifact root", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "vinext-prod-server-nested-entry-"));
+    roots.push(root);
+    const distDir = path.join(root, "dist");
+    const clientDir = path.join(distDir, "client");
+    const serverDir = path.join(distDir, "server");
+    const entryPath = path.join(serverDir, "entries", "application.js");
+    fs.mkdirSync(clientDir, { recursive: true });
+    fs.mkdirSync(path.dirname(entryPath), { recursive: true });
+    fs.writeFileSync(
+      path.join(serverDir, "vinext-server.json"),
+      JSON.stringify({ prerenderSecret: "nested-secret" }),
+    );
+    fs.writeFileSync(
+      entryPath,
+      ["export default async function handler() { return new Response('ok'); }", ""].join("\n"),
+    );
+
+    const { startProdServer } = await import("../packages/vinext/src/server/prod-server.js");
+    const { server, port } = await startProdServer({
+      port: 0,
+      host: "127.0.0.1",
+      outDir: distDir,
+      rscEntryPath: entryPath,
+      serverDir,
+      noCompression: true,
+      silent: true,
+    });
+    try {
+      const denied = await fetch(`http://127.0.0.1:${port}/__vinext/prerender/static-params`);
+      expect(denied.status).toBe(403);
+      const allowed = await fetch(`http://127.0.0.1:${port}/__vinext/prerender/static-params`, {
+        headers: { "x-vinext-prerender-secret": "nested-secret" },
+      });
+      expect(allowed.status).toBe(200);
+      await expect(allowed.text()).resolves.toBe("ok");
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
   it("uses the prerender-specific startup log for App Router production servers", async () => {
     const root = createAppBuild();
     roots.push(root);