vinext 1.0.0-beta.1 → 1.0.0-beta.3

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

@@ -1,11 +1,13 @@
-import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, closeAfterResponseWithBody, 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 { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER, VINEXT_REVALIDATE_HOST_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 { requestContextFromRequest } from "../config/request-context.js";
+import { isExternalUrl } from "../utils/external-url.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { applyConfigHeadersToResponse, cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
+import { cloneRequestWithHeaders, cloneRequestWithUrl, filterInternalHeaders, normalizeTrailingSlash, resolvePublicFileRoute } from "./request-pipeline.js";
+import { isOnDemandRevalidateRequest } from "./isr-cache.js";
 import { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -19,17 +21,20 @@ import "./app-page-response.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 { flattenErrorCauses } from "../utils/error-cause.js";
-import { pickRootParams, setRootParams } from "../shims/root-params.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 { pickRootParams, setRootParams } from "../shims/root-params.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";
 //#region src/server/app-rsc-handler.ts
 const STATIC_METADATA_CONFIG_HEADER_OVERRIDES = /* @__PURE__ */ new Set(["cache-control"]);
+const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
+const HAS_CONFIG_REDIRECTS = process.env.__VINEXT_HAS_CONFIG_REDIRECTS !== "false";
+const HAS_CONFIG_REWRITES = process.env.__VINEXT_HAS_CONFIG_REWRITES !== "false";
 function applyMiddlewareContextToResponse(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const headers = new Headers(response.headers);
@@ -61,12 +66,14 @@ function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
 	return basePath + destination;
 }
 async function applyRewrite(options, cleanPathname) {
-	if (!options.rewrites.length) return null;
-	const rewritten = matchRewrite(cleanPathname, options.rewrites, options.requestContext, options.basePathState);
+	if (!HAS_CONFIG_REWRITES || !options.rewrites.length) return null;
+	const sourcePathname = options.paramsPathname ?? cleanPathname;
+	const configMatchers = await import("../config/config-matchers.js");
+	const rewritten = configMatchers.matchRewrite(sourcePathname, options.rewrites, options.requestContext, options.basePathState, options.paramsPathname);
 	if (!rewritten) return null;
 	if (isExternalUrl(rewritten)) {
 		options.clearRequestContext();
-		return proxyExternalRequest(options.request, rewritten);
+		return configMatchers.proxyExternalRequest(options.request, rewritten);
 	}
 	return rewritten;
 }
@@ -81,9 +88,10 @@ function requestContextForResolvedUrl(requestContext, resolvedUrl, baseUrl) {
 function pathnameForResolvedUrl(resolvedUrl) {
 	return resolvedUrl.split("#", 1)[0].split("?", 1)[0];
 }
-function applyConfigHeadersToMiddlewareRedirect(response, options) {
+async function applyConfigHeadersToMiddlewareRedirect(response, options) {
 	if (response.status < 300 || response.status >= 400) return response;
-	if (!options.configHeaders.length) return response;
+	if (!HAS_CONFIG_HEADERS || !options.configHeaders.length) return response;
+	const { applyConfigHeadersToResponse } = await import("./config-headers.js");
 	const headers = new Headers();
 	applyConfigHeadersToResponse(headers, {
 		configHeaders: options.configHeaders,
@@ -130,6 +138,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const normalized = normalizeRscRequest(request, options.basePath, canHandleOutsideBasePath);
 	if (normalized instanceof Response) return normalized;
 	const { url, isRscRequest, interceptionContextHeader, mountedSlotsHeader, renderMode, clientReuseManifest, hadBasePath } = normalized;
+	const { requestCleanPathname } = normalized;
 	let { pathname, cleanPathname } = normalized;
 	let resolvedUrl = cleanPathname + url.search;
 	const originalResolvedUrl = resolvedUrl;
@@ -139,6 +148,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		basePath: options.basePath,
 		hadBasePath
 	};
+	let cleanPathnameIsRequestPathname = true;
+	const matchCleanPathname = () => cleanPathnameIsRequestPathname && options.matchRequestRoute ? options.matchRequestRoute(requestCleanPathname) : options.matchRoute(cleanPathname);
 	if (pathname === "/__vinext/prerender/static-params" || pathname === "/__vinext/prerender/pages-static-paths") {
 		const { handleAppPrerenderEndpoint } = await import("./app-prerender-endpoints.js");
 		const prerenderEndpointResponse = await handleAppPrerenderEndpoint(request, {
@@ -152,13 +163,15 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	const trailingSlashRedirect = normalizeTrailingSlash(pathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
+	const trailingSlashRedirect = normalizeTrailingSlash(requestCleanPathname, 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, hadBasePath));
-		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : preserveRedirectDestinationQuery(destination, url.search);
+	const redirectPathname = matchPathname(requestCleanPathname);
+	const configMatchers = HAS_CONFIG_REDIRECTS && options.configRedirects.length ? await import("../config/config-matchers.js") : null;
+	const redirect = configMatchers ? configMatchers.matchRedirect(redirectPathname, options.configRedirects, preMiddlewareRequestContext, basePathState) : null;
+	if (configMatchers && redirect) {
+		const destination = configMatchers.sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : configMatchers.preserveRedirectDestinationQuery(destination, url.search);
 		return new Response(null, {
 			status: redirect.permanent ? 308 : 307,
 			headers: { Location: location }
@@ -178,8 +191,9 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	};
 	let didMiddlewareRewrite = false;
 	let didMiddlewareRewritePathname = false;
-	if (options.runMiddleware) {
-		const middlewareResult = await options.runMiddleware({
+	const runMiddleware = isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate")) ? void 0 : options.runMiddleware;
+	if (runMiddleware) {
+		const middlewareResult = await runMiddleware({
 			cleanPathname,
 			context: middlewareContext,
 			hadBasePath,
@@ -189,11 +203,12 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		if (middlewareResult.kind === "response") return applyConfigHeadersToMiddlewareRedirect(middlewareResult.response, {
 			basePathState,
 			configHeaders: options.configHeaders,
-			pathname: matchPathname(cleanPathname),
+			pathname: matchPathname(requestCleanPathname),
 			requestContext: preMiddlewareRequestContext
 		});
 		cleanPathname = middlewareResult.cleanPathname;
 		didMiddlewareRewrite = middlewareResult.rewritten;
+		if (didMiddlewareRewrite || cleanPathname !== normalized.cleanPathname) cleanPathnameIsRequestPathname = false;
 		didMiddlewareRewritePathname = cleanPathname !== normalized.cleanPathname;
 		if (middlewareResult.search !== null) url.search = middlewareResult.search;
 		resolvedUrl = cleanPathname + url.search;
@@ -214,12 +229,14 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			clearRequestContext: options.clearRequestContext,
 			request: normalizedUserlandRequest,
 			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (beforeFilesRewrite instanceof Response) return beforeFilesRewrite;
 		if (beforeFilesRewrite) {
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, beforeFilesRewrite);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			cleanPathnameIsRequestPathname = false;
 			filesystemRouteEligible = true;
 		}
 	}
@@ -238,14 +255,16 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				clearRequestContext: options.clearRequestContext,
 				request: normalizedUserlandRequest,
 				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 				rewrites: [rewrite]
 			}, matchPathname(cleanPathname));
 			if (rewritten instanceof Response) return rewritten;
 			if (!rewritten) continue;
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			cleanPathnameIsRequestPathname = false;
 			filesystemRouteEligible = true;
-			actionMatch = options.matchRoute(cleanPathname);
+			actionMatch = matchCleanPathname();
 			if (actionMatch) break;
 		}
 		if (!actionMatch) for (const rewrite of options.configRewrites.fallback) {
@@ -254,14 +273,16 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 				clearRequestContext: options.clearRequestContext,
 				request: normalizedUserlandRequest,
 				requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+				paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 				rewrites: [rewrite]
 			}, matchPathname(cleanPathname));
 			if (rewritten instanceof Response) return rewritten;
 			if (!rewritten) continue;
 			resolvedUrl = mergeRewriteQuery(resolvedUrl, rewritten);
 			cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+			cleanPathnameIsRequestPathname = false;
 			filesystemRouteEligible = true;
-			actionMatch = options.matchRoute(cleanPathname);
+			actionMatch = matchCleanPathname();
 			if (actionMatch) break;
 		}
 		resolvedLateRewritesForAction = filesystemRouteEligible;
@@ -275,16 +296,17 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	if (filesystemRouteEligible && options.handleMetadataRouteRequest) {
 		const metadataRouteResponse = await options.handleMetadataRouteRequest(cleanPathname);
-		if (metadataRouteResponse) {
+		if (metadataRouteResponse && HAS_CONFIG_HEADERS && options.configHeaders.length) {
+			const { applyConfigHeadersToResponse } = await import("./config-headers.js");
 			applyConfigHeadersToResponse(metadataRouteResponse.headers, {
 				basePathState,
 				configHeaders: options.configHeaders,
 				overwriteExisting: STATIC_METADATA_CONFIG_HEADER_OVERRIDES,
-				pathname: matchPathname(cleanPathname),
+				pathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 				requestContext: preMiddlewareRequestContext
 			});
-			return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 		}
+		if (metadataRouteResponse) return applyMiddlewareContextToResponse(metadataRouteResponse, middlewareContext);
 	}
 	const publicFileResponse = filesystemRouteEligible ? resolvePublicFileRoute({
 		cleanPathname,
@@ -306,7 +328,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		searchParams: getResolvedSearchParams(),
 		params: {}
 	});
-	const preActionMatch = filesystemRouteEligible ? options.matchRoute(cleanPathname) : null;
+	const preActionMatch = filesystemRouteEligible ? matchCleanPathname() : null;
 	if (preActionMatch) setRootParams(pickRootParams(preActionMatch.params, preActionMatch.route.rootParamNames));
 	if (pagesDataRequest && didMiddlewareRewritePathname && preActionMatch) {
 		const headers = new Headers();
@@ -327,7 +349,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			cleanPathname,
 			contentType,
 			middlewareContext,
-			request
+			request,
+			routeMatch: preActionMatch
 		});
 		else if (preActionMatch?.route.__loadPage && !preActionMatch.route.__loadRouteHandler) return createMissingServerActionResponse(options, null);
 	}
@@ -351,6 +374,8 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		middlewareContext,
 		mountedSlotsHeader,
 		request,
+		routeMatch: preActionMatch,
+		routePathname: cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname,
 		searchParams: getResolvedSearchParams()
 	}) : null;
 	if (serverActionResponse) return serverActionResponse;
@@ -390,16 +415,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			clearRequestContext: options.clearRequestContext,
 			request: normalizedUserlandRequest,
 			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (afterFilesRewrite instanceof Response) return afterFilesRewrite;
 		if (!afterFilesRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, afterFilesRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		cleanPathnameIsRequestPathname = false;
 		filesystemRouteEligible = true;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
-		match = options.matchRoute(cleanPathname);
+		match = matchCleanPathname();
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
 			options.clearRequestContext();
@@ -423,16 +450,18 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 			clearRequestContext: options.clearRequestContext,
 			request: normalizedUserlandRequest,
 			requestContext: requestContextForResolvedUrl(postMiddlewareRequestContext, resolvedUrl, url),
+			paramsPathname: matchPathname(cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname),
 			rewrites: [rewrite]
 		}, matchPathname(cleanPathname));
 		if (fallbackRewrite instanceof Response) return fallbackRewrite;
 		if (!fallbackRewrite) continue;
 		resolvedUrl = mergeRewriteQuery(resolvedUrl, fallbackRewrite);
 		cleanPathname = pathnameForResolvedUrl(resolvedUrl);
+		cleanPathnameIsRequestPathname = false;
 		filesystemRouteEligible = true;
 		const claimedRscCacheBustingRedirect = await validateClaimedOutsideBasePathRsc();
 		if (claimedRscCacheBustingRedirect) return claimedRscCacheBustingRedirect;
-		match = options.matchRoute(cleanPathname);
+		match = matchCleanPathname();
 		const rewrittenStaticPagesResponse = await renderPagesForMatchKind("static");
 		if (rewrittenStaticPagesResponse) {
 			options.clearRequestContext();
@@ -453,7 +482,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	}
 	if (pagesDataRequest) {
 		options.clearRequestContext();
-		if (options.runMiddleware && (middlewareContext.status === null || middlewareContext.status === 200 || middlewareContext.status === 404)) {
+		if (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));
@@ -536,6 +565,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
+		interceptionPathname: cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname,
 		isProgressiveActionRender,
 		isRscRequest,
 		middlewareContext,
@@ -604,9 +634,11 @@ function createAppRscHandler(options) {
 		const pagesDataNormalization = options.renderPagesFallback && pagesDataCandidate ? normalizePagesDataRequest(pagesDataCandidate, options.buildId, "", typeof options.runMiddleware === "function" && options.trailingSlash) : null;
 		if (pagesDataNormalization?.notFoundResponse) return pagesDataNormalization.notFoundResponse;
 		const isPagesDataRequest = pagesDataNormalization?.isDataReq === true;
+		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
 		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);
+		const filteredHeaders = executionContext?.isInternalPagesRevalidation ? new Headers(rawRequest.headers) : filterInternalHeaders(rawRequest.headers);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		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);
@@ -619,12 +651,12 @@ function createAppRscHandler(options) {
 		}
 		const request = cloneRequestWithHeaders(appRequest, filteredHeaders);
 		const pagesDataRequest = pagesDataNormalization?.isDataReq ? cloneRequestWithHeaders(pagesDataCandidate, filteredHeaders) : null;
-		const executionContext = isExecutionContextLike(ctx) ? ctx : getRequestExecutionContext() ?? null;
-		return runWithRequestContext(createRequestContext({
+		const requestContext = createRequestContext({
 			headersContext: headersContextFromRequest(request, { draftModeSecret: options.draftModeSecret }),
 			executionContext,
 			unstableCacheRevalidation: "background"
-		}), () => runWithPrerenderWorkUnit(async () => {
+		});
+		const responsePromise = runWithRequestContext(requestContext, () => runWithPrerenderWorkUnit(async () => {
 			ensureFetchPatch();
 			const preMiddlewareRequestContext = requestContextFromRequest(request);
 			let response;
@@ -641,6 +673,14 @@ function createAppRscHandler(options) {
 				requestContext: preMiddlewareRequestContext
 			});
 		}, { route: () => new URL(request.url).pathname }));
+		let response;
+		try {
+			response = await responsePromise;
+		} catch (error) {
+			await closeAfterResponse(requestContext);
+			throw error;
+		}
+		return closeAfterResponseWithBody(response, requestContext);
 	};
 }
 //#endregion

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

@@ -1,12 +1,13 @@
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
-import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { normalizeMountedSlotsHeader } from "./app-mounted-slots-header.js";
 
 //#region src/server/app-rsc-request-normalization.d.ts
 type NormalizedRscRequest = {
   /** Parsed URL. Callers may mutate `url.search` after middleware runs. */url: URL; /** Normalized pathname with basePath stripped. Used for all internal routing. */
   pathname: string; /** Pathname with `.rsc` suffix removed. Used for route matching and navigation context. */
-  cleanPathname: string; /** True when the request targets a canonical `.rsc` payload URL. */
+  cleanPathname: string; /** Original encoded request pathname with basePath and `.rsc` removed. */
+  requestCleanPathname: string; /** True when the request targets a canonical `.rsc` payload URL. */
   isRscRequest: boolean; /** Sanitized X-Vinext-Interception-Context header (null bytes stripped). null when absent. */
   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". */

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

@@ -50,14 +50,19 @@ function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 		return badRequestResponse();
 	}
 	let pathname = normalizePath(decoded);
+	let requestPathname = url.pathname;
 	let hadBasePath = true;
 	if (basePath) {
-		hadBasePath = hasBasePath(pathname, basePath);
+		hadBasePath = hasBasePath(requestPathname, basePath);
 		if (!hadBasePath && !pathname.startsWith("/__vinext/") && !allowOutsideBasePath) return notFoundResponse();
-		if (hadBasePath) pathname = stripBasePath(pathname, basePath);
+		if (hadBasePath) {
+			pathname = stripBasePath(pathname, basePath);
+			requestPathname = stripBasePath(requestPathname, basePath);
+		}
 	}
 	const isRscRequest = pathname.endsWith(".rsc") || request.headers.get("RSC") === "1";
 	const cleanPathname = stripRscSuffix(pathname);
+	const requestCleanPathname = stripRscSuffix(requestPathname);
 	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;
@@ -67,6 +72,7 @@ function normalizeRscRequest(request, basePath, allowOutsideBasePath = false) {
 		url,
 		pathname,
 		cleanPathname,
+		requestCleanPathname,
 		isRscRequest,
 		interceptionContextHeader,
 		mountedSlotsHeader,

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

@@ -1,5 +1,5 @@
 import { NextHeader, NextI18nConfig } from "../config/next-config.js";
-import { RequestContext } from "../config/config-matchers.js";
+import { RequestContext } from "../config/request-context.js";
 
 //#region src/server/app-rsc-response-finalizer.d.ts
 type FinalizeAppRscResponseOptions = {
@@ -32,6 +32,6 @@ type FinalizeAppRscResponseOptions = {
  * headers that throw on mutation, and Next.js does not apply config headers
  * to redirects regardless.
  */
-declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Response;
+declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Promise<Response>;
 //#endregion
 export { finalizeAppRscResponse };

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

@@ -1,13 +1,11 @@
-import { normalizePathnameForRouteMatch } from "../routing/utils.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import "./headers.js";
-import { normalizePath } from "./normalize-path.js";
-import { applyConfigHeadersToResponse } from "./request-pipeline.js";
 import { applyCdnResponseHeaders } from "./cache-control.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
+const HAS_CONFIG_HEADERS = process.env.__VINEXT_HAS_CONFIG_HEADERS !== "false";
 /**
 * Apply App Router response finalization that must happen outside individual
 * route dispatchers.
@@ -20,7 +18,7 @@ import { mergeVaryHeader } from "./middleware-response-headers.js";
 * headers that throw on mutation, and Next.js does not apply config headers
 * to redirects regardless.
 */
-function finalizeAppRscResponse(response, request, options) {
+async function finalizeAppRscResponse(response, request, options) {
 	if (response.status >= 300 && response.status < 400) return response;
 	if (!response.headers.has("x-vinext-static-file")) {
 		const varyHeader = response.headers.get("Vary");
@@ -28,17 +26,13 @@ function finalizeAppRscResponse(response, request, options) {
 		else if (varyHeader !== VINEXT_RSC_VARY_HEADER) mergeVaryHeader(response.headers, VINEXT_RSC_VARY_HEADER);
 	}
 	if (!response.headers.has("Cache-Control")) applyCdnResponseHeaders(response.headers, { cacheControl: "" });
-	if (!options.configHeaders.length) return response;
+	if (!HAS_CONFIG_HEADERS || !options.configHeaders.length) return response;
 	const url = new URL(request.url);
-	let pathname;
-	try {
-		pathname = normalizePath(normalizePathnameForRouteMatch(url.pathname));
-	} catch {
-		pathname = url.pathname;
-	}
+	let pathname = url.pathname;
 	const hadBasePath = !options.basePath || hasBasePath(pathname, options.basePath);
 	pathname = stripBasePath(pathname, options.basePath);
 	const matchPathname = options.i18nConfig ? normalizeDefaultLocalePathname(pathname, options.i18nConfig, { hostname: url.hostname }) : pathname;
+	const { applyConfigHeadersToResponse } = await import("./config-headers.js");
 	applyConfigHeadersToResponse(response.headers, {
 		configHeaders: options.configHeaders,
 		pathname: matchPathname,

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

@@ -33,9 +33,16 @@ type AppRscInterceptForMatching = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
+  interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
+  notFound?: unknown;
+  __loadNotFound?: (() => Promise<unknown>) | null;
+  notFoundTreePosition?: number | null;
   params: readonly string[];
 };
 type AppRscSlotForMatching = {
@@ -50,14 +57,23 @@ type AppRscSiblingInterceptForMatching = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
+  interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
+  notFound?: unknown;
+  __loadNotFound?: (() => Promise<unknown>) | null;
+  notFoundTreePosition?: number | null;
   params: readonly string[];
 };
 type AppRscRouteForMatching = {
+  __loadRouteHandler?: unknown;
   pattern: string;
   patternParts: string[];
+  routeHandler?: unknown;
   slots?: Record<string, AppRscSlotForMatching>;
   siblingIntercepts?: AppRscSiblingInterceptForMatching[];
 };
@@ -68,6 +84,8 @@ type AppRscInterceptMatch = AppRscInterceptLookupEntry & {
 type AppRscInterceptLoadState = {
   page: unknown;
   pageLoading: Promise<unknown> | null;
+  notFound: unknown;
+  notFoundLoading: Promise<unknown> | null;
   interceptLayoutsLoading: Promise<readonly unknown[]> | null;
 };
 type AppRscInterceptLookupEntry = {
@@ -81,9 +99,16 @@ type AppRscInterceptLookupEntry = {
   interceptLayouts: readonly unknown[];
   interceptLayoutSegments?: readonly (readonly string[])[];
   interceptBranchSegments?: readonly string[];
+  interceptLoadings?: readonly unknown[];
+  interceptLoadingTreePositions?: readonly number[];
+  interceptNotFoundBranchSegments?: readonly string[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
+  notFound: unknown;
+  __loadNotFound?: (() => Promise<unknown>) | null;
+  notFoundTreePosition?: number | null;
   __loadState: AppRscInterceptLoadState;
   params: readonly string[];
   slotId: string | null;
@@ -93,6 +118,10 @@ declare function createAppRscRouteMatcher<Route extends AppRscRouteForMatching>(
     route: Route;
     params: AppRscRouteParams;
   } | null;
+  matchRequestRoute(url: string): {
+    route: Route;
+    params: AppRscRouteParams;
+  } | null;
   findIntercept(pathname: string, sourcePathname?: string | null): AppRscInterceptMatch | null;
 };
 declare function matchAppRscRoutePattern(urlParts: string[], patternParts: string[]): AppRscRouteParams | null;