vinext 1.0.1 → 1.1.0

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

@@ -1,9 +1,10 @@
 import { VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { isPromiseLike } from "../utils/promise.js";
 import { runWithConnectionProbe } from "../shims/headers.js";
+import { isThrownNavigationError } from "../shims/navigation-errors.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { copyLinkHeaderProvenance, hasFrameworkLinkHeaders, markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
+import { copyLinkHeaderProvenance, getFrameworkLinkHeader, markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { renderSsrErrorMetaTags } from "./app-ssr-error-meta.js";
@@ -43,7 +44,7 @@ function getAppPageStatusText(statusCode) {
 	return statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
 }
 function mergeAppPageSpecialErrorHeaders(response, middlewareContext) {
-	const frameworkLink = hasFrameworkLinkHeaders(response.headers) ? response.headers.get("link") : null;
+	const frameworkLink = getFrameworkLinkHeader(response.headers);
 	const headers = new Headers(response.headers);
 	if (frameworkLink) headers.delete("link");
 	mergeMiddlewareResponseHeaders(headers, middlewareContext?.headers ?? null);
@@ -77,6 +78,23 @@ function resolveAppPageSpecialError(error) {
 	return null;
 }
 /**
+* Resolve the special error that rejected an SSR shell. An error from the RSC
+* render reaches the shell decoded from its Flight digest, so whether
+* generateMetadata() threw it comes from the errors the RSC render threw with
+* that digest. When the page threw one too, the page's decides. An error a
+* client component threw during SSR is the page's, since generateMetadata()
+* runs only in the RSC render.
+*/
+function resolveAppPageShellSpecialError(error, renderedSpecialErrors) {
+	const specialError = resolveAppPageSpecialError(error);
+	if (!specialError || specialError.fromMetadata === true) return specialError;
+	if (isThrownNavigationError(error)) return specialError;
+	return renderedSpecialErrors.length > 0 && renderedSpecialErrors.every((rendered) => resolveAppPageSpecialError(rendered)?.fromMetadata === true) ? {
+		...specialError,
+		fromMetadata: true
+	} : specialError;
+}
+/**
 * Resolves a redirect() target against the request URL and prepends the
 * configured basePath when the target is an app-internal absolute path.
 *
@@ -95,6 +113,15 @@ function applyAppPageRedirectBasePath(location, basePath) {
 	return `${basePath}${suffixIndex === -1 ? location : location.slice(0, suffixIndex)}${suffixIndex === -1 ? "" : location.slice(suffixIndex)}`;
 }
 /**
+* The response headers stored with a page's special-error entries: a
+* redirect's own `location`, not the response's, which middleware may have
+* replaced for this request.
+*/
+function resolveAppPageSpecialErrorStoredHeaders(specialError, basePath) {
+	if (specialError.kind !== "redirect") return void 0;
+	return { location: applyAppPageRedirectBasePath(specialError.location, basePath) };
+}
+/**
 * Returns a path-relative form (`/foo?bar`) of an absolute URL when it shares
 * the request's origin; otherwise returns the URL verbatim. Used so the digest
 * we embed in the flight payload matches Next.js's convention — the digest
@@ -254,43 +281,6 @@ async function probeLayoutForErrors(options, layoutIndex) {
 	});
 	return outcome.completed ? outcome.result : null;
 }
-async function probeAppPageComponent(options) {
-	return options.runWithSuppressedHookWarning(async () => {
-		const outcome = await runWithConnectionProbe(async () => {
-			try {
-				const pageResult = options.probePage();
-				if (isPromiseLike(pageResult)) {
-					if (options.awaitAsyncResult) await pageResult;
-					else Promise.resolve(pageResult).catch(() => {});
-				}
-			} catch (error) {
-				return options.onError(error);
-			}
-			return null;
-		});
-		return outcome.completed ? outcome.result : null;
-	});
-}
-async function probeAppPageThrownError(options) {
-	return options.runWithSuppressedHookWarning(async () => {
-		const outcome = await runWithConnectionProbe(async () => {
-			try {
-				const pageResult = options.probePage();
-				if (isPromiseLike(pageResult)) await pageResult;
-			} catch (error) {
-				return {
-					error,
-					thrown: true
-				};
-			}
-			return {
-				error: null,
-				thrown: false
-			};
-		});
-		return outcome.completed && outcome.result.thrown ? outcome.result.error : null;
-	});
-}
 async function readAppPageBinaryStream(stream) {
 	const reader = stream.getReader();
 	const chunks = [];
@@ -335,4 +325,4 @@ function buildAppPageFontLinkHeader(preloads) {
 	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
 }
 //#endregion
-export { bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageComponent, probeAppPageLayouts, probeAppPageThrownError, readAppPageBinaryStream, resolveAppPageSpecialError, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageMetadataError, teeAppPageRscStreamForCapture };

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

@@ -121,6 +121,11 @@ export declare function collectAppPageSearchParams(searchParams: URLSearchParams
  */
 export declare function resolveOrderedAppPageMetadata<TModule extends AppPageHeadModule>(options: ResolveOrderedAppPageMetadataOptions<TModule>): Promise<Metadata | null>;
 export declare function resolveAppPageHead<TModule extends AppPageHeadModule>(options: ResolveAppPageHeadOptions<TModule>): Promise<ResolveAppPageHeadResult>;
+/**
+ * Whether any segment of the page's head exports `generateMetadata()`. Known
+ * from the modules alone, so callers can place the head before resolving it.
+ */
+export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadModule>(options: Pick<ResolveAppPageHeadOptions<TModule>, "layoutModules" | "pageModule" | "parallelRoutes">): boolean;
 /**
  * Start metadata and viewport resolution without coupling their completion.
  *

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

@@ -294,6 +294,13 @@ async function resolveAppPageHead(options) {
 	};
 }
 /**
+* Whether any segment of the page's head exports `generateMetadata()`. Known
+* from the modules alone, so callers can place the head before resolving it.
+*/
+function hasAppPageDynamicMetadata(options) {
+	return options.layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(options.pageModule) || (options.parallelRoutes ?? []).some(parallelRouteHasDynamicMetadata);
+}
+/**
 * Start metadata and viewport resolution without coupling their completion.
 *
 * Live document renders can place the metadata promise behind Suspense while
@@ -308,7 +315,6 @@ function prepareAppPageHeadInner(options) {
 	const layoutTreePositions = options.layoutTreePositions ?? [];
 	const layoutInputs = createLayoutInputs(options.layoutModules, layoutTreePositions);
 	const layoutSourcePositions = layoutInputs.map((input) => input.treePosition);
-	const primaryHasDynamicMetadata = layoutInputs.some((input) => hasGenerateMetadata(input.module)) || hasGenerateMetadata(options.pageModule);
 	const { hasSearchParams, pageSearchParams } = collectAppPageSearchParams(options.searchParams);
 	const layoutMetadataPromise = resolveLayoutMetadata(layoutInputs, options.params, routeSegments);
 	const layoutViewport = resolveLayoutViewport(layoutInputs, options.params, routeSegments);
@@ -334,7 +340,7 @@ function prepareAppPageHeadInner(options) {
 		accumulatedViewport = parallelViewport.resolvedViewport;
 	}
 	const parallelRouteViewportPromise = Promise.all(parallelRouteViewportPromises);
-	const hasDynamicMetadata = primaryHasDynamicMetadata || parallelRoutes.some(parallelRouteHasDynamicMetadata);
+	const hasDynamicMetadata = hasAppPageDynamicMetadata(options);
 	const metadata = Promise.all([
 		layoutMetadataPromise,
 		pageMetadataPromise,
@@ -379,4 +385,4 @@ function prepareAppPageHeadInner(options) {
 	};
 }
 //#endregion
-export { collectAppPageSearchParams, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveOrderedAppPageMetadata };
+export { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveOrderedAppPageMetadata };

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

@@ -12,124 +12,15 @@ type ProbeReactServerSubtreeOptions = Readonly<{
  * failures only make static-layout skip fall back to render-and-send.
  */
 export declare function probeReactServerSubtree(node: unknown, options?: ProbeReactServerSubtreeOptions): Promise<void>;
-/**
- * Build a probePage() invocation for the App Router request lifecycle.
- *
- * The generated RSC entry calls this once per request after route matching to
- * eagerly invoke the page component. Surfacing redirect()/notFound() throws
- * here lets the probe lifecycle turn them into proper HTTP responses before
- * RSC streaming begins (see `probeAppPageBeforeRender`).
- *
- * The helper exists to keep the generated entry thin (a single delegation
- * call) and to make the search-params wiring directly unit-testable. A bug
- * here previously slipped through because the entry hand-rolled the call and
- * read a non-existent key off `collectAppPageSearchParams`'s return value
- * (see https://github.com/cloudflare/vinext/issues/1235).
- *
- * Returns `null` when the route has no page component (eg. interception-only
- * routes), matching the caller contract on `probePage`.
- */
-export declare function probeAppPage(options: {
-  pageComponent: unknown;
-  asyncRouteParams: unknown;
-  searchParams: URLSearchParams | null | undefined;
-}): unknown;
-type AppPageProbeModule = Readonly<{
-  default?: unknown;
-}> | null | undefined;
-type AppPageProbeSlot = Readonly<{
-  page?: AppPageProbeModule;
-  loading?: AppPageProbeModule;
-  loadings?: readonly AppPageProbeModule[] | null;
-  loadingTreePositions?: readonly number[] | null;
-}> | null | undefined;
-type AppPageProbeRoute = Readonly<{
-  slots?: Readonly<Record<string, AppPageProbeSlot>> | null;
-}>;
-type AppPageProbeIntercept = Readonly<{
-  page?: AppPageProbeModule;
-  interceptLoadings?: readonly AppPageProbeModule[] | null;
-  matchedParams?: unknown;
-  /**
-   * Key of the parallel-route slot this interception overrides. At render
-   * time the matched route's `slots[slotKey].page` is replaced by the
-   * interception page (see app-page-element-builder.ts), so the slot's own
-   * page never renders for this request.
-   */
-  slotKey?: string | null;
-}> | null | undefined;
-/**
- * Fan out the per-request page probes for the App Router dispatch lifecycle.
- *
- * A single request can render more than one page component: the matched page,
- * each active parallel-route slot page, and an interception page when one
- * matches. Each must be probed so searchParams access anywhere in the rendered
- * tree bails the request out of the query-invariant static cache.
- *
- * Extracted out of the generated RSC entry so the fan-out is directly
- * unit-testable and the entry stays codegen glue (see AGENTS.md "Generated
- * Entry Modules Should Stay Thin"). Returns a list of resolved promises so the
- * caller can `Promise.all` them.
- *
- * The fan-out is scoped to the page components that render for this request:
- *
- * - **Interception override:** when an interception matches it replaces the
- *   page of the slot named by `intercept.slotKey` (the element builder sets
- *   `overrides[slotKey].pageModule` to the interception page, which wins over
- *   `slot.page` in `app-page-route-wiring.tsx`). We probe the interception page
- *   in place of that slot's own page rather than probing both — probing the
- *   overridden slot page would mark an otherwise-static request dynamic for a
- *   component that never renders.
- * - **Non-overridden slots:** `slot.page?.default` is exactly what renders.
- *   `app-page-route-wiring.tsx` resolves a slot to `overrideOrPageComponent ??
- *   defaultComponent`, so whenever a slot has a `page.tsx` that page renders.
- *   When a slot has only a `default.tsx` (including the soft-nav case at
- *   `app-page-route-wiring.tsx:741` that skips an already-mounted slot), there
- *   is no `slot.page?.default`, so `probeAppPage` short-circuits to `null` and
- *   probes nothing — a no-op, not an over-bail.
- *
- * Interception only fires for RSC navigations (`resolveAppPageInterceptState`
- * returns `kind: "none"` when `!isRscRequest`, app-page-request.ts:324), so the
- * interception handling here is gated on `isRscRequest`. For non-RSC (HTML)
- * requests the matched route renders normally, so we probe every slot's own
- * page and skip the interception probe entirely. The remaining "source-route"
- * interception case (where a *different* route renders, app-page-request.ts:342)
- * never reaches this probe: `dispatchAppPage` returns the intercepted response
- * before calling `probePage`, so by the time this runs any matched interception
- * is the current-route override case above.
- *
- * A `default.tsx` that itself awaits `searchParams` is not probed here, but the
- * real render still observes that access and skips the query-invariant cache
- * write (the same loading.tsx backstop), so this cannot under-bail.
- */
-export declare function buildAppPageProbes(options: {
-  route: AppPageProbeRoute;
-  pageComponent: unknown;
-  asyncRouteParams: unknown;
-  searchParams: URLSearchParams | null | undefined;
-  intercept?: AppPageProbeIntercept;
-  /**
-   * Whether this is an RSC navigation. Interception only fires for RSC
-   * requests, so the interception probe is ignored when this is false.
-   */
-  isRscRequest: boolean;
-  /** Fallback raw params used when an interception match omits its own. */
-  matchedParams: unknown;
-  makeThenableParams: (params: unknown) => unknown;
-}): Promise<unknown>[];
 type ProbeAppPageBeforeRenderResult = {
   response: Response | null;
   layoutFlags: LayoutFlags;
 };
 type ProbeAppPageBeforeRenderOptions = {
-  hasLoadingBoundary: boolean;
-  probePageBeforeRender?: boolean;
   skipProbes?: boolean;
   layoutCount: number;
   probeLayoutAt: (layoutIndex: number) => unknown;
-  probePage: () => unknown;
   renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
-  renderPageSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
   resolveSpecialError: (error: unknown) => AppPageSpecialError | null;
   runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   /** When provided, enables per-layout static/dynamic classification. */

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

@@ -1,10 +1,5 @@
 import { isPromiseLike } from "../utils/promise.js";
-import { isNextRouterError } from "../shims/navigation-errors.js";
-import "../shims/navigation-server.js";
-import { markAppPagePropsForUseCache, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
-import { probeAppPageComponent, probeAppPageLayouts } from "./app-page-execution.js";
-import { collectAppPageSearchParams } from "./app-page-head.js";
-import { makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
+import { probeAppPageLayouts } from "./app-page-execution.js";
 import { Fragment, isValidElement } from "react";
 //#region src/server/app-page-probe.ts
 const DEFAULT_SUBTREE_PROBE_MAX_DEPTH = 32;
@@ -123,119 +118,6 @@ async function probeReactServerSubtree(node, options = {}) {
 	};
 	await visit(node, 0);
 }
-async function probeReactServerSubtreeForDynamicUsage(node) {
-	try {
-		await probeReactServerSubtree(node);
-	} catch (error) {
-		if (isNextRouterError(error)) return;
-		throw error;
-	}
-}
-/**
-* Build a probePage() invocation for the App Router request lifecycle.
-*
-* The generated RSC entry calls this once per request after route matching to
-* eagerly invoke the page component. Surfacing redirect()/notFound() throws
-* here lets the probe lifecycle turn them into proper HTTP responses before
-* RSC streaming begins (see `probeAppPageBeforeRender`).
-*
-* The helper exists to keep the generated entry thin (a single delegation
-* call) and to make the search-params wiring directly unit-testable. A bug
-* here previously slipped through because the entry hand-rolled the call and
-* read a non-existent key off `collectAppPageSearchParams`'s return value
-* (see https://github.com/cloudflare/vinext/issues/1235).
-*
-* Returns `null` when the route has no page component (eg. interception-only
-* routes), matching the caller contract on `probePage`.
-*/
-function probeAppPage(options) {
-	const { pageComponent, asyncRouteParams, searchParams } = options;
-	if (typeof pageComponent !== "function") return null;
-	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
-	const asyncSearchParams = makeObservedAppPageSearchParamsThenable(pageSearchParams, { observeReactPromiseStatus: true });
-	const result = pageComponent(markAppPagePropsForUseCache(withUseCachePageMarker(pageComponent, {
-		params: asyncRouteParams,
-		searchParams: asyncSearchParams
-	})));
-	if (isPromiseLike(result)) return result.then(async (resolved) => {
-		await probeReactServerSubtreeForDynamicUsage(resolved);
-		return resolved;
-	});
-	if (isValidElement(result) || Array.isArray(result)) return probeReactServerSubtreeForDynamicUsage(result).then(() => result);
-	return result;
-}
-/**
-* Fan out the per-request page probes for the App Router dispatch lifecycle.
-*
-* A single request can render more than one page component: the matched page,
-* each active parallel-route slot page, and an interception page when one
-* matches. Each must be probed so searchParams access anywhere in the rendered
-* tree bails the request out of the query-invariant static cache.
-*
-* Extracted out of the generated RSC entry so the fan-out is directly
-* unit-testable and the entry stays codegen glue (see AGENTS.md "Generated
-* Entry Modules Should Stay Thin"). Returns a list of resolved promises so the
-* caller can `Promise.all` them.
-*
-* The fan-out is scoped to the page components that render for this request:
-*
-* - **Interception override:** when an interception matches it replaces the
-*   page of the slot named by `intercept.slotKey` (the element builder sets
-*   `overrides[slotKey].pageModule` to the interception page, which wins over
-*   `slot.page` in `app-page-route-wiring.tsx`). We probe the interception page
-*   in place of that slot's own page rather than probing both — probing the
-*   overridden slot page would mark an otherwise-static request dynamic for a
-*   component that never renders.
-* - **Non-overridden slots:** `slot.page?.default` is exactly what renders.
-*   `app-page-route-wiring.tsx` resolves a slot to `overrideOrPageComponent ??
-*   defaultComponent`, so whenever a slot has a `page.tsx` that page renders.
-*   When a slot has only a `default.tsx` (including the soft-nav case at
-*   `app-page-route-wiring.tsx:741` that skips an already-mounted slot), there
-*   is no `slot.page?.default`, so `probeAppPage` short-circuits to `null` and
-*   probes nothing — a no-op, not an over-bail.
-*
-* Interception only fires for RSC navigations (`resolveAppPageInterceptState`
-* returns `kind: "none"` when `!isRscRequest`, app-page-request.ts:324), so the
-* interception handling here is gated on `isRscRequest`. For non-RSC (HTML)
-* requests the matched route renders normally, so we probe every slot's own
-* page and skip the interception probe entirely. The remaining "source-route"
-* interception case (where a *different* route renders, app-page-request.ts:342)
-* never reaches this probe: `dispatchAppPage` returns the intercepted response
-* before calling `probePage`, so by the time this runs any matched interception
-* is the current-route override case above.
-*
-* A `default.tsx` that itself awaits `searchParams` is not probed here, but the
-* real render still observes that access and skips the query-invariant cache
-* write (the same loading.tsx backstop), so this cannot under-bail.
-*/
-function buildAppPageProbes(options) {
-	const { route, pageComponent, asyncRouteParams, searchParams, matchedParams } = options;
-	const intercept = options.isRscRequest ? options.intercept : null;
-	const probes = [probeAppPage({
-		pageComponent,
-		asyncRouteParams,
-		searchParams
-	})];
-	const overriddenSlotKey = intercept?.slotKey ?? null;
-	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
-		if (overriddenSlotKey !== null && slotKey === overriddenSlotKey) continue;
-		if (slot?.loading?.default || slot?.loadings?.some((loading) => loading?.default)) continue;
-		probes.push(probeAppPage({
-			pageComponent: slot?.page?.default,
-			asyncRouteParams,
-			searchParams
-		}));
-	}
-	const interceptedSlot = intercept?.slotKey ? route.slots?.[intercept.slotKey] : null;
-	const interceptedSlotHasRootLoading = Boolean(interceptedSlot?.loading?.default || interceptedSlot?.loadings?.some((loading, index) => loading?.default && interceptedSlot.loadingTreePositions?.[index] === 0));
-	const interceptHasLoadingBoundary = Boolean(intercept?.interceptLoadings?.some((loading) => loading?.default) || interceptedSlotHasRootLoading);
-	if (intercept && !interceptHasLoadingBoundary) probes.push(probeAppPage({
-		pageComponent: intercept.page?.default,
-		asyncRouteParams: options.makeThenableParams(intercept.matchedParams ?? matchedParams),
-		searchParams
-	}));
-	return probes.map((probe) => Promise.resolve(probe));
-}
 async function probeAppPageBeforeRender(options) {
 	let layoutFlags = {};
 	if (options.skipProbes) return {
@@ -262,25 +144,10 @@ async function probeAppPageBeforeRender(options) {
 			layoutFlags
 		};
 	}
-	if (options.hasLoadingBoundary || options.probePageBeforeRender === false) return {
-		response: null,
-		layoutFlags
-	};
 	return {
-		response: await probeAppPageComponent({
-			awaitAsyncResult: true,
-			async onError(pageError) {
-				const specialError = options.resolveSpecialError(pageError);
-				if (specialError) return options.renderPageSpecialError(specialError);
-				return null;
-			},
-			probePage: options.probePage,
-			runWithSuppressedHookWarning(probe) {
-				return options.runWithSuppressedHookWarning(probe);
-			}
-		}),
+		response: null,
 		layoutFlags
 	};
 }
 //#endregion
-export { buildAppPageProbes, probeAppPage, probeAppPageBeforeRender, probeReactServerSubtree };
+export { probeAppPageBeforeRender, probeReactServerSubtree };

package/dist/server/app-page-render-identity.d.ts

@@ -18,6 +18,5 @@ export type AppPageRenderIdentity = {
   routeId: string;
   targetMatchedPathname: string;
 };
-export declare function normalizeAppPageInterceptionProofPathname(pathname: string | null): string | null;
 export declare function createAppPageRenderIdentity(input: AppPageRenderIdentityInput): AppPageRenderIdentity;
 //#endregion

package/dist/server/app-page-render-identity.js

@@ -38,4 +38,4 @@ function createAppPageRenderIdentity(input) {
 	};
 }
 //#endregion
-export { createAppPageRenderIdentity, normalizeAppPageInterceptionProofPathname };
+export { createAppPageRenderIdentity };

package/dist/server/app-page-render-observation.js

@@ -1,10 +1,10 @@
 import { fnv1a64 } from "../utils/hash.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
-import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
-import "./app-elements.js";
 import { consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { consumeDynamicFetchObservations } from "../shims/fetch-cache.js";
+import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
+import "./app-elements.js";
 import { buildRenderObservation, buildRenderRequestApiObservations } from "./cache-proof.js";
 //#region src/server/app-page-render-observation.ts
 function readRootBoundaryId(element) {

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

@@ -23,6 +23,13 @@ type AppPageRequestCacheLife = {
   stale?: number;
 };
 type AppPageRenderableElement = ReactNode | Readonly<Record<string, ReactNode>>;
+type AppPageSpecialErrorRenderOptions = {
+  /**
+   * The document may be stored in place of the page's, so like a cache
+   * candidate's render it must not carry the request's query.
+   */
+  isCacheCandidate?: boolean;
+};
 type PreparedAppPageElement = {
   element: AppPageRenderableElement;
   response?: never;
@@ -63,7 +70,6 @@ type RenderAppPageLifecycleOptionsBase = {
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
   hasCustomGlobalError?: boolean;
-  hasLoadingBoundary: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
   isDraftMode: boolean;
@@ -83,9 +89,12 @@ type RenderAppPageLifecycleOptionsBase = {
   isCacheCandidate?: boolean;
   isProgressiveActionRender?: boolean;
   isPrerender?: boolean;
+  /** PPR routes send every RSC response as a 200. */
+  isRoutePPREnabled?: boolean;
   isSpeculativePrerender?: boolean;
+  /** Wait for the whole document before its first byte, as a prerender does. */
+  renderWholeDocument?: boolean;
   isProduction: boolean;
-  probePageBeforeRender?: boolean;
   omitPendingDynamicCacheState?: boolean;
   isRscRequest: boolean;
   traceOperation?: "prerender" | "render";
@@ -107,13 +116,12 @@ type RenderAppPageLifecycleOptionsBase = {
   rootParams?: RootParams;
   peekRenderObservationState?: () => AppPageRenderObservationState;
   probeLayoutAt: (layoutIndex: number) => unknown;
-  probePage: () => unknown;
   expireSeconds?: number;
   formState?: ReactFormState | null;
   revalidateSeconds: number | null;
   renderErrorBoundaryResponse: (error: unknown, errorOrigin: "rsc" | "ssr") => Promise<Response | null>;
   renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
-  renderPageSpecialError: (specialError: AppPageSpecialError) => Promise<Response>;
+  renderPageSpecialError: (specialError: AppPageSpecialError, renderOptions?: AppPageSpecialErrorRenderOptions) => Promise<Response>;
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {
     onError: AppPageBoundaryOnError;
     signal?: AbortSignal;
@@ -150,6 +158,6 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  * its response policy, such as error boundaries and special errors, get the
  * same header as the normal render.
  */
-export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">): Response;
+export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, probeCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
 //#endregion