vinext 1.0.0-beta.8 → 1.0.0

package/dist/build/prerender.js

@@ -1,6 +1,8 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
+import { BLOCKED_PAGES } from "../shims/constants.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { appRouteLayoutStaticParamsGroups } from "../routing/app-router.js";
 import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER } from "../server/headers.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
@@ -8,12 +10,11 @@ import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cac
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
-import { BLOCKED_PAGES } from "../shims/constants.js";
+import { readPrerenderSecret } from "./server-manifest.js";
 import { buildPregeneratedConcretePathTable } from "../server/prerender-manifest.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
 import { navigationRuntimeRscBootstrapExpression } from "../server/app-ssr-stream.js";
 import { encodePrerenderRouteParams, serializePrerenderRouteParamsHeader } from "../server/prerender-route-params.js";
-import { readPrerenderSecret } from "./server-manifest.js";
 import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
@@ -25,7 +26,7 @@ import fs from "node:fs";
 import os from "node:os";
 //#region src/build/prerender.ts
 /**
-* Prerendering phase for vinext build.
+* Prerendering phase for vite build.
 *
 * Classifies every route, renders static and ISR routes to HTML/JSON/RSC files,
 * and writes a `vinext-prerender.json` build index.
@@ -48,15 +49,19 @@ function isExperimentalPprFallbackShellGenerationEnabled(env = process.env) {
 function getErrorMessageWithStack(err) {
 	return err.stack || err.message;
 }
-async function startOptionalPrerenderServerPool(outDir, poolSize) {
+async function startOptionalPrerenderServerPool(outDir, poolSize, rscEntryPath, serverDir) {
 	try {
-		return await startPrerenderServerPool(outDir, poolSize);
+		return await startPrerenderServerPool(outDir, poolSize, {
+			rscEntryPath,
+			serverDir
+		});
 	} 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 {};
+var InvalidStaticParamsError = class extends Error {};
 function parsePrerenderEndpointError(text) {
 	try {
 		const parsed = JSON.parse(text);
@@ -181,54 +186,85 @@ function metadataOutputPath(servedUrl) {
 	if (segments.length === 0 || segments.some((segment) => segment === "." || segment === "..")) return null;
 	return segments.join("/");
 }
-function emitStaticMetadataFiles(metadataRoutes, outDir) {
+function emitStaticMetadataFiles(metadataRoutes, outDir, basePath = "") {
 	const outputFiles = [];
+	const outputPrefix = basePath.replace(/^\//, "").replace(/\/$/, "");
 	for (const route of metadataRoutes) {
 		if (route.isDynamic) continue;
 		const outputPath = metadataOutputPath(route.servedUrl);
 		if (!outputPath) continue;
-		const fullPath = path.join(outDir, ...outputPath.split("/"));
+		const namespacedOutputPath = outputPrefix ? `${outputPrefix}/${outputPath}` : outputPath;
+		const fullPath = path.join(outDir, ...namespacedOutputPath.split("/"));
 		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
 		fs.copyFileSync(route.filePath, fullPath);
-		outputFiles.push(outputPath);
+		outputFiles.push(namespacedOutputPath);
+	}
+	return outputFiles;
+}
+function emitStatic404Files(outDir, html, trailingSlash) {
+	const outputFiles = ["404.html"];
+	if (trailingSlash) outputFiles.push("404/index.html");
+	for (const outputFile of outputFiles) {
+		const fullPath = path.join(outDir, ...outputFile.split("/"));
+		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+		fs.writeFileSync(fullPath, html, "utf-8");
 	}
 	return outputFiles;
 }
 /**
-* Resolve parent dynamic segment params for a route.
+* Next.js fails `output: "export"` on any generateStaticParams call that
+* returns no params (build/static-paths/app.ts callGenerateStaticParams).
+*/
+function emptyStaticExportParamsError(pattern) {
+	return /* @__PURE__ */ new Error(`Page "${pattern}" returned an empty array from "generateStaticParams()". With "output: export", at least one route must be generated. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
+}
+/**
+* Resolve the params a route's layouts above its own pattern generate.
 * Handles top-down generateStaticParams resolution for nested dynamic routes.
 *
 * Uses the `staticParamsMap` (pattern → generateStaticParams) exported from
-* the production bundle.
+* the production bundle. As in Next.js, which walks every segment of the
+* route's own loader tree top-down and passes each parent param set to the
+* next generateStaticParams (build/static-paths/app.ts
+* generateRouteStaticParams), every layout of the route contributes, including
+* one at the last dynamic segment when static segments follow it. The layouts
+* at the route's full pattern compose with its page under
+* `staticParamsMap[route.pattern]`, so they're left to the caller. A page or a
+* route group's layout at the same prefix belongs to a sibling route and never
+* supplies params.
+*
+* An App Route handler inherits no layouts: Next.js builds its segments from
+* the route module alone (build/segment-config/app/app-segments.ts
+* collectAppRouteSegments), so it has no parent params. A layout that returns
+* no params passes each parent set through unchanged, as Next.js does outside
+* Cache Components, except under `output: "export"`, where Next.js rejects any
+* generateStaticParams that returns no params (build/static-paths/app.ts
+* callGenerateStaticParams).
 */
-async function resolveParentParams(childRoute, staticParamsMap) {
-	const { patternParts } = childRoute;
-	let lastDynamicIdx = -1;
-	for (let i = patternParts.length - 1; i >= 0; i--) if (patternParts[i].startsWith(":")) {
-		lastDynamicIdx = i;
-		break;
-	}
+async function resolveParentParams(childRoute, staticParamsMap, options = {}) {
+	if (childRoute.routePath && !childRoute.pagePath) return [];
 	const parentSegments = [];
-	let prefixPattern = "";
-	for (let i = 0; i < lastDynamicIdx; i++) {
-		const part = patternParts[i];
-		prefixPattern += "/" + part;
-		if (!part.startsWith(":")) continue;
-		const fn = staticParamsMap[prefixPattern];
+	for (const group of appRouteLayoutStaticParamsGroups(childRoute)) {
+		if (group.pattern === childRoute.pattern) continue;
+		const fn = staticParamsMap[group.key];
 		if (typeof fn === "function") parentSegments.push(fn);
 	}
 	if (parentSegments.length === 0) return [];
-	let currentParams = [{}];
-	let resolvedAnyParent = false;
+	let currentParams = [];
 	for (const generateStaticParams of parentSegments) {
 		const nextParams = [];
 		let resolvedThisParent = false;
-		for (const parentParams of currentParams) {
+		const hasParentSets = currentParams.length > 0;
+		for (const parentParams of hasParentSets ? currentParams : [{}]) {
 			const results = await generateStaticParams({ params: parentParams });
 			if (results === null) continue;
 			if (!Array.isArray(results)) return [];
+			if (options.staticExport && results.length === 0) throw emptyStaticExportParamsError(childRoute.pattern);
 			resolvedThisParent = true;
-			resolvedAnyParent = true;
+			if (results.length === 0 && hasParentSets) {
+				nextParams.push(parentParams);
+				continue;
+			}
 			for (const result of results) nextParams.push({
 				...parentParams,
 				...result
@@ -236,7 +272,70 @@ async function resolveParentParams(childRoute, staticParamsMap) {
 		}
 		if (resolvedThisParent) currentParams = nextParams;
 	}
-	return resolvedAnyParent ? currentParams : [];
+	return currentParams;
+}
+function getDynamicPatternParams(pattern) {
+	return pattern.split("/").filter((segment) => segment.startsWith(":")).map((segment) => ({
+		name: segment.slice(1, segment.endsWith("+") || segment.endsWith("*") ? -1 : void 0),
+		optional: segment.endsWith("*"),
+		repeat: segment.endsWith("+") || segment.endsWith("*")
+	}));
+}
+function validateDiscoveredParams(value, pattern, source) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new InvalidStaticParamsError(`${source} must return parameter objects for ${pattern}.`);
+	const params = { ...value };
+	for (const { name, optional, repeat } of getDynamicPatternParams(pattern)) {
+		const hasValue = Object.prototype.hasOwnProperty.call(params, name);
+		let paramValue = params[name];
+		if (optional && hasValue && (paramValue === null || paramValue === void 0 || paramValue === false)) {
+			paramValue = [];
+			params[name] = paramValue;
+		}
+		if (!(repeat ? Array.isArray(paramValue) && paramValue.every((entry) => typeof entry === "string") : typeof paramValue === "string")) throw new InvalidStaticParamsError(`Parameter ${name} from ${source} for ${pattern} must be ${repeat ? "an array of strings" : "a string"}.`);
+		if ((Array.isArray(paramValue) ? paramValue : [paramValue]).some((entry) => entry === "." || entry === "..")) throw new InvalidStaticParamsError(`Parameter ${name} from ${source} for ${pattern} must not contain dot path segments.`);
+	}
+	return params;
+}
+/**
+* The param sets of an App route that become concrete paths, following
+* Next.js's buildAppStaticPaths (build/static-paths/app.ts). Unless every set
+* names every pathname param (hadAllParamsGenerated), none is prerendered.
+* Otherwise every set is checked against the route's pathname params
+* (validateParams), and, outside a partial prerender, a set with an empty
+* required value is skipped rather than built into a path with an empty
+* segment. An array, including an optional catch-all's empty one, is never
+* empty in that sense. Under `output: "export"` incomplete sets fail the
+* build instead, as Next.js requires every export path to be generated.
+*/
+function routeStaticParamSets(route, paramSets, options = {}) {
+	const patternParams = getDynamicPatternParams(route.pattern);
+	const objects = paramSets.map((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new InvalidStaticParamsError(`generateStaticParams must return parameter objects for ${route.pattern}.`);
+		return value;
+	});
+	const missingParamNames = patternParams.filter(({ name }) => objects.some((params) => !(name in params))).map(({ name }) => name);
+	if (missingParamNames.length > 0) {
+		if (options.staticExport && objects.length > 0) throw new InvalidStaticParamsError(`Page "${route.pattern}" returned incomplete params from "generateStaticParams()". With "output: export", every params object must include all dynamic route parameters. Missing: ${missingParamNames.map((name) => `"${name}"`).join(", ")}. See more info here: https://nextjs.org/docs/messages/generate-static-params`);
+		return [];
+	}
+	const materializable = [];
+	for (const value of objects) {
+		const params = validateDiscoveredParams(value, route.pattern, "generateStaticParams");
+		if (patternParams.some(({ name, repeat }) => !repeat && params[name] === "")) continue;
+		materializable.push(params);
+	}
+	return materializable;
+}
+/**
+* The param sets a route's layouts generate, standing in for the route's own
+* when none of the segments at its full pattern has generateStaticParams.
+* Next.js prerenders none of a route's paths unless every set fills every
+* pathname param (build/static-paths/app.ts hadAllParamsGenerated), so
+* incomplete sets leave the route without static params (`null`). Complete
+* sets still go through routeStaticParamSets.
+*/
+function layoutOnlyParamSets(route, parentParamSets) {
+	return parentParamSets.length > 0 && parentParamSets.every((params) => route.params.every((name) => name in params)) ? parentParamSets : null;
 }
 /**
 * Run the prerender phase for Pages Router.
@@ -274,7 +373,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 	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.");
+		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and dynamic routes will produce no paths. Run `vite build` to regenerate the secret.");
 		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
@@ -292,7 +391,9 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		let renderRoundRobin = 0;
 		const renderPage = (urlPath) => {
 			const port = renderPorts[renderRoundRobin++ % renderPorts.length];
-			return fetch(`http://127.0.0.1:${port}${urlPath}`, {
+			const routeRequestPath = config.trailingSlash && !urlPath.endsWith("/") ? `${urlPath}/` : urlPath;
+			const requestPath = config.basePath && routeRequestPath === "/" && !config.trailingSlash ? config.basePath : `${config.basePath ?? ""}${routeRequestPath}`;
+			return fetch(`http://127.0.0.1:${port}${requestPath}`, {
 				headers: secretHeaders,
 				redirect: "manual"
 			});
@@ -316,7 +417,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 						fallback: false
 					};
 				}
-				if (text === "null") return {
+				if (res.status === 204 || text === "null") return {
 					paths: [],
 					fallback: false
 				};
@@ -430,7 +531,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			try {
 				const response = await renderPage(urlPath);
 				const outputFiles = [];
-				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash);
+				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash, mode === "export" ? config.basePath : "");
 				const htmlFullPath = path.join(outDir, htmlOutputPath);
 				if (response.status >= 300 && response.status < 400) {
 					const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${(response.headers.get("location") ?? "/").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}" /></head><body></body></html>`;
@@ -479,12 +580,10 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 			const contentType = notFoundRes.headers.get("content-type") ?? "";
 			if (notFoundRes.status === 404 && contentType.includes("text/html")) {
 				const html404 = await notFoundRes.text();
-				const fullPath = path.join(outDir, "404.html");
-				fs.writeFileSync(fullPath, html404, "utf-8");
 				results.push({
 					route: "/404",
 					status: "rendered",
-					outputFiles: ["404.html"],
+					outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
 					revalidate: false,
 					router: "pages"
 				});
@@ -514,18 +613,18 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 * Starts a local production server and fetches every static/ISR route via HTTP.
 * Works for both plain Node and Cloudflare Workers builds — the CF Workers bundle
 * (`dist/server/index.js`) is a standard Node-compatible server entry, so no
-* wrangler/miniflare is needed. Writes HTML files, `.rsc` files, and
+* wrangler/miniflare is needed. Writes HTML files, Flight payloads, and
 * `vinext-prerender.json` to `outDir`.
 *
 * If the bundle does not exist, an error is thrown directing the user to run
-* `vinext build` first.
+* `vite build` first.
 *
 * Speculative static rendering: routes classified as 'unknown' (no explicit
 * config, non-dynamic URL) are attempted with an empty headers/cookies context.
 * If they succeed, they are marked as rendered. If they throw a DynamicUsageError
 * or fail, they are marked as skipped with reason 'dynamic'.
 */
-async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode, rscBundlePath, ...options }) {
+async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode, rscBundlePath, serverDir = path.dirname(rscBundlePath), buildOutDir = path.dirname(serverDir), ...options }) {
 	const manifestDir = options.manifestDir ?? outDir;
 	const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
 	const onProgress = options.onProgress;
@@ -535,7 +634,6 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	const previousHandler = getCacheHandler();
 	setCacheHandler(new NoOpCacheHandler());
 	const restorePrerenderPhase = enterPrerenderPhase();
-	const serverDir = path.dirname(rscBundlePath);
 	let rscHandler;
 	let staticParamsMap = {};
 	let ownedProdServerHandle = null;
@@ -544,12 +642,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	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.");
+		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and generateStaticParams will not be called. Run `vite build` to regenerate the secret.");
 		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
 				host: "127.0.0.1",
-				outDir: path.dirname(serverDir),
+				outDir: buildOutDir,
+				rscEntryPath: rscBundlePath,
+				serverDir,
 				noCompression: true,
 				purpose: "prerender"
 			});
@@ -582,6 +682,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					const request = (async () => {
 						const search = new URLSearchParams({ pattern });
 						if (Object.keys(params).length > 0) search.set("parentParams", JSON.stringify(params));
+						if (mode === "export") search.set("rejectEmptyResults", "1");
 						const res = await fetch(`${baseUrl}/__vinext/prerender/static-params?${search}`, { headers: secretHeaders });
 						const text = await res.text();
 						if (!res.ok) {
@@ -589,7 +690,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							console.warn(`[vinext] Warning: /__vinext/prerender/static-params returned ${res.status} for ${pattern}. Static params will be skipped. This may indicate a stale or missing prerender secret.`);
 							return null;
 						}
-						if (text === "null") return null;
+						if (res.status === 204 || text === "null") return null;
 						return JSON.parse(text);
 					})();
 					request.catch(() => staticParamsCache.delete(cacheKey));
@@ -651,28 +752,36 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					});
 					continue;
 				}
-				const parentParamSets = await resolveParentParams(route, staticParamsMap);
+				const parentParamSets = await resolveParentParams(route, staticParamsMap, { staticExport: mode === "export" });
 				let paramSets;
 				if (parentParamSets.length > 0) {
 					paramSets = [];
 					for (const parentParams of parentParamSets) {
 						const childResults = await generateStaticParamsFn({ params: parentParams });
 						if (childResults === null) {
-							paramSets = null;
+							paramSets = layoutOnlyParamSets(route, parentParamSets);
 							break;
 						}
-						if (Array.isArray(childResults)) for (const childParams of childResults) paramSets.push({
-							...parentParams,
-							...childParams
-						});
-						else {
+						if (Array.isArray(childResults)) {
+							if (mode === "export" && childResults.length === 0) throw emptyStaticExportParamsError(route.pattern);
+							if (childResults.length === 0) {
+								paramSets.push(parentParams);
+								continue;
+							}
+							for (const childParams of childResults) paramSets.push({
+								...parentParams,
+								...childParams
+							});
+						} else {
 							paramSets = [];
 							break;
 						}
 					}
+					if (paramSets !== null) paramSets = routeStaticParamSets(route, paramSets, { staticExport: mode === "export" });
 				} else {
 					const results = await generateStaticParamsFn({ params: {} });
-					paramSets = Array.isArray(results) || results === null ? results : [];
+					if (mode === "export" && Array.isArray(results) && results.length === 0) throw emptyStaticExportParamsError(route.pattern);
+					paramSets = results === null ? null : routeStaticParamSets(route, Array.isArray(results) ? results : [], { staticExport: mode === "export" });
 				}
 				if (paramSets === null) {
 					if (mode === "export") results.push({
@@ -691,7 +800,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					results.push({
 						route: route.pattern,
 						status: "skipped",
-						reason: "no-static-params"
+						reason: "empty-static-params"
 					});
 					continue;
 				}
@@ -728,7 +837,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					route: route.pattern,
 					status: "error",
 					error: `Failed to call generateStaticParams(): ${detail}`,
-					...e instanceof PrerenderUserFunctionError ? { fatal: true } : {}
+					...e instanceof PrerenderUserFunctionError || e instanceof InvalidStaticParamsError ? { fatal: true } : {}
 				});
 			}
 			else if (type === "unknown") urlsToRender.push({
@@ -829,7 +938,9 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				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 routeRequestPath = config.trailingSlash && !urlPath.endsWith("/") ? `${urlPath}/` : urlPath;
+				const requestPath = config.basePath && routeRequestPath === "/" && !config.trailingSlash ? config.basePath : `${config.basePath ?? ""}${routeRequestPath}`;
+				const htmlRequest = new Request(`http://localhost${requestPath}`, { headers: htmlHeaders });
 				const htmlRender = await runWithHeadersContext(headersContextFromRequest(htmlRequest), async () => {
 					const response = await rscHandler(htmlRequest);
 					const cacheControl = response.headers.get("cache-control") ?? "";
@@ -896,7 +1007,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					});
 					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 rscRequest = new Request(`http://localhost${requestPath}`, { headers: rscHeaders });
 					const rscRes = await runWithHeadersContext(headersContextFromRequest(rscRequest), () => rscHandler(rscRequest));
 					if (!rscRes.ok) {
 						await rscRes.body?.cancel();
@@ -905,12 +1016,16 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					rscData = new Uint8Array(await rscRes.arrayBuffer());
 				}
 				const outputFiles = [];
-				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash);
+				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash, mode === "export" ? config.basePath : "");
 				const htmlFullPath = path.join(outDir, htmlOutputPath);
 				fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
 				fs.writeFileSync(htmlFullPath, html, "utf-8");
 				outputFiles.push(htmlOutputPath);
-				const rscOutputPath = getRscOutputPath(urlPath);
+				const rscOutputPath = getRscOutputPath(urlPath, {
+					mode,
+					trailingSlash: config.trailingSlash,
+					basePath: mode === "export" ? config.basePath : ""
+				});
 				const rscFullPath = path.join(outDir, rscOutputPath);
 				fs.mkdirSync(path.dirname(rscFullPath), { recursive: true });
 				fs.writeFileSync(rscFullPath, rscData);
@@ -950,7 +1065,7 @@ 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);
+				renderPool = await startOptionalPrerenderServerPool(buildOutDir, poolSize, rscBundlePath, serverDir);
 				if (renderPool) renderPorts = renderPool.ports;
 			}
 		}
@@ -967,19 +1082,17 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 		});
 		results.push(...appResults);
 		renderPool?.assertHealthy();
-		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir) : [];
+		const outputFiles = mode === "export" && metadataRoutes.length > 0 ? emitStaticMetadataFiles(metadataRoutes, outDir, config.basePath) : [];
 		try {
-			const notFoundRequest = new Request(`http://localhost${NOT_FOUND_SENTINEL_PATH}`);
+			const notFoundPath = config.trailingSlash && !NOT_FOUND_SENTINEL_PATH.endsWith("/") ? `${NOT_FOUND_SENTINEL_PATH}/` : NOT_FOUND_SENTINEL_PATH;
+			const notFoundRequest = new Request(`http://localhost${config.basePath ?? ""}${notFoundPath}`);
 			const notFoundRes = await runWithHeadersContext(headersContextFromRequest(notFoundRequest), () => rscHandler(notFoundRequest));
 			if (notFoundRes.status === 404) {
 				const html404 = await notFoundRes.text();
-				const fullPath = path.join(outDir, "404.html");
-				fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-				fs.writeFileSync(fullPath, html404, "utf-8");
 				results.push({
 					route: "/404",
 					status: "rendered",
-					outputFiles: ["404.html"],
+					outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
 					revalidate: false,
 					router: "app"
 				});
@@ -1097,4 +1210,4 @@ function writePrerenderIndex(routes, outDir, options) {
 	fs.writeFileSync(path.join(outDir, "vinext-prerender.json"), JSON.stringify(index, null, 2), "utf-8");
 }
 //#endregion
-export { buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, layoutOnlyParamSets, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, routeStaticParamSets, validateDiscoveredParams, writePrerenderIndex };

package/dist/build/preview-credentials.d.ts

@@ -1,11 +1,10 @@
 //#region src/build/preview-credentials.d.ts
-type PreviewBuildCredentials = {
+export type PreviewBuildCredentials = {
   id: string;
   signingKey: string;
   encryptionKey: string;
 };
-declare function createPreviewBuildCredentials(): PreviewBuildCredentials;
-declare function getPreviewBuildCredentials(): PreviewBuildCredentials | undefined;
-declare function runWithPreviewBuildCredentials<T>(callback: () => T): T;
-//#endregion
-export { PreviewBuildCredentials, createPreviewBuildCredentials, getPreviewBuildCredentials, runWithPreviewBuildCredentials };
+export declare function createPreviewBuildCredentials(): PreviewBuildCredentials;
+export declare function getPreviewBuildCredentials(): PreviewBuildCredentials | undefined;
+export declare function runWithPreviewBuildCredentials<T>(callback: () => T, credentials?: PreviewBuildCredentials): T;
+//#endregion

package/dist/build/preview-credentials.js

@@ -12,8 +12,8 @@ function createPreviewBuildCredentials() {
 function getPreviewBuildCredentials() {
 	return previewBuildCredentialsStorage.getStore();
 }
-function runWithPreviewBuildCredentials(callback) {
-	return previewBuildCredentialsStorage.run(createPreviewBuildCredentials(), callback);
+function runWithPreviewBuildCredentials(callback, credentials = createPreviewBuildCredentials()) {
+	return previewBuildCredentialsStorage.run(credentials, callback);
 }
 //#endregion
 export { createPreviewBuildCredentials, getPreviewBuildCredentials, runWithPreviewBuildCredentials };

package/dist/build/public-dir-conflict.d.ts

@@ -1,14 +1,13 @@
 //#region src/build/public-dir-conflict.d.ts
-type PublicDirConflictOptions = {
+export type PublicDirConflictOptions = {
   root: string;
   publicDir: string | null;
   assetsDir: string;
 };
-type PublicNextRequestConflictOptions = Pick<PublicDirConflictOptions, "root" | "publicDir"> & {
+export type PublicNextRequestConflictOptions = Pick<PublicDirConflictOptions, "root" | "publicDir"> & {
   basePath: string;
   requestUrl: string;
 };
-declare function assertNoPublicNextRequestConflict({ root, publicDir, basePath, requestUrl }: PublicNextRequestConflictOptions): void;
-declare function assertNoPublicDirAssetConflict({ root, publicDir, assetsDir }: PublicDirConflictOptions): void;
-//#endregion
-export { PublicDirConflictOptions, PublicNextRequestConflictOptions, assertNoPublicDirAssetConflict, assertNoPublicNextRequestConflict };
+export declare function assertNoPublicNextRequestConflict({ root, publicDir, basePath, requestUrl }: PublicNextRequestConflictOptions): void;
+export declare function assertNoPublicDirAssetConflict({ root, publicDir, assetsDir }: PublicDirConflictOptions): void;
+//#endregion

package/dist/build/public-dir-conflict.js

@@ -4,7 +4,8 @@ import { existsSync } from "node:fs";
 const PUBLIC_NEXT_CONFLICT_ERROR = "You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict";
 function assertNoPublicNextDir(root, publicDir) {
 	if (!publicDir) return;
-	if (existsSync(path.join(path.resolve(root, publicDir), "_next"))) throw new Error(PUBLIC_NEXT_CONFLICT_ERROR);
+	const publicNextDir = path.join(path.resolve(root, publicDir), "_next");
+	if (existsSync(publicNextDir)) throw new Error(PUBLIC_NEXT_CONFLICT_ERROR);
 }
 function assertNoPublicNextRequestConflict({ root, publicDir, basePath, requestUrl }) {
 	const internalOrigin = "http://vinext.invalid";