vinext 0.0.41 → 0.0.42

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

@@ -1,12 +1,19 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
-import { __basePath, activateNavigationSnapshot, commitClientNavigationState, consumePrefetchResponse, createClientNavigationRenderSnapshot, getClientNavigationRenderContext, getPrefetchCache, getPrefetchedUrls, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setNavigationContext, snapshotRscResponse, toRscUrl } from "../shims/navigation.js";
+import { createAppPayloadCacheKey, getMountedSlotIdsHeader, normalizeAppElements, readAppElementsMetadata, resolveVisitedResponseInterceptionContext } from "./app-elements.js";
+import { __basePath, activateNavigationSnapshot, clearPendingPathname, commitClientNavigationState, consumePrefetchResponse, createClientNavigationRenderSnapshot, getClientNavigationRenderContext, getClientNavigationState, getCurrentInterceptionContext, getCurrentNextUrl, getPrefetchCache, getPrefetchedUrls, pushHistoryStateWithoutNotify, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, toRscUrl } from "../shims/navigation.js";
+import { ElementsContext, Slot } from "../shims/slot.js";
 import "../client/instrumentation-client.js";
 import { chunksToReadableStream, createProgressiveRscStream, getVinextBrowserGlobal } from "./app-browser-stream.js";
-import { createElement, startTransition, use, useLayoutEffect, useState } from "react";
+import { createHistoryStateWithPreviousNextUrl, createPendingNavigationCommit, readHistoryStatePreviousNextUrl, resolveAndClassifyNavigationCommit, resolveInterceptionContextFromPreviousNextUrl, resolvePendingNavigationCommitDisposition, resolveServerActionRequestState, routerReducer } from "./app-browser-state.js";
+import { devOnCaughtError } from "./app-browser-error.js";
+import { createElement, startTransition, use, useLayoutEffect, useReducer, useRef } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "@vitejs/plugin-rsc/browser";
 //#region src/server/app-browser-entry.ts
+function toActionType(kind) {
+	return kind === "traverse" ? "traverse" : "navigate";
+}
 const MAX_VISITED_RESPONSE_CACHE_SIZE = 50;
 const VISITED_RESPONSE_CACHE_TTL = 5 * 6e4;
 const MAX_TRAVERSAL_CACHE_TTL = 30 * 6e4;
@@ -14,15 +21,20 @@ let nextNavigationRenderId = 0;
 let activeNavigationId = 0;
 const pendingNavigationCommits = /* @__PURE__ */ new Map();
 const pendingNavigationPrePaintEffects = /* @__PURE__ */ new Map();
-let setBrowserTreeState = null;
+let dispatchBrowserRouterAction = null;
+let browserRouterStateRef = null;
 let latestClientParams = {};
 const visitedResponseCache = /* @__PURE__ */ new Map();
 function isServerActionResult(value) {
 	return !!value && typeof value === "object" && "root" in value;
 }
-function getBrowserTreeStateSetter() {
-	if (!setBrowserTreeState) throw new Error("[vinext] Browser tree state is not initialized");
-	return setBrowserTreeState;
+function getBrowserRouterDispatch() {
+	if (!dispatchBrowserRouterAction) throw new Error("[vinext] Browser router dispatch is not initialized");
+	return dispatchBrowserRouterAction;
+}
+function getBrowserRouterState() {
+	if (!browserRouterStateRef) throw new Error("[vinext] Browser router state is not initialized");
+	return browserRouterStateRef.current;
 }
 function applyClientParams(params) {
 	latestClientParams = params;
@@ -62,15 +74,21 @@ function drainPrePaintEffects(upToRenderId) {
 	for (const [id, effect] of pendingNavigationPrePaintEffects) if (id <= upToRenderId) {
 		pendingNavigationPrePaintEffects.delete(id);
 		if (id === upToRenderId) effect();
-		else commitClientNavigationState();
+		else commitClientNavigationState(void 0);
 	}
 }
-function createNavigationCommitEffect(href, historyUpdateMode) {
+function createNavigationCommitEffect(href, historyUpdateMode, navId, params, previousNextUrl) {
 	return () => {
+		if (navId !== activeNavigationId) {
+			commitClientNavigationState(void 0);
+			return;
+		}
 		const targetHref = new URL(href, window.location.origin).href;
-		if (historyUpdateMode === "replace" && window.location.href !== targetHref) replaceHistoryStateWithoutNotify(null, "", href);
-		else if (historyUpdateMode === "push" && window.location.href !== targetHref) pushHistoryStateWithoutNotify(null, "", href);
-		commitClientNavigationState();
+		stageClientParams(params);
+		const historyState = createHistoryStateWithPreviousNextUrl(historyUpdateMode === "replace" ? window.history.state : null, previousNextUrl);
+		if (historyUpdateMode === "replace" && window.location.href !== targetHref) replaceHistoryStateWithoutNotify(historyState, "", href);
+		else if (historyUpdateMode === "push" && window.location.href !== targetHref) pushHistoryStateWithoutNotify(historyState, "", href);
+		commitClientNavigationState(navId);
 	};
 }
 function evictVisitedResponseCacheIfNeeded() {
@@ -80,38 +98,76 @@ function evictVisitedResponseCacheIfNeeded() {
 		visitedResponseCache.delete(oldest);
 	}
 }
-function getVisitedResponse(rscUrl, navigationKind) {
-	const cached = visitedResponseCache.get(rscUrl);
+function getVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, navigationKind) {
+	const cacheKey = createAppPayloadCacheKey(rscUrl, interceptionContext);
+	const cached = visitedResponseCache.get(cacheKey);
 	if (!cached) return null;
+	if ((cached.response.mountedSlotsHeader ?? null) !== mountedSlotsHeader) {
+		visitedResponseCache.delete(cacheKey);
+		return null;
+	}
 	if (navigationKind === "refresh") return null;
 	if (navigationKind === "traverse") {
 		const createdAt = cached.expiresAt - VISITED_RESPONSE_CACHE_TTL;
 		if (Date.now() - createdAt >= MAX_TRAVERSAL_CACHE_TTL) {
-			visitedResponseCache.delete(rscUrl);
+			visitedResponseCache.delete(cacheKey);
 			return null;
 		}
-		visitedResponseCache.delete(rscUrl);
-		visitedResponseCache.set(rscUrl, cached);
+		visitedResponseCache.delete(cacheKey);
+		visitedResponseCache.set(cacheKey, cached);
 		return cached;
 	}
 	if (cached.expiresAt > Date.now()) {
-		visitedResponseCache.delete(rscUrl);
-		visitedResponseCache.set(rscUrl, cached);
+		visitedResponseCache.delete(cacheKey);
+		visitedResponseCache.set(cacheKey, cached);
 		return cached;
 	}
-	visitedResponseCache.delete(rscUrl);
+	visitedResponseCache.delete(cacheKey);
 	return null;
 }
-function storeVisitedResponseSnapshot(rscUrl, snapshot, params) {
-	visitedResponseCache.delete(rscUrl);
+function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, params) {
+	const cacheKey = createAppPayloadCacheKey(rscUrl, interceptionContext);
+	visitedResponseCache.delete(cacheKey);
 	evictVisitedResponseCacheIfNeeded();
 	const now = Date.now();
-	visitedResponseCache.set(rscUrl, {
+	visitedResponseCache.set(cacheKey, {
 		params,
 		expiresAt: now + VISITED_RESPONSE_CACHE_TTL,
 		response: snapshot
 	});
 }
+function getRequestState(navigationKind, previousNextUrlOverride) {
+	if (previousNextUrlOverride !== void 0) return {
+		interceptionContext: resolveInterceptionContextFromPreviousNextUrl(previousNextUrlOverride, __basePath),
+		previousNextUrl: previousNextUrlOverride
+	};
+	switch (navigationKind) {
+		case "navigate": return {
+			interceptionContext: getCurrentInterceptionContext(),
+			previousNextUrl: getCurrentNextUrl()
+		};
+		case "traverse": {
+			const previousNextUrl = readHistoryStatePreviousNextUrl(window.history.state);
+			return {
+				interceptionContext: resolveInterceptionContextFromPreviousNextUrl(previousNextUrl, __basePath),
+				previousNextUrl
+			};
+		}
+		case "refresh": {
+			const currentPreviousNextUrl = getBrowserRouterState().previousNextUrl;
+			return {
+				interceptionContext: resolveInterceptionContextFromPreviousNextUrl(currentPreviousNextUrl, __basePath),
+				previousNextUrl: currentPreviousNextUrl
+			};
+		}
+		default: throw new Error("[vinext] Unknown navigation kind: " + String(navigationKind));
+	}
+}
+function createRscRequestHeaders(interceptionContext) {
+	const headers = new Headers({ Accept: "text/x-component" });
+	if (interceptionContext !== null) headers.set("X-Vinext-Interception-Context", interceptionContext);
+	return headers;
+}
 /**
 * Resolve all pending navigation commits with renderId <= the committed renderId.
 * Note: Map iteration handles concurrent deletion safely — entries are visited in
@@ -137,63 +193,126 @@ function NavigationCommitSignal({ renderId, children }) {
 	}, [renderId]);
 	return children;
 }
-function BrowserRoot({ initialNode, initialNavigationSnapshot }) {
-	const [treeState, setTreeState] = useState({
+function normalizeAppElementsPromise(payload) {
+	return Promise.resolve(payload).then((elements) => normalizeAppElements(elements));
+}
+async function commitSameUrlNavigatePayload(nextElements, returnValue) {
+	const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
+	const currentState = getBrowserRouterState();
+	const startedNavigationId = activeNavigationId;
+	const { disposition, pending } = await resolveAndClassifyNavigationCommit({
+		activeNavigationId,
+		currentState,
+		navigationSnapshot,
+		nextElements,
+		renderId: ++nextNavigationRenderId,
+		startedNavigationId,
+		type: "navigate"
+	});
+	if (disposition === "hard-navigate") {
+		window.location.assign(window.location.href);
+		return;
+	}
+	if (disposition === "dispatch") dispatchBrowserTree(pending.action.elements, navigationSnapshot, pending.action.renderId, "navigate", pending.interceptionContext, pending.action.layoutFlags, pending.previousNextUrl, pending.routeId, pending.rootLayoutTreePath, false);
+	if (returnValue) {
+		if (!returnValue.ok) throw returnValue.data;
+		return returnValue.data;
+	}
+}
+function BrowserRoot({ initialElements, initialNavigationSnapshot }) {
+	const resolvedElements = use(initialElements);
+	const initialMetadata = readAppElementsMetadata(resolvedElements);
+	const [treeState, dispatchTreeState] = useReducer(routerReducer, {
+		elements: resolvedElements,
+		interceptionContext: initialMetadata.interceptionContext,
+		layoutFlags: initialMetadata.layoutFlags,
+		navigationSnapshot: initialNavigationSnapshot,
+		previousNextUrl: null,
 		renderId: 0,
-		node: use(initialNode),
-		navigationSnapshot: initialNavigationSnapshot
+		rootLayoutTreePath: initialMetadata.rootLayoutTreePath,
+		routeId: initialMetadata.routeId
 	});
+	const stateRef = useRef(treeState);
+	stateRef.current = treeState;
+	useLayoutEffect(() => {
+		dispatchBrowserRouterAction = dispatchTreeState;
+		browserRouterStateRef = stateRef;
+		return () => {
+			if (dispatchBrowserRouterAction === dispatchTreeState) dispatchBrowserRouterAction = null;
+			if (browserRouterStateRef === stateRef) browserRouterStateRef = null;
+			setMountedSlotsHeader(null);
+		};
+	}, [dispatchTreeState]);
+	useLayoutEffect(() => {
+		setMountedSlotsHeader(getMountedSlotIdsHeader(stateRef.current.elements));
+	}, [treeState.elements]);
 	useLayoutEffect(() => {
-		setBrowserTreeState = setTreeState;
-	}, []);
-	const committedTree = createElement(NavigationCommitSignal, { renderId: treeState.renderId }, treeState.node);
+		if (treeState.renderId !== 0) return;
+		replaceHistoryStateWithoutNotify(createHistoryStateWithPreviousNextUrl(window.history.state, treeState.previousNextUrl), "", window.location.href);
+	}, [treeState.previousNextUrl, treeState.renderId]);
+	const committedTree = createElement(NavigationCommitSignal, { renderId: treeState.renderId }, createElement(ElementsContext.Provider, { value: treeState.elements }, createElement(Slot, { id: treeState.routeId })));
 	const ClientNavigationRenderContext = getClientNavigationRenderContext();
 	if (!ClientNavigationRenderContext) return committedTree;
 	return createElement(ClientNavigationRenderContext.Provider, { value: treeState.navigationSnapshot }, committedTree);
 }
-function updateBrowserTree(node, navigationSnapshot, renderId, useTransitionMode, snapshotActivated = false) {
-	const setter = getBrowserTreeStateSetter();
-	const resolvedThenSet = (resolvedNode) => {
-		setter({
-			renderId,
-			node: resolvedNode,
-			navigationSnapshot
-		});
-	};
-	const handleAsyncError = () => {
-		pendingNavigationPrePaintEffects.delete(renderId);
-		const resolve = pendingNavigationCommits.get(renderId);
-		pendingNavigationCommits.delete(renderId);
-		if (snapshotActivated) commitClientNavigationState();
-		resolve?.();
-	};
-	if (node != null && typeof node.then === "function") {
-		const thenable = node;
-		if (useTransitionMode) thenable.then((resolved) => startTransition(() => resolvedThenSet(resolved)), handleAsyncError);
-		else thenable.then(resolvedThenSet, handleAsyncError);
-		return;
-	}
-	const syncNode = node;
-	if (useTransitionMode) {
-		startTransition(() => resolvedThenSet(syncNode));
-		return;
-	}
-	resolvedThenSet(syncNode);
+function dispatchBrowserTree(elements, navigationSnapshot, renderId, actionType, interceptionContext, layoutFlags, previousNextUrl, routeId, rootLayoutTreePath, useTransitionMode) {
+	const dispatch = getBrowserRouterDispatch();
+	const applyAction = () => dispatch({
+		elements,
+		interceptionContext,
+		layoutFlags,
+		navigationSnapshot,
+		previousNextUrl,
+		renderId,
+		rootLayoutTreePath,
+		routeId,
+		type: actionType
+	});
+	if (useTransitionMode) startTransition(applyAction);
+	else applyAction();
 }
-function renderNavigationPayload(payload, navigationSnapshot, prePaintEffect = null, useTransition = true) {
+async function renderNavigationPayload(payload, navigationSnapshot, targetHref, navId, historyUpdateMode, params, previousNextUrl, useTransition = true, actionType = "navigate") {
 	const renderId = ++nextNavigationRenderId;
-	queuePrePaintNavigationEffect(renderId, prePaintEffect);
 	const committed = new Promise((resolve) => {
 		pendingNavigationCommits.set(renderId, resolve);
 	});
-	activateNavigationSnapshot();
+	let snapshotActivated = false;
 	try {
-		updateBrowserTree(payload, navigationSnapshot, renderId, useTransition, true);
+		const currentState = getBrowserRouterState();
+		const pending = await createPendingNavigationCommit({
+			currentState,
+			nextElements: payload,
+			navigationSnapshot,
+			previousNextUrl,
+			renderId,
+			type: actionType
+		});
+		const disposition = resolvePendingNavigationCommitDisposition({
+			activeNavigationId,
+			currentRootLayoutTreePath: currentState.rootLayoutTreePath,
+			nextRootLayoutTreePath: pending.rootLayoutTreePath,
+			startedNavigationId: navId
+		});
+		if (disposition === "skip") {
+			const resolve = pendingNavigationCommits.get(renderId);
+			pendingNavigationCommits.delete(renderId);
+			resolve?.();
+			return;
+		}
+		if (disposition === "hard-navigate") {
+			pendingNavigationCommits.delete(renderId);
+			window.location.assign(targetHref);
+			return;
+		}
+		queuePrePaintNavigationEffect(renderId, createNavigationCommitEffect(targetHref, historyUpdateMode, navId, params, pending.previousNextUrl));
+		activateNavigationSnapshot();
+		snapshotActivated = true;
+		dispatchBrowserTree(pending.action.elements, navigationSnapshot, renderId, actionType, pending.interceptionContext, pending.action.layoutFlags, pending.previousNextUrl, pending.routeId, pending.rootLayoutTreePath, useTransition);
 	} catch (error) {
 		pendingNavigationPrePaintEffects.delete(renderId);
 		const resolve = pendingNavigationCommits.get(renderId);
 		pendingNavigationCommits.delete(renderId);
-		commitClientNavigationState();
+		if (snapshotActivated) commitClientNavigationState(navId);
 		resolve?.();
 		throw error;
 	}
@@ -245,9 +364,16 @@ function registerServerActionCallback() {
 	setServerCallback(async (id, args) => {
 		const temporaryReferences = createTemporaryReferenceSet();
 		const body = await encodeReply(args, { temporaryReferences });
+		const currentState = getBrowserRouterState();
+		const { headers } = resolveServerActionRequestState({
+			actionId: id,
+			basePath: __basePath,
+			elements: currentState.elements,
+			previousNextUrl: currentState.previousNextUrl
+		});
 		const fetchResponse = await fetch(toRscUrl(window.location.pathname + window.location.search), {
 			method: "POST",
-			headers: { "x-rsc-action": id },
+			headers,
 			body
 		});
 		const actionRedirect = fetchResponse.headers.get("x-action-redirect");
@@ -264,28 +390,21 @@ function registerServerActionCallback() {
 		}
 		clearClientNavigationCaches();
 		const result = await createFromFetch(Promise.resolve(fetchResponse), { temporaryReferences });
-		if (isServerActionResult(result)) {
-			updateBrowserTree(result.root, createClientNavigationRenderSnapshot(window.location.href, latestClientParams), ++nextNavigationRenderId, false);
-			if (result.returnValue) {
-				if (!result.returnValue.ok) throw result.returnValue.data;
-				return result.returnValue.data;
-			}
-			return;
-		}
-		updateBrowserTree(result, createClientNavigationRenderSnapshot(window.location.href, latestClientParams), ++nextNavigationRenderId, false);
-		return result;
+		if (isServerActionResult(result)) return commitSameUrlNavigatePayload(Promise.resolve(normalizeAppElements(result.root)), result.returnValue);
+		return commitSameUrlNavigatePayload(Promise.resolve(normalizeAppElements(result)));
 	});
 }
 async function main() {
 	registerServerActionCallback();
-	const root = createFromReadableStream(await readInitialRscStream());
+	const root = normalizeAppElementsPromise(createFromReadableStream(await readInitialRscStream()));
 	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
+	replaceHistoryStateWithoutNotify(createHistoryStateWithPreviousNextUrl(window.history.state, null), "", window.location.href);
 	window.__VINEXT_RSC_ROOT__ = hydrateRoot(document, createElement(BrowserRoot, {
-		initialNode: root,
+		initialElements: root,
 		initialNavigationSnapshot
-	}), import.meta.env.DEV ? { onCaughtError() {} } : void 0);
+	}), import.meta.env.DEV ? { onCaughtError: devOnCaughtError } : void 0);
 	window.__VINEXT_HYDRATED_AT = performance.now();
-	window.__VINEXT_RSC_NAVIGATE__ = async function navigateRsc(href, redirectDepth = 0, navigationKind = "navigate", historyUpdateMode) {
+	window.__VINEXT_RSC_NAVIGATE__ = async function navigateRsc(href, redirectDepth = 0, navigationKind = "navigate", historyUpdateMode, previousNextUrlOverride) {
 		if (redirectDepth > 10) {
 			console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
 			window.location.href = href;
@@ -296,19 +415,25 @@ async function main() {
 		try {
 			const url = new URL(href, window.location.origin);
 			const rscUrl = toRscUrl(url.pathname + url.search);
-			const isSameRoute = stripBasePath(url.pathname, __basePath) === stripBasePath(window.location.pathname, __basePath);
-			const cachedRoute = getVisitedResponse(rscUrl, navigationKind);
-			const navigationCommitEffect = createNavigationCommitEffect(href, historyUpdateMode);
+			const requestState = getRequestState(navigationKind, previousNextUrlOverride);
+			const requestInterceptionContext = requestState.interceptionContext;
+			const requestPreviousNextUrl = requestState.previousNextUrl;
+			const navState = getClientNavigationState();
+			const currentPath = navState?.pendingPathname ?? navState?.cachedPathname ?? stripBasePath(window.location.pathname, __basePath);
+			const isSameRoute = stripBasePath(url.pathname, __basePath) === currentPath;
+			setPendingPathname(url.pathname, navId);
+			const elementsAtNavStart = getBrowserRouterState().elements;
+			const mountedSlotsHeader = getMountedSlotIdsHeader(elementsAtNavStart);
+			const cachedRoute = getVisitedResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader, navigationKind);
 			if (cachedRoute) {
 				if (navId !== activeNavigationId) return;
 				const cachedParams = cachedRoute.params;
 				const cachedNavigationSnapshot = createClientNavigationRenderSnapshot(href, cachedParams);
-				const cachedPayload = await createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response)));
+				const cachedPayload = normalizeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(cachedRoute.response))));
 				if (navId !== activeNavigationId) return;
 				_snapshotPending = true;
-				stageClientParams(cachedParams);
 				try {
-					await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, navigationCommitEffect, isSameRoute);
+					await renderNavigationPayload(cachedPayload, cachedNavigationSnapshot, href, navId, historyUpdateMode, cachedParams, requestPreviousNextUrl, isSameRoute, toActionType(navigationKind));
 				} finally {
 					_snapshotPending = false;
 				}
@@ -317,28 +442,32 @@ async function main() {
 			let navResponse;
 			let navResponseUrl = null;
 			if (navigationKind !== "refresh") {
-				const prefetchedResponse = consumePrefetchResponse(rscUrl);
+				const prefetchedResponse = consumePrefetchResponse(rscUrl, requestInterceptionContext, mountedSlotsHeader);
 				if (prefetchedResponse) {
 					navResponse = restoreRscResponse(prefetchedResponse, false);
 					navResponseUrl = prefetchedResponse.url;
 				}
 			}
-			if (!navResponse) navResponse = await fetch(rscUrl, {
-				headers: { Accept: "text/x-component" },
-				credentials: "include"
-			});
+			if (!navResponse) {
+				const requestHeaders = createRscRequestHeaders(requestInterceptionContext);
+				if (mountedSlotsHeader) requestHeaders.set("X-Vinext-Mounted-Slots", mountedSlotsHeader);
+				navResponse = await fetch(rscUrl, {
+					headers: requestHeaders,
+					credentials: "include"
+				});
+			}
 			if (navId !== activeNavigationId) return;
 			const finalUrl = new URL(navResponseUrl ?? navResponse.url, window.location.origin);
 			const requestedUrl = new URL(rscUrl, window.location.origin);
 			if (finalUrl.pathname !== requestedUrl.pathname) {
 				const destinationPath = finalUrl.pathname.replace(/\.rsc$/, "") + finalUrl.search;
-				replaceHistoryStateWithoutNotify(null, "", destinationPath);
+				replaceHistoryStateWithoutNotify(createHistoryStateWithPreviousNextUrl(null, requestPreviousNextUrl), "", destinationPath);
 				const navigate = window.__VINEXT_RSC_NAVIGATE__;
 				if (!navigate) {
 					window.location.href = destinationPath;
 					return;
 				}
-				return navigate(destinationPath, redirectDepth + 1, navigationKind, void 0);
+				return navigate(destinationPath, redirectDepth + 1, navigationKind, void 0, requestPreviousNextUrl);
 			}
 			let navParams = {};
 			const paramsHeader = navResponse.headers.get("X-Vinext-Params");
@@ -348,22 +477,23 @@ async function main() {
 			const navigationSnapshot = createClientNavigationRenderSnapshot(href, navParams);
 			const responseSnapshot = await snapshotRscResponse(navResponse);
 			if (navId !== activeNavigationId) return;
-			const rscPayload = await createFromFetch(Promise.resolve(restoreRscResponse(responseSnapshot)));
+			const rscPayload = normalizeAppElementsPromise(createFromFetch(Promise.resolve(restoreRscResponse(responseSnapshot))));
 			if (navId !== activeNavigationId) return;
 			_snapshotPending = true;
-			stageClientParams(navParams);
 			try {
-				await renderNavigationPayload(rscPayload, navigationSnapshot, navigationCommitEffect, isSameRoute);
+				await renderNavigationPayload(rscPayload, navigationSnapshot, href, navId, historyUpdateMode, navParams, requestPreviousNextUrl, isSameRoute, toActionType(navigationKind));
 			} finally {
 				_snapshotPending = false;
 			}
-			storeVisitedResponseSnapshot(rscUrl, responseSnapshot, navParams);
+			if (navId !== activeNavigationId) return;
+			storeVisitedResponseSnapshot(rscUrl, resolveVisitedResponseInterceptionContext(requestInterceptionContext, readAppElementsMetadata(await rscPayload).interceptionContext), responseSnapshot, navParams);
 			return;
 		} catch (error) {
 			if (_snapshotPending) {
 				_snapshotPending = false;
-				commitClientNavigationState();
+				commitClientNavigationState(navId);
 			}
+			if (navId === activeNavigationId) clearPendingPathname(navId);
 			if (navId !== activeNavigationId) return;
 			console.error("[vinext] RSC navigation error:", error);
 			window.location.href = href;
@@ -382,13 +512,21 @@ async function main() {
 	if (import.meta.hot) import.meta.hot.on("rsc:update", async () => {
 		try {
 			clearClientNavigationCaches();
-			updateBrowserTree(await createFromFetch(fetch(toRscUrl(window.location.pathname + window.location.search))), createClientNavigationRenderSnapshot(window.location.href, latestClientParams), ++nextNavigationRenderId, false);
+			const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
+			const pending = await createPendingNavigationCommit({
+				currentState: getBrowserRouterState(),
+				nextElements: normalizeAppElementsPromise(createFromFetch(fetch(toRscUrl(window.location.pathname + window.location.search)))),
+				navigationSnapshot,
+				renderId: ++nextNavigationRenderId,
+				type: "replace"
+			});
+			dispatchBrowserTree(pending.action.elements, navigationSnapshot, pending.action.renderId, "replace", pending.interceptionContext, pending.action.layoutFlags, pending.previousNextUrl, pending.routeId, pending.rootLayoutTreePath, false);
 		} catch (error) {
 			console.error("[vinext] RSC HMR error:", error);
 		}
 	});
 }
-main();
+if (typeof document !== "undefined") main();
 //#endregion
 export {};