vinext 0.1.2 → 0.1.4

package/dist/server/hybrid-route-priority.d.ts

@@ -0,0 +1,22 @@
+//#region src/server/hybrid-route-priority.d.ts
+type HybridRoutePriorityRoute = {
+  isDynamic: boolean;
+  pattern: string;
+  sourcePath?: string | null;
+};
+declare function validateHybridRouteConflicts(pagesRoutes: readonly HybridRoutePriorityRoute[], appRoutes: readonly HybridRoutePriorityRoute[]): void;
+/**
+ * Return whether a matched Pages Router route should own the request instead
+ * of a matched App Router route.
+ *
+ * Next.js registers Pages providers before App providers, then sorts all
+ * dynamic route pathnames together in DefaultRouteMatcherManager. Vinext keeps
+ * separate route tries for each router, so the hybrid boundary needs to apply
+ * that same cross-router ordering after both routers have produced their best
+ * local match. The decision itself lives in
+ * `routing/utils.ts#compareHybridRoutePatterns` so the server and client
+ * always reach the same answer.
+ */
+declare function pagesRouteHasPriorityOverAppRoute(pagesRoute: HybridRoutePriorityRoute, appRoute: HybridRoutePriorityRoute | null): boolean;
+//#endregion
+export { HybridRoutePriorityRoute, pagesRouteHasPriorityOverAppRoute, validateHybridRouteConflicts };

package/dist/server/hybrid-route-priority.js

@@ -0,0 +1,33 @@
+import { compareHybridRoutePatterns } from "../routing/utils.js";
+import { validateRoutePatterns } from "../routing/route-validation.js";
+//#region src/server/hybrid-route-priority.ts
+function validateHybridRouteConflicts(pagesRoutes, appRoutes) {
+	const pagesByPattern = new Map(pagesRoutes.map((route) => [route.pattern, route]));
+	const conflicts = appRoutes.flatMap((appRoute) => {
+		const pagesRoute = pagesByPattern.get(appRoute.pattern);
+		return pagesRoute === void 0 ? [] : [[pagesRoute, appRoute]];
+	});
+	if (conflicts.length > 0) {
+		const message = `Conflicting app and page file${conflicts.length === 1 ? " was" : "s were"} found, please remove the conflicting files to continue:`;
+		throw new Error(`${message}\n${conflicts.map(([pagesRoute, appRoute]) => `  "${pagesRoute.sourcePath ?? pagesRoute.pattern}" - "${appRoute.sourcePath ?? appRoute.pattern}"`).join("\n")}`);
+	}
+	validateRoutePatterns([...pagesRoutes.map((route) => route.pattern), ...appRoutes.map((route) => route.pattern)]);
+}
+/**
+* Return whether a matched Pages Router route should own the request instead
+* of a matched App Router route.
+*
+* Next.js registers Pages providers before App providers, then sorts all
+* dynamic route pathnames together in DefaultRouteMatcherManager. Vinext keeps
+* separate route tries for each router, so the hybrid boundary needs to apply
+* that same cross-router ordering after both routers have produced their best
+* local match. The decision itself lives in
+* `routing/utils.ts#compareHybridRoutePatterns` so the server and client
+* always reach the same answer.
+*/
+function pagesRouteHasPriorityOverAppRoute(pagesRoute, appRoute) {
+	if (appRoute === null) return true;
+	return compareHybridRoutePatterns(pagesRoute.pattern, pagesRoute.isDynamic, appRoute.pattern, appRoute.isDynamic) === "pages";
+}
+//#endregion
+export { pagesRouteHasPriorityOverAppRoute, validateHybridRouteConflicts };

package/dist/server/image-optimization.d.ts

@@ -33,7 +33,15 @@ declare function isImageOptimizationPath(pathname: string): boolean;
  * Controls SVG handling and security headers for the image endpoint.
  */
 type ImageConfig = {
-  /** Allow SVG through the image optimization endpoint. Default: false. */dangerouslyAllowSVG?: boolean;
+  /** Allowed device widths. Defaults to Next.js device sizes. */deviceSizes?: number[]; /** Allowed fixed-image widths. Defaults to Next.js image sizes. */
+  imageSizes?: number[];
+  /**
+   * Allowed output qualities. When unset, any quality from 1-100 is permitted
+   * (matches Next.js: an unset `images.qualities` is not restricted to a single
+   * value). When set, only the listed qualities are accepted.
+   */
+  qualities?: number[]; /** Allow SVG through the image optimization endpoint. Default: false. */
+  dangerouslyAllowSVG?: boolean;
   /**
    * Allow image optimization for hostnames that resolve to private IP addresses.
    * Default: false.
@@ -54,18 +62,19 @@ type ImageConfig = {
  */
 declare const DEFAULT_DEVICE_SIZES: number[];
 declare const DEFAULT_IMAGE_SIZES: number[];
+type ParseImageParamsOptions = {
+  isDev?: boolean;
+};
+declare function resolveDevImageRedirect(requestUrl: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): string | null;
 /**
  * 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
  */
-declare function parseImageParams(url: URL, allowedWidths?: number[]): {
+declare function parseImageParams(url: URL, allowedWidths?: number[], allowedQualities?: number[], options?: ParseImageParamsOptions): {
   imageUrl: string;
   width: number;
   quality: number;
@@ -113,4 +122,4 @@ type ImageHandlers = {
  */
 declare function handleImageOptimization(request: Request, handlers: ImageHandlers, allowedWidths?: number[], imageConfig?: ImageConfig): Promise<Response>;
 //#endregion
-export { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, IMAGE_CACHE_CONTROL, IMAGE_CONTENT_SECURITY_POLICY, IMAGE_OPTIMIZATION_PATH, ImageConfig, ImageHandlers, 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, ImageConfig, ImageHandlers, ParseImageParamsOptions, VINEXT_IMAGE_OPTIMIZATION_PATH, handleImageOptimization, isImageOptimizationPath, isSafeImageContentType, negotiateImageFormat, parseImageParams, resolveDevImageRedirect };

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/middleware-matcher.js

@@ -1,5 +1,5 @@
 import { removeTrailingSlash } from "../utils/base-path.js";
-import { checkHasConditions, requestContextFromRequest, safeRegExp } from "../config/config-matchers.js";
+import { checkHasConditions, isSafeRegex, requestContextFromRequest, safeRegExp } from "../config/config-matchers.js";
 //#region src/server/middleware-matcher.ts
 const EMPTY_MIDDLEWARE_REQUEST_CONTEXT = {
 	headers: new Headers(),
@@ -7,6 +7,7 @@ const EMPTY_MIDDLEWARE_REQUEST_CONTEXT = {
 	query: new URLSearchParams(),
 	host: ""
 };
+const UNSAFE_MATCHER_PATTERN = Symbol("unsafe matcher pattern");
 const _mwPatternCache = /* @__PURE__ */ new Map();
 function matchesMiddleware(pathname, matcher, request, i18nConfig) {
 	if (!matcher) return true;
@@ -55,6 +56,7 @@ function matchPattern(pathname, pattern) {
 		cached = compileMatcherPattern(pattern);
 		_mwPatternCache.set(pattern, cached);
 	}
+	if (cached === UNSAFE_MATCHER_PATTERN) return true;
 	if (cached === null) return pathname === pattern;
 	return cached.test(pathname);
 }
@@ -74,7 +76,7 @@ function extractConstraint(str, re) {
 }
 function compileMatcherPattern(pattern) {
 	const hasConstraints = /:[\w-]+[*+]?\(/.test(pattern);
-	if (!hasConstraints && (pattern.includes("(") || pattern.includes("\\"))) return safeRegExp("^" + pattern + "$");
+	if (!hasConstraints && (pattern.includes("(") || pattern.includes("\\"))) return compileMatcherRegExp("^" + pattern + "$", pattern);
 	let regexStr = "";
 	const tokenRe = /\/:([\w-]+)\*|\/:([\w-]+)\+|:([\w-]+)|[.]|[^/:.]+|./g;
 	let tok;
@@ -94,7 +96,14 @@ function compileMatcherPattern(pattern) {
 		else regexStr += group;
 	} else if (tok[0] === ".") regexStr += "\\.";
 	else regexStr += tok[0];
-	return safeRegExp("^" + regexStr + "$");
+	return compileMatcherRegExp("^" + regexStr + "$", pattern);
+}
+function compileMatcherRegExp(regexPattern, sourcePattern) {
+	if (!isSafeRegex(regexPattern)) {
+		console.warn(`[vinext] Rejecting potentially unsafe middleware matcher (ReDoS risk): ${sourcePattern}\n  Middleware will run for all paths to avoid bypassing request guards.\n  Simplify the matcher to avoid nested repetition.`);
+		return UNSAFE_MATCHER_PATTERN;
+	}
+	return safeRegExp(regexPattern);
 }
 //#endregion
 export { matchPattern, matchesMiddleware };

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

@@ -35,10 +35,9 @@ type ExecuteMiddlewareOptions = {
   i18nConfig?: NextI18nConfig | null;
   includeErrorDetails?: boolean;
   /**
-   * Whether the incoming request was a Next.js `_next/data` fetch (carried
-   * `x-nextjs-data: 1`). The header itself is stripped by `filterInternalHeaders`
-   * before the middleware request is constructed, so callers must capture this
-   * flag from the raw incoming headers and forward it explicitly.
+   * Whether the incoming request was recognized as a Next.js `_next/data`
+   * fetch. Internal headers are stripped before middleware runs, so adapters
+   * must derive and forward this from trusted URL normalization.
    */
   isDataRequest?: boolean;
   isProxy: boolean;

package/dist/server/middleware-runtime.js

@@ -142,6 +142,8 @@ async function executeMiddleware(options) {
 			response: internalServerErrorResponse(options.includeErrorDetails ? "Middleware Error: " + (e instanceof Error ? e.message : String(e)) : "Internal Server Error"),
 			waitUntilPromises
 		};
+	} finally {
+		if (process.env.NODE_ENV !== "development" && nextRequest.body) nextRequest.body.cancel().catch(() => {});
 	}
 	const waitUntilPromises = drainFetchEvent(fetchEvent);
 	if (!response) return {

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

@@ -2,46 +2,37 @@ import { RouteManifest } from "../routing/app-route-graph.js";
 import { CacheEntryReuseDecision, CacheEntryReuseProof } from "./cache-proof.js";
 import { AppElementsSlotBinding } from "./app-elements-wire.js";
 import { NavigationTrace, NavigationTraceFields } from "./navigation-trace.js";
+import { OperationLane, OperationToken } from "./operation-token.js";
 
 //#region src/server/navigation-planner.d.ts
-type OperationLane = "hmr" | "navigation" | "prefetch" | "refresh" | "server-action" | "traverse";
-type OperationToken = {
-  operationId: number;
-  lane: OperationLane;
-  baseVisibleCommitVersion: number;
-  graphVersion: string | null;
-  deploymentVersion: string | null;
-  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 +53,7 @@ type NavigationEvent = {
 } | {
   kind: "flightResponseArrived";
   token: OperationToken;
-  result: FlightResultV0;
+  result: FlightResult;
 };
 type RequestedWork = {
   kind: "flight";
@@ -82,12 +73,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 HardNavigationReason = "cacheProofRejected" | "cacheReuseTokenRejected" | "interceptionProofRejected" | "rootBoundaryChanged";
 type RootBoundaryTransition = "currentRootBoundary" | "rootBoundaryChanged" | "rootBoundaryUnknown";
-type NavigationDecisionV0 = {
+type NavigationDecision = {
   kind: "requestWork";
   token: OperationToken;
   work: RequestedWork;
@@ -109,13 +100,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 +121,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 +144,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 +162,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 +253,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, type OperationLane, type OperationToken, ParallelSlotBindingSnapshot, RefreshScope, RootBoundaryTransition, RouteSnapshot, RscFetchResultDecision, RscFetchResultFacts, RscNavigationErrorDecision, RscNavigationErrorFacts, ServerActionResultDecision, ServerActionResultFacts, TraverseDirection, VisitedResponseCacheCandidateFacts, navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts };