vinext 1.3.1 → 1.4.1

package/dist/server/app-rsc-response-stage.js

@@ -1,15 +1,16 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
 import { closeAfterResponse, closeAfterResponseWithBody, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
-import { VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { PRERENDER_REVALIDATE_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import "./headers.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders } from "./request-pipeline.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runOutsideWorkStoreScope } from "../shims/internal/work-store-scope.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { applyEffectiveRequestCookieHeader, getDraftModeCookieHeader, headersContextFromRequest, restoreDraftModeTransition } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { traceFindPageComponents } from "./pages-execution-tracing.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, hasRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, hasRscCacheBustingSearchParam, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { traceAppPageRender } from "./app-page-tracing.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
@@ -47,13 +48,6 @@ function requestWithoutRscCacheBustingSearchParam(request) {
 	stripRscCacheBustingSearchParam(url);
 	return cloneRequestWithUrl(request, url.toString());
 }
-function requestWithoutRscSuffix(request) {
-	const url = new URL(request.url);
-	const pathname = stripRscSuffix(url.pathname);
-	if (pathname === url.pathname) return request;
-	url.pathname = pathname;
-	return cloneRequestWithUrl(request, url.toString());
-}
 function pathnameForResolvedUrl(resolvedUrl) {
 	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
 }
@@ -69,7 +63,7 @@ function rematchAppWorkerResponseStageRoute(options, normalized, props) {
 	return match;
 }
 async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, stageOptions) {
-	if (props.protocolVersion !== 11 || props.buildId !== options.buildId) return new Response("Incompatible vinext App response stage", { status: 409 });
+	if (props.protocolVersion !== 13 || props.buildId !== options.buildId) return new Response("Incompatible vinext App response stage", { status: 409 });
 	if (props.kind === "app-full-request") return new Response("Invalid vinext App response stage", { status: 400 });
 	const rawRequestSignal = rawRequest.signal;
 	options.registerCacheAdapters();
@@ -104,6 +98,7 @@ async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, sta
 	const requestContext = createRequestContext({
 		headersContext,
 		executionContext,
+		isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER)),
 		requestSignal: executionContext?.requestSignal ?? rawRequestSignal,
 		unstableCacheRevalidation: "background"
 	});
@@ -171,6 +166,7 @@ async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, sta
 				pathname: props.resolvedUrl,
 				pagesDataRequest: props.isDataRequest ? request : null,
 				request: pageRequest,
+				sharedAcrossHosts: props.sharedAcrossHosts,
 				url: new URL(props.requestUrl)
 			}));
 			if (!pagesResponse) return new Response("Invalid vinext App response stage", { status: 404 });
@@ -189,9 +185,8 @@ async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, sta
 		setRootParams(rootParams);
 		if (props.kind === "app-route-handler") {
 			setCurrentFetchSoftTags(buildPageCacheTags(props.cleanPathname, [], [...route.routeSegments], "route"));
-			const normalizedUserlandRequest = requestWithoutRscSuffix(request);
-			const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
-			const routeHandlerRequest = isEdgeRouteHandler(route.routeHandler) ? userlandRequest : normalizedUserlandRequest;
+			const userlandRequest = requestWithoutRscCacheBustingSearchParam(request);
+			const routeHandlerRequest = isEdgeRouteHandler(route.routeHandler) ? userlandRequest : request;
 			const routeHandlerUrl = new URL(routeHandlerRequest.url);
 			const internalRscValues = isEdgeRouteHandler(route.routeHandler) ? [] : routeHandlerUrl.searchParams.getAll(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 			routeHandlerUrl.search = searchParams.toString();
@@ -216,14 +211,13 @@ async function renderAppWorkerResponseStage(options, rawRequest, ctx, props, sta
 		return options.dispatchMatchedPage({
 			bypassInterceptionContextCache: props.bypassInterceptionContextCache,
 			cachePathname: props.cachePathname,
-			clientReuseManifest: normalized.clientReuseManifest,
 			cleanPathname: props.cleanPathname,
 			displayPathname: props.canonicalPathname,
 			formState: null,
 			handlerStart: process.env.NODE_ENV !== "production" ? performance.now() : 0,
 			interceptionContext: normalized.interceptionContextHeader,
 			interceptionId: normalized.interceptionIdHeader,
-			interceptionPathname: props.matchKind === "resolved" ? props.cleanPathname : normalized.requestCleanPathname,
+			interceptionPathname: props.matchKind === "resolved" ? props.cleanPathname : normalized.requestPathname,
 			isProgressiveActionRender: false,
 			isRscRequest: normalized.isRscRequest,
 			middlewareContext,

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

@@ -1,10 +1,10 @@
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
-import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
 import { FetchCacheMode } from "../shims/fetch-cache-state.js";
 import "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/internal/headers-state.js";
 import "../shims/headers.js";
+import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-server-action-execution.d.ts
 type AppPageParams = Record<string, string | string[]>;
@@ -156,6 +156,8 @@ export type HandleProgressiveServerActionRequestOptions = {
    * routes fall through. See issue #1340.
    */
   hasPageRoute: boolean;
+  /** The App Router route the form posted to, whose implicit tags the action runs with. */
+  currentRoute?: AppServerActionRoute | null;
   maxActionBodySize: number;
   middlewareHeaders: Headers | null;
   readFormDataWithLimit: ReadFormDataWithLimit;

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

@@ -6,24 +6,25 @@ import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { NEXT_ROUTER_STATE_TREE_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
+import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER, ACTION_REDIRECT_TYPE_HEADER, ACTION_REVALIDATED_HEADER, VINEXT_MOUNTED_LAYOUTS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER } from "./headers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { attachRequestCfMetadata, validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
 import { splitPathSegments } from "../routing/utils.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
+import { logRequestError } from "./request-error-log.js";
 import { shareIsolatePromise } from "./isolate-shared-promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
 import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { _drainPendingRevalidations, getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRequestUrl, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRequestUrl, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
+import { getSetCookieName } from "./cookie-utils.js";
+import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { hasDigest } from "./app-rsc-errors.js";
-import { getSetCookieName } from "./cookie-utils.js";
-import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import "./app-page-stream.js";
 import { buildAppPageTags } from "./implicit-tags.js";
@@ -211,6 +212,7 @@ async function createActionRedirectTargetRequest(options) {
 	headers.set("cookie", cookieHeader ?? "");
 	headers.set("RSC", "1");
 	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(VINEXT_MOUNTED_LAYOUTS_HEADER);
 	stripRscCacheBustingSearchParam(options.url);
 	const requestPath = await createRscRequestUrl(`${options.url.pathname}${options.url.search}`, headers);
 	const requestUrl = new URL(requestPath, options.url.origin);
@@ -508,7 +510,10 @@ function createRejectedActionResult(error) {
 * Next.js, a thrown string is not logged in development.
 */
 function logRejectedActionResult(error) {
-	if (process.env.NODE_ENV === "production" || hasDigest(error)) console.error("[vinext] Server action error:", error);
+	if (process.env.NODE_ENV === "production" || hasDigest(error)) {
+		if (typeof error === "string") console.error("[vinext] Server action error:", error);
+		else logRequestError("[vinext] Server action error:", error);
+	}
 }
 function getActionHttpFallbackStatus(error) {
 	const digest = getNextErrorDigest(error);
@@ -519,7 +524,7 @@ function getActionHttpFallbackStatus(error) {
 }
 function createServerActionErrorResponse(error, options) {
 	options.getAndClearPendingCookies();
-	console.error("[vinext] Server action error:", error);
+	logRequestError("[vinext] Server action error:", error);
 	options.reportRequestError(error, {
 		path: options.cleanPathname,
 		method: options.request.method,
@@ -614,6 +619,7 @@ async function handleProgressiveServerActionRequest(options) {
 		let actionThrew = false;
 		let actionResult;
 		const rootParamsUsage = createRootParamsUsageController();
+		if (options.currentRoute) setCurrentFetchSoftTags(buildServerActionPageTags(options.currentRoute, options.cleanPathname));
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			actionResult = await runWithRootParamsUsage({ kind: "server-action" }, action, rootParamsUsage);
@@ -625,7 +631,7 @@ async function handleProgressiveServerActionRequest(options) {
 				actionFailed = true;
 				actionFailedWithError = getActionHttpFallbackStatus(error) === null && !isServerActionNotFoundError(error, null);
 				if (actionFailedWithError) {
-					console.error("[vinext] Server action error:", error);
+					logRequestError("[vinext] Server action error:", error);
 					options.reportRequestError(error, {
 						path: options.cleanPathname,
 						method: options.request.method,
@@ -697,7 +703,7 @@ async function handleProgressiveServerActionRequest(options) {
 		});
 		getAndClearActionRevalidationKind();
 		options.getAndClearPendingCookies();
-		console.error("[vinext] Server action payload parsing error:", error);
+		logRequestError("[vinext] Server action payload parsing error:", error);
 		options.reportRequestError(error, {
 			path: options.cleanPathname,
 			method: options.request.method,
@@ -823,6 +829,7 @@ async function handleServerActionRscRequest(options) {
 		let actionThrew = false;
 		const actionWasForwarded = Boolean(options.request.headers.get(ACTION_FORWARDED_HEADER));
 		const rootParamsUsage = createRootParamsUsageController();
+		if (options.currentRouteMatch) setCurrentFetchSoftTags(buildServerActionPageTags(options.currentRouteMatch.route, options.cleanPathname));
 		const previousHeadersPhase = options.setHeadersAccessPhase("action");
 		try {
 			try {

package/dist/server/app-ssr-entry.d.ts

@@ -25,6 +25,8 @@ export declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navCont
     value: Promise<ArrayBuffer> | null;
   };
   pprFallbackShellSignal?: AbortSignal;
+  /** Aborts a streaming render whose document is given up. */
+  signal?: AbortSignal;
   /**
    * Pattern of the route this render shows, whose client references load
    * before it starts, or null for a render without a route (a route-miss
@@ -70,6 +72,12 @@ export declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navCont
    */
   isCacheCandidate?: boolean;
   fallbackToErrorDocumentOnShellError?: boolean;
+  /**
+   * Whether the RSC render threw the given shell error. As in Next.js, in
+   * dev the error document carries only an error that the HTML render alone
+   * threw, for the overlay: the browser reports the others itself.
+   */
+  isServerComponentError?: (error: unknown) => boolean;
   /**
    * The parallel slot not-found boundaries that catch the error that
    * rejected the shell, or null when none catches it. The document then

package/dist/server/app-ssr-entry.js

@@ -2,6 +2,7 @@ import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped, repeatedSlashRedirectResponse } from "./open-redirect.js";
 import "./server-globals.js";
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { onRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
@@ -10,23 +11,24 @@ import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
 import { getClientTraceMetadataHTML, markClientTraceMetadataBlock } from "./client-trace-metadata.js";
 import { setPagesClientAssets } from "./pages-client-assets.js";
+import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
+import { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscCompatibilityScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, rewriteInlineCssStylesheetLinks, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
+import { isBailoutToCSRError, isDynamicServerError } from "../shims/navigation-errors.js";
 import { ServerInsertedHTMLContext, clearServerInsertedHTML, getBfcacheIdMapContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation-server.js";
-import DefaultGlobalError from "../shims/default-global-error.js";
-import { CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL, withCaughtNotFoundBoundaries } from "../shims/caught-not-found-boundaries.js";
 import { BfcacheIdentityMapContext } from "../shims/slot.js";
-import { getNextErrorDigest } from "./next-error-digest.js";
-import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
-import { createRenderStreamCancellation, isAppRenderAbortError } from "./app-render-abort-error.js";
-import { RSC_FORM_STATE_GLOBAL } from "../client/browser-globals.js";
-import { createNavigationRuntimeRenderedSearchScript, createNavigationRuntimeRscCompatibilityScript, createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform, rewriteInlineCssStylesheetLinks, waitAtLeastOneReactRenderTask } from "./app-ssr-stream.js";
-import { createInitialBfcacheMaps } from "./app-bfcache-identity.js";
 import { createAppRouteTree } from "./app-route-tree.js";
+import DefaultGlobalError from "../shims/default-global-error.js";
+import { CAUGHT_NOT_FOUND_BOUNDARIES_GLOBAL, withCaughtNotFoundBoundaries } from "../shims/caught-not-found-boundaries.js";
 import { ssrServerConsumerManifest } from "./app-client-reference-manifest.js";
 import { createClientReferencePreloader, resolveRouteClientReferences } from "./app-client-reference-preloader.js";
+import { getNextErrorDigest } from "./next-error-digest.js";
+import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createClientPageSsrSearchParamsSource } from "./app-page-search-params-observation.js";
+import { createRenderStreamCancellation, isAppRenderAbortError } from "./app-render-abort-error.js";
 import { runWithRootParamsScope } from "../shims/root-params.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { startCandidateSearchParamsGate } from "./app-ssr-search-params-gate.js";
@@ -71,13 +73,14 @@ function createUtf8Stream(html) {
 		controller.close();
 	} });
 }
-function buildBootstrapModuleScript(bootstrapModuleUrl, nonce) {
+function buildBootstrapModuleScript(bootstrapModuleUrl, nonce, crossOrigin) {
 	if (!bootstrapModuleUrl) return "";
-	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + "\" id=\"_R_\" async=\"\" fetchPriority=\"low\"><\/script>";
+	const crossOriginAttribute = crossOrigin === void 0 ? "" : ` crossorigin="${crossOrigin === "use-credentials" ? "use-credentials" : ""}"`;
+	return `<script type="module"${createNonceAttribute(nonce)} src="` + escapeHtmlAttr(bootstrapModuleUrl) + `"${crossOriginAttribute} id="_R_" async="" fetchPriority="low"><\/script>`;
 }
-function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce) {
-	const html = renderToStaticMarkup(createElement(DefaultGlobalError, { error: null })).replace("<style>", "<style data-vinext-error-shell-style=\"\">");
-	const bootstrapScript = buildBootstrapModuleScript(bootstrapModuleUrl, nonce);
+function renderSsrErrorDocumentShell(bootstrapModuleUrl, nonce, crossOrigin) {
+	const html = renderToStaticMarkup(createElement(DefaultGlobalError, { error: null })).replace("<head>", "<head><meta name=\"robots\" content=\"noindex\"/>").replace("<style>", "<style data-vinext-error-shell-style=\"\">");
+	const bootstrapScript = buildBootstrapModuleScript(bootstrapModuleUrl, nonce, crossOrigin);
 	if (!bootstrapScript) return createUtf8Stream(`<!DOCTYPE html>${html}`);
 	const documentClose = "</body></html>";
 	if (!html.endsWith(documentClose)) return createUtf8Stream(`<!DOCTYPE html>${html}${bootstrapScript}`);
@@ -277,6 +280,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 						if (link) reactLinkHeader = link;
 					} : void 0,
 					maxHeadersLength: captureHeaders ? maxHeadersLength : void 0,
+					signal: options?.signal,
 					onError(error) {
 						if (pprFallbackShellSignal && isPprFallbackShellAbortError(error)) return;
 						if (isAppRenderAbortError(error) || htmlCancellation.isReason(error)) return;
@@ -291,6 +295,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				let htmlStream;
 				let renderComplete = Promise.resolve();
 				let shellErrorRecovered = false;
+				let ssrOnlyShellError;
 				let caughtShellError;
 				let caughtBoundaries = null;
 				let shouldDelayInitialHtmlPull = false;
@@ -354,10 +359,11 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 							shouldDelayInitialHtmlPull = options?.waitForAllReady !== true;
 							caughtShellError = error;
 							htmlStream = caughtHtmlStream;
-						} else if (options?.fallbackToErrorDocumentOnShellError !== true || options?.waitForAllReady === true || typeof error?.digest === "string") throw error;
+						} else if (options?.fallbackToErrorDocumentOnShellError !== true || isNavigationSignalError(error) || isBailoutToCSRError(error) || isDynamicServerError(error)) throw error;
 						else {
 							shellErrorRecovered = true;
-							htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce);
+							if (options?.isServerComponentError?.(error) !== true) ssrOnlyShellError = error;
+							htmlStream = renderSsrErrorDocumentShell(bootstrapModuleUrl, options?.scriptNonce, assetCrossOrigin);
 						}
 					}
 				}
@@ -384,7 +390,7 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 				const getInsertedHTML = () => {
 					const insertedHTML = renderInsertedHtml(renderServerInsertedHTML());
 					const errorMetaHTML = errorMetaRenderer.flush();
-					const initialDevServerErrorHTML = createInitialDevServerErrorScript(options?.initialDevServerError, options?.scriptNonce);
+					const initialDevServerErrorHTML = createInitialDevServerErrorScript(options?.initialDevServerError ?? ssrOnlyShellError, options?.scriptNonce);
 					if (didInjectHeadHTML) return insertedHTML + errorMetaHTML + getRenderedSearchHTML();
 					didInjectHeadHTML = true;
 					const hidesQuery = searchParamsGate !== null && searchParamsGate.gate.decision !== "real";

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

@@ -1,7 +1,7 @@
 import { createNonceAttribute, escapeHtmlAttr, htmlTokenListContains, safeJsonStringify, scriptSafeJsonStringify } from "./html.js";
-import { getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { bytesToBase64, concatUint8Arrays } from "./app-rsc-embedded-chunks.js";
 import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "../client/browser-globals.js";
+import { getVinextRscCompatibilityId } from "./app-rsc-cache-busting.js";
 import { Buffer, isUtf8 } from "node:buffer";
 //#region src/server/app-ssr-stream.ts
 const RSC_EMBED_TEXT_BATCH_MAX_BYTES = 65536;

package/dist/server/app-visited-response-cache.d.ts

@@ -7,7 +7,17 @@ export type VisitedResponseCacheEntry = {
   createdAt: number;
   elements?: AppElements;
   expiresAt: number;
+  /**
+   * Stored by initial hydration, which Next.js keeps out of its route cache
+   * (outside Cache Components), so a visible Link still prefetches the URL.
+   */
+  fromHydration?: true;
   mountedSlotsHeader: string | null;
+  /**
+   * A history restore revoked navigation reuse. The entry stays only as the
+   * BFCache that a full prefetch reads (see `findVisitedResponseForFullPrefetch`).
+   */
+  navigationReuseRevoked?: true;
   params: Record<string, string | string[]>;
   response: CachedRscResponse;
   reuseAfterHistoryRestore: boolean;
@@ -18,6 +28,7 @@ export declare function hasNavigationResponseHistoryLifetime(snapshot: CachedRsc
 export declare function createVisitedResponseCacheEntry(options: {
   elements?: AppElements;
   fallbackTtlMs?: number;
+  fromHydration?: boolean;
   now: number;
   mountedSlotsHeader?: string | null;
   params: Record<string, string | string[]>;
@@ -34,6 +45,30 @@ export declare function findVisitedResponseCacheEntry(cache: Map<string, Visited
 } | null;
 export declare function deleteVisitedResponseCacheEntry(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): boolean;
 export declare function deleteAllVisitedResponseCacheEntries(cache: Map<string, VisitedResponseCacheEntry>, rscUrl: string, interceptionContext: string | null): number;
-export declare function deleteInvalidatedHistoryRestoreEntries(cache: Map<string, VisitedResponseCacheEntry>): void;
+export declare function revokeHistoryRestoreNavigationReuse(cache: Map<string, VisitedResponseCacheEntry>): void;
+/**
+ * Next.js fulfills a full prefetch from the BFCache, which holds the data of
+ * every navigation, while it is within the static stale time of that
+ * navigation (`attemptToFulfillDynamicSegmentFromBFCache`). Navigation reuse
+ * that a history restore revoked does not matter here.
+ *
+ * Next.js dates a BFCache entry from its navigation, even one that committed an
+ * older prefetched payload. Its re-prefetch of an expired route still waits for
+ * a fresh route tree first, so a navigation made then fetches fresh data
+ * (`client-cache.experimental.test.ts`, "re-use the cache for 5 minutes").
+ * vinext seeds the full prefetch synchronously, so dating it from the
+ * navigation would replay that expired payload. It dates from when the payload
+ * arrived instead, which only costs a request Next.js might have saved.
+ *
+ * The match follows direct visited reuse: an entry with committed elements
+ * replays them, because its raw response may be skip-pruned against the tree
+ * it was requested from; otherwise the request-time or response-declared slot
+ * context must match.
+ */
+export declare function findVisitedResponseForFullPrefetch(cache: Map<string, VisitedResponseCacheEntry>, rscUrls: readonly string[], interceptionContext: string | null, mountedSlotsHeader: string | null): {
+  navigatedAt: number;
+  navigationFreshUntil: number | null;
+  response: CachedRscResponse;
+} | null;
 //#endregion
 export {};

package/dist/server/app-visited-response-cache.js

@@ -1,6 +1,6 @@
+import { parseRscRequestPath, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
-import { parseRscRequestPath, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { resolveCachedRscResponseExpiresAt } from "../shims/navigation.js";
 //#region src/server/app-visited-response-cache.ts
 const VISITED_RESPONSE_CACHE_TTL = 3e5;
@@ -14,6 +14,7 @@ function createVisitedResponseCacheEntry(options) {
 		createdAt: options.now,
 		...options.elements ? { elements: options.elements } : {},
 		expiresAt: resolveCachedRscResponseExpiresAt(options.now, options.response, options.fallbackTtlMs ?? 3e5),
+		...options.fromHydration === true ? { fromHydration: true } : {},
 		mountedSlotsHeader: options.mountedSlotsHeader ?? null,
 		params: options.params,
 		response: options.response,
@@ -75,11 +76,51 @@ function deleteAllVisitedResponseCacheEntries(cache, rscUrl, interceptionContext
 	while (deleteVisitedResponseCacheEntry(cache, rscUrl, interceptionContext)) deleted++;
 	return deleted;
 }
-function deleteInvalidatedHistoryRestoreEntries(cache) {
-	for (const [cacheKey, entry] of cache) {
+function revokeHistoryRestoreNavigationReuse(cache) {
+	for (const entry of cache.values()) {
 		if (entry.reuseAfterHistoryRestore) continue;
-		cache.delete(cacheKey);
+		entry.navigationReuseRevoked = true;
+	}
+}
+/**
+* Next.js fulfills a full prefetch from the BFCache, which holds the data of
+* every navigation, while it is within the static stale time of that
+* navigation (`attemptToFulfillDynamicSegmentFromBFCache`). Navigation reuse
+* that a history restore revoked does not matter here.
+*
+* Next.js dates a BFCache entry from its navigation, even one that committed an
+* older prefetched payload. Its re-prefetch of an expired route still waits for
+* a fresh route tree first, so a navigation made then fetches fresh data
+* (`client-cache.experimental.test.ts`, "re-use the cache for 5 minutes").
+* vinext seeds the full prefetch synchronously, so dating it from the
+* navigation would replay that expired payload. It dates from when the payload
+* arrived instead, which only costs a request Next.js might have saved.
+*
+* The match follows direct visited reuse: an entry with committed elements
+* replays them, because its raw response may be skip-pruned against the tree
+* it was requested from; otherwise the request-time or response-declared slot
+* context must match.
+*/
+function findVisitedResponseForFullPrefetch(cache, rscUrls, interceptionContext, mountedSlotsHeader) {
+	for (const rscUrl of rscUrls) {
+		const match = findVisitedResponseCacheEntry(cache, rscUrl, interceptionContext);
+		if (match === null) continue;
+		const { entry } = match;
+		if (entry.elements === void 0 && entry.mountedSlotsHeader !== mountedSlotsHeader && (entry.response.mountedSlotsHeader ?? null) !== mountedSlotsHeader) continue;
+		const navigationFresh = entry.fromHydration !== true && entry.navigationReuseRevoked !== true && (entry.elements !== void 0 || entry.mountedSlotsHeader === mountedSlotsHeader) && isVisitedResponseCacheEntryFresh(entry, {
+			navigationKind: "navigate",
+			now: Date.now()
+		});
+		return {
+			navigatedAt: entry.response.receivedAt ?? entry.createdAt,
+			navigationFreshUntil: navigationFresh ? entry.expiresAt : null,
+			response: entry.elements === void 0 ? entry.response : {
+				...entry.response,
+				preparedElements: entry.elements
+			}
+		};
 	}
+	return null;
 }
 //#endregion
-export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, deleteAllVisitedResponseCacheEntries, deleteInvalidatedHistoryRestoreEntries, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, hasNavigationResponseHistoryLifetime, isVisitedResponseCacheEntryFresh };
+export { MAX_TRAVERSAL_CACHE_TTL, VISITED_RESPONSE_CACHE_TTL, createVisitedResponseCacheEntry, deleteAllVisitedResponseCacheEntries, deleteVisitedResponseCacheEntry, findVisitedResponseCacheEntry, findVisitedResponseForFullPrefetch, hasNavigationResponseHistoryLifetime, isVisitedResponseCacheEntryFresh, revokeHistoryRestoreNavigationReuse };

package/dist/server/app-worker-stages.d.ts

@@ -3,7 +3,7 @@ import { VinextResponseStageCacheability, VinextResponseStageDispatchOptions, Vi
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { TrustedPrerenderState } from "./prerender-route-params.js";
 //#region src/server/app-worker-stages.d.ts
-export declare const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 11;
+export declare const APP_WORKER_RESPONSE_STAGE_PROTOCOL_VERSION = 13;
 export declare const APP_METADATA_RESPONSE_STAGE_NO_MATCH_HEADER = "x-vinext-app-metadata-stage-no-match";
 type AppPageParams = Record<string, string | string[]>;
 type AppWorkerResponseStageEnvelope = {
@@ -66,7 +66,7 @@ type AppMetadataWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   resolvedUrl: string;
   routePathname: string;
 };
-type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
+export type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   kind: "hybrid-pages";
   allowRscDocumentFallback: boolean;
   appRouteMatch: {
@@ -83,19 +83,50 @@ type HybridPagesWorkerResponseStageProps = AppWorkerResponseStageEnvelope & {
   resourceKind: "api" | "page";
   requestUrl: string;
   resolvedUrl: string;
+  /**
+   * The shared cache entry answers every host, as Next.js keys a static page
+   * by its path, so a getInitialProps render of a page without
+   * getStaticProps, which reads the request, is not stored.
+   */
+  sharedAcrossHosts: boolean;
 };
 export type AppWorkerResponseStageProps = AppFullRequestWorkerResponseStageProps | AppMatchedWorkerResponseStageProps | AppMetadataWorkerResponseStageProps | AppNotFoundWorkerResponseStageProps | HybridPagesWorkerResponseStageProps;
 export type DispatchAppWorkerResponseStage = VinextResponseStageTransport<AppWorkerResponseStageProps>;
 export type RenderAppWorkerResponseStageLocally = (request: Request, props: AppWorkerResponseStageProps) => Promise<Response>;
 /** Normalize a shared App page HEAD request onto its method-invariant GET representation. */
 export declare function prepareSharedAppPageDispatch(request: Request, cache: VinextResponseStageDispatchOptions["cache"]): Request;
+type SharedAppCacheIdentity = NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+/** App Router dispatches whose shared cache entry every host can reuse. */
+export type SharedAppCacheIdentityProps = Exclude<AppWorkerResponseStageProps, {
+  kind: "app-full-request" | "hybrid-pages";
+}>;
+/**
+ * Build the cache identity of a shared App Router dispatch: the dispatched
+ * request and props under the cache identity origin.
+ */
+export declare function createSharedAppCacheIdentity(request: Request, props: SharedAppCacheIdentityProps): SharedAppCacheIdentity;
 /**
  * Build the query-free cache identity of a shared App page dispatch. The user
- * query leaves both the URL and `resolvedUrl`; the `.rsc` suffix, an RSC
- * request's validated `_rsc`, and the render mode stay because they select the
- * representation. HTML identities also drop the RSC selector headers.
+ * query leaves both the URL and `resolvedUrl`; an RSC request's validated
+ * `_rsc` and the render mode stay because they select the representation. HTML identities also drop the RSC selector headers.
+ */
+export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): SharedAppCacheIdentity;
+/**
+ * Build the query-free cache identity of a shared Route Handler or metadata
+ * route dispatch. Next.js keys a route handler by its pathname: the query and
+ * the RSC selectors pick no representation of a handler's response, and a
+ * handler that reads the request's URL or headers is dynamic, so admission
+ * refuses its response. Keeping them in the identity would only let a client
+ * store one entry per query or selector value. The method, path and route
+ * props stay; the selector headers and the props derived from them leave.
+ */
+export declare function createSharedAppRouteCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps | AppMetadataWorkerResponseStageProps): SharedAppCacheIdentity;
+/**
+ * Build the cache identity of a shared hybrid Pages page dispatch: the
+ * dispatched request and props under `origin`, so every host that names it
+ * shares one entry.
  */
-export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+export declare function createSharedHybridPagesCacheIdentity(request: Request, props: HybridPagesWorkerResponseStageProps, origin: string): SharedAppCacheIdentity;
 /**
  * Drop the user query from an App page dispatch URL and its `resolvedUrl`,
  * keeping an RSC request's validated `_rsc`, the rule the query-free cache