vinext 0.1.1 → 0.1.3

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,23 +109,148 @@ type NavigationDecisionV0 = {
   reason: HardNavigationReason;
   trace: NavigationTrace;
 };
-type FlightResultV0 = {
+type FlightResult = {
   cacheEntryReuseProof?: CacheEntryReuseProof;
   href: string;
-  targetSnapshot: RouteSnapshotV0;
+  targetSnapshot: RouteSnapshot;
+};
+type RscFetchResultSource = "cached" | "live";
+type RscFetchResultFacts = {
+  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 RscRedirectFollow = {
+  href: string;
+  historyUpdateMode: "push" | "replace";
+  previousNextUrl: string | null;
+  redirectDepth: number;
+};
+type RscFetchResultHardNavReason = "invalidRscPayload" | "rscCompatibilityMismatch" | "externalRedirectTarget" | "redirectDepthExhausted" | "streamedRedirectLoop";
+type RscFetchResultDecision = {
+  kind: "proceedToCommit";
+  discardBody: false;
+  trace: NavigationTrace;
+} | {
+  kind: "followRedirect";
+  discardBody: boolean;
+  redirect: RscRedirectFollow;
+  trace: NavigationTrace;
+} | {
+  kind: "hardNavigate";
+  discardBody: boolean;
+  url: string;
+  reason: RscFetchResultHardNavReason;
+  trace: NavigationTrace;
+};
+type EarlyNavigationIntentFacts = {
+  basePath: string;
+  currentHref: string;
+  mode: "push" | "replace";
+  scroll: boolean;
+  targetHref: string;
+};
+type EarlyNavigationIntentDecision = {
+  kind: "sameDocumentScroll";
+  hash: string;
+  mode: "push" | "replace";
+  scroll: boolean;
+  trace: NavigationTrace;
+} | {
+  kind: "flightNavigation";
+  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: 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:
  *
@@ -137,17 +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 { FlightResultV0, InterceptionSnapshotV0, MountedParallelSlotSnapshotV0, NavigationDecisionV0, NavigationEvent, NavigationPlannerInput, NavigationPlannerStateV0, OperationLane, OperationToken, ParallelSlotBindingSnapshotV0, RefreshScope, RootBoundaryTransition, RouteSnapshotV0, 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

@@ -1,7 +1,10 @@
 import { splitPathnameForRouteMatch } from "../routing/utils.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,254 @@ 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 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,
@@ -494,8 +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

@@ -4,6 +4,9 @@ type NavigationTraceSchemaVersion = 0;
 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";
   interceptedRejectedMissingProof: "NC_INTERCEPT_REJECT_MISSING_PROOF";
@@ -11,11 +14,25 @@ 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";
+  redirectTerminalExternal: "NC_RSC_REDIRECT_EXTERNAL";
   requestWork: "NC_REQUEST";
   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";
@@ -25,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" | "operationLane" | "pendingOperationId" | "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

@@ -3,6 +3,9 @@ const NAVIGATION_TRACE_SCHEMA_VERSION = 0;
 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",
 	interceptedRejectedMissingProof: "NC_INTERCEPT_REJECT_MISSING_PROOF",
@@ -10,11 +13,25 @@ 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",
+	redirectTerminalExternal: "NC_RSC_REDIRECT_EXTERNAL",
 	requestWork: "NC_REQUEST",
 	rootBoundaryChanged: "NC_ROOT",
 	rootBoundaryUnknown: "NC_ROOT_UNKNOWN",
-	staleOperation: "NC_STALE"
+	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"
 };
 const NavigationTraceTransactionCodes = {
 	hardNavigate: "NT_HARD_NAVIGATE",