vinext 1.0.0-beta.9 → 1.0.0

package/dist/build/prerender-phase.d.ts

@@ -10,6 +10,5 @@ type PrerenderPhaseEnv = {
  * direct prerender helpers can run inside the CLI's broader build scope without
  * overwriting the caller's prior phase when they finish.
  */
-declare function enterPrerenderPhase(env?: PrerenderPhaseEnv): () => void;
-//#endregion
-export { enterPrerenderPhase };
+export declare function enterPrerenderPhase(env?: PrerenderPhaseEnv): () => void;
+//#endregion

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

@@ -1,4 +1,5 @@
 import { NoOpCacheHandler, setCacheHandler } from "../shims/cache-handler.js";
+import { registerPrerenderCloudflareLoader } from "./prerender-cloudflare-loader.js";
 import { startProdServer } from "../server/prod-server.js";
 //#region src/build/prerender-server-entry.ts
 /**
@@ -11,18 +12,25 @@ import { startProdServer } from "../server/prod-server.js";
 * 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` / `NEXT_PHASE` / `VINEXT_PRERENDER_OUTDIR` are passed via
-* the fork env so they are set before any module loads (some server and user
-* modules read the phase at import time).
+* `VINEXT_PRERENDER`, `NEXT_PHASE`, `VINEXT_PRERENDER_OUTDIR`, and the optional
+* `VINEXT_PRERENDER_RSC_ENTRY_PATH`, and `VINEXT_PRERENDER_SERVER_DIR` are
+* passed via the fork env so they are set
+* before any module loads (some server and user modules read the phase at
+* import time).
 */
 async function main() {
 	const outDir = process.env.VINEXT_PRERENDER_OUTDIR;
+	const rscEntryPath = process.env.VINEXT_PRERENDER_RSC_ENTRY_PATH;
+	const serverDir = process.env.VINEXT_PRERENDER_SERVER_DIR;
 	if (!outDir) throw new Error("[vinext] prerender server worker: VINEXT_PRERENDER_OUTDIR not set");
 	setCacheHandler(new NoOpCacheHandler());
+	registerPrerenderCloudflareLoader();
 	const { port } = await startProdServer({
 		port: 0,
 		host: "127.0.0.1",
 		outDir,
+		...rscEntryPath ? { rscEntryPath } : {},
+		...serverDir ? { serverDir } : {},
 		noCompression: true,
 		purpose: "prerender",
 		silent: true

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

@@ -5,8 +5,8 @@
  * 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 = {
+export declare function prerenderPoolAvailable(): boolean;
+export type PrerenderServerPool = {
   /** Ports of the forked render servers, for round-robin per-route fetches. */
   ports: number[];
   /**
@@ -35,12 +35,15 @@ type PrerenderServerPool = {
  * 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;
+export 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 };
+export declare function startPrerenderServerPool(outDir: string, size: number, options?: {
+  entry?: string;
+  rscEntryPath?: string;
+  serverDir?: string;
+}): Promise<PrerenderServerPool>;
+//#endregion

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

@@ -2,8 +2,8 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import os from "node:os";
 import { fork } from "node:child_process";
+import os from "node:os";
 //#region src/build/prerender-server-pool.ts
 /**
 * Parallel prerender server pool.
@@ -41,12 +41,12 @@ const MAX_POOL_SIZE = 8;
 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;
+const APPROX_MAIN_PROCESS_BYTES = 805306368;
 /** 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;
+const APPROX_BYTES_PER_WORKER = 805306368;
 /** 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. */
@@ -90,7 +90,8 @@ function isWorkerTransportError(err) {
 * 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) {
+async function startPrerenderServerPool(outDir, size, options = {}) {
+	const { entry = WORKER_ENTRY, rscEntryPath, serverDir } = options;
 	const children = [];
 	let shuttingDown = false;
 	let crash = null;
@@ -107,7 +108,9 @@ async function startPrerenderServerPool(outDir, size, entry = WORKER_ENTRY) {
 					...process.env,
 					VINEXT_PRERENDER: "1",
 					NEXT_PHASE: PHASE_PRODUCTION_BUILD,
-					VINEXT_PRERENDER_OUTDIR: outDir
+					VINEXT_PRERENDER_OUTDIR: outDir,
+					...rscEntryPath ? { VINEXT_PRERENDER_RSC_ENTRY_PATH: rscEntryPath } : {},
+					...serverDir ? { VINEXT_PRERENDER_SERVER_DIR: serverDir } : {}
 				},
 				stdio: [
 					"ignore",

package/dist/build/prerender.d.ts

@@ -5,13 +5,13 @@ import { MetadataFileRoute } from "../server/metadata-routes.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { Server } from "node:http";
 //#region src/build/prerender.d.ts
-type PrerenderResult = {
+export type PrerenderResult = {
   /** One entry per route (including skipped/error routes). */
   routes: PrerenderRouteResult[];
   /** Additional generated files that are not represented as route entries. */
   outputFiles?: string[];
 };
-type PrerenderRouteResult = {
+export type PrerenderRouteResult = {
   /** The route's file-system pattern, e.g. `/blog/:slug`. */
   route: string;
   status: "rendered";
@@ -41,7 +41,7 @@ type PrerenderRouteResult = {
 } | {
   route: string;
   status: "skipped";
-  reason: "ssr" | "dynamic" | "no-static-params" | "api" | "internal";
+  reason: "ssr" | "dynamic" | "no-static-params" | "empty-static-params" | "api" | "internal";
 } | {
   route: string;
   status: "error";
@@ -124,6 +124,16 @@ type PrerenderAppOptions = {
    * Absolute path to the pre-built RSC handler bundle (e.g. `dist/server/index.js`).
    */
   rscBundlePath: string;
+  /**
+   * Root directory for build metadata and sibling server artifacts. Defaults
+   * to the RSC entry's directory for compatibility with standalone callers.
+   */
+  serverDir?: string;
+  /**
+   * Root of the complete production build passed to the local prerender
+   * server. Defaults to the parent of `serverDir` for standalone callers.
+   */
+  buildOutDir?: string;
 } & PrerenderOptions;
 type PrerenderPagesOptionsInternal = PrerenderPagesOptions & {
   _prodServer?: {
@@ -158,7 +168,7 @@ type PrerenderAppOptionsInternal = PrerenderAppOptions & {
  * Safe regex usage: safeJsonStringify (used by createRscEmbedTransform) escapes
  * all '<' and '>' in the embedded JSON, preventing false </script> matches.
  */
-declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array | null;
+export declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array | null;
 /**
  * Build a URL path from a route pattern and params.
  * "/posts/:id" + { id: "42" } → "/posts/42"
@@ -169,21 +179,61 @@ declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array
  * caller (prerenderPages / prerenderApp) catches this and surfaces it as a
  * per-route error result.
  */
-declare function buildUrlFromParams(pattern: string, params: Record<string, string | string[]> | undefined | null): string;
+export declare function buildUrlFromParams(pattern: string, params: Record<string, string | string[]> | undefined | null): string;
 /** Map of route patterns to generateStaticParams functions (or null/undefined). */
-type StaticParamsMap = Record<string, ((opts: {
+export type StaticParamsMap = Record<string, ((opts: {
   params: Record<string, string | string[]>;
 }) => Promise<unknown>) | null | undefined>;
 /**
- * Resolve parent dynamic segment params for a route.
+ * 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).
  */
-declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: StaticParamsMap, options?: {
-  includeLastDynamicSegment?: boolean;
+export declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: StaticParamsMap, options?: {
+  staticExport?: boolean;
 }): Promise<Record<string, string | string[]>[]>;
+export declare function validateDiscoveredParams(value: unknown, pattern: string, source: "generateStaticParams" | "getStaticPaths"): Record<string, string | string[]>;
+/**
+ * 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.
+ */
+export declare function routeStaticParamSets(route: Pick<AppRoute, "pattern">, paramSets: readonly unknown[], options?: {
+  staticExport?: boolean;
+}): Record<string, string | string[]>[];
+/**
+ * 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.
+ */
+export declare function layoutOnlyParamSets(route: Pick<AppRoute, "params" | "pattern">, parentParamSets: Record<string, string | string[]>[]): Record<string, string | string[]>[] | null;
 /**
  * Run the prerender phase for Pages Router.
  *
@@ -197,7 +247,7 @@ declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: Stat
  * Writes HTML files to `outDir`. If `manifestDir` is set, writes
  * `vinext-prerender.json` there; otherwise writes it to `outDir`.
  */
-declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mode, ...options }: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
+export declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mode, ...options }: PrerenderPagesOptionsInternal): Promise<PrerenderResult>;
 /**
  * Run the prerender phase for App Router.
  *
@@ -208,14 +258,14 @@ declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, m
  * `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'.
  */
-declare function prerenderApp({ routes, metadataRoutes, outDir, config, mode, rscBundlePath, ...options }: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
+export declare function prerenderApp({ routes, metadataRoutes, outDir, config, mode, rscBundlePath, serverDir, buildOutDir, ...options }: PrerenderAppOptionsInternal): Promise<PrerenderResult>;
 /**
  * Write `vinext-prerender.json` to `outDir`.
  *
@@ -223,9 +273,9 @@ declare function prerenderApp({ routes, metadataRoutes, outDir, config, mode, rs
  * ISR cache population at production startup. The `buildId` is included so
  * the seeding function can construct matching cache keys.
  */
-declare function writePrerenderIndex(routes: PrerenderRouteResult[], outDir: string, options?: {
+export declare function writePrerenderIndex(routes: PrerenderRouteResult[], outDir: string, options?: {
   buildId?: string;
   trailingSlash?: boolean;
 }): void;
 //#endregion
-export { PrerenderResult, PrerenderRouteResult, StaticParamsMap, buildUrlFromParams, extractRscPayloadFromPrerenderedHtml, prerenderApp, prerenderPages, readPrerenderSecret, resolveParentParams, writePrerenderIndex };
+export { readPrerenderSecret };

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);
@@ -207,41 +212,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 +272,70 @@ 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;
 }
 /**
 * Run the prerender phase for Pages Router.
@@ -287,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,
@@ -531,14 +617,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 +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;
@@ -557,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"
 			});
@@ -595,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) {
@@ -664,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({
@@ -704,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;
 				}
@@ -741,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({
@@ -969,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;
 			}
 		}
@@ -1114,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 };