vinext 1.3.0 → 1.4.0

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

@@ -3,12 +3,14 @@ import "./app-rsc-vary.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { createRscOnErrorHandler } from "./app-rsc-errors.js";
 //#region src/server/app-rsc-error-handler.ts
+const loggedErrorsByRequest = /* @__PURE__ */ new WeakMap();
 /**
 * Build a per-request RSC error handler that extracts request metadata from
 * the incoming Web `Request`, wires it into a `createRscOnErrorHandler` call,
 * and binds the configured `reportRequestError` reporter.
 *
-* Pure factory: takes all deps explicitly — no closure over module-level state.
+* Takes all deps explicitly. The only module-level state is the set of errors
+* each request already logged, keyed weakly by its `Request`.
 */
 function createAppRscOnErrorHandler(reportRequestError, request, pathname, routePath, overrides) {
 	const requestHeaders = Object.fromEntries(request.headers.entries());
@@ -24,9 +26,15 @@ function createAppRscOnErrorHandler(reportRequestError, request, pathname, route
 		renderSource: overrides?.renderSource ?? (request.headers.get("RSC") === "1" || new URL(request.url).pathname.endsWith(".rsc") ? "react-server-components-payload" : "react-server-components"),
 		revalidateReason: isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate")) ? "on-demand" : overrides?.revalidateReason
 	};
+	let loggedErrors = loggedErrorsByRequest.get(request);
+	if (!loggedErrors) {
+		loggedErrors = /* @__PURE__ */ new WeakSet();
+		loggedErrorsByRequest.set(request, loggedErrors);
+	}
 	return createRscOnErrorHandler({
 		attachDigest: errorContext.renderSource !== "server-rendering",
 		errorContext,
+		loggedErrors,
 		reportRequestError(error, info, context) {
 			reportRequestError(error, info, context);
 		},

package/dist/server/app-rsc-errors.d.ts

@@ -15,6 +15,14 @@ type RscErrorReporter = (error: unknown, requestInfo: RscRequestInfo, errorConte
 type CreateRscOnErrorHandlerOptions = {
   attachDigest?: boolean;
   errorContext: RscErrorContext | null;
+  /**
+   * The errors this request already logged, shared by its handlers so an error
+   * reaching more than one, such as in the RSC and then the SSR pass, is logged
+   * once. Like Next.js, a digest alone does not mean an error was logged: user
+   * code can set its own. Request-scoped, as a failed module evaluation throws
+   * the same error on every request. Defaults to this handler's own.
+   */
+  loggedErrors?: WeakSet<object>;
   nodeEnv?: string;
   reportRequestError: RscErrorReporter;
   requestInfo: RscRequestInfo | null;
@@ -46,4 +54,5 @@ export declare function errorDigest(input: string): string;
 export declare const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 export declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
 export declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};

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

@@ -63,6 +63,13 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 }
 function createRscOnErrorHandler(options) {
 	let loggedPrerenderErrors;
+	const loggedErrors = options.loggedErrors ?? /* @__PURE__ */ new WeakSet();
+	const wasLogged = (error) => {
+		if (typeof error !== "object" && typeof error !== "function" || error === null) return false;
+		if (loggedErrors.has(error)) return true;
+		loggedErrors.add(error);
+		return false;
+	};
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
 		const reportableError = error && typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
@@ -87,7 +94,7 @@ function createRscOnErrorHandler(options) {
 				const route = options.requestInfo?.path ?? options.errorContext?.routePath ?? "<unknown>";
 				console.error(`[vinext] Error prerendering route ${JSON.stringify(route)}:`, reportableError);
 			}
-		} else if (nodeEnv !== "production" && !thrownHasDigest) console.error("[vinext] Server render error:", properError);
+		} else if (!(reportableError !== error && thrownHasDigest) && !wasLogged(reportableError)) console.error("[vinext] Server render error:", properError);
 		return digest;
 	};
 }

package/dist/server/app-rsc-handler.d.ts

@@ -1,14 +1,13 @@
 import { VinextCacheabilityProbeMode } from "./multi-stage.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { ImageConfig } from "./image-optimization.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
-import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
-import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { PagesRouteDataKind } from "./pages-route-data-kind.js";
+import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { TrustedPrerenderState } from "./prerender-route-params.js";
 import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
 import { DispatchAppWorkerResponseStage, RenderAppWorkerResponseStageLocally } from "./app-worker-stages.js";
@@ -52,7 +51,6 @@ type AppRscRouteMatch<TRoute> = {
 type DispatchMatchedPageOptions<TRoute> = {
   bypassInterceptionContextCache: boolean;
   cachePathname: string;
-  clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname: string;
   formState: ReactFormState | null;
@@ -170,7 +168,7 @@ type RenderPagesFallbackOptions = {
       pattern: string;
     };
   } | null;
-  dispatchPagesResponseStage?: (request: Request, resourceKind: "api" | "page", dataKind?: PagesRouteDataKind, hasRequestAwareDocument?: boolean) => Promise<Response>;
+  dispatchPagesResponseStage?: (request: Request, resourceKind: "api" | "page", dataKind?: PagesRouteDataKind, hasRequestAwareDocument?: boolean, runsInitialProps?: boolean) => Promise<Response>;
   isDataRequest?: boolean;
   isRscRequest: boolean;
   initialResponseHeaders?: Headers;
@@ -179,6 +177,8 @@ 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;
 };
 type NavigationContextValue = {
@@ -263,4 +263,5 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
 export type AppRscRequestHandler = (request: Request, ctx: unknown, allowInternalRscDocumentFallback?: boolean, dispatchResponseStage?: DispatchAppWorkerResponseStage, responseStageProbeMode?: VinextCacheabilityProbeMode | null, trustedPrerenderState?: TrustedPrerenderState | null) => Promise<Response>;
 /** Build the request-only handler without retaining the response renderer graph. */
 export declare function createAppRscRequestHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): AppRscRequestHandler;
-//#endregion
+//#endregion
+export {};

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 { buildPageCacheTags } from "./implicit-tags.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, ".");
@@ -195,10 +191,6 @@ function createMissingServerActionResponse(options, actionId) {
 	options.clearRequestContext();
 	return createServerActionNotFoundResponse();
 }
-function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
-	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
-	return basePath + destination;
-}
 async function applyRewrite(options, cleanPathname, recordCacheability = true) {
 	if (!HAS_CONFIG_REWRITES || !options.rewrites.length) return null;
 	const sourcePathname = options.paramsPathname ?? cleanPathname;
@@ -316,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);
@@ -371,7 +363,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	if (!options.skipTrailingSlashRedirect) {
+	if (!isDataRequest && !options.skipTrailingSlashRedirect) {
 		const trailingSlashRedirect = options.trailingSlash && options.isMetadataRoutePath && await options.isMetadataRoutePath(cleanPathname) ? null : normalizeTrailingSlash(requestCleanPathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
 		if (trailingSlashRedirect) return trailingSlashRedirect;
 	}
@@ -385,10 +377,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const configMatchers = HAS_CONFIG_REDIRECTS && options.configRedirects.length ? await import("../config/config-matchers.js") : null;
 	const redirect = configMatchers ? configMatchers.matchRedirect(redirectPathname, options.configRedirects, preMiddlewareRequestContext, basePathState, dispatchResponseStage ? void 0 : markConditionalRedirectCacheability) : null;
 	if (configMatchers && redirect) {
-		const destination = configMatchers.sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
-		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : configMatchers.preserveRedirectDestinationQuery(destination, url.search, redirect.destinationQuery);
+		const destination = redirect.destination;
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(configMatchers.encodeRedirectLocation(destination), request) : configMatchers.encodeRedirectLocation(configMatchers.preserveRedirectDestinationQuery(destination, url.search, redirect.destinationQuery));
 		return new Response(null, {
-			status: redirect.permanent ? 308 : 307,
+			status: redirect.statusCode,
 			headers: { Location: location }
 		});
 	}
@@ -484,7 +476,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		const cache = responseStageProbeMode || isOnDemandRevalidate || (props.kind === "app-page" || props.kind === "app-route-handler") && (props.bypassInterceptionContextCache || props.forceDynamic === true && responseStagePolicy === null) ? "bypass" : canUseSharedWorkerResponseStage ? "shared" : "bypass";
 		let dispatchRequest = props.kind === "app-page" ? prepareSharedAppPageDispatch(stageRequest, cache) : stageRequest;
 		let canonicalRsc = null;
-		if (cache === "shared" && props.kind === "app-page" && props.isRscRequest && props.matchKind === "request" && props.interceptionContext === null && props.interceptionId === null && props.mountedSlotsHeader === null) {
+		if (cache === "shared" && props.kind === "app-page" && props.isRscRequest && (props.matchKind === "request" || props.matchKind === "resolved") && props.interceptionContext === null && props.interceptionId === null && props.mountedSlotsHeader === null) {
 			const headers = new Headers(dispatchRequest.headers);
 			if (props.renderMode === "navigation" ? canonicalizePrewarmableRscRequestHeaders(headers) : props.renderMode === "prefetch-loading-shell" && props.canUseCanonicalLoadingShell ? canonicalizeLoadingShellRscRequestHeaders(headers) : false) {
 				canonicalRsc = {
@@ -513,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
@@ -557,7 +549,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				isRscRequest,
 				middlewareCookieOverlay,
 				mountedSlotsHeader,
-				protocolVersion: 11,
+				protocolVersion: 13,
 				requestOrigin: url.origin,
 				renderMode,
 				resolvedUrl,
@@ -925,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: {
@@ -949,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
@@ -1163,7 +1165,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			isRscRequest,
 			middlewareCookieOverlay,
 			mountedSlotsHeader,
-			protocolVersion: 11,
+			protocolVersion: 13,
 			requestOrigin: url.origin,
 			renderMode,
 			resolvedUrl,
@@ -1250,7 +1252,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			middlewareCookieOverlay,
 			mountedSlotsHeader,
 			params,
-			protocolVersion: 11,
+			protocolVersion: 13,
 			requestOrigin: url.origin,
 			renderMode,
 			resolvedUrl,
@@ -1292,7 +1294,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareCookieOverlay,
 		mountedSlotsHeader,
 		params,
-		protocolVersion: 11,
+		protocolVersion: 13,
 		requestOrigin: url.origin,
 		renderMode,
 		resolvedUrl,
@@ -1302,7 +1304,6 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}).then(composeResponseStageResponse) : await options.dispatchMatchedPage({
 		bypassInterceptionContextCache,
 		cachePathname,
-		clientReuseManifest,
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState: progressiveActionFormState?.formState ?? null,
@@ -1410,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.d.ts

@@ -47,4 +47,5 @@ export declare function applyAppRscConfigHeaders(headers: Headers, request: Requ
  * to redirects regardless.
  */
 export declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

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-rsc-route-matching.d.ts

@@ -35,13 +35,25 @@ type AppRscInterceptForMatching = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   params: readonly string[];
 };
 type AppRscSlotForMatching = {
@@ -60,13 +72,25 @@ type AppRscSiblingInterceptForMatching = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   params: readonly string[];
 };
 type AppRscRouteForMatching = {
@@ -108,13 +132,25 @@ type AppRscInterceptLookupEntry = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   __loadState: AppRscInterceptLoadState;
   params: readonly string[];
   slotId: string | null;
@@ -141,4 +177,5 @@ export declare function createAppRscRouteMatcher<Route extends AppRscRouteForMat
   } | null;
   findIntercept(pathname: string, sourcePathname?: string | null, interceptionId?: string | null): AppRscInterceptMatch | null;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-route-matching.js

@@ -209,6 +209,9 @@ function createInterceptLookup(routes) {
 					interceptLoadings: intercept.interceptLoadings,
 					interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 					interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+					interceptNotFounds: intercept.interceptNotFounds,
+					interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
+					__loadInterceptNotFounds: intercept.__loadInterceptNotFounds,
 					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 					__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 					page: intercept.page,
@@ -216,6 +219,15 @@ function createInterceptLookup(routes) {
 					notFound: intercept.notFound,
 					__loadNotFound: intercept.__loadNotFound,
 					notFoundTreePosition: intercept.notFoundTreePosition,
+					interceptForbiddens: intercept.interceptForbiddens,
+					interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+					__loadInterceptForbiddens: intercept.__loadInterceptForbiddens,
+					interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+					interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+					__loadInterceptUnauthorizeds: intercept.__loadInterceptUnauthorizeds,
+					interceptErrors: intercept.interceptErrors,
+					interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+					__loadInterceptErrors: intercept.__loadInterceptErrors,
 					__loadState: {
 						page: intercept.page,
 						pageLoading: null,
@@ -248,6 +260,9 @@ function createInterceptLookup(routes) {
 				interceptLoadings: intercept.interceptLoadings,
 				interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 				interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+				interceptNotFounds: intercept.interceptNotFounds,
+				interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
+				__loadInterceptNotFounds: intercept.__loadInterceptNotFounds,
 				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 				__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 				page: intercept.page,
@@ -255,6 +270,15 @@ function createInterceptLookup(routes) {
 				notFound: intercept.notFound,
 				__loadNotFound: intercept.__loadNotFound,
 				notFoundTreePosition: intercept.notFoundTreePosition,
+				interceptForbiddens: intercept.interceptForbiddens,
+				interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+				__loadInterceptForbiddens: intercept.__loadInterceptForbiddens,
+				interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+				interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+				__loadInterceptUnauthorizeds: intercept.__loadInterceptUnauthorizeds,
+				interceptErrors: intercept.interceptErrors,
+				interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+				__loadInterceptErrors: intercept.__loadInterceptErrors,
 				__loadState: {
 					page: intercept.page,
 					pageLoading: null,

package/dist/server/app-segment-config.d.ts

@@ -169,4 +169,5 @@ export declare function isAppPageStaticEligible(options: {
   isStaticGenerationEdgeRuntime: boolean;
   revalidateSeconds: number | null;
 }): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-segment-config.js

@@ -1,3 +1,4 @@
+import { compareFolderNames } from "../utils/compare.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-segment-config.ts
 const DYNAMIC_VALUES = /* @__PURE__ */ new Set([
@@ -310,20 +311,6 @@ function hasGenerateStaticParamsExport(segment) {
 }
 const DEFAULT_SEGMENT_NAME = "__DEFAULT__";
 /**
-* Turbopack reads a folder's subfolders from a `BTreeMap<RcStr, _>`, whose
-* keys compare as Rust `str`s: by UTF-8 bytes. That is Unicode code point
-* order, which JavaScript's `<` (UTF-16 code units) doesn't match above the
-* Basic Multilingual Plane.
-* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L188-L192
-* https://github.com/vercel/next.js/blob/v16.2.7/turbopack/crates/turbo-rcstr/src/lib.rs#L350-L354
-*/
-function compareFolderNames(a, b) {
-	const left = Array.from(a, (char) => char.codePointAt(0) ?? 0);
-	const right = Array.from(b, (char) => char.codePointAt(0) ?? 0);
-	for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return left[index] - right[index];
-	return left.length - right.length;
-}
-/**
 * Collect the loader-tree segments of an App page route from its layout, page
 * and parallel-slot modules, for `lastDynamicSegmentHasGenerateStaticParams`.
 *