vinext 0.1.2 → 0.1.3

package/dist/server/image-optimization.js

@@ -56,32 +56,46 @@ const DEFAULT_IMAGE_SIZES = [
 	256,
 	384
 ];
-/**
-* Absolute maximum image width. Even if custom deviceSizes/imageSizes are
-* configured, widths above this are always rejected. This prevents resource
-* exhaustion from absurdly large resize requests.
-*/
-const ABSOLUTE_MAX_WIDTH = 3840;
+const DEV_BLUR_MAX_WIDTH = 8;
+const DEV_BLUR_QUALITY = 70;
+function resolveDevImageRedirect(requestUrl, allowedWidths = [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES], allowedQualities, options = { isDev: true }) {
+	const params = parseImageParams(requestUrl, allowedWidths, allowedQualities, options);
+	if (!params) return null;
+	if (params.imageUrl.startsWith("/@") || params.imageUrl.startsWith("/__vite") || params.imageUrl.startsWith("/node_modules")) return null;
+	const resolved = new URL(params.imageUrl, requestUrl.origin);
+	if (resolved.origin !== requestUrl.origin) return null;
+	return resolved.pathname + resolved.search;
+}
 /**
 * Parse and validate image optimization query parameters.
 * Returns null if the request is malformed.
 *
-* When `allowedWidths` is provided, the width must be 0 (no resize) or
-* exactly match one of the allowed values. This matches Next.js behavior
-* where only configured deviceSizes and imageSizes are accepted.
-*
-* When `allowedWidths` is not provided, any width from 0 to ABSOLUTE_MAX_WIDTH
-* is accepted (backwards-compatible fallback).
+* Ported from Next.js:
+* test/integration/image-optimizer/test/index.test.ts
+* https://github.com/vercel/next.js/blob/canary/test/integration/image-optimizer/test/index.test.ts
 */
-function parseImageParams(url, allowedWidths) {
+function parseImageParams(url, allowedWidths = [...DEFAULT_DEVICE_SIZES, ...DEFAULT_IMAGE_SIZES], allowedQualities, options = {}) {
+	const allowedParamNames = new Set([
+		"url",
+		"w",
+		"q"
+	]);
+	for (const name of url.searchParams.keys()) if (!allowedParamNames.has(name) || url.searchParams.getAll(name).length !== 1) return null;
 	const imageUrl = url.searchParams.get("url");
 	if (!imageUrl) return null;
-	const w = parseInt(url.searchParams.get("w") || "0", 10);
-	const q = parseInt(url.searchParams.get("q") || "75", 10);
-	if (Number.isNaN(w) || w < 0) return null;
-	if (w > ABSOLUTE_MAX_WIDTH) return null;
-	if (allowedWidths && w !== 0 && !allowedWidths.includes(w)) return null;
-	if (Number.isNaN(q) || q < 1 || q > 100) return null;
+	if (imageUrl.length > 3072) return null;
+	const widthParam = url.searchParams.get("w");
+	const qualityParam = url.searchParams.get("q");
+	if (!widthParam || !/^[0-9]+$/.test(widthParam)) return null;
+	if (!qualityParam || !/^[0-9]+$/.test(qualityParam)) return null;
+	const width = Number.parseInt(widthParam, 10);
+	const quality = Number.parseInt(qualityParam, 10);
+	if (String(width) !== widthParam || String(quality) !== qualityParam) return null;
+	const isDevBlurWidth = options.isDev && width <= DEV_BLUR_MAX_WIDTH;
+	const isDevBlurQuality = options.isDev && quality === DEV_BLUR_QUALITY;
+	if (width <= 0 || !allowedWidths.includes(width) && !isDevBlurWidth) return null;
+	if (quality < 1 || quality > 100) return null;
+	if (allowedQualities && !allowedQualities.includes(quality) && !isDevBlurQuality) return null;
 	const normalizedUrl = imageUrl.replaceAll("\\", "/");
 	if (!normalizedUrl.startsWith("/") || normalizedUrl.startsWith("//")) return null;
 	try {
@@ -92,8 +106,8 @@ function parseImageParams(url, allowedWidths) {
 	}
 	return {
 		imageUrl: normalizedUrl,
-		width: w,
-		quality: q
+		width,
+		quality
 	};
 }
 /**
@@ -174,7 +188,7 @@ function createPassthroughImageResponse(source, config) {
 * cache headers.
 */
 async function handleImageOptimization(request, handlers, allowedWidths, imageConfig) {
-	const params = parseImageParams(new URL(request.url), allowedWidths);
+	const params = parseImageParams(new URL(request.url), allowedWidths, imageConfig?.qualities);
 	if (!params) return badRequestResponse();
 	const { imageUrl, width, quality } = params;
 	const source = await handlers.fetchAsset(imageUrl, request);
@@ -212,4 +226,4 @@ async function handleImageOptimization(request, handlers, allowedWidths, imageCo
 	}
 }
 //#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams };
+export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect };

package/dist/server/implicit-tags.d.ts

@@ -1,5 +1,6 @@
 //#region src/server/implicit-tags.d.ts
 type AppCacheLeafKind = "page" | "route";
+declare function buildAppPageTags(cleanPathname: string, extraTags: string[], routeSegments: readonly string[]): string[];
 declare function buildPageCacheTags(pathname: string, extraTags: string[], routeSegments: string[], leafKind: AppCacheLeafKind): string[];
 //#endregion
-export { buildPageCacheTags };
+export { buildAppPageTags, buildPageCacheTags };

package/dist/server/implicit-tags.js

@@ -29,6 +29,9 @@ function appendDerivedTags(tags, routePath) {
 		appendUnique(tags, `${NEXT_CACHE_IMPLICIT_TAG_ID}${currentPathname}`);
 	}
 }
+function buildAppPageTags(cleanPathname, extraTags, routeSegments) {
+	return buildPageCacheTags(cleanPathname, extraTags, [...routeSegments], "page");
+}
 function buildPageCacheTags(pathname, extraTags, routeSegments, leafKind) {
 	const tags = [pathname, `${NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`];
 	if (pathname === "/") appendUnique(tags, `${NEXT_CACHE_IMPLICIT_TAG_ID}/index`);
@@ -38,4 +41,4 @@ function buildPageCacheTags(pathname, extraTags, routeSegments, leafKind) {
 	return tags.map(encodeCacheTag);
 }
 //#endregion
-export { buildPageCacheTags };
+export { buildAppPageTags, buildPageCacheTags };

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

@@ -14,34 +14,34 @@ type OperationToken = {
   targetSnapshotFingerprint: string;
   cacheVariantFingerprint?: string;
 };
-type RouteSnapshotV0 = {
-  interception: InterceptionSnapshotV0 | null;
+type RouteSnapshot = {
+  interception: InterceptionSnapshot | null;
   interceptionContext: string | null;
   routeId: string;
   layoutIds: readonly string[];
-  mountedParallelSlots: readonly MountedParallelSlotSnapshotV0[];
+  mountedParallelSlots: readonly MountedParallelSlotSnapshot[];
   rootBoundaryId: string | null;
   displayUrl: string;
   matchedUrl: string;
-  slotBindings: readonly ParallelSlotBindingSnapshotV0[];
+  slotBindings: readonly ParallelSlotBindingSnapshot[];
 };
-type InterceptionSnapshotV0 = {
+type InterceptionSnapshot = {
   sourceMatchedUrl: string;
   sourceRouteId: string;
   slotId: string;
   targetMatchedUrl: string;
   targetRouteId: string;
 };
-type MountedParallelSlotSnapshotV0 = {
+type MountedParallelSlotSnapshot = {
   slotId: string;
   ownerLayoutId: string | null;
 };
-type ParallelSlotBindingSnapshotV0 = AppElementsSlotBinding;
-type NavigationPlannerStateV0 = {
+type ParallelSlotBindingSnapshot = AppElementsSlotBinding;
+type NavigationPlannerState = {
   nextOperationToken: OperationToken;
   traceFields?: NavigationTraceFields;
   visibleCommitVersion: number;
-  visibleSnapshot: RouteSnapshotV0;
+  visibleSnapshot: RouteSnapshot;
 };
 type RefreshScope = "visible";
 type TraverseDirection = "back" | "forward" | "unknown";
@@ -62,7 +62,7 @@ type NavigationEvent = {
 } | {
   kind: "flightResponseArrived";
   token: OperationToken;
-  result: FlightResultV0;
+  result: FlightResult;
 };
 type RequestedWork = {
   kind: "flight";
@@ -82,12 +82,12 @@ type CommitProposal = {
   preserveElementIds: readonly string[];
   preservePreviousSlotIds: readonly string[];
   reason: "currentRootBoundary" | "interceptedCurrentRootBoundary" | "unprovenTopologyFallback";
-  targetSnapshot: RouteSnapshotV0;
+  targetSnapshot: RouteSnapshot;
 };
 type NoCommitReason = "prefetchOnly";
 type HardNavigationReason = "cacheProofRejected" | "interceptionProofRejected" | "rootBoundaryChanged";
 type RootBoundaryTransition = "currentRootBoundary" | "rootBoundaryChanged" | "rootBoundaryUnknown";
-type NavigationDecisionV0 = {
+type NavigationDecision = {
   kind: "requestWork";
   token: OperationToken;
   work: RequestedWork;
@@ -109,13 +109,13 @@ type NavigationDecisionV0 = {
   reason: HardNavigationReason;
   trace: NavigationTrace;
 };
-type FlightResultV0 = {
+type FlightResult = {
   cacheEntryReuseProof?: CacheEntryReuseProof;
   href: string;
-  targetSnapshot: RouteSnapshotV0;
+  targetSnapshot: RouteSnapshot;
 };
 type RscFetchResultSource = "cached" | "live";
-type RscFetchResultFactsV0 = {
+type RscFetchResultFacts = {
   source: RscFetchResultSource;
   currentHref: string;
   origin: string;
@@ -130,21 +130,21 @@ type RscFetchResultFactsV0 = {
   responseUrl: string | null;
   streamedRedirectTarget: string | null;
 };
-type RscRedirectFollowV0 = {
+type RscRedirectFollow = {
   href: string;
   historyUpdateMode: "push" | "replace";
   previousNextUrl: string | null;
   redirectDepth: number;
 };
 type RscFetchResultHardNavReason = "invalidRscPayload" | "rscCompatibilityMismatch" | "externalRedirectTarget" | "redirectDepthExhausted" | "streamedRedirectLoop";
-type RscFetchResultDecisionV0 = {
+type RscFetchResultDecision = {
   kind: "proceedToCommit";
   discardBody: false;
   trace: NavigationTrace;
 } | {
   kind: "followRedirect";
   discardBody: boolean;
-  redirect: RscRedirectFollowV0;
+  redirect: RscRedirectFollow;
   trace: NavigationTrace;
 } | {
   kind: "hardNavigate";
@@ -153,14 +153,14 @@ type RscFetchResultDecisionV0 = {
   reason: RscFetchResultHardNavReason;
   trace: NavigationTrace;
 };
-type EarlyNavigationIntentFactsV0 = {
+type EarlyNavigationIntentFacts = {
   basePath: string;
   currentHref: string;
   mode: "push" | "replace";
   scroll: boolean;
   targetHref: string;
 };
-type EarlyNavigationIntentDecisionV0 = {
+type EarlyNavigationIntentDecision = {
   kind: "sameDocumentScroll";
   hash: string;
   mode: "push" | "replace";
@@ -171,20 +171,86 @@ type EarlyNavigationIntentDecisionV0 = {
   bypassNavigationCache: boolean;
   trace: NavigationTrace;
 };
+type NavigationReuseNavigationKind = "navigate" | "refresh" | "traverse";
+type VisitedResponseCacheCandidateFacts = {
+  candidate: "missing";
+  navigationKind: NavigationReuseNavigationKind;
+} | {
+  candidate: "present";
+  fresh: boolean;
+  mountedSlotsMatch: boolean;
+  navigationKind: NavigationReuseNavigationKind;
+};
+type VisitedResponseCacheCandidateDecision = {
+  kind: "miss";
+} | {
+  kind: "evict";
+  reason: "mountedSlotsMismatch" | "refresh" | "stale";
+} | {
+  kind: "reuse";
+};
+type NavigationReuseCandidateAvailability = {
+  status: "available";
+} | {
+  status: "unavailable";
+};
+type OptimisticRouteShellCandidateAvailability = {
+  status: "available";
+} | {
+  status: "unavailable";
+  reason: "routeManifestMissing";
+};
+type NavigationReuseFacts = {
+  bypassNavigationCache: boolean;
+  navigationKind: NavigationReuseNavigationKind;
+  optimisticRouteShell: OptimisticRouteShellCandidateAvailability;
+  prefetch: NavigationReuseCandidateAvailability;
+  targetHref: string;
+  visitedResponse: NavigationReuseCandidateAvailability;
+};
+type FreshFetchReason = "cacheBypassed" | "cacheMiss" | "refresh" | "routeManifestMissing";
+type NavigationReuseDecision = {
+  kind: "reuseVisitedResponse";
+  trace: NavigationTrace;
+} | {
+  kind: "consumePrefetch";
+  trace: NavigationTrace;
+} | {
+  kind: "attemptOptimisticRouteShell";
+  trace: NavigationTrace;
+} | {
+  kind: "fetchFresh";
+  reason: FreshFetchReason;
+  trace: NavigationTrace;
+};
+type NavigationPrefetchProbeFacts = {
+  bypassNavigationCache: boolean;
+  navigationKind: NavigationReuseNavigationKind;
+  visitedResponse: NavigationReuseCandidateAvailability;
+};
+type NavigationPrefetchProbeDecision = {
+  kind: "probe";
+} | {
+  kind: "skip";
+  reason: "cacheBypassed" | "refresh" | "visitedResponseAvailable";
+};
 type NavigationPlannerInput = {
   routeManifest: RouteManifest | null;
-  state: NavigationPlannerStateV0;
+  state: NavigationPlannerState;
   event: NavigationEvent;
 };
 type AcceptedCacheEntryReuseDecision = Extract<CacheEntryReuseDecision, {
   canReuse: true;
 }>;
-declare function classifyRscFetchResult(facts: RscFetchResultFactsV0): RscFetchResultDecisionV0;
-declare function classifyEarlyNavigationIntent(facts: EarlyNavigationIntentFactsV0): EarlyNavigationIntentDecisionV0;
+declare function classifyRscFetchResult(facts: RscFetchResultFacts): RscFetchResultDecision;
+declare function classifyEarlyNavigationIntent(facts: EarlyNavigationIntentFacts): EarlyNavigationIntentDecision;
+declare function classifyVisitedResponseCacheCandidate(facts: VisitedResponseCacheCandidateFacts): VisitedResponseCacheCandidateDecision;
+declare function classifyNavigationReuse(facts: NavigationReuseFacts): NavigationReuseDecision;
+declare function classifyNavigationPrefetchProbe(facts: NavigationPrefetchProbeFacts): NavigationPrefetchProbeDecision;
 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[];
-declare function resolveCurrentRootBoundaryElementPersistence(currentSnapshot: RouteSnapshotV0, targetSnapshot: RouteSnapshotV0): readonly string[];
+declare function resolveSameLayoutAncestorPersistence(currentSnapshot: RouteSnapshot, targetSnapshot: RouteSnapshot): readonly string[];
+declare function resolveMountedParallelSlotPersistence(currentSnapshot: RouteSnapshot, targetSnapshot: RouteSnapshot): readonly string[];
+declare function resolveCurrentRootBoundaryElementPersistence(currentSnapshot: RouteSnapshot, targetSnapshot: RouteSnapshot): readonly string[];
 /**
  * Default/unmatched slot preservation law:
  *
@@ -196,19 +262,56 @@ declare function resolveCurrentRootBoundaryElementPersistence(currentSnapshot: R
  * Wire absence and UNMATCHED_SLOT markers are not semantic proof.
  */
 declare function resolveDefaultOrUnmatchedSlotPersistenceForLayouts(options: {
-  currentSlotBindings: readonly ParallelSlotBindingSnapshotV0[];
+  currentSlotBindings: readonly ParallelSlotBindingSnapshot[];
   preservedLayoutIds: readonly string[];
-  targetSlotBindings: readonly ParallelSlotBindingSnapshotV0[];
+  targetSlotBindings: readonly ParallelSlotBindingSnapshot[];
 }): readonly string[];
-declare function planNavigation(input: NavigationPlannerInput): NavigationDecisionV0;
+declare function planNavigation(input: NavigationPlannerInput): NavigationDecision;
+type ServerActionResultFacts = {
+  actionRedirectHref: string | null;
+  actionRedirectType: "push" | "replace";
+  clientCompatibilityId: string | null;
+  compatibilityIdHeader: string | null;
+  currentHref: string;
+  isRscContentType: boolean;
+  origin: string;
+  responseUrl: string | null;
+};
+type ServerActionResultDecision = {
+  kind: "proceed";
+  trace: NavigationTrace;
+} | {
+  kind: "hardNavigate";
+  url: string;
+  historyMode?: "assign" | "replace";
+  clearClientNavigationCaches: boolean;
+  reason: "serverActionRedirectCompatibilityMismatch" | "serverActionRscCompatibilityMismatch";
+  trace: NavigationTrace;
+};
+type RscNavigationErrorFacts = {
+  currentHref: string;
+};
+type RscNavigationErrorDecision = {
+  kind: "hardNavigate";
+  url: string;
+  reason: "rscNavigationError";
+  trace: NavigationTrace;
+};
+declare function classifyServerActionResult(facts: ServerActionResultFacts): ServerActionResultDecision;
+declare function classifyRscNavigationError(facts: RscNavigationErrorFacts): RscNavigationErrorDecision;
 declare const navigationPlanner: {
   classifyEarlyNavigationIntent: typeof classifyEarlyNavigationIntent;
+  classifyNavigationPrefetchProbe: typeof classifyNavigationPrefetchProbe;
+  classifyNavigationReuse: typeof classifyNavigationReuse;
   classifyRscFetchResult: typeof classifyRscFetchResult;
+  classifyRscNavigationError: typeof classifyRscNavigationError;
   classifyRootBoundaryTransition: typeof classifyRootBoundaryTransition;
+  classifyServerActionResult: typeof classifyServerActionResult;
+  classifyVisitedResponseCacheCandidate: typeof classifyVisitedResponseCacheCandidate;
   plan: typeof planNavigation;
   resolveCurrentRootBoundaryElementPersistence: typeof resolveCurrentRootBoundaryElementPersistence;
   resolveMountedParallelSlotPersistence: typeof resolveMountedParallelSlotPersistence;
   resolveSameLayoutAncestorPersistence: typeof resolveSameLayoutAncestorPersistence;
 };
 //#endregion
-export { EarlyNavigationIntentDecisionV0, EarlyNavigationIntentFactsV0, FlightResultV0, InterceptionSnapshotV0, MountedParallelSlotSnapshotV0, NavigationDecisionV0, NavigationEvent, NavigationPlannerInput, NavigationPlannerStateV0, OperationLane, OperationToken, ParallelSlotBindingSnapshotV0, RefreshScope, RootBoundaryTransition, RouteSnapshotV0, RscFetchResultDecisionV0, RscFetchResultFactsV0, TraverseDirection, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };
+export { EarlyNavigationIntentDecision, EarlyNavigationIntentFacts, FlightResult, InterceptionSnapshot, MountedParallelSlotSnapshot, NavigationDecision, NavigationEvent, NavigationPlannerInput, NavigationPlannerState, NavigationReuseDecision, NavigationReuseFacts, OperationLane, OperationToken, ParallelSlotBindingSnapshot, RefreshScope, RootBoundaryTransition, RouteSnapshot, RscFetchResultDecision, RscFetchResultFacts, RscNavigationErrorDecision, RscNavigationErrorFacts, ServerActionResultDecision, ServerActionResultFacts, TraverseDirection, VisitedResponseCacheCandidateFacts, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };

package/dist/server/navigation-planner.js

@@ -213,6 +213,71 @@ function classifyEarlyNavigationIntent(facts) {
 		trace: createEarlyNavigationIntentTrace(NavigationTraceReasonCodes.crossDocumentFlight, facts)
 	};
 }
+function classifyVisitedResponseCacheCandidate(facts) {
+	if (facts.candidate === "missing") return { kind: "miss" };
+	if (!facts.mountedSlotsMatch) return {
+		kind: "evict",
+		reason: "mountedSlotsMismatch"
+	};
+	if (facts.navigationKind === "refresh") return {
+		kind: "evict",
+		reason: "refresh"
+	};
+	if (!facts.fresh) return {
+		kind: "evict",
+		reason: "stale"
+	};
+	return { kind: "reuse" };
+}
+function createNavigationReuseTrace(code, facts, fields = {}) {
+	return createNavigationTrace(code, {
+		eventKind: facts.navigationKind,
+		targetHref: facts.targetHref,
+		...fields
+	});
+}
+function createFreshFetchDecision(facts, reason) {
+	return {
+		kind: "fetchFresh",
+		reason,
+		trace: createNavigationReuseTrace(NavigationTraceReasonCodes.fetchFresh, facts, { freshFetchReason: reason })
+	};
+}
+function classifyNavigationReuse(facts) {
+	if (facts.navigationKind === "refresh") return createFreshFetchDecision(facts, "refresh");
+	if (!facts.bypassNavigationCache && facts.visitedResponse.status === "available") return {
+		kind: "reuseVisitedResponse",
+		trace: createNavigationReuseTrace(NavigationTraceReasonCodes.visitedResponseReuse, facts)
+	};
+	if (!facts.bypassNavigationCache && facts.prefetch.status === "available") return {
+		kind: "consumePrefetch",
+		trace: createNavigationReuseTrace(NavigationTraceReasonCodes.prefetchResponseReuse, facts)
+	};
+	if (facts.navigationKind === "navigate") {
+		if (facts.optimisticRouteShell.status === "available") return {
+			kind: "attemptOptimisticRouteShell",
+			trace: createNavigationReuseTrace(NavigationTraceReasonCodes.optimisticRouteShell, facts)
+		};
+		return createFreshFetchDecision(facts, facts.bypassNavigationCache ? "cacheBypassed" : facts.optimisticRouteShell.reason);
+	}
+	if (facts.bypassNavigationCache) return createFreshFetchDecision(facts, "cacheBypassed");
+	return createFreshFetchDecision(facts, "cacheMiss");
+}
+function classifyNavigationPrefetchProbe(facts) {
+	if (facts.visitedResponse.status === "available") return {
+		kind: "skip",
+		reason: "visitedResponseAvailable"
+	};
+	if (facts.navigationKind === "refresh") return {
+		kind: "skip",
+		reason: "refresh"
+	};
+	if (facts.bypassNavigationCache) return {
+		kind: "skip",
+		reason: "cacheBypassed"
+	};
+	return { kind: "probe" };
+}
 function createSnapshotRouteTopology(snapshot) {
 	return {
 		layoutIds: snapshot.layoutIds,
@@ -680,10 +745,59 @@ function planNavigation(input) {
 		}
 	}
 }
+function classifyServerActionResult(facts) {
+	if (facts.clientCompatibilityId === null) return {
+		kind: "proceed",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.proceedToCommit, {})
+	};
+	if (!facts.isRscContentType) return {
+		kind: "proceed",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.proceedToCommit, {})
+	};
+	if (resolveRscCompatibilityNavigationDecision({
+		clientCompatibilityId: facts.clientCompatibilityId,
+		currentHref: facts.currentHref,
+		origin: facts.origin,
+		responseCompatibilityId: facts.compatibilityIdHeader,
+		responseUrl: facts.responseUrl
+	}).kind === "compatible") return {
+		kind: "proceed",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.proceedToCommit, {})
+	};
+	if (facts.actionRedirectHref !== null) return {
+		kind: "hardNavigate",
+		url: facts.actionRedirectHref,
+		historyMode: facts.actionRedirectType === "push" ? "assign" : "replace",
+		clearClientNavigationCaches: true,
+		reason: "serverActionRedirectCompatibilityMismatch",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.serverActionRedirectCompatibilityMismatch, { targetHref: facts.actionRedirectHref })
+	};
+	const targetUrl = facts.currentHref;
+	return {
+		kind: "hardNavigate",
+		url: targetUrl,
+		clearClientNavigationCaches: false,
+		reason: "serverActionRscCompatibilityMismatch",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.serverActionRscCompatibilityMismatch, { targetHref: targetUrl })
+	};
+}
+function classifyRscNavigationError(facts) {
+	return {
+		kind: "hardNavigate",
+		url: facts.currentHref,
+		reason: "rscNavigationError",
+		trace: createNavigationTrace(NavigationTraceReasonCodes.rscNavigationError, { targetHref: facts.currentHref })
+	};
+}
 const navigationPlanner = {
 	classifyEarlyNavigationIntent,
+	classifyNavigationPrefetchProbe,
+	classifyNavigationReuse,
 	classifyRscFetchResult,
+	classifyRscNavigationError,
 	classifyRootBoundaryTransition,
+	classifyServerActionResult,
+	classifyVisitedResponseCacheCandidate,
 	plan: planNavigation,
 	resolveCurrentRootBoundaryElementPersistence,
 	resolveMountedParallelSlotPersistence,

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

@@ -5,6 +5,7 @@ declare const NavigationTraceReasonCodes: {
   cacheProofRejected: "NC_CACHE_REJECT";
   commitCurrent: "NC_COMMIT";
   crossDocumentFlight: "NC_CROSS_DOC_FLIGHT";
+  fetchFresh: "NC_FETCH_FRESH";
   invalidRscPayload: "NC_RSC_INVALID";
   interceptedCommitCurrent: "NC_INTERCEPT_COMMIT";
   interceptedRejectedIncompatibleRoot: "NC_INTERCEPT_REJECT_ROOT";
@@ -13,7 +14,9 @@ declare const NavigationTraceReasonCodes: {
   interceptedRejectedTargetMismatch: "NC_INTERCEPT_REJECT_TARGET";
   interceptedRejectedUndeclaredTopology: "NC_INTERCEPT_REJECT_GRAPH";
   interceptedRejectedUnknownSource: "NC_INTERCEPT_REJECT_SOURCE";
+  optimisticRouteShell: "NC_OPTIMISTIC_SHELL";
   prefetchOnly: "NC_PREFETCH_ONLY";
+  prefetchResponseReuse: "NC_PREFETCH_REUSE";
   proceedToCommit: "NC_RSC_PROCEED";
   redirectFollow: "NC_RSC_REDIRECT_FOLLOW";
   redirectTerminalDepth: "NC_RSC_REDIRECT_DEPTH";
@@ -22,10 +25,14 @@ declare const NavigationTraceReasonCodes: {
   rootBoundaryChanged: "NC_ROOT";
   rootBoundaryUnknown: "NC_ROOT_UNKNOWN";
   rscCompatibilityMismatch: "NC_RSC_COMPAT_MISMATCH";
+  rscNavigationError: "NC_RSC_NAV_ERROR";
   sameDocumentScroll: "NC_SAME_DOC_SCROLL";
   samePageSearch: "NC_SAME_PAGE_SEARCH";
+  serverActionRedirectCompatibilityMismatch: "NC_SA_REDIRECT_COMPAT";
+  serverActionRscCompatibilityMismatch: "NC_SA_RSC_COMPAT";
   staleOperation: "NC_STALE";
   streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP";
+  visitedResponseReuse: "NC_VISITED_REUSE";
 };
 declare const NavigationTraceTransactionCodes: {
   hardNavigate: "NT_HARD_NAVIGATE";
@@ -35,7 +42,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" | "fetchResultSource" | "operationLane" | "pendingOperationId" | "redirectDepth" | "redirectSignal" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
+type NavigationTraceFieldName = "activeNavigationId" | "cacheProofCode" | "cacheProofMode" | "cacheProofReuseClass" | "cacheProofScope" | "currentRootLayoutTreePath" | "currentVisibleCommitVersion" | "nextRootLayoutTreePath" | "eventKind" | "fetchResultSource" | "freshFetchReason" | "operationLane" | "pendingOperationId" | "redirectDepth" | "redirectSignal" | "startedVisibleCommitVersion" | "startedNavigationId" | "targetHref" | "traverseDirection";
 type NavigationTraceFieldValue = string | number | boolean | null;
 type NavigationTraceFields = Readonly<Partial<Record<NavigationTraceFieldName, NavigationTraceFieldValue>>>;
 type NavigationTraceEntry = Readonly<{

package/dist/server/navigation-trace.js

@@ -4,6 +4,7 @@ const NavigationTraceReasonCodes = {
 	cacheProofRejected: "NC_CACHE_REJECT",
 	commitCurrent: "NC_COMMIT",
 	crossDocumentFlight: "NC_CROSS_DOC_FLIGHT",
+	fetchFresh: "NC_FETCH_FRESH",
 	invalidRscPayload: "NC_RSC_INVALID",
 	interceptedCommitCurrent: "NC_INTERCEPT_COMMIT",
 	interceptedRejectedIncompatibleRoot: "NC_INTERCEPT_REJECT_ROOT",
@@ -12,7 +13,9 @@ const NavigationTraceReasonCodes = {
 	interceptedRejectedTargetMismatch: "NC_INTERCEPT_REJECT_TARGET",
 	interceptedRejectedUndeclaredTopology: "NC_INTERCEPT_REJECT_GRAPH",
 	interceptedRejectedUnknownSource: "NC_INTERCEPT_REJECT_SOURCE",
+	optimisticRouteShell: "NC_OPTIMISTIC_SHELL",
 	prefetchOnly: "NC_PREFETCH_ONLY",
+	prefetchResponseReuse: "NC_PREFETCH_REUSE",
 	proceedToCommit: "NC_RSC_PROCEED",
 	redirectFollow: "NC_RSC_REDIRECT_FOLLOW",
 	redirectTerminalDepth: "NC_RSC_REDIRECT_DEPTH",
@@ -21,10 +24,14 @@ const NavigationTraceReasonCodes = {
 	rootBoundaryChanged: "NC_ROOT",
 	rootBoundaryUnknown: "NC_ROOT_UNKNOWN",
 	rscCompatibilityMismatch: "NC_RSC_COMPAT_MISMATCH",
+	rscNavigationError: "NC_RSC_NAV_ERROR",
 	sameDocumentScroll: "NC_SAME_DOC_SCROLL",
 	samePageSearch: "NC_SAME_PAGE_SEARCH",
+	serverActionRedirectCompatibilityMismatch: "NC_SA_REDIRECT_COMPAT",
+	serverActionRscCompatibilityMismatch: "NC_SA_RSC_COMPAT",
 	staleOperation: "NC_STALE",
-	streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP"
+	streamedRedirectLoop: "NC_RSC_STREAMED_REDIRECT_LOOP",
+	visitedResponseReuse: "NC_VISITED_REUSE"
 };
 const NavigationTraceTransactionCodes = {
 	hardNavigate: "NT_HARD_NAVIGATE",

package/dist/server/pages-api-route.d.ts

@@ -1,3 +1,4 @@
+import { NextI18nConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
 import { PagesReqResRequest, PagesReqResResponse, PagesRequestQuery } from "./pages-node-compat.js";
@@ -71,6 +72,11 @@ type HandlePagesApiRouteOptions = {
   reportRequestError?: (error: Error, routePattern: string) => void | Promise<void>;
   request: Request;
   url: string;
+  nextConfig?: {
+    basePath?: string;
+    i18n?: NextI18nConfig | null;
+    trailingSlash?: boolean;
+  };
 };
 declare function handlePagesApiRoute(options: HandlePagesApiRouteOptions): Promise<Response>;
 //#endregion

package/dist/server/pages-api-route.js

@@ -2,7 +2,8 @@ import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import { NextRequest } from "../shims/server.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
-import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { cloneRequestWithUrl } from "./request-pipeline.js";
+import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { PagesBodyParseError } from "./pages-media-type.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { resolveBodyParserConfig } from "./pages-body-parser-config.js";
@@ -14,6 +15,12 @@ function resolveModuleRuntime(module) {
 function buildPagesApiQuery(url, params) {
 	return mergeRouteParamsIntoQuery(parseQueryString(url), params);
 }
+function createEdgeApiRequest(request, url, params) {
+	const resolvedUrl = new URL(request.url);
+	resolvedUrl.search = urlQueryToSearchParams(buildPagesApiQuery(url, params)).toString();
+	const resolvedUrlString = resolvedUrl.toString();
+	return resolvedUrlString === request.url ? request : cloneRequestWithUrl(request, resolvedUrlString);
+}
 function isEdgeApiRouteModule(module) {
 	return typeof module.default === "function" && isEdgeApiRuntime(resolveModuleRuntime(module));
 }
@@ -29,7 +36,11 @@ async function _handlePagesApiRoute(options) {
 	const { route, params } = options.match;
 	try {
 		if (isEdgeApiRouteModule(route.module)) {
-			const nextRequest = new NextRequest(options.request);
+			const nextRequest = new NextRequest(createEdgeApiRequest(options.request, options.url, params), options.nextConfig ? { nextConfig: {
+				basePath: options.nextConfig.basePath,
+				i18n: options.nextConfig.i18n ?? void 0,
+				trailingSlash: options.nextConfig.trailingSlash
+			} } : void 0);
 			const response = await route.module.default(nextRequest);
 			if (response instanceof Response) return response;
 			throw new Error("Edge API route did not return a Response");