vinext 0.1.0 → 0.1.2

package/dist/server/isr-decision.js

@@ -0,0 +1,70 @@
+import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildCachedRevalidateCacheControl, buildRevalidateCacheControl } from "./cache-control.js";
+//#region src/server/isr-decision.ts
+/** Resolve effective revalidate/expire, preferring per-entry metadata. */
+function resolveRevalidate(options) {
+	return {
+		effectiveRevalidate: options.cacheControlMeta?.revalidate ?? options.revalidateSeconds,
+		effectiveExpire: options.cacheControlMeta === void 0 ? void 0 : options.cacheControlMeta.expire ?? options.expireSeconds
+	};
+}
+function buildCacheControl(disposition, kind, revalidate, expire) {
+	if (kind === "app-route") {
+		if (revalidate === 0) return NEVER_CACHE_CONTROL;
+		if (revalidate === Infinity) return STATIC_CACHE_CONTROL;
+	}
+	return buildCachedRevalidateCacheControl(disposition, revalidate, expire);
+}
+/**
+* Derive the `Cache-Control` string for an ISR response.
+*
+* Content guards (kind mismatch, query-variant-unproven, empty body) are the
+* caller's responsibility and must happen *before* this call. `cacheState`
+* must only be `"HIT"` or `"STALE"` when those guards have already passed.
+*/
+function decideIsr(options) {
+	if (options.cacheState === "MISS") return {
+		disposition: "MISS",
+		scheduleRegeneration: false,
+		cacheControl: ""
+	};
+	const { effectiveRevalidate, effectiveExpire } = resolveRevalidate(options);
+	if (options.cacheState === "HIT") return {
+		disposition: "HIT",
+		scheduleRegeneration: false,
+		cacheControl: buildCacheControl("HIT", options.kind, effectiveRevalidate, effectiveExpire)
+	};
+	return {
+		disposition: "STALE",
+		scheduleRegeneration: true,
+		cacheControl: buildCacheControl("STALE", options.kind, effectiveRevalidate, effectiveExpire)
+	};
+}
+/**
+* Build the `Cache-Control` string for a fresh MISS response whose ISR policy
+* is known (i.e. revalidate is set and > 0). Uses the unbounded SWR form when
+* no expire ceiling is available, exactly as `buildRevalidateCacheControl` does.
+*
+* Separate from `decideIsr` because a MISS doesn't read a cache entry and
+* therefore never has `cacheControlMeta`. `expireSeconds` here is the route
+* config ceiling passed directly from the caller (not a per-entry fallback).
+*/
+function buildMissIsrCacheControl(revalidateSeconds, expireSeconds) {
+	return buildRevalidateCacheControl(revalidateSeconds, expireSeconds);
+}
+/**
+* Build the `Cache-Control` string for a fresh (MISS) app-route response.
+*
+* Applies the same `revalidateSeconds=0`→NEVER and `Infinity`→STATIC gates
+* that `decideIsr` uses for app-route cached responses. `expireSeconds` is
+* the route config ceiling passed directly (not per-entry metadata fallback).
+*
+* Used by `applyRouteHandlerRevalidateHeader` which operates on a fresh
+* response that has no per-entry cache metadata.
+*/
+function buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds) {
+	if (revalidateSeconds === 0) return NEVER_CACHE_CONTROL;
+	if (revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
+	return buildRevalidateCacheControl(revalidateSeconds, expireSeconds);
+}
+//#endregion
+export { NEVER_CACHE_CONTROL as ISR_NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL as ISR_NO_STORE_CACHE_CONTROL, buildAppRouteMissIsrCacheControl, buildMissIsrCacheControl, decideIsr };

package/dist/server/metadata-route-response.js

@@ -53,9 +53,9 @@ function getMetadataRouteFunctions(route) {
 	routeFunctionCache.set(route, functions);
 	return functions;
 }
-function matchMetadataRoute(route, cleanPathname, functions) {
+function matchMetadataRoute(route, cleanPathname, functions, getUrlParts) {
 	if (route.patternParts) {
-		const urlParts = cleanPathname.split("/").filter(Boolean);
+		const urlParts = getUrlParts();
 		if (functions.hasGeneratedImageMetadata && urlParts.length > 0) {
 			const params = matchMetadataRoutePattern(urlParts.slice(0, -1), route.patternParts);
 			if (params) return {
@@ -184,6 +184,8 @@ function serveStaticMetadataRoute(route) {
 	}
 }
 async function handleMetadataRouteRequest(options) {
+	let urlParts;
+	const getUrlParts = () => urlParts ??= options.cleanPathname.split("/").filter(Boolean);
 	for (const route of options.metadataRoutes) {
 		const functions = getMetadataRouteFunctions(route);
 		if (route.type === "sitemap" && route.isDynamic) {
@@ -193,7 +195,7 @@ async function handleMetadataRouteRequest(options) {
 				continue;
 			}
 		}
-		const match = matchMetadataRoute(route, options.cleanPathname, functions);
+		const match = matchMetadataRoute(route, options.cleanPathname, functions, getUrlParts);
 		if (!match) continue;
 		return route.isDynamic ? callDynamicMetadataRoute(route, match, options.makeThenableParams, functions) : serveStaticMetadataRoute(route);
 	}

package/dist/server/middleware-runtime.d.ts

@@ -19,6 +19,19 @@ type MiddlewareHandler = (request: NextRequest, event: NextFetchEvent) => Respon
 type ExecuteMiddlewareOptions = {
   basePath?: string;
   filePath?: string;
+  /**
+   * Whether the incoming request was inside the configured basePath. Drives
+   * the `nextUrl.basePath` the middleware observes: in-basePath requests are
+   * re-prefixed so NextURL reports the configured basePath, while
+   * out-of-basePath ("absolute path") requests stay un-prefixed so middleware
+   * sees `nextUrl.basePath === ""` (Next.js `getNextPathnameInfo` semantics —
+   * see test/e2e/middleware-base-path "should execute from absolute paths").
+   * When omitted it is derived from the request URL, which is correct for the
+   * Pages prod/deploy adapters because they pass the original (un-stripped)
+   * URL. Callers that pass an already-stripped URL (dev server, App Router)
+   * must set this explicitly.
+   */
+  hadBasePath?: boolean;
   i18nConfig?: NextI18nConfig | null;
   includeErrorDetails?: boolean;
   /**

package/dist/server/middleware-runtime.js

@@ -1,4 +1,5 @@
 import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { addBasePathToPathname, hasBasePath, stripBasePath } from "../utils/base-path.js";
 import "./server-globals.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "../shims/request-context.js";
 import { MIDDLEWARE_REWRITE_HEADER } from "./headers.js";
@@ -99,12 +100,13 @@ function resolveMiddlewarePathname(request) {
 		return badRequestResponse();
 	}
 }
-function createNextRequest(request, normalizedPathname, i18nConfig, basePath, trailingSlash) {
+function createNextRequest(request, normalizedPathname, i18nConfig, basePath, trailingSlash, hadBasePath) {
 	const url = new URL(request.url);
 	let mwRequest = request.body && !request.bodyUsed ? request.clone() : request;
-	if (normalizedPathname !== url.pathname) {
+	const mwPathname = basePath && hadBasePath ? addBasePathToPathname(normalizedPathname, basePath) : normalizedPathname;
+	if (mwPathname !== url.pathname) {
 		const mwUrl = new URL(url);
-		mwUrl.pathname = normalizedPathname;
+		mwUrl.pathname = mwPathname;
 		mwRequest = new Request(mwUrl, mwRequest);
 	}
 	const nextConfig = basePath || i18nConfig || trailingSlash ? {
@@ -124,9 +126,11 @@ async function executeMiddleware(options) {
 		continue: false,
 		response: normalizedPathname
 	};
-	if (!matchesMiddleware(normalizedPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
-	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash);
-	const fetchEvent = new NextFetchEvent({ page: normalizedPathname });
+	const hadBasePath = options.hadBasePath ?? (!options.basePath || hasBasePath(new URL(options.request.url).pathname, options.basePath));
+	const matchPathname = options.basePath ? stripBasePath(normalizedPathname, options.basePath) : normalizedPathname;
+	if (!matchesMiddleware(matchPathname, middlewareMatcher(options.module), options.request, options.i18nConfig)) return { continue: true };
+	const nextRequest = createNextRequest(options.request, normalizedPathname, options.i18nConfig, options.basePath, options.trailingSlash, hadBasePath);
+	const fetchEvent = new NextFetchEvent({ page: matchPathname });
 	let response;
 	try {
 		response = await middlewareFn(nextRequest, fetchEvent);
@@ -195,7 +199,7 @@ async function executeMiddleware(options) {
 		try {
 			const rewriteParsed = new URL(rewriteUrl, options.request.url);
 			const requestOrigin = new URL(options.request.url).origin;
-			if (rewriteParsed.origin === requestOrigin) rewritePath = rewriteParsed.pathname + rewriteParsed.search;
+			if (rewriteParsed.origin === requestOrigin) rewritePath = (options.basePath ? stripBasePath(rewriteParsed.pathname, options.basePath) : rewriteParsed.pathname) + rewriteParsed.search;
 			else rewritePath = rewriteParsed.href;
 		} catch {
 			rewritePath = rewriteUrl;

package/dist/server/middleware.js

@@ -85,6 +85,7 @@ async function runMiddleware(runner, middlewarePath, request, i18nConfig, basePa
 	return runGeneratedMiddleware({
 		basePath,
 		filePath: middlewarePath,
+		hadBasePath: true,
 		i18nConfig,
 		includeErrorDetails: process.env.NODE_ENV !== "production",
 		isDataRequest,

package/dist/server/navigation-planner.d.ts

@@ -114,6 +114,63 @@ type FlightResultV0 = {
   href: string;
   targetSnapshot: RouteSnapshotV0;
 };
+type RscFetchResultSource = "cached" | "live";
+type RscFetchResultFactsV0 = {
+  source: RscFetchResultSource;
+  currentHref: string;
+  origin: string;
+  effectiveHistoryUpdateMode: "push" | "replace";
+  redirectDepth: number;
+  requestPreviousNextUrl: string | null;
+  clientCompatibilityId: string | null;
+  responseOk: boolean;
+  isRscContentType: boolean;
+  hasBody: boolean;
+  compatibilityIdHeader: string | null;
+  responseUrl: string | null;
+  streamedRedirectTarget: string | null;
+};
+type RscRedirectFollowV0 = {
+  href: string;
+  historyUpdateMode: "push" | "replace";
+  previousNextUrl: string | null;
+  redirectDepth: number;
+};
+type RscFetchResultHardNavReason = "invalidRscPayload" | "rscCompatibilityMismatch" | "externalRedirectTarget" | "redirectDepthExhausted" | "streamedRedirectLoop";
+type RscFetchResultDecisionV0 = {
+  kind: "proceedToCommit";
+  discardBody: false;
+  trace: NavigationTrace;
+} | {
+  kind: "followRedirect";
+  discardBody: boolean;
+  redirect: RscRedirectFollowV0;
+  trace: NavigationTrace;
+} | {
+  kind: "hardNavigate";
+  discardBody: boolean;
+  url: string;
+  reason: RscFetchResultHardNavReason;
+  trace: NavigationTrace;
+};
+type EarlyNavigationIntentFactsV0 = {
+  basePath: string;
+  currentHref: string;
+  mode: "push" | "replace";
+  scroll: boolean;
+  targetHref: string;
+};
+type EarlyNavigationIntentDecisionV0 = {
+  kind: "sameDocumentScroll";
+  hash: string;
+  mode: "push" | "replace";
+  scroll: boolean;
+  trace: NavigationTrace;
+} | {
+  kind: "flightNavigation";
+  bypassNavigationCache: boolean;
+  trace: NavigationTrace;
+};
 type NavigationPlannerInput = {
   routeManifest: RouteManifest | null;
   state: NavigationPlannerStateV0;
@@ -122,6 +179,8 @@ type NavigationPlannerInput = {
 type AcceptedCacheEntryReuseDecision = Extract<CacheEntryReuseDecision, {
   canReuse: true;
 }>;
+declare function classifyRscFetchResult(facts: RscFetchResultFactsV0): RscFetchResultDecisionV0;
+declare function classifyEarlyNavigationIntent(facts: EarlyNavigationIntentFactsV0): EarlyNavigationIntentDecisionV0;
 declare function classifyRootBoundaryTransition(currentRootBoundaryId: string | null, nextRootBoundaryId: string | null): RootBoundaryTransition;
 declare function resolveSameLayoutAncestorPersistence(currentSnapshot: RouteSnapshotV0, targetSnapshot: RouteSnapshotV0): readonly string[];
 declare function resolveMountedParallelSlotPersistence(currentSnapshot: RouteSnapshotV0, targetSnapshot: RouteSnapshotV0): readonly string[];
@@ -143,6 +202,8 @@ declare function resolveDefaultOrUnmatchedSlotPersistenceForLayouts(options: {
 }): readonly string[];
 declare function planNavigation(input: NavigationPlannerInput): NavigationDecisionV0;
 declare const navigationPlanner: {
+  classifyEarlyNavigationIntent: typeof classifyEarlyNavigationIntent;
+  classifyRscFetchResult: typeof classifyRscFetchResult;
   classifyRootBoundaryTransition: typeof classifyRootBoundaryTransition;
   plan: typeof planNavigation;
   resolveCurrentRootBoundaryElementPersistence: typeof resolveCurrentRootBoundaryElementPersistence;
@@ -150,4 +211,4 @@ declare const navigationPlanner: {
   resolveSameLayoutAncestorPersistence: typeof resolveSameLayoutAncestorPersistence;
 };
 //#endregion
-export { FlightResultV0, InterceptionSnapshotV0, MountedParallelSlotSnapshotV0, NavigationDecisionV0, NavigationEvent, NavigationPlannerInput, NavigationPlannerStateV0, OperationLane, OperationToken, ParallelSlotBindingSnapshotV0, RefreshScope, RootBoundaryTransition, RouteSnapshotV0, TraverseDirection, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };
+export { EarlyNavigationIntentDecisionV0, EarlyNavigationIntentFactsV0, FlightResultV0, InterceptionSnapshotV0, MountedParallelSlotSnapshotV0, NavigationDecisionV0, NavigationEvent, NavigationPlannerInput, NavigationPlannerStateV0, OperationLane, OperationToken, ParallelSlotBindingSnapshotV0, RefreshScope, RootBoundaryTransition, RouteSnapshotV0, RscFetchResultDecisionV0, RscFetchResultFactsV0, TraverseDirection, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };

package/dist/server/navigation-planner.js

@@ -1,7 +1,10 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.js";
-import { matchRoutePattern, matchRoutePatternPrefix } from "../routing/route-pattern.js";
+import { stripBasePath } from "../utils/base-path.js";
+import { matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments } from "../routing/route-pattern.js";
 import { compareAppElementsSlotIds } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { resolveHardNavigationTargetFromRscResponse, resolveRscCompatibilityNavigationDecision } from "./app-rsc-cache-busting.js";
+import { resolveRscRedirectLifecycleHop, resolveStreamedRscRedirectLifecycleHop } from "./app-browser-rsc-redirect.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 //#region src/server/navigation-planner.ts
 const ROUTE_INTERCEPTION_CONTEXT_SEPARATOR = "\0";
@@ -27,6 +30,189 @@ function getRequestedWorkTargetHref(work) {
 		default: throw new Error("[vinext] Unknown requested navigation work: " + String(work));
 	}
 }
+function createRscFetchResultTraceFields(facts, fields = {}) {
+	return {
+		fetchResultSource: facts.source,
+		...fields
+	};
+}
+function createRscFetchResultHardNavigationDecision(options) {
+	return {
+		discardBody: options.discardBody,
+		kind: "hardNavigate",
+		reason: options.reason,
+		trace: createNavigationTrace(options.reasonCode, createRscFetchResultTraceFields(options.facts, {
+			...options.redirectSignal !== void 0 ? { redirectSignal: options.redirectSignal } : {},
+			redirectDepth: options.facts.redirectDepth,
+			targetHref: options.url
+		})),
+		url: options.url
+	};
+}
+function createRscFetchResultFollowRedirectDecision(options) {
+	return {
+		discardBody: options.discardBody,
+		kind: "followRedirect",
+		redirect: options.redirect,
+		trace: createNavigationTrace(NavigationTraceReasonCodes.redirectFollow, createRscFetchResultTraceFields(options.facts, {
+			redirectDepth: options.redirect.redirectDepth,
+			redirectSignal: options.redirectSignal,
+			targetHref: options.redirect.href
+		}))
+	};
+}
+function mapRscRedirectTerminalReason(reason) {
+	switch (reason) {
+		case "externalRedirect": return {
+			hardNavigationReason: "externalRedirectTarget",
+			traceReasonCode: NavigationTraceReasonCodes.redirectTerminalExternal
+		};
+		case "maxRedirectsExceeded": return {
+			hardNavigationReason: "redirectDepthExhausted",
+			traceReasonCode: NavigationTraceReasonCodes.redirectTerminalDepth
+		};
+		default: throw new Error("[vinext] Unknown RSC redirect terminal reason: " + String(reason));
+	}
+}
+function classifyRscFetchResult(facts) {
+	if (!facts.responseOk || !facts.isRscContentType || !facts.hasBody) {
+		const url = resolveHardNavigationTargetFromRscResponse(facts.responseUrl, facts.currentHref, facts.origin);
+		return createRscFetchResultHardNavigationDecision({
+			discardBody: false,
+			facts,
+			reason: "invalidRscPayload",
+			reasonCode: NavigationTraceReasonCodes.invalidRscPayload,
+			url
+		});
+	}
+	const compatibilityDecision = resolveRscCompatibilityNavigationDecision({
+		clientCompatibilityId: facts.clientCompatibilityId,
+		currentHref: facts.currentHref,
+		origin: facts.origin,
+		responseCompatibilityId: facts.compatibilityIdHeader,
+		responseUrl: facts.responseUrl
+	});
+	if (compatibilityDecision.kind === "hard-navigate") return createRscFetchResultHardNavigationDecision({
+		discardBody: false,
+		facts,
+		reason: "rscCompatibilityMismatch",
+		reasonCode: NavigationTraceReasonCodes.rscCompatibilityMismatch,
+		url: compatibilityDecision.hardNavigationTarget
+	});
+	if (facts.responseUrl !== null) {
+		const redirectDecision = resolveRscRedirectLifecycleHop({
+			currentHref: facts.currentHref,
+			historyUpdateMode: facts.effectiveHistoryUpdateMode,
+			origin: facts.origin,
+			redirectDepth: facts.redirectDepth,
+			requestPreviousNextUrl: facts.requestPreviousNextUrl,
+			responseUrl: facts.responseUrl
+		});
+		if (redirectDecision.kind === "terminal-hard-navigation") {
+			const terminalReason = mapRscRedirectTerminalReason(redirectDecision.reason);
+			return createRscFetchResultHardNavigationDecision({
+				discardBody: false,
+				facts,
+				reason: terminalReason.hardNavigationReason,
+				reasonCode: terminalReason.traceReasonCode,
+				redirectSignal: "response-url",
+				url: redirectDecision.href
+			});
+		}
+		if (redirectDecision.kind === "follow") return createRscFetchResultFollowRedirectDecision({
+			discardBody: false,
+			facts,
+			redirect: {
+				href: redirectDecision.href,
+				historyUpdateMode: facts.effectiveHistoryUpdateMode,
+				previousNextUrl: redirectDecision.previousNextUrl,
+				redirectDepth: redirectDecision.redirectDepth
+			},
+			redirectSignal: "response-url"
+		});
+	}
+	if (facts.streamedRedirectTarget !== null) {
+		const redirectDecision = resolveStreamedRscRedirectLifecycleHop({
+			currentHref: facts.currentHref,
+			historyUpdateMode: facts.effectiveHistoryUpdateMode,
+			origin: facts.origin,
+			redirectDepth: facts.redirectDepth,
+			requestPreviousNextUrl: facts.requestPreviousNextUrl,
+			streamedRedirectTarget: facts.streamedRedirectTarget
+		});
+		if (redirectDecision.kind === "terminal-hard-navigation") {
+			const terminalReason = mapRscRedirectTerminalReason(redirectDecision.reason);
+			return createRscFetchResultHardNavigationDecision({
+				discardBody: true,
+				facts,
+				reason: terminalReason.hardNavigationReason,
+				reasonCode: terminalReason.traceReasonCode,
+				redirectSignal: "streamed-header",
+				url: redirectDecision.href
+			});
+		}
+		if (redirectDecision.kind === "follow") return createRscFetchResultFollowRedirectDecision({
+			discardBody: true,
+			facts,
+			redirect: {
+				href: redirectDecision.href,
+				historyUpdateMode: facts.effectiveHistoryUpdateMode,
+				previousNextUrl: redirectDecision.previousNextUrl,
+				redirectDepth: redirectDecision.redirectDepth
+			},
+			redirectSignal: "streamed-header"
+		});
+		return createRscFetchResultHardNavigationDecision({
+			discardBody: true,
+			facts,
+			reason: "streamedRedirectLoop",
+			reasonCode: NavigationTraceReasonCodes.streamedRedirectLoop,
+			redirectSignal: "streamed-header",
+			url: redirectDecision.href
+		});
+	}
+	return {
+		discardBody: false,
+		kind: "proceedToCommit",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.proceedToCommit, createRscFetchResultTraceFields(facts))
+	};
+}
+function createEarlyNavigationIntentTrace(reasonCode, facts) {
+	return createNavigationTrace(reasonCode, { targetHref: facts.targetHref });
+}
+function classifyEarlyNavigationIntent(facts) {
+	let current;
+	let next;
+	try {
+		current = new URL(facts.currentHref);
+		next = new URL(facts.targetHref, facts.currentHref);
+	} catch {
+		return {
+			bypassNavigationCache: false,
+			kind: "flightNavigation",
+			trace: createEarlyNavigationIntentTrace(NavigationTraceReasonCodes.crossDocumentFlight, facts)
+		};
+	}
+	const samePathname = current.origin === next.origin && stripBasePath(current.pathname, facts.basePath) === stripBasePath(next.pathname, facts.basePath);
+	const sameSearch = current.searchParams.toString() === next.searchParams.toString();
+	if (samePathname && sameSearch && next.hash !== "") return {
+		hash: next.hash,
+		kind: "sameDocumentScroll",
+		mode: facts.mode,
+		scroll: facts.scroll,
+		trace: createEarlyNavigationIntentTrace(NavigationTraceReasonCodes.sameDocumentScroll, facts)
+	};
+	if (samePathname && !sameSearch) return {
+		bypassNavigationCache: true,
+		kind: "flightNavigation",
+		trace: createEarlyNavigationIntentTrace(NavigationTraceReasonCodes.samePageSearch, facts)
+	};
+	return {
+		bypassNavigationCache: false,
+		kind: "flightNavigation",
+		trace: createEarlyNavigationIntentTrace(NavigationTraceReasonCodes.crossDocumentFlight, facts)
+	};
+}
 function createSnapshotRouteTopology(snapshot) {
 	return {
 		layoutIds: snapshot.layoutIds,
@@ -119,8 +305,10 @@ function findRouteManifestInterceptionForProof(routeManifest, proof) {
 	const candidateInterceptions = routeManifest.segmentGraph.interceptionsBySlotId.get(proof.slotId) ?? [];
 	for (const interception of candidateInterceptions) {
 		if (!matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) continue;
-		if (matchRoutePattern(targetParts, interception.targetPatternParts) === null) continue;
-		if (interception.targetRouteId !== null && targetRoute?.id !== interception.targetRouteId) continue;
+		const exactTargetParams = matchRoutePattern(targetParts, interception.targetPatternParts);
+		const allowsMiddlewareRewriteTarget = exactTargetParams === null && matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts);
+		if (exactTargetParams === null && !allowsMiddlewareRewriteTarget) continue;
+		if (!allowsMiddlewareRewriteTarget && interception.targetRouteId !== null && targetRoute?.id !== interception.targetRouteId) continue;
 		return interception;
 	}
 	return null;
@@ -493,6 +681,8 @@ function planNavigation(input) {
 	}
 }
 const navigationPlanner = {
+	classifyEarlyNavigationIntent,
+	classifyRscFetchResult,
 	classifyRootBoundaryTransition,
 	plan: planNavigation,
 	resolveCurrentRootBoundaryElementPersistence,

package/dist/server/navigation-trace.d.ts

@@ -4,6 +4,8 @@ type NavigationTraceSchemaVersion = 0;
 declare const NavigationTraceReasonCodes: {
   cacheProofRejected: "NC_CACHE_REJECT";
   commitCurrent: "NC_COMMIT";
+  crossDocumentFlight: "NC_CROSS_DOC_FLIGHT";
+  invalidRscPayload: "NC_RSC_INVALID";
   interceptedCommitCurrent: "NC_INTERCEPT_COMMIT";
   interceptedRejectedIncompatibleRoot: "NC_INTERCEPT_REJECT_ROOT";
   interceptedRejectedMissingProof: "NC_INTERCEPT_REJECT_MISSING_PROOF";
@@ -12,10 +14,18 @@ declare const NavigationTraceReasonCodes: {
   interceptedRejectedUndeclaredTopology: "NC_INTERCEPT_REJECT_GRAPH";
   interceptedRejectedUnknownSource: "NC_INTERCEPT_REJECT_SOURCE";
   prefetchOnly: "NC_PREFETCH_ONLY";
+  proceedToCommit: "NC_RSC_PROCEED";
+  redirectFollow: "NC_RSC_REDIRECT_FOLLOW";
+  redirectTerminalDepth: "NC_RSC_REDIRECT_DEPTH";
+  redirectTerminalExternal: "NC_RSC_REDIRECT_EXTERNAL";
   requestWork: "NC_REQUEST";
   rootBoundaryChanged: "NC_ROOT";
   rootBoundaryUnknown: "NC_ROOT_UNKNOWN";
+  rscCompatibilityMismatch: "NC_RSC_COMPAT_MISMATCH";
+  sameDocumentScroll: "NC_SAME_DOC_SCROLL";
+  samePageSearch: "NC_SAME_PAGE_SEARCH";
   staleOperation: "NC_STALE";
+  streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP";
 };
 declare const NavigationTraceTransactionCodes: {
   hardNavigate: "NT_HARD_NAVIGATE";
@@ -25,7 +35,7 @@ declare const NavigationTraceTransactionCodes: {
 type NavigationTraceReasonCode = (typeof NavigationTraceReasonCodes)[keyof typeof NavigationTraceReasonCodes];
 type NavigationTraceTransactionCode = (typeof NavigationTraceTransactionCodes)[keyof typeof NavigationTraceTransactionCodes];
 type NavigationTraceCode = NavigationTraceReasonCode | NavigationTraceTransactionCode;
-type NavigationTraceFieldName = "activeNavigationId" | "cacheProofCode" | "cacheProofMode" | "cacheProofReuseClass" | "cacheProofScope" | "currentRootLayoutTreePath" | "currentVisibleCommitVersion" | "nextRootLayoutTreePath" | "eventKind" | "operationLane" | "pendingOperationId" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
+type NavigationTraceFieldName = "activeNavigationId" | "cacheProofCode" | "cacheProofMode" | "cacheProofReuseClass" | "cacheProofScope" | "currentRootLayoutTreePath" | "currentVisibleCommitVersion" | "nextRootLayoutTreePath" | "eventKind" | "fetchResultSource" | "operationLane" | "pendingOperationId" | "redirectDepth" | "redirectSignal" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
 type NavigationTraceFieldValue = string | number | boolean | null;
 type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
 type NavigationTraceEntry = Readonly<{
@@ -47,4 +57,4 @@ declare function createNavigationLifecycleTraceFields(options: {
 declare function createNavigationTrace(code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
 declare function prependNavigationTraceEntry(trace: NavigationTrace, code: NavigationTraceCode, fields?: NavigationTraceFields): NavigationTrace;
 //#endregion
-export { NAVIGATION_TRACE_SCHEMA_VERSION, NavigationTrace, NavigationTraceCode, NavigationTraceFields, NavigationTraceReasonCode, NavigationTraceReasonCodes, NavigationTraceTransactionCode, NavigationTraceTransactionCodes, createNavigationLifecycleTraceFields, createNavigationTrace, prependNavigationTraceEntry };
+export { NAVIGATION_TRACE_SCHEMA_VERSION, NavigationTrace, NavigationTraceFields, NavigationTraceReasonCode, NavigationTraceReasonCodes, NavigationTraceTransactionCode, NavigationTraceTransactionCodes, createNavigationLifecycleTraceFields, createNavigationTrace, prependNavigationTraceEntry };

package/dist/server/navigation-trace.js

@@ -3,6 +3,8 @@ const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
 const NavigationTraceReasonCodes = {
 	cacheProofRejected: "NC_CACHE_REJECT",
 	commitCurrent: "NC_COMMIT",
+	crossDocumentFlight: "NC_CROSS_DOC_FLIGHT",
+	invalidRscPayload: "NC_RSC_INVALID",
 	interceptedCommitCurrent: "NC_INTERCEPT_COMMIT",
 	interceptedRejectedIncompatibleRoot: "NC_INTERCEPT_REJECT_ROOT",
 	interceptedRejectedMissingProof: "NC_INTERCEPT_REJECT_MISSING_PROOF",
@@ -11,10 +13,18 @@ const NavigationTraceReasonCodes = {
 	interceptedRejectedUndeclaredTopology: "NC_INTERCEPT_REJECT_GRAPH",
 	interceptedRejectedUnknownSource: "NC_INTERCEPT_REJECT_SOURCE",
 	prefetchOnly: "NC_PREFETCH_ONLY",
+	proceedToCommit: "NC_RSC_PROCEED",
+	redirectFollow: "NC_RSC_REDIRECT_FOLLOW",
+	redirectTerminalDepth: "NC_RSC_REDIRECT_DEPTH",
+	redirectTerminalExternal: "NC_RSC_REDIRECT_EXTERNAL",
 	requestWork: "NC_REQUEST",
 	rootBoundaryChanged: "NC_ROOT",
 	rootBoundaryUnknown: "NC_ROOT_UNKNOWN",
-	staleOperation: "NC_STALE"
+	rscCompatibilityMismatch: "NC_RSC_COMPAT_MISMATCH",
+	sameDocumentScroll: "NC_SAME_DOC_SCROLL",
+	samePageSearch: "NC_SAME_PAGE_SEARCH",
+	staleOperation: "NC_STALE",
+	streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP"
 };
 const NavigationTraceTransactionCodes = {
 	hardNavigate: "NT_HARD_NAVIGATE",

package/dist/server/normalize-path.d.ts

@@ -1,12 +1,4 @@
 //#region src/server/normalize-path.d.ts
-/**
- * Re-encode path delimiter characters that were decoded by decodeURIComponent.
- * After decoding a URL segment, characters like / # ? \ need to be re-encoded
- * so they don't change the path structure.
- *
- * Ported from Next.js: packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
- * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
- */
 declare function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;
 /**
  * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.

package/dist/server/normalize-path.js

@@ -7,8 +7,10 @@
 * Ported from Next.js: packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
 * https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts
 */
+const PATH_DELIMITERS_RE = /([/#?])/gi;
+const PATH_DELIMITERS_ENCODED_RE = /([/#?]|%(2f|23|3f|5c))/gi;
 function escapePathDelimiters(segment, escapeEncoded) {
-	return segment.replace(new RegExp(`([/#?]${escapeEncoded ? "|%(2f|23|3f|5c)" : ""})`, "gi"), (char) => encodeURIComponent(char));
+	return segment.replace(escapeEncoded ? PATH_DELIMITERS_ENCODED_RE : PATH_DELIMITERS_RE, (char) => encodeURIComponent(char));
 }
 /**
 * Decode a URL pathname segment-by-segment, preserving encoded path delimiters.

package/dist/server/otel-tracer-extension.d.ts

@@ -0,0 +1,45 @@
+//#region src/server/otel-tracer-extension.d.ts
+/**
+ * OpenTelemetry tracer provider extension for Cache Components.
+ *
+ * When `cacheComponents: true` is enabled in next.config, component renders
+ * go through multiple phases (warmup → resume). During these phases, the
+ * `workUnitAsyncStorage` carries a prerender or cache store. Without this
+ * extension, calls to `tracer.startSpan()` / `tracer.startActiveSpan()` from
+ * inside user RSC code would inherit that prerender context, causing:
+ *
+ *  1. Spans to reuse the same trace ID across requests (the frozen prerender
+ *     context bleeds into the runtime resume render).
+ *  2. Spans not being created at all during fallback resume (the work unit
+ *     context gates span creation in some OTel SDK implementations).
+ *
+ * The fix mirrors Next.js's `instrumentation-node-extensions.ts`:
+ *  - Wrap `tracer.startSpan` to exit `workUnitAsyncStorage` before creating
+ *    the span, ensuring a clean context for span ID generation.
+ *  - Wrap `tracer.startActiveSpan` similarly and re-enter the work unit store
+ *    for the callback, so that the callback runs with the correct request
+ *    context restored.
+ *
+ * This extension is intentionally a no-op when:
+ *  - `@opentelemetry/api` is not installed (graceful degradation).
+ *  - No OTel tracer provider has been registered (provider is the noop provider).
+ *  - `workUnitAsyncStorage` has no active store (non-render contexts).
+ *
+ * References:
+ *  - packages/next/src/server/lib/router-utils/instrumentation-node-extensions.ts
+ *  - https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-utils/instrumentation-node-extensions.ts
+ */
+/**
+ * Extend the registered OTel tracer provider so that `startSpan` and
+ * `startActiveSpan` exit the `workUnitAsyncStorage` context before creating
+ * spans. This prevents the prerender/cache work unit store from leaking into
+ * span ID generation during Cache Component fallback resumes.
+ *
+ * Safe to call multiple times — subsequent calls are no-ops once the provider
+ * has been wrapped.
+ *
+ * Must only be called in Node.js environments (not Edge runtime).
+ */
+declare function extendTracerProviderForCacheComponents(): void;
+//#endregion
+export { extendTracerProviderForCacheComponents };