vinext 1.3.0 → 1.4.0

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

@@ -1,7 +1,9 @@
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
 import { RootParams } from "../shims/root-params.js";
-import { AppPageSsrHandler } from "./app-page-stream.js";
+import { InitialNavigationCacheMetadata } from "./app-ssr-stream.js";
+import { AppPageFontData, AppPageSsrHandler } from "./app-page-stream.js";
+import { CdnAppPageDocument } from "../shims/cdn-cache.js";
 //#region src/server/app-page-rsc-render-status.d.ts
 /**
  * The status of a finished RSC render, as Next.js's static generation decides
@@ -10,6 +12,8 @@ import { AppPageSsrHandler } from "./app-page-stream.js";
  */
 export type AppPageRscRenderStatus = {
   kind: "page";
+  /** The page's document, when the resolver rendered one to store. */
+  document?: CdnAppPageDocument;
 } | {
   kind: "special-error";
   status: number;
@@ -22,9 +26,28 @@ export type AppPageRscRenderStatus = {
 {
   kind: "unstorable";
 };
+/** What the page's document renders with, as an HTML request renders it. */
+type AppPageRscRenderDocumentOptions = {
+  clientTraceMetadata?: readonly string[];
+  /**
+   * When the document's render is given up, as completed-response admission
+   * gives up a body it hasn't captured by its deadline.
+   */
+  deadlineAt?: number;
+  getFontData: () => AppPageFontData;
+  getInitialNavigationCacheMetadata: () => InitialNavigationCacheMetadata;
+  mirrorNextFlight: () => boolean;
+  onSsrError: (error: unknown) => unknown;
+  reactMaxHeadersLength?: number;
+};
 type CreateAppPageRscRenderStatusResolverOptions = {
   basePath?: string;
   capturedRscData: Promise<ArrayBuffer>;
+  /**
+   * Render the page's document from the payload, to be stored beside it.
+   * Without it, only a render that threw a special error renders its shell.
+   */
+  document?: AppPageRscRenderDocumentOptions;
   getCapturedSpecialError: () => unknown;
   getCapturedSpecialErrors: (error: unknown) => readonly unknown[];
   isForceStatic: boolean;
@@ -39,6 +62,9 @@ type CreateAppPageRscRenderStatusResolverOptions = {
  * a render that threw one renders the document's shell from the same payload,
  * as Next.js's static generation renders HTML beside RSC. Its server
  * components don't run again. A render without a special error is a 200.
+ *
+ * With `document`, every render renders its document from the payload, as
+ * Next.js keeps a page's document and RSC payload in one entry.
  */
 export declare function createAppPageRscRenderStatusResolver(options: CreateAppPageRscRenderStatusResolverOptions): () => Promise<AppPageRscRenderStatus>;
 /**
@@ -46,4 +72,5 @@ export declare function createAppPageRscRenderStatusResolver(options: CreateAppP
  * payload carries a redirect, so a redirect is a 200 with its `location`.
  */
 export declare function resolveAppPageRscResponseStatus(status: number): number;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-page-rsc-render-status.js

@@ -1,5 +1,8 @@
-import { resolveAppPageShellSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
-import { isAppSsrRenderResult } from "./app-page-stream.js";
+import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
+import "../shims/headers.js";
+import { readStreamAsText } from "../utils/text-stream.js";
+import { buildAppPageFontLinkHeader, resolveAppPageShellSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
+import { buildAppPageLinkHeader, isAppSsrRenderResult } from "./app-page-stream.js";
 //#region src/server/app-page-rsc-render-status.ts
 const PAGE_STATUS = { kind: "page" };
 /**
@@ -8,28 +11,109 @@ const PAGE_STATUS = { kind: "page" };
 * a render that threw one renders the document's shell from the same payload,
 * as Next.js's static generation renders HTML beside RSC. Its server
 * components don't run again. A render without a special error is a 200.
+*
+* With `document`, every render renders its document from the payload, as
+* Next.js keeps a page's document and RSC payload in one entry.
 */
 function createAppPageRscRenderStatusResolver(options) {
 	let status;
 	return () => status ??= resolveAppPageRscRenderStatus(options);
 }
 async function resolveAppPageRscRenderStatus(options) {
+	const deadlineAt = options.document?.deadlineAt;
+	if (deadlineAt === void 0) return renderAppPageRscRenderStatus(options);
+	const expired = new AbortController();
+	const remaining = deadlineAt - Date.now();
+	const timer = remaining > 0 ? setTimeout(() => expired.abort(), remaining) : void 0;
+	if (timer === void 0) expired.abort();
+	try {
+		return await unlessExpired(renderAppPageRscRenderStatus(options, expired.signal), expired.signal, () => {}) ?? expiredDocumentStatus(options);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Settle with `promise`, or with `null` once `signal` aborts. */
+function unlessExpired(promise, signal, discard) {
+	if (!signal) return promise;
+	if (signal.aborted) {
+		promise.then(discard, () => {});
+		return Promise.resolve(null);
+	}
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			promise.then(discard, () => {});
+			resolve(null);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			if (signal.aborted) discard(value);
+			else resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/** Read the document, or cancel it and settle with `null` once `signal` aborts. */
+async function readDocumentHtml(stream, signal) {
+	if (!signal) return readStreamAsText(stream);
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	const chunks = [];
+	for (;;) {
+		const result = await unlessExpired(reader.read(), signal, () => {});
+		if (result === null) {
+			reader.cancel().catch(() => {});
+			return null;
+		}
+		if (result.done) break;
+		chunks.push(decoder.decode(result.value, { stream: true }));
+	}
+	chunks.push(decoder.decode());
+	return chunks.join("");
+}
+/**
+* A document given up at its deadline isn't stored. A render without a
+* special error is still a 200, but one with a special error needs its shell.
+*/
+function expiredDocumentStatus(options) {
+	return options.getCapturedSpecialError() === null ? PAGE_STATUS : { kind: "unstorable" };
+}
+async function renderAppPageRscRenderStatus(options, signal) {
 	const rscData = await options.capturedRscData;
-	if (options.getCapturedSpecialError() === null) return PAGE_STATUS;
+	const documentOptions = options.document;
+	if (!documentOptions && options.getCapturedSpecialError() === null) return PAGE_STATUS;
 	const ssrHandler = await options.loadSsrHandler();
+	if (signal?.aborted) return expiredDocumentStatus(options);
+	const fontData = documentOptions?.getFontData() ?? {
+		links: [],
+		preloads: [],
+		styles: []
+	};
+	const clientTraceMetadataMarker = documentOptions?.clientTraceMetadata && documentOptions.clientTraceMetadata.length > 0 ? crypto.randomUUID() : void 0;
 	let rendered;
 	try {
-		rendered = await ssrHandler.handleSsr(new Response(rscData).body, options.navigationContext, {
-			links: [],
-			preloads: [],
-			styles: []
-		}, {
+		rendered = await unlessExpired(ssrHandler.handleSsr(new Response(rscData).body, options.navigationContext, fontData, {
 			basePath: options.basePath,
 			isForceStatic: options.isForceStatic,
-			isStaticGeneration: true,
-			onSsrError: () => void 0,
 			preloadRoutePattern: options.routePattern,
-			rootParams: options.rootParams
+			rootParams: options.rootParams,
+			...documentOptions ? {
+				clientTraceMetadata: documentOptions.clientTraceMetadata,
+				clientTraceMetadataMarker,
+				getInitialNavigationCacheMetadata: documentOptions.getInitialNavigationCacheMetadata,
+				isCacheCandidate: true,
+				mirrorNextFlight: documentOptions.mirrorNextFlight,
+				onSsrError: documentOptions.onSsrError,
+				reactMaxHeadersLength: documentOptions.reactMaxHeadersLength,
+				signal
+			} : {
+				isStaticGeneration: true,
+				onSsrError: () => void 0
+			}
+		}), signal, (late) => {
+			(isAppSsrRenderResult(late) ? late.htmlStream : late).cancel().catch(() => {});
 		});
 	} catch (error) {
 		const specialError = resolveAppPageShellSpecialError(error, options.getCapturedSpecialErrors(error));
@@ -41,8 +125,32 @@ async function resolveAppPageRscRenderStatus(options) {
 			...headers ? { headers } : {}
 		};
 	}
-	(isAppSsrRenderResult(rendered) ? rendered.htmlStream : rendered).cancel().catch(() => {});
-	return PAGE_STATUS;
+	if (rendered === null) return expiredDocumentStatus(options);
+	const htmlStream = isAppSsrRenderResult(rendered) ? rendered.htmlStream : rendered;
+	if (!documentOptions) {
+		htmlStream.cancel().catch(() => {});
+		return PAGE_STATUS;
+	}
+	let html;
+	try {
+		html = await readDocumentHtml(htmlStream, signal);
+	} catch {
+		return PAGE_STATUS;
+	}
+	if (html === null) return expiredDocumentStatus(options);
+	if (isRenderDynamicLatched()) return PAGE_STATUS;
+	const linkHeader = buildAppPageLinkHeader(isAppSsrRenderResult(rendered) ? rendered.linkHeader : void 0, buildAppPageFontLinkHeader(fontData.preloads), documentOptions.reactMaxHeadersLength);
+	if (clientTraceMetadataMarker) {
+		const { stripClientTraceMetadataBlock } = await import("./client-trace-metadata.js");
+		html = stripClientTraceMetadataBlock(html, clientTraceMetadataMarker);
+	}
+	return {
+		kind: "page",
+		document: {
+			html,
+			...linkHeader ? { linkHeader } : {}
+		}
+	};
 }
 /**
 * The status Next.js sends an RSC request for a render with this status. Its

package/dist/server/app-page-search-params-observation.d.ts

@@ -5,7 +5,11 @@ type ClientPageSsrSearchParamsOptions = {
   isForceStatic?: boolean;
   isPprFallbackShell?: boolean;
 };
-export declare function createAppPageSearchParamsObserver(): ThenableParamsObserver;
+/**
+ * The observer a route's head hands generateMetadata() and generateViewport()
+ * for `searchParams`, or none when a read doesn't count (`force-static`).
+ */
+export declare function createAppPageMetadataSearchParamsObserver(observe: boolean): ThenableParamsObserver | undefined;
 export declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams): ThenableParams<AppPageSearchParams>;
 /**
  * The `searchParams` a client page receives during SSR (see
@@ -26,4 +30,5 @@ export declare function makeClientPageSsrSearchParamsThenable(searchParams: URLS
  * The cache lives in this render's navigation context and is dropped with it.
  */
 export declare function createClientPageSsrSearchParamsSource(searchParams: URLSearchParams, options: ClientPageSsrSearchParamsOptions): (pageProps: object) => ThenableParams<AppPageSearchParams>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-page-search-params-observation.js

@@ -16,6 +16,13 @@ function createAppPageSearchParamsObserver() {
 		observeThenRead: throwIfStaticGenerationAccessError
 	};
 }
+/**
+* The observer a route's head hands generateMetadata() and generateViewport()
+* for `searchParams`, or none when a read doesn't count (`force-static`).
+*/
+function createAppPageMetadataSearchParamsObserver(observe) {
+	return observe ? createAppPageSearchParamsObserver() : void 0;
+}
 function makeObservedAppPageSearchParamsThenable(pageSearchParams) {
 	return makeThenableParams(pageSearchParams, createAppPageSearchParamsObserver());
 }
@@ -55,4 +62,4 @@ function makeClientPageSsrSearchParamsThenableFromRecord(pageSearchParams, optio
 	return options.isForceStatic !== true && options.isPprFallbackShell !== true ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
 }
 //#endregion
-export { createAppPageSearchParamsObserver, createClientPageSsrSearchParamsSource, makeClientPageSsrSearchParamsThenable, makeObservedAppPageSearchParamsThenable };
+export { createAppPageMetadataSearchParamsObserver, createClientPageSsrSearchParamsSource, makeClientPageSsrSearchParamsThenable, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-segment-plan.d.ts

@@ -52,4 +52,5 @@ export declare function createAppPageSegmentPlan<TModule extends AppPageModule,
   slotBindings: readonly AppElementsSlotBinding[];
   templateEntries: readonly AppPageTemplateEntry<TModule>[];
 }): AppPageSegmentPlan<TModule>;
-//#endregion
+//#endregion
+export {};

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

@@ -22,6 +22,12 @@ export type AppSsrRenderResult = {
   renderComplete?: Promise<void>;
   capturedRscData: Promise<ArrayBuffer> | null;
   shellErrorRecovered?: boolean;
+  /**
+   * The special error that rejected the shell, when parallel slot not-found
+   * boundaries caught it in a second render of the same payload. The document
+   * is that error's, with its status.
+   */
+  caughtShellError?: unknown;
   /**
    * Preload `Link` header value emitted by React during SSR (via `onHeaders`),
    * already capped to `reactMaxHeadersLength`. Empty/undefined when React
@@ -71,6 +77,8 @@ export type AppPageSsrHandler = {
     };
     /** Abort signal for a build-time PPR fallback-shell static render. */
     pprFallbackShellSignal?: AbortSignal;
+    /** Aborts a streaming render whose document is given up. */
+    signal?: AbortSignal;
     /** Route whose client references load before the render; null for none. */
     preloadRoutePattern?: string | null;
     /** When true, wait for the full React tree before emitting bytes. */
@@ -92,6 +100,8 @@ export type AppPageSsrHandler = {
      *  default `__next_error__` error-document shell (with the original
      *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
     fallbackToErrorDocumentOnShellError?: boolean;
+    /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
+    resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
     dynamicStaleTimeSeconds?: number;
     getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
   }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
@@ -145,6 +155,8 @@ type RenderAppPageHtmlStreamOptions = {
   isCacheCandidate?: boolean;
   /** Override the default shell-error recovery decision passed to handleSsr. */
   fallbackToErrorDocumentOnShellError?: boolean;
+  /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
+  resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   /** Dev-only: original server error to surface in the browser overlay. */
   initialDevServerError?: unknown;
   /** Report an SSR/Fizz render failure through instrumentation. */
@@ -178,9 +190,20 @@ type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
   onShellRendered?: () => void;
   renderErrorBoundaryResponse: (error: unknown) => Promise<Response | null>;
   renderHtmlStream: () => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
-  renderSpecialErrorResponse: (specialError: TSpecialError) => Promise<Response>;
+  /**
+   * The document of a special error that rejected the shell. With
+   * `caughtDocument`, parallel slot boundaries caught it in the page's own
+   * document, which that response sends.
+   */
+  renderSpecialErrorResponse: (specialError: TSpecialError, caughtDocument?: AppPageCaughtShellErrorDocument) => Promise<Response>;
   resolveSpecialError: (error: unknown) => TSpecialError | null;
 };
+/** The page's document, rendered with the slot boundaries that caught its shell error. */
+type AppPageCaughtShellErrorDocument = {
+  htmlStream: ReadableStream<Uint8Array>;
+  /** React-emitted preload `Link` header (already capped). */
+  linkHeader?: string;
+};
 type AppPageRscErrorTracker = {
   getCapturedError: () => unknown;
   /**
@@ -202,6 +225,15 @@ export declare function createAppPageSsrErrorHandler(baseOnError: (error: unknow
 export declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
 export declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
 export declare function renderAppPageHtmlResponse(options: RenderAppPageHtmlResponseOptions): Promise<Response>;
+export declare function buildAppPageHtmlDocumentResponse(htmlStream: ReadableStream<Uint8Array>, options: {
+  clearRequestContext: () => void;
+  fontLinkHeader?: string;
+  isEdgeRuntime?: boolean;
+  middlewareHeaders?: Headers | null;
+  reactLinkHeader?: string;
+  reactMaxHeadersLength?: number;
+  status: number;
+}): Response;
 export declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError>): Promise<AppPageHtmlStreamRecoveryResult>;
 export declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
 //#endregion

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

@@ -1,9 +1,9 @@
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.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 { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import "./app-rsc-cache-busting.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest } from "./next-error-digest.js";
 import { isAppRenderAbortError } from "./app-render-abort-error.js";
@@ -87,6 +87,7 @@ async function renderAppPageHtmlStream(options) {
 		onSsrError: options.onSsrError,
 		mirrorNextFlight: options.mirrorNextFlight,
 		fallbackToErrorDocumentOnShellError: options.fallbackToErrorDocumentOnShellError ?? (options.waitForAllReady !== true && options.hasCustomGlobalError === false),
+		resolveCaughtNotFoundBoundaries: options.resolveCaughtNotFoundBoundaries,
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		getInitialNavigationCacheMetadata: options.getInitialNavigationCacheMetadata
 	};
@@ -94,6 +95,12 @@ async function renderAppPageHtmlStream(options) {
 }
 async function renderAppPageHtmlResponse(options) {
 	const { htmlStream, linkHeader: reactLinkHeader } = await renderAppPageHtmlStream(options);
+	return buildAppPageHtmlDocumentResponse(htmlStream, {
+		...options,
+		reactLinkHeader
+	});
+}
+function buildAppPageHtmlDocumentResponse(htmlStream, options) {
 	const safeStream = deferUntilStreamConsumed(htmlStream, () => {
 		options.clearRequestContext();
 	});
@@ -103,7 +110,7 @@ async function renderAppPageHtmlResponse(options) {
 	});
 	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
-	const frameworkLinkHeader = buildAppPageLinkHeader(reactLinkHeader, options.fontLinkHeader, options.reactMaxHeadersLength);
+	const frameworkLinkHeader = buildAppPageLinkHeader(options.reactLinkHeader, options.fontLinkHeader, options.reactMaxHeadersLength);
 	if (frameworkLinkHeader) headers.append("Link", frameworkLinkHeader);
 	const response = new Response(safeStream, {
 		status: options.status,
@@ -114,8 +121,20 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, renderComplete, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, renderComplete, capturedRscData, linkHeader, shellErrorRecovered, caughtShellError } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
+		const caughtSpecialError = caughtShellError === void 0 ? null : options.resolveSpecialError(caughtShellError);
+		if (caughtSpecialError) return {
+			htmlStream: null,
+			response: await options.renderSpecialErrorResponse(caughtSpecialError, {
+				htmlStream,
+				linkHeader
+			}),
+			metadataReady: resolvedMetadataReady,
+			renderComplete: renderComplete ?? resolvedMetadataReady,
+			capturedRscData: null,
+			shellErrorRecovered: false
+		};
 		return {
 			htmlStream,
 			response: null,
@@ -185,4 +204,4 @@ function createAppPageRscErrorTracker(baseOnError) {
 	};
 }
 //#endregion
-export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };
+export { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -1,8 +1,10 @@
 import { AppMiddlewareContext } from "./app-middleware.js";
 import { MiddlewareResponseMergeOptions } from "./middleware-response-headers.js";
 import { EdgeApiExecutionRuntime } from "./edge-api-runtime.js";
+import { RuntimePagesDataKind } from "./pages-route-data-kind.js";
 //#region src/server/app-pages-bridge.d.ts
 export type PagesEntry = {
+  getRuntimePageDataKind?: (url: string, request: Request) => RuntimePagesDataKind;
   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;
@@ -55,10 +57,13 @@ type RenderPagesFallbackOptions = {
   pathname?: string;
   pagesDataRequest?: Request | null;
   request: Request;
+  /** The shared cache entry answers every host; a request-time render is not stored. */
+  sharedAcrossHosts?: boolean;
   url: URL;
 };
 /**
  * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
  */
 export declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

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

@@ -1,6 +1,6 @@
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { beginRouteCacheability } from "../shims/cacheability-classification.js";
+import { beginRouteCacheability, markRouteCacheabilityDynamic } 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
@@ -18,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, initialResponseHeaders, 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, sharedAcrossHosts = false, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
@@ -61,7 +61,11 @@ 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;
-	if (pageMatch !== null) beginRouteCacheability("pages-page", pageMatch.route.pattern);
+	if (pageMatch !== null) {
+		beginRouteCacheability("pages-page", pageMatch.route.pattern);
+		const runtimeDataKind = sharedAcrossHosts ? pagesEntry.getRuntimePageDataKind?.(pagesUrl, matchRequest) : void 0;
+		if (runtimeDataKind === "server" || runtimeDataKind === "initial") markRouteCacheabilityDynamic("getInitialProps render shares a cache entry across hosts");
+	}
 	const pagesRequest = claimPagesRequest();
 	const renderArgs = [
 		pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest,

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

@@ -13,4 +13,5 @@ export type WarmPprFallbackShellCachesOptions = {
   state: PprFallbackShellState;
 };
 export declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
-//#endregion
+//#endregion
+export {};

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

@@ -29,4 +29,5 @@ export declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
   pathname: string;
   searchParams: URLSearchParams;
 }): string;
-//#endregion
+//#endregion
+export {};

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

@@ -15,4 +15,5 @@ type HandleAppPrerenderEndpointOptions = {
   staticParamsMap: AppPrerenderStaticParamsMap;
 };
 export declare function handleAppPrerenderEndpoint(request: Request, options: HandleAppPrerenderEndpointOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

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

@@ -34,4 +34,5 @@ type CallAppPrerenderStaticParamsOptions = {
   rootParamNamesByPattern: Record<string, readonly string[] | undefined>;
 };
 export declare function callAppPrerenderStaticParams(options: CallAppPrerenderStaticParamsOptions): Promise<unknown>;
-//#endregion
+//#endregion
+export {};

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

@@ -11,12 +11,29 @@ export type AppPageRenderDependency = AppRenderDependency & {
 /** 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;
+/**
+ * `mapError` replaces an error thrown by a CSS-wrapped export's inner
+ * component, which renders after this call returns. The caller maps the
+ * errors this call throws or rejects with.
+ */
+export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError?: (error: unknown) => unknown): ReactNode | Promise<ReactNode>;
+/**
+ * Reports how a component's own render ended: `failure` holds what it threw
+ * or rejected with, after `mapError`. A suspension isn't an end, as React
+ * renders the component again.
+ */
+export type AppComponentSettledCallback = (failure?: {
+  error: unknown;
+}) => void;
+/**
+ * `invokeAppComponent()`, with every error the component throws or rejects
+ * with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+ * `onSettled` hears once how the component, or that inner one, ended.
+ */
+export declare function invokeAppComponentMappingErrors(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError: (error: unknown) => unknown, onSettled?: AppComponentSettledCallback): ReactNode | Promise<ReactNode>;
 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;
+export declare function renderAppComponentWithDependencyBarrier(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, dependency: AppRenderDependency, mapError?: (error: unknown) => unknown, onSettled?: AppComponentSettledCallback): ReactNode;
 //#endregion