vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/app-page-stream.js

@@ -1,9 +1,12 @@
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { getNextErrorDigest } from "./next-error-digest.js";
+import { isAppRenderAbortError } from "./app-rsc-errors.js";
 //#region src/server/app-page-stream.ts
 function isAppSsrRenderResult(value) {
 	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
@@ -49,6 +52,13 @@ function buildAppPageLinkHeader(reactLinkHeader, fontLinkHeader, maxHeadersLengt
 	}
 	return header;
 }
+function createAppPageSsrErrorHandler(baseOnError, isCapturedRscError) {
+	return (error) => {
+		if (isAppRenderAbortError(error)) return void 0;
+		if (isCapturedRscError(error)) return getNextErrorDigest(error) ?? void 0;
+		return baseOnError(error, void 0, void 0);
+	};
+}
 function createAppPageFontData(options) {
 	return {
 		links: options.getLinks(),
@@ -62,6 +72,7 @@ async function renderAppPageHtmlStream(options) {
 		scriptNonce: options.scriptNonce,
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
+		clientTraceMetadataMarker: options.clientTraceMetadataMarker,
 		reactMaxHeadersLength: options.reactMaxHeadersLength,
 		rootParams: options.rootParams,
 		sideStream: options.sideStream,
@@ -70,7 +81,9 @@ async function renderAppPageHtmlStream(options) {
 		waitForAllReady: options.waitForAllReady,
 		isStaticGeneration: options.isStaticGeneration,
 		isForceStatic: options.isForceStatic,
+		isCacheCandidate: options.isCacheCandidate,
 		initialDevServerError: options.initialDevServerError,
+		onSsrError: options.onSsrError,
 		mirrorNextFlight: options.mirrorNextFlight,
 		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
@@ -100,12 +113,13 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, renderComplete, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
 			response: null,
 			metadataReady,
+			renderComplete: renderComplete ?? resolvedMetadataReady,
 			capturedRscData,
 			shellErrorRecovered: shellErrorRecovered === true,
 			linkHeader
@@ -116,6 +130,7 @@ async function renderAppPageHtmlStreamWithRecovery(options) {
 			htmlStream: null,
 			response: await options.renderSpecialErrorResponse(specialError),
 			metadataReady: resolvedMetadataReady,
+			renderComplete: resolvedMetadataReady,
 			capturedRscData: null,
 			shellErrorRecovered: false
 		};
@@ -124,6 +139,7 @@ async function renderAppPageHtmlStreamWithRecovery(options) {
 			htmlStream: null,
 			response: boundaryResponse,
 			metadataReady: resolvedMetadataReady,
+			renderComplete: resolvedMetadataReady,
 			capturedRscData: null,
 			shellErrorRecovered: false
 		};
@@ -133,6 +149,8 @@ async function renderAppPageHtmlStreamWithRecovery(options) {
 function createAppPageRscErrorTracker(baseOnError) {
 	let capturedError = null;
 	let capturedSpecialError = null;
+	const capturedErrors = /* @__PURE__ */ new Set();
+	const capturedDigests = /* @__PURE__ */ new Set();
 	return {
 		getCapturedError() {
 			return capturedError;
@@ -140,13 +158,24 @@ function createAppPageRscErrorTracker(baseOnError) {
 		getCapturedSpecialError() {
 			return capturedSpecialError;
 		},
+		isCapturedError(error) {
+			if (capturedErrors.has(error)) return true;
+			const digest = getNextErrorDigest(error);
+			return digest !== null && capturedDigests.has(digest);
+		},
 		onRenderError(error, requestInfo, errorContext) {
 			if (isNavigationSignalError(error)) {
 				if (capturedSpecialError === null) capturedSpecialError = error;
-			} else capturedError = error;
-			return baseOnError(error, requestInfo, errorContext);
+			} else {
+				capturedError = error;
+				capturedErrors.add(error);
+			}
+			const result = baseOnError(error, requestInfo, errorContext);
+			const digest = typeof result === "string" ? result : getNextErrorDigest(error);
+			if (digest !== null && !isNavigationSignalError(error)) capturedDigests.add(digest);
+			return result;
 		}
 	};
 }
 //#endregion
-export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

package/dist/server/app-page-tracing.d.ts

@@ -0,0 +1,33 @@
+import { FrameworkSpan } from "./framework-tracer.js";
+//#region src/server/app-page-tracing.d.ts
+export declare function traceAppPageRender<T>(routePattern: string, operation: "prerender" | "render", callback: (span: FrameworkSpan) => T): T;
+export declare function createAppPageRenderSpanDescriptor(routePattern: string, operation: "prerender" | "render"): {
+  readonly attributes: {
+    readonly "next.route": string;
+  };
+  readonly name: `prerender route (app) ${string}` | `render route (app) ${string}`;
+  readonly type: "AppRender.getBodyResult";
+};
+export declare function createGetLayoutOrPageModuleSpanDescriptor(segment: string): {
+  readonly attributes: {
+    readonly "next.segment": string;
+  };
+  readonly name: "resolve segment modules";
+  readonly type: "NextNodeServer.getLayoutOrPageModule";
+};
+export declare function createComponentTreeSpanDescriptor(): {
+  readonly name: "build component tree";
+  readonly type: "NextNodeServer.createComponentTree";
+};
+export declare function traceCreateComponentTree<T>(callback: () => T): T;
+export declare function traceGetLayoutOrPageModule<T>(segment: string, callback: () => T): T;
+export declare function resolveAppPageModuleTraceSegment(routeSegments: readonly string[], treePosition: number): string;
+export declare function recordAppPageRenderError(span: FrameworkSpan, error: unknown): void;
+export declare function resolveAppPageTraceOperation(options: {
+  hasRequestSearchParams: boolean;
+  isDynamicError: boolean;
+  isForceStatic: boolean;
+  isKnownPrerenderedRoute: boolean;
+  isPrerender: boolean;
+}): "prerender" | "render";
+//#endregion

package/dist/server/app-page-tracing.js

@@ -0,0 +1,49 @@
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { recordFrameworkSpanError } from "./framework-tracer.js";
+import { frameworkTracer } from "./tracer.js";
+import { getDigestForWellKnownError, isAppRenderAbortError } from "./app-rsc-errors.js";
+//#region src/server/app-page-tracing.ts
+function traceAppPageRender(routePattern, operation, callback) {
+	return frameworkTracer.trace(createAppPageRenderSpanDescriptor(routePattern, operation), callback);
+}
+function createAppPageRenderSpanDescriptor(routePattern, operation) {
+	const route = patternToNextFormat(routePattern);
+	return {
+		attributes: { "next.route": route },
+		name: `${operation} route (app) ${route}`,
+		type: "AppRender.getBodyResult"
+	};
+}
+function createGetLayoutOrPageModuleSpanDescriptor(segment) {
+	return {
+		attributes: { "next.segment": segment },
+		name: "resolve segment modules",
+		type: "NextNodeServer.getLayoutOrPageModule"
+	};
+}
+function createComponentTreeSpanDescriptor() {
+	return {
+		name: "build component tree",
+		type: "NextNodeServer.createComponentTree"
+	};
+}
+function traceCreateComponentTree(callback) {
+	return frameworkTracer.trace(createComponentTreeSpanDescriptor(), callback);
+}
+function traceGetLayoutOrPageModule(segment, callback) {
+	return frameworkTracer.trace(createGetLayoutOrPageModuleSpanDescriptor(segment), callback);
+}
+function resolveAppPageModuleTraceSegment(routeSegments, treePosition) {
+	return treePosition === 0 ? "" : routeSegments[treePosition - 1] ?? "";
+}
+function recordAppPageRenderError(span, error) {
+	if (isAppRenderAbortError(error) || getDigestForWellKnownError(error) !== void 0) return;
+	recordFrameworkSpanError(span, error);
+}
+function resolveAppPageTraceOperation(options) {
+	if (options.isPrerender || options.isForceStatic || options.isDynamicError) return "prerender";
+	if (options.hasRequestSearchParams) return "render";
+	return options.isKnownPrerenderedRoute ? "prerender" : "render";
+}
+//#endregion
+export { createAppPageRenderSpanDescriptor, createComponentTreeSpanDescriptor, createGetLayoutOrPageModuleSpanDescriptor, recordAppPageRenderError, resolveAppPageModuleTraceSegment, resolveAppPageTraceOperation, traceAppPageRender, traceCreateComponentTree, traceGetLayoutOrPageModule };

package/dist/server/app-pages-bridge.d.ts

@@ -1,13 +1,13 @@
 import { AppMiddlewareContext } from "./app-middleware.js";
 import { EdgeApiExecutionRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-pages-bridge.d.ts
-type PagesEntry = {
-  handleApiRoute?: (request: Request, url: string, ctx: unknown, trustedRevalidateOrigin: string | undefined, edgeRuntime: EdgeApiExecutionRuntime) => Promise<Response> | Response;
+export type PagesEntry = {
+  handleApiRoute?: (request: Request, url: string, ctx: unknown, trustedRevalidateOrigin: string | undefined, edgeRuntime: EdgeApiExecutionRuntime, initialResponseHeaders?: Headers) => Promise<Response> | Response;
   matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null, options?: {
     isDataReq?: boolean;
-  }) => Promise<Response> | Response;
+  }, initialResponseHeaders?: Headers) => Promise<Response> | Response;
 };
 type PagesRouteMatch = {
   route: {
@@ -48,6 +48,7 @@ type RenderPagesFallbackOptions = {
   appRouteMatch?: AppRouteMatch | null;
   isDataRequest?: boolean;
   isRscRequest: boolean;
+  initialResponseHeaders?: Headers;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
   pathname?: string;
@@ -58,6 +59,5 @@ type RenderPagesFallbackOptions = {
 /**
  * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
  */
-declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
-//#endregion
-export { PagesEntry, renderPagesFallback };
+export declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
+//#endregion

package/dist/server/app-pages-bridge.js

@@ -1,5 +1,6 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { beginRouteCacheability } from "../shims/cacheability-classification.js";
 import { mergeHeaders } from "./worker-utils.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
 //#region src/server/app-pages-bridge.ts
@@ -17,7 +18,7 @@ function applyPagesMiddlewareContext(response, middlewareContext) {
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, initialResponseHeaders, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
@@ -39,7 +40,14 @@ async function renderPagesFallback(options, dependencies) {
 			if (apiMatch === null || !pagesRouteHasPriorityOverAppRoute(apiMatch.route, appRouteMatch.route)) return null;
 		}
 		const executionContext = getRequestExecutionContext();
-		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl, void 0, executionContext?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin, executionContext?.hostRuntime ?? "node");
+		const apiArgs = [
+			pagesRequest,
+			pagesUrl,
+			void 0,
+			executionContext?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin,
+			executionContext?.hostRuntime ?? "node"
+		];
+		const pagesApiResponse = await (initialResponseHeaders ? pagesEntry.handleApiRoute(...apiArgs, initialResponseHeaders) : pagesEntry.handleApiRoute(...apiArgs));
 		const draftCookie = getDraftModeCookieHeader();
 		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
 	}
@@ -50,8 +58,15 @@ async function renderPagesFallback(options, dependencies) {
 	if (pageMatch !== null && matchKind === "static" && pageMatch.route.isDynamic) return null;
 	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
 	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
-	const renderRequest = pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest;
-	const pagesRes = isDataRequest ? await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders, { isDataReq: true }) : await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	if (pageMatch !== null) beginRouteCacheability("pages-page", pageMatch.route.pattern);
+	const renderArgs = [
+		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,
+		pagesUrl,
+		{},
+		void 0,
+		middlewareContext.requestHeaders
+	];
+	const pagesRes = isDataRequest ? await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, { isDataReq: true }, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs, { isDataReq: true })) : await (initialResponseHeaders ? pagesEntry.renderPage(...renderArgs, void 0, initialResponseHeaders) : pagesEntry.renderPage(...renderArgs));
 	if (pagesRes.status === 404 && pageMatch === null) return null;
 	return applyDraftModeCookie(applyPagesMiddlewareContext(pagesRes, middlewareContext), getDraftModeCookieHeader());
 }

package/dist/server/app-post-middleware-context.d.ts

@@ -9,6 +9,5 @@ import { RequestContext } from "../config/request-context.js";
  * Falls back to `requestContextFromRequest(request)` when no HeadersContext
  * is set (no middleware ran, or middleware didn't set request headers).
  */
-declare function buildPostMwRequestContext(request: Request): RequestContext;
-//#endregion
-export { buildPostMwRequestContext };
+export declare function buildPostMwRequestContext(request: Request): RequestContext;
+//#endregion

package/dist/server/app-ppr-fallback-shell-render.d.ts

@@ -3,7 +3,7 @@ import { ReactNode } from "react";
 //#region src/server/app-ppr-fallback-shell-render.d.ts
 type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
-type WarmPprFallbackShellCachesOptions = {
+export type WarmPprFallbackShellCachesOptions = {
   element: AppPageRenderableElement;
   onError: AppPageBoundaryOnError;
   renderToReadableStream: (element: AppPageRenderableElement, options: {
@@ -12,6 +12,5 @@ type WarmPprFallbackShellCachesOptions = {
   }) => ReadableStream<Uint8Array>;
   state: PprFallbackShellState;
 };
-declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
-//#endregion
-export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };
+export declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
+//#endregion

package/dist/server/app-ppr-fallback-shell-render.js

@@ -3,13 +3,14 @@ import { readAppPageBinaryStream } from "./app-page-execution.js";
 //#region src/server/app-ppr-fallback-shell-render.ts
 async function warmPprFallbackShellCaches(options) {
 	let warmupError = null;
-	const warmupDrain = readAppPageBinaryStream(options.renderToReadableStream(options.element, {
+	const warmupStream = options.renderToReadableStream(options.element, {
 		signal: options.state.abortController.signal,
 		onError(error, requestInfo, errorContext) {
 			if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
 			return options.onError(error, requestInfo, errorContext);
 		}
-	})).catch((error) => {
+	});
+	const warmupDrain = readAppPageBinaryStream(warmupStream).catch((error) => {
 		if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
 		warmupError = error;
 	});

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -14,20 +14,19 @@ type AppPprFallbackShell = {
  * Produced at build time by the PPR prerender and served at request time
  * when the exact cache entry for a dynamic child param is missing.
  */
-type AppPagePprFallbackCacheShell = {
+export type AppPagePprFallbackCacheShell = {
   fallbackParamNames: readonly string[];
   params: Record<string, string | string[]>;
   pathname: string;
 };
-declare function markAppPprDynamicFallbackShellHtml(html: string): string;
-declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
-declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
-declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
+export declare function markAppPprDynamicFallbackShellHtml(html: string): string;
+export declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
+export declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
+export declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   html: string;
   isForceStatic?: boolean;
   params: Record<string, string | string[]>;
   pathname: string;
   searchParams: URLSearchParams;
 }): string;
-//#endregion
-export { AppPagePprFallbackCacheShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };
+//#endregion

package/dist/server/app-prerender-endpoints.d.ts

@@ -2,9 +2,10 @@ import { RootParams } from "../shims/root-params.js";
 //#region src/server/app-prerender-endpoints.d.ts
 type GenerateStaticParams = (args: {
   params: RootParams;
+  rejectEmptyResults?: boolean;
 }) => unknown;
-type AppPrerenderStaticParamsMap = Record<string, GenerateStaticParams | null | undefined>;
-type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | undefined>;
+export type AppPrerenderStaticParamsMap = Record<string, GenerateStaticParams | null | undefined>;
+export type AppPrerenderRootParamNamesMap = Record<string, readonly string[] | undefined>;
 type HandleAppPrerenderEndpointOptions = {
   isPrerenderEnabled?: () => boolean;
   getMetadataRoutePaths?: () => Promise<unknown>;
@@ -13,6 +14,5 @@ type HandleAppPrerenderEndpointOptions = {
   rootParamNamesByPattern?: AppPrerenderRootParamNamesMap;
   staticParamsMap: AppPrerenderStaticParamsMap;
 };
-declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
-//#endregion
-export { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap, handleAppPrerenderEndpoint };
+export declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
+//#endregion

package/dist/server/app-prerender-endpoints.js

@@ -2,7 +2,11 @@ import "./headers.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { callAppPrerenderStaticParams } from "./app-prerender-static-params.js";
 //#region src/server/app-prerender-endpoints.ts
-const JSON_HEADERS = { "content-type": "application/json" };
+const JSON_HEADERS = {
+	"cache-control": "no-store",
+	"content-type": "application/json"
+};
+const NO_STORE_HEADERS = { "cache-control": "no-store" };
 async function handleAppPrerenderEndpoint(request, options) {
 	if (options.pathname === "/__vinext/prerender/static-params") return handleStaticParamsEndpoint(request, options);
 	if (options.pathname === "/__vinext/prerender/pages-static-paths") {
@@ -16,7 +20,7 @@ async function handleAppPrerenderEndpoint(request, options) {
 	return null;
 }
 async function handleMetadataRoutesEndpoint(options) {
-	if (!isEnabled(options)) return notFoundResponse();
+	if (!isEnabled(options)) return notFoundResponse({ headers: NO_STORE_HEADERS });
 	try {
 		return jsonResponse(await options.getMetadataRoutePaths?.());
 	} catch (error) {
@@ -24,28 +28,38 @@ async function handleMetadataRoutesEndpoint(options) {
 	}
 }
 async function handleStaticParamsEndpoint(request, options) {
-	if (!isEnabled(options)) return notFoundResponse();
+	if (!isEnabled(options)) return notFoundResponse({ headers: NO_STORE_HEADERS });
 	const url = new URL(request.url);
 	const pattern = url.searchParams.get("pattern");
-	if (!pattern) return new Response("missing pattern", { status: 400 });
+	if (!pattern) return new Response("missing pattern", {
+		headers: NO_STORE_HEADERS,
+		status: 400
+	});
 	const generateStaticParams = options.staticParamsMap[pattern];
 	if (typeof generateStaticParams !== "function") return jsonNullResponse();
 	try {
-		return jsonResponse(await callAppPrerenderStaticParams({
+		const params = parseParentParams(url.searchParams.get("parentParams"));
+		const result = await callAppPrerenderStaticParams({
 			fn: generateStaticParams,
-			params: parseParentParams(url.searchParams.get("parentParams")),
+			params,
 			pattern,
+			rejectEmptyResults: url.searchParams.get("rejectEmptyResults") === "1",
 			rootParamNamesByPattern: options.rootParamNamesByPattern ?? {}
-		}));
+		});
+		if (result === null) return jsonNullResponse();
+		return jsonResponse(result);
 	} catch (error) {
 		return jsonResponse({ error: String(error) }, 500);
 	}
 }
 async function handlePagesStaticPathsEndpoint(request, options) {
-	if (!isEnabled(options)) return notFoundResponse();
+	if (!isEnabled(options)) return notFoundResponse({ headers: NO_STORE_HEADERS });
 	const url = new URL(request.url);
 	const pattern = url.searchParams.get("pattern");
-	if (!pattern) return new Response("missing pattern", { status: 400 });
+	if (!pattern) return new Response("missing pattern", {
+		headers: NO_STORE_HEADERS,
+		status: 400
+	});
 	try {
 		const getStaticPaths = findPageRoute(await options.loadPagesRoutes?.(), pattern)?.module?.getStaticPaths;
 		if (typeof getStaticPaths !== "function") return jsonNullResponse();
@@ -67,9 +81,9 @@ function jsonResponse(body, status = 200) {
 	});
 }
 function jsonNullResponse() {
-	return new Response("null", {
-		headers: JSON_HEADERS,
-		status: 200
+	return new Response(null, {
+		headers: NO_STORE_HEADERS,
+		status: 204
 	});
 }
 function parseParentParams(raw) {

package/dist/server/app-prerender-static-params.d.ts

@@ -1,8 +1,16 @@
 import { RootParams } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.d.ts
-type GenerateStaticParamsFunction = (input: {
+/**
+ * A prerender resolver's input. `rejectEmptyResults` is set where Next.js
+ * fails the build on any generateStaticParams that returns no params
+ * (`output: "export"`, Cache Components), so the resolver hands the empty
+ * result back for the caller to reject instead of passing parents through.
+ */
+type AppPrerenderStaticParamsResolverInput = {
   params: RootParams;
-}) => unknown;
+  rejectEmptyResults?: boolean;
+};
+type AppPrerenderStaticParamsResolver = (input: AppPrerenderStaticParamsResolverInput) => unknown;
 /**
  * Build a prerender `generateStaticParams` resolver for one route pattern.
  *
@@ -17,13 +25,13 @@ type GenerateStaticParamsFunction = (input: {
  *
  * Returns `null` (no resolver) only when the pattern has zero sources at all.
  */
-declare function createAppPrerenderStaticParamsResolver(sources: readonly unknown[], rootParamNames?: readonly string[]): GenerateStaticParamsFunction | null;
+export declare function createAppPrerenderStaticParamsResolver(sources: readonly unknown[], rootParamNames?: readonly string[]): AppPrerenderStaticParamsResolver | null;
 type CallAppPrerenderStaticParamsOptions = {
-  fn: GenerateStaticParamsFunction;
+  fn: AppPrerenderStaticParamsResolver;
   params: RootParams;
   pattern: string;
+  rejectEmptyResults?: boolean;
   rootParamNamesByPattern: Record<string, readonly string[] | undefined>;
 };
-declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
-//#endregion
-export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };
+export declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
+//#endregion

package/dist/server/app-prerender-static-params.js

@@ -1,6 +1,14 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { pickRootParams, runWithRootParamsScope } from "../shims/root-params.js";
 //#region src/server/app-prerender-static-params.ts
+/**
+* Next.js rejects malformed generateStaticParams output in every mode
+* (build/static-paths/app.ts callGenerateStaticParams), so it must never read
+* as an empty result that later providers continue from.
+*/
+function invalidGenerateStaticParamsResult(message) {
+	throw new Error(message);
+}
 function isGenerateStaticParamsFunction(value) {
 	return typeof value === "function";
 }
@@ -8,7 +16,9 @@ function isLazyStaticParamsSource(value) {
 	return typeof value === "object" && value !== null && "load" in value && typeof value.load === "function";
 }
 function isRootParams(value) {
-	return isUnknownRecord(value);
+	if (!isUnknownRecord(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 }
 /**
 * Build a prerender `generateStaticParams` resolver for one route pattern.
@@ -48,21 +58,29 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 		if (fns.length === 0) return null;
 		if (fns.length === 1) {
 			const single = fns[0];
-			return runWithRootParamsScope(filterRootParams(input.params), async () => {
-				const result = await single(input);
-				if (!Array.isArray(result)) return [];
-				for (const item of result) if (!isRootParams(item)) return [];
+			const picked = filterRootParams(input.params);
+			return runWithRootParamsScope(picked, async () => {
+				const result = await single({ params: input.params });
+				if (!Array.isArray(result)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array");
+				for (const item of result) if (!isRootParams(item)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array of objects");
 				return result;
 			});
 		}
-		let paramSets = [input.params];
+		let paramSets = Object.keys(input.params).length > 0 ? [input.params] : [];
 		for (const generateStaticParams of fns) {
 			const nextParamSets = [];
-			for (const parentParams of paramSets) {
-				const result = await runWithRootParamsScope(filterRootParams(parentParams), async () => generateStaticParams({ params: parentParams }));
-				if (!Array.isArray(result)) return [];
+			const hasParentSets = paramSets.length > 0;
+			for (const parentParams of hasParentSets ? paramSets : [{}]) {
+				const rootScope = filterRootParams(parentParams);
+				const result = await runWithRootParamsScope(rootScope, async () => generateStaticParams({ params: parentParams }));
+				if (!Array.isArray(result)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array");
+				if (result.length === 0) {
+					if (input.rejectEmptyResults) return [];
+					if (hasParentSets) nextParamSets.push(parentParams);
+					continue;
+				}
 				for (const item of result) {
-					if (!isRootParams(item)) return [];
+					if (!isRootParams(item)) return invalidGenerateStaticParamsResult("generateStaticParams must return an array of objects");
 					nextParamSets.push({
 						...parentParams,
 						...item
@@ -75,7 +93,11 @@ function createAppPrerenderStaticParamsResolver(sources, rootParamNames) {
 	};
 }
 async function callAppPrerenderStaticParams(options) {
-	return runWithRootParamsScope(pickRootParams(options.params, options.rootParamNamesByPattern[options.pattern]), () => options.fn({ params: options.params }));
+	const picked = pickRootParams(options.params, options.rootParamNamesByPattern[options.pattern]);
+	return runWithRootParamsScope(picked, () => options.fn(options.rejectEmptyResults ? {
+		params: options.params,
+		rejectEmptyResults: true
+	} : { params: options.params }));
 }
 //#endregion
 export { callAppPrerenderStaticParams, createAppPrerenderStaticParamsResolver };

package/dist/server/app-render-dependency.d.ts

@@ -1,21 +1,22 @@
 import { ComponentType, ReactNode } from "react";
 //#region src/server/app-render-dependency.d.ts
-type AppRenderDependency = {
+export type AppRenderDependency = {
   promise: Promise<void>;
   release: () => void;
 };
-type AppPageRenderDependency = AppRenderDependency & {
+export type AppPageRenderDependency = AppRenderDependency & {
   resultDependencies: readonly AppRenderDependency[];
   setResultDependencies: (dependencies: readonly AppRenderDependency[]) => void;
 };
-declare function isReactOwnedAppComponent(component: unknown): boolean;
-declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
-declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
-declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
-declare function createAppRenderDependency(): AppRenderDependency;
-declare function createAppPageRenderDependency(): AppPageRenderDependency;
-declare function isAppRenderSuspension(error: unknown): boolean;
-declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
-declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency): ReactNode;
-//#endregion
-export { AppPageRenderDependency, AppRenderDependency, createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+/** Whether `component` is a "use client" export seen from the RSC environment. */
+export declare function isAppClientReference(component: unknown): boolean;
+export declare function isReactOwnedAppComponent(component: unknown): boolean;
+export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
+export declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
+export declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
+export declare function createAppRenderDependency(): AppRenderDependency;
+export declare function createAppPageRenderDependency(): AppPageRenderDependency;
+export declare function isAppRenderSuspension(error: unknown): boolean;
+export declare function renderAfterAppDependencies(children: ReactNode, dependencies: readonly AppRenderDependency[]): ReactNode;
+export declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency): ReactNode;
+//#endregion

package/dist/server/app-render-dependency.js

@@ -6,6 +6,10 @@ const REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
 const REACT_FORWARD_REF = Symbol.for("react.forward_ref");
 const REACT_LAZY = Symbol.for("react.lazy");
 const REACT_MEMO = Symbol.for("react.memo");
+/** Whether `component` is a "use client" export seen from the RSC environment. */
+function isAppClientReference(component) {
+	return component?.$$typeof === REACT_CLIENT_REFERENCE;
+}
 function isReactOwnedAppComponent(component) {
 	const candidate = component;
 	if (candidate?.$$typeof === REACT_MEMO || candidate?.$$typeof === REACT_LAZY || candidate?.$$typeof === REACT_FORWARD_REF) return false;
@@ -88,4 +92,4 @@ function renderAppComponentWithDependencyBarrier(component, props, dependency) {
 	return createElement(AppComponentDependencyBarrier);
 }
 //#endregion
-export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };