vinext 0.0.50 → 0.0.52

package/dist/shims/navigation.js

@@ -1,12 +1,18 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER } from "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
-import { isHashOnlyBrowserUrlChange, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
+import { isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
+import { scrollToHashTarget } from "./hash-scroll.js";
+import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
+import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
+import { createExternalHistoryStatePreservingMetadata } from "../server/app-history-state.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
+import { AppRouterContext } from "./internal/app-router-context.js";
+import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
 import * as React$1 from "react";
 //#region src/shims/navigation.ts
 /**
@@ -103,6 +109,16 @@ function _registerStateAccessors(accessors) {
 	_getInsertedHTMLCallbacks = accessors.getInsertedHTMLCallbacks;
 	_clearInsertedHTMLCallbacks = accessors.clearInsertedHTMLCallbacks;
 }
+const PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
+function _getPagesNavigationContext() {
+	const accessor = globalThis[PAGES_NAVIGATION_ACCESSOR_KEY];
+	if (!accessor) return null;
+	try {
+		return accessor();
+	} catch {
+		return null;
+	}
+}
 /**
 * Get the navigation context for the current SSR/RSC render.
 * Reads from AsyncLocalStorage when available (concurrent-safe),
@@ -129,6 +145,21 @@ function getCurrentInterceptionContext() {
 	if (isServer) return null;
 	return stripBasePath(window.location.pathname, __basePath);
 }
+function getPrefetchInterceptionContext(targetHref) {
+	if (isServer) return null;
+	let targetUrl;
+	try {
+		targetUrl = new URL(targetHref, window.location.href);
+	} catch {
+		return null;
+	}
+	return resolveManifestNavigationInterceptionContext({
+		basePath: __basePath,
+		currentPathname: window.location.pathname,
+		routeManifest: getNavigationRuntime()?.bootstrap.routeManifest ?? null,
+		targetPathname: targetUrl.pathname
+	});
+}
 function getCurrentNextUrl() {
 	if (isServer) return "/";
 	return window.location.pathname + window.location.search;
@@ -157,18 +188,80 @@ function evictPrefetchCacheIfNeeded() {
 	if (cache.size < 50) return;
 	const now = Date.now();
 	const prefetched = getPrefetchedUrls();
-	for (const [key, entry] of cache) if (now - entry.timestamp >= 3e4) {
-		cache.delete(key);
-		prefetched.delete(key);
-	}
+	for (const [key, entry] of cache) if (now - entry.timestamp >= 3e4) deletePrefetchCacheEntry(cache, prefetched, key, entry, true);
 	while (cache.size >= 50) {
 		const oldest = cache.keys().next().value;
 		if (oldest !== void 0) {
-			cache.delete(oldest);
-			prefetched.delete(oldest);
+			const entry = cache.get(oldest);
+			if (entry) deletePrefetchCacheEntry(cache, prefetched, oldest, entry, true);
+			else {
+				cache.delete(oldest);
+				prefetched.delete(oldest);
+			}
 		} else break;
 	}
 }
+function clearPrefetchInvalidation(entry) {
+	if (entry.invalidationTimer !== void 0) {
+		clearTimeout(entry.invalidationTimer);
+		entry.invalidationTimer = void 0;
+	}
+}
+function notifyPrefetchInvalidated(entry) {
+	clearPrefetchInvalidation(entry);
+	const callbacks = entry.onInvalidateCallbacks;
+	entry.onInvalidateCallbacks = void 0;
+	if (callbacks === void 0) return;
+	for (const onInvalidate of callbacks) try {
+		onInvalidate();
+	} catch (error) {
+		if (typeof reportError === "function") reportError(error);
+		else console.error(error);
+	}
+}
+function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
+	cache.delete(cacheKey);
+	prefetched.delete(cacheKey);
+	if (notify) notifyPrefetchInvalidated(entry);
+	else {
+		clearPrefetchInvalidation(entry);
+		entry.onInvalidateCallbacks = void 0;
+	}
+}
+function invalidatePrefetchCacheEntry(cacheKey) {
+	const cache = getPrefetchCache();
+	const entry = cache.get(cacheKey);
+	if (!entry) return;
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+}
+function schedulePrefetchInvalidation(cacheKey, entry) {
+	if (entry.onInvalidateCallbacks === void 0 || entry.onInvalidateCallbacks.size === 0) return;
+	clearPrefetchInvalidation(entry);
+	const elapsed = Date.now() - entry.timestamp;
+	const delay = Math.max(0, PREFETCH_CACHE_TTL - elapsed);
+	entry.invalidationTimer = setTimeout(() => {
+		invalidatePrefetchCacheEntry(cacheKey);
+	}, delay);
+}
+function addPrefetchInvalidationCallback(entry, onInvalidate) {
+	if (onInvalidate === void 0) return;
+	if (entry.onInvalidateCallbacks === void 0) entry.onInvalidateCallbacks = /* @__PURE__ */ new Set();
+	entry.onInvalidateCallbacks.add(onInvalidate);
+}
+function attachPrefetchInvalidationCallback(cacheKey, onInvalidate) {
+	if (onInvalidate === void 0) return;
+	const entry = getPrefetchCache().get(cacheKey);
+	if (!entry) return;
+	addPrefetchInvalidationCallback(entry, onInvalidate);
+	if (entry.outcome === "cache-seeded") schedulePrefetchInvalidation(cacheKey, entry);
+}
+function invalidatePrefetchCache() {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	for (const [cacheKey, entry] of cache) deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+	prefetched.clear();
+	if (!isServer) getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
 /**
 * Store a prefetched RSC response in the cache by snapshotting it to an
 * ArrayBuffer.  The snapshot completes asynchronously; during that window
@@ -185,37 +278,45 @@ function evictPrefetchCacheIfNeeded() {
 * NB: Caller is responsible for managing getPrefetchedUrls() — this
 * function only stores the response in the prefetch cache.
 */
-function storePrefetchResponse(rscUrl, response, interceptionContext = null) {
+function storePrefetchResponse(rscUrl, response, interceptionContext = null, options) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	evictPrefetchCacheIfNeeded();
 	const entry = {
 		outcome: "pending",
 		timestamp: Date.now()
 	};
+	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.pending = snapshotRscResponse(response).then((snapshot) => {
 		entry.snapshot = snapshot;
 	}).catch(() => {
-		getPrefetchCache().delete(cacheKey);
+		deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, false);
 	}).finally(() => {
 		entry.pending = void 0;
-		if (entry.snapshot) entry.outcome = "cache-seeded";
+		if (entry.snapshot) {
+			entry.outcome = "cache-seeded";
+			schedulePrefetchInvalidation(cacheKey, entry);
+		}
 	});
 	getPrefetchCache().set(cacheKey, entry);
 }
-/**
-* 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) {
+function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
 	return {
-		buffer: await response.arrayBuffer(),
+		compatibilityIdHeader: response.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+		buffer,
 		contentType: response.headers.get("content-type") ?? "text/x-component",
 		mountedSlotsHeader: response.headers.get(VINEXT_MOUNTED_SLOTS_HEADER),
 		paramsHeader: response.headers.get(VINEXT_PARAMS_HEADER),
-		url: response.url
+		url: responseUrl ?? response.url
 	};
 }
 /**
+* 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 createCachedRscResponseSnapshot(response, await response.arrayBuffer());
+}
+/**
 * Reconstruct a Response from a cached RSC snapshot.
 * Creates a new Response with the original ArrayBuffer so createFromFetch
 * can consume the stream from scratch.
@@ -233,6 +334,7 @@ async function snapshotRscResponse(response) {
 function restoreRscResponse(cached, copy = true) {
 	const headers = new Headers({ "content-type": cached.contentType });
 	if (cached.mountedSlotsHeader != null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, cached.mountedSlotsHeader);
+	if (cached.compatibilityIdHeader != null) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, cached.compatibilityIdHeader);
 	if (cached.paramsHeader != null) headers.set(VINEXT_PARAMS_HEADER, cached.paramsHeader);
 	return new Response(copy ? cached.buffer.slice(0) : cached.buffer, {
 		status: 200,
@@ -246,29 +348,32 @@ function restoreRscResponse(cached, copy = true) {
 * Enforces a maximum cache size to prevent unbounded memory growth on
 * link-heavy pages.
 */
-function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, mountedSlotsHeader = null) {
+function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, mountedSlotsHeader = null, options, behavior = {}) {
 	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 	const cache = getPrefetchCache();
 	const prefetched = getPrefetchedUrls();
+	const now = Date.now();
 	const entry = {
+		cacheForNavigation: behavior.cacheForNavigation ?? true,
+		optimisticRouteShell: behavior.optimisticRouteShell === true,
 		outcome: "pending",
-		timestamp: Date.now()
+		timestamp: now
 	};
+	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.pending = fetchPromise.then(async (response) => {
 		if (response.ok) entry.snapshot = {
 			...await snapshotRscResponse(response),
 			mountedSlotsHeader
 		};
-		else {
-			prefetched.delete(cacheKey);
-			cache.delete(cacheKey);
-		}
+		else deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
 	}).catch(() => {
-		prefetched.delete(cacheKey);
-		cache.delete(cacheKey);
+		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
 	}).finally(() => {
 		entry.pending = void 0;
-		if (entry.snapshot) entry.outcome = "cache-seeded";
+		if (entry.snapshot) {
+			entry.outcome = "cache-seeded";
+			schedulePrefetchInvalidation(cacheKey, entry);
+		}
 	});
 	cache.set(cacheKey, entry);
 	evictPrefetchCacheIfNeeded();
@@ -284,8 +389,8 @@ function consumePrefetchResponse(rscUrl, interceptionContext = null, mountedSlot
 	const entry = cache.get(cacheKey);
 	if (!entry) return null;
 	if (entry.pending || entry.outcome !== "cache-seeded") return null;
-	cache.delete(cacheKey);
-	getPrefetchedUrls().delete(cacheKey);
+	if (entry.cacheForNavigation === false) return null;
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
 	if (entry.snapshot) {
 		if ((entry.snapshot.mountedSlotsHeader ?? null) !== mountedSlotsHeader) return null;
 		if (Date.now() - entry.timestamp >= 3e4) return null;
@@ -379,6 +484,8 @@ function syncCommittedUrlStateFromLocation() {
 function getServerSearchParamsSnapshot() {
 	const ctx = _getServerContext();
 	if (!ctx) {
+		const pagesCtx = _getPagesNavigationContext();
+		if (pagesCtx) return new ReadonlyURLSearchParams(pagesCtx.searchParams);
 		if (_cachedEmptyServerSearchParams === null) _cachedEmptyServerSearchParams = new ReadonlyURLSearchParams();
 		return _cachedEmptyServerSearchParams;
 	}
@@ -488,10 +595,16 @@ function clearPendingPathname(navId) {
 	}
 }
 function getClientParamsSnapshot() {
-	return getClientNavigationState()?.clientParams ?? _EMPTY_PARAMS;
+	const state = getClientNavigationState();
+	if (state && Object.keys(state.clientParams).length > 0) return state.clientParams;
+	const pagesCtx = _getPagesNavigationContext();
+	if (pagesCtx) return pagesCtx.params;
+	return state?.clientParams ?? _EMPTY_PARAMS;
 }
 function getServerParamsSnapshot() {
-	return _getServerContext()?.params ?? _EMPTY_PARAMS;
+	const ctx = _getServerContext();
+	if (ctx) return ctx.params;
+	return _getPagesNavigationContext()?.params ?? _EMPTY_PARAMS;
 }
 function subscribeToNavigation(cb) {
 	const state = getClientNavigationState();
@@ -506,9 +619,13 @@ function subscribeToNavigation(cb) {
 * Server: from request context. Client: from window.location.
 */
 function usePathname() {
-	if (isServer) return _getServerContext()?.pathname ?? "/";
+	if (isServer) {
+		const ctx = _getServerContext();
+		if (ctx) return ctx.pathname;
+		return _getPagesNavigationContext()?.pathname ?? "/";
+	}
 	const renderSnapshot = useClientNavigationRenderSnapshot();
-	const pathname = React$1.useSyncExternalStore(subscribeToNavigation, getPathnameSnapshot, () => _getServerContext()?.pathname ?? "/");
+	const pathname = React$1.useSyncExternalStore(subscribeToNavigation, getPathnameSnapshot, () => _getServerContext()?.pathname ?? _getPagesNavigationContext()?.pathname ?? "/");
 	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.pathname;
 	return pathname;
 }
@@ -526,7 +643,7 @@ function useSearchParams() {
 * Returns the dynamic params for the current route.
 */
 function useParams() {
-	if (isServer) return _getServerContext()?.params ?? _EMPTY_PARAMS;
+	if (isServer) return getServerParamsSnapshot();
 	const renderSnapshot = useClientNavigationRenderSnapshot();
 	const params = React$1.useSyncExternalStore(subscribeToNavigation, getClientParamsSnapshot, getServerParamsSnapshot);
 	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.params;
@@ -536,7 +653,7 @@ function useParams() {
 * Check if a href is an external URL (any URL scheme per RFC 3986, or protocol-relative).
 */
 function isExternalUrl(href) {
-	return /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+	return isAbsoluteOrProtocolRelativeUrl(href);
 }
 /**
 * Check if a href is only a hash change relative to the current URL.
@@ -546,18 +663,6 @@ function isHashOnlyChange(href) {
 	if (href.startsWith("#")) return true;
 	return isHashOnlyBrowserUrlChange(href, window.location.href, __basePath);
 }
-/**
-* Scroll to a hash target element, or to the top if no hash.
-*/
-function scrollToHash(hash) {
-	if (!hash || hash === "#") {
-		window.scrollTo(0, 0);
-		return;
-	}
-	const id = hash.slice(1);
-	const element = document.getElementById(id);
-	if (element) element.scrollIntoView({ behavior: "auto" });
-}
 function withSuppressedUrlNotifications(fn) {
 	const state = getClientNavigationState();
 	if (!state) return fn();
@@ -594,7 +699,10 @@ function commitClientNavigationState(navId, options) {
 	}
 	const shouldNotify = urlChanged || state.hasPendingNavigationUpdate;
 	state.hasPendingNavigationUpdate = false;
-	if (shouldNotify) notifyNavigationListeners();
+	if (shouldNotify) {
+		notifyNavigationListeners();
+		getNavigationRuntime()?.functions.pingVisibleLinks?.();
+	}
 }
 function pushHistoryStateWithoutNotify(data, unused, url) {
 	withSuppressedUrlNotifications(() => {
@@ -620,12 +728,21 @@ function saveScrollPosition() {
 		__vinext_scrollY: window.scrollY
 	}, "");
 }
+function commitHashOnlyHistoryState(href, mode, scroll) {
+	const commitAppRouterHashNavigation = getNavigationRuntime()?.functions.commitHashNavigation;
+	if (commitAppRouterHashNavigation) {
+		commitAppRouterHashNavigation(href, mode, scroll);
+		return;
+	}
+	if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", href);
+	else pushHistoryStateWithoutNotify(null, "", href);
+}
 /**
 * Restore scroll position from a history state object (used on popstate).
 *
 * When an RSC navigation is in flight (back/forward triggers both this
-* handler and the browser entry's popstate handler which calls
-* __VINEXT_RSC_NAVIGATE__), we must wait for the new content to render
+* handler and the browser entry's popstate handler which calls the registered
+* navigation runtime), we must wait for the new content to render
 * before scrolling. Otherwise the user sees old content flash at the
 * restored scroll position.
 *
@@ -670,33 +787,31 @@ async function navigateClientSide(href, mode, scroll, programmaticTransition = f
 	if (mode === "push") saveScrollPosition();
 	if (isHashOnlyChange(fullHref)) {
 		const hash = fullHref.includes("#") ? fullHref.slice(fullHref.indexOf("#")) : "";
-		if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
-		else pushHistoryStateWithoutNotify(null, "", fullHref);
+		commitHashOnlyHistoryState(fullHref, mode, scroll);
 		commitClientNavigationState();
-		if (scroll) scrollToHash(hash);
+		if (scroll) scrollToHashTarget(hash);
 		return;
 	}
 	const hashIdx = fullHref.indexOf("#");
 	const hash = hashIdx !== -1 ? fullHref.slice(hashIdx) : "";
-	if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") await window.__VINEXT_RSC_NAVIGATE__(fullHref, 0, "navigate", mode, void 0, programmaticTransition);
+	const appNavigate = getNavigationRuntime()?.functions.navigate;
+	if (appNavigate) await appNavigate(fullHref, 0, "navigate", mode, void 0, programmaticTransition);
 	else {
 		if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
 		else pushHistoryStateWithoutNotify(null, "", fullHref);
 		commitClientNavigationState();
 	}
-	if (scroll) if (hash) scrollToHash(hash);
+	if (scroll) if (hash) scrollToHashTarget(hash);
 	else window.scrollTo(0, 0);
 }
 /**
-* App Router public router instance. Mirrors Next.js's
-* `publicAppRouterInstance` from
-* `packages/next/src/client/components/app-router-instance.ts`.
+* Public App Router instance, exposed for the browser entry so it can wire
+* `window.next.router` to the same singleton returned from `useRouter()`.
 *
-* Exported so the App Router browser entry can install it on
-* `window.next.router` for Next.js parity (see `client/window-next.ts`).
-* Internal callers in this file continue to use `_appRouter` for brevity.
+* Mirrors `publicAppRouterInstance` from Next.js's
+* `packages/next/src/client/components/app-router-instance.ts` (line 392).
 */
-const _appRouter = {
+const appRouterInstance = {
 	bfcacheId: "0",
 	push(href, options) {
 		assertSafeNavigationUrl(href);
@@ -722,55 +837,49 @@ const _appRouter = {
 	},
 	refresh() {
 		if (isServer) return;
-		const clearCaches = window.__VINEXT_CLEAR_NAV_CACHES__;
-		if (typeof clearCaches === "function") clearCaches();
-		const rscNavigate = window.__VINEXT_RSC_NAVIGATE__;
-		if (typeof rscNavigate === "function") {
+		getNavigationRuntime()?.functions.clearNavigationCaches?.();
+		const rscNavigate = getNavigationRuntime()?.functions.navigate;
+		if (rscNavigate) {
 			const navigate = () => {
 				rscNavigate(window.location.href, 0, "refresh", void 0, void 0, true);
 			};
 			React$1.startTransition(navigate);
 		}
 	},
-	prefetch(href) {
+	prefetch(href, options) {
 		assertSafeNavigationUrl(href);
 		if (isServer) return;
 		(async () => {
 			let prefetchHref = href;
-			if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//")) {
+			if (isAbsoluteOrProtocolRelativeUrl(href)) {
 				const localPath = toSameOriginAppPath(href, __basePath);
 				if (localPath == null) return;
 				prefetchHref = localPath;
 			}
 			const fullHref = toBrowserNavigationHref(prefetchHref, window.location.href, __basePath);
-			const interceptionContext = getCurrentInterceptionContext();
+			const interceptionContext = getPrefetchInterceptionContext(fullHref);
 			const mountedSlotsHeader = getMountedSlotsHeader();
 			const headers = createRscRequestHeaders({ interceptionContext });
 			if (mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, mountedSlotsHeader);
 			const rscUrl = await createRscRequestUrl(fullHref, headers);
 			const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
 			const prefetched = getPrefetchedUrls();
-			if (prefetched.has(cacheKey)) return;
+			if (prefetched.has(cacheKey)) {
+				attachPrefetchInvalidationCallback(cacheKey, options?.onInvalidate);
+				return;
+			}
 			prefetched.add(cacheKey);
 			prefetchRscResponse(rscUrl, fetch(rscUrl, {
 				headers,
 				credentials: "include",
 				priority: "low"
-			}), interceptionContext, mountedSlotsHeader);
+			}), interceptionContext, mountedSlotsHeader, options);
 		})().catch((error) => {
 			console.error("[vinext] RSC prefetch setup error:", error);
 		});
 	}
 };
 /**
-* Public App Router instance, exposed for the browser entry so it can wire
-* `window.next.router` to the same singleton returned from `useRouter()`.
-*
-* Mirrors `publicAppRouterInstance` from Next.js's
-* `packages/next/src/client/components/app-router-instance.ts` (line 392).
-*/
-const appRouterInstance = _appRouter;
-/**
 * App Router's useRouter — returns push/replace/back/forward/refresh.
 * Different from Pages Router's useRouter (next/router).
 *
@@ -779,7 +888,10 @@ const appRouterInstance = _appRouter;
 * (e.g. useMemo / useEffect deps, React.memo) don't re-render unnecessarily.
 */
 function useRouter() {
-	return _appRouter;
+	if (!AppRouterContext || typeof React$1.useContext !== "function") throw new Error("invariant expected app router to be mounted");
+	const router = React$1.useContext(AppRouterContext);
+	if (router === null) throw new Error("invariant expected app router to be mounted");
+	return router;
 }
 /**
 * Returns the active child segment one level below the layout where it's called.
@@ -964,27 +1076,186 @@ function forbidden() {
 function unauthorized() {
 	throw new VinextNavigationError("NEXT_UNAUTHORIZED", `${HTTP_ERROR_FALLBACK_ERROR_CODE};401`);
 }
+/**
+* Check whether an error was produced by `redirect()` or `permanentRedirect()`.
+*
+* **Note on vinext public surface:** Next.js does NOT expose `isRedirectError`
+* from `next/navigation` — it's an internal predicate. vinext exposes it for
+* symmetry with the already-public `isHTTPAccessFallbackError` and because
+* `unstable_rethrow` consumers benefit from being able to narrow types.
+* Treat it as a vinext-only extension.
+*
+* **Divergence from Next.js:** Next.js's internal `isRedirectError` performs
+* full 4-segment validation — it splits the digest on `;`, checks `type` ∈
+* {push, replace}, requires a non-empty destination, and validates the
+* status code (303, 307, 308). See:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/redirect-error.ts
+*
+* vinext instead uses a simple prefix check (`startsWith("NEXT_REDIRECT;")`).
+* Reasons:
+*   1. vinext emits two digest shapes — 3-part for `redirect()`
+*      (`NEXT_REDIRECT;{type};{encoded-url}`) and 4-part for
+*      `permanentRedirect()` (`NEXT_REDIRECT;{type};{encoded-url};308`).
+*      Strict validation would have to special-case both, and Next.js's
+*      validator (tuned to its 5-part canary digests) rejects them.
+*   2. The `type` field is sometimes empty in vinext's redirect digests
+*      (context-dependent resolution; see `redirect()` above), which the
+*      strict check disallows.
+*
+* **Consequence:** A malformed digest such as `"NEXT_REDIRECT;garbage"`
+* returns `true` here, whereas Next.js would return `false`. In practice,
+* the only callers of this predicate are vinext-internal code paths
+* (`unstable_rethrow`, `unstable_catchError`, the redirect error boundary)
+* that see digests vinext itself emits — so the divergence does not surface
+* in normal use. Maintainers extending the prefix logic should keep this
+* predicate in lockstep with the corresponding `decode*` helpers in
+* `shims/error-boundary.tsx`.
+*/
+function isRedirectError(error) {
+	if (!error || typeof error !== "object" || !("digest" in error) || typeof error.digest !== "string") return false;
+	return error.digest.startsWith("NEXT_REDIRECT;");
+}
+/**
+* Returns true if the error is a Next.js navigation signal — either a redirect
+* or an HTTP access fallback (notFound / forbidden / unauthorized).
+*
+* **Note on vinext public surface:** Like `isRedirectError`, Next.js does NOT
+* expose this from `next/navigation`. vinext exposes it for symmetry — treat
+* it as a vinext-only extension.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/is-next-router-error.ts
+*/
+function isNextRouterError(error) {
+	return isRedirectError(error) || isHTTPAccessFallbackError(error);
+}
+const _BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+/**
+* Error thrown to bail out of server rendering and fall back to client-side
+* rendering. Used by `next/dynamic` with `ssr: false`.
+*
+* vinext does not yet emit this error itself — it's exposed so user code and
+* third-party libraries that mimic `next/dynamic`'s bailout semantics can
+* construct an error with the canonical digest that `unstable_rethrow`
+* recognises.
+*
+* Ported 1:1 from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/lazy-dynamic/bailout-to-csr.ts
+*/
+var BailoutToCSRError = class extends Error {
+	digest = _BAILOUT_TO_CSR_DIGEST;
+	reason;
+	constructor(reason) {
+		super(`Bail out to client-side rendering: ${reason}`);
+		this.reason = reason;
+	}
+};
+/**
+* Returns true if the error is a `BailoutToCSRError`. Matches Next.js's
+* digest-based predicate, so any error from a foreign module instance of
+* the class (or constructed manually with the canonical digest) is also
+* detected.
+*
+* **Note on vinext public surface:** Next.js does NOT expose this from
+* `next/navigation`. vinext exposes it for symmetry with `isRedirectError`
+* — treat it as a vinext-only extension. The matching producer
+* (`BailoutToCSRError`) is the public detection contract; Next.js exposes
+* neither.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/lazy-dynamic/bailout-to-csr.ts
+*/
+function isBailoutToCSRError(error) {
+	if (!error || typeof error !== "object" || !("digest" in error)) return false;
+	return error.digest === _BAILOUT_TO_CSR_DIGEST;
+}
+const _DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+/**
+* Error thrown when dynamic server APIs (`cookies()`, `headers()`, etc.) are
+* used inside a static/prerender context. Carries the `DYNAMIC_SERVER_USAGE`
+* digest so `unstable_rethrow` can recognise and propagate it.
+*
+* vinext does not construct this error itself — exposed for the same
+* "stable detection contract" reason as `BailoutToCSRError` above.
+*
+* Ported 1:1 from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/hooks-server-context.ts
+*/
+var DynamicServerError = class extends Error {
+	digest = _DYNAMIC_SERVER_USAGE_DIGEST;
+	description;
+	constructor(description) {
+		super(`Dynamic server usage: ${description}`);
+		this.description = description;
+	}
+};
+/**
+* Returns true if the error is a `DynamicServerError` (or any error with the
+* canonical `DYNAMIC_SERVER_USAGE` digest).
+*
+* **Note on vinext public surface:** Next.js does NOT expose this from
+* `next/navigation`. vinext exposes it for symmetry — treat it as a
+* vinext-only extension.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/hooks-server-context.ts
+*/
+function isDynamicServerError(error) {
+	if (!error || typeof error !== "object" || !("digest" in error)) return false;
+	return error.digest === _DYNAMIC_SERVER_USAGE_DIGEST;
+}
+/**
+* Rethrow internal Next.js errors so they're handled by the framework.
+*
+* When wrapping an API that uses errors for control flow (redirect, notFound,
+* cookies in static render, `next/dynamic` SSR bailout, etc.), call this
+* inside `catch` blocks before doing your own error handling. If the error
+* is a Next.js internal error, it's rethrown; otherwise this is a no-op
+* (apart from recursing through `error.cause`).
+*
+* Recognises (matches Next.js's browser build + the subset of the server
+* build that vinext can realistically encounter):
+*   - `isNextRouterError`: redirect / notFound / forbidden / unauthorized
+*   - `isBailoutToCSRError`: `next/dynamic` `ssr: false` bailout
+*   - `isDynamicServerError`: dynamic API used in static render
+*
+* vinext does not yet recognise four additional server-only Next.js
+* categories — `isDynamicPostpone`, `isPostpone`,
+* `isHangingPromiseRejectionError`, `isPrerenderInterruptedError` — because
+* they signal PPR / prerender-controller events that vinext's render
+* pipeline does not generate. User code cannot construct these in normal
+* use; they will be added if/when vinext grows PPR support.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/unstable-rethrow.ts
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/unstable-rethrow.server.ts
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/unstable-rethrow.browser.ts
+*/
+function unstable_rethrow(error) {
+	if (isNextRouterError(error) || isBailoutToCSRError(error) || isDynamicServerError(error)) throw error;
+	if (error instanceof Error && "cause" in error) unstable_rethrow(error.cause);
+}
 if (!isServer) {
 	const state = getClientNavigationState();
 	if (state && !state.patchInstalled) {
 		state.patchInstalled = true;
 		window.addEventListener("popstate", (event) => {
-			if (typeof window.__VINEXT_RSC_NAVIGATE__ !== "function") {
+			if (!hasAppNavigationRuntime()) {
 				commitClientNavigationState();
 				restoreScrollPosition(event.state);
 			}
 		});
 		window.history.pushState = function patchedPushState(data, unused, url) {
-			state.originalPushState.call(window.history, data, unused, url);
+			state.originalPushState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), unused, url);
 			if (state.suppressUrlNotifyCount === 0) commitClientNavigationState();
 		};
 		window.history.replaceState = function patchedReplaceState(data, unused, url) {
-			state.originalReplaceState.call(window.history, data, unused, url);
+			state.originalReplaceState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), 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, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, createClientNavigationRenderSnapshot, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchedUrls, isHTTPAccessFallbackError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, restoreRscResponse, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
 
 //# sourceMappingURL=navigation.js.map