vinext 1.4.1 → 1.4.2

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

@@ -669,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) => {
@@ -753,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];
@@ -786,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];
@@ -878,17 +880,19 @@ function buildAppPageElements(options) {
 		children: routeChildren
 	});
 	const firstLayoutWithElementTreePosition = layoutEntries.find((entry) => getDefaultExport(entry.layoutModule) !== null)?.treePosition;
-	const keepsSegmentLevelLists = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && firstLayoutWithElementTreePosition !== void 0 && !options.route.childrenSlot && options.semanticPageIdentity === void 0;
-	const spineTreePositions = keepsSegmentLevelLists ? Array.from(/* @__PURE__ */ new Set([...orderedTreePositions, ...Array.from({ length: Math.max(0, routeSegments.length - firstLayoutWithElementTreePosition) }, (_, offset) => firstLayoutWithElementTreePosition + 1 + offset)])).sort((left, right) => left - right) : orderedTreePositions;
+	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 ?? routeSegments.length + 1;
+	let childSegmentTreePosition = firstLayoutBelowShell?.treePosition ?? spineSegmentCount + 1;
 	const retainChildSegment = (treePosition, children) => treePosition === childSegmentTreePosition - 1 ? /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
 		id: childSegmentElementId,
 		children
 	}) : /* @__PURE__ */ jsx(BfcacheChildrenBoundary, {
-		stateKey: createBfcacheChildSegmentStateKey(resolveAppPageTemplateStateKey(routeSegments, treePosition, options.matchedParams)),
+		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--) {

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-response-stage-entry.js

@@ -58,6 +58,7 @@ async function handleResponseStage(request, env, platformCtx, props, dispatchReq
 		probeMode: props.cacheability.probeMode,
 		rawManifest: __cacheabilityManifest,
 		recomposesRequestScopedHeaders: props.kind === "app-page" && props.isRscRequest,
+		keepsParamsHeader: props.kind === "app-page" && props.interceptionContext !== null,
 		registerCacheAdapters: () => registerConfiguredCacheAdapters(env),
 		request,
 		representation: props.cacheability.representation,

package/dist/server/app-route-module-loader.d.ts

@@ -67,6 +67,7 @@ type LazyLoadableSlot = {
   loading?: unknown;
   loadings?: readonly unknown[];
   error?: unknown;
+  errors?: readonly unknown[];
   notFound?: unknown;
   notFounds?: readonly unknown[];
   __loadPage?: LazyModuleThunk | null;
@@ -76,6 +77,7 @@ type LazyLoadableSlot = {
   __loadLoading?: LazyModuleThunk | null;
   __loadLoadings?: LazyModuleLoaderArray | null;
   __loadError?: LazyModuleThunk | null;
+  __loadErrors?: LazyModuleLoaderArray | null;
   __loadNotFound?: LazyModuleThunk | null;
   __loadNotFounds?: LazyModuleLoaderArray | null;
   /** Hydrated only after an intercept matches, not with the slot's base modules. */

package/dist/server/app-route-module-loader.js

@@ -145,6 +145,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
 		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
+		pushArrayLoads(loads, slot.errors, slot.__loadErrors);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
 		pushArrayLoads(loads, slot.notFounds, slot.__loadNotFounds);
 	}

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

@@ -6,6 +6,7 @@ import { ExecutionContextLike } from "../shims/request-context.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
+import { AppPageNavigationParamSlot } from "./app-page-navigation-params.js";
 import { PagesRouteDataKind } from "./pages-route-data-kind.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { TrustedPrerenderState } from "./prerender-route-params.js";
@@ -41,9 +42,17 @@ export type AppRscHandlerRoute = {
   rootParamNames?: readonly string[];
   routeHandler?: unknown;
   routeSegments: readonly string[];
-  slots?: AppRouteTreePrefetchRoute["slots"];
+  slots?: Readonly<Record<string, NonNullable<AppRouteTreePrefetchRoute["slots"]>[string] & AppPageNavigationParamSlot>> | null;
 };
 type AppRscRouteMatch<TRoute> = {
+  /**
+   * For an interception match, the source route and params the interception
+   * context names, when they differ from the rendered `route` and `params`:
+   * a sibling intercept opened from a deeper source renders the intercepting
+   * route itself, while the deeper source is what gets authorized.
+   */
+  authorizationParams?: AppPageParams;
+  authorizationRoute?: TRoute;
   interceptionSourceIsConcrete?: boolean;
   params: AppPageParams;
   route: TRoute;

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

@@ -4,11 +4,11 @@ import { PRERENDER_REVALIDATE_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROU
 import { buildRequestHeadersFromMiddlewareResponse, hasMiddlewareRequestHeaderOverrides } from "../utils/middleware-request-headers.js";
 import { requestContextFromRequest } from "../config/request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
-import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
+import { hasBasePath, restoreBasePath, stripBasePath } from "../utils/base-path.js";
 import "./app-rsc-vary.js";
 import { ACTION_REVALIDATED_HEADER, FLIGHT_HEADERS, VINEXT_PARAMS_HEADER, VINEXT_PRERENDER_REWRITTEN_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, normalizeTrailingSlashPathname, resolvePublicFileRoute, stripRequestUrlFragment } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, hasUrlParserDotSegment, normalizeTrailingSlash, normalizeTrailingSlashPathname, resolvePublicFileRoute, stripRequestUrlFragment } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
 import { patternToNextFormat } from "../routing/route-validation.js";
@@ -18,7 +18,7 @@ import { isInterceptionMatchedUrlPath, normalizePath } from "./normalize-path.js
 import { normalizeDefaultLocalePathname, shouldRestoreLocaleRootTrailingSlash } from "./pages-i18n.js";
 import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
 import { markRouteCacheabilityDynamic, preserveRouteCacheabilityResponsePolicy } from "../shims/cacheability-classification.js";
-import { NEVER_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyOverrides, isCdnResponsePolicyHeader, reconcileCdnResponseHeadersAfterOuterPolicy } from "./cache-control.js";
+import { NEVER_CACHE_CONTROL, SERVER_ACTION_CACHE_CONTROL, applyCdnResponseHeaders, captureCdnResponsePolicyOverrides, isCdnResponsePolicyHeader, reconcileCdnResponseHeadersAfterOuterPolicy } from "./cache-control.js";
 import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersContext, hasEffectiveRequestCookieChanges, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, runWithHeadersContext } from "../shims/headers.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -33,11 +33,13 @@ import { setFrameworkRequestRoute, traceFrameworkRequest } from "./request-traci
 import { mergeMiddlewareResponseHeaders, mergeMiddlewareResponseHeadersOntoResponse, withExternalRewriteResponseHeaders } from "./middleware-response-headers.js";
 import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestUrl, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { applyAppRscConfigHeaders, finalizeAppRscResponse, isStreamedActionRedirectResponse, markAppRscResponseConfigHeadersApplied, markStreamedActionRedirectResponse } from "./app-rsc-response-finalizer.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 { resolveAppPageNavigationParams } from "./app-page-navigation-params.js";
 import { traceAppPageRender } from "./app-page-tracing.js";
 import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
@@ -46,7 +48,6 @@ import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
 import { createSharedAppCacheIdentity, createSharedAppPageCacheIdentity, createSharedAppRouteCacheIdentity, 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";
@@ -132,11 +133,8 @@ function readCacheabilityRequestProjection(options) {
 	};
 	return parsedCacheabilityRequestProjection.manifest;
 }
-function hasUrlParserDotSegment(pathname) {
-	return pathname.split("/").some((segment) => {
-		const decodedDots = segment.replaceAll(/%2e/gi, ".");
-		return decodedDots === "." || decodedDots === "..";
-	});
+function isSameInterceptionSource(a, b) {
+	return b != null && (a.authorizationRoute ?? a.route) === b.route && haveSamePageParams(a.authorizationParams ?? a.params, b.params);
 }
 function applyMiddlewareContextToResponse(response, middlewareContext, appendToPostConfigLink = false) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
@@ -152,6 +150,27 @@ function applyMiddlewareContextToResponse(response, middlewareContext, appendToP
 	}));
 }
 /**
+* These headers describe the current routed request, not the shared RSC
+* bytes, so they are composed above a transported response stage: a cache HIT
+* cannot replay another query/path and never loses dynamic params. An
+* intercepted response's params include its target's, which this match lacks,
+* so the response stage keeps them under an interception context, in its
+* cache identity.
+*/
+function withRoutedRscHeaders(response, navigationParams, resolvedUrl, keepsRenderedParams) {
+	const headers = new Headers(response.headers);
+	if (!keepsRenderedParams || !headers.has("X-Vinext-Params")) {
+		if (Object.keys(navigationParams).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(navigationParams)));
+		else headers.delete(VINEXT_PARAMS_HEADER);
+	}
+	headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(resolvedUrl));
+	return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	}));
+}
+/**
 * Next.js answers a Link's segment prefetch of a page whose notFound(),
 * forbidden() or unauthorized() it stored with a 200, so its router renders
 * the page's fallback without loading the document. A shared response stage
@@ -257,10 +276,10 @@ function requestWithoutRscCacheBustingSearchParam(request) {
 	stripRscCacheBustingSearchParam(url);
 	return cloneRequestWithUrl(request, url.toString());
 }
-/** Send a response with the never-cache policy, rebuilding immutable headers. */
-function withNeverCacheControl(response) {
+/** Send a response with a never-cache policy, rebuilding immutable headers. */
+function withNeverCacheControl(response, cacheControl = NEVER_CACHE_CONTROL) {
 	const applyNoStore = (headers) => {
-		applyCdnResponseHeaders(headers, { cacheControl: NEVER_CACHE_CONTROL });
+		applyCdnResponseHeaders(headers, { cacheControl });
 	};
 	let markedResponse = response;
 	try {
@@ -283,6 +302,19 @@ function withUnmatchedRouteCacheControl(response) {
 	unmatchedRouteResponses.add(markedResponse);
 	return markedResponse;
 }
+const serverActionResponses = /* @__PURE__ */ new WeakSet();
+function markServerActionResponse(response) {
+	serverActionResponses.add(response);
+	return response;
+}
+/**
+* A fetch action's redirect that streams its target's render keeps the
+* target's policy, as in Next.js. Every other action response is never cached.
+*/
+function withServerActionCacheControl(response) {
+	if (isStreamedActionRedirectResponse(response)) return response;
+	return withNeverCacheControl(response, SERVER_ACTION_CACHE_CONTROL);
+}
 async function handleAppRscRequest(options, request, preMiddlewareRequestContext, middlewareContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest, dispatchInternalRequest, allowInternalRscDocumentFallback, dispatchResponseStage, responseStageProbeMode = null, setInterceptionResponseUncacheable = () => {}) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
@@ -339,7 +371,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const provesConcreteInterceptionSource = (sourceMatch, sourceContext = interceptionContextHeader) => {
 		if (sourceMatch === null) return false;
 		if (sourceMatch.interceptionSourceIsConcrete !== void 0) return sourceMatch.interceptionSourceIsConcrete;
-		return sourceContext !== null && (options.matchRequestRoute ?? options.matchRoute)(sourceContext)?.route === sourceMatch.route;
+		return sourceContext !== null && (options.matchRequestRoute ?? options.matchRoute)(sourceContext)?.route === (sourceMatch.authorizationRoute ?? sourceMatch.route);
 	};
 	if (provesConcreteInterceptionSource(hadBasePath && hasRawInterceptionContext && interceptionContextHeader !== null ? options.matchInterceptRoute?.(requestPathname, interceptionContextHeader, interceptionIdHeader) ?? null : null)) setInterceptionResponseUncacheable(false);
 	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths" || pathname === "/__vinext/prerender/metadata-routes") {
@@ -510,16 +542,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				statusText: response.statusText
 			});
 		}
-		if (props.kind !== "app-page" || !props.isRscRequest) return response;
-		const headers = new Headers(response.headers);
-		if (Object.keys(props.params).length > 0) headers.set(VINEXT_PARAMS_HEADER, encodeURIComponent(JSON.stringify(props.params)));
-		else headers.delete(VINEXT_PARAMS_HEADER);
-		headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(props.resolvedUrl));
-		return preserveFullyBufferedBodyMetadata(response, new Response(response.body, {
-			headers,
-			status: response.status,
-			statusText: response.statusText
-		}));
+		return response;
 	} : void 0;
 	const responseStageRequest = (stageRequest = request) => {
 		const activeHeaders = getHeadersContext()?.headers;
@@ -629,10 +652,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const isPostRequest = request.method.toUpperCase() === "POST";
 	const contentType = request.headers.get("content-type") || "";
 	const isProgressiveActionRequest = isPostRequest && !actionId && contentType.startsWith("multipart/form-data");
-	const serveImageEndpointIfMatched = () => {
-		if (!filesystemRouteEligible || !resolvedPathnameHasBasePath || !isImageOptimizationPath(cleanPathname)) return null;
+	const serveImageEndpointIfMatched = async () => {
+		if (!filesystemRouteEligible || !resolvedPathnameHasBasePath || !isImageOptimizationPath(cleanPathnameIsRequestPathname ? requestPathname : cleanPathname)) return null;
 		const imageUrl = new URL(resolvedUrl, url);
-		const imageRedirect = resolveDevImageRedirect(imageUrl, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
+		const imageRedirect = resolveDevImageRedirect(imageUrl, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, {
+			isDev: options.isDev,
+			localPatterns: options.imageConfig?.localPatterns
+		});
 		const middlewareHeaders = new Headers();
 		mergeMiddlewareResponseHeaders(middlewareHeaders, middlewareContext.headers);
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", {
@@ -641,12 +667,12 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		const overrideHeaders = middlewareContext.requestHeaders ?? middlewareContext.headers;
 		return markImageOptimizationSignal(Response.redirect(new URL(imageRedirect, url.origin).href, 302), {
-			middlewareHeaders,
+			middlewareHeaders: new Headers(await loadPreHandlerResponseHeaders()),
 			requestHeaders: overrideHeaders ? buildRequestHeadersFromMiddlewareResponse(request.headers, overrideHeaders) : null,
 			search: imageUrl.search
 		});
 	};
-	const imageEndpointResponse = serveImageEndpointIfMatched();
+	const imageEndpointResponse = await serveImageEndpointIfMatched();
 	if (imageEndpointResponse) return imageEndpointResponse;
 	const metadataRouteResponse = await renderMetadataRouteIfMatched();
 	if (metadataRouteResponse) return composeResponseStageResponse(metadataRouteResponse);
@@ -689,7 +715,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		bypassInterceptionContextCache = true;
 		setInterceptionResponseUncacheable(true);
 	};
-	if (interceptionSourceMatch !== null && interceptionContextHeader !== null && interceptionSourcePathname !== null && !(interceptionSourceMatch.route === directPreActionMatch?.route && haveSamePageParams(interceptionSourceMatch.params, directPreActionMatch.params))) {
+	if (interceptionSourceMatch !== null && interceptionContextHeader !== null && interceptionSourcePathname !== null && !isSameInterceptionSource(interceptionSourceMatch, directPreActionMatch)) {
 		const sourceRequestPathname = options.skipTrailingSlashRedirect ? interceptionContextHeader : normalizeTrailingSlashPathname(interceptionContextHeader, options.trailingSlash) ?? interceptionContextHeader;
 		const decodedSourceRequestPathname = options.skipTrailingSlashRedirect ? interceptionSourcePathname : normalizeTrailingSlashPathname(interceptionSourcePathname, options.trailingSlash) ?? interceptionSourcePathname;
 		const adoptRewrittenInterceptionSource = (rewrittenPathname) => {
@@ -699,7 +725,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				interceptionSourceContext = rewrittenPathname;
 			}
 			const rewrittenSourceMatch = options.matchRoute(rewrittenPathname);
-			return interceptionSourceMatch !== null && rewrittenSourceMatch?.route === interceptionSourceMatch.route && haveSamePageParams(rewrittenSourceMatch.params, interceptionSourceMatch.params);
+			return interceptionSourceMatch !== null && isSameInterceptionSource(interceptionSourceMatch, rewrittenSourceMatch);
 		};
 		if (configMatchers?.matchRedirect(matchPathname(sourceRequestPathname), options.configRedirects, preMiddlewareRequestContext, currentBasePathState(), dispatchResponseStage ? void 0 : markConditionalRedirectCacheability)) {
 			options.clearRequestContext();
@@ -709,7 +735,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (runMiddleware) {
 			const sourceUrl = new URL(userlandRequest.url);
 			sourceUrl.search = new URL(resolvedUrl, url).search;
-			const sourceUrlPathname = resolvedPathnameHasBasePath && options.basePath ? sourceRequestPathname === "/" ? options.basePath : options.basePath + sourceRequestPathname : sourceRequestPathname;
+			const sourceUrlPathname = resolvedPathnameHasBasePath ? restoreBasePath(sourceRequestPathname, options.basePath) : sourceRequestPathname;
 			sourceUrl.pathname = sourceUrlPathname;
 			if (sourceUrl.pathname !== sourceUrlPathname) {
 				options.clearRequestContext();
@@ -798,7 +824,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				}
 				return !didRewriteSource || adoptRewrittenInterceptionSource(sourceRulesPathname);
 			};
-			if (!rewriteSource(options.configRewrites.beforeFiles, false) || interceptionSourceMatch.route.isDynamic && !rewriteSource(options.configRewrites.afterFiles, true)) {
+			if (!rewriteSource(options.configRewrites.beforeFiles, false) || (interceptionSourceMatch.authorizationRoute ?? interceptionSourceMatch.route).isDynamic && !rewriteSource(options.configRewrites.afterFiles, true)) {
 				options.clearRequestContext();
 				return notFoundResponse();
 			}
@@ -844,7 +870,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const handleServerAction = async (routeMatch, routePathname) => {
 		if (!filesystemRouteEligible || !isPostRequest || !actionId) return null;
 		if (routeMatch && isAppRouteHandlerRoute(routeMatch.route)) return null;
-		if (!options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
+		if (!options.handleServerActionRequest) return markServerActionResponse(createMissingServerActionResponse(options, actionId));
 		const sourceConfigHeaders = new Headers();
 		await applyAppRscConfigHeaders(sourceConfigHeaders, request, {
 			basePath: options.basePath,
@@ -855,7 +881,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			recordCacheability: dispatchResponseStage === void 0,
 			requestContext: preMiddlewareRequestContext
 		});
-		return options.handleServerActionRequest({
+		const serverActionResponse = await options.handleServerActionRequest({
 			actionId,
 			cleanPathname,
 			contentType,
@@ -871,13 +897,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			sourceConfigHeaders,
 			searchParams: getResolvedSearchParams()
 		});
+		return serverActionResponse && markServerActionResponse(serverActionResponse);
 	};
 	let progressiveActionHandled = false;
 	let progressiveActionFormState = null;
 	const handleProgressiveAction = async (routeMatch, unrenderedRouteMatch) => {
 		if (!filesystemRouteEligible || !isProgressiveActionRequest) return null;
 		if (routeMatch && isAppRouteHandlerRoute(routeMatch.route)) return null;
-		if (!options.handleProgressiveActionRequest) return unrenderedRouteMatch?.route.__loadPage && !unrenderedRouteMatch.route.__loadRouteHandler ? createMissingServerActionResponse(options, null) : null;
+		if (!options.handleProgressiveActionRequest) return unrenderedRouteMatch?.route.__loadPage && !unrenderedRouteMatch.route.__loadRouteHandler ? markServerActionResponse(createMissingServerActionResponse(options, null)) : null;
 		const progressiveActionResult = await options.handleProgressiveActionRequest({
 			actionId,
 			cleanPathname,
@@ -886,7 +913,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			request,
 			routeMatch
 		});
-		if (progressiveActionResult instanceof Response) return progressiveActionResult;
+		if (progressiveActionResult instanceof Response) return markServerActionResponse(progressiveActionResult);
 		if (progressiveActionResult?.kind !== "form-state") return null;
 		if ("actionError" in progressiveActionResult && middlewareContext.status === null && progressiveActionHttpFallbackStatus(progressiveActionResult.actionError) === null) middlewareContext.status = 500;
 		return progressiveActionResult;
@@ -1018,7 +1045,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		filesystemRouteEligible = resolvedPathnameHasBasePath;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
-		const rewrittenImageEndpointResponse = serveImageEndpointIfMatched();
+		const rewrittenImageEndpointResponse = await serveImageEndpointIfMatched();
 		if (rewrittenImageEndpointResponse) return rewrittenImageEndpointResponse;
 		const rewrittenMetadataResponse = await renderMetadataRouteIfMatched();
 		if (rewrittenMetadataResponse) return composeResponseStageResponse(rewrittenMetadataResponse);
@@ -1066,7 +1093,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		filesystemRouteEligible = resolvedPathnameHasBasePath;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
-		const rewrittenImageEndpointResponse = serveImageEndpointIfMatched();
+		const rewrittenImageEndpointResponse = await serveImageEndpointIfMatched();
 		if (rewrittenImageEndpointResponse) return rewrittenImageEndpointResponse;
 		const rewrittenMetadataResponse = await renderMetadataRouteIfMatched();
 		if (rewrittenMetadataResponse) return composeResponseStageResponse(rewrittenMetadataResponse);
@@ -1088,7 +1115,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (interceptionCacheProofInvalidated && interceptionSourceContext !== null) {
 		const finalInterceptionTargetPathname = cleanPathnameIsRequestPathname ? requestPathname : cleanPathname;
 		const finalInterceptionSourceMatch = filesystemRouteEligible && match !== null ? options.matchInterceptRoute?.(finalInterceptionTargetPathname, interceptionSourceContext, interceptionIdHeader) ?? null : null;
-		const hasVerifiedFinalInterceptionSource = hasVerifiedInterceptionSource && interceptionSourceMatch !== null && provesConcreteInterceptionSource(finalInterceptionSourceMatch) && finalInterceptionSourceMatch?.route === interceptionSourceMatch.route && haveSamePageParams(finalInterceptionSourceMatch.params, interceptionSourceMatch.params);
+		const hasVerifiedFinalInterceptionSource = hasVerifiedInterceptionSource && interceptionSourceMatch !== null && provesConcreteInterceptionSource(finalInterceptionSourceMatch) && finalInterceptionSourceMatch !== null && finalInterceptionSourceMatch.route === interceptionSourceMatch.route && haveSamePageParams(finalInterceptionSourceMatch.params, interceptionSourceMatch.params) && isSameInterceptionSource(finalInterceptionSourceMatch, {
+			params: interceptionSourceMatch.authorizationParams ?? interceptionSourceMatch.params,
+			route: interceptionSourceMatch.authorizationRoute ?? interceptionSourceMatch.route
+		});
 		if (interceptionIdHeader !== null && !hasVerifiedFinalInterceptionSource) {
 			options.clearRequestContext();
 			setInterceptionResponseUncacheable(true);
@@ -1291,7 +1321,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		routePattern: route.pattern,
 		routePathname: responseStageRoutePathname,
 		scriptNonce: scriptNonce ?? null
-	}).then(composeResponseStageResponse) : await options.dispatchMatchedPage({
+	}).then((response) => transportedResponseStage && isRscRequest ? withRoutedRscHeaders(response, resolveAppPageNavigationParams(route, params, cleanPathname), resolvedUrl, interceptionSourceContext !== null) : response).then(composeResponseStageResponse) : await options.dispatchMatchedPage({
 		bypassInterceptionContextCache,
 		cachePathname,
 		cleanPathname,
@@ -1324,7 +1354,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: resolvedSearchParams,
 		renderMode
 	}), isRscRequest && request.headers.get("Next-Router-Prefetch") === "1" && request.headers.has("Next-Router-Segment-Prefetch"));
-	if (progressiveActionFormState) return applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState);
+	if (progressiveActionFormState) return markServerActionResponse(applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState));
 	return pageResponse;
 }
 function progressiveActionHttpFallbackStatus(actionError) {
@@ -1393,7 +1423,7 @@ function createAppRscRequestHandler(options) {
 		let appRequest = rawRequest;
 		if (pagesDataNormalization?.isDataReq) {
 			const appRequestUrl = new URL(pagesDataNormalization.request.url);
-			appRequestUrl.pathname = addBasePathToPathname(appRequestUrl.pathname, options.basePath);
+			appRequestUrl.pathname = restoreBasePath(appRequestUrl.pathname, options.basePath);
 			appRequest = cloneRequestWithUrl(pagesDataCandidate, appRequestUrl.toString());
 		}
 		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
@@ -1436,6 +1466,7 @@ function createAppRscRequestHandler(options) {
 				recordCacheability: dispatchResponseStage === void 0,
 				requestContext: preMiddlewareRequestContext
 			});
+			if (serverActionResponses.has(response)) return withServerActionCacheControl(response);
 			return interceptionResponseUncacheable || unmatchedRouteResponses.has(response) ? withNeverCacheControl(response) : response;
 		}, {
 			cacheComponents: options.createPprFallbackShells !== void 0,
@@ -1448,7 +1479,8 @@ function createAppRscRequestHandler(options) {
 			await closeAfterResponse(requestContext);
 			throw error;
 		}
-		return closeAfterResponseWithBody(response, requestContext);
+		const closedResponse = closeAfterResponseWithBody(response, requestContext);
+		return isStreamedActionRedirectResponse(response) ? markStreamedActionRedirectResponse(closedResponse) : closedResponse;
 	};
 	const appRscHandler = async function appRscHandler(rawRequest, ctx, allowInternalRscDocumentFallback = false, dispatchResponseStage, responseStageProbeMode = null, transportedPrerenderState, detachedTrace = false) {
 		options.registerCacheAdapters();

package/dist/server/app-rsc-response-finalizer.d.ts

@@ -32,6 +32,9 @@ type FinalizeAppRscResponseOptions = {
 };
 /** Mark a response whose final target pipeline has already applied config headers. */
 export declare function markAppRscResponseConfigHeadersApplied(response: Response): Response;
+/** Mark a Server Action redirect that streams its target's render, and so keeps its policy. */
+export declare function markStreamedActionRedirectResponse(response: Response): Response;
+export declare function isStreamedActionRedirectResponse(response: Response): boolean;
 /** Apply only the matching next.config headers for an App Router request. */
 export declare function applyAppRscConfigHeaders(headers: Headers, request: Request, options: FinalizeAppRscResponseOptions): Promise<void>;
 /**

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

@@ -25,6 +25,15 @@ function markAppRscResponseConfigHeadersApplied(response) {
 	configHeadersAlreadyApplied.add(response);
 	return response;
 }
+const streamedActionRedirects = /* @__PURE__ */ new WeakSet();
+/** Mark a Server Action redirect that streams its target's render, and so keeps its policy. */
+function markStreamedActionRedirectResponse(response) {
+	streamedActionRedirects.add(response);
+	return response;
+}
+function isStreamedActionRedirectResponse(response) {
+	return streamedActionRedirects.has(response);
+}
 /** Apply only the matching next.config headers for an App Router request. */
 async function applyAppRscConfigHeaders(headers, request, options) {
 	if (!HAS_CONFIG_HEADERS || !options.configHeaders.length) return;
@@ -73,6 +82,7 @@ async function finalizeAppRscResponse(response, request, options) {
 	if (!response.headers.has("Cache-Control")) {
 		applyCdnResponseHeaders(response.headers, { cacheControl: "" });
 		captureRouteCacheabilityResponsePolicy(captureCdnResponsePolicyHeaders(response.headers));
+		if (isStaticFileSignal(response)) response.headers.delete("Cache-Control");
 	}
 	if (configHeadersAlreadyApplied.has(response)) {
 		normalizeExplicitNonCacheablePolicy(response.headers);
@@ -84,4 +94,4 @@ async function finalizeAppRscResponse(response, request, options) {
 	return response;
 }
 //#endregion
-export { applyAppRscConfigHeaders, finalizeAppRscResponse, markAppRscResponseConfigHeadersApplied };
+export { applyAppRscConfigHeaders, finalizeAppRscResponse, isStreamedActionRedirectResponse, markAppRscResponseConfigHeadersApplied, markStreamedActionRedirectResponse };