vinext 0.1.3 → 0.1.5

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

@@ -1,6 +1,7 @@
 import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 //#region src/server/app-page-stream.ts
 function isAppSsrRenderResult(value) {
 	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
@@ -70,41 +71,6 @@ async function renderAppPageHtmlStream(options) {
 	};
 	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
-/**
-* Wraps a stream so that `onFlush` is called when the last byte has been read
-* by the downstream consumer (i.e. when the HTTP layer finishes draining the
-* response body). This is the correct place to clear per-request context,
-* because the RSC/SSR pipeline is lazy — components execute while the stream
-* is being consumed, not when the stream handle is first obtained.
-*/
-function deferUntilStreamConsumed(stream, onFlush) {
-	let called = false;
-	const once = () => {
-		if (!called) {
-			called = true;
-			onFlush();
-		}
-	};
-	const cleanup = new TransformStream({ flush() {
-		once();
-	} });
-	const reader = stream.pipeThrough(cleanup).getReader();
-	return new ReadableStream({
-		pull(controller) {
-			return reader.read().then(({ done, value }) => {
-				if (done) controller.close();
-				else controller.enqueue(value);
-			}, (error) => {
-				once();
-				controller.error(error);
-			});
-		},
-		cancel(reason) {
-			once();
-			return reader.cancel(reason);
-		}
-	});
-}
 async function renderAppPageHtmlResponse(options) {
 	const { htmlStream } = await renderAppPageHtmlStream(options);
 	const safeStream = deferUntilStreamConsumed(htmlStream, () => {

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

@@ -5,7 +5,9 @@ type PagesEntry = {
   handleApiRoute?: (request: Request, url: string) => Promise<Response> | Response;
   matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
-  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null) => Promise<Response> | Response;
+  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null, options?: {
+    isDataReq?: boolean;
+  }) => Promise<Response> | Response;
 };
 type PagesRouteMatch = {
   route: {
@@ -44,10 +46,12 @@ type RenderPagesFallbackDependencies = {
 type RenderPagesFallbackOptions = {
   allowRscDocumentFallback?: boolean;
   appRouteMatch?: AppRouteMatch | null;
+  isDataRequest?: boolean;
   isRscRequest: boolean;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppMiddlewareContext;
   pathname?: string;
+  pagesDataRequest?: Request | null;
   request: Request;
   url: URL;
 };

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

@@ -1,26 +1,17 @@
+import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
 //#region src/server/app-pages-bridge.ts
 /**
 * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
 */
 async function renderPagesFallback(options, dependencies) {
-	const { allowRscDocumentFallback = false, appRouteMatch = null, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, request, url } = options;
+	const { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
 	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
 	if (isRscRequest && !allowRscDocumentFallback) return null;
 	const pagesEntry = await loadPagesEntry();
 	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
 	let pagesRequest = request;
-	if (pagesRequestHeaders) {
-		const pagesRequestInit = {
-			method: request.method,
-			headers: pagesRequestHeaders
-		};
-		if (request.method !== "GET" && request.method !== "HEAD") {
-			pagesRequestInit.body = request.body;
-			pagesRequestInit.duplex = "half";
-		}
-		pagesRequest = new Request(request.url, pagesRequestInit);
-	}
+	if (pagesRequestHeaders) pagesRequest = cloneRequestWithHeaders(request, pagesRequestHeaders);
 	const queryIndex = pathname.indexOf("?");
 	const pagesPathname = queryIndex === -1 ? pathname : pathname.slice(0, queryIndex);
 	const pagesSearch = queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex);
@@ -46,7 +37,8 @@ async function renderPagesFallback(options, dependencies) {
 	if (pageMatch !== null && matchKind === "static" && pageMatch.route.isDynamic) return null;
 	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
 	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
-	const pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	const renderRequest = pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest;
+	const pagesRes = isDataRequest ? await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders, { isDataReq: true }) : await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
 	if (pagesRes.status === 404 && pageMatch === null) return null;
 	return applyDraftModeCookie(pagesRes, getDraftModeCookieHeader());
 }

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

@@ -1,5 +1,4 @@
-import { NavigationContext } from "../shims/navigation.js";
-
+import { NavigationContext } from "../shims/navigation-context-state.js";
 //#region src/server/app-request-context.d.ts
 /**
  * Set navigation context in the ALS-backed store. "use client" components

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

@@ -1,5 +1,6 @@
 import { setHeadersContext } from "../shims/headers.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
+import "../shims/navigation-server.js";
 import { setRootParams } from "../shims/root-params.js";
 //#region src/server/app-request-context.ts
 /**

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

@@ -3,13 +3,14 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getAndClearPendingCookies, getDraftModeCookieHeader, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
 import { ensureFetchPatch, getCollectedFetchTags, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { setNavigationContext } from "../shims/navigation.js";
+import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
+import "../shims/navigation.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
-import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext } from "./app-static-generation.js";
 import { executeAppRouteHandler } from "./app-route-handler-execution.js";
 import { readAppRouteHandlerCacheResponse } from "./app-route-handler-cache.js";
 import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";

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

@@ -1,6 +1,6 @@
 import { NextI18nConfig } from "../config/next-config.js";
+import { CachedRouteValue } from "../shims/cache-handler.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
-import { CachedRouteValue } from "../shims/cache.js";
 import { NextRequest } from "../shims/server.js";
 import { HeadersAccessPhase } from "../shims/headers.js";
 import { RouteHandlerMiddlewareContext } from "./app-route-handler-response.js";

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

@@ -1,8 +1,8 @@
 import { setHeadersContext } from "../shims/headers.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
 import { isPossibleAppRouteActionRequest, resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidateHeader, shouldWriteAppRouteHandlerCache } from "./app-route-handler-policy.js";
-import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
+import { createStaticGenerationHeadersContext, getAppRouteStaticGenerationErrorMessage } from "./app-static-generation.js";
 //#region src/server/app-route-handler-execution.ts
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {

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

@@ -1,4 +1,4 @@
-import { CacheControlMetadata, CachedRouteValue } from "../shims/cache.js";
+import { CacheControlMetadata, CachedRouteValue } from "../shims/cache-handler.js";
 
 //#region src/server/app-route-handler-response.d.ts
 type RouteHandlerMiddlewareContext = {

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

@@ -2,7 +2,8 @@ import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { cloneRequestWithHeaders, filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";

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

@@ -130,10 +130,12 @@ type RenderPagesFallbackOptions = {
       pattern: string;
     };
   } | null;
+  isDataRequest?: boolean;
   isRscRequest: boolean;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppRscMiddlewareContext;
   pathname?: string;
+  pagesDataRequest?: Request | null;
   request: Request;
   url: URL;
 };
@@ -144,6 +146,7 @@ type NavigationContextValue = {
 };
 type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
+  buildId: string | null;
   cacheComponents?: boolean;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];

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

@@ -1,5 +1,5 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
-import { hasBasePath } from "../utils/base-path.js";
+import { addBasePathToPathname, hasBasePath, stripBasePath } 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, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination } from "../config/config-matchers.js";
@@ -8,20 +8,19 @@ import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWith
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
-import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, resolveDevImageRedirect } from "./image-optimization.js";
+import { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, createRscRedirectLocation, hasRscCacheBustingSearchParam, resolveInvalidRscCacheBustingRequest, stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import "./app-page-response.js";
-import { createAppPprFallbackShells } from "./app-ppr-fallback-shell.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { getRenderedConcreteUrlPathsForRoute } from "./pregenerated-concrete-paths.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 { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { handleAppPrerenderEndpoint } from "./app-prerender-endpoints.js";
 import { finalizeAppRscResponse } from "./app-rsc-response-finalizer.js";
 import { normalizeRscRequest } from "./app-rsc-request-normalization.js";
@@ -108,7 +107,7 @@ function requestWithoutRscSuffix(request) {
 	url.pathname = pathname;
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest) {
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
@@ -119,6 +118,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	let resolvedUrl = cleanPathname + url.search;
+	const originalResolvedUrl = resolvedUrl;
 	const getResolvedSearchParams = () => new URL(resolvedUrl, url).searchParams;
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
@@ -142,6 +142,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (redirect) {
 		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
 		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
+		if (isDataRequest) return new Response(null, {
+			status: 200,
+			headers: { "x-nextjs-redirect": location }
+		});
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -161,6 +165,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	};
 	let didMiddlewareRewrite = false;
 	if (options.middlewareModule) {
+		const { applyAppMiddleware } = await import("./app-middleware.js");
 		const middlewareResult = await applyAppMiddleware({
 			basePath: options.basePath,
 			cleanPathname,
@@ -243,7 +248,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
 	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
 	const contentType = request.headers.get("content-type") || "";
-	const progressiveActionResult = await options.handleProgressiveActionRequest({
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	let progressiveActionResult = null;
+	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) progressiveActionResult = await options.handleProgressiveActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -251,12 +258,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		request
 	});
 	if (progressiveActionResult instanceof Response) return progressiveActionResult;
-	const isProgressiveActionRender = progressiveActionResult?.kind === "form-state";
-	const formState = isProgressiveActionRender ? progressiveActionResult.formState : null;
-	const failedProgressiveActionResult = isProgressiveActionRender && "actionFailed" in progressiveActionResult ? progressiveActionResult : null;
+	const progressiveActionFormState = progressiveActionResult?.kind === "form-state" ? progressiveActionResult : null;
+	const isProgressiveActionRender = progressiveActionFormState !== null;
+	const formState = progressiveActionFormState?.formState ?? null;
+	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = await options.handleServerActionRequest({
+	const serverActionResponse = isPostRequest && actionId ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -266,19 +274,31 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		mountedSlotsHeader,
 		request,
 		searchParams: getResolvedSearchParams()
-	});
+	}) : null;
 	if (serverActionResponse) return serverActionResponse;
 	let match = preActionMatch;
-	const renderPagesForMatchKind = async (matchKind) => match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
-		appRouteMatch: match ?? null,
-		allowRscDocumentFallback: didMiddlewareRewrite,
-		isRscRequest,
-		matchKind,
-		middlewareContext,
-		pathname: resolvedUrl,
-		request,
-		url
-	}) ?? null : null;
+	const renderPagesForMatchKind = async (matchKind) => {
+		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
+			appRouteMatch: match ?? null,
+			allowRscDocumentFallback: didMiddlewareRewrite,
+			isDataRequest,
+			isRscRequest,
+			matchKind,
+			middlewareContext,
+			pathname: resolvedUrl,
+			pagesDataRequest,
+			request,
+			url
+		}) ?? null : null;
+		if (!response || !pagesDataRequest || resolvedUrl === originalResolvedUrl) return response;
+		const headers = new Headers(response.headers);
+		headers.set("x-nextjs-rewrite", resolvedUrl);
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	};
 	const staticPagesFallbackResponse = await renderPagesForMatchKind("static");
 	if (staticPagesFallbackResponse) {
 		options.clearRequestContext();
@@ -339,6 +359,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		}
 		if (match) break;
 	}
+	if (pagesDataRequest) {
+		options.clearRequestContext();
+		return buildNextDataNotFoundResponse();
+	}
 	if (!match) {
 		if (process.env.NODE_ENV !== "production" && canonicalPathname === "/favicon.ico") {
 			options.clearRequestContext();
@@ -364,11 +388,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
 	const resolvedSearchParams = getResolvedSearchParams();
-	const runtimeFallbackShells = options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params ? createAppPprFallbackShells({
-		params: route.params,
-		pattern: route.pattern,
-		rootParamNames: route.rootParamNames
-	}, params) : [];
+	let runtimeFallbackShells = [];
+	if (options.cacheComponents === true && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) {
+		const { createAppPprFallbackShells } = await import("./app-ppr-fallback-shell.js");
+		runtimeFallbackShells = createAppPprFallbackShells({
+			params: route.params,
+			pattern: route.pattern,
+			rootParamNames: route.rootParamNames
+		}, params);
+	}
 	options.setNavigationContext({
 		pathname: canonicalPathname,
 		searchParams: resolvedSearchParams,
@@ -421,7 +449,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: resolvedSearchParams,
 		renderMode
 	});
-	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionResult);
+	if (isProgressiveActionRender) return applyProgressiveActionSideEffects(pageResponse, progressiveActionFormState);
 	return pageResponse;
 }
 /**
@@ -461,13 +489,27 @@ function createAppRscHandler(options) {
 		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
-		const isDataRequest = rawRequest.headers.get("x-nextjs-data") === "1";
+		const hasDataRequestHeader = rawRequest.headers.get("x-nextjs-data") === "1";
+		const pagesDataUrl = new URL(rawRequest.url);
+		const pagesDataInScope = !options.basePath || hasBasePath(pagesDataUrl.pathname, options.basePath);
+		if (pagesDataInScope) pagesDataUrl.pathname = stripBasePath(pagesDataUrl.pathname, options.basePath);
+		const pagesDataCandidate = pagesDataInScope ? cloneRequestWithUrl(rawRequest, pagesDataUrl.toString()) : null;
+		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId) : null;
+		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
+		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
 		const filteredHeaders = filterInternalHeaders(rawRequest.headers);
 		if (mwCtx !== null) filteredHeaders.set(VINEXT_MW_CTX_HEADER, mwCtx);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
-		const request = cloneRequestWithHeaders(rawRequest, filteredHeaders);
+		let appRequest = rawRequest;
+		if (pagesDataNormalization?.isDataReq) {
+			const appRequestUrl = new URL(pagesDataNormalization.request.url);
+			appRequestUrl.pathname = addBasePathToPathname(appRequestUrl.pathname, options.basePath);
+			appRequest = cloneRequestWithUrl(pagesDataCandidate, appRequestUrl.toString());
+		}
+		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
+		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
 		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
 		return runWithRequestContext(createRequestContext({
 			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
@@ -478,7 +520,7 @@ function createAppRscHandler(options) {
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest);
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
 			} catch (error) {
 				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
 				throw error;

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

@@ -4,8 +4,8 @@ import "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { applyConfigHeadersToResponse } from "./request-pipeline.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
-import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeVaryHeader } from "./middleware-response-headers.js";
 //#region src/server/app-rsc-response-finalizer.ts
 /**

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

@@ -18,6 +18,7 @@ function appRscPathnameParts(pathname) {
 function createAppRscRouteMatcher(routes) {
 	const routeTrie = buildRouteTrie(routes);
 	const interceptLookup = createInterceptLookup(routes);
+	const routeIndexes = new Map(routes.map((route, index) => [route, index]));
 	return {
 		matchRoute(url) {
 			return trieMatch(routeTrie, appRscPathnameParts(url));
@@ -26,16 +27,19 @@ function createAppRscRouteMatcher(routes) {
 			if (sourcePathname === null) return null;
 			const urlParts = appRscPathnameParts(pathname);
 			const sourceParts = appRscPathnameParts(sourcePathname);
+			const matchedSourceRoute = trieMatch(routeTrie, sourceParts);
 			for (const entry of interceptLookup) {
 				if (!matchInterceptSource(sourceParts, entry)) continue;
 				const params = matchAppRscRoutePattern(urlParts, entry.targetPatternParts);
 				if (params === null) continue;
-				const sourceRoute = routes[entry.sourceRouteIndex];
-				const matchedSourceParams = sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
+				const concreteSourceRouteIndex = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? routeIndexes.get(matchedSourceRoute.route) ?? entry.sourceRouteIndex : entry.sourceRouteIndex;
+				const sourceRoute = routes[concreteSourceRouteIndex];
+				const matchedSourceParams = matchedSourceRoute && entry.sourceMatchPatternParts !== null ? matchedSourceRoute.params : sourceRoute ? matchAppRscRoutePattern(sourceParts, sourceRoute.patternParts) : null;
 				if (matchedSourceParams === null && entry.sourceMatchPatternParts === null) continue;
 				const sourceParams = matchedSourceParams ?? createRouteParams();
 				return {
 					...entry,
+					sourceRouteIndex: concreteSourceRouteIndex,
 					matchedParams: mergeMatchedParams(sourceParams, params)
 				};
 			}

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

@@ -1,4 +1,4 @@
-import { ActionRevalidationKind } from "../shims/cache.js";
+import { ActionRevalidationKind } from "../shims/cache-request-state.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { FetchCacheMode } from "../shims/fetch-cache.js";
 import { HeadersAccessPhase } from "../shims/headers.js";

package/dist/server/app-server-action-execution.js

@@ -4,17 +4,18 @@ import { ACTION_FORWARDED_HEADER, ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS
 import { isExternalUrl } from "../config/config-matchers.js";
 import { internalServerErrorResponse, payloadTooLargeResponse } from "./http-error-responses.js";
 import { validateCsrfOrigin, validateServerActionPayload } from "./request-pipeline.js";
-import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
-import { getAndClearActionRevalidationKind } from "../shims/cache.js";
 import { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI } from "./app-rsc-render-mode.js";
+import { headersContextFromRequest, setHeadersContext } from "../shims/headers.js";
+import { getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
-import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import "./app-page-stream.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
@@ -177,7 +178,7 @@ async function readActionFormDataWithLimit(request, maxBytes) {
 		if (result.done) break;
 		totalSize += result.value.byteLength;
 		if (totalSize > maxBytes) {
-			await reader.cancel();
+			reader.cancel();
 			throw new Error("Request body too large");
 		}
 		chunks.push(result.value);
@@ -485,7 +486,10 @@ async function handleServerActionRscRequest(options) {
 	if (options.request.method.toUpperCase() !== "POST" || !options.actionId) return null;
 	const csrfResponse = validateCsrfOrigin(options.request, options.allowedOrigins);
 	if (csrfResponse) return csrfResponse;
-	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) return renderFetchActionBodyExceededResponse(options);
+	if (parseInt(options.request.headers.get("content-length") || "0", 10) > options.maxActionBodySize) {
+		if (options.request.body) options.request.body.cancel().catch(() => {});
+		return renderFetchActionBodyExceededResponse(options);
+	}
 	try {
 		let action;
 		if (options.contentType.startsWith("multipart/form-data")) {

package/dist/server/app-ssr-entry.d.ts

@@ -1,4 +1,4 @@
-import { NavigationContext } from "../shims/navigation.js";
+import { NavigationContext } from "../shims/navigation-context-state.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppSsrRenderResult } from "./app-page-stream.js";
 import { ReactFormState } from "react-dom/client";

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

@@ -1,12 +1,13 @@
 import "./server-globals.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./request-pipeline.js";
-import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { isPprFallbackShellAbortError } from "../shims/ppr-fallback-shell.js";
 import { AppRouterContext } from "../shims/internal/app-router-context.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
-import { ServerInsertedHTMLContext, appRouterInstance, clearServerInsertedHTML, getBfcacheIdMapContext, renderServerInsertedHTML, setNavigationContext, useServerInsertedHTML } from "../shims/navigation.js";
+import { ServerInsertedHTMLContext, clearServerInsertedHTML, getBfcacheIdMapContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "../shims/navigation-context-state.js";
+import "../shims/navigation-server.js";
 import { runWithNavigationContext } from "../shims/navigation-state.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createInlineScriptTag, createNonceAttribute, escapeHtmlAttr, safeJsonStringify } from "./html.js";
@@ -15,13 +16,15 @@ import DefaultGlobalError from "../shims/default-global-error.js";
 import { BfcacheStateKeyMapContext, ElementsContext, Slot } from "../shims/slot.js";
 import { createSsrErrorMetaRenderer } from "./app-ssr-error-meta.js";
 import { createNavigationRuntimeRscMetadataScript, createRscEmbedTransform, createTickBufferedTransform } from "./app-ssr-stream.js";
-import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
-import { runWithRootParamsScope } from "../shims/root-params.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-browser-state.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap } from "./app-bfcache-identity.js";
 import { RSC_FORM_STATE_GLOBAL } from "./app-browser-hydration.js";
 import { createClientReferencePreloader } from "./app-client-reference-preloader.js";
-import { deferUntilStreamConsumed } from "./app-page-stream.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { runWithRootParamsScope } from "../shims/root-params.js";
+import { BeforeInteractiveContext } from "../shims/before-interactive-context.js";
+import { renderBeforeInteractiveInlineScripts } from "./before-interactive-head.js";
 import { createInitialDevServerErrorScript } from "./dev-initial-server-error.js";
+import { ssrAppRouterInstance } from "./app-ssr-router-instance.js";
 import { Fragment, createElement, use } from "react";
 import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
 import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
@@ -107,35 +110,6 @@ function renderInsertedHtml(insertedElements) {
 	} catch {}
 	return insertedHTML;
 }
-/**
-* Render captured `<Script strategy="beforeInteractive">` inline scripts to
-* HTML, ready to splice immediately after `<head ...>` opens. Each entry has
-* already had its inline content escaped via `escapeInlineContent(..., "script")`
-* inside the Script shim, so this function only quotes the attributes that
-* actually go on the tag (id, nonce, plus the residual passthroughs).
-*
-* Keeping this function colocated with the rest of the head-injection
-* helpers makes it obvious where the boundary is: anything passed through
-* here is being concatenated directly into HTML; treat the inputs
-* accordingly.
-*/
-const VALID_ATTR_NAME = /^[a-zA-Z][\w.-]*$/;
-function renderBeforeInteractiveInlineScripts(scripts) {
-	if (scripts.length === 0) return "";
-	let html = "";
-	for (const script of scripts) {
-		let attrs = "";
-		if (script.id) attrs += ` id="${escapeHtmlAttr(script.id)}"`;
-		attrs += createNonceAttribute(script.nonce);
-		if (script.attributes) for (const [key, value] of Object.entries(script.attributes)) {
-			if (!VALID_ATTR_NAME.test(key)) continue;
-			if (value === true) attrs += ` ${key}`;
-			else if (typeof value === "string") attrs += ` ${key}="${escapeHtmlAttr(value)}"`;
-		}
-		html += `<script${attrs}>${script.innerHTML}<\/script>`;
-	}
-	return html;
-}
 function renderFontHtml(fontData, nonce, options = {}) {
 	if (!fontData) return "";
 	let fontHTML = "";
@@ -220,8 +194,8 @@ async function handleSsr(rscStream, navContext, fontData, options) {
 					return BfcacheIdMapContext ? createElement(BfcacheIdMapContext.Provider, { value: createInitialBfcacheIdMap(elements) }, stateKeyTree) : stateKeyTree;
 				}
 				const flightRootElement = createElement(VinextFlightRoot);
-				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouterInstance }, flightRootElement) : flightRootElement;
-				const ssrTree = ServerInsertedHTMLContext ? createElement(ServerInsertedHTMLContext.Provider, { value: useServerInsertedHTML }, root) : root;
+				const root = AppRouterContext ? createElement(AppRouterContext.Provider, { value: ssrAppRouterInstance }, flightRootElement) : flightRootElement;
+				const ssrTree = ServerInsertedHTMLContext ? createElement(ServerInsertedHTMLContext.Provider, { value: registerServerInsertedHTMLCallback }, root) : root;
 				const beforeInteractiveInlineScripts = [];
 				const registerBeforeInteractiveInlineScript = (script) => {
 					beforeInteractiveInlineScripts.push(script);

package/dist/server/app-ssr-router-instance.d.ts

@@ -0,0 +1,6 @@
+import { AppRouterInstance } from "../shims/internal/app-router-context.js";
+
+//#region src/server/app-ssr-router-instance.d.ts
+declare const ssrAppRouterInstance: AppRouterInstance;
+//#endregion
+export { ssrAppRouterInstance };