vinext 1.0.0 → 1.1.0

package/dist/server/app-page-element-builder.js

@@ -1,27 +1,27 @@
 import { isPromiseLike } from "../utils/promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { createAppPageRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies } from "./app-render-dependency.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
-import { matchRoutePattern } from "../routing/route-pattern.js";
+import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
-import { withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
-import { prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
-import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 import { sanitizeErrorForClient } from "./app-rsc-errors.js";
 import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
 import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
+import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
 import { resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
 import { ClientPageRoot } from "../shims/client-page-root.js";
 import "./app-rsc-route-matching.js";
 import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
+import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
+import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { Suspense, createElement } from "react";
+import { Suspense, cache, createElement } from "react";
 //#region src/server/app-page-element-builder.ts
 function resolveInterceptLayoutParams(branchSegments, layoutSegments, params) {
 	return resolveAppPageBranchParams(branchSegments, layoutSegments.length, params, layoutSegments);
@@ -60,7 +60,7 @@ function traceAppPageInterceptLayoutModules(modules, branchSegments, layoutSegme
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, serveStreamingMetadata, isProduction = process.env.NODE_ENV === "production" } = pageRequest;
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production" } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -140,7 +140,7 @@ async function buildPageElements(options) {
 	} : null;
 	const parallelRoutes = [...primaryParallelRouteHeadInput ? [primaryParallelRouteHeadInput.head] : [], ...activeParallelRouteHeadInputs.map((input) => input.head)];
 	const metadataSearchParamsObserver = observeMetadataSearchParamsAccess ? createAppPageSearchParamsObserver() : void 0;
-	const preparedHead = prepareAppPageHead({
+	const headOptions = {
 		applyFileBasedMetadata: options.applyFileBasedMetadata,
 		basePath: options.basePath ?? "",
 		layoutModules: route.layouts,
@@ -153,15 +153,11 @@ async function buildPageElements(options) {
 		routeSegments: route.routeSegments ?? null,
 		searchParams,
 		searchParamsObserver: metadataSearchParamsObserver
-	});
-	const { hasDynamicMetadata, pageSearchParams } = preparedHead;
+	};
+	const hasDynamicMetadata = hasAppPageDynamicMetadata(headOptions);
+	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
 	const streamGeneratedHead = serveStreamingMetadata ?? shouldServeStreamingMetadata(pageRequest.request.headers.get("user-agent") ?? "", options.htmlLimitedBots);
-	const metadataPlacement = hasDynamicMetadata && streamGeneratedHead ? "body" : "head";
-	const shouldDeferMetadata = metadataPlacement === "body";
-	const streamingMetadata = shouldDeferMetadata ? isProduction ? preparedHead.metadata.catch((error) => {
-		throw sanitizeErrorForClient(error, "production");
-	}) : preparedHead.metadata : null;
-	streamingMetadata?.catch(() => null);
+	const metadataPlacement = hasDynamicMetadata && streamGeneratedHead && !placeStreamedMetadataInHead ? "body" : "head";
 	const resolveNotFoundFallbackPlanOptions = () => {
 		const routeBoundaryModule = route.notFound;
 		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
@@ -189,8 +185,6 @@ async function buildPageElements(options) {
 			routeSegments: route.routeSegments ?? null
 		};
 	};
-	let viewportErrorOutlet = null;
-	let metadataErrorOutlet = null;
 	const resolveMetadataErrorTags = async (error) => {
 		if (resolveAppPageSpecialError(error)?.kind !== "http-access-fallback") return null;
 		return resolveHttpAccessFallbackMetadata({
@@ -201,24 +195,19 @@ async function buildPageElements(options) {
 			routePath: route.pattern
 		}).catch(() => null);
 	};
-	const [resolvedMetadata, resolvedViewport] = await Promise.all([shouldDeferMetadata ? Promise.resolve(null) : preparedHead.metadata.catch((error) => {
-		metadataErrorOutlet = Promise.reject(isProduction ? sanitizeErrorForClient(error, "production") : error);
-		metadataErrorOutlet.catch(() => null);
-		return resolveMetadataErrorTags(error);
-	}), preparedHead.viewport.catch(async (error) => {
-		const specialError = resolveAppPageSpecialError(error);
-		viewportErrorOutlet = Promise.reject(isProduction ? sanitizeErrorForClient(error, "production") : error);
-		viewportErrorOutlet.catch(() => null);
-		return specialError?.kind === "http-access-fallback" ? resolveHttpAccessFallbackViewport(resolveNotFoundFallbackPlanOptions()).catch(() => ({})) : {};
-	})]);
-	const streamingMetadataTags = shouldDeferMetadata ? preparedHead.metadata.catch(resolveMetadataErrorTags) : null;
-	const streamingMetadataOutletInputs = [
-		streamingMetadata,
-		metadataErrorOutlet,
-		viewportErrorOutlet
-	].filter((promise) => promise !== null).map((promise) => Promise.resolve(promise));
-	const streamingMetadataOutlet = streamingMetadataOutletInputs.length > 0 ? Promise.all(streamingMetadataOutletInputs).then(() => null) : null;
-	streamingMetadataOutlet?.catch(() => null);
+	const toClientError = (error) => isProduction ? sanitizeErrorForClient(error, "production") : error;
+	const resolveHead = cache(() => {
+		const preparedHead = prepareAppPageHead(headOptions);
+		const outlet = Promise.all([preparedHead.metadata, preparedHead.viewport]).then(() => null, (error) => {
+			throw toClientError(error);
+		});
+		outlet.catch(() => null);
+		return {
+			metadata: preparedHead.metadata.catch(resolveMetadataErrorTags),
+			outlet,
+			viewport: preparedHead.viewport.catch((error) => resolveAppPageSpecialError(error)?.kind === "http-access-fallback" ? resolveHttpAccessFallbackViewport(resolveNotFoundFallbackPlanOptions()).catch(() => ({})) : {})
+		};
+	});
 	const pageProps = { params: makeThenableParams(effectiveParams) };
 	const pageTreePosition = (sourcePageSegments ?? route.routeSegments ?? []).length;
 	const hasPageLoadingBoundary = resolveAppPageLoadingModuleAtOrAbove(route, pageTreePosition) !== null || isSiblingIntercept && resolveAppPageLoadingModuleAtOrAbove({
@@ -299,7 +288,7 @@ async function buildPageElements(options) {
 				const LayoutComponent = traceGetLayoutOrPageModule(resolveInterceptLayoutTraceSegment(opts?.interceptBranchSegments, interceptLayoutSegments), () => layoutModule.default);
 				if (!LayoutComponent) continue;
 				const interceptLayoutParams = resolveInterceptLayoutParams(opts?.interceptBranchSegments ?? interceptLayoutSegments, interceptLayoutSegments, effectiveParams);
-				element = createElement(LayoutComponent, { params: makeThenableParams(interceptLayoutParams) }, element);
+				element = createElement(LayoutComponent, withUseCacheLayoutMarker(LayoutComponent, { params: makeThenableParams(interceptLayoutParams) }), element);
 			}
 		}
 		return element;
@@ -319,14 +308,10 @@ async function buildPageElements(options) {
 			matchedParams: params,
 			pageRenderDependency,
 			metadataPlacement,
-			resolvedMetadata,
+			resolveHead,
 			resolvedMetadataPathname: routePath,
-			resolvedViewport,
 			scriptNonce: options.scriptNonce,
-			streamingMetadata,
-			streamingMetadataOutlet,
 			streamingMetadataOutletSuspended: streamGeneratedHead,
-			streamingMetadataTags,
 			renderIdentity,
 			routePath,
 			semanticPageIdentity,

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

@@ -123,22 +123,25 @@ type ProbeAppPageLayoutsOptions = {
   /** When provided, enables per-layout static/dynamic classification. */
   classification?: LayoutClassificationOptions | null;
 };
-type ProbeAppPageComponentOptions = {
-  awaitAsyncResult: boolean;
-  onError: (error: unknown) => Promise<Response | null>;
-  probePage: () => unknown;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-};
-type ProbeAppPageThrownErrorOptions = {
-  probePage: () => unknown;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-};
 export declare function resolveAppPageSpecialError(error: unknown): AppPageSpecialError | 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.
+ */
+export declare function resolveAppPageShellSpecialError(error: unknown, renderedSpecialErrors: readonly unknown[]): AppPageSpecialError | null;
+/**
+ * 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.
+ */
+export declare function resolveAppPageSpecialErrorStoredHeaders(specialError: AppPageSpecialError, basePath: string | undefined): Record<string, string> | undefined;
 export declare function buildAppPageSpecialErrorResponse(options: BuildAppPageSpecialErrorResponseOptions): Promise<Response>;
 /** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
 export declare function probeAppPageLayouts(options: ProbeAppPageLayoutsOptions): Promise<ProbeAppPageLayoutsResult>;
-export declare function probeAppPageComponent(options: ProbeAppPageComponentOptions): Promise<Response | null>;
-export declare function probeAppPageThrownError(options: ProbeAppPageThrownErrorOptions): Promise<unknown>;
 export declare function readAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
 export declare function bufferAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
 export declare function teeAppPageRscStreamForCapture(stream: ReadableStream<Uint8Array>, shouldCapture: boolean): AppPageRscStreamCapture;

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) {