vinext 1.0.0-beta.9 → 1.0.1

package/dist/build/prerender.js

@@ -1,31 +1,33 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
+import { isUnknownRecord } from "../utils/record.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 { extractLocaleFromUrl } from "../server/pages-i18n.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
 import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
 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";
 import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
 import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildAppRouteCacheValue } from "../server/app-route-handler-response.js";
-import { isMetadataResponseCacheable } from "../server/metadata-route-cache-policy.js";
 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 +50,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);
@@ -207,41 +213,59 @@ function emitStatic404Files(outDir, html, trailingSlash) {
 	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, options = {}) {
-	const { patternParts } = childRoute;
-	let lastDynamicIdx = -1;
-	for (let i = patternParts.length - 1; i >= 0; i--) if (patternParts[i].startsWith(":")) {
-		lastDynamicIdx = i;
-		break;
-	}
+	if (childRoute.routePath && !childRoute.pagePath) return [];
 	const parentSegments = [];
-	let prefixPattern = "";
-	const prefixEnd = options.includeLastDynamicSegment ? lastDynamicIdx + 1 : lastDynamicIdx;
-	for (let i = 0; i < prefixEnd; 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
@@ -249,7 +273,78 @@ async function resolveParentParams(childRoute, staticParamsMap, options = {}) {
 		}
 		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;
+}
+function localizePagesPath(pathname, locale, i18n) {
+	if (!i18n || !locale) return pathname;
+	if (locale === i18n.defaultLocale) {
+		const firstSegment = pathname.split("/")[1]?.toLowerCase();
+		if (!i18n.locales.some((candidate) => candidate.toLowerCase() === firstSegment)) return pathname;
+	}
+	return pathname === "/" ? `/${locale}` : `/${locale}${pathname}`;
 }
 /**
 * Run the prerender phase for Pages Router.
@@ -287,12 +382,14 @@ 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,
 				host: "127.0.0.1",
 				outDir: path.dirname(path.dirname(pagesBundlePath)),
+				serverDir: path.dirname(pagesBundlePath),
+				serverEntryPath: pagesBundlePath,
 				noCompression: true,
 				purpose: "prerender"
 			});
@@ -342,7 +439,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		for (const route of bundlePageRoutes) {
 			if (BLOCKED_PAGES.includes(route.pattern)) continue;
 			if (route.pattern === "/404") continue;
-			const { type, revalidate: classifiedRevalidate } = classifyPagesRoute(route.filePath);
+			const { type, revalidate: classifiedRevalidate, hasStaticProps = false } = classifyPagesRoute(route.filePath);
 			if (type === "ssr") {
 				if (mode === "export") results.push({
 					route: route.pattern,
@@ -374,8 +471,8 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				let pathsResult;
 				try {
 					pathsResult = await route.module.getStaticPaths({
-						locales: [],
-						defaultLocale: ""
+						locales: [...config.i18n?.locales ?? []],
+						defaultLocale: config.i18n?.defaultLocale ?? ""
 					});
 				} catch (e) {
 					results.push({
@@ -397,21 +494,38 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				}
 				const paths = pathsResult?.paths ?? [];
 				let entryError = null;
+				const seenPaths = /* @__PURE__ */ new Set();
 				for (const item of paths) {
-					const normalized = normalizeStaticPathsEntry(item, route.pattern);
+					let locale = config.i18n?.defaultLocale;
+					let pathEntry = item;
+					if (config.i18n && typeof item === "string") {
+						const localized = extractLocaleFromUrl(item, config.i18n);
+						locale = localized.locale;
+						pathEntry = localized.url;
+					} else if (item && typeof item === "object" && item.locale !== void 0) locale = item.locale;
+					const normalized = normalizeStaticPathsEntry(pathEntry, route.pattern);
 					if ("error" in normalized) {
 						entryError = normalized.error;
 						break;
 					}
+					if (locale !== void 0 && !config.i18n?.locales.includes(locale)) {
+						entryError = `Invalid locale returned from getStaticPaths for ${route.pattern}: ${locale}`;
+						break;
+					}
 					const { params } = normalized;
 					try {
-						const urlPath = buildUrlFromParams(route.pattern, params);
-						pagesToRender.push({
-							route,
-							urlPath,
-							params,
-							revalidate
-						});
+						const urlPath = localizePagesPath(buildUrlFromParams(route.pattern, params), locale, config.i18n);
+						if (!seenPaths.has(urlPath)) {
+							seenPaths.add(urlPath);
+							pagesToRender.push({
+								route,
+								urlPath,
+								params,
+								revalidate,
+								hasStaticProps,
+								locale
+							});
+						}
 					} catch (e) {
 						entryError = e.message;
 						break;
@@ -425,25 +539,58 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					});
 					continue;
 				}
-			} else pagesToRender.push({
+			} else for (const locale of config.i18n?.locales ?? [void 0]) pagesToRender.push({
 				route,
-				urlPath: route.pattern,
+				urlPath: localizePagesPath(route.pattern, locale, config.i18n),
 				params: {},
-				revalidate
+				revalidate,
+				hasStaticProps,
+				locale
 			});
 		}
 		if (!options._prodServer && pagesBundlePath && prerenderPoolAvailable()) {
 			const poolSize = resolvePrerenderPoolSize(pagesToRender.length, concurrency);
 			if (poolSize > 1) {
-				renderPool = await startOptionalPrerenderServerPool(path.dirname(path.dirname(pagesBundlePath)), poolSize);
+				renderPool = await startOptionalPrerenderServerPool(path.dirname(path.dirname(pagesBundlePath)), poolSize, void 0, path.dirname(pagesBundlePath));
 				if (renderPool) renderPorts = renderPool.ports;
 			}
 		}
 		let completed = 0;
-		const pageResults = await runWithConcurrency(pagesToRender, concurrency, async ({ route, urlPath, revalidate }) => {
+		const pageResults = await runWithConcurrency(pagesToRender, concurrency, async ({ route, urlPath, revalidate, hasStaticProps, locale }) => {
 			let result;
 			try {
 				const response = await renderPage(urlPath);
+				if (mode === "default" && response.headers.get("x-vinext-prerender-rewritten") !== "0") {
+					response.body?.cancel().catch(() => {});
+					const skipped = {
+						route: route.pattern,
+						status: "skipped",
+						reason: "dynamic"
+					};
+					onProgress?.({
+						completed: ++completed,
+						total: pagesToRender.length,
+						route: urlPath,
+						status: skipped.status
+					});
+					return skipped;
+				}
+				const contentType = response.headers.get("content-type");
+				const isStaticPropsResponse = mode === "default" && hasStaticProps && response.headers.get("X-Vinext-Cache") === "MISS";
+				const notFound = isStaticPropsResponse && response.status === 404;
+				const redirect = isStaticPropsResponse && [
+					301,
+					302,
+					303,
+					307,
+					308
+				].includes(response.status);
+				let redirectProps;
+				if (redirect) {
+					const props = await response.json();
+					if (!isUnknownRecord(props) || !isUnknownRecord(props.pageProps) || typeof props.pageProps.__N_REDIRECT !== "string" || props.pageProps.__N_REDIRECT_STATUS !== response.status || props.pageProps.__N_REDIRECT_BASE_PATH !== void 0 && typeof props.pageProps.__N_REDIRECT_BASE_PATH !== "boolean") throw new Error(`Invalid prerendered Pages redirect props for ${urlPath}`);
+					redirectProps = props;
+				}
 				const outputFiles = [];
 				const htmlOutputPath = getOutputPath(urlPath, config.trailingSlash, mode === "export" ? config.basePath : "");
 				const htmlFullPath = path.join(outDir, htmlOutputPath);
@@ -453,7 +600,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					fs.writeFileSync(htmlFullPath, html, "utf-8");
 					outputFiles.push(htmlOutputPath);
 				} else {
-					if (!response.ok) throw new Error(`renderPage returned ${response.status} for ${urlPath}`);
+					if (!response.ok && !notFound) throw new Error(`renderPage returned ${response.status} for ${urlPath}`);
 					const html = await response.text();
 					fs.mkdirSync(path.dirname(htmlFullPath), { recursive: true });
 					fs.writeFileSync(htmlFullPath, html, "utf-8");
@@ -466,7 +613,19 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					revalidate,
 					...typeof revalidate === "number" ? { expire: config.expireTime } : {},
 					router: "pages",
-					...urlPath !== route.pattern ? { path: urlPath } : {}
+					...urlPath !== route.pattern ? { path: urlPath } : {},
+					...locale ? { locale } : {},
+					...response.ok ? { responseStatus: response.status } : {},
+					...response.ok && contentType ? { headers: { "content-type": contentType } } : {},
+					...notFound ? {
+						notFound: true,
+						responseStatus: 404
+					} : {},
+					...redirect ? {
+						responseStatus: response.status,
+						redirectProps,
+						headers: { location: response.headers.get("location") ?? "/" }
+					} : {}
 				};
 			} catch (e) {
 				renderPool?.recordRenderError(e);
@@ -489,21 +648,41 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 		renderPool?.assertHealthy();
 		const hasCustom404 = findFileWithExtensions(path.join(pagesDir, "404"), fileMatcher);
 		const hasErrorPage = findFileWithExtensions(path.join(pagesDir, "_error"), fileMatcher);
-		if (hasCustom404 || hasErrorPage) try {
-			const notFoundRes = await renderPage(hasCustom404 ? "/404" : NOT_FOUND_SENTINEL_PATH);
-			const contentType = notFoundRes.headers.get("content-type") ?? "";
-			if (notFoundRes.status === 404 && contentType.includes("text/html")) {
-				const html404 = await notFoundRes.text();
-				results.push({
-					route: "/404",
-					status: "rendered",
-					outputFiles: emitStatic404Files(outDir, html404, config.trailingSlash),
-					revalidate: false,
-					router: "pages"
-				});
+		for (const locale of config.i18n?.locales ?? [void 0]) {
+			if (!hasCustom404 && !hasErrorPage) break;
+			try {
+				const notFoundRes = await renderPage(localizePagesPath(hasCustom404 ? "/404" : NOT_FOUND_SENTINEL_PATH, locale, config.i18n));
+				if (mode === "default" && notFoundRes.headers.get("x-vinext-prerender-rewritten") !== "0") {
+					notFoundRes.body?.cancel().catch(() => {});
+					continue;
+				}
+				const contentType = notFoundRes.headers.get("content-type") ?? "";
+				if (notFoundRes.status === 404 && contentType.includes("text/html")) {
+					const html404 = await notFoundRes.text();
+					const pathname = localizePagesPath("/404", locale, config.i18n);
+					let outputFiles;
+					if (pathname === "/404") outputFiles = emitStatic404Files(outDir, html404, config.trailingSlash);
+					else {
+						const outputPath = getOutputPath(pathname, config.trailingSlash);
+						const fullPath = path.join(outDir, outputPath);
+						fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+						fs.writeFileSync(fullPath, html404, "utf8");
+						outputFiles = [outputPath];
+					}
+					results.push({
+						route: "/404",
+						status: "rendered",
+						outputFiles,
+						revalidate: false,
+						router: "pages",
+						headers: { "content-type": contentType },
+						...pathname !== "/404" ? { path: pathname } : {},
+						...locale ? { locale } : {}
+					});
+				}
+			} catch (e) {
+				renderPool?.recordRenderError(e);
 			}
-		} catch (e) {
-			renderPool?.recordRenderError(e);
 		}
 		renderPool?.assertHealthy();
 		if (!skipManifest) writePrerenderIndex(results, manifestDir, {
@@ -531,14 +710,14 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 * `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;
@@ -548,7 +727,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;
@@ -557,12 +735,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"
 			});
@@ -595,6 +775,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) {
@@ -664,28 +845,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({
@@ -704,7 +893,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;
 				}
@@ -741,7 +930,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({
@@ -804,7 +993,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						};
 					}
 					const cacheControl = response.headers.get("cache-control") ?? "";
-					if (!isMetadataResponseCacheable(response)) {
+					const requestCacheLife = readPrerenderCacheLifeHeader(response.headers);
+					if (requestCacheLife?.revalidate === 0) {
 						await response.body?.cancel();
 						return {
 							route: routePattern,
@@ -812,15 +1002,14 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							reason: "dynamic"
 						};
 					}
-					const requestCacheLife = readPrerenderCacheLifeHeader(response.headers);
 					const collectedTags = readPrerenderCacheTagsHeader(response.headers);
-					const cacheValue = await buildAppRouteCacheValue(response);
+					const cacheValue = await buildAppRouteCacheValue(response, cacheControl);
 					cacheValue.headers[VINEXT_METADATA_ROUTE_CACHE_HEADER] = "1";
 					const outputPath = getAppRouteOutputPath(urlPath);
 					const fullPath = path.join(outDir, outputPath);
 					fs.mkdirSync(path.dirname(fullPath), { recursive: true });
 					fs.writeFileSync(fullPath, new Uint8Array(cacheValue.body));
-					const renderedCacheControl = resolveRenderedCacheControl(requestCacheLife ?? {}, cacheControl, config.expireTime);
+					const renderedCacheControl = resolveRenderedCacheControl(requestCacheLife ?? {}, "", config.expireTime);
 					const renderedRevalidate = renderedCacheControl.revalidate ?? false;
 					const renderedStale = resolveClientStaleTimeSeconds(requestCacheLife ?? void 0);
 					return {
@@ -969,7 +1158,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;
 			}
 		}
@@ -1091,6 +1280,9 @@ function writePrerenderIndex(routes, outDir, options) {
 			...r.routeSegments ? { routeSegments: r.routeSegments } : {},
 			...r.headers ? { headers: r.headers } : {},
 			...typeof r.responseStatus === "number" ? { responseStatus: r.responseStatus } : {},
+			...r.notFound ? { notFound: true } : {},
+			...r.redirectProps ? { redirectProps: r.redirectProps } : {},
+			...r.locale ? { locale: r.locale } : {},
 			...r.path ? { path: r.path } : {},
 			...r.fallback ? { fallback: true } : {}
 		};
@@ -1114,4 +1306,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, localizePagesPath, 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