vinext 0.1.8 → 0.2.1

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

@@ -1,7 +1,8 @@
 import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.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 { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { ACTION_REVALIDATED_HEADER } from "./headers.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 } from "./request-pipeline.js";
@@ -10,18 +11,20 @@ import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.
 import { mergeRewriteQuery } from "../utils/query.js";
 import { getScriptNonceFromHeaderSources } from "./csp.js";
 import { normalizeDefaultLocalePathname } from "./pages-i18n.js";
+import { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.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 { buildNextDataNotFoundResponse, normalizePagesDataRequest } from "./pages-data-route.js";
+import { parseNextHttpErrorDigest } from "./next-error-digest.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 { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
+import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.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 { runWithPrerenderWorkUnit } from "./prerender-work-unit-setup.js";
@@ -53,8 +56,8 @@ function createMissingServerActionResponse(options, actionId) {
 	options.clearRequestContext();
 	return createServerActionNotFoundResponse();
 }
-function redirectDestinationWithBasePath(destination, basePath) {
-	if (!basePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
+function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
+	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
 	return basePath + destination;
 }
 async function applyRewrite(options, cleanPathname) {
@@ -111,15 +114,22 @@ function requestWithoutRscSuffix(request) {
 	url.pathname = pathname;
 	return cloneRequestWithUrl(request.body ? request.clone() : request, url.toString());
 }
-async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest) {
+async function handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, isMiddlewareDataRequest, pagesDataRequest) {
 	const handlerStart = process.env.NODE_ENV !== "production" ? performance.now() : 0;
 	if (process.env.NODE_ENV !== "production") {
 		const originBlock = options.validateDevRequestOrigin?.(request);
 		if (originBlock) return originBlock;
 	}
-	const normalized = normalizeRscRequest(request, options.basePath);
+	const canHandleOutsideBasePath = Boolean(options.runMiddleware) || [
+		...options.configRedirects,
+		...options.configRewrites.beforeFiles,
+		...options.configRewrites.afterFiles,
+		...options.configRewrites.fallback,
+		...options.configHeaders
+	].some((rule) => rule.basePath === false);
+	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath);
 	if (normalized instanceof Response) return normalized;
-	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest } = normalized;
+	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	let resolvedUrl = cleanPathname + url.search;
 	const originalResolvedUrl = resolvedUrl;
@@ -127,7 +137,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const canonicalPathname = cleanPathname;
 	const basePathState = {
 		basePath: options.basePath,
-		hadBasePath: true
+		hadBasePath
 	};
 	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
 		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
@@ -142,26 +152,22 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	const trailingSlashRedirect = normalizeTrailingSlash(pathname, options.basePath, options.trailingSlash, url.search);
+	const trailingSlashRedirect = normalizeTrailingSlash(pathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
 	if (trailingSlashRedirect) return trailingSlashRedirect;
 	const matchPathname = (p) => normalizeDefaultLocalePathname(p, options.i18nConfig, { hostname: url.hostname });
 	const redirect = matchRedirect(matchPathname(stripRscSuffix(pathname)), options.configRedirects, preMiddlewareRequestContext, basePathState);
 	if (redirect) {
-		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath));
+		const destination = sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
 		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 }
 		});
 	}
-	const rscCacheBustingRedirect = await resolveInvalidRscCacheBustingRequest({
+	const rscCacheBustingRedirect = hadBasePath ? await resolveInvalidRscCacheBustingRequest({
 		isRscRequest,
 		request
-	});
+	}) : null;
 	if (rscCacheBustingRedirect) return rscCacheBustingRedirect;
 	const normalizedUserlandRequest = requestWithoutRscSuffix(request);
 	const userlandRequest = requestWithoutRscCacheBustingSearchParam(normalizedUserlandRequest);
@@ -171,11 +177,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		status: null
 	};
 	let didMiddlewareRewrite = false;
+	let didMiddlewareRewritePathname = false;
 	if (options.runMiddleware) {
 		const middlewareResult = await options.runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
-			isDataRequest,
+			hadBasePath,
+			isDataRequest: isMiddlewareDataRequest,
 			request: userlandRequest
 		});
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
@@ -185,12 +193,21 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
-		didMiddlewareRewrite = cleanPathname !== normalized.cleanPathname;
+		didMiddlewareRewrite = middlewareResult.rewritten;
+		didMiddlewareRewritePathname = cleanPathname !== normalized.cleanPathname;
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
 		resolvedUrl = cleanPathname + url.search;
 	}
 	const scriptNonce = getScriptNonceFromHeaderSources(request.headers, middlewareContext.headers);
 	const postMiddlewareRequestContext = buildPostMwRequestContext(userlandRequest);
+	let filesystemRouteEligible = hadBasePath || didMiddlewareRewrite;
+	const validateClaimedOutsideBasePathRsc = async () => {
+		if (hadBasePath || !filesystemRouteEligible) return null;
+		return resolveInvalidRscCacheBustingRequest({
+			isRscRequest,
+			request
+		});
+	};
 	for (const rewrite of options.configRewrites.beforeFiles) {
 		const beforeFilesRewrite = await applyRewrite({
 			basePathState,
@@ -203,14 +220,60 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (beforeFilesRewrite) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
 		}
 	}
-	if (isImageOptimizationPath(cleanPathname)) {
+	const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+	if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
+	const actionId = request.headers.get("x-rsc-action") ?? request.headers.get("next-action");
+	const isPostRequest = request.method.toUpperCase() === "POST";
+	const contentType = request.headers.get("content-type") || "";
+	const isProgressiveActionRequest = isPostRequest && !actionId && contentType.startsWith("multipart/form-data");
+	let resolvedLateRewritesForAction = false;
+	if (!filesystemRouteEligible && (actionId || isProgressiveActionRequest)) {
+		let actionMatch = null;
+		for (const rewrite of options.configRewrites.afterFiles) {
+			const rewritten = await applyRewrite({
+				basePathState,
+				clearRequestContext: options.clearRequestContext,
+				request: normalizedUserlandRequest,
+				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				rewrites: [rewrite]
+			}, matchPathname(cleanPathname));
+			if (rewritten instanceof Response) return rewritten;
+			if (!rewritten) continue;
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
+			actionMatch = options.matchRoute(cleanPathname);
+			if (actionMatch) break;
+		}
+		if (!actionMatch) for (const rewrite of options.configRewrites.fallback) {
+			const rewritten = await applyRewrite({
+				basePathState,
+				clearRequestContext: options.clearRequestContext,
+				request: normalizedUserlandRequest,
+				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				rewrites: [rewrite]
+			}, matchPathname(cleanPathname));
+			if (rewritten instanceof Response) return rewritten;
+			if (!rewritten) continue;
+			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
+			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			filesystemRouteEligible = true;
+			actionMatch = options.matchRoute(cleanPathname);
+			if (actionMatch) break;
+		}
+		resolvedLateRewritesForAction = filesystemRouteEligible;
+	}
+	const lateActionRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+	if (lateActionRscCacheBustingRedirect) return lateActionRscCacheBustingRedirect;
+	if (filesystemRouteEligible && isImageOptimizationPath(cleanPathname)) {
 		const imageRedirect = resolveDevImageRedirect(url, [...options.imageConfig?.deviceSizes ?? DEFAULT_DEVICE_SIZES, ...options.imageConfig?.imageSizes ?? DEFAULT_IMAGE_SIZES], options.imageConfig?.qualities, { isDev: options.isDev });
 		if (!imageRedirect) return new Response("Invalid image optimization parameters", { status: 400 });
 		return Response.redirect(new URL(imageRedirect, url.origin).href, 302);
 	}
-	if (options.handleMetadataRouteRequest) {
+	if (filesystemRouteEligible && options.handleMetadataRouteRequest) {
 		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
 		if (metadataRouteResponse) {
 			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
@@ -223,13 +286,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 		}
 	}
-	const publicFileResponse = resolvePublicFileRoute({
+	const publicFileResponse = filesystemRouteEligible ? resolvePublicFileRoute({
 		cleanPathname,
 		middlewareContext,
 		pathname,
 		publicFiles: options.publicFiles,
 		request
-	});
+	}) : null;
 	if (publicFileResponse) {
 		options.clearRequestContext();
 		return publicFileResponse;
@@ -243,13 +306,22 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
-	const preActionMatch = options.matchRoute(cleanPathname);
+	const preActionMatch = filesystemRouteEligible ? options.matchRoute(cleanPathname) : null;
 	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 isPostRequest = request.method.toUpperCase() === "POST";
+	if (pagesDataRequest && didMiddlewareRewritePathname && preActionMatch) {
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		headers.set("content-type", "application/json");
+		headers.set("x-nextjs-rewrite", resolvedUrl);
+		options.clearRequestContext();
+		return new Response("{}", { headers });
+	}
+	if (!filesystemRouteEligible && isPostRequest && actionId) {
+		options.clearRequestContext();
+		return notFoundResponse();
+	}
 	let progressiveActionResult = null;
-	if (isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
+	if (filesystemRouteEligible && isPostRequest && contentType.startsWith("multipart/form-data") && !actionId) {
 		if (options.handleProgressiveActionRequest) progressiveActionResult = await options.handleProgressiveActionRequest({
 			actionId,
 			cleanPathname,
@@ -266,7 +338,11 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const failedProgressiveActionResult = progressiveActionFormState && "actionError" in progressiveActionFormState ? progressiveActionFormState : null;
 	const actionFailed = failedProgressiveActionResult !== null;
 	const actionError = failedProgressiveActionResult?.actionError;
-	const serverActionResponse = isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
+	const actionErrorDigest = actionError && typeof actionError === "object" && "digest" in actionError ? String(actionError.digest) : null;
+	const actionHttpFallbackStatus = actionErrorDigest ? parseNextHttpErrorDigest(actionErrorDigest)?.status ?? null : null;
+	const normalizedProgressiveActionError = actionHttpFallbackStatus === null || actionHttpFallbackStatus === 404 ? actionError : { digest: "NEXT_NOT_FOUND" };
+	if (actionFailed && middlewareContext.status === null && actionHttpFallbackStatus === null) middlewareContext.status = 500;
+	const serverActionResponse = filesystemRouteEligible && isPostRequest && actionId && options.handleServerActionRequest ? await options.handleServerActionRequest({
 		actionId,
 		cleanPathname,
 		contentType,
@@ -278,12 +354,13 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
-	if (isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
+	if (filesystemRouteEligible && isPostRequest && actionId && !options.handleServerActionRequest) return createMissingServerActionResponse(options, actionId);
 	let match = preActionMatch;
 	const renderPagesForMatchKind = async (matchKind) => {
+		if (!filesystemRouteEligible) return null;
 		const response = match === null || match.route.isDynamic ? await options.renderPagesFallback?.({
 			appRouteMatch: match ?? null,
-			allowRscDocumentFallback: didMiddlewareRewrite,
+			allowRscDocumentFallback: didMiddlewareRewritePathname,
 			isDataRequest,
 			isRscRequest,
 			matchKind,
@@ -307,7 +384,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return staticPagesFallbackResponse;
 	}
-	if (!match || match.route.isDynamic) for (const rewrite of options.configRewrites.afterFiles) {
+	if (!resolvedLateRewritesForAction && (!match || match.route.isDynamic)) for (const rewrite of options.configRewrites.afterFiles) {
 		const afterFilesRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
@@ -319,6 +396,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!afterFilesRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
+		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -337,7 +417,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		options.clearRequestContext();
 		return dynamicPagesFallbackResponse;
 	}
-	if (!match) for (const rewrite of options.configRewrites.fallback) {
+	if (!resolvedLateRewritesForAction && !match) for (const rewrite of options.configRewrites.fallback) {
 		const fallbackRewrite = await applyRewrite({
 			basePathState,
 			clearRequestContext: options.clearRequestContext,
@@ -349,6 +429,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (!fallbackRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		filesystemRouteEligible = true;
+		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
+		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
 		match = options.matchRoute(cleanPathname);
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
@@ -362,8 +445,24 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		}
 		if (match) break;
 	}
+	if (!filesystemRouteEligible) {
+		options.clearRequestContext();
+		const headers = new Headers();
+		mergeMiddlewareResponseHeaders(headers, middlewareContext.headers);
+		return notFoundResponse({ headers });
+	}
 	if (pagesDataRequest) {
 		options.clearRequestContext();
+		if (options.runMiddleware && (middlewareContext.status === null || middlewareContext.status === 200 || middlewareContext.status === 404)) {
+			const response = buildNextDataNotFoundResponse();
+			const headers = new Headers(response.headers);
+			headers.set("x-nextjs-matched-path", matchPathname(canonicalPathname));
+			if (resolvedUrl !== originalResolvedUrl) headers.set("x-nextjs-rewrite", resolvedUrl);
+			return new Response("{}", {
+				status: 200,
+				headers
+			});
+		}
 		return buildNextDataNotFoundResponse();
 	}
 	if (!match) {
@@ -386,11 +485,19 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	const { route, params } = match;
 	if (options.ensureRouteLoaded) await options.ensureRouteLoaded(route);
+	const resolvedSearchParams = getResolvedSearchParams();
+	if (isRouteTreePrefetchRequest(request) && !route.routeHandler) {
+		const response = await createRouteTreePrefetchResponse(route, {
+			buildId: options.buildId,
+			prefetchInlining: options.prefetchInlining
+		});
+		options.clearRequestContext();
+		return applyMiddlewareContextToResponse(response, middlewareContext);
+	}
 	const prerenderRouteParamsMatch = matchPrerenderRouteParamsPayload(readTrustedPrerenderRouteParams(request), route.pattern, params);
 	const prerenderRouteParams = prerenderRouteParamsMatch?.params ?? null;
 	const isPrerenderFallbackShell = prerenderRouteParamsMatch?.kind === "fallback-shell";
 	const renderParams = prerenderRouteParams ?? params;
-	const resolvedSearchParams = getResolvedSearchParams();
 	let runtimeFallbackShells = [];
 	if (options.createPprFallbackShells && request.method === "GET" && !isRscRequest && !isPrerenderFallbackShell && route.params) runtimeFallbackShells = options.createPprFallbackShells({
 		params: route.params,
@@ -425,7 +532,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		cleanPathname,
 		displayPathname: canonicalPathname,
 		formState,
-		actionError,
+		actionError: normalizedProgressiveActionError,
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
@@ -444,6 +551,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		staticParamsValidationParams: prerenderRouteParams === null || isPrerenderFallbackShell ? void 0 : params,
 		rootParams,
 		request,
+		renderedPathAndSearch: resolvedUrl,
 		route,
 		scriptNonce,
 		searchParams: resolvedSearchParams,
@@ -489,19 +597,20 @@ function createAppRscHandler(options) {
 		options.registerCacheAdapters();
 		await options.ensureInstrumentation?.();
 		const mwCtx = rawRequest.headers.get(VINEXT_MW_CTX_HEADER);
-		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;
+		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId, "", typeof options.runMiddleware === "function" && options.trailingSlash) : null;
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
-		const isDataRequest = hasDataRequestHeader || pagesDataNormalization?.isDataReq === true;
+		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(rawRequest);
+		const isTrustedSpeculativePrerender = process.env.VINEXT_PRERENDER === "1" && rawRequest.headers.get("x-vinext-prerender-secret") !== null && rawRequest.headers.get("x-vinext-prerender-speculative") === "1";
 		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);
+		if (isTrustedSpeculativePrerender) filteredHeaders.set(VINEXT_PRERENDER_SPECULATIVE_HEADER, "1");
 		let appRequest = rawRequest;
 		if (pagesDataNormalization?.isDataReq) {
 			const appRequestUrl = new URL(pagesDataNormalization.request.url);
@@ -520,7 +629,7 @@ function createAppRscHandler(options) {
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
 			try {
-				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isDataRequest, pagesDataRequest);
+				response = await handleAppRscRequest(options, request, preMiddlewareRequestContext, isPagesDataRequest, isPagesDataRequest, pagesDataRequest);
 			} catch (error) {
 				if (process.env.NODE_ENV !== "production") flattenErrorCauses(error);
 				throw error;

package/dist/server/app-rsc-render-mode.d.ts

@@ -1,6 +1,7 @@
 //#region src/server/app-rsc-render-mode.d.ts
-type AppRscRenderMode = "navigation" | "prefetch-loading-shell" | "refresh-preserve-ui" | "action-rerender-preserve-ui";
+type AppRscRenderMode = "navigation" | "prefetch-dynamic-shell" | "prefetch-loading-shell" | "refresh-preserve-ui" | "action-rerender-preserve-ui";
 declare const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+declare const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 declare const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
 declare const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
 declare const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
@@ -8,4 +9,4 @@ declare function shouldSuppressLoadingBoundaries(mode: AppRscRenderMode): boolea
 declare function getRscRenderModeCacheVariant(mode: AppRscRenderMode): string | null;
 declare function parseAppRscRenderMode(value: string | null): AppRscRenderMode;
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
+export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, AppRscRenderMode, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };

package/dist/server/app-rsc-render-mode.js

@@ -1,5 +1,6 @@
 //#region src/server/app-rsc-render-mode.ts
 const APP_RSC_RENDER_MODE_NAVIGATION = "navigation";
+const APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL = "prefetch-dynamic-shell";
 const APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL = "prefetch-loading-shell";
 const APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI = "refresh-preserve-ui";
 const APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI = "action-rerender-preserve-ui";
@@ -10,11 +11,13 @@ function shouldUsePreserveUiCacheVariant(mode) {
 	return shouldSuppressLoadingBoundaries(mode);
 }
 function getRscRenderModeCacheVariant(mode) {
+	if (mode === "prefetch-dynamic-shell") return "prefetch-dynamic-shell";
 	if (mode === "prefetch-loading-shell") return "prefetch-loading-shell";
 	return shouldUsePreserveUiCacheVariant(mode) ? "preserve-ui" : null;
 }
 function parseAppRscRenderMode(value) {
 	switch (value) {
+		case APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL;
 		case APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL: return APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
 		case APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI: return APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI;
 		case APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI: return APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI;
@@ -22,4 +25,4 @@ function parseAppRscRenderMode(value) {
 	}
 }
 //#endregion
-export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };
+export { APP_RSC_RENDER_MODE_ACTION_RERENDER_PRESERVE_UI, APP_RSC_RENDER_MODE_NAVIGATION, APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, APP_RSC_RENDER_MODE_REFRESH_PRESERVE_UI, getRscRenderModeCacheVariant, parseAppRscRenderMode, shouldSuppressLoadingBoundaries };

package/dist/server/app-rsc-request-normalization.d.ts

@@ -11,7 +11,8 @@ type NormalizedRscRequest = {
   interceptionContextHeader: string | null; /** Normalized x-vinext-mounted-slots header (deduplicated, sorted). null when absent or blank. */
   mountedSlotsHeader: string | null; /** Semantic RSC payload mode. HTML requests always normalize to "navigation". */
   renderMode: AppRscRenderMode; /** Parsed ClientReuseManifest hint. Verification and skip authorization happen later. */
-  clientReuseManifest: ClientReuseManifestParseResult;
+  clientReuseManifest: ClientReuseManifestParseResult; /** Whether the incoming pathname included the configured basePath. */
+  hadBasePath: boolean;
 };
 /**
  * Normalize an App Router RSC request.
@@ -30,10 +31,9 @@ type NormalizedRscRequest = {
  *   4. Collapse double-slashes, resolve `.` and `..` segments (normalizePath)
  *   5. basePath check + strip — 404 when pathname lacks the basePath prefix.
  *      `/__vinext/` bypasses this for internal prerender endpoints.
- *   6. RSC detection: `.rsc` suffix, or Next-style `RSC: 1` plus the internal
- *      `_rsc` cache-busting query. The header alone does not select payload
- *      rendering at the canonical HTML URL, so caches that ignore Vary cannot
- *      store Flight responses under HTML URLs.
+ *   6. RSC detection: `.rsc` suffix or Next-style `RSC: 1`. The internal
+ *      `_rsc` cache-busting query is validated separately so full-route Flight
+ *      responses do not share the canonical HTML URL in caches that ignore Vary.
  *   7. cleanPathname — pathname with `.rsc` suffix stripped
  *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
  *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
@@ -43,6 +43,6 @@ type NormalizedRscRequest = {
  * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
  *          or a NormalizedRscRequest for valid requests.
  */
-declare function normalizeRscRequest(request: Request, basePath: string): Response | NormalizedRscRequest;
+declare function normalizeRscRequest(request: Request, basePath: string, allowOutsideBasePath?: boolean): Response | NormalizedRscRequest;
 //#endregion
 export { NormalizedRscRequest, normalizeMountedSlotsHeader, normalizeRscRequest };

package/dist/server/app-rsc-request-normalization.js

@@ -27,10 +27,9 @@ import { normalizeInterceptionContextHeader } from "./app-interception-context-h
 *   4. Collapse double-slashes, resolve `.` and `..` segments (normalizePath)
 *   5. basePath check + strip — 404 when pathname lacks the basePath prefix.
 *      `/__vinext/` bypasses this for internal prerender endpoints.
-*   6. RSC detection: `.rsc` suffix, or Next-style `RSC: 1` plus the internal
-*      `_rsc` cache-busting query. The header alone does not select payload
-*      rendering at the canonical HTML URL, so caches that ignore Vary cannot
-*      store Flight responses under HTML URLs.
+*   6. RSC detection: `.rsc` suffix or Next-style `RSC: 1`. The internal
+*      `_rsc` cache-busting query is validated separately so full-route Flight
+*      responses do not share the canonical HTML URL in caches that ignore Vary.
 *   7. cleanPathname — pathname with `.rsc` suffix stripped
 *   8. Sanitize X-Vinext-Interception-Context — strip null bytes (header injection)
 *   9. Normalize x-vinext-mounted-slots — dedup and sort for canonical cache keys
@@ -40,7 +39,7 @@ import { normalizeInterceptionContextHeader } from "./app-interception-context-h
 * @returns A 400 or 404 Response for invalid or out-of-scope inputs,
 *          or a NormalizedRscRequest for valid requests.
 */
-function normalizeRscRequest(request, basePath) {
+function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 	const url = new URL(request.url);
 	const protoGuard = guardProtocolRelativeUrl(url.pathname);
 	if (protoGuard) return protoGuard;
@@ -51,17 +50,20 @@ function normalizeRscRequest(request, basePath) {
 		return badRequestResponse();
 	}
 	let pathname = normalizePath(decoded);
+	let hadBasePath = true;
 	if (basePath) {
-		if (!hasBasePath(pathname, basePath) && !pathname.startsWith("/__vinext/")) return notFoundResponse();
-		pathname = stripBasePath(pathname, basePath);
+		hadBasePath = hasBasePath(pathname, basePath);
+		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath) return notFoundResponse();
+		if (hadBasePath) pathname = stripBasePath(pathname, basePath);
 	}
-	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1" && url.searchParams.has("_rsc");
+	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1";
 	const cleanPathname = stripRscSuffix(pathname);
 	const interceptionContextHeader = normalizeInterceptionContextHeader(request.headers.get(VINEXT_INTERCEPTION_CONTEXT_HEADER));
 	const mountedSlotsHeader = normalizeMountedSlotsHeader(request.headers.get(VINEXT_MOUNTED_SLOTS_HEADER));
 	const renderMode = isRscRequest ? parseAppRscRenderMode(request.headers.get(VINEXT_RSC_RENDER_MODE_HEADER)) : APP_RSC_RENDER_MODE_NAVIGATION;
 	return {
 		clientReuseManifest: isRscRequest ? parseClientReuseManifestHeader(request.headers.get(VINEXT_CLIENT_REUSE_MANIFEST_HEADER)) : { kind: "absent" },
+		hadBasePath,
 		url,
 		pathname,
 		cleanPathname,

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

@@ -6,6 +6,7 @@ type AppRouteSegmentConfigModule = {
   dynamic?: unknown;
   dynamicParams?: unknown;
   fetchCache?: unknown;
+  generateStaticParams?: unknown;
   revalidate?: unknown;
   runtime?: unknown;
   unstable_dynamicStaleTime?: unknown;
@@ -18,11 +19,21 @@ type EffectiveAppPageSegmentConfig = {
   revalidateSeconds: number | null;
   runtime?: "edge" | "experimental-edge" | "nodejs";
 };
+type ParallelAppPageSegmentConfigBranch = {
+  configLayouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  layout?: AppRouteSegmentConfigModule | null;
+  page?: AppRouteSegmentConfigModule | null;
+  routeSegments?: readonly string[] | null;
+};
 type ResolveAppPageSegmentConfigOptions = {
   layouts?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  layoutTreePositions?: readonly number[];
   page?: AppRouteSegmentConfigModule | null;
+  parallelBranches?: readonly (ParallelAppPageSegmentConfigBranch | null | undefined)[];
   parallelPages?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
   parallelSegments?: readonly (AppRouteSegmentConfigModule | null | undefined)[];
+  routeSegments?: readonly string[];
 };
 /**
  * Resolve the route segment config that applies to an App page route.