vinext 1.0.0-beta.0 → 1.0.0-beta.2

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

@@ -39,12 +39,14 @@ type LazyLoadableSlot = {
   configLayouts?: readonly unknown[];
   loading?: unknown;
   error?: unknown;
+  notFound?: unknown;
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
   __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
-  __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
+  __loadError?: LazyModuleThunk | null;
+  __loadNotFound?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
 };
 type LazyLoadableRoute = {

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

@@ -64,6 +64,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
+		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
 	}
 	if (loads.length === 0) {
 		route.__loaded = true;

package/dist/server/app-route-tree-prefetch.js

@@ -86,7 +86,7 @@ function modulesByTreePosition(modules, positions) {
 async function buildTree(route) {
 	const layoutsByPosition = layoutModuleByTreePosition(route);
 	const root = createNode("", layoutsByPosition.get(0));
-	const nodesByPosition = new Map([[0, root]]);
+	const nodesByPosition = /* @__PURE__ */ new Map([[0, root]]);
 	let current = root;
 	for (const [index, segment] of route.routeSegments.entries()) {
 		const position = index + 1;

package/dist/server/app-rsc-cache-busting.d.ts

@@ -1,5 +1,5 @@
-import { VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
+import { VINEXT_RSC_RENDER_MODE_HEADER } from "./headers.js";
 
 //#region src/server/app-rsc-cache-busting.d.ts
 /**

package/dist/server/app-rsc-cache-busting.js

@@ -189,7 +189,7 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	const actualHash = url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM);
 	const expectedHash = await computeRscCacheBustingSearchParam(options.request.headers);
 	if (actualHash === null && expectedHash === "" && url.pathname.endsWith(".rsc")) return null;
-	const acceptedHashes = new Set([expectedHash]);
+	const acceptedHashes = /* @__PURE__ */ new Set([expectedHash]);
 	if (actualHash !== null && actualHash !== expectedHash) {
 		acceptedHashes.add(computeLegacyRscCacheBustingSearchParam(options.request.headers));
 		if (normalizeRenderModeHeaderValue(options.request.headers.get("X-Vinext-Rsc-Render-Mode")) === null) {

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

@@ -34,7 +34,7 @@ declare function getDigestForWellKnownError(error: unknown): string | undefined;
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
 declare function errorDigest(input: string): string;
-declare function sanitizeErrorForClient(error: unknown, nodeEnv?: string | undefined): unknown;
+declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
 declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
 //#endregion
 export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };

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

@@ -1,6 +1,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
 //#region src/server/app-rsc-errors.ts
+const ORIGINAL_SERVER_ERROR = Symbol.for("vinext.originalServerError");
 function hasDigest(error) {
 	return Boolean(error && typeof error === "object" && "digest" in error);
 }
@@ -39,7 +40,13 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 	if (resolveAppPageSpecialError(error)) return error;
 	if (nodeEnv !== "production") return error;
 	const sanitized = /* @__PURE__ */ new Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
-	sanitized.digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+	sanitized.digest = hasDigest(error) ? String(error.digest) : errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
+	Object.defineProperty(sanitized, ORIGINAL_SERVER_ERROR, {
+		configurable: false,
+		enumerable: false,
+		value: error,
+		writable: false
+	});
 	return sanitized;
 }
 function createRscOnErrorHandler(options) {
@@ -51,7 +58,10 @@ function createRscOnErrorHandler(options) {
 			console.error("[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\n\nCommon causes:\n  * Passing a module namespace (import * as X) directly as a prop.\n    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\n    which are not serializable. Fix: pass individual values instead,\n    e.g. <Comp value={module.value} />\n  * Passing a class instance (new Foo()) as a prop.\n    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\n  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\n  * Passing Object.create(null). Use { ...obj } to restore a prototype.\n\nOriginal error:", error.message);
 			return;
 		}
-		if (options.requestInfo && options.errorContext && error) options.reportRequestError(error instanceof Error ? error : new Error(getThrownValueMessage(error)), options.requestInfo, options.errorContext);
+		if (options.requestInfo && options.errorContext && error) {
+			const reportableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
+			options.reportRequestError(reportableError instanceof Error ? reportableError : new Error(getThrownValueMessage(reportableError)), options.requestInfo, options.errorContext);
+		}
 		if (hasDigest(error)) return String(error.digest);
 		if (error) {
 			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));

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

@@ -1,9 +1,9 @@
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
 import { ImageConfig } from "./image-optimization.js";
 import { ClientReuseManifestParseResult } from "./client-reuse-manifest.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
 import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
@@ -48,6 +48,7 @@ type DispatchMatchedPageOptions<TRoute> = {
   actionFailed?: boolean;
   handlerStart: number;
   interceptionContext: string | null;
+  interceptionPathname: string;
   isProgressiveActionRender: boolean;
   isRscRequest: boolean;
   middlewareContext: AppRscMiddlewareContext;
@@ -87,12 +88,13 @@ type DispatchMatchedRouteHandlerOptions<TRoute> = {
   route: TRoute;
   searchParams: URLSearchParams;
 };
-type HandleProgressiveActionRequestOptions = {
+type HandleProgressiveActionRequestOptions<TRoute> = {
   actionId: string | null;
   cleanPathname: string;
   contentType: string;
   middlewareContext: AppRscMiddlewareContext;
   request: Request;
+  routeMatch: AppRscRouteMatch<TRoute> | null;
 };
 /**
  * Side-effect headers captured during a progressive (no-JS) server action's
@@ -114,7 +116,7 @@ type ProgressiveActionFormStateResult = ({
   formState: null;
   kind: "form-state";
 } & ProgressiveActionSideEffects);
-type HandleServerActionRequestOptions = {
+type HandleServerActionRequestOptions<TRoute> = {
   actionId: string | null;
   cleanPathname: string;
   contentType: string;
@@ -123,6 +125,8 @@ type HandleServerActionRequestOptions = {
   middlewareContext: AppRscMiddlewareContext;
   mountedSlotsHeader: string | null;
   request: Request;
+  routeMatch: AppRscRouteMatch<TRoute> | null;
+  routePathname: string;
   searchParams: URLSearchParams;
 };
 type RenderNotFoundOptions<TRoute> = {
@@ -183,15 +187,16 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * Node server and dev included, not just the Cloudflare worker entry.
    */
   registerCacheAdapters: (env?: Record<string, unknown>) => void;
-  handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions) => Promise<Response | ProgressiveActionFormStateResult | null>;
+  handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions<TRoute>) => Promise<Response | ProgressiveActionFormStateResult | null>;
   handleMetadataRouteRequest?: (cleanPathname: string) => Promise<Response | null>;
   createPprFallbackShells?: (route: Pick<AppRscHandlerRoute, "params" | "pattern" | "rootParamNames">, params: AppPageParams) => AppPagePprFallbackCacheShell[];
-  handleServerActionRequest?: (options: HandleServerActionRequestOptions) => Promise<Response | null>;
+  handleServerActionRequest?: (options: HandleServerActionRequestOptions<TRoute>) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
   imageConfig?: ImageConfig;
   isDev: boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
   matchRoute: (pathname: string) => AppRscRouteMatch<TRoute> | null;
+  matchRequestRoute?: (pathname: string) => AppRscRouteMatch<TRoute> | null;
   runMiddleware?: (options: RunAppMiddlewareOptions) => Promise<ApplyAppMiddlewareResult>;
   publicFiles: ReadonlySet<string>;
   prefetchInlining?: PrefetchInliningConfig;

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

@@ -3,9 +3,10 @@ import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base
 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 { 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 { headersContextFromRequest } from "../shims/headers.js";
 import { ensureFetchPatch, setCurrentFetchSoftTags } from "../shims/fetch-cache.js";
 import { mergeRewriteQuery } from "../utils/query.js";
@@ -29,7 +30,10 @@ 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 = new Set(["cache-control"]);
+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 +65,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 +87,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 +137,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 +147,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 +162,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 }
@@ -189,11 +201,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 +227,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 +253,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 +271,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 +294,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 +326,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 +347,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 +372,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 +413,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 +448,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();
@@ -536,6 +563,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		actionFailed,
 		handlerStart,
 		interceptionContext: interceptionContextHeader,
+		interceptionPathname: cleanPathnameIsRequestPathname ? requestCleanPathname : cleanPathname,
 		isProgressiveActionRender,
 		isRscRequest,
 		middlewareContext,

package/dist/server/app-rsc-redirect-flight.d.ts

@@ -0,0 +1,66 @@
+import { ReactNode } from "react";
+
+//#region src/server/app-rsc-redirect-flight.d.ts
+/**
+ * Encoding of a `redirect()` for RSC transport: the canonical
+ * `NEXT_REDIRECT;<type>;<url>;<status>;` digest and the flight payload that
+ * carries it. Kept in one module so the digest format and the stream that
+ * serializes it have a single owner; `buildAppPageSpecialErrorResponse` and the
+ * boundary/dispatch special-error paths all depend on this contract.
+ */
+/**
+ * Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
+ * Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when we
+ * synthesize a flight payload for an RSC navigation: the digest must round-trip
+ * through the client's `RedirectErrorBoundary` so the same
+ * `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
+ *
+ * The URL is included verbatim, not encoded — Next.js's `getRedirectError`
+ * sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
+ * client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
+ * default `type=replace` because `redirect()` is replace-style outside of
+ * server actions, matching Next.js's `getRedirectError` default.
+ *
+ * Reference:
+ *   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
+ *   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
+ */
+declare function formatNextRedirectDigest(options: {
+  type: "push" | "replace";
+  url: string;
+  statusCode: number;
+}): string;
+/**
+ * The subset of `renderToReadableStream` the redirect-flight encoding needs.
+ * Both the boundary and dispatch special-error paths hand in their own
+ * environment-specific renderer, which accepts a wider element type; a plain
+ * throwing React element satisfies all of them.
+ */
+type RedirectFlightStreamRenderer = (element: ReactNode, options: {
+  onError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+}) => ReadableStream<Uint8Array>;
+/**
+ * Builds an RSC flight payload that encodes a `redirect()` as a React error
+ * carrying the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest. We
+ * render a tiny element that throws immediately; `renderToReadableStream`'s
+ * `onError` returns the digest, react-server-dom-webpack serializes the error
+ * into the stream, and the client's `RedirectErrorBoundary` decodes it via
+ * `getURLFromRedirectError` / `getRedirectTypeFromError`. The HTTP response
+ * stays 200 because the redirect rides in the flight body, not the status line.
+ *
+ * Mirrors Next.js's `generateDynamicFlightRenderResult` in `app-render.tsx`,
+ * where a redirect thrown during RSC rendering propagates through
+ * `renderToFlightStream`'s `onError` into the flight payload.
+ *
+ * This is the single owner of the redirect-flight encoding: the matched
+ * dispatch paths (`renderLayoutSpecialError` / `renderPageSpecialError`) and the
+ * route-miss boundary path (`renderBoundarySpecialErrorResponse`) both call it
+ * through the `buildRscRedirectFlightStream` option of
+ * `buildAppPageSpecialErrorResponse`.
+ */
+declare function buildRscRedirectFlightStream(options: {
+  renderToReadableStream: RedirectFlightStreamRenderer;
+  digest: string;
+}): ReadableStream<Uint8Array>;
+//#endregion
+export { RedirectFlightStreamRenderer, buildRscRedirectFlightStream, formatNextRedirectDigest };

package/dist/server/app-rsc-redirect-flight.js

@@ -0,0 +1,71 @@
+import { createElement } from "react";
+//#region src/server/app-rsc-redirect-flight.ts
+/**
+* Encoding of a `redirect()` for RSC transport: the canonical
+* `NEXT_REDIRECT;<type>;<url>;<status>;` digest and the flight payload that
+* carries it. Kept in one module so the digest format and the stream that
+* serializes it have a single owner; `buildAppPageSpecialErrorResponse` and the
+* boundary/dispatch special-error paths all depend on this contract.
+*/
+/**
+* Builds the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest that
+* Next.js encodes on `redirect()` / `permanentRedirect()` throws. Used when we
+* synthesize a flight payload for an RSC navigation: the digest must round-trip
+* through the client's `RedirectErrorBoundary` so the same
+* `getURLFromRedirectError` / `getRedirectTypeFromError` helpers decode it.
+*
+* The URL is included verbatim, not encoded — Next.js's `getRedirectError`
+* sets `digest = ${CODE};${type};${url};${status};` with the raw URL, and the
+* client decodes via `error.digest.split(';').slice(2, -2).join(';')`. We
+* default `type=replace` because `redirect()` is replace-style outside of
+* server actions, matching Next.js's `getRedirectError` default.
+*
+* Reference:
+*   `.nextjs-ref/packages/next/src/client/components/redirect.ts:20-23`
+*   `.nextjs-ref/packages/next/src/client/components/redirect-error.ts`
+*/
+function formatNextRedirectDigest(options) {
+	return `NEXT_REDIRECT;${options.type};${options.url};${options.statusCode};`;
+}
+/**
+* Error thrown by the redirect-flight renderer below. Its `digest` is the
+* canonical `NEXT_REDIRECT;...` string that react-server-dom's `onError`
+* reports so the client's `RedirectErrorBoundary` can decode it. A named
+* subclass keeps `digest` a real field rather than an `as`-cast on a plain
+* `Error`.
+*/
+var RscRedirectFlightError = class extends Error {
+	digest;
+	constructor(digest) {
+		super("NEXT_REDIRECT");
+		this.digest = digest;
+	}
+};
+/**
+* Builds an RSC flight payload that encodes a `redirect()` as a React error
+* carrying the canonical `NEXT_REDIRECT;<type>;<url>;<status>;` digest. We
+* render a tiny element that throws immediately; `renderToReadableStream`'s
+* `onError` returns the digest, react-server-dom-webpack serializes the error
+* into the stream, and the client's `RedirectErrorBoundary` decodes it via
+* `getURLFromRedirectError` / `getRedirectTypeFromError`. The HTTP response
+* stays 200 because the redirect rides in the flight body, not the status line.
+*
+* Mirrors Next.js's `generateDynamicFlightRenderResult` in `app-render.tsx`,
+* where a redirect thrown during RSC rendering propagates through
+* `renderToFlightStream`'s `onError` into the flight payload.
+*
+* This is the single owner of the redirect-flight encoding: the matched
+* dispatch paths (`renderLayoutSpecialError` / `renderPageSpecialError`) and the
+* route-miss boundary path (`renderBoundarySpecialErrorResponse`) both call it
+* through the `buildRscRedirectFlightStream` option of
+* `buildAppPageSpecialErrorResponse`.
+*/
+function buildRscRedirectFlightStream(options) {
+	const { digest } = options;
+	const throwingElement = createElement(function NextRedirectFlightThrower() {
+		throw new RscRedirectFlightError(digest);
+	});
+	return options.renderToReadableStream(throwingElement, { onError: () => digest });
+}
+//#endregion
+export { buildRscRedirectFlightStream, formatNextRedirectDigest };

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 };