vinext 0.1.0 → 0.1.1

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

@@ -90,8 +90,8 @@ async function validateAppPageDynamicParams(options) {
 * `setNavigationContext` + element build + Response wrap) and the server-action
 * POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
 */
-function resolveAppPageInterceptMatch(options) {
-	const interceptState = resolveAppPageInterceptState(options);
+async function resolveAppPageInterceptMatch(options) {
+	const interceptState = await resolveAppPageInterceptState(options);
 	if (interceptState.kind !== "source-route") return null;
 	return {
 		interceptOpts: options.toInterceptOpts(interceptState.intercept),
@@ -100,11 +100,12 @@ function resolveAppPageInterceptMatch(options) {
 		sourceRoute: interceptState.sourceRoute
 	};
 }
-function resolveAppPageInterceptState(options) {
+async function resolveAppPageInterceptState(options) {
 	if (!options.isRscRequest) return { kind: "none" };
 	const intercept = options.findIntercept(options.cleanPathname);
 	if (!intercept) return { kind: "none" };
-	const sourceRoute = options.getSourceRoute(intercept.sourceRouteIndex);
+	if (intercept.__pageLoader && intercept.page == null) intercept.page = await intercept.__pageLoader();
+	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {
 		kind: "current-route",
@@ -116,8 +117,8 @@ function resolveAppPageInterceptState(options) {
 		sourceRoute
 	};
 }
-function resolveAppPageInterceptionRerenderTarget(options) {
-	const interceptState = resolveAppPageInterceptState({
+async function resolveAppPageInterceptionRerenderTarget(options) {
+	const interceptState = await resolveAppPageInterceptState({
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
@@ -143,7 +144,7 @@ function resolveAppPageActionRerenderTarget(options) {
 	return resolveAppPageInterceptionRerenderTarget(options);
 }
 async function resolveAppPageIntercept(options) {
-	const interceptState = resolveAppPageInterceptState({
+	const interceptState = await resolveAppPageInterceptState({
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
@@ -153,15 +154,17 @@ async function resolveAppPageIntercept(options) {
 		toInterceptOpts: options.toInterceptOpts
 	});
 	if (interceptState.kind === "source-route") {
+		const renderRoute = interceptState.sourceRoute;
+		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
 		options.setNavigationContext({
 			params: interceptState.intercept.matchedParams,
 			pathname: options.cleanPathname,
 			searchParams: options.searchParams
 		});
-		const interceptElement = await options.buildPageElement(interceptState.sourceRoute, pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)), options.toInterceptOpts(interceptState.intercept), options.searchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, options.toInterceptOpts(interceptState.intercept), options.searchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
-			response: await options.renderInterceptResponse(interceptState.sourceRoute, interceptElement)
+			response: await options.renderInterceptResponse(renderRoute, interceptElement)
 		};
 	}
 	return {

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

@@ -45,8 +45,8 @@ type BuildAppPageRscResponseOptions = {
   timing?: AppPageResponseTiming;
 };
 type BuildAppPageHtmlResponseOptions = {
-  draftCookie?: string | null;
-  fontLinkHeader?: string;
+  draftCookie?: string | null; /** Combined preload `Link` header value (React hints + font preloads), already capped. */
+  linkHeader?: string;
   isEdgeRuntime?: boolean;
   middlewareContext: AppPageMiddlewareContext;
   policy: AppPageResponsePolicy;

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

@@ -108,7 +108,7 @@ function buildAppPageHtmlResponse(body, options) {
 	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
 	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
 	if (options.draftCookie) headers.append("Set-Cookie", options.draftCookie);
-	if (options.fontLinkHeader) headers.set("Link", options.fontLinkHeader);
+	if (options.linkHeader) headers.set("Link", options.linkHeader);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {

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

@@ -329,7 +329,7 @@ function buildAppPageElements(options) {
 	}
 	let routeChildren = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
 		segmentMap: { children: [] },
-		children: /* @__PURE__ */ jsx(AppRouterScrollTarget, { children: /* @__PURE__ */ jsx(Slot, { id: pageId }) })
+		children: /* @__PURE__ */ jsx(Slot, { id: pageId })
 	});
 	if (isPrefetchLoadingShell) if (routeLoadingComponent === null) routeChildren = null;
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
@@ -339,6 +339,7 @@ function buildAppPageElements(options) {
 			fallback: /* @__PURE__ */ jsx(routeLoadingComponent, {}),
 			children: routeChildren
 		}, routeResetKey);
+		routeChildren = /* @__PURE__ */ jsx(AppRouterScrollTarget, { children: routeChildren });
 	}
 	const lastLayoutErrorModule = errorEntries.length > 0 ? errorEntries[errorEntries.length - 1].errorModule : null;
 	const notFoundComponent = getDefaultExport(options.route.notFound) ?? getDefaultExport(options.rootNotFoundModule);

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

@@ -18,8 +18,30 @@ type AppSsrRenderResult = {
   htmlStream: ReadableStream<Uint8Array>;
   metadataReady: Promise<void>;
   capturedRscData: Promise<ArrayBuffer> | null;
+  /**
+   * Preload `Link` header value emitted by React during SSR (via `onHeaders`),
+   * already capped to `reactMaxHeadersLength`. Empty/undefined when React
+   * emitted no preload headers (or emission was disabled with `0`).
+   */
+  linkHeader?: string;
 };
 declare function isAppSsrRenderResult(value: unknown): value is AppSsrRenderResult;
+/**
+ * Combine the React-emitted preload `Link` header with vinext's font preload
+ * `Link` header, capping the result to `reactMaxHeadersLength`.
+ *
+ * React already caps its own portion, but vinext emits font preloads through a
+ * separate channel. Mirroring Next.js — where every preload flows through a
+ * single capped `onHeaders` callback — we cap the *combined* header here,
+ * keeping only whole entries that fit and dropping the rest once the limit is
+ * exceeded. `0` disables emission entirely (matches React); `undefined` falls
+ * back to the React default of 6000.
+ *
+ * React's hints (scripts/modules/styles) come first so that under a tight cap
+ * the render-critical entries survive and trailing font preloads are dropped
+ * first.
+ */
+declare function buildAppPageLinkHeader(reactLinkHeader: string | undefined, fontLinkHeader: string | undefined, maxHeadersLength: number | undefined): string;
 type AppPageSsrHandler = {
   handleSsr: (rscStream: ReadableStream<Uint8Array>, navigationContext: NavigationContext | null, fontData: AppPageFontData, options?: {
     formState?: ReactFormState | null;
@@ -30,6 +52,12 @@ type AppPageSsrHandler = {
      * in the SSR head. Sourced from `experimental.clientTraceMetadata`.
      */
     clientTraceMetadata?: readonly string[];
+    /**
+     * Maximum total length (in characters) of the preload `Link` header
+     * emitted during SSR. `0` disables emission. From `reactMaxHeadersLength`
+     * in `next.config`.
+     */
+    reactMaxHeadersLength?: number;
     rootParams?: RootParams;
     sideStream?: ReadableStream<Uint8Array>;
     capturedRscDataRef?: {
@@ -52,6 +80,12 @@ type RenderAppPageHtmlStreamOptions = {
    * the SSR head. Undefined or empty disables emission.
    */
   clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `next.config`.
+   */
+  reactMaxHeadersLength?: number;
   rootParams?: RootParams;
   ssrHandler: AppPageSsrHandler;
   /** Pre-split side stream for fused embed+capture (#981). When set,
@@ -74,7 +108,8 @@ type AppPageHtmlStreamRecoveryResult = {
   htmlStream: ReadableStream<Uint8Array> | null;
   response: Response | null;
   metadataReady: Promise<void>;
-  capturedRscData: Promise<ArrayBuffer> | null;
+  capturedRscData: Promise<ArrayBuffer> | null; /** React-emitted preload `Link` header (already capped). */
+  linkHeader?: string;
 };
 type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
   onShellRendered?: () => void;
@@ -113,4 +148,4 @@ declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: Ren
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
 declare function shouldRerenderAppPageWithGlobalError(options: ShouldRerenderAppPageWithGlobalErrorOptions): boolean;
 //#endregion
-export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

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

@@ -14,6 +14,37 @@ function normalizeAppSsrRenderResult(raw, fallbackCapturedRscData = null) {
 		capturedRscData: fallbackCapturedRscData
 	};
 }
+/**
+* Combine the React-emitted preload `Link` header with vinext's font preload
+* `Link` header, capping the result to `reactMaxHeadersLength`.
+*
+* React already caps its own portion, but vinext emits font preloads through a
+* separate channel. Mirroring Next.js — where every preload flows through a
+* single capped `onHeaders` callback — we cap the *combined* header here,
+* keeping only whole entries that fit and dropping the rest once the limit is
+* exceeded. `0` disables emission entirely (matches React); `undefined` falls
+* back to the React default of 6000.
+*
+* React's hints (scripts/modules/styles) come first so that under a tight cap
+* the render-critical entries survive and trailing font preloads are dropped
+* first.
+*/
+function buildAppPageLinkHeader(reactLinkHeader, fontLinkHeader, maxHeadersLength) {
+	const limit = typeof maxHeadersLength === "number" ? maxHeadersLength : 6e3;
+	if (limit <= 0) return "";
+	const entries = [];
+	for (const source of [reactLinkHeader, fontLinkHeader]) {
+		if (!source) continue;
+		for (const entry of source.split(", ")) if (entry.length > 0) entries.push(entry);
+	}
+	let header = "";
+	for (const entry of entries) {
+		const next = header.length === 0 ? entry : `${header}, ${entry}`;
+		if (next.length > limit) break;
+		header = next;
+	}
+	return header;
+}
 function createAppPageFontData(options) {
 	return {
 		links: options.getLinks(),
@@ -27,6 +58,7 @@ async function renderAppPageHtmlStream(options) {
 		scriptNonce: options.scriptNonce,
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
+		reactMaxHeadersLength: options.reactMaxHeadersLength,
 		rootParams: options.rootParams,
 		sideStream: options.sideStream,
 		capturedRscDataRef: options.capturedRscDataRef,
@@ -89,13 +121,14 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, capturedRscData } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, capturedRscData, linkHeader } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
 			response: null,
 			metadataReady,
-			capturedRscData
+			capturedRscData,
+			linkHeader
 		};
 	} catch (error) {
 		const specialError = options.resolveSpecialError(error);
@@ -137,4 +170,4 @@ function shouldRerenderAppPageWithGlobalError(options) {
 	return Boolean(options.capturedError) && !options.hasLocalBoundary;
 }
 //#endregion
-export { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

package/dist/server/app-pages-bridge.d.ts

@@ -10,6 +10,22 @@ type RenderPagesFallbackDependencies = {
   buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
   decodePathParams: (pathname: string) => string;
   applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext) => Response;
+  /**
+   * Returns the `__prerender_bypass` Set-Cookie header emitted by a
+   * `draftMode().enable()`/`disable()` call inside middleware, if any. Reading
+   * it clears it. Mirrors how App Router route handlers and page renders surface
+   * the middleware-enabled draft cookie so the same flow works when the request
+   * falls through to a Pages Router route.
+   *
+   * Note: this closes the draft-mode flow for production (Cloudflare Workers /
+   * Node), where middleware runs inline in the same RSC handler context that
+   * builds this fallback. In hybrid *dev*, middleware runs in a separate Vite
+   * Pages SSR runner and `draftMode()` inside middleware is not yet permitted
+   * there (it throws a scope error before any cookie is set), so this getter
+   * returns `null` and no cookie is appended. That dev limitation is pre-existing
+   * and tracked separately from #1520.
+   */
+  getDraftModeCookieHeader: () => string | null | undefined;
 };
 type RenderPagesFallbackOptions = {
   isRscRequest: boolean;

package/dist/server/app-pages-bridge.js

@@ -4,7 +4,7 @@
 */
 async function renderPagesFallback(options, dependencies) {
 	const { isRscRequest, middlewareContext, request, url } = options;
-	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext } = dependencies;
+	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest) return null;
 	const pagesEntry = await loadPagesEntry();
 	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
@@ -24,11 +24,31 @@ async function renderPagesFallback(options, dependencies) {
 	const pagesPathname = url.pathname;
 	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
 		if (typeof pagesEntry.handleApiRoute !== "function") return null;
-		return applyRouteHandlerMiddlewareContext(await pagesEntry.handleApiRoute(pagesRequest, pagesUrl), middlewareContext);
+		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl);
+		const draftCookie = getDraftModeCookieHeader();
+		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
 	}
 	if (typeof pagesEntry.renderPage !== "function") return null;
 	const pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
-	return pagesRes.status !== 404 ? pagesRes : null;
+	if (pagesRes.status === 404) return null;
+	return applyDraftModeCookie(pagesRes, getDraftModeCookieHeader());
+}
+/**
+* Append a middleware-emitted `__prerender_bypass` Set-Cookie header to a Pages
+* Router fallback response. Returns the response unchanged when there is no
+* draft cookie to add. App Router route handlers/page renders surface this same
+* cookie via `finalizeRouteHandlerResponse`/the page response builder; this
+* keeps draft-mode parity for requests that fall through to the Pages Router.
+*/
+function applyDraftModeCookie(response, draftCookie) {
+	if (!draftCookie) return response;
+	const headers = new Headers(response.headers);
+	headers.append("Set-Cookie", draftCookie);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
 }
 //#endregion
 export { renderPagesFallback };

package/dist/server/app-route-handler-cache.d.ts

@@ -18,6 +18,7 @@ type ReadAppRouteHandlerCacheOptions = {
   getCollectedFetchTags: () => string[];
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   isAutoHead: boolean;
   isrDebug?: AppRouteDebugLogger;
   isrGet: RouteHandlerCacheGetter;

package/dist/server/app-route-handler-cache.js

@@ -39,6 +39,7 @@ async function readAppRouteHandlerCacheResponse(options) {
 						dynamicConfig: options.dynamicConfig,
 						handlerFn: options.handlerFn,
 						i18n: options.i18n,
+						trailingSlash: options.trailingSlash,
 						markDynamicUsage: options.markDynamicUsage,
 						params: options.params === null ? null : makeThenableParams(options.params),
 						request: new Request(options.requestUrl, { method: "GET" }),

package/dist/server/app-route-handler-dispatch.d.ts

@@ -30,6 +30,7 @@ type DispatchAppRouteHandlerOptions = {
   isrGet: RouteHandlerCacheGetter;
   isrRouteKey: (pathname: string) => string;
   isrSet: RouteHandlerCacheSetter;
+  trailingSlash?: boolean;
   middlewareContext: RouteHandlerMiddlewareContext;
   middlewareRequestHeaders?: Headers | null;
   /**

package/dist/server/app-route-handler-dispatch.js

@@ -77,6 +77,7 @@ async function dispatchAppRouteHandler(options) {
 			getCollectedFetchTags,
 			handlerFn: resolvedHandlerFn,
 			i18n: options.i18n,
+			trailingSlash: options.trailingSlash,
 			isAutoHead,
 			isrDebug: options.isrDebug,
 			isrGet: options.isrGet,
@@ -127,6 +128,7 @@ async function dispatchAppRouteHandler(options) {
 		handler,
 		handlerFn: resolvedHandlerFn,
 		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
 		isAutoHead,
 		isProduction,
 		isrDebug: options.isrDebug,

package/dist/server/app-route-handler-execution.d.ts

@@ -42,6 +42,7 @@ type RunAppRouteHandlerOptions = {
   dynamicConfig?: string;
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   markDynamicUsage: MarkAppRouteDynamicUsageFn;
   middlewareRequestHeaders?: Headers | null;
   /**

package/dist/server/app-route-handler-execution.js

@@ -21,6 +21,7 @@ async function runAppRouteHandler(options) {
 	const trackedRequest = createTrackedAppRouteRequest(options.request, {
 		basePath: options.basePath,
 		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
 		middlewareHeaders: options.middlewareRequestHeaders,
 		onDynamicAccess() {
 			options.markDynamicUsage();

package/dist/server/app-route-handler-runtime.d.ts

@@ -24,6 +24,7 @@ type AppRouteRequestMode = "auto" | "force-static" | "error";
 type TrackedAppRouteRequestOptions = {
   basePath?: string;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   middlewareHeaders?: Headers | null;
   onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
   requestMode?: AppRouteRequestMode;

package/dist/server/app-route-handler-runtime.js

@@ -43,10 +43,11 @@ function bindMethodIfNeeded(value, target) {
 	return typeof value === "function" ? value.bind(target) : value;
 }
 function buildNextConfig(options) {
-	if (!options.basePath && !options.i18n) return null;
+	if (!options.basePath && !options.i18n && !options.trailingSlash) return null;
 	return {
 		basePath: options.basePath,
-		i18n: options.i18n ?? void 0
+		i18n: options.i18n ?? void 0,
+		trailingSlash: options.trailingSlash
 	};
 }
 function rebuildRequestWithHeaders(input, headers) {

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

@@ -30,6 +30,7 @@ type AppRscRouteMatch<TRoute> = {
 type DispatchMatchedPageOptions<TRoute> = {
   clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
+  displayPathname: string;
   formState: ReactFormState | null;
   actionError?: unknown;
   actionFailed?: boolean;

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

@@ -2,7 +2,7 @@ import { createRequestContext, runWithRequestContext } from "../shims/unified-re
 import { hasBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { ACTION_REVALIDATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
-import { isExternalUrl, matchRedirect, matchRewrite, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
+import { isExternalUrl, matchRedirect, matchRewrite, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
 import { notFoundResponse } from "./http-error-responses.js";
 import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute, validateImageUrl } from "./request-pipeline.js";
 import { headersContextFromRequest } from "../shims/headers.js";
@@ -15,11 +15,11 @@ import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js
 import "./app-page-response.js";
 import { prerenderRouteParamsPayloadMatchesRoute, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
-import { flattenErrorCauses } from "../utils/error-cause.js";
 import { applyAppMiddleware } from "./app-middleware.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
+import { flattenErrorCauses } from "../utils/error-cause.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
 import { handleMetadataRouteRequest } from "./metadata-route-response.js";
@@ -113,7 +113,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
 	if (redirect) {
 		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
-		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : destination;
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -302,6 +302,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const pageResponse = await options.dispatchMatchedPage({
 		clientReuseManifest,
 		cleanPathname,
+		displayPathname: canonicalPathname,
 		formState,
 		actionError,
 		actionFailed,

package/dist/server/app-rsc-route-matching.d.ts

@@ -1,6 +1,12 @@
 import { RoutePatternParams } from "../routing/route-pattern.js";
 
 //#region src/server/app-rsc-route-matching.d.ts
+/**
+ * Sentinel slot key used for sibling-style interception entries.
+ * When a matched intercept carries this key, the render layer replaces the
+ * route's main page element instead of a parallel slot.
+ */
+declare const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
 type AppRscRouteParams = RoutePatternParams;
 type AppRscInterceptForMatching = {
   targetPattern: string;
@@ -25,15 +31,27 @@ type AppRscInterceptForMatching = {
   sourceMatchPattern?: string;
   interceptLayouts: readonly unknown[];
   page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
 };
 type AppRscSlotForMatching = {
   id?: string | null;
   intercepts?: readonly AppRscInterceptForMatching[];
 };
+type AppRscSiblingInterceptForMatching = {
+  targetPattern: string;
+  sourceMatchPattern: string | null;
+  slotId: string | null;
+  interceptLayouts: readonly unknown[];
+  page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
+  params: readonly string[];
+};
 type AppRscRouteForMatching = {
+  pattern: string;
   patternParts: string[];
   slots?: Record<string, AppRscSlotForMatching>;
+  siblingIntercepts?: AppRscSiblingInterceptForMatching[];
 };
 type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
   matchedParams: AppRscRouteParams;
@@ -47,6 +65,7 @@ type AppRscInterceptLookupEntry = {
   sourceMatchPatternParts: string[] | null;
   interceptLayouts: readonly unknown[];
   page: unknown;
+  __pageLoader?: (() => Promise<unknown>) | null;
   params: readonly string[];
   slotId: string | null;
 };
@@ -59,4 +78,4 @@ declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(
 };
 declare function matchAppRscRoutePattern(urlParts: string[], patternParts: string[]): AppRscRouteParams | null;
 //#endregion
-export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

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

@@ -2,6 +2,12 @@ import { splitPathnameForRouteMatch } from "../routing/utils.js";
 import { buildRouteTrie, trieMatch } from "../routing/route-trie.js";
 import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
 //#region src/server/app-rsc-route-matching.ts
+/**
+* Sentinel slot key used for sibling-style interception entries.
+* When a matched intercept carries this key, the render layer replaces the
+* route's main page element instead of a parallel slot.
+*/
+const SIBLING_PAGE_INTERCEPT_SLOT_KEY = "__vinext_page_intercept";
 function createRouteParams() {
 	return Object.create(null);
 }
@@ -54,17 +60,18 @@ function matchInterceptSource(sourceParts, entry) {
 	return matchRoutePatternPrefix(sourceParts, patternParts);
 }
 function createInterceptLookup(routes) {
+	const patternToIndex = new Map(routes.map((r, i) => [r.pattern, i]));
 	const interceptLookup = [];
 	for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
 		const route = routes[routeIndex];
-		if (!route.slots) continue;
-		for (const [slotKey, slotModule] of Object.entries(route.slots)) {
+		if (route.slots) for (const [slotKey, slotModule] of Object.entries(route.slots)) {
 			if (!slotModule.intercepts) continue;
 			for (const intercept of slotModule.intercepts) {
 				const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
 				const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+				const ownerRouteIndex = sourceMatchPattern !== null ? patternToIndex.get(sourceMatchPattern) ?? routeIndex : routeIndex;
 				interceptLookup.push({
-					sourceRouteIndex: routeIndex,
+					sourceRouteIndex: ownerRouteIndex,
 					slotKey,
 					slotId: typeof slotModule.id === "string" ? slotModule.id : null,
 					targetPattern: intercept.targetPattern,
@@ -73,10 +80,28 @@ function createInterceptLookup(routes) {
 					sourceMatchPatternParts,
 					interceptLayouts: intercept.interceptLayouts,
 					page: intercept.page,
+					__pageLoader: intercept.__pageLoader,
 					params: intercept.params
 				});
 			}
 		}
+		if (route.siblingIntercepts) for (const intercept of route.siblingIntercepts) {
+			const sourceMatchPattern = intercept.sourceMatchPattern ?? null;
+			const sourceMatchPatternParts = sourceMatchPattern ? sourceMatchPattern.split("/").filter(Boolean) : null;
+			interceptLookup.push({
+				sourceRouteIndex: routeIndex,
+				slotKey: SIBLING_PAGE_INTERCEPT_SLOT_KEY,
+				slotId: typeof intercept.slotId === "string" ? intercept.slotId : null,
+				targetPattern: intercept.targetPattern,
+				targetPatternParts: intercept.targetPattern.split("/").filter(Boolean),
+				sourceMatchPattern,
+				sourceMatchPatternParts,
+				interceptLayouts: intercept.interceptLayouts,
+				page: intercept.page,
+				__pageLoader: intercept.__pageLoader,
+				params: intercept.params
+			});
+		}
 	}
 	return interceptLookup;
 }
@@ -87,4 +112,4 @@ function mergeMatchedParams(sourceParams, targetParams) {
 	return Object.assign(createRouteParams(), sourceParams, targetParams);
 }
 //#endregion
-export { createAppRscRouteMatcher, matchAppRscRoutePattern };
+export { SIBLING_PAGE_INTERCEPT_SLOT_KEY, createAppRscRouteMatcher, matchAppRscRoutePattern };

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

@@ -108,6 +108,15 @@ type HandleProgressiveServerActionRequestOptions = {
   decodeFormState: AppServerActionFormStateDecoder;
   getAndClearPendingCookies: () => string[];
   getDraftModeCookieHeader: () => string | null | undefined;
+  /**
+   * Whether the posted-to route resolves to an App Router *page* (as opposed to
+   * a route handler or no match). Multipart form POSTs to a page are always
+   * server-action attempts in Next.js, so a body that decodes to no action must
+   * surface as 404 action-not-found rather than rendering the page. Route
+   * handlers (which run *after* this dispatch in vinext) legitimately receive
+   * raw multipart POSTs, so they must still fall through. See issue #1340.
+   */
+  hasPageRoute: boolean;
   maxActionBodySize: number;
   middlewareHeaders: Headers | null;
   readFormDataWithLimit: ReadFormDataWithLimit;
@@ -143,7 +152,8 @@ type HandleServerActionRscRequestOptions<TElement, TRoute extends AppServerActio
   isRscRequest: boolean;
   loadServerAction: (actionId: string) => Promise<unknown>;
   matchRoute: (pathname: string) => AppServerActionMatch<TRoute> | null;
-  maxActionBodySize: number;
+  maxActionBodySize: number; /** Verbatim `serverActions.bodySizeLimit` config string (e.g. "2mb") for the body-exceeded error. */
+  maxActionBodySizeLabel: string;
   middlewareHeaders: Headers | null;
   middlewareStatus: number | null | undefined;
   mountedSlotsHeader: string | null;