vinext 0.1.7 → 0.2.0

package/dist/server/app-browser-history-controller.js

@@ -1,5 +1,9 @@
 import { RestorableClientStateController, createHistoryStateWithNavigationMetadata, readHistoryStateBfcacheIds, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 //#region src/server/app-browser-history-controller.ts
+function createCanonicalBrowserHistoryHref(href) {
+	const url = new URL(href);
+	return `${url.pathname}${url.search}${url.hash}`;
+}
 function stripVinextScrollState(state) {
 	if (!state || typeof state !== "object") return state;
 	const nextState = {};
@@ -166,7 +170,7 @@ var AppBrowserHistoryController = class {
 		this.#replaceHistoryState(createHistoryStateWithNavigationMetadata(this.#readHistoryState(), {
 			previousNextUrl: null,
 			traversalIndex: this.#currentHistoryTraversalIndex
-		}), this.#readCurrentHref());
+		}), createCanonicalBrowserHistoryHref(this.#readCurrentHref()));
 	}
 	/** History write performed on the first committed (hydrated) render. */
 	writeHydratedHistoryMetadata(options) {
@@ -207,4 +211,4 @@ function areBfcacheIdMapsEqual(a, b) {
 	return aEntries.every(([key, value]) => b[key] === value);
 }
 //#endregion
-export { AppBrowserHistoryController };
+export { AppBrowserHistoryController, createCanonicalBrowserHistoryHref };

package/dist/server/app-browser-interception-context.d.ts

@@ -3,6 +3,7 @@ import { RouteManifest } from "../routing/app-route-graph.js";
 //#region src/server/app-browser-interception-context.d.ts
 type ResolveManifestNavigationInterceptionContextOptions = {
   basePath: string;
+  currentMatchedPathname?: string | null;
   currentPathname: string;
   routeManifest: RouteManifest | null;
   targetPathname: string;

package/dist/server/app-browser-interception-context.js

@@ -29,13 +29,15 @@ function resolveManifestNavigationInterceptionContext(options) {
 function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
 	if (options.routeManifest === null) return null;
 	const currentPathname = stripBasePath(options.currentPathname, options.basePath);
+	const currentMatchedPathname = options.currentMatchedPathname ? stripBasePath(options.currentMatchedPathname, options.basePath) : null;
 	const targetPathname = stripBasePath(options.targetPathname, options.basePath);
 	const sourceParts = splitPathnameForRouteMatch(currentPathname);
+	const matchedSourceParts = currentMatchedPathname ? splitPathnameForRouteMatch(currentMatchedPathname) : null;
 	const targetParts = splitPathnameForRouteMatch(targetPathname);
 	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
-		if (!matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) continue;
 		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
-		return currentPathname;
+		if (matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) return currentPathname;
+		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return currentMatchedPathname;
 	}
 	return null;
 }

package/dist/server/app-browser-navigation-controller.d.ts

@@ -77,7 +77,9 @@ type BrowserNavigationController = {
     targetHistoryIndex?: number | null;
     targetHref: string;
     navId: number;
+    navigationCommitKind?: "authoritative" | "detached";
     visibleCommitMode?: NavigationRuntimeVisibleCommitMode;
+    onCommittedState?: (state: AppRouterState) => void;
   }): Promise<NavigationPayloadOutcome>;
   commitSameUrlNavigatePayload(nextElements: Promise<AppElements>, navigationSnapshot: ClientNavigationRenderSnapshot, returnValue?: {
     ok: boolean;

package/dist/server/app-browser-navigation-controller.js

@@ -1,8 +1,8 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { clearAppNavigationFailureTarget, getAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { claimAppRouterScrollIntentForCommit, consumeAppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
+import { resolveServerActionOperationLane, shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, createSnapshotPathAndSearch } from "../shims/navigation.js";
-import { shouldScheduleRefreshForDiscardedServerAction } from "./app-browser-action-result.js";
 import { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, createPendingNavigationCommit } from "./app-browser-state.js";
 import { applyApprovedVisibleCommit, approveHmrVisibleCommit, approvePendingNavigationCommit, resolveAndClassifyNavigationCommit } from "./app-browser-visible-commit.js";
 import { startTransition, useInsertionEffect, useLayoutEffect } from "react";
@@ -73,6 +73,9 @@ function createAppBrowserNavigationController(deps = {}) {
 	const syncHistoryStatePreviousNextUrl = deps.syncHistoryStatePreviousNextUrl ?? (() => {});
 	let nextNavigationRenderId = 0;
 	let activeNavigationId = 0;
+	let pendingUserNavigationId = null;
+	let pendingUserNavigationLane = null;
+	let latestHmrUpdateId = 0;
 	const pendingNavigationCommits = /* @__PURE__ */ new Map();
 	const pendingNavigationFailureTargets = /* @__PURE__ */ new Map();
 	const pendingNavigationPrePaintEffects = /* @__PURE__ */ new Map();
@@ -105,7 +108,10 @@ function createAppBrowserNavigationController(deps = {}) {
 		resolveReady?.();
 	}
 	function beginNavigation() {
+		latestHmrUpdateId += 1;
 		activeNavigationId += 1;
+		pendingUserNavigationId = activeNavigationId;
+		pendingUserNavigationLane = null;
 		return activeNavigationId;
 	}
 	function getActiveNavigationId() {
@@ -149,13 +155,11 @@ function createAppBrowserNavigationController(deps = {}) {
 	}
 	function finalizeNavigation(navId, pending) {
 		settlePendingBrowserRouterState(pending);
-		if (isCurrentNavigation(navId)) clearPendingPathname(navId);
-	}
-	function resolvePendingBrowserRouterState(pending, commit) {
-		if (!pending || pending.settled) return;
-		pending.settled = true;
-		pending.resolve(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
-		if (activePendingBrowserRouterState === pending) activePendingBrowserRouterState = null;
+		if (isCurrentNavigation(navId)) {
+			pendingUserNavigationId = null;
+			pendingUserNavigationLane = null;
+			clearPendingPathname(navId);
+		}
 	}
 	function queuePrePaintNavigationEffect(renderId, effect) {
 		if (!effect) return;
@@ -181,16 +185,17 @@ function createAppBrowserNavigationController(deps = {}) {
 		}
 	}
 	/**
-	* Resolve all pending navigation commits with renderId <= the committed renderId.
-	* Note: Map iteration handles concurrent deletion safely — entries are visited in
-	* insertion order and deletion doesn't affect the iterator's view of remaining entries.
-	* This pattern is also used in drainPrePaintEffects with the same semantics.
+	* Settle all pending navigation renders through the supplied renderId. Only
+	* the exact render whose layout effect ran is a successful commit; older
+	* superseded renders and cleanup-only settlements resolve as no-commit.
 	*/
-	function resolveCommittedNavigations(renderId) {
-		for (const [pendingId, resolve] of pendingNavigationCommits) {
+	function settleNavigationCommits(renderId, committed) {
+		for (const [pendingId, pendingCommit] of pendingNavigationCommits) {
 			if (pendingId > renderId) continue;
 			pendingNavigationCommits.delete(pendingId);
-			resolve();
+			const didCommit = committed && pendingId === renderId;
+			if (didCommit && pendingCommit.committedState !== null) pendingCommit.onCommittedState?.(pendingCommit.committedState);
+			pendingCommit.resolve(didCommit);
 		}
 	}
 	function clearCommittedNavigationFailureTargets(renderId) {
@@ -201,6 +206,8 @@ function createAppBrowserNavigationController(deps = {}) {
 		}
 	}
 	async function hmrReplaceTree(nextElements, navigationSnapshot) {
+		const hmrUpdateId = ++latestHmrUpdateId;
+		const startedDuringUserNavigation = pendingUserNavigationLane === "navigation";
 		if (!hasBrowserRouterState()) return;
 		const pending = await createPendingNavigationCommit({
 			currentState: getBrowserRouterState(),
@@ -211,8 +218,16 @@ function createAppBrowserNavigationController(deps = {}) {
 			renderId: allocateRenderId(),
 			type: "replace"
 		});
+		if (hmrUpdateId !== latestHmrUpdateId || startedDuringUserNavigation) return;
 		if (!hasBrowserRouterState()) return;
-		dispatchSynchronousVisibleCommit(approveHmrVisibleCommit(pending));
+		const approval = approveHmrVisibleCommit({
+			currentState: getBrowserRouterState(),
+			pending,
+			routeManifest: deps.getRouteManifest?.() ?? null,
+			targetHref: createSnapshotPathAndSearch(navigationSnapshot)
+		});
+		if (approval.approvedCommit) dispatchSynchronousVisibleCommit(approval.approvedCommit);
+		else if (approval.decision.disposition === "hard-navigate") performHardNavigation(createSnapshotPathAndSearch(navigationSnapshot));
 	}
 	function NavigationCommitSignal({ renderId, children }) {
 		useInsertionEffect(() => {
@@ -220,30 +235,36 @@ function createAppBrowserNavigationController(deps = {}) {
 		}, [renderId]);
 		useLayoutEffect(() => {
 			drainPrePaintEffects(renderId);
-			const frame = requestAnimationFrame(() => {
-				resolveCommittedNavigations(renderId);
-			});
+			settleNavigationCommits(renderId, true);
 			return () => {
-				cancelAnimationFrame(frame);
-				resolveCommittedNavigations(renderId);
+				settleNavigationCommits(renderId, false);
 			};
 		}, [renderId]);
 		return children;
 	}
-	function dispatchApprovedVisibleCommit(commit, pendingRouterState, visibleCommitMode) {
+	function dispatchApprovedVisibleCommit(renderId, commit, pendingRouterState, visibleCommitMode) {
 		const setter = getBrowserRouterStateSetter();
+		const pendingCommit = pendingNavigationCommits.get(renderId);
+		const captureCandidateState = (state) => {
+			if (pendingCommit) pendingCommit.committedState = state;
+			return state;
+		};
 		if (pendingRouterState) {
-			resolvePendingBrowserRouterState(pendingRouterState, commit);
+			if (pendingRouterState.settled) return;
+			const committedState = captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
+			pendingRouterState.settled = true;
+			pendingRouterState.resolve(committedState);
+			if (activePendingBrowserRouterState === pendingRouterState) activePendingBrowserRouterState = null;
 			return;
 		}
 		if (visibleCommitMode === "synchronous") {
 			flushSync(() => {
-				setter(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
+				setter(captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit)));
 			});
 			return;
 		}
 		startTransition(() => {
-			setter(applyApprovedVisibleCommit(getBrowserRouterState(), commit));
+			setter(captureCandidateState(applyApprovedVisibleCommit(getBrowserRouterState(), commit)));
 		});
 	}
 	function dispatchSynchronousVisibleCommit(commit) {
@@ -280,6 +301,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			previousNextUrl: options.restoredState.previousNextUrl,
 			rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
 			routeId: options.restoredState.routeId,
+			restoredHistorySnapshot: true,
 			skippedLayoutIds: []
 		};
 	}
@@ -309,18 +331,25 @@ function createAppBrowserNavigationController(deps = {}) {
 		lifecycleOptions?.onDiscardedRevalidation?.();
 	}
 	async function renderNavigationPayload(options) {
+		if (options.navId === pendingUserNavigationId) pendingUserNavigationLane = options.operationLane;
 		const renderId = allocateRenderId();
 		const failureTarget = getAppNavigationFailureTarget(options.targetHref);
 		if (failureTarget) pendingNavigationFailureTargets.set(renderId, failureTarget);
 		let resolveCommitted;
 		const committed = new Promise((resolve) => {
 			resolveCommitted = resolve;
-			pendingNavigationCommits.set(renderId, resolve);
+			pendingNavigationCommits.set(renderId, {
+				committedState: null,
+				onCommittedState: options.onCommittedState,
+				resolve
+			});
 		});
 		let snapshotActivated = false;
 		try {
 			const pending = await createPendingNavigationCommit({
 				currentState: getBrowserRouterState(),
+				navigationCommitKind: options.navigationCommitKind,
+				navigationId: options.navId,
 				nextElements: options.nextElements,
 				navigationSnapshot: options.navigationSnapshot,
 				operationLane: options.operationLane,
@@ -344,7 +373,7 @@ function createAppBrowserNavigationController(deps = {}) {
 				pendingNavigationFailureTargets.delete(renderId);
 				if (failureTarget) clearAppNavigationFailureTarget(failureTarget);
 				pendingNavigationCommits.delete(renderId);
-				resolveCommitted?.();
+				resolveCommitted?.(false);
 				consumeAppRouterScrollIntent(options.scrollIntent ?? null);
 				return "no-commit";
 			}
@@ -371,17 +400,17 @@ function createAppBrowserNavigationController(deps = {}) {
 			claimAppRouterScrollIntentForCommit(options.scrollIntent, renderId);
 			activateNavigationSnapshot();
 			snapshotActivated = true;
-			dispatchApprovedVisibleCommit(approvedCommit, options.pendingRouterState, options.visibleCommitMode ?? "transition");
+			dispatchApprovedVisibleCommit(renderId, approvedCommit, options.pendingRouterState, options.visibleCommitMode ?? "transition");
 		} catch (error) {
 			pendingNavigationFailureTargets.delete(renderId);
 			pendingNavigationPrePaintEffects.delete(renderId);
 			pendingNavigationCommits.delete(renderId);
 			if (snapshotActivated) commitClientNavigationStateImpl(options.navId);
 			settlePendingBrowserRouterState(options.pendingRouterState);
-			resolveCommitted?.();
+			resolveCommitted?.(false);
 			throw error;
 		}
-		return committed.then(() => "committed");
+		return committed.then((didCommit) => didCommit ? "committed" : "no-commit");
 	}
 	async function commitSameUrlNavigatePayload(nextElements, navigationSnapshot, returnValue, actionInitiationState, lifecycleOptions) {
 		const currentState = actionInitiationState ?? getBrowserRouterState();
@@ -395,7 +424,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			navigationSnapshot,
 			nextElements,
 			renderId: allocateRenderId(),
-			operationLane: "server-action",
+			operationLane: resolveServerActionOperationLane(lifecycleOptions?.revalidation ?? "none"),
 			payloadOrigin: FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN,
 			startedNavigationId,
 			routeManifest: getRouteManifest(),

package/dist/server/app-browser-server-action-client.d.ts

@@ -0,0 +1,32 @@
+import { AppElements, AppWireElements } from "./app-elements-wire.js";
+import { navigationPlanner } from "./navigation-planner.js";
+import { AppBrowserServerActionResult, ServerActionRevalidationKind } from "./app-browser-action-result.js";
+import { AppRouterState } from "./app-browser-state.js";
+
+//#region src/server/app-browser-server-action-client.d.ts
+type ServerActionResult = AppBrowserServerActionResult<AppWireElements>;
+type ClientServerActionInitiation = {
+  href: string;
+  navigationId: number;
+  path: string;
+  routerState: AppRouterState;
+};
+type ActionRedirectTarget = {
+  href: string;
+  type: string;
+  status: number;
+};
+type ClientServerActionDeps = {
+  basePath: string;
+  clearClientNavigationCaches(): void;
+  clientRscCompatibilityId: string | null;
+  commitSameUrlNavigatePayload(elements: Promise<AppElements>, actionInitiation: ClientServerActionInitiation, returnValue: ServerActionResult["returnValue"] | undefined, revalidation: ServerActionRevalidationKind): Promise<unknown>;
+  navigationPlanner: typeof navigationPlanner;
+  performHardNavigation(url: string, historyMode?: "assign" | "replace"): void;
+  renderRedirectPayload(elements: AppElements, target: ActionRedirectTarget, actionInitiation: ClientServerActionInitiation, revalidation: ServerActionRevalidationKind): void;
+  syncCurrentHistoryState(previousNextUrl: string | null, bfcacheIds: Readonly<Record<string, string>>): void;
+  syncServerActionHttpFallbackHead(status: number | null): void;
+};
+declare function invokeClientServerAction(id: string, args: unknown[], actionInitiation: ClientServerActionInitiation, deps: ClientServerActionDeps): Promise<unknown>;
+//#endregion
+export { ClientServerActionDeps, ClientServerActionInitiation, invokeClientServerAction };

package/dist/server/app-browser-server-action-client.js

@@ -0,0 +1,127 @@
+import { ACTION_REDIRECT_HEADER, ACTION_REDIRECT_STATUS_HEADER } from "./headers.js";
+import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-safety.js";
+import { AppElementsWire } from "./app-elements-wire.js";
+import "./app-elements.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
+import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldSyncServerActionHttpFallbackHead } from "./app-browser-action-result.js";
+import { resolveServerActionRequestState } from "./app-browser-state.js";
+import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
+import { throwOnServerActionNotFound } from "./server-action-not-found.js";
+import { createFromFetch, createTemporaryReferenceSet, encodeReply } from "@vitejs/plugin-rsc/browser";
+//#region src/server/app-browser-server-action-client.ts
+function resolveActionRedirectTarget(response, performHardNavigation) {
+	const actionRedirect = response.headers.get(ACTION_REDIRECT_HEADER);
+	if (!actionRedirect) return null;
+	if (isDangerousScheme(actionRedirect)) {
+		console.error(DANGEROUS_URL_BLOCK_MESSAGE);
+		return null;
+	}
+	try {
+		let redirectUrl;
+		if (actionRedirect.startsWith("/") || /^[a-z]+:/i.test(actionRedirect)) redirectUrl = new URL(actionRedirect, window.location.href);
+		else {
+			const baseParsed = new URL(window.location.href);
+			let baseDir = baseParsed.pathname;
+			if (!baseDir.endsWith("/")) baseDir += "/";
+			redirectUrl = new URL(actionRedirect, `${baseParsed.origin}${baseDir}${baseParsed.search}`);
+		}
+		if (redirectUrl.origin !== window.location.origin) {
+			performHardNavigation(actionRedirect);
+			return null;
+		}
+		const statusHeader = response.headers.get(ACTION_REDIRECT_STATUS_HEADER);
+		return {
+			href: redirectUrl.href,
+			type: response.headers.get("x-action-redirect-type") ?? "push",
+			status: statusHeader ? parseInt(statusHeader, 10) : 307
+		};
+	} catch {
+		performHardNavigation(actionRedirect);
+		return null;
+	}
+}
+var ServerActionRedirectError = class extends Error {
+	digest;
+	handled = true;
+	constructor(target) {
+		super("NEXT_REDIRECT");
+		const redirectUrl = new URL(target.href, window.location.href);
+		const redirectHref = redirectUrl.pathname + redirectUrl.search + redirectUrl.hash;
+		const redirectType = target.type === "push" ? "push" : "replace";
+		this.digest = `NEXT_REDIRECT;${redirectType};${encodeURIComponent(redirectHref)};${target.status};`;
+	}
+};
+async function invokeClientServerAction(id, args, actionInitiation, deps) {
+	deps.syncServerActionHttpFallbackHead(null);
+	const temporaryReferences = createTemporaryReferenceSet();
+	deps.syncCurrentHistoryState(actionInitiation.routerState.previousNextUrl, actionInitiation.routerState.bfcacheIds);
+	const body = await encodeReply(args, { temporaryReferences });
+	const headers = resolveServerActionRequestState({
+		actionId: id,
+		basePath: deps.basePath,
+		elements: actionInitiation.routerState.elements,
+		previousNextUrl: actionInitiation.routerState.previousNextUrl
+	}).headers;
+	const fetchResponse = await fetch(createServerActionRequestUrl(actionInitiation.path), {
+		method: "POST",
+		headers,
+		body
+	});
+	throwOnServerActionNotFound(fetchResponse, id);
+	const hasActionRedirect = fetchResponse.headers.has(ACTION_REDIRECT_HEADER);
+	const actionRedirectTarget = resolveActionRedirectTarget(fetchResponse, (url, historyMode) => deps.performHardNavigation(url, historyMode));
+	if (hasActionRedirect && !actionRedirectTarget) return void 0;
+	const actionResultFacts = createServerActionResultFacts({
+		actionRedirectHref: actionRedirectTarget?.href ?? null,
+		actionRedirectType: actionRedirectTarget?.type ?? null,
+		clientCompatibilityId: deps.clientRscCompatibilityId,
+		compatibilityIdHeader: fetchResponse.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+		contentTypeHeader: fetchResponse.headers.get("content-type"),
+		currentHref: actionInitiation.href,
+		origin: window.location.origin,
+		responseUrl: fetchResponse.url
+	});
+	const fetchResponseIsRsc = actionResultFacts.isRscContentType;
+	if (applyServerActionResultDecision(deps.navigationPlanner.classifyServerActionResult(actionResultFacts), () => deps.clearClientNavigationCaches(), (url, historyMode) => deps.performHardNavigation(url, historyMode))) return;
+	const revalidation = parseServerActionRevalidationHeader(fetchResponse.headers);
+	if (revalidation !== "none") deps.clearClientNavigationCaches();
+	const invalidResponseError = await readInvalidServerActionResponseError(fetchResponse.clone(), actionRedirectTarget !== null);
+	if (invalidResponseError) throw invalidResponseError;
+	if (actionRedirectTarget && !fetchResponseIsRsc) {
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	const flightResponse = fetchResponse.status === 303 ? new Response(fetchResponse.body, {
+		headers: fetchResponse.headers,
+		status: 200,
+		statusText: "OK"
+	}) : fetchResponse;
+	const result = await createFromFetch(Promise.resolve(flightResponse), { temporaryReferences });
+	if (revalidation === "none" && shouldClearClientNavigationCachesForServerActionResult(result, revalidation)) deps.clearClientNavigationCaches();
+	if (actionRedirectTarget) {
+		if (isServerActionResult(result) && result.root !== void 0) {
+			deps.renderRedirectPayload(AppElementsWire.decode(result.root), actionRedirectTarget, actionInitiation, revalidation);
+			throw new ServerActionRedirectError(actionRedirectTarget);
+		}
+		deps.performHardNavigation(actionRedirectTarget.href);
+		return;
+	}
+	deps.syncServerActionHttpFallbackHead(shouldSyncServerActionHttpFallbackHead(result) ? fetchResponse.status : null);
+	if (isServerActionResult(result)) {
+		if (result.root !== void 0) {
+			const returnValue = result.returnValue && !result.returnValue.ok ? {
+				ok: false,
+				data: normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status)
+			} : result.returnValue;
+			return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result.root)), actionInitiation, returnValue, revalidation);
+		}
+		if (result.returnValue) {
+			if (!result.returnValue.ok) throw normalizeServerActionThrownValue(result.returnValue.data, fetchResponse.status);
+			return result.returnValue.data;
+		}
+		return;
+	}
+	return deps.commitSameUrlNavigatePayload(Promise.resolve(AppElementsWire.decode(result)), actionInitiation, void 0, revalidation);
+}
+//#endregion
+export { invokeClientServerAction };

package/dist/server/app-browser-state.d.ts

@@ -11,6 +11,8 @@ import { ClientNavigationRenderSnapshot } from "../shims/navigation.js";
 type OperationRecordBase = {
   id: number;
   lane: OperationLane;
+  navigationCommitKind?: "authoritative" | "detached";
+  navigationId?: number;
   startedVisibleCommitVersion: number;
 };
 type PendingOperationRecord = OperationRecordBase & {
@@ -64,18 +66,23 @@ type PendingNavigationCommit = {
   previousNextUrl: string | null;
   rootLayoutTreePath: string | null;
   routeId: string;
+  restoredHistorySnapshot?: boolean;
   skippedLayoutIds: readonly string[];
 };
 type AppNavigationPayloadOrigin = Readonly<{
+  origin: "committed-cache";
+} | {
   origin: "fresh";
 } | {
   origin: "visited-cache";
 }>;
+declare const COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 declare const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 declare const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN: AppNavigationPayloadOrigin;
 type PendingNavigationCommitDisposition = "dispatch" | "hard-navigate" | "skip";
 type CacheRestorableAppPayloadMetadata = Readonly<{
   cacheEntryReuseProof?: CacheEntryReuseProof;
+  dynamicStaleTimeSeconds?: number;
   skippedLayoutIds: readonly string[];
 }>;
 type DispatchPendingNavigationCommitDispositionDecision = {
@@ -91,6 +98,7 @@ type NonDispatchPendingNavigationCommitDispositionDecision = {
   trace: NavigationTrace;
 };
 type PendingNavigationCommitDispositionDecision = DispatchPendingNavigationCommitDispositionDecision | NonDispatchPendingNavigationCommitDispositionDecision;
+declare function isCompleteAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): boolean;
 declare function isCacheRestorableAppPayloadMetadata(metadata: CacheRestorableAppPayloadMetadata): metadata is CacheRestorableAppPayloadMetadata & {
   cacheEntryReuseProof: CacheEntryReuseProof;
 };
@@ -126,6 +134,8 @@ declare function resolvePendingNavigationCommitDispositionDecision(options: {
 }): PendingNavigationCommitDispositionDecision;
 declare function createPendingNavigationCommit(options: {
   currentState: AppRouterState;
+  navigationCommitKind?: "authoritative" | "detached";
+  navigationId?: number;
   nextElements: Promise<AppElements>;
   navigationSnapshot: ClientNavigationRenderSnapshot;
   operationLane: OperationLane;
@@ -137,4 +147,4 @@ declare function createPendingNavigationCommit(options: {
   type: "navigate" | "replace" | "traverse";
 }): Promise<PendingNavigationCommit>;
 //#endregion
-export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, type BfcacheIdMap, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
+export { AppNavigationPayloadOrigin, AppRouterAction, AppRouterState, type BfcacheIdMap, COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, CommittedOperationRecord, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, type HistoryTraversalIntent, type OperationLane, PendingNavigationCommit, PendingOperationRecord, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

package/dist/server/app-browser-state.js

@@ -6,28 +6,35 @@ import { AppElementsWire } from "./app-elements-wire.js";
 import { getMountedSlotIds, getMountedSlotIdsHeader } from "./app-elements.js";
 import { createRscRequestHeaders } from "./app-rsc-cache-busting.js";
 import { createCacheEntryReuseProof } from "./cache-proof.js";
+import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 import { createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, isHistoryStateBfcacheVersionCurrent, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 import { NavigationTraceReasonCodes, createNavigationLifecycleTraceFields, createNavigationTrace } from "./navigation-trace.js";
 import { verifyOperationTokenForCommit } from "./operation-token.js";
 import { navigationPlanner, resolveDefaultOrUnmatchedSlotPersistenceForLayouts } from "./navigation-planner.js";
 import { createSnapshotPathAndSearch } from "../shims/navigation.js";
-import { createBfcacheSegmentStateKeyMap, createInitialBfcacheIdMap, createNextBfcacheIdMap, preserveBfcacheIdsForMergedElements } from "./app-bfcache-identity.js";
 //#region src/server/app-browser-state.ts
+const COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "committed-cache" };
 const FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "fresh" };
 const VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN = { origin: "visited-cache" };
 function createOperationRecord(options) {
 	return {
 		id: options.id,
 		lane: options.lane,
+		...options.navigationCommitKind !== void 0 ? { navigationCommitKind: options.navigationCommitKind } : {},
+		...options.navigationId !== void 0 ? { navigationId: options.navigationId } : {},
 		startedVisibleCommitVersion: options.startedVisibleCommitVersion,
 		state: "pending"
 	};
 }
+function isCompleteAppPayloadMetadata(metadata) {
+	return metadata.skippedLayoutIds.length === 0;
+}
 function isCacheRestorableAppPayloadMetadata(metadata) {
-	return metadata.cacheEntryReuseProof !== void 0 && metadata.skippedLayoutIds.length === 0;
+	return metadata.cacheEntryReuseProof !== void 0 && isCompleteAppPayloadMetadata(metadata);
 }
 function requiresCacheEntryReuseProof(origin) {
 	switch (origin.origin) {
+		case "committed-cache":
 		case "fresh": return false;
 		case "visited-cache": return true;
 		default: throw new Error("[vinext] Unknown App Router payload origin: " + String(origin));
@@ -70,14 +77,21 @@ function resolveServerActionRequestState(options) {
 function resolvePendingNavigationCommitDispositionDecision(options) {
 	const traceFields = createPendingNavigationTraceFields(options);
 	const targetSnapshot = createPendingRouteSnapshot(options.pending);
-	const verdict = verifyOperationTokenForCommit(createPendingNavigationOperationToken({
+	const token = createPendingNavigationOperationToken({
 		pending: options.pending,
 		routeManifest: options.routeManifest ?? null,
 		startedNavigationId: options.startedNavigationId,
 		targetSnapshot
-	}), {
+	});
+	if (options.pending.action.operation.navigationCommitKind === "detached" && options.currentState.activeOperation?.navigationId === options.startedNavigationId && options.currentState.activeOperation.navigationCommitKind === "authoritative") return {
+		disposition: "skip",
+		preserveElementIds: [],
+		trace: createNavigationTrace(NavigationTraceReasonCodes.staleOperation, traceFields)
+	};
+	const visibleCommitVersion = options.currentState.activeOperation?.navigationId === options.startedNavigationId && options.currentState.activeOperation.navigationCommitKind === "detached" && options.pending.action.operation.navigationCommitKind === "authoritative" ? options.pending.action.operation.startedVisibleCommitVersion : options.currentState.visibleCommitVersion;
+	const verdict = verifyOperationTokenForCommit(token, {
 		activeNavigationId: options.activeNavigationId,
-		visibleCommitVersion: options.currentState.visibleCommitVersion
+		visibleCommitVersion
 	});
 	if (!verdict.authorized) return {
 		disposition: "skip",
@@ -126,7 +140,7 @@ function createMountedParallelSlotSnapshots(elements) {
 }
 function createVisibleRouteSnapshot(state) {
 	const displayUrl = createSnapshotPathAndSearch(state.navigationSnapshot);
-	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
+	const matchedUrl = state.interception?.targetMatchedUrl ?? normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
 	return {
 		displayUrl,
 		interception: state.interception,
@@ -144,7 +158,7 @@ function createVisibleRouteSnapshot(state) {
 }
 function createPendingRouteSnapshot(pending) {
 	const displayUrl = createSnapshotPathAndSearch(pending.action.navigationSnapshot);
-	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
+	const matchedUrl = pending.action.interception?.targetMatchedUrl ?? normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
 	return {
 		displayUrl,
 		interception: pending.action.interception,
@@ -188,6 +202,7 @@ function planPendingRootBoundaryFlightResponse(options) {
 			kind: "flightResponseArrived",
 			result: {
 				...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
+				...options.pending.restoredHistorySnapshot ? { restoredHistorySnapshot: true } : {},
 				href: options.targetHref ?? options.targetSnapshot.displayUrl,
 				targetSnapshot: options.targetSnapshot
 			},
@@ -292,6 +307,8 @@ async function createPendingNavigationCommit(options) {
 			operation: createOperationRecord({
 				id: options.renderId,
 				lane: options.operationLane,
+				navigationCommitKind: options.navigationCommitKind,
+				navigationId: options.navigationId,
 				startedVisibleCommitVersion: options.currentState.visibleCommitVersion
 			}),
 			previousNextUrl,
@@ -312,4 +329,4 @@ async function createPendingNavigationCommit(options) {
 	};
 }
 //#endregion
-export { FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };
+export { COMMITTED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, FRESH_APP_NAVIGATION_PAYLOAD_ORIGIN, VISITED_CACHE_APP_NAVIGATION_PAYLOAD_ORIGIN, createBfcacheSegmentStateKeyMap, createHistoryStateWithNavigationMetadata, createHistoryStateWithPreviousNextUrl, createInitialBfcacheIdMap, createNextBfcacheIdMap, createPendingNavigationCommit, isCacheRestorableAppPayloadMetadata, isCompleteAppPayloadMetadata, isHistoryStateBfcacheVersionCurrent, preserveBfcacheIdsForMergedElements, readHistoryStateBfcacheIds, readHistoryStateBfcacheVersion, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDispositionDecision, resolveServerActionRequestState };

package/dist/server/app-browser-visible-commit.d.ts

@@ -49,7 +49,12 @@ type ClassifiedPendingNavigationCommit = {
   trace: NavigationTrace;
 };
 declare function applyApprovedVisibleCommit(state: AppRouterState, commit: ApprovedVisibleCommit): AppRouterState;
-declare function approveHmrVisibleCommit(pending: PendingNavigationCommit): ApprovedVisibleCommit;
+declare function approveHmrVisibleCommit(options: {
+  currentState: AppRouterState;
+  pending: PendingNavigationCommit;
+  routeManifest?: RouteManifest | null;
+  targetHref: string;
+}): CommitApproval;
 declare function approvePendingNavigationCommit(options: {
   activeNavigationId: number;
   currentState: AppRouterState;