vinext 1.0.0-beta.8 → 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,19 +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).
+ */
+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.
  */
-declare function resolveParentParams(childRoute: AppRoute, staticParamsMap: StaticParamsMap): Promise<Record<string, string | string[]>[]>;
+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.
  *
@@ -195,25 +247,25 @@ 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.
  *
  * 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'.
  */
-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`.
  *
@@ -221,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 };