vinext 1.4.0 → 1.4.2

package/dist/server/app-page-navigation-params.js

@@ -0,0 +1,49 @@
+import { matchRoutePattern } from "../routing/route-pattern.js";
+import "./app-rsc-route-matching.js";
+//#region src/server/app-page-navigation-params.ts
+function resolveSlotParamOverrides(route, routePath) {
+	const overrides = {};
+	const slots = route.slots;
+	if (slots) {
+		let urlParts = null;
+		const routeParamSet = collectParamNameSet(route.params);
+		for (const [slotKey, slot] of Object.entries(slots)) {
+			const patternParts = slot.slotPatternParts;
+			const paramNames = slot.slotParamNames;
+			if (!patternParts || patternParts.length === 0) continue;
+			if (paramNames && paramNames.every((name) => routeParamSet.has(name))) continue;
+			if (urlParts === null) urlParts = routePath.split("/").filter(Boolean);
+			const matched = matchRoutePattern(urlParts, patternParts);
+			if (!matched) continue;
+			overrides[slotKey] = matched;
+		}
+	}
+	return Object.keys(overrides).length > 0 ? overrides : null;
+}
+function mergeAppPageParams(target, source) {
+	for (const [key, value] of Object.entries(source)) target[key] = value;
+}
+function isDefaultExportModule(module) {
+	return typeof module === "object" && module !== null;
+}
+function hasDefaultExport(module) {
+	if (!isDefaultExportModule(module)) return false;
+	return module?.default !== null && module?.default !== void 0;
+}
+function resolveAppPageNavigationParams(route, routeParams, routePath, opts) {
+	const navigationParams = { ...routeParams };
+	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
+	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
+		const isInterceptedSlot = opts?.interceptSlotKey === slotKey && opts.interceptSlotKey !== "__vinext_page_intercept" && hasDefaultExport(opts.interceptPage);
+		if (!isInterceptedSlot && !hasDefaultExport(slot.page) && !hasDefaultExport(slot.default) && !slot.__loadPage && !slot.__loadDefault) continue;
+		mergeAppPageParams(navigationParams, isInterceptedSlot ? opts?.interceptParams ?? routeParams : slotParamOverrides?.[slotKey] ?? routeParams);
+	}
+	return navigationParams;
+}
+function collectParamNameSet(params) {
+	const set = /* @__PURE__ */ new Set();
+	if (params) for (const name of params) set.add(name);
+	return set;
+}
+//#endregion
+export { resolveAppPageNavigationParams, resolveSlotParamOverrides };

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

@@ -72,7 +72,6 @@ type RenderAppPageLifecycleOptionsBase = {
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
-  hasCustomGlobalError?: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
   isDraftMode: boolean;
@@ -151,9 +150,12 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  * static, draft mode, `force-dynamic`, `revalidate = 0`, or a dynamic API read
  * before the response left the render. Responses that leave the render before
  * its response policy, such as error boundaries and special errors, get the
- * same header as the normal render.
+ * same header as the normal render. One not yet known dynamic is never stored
+ * either, and its body can still reach a dynamic API after its headers leave,
+ * so it is sent like a dynamic render (see resolveUnstoredEarlyResponseCacheControl
+ * for the responses that aren't).
  */
-export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
+export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isPrerender" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
 //#endregion
 export {};

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

@@ -13,6 +13,7 @@ import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
 import { peekDynamicUsage } from "../shims/headers.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
@@ -21,13 +22,12 @@ import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
 import { isBailoutToCSRError } from "../shims/navigation-errors.js";
-import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getAppPageLayoutGate } from "./app-page-layout-gate.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
-import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
 import { createAppPageRscRenderStatusResolver } from "./app-page-rsc-render-status.js";
 import { finalizeAppPageCacheabilityEvaluationResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
@@ -70,11 +70,14 @@ function applyRequestCacheLife(options) {
 * static, draft mode, `force-dynamic`, `revalidate = 0`, or a dynamic API read
 * before the response left the render. Responses that leave the render before
 * its response policy, such as error boundaries and special errors, get the
-* same header as the normal render.
+* same header as the normal render. One not yet known dynamic is never stored
+* either, and its body can still reach a dynamic API after its headers leave,
+* so it is sent like a dynamic render (see resolveUnstoredEarlyResponseCacheControl
+* for the responses that aren't).
 */
 function applyIneligibleRouteCachePolicy(response, options, requestCacheLife = null) {
-	const cacheControl = resolveEarlyResponseCacheControl(options);
 	const isRscRedirect = options.isRscRequest && response.headers.has("X-Vinext-Rsc-Redirect");
+	const cacheControl = resolveEarlyResponseCacheControl(options) ?? (isRscRedirect ? null : resolveUnstoredEarlyResponseCacheControl(response, options));
 	if (!cacheControl) {
 		const staleTimeSeconds = isRscRedirect ? resolveClientStaleTimeSeconds(requestCacheLife) : void 0;
 		if (staleTimeSeconds === void 0) return response;
@@ -108,6 +111,17 @@ function resolveEarlyResponseCacheControl(options) {
 	const ignoresDynamicUsage = (options.isForceStatic || options.isDynamicError) && (options.revalidateSeconds === null || options.revalidateSeconds === Infinity);
 	return options.revalidateSeconds === 0 || !ignoresDynamicUsage && (options.peekDynamicUsage?.() ?? peekDynamicUsage()) ? uncacheable : null;
 }
+/**
+* The normal render can still become a cache entry, so it sends its pending
+* policy until the stream proves it static. An early response never does, and
+* nothing checks it again, so one with a body takes the never-cache header
+* unless it already carries a policy, such as middleware's. A force-static or
+* dynamic = "error" render can't read the request, and dev and the build's
+* prerender, which reads `no-store` as a dynamic render, keep no policy.
+*/
+function resolveUnstoredEarlyResponseCacheControl(response, options) {
+	return options.isProduction && options.isPrerender !== true && !options.isForceStatic && !options.isDynamicError && response.body !== null && !response.headers.has("cache-control") ? NEVER_CACHE_CONTROL : null;
+}
 function resolveAppPageCacheWriteRevalidateSeconds(options) {
 	if (!options.isStaticEligible) return null;
 	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
@@ -230,7 +244,6 @@ async function prepareAppPageElement(options) {
 }
 async function renderAppPageLifecycleImpl(options, renderSpan) {
 	let dynamicUsageObserved = false;
-	let dynamicUsageFinalized = false;
 	const isCacheCandidateHtmlRender = options.isCacheCandidate === true && options.isPrerender !== true && !options.isRscRequest;
 	const readsRenderDynamicLatch = isCacheCandidateHtmlRender || !options.isRscRequest && options.pprFallbackShellSignal === void 0 && (options.isPrerender === true || isRouteCacheabilityEvaluation());
 	const readDynamicUsage = bindRequestContext(() => options.consumeDynamicUsage() || readsRenderDynamicLatch && isRenderDynamicLatched());
@@ -240,13 +253,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		if (!dynamicUsageObserved) dynamicUsageObserved = readDynamicUsage();
 		return dynamicUsageObserved;
 	};
-	const finalizeRenderDynamicUsage = () => {
-		if (!dynamicUsageFinalized) {
-			consumeRenderDynamicUsage();
-			dynamicUsageFinalized = true;
-		}
-		return dynamicUsageObserved;
-	};
 	const artifactCompatibility = createAppPageArtifactCompatibility(options.element, options.routePattern);
 	const rootBoundaryId = artifactCompatibility?.rootBoundaryId ?? null;
 	const renderEpoch = artifactCompatibility?.renderEpoch ?? null;
@@ -429,7 +435,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		const completionHeaders = new Headers(rscResponse.headers);
 		completionHeaders.set(VINEXT_RSC_COMPLETION_METADATA_HEADER, "1");
 		const completionResponse = dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic && rscResponse.body ? new Response(appendRscCompletionMetadata(rscResponse.body, () => {
-			if (!finalizeRenderDynamicUsage()) return void 0;
+			if (!consumeRenderDynamicUsage()) return void 0;
 			const completedServerStaleTimeSeconds = resolveClientStaleTimeSeconds(options.peekRequestCacheLife?.());
 			if (shouldEmitDynamicStaleTime && completedServerStaleTimeSeconds === void 0) return;
 			return {
@@ -447,7 +453,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			bypassInterceptionContextCache: options.bypassInterceptionContextCache,
 			captureAdmittedDocument,
 			cleanPathname: options.cleanPathname,
-			consumeDynamicUsage: finalizeRenderDynamicUsage,
+			consumeDynamicUsage: consumeRenderDynamicUsage,
 			consumeRenderObservationState,
 			createHtmlRenderObservation(input) {
 				return createAppPageRenderObservation({
@@ -630,6 +636,12 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		copyLinkHeaderProvenance(response.headers, prerenderResponse.headers);
 		return prerenderResponse;
 	};
+	const markPrerenderedDynamicShellSpecialError = (response, specialError) => {
+		if (options.isPrerender === true && response.status === specialError.statusCode && resolveEarlyResponseCacheControl(options) !== null && response.headers.get("cache-control")?.includes("no-store")) getRequestExecutionContext()?.recordPrerenderSpecialError?.({
+			headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath) ?? {},
+			status: response.status
+		});
+	};
 	const finalizeShellSpecialErrorResponse = (response, specialError) => {
 		if (response.status !== specialError.statusCode) return applyIneligibleRouteCachePolicy(response, options);
 		const dynamicUsedDuringRender = consumeRenderDynamicUsage();
@@ -687,7 +699,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				capturedRscDataRef,
 				getInitialNavigationCacheMetadata: () => resolveInitialNavigationCacheMetadata(dynamicUsedDuringHtmlRender || peekDynamicUsage(), options.isPrerender === true ? requestCacheLifeForPrerender ?? options.peekRequestCacheLife?.() : options.peekRequestCacheLife?.()),
 				fontData,
-				hasCustomGlobalError: options.hasCustomGlobalError,
 				navigationContext: options.getNavigationContext(),
 				basePath: options.basePath,
 				clientTraceMetadata: options.clientTraceMetadata,
@@ -701,7 +712,8 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				scriptNonce: options.scriptNonce,
 				sideStream: rscCapture.sideStream,
 				ssrHandler,
-				fallbackToErrorDocumentOnShellError: options.isPrerender === true && options.isSpeculativePrerender === true ? false : void 0,
+				fallbackToErrorDocumentOnShellError: !(options.isPrerender === true && options.isSpeculativePrerender === true),
+				isServerComponentError: rscErrorTracker.isCapturedError,
 				waitForAllReady: shouldWaitForAllReady,
 				isStaticGeneration: options.isPrerender === true,
 				isForceStatic: options.isForceStatic,
@@ -740,7 +752,9 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 	if (htmlRender.response) {
 		if (shellSpecialError && options.isProduction && options.isPrerender !== true && resolveEarlyResponseCacheControl(options) === null) return finalizeShellSpecialErrorResponse(htmlRender.response, shellSpecialError);
 		if (shellSpecialError && prerenderedSpecialError) return finalizePrerenderedShellSpecialErrorResponse(htmlRender.response, shellSpecialError, prerenderedSpecialError);
-		return applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		const response = applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		if (shellSpecialError) markPrerenderedDynamicShellSpecialError(response, shellSpecialError);
+		return response;
 	}
 	let htmlStream = htmlRender.htmlStream;
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");

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

@@ -100,6 +100,25 @@ type AppPageInterceptMatch<TPage = unknown> = {
   targetPatternParts?: readonly string[];
   targetRouteGraphId?: string | null;
 };
+export type AppPageInterceptState<TRoute, TPage> = {
+  kind: "none";
+} | {
+  kind: "current-route";
+  intercept: AppPageInterceptMatch<TPage>;
+} | {
+  kind: "source-route";
+  intercept: AppPageInterceptMatch<TPage>;
+  sourceRoute: TRoute;
+};
+type AppPageInterceptStateLookup<TRoute, TPage> = {
+  cleanPathname: string;
+  currentRoute: TRoute;
+  findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  /** The state this request already resolved, which is then reused. */
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
+  isRscRequest: boolean;
+};
 type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = {
   cleanPathname: string;
   currentParams: AppPageParams;
@@ -107,6 +126,7 @@ type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOp
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -128,10 +148,11 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
+  interceptState?: AppPageInterceptState<TRoute, TPage>;
   isRscRequest: boolean;
   resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
-  renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
-  resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams) => Awaitable<URLSearchParams>;
+  renderInterceptResponse: (route: TRoute, element: TElement, navigationParams: AppPageParams) => Promise<Response> | Response;
+  resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams, interceptOpts: TInterceptOpts) => Awaitable<URLSearchParams>;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
     params: AppPageParams;
@@ -146,6 +167,7 @@ type ResolveAppPageInterceptResult<TInterceptOpts> = {
 };
 export declare function resolveAppPageGenerateStaticParamsSources(options: ResolveAppPageGenerateStaticParamsSourcesOptions): GenerateStaticParamsSource[];
 export declare function validateAppPageDynamicParams(options: ValidateAppPageDynamicParamsOptions): Promise<Response | null>;
+export declare function resolveAppPageInterceptState<TRoute, TPage>(options: AppPageInterceptStateLookup<TRoute, TPage>): Promise<AppPageInterceptState<TRoute, TPage>>;
 export declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>>;
 export declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
 export declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;

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

@@ -278,6 +278,7 @@ async function validateAppPageDynamicParams(options) {
 	return null;
 }
 async function resolveAppPageInterceptState(options) {
+	if (options.interceptState) return options.interceptState;
 	if (!options.isRscRequest) return { kind: "none" };
 	const intercept = options.findIntercept(options.cleanPathname);
 	if (!intercept) return { kind: "none" };
@@ -301,10 +302,9 @@ async function resolveAppPageInterceptionRerenderTarget(options) {
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
-		getRouteParamNames: options.getRouteParamNames,
 		getSourceRoute: options.getSourceRoute,
-		isRscRequest: options.isRscRequest,
-		toInterceptOpts: options.toInterceptOpts
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
 	});
 	if (interceptState.kind === "source-route") {
 		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
@@ -333,10 +333,9 @@ async function resolveAppPageIntercept(options) {
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
-		getRouteParamNames: options.getRouteParamNames,
 		getSourceRoute: options.getSourceRoute,
-		isRscRequest: options.isRscRequest,
-		toInterceptOpts: options.toInterceptOpts
+		interceptState: options.interceptState,
+		isRscRequest: options.isRscRequest
 	});
 	if (interceptState.kind === "source-route") {
 		const renderRoute = interceptState.sourceRoute;
@@ -346,17 +345,18 @@ async function resolveAppPageIntercept(options) {
 			...sourceMatchedParams,
 			...interceptState.intercept.matchedParams
 		};
-		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams) : options.searchParams;
+		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams, interceptOpts) : options.searchParams;
 		const renderParams = pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute));
+		const resolvedNavigationParams = options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts);
 		options.setNavigationContext({
-			params: options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts),
+			params: resolvedNavigationParams,
 			pathname: options.cleanPathname,
 			searchParams: renderSearchParams
 		});
 		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams);
 		return {
 			interceptOpts: void 0,
-			response: await options.renderInterceptResponse(renderRoute, interceptElement)
+			response: await options.renderInterceptResponse(renderRoute, interceptElement, resolvedNavigationParams)
 		};
 	}
 	return {
@@ -385,4 +385,4 @@ async function buildAppPageElement(options) {
 	}
 }
 //#endregion
-export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };
+export { buildAppPageElement, resolveAppPageActionRerenderTarget, resolveAppPageGenerateStaticParamsSources, resolveAppPageIntercept, resolveAppPageInterceptState, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams };

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

@@ -2,10 +2,10 @@ import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-v
 import { NEXT_CACHE_TAGS_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
-import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
 	if (!timing) return;

package/dist/server/app-page-route-wiring.d.ts

@@ -35,6 +35,8 @@ export type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule
   configLayouts?: readonly (TModule | null | undefined)[] | null;
   configLayoutTreePositions?: readonly number[] | null;
   error?: TErrorModule | null;
+  errors?: readonly (TErrorModule | null | undefined)[] | null;
+  errorTreePositions?: readonly number[] | null;
   layout?: TModule | null;
   layoutIndex: number;
   loading?: TModule | null;
@@ -99,6 +101,8 @@ export type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModul
     id: string;
     ownerTreePath: string;
     state: AppElementsSlotBinding["state"];
+    /** A slot sub-route whose children its route segments don't describe. */
+    synthetic?: boolean;
   } | null;
   /**
    * Static sibling segment names at each dynamic URL level for this route. Used
@@ -241,6 +245,12 @@ type BuildAppPageElementsOptions<TModule extends AppPageModule = AppPageModule,
     sourceRouteGraphId: string;
   }> | null;
   semanticInterceptionTargetRouteId?: string | null;
+  /**
+   * A sibling intercept's segment state keys, app root first, down to the
+   * segment its page element renders. Its BFCache segment levels follow these
+   * rather than the source route's segments.
+   */
+  siblingInterceptSegmentKeys?: readonly string[] | null;
   sourcePageSegments?: readonly string[] | null;
 };
 export type AppPageTemplateEntry<TModule extends AppPageModule = AppPageModule> = {

package/dist/server/app-page-route-wiring.js

@@ -3,6 +3,7 @@ import { fnv1a64 } from "../utils/hash.js";
 import { createInlineScriptTag, escapeHtmlAttr } from "./html.js";
 import { APP_LAYOUT_IDS_KEY, APP_ROOT_LAYOUT_KEY, APP_SKIPPED_LAYOUT_IDS_KEY, APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY, APP_STREAMING_METADATA_BODY_ID_PREFIX } from "./app-elements.js";
+import { createBfcacheChildSegmentStateKey } from "./bfcache-identity.js";
 import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { hashMountedLayoutIdentity } from "./app-mounted-layouts.js";
 import { BfcacheChildrenBoundary, BfcacheSegmentBoundary, Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
@@ -668,9 +669,11 @@ function buildAppPageElements(options) {
 			branchAccessBoundaries.set(treePosition, entries);
 		}
 		const branchErrors = /* @__PURE__ */ new Map();
-		if (overrideOrPageComponent && hasSlotTreeOverride) for (const [index, errorModule] of (slotOverride?.errorModules ?? []).entries()) {
+		const slotErrorModules = !overrideOrPageComponent ? void 0 : hasSlotTreeOverride ? slotOverride?.errorModules : slot.errors;
+		const slotErrorTreePositions = hasSlotTreeOverride ? slotOverride?.errorTreePositions : slot.errorTreePositions;
+		for (const [index, errorModule] of (slotErrorModules ?? []).entries()) {
 			const component = getErrorBoundaryExport(errorModule);
-			const treePosition = slotOverride?.errorTreePositions?.[index];
+			const treePosition = slotErrorTreePositions?.[index];
 			if (component && treePosition !== void 0) branchErrors.set(treePosition, component);
 		}
 		const resolveSlotNotFoundBoundary = (treePosition) => {
@@ -752,12 +755,6 @@ function buildAppPageElements(options) {
 		])).filter((treePosition) => !prefetchSlotLoadingEntry || !isOwnedAtRoutePrefetchCutoff && treePosition <= prefetchSlotLoadingEntry.treePosition).sort((left, right) => left - right);
 		for (let index = branchTreePositions.length - 1; index >= 0; index--) {
 			const treePosition = branchTreePositions[index];
-			const nestedBfcacheSegment = nestedBfcacheSegments.find((segment) => segment.treePosition === treePosition);
-			if (nestedBfcacheSegment) slotElement = /* @__PURE__ */ jsx(BfcacheSegmentBoundary, {
-				id: nestedBfcacheSegment.id,
-				stateKey: nestedBfcacheSegment.stateKey,
-				children: slotElement
-			});
 			const loadingComponents = prefetchSlotLoadingEntry ? [] : branchLoadings.get(treePosition) ?? [];
 			for (let loadingIndex = loadingComponents.length - 1; loadingIndex >= 0; loadingIndex--) {
 				const LoadingComponent = loadingComponents[loadingIndex];
@@ -785,6 +782,12 @@ function buildAppPageElements(options) {
 				fallback: SegmentErrorComponent,
 				children: slotElement
 			});
+			const nestedBfcacheSegment = nestedBfcacheSegments.find((segment) => segment.treePosition === treePosition);
+			if (nestedBfcacheSegment) slotElement = /* @__PURE__ */ jsx(BfcacheSegmentBoundary, {
+				id: nestedBfcacheSegment.id,
+				stateKey: nestedBfcacheSegment.stateKey,
+				children: slotElement
+			});
 			const layoutEntriesAtPosition = branchLayouts.get(treePosition) ?? [];
 			for (let layoutIndex = layoutEntriesAtPosition.length - 1; layoutIndex >= 0; layoutIndex--) {
 				const layoutEntry = layoutEntriesAtPosition[layoutIndex];
@@ -876,8 +879,22 @@ function buildAppPageElements(options) {
 		fallback: pageErrorComponent,
 		children: routeChildren
 	});
-	const renderedTreePositions = isPrefetchLoadingShell ? orderedTreePositions.filter(includesPrefetchTreePosition) : orderedTreePositions;
-	let childSegmentElementId = pageElementId;
+	const firstLayoutWithElementTreePosition = layoutEntries.find((entry) => getDefaultExport(entry.layoutModule) !== null)?.treePosition;
+	const siblingInterceptSegmentKeys = options.siblingInterceptSegmentKeys ?? null;
+	const keepsSegmentLevelLists = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && firstLayoutWithElementTreePosition !== void 0 && !options.route.childrenSlot?.synthetic && (options.semanticPageIdentity === void 0 || siblingInterceptSegmentKeys !== null);
+	const spineSegmentCount = siblingInterceptSegmentKeys?.length ?? routeSegments.length;
+	const spineTreePositions = keepsSegmentLevelLists ? Array.from(/* @__PURE__ */ new Set([...orderedTreePositions, ...Array.from({ length: Math.max(0, spineSegmentCount - firstLayoutWithElementTreePosition) }, (_, offset) => firstLayoutWithElementTreePosition + 1 + offset)])).sort((left, right) => left - right) : orderedTreePositions;
+	const renderedTreePositions = isPrefetchLoadingShell ? spineTreePositions.filter(includesPrefetchTreePosition) : spineTreePositions;
+	const firstLayoutBelowShell = keepsSegmentLevelLists && isPrefetchLoadingShell ? layoutEntries.find((entry) => !includesPrefetchTreePosition(entry.treePosition) && getDefaultExport(entry.layoutModule) !== null) : void 0;
+	let childSegmentElementId = firstLayoutBelowShell?.id ?? pageElementId;
+	let childSegmentTreePosition = firstLayoutBelowShell?.treePosition ?? spineSegmentCount + 1;
+	const retainChildSegment = (treePosition, children) => treePosition === childSegmentTreePosition - 1 ? /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		id: childSegmentElementId,
+		children
+	}) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+		stateKey: createBfcacheChildSegmentStateKey(siblingInterceptSegmentKeys ? JSON.stringify(siblingInterceptSegmentKeys.slice(0, treePosition + 1)) : resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
+		children
+	});
 	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
 		const treePosition = renderedTreePositions[index];
 		const segmentResetKey = resolveRouteSegmentResetKey(treePosition);
@@ -927,11 +944,12 @@ function buildAppPageElements(options) {
 				children: segmentChildren
 			}, String(process.env.__NEXT_CACHE_COMPONENTS) === "true" ? void 0 : templateStateKey);
 		}
+		const layoutHasElement = layoutEntry !== void 0 && getDefaultExport(layoutEntry.layoutModule) !== null;
+		if (keepsSegmentLevelLists && !layoutHasElement && treePosition > firstLayoutWithElementTreePosition && treePosition < childSegmentTreePosition) segmentChildren = retainChildSegment(treePosition, segmentChildren);
 		if (!layoutEntry) {
 			routeChildren = segmentChildren;
 			continue;
 		}
-		const layoutHasElement = getDefaultExport(layoutEntry.layoutModule) !== null;
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition) ?? -1;
 		const segmentMap = { children: resolveAppPageLayoutSegmentProviderSegments(options.route.childrenRouteSegments ?? routeSegments, layoutEntry.treePosition, options.matchedParams) };
 		for (const [slotKey, slot] of Object.entries(options.route.slots ?? {})) {
@@ -949,13 +967,16 @@ function buildAppPageElements(options) {
 			children: layoutHasElement ? /* @__PURE__ */ jsx(Slot, {
 				id: layoutEntry.id,
 				parallelSlots: createAppPageParallelSlotEntries(layoutIndex, layoutEntries, options.route, getEffectiveSlotParams, resolveSlotOverride),
-				children: /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
+				children: keepsSegmentLevelLists ? retainChildSegment(treePosition, segmentChildren) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
 					id: childSegmentElementId,
 					children: segmentChildren
 				})
 			}) : segmentChildren
 		});
-		if (layoutHasElement) childSegmentElementId = layoutEntry.id;
+		if (layoutHasElement) {
+			childSegmentElementId = layoutEntry.id;
+			childSegmentTreePosition = treePosition;
+		}
 	}
 	const globalErrorComponent = getErrorBoundaryExport(options.globalErrorModule);
 	routeChildren = /* @__PURE__ */ jsx(GlobalErrorBoundary, {

package/dist/server/app-page-segment-plan.js

@@ -1,7 +1,7 @@
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { createNestedBfcacheSlotSegmentId, deriveBfcacheSegmentIdentity } from "./bfcache-identity.js";
-import { resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
+import { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, resolveAppPageRouteStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey } from "./app-page-segment-state.js";
 //#region src/server/app-page-segment-plan.ts
 function requireGraphSequenceId(ids, index, kind) {
 	const id = ids[index];
@@ -118,6 +118,14 @@ function createAppPageSegmentPlan(options) {
 					treePosition
 				});
 			}
+			if (semanticSegments.length > 0) {
+				const leafKey = slotBinding.state === "default" ? APP_PAGE_DEFAULT_SEGMENT_KEY : APP_PAGE_SEGMENT_KEY;
+				semanticSegments.push({
+					identityKey: JSON.stringify([...boundSegmentKeys, leafKey]),
+					stateKey: leafKey,
+					treePosition: branchSegments.length
+				});
+			}
 		}
 		const includedInPayload = options.includeSlot(ownerTreePosition, targetTreePosition);
 		const graphId = graphIds ? graphIds.slots[slotKey] : slot.id ?? slotId;

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

@@ -1,8 +1,17 @@
 import { AppPageParams } from "./app-page-boundary.js";
 //#region src/server/app-page-segment-state.d.ts
 export declare const APP_PAGE_SEGMENT_KEY = "__PAGE__";
+export declare const APP_PAGE_DEFAULT_SEGMENT_KEY = "__DEFAULT__";
 export declare function isAppPageRouteGroupSegment(segment: string): boolean;
 export declare function canonicalizeAppPageParams(params: AppPageParams): void;
+/**
+ * Rebinds segment state keys and BFCache identities resolved with one set of
+ * params to another. Keys are JSON arrays of segment keys, nested to any
+ * depth, so each whole segment key is compared with the param tokens
+ * `resolveSingleSegmentStateKey` produced for the learned params; only those
+ * whose value differs are replaced. Returns null when no token changes.
+ */
+export declare function createAppPageSegmentStateKeyRebinder(fromParams: AppPageParams, toParams: AppPageParams): ((stateKey: string) => string) | null;
 export declare function resolveAppPageChildSegments(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string[];
 export declare function resolveAppPageSegmentStateKey(routeSegments: readonly string[], treePosition: number, params: AppPageParams): string;
 /**

package/dist/server/app-page-segment-state.js

@@ -1,6 +1,7 @@
 import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
 const APP_PAGE_SEGMENT_KEY = "__PAGE__";
+const APP_PAGE_DEFAULT_SEGMENT_KEY = "__DEFAULT__";
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -49,6 +50,58 @@ function resolveSingleSegmentStateKey(segment, params) {
 	if (!param) return segment;
 	return `${param.name}|${formatSegmentStateParamValue(param, params, segment)}|${param.type}`;
 }
+const SEGMENT_PARAM_TYPES = [
+	"d",
+	"c",
+	"oc"
+];
+function formatSegmentParamPattern(param) {
+	if (param.type === "oc") return `[[...${param.name}]]`;
+	if (param.type === "c") return `[...${param.name}]`;
+	return `[${param.name}]`;
+}
+/**
+* Rebinds segment state keys and BFCache identities resolved with one set of
+* params to another. Keys are JSON arrays of segment keys, nested to any
+* depth, so each whole segment key is compared with the param tokens
+* `resolveSingleSegmentStateKey` produced for the learned params; only those
+* whose value differs are replaced. Returns null when no token changes.
+*/
+function createAppPageSegmentStateKeyRebinder(fromParams, toParams) {
+	const tokens = /* @__PURE__ */ new Map();
+	for (const name of /* @__PURE__ */ new Set([...Object.keys(fromParams), ...Object.keys(toParams)])) for (const type of SEGMENT_PARAM_TYPES) {
+		const param = {
+			name,
+			type
+		};
+		const fallbackSegment = formatSegmentParamPattern(param);
+		const from = formatSegmentStateParamValue(param, fromParams, fallbackSegment);
+		const to = formatSegmentStateParamValue(param, toParams, fallbackSegment);
+		if (from !== to) tokens.set(`${name}|${from}|${type}`, `${name}|${to}|${type}`);
+	}
+	if (tokens.size === 0) return null;
+	const rebind = (stateKey) => {
+		const token = tokens.get(stateKey);
+		if (token !== void 0) return token;
+		if (!stateKey.startsWith("[")) return stateKey;
+		let parts;
+		try {
+			parts = JSON.parse(stateKey);
+		} catch {
+			return stateKey;
+		}
+		if (!Array.isArray(parts)) return stateKey;
+		let changed = false;
+		const rebound = parts.map((part) => {
+			if (typeof part !== "string") return part;
+			const next = rebind(part);
+			if (next !== part) changed = true;
+			return next;
+		});
+		return changed ? JSON.stringify(rebound) : stateKey;
+	};
+	return rebind;
+}
 function resolveAppPageChildSegments(routeSegments, treePosition, params) {
 	const rawSegments = routeSegments.slice(treePosition);
 	const resolvedSegments = [];
@@ -104,4 +157,4 @@ function resolveAppPageTemplateStateKey(routeSegments, treePosition, params) {
 	return statePath.length > 0 ? JSON.stringify(statePath) : "";
 }
 //#endregion
-export { APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey };
+export { APP_PAGE_DEFAULT_SEGMENT_KEY, APP_PAGE_SEGMENT_KEY, canonicalizeAppPageParams, createAppPageSegmentStateKeyRebinder, isAppPageRouteGroupSegment, resolveAppPageChildSegments, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey, resolveAppPageSemanticSegmentStateKey, resolveAppPageTemplateStateKey };

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

@@ -96,10 +96,13 @@ export type AppPageSsrHandler = {
     /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
      *  mirroring once a function returns true. */
     mirrorNextFlight?: boolean | (() => boolean);
-    /** When true, an SSR-phase-only shell render error resolves to the
-     *  default `__next_error__` error-document shell (with the original
-     *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+    /** When true, a shell render error other than a redirect, HTTP access
+     *  fallback or bail-out resolves to the default `__next_error__`
+     *  error-document shell (with the original flight payload and
+     *  bootstrap) instead of rejecting. See handleSsr. */
     fallbackToErrorDocumentOnShellError?: boolean;
+    /** Whether the RSC render threw the given shell error. See handleSsr. */
+    isServerComponentError?: (error: unknown) => boolean;
     /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
     resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
     dynamicStaleTimeSeconds?: number;
@@ -153,8 +156,11 @@ type RenderAppPageHtmlStreamOptions = {
   isForceStatic?: boolean;
   /** Production render that may be stored under a query-free key. */
   isCacheCandidate?: boolean;
-  /** Override the default shell-error recovery decision passed to handleSsr. */
+  /** Whether handleSsr answers a shell error with the error document. Off by
+   *  default: a boundary render that fails keeps rejecting. */
   fallbackToErrorDocumentOnShellError?: boolean;
+  /** Whether the RSC render threw the given shell error. See handleSsr. */
+  isServerComponentError?: (error: unknown) => boolean;
   /** The parallel slot not-found boundaries that catch a shell error. See handleSsr. */
   resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   /** Dev-only: original server error to surface in the browser overlay. */
@@ -164,10 +170,6 @@ type RenderAppPageHtmlStreamOptions = {
   /** Mirror inline Flight chunks into Next.js's `self.__next_f` transport, or start
    *  mirroring once a function returns true. */
   mirrorNextFlight?: boolean | (() => boolean);
-  /** True when the app supplies a custom global-error.tsx. Disables the
-   *  default error-document shell fallback so SSR shell errors keep driving
-   *  the server-rendered global-error boundary re-render. */
-  hasCustomGlobalError?: boolean;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;