vinext 1.3.1 → 1.4.0

package/dist/server/app-rsc-handler.js

@@ -17,7 +17,6 @@ import { runOutsideWorkStoreScope } from "../shims/internal/work-store-scope.js"
 import { isInterceptionMatchedUrlPath, normalizePath } from "./normalize-path.js";
 import { normalizeDefaultLocalePathname, shouldRestoreLocaleRootTrailingSlash } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
-import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { markRouteCacheabilityDynamic, preserveRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyOverrides, isCdnResponsePolicyHeader, reconcileCdnResponseHeadersAfterOuterPolicy } from "./cache-control.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
@@ -28,29 +27,30 @@ import { traceFindPageComponents } from "./pages-execution-tracing.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, markImageOptimizationSignal, resolveDevImageRedirect } from "./image-optimization.js";
 import { parseCacheabilityManifest } from "./cacheability-manifest.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestUrl, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
-import { mergeMiddlewareResponseHeaders, mergeMiddlewareResponseHeadersOntoResponse, withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
-import { consumeResponseStageLinkProvenance, copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
-import "./app-page-response.js";
-import { parseNextHttpErrorDigest } from "./next-error-digest.js";
-import { traceAppPageRender } from "./app-page-tracing.js";
 import { openForwardedMiddlewareContext } from "./forwarded-middleware-context.js";
+import { consumeResponseStageLinkProvenance, copyLinkHeaderProvenance } from "./app-response-header-provenance.js";
 import { setFrameworkRequestRoute, traceFrameworkRequest } from "./request-tracing.js";
+import { mergeMiddlewareResponseHeaders, mergeMiddlewareResponseHeadersOntoResponse, withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestUrl, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
+import "./app-page-response.js";
+import { parseNextHttpErrorDigest } from "./next-error-digest.js";
 import { isAppRouteHandlerRoute } from "./app-rsc-route-matching.js";
+import { traceAppPageRender } from "./app-page-tracing.js";
 import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
-import { createSharedAppPageCacheIdentity, isStaticCandidateAppPageDispatch, prepareSharedAppPageDispatch, withoutAppPageDispatchQuery } from "./app-worker-stages.js";
+import { createSharedAppCacheIdentity, createSharedAppPageCacheIdentity, createSharedHybridPagesCacheIdentity, isStaticCandidateAppPageDispatch, prepareSharedAppPageDispatch, withoutAppPageDispatchQuery } from "./app-worker-stages.js";
 import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppRscConfigHeaders, finalizeAppRscResponse, markAppRscResponseConfigHeadersApplied } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { hasPagesPreviewCookie } from "./pages-response-stage.js";
 import { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
+import { adapterSharedCacheIdentity, adapterUsesSharedCacheIdentity, pagesCacheIdentityOrigin, pagesPageSharesAcrossHosts } from "./shared-cache-identity.js";
 import { consumePagesResponseStagePolicyOwner, withoutResponseStageVary } from "./response-stage-policy.js";
 //#region src/server/app-rsc-handler.ts
 const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
@@ -132,10 +132,6 @@ function readCacheabilityRequestProjection(options) {
 	};
 	return parsedCacheabilityRequestProjection.manifest;
 }
-function adapterUsesQueryFreeCacheIdentity() {
-	const adapter = getCdnCacheAdapter();
-	return adapter.requiresCompletedResponseAdmission === true && adapter.responseStageCacheIdentity === "query-free";
-}
 function hasUrlParserDotSegment(pathname) {
 	return pathname.split("/").some((segment) => {
 		const decodedDots = segment.replaceAll(/%2e/gi, ".");
@@ -312,7 +308,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (request.headers.has("X-Vinext-Interception-Context") || request.headers.has("X-Vinext-Interception-Id")) setInterceptionResponseUncacheable(true);
 		return normalized;
 	}
-	const { url, isRscRequest, interceptionContextHeader, interceptionIdHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
+	const { url, isRscRequest, interceptionContextHeader, interceptionIdHeader, mountedSlotsHeader, renderMode, hadBasePath } = normalized;
 	setFrameworkRequestRoute(void 0, isRscRequest);
 	const hasRawInterceptionContext = isRscRequest && request.headers.has("X-Vinext-Interception-Context");
 	if (hasRawInterceptionContext) setInterceptionResponseUncacheable(true);
@@ -509,7 +505,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			const rscPath = canonicalRsc.navigation ? createCanonicalRscRequestUrl(dispatchRequest.url) : await createRscRequestUrl(dispatchRequest.url, canonicalRsc.headers);
 			dispatchRequest = cloneRequestWithUrl(dispatchRequest, new URL(rscPath, dispatchRequest.url).toString());
 		}
-		const cacheIdentity = cache === "shared" && responseStagePolicy === null && stageProps.kind === "app-page" && stageProps.matchKind !== "interception" && stageProps.interceptionContext === null && stageProps.interceptionId === null && stageProps.mountedSlotsHeader === null && adapterUsesQueryFreeCacheIdentity() ? createSharedAppPageCacheIdentity(dispatchRequest, stageProps) : void 0;
+		const cacheIdentity = cache !== "shared" || stageProps.kind === "app-full-request" || stageProps.kind === "hybrid-pages" || !adapterUsesSharedCacheIdentity() ? void 0 : stageProps.kind === "app-page" && adapterSharedCacheIdentity() === "query-free" && responseStagePolicy === null && stageProps.matchKind !== "interception" && stageProps.interceptionContext === null && stageProps.interceptionId === null && stageProps.mountedSlotsHeader === null ? createSharedAppPageCacheIdentity(dispatchRequest, stageProps) : createSharedAppCacheIdentity(dispatchRequest, stageProps);
 		let response = await dispatchResponseStage(dispatchRequest, stageProps, cacheIdentity ? {
 			cache,
 			cacheIdentity
@@ -553,7 +549,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				isRscRequest,
 				middlewareCookieOverlay,
 				mountedSlotsHeader,
-				protocolVersion: 11,
+				protocolVersion: 13,
 				requestOrigin: url.origin,
 				renderMode,
 				resolvedUrl,
@@ -921,10 +917,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!filesystemRouteEligible) return null;
 		const pagesRouteUrl = cleanPathnameIsRequestPathname ? requestCleanPathname + resolvedUrl.slice(pathnameForResolvedUrl(resolvedUrl).length) : resolvedUrl;
 		let sharedOuterPolicyNeedsReconciliation = false;
-		const dispatchPagesResponseStage = dispatchResponseStage ? async (stageRequest, resourceKind, dataKind, hasRequestAwareDocument) => {
+		const dispatchPagesResponseStage = dispatchResponseStage ? async (stageRequest, resourceKind, dataKind, hasRequestAwareDocument, runsInitialProps) => {
 			const pagesOnDemandRevalidate = resourceKind === "page" && isOnDemandRevalidateRequest(stageRequest.headers.get("x-prerender-revalidate"));
 			const cache = responseStageProbeMode || pagesOnDemandRevalidate || hasPagesPreviewCookie(stageRequest.headers.get("cookie")) || resourceKind === "page" && dataKind === "static" && hasRequestAwareDocument ? "bypass" : canUseSharedWorkerResponseStage ? "shared" : "bypass";
-			let response = await dispatchResponseStage(responseStageRequest(stageRequest), {
+			const renderRequest = responseStageRequest(stageRequest);
+			const sharedAcrossHosts = (cache === "shared" || responseStageProbeMode !== null) && resourceKind === "page" && pagesPageSharesAcrossHosts({
+				dataKind,
+				runsInitialProps
+			}) && adapterUsesSharedCacheIdentity();
+			const hybridProps = {
 				kind: "hybrid-pages",
 				buildId: options.buildId,
 				cacheability: {
@@ -945,13 +946,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				matchKind,
 				middlewareCookieOverlay,
 				preHandlerHeaders: cache === "shared" && resourceKind === "page" && dataKind === "static" ? null : [...await loadPreHandlerResponseHeaders()],
-				protocolVersion: 11,
+				protocolVersion: 13,
 				requestOrigin: url.origin,
 				resourceKind,
 				requestUrl: request.url,
 				resolvedUrl: pagesRouteUrl,
-				scriptNonce: scriptNonce ?? null
-			}, { cache });
+				scriptNonce: scriptNonce ?? null,
+				sharedAcrossHosts
+			};
+			let response = await dispatchResponseStage(renderRequest, hybridProps, cache === "shared" && sharedAcrossHosts ? {
+				cache,
+				cacheIdentity: createSharedHybridPagesCacheIdentity(renderRequest, hybridProps, pagesCacheIdentityOrigin(request.url, options.i18nConfig))
+			} : { cache });
 			const policyOwner = resourceKind === "page" ? consumePagesResponseStagePolicyOwner(response) : {
 				owner: null,
 				response
@@ -1159,7 +1165,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			isRscRequest,
 			middlewareCookieOverlay,
 			mountedSlotsHeader,
-			protocolVersion: 11,
+			protocolVersion: 13,
 			requestOrigin: url.origin,
 			renderMode,
 			resolvedUrl,
@@ -1246,7 +1252,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			middlewareCookieOverlay,
 			mountedSlotsHeader,
 			params,
-			protocolVersion: 11,
+			protocolVersion: 13,
 			requestOrigin: url.origin,
 			renderMode,
 			resolvedUrl,
@@ -1288,7 +1294,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareCookieOverlay,
 		mountedSlotsHeader,
 		params,
-		protocolVersion: 11,
+		protocolVersion: 13,
 		requestOrigin: url.origin,
 		renderMode,
 		resolvedUrl,
@@ -1298,7 +1304,6 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}).then(composeResponseStageResponse) : await options.dispatchMatchedPage({
 		bypassInterceptionContextCache,
 		cachePathname,
-		clientReuseManifest,
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState: progressiveActionFormState?.formState ?? null,
@@ -1406,6 +1411,7 @@ function createAppRscRequestHandler(options) {
 		const requestContext = createRequestContext({
 			headersContext,
 			executionContext,
+			isOnDemandRevalidate: isOnDemandRevalidateRequest(request.headers.get(PRERENDER_REVALIDATE_HEADER)),
 			requestSignal: executionContext?.requestSignal ?? rawRequestSignal,
 			unstableCacheRevalidation: "background"
 		});

package/dist/server/app-rsc-request-normalization.d.ts

@@ -1,4 +1,3 @@
-import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 //#region src/server/app-rsc-request-normalization.d.ts
@@ -21,8 +20,6 @@ export type NormalizedRscRequest = {
   mountedSlotsHeader: string | null;
   /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
   renderMode: AppRscRenderMode;
-  /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
-  clientReuseManifest: ClientReuseManifestParseResult;
   /** Whether the incoming pathname included the configured basePath. */
   hadBasePath: boolean;
 };
@@ -52,7 +49,6 @@ export type NormalizedRscRequest = {
  *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
  *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
  *   10. Read semantic render mode for refresh/action payload rendering
- *   11. Parse ClientReuseManifest hints on canonical RSC payload requests
  *
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.

package/dist/server/app-rsc-request-normalization.js

@@ -1,6 +1,6 @@
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "./app-rsc-vary.js";
-import { VINEXT_CLIENT_REUSE_MANIFEST_HEADER } from "./headers.js";
+import "./headers.js";
 import { badRequestResponse, notFoundResponse } from "./http-error-responses.js";
 import { guardProtocolRelativeUrl } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
@@ -9,7 +9,6 @@ import { normalizePath } from "./normalize-path.js";
 import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_EMPTY, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, stripRscSuffix } from "./app-rsc-cache-busting.js";
-import { parseClientReuseManifestHeader } from "./client-reuse-manifest.js";
 import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 //#region src/server/app-rsc-request-normalization.ts
 function extractFlightRouterStatePath(value, depth = 0) {
@@ -86,7 +85,6 @@ function tryNormalizeComparablePathAndSearch(value, basePath, baseUrl) {
 *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
 *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
 *   10. Read semantic render mode for refresh/action payload rendering
-*   11. Parse ClientReuseManifest hints on canonical RSC payload requests
 *
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
@@ -135,7 +133,6 @@ function normalizeRscRequest(request, basePath, allowOutsideBasePath = false, as
 		}
 	}
 	return {
-		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
 		hadBasePath,
 		url,
 		pathname,

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

@@ -6,9 +6,9 @@ import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { isNonCacheableCacheControl } from "../shims/cdn-cache.js";
 import { captureRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
 import { NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyHeaders, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader } from "./cache-control.js";
-import "./app-rsc-cache-busting.js";
-import { mergeVaryHeader } from "./middleware-response-headers.js";
 import { hasPostConfigLinkHeaders } from "./app-response-header-provenance.js";
+import { mergeVaryHeader } from "./middleware-response-headers.js";
+import "./app-rsc-cache-busting.js";
 //#region src/server/app-rsc-response-finalizer.ts
 const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
 const configHeadersAlreadyApplied = /* @__PURE__ */ new WeakSet();

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

@@ -1,10 +1,11 @@
 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";
@@ -69,7 +70,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 +105,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 +173,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 });
@@ -216,7 +219,6 @@ 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,

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,7 +6,7 @@ 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";
@@ -17,13 +17,13 @@ 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 +211,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);
@@ -614,6 +615,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);
@@ -823,6 +825,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

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

@@ -10,23 +10,23 @@ 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 { 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";
@@ -277,6 +277,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;

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,41 @@ 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.
  */
-export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): NonNullable<VinextResponseStageDispatchOptions["cacheIdentity"]>;
+export declare function createSharedAppPageCacheIdentity(request: Request, props: AppMatchedWorkerResponseStageProps): 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 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