vinext 1.0.0-beta.9 → 1.0.0

package/dist/server/pages-router-entry.js

@@ -1,171 +1,58 @@
-import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
-import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
-import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
-import { notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
-import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
+import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
-import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
-import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
-import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
-import { finalizeMissingStaticAssetResponse } from "./worker-utils.js";
-import { fetchWorkerFilesystemRoute, runPagesRequest, wrapMiddlewareWithBasePath } from "./pages-request-pipeline.js";
+import { validateCdnRequest } from "./cache-control.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
-import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse, isWorkerPrerenderDiscoveryPath } from "./worker-prerender-discovery.js";
+import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
+import { handleRequestStageLocally, pagesRequestStageBuildId, pagesRequestStagePrerenderSecret } from "./pages-request-stage-entry.js";
+import { renderPagesResponse } from "./pages-response-stage-entry.js";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
-import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
-import * as pagesEntry from "virtual:vinext-server-entry";
+import { __ensureInstrumentation } from "virtual:vinext-pages-request-entry";
+import { __ensureInstrumentation as __ensureInstrumentation$1 } from "virtual:vinext-pages-response-entry";
 import __cacheabilityManifest from "virtual:vinext-cacheability-manifest";
 //#region src/server/pages-router-entry.ts
-/**
-* Router-specific Cloudflare Worker entry point for vinext Pages Router.
-*
-* New projects should usually use the router-selected entry in wrangler.jsonc:
-*   "main": "vinext/server/fetch-handler"
-*
-* This Pages Router entry remains available for existing configs and for custom
-* workers that need to opt into the Pages Router handler explicitly:
-*   "main": "vinext/server/pages-router-entry"
-*
-* Or import and delegate to it from a custom worker:
-*   import handler from "vinext/server/pages-router-entry";
-*   return handler.fetch(request, env, ctx);
-*/
-const { authorizeOnDemandRevalidate, handleApiRoute, hasMiddleware, matchApiRoute, matchPageRoute, normalizeDataRequest, publicFiles, renderPage, runMiddleware, vinextConfig } = pagesEntry;
-const basePath = vinextConfig?.basePath ?? "";
-const assetPathPrefix = assetPrefixPathname(vinextConfig?.assetPrefix ?? "");
-const trailingSlash = vinextConfig?.trailingSlash ?? false;
-const i18nConfig = vinextConfig?.i18n ?? null;
-const configRedirects = vinextConfig?.redirects ?? [];
-const configRewrites = vinextConfig?.rewrites ?? {
-	beforeFiles: [],
-	afterFiles: [],
-	fallback: []
-};
-const configHeaders = vinextConfig?.headers ?? [];
-const imageConfig = vinextConfig?.images ? {
-	qualities: vinextConfig.images.qualities,
-	dangerouslyAllowSVG: vinextConfig.images.dangerouslyAllowSVG,
-	dangerouslyAllowLocalIP: vinextConfig.images.dangerouslyAllowLocalIP,
-	contentDispositionType: vinextConfig.images.contentDispositionType,
-	contentSecurityPolicy: vinextConfig.images.contentSecurityPolicy
-} : void 0;
-var pages_router_entry_default = { async fetch(request, env, ctx) {
-	return applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request);
-} };
-async function handleRequest(request, env, platformCtx) {
-	const requestCtx = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
+/** Router-specific single-entry Worker facade for vinext Pages Router. */
+async function handleSingleStageRequest(request, env, platformCtx) {
+	const ctxWithRevalidation = createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleSingleStageRequest(internalRequest, env, internalCtx), "worker");
 	registerConfiguredCacheAdapters(env);
-	const cdnCacheAdapter = getCdnCacheAdapter();
-	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, pagesEntry.prerenderSecret);
+	const adapter = getCdnCacheAdapter();
+	let ctx = createWorkerPrerenderDiscoveryContext(ctxWithRevalidation, request, pagesRequestStagePrerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
-	if (readinessResponse) return await validateCdnRequest(request) ?? readinessResponse;
-	let finalizeCacheabilityResponse;
+	if (readinessResponse) {
+		if (readinessResponse.status === 204) await Promise.all([__ensureInstrumentation(), __ensureInstrumentation$1()]);
+		return await validateCdnRequest(request) ?? readinessResponse;
+	}
+	let finalize;
 	if (request.headers.has("X-Vinext-Cacheability-Probe")) {
 		const cacheability = await import("./cacheability-request.js");
-		const probeContext = cacheability.createWorkerCacheabilityContext(ctx, request, pagesEntry.prerenderSecret, cdnCacheAdapter.responseVary);
+		const probeContext = cacheability.createWorkerCacheabilityContext(ctx, request, pagesRequestStagePrerenderSecret, adapter.responseVary);
 		if (probeContext !== ctx) {
 			ctx = probeContext;
-			finalizeCacheabilityResponse = cacheability.finalizeWorkerCacheabilityResponse;
+			finalize = cacheability.finalizeWorkerCacheabilityResponse;
 			const probeUrl = new URL(request.url);
-			if (probeUrl.searchParams.has("__vinext_cacheability_probe")) {
-				probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
-				request = new Request(probeUrl, request);
-			}
+			probeUrl.searchParams.delete(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM);
+			request = cloneRequestWithUrl(request, probeUrl.toString());
+			const headers = new Headers(request.headers);
+			headers.delete(VINEXT_CACHEABILITY_PROBE_HEADER);
+			request = cloneRequestWithHeaders(request, headers);
 		}
 	}
-	const requiresCompletedResponseAdmission = cdnCacheAdapter.requiresCompletedResponseAdmission === true;
-	if (!finalizeCacheabilityResponse && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
+	const requiresCompletedResponseAdmission = adapter.requiresCompletedResponseAdmission === true;
+	if (!finalize && (__cacheabilityManifest || requiresCompletedResponseAdmission)) {
 		const cacheability = await import("./cacheability-request.js");
-		const admissionContext = cacheability.createWorkerCacheabilityAdmissionContext(ctx, request, __cacheabilityManifest, pagesEntry.buildId, requiresCompletedResponseAdmission, cdnCacheAdapter.responseVary);
+		const admissionContext = cacheability.createWorkerCacheabilityAdmissionContext(ctx, request, __cacheabilityManifest, pagesRequestStageBuildId, requiresCompletedResponseAdmission, adapter.responseVary);
 		if (admissionContext !== ctx) {
 			ctx = admissionContext;
-			finalizeCacheabilityResponse = cacheability.finalizeWorkerCacheabilityResponse;
-		}
-	}
-	const finalize = (response) => finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : Promise.resolve(response);
-	registerConfiguredImageOptimizer(env);
-	try {
-		const cdnValidationResponse = await validateCdnRequest(request);
-		if (cdnValidationResponse) return finalize(cdnValidationResponse);
-		let pathname = new URL(request.url).pathname;
-		if (ctx.isPrerenderPathDiscovery && isWorkerPrerenderDiscoveryPath(pathname)) {
-			const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
-			const response = await runWithExecutionContext(ctx, () => handleAppPrerenderEndpoint(request, {
-				isPrerenderEnabled: () => true,
-				loadPagesRoutes: async () => pagesEntry.pageRoutes,
-				pathname,
-				staticParamsMap: {}
-			}));
-			if (response) return finalize(response);
+			finalize = cacheability.finalizeWorkerCacheabilityResponse;
 		}
-		if (isOpenRedirectShaped(pathname)) return finalize(new Response("This page could not be found", { status: 404 }));
-		try {
-			normalizePathnameForRouteMatchStrict(pathname);
-		} catch {
-			return finalize(new Response("Bad Request", { status: 400 }));
-		}
-		const missingBuildAsset = isNextStaticPath(pathname, basePath, assetPathPrefix);
-		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
-		filteredHeaders.delete(VINEXT_PRERENDER_SECRET_HEADER);
-		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
-		request = cloneRequestWithHeaders(request, filteredHeaders);
-		const hadBasePath = !basePath || hasBasePath(pathname, basePath);
-		{
-			const stripped = stripBasePath(pathname, basePath);
-			if (stripped !== pathname) {
-				const strippedUrl = new URL(request.url);
-				strippedUrl.pathname = stripped;
-				request = cloneRequestWithUrl(request, strippedUrl.toString());
-				pathname = stripped;
-			}
-		}
-		const middlewareRequest = request;
-		const dataNorm = normalizeDataRequest(request);
-		if (dataNorm.notFoundResponse && !vinextConfig?.skipProxyUrlNormalize) return finalize(dataNorm.notFoundResponse);
-		const isDataReq = dataNorm.isDataReq;
-		if (isDataReq && dataNorm.normalizedPathname) {
-			request = dataNorm.request;
-			pathname = dataNorm.normalizedPathname;
-		}
-		const deps = {
-			basePath,
-			trailingSlash,
-			i18nConfig,
-			configRedirects,
-			configRewrites,
-			configHeaders,
-			hadBasePath,
-			isDataReq,
-			isDataRequest: isDataReq,
-			hasMiddleware,
-			ctx,
-			middlewareRequest: isDataReq && vinextConfig?.skipProxyUrlNormalize ? middlewareRequest : void 0,
-			dataNotFoundResponse: vinextConfig?.skipProxyUrlNormalize ? dataNorm.notFoundResponse : null,
-			authorizeOnDemandRevalidate: typeof authorizeOnDemandRevalidate === "function" ? authorizeOnDemandRevalidate : void 0,
-			matchApiRoute: typeof matchApiRoute === "function" ? matchApiRoute : null,
-			matchPageRoute: typeof matchPageRoute === "function" ? matchPageRoute : null,
-			runMiddleware: typeof runMiddleware === "function" ? wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) : null,
-			renderPage: typeof renderPage === "function" ? (req, resolvedUrl, options, stagedHeaders) => renderPage(req, resolvedUrl, null, ctx, stagedHeaders, options) : null,
-			handleApi: typeof handleApiRoute === "function" ? (req, apiUrl) => handleApiRoute(req, apiUrl, ctx, new URL(req.url).origin, "worker") : null,
-			serveFilesystemRoute: async (requestPathname, _stagedHeaders, phase, resolvedUrl) => {
-				if (!env?.ASSETS) return false;
-				if (isImageOptimizationPath(requestPathname)) {
-					const imageUrl = new URL(resolvedUrl, request.url);
-					return handleConfiguredImageOptimization(new Request(imageUrl, request), (assetPath) => Promise.resolve(env.ASSETS.fetch(new Request(new URL(assetPath, request.url)))), [...vinextConfig?.images?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...vinextConfig?.images?.imageSizes ?? DEFAULT_IMAGE_SIZES], imageConfig);
-				}
-				return fetchWorkerFilesystemRoute(request, requestPathname, phase, (assetRequest) => Promise.resolve(env.ASSETS.fetch(assetRequest)), publicFiles, missingBuildAsset);
-			}
-		};
-		const result = await runPagesRequest(request, deps);
-		if (result.type === "response") return finalize(finalizeMissingStaticAssetResponse(result.response, missingBuildAsset));
-		return finalize(missingBuildAsset ? notFoundStaticAssetResponse() : new Response("This page could not be found", { status: 404 }));
-	} catch (error) {
-		console.error("[vinext] Worker error:", error);
-		return finalize(new Response("Internal Server Error", { status: 500 }));
 	}
+	const response = await handleRequestStageLocally(request, env, ctx, (stageRequest, stageEnv, stageCtx, props) => renderPagesResponse(stageRequest, stageEnv, stageCtx, props));
+	return finalize ? finalize(response, ctx) : response;
 }
+var pages_router_entry_default = { fetch(request, env, ctx) {
+	const handle = () => handleSingleStageRequest(request, env, ctx);
+	return ctx && typeof ctx.waitUntil === "function" ? runWithExecutionContext(ctx, handle) : handle();
+} };
 //#endregion
 export { pages_router_entry_default as default };

package/dist/server/pages-serializable-props.d.ts

@@ -16,9 +16,8 @@
  * `pages-page-data.ts` so users see a clear error instead of an empty page
  * when they accidentally return a `Date`, `Map`, or class instance.
  */
-declare class SerializableError extends Error {
+export declare class SerializableError extends Error {
   constructor(page: string, method: string, path: string, message: string);
 }
-declare function isSerializableProps(page: string, method: string, input: unknown): true;
-//#endregion
-export { SerializableError, isSerializableProps };
+export declare function isSerializableProps(page: string, method: string, input: unknown): true;
+//#endregion

package/dist/server/pregenerated-concrete-paths.d.ts

@@ -2,15 +2,17 @@
 declare global {
   var __VINEXT_PREGENERATED_CONCRETE_PATHS: unknown;
 }
-declare function normalizePregeneratedPathname(pathname: string): string;
-declare function clearPregeneratedConcretePaths(): void;
-declare function addPregeneratedConcretePath(routePattern: string, pathname: string): void;
-declare function getRenderedConcreteUrlPathsForRoute(routePattern: string): ReadonlySet<string> | undefined;
+/** Stable post-build module populated after prerendering completes. */
+export declare const PREGENERATED_CONCRETE_PATHS_MODULE = "__vinext_pregenerated_concrete_paths.js";
+export declare function normalizePregeneratedPathname(pathname: string): string;
+export declare function clearPregeneratedConcretePaths(): void;
+export declare function addPregeneratedRoute(routePattern: string): void;
+export declare function addPregeneratedConcretePath(routePattern: string, pathname: string): void;
+export declare function getRenderedConcreteUrlPathsForRoute(routePattern: string): ReadonlySet<string> | undefined;
 /**
  * Populate the registry from `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`.
  * No-op when the global is not set (Node path — seed-cache handles it later).
  * Pathnames are normalised so they match the runtime `cleanPathname`.
  */
-declare function initPregeneratedPathsFromGlobals(): void;
-//#endregion
-export { addPregeneratedConcretePath, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };
+export declare function initPregeneratedPathsFromGlobals(): void;
+//#endregion

package/dist/server/pregenerated-concrete-paths.js

@@ -1,6 +1,8 @@
 import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { normalizePath } from "./normalize-path.js";
 //#region src/server/pregenerated-concrete-paths.ts
+/** Stable post-build module populated after prerendering completes. */
+const PREGENERATED_CONCRETE_PATHS_MODULE = "__vinext_pregenerated_concrete_paths.js";
 function normalizePregeneratedPathname(pathname) {
 	return normalizePath(normalizePathnameForRouteMatch(pathname));
 }
@@ -16,12 +18,13 @@ const concreteUrlPathsByRoute = /* @__PURE__ */ new Map();
 function clearPregeneratedConcretePaths() {
 	concreteUrlPathsByRoute.clear();
 }
+function addPregeneratedRoute(routePattern) {
+	if (!concreteUrlPathsByRoute.has(routePattern)) concreteUrlPathsByRoute.set(routePattern, /* @__PURE__ */ new Set());
+}
 function addPregeneratedConcretePath(routePattern, pathname) {
+	addPregeneratedRoute(routePattern);
 	let paths = concreteUrlPathsByRoute.get(routePattern);
-	if (!paths) {
-		paths = /* @__PURE__ */ new Set();
-		concreteUrlPathsByRoute.set(routePattern, paths);
-	}
+	if (!paths) return;
 	paths.add(normalizePregeneratedPathname(pathname));
 }
 function getRenderedConcreteUrlPathsForRoute(routePattern) {
@@ -37,7 +40,10 @@ function initPregeneratedPathsFromGlobals() {
 	const data = parsePregeneratedConcretePaths(raw);
 	if (!data) return;
 	clearPregeneratedConcretePaths();
-	for (const [routePattern, pathnames] of data) for (const pathname of pathnames) addPregeneratedConcretePath(routePattern, pathname);
+	for (const [routePattern, pathnames] of data) {
+		addPregeneratedRoute(routePattern);
+		for (const pathname of pathnames) addPregeneratedConcretePath(routePattern, pathname);
+	}
 }
 function parsePregeneratedConcretePaths(value) {
 	if (!Array.isArray(value)) return void 0;
@@ -58,4 +64,4 @@ function parsePregeneratedConcretePaths(value) {
 	return result;
 }
 //#endregion
-export { addPregeneratedConcretePath, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };
+export { PREGENERATED_CONCRETE_PATHS_MODULE, addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, getRenderedConcreteUrlPathsForRoute, initPregeneratedPathsFromGlobals, normalizePregeneratedPathname };

package/dist/server/prerender-cache-life-header.d.ts

@@ -5,7 +5,6 @@ type PrerenderCacheLife = {
   /** Client-router dimension — see `resolveClientStaleTimeSeconds`. */
   stale?: number;
 };
-declare function applyPrerenderCacheLifeHeader(headers: Headers, requestCacheLife: PrerenderCacheLife | null | undefined): void;
-declare function applyPrerenderCacheTagsHeader(headers: Headers, cacheTags: readonly string[]): void;
-//#endregion
-export { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader };
+export declare function applyPrerenderCacheLifeHeader(headers: Headers, requestCacheLife: PrerenderCacheLife | null | undefined): void;
+export declare function applyPrerenderCacheTagsHeader(headers: Headers, cacheTags: readonly string[]): void;
+//#endregion

package/dist/server/prerender-manifest.d.ts

@@ -1,7 +1,8 @@
 //#region src/server/prerender-manifest.d.ts
-type PrerenderManifestRoute = {
+export type PrerenderManifestRoute = {
   route: string;
   status?: string;
+  reason?: string;
   revalidate?: number | false;
   expire?: number;
   /**
@@ -18,25 +19,25 @@ type PrerenderManifestRoute = {
   routeSegments?: string[];
   tags?: string[];
 };
-type PrerenderManifest = {
+export type PrerenderManifest = {
   buildId?: string;
   trailingSlash?: boolean;
   routes?: PrerenderManifestRoute[];
   pregeneratedConcretePaths?: Array<[string, string[]]>;
 };
-type PrerenderedPathSelectionOptions = {
+export type PrerenderedPathSelectionOptions = {
   includeFallbackShells?: boolean;
   includeErrorDocuments?: boolean;
 };
-declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
-declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
-declare function getRenderedMetadataRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
+export declare function readPrerenderManifest(manifestPath: string): PrerenderManifest | null;
+export declare function getRenderedAppRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
+export declare function getRenderedMetadataRoutes(routes: PrerenderManifestRoute[]): PrerenderManifestRoute[];
 /**
  * Returns true when `pathname` contains bracket-delimited route params,
  * indicating it is a fallback-shell placeholder (e.g. `/en/blog/[slug]`)
  * rather than a concrete rendered URL.
  */
-declare function isFallbackShellArtifactPath(pathname: string, route?: PrerenderManifestRoute): boolean;
+export declare function isFallbackShellArtifactPath(pathname: string, route?: PrerenderManifestRoute): boolean;
 /**
  * Build the pregenerated concrete-path payload table from a prerender manifest.
  *
@@ -44,7 +45,7 @@ declare function isFallbackShellArtifactPath(pathname: string, route?: Prerender
  * paths by route pattern. Returns an empty array when the manifest has no
  * rendered App routes or all routes are fallback-shell artifacts.
  */
-declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
+export declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest): Array<[string, string[]]>;
 /**
  * Select concrete URL paths that were rendered by the prerender engine.
  *
@@ -54,6 +55,5 @@ declare function buildPregeneratedConcretePathTable(manifest: PrerenderManifest)
  * and known error documents are excluded by default so warmup does not request
  * synthetic bracket paths or treat a healthy 404 response as a failed warmup.
  */
-declare function getPrerenderedConcretePaths(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];
-//#endregion
-export { PrerenderManifest, PrerenderManifestRoute, PrerenderedPathSelectionOptions, buildPregeneratedConcretePathTable, getPrerenderedConcretePaths, getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest };
+export declare function getPrerenderedConcretePaths(manifest: PrerenderManifest, options?: PrerenderedPathSelectionOptions): string[];
+//#endregion

package/dist/server/prerender-manifest.js

@@ -51,10 +51,13 @@ function isFallbackShellArtifactPath(pathname, route) {
 function buildPregeneratedConcretePathTable(manifest) {
 	const routes = manifest?.routes;
 	if (!routes?.length) return [];
-	const concreteRoutes = getRenderedAppRoutes(routes).filter((r) => {
+	const byPattern = groupRoutesByPattern(getRenderedAppRoutes(routes).filter((r) => {
 		return !isFallbackShellArtifactPath(r.path ?? r.route, r);
-	});
-	return Array.from(groupRoutesByPattern(concreteRoutes).entries());
+	}));
+	for (const route of routes) if (route.status === "skipped" && route.reason === "empty-static-params") {
+		if (!byPattern.has(route.route)) byPattern.set(route.route, []);
+	}
+	return Array.from(byPattern.entries());
 }
 /**
 * Select concrete URL paths that were rendered by the prerender engine.

package/dist/server/prerender-route-params.d.ts

@@ -1,10 +1,15 @@
 //#region src/server/prerender-route-params.d.ts
-type PrerenderRouteParams = Record<string, string | string[]>;
-type PrerenderRouteParamsPayload = {
+export type PrerenderRouteParams = Record<string, string | string[]>;
+export type PrerenderRouteParamsPayload = {
   fallbackParamNames?: readonly string[];
   params: PrerenderRouteParams;
   routePattern: string;
 };
+/** Prerender-only request state authenticated at the public request boundary. */
+export type TrustedPrerenderState = {
+  routeParams: PrerenderRouteParamsPayload | null;
+  speculative: boolean;
+};
 type PrerenderRouteParamsRouteMatch = {
   kind: "exact";
   params: PrerenderRouteParams;
@@ -13,10 +18,12 @@ type PrerenderRouteParamsRouteMatch = {
   kind: "fallback-shell";
   params: PrerenderRouteParams;
 };
-declare function serializePrerenderRouteParamsHeader(payload: PrerenderRouteParamsPayload | null): string | null;
-declare function readTrustedPrerenderRouteParamsFromHeaders(headers: Headers, expectedSecret?: string): PrerenderRouteParamsPayload | null;
-declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
-declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
-declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
-//#endregion
-export { PrerenderRouteParams, PrerenderRouteParamsPayload, encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
+export declare function isTrustedPrerenderState(value: unknown): value is TrustedPrerenderState;
+export declare function serializePrerenderRouteParamsHeader(payload: PrerenderRouteParamsPayload | null): string | null;
+export declare function readTrustedPrerenderRouteParamsFromHeaders(headers: Headers, expectedSecret?: string): PrerenderRouteParamsPayload | null;
+/** Authenticate prerender params and mode once before crossing a stage transport. */
+export declare function readTrustedPrerenderStateFromHeaders(headers: Headers, expectedSecret: string): TrustedPrerenderState | null;
+export declare function readTrustedPrerenderRouteParams(request: Request): PrerenderRouteParamsPayload | null;
+export declare function matchPrerenderRouteParamsPayload(payload: PrerenderRouteParamsPayload | null, routePattern: string, params: PrerenderRouteParams): PrerenderRouteParamsRouteMatch | null;
+export declare function encodePrerenderRouteParams(pattern: string, params: PrerenderRouteParams, fallbackParamNames?: readonly string[]): PrerenderRouteParamsPayload | null;
+//#endregion

package/dist/server/prerender-route-params.js

@@ -1,6 +1,6 @@
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
-import "./headers.js";
 import { isUnknownRecord } from "../utils/record.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import "./headers.js";
 //#region src/server/prerender-route-params.ts
 function isPrerenderRouteParams(value) {
 	if (!isUnknownRecord(value)) return false;
@@ -19,6 +19,11 @@ function isPrerenderRouteParamsPayload(value) {
 	if ("fallbackParamNames" in value && (!Array.isArray(value.fallbackParamNames) || !value.fallbackParamNames.every((name) => typeof name === "string"))) return false;
 	return typeof value.routePattern === "string" && value.routePattern.startsWith("/") && isPrerenderRouteParams(value.params);
 }
+function isTrustedPrerenderState(value) {
+	if (!isUnknownRecord(value)) return false;
+	const keys = Object.keys(value);
+	return keys.length === 2 && keys.every((key) => key === "routeParams" || key === "speculative") && (value.routeParams === null || isPrerenderRouteParamsPayload(value.routeParams)) && typeof value.speculative === "boolean";
+}
 function serializePrerenderRouteParamsHeader(payload) {
 	if (payload === null || Object.keys(payload.params).length === 0) return null;
 	return encodeURIComponent(JSON.stringify(payload));
@@ -43,6 +48,16 @@ function readTrustedPrerenderRouteParamsFromHeaders(headers, expectedSecret) {
 	if (params === null) throw new Error("[vinext] Invalid internal prerender route params header.");
 	return params;
 }
+/** Authenticate prerender params and mode once before crossing a stage transport. */
+function readTrustedPrerenderStateFromHeaders(headers, expectedSecret) {
+	if (process.env.VINEXT_PRERENDER !== "1") return null;
+	const secret = headers.get(VINEXT_PRERENDER_SECRET_HEADER);
+	if (!expectedSecret || secret === null || secret !== expectedSecret) return null;
+	return {
+		routeParams: readTrustedPrerenderRouteParamsFromHeaders(headers, expectedSecret),
+		speculative: headers.get(VINEXT_PRERENDER_SPECULATIVE_HEADER) === "1"
+	};
+}
 function readTrustedPrerenderRouteParams(request) {
 	return readTrustedPrerenderRouteParamsFromHeaders(request.headers);
 }
@@ -108,4 +123,4 @@ function encodePrerenderRouteParams(pattern, params, fallbackParamNames) {
 	} : null;
 }
 //#endregion
-export { encodePrerenderRouteParams, matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRouteParamsHeader };
+export { encodePrerenderRouteParams, isTrustedPrerenderState, matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, readTrustedPrerenderRouteParamsFromHeaders, readTrustedPrerenderStateFromHeaders, serializePrerenderRouteParamsHeader };

package/dist/server/prerender-work-unit-setup.d.ts

@@ -1,7 +1,6 @@
 //#region src/server/prerender-work-unit-setup.d.ts
-declare function runWithPrerenderWorkUnit(fn: () => Promise<Response>, options?: {
+export declare function runWithPrerenderWorkUnit(fn: () => Promise<Response>, options?: {
   cacheComponents?: boolean;
   route?: string | (() => string);
 }): Promise<Response>;
-//#endregion
-export { runWithPrerenderWorkUnit };
+//#endregion

package/dist/server/prerender-work-unit-setup.js

@@ -1,10 +1,11 @@
-import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
-import { isRouteCacheabilityProbe } from "../shims/cacheability-classification.js";
 import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.js";
+import { isRouteCacheabilityProbe } from "../shims/cacheability-classification.js";
+import { NO_STORE_CACHE_CONTROL } from "./cache-control.js";
 //#region src/server/prerender-work-unit-setup.ts
 /**
-* Sets up the work unit async storage for prerendering.
+* Sets up the work unit async storage for App Router rendering.
 *
+* During ordinary Cache Components requests, wraps execution in a RequestStore.
 * During build prerendering and authenticated cacheability probes, wraps
 * execution in a PrerenderStore so dynamic APIs can suspend and the render
 * owner can interrupt the attempt without exposing catchable framework errors
@@ -12,14 +13,13 @@ import { workUnitAsyncStorage } from "../shims/internal/work-unit-async-storage.
 *
 * Used by: app-rsc-entry.ts handler template.
 *
-* TODO: If future dynamic APIs need request-scoped stores for normal (non-prerender)
-* requests, add a `{ type: "request" }` store during normal request handling.
 */
 function runWithPrerenderWorkUnit(fn, options) {
 	if (process.env.VINEXT_PRERENDER === "1" || isRouteCacheabilityProbe()) {
 		if (options?.cacheComponents !== true) return workUnitAsyncStorage.run({ type: "prerender-legacy" }, fn);
 		return runWithPrerenderWorkUnitOwner(fn, options);
 	}
+	if (options?.cacheComponents === true) return workUnitAsyncStorage.run({ type: "request" }, fn);
 	return fn();
 }
 async function runWithPrerenderWorkUnitOwner(fn, options) {

package/dist/server/prod-server.d.ts

@@ -39,12 +39,12 @@ import { IncomingMessage, ServerResponse } from "node:http";
  *
  * Exported for direct unit testing of the URL choice.
  */
-declare function resolveServerEntryImportUrl(entryPath: string): string;
-declare function rememberCurrentServerEntryImportMtime(entryPath: string): void;
-declare function importServerEntryModule(entryPath: string): Promise<any>;
+export declare function resolveServerEntryImportUrl(entryPath: string): string;
+export declare function rememberCurrentServerEntryImportMtime(entryPath: string): void;
+export declare function importServerEntryModule(entryPath: string): Promise<any>;
 /** Convert a Node.js IncomingMessage into a ReadableStream for Web Request body. */
-declare function readNodeStream(req: IncomingMessage): ReadableStream<Uint8Array>;
-type ProdServerOptions = {
+export declare function readNodeStream(req: IncomingMessage): ReadableStream<Uint8Array>;
+export type ProdServerOptions = {
   /** Port to listen on */
   port?: number;
   /** Host to bind to */
@@ -53,6 +53,8 @@ type ProdServerOptions = {
   outDir?: string;
   /** Explicit App Router RSC entry path. Defaults to `<outDir>/server/index.js`. */
   rscEntryPath?: string;
+  /** Directory containing server manifests, sidecars, and prerender artifacts. */
+  serverDir?: string;
   /** Explicit Pages Router server entry path. Defaults to `<outDir>/server/entry.js`. */
   serverEntryPath?: string;
   /** Disable compression (default: false) */
@@ -116,18 +118,19 @@ declare function nodeToWebRequest(req: IncomingMessage, urlOverride?: string, pr
  * Supports streaming compression for SSR responses.
  */
 declare function sendWebResponse(webResponse: Response, req: IncomingMessage, res: ServerResponse, compress: boolean): Promise<void>;
+declare function waitForNodeResponseCompletion(res: ServerResponse): Promise<void>;
 /**
  * Start the production server.
  *
  * Automatically detects whether the build is App Router (dist/server/index.js) or
  * Pages Router (dist/server/entry.js) and configures the appropriate handler.
  */
-declare function startProdServer(options?: ProdServerOptions): Promise<{
+export declare function startProdServer(options?: ProdServerOptions): Promise<{
   server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
   port: number;
 }>;
 type AppRouterPrerenderSeeder = (serverDir: string) => Promise<number>;
-declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRouterPrerenderSeeder;
+export declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRouterPrerenderSeeder;
 /**
  * Resolve a request pathname to a static-asset lookup path inside `clientDir`.
  *
@@ -150,6 +153,6 @@ declare function resolveAppRouterPrerenderSeeder(entryModule: unknown): AppRoute
  *    to the CDN — but we accept them so a same-origin reverse proxy can
  *    route through; the on-disk path is just `_next/static/...`.
  */
-declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
+export declare function resolveAppRouterAssetPath(pathname: string, assetPathPrefix: string, assetPrefix: string): string | null;
 //#endregion
-export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, ProdServerOptions, importServerEntryModule, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, readNodeStream, rememberCurrentServerEntryImportMtime, resolveAppRouterAssetPath, resolveAppRouterPrerenderSeeder, resolveRequestHost as resolveHost, resolveServerEntryImportUrl, sendCompressed, sendWebResponse, startProdServer, trustProxy, trustedHosts, tryServeStatic };
+export { COMPRESSIBLE_TYPES, COMPRESS_THRESHOLD, mergeResponseHeaders, mergeWebResponse, negotiateEncoding, nodeToWebRequest, resolveRequestHost as resolveHost, sendCompressed, sendWebResponse, trustProxy, trustedHosts, tryServeStatic, waitForNodeResponseCompletion };