vinext 0.2.0 → 0.2.1

package/dist/build/css-url-assets.d.ts

@@ -13,6 +13,8 @@ type EmitRestoredCssUrlAsset = (asset: {
  * safe to run on every build-environment stylesheet, vendored CSS included.
  */
 declare function markCssUrlAssetReferences(code: string, id: string): string | null;
+/** Rebase relative asset URLs when Sass inlines a partial into an entry file. */
+declare function rebaseCssUrlAssetReferences(code: string, sourceDirectory: string, targetDirectory: string): string | null;
 /**
  * Mutates emitted CSS assets in place so byte-identical `url()` dependencies
  * keep their distinct Next-compatible filenames. Sibling files are produced via
@@ -26,4 +28,4 @@ declare function markCssUrlAssetReferences(code: string, id: string): string | n
  */
 declare function restoreDedupedCssAssetReferences(bundle: CssUrlAssetBundle, emitRestoredAsset: EmitRestoredCssUrlAsset): void;
 //#endregion
-export { markCssUrlAssetReferences, restoreDedupedCssAssetReferences };
+export { markCssUrlAssetReferences, rebaseCssUrlAssetReferences, restoreDedupedCssAssetReferences };

package/dist/build/css-url-assets.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 //#region src/build/css-url-assets.ts
 /**
 * Next-parity for CSS `url()` asset dependencies.
@@ -128,6 +129,22 @@ function markCssUrlAssetReferences(code, id) {
 		});
 	});
 }
+/** Rebase relative asset URLs when Sass inlines a partial into an entry file. */
+function rebaseCssUrlAssetReferences(code, sourceDirectory, targetDirectory) {
+	return rewriteCssUrls(code, (rawUrl) => {
+		const parts = splitUrl(rawUrl.trim());
+		if (!isRelativeAssetUrl(parts.path)) return null;
+		const lower = parts.path.toLowerCase();
+		if (!CSS_ASSET_EXT_RE.test(lower) || lower.endsWith(".css")) return null;
+		const absolutePath = path.resolve(sourceDirectory, parts.path);
+		let rebasedPath = path.relative(targetDirectory, absolutePath).replaceAll("\\", "/");
+		if (!rebasedPath.startsWith(".")) rebasedPath = `./${rebasedPath}`;
+		return joinUrl({
+			...parts,
+			path: rebasedPath
+		});
+	});
+}
 function isCssFileName(fileName) {
 	return fileName.toLowerCase().endsWith(".css");
 }
@@ -210,4 +227,4 @@ function stripChunkMarkers(code) {
 	return code.replace(CSS_URL_MARKER_PARAM_RE, (_m, leadingQuestion) => leadingQuestion ? leadingQuestion : "");
 }
 //#endregion
-export { markCssUrlAssetReferences, restoreDedupedCssAssetReferences };
+export { markCssUrlAssetReferences, rebaseCssUrlAssetReferences, restoreDedupedCssAssetReferences };

package/dist/build/inject-pregenerated-paths.d.ts

@@ -1,4 +1,7 @@
 //#region src/build/inject-pregenerated-paths.d.ts
+declare global {
+  var __VINEXT_PREGENERATED_CONCRETE_PATHS: unknown;
+}
 declare function injectPregeneratedConcretePaths(root: string): void;
 //#endregion
 export { injectPregeneratedConcretePaths };

package/dist/build/inject-pregenerated-paths.js

@@ -11,7 +11,10 @@ function injectPregeneratedConcretePaths(root) {
 	if (!fs.existsSync(workerEntry)) return;
 	let code = fs.readFileSync(workerEntry, "utf-8").replace(VINEXT_PREGEN_RE, "");
 	const table = readPrerenderManifest(path.join(root, "dist", "server", "vinext-prerender.json"))?.pregeneratedConcretePaths ?? [];
-	if (table.length > 0) code = `${VINEXT_PREGEN_START}\nglobalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = ${JSON.stringify(table)};\n${VINEXT_PREGEN_END}\n` + code;
+	if (table.length > 0) {
+		globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = table;
+		code = `${VINEXT_PREGEN_START}\nglobalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS = ${JSON.stringify(table)};\n${VINEXT_PREGEN_END}\n` + code;
+	} else delete globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS;
 	fs.writeFileSync(workerEntry, code);
 }
 //#endregion

package/dist/build/prerender-server-entry.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/build/prerender-server-entry.js

@@ -0,0 +1,49 @@
+import { NoOpCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
+import { startProdServer } from "../server/prod-server.js";
+//#region src/build/prerender-server-entry.ts
+/**
+* Child-process entry for a parallel prerender render server.
+*
+* Forked by `prerender-server-pool.ts`. React SSR/RSC rendering is CPU-bound
+* JS, so a single-process promise pool serializes every render on one core.
+* This entry lets the prerender phase fan rendering out across N OS processes
+* (one per core, like Next.js's static worker pool): each child starts a normal
+* vinext production server on an ephemeral port and reports it to the parent
+* over IPC. The parent then load-balances per-route fetches across the pool.
+*
+* `VINEXT_PRERENDER` / `VINEXT_PRERENDER_OUTDIR` are passed via the fork env so
+* they are set before any module loads (some server modules read the flag at
+* import time).
+*/
+async function main() {
+	const outDir = process.env.VINEXT_PRERENDER_OUTDIR;
+	if (!outDir) throw new Error("[vinext] prerender server worker: VINEXT_PRERENDER_OUTDIR not set");
+	setCacheHandler(new NoOpCacheHandler());
+	const { port } = await startProdServer({
+		port: 0,
+		host: "127.0.0.1",
+		outDir,
+		noCompression: true,
+		purpose: "prerender",
+		silent: true
+	});
+	if (typeof process.send === "function") process.send({
+		type: "ready",
+		port
+	});
+	else throw new Error("[vinext] prerender server worker: no IPC channel to parent");
+}
+process.on("disconnect", () => process.exit(0));
+main().catch((err) => {
+	const message = err instanceof Error ? err.stack ?? err.message : String(err);
+	if (typeof process.send === "function") {
+		process.send({
+			type: "error",
+			error: message
+		}, () => process.exit(1));
+		return;
+	}
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/build/prerender-server-pool.d.ts

@@ -0,0 +1,44 @@
+//#region src/build/prerender-server-pool.d.ts
+/**
+ * Whether the forkable worker entry exists as a runnable `.js` sibling. False
+ * when vinext runs from source (e.g. the test suite transpiles `.ts` on the
+ * fly and a forked plain-node child can't load `.ts`); callers fall back to the
+ * single in-process server. True in the published/built package.
+ */
+declare function prerenderPoolAvailable(): boolean;
+type PrerenderServerPool = {
+  /** Ports of the forked render servers, for round-robin per-route fetches. */ports: number[];
+  /**
+   * Throw if any worker exited unexpectedly (i.e. not via `close()`). The
+   * caller MUST call this after the render loop: a crashed worker makes every
+   * route routed to it fail with a connection error, which the per-route
+   * handler records as a (non-fatal) error — without this check the build
+   * would emit partial output and still exit 0. Mirrors the single-process
+   * design, where a server crash takes the whole build down loudly.
+   */
+  assertHealthy: () => void;
+  /**
+   * Record a failed fetch to a render worker. This closes the tiny ordering gap
+   * where the request can fail before Node has delivered the child `exit` event.
+   */
+  recordRenderError: (err: unknown) => void; /** Kill every forked server. Safe to call more than once. */
+  close: () => Promise<void>;
+};
+/**
+ * Choose how many render processes to fork for `routeCount` routes.
+ *
+ * Returns 1 to mean "don't fork — render in-process as before" (small apps,
+ * single/dual-core, low memory, or an explicit `--prerender-concurrency 1`).
+ * `maxOverride` comes from `--prerender-concurrency`, which caps both the
+ * number of in-flight route fetches and the worker count (the default is capped
+ * at `min(cores, 8)`).
+ */
+declare function resolvePrerenderPoolSize(routeCount: number, maxOverride?: number): number;
+/**
+ * Fork `size` production servers against `outDir` and resolve once all are
+ * listening. Each child reports its port over IPC. Rejects (and tears down any
+ * already-started children) if any child fails to come up.
+ */
+declare function startPrerenderServerPool(outDir: string, size: number, entry?: string): Promise<PrerenderServerPool>;
+//#endregion
+export { PrerenderServerPool, prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool };

package/dist/build/prerender-server-pool.js

@@ -0,0 +1,194 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+import { fork } from "node:child_process";
+//#region src/build/prerender-server-pool.ts
+/**
+* Parallel prerender server pool.
+*
+* React SSR/RSC rendering during prerender is CPU-bound JS. vinext renders
+* every route by fetching it from a single in-process production server, so the
+* promise pool in `prerender.ts` only overlaps I/O — the actual rendering
+* serializes on one core. This module forks a pool of OS processes (one vinext
+* production server each, on its own ephemeral port) so the prerender phase can
+* spread rendering across cores, mirroring Next.js's static worker pool. The
+* caller load-balances per-route fetches across `ports`.
+*
+* child_process (not worker_threads) is deliberate: worker threads share the
+* process and contend badly for CPU on this workload (measured ~2× slower
+* per route and non-scaling), which is also why Next.js uses processes.
+*/
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKER_ENTRY = path.join(__dirname, "prerender-server-entry.js");
+/**
+* Whether the forkable worker entry exists as a runnable `.js` sibling. False
+* when vinext runs from source (e.g. the test suite transpiles `.ts` on the
+* fly and a forked plain-node child can't load `.ts`); callers fall back to the
+* single in-process server. True in the published/built package.
+*/
+function prerenderPoolAvailable() {
+	return fs.existsSync(WORKER_ENTRY);
+}
+/** Hard cap on render processes. Beyond this the main thread (which collects
+* HTML and writes files) becomes the bottleneck, so more workers don't help. */
+const MAX_POOL_SIZE = 8;
+/** Don't fork a dedicated process unless a worker gets at least this many
+* routes — below this the fork + bundle-import startup cost outweighs the
+* parallel-render saving (measured: a 2-worker pool only reliably beats the
+* single server from ~50 routes/worker up). */
+const MIN_ROUTES_PER_WORKER = 48;
+/** Rough memory budget reserved for the main build process plus its in-process
+* prerender server. */
+const APPROX_MAIN_PROCESS_BYTES = 768 * 1024 * 1024;
+/** Rough memory budget per worker (a worker loads the whole server bundle).
+* Used with total system memory as a coarse upper bound on constrained machines
+* so K render processes don't OOM. Deliberately under-forks rather than risking
+* OOM; measured mid-size apps are usually lower (~260-380 MB/worker). */
+const APPROX_BYTES_PER_WORKER = 768 * 1024 * 1024;
+/** Per-worker readiness timeout. */
+const WORKER_READY_TIMEOUT_MS = 6e4;
+/** Best-effort close timeout so build cleanup is not blocked forever by a wedged child. */
+const WORKER_CLOSE_TIMEOUT_MS = 5e3;
+const PRERENDER_WORKER_TRANSPORT_ERROR_CODES = new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EPIPE",
+	"UND_ERR_SOCKET"
+]);
+/**
+* Choose how many render processes to fork for `routeCount` routes.
+*
+* Returns 1 to mean "don't fork — render in-process as before" (small apps,
+* single/dual-core, low memory, or an explicit `--prerender-concurrency 1`).
+* `maxOverride` comes from `--prerender-concurrency`, which caps both the
+* number of in-flight route fetches and the worker count (the default is capped
+* at `min(cores, 8)`).
+*/
+function resolvePrerenderPoolSize(routeCount, maxOverride) {
+	const cores = Math.max(1, os.availableParallelism());
+	const byCores = Math.max(1, Math.min(cores - 1, MAX_POOL_SIZE));
+	const memoryForWorkers = Math.max(0, os.totalmem() - APPROX_MAIN_PROCESS_BYTES);
+	const byMemory = Math.max(1, Math.floor(memoryForWorkers / APPROX_BYTES_PER_WORKER));
+	const cap = maxOverride && maxOverride > 0 ? Math.min(maxOverride, byCores) : byCores;
+	const byRoutes = Math.floor(routeCount / MIN_ROUTES_PER_WORKER);
+	return Math.max(1, Math.min(cap, byMemory, byRoutes));
+}
+function getErrorCauseCode(err) {
+	if (!(err instanceof Error)) return void 0;
+	const cause = err.cause;
+	return typeof cause?.code === "string" ? cause.code : void 0;
+}
+function isWorkerTransportError(err) {
+	const code = getErrorCauseCode(err);
+	if (code && PRERENDER_WORKER_TRANSPORT_ERROR_CODES.has(code)) return true;
+	return err instanceof TypeError && err.message === "fetch failed";
+}
+/**
+* Fork `size` production servers against `outDir` and resolve once all are
+* listening. Each child reports its port over IPC. Rejects (and tears down any
+* already-started children) if any child fails to come up.
+*/
+async function startPrerenderServerPool(outDir, size, entry = WORKER_ENTRY) {
+	const children = [];
+	let shuttingDown = false;
+	let crash = null;
+	let renderTransportError = null;
+	const close = async () => {
+		shuttingDown = true;
+		await Promise.all(children.map(closeChild));
+	};
+	try {
+		const readies = Array.from({ length: size }, () => {
+			const child = fork(entry, [], {
+				cwd: process.cwd(),
+				env: {
+					...process.env,
+					VINEXT_PRERENDER: "1",
+					VINEXT_PRERENDER_OUTDIR: outDir
+				},
+				stdio: [
+					"ignore",
+					"inherit",
+					"inherit",
+					"ipc"
+				]
+			});
+			children.push(child);
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("[vinext] prerender render server did not start within 60s"));
+				}, WORKER_READY_TIMEOUT_MS);
+				const cleanupStartupListeners = () => {
+					clearTimeout(timer);
+					child.off("message", onMessage);
+					child.off("error", onError);
+					child.off("exit", onStartupExit);
+				};
+				const onMessage = (msg) => {
+					cleanupStartupListeners();
+					if (msg?.type === "ready" && typeof msg.port === "number") {
+						child.once("exit", (code, signal) => {
+							if (!shuttingDown && !crash) crash = {
+								port: msg.port,
+								code,
+								signal
+							};
+						});
+						resolve(msg.port);
+					} else reject(/* @__PURE__ */ new Error(`[vinext] prerender render server failed: ${msg?.error ?? "unknown"}`));
+				};
+				const onError = (err) => {
+					cleanupStartupListeners();
+					reject(err);
+				};
+				const onStartupExit = (code, signal) => {
+					if (code !== null || signal !== null) {
+						cleanupStartupListeners();
+						reject(/* @__PURE__ */ new Error(`[vinext] prerender render server exited during startup (code ${code}, signal ${signal})`));
+					}
+				};
+				child.once("message", onMessage);
+				child.once("error", onError);
+				child.once("exit", onStartupExit);
+			});
+		});
+		const ports = await Promise.all(readies);
+		const recordRenderError = (err) => {
+			if (!renderTransportError && isWorkerTransportError(err)) renderTransportError = err instanceof Error ? err : new Error(String(err));
+		};
+		const assertHealthy = () => {
+			if (crash) throw new Error(`[vinext] A prerender render worker (port ${crash.port}) exited unexpectedly (code ${crash.code}, signal ${crash.signal}) during the build. Prerender output is incomplete; failing the build. This is often an out-of-memory kill — try a lower --prerender-concurrency.`);
+			if (renderTransportError) {
+				const causeCode = getErrorCauseCode(renderTransportError);
+				throw new Error(`[vinext] A prerender render worker request failed` + (causeCode ? ` (${causeCode})` : "") + " before the worker exit was observed. Prerender output is incomplete; failing the build. This is often an out-of-memory kill — try a lower --prerender-concurrency.");
+			}
+		};
+		return {
+			ports,
+			assertHealthy,
+			recordRenderError,
+			close
+		};
+	} catch (err) {
+		await close();
+		throw err;
+	}
+}
+async function closeChild(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	const exited = new Promise((resolve) => {
+		const timer = setTimeout(resolve, WORKER_CLOSE_TIMEOUT_MS);
+		timer.unref?.();
+		const finish = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		child.once("exit", finish);
+		if (child.exitCode !== null || child.signalCode !== null) finish();
+	});
+	if (!child.killed) child.kill("SIGKILL");
+	await exited;
+}
+//#endregion
+export { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool };

package/dist/build/prerender.js

@@ -1,5 +1,6 @@
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_CACHE_LIFE_HEADER } from "../server/headers.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
@@ -14,6 +15,7 @@ import { readPrerenderSecret } from "./server-manifest.js";
 import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
+import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -42,6 +44,14 @@ function isExperimentalPprFallbackShellGenerationEnabled(env = process.env) {
 function getErrorMessageWithStack(err) {
 	return err.stack || err.message;
 }
+async function startOptionalPrerenderServerPool(outDir, poolSize) {
+	try {
+		return await startPrerenderServerPool(outDir, poolSize);
+	} catch (e) {
+		console.warn(`[vinext] prerender render pool failed to start; falling back to single-process render: ${e instanceof Error ? e.message : String(e)}`);
+		return null;
+	}
+}
 var PrerenderUserFunctionError = class extends Error {};
 function parsePrerenderEndpointError(text) {
 	try {
@@ -257,11 +267,12 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 	const previousPrerenderFlag = process.env.VINEXT_PRERENDER;
 	process.env.VINEXT_PRERENDER = "1";
 	let ownedProdServerHandle = null;
+	let renderPool = null;
 	try {
 		let prerenderSecret = options._prerenderSecret;
 		if (!prerenderSecret && pagesBundlePath) prerenderSecret = readPrerenderSecret(path.dirname(pagesBundlePath));
 		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and dynamic routes will produce no paths. Run `vinext build` to regenerate the secret.");
-		const baseUrl = `http://127.0.0.1:${(options._prodServer ? options._prodServer : await (async () => {
+		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
 				host: "127.0.0.1",
@@ -271,12 +282,18 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			});
 			ownedProdServerHandle = srv;
 			return srv;
-		})()).port}`;
+		})();
+		const baseUrl = `http://127.0.0.1:${prodServer.port}`;
 		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
-		const renderPage = (urlPath) => fetch(`${baseUrl}${urlPath}`, {
-			headers: secretHeaders,
-			redirect: "manual"
-		});
+		let renderPorts = [prodServer.port];
+		let renderRoundRobin = 0;
+		const renderPage = (urlPath) => {
+			const port = renderPorts[renderRoundRobin++ % renderPorts.length];
+			return fetch(`http://127.0.0.1:${port}${urlPath}`, {
+				headers: secretHeaders,
+				redirect: "manual"
+			});
+		};
 		const bundlePageRoutes = routes.map((r) => ({
 			pattern: r.pattern,
 			isDynamic: r.isDynamic ?? false,
@@ -397,6 +414,13 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				revalidate
 			});
 		}
+		if (!options._prodServer && pagesBundlePath && prerenderPoolAvailable()) {
+			const poolSize = resolvePrerenderPoolSize(pagesToRender.length, concurrency);
+			if (poolSize > 1) {
+				renderPool = await startOptionalPrerenderServerPool(path.dirname(path.dirname(pagesBundlePath)), poolSize);
+				if (renderPool) renderPorts = renderPool.ports;
+			}
+		}
 		let completed = 0;
 		const pageResults = await runWithConcurrency(pagesToRender, concurrency, async ({ route, urlPath, revalidate }) => {
 			let result;
@@ -427,6 +451,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					...urlPath !== route.pattern ? { path: urlPath } : {}
 				};
 			} catch (e) {
+				renderPool?.recordRenderError(e);
 				const err = e;
 				result = {
 					route: route.pattern,
@@ -443,6 +468,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			return result;
 		});
 		results.push(...pageResults);
+		renderPool?.assertHealthy();
 		const hasCustom404 = findFileWithExtensions(path.join(pagesDir, "404"), fileMatcher);
 		const hasErrorPage = findFileWithExtensions(path.join(pagesDir, "_error"), fileMatcher);
 		if (hasCustom404 || hasErrorPage) try {
@@ -460,13 +486,17 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					router: "pages"
 				});
 			}
-		} catch {}
+		} catch (e) {
+			renderPool?.recordRenderError(e);
+		}
+		renderPool?.assertHealthy();
 		if (!skipManifest) writePrerenderIndex(results, manifestDir, {
 			buildId: config.buildId,
 			trailingSlash: config.trailingSlash
 		});
 		return { routes: results };
 	} finally {
+		if (renderPool) await renderPool.close();
 		setCacheHandler(previousHandler);
 		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
 		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
@@ -505,10 +535,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	let rscHandler;
 	let staticParamsMap = {};
 	let ownedProdServerHandle = null;
+	let renderPool = null;
+	let renderPorts = [];
+	let renderRoundRobin = 0;
 	try {
 		const prerenderSecret = readPrerenderSecret(serverDir);
 		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and generateStaticParams will not be called. Run `vinext build` to regenerate the secret.");
-		const baseUrl = `http://127.0.0.1:${(options._prodServer ? options._prodServer : await (async () => {
+		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
 				host: "127.0.0.1",
@@ -518,11 +551,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			});
 			ownedProdServerHandle = srv;
 			return srv;
-		})()).port}`;
+		})();
+		const baseUrl = `http://127.0.0.1:${prodServer.port}`;
+		renderPorts = [prodServer.port];
 		const secretHeaders = prerenderSecret ? { [VINEXT_PRERENDER_SECRET_HEADER]: prerenderSecret } : {};
 		rscHandler = (req) => {
 			const parsed = new URL(req.url);
-			const url = `${baseUrl}${parsed.pathname}${parsed.search}`;
+			const url = `http://127.0.0.1:${renderPorts[renderRoundRobin++ % renderPorts.length]}${parsed.pathname}${parsed.search}`;
 			return fetch(url, {
 				method: req.method,
 				headers: {
@@ -718,12 +753,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParams);
 				const htmlHeaders = new Headers();
 				if (prerenderRouteParamsHeader !== null) htmlHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+				if (isSpeculative) htmlHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 				const htmlRequest = new Request(`http://localhost${urlPath}`, { headers: htmlHeaders });
 				const htmlRender = await runWithHeadersContext(headersContextFromRequest(htmlRequest), async () => {
 					const response = await rscHandler(htmlRequest);
 					const cacheControl = response.headers.get("cache-control") ?? "";
 					const linkHeader = response.headers.get("link");
-					if (!response.ok || isSpeculative && cacheControl.includes("no-store")) {
+					const responseCacheLife = readPrerenderCacheLifeHeader(response.headers);
+					if (!response.ok || cacheControl.includes("no-store")) {
 						await response.body?.cancel();
 						return {
 							cacheControl,
@@ -734,12 +771,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							status: response.status
 						};
 					}
+					const html = await response.text();
+					const processCacheLife = _consumeRequestScopedCacheLife();
 					return {
 						cacheControl,
 						linkHeader,
-						html: await response.text(),
+						html,
 						ok: true,
-						requestCacheLife: _consumeRequestScopedCacheLife(),
+						requestCacheLife: responseCacheLife ?? processCacheLife,
 						status: response.status
 					};
 				});
@@ -756,13 +795,11 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						error: `RSC handler returned ${htmlRender.status}`
 					};
 				}
-				if (isSpeculative) {
-					if (htmlCacheControl.includes("no-store")) return {
-						route: routePattern,
-						status: "skipped",
-						reason: "dynamic"
-					};
-				}
+				if (htmlCacheControl.includes("no-store")) return {
+					route: routePattern,
+					status: "skipped",
+					reason: "dynamic"
+				};
 				if (htmlRender.html === null) return {
 					route: routePattern,
 					status: "error",
@@ -776,6 +813,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						RSC: "1"
 					});
 					if (prerenderRouteParamsHeader !== null) rscHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
+					if (isSpeculative) rscHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 					const rscRequest = new Request(`http://localhost${urlPath}`, { headers: rscHeaders });
 					const rscRes = await runWithHeadersContext(headersContextFromRequest(rscRequest), () => rscHandler(rscRequest));
 					if (!rscRes.ok) {
@@ -809,6 +847,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					...isFallback ? { fallback: true } : {}
 				};
 			} catch (e) {
+				renderPool?.recordRenderError(e);
 				if (isSpeculative) return {
 					route: routePattern,
 					status: "skipped",
@@ -823,6 +862,13 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				};
 			}
 		}
+		if (!options._prodServer && prerenderPoolAvailable()) {
+			const poolSize = resolvePrerenderPoolSize(urlsToRender.length, concurrency);
+			if (poolSize > 1) {
+				renderPool = await startOptionalPrerenderServerPool(path.dirname(serverDir), poolSize);
+				if (renderPool) renderPorts = renderPool.ports;
+			}
+		}
 		let completedApp = 0;
 		const appResults = await runWithConcurrency(urlsToRender, concurrency, async (urlToRender) => {
 			const result = await renderUrl(urlToRender);
@@ -835,6 +881,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			return result;
 		});
 		results.push(...appResults);
+		renderPool?.assertHealthy();
 		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir) : [];
 		try {
 			const notFoundRequest = new Request(`http://localhost${NOT_FOUND_SENTINEL_PATH}`);
@@ -852,7 +899,10 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					router: "app"
 				});
 			}
-		} catch {}
+		} catch (e) {
+			renderPool?.recordRenderError(e);
+		}
+		renderPool?.assertHealthy();
 		if (!skipManifest) writePrerenderIndex(results, manifestDir, {
 			buildId: config.buildId,
 			trailingSlash: config.trailingSlash
@@ -862,6 +912,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 			...outputFiles.length > 0 ? { outputFiles } : {}
 		};
 	} finally {
+		if (renderPool) await renderPool.close();
 		setCacheHandler(previousHandler);
 		if (previousPrerenderFlag === void 0) delete process.env.VINEXT_PRERENDER;
 		else process.env.VINEXT_PRERENDER = previousPrerenderFlag;
@@ -881,6 +932,19 @@ function resolveRenderedCacheControl(requestCacheLife, cacheControl, fallbackExp
 		...revalidate === void 0 ? {} : { revalidate }
 	};
 }
+function readPrerenderCacheLifeHeader(headers) {
+	const value = headers.get(VINEXT_PRERENDER_CACHE_LIFE_HEADER);
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		const cacheLife = {};
+		if (typeof parsed.revalidate === "number" && Number.isFinite(parsed.revalidate)) cacheLife.revalidate = parsed.revalidate;
+		if (typeof parsed.expire === "number" && Number.isFinite(parsed.expire)) cacheLife.expire = parsed.expire;
+		return cacheLife.revalidate === void 0 && cacheLife.expire === void 0 ? null : cacheLife;
+	} catch {
+		return null;
+	}
+}
 function resolveRenderedExpireSeconds(options) {
 	const { fallbackExpireSeconds, sMaxage, staleWhileRevalidate } = options;
 	if (sMaxage === void 0 || staleWhileRevalidate === void 0) return fallbackExpireSeconds;

package/dist/build/run-prerender.js

@@ -4,7 +4,7 @@ import { appRouter } from "../routing/app-router.js";
 import { scanMetadataFiles } from "../server/metadata-routes.js";
 import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { readPrerenderSecret } from "./server-manifest.js";
-import { startProdServer } from "../server/prod-server.js";
+import { rememberCurrentServerEntryImportMtime, startProdServer } from "../server/prod-server.js";
 import { prerenderApp, prerenderPages, writePrerenderIndex } from "./prerender.js";
 import { injectPregeneratedConcretePaths } from "./inject-pregenerated-paths.js";
 import fs from "node:fs";
@@ -224,6 +224,7 @@ async function runPrerender(options) {
 		throw new Error(`Static export failed: ${errors} route${errors !== 1 ? "s" : ""} cannot be statically exported.\n${errorRoutes}\n\nRemove server-side data fetching (getServerSideProps, force-dynamic, revalidate) from these routes, or remove \`output: "export"\` from next.config.js.`);
 	}
 	injectPregeneratedConcretePaths(root);
+	if (fs.existsSync(rscBundlePath)) rememberCurrentServerEntryImportMtime(rscBundlePath);
 	return {
 		routes: allRoutes,
 		...allOutputFiles.length > 0 ? { outputFiles: allOutputFiles } : {}