vinext 0.0.38 → 0.0.39

package/dist/shims/navigation.js

@@ -27,18 +27,19 @@ const ServerInsertedHTMLContext = getServerInsertedHTMLContext();
 function getLayoutSegmentContext() {
 	if (typeof React$1.createContext !== "function") return null;
 	const globalState = globalThis;
-	if (!globalState[_LAYOUT_SEGMENT_CTX_KEY]) globalState[_LAYOUT_SEGMENT_CTX_KEY] = React$1.createContext([]);
+	if (!globalState[_LAYOUT_SEGMENT_CTX_KEY]) globalState[_LAYOUT_SEGMENT_CTX_KEY] = React$1.createContext({ children: [] });
 	return globalState[_LAYOUT_SEGMENT_CTX_KEY] ?? null;
 }
 /**
-* Read the child segments below the current layout from context.
-* Returns [] if no context is available (RSC environment, outside React tree).
+* Read the child segments for a parallel route below the current layout.
+* Returns [] if no context is available (RSC environment, outside React tree)
+* or if the requested key is not present in the segment map.
 */
-function useChildSegments() {
+function useChildSegments(parallelRoutesKey = "children") {
 	const ctx = getLayoutSegmentContext();
 	if (!ctx) return [];
 	try {
-		return React$1.useContext(ctx);
+		return React$1.useContext(ctx)[parallelRoutesKey] ?? [];
 	} catch {
 		return [];
 	}
@@ -130,91 +131,300 @@ function getPrefetchedUrls() {
 	return window.__VINEXT_RSC_PREFETCHED_URLS__;
 }
 /**
-* Store a prefetched RSC response in the cache.
-* Enforces a maximum cache size to prevent unbounded memory growth on
-* link-heavy pages.
+* Evict prefetch cache entries if at capacity.
+* First sweeps expired entries, then falls back to FIFO eviction.
 */
-function storePrefetchResponse(rscUrl, response) {
+function evictPrefetchCacheIfNeeded() {
 	const cache = getPrefetchCache();
+	if (cache.size < 50) return;
 	const now = Date.now();
-	if (cache.size >= 50) {
-		const prefetched = getPrefetchedUrls();
-		for (const [key, entry] of cache) if (now - entry.timestamp >= 3e4) {
-			cache.delete(key);
-			prefetched.delete(key);
-		}
+	const prefetched = getPrefetchedUrls();
+	for (const [key, entry] of cache) if (now - entry.timestamp >= 3e4) {
+		cache.delete(key);
+		prefetched.delete(key);
 	}
-	if (cache.size >= 50) {
+	while (cache.size >= 50) {
 		const oldest = cache.keys().next().value;
 		if (oldest !== void 0) {
 			cache.delete(oldest);
-			getPrefetchedUrls().delete(oldest);
-		}
+			prefetched.delete(oldest);
+		} else break;
 	}
-	cache.set(rscUrl, {
-		response,
-		timestamp: now
+}
+/**
+* Store a prefetched RSC response in the cache by snapshotting it to an
+* ArrayBuffer.  The snapshot completes asynchronously; during that window
+* the entry is marked `pending` so consumePrefetchResponse() will skip it
+* (the caller falls back to a fresh fetch, which is acceptable).
+*
+* Prefer prefetchRscResponse() for new call-sites — it handles the full
+* prefetch lifecycle including dedup.  storePrefetchResponse() is kept for
+* backward compatibility and test helpers.
+*
+* NB: Caller is responsible for managing getPrefetchedUrls() — this
+* function only stores the response in the prefetch cache.
+*/
+function storePrefetchResponse(rscUrl, response) {
+	evictPrefetchCacheIfNeeded();
+	const entry = { timestamp: Date.now() };
+	entry.pending = snapshotRscResponse(response).then((snapshot) => {
+		entry.snapshot = snapshot;
+	}).catch(() => {
+		getPrefetchCache().delete(rscUrl);
+	}).finally(() => {
+		entry.pending = void 0;
 	});
+	getPrefetchCache().set(rscUrl, entry);
 }
-const _listeners = /* @__PURE__ */ new Set();
-function notifyListeners() {
-	for (const fn of _listeners) fn();
+/**
+* Snapshot an RSC response to an ArrayBuffer for caching and replay.
+* Consumes the response body and stores it with content-type and URL metadata.
+*/
+async function snapshotRscResponse(response) {
+	return {
+		buffer: await response.arrayBuffer(),
+		contentType: response.headers.get("content-type") ?? "text/x-component",
+		paramsHeader: response.headers.get("X-Vinext-Params"),
+		url: response.url
+	};
+}
+/**
+* Reconstruct a Response from a cached RSC snapshot.
+* Creates a new Response with the original ArrayBuffer so createFromFetch
+* can consume the stream from scratch.
+*
+* NOTE: The reconstructed Response always has `url === ""` — the Response
+* constructor does not accept a `url` option, and `response.url` is read-only
+* set by the fetch infrastructure. Callers that need the original URL should
+* read it from `cached.url` directly rather than from the restored Response.
+*
+* @param copy - When true (default), copies the ArrayBuffer so the cached
+*   snapshot remains replayable (needed for the visited-response cache).
+*   Pass false for single-consumption paths (e.g. prefetch cache entries
+*   that are deleted after consumption) to avoid the extra allocation.
+*/
+function restoreRscResponse(cached, copy = true) {
+	const headers = new Headers({ "content-type": cached.contentType });
+	if (cached.paramsHeader != null) headers.set("X-Vinext-Params", cached.paramsHeader);
+	return new Response(copy ? cached.buffer.slice(0) : cached.buffer, {
+		status: 200,
+		headers
+	});
+}
+/**
+* Prefetch an RSC response and snapshot it for later consumption.
+* Stores the in-flight promise so immediate clicks can await it instead
+* of firing a duplicate fetch.
+* Enforces a maximum cache size to prevent unbounded memory growth on
+* link-heavy pages.
+*/
+function prefetchRscResponse(rscUrl, fetchPromise) {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const entry = { timestamp: Date.now() };
+	entry.pending = fetchPromise.then(async (response) => {
+		if (response.ok) entry.snapshot = await snapshotRscResponse(response);
+		else {
+			prefetched.delete(rscUrl);
+			cache.delete(rscUrl);
+		}
+	}).catch(() => {
+		prefetched.delete(rscUrl);
+		cache.delete(rscUrl);
+	}).finally(() => {
+		entry.pending = void 0;
+	});
+	cache.set(rscUrl, entry);
+	evictPrefetchCacheIfNeeded();
+}
+/**
+* Consume a prefetched response for a given rscUrl.
+* Only returns settled (non-pending) snapshots synchronously.
+* Returns null if the entry is still in flight or doesn't exist.
+*/
+function consumePrefetchResponse(rscUrl) {
+	const cache = getPrefetchCache();
+	const entry = cache.get(rscUrl);
+	if (!entry) return null;
+	if (entry.pending) return null;
+	cache.delete(rscUrl);
+	getPrefetchedUrls().delete(rscUrl);
+	if (entry.snapshot) {
+		if (Date.now() - entry.timestamp >= 3e4) return null;
+		return entry.snapshot;
+	}
+	return null;
+}
+const _CLIENT_NAV_STATE_KEY = Symbol.for("vinext.clientNavigationState");
+function getClientNavigationState() {
+	if (isServer) return null;
+	const globalState = window;
+	globalState[_CLIENT_NAV_STATE_KEY] ??= {
+		listeners: /* @__PURE__ */ new Set(),
+		cachedSearch: window.location.search,
+		cachedReadonlySearchParams: new ReadonlyURLSearchParams(window.location.search),
+		cachedPathname: stripBasePath(window.location.pathname, __basePath),
+		clientParams: {},
+		clientParamsJson: "{}",
+		pendingClientParams: null,
+		pendingClientParamsJson: null,
+		originalPushState: window.history.pushState.bind(window.history),
+		originalReplaceState: window.history.replaceState.bind(window.history),
+		patchInstalled: false,
+		hasPendingNavigationUpdate: false,
+		suppressUrlNotifyCount: 0,
+		navigationSnapshotActiveCount: 0
+	};
+	return globalState[_CLIENT_NAV_STATE_KEY];
+}
+function notifyNavigationListeners() {
+	const state = getClientNavigationState();
+	if (!state) return;
+	for (const fn of state.listeners) fn();
 }
-let _cachedSearch = !isServer ? window.location.search : "";
-let _cachedReadonlySearchParams = new ReadonlyURLSearchParams(_cachedSearch);
 let _cachedEmptyServerSearchParams = null;
-let _cachedPathname = !isServer ? stripBasePath(window.location.pathname, __basePath) : "/";
+/**
+* Get cached pathname snapshot for useSyncExternalStore.
+* Note: Returns cached value from ClientNavigationState, not live window.location.
+* The cache is updated by syncCommittedUrlStateFromLocation() after navigation commits.
+* This ensures referential stability and prevents infinite re-renders.
+* External pushState/replaceState while URL notifications are suppressed won't
+* be visible until the next commit.
+*/
 function getPathnameSnapshot() {
-	const current = stripBasePath(window.location.pathname, __basePath);
-	if (current !== _cachedPathname) _cachedPathname = current;
-	return _cachedPathname;
+	return getClientNavigationState()?.cachedPathname ?? "/";
 }
+let _cachedEmptyClientSearchParams = null;
+/**
+* Get cached search params snapshot for useSyncExternalStore.
+* Note: Returns cached value from ClientNavigationState, not live window.location.search.
+* The cache is updated by syncCommittedUrlStateFromLocation() after navigation commits.
+* This ensures referential stability and prevents infinite re-renders.
+* External pushState/replaceState while URL notifications are suppressed won't
+* be visible until the next commit.
+*/
 function getSearchParamsSnapshot() {
-	const current = window.location.search;
-	if (current !== _cachedSearch) {
-		_cachedSearch = current;
-		_cachedReadonlySearchParams = new ReadonlyURLSearchParams(current);
+	const cached = getClientNavigationState()?.cachedReadonlySearchParams;
+	if (cached) return cached;
+	if (_cachedEmptyClientSearchParams === null) _cachedEmptyClientSearchParams = new ReadonlyURLSearchParams();
+	return _cachedEmptyClientSearchParams;
+}
+function syncCommittedUrlStateFromLocation() {
+	const state = getClientNavigationState();
+	if (!state) return false;
+	let changed = false;
+	const pathname = stripBasePath(window.location.pathname, __basePath);
+	if (pathname !== state.cachedPathname) {
+		state.cachedPathname = pathname;
+		changed = true;
+	}
+	const search = window.location.search;
+	if (search !== state.cachedSearch) {
+		state.cachedSearch = search;
+		state.cachedReadonlySearchParams = new ReadonlyURLSearchParams(search);
+		changed = true;
 	}
-	return _cachedReadonlySearchParams;
+	return changed;
 }
 function getServerSearchParamsSnapshot() {
 	const ctx = _getServerContext();
-	if (ctx != null) {
-		const searchParams = ctx.searchParams;
-		if (ctx[_READONLY_SEARCH_PARAMS_SOURCE] !== searchParams) {
-			ctx[_READONLY_SEARCH_PARAMS_SOURCE] = searchParams;
-			ctx[_READONLY_SEARCH_PARAMS] = new ReadonlyURLSearchParams(searchParams);
-		}
-		return ctx[_READONLY_SEARCH_PARAMS];
+	if (!ctx) {
+		if (_cachedEmptyServerSearchParams === null) _cachedEmptyServerSearchParams = new ReadonlyURLSearchParams();
+		return _cachedEmptyServerSearchParams;
 	}
-	if (_cachedEmptyServerSearchParams === null) _cachedEmptyServerSearchParams = new ReadonlyURLSearchParams();
-	return _cachedEmptyServerSearchParams;
+	const source = ctx.searchParams;
+	const cached = ctx[_READONLY_SEARCH_PARAMS];
+	const cachedSource = ctx[_READONLY_SEARCH_PARAMS_SOURCE];
+	if (cached && cachedSource === source) return cached;
+	const readonly = new ReadonlyURLSearchParams(source);
+	ctx[_READONLY_SEARCH_PARAMS] = readonly;
+	ctx[_READONLY_SEARCH_PARAMS_SOURCE] = source;
+	return readonly;
+}
+/**
+* Mark a navigation snapshot as active. Called before startTransition
+* in renderNavigationPayload. While active, hooks prefer the snapshot
+* context value over useSyncExternalStore. Uses a counter (not boolean)
+* to handle overlapping navigations — rapid clicks can interleave
+* activate/deactivate if multiple transitions are in flight.
+*/
+function activateNavigationSnapshot() {
+	const state = getClientNavigationState();
+	if (state) state.navigationSnapshotActiveCount++;
 }
 const _EMPTY_PARAMS = {};
-let _clientParams = _EMPTY_PARAMS;
-let _clientParamsJson = "{}";
+const _CLIENT_NAV_RENDER_CTX_KEY = Symbol.for("vinext.clientNavigationRenderContext");
+function getClientNavigationRenderContext() {
+	if (typeof React$1.createContext !== "function") return null;
+	const globalState = globalThis;
+	if (!globalState[_CLIENT_NAV_RENDER_CTX_KEY]) globalState[_CLIENT_NAV_RENDER_CTX_KEY] = React$1.createContext(null);
+	return globalState[_CLIENT_NAV_RENDER_CTX_KEY] ?? null;
+}
+function useClientNavigationRenderSnapshot() {
+	const ctx = getClientNavigationRenderContext();
+	if (!ctx || typeof React$1.useContext !== "function") return null;
+	try {
+		return React$1.useContext(ctx);
+	} catch {
+		return null;
+	}
+}
+function createClientNavigationRenderSnapshot(href, params) {
+	const origin = typeof window !== "undefined" ? window.location.origin : "http://localhost";
+	const url = new URL(href, origin);
+	return {
+		pathname: stripBasePath(url.pathname, __basePath),
+		searchParams: new ReadonlyURLSearchParams(url.search),
+		params
+	};
+}
+let _fallbackClientParams = _EMPTY_PARAMS;
+let _fallbackClientParamsJson = "{}";
 function setClientParams(params) {
+	const state = getClientNavigationState();
+	if (!state) {
+		const json = JSON.stringify(params);
+		if (json !== _fallbackClientParamsJson) {
+			_fallbackClientParams = params;
+			_fallbackClientParamsJson = json;
+		}
+		return;
+	}
+	const json = JSON.stringify(params);
+	if (json !== state.clientParamsJson) {
+		state.clientParams = params;
+		state.clientParamsJson = json;
+		state.pendingClientParams = null;
+		state.pendingClientParamsJson = null;
+		notifyNavigationListeners();
+	}
+}
+function replaceClientParamsWithoutNotify(params) {
+	const state = getClientNavigationState();
+	if (!state) return;
 	const json = JSON.stringify(params);
-	if (json !== _clientParamsJson) {
-		_clientParams = params;
-		_clientParamsJson = json;
-		notifyListeners();
+	if (json !== state.clientParamsJson && json !== state.pendingClientParamsJson) {
+		state.pendingClientParams = params;
+		state.pendingClientParamsJson = json;
+		state.hasPendingNavigationUpdate = true;
 	}
 }
 /** Get the current client params (for testing referential stability). */
 function getClientParams() {
-	return _clientParams;
+	return getClientNavigationState()?.clientParams ?? _fallbackClientParams;
 }
 function getClientParamsSnapshot() {
-	return _clientParams;
+	return getClientNavigationState()?.clientParams ?? _EMPTY_PARAMS;
 }
 function getServerParamsSnapshot() {
 	return _getServerContext()?.params ?? _EMPTY_PARAMS;
 }
 function subscribeToNavigation(cb) {
-	_listeners.add(cb);
+	const state = getClientNavigationState();
+	if (!state) return () => {};
+	state.listeners.add(cb);
 	return () => {
-		_listeners.delete(cb);
+		state.listeners.delete(cb);
 	};
 }
 /**
@@ -223,21 +433,30 @@ function subscribeToNavigation(cb) {
 */
 function usePathname() {
 	if (isServer) return _getServerContext()?.pathname ?? "/";
-	return React$1.useSyncExternalStore(subscribeToNavigation, getPathnameSnapshot, () => _getServerContext()?.pathname ?? "/");
+	const renderSnapshot = useClientNavigationRenderSnapshot();
+	const pathname = React$1.useSyncExternalStore(subscribeToNavigation, getPathnameSnapshot, () => _getServerContext()?.pathname ?? "/");
+	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.pathname;
+	return pathname;
 }
 /**
 * Returns the current search params as a read-only URLSearchParams.
 */
 function useSearchParams() {
 	if (isServer) return getServerSearchParamsSnapshot();
-	return React$1.useSyncExternalStore(subscribeToNavigation, getSearchParamsSnapshot, getServerSearchParamsSnapshot);
+	const renderSnapshot = useClientNavigationRenderSnapshot();
+	const searchParams = React$1.useSyncExternalStore(subscribeToNavigation, getSearchParamsSnapshot, getServerSearchParamsSnapshot);
+	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.searchParams;
+	return searchParams;
 }
 /**
 * Returns the dynamic params for the current route.
 */
 function useParams() {
 	if (isServer) return _getServerContext()?.params ?? _EMPTY_PARAMS;
-	return React$1.useSyncExternalStore(subscribeToNavigation, getClientParamsSnapshot, getServerParamsSnapshot);
+	const renderSnapshot = useClientNavigationRenderSnapshot();
+	const params = React$1.useSyncExternalStore(subscribeToNavigation, getClientParamsSnapshot, getServerParamsSnapshot);
+	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.params;
+	return params;
 }
 /**
 * Check if a href is an external URL (any URL scheme per RFC 3986, or protocol-relative).
@@ -254,7 +473,7 @@ function isHashOnlyChange(href) {
 	try {
 		const current = new URL(window.location.href);
 		const next = new URL(href, window.location.href);
-		return current.pathname === next.pathname && current.search === next.search && next.hash !== "";
+		return stripBasePath(current.pathname, __basePath) === stripBasePath(next.pathname, __basePath) && current.search === next.search && next.hash !== "";
 	} catch {
 		return false;
 	}
@@ -271,25 +490,52 @@ function scrollToHash(hash) {
 	const element = document.getElementById(id);
 	if (element) element.scrollIntoView({ behavior: "auto" });
 }
-/**
-* Reference to the native history.replaceState before patching.
-* Used internally to avoid triggering the interception for internal operations
-* (e.g. saving scroll position shouldn't cause re-renders).
-* Captured before the history method patching at the bottom of this module.
-*/
-const _nativeReplaceState = !isServer ? window.history.replaceState.bind(window.history) : null;
+function withSuppressedUrlNotifications(fn) {
+	const state = getClientNavigationState();
+	if (!state) return fn();
+	state.suppressUrlNotifyCount += 1;
+	try {
+		return fn();
+	} finally {
+		state.suppressUrlNotifyCount -= 1;
+	}
+}
+function commitClientNavigationState() {
+	if (isServer) return;
+	const state = getClientNavigationState();
+	if (!state) return;
+	if (state.navigationSnapshotActiveCount > 0) state.navigationSnapshotActiveCount -= 1;
+	const urlChanged = syncCommittedUrlStateFromLocation();
+	if (state.pendingClientParams !== null && state.pendingClientParamsJson !== null) {
+		state.clientParams = state.pendingClientParams;
+		state.clientParamsJson = state.pendingClientParamsJson;
+		state.pendingClientParams = null;
+		state.pendingClientParamsJson = null;
+	}
+	const shouldNotify = urlChanged || state.hasPendingNavigationUpdate;
+	state.hasPendingNavigationUpdate = false;
+	if (shouldNotify) notifyNavigationListeners();
+}
+function pushHistoryStateWithoutNotify(data, unused, url) {
+	withSuppressedUrlNotifications(() => {
+		getClientNavigationState()?.originalPushState.call(window.history, data, unused, url);
+	});
+}
+function replaceHistoryStateWithoutNotify(data, unused, url) {
+	withSuppressedUrlNotifications(() => {
+		getClientNavigationState()?.originalReplaceState.call(window.history, data, unused, url);
+	});
+}
 /**
 * Save the current scroll position into the current history state.
 * Called before every navigation to enable scroll restoration on back/forward.
 *
-* Uses _nativeReplaceState to avoid triggering the history.replaceState
-* interception (which would cause spurious re-renders from notifyListeners).
+* Uses replaceHistoryStateWithoutNotify to avoid triggering the patched
+* history.replaceState interception (which would cause spurious re-renders).
 */
 function saveScrollPosition() {
-	if (!_nativeReplaceState) return;
-	const state = window.history.state ?? {};
-	_nativeReplaceState.call(window.history, {
-		...state,
+	replaceHistoryStateWithoutNotify({
+		...window.history.state ?? {},
 		__vinext_scrollX: window.scrollX,
 		__vinext_scrollY: window.scrollY
 	}, "");
@@ -306,7 +552,8 @@ function saveScrollPosition() {
 * This handler fires before the browser entry's popstate handler (because
 * navigation.ts is loaded before hydration completes), so we defer via a
 * microtask to give the browser entry handler a chance to set
-* __VINEXT_RSC_PENDING__ first.
+* __VINEXT_RSC_PENDING__. Promise.resolve() schedules a microtask
+* that runs after all synchronous event listeners have completed.
 */
 function restoreScrollPosition(state) {
 	if (state && typeof state === "object" && "__vinext_scrollY" in state) {
@@ -327,7 +574,7 @@ function restoreScrollPosition(state) {
 /**
 * Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
 */
-async function navigateImpl(href, mode, scroll) {
+async function navigateClientSide(href, mode, scroll) {
 	let normalizedHref = href;
 	if (isExternalUrl(href)) {
 		const localPath = toSameOriginAppPath(href, __basePath);
@@ -343,29 +590,31 @@ async function navigateImpl(href, mode, scroll) {
 	if (mode === "push") saveScrollPosition();
 	if (isHashOnlyChange(fullHref)) {
 		const hash = fullHref.includes("#") ? fullHref.slice(fullHref.indexOf("#")) : "";
-		if (mode === "replace") window.history.replaceState(null, "", fullHref);
-		else window.history.pushState(null, "", fullHref);
-		notifyListeners();
+		if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
+		else pushHistoryStateWithoutNotify(null, "", fullHref);
+		commitClientNavigationState();
 		if (scroll) scrollToHash(hash);
 		return;
 	}
 	const hashIdx = fullHref.indexOf("#");
 	const hash = hashIdx !== -1 ? fullHref.slice(hashIdx) : "";
-	if (mode === "replace") window.history.replaceState(null, "", fullHref);
-	else window.history.pushState(null, "", fullHref);
-	notifyListeners();
-	if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") await window.__VINEXT_RSC_NAVIGATE__(fullHref);
+	if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") await window.__VINEXT_RSC_NAVIGATE__(fullHref, 0, "navigate", mode);
+	else {
+		if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
+		else pushHistoryStateWithoutNotify(null, "", fullHref);
+		commitClientNavigationState();
+	}
 	if (scroll) if (hash) scrollToHash(hash);
 	else window.scrollTo(0, 0);
 }
 const _appRouter = {
 	push(href, options) {
 		if (isServer) return;
-		navigateImpl(href, "push", options?.scroll !== false);
+		navigateClientSide(href, "push", options?.scroll !== false);
 	},
 	replace(href, options) {
 		if (isServer) return;
-		navigateImpl(href, "replace", options?.scroll !== false);
+		navigateClientSide(href, "replace", options?.scroll !== false);
 	},
 	back() {
 		if (isServer) return;
@@ -377,7 +626,7 @@ const _appRouter = {
 	},
 	refresh() {
 		if (isServer) return;
-		if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") window.__VINEXT_RSC_NAVIGATE__(window.location.href);
+		if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") window.__VINEXT_RSC_NAVIGATE__(window.location.href, 0, "refresh");
 	},
 	prefetch(href) {
 		if (isServer) return;
@@ -385,16 +634,11 @@ const _appRouter = {
 		const prefetched = getPrefetchedUrls();
 		if (prefetched.has(rscUrl)) return;
 		prefetched.add(rscUrl);
-		fetch(rscUrl, {
+		prefetchRscResponse(rscUrl, fetch(rscUrl, {
 			headers: { Accept: "text/x-component" },
 			credentials: "include",
 			priority: "low"
-		}).then((response) => {
-			if (response.ok) storePrefetchResponse(rscUrl, response);
-			else prefetched.delete(rscUrl);
-		}).catch(() => {
-			prefetched.delete(rscUrl);
-		});
+		}));
 	}
 };
 /**
@@ -417,23 +661,21 @@ function useRouter() {
 *
 * @param parallelRoutesKey - Which parallel route to read (default: "children")
 */
-function useSelectedLayoutSegment(_parallelRoutesKey) {
-	const segments = useSelectedLayoutSegments(_parallelRoutesKey);
+function useSelectedLayoutSegment(parallelRoutesKey) {
+	const segments = useSelectedLayoutSegments(parallelRoutesKey);
 	return segments.length > 0 ? segments[0] : null;
 }
 /**
 * Returns all active segments below the layout where it's called.
 *
 * Each layout in the App Router tree wraps its children with a
-* LayoutSegmentProvider whose value is the remaining route tree segments
-* (including route groups, with dynamic params resolved to actual values
-* and catch-all segments joined with "/"). This hook reads those segments
-* directly from context.
+* LayoutSegmentProvider whose value is a map of parallel route key to
+* segment arrays. The "children" key is the default parallel route.
 *
 * @param parallelRoutesKey - Which parallel route to read (default: "children")
 */
-function useSelectedLayoutSegments(_parallelRoutesKey) {
-	return useChildSegments();
+function useSelectedLayoutSegments(parallelRoutesKey) {
+	return useChildSegments(parallelRoutesKey);
 }
 /**
 * useServerInsertedHTML — inject HTML during SSR from client components.
@@ -561,22 +803,26 @@ function unauthorized() {
 	throw new VinextNavigationError("NEXT_UNAUTHORIZED", `${HTTP_ERROR_FALLBACK_ERROR_CODE};401`);
 }
 if (!isServer) {
-	window.addEventListener("popstate", (event) => {
-		notifyListeners();
-		restoreScrollPosition(event.state);
-	});
-	const originalPushState = window.history.pushState.bind(window.history);
-	const originalReplaceState = window.history.replaceState.bind(window.history);
-	window.history.pushState = function patchedPushState(data, unused, url) {
-		originalPushState(data, unused, url);
-		notifyListeners();
-	};
-	window.history.replaceState = function patchedReplaceState(data, unused, url) {
-		originalReplaceState(data, unused, url);
-		notifyListeners();
-	};
+	const state = getClientNavigationState();
+	if (state && !state.patchInstalled) {
+		state.patchInstalled = true;
+		window.addEventListener("popstate", (event) => {
+			if (typeof window.__VINEXT_RSC_NAVIGATE__ !== "function") {
+				commitClientNavigationState();
+				restoreScrollPosition(event.state);
+			}
+		});
+		window.history.pushState = function patchedPushState(data, unused, url) {
+			state.originalPushState.call(window.history, data, unused, url);
+			if (state.suppressUrlNotifyCount === 0) commitClientNavigationState();
+		};
+		window.history.replaceState = function patchedReplaceState(data, unused, url) {
+			state.originalReplaceState.call(window.history, data, unused, url);
+			if (state.suppressUrlNotifyCount === 0) commitClientNavigationState();
+		};
+	}
 }
 //#endregion
-export { GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getClientParams, getLayoutSegmentContext, getNavigationContext, getPrefetchCache, getPrefetchedUrls, isHTTPAccessFallbackError, notFound, permanentRedirect, redirect, setClientParams, setNavigationContext, storePrefetchResponse, toRscUrl, unauthorized, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
+export { GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, __basePath, _registerStateAccessors, activateNavigationSnapshot, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, createClientNavigationRenderSnapshot, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getClientNavigationRenderContext, getClientParams, getLayoutSegmentContext, getNavigationContext, getPrefetchCache, getPrefetchedUrls, isHTTPAccessFallbackError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setNavigationContext, snapshotRscResponse, storePrefetchResponse, toRscUrl, unauthorized, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
 
 //# sourceMappingURL=navigation.js.map