vinext 1.4.4 → 1.4.5

package/dist/shims/app-router-navigation.js

@@ -0,0 +1,1559 @@
+import { __basePath, commitClientNavigationState, getClientNavigationState } from "./navigation.js";
+import { getNavigationRuntime, hasAppNavigationRuntime, loadNavigationRuntimeRouteManifest } from "../client/navigation-runtime.js";
+import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
+import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "../server/app-rsc-vary.js";
+import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
+import "../server/app-bfcache-id.js";
+import "../server/app-elements.js";
+import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
+import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState, readHistoryStateTraversalIndex } from "../server/app-history-state.js";
+import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, formatRscRequestPath, parseRscRequestPath, stripRscCacheBustingSearchParam } from "../server/app-rsc-cache-busting.js";
+import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
+import { NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_STALE_TIME_PENDING_HEADER } from "../server/headers.js";
+import { extractRscCompletionMetadata } from "../server/rsc-completion-metadata.js";
+import { isHashOnlyBrowserUrlChange, toCanonicalBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { navigationPlanner } from "../server/navigation-planner.js";
+import { stripBasePath } from "../utils/base-path.js";
+import { isBotUserAgent } from "../utils/html-limited-bots.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import { isExternalUrl } from "../utils/external-url.js";
+import { assertSafeNavigationUrl } from "./url-safety.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-route-owner-direct.js";
+import { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
+import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
+import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
+import { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch } from "./internal/app-prefetch-fetch-queue.js";
+import * as React$1 from "react";
+// src/shims/app-router-navigation.ts
+/**
+* App Router client navigation runtime.
+*
+* The prefetch cache, router history writes and `window.history` patches,
+* scroll handling, `navigateClientSide` and the public App Router instance.
+* Kept out of `navigation.ts` (the `next/navigation` hooks and the client
+* navigation state they read) so Pages Router pages that use those hooks don't
+* load it. In Next.js too, the hooks read React contexts and this machinery
+* lives in the App Router (`app-router.tsx`, `app-router-instance.ts`).
+*
+* The App Router browser entry imports this module before hydration, which
+* installs the history patches below. `next/link` and `next/form` load it for
+* App Router navigations.
+*/
+const HAS_PAGES_ROUTER = process.env.__VINEXT_HAS_PAGES_ROUTER !== "false";
+const HAS_CLIENT_REWRITES = process.env.__VINEXT_HAS_CLIENT_REWRITES !== "false";
+let hybridClientRouteOwnerModule = null;
+let hybridClientRouteOwnerModulePromise = null;
+/** Load rewrite-aware hybrid route ownership before navigation becomes interactive. */
+async function preloadHybridClientRouteOwner() {
+	if (hybridClientRouteOwnerModule) return;
+	hybridClientRouteOwnerModulePromise ??= import("./internal/hybrid-client-route-owner.js");
+	hybridClientRouteOwnerModule = await hybridClientRouteOwnerModulePromise;
+}
+function resolveLoadedHybridClientRewriteHref(href, basePath) {
+	return hybridClientRouteOwnerModule?.resolveHybridClientRewriteHref(href, basePath) ?? null;
+}
+function resolveHybridClientRouteOwner(href) {
+	if (!HAS_PAGES_ROUTER) return null;
+	return hybridClientRouteOwnerModule ? hybridClientRouteOwnerModule.resolveHybridClientRouteOwner(href, __basePath) : resolveDirectHybridClientRouteOwner(href, __basePath);
+}
+const isServer = typeof window === "undefined";
+/** trailingSlash from next.config.js, injected by the plugin at build time */
+const __trailingSlash = process.env.__VINEXT_TRAILING_SLASH === "true";
+/** prefetch inlining (Segment Cache wire mode), injected by the plugin at build time */
+const __prefetchInlining = process.env.__VINEXT_PREFETCH_INLINING === "true";
+/** Maximum buffered bytes in the RSC prefetch cache. Mirrors Next.js' 50 MB LRU. */
+const MAX_PREFETCH_CACHE_SIZE = 52428800;
+const PREFETCH_CACHE_EVICTION_TARGET_SIZE = MAX_PREFETCH_CACHE_SIZE * .9;
+/**
+* TTL for prefetch cache entries in ms.
+*
+* Mirrors Next.js' `STATIC_STALETIME_MS` derivation. The plugin injects
+* `process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME` from
+* `experimental.staleTimes.static` (in seconds) at build time; we convert
+* to ms here.
+*
+* Falls back to vinext's historical default of 30s when the env var is
+* absent (e.g. unit tests that import this module without going through
+* the plugin's `define` pipeline). When the plugin is active and the user
+* has not set `experimental.staleTimes`, Next.js' 300s default applies
+* (see `resolveStaleTimes` in `config/next-config.ts`).
+*/
+function resolveClientRouterStaleTime(raw, fallbackMs) {
+	if (raw === void 0 || raw === "") return fallbackMs;
+	const seconds = Number(raw);
+	if (!Number.isFinite(seconds) || seconds < 0) return fallbackMs;
+	return seconds * 1e3;
+}
+const DYNAMIC_NAVIGATION_CACHE_TTL = resolveClientRouterStaleTime(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME, 3e4);
+const PREFETCH_CACHE_TTL = resolveClientRouterStaleTime(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME, 3e4);
+/**
+* Floor for any server-declared `cacheLife` stale time, mirroring Next.js's
+* `getStaleTimeMs` (`Math.max(staleTimeSeconds, 30) * 1000`). One rule for
+* both client caches, so behavior does not depend on which cache a route hit.
+*/
+const MIN_SERVER_STALE_TIME_SECONDS = 30;
+const MIN_PREFETCH_STALE_TIME_MS = MIN_SERVER_STALE_TIME_SECONDS * 1e3;
+function getCurrentInterceptionContext() {
+	if (isServer) return null;
+	return stripBasePath(window.location.pathname, __basePath);
+}
+function getPrefetchInterceptionContext(targetHref, currentPathname) {
+	if (isServer) return null;
+	let targetUrl;
+	try {
+		targetUrl = new URL(targetHref, window.location.href);
+	} catch {
+		return null;
+	}
+	return resolveManifestNavigationInterceptionContext({
+		basePath: __basePath,
+		currentPathname: currentPathname ?? window.location.pathname,
+		routeManifest: getNavigationRuntime()?.bootstrap.routeManifest ?? null,
+		targetPathname: targetUrl.pathname
+	});
+}
+function getCurrentNextUrl() {
+	if (isServer) return "/";
+	return window.location.pathname + window.location.search;
+}
+function createAppPrefetchRequestHeaders(options) {
+	const prefetchRouterState = getNavigationRuntime()?.functions.getPrefetchRouterState?.() ?? null;
+	return createRscRequestHeaders({
+		...options,
+		nextUrl: getCurrentNextUrl(),
+		includePrefetchHeader: options.prefetchKind !== "full",
+		prefetchRouterState
+	});
+}
+/** Get or create the shared in-memory RSC prefetch cache on window. */
+function getPrefetchCache() {
+	if (isServer) return /* @__PURE__ */ new Map();
+	if (!window.__VINEXT_RSC_PREFETCH_CACHE__) window.__VINEXT_RSC_PREFETCH_CACHE__ = /* @__PURE__ */ new Map();
+	return window.__VINEXT_RSC_PREFETCH_CACHE__;
+}
+/**
+* Read an exact prefetch entry without allowing a settled stale value to
+* steer a later request. Timers are an eviction optimization, not a freshness
+* guarantee: background throttling can leave an expired route-tree entry in
+* the Map until the next foreground read.
+*/
+function getFreshPrefetchCacheEntry(cacheKey) {
+	const cache = getPrefetchCache();
+	const entry = cache.get(cacheKey);
+	if (entry === void 0 || entry.pending) return entry;
+	if (resolvePrefetchCacheEntryExpiresAt(entry) > Date.now()) return entry;
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+}
+/**
+* Get or create the shared set of already-prefetched RSC URLs on window.
+* Keyed by interception-aware cache key so distinct source routes do not alias.
+*/
+function getPrefetchedUrls() {
+	if (isServer) return /* @__PURE__ */ new Set();
+	if (!window.__VINEXT_RSC_PREFETCHED_URLS__) window.__VINEXT_RSC_PREFETCHED_URLS__ = /* @__PURE__ */ new Set();
+	return window.__VINEXT_RSC_PREFETCHED_URLS__;
+}
+function isStaleTimeSeconds(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function isCacheExpiresAt(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function parseStaleTimeSecondsHeader(value) {
+	if (value === null || value === "") return void 0;
+	const seconds = Number(value);
+	return isStaleTimeSeconds(seconds) ? seconds : void 0;
+}
+/**
+* The floor a `cacheLife` claim licenses. A pending claim contributes exactly
+* the floor — the least any resolution of it could have granted.
+*/
+function serverStaleTimeSeconds(server) {
+	if (server === void 0) return void 0;
+	if (server.kind === "pending") return MIN_SERVER_STALE_TIME_SECONDS;
+	return Math.max(server.seconds, MIN_SERVER_STALE_TIME_SECONDS);
+}
+/**
+* Min-combine the two independent staleness lattices a response can carry:
+* `dynamicStaleTimeSeconds` (from `experimental.staleTimes` config) and
+* `serverStaleTime` (from the render's `cacheLife`) — neither may override
+* the other. The cacheLife value is floored *before* the min so the floor
+* never raises the config bound. Undefined = no signal; the caller's
+* fallback TTL stays in force.
+*/
+function resolveRscResponseStaleTimeSeconds(cached) {
+	const dynamic = cached.dynamicStaleTimeSeconds;
+	const server = serverStaleTimeSeconds(cached.serverStaleTime);
+	if (!isStaleTimeSeconds(dynamic)) return server;
+	return server === void 0 ? dynamic : Math.min(dynamic, server);
+}
+function resolveCachedRscResponseTtlMs(cached, fallbackTtlMs) {
+	const seconds = resolveRscResponseStaleTimeSeconds(cached);
+	if (seconds === void 0) return fallbackTtlMs;
+	return seconds * 1e3;
+}
+function resolveCachedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs) {
+	if (isCacheExpiresAt(cached.expiresAt)) return cached.expiresAt;
+	return timestamp + resolveCachedRscResponseTtlMs(cached, fallbackTtlMs);
+}
+function resolvePrefetchedRscResponseExpiresAt(timestamp, cached, fallbackTtlMs, dynamicStaleTime) {
+	if (isCacheExpiresAt(cached.expiresAt)) return cached.expiresAt;
+	const serverSeconds = cached.serverStaleTime?.kind === "pending" && dynamicStaleTime !== "verbatim" ? void 0 : serverStaleTimeSeconds(cached.serverStaleTime);
+	if (serverSeconds !== void 0) return timestamp + serverSeconds * 1e3;
+	if (dynamicStaleTime === "ignore") return timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
+	const seconds = isStaleTimeSeconds(cached.dynamicStaleTimeSeconds) ? cached.dynamicStaleTimeSeconds : void 0;
+	if (seconds === void 0) return timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
+	return dynamicStaleTime === "verbatim" ? timestamp + seconds * 1e3 : timestamp + (seconds === 0 ? Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS) : Math.max(seconds * 1e3, MIN_PREFETCH_STALE_TIME_MS));
+}
+function resolvePrefetchCacheEntryExpiresAt(entry) {
+	if (entry.expiresAt !== void 0) return entry.expiresAt;
+	if (entry.snapshot) return resolveCachedRscResponseExpiresAt(entry.timestamp, entry.snapshot, PREFETCH_CACHE_TTL);
+	return entry.timestamp + PREFETCH_CACHE_TTL;
+}
+function resolvePrefetchCacheEntryMountedSlotsHeader(entry) {
+	if (entry.mountedSlotsHeader !== void 0) return entry.mountedSlotsHeader;
+	return entry.snapshot?.mountedSlotsHeader ?? null;
+}
+function normalizeRscCacheLookupUrl(rscUrl) {
+	try {
+		const url = parseRscRequestPath(rscUrl);
+		stripRscCacheBustingSearchParam(url);
+		return `${url.pathname}${url.search}`;
+	} catch {
+		return null;
+	}
+}
+function normalizeRscCacheLookupPathname(rscUrl) {
+	try {
+		return parseRscRequestPath(rscUrl).pathname;
+	} catch {
+		return null;
+	}
+}
+function isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader) {
+	if (resolvePrefetchCacheEntryMountedSlotsHeader(entry) === mountedSlotsHeader) return true;
+	return (entry.snapshot?.mountedSlotsHeader ?? null) === mountedSlotsHeader;
+}
+function findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = []) {
+	const cache = getPrefetchCache();
+	const rscUrls = [rscUrl, ...additionalRscUrls];
+	for (const lookupRscUrl of rscUrls) {
+		const exactCacheKey = AppElementsWire.encodeCacheKey(lookupRscUrl, interceptionContext);
+		const exactEntry = cache.get(exactCacheKey);
+		if (exactEntry && exactEntry.cacheForNavigation !== false && isPrefetchCacheEntryCompatibleWithMountedSlots(exactEntry, mountedSlotsHeader)) return {
+			cacheKey: exactCacheKey,
+			entry: exactEntry
+		};
+	}
+	const normalizedTargets = new Set(rscUrls.map((lookupRscUrl) => normalizeRscCacheLookupUrl(lookupRscUrl)).filter((lookupRscUrl) => lookupRscUrl !== null));
+	if (normalizedTargets.size === 0) return null;
+	for (const [cacheKey, entry] of cache) {
+		if (entry.cacheForNavigation === false) continue;
+		const source = AppElementsWire.decodeCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		const normalizedSource = normalizeRscCacheLookupUrl(source.rscUrl);
+		if (normalizedSource === null || !normalizedTargets.has(normalizedSource)) continue;
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
+		return {
+			cacheKey,
+			entry
+		};
+	}
+	return null;
+}
+function hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options = {}) {
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options.additionalRscUrls);
+	if (match === null) return false;
+	if (match.entry.pending !== void 0 && options.reusePending === false) return false;
+	if (match.entry.pending !== void 0 || resolvePrefetchCacheEntryExpiresAt(match.entry) > Date.now()) {
+		touchPrefetchCacheEntry(getPrefetchCache(), match.cacheKey, match.entry);
+		attachPrefetchInvalidationToEntry(match.cacheKey, match.entry, options.onInvalidate);
+		options.onReuse?.(match.entry, match.cacheKey);
+		return true;
+	}
+	deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), match.cacheKey, match.entry, options.notifyInvalidation ?? true);
+	return false;
+}
+/**
+* Return whether the exact learning-only Link prefetch is still usable.
+* Pending entries dedupe concurrent Links; settled entries only suppress a
+* remount while their response-derived freshness window remains active.
+*/
+function hasFreshLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = null) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const entry = cache.get(cacheKey);
+	if (entry?.cacheForNavigation !== false) return false;
+	if (entry.pending !== void 0 || resolvePrefetchCacheEntryExpiresAt(entry) > Date.now()) {
+		touchPrefetchCacheEntry(cache, cacheKey, entry);
+		return true;
+	}
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+	return false;
+}
+function hasSearchAgnosticPrefetchShellForRoute(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
+	const normalizedTargetPathname = normalizeRscCacheLookupPathname(rscUrl);
+	if (normalizedTargetPathname === null) return false;
+	const cache = getPrefetchCache();
+	for (const [cacheKey, entry] of cache) {
+		if (entry.searchAgnosticShell !== true) continue;
+		const source = AppElementsWire.decodeCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		if (normalizeRscCacheLookupPathname(source.rscUrl) !== normalizedTargetPathname) continue;
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
+		if (entry.pending !== void 0) return true;
+		if (resolvePrefetchCacheEntryExpiresAt(entry) > Date.now()) return true;
+		deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+	}
+	return false;
+}
+function getPrefetchCacheEntrySize(entry) {
+	return entry.snapshot?.buffer.byteLength ?? entry.size ?? 0;
+}
+let trackedPrefetchCache = null;
+let trackedPrefetchCacheByteSize = 0;
+function getPrefetchCacheByteSize(cache) {
+	if (trackedPrefetchCache === cache) return trackedPrefetchCacheByteSize;
+	let total = 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of cache.values()) {
+		if (seen.has(entry)) continue;
+		seen.add(entry);
+		total += getPrefetchCacheEntrySize(entry);
+	}
+	trackedPrefetchCache = cache;
+	trackedPrefetchCacheByteSize = total;
+	return total;
+}
+function adjustPrefetchCacheByteSize(cache, delta) {
+	if (trackedPrefetchCache !== cache) return;
+	trackedPrefetchCacheByteSize = Math.max(0, trackedPrefetchCacheByteSize + delta);
+}
+function touchPrefetchCacheEntry(cache, cacheKey, entry) {
+	if (cache.get(cacheKey) !== entry) return;
+	cache.delete(cacheKey);
+	cache.set(cacheKey, entry);
+	for (const key of entry.cacheKeys ?? []) {
+		if (key === cacheKey || cache.get(key) !== entry) continue;
+		cache.delete(key);
+		cache.set(key, entry);
+	}
+}
+/**
+* Evict prefetch cache entries if buffered payloads exceed the byte budget.
+* Sweeps expired entries only after the cheap byte-budget check says cleanup is
+* needed, then evicts least-recently-used entries down to the target size.
+*/
+function evictPrefetchCacheIfNeeded() {
+	const cache = getPrefetchCache();
+	let totalSize = getPrefetchCacheByteSize(cache);
+	if (totalSize <= 52428800) return;
+	const now = Date.now();
+	const prefetched = getPrefetchedUrls();
+	for (const [key, entry] of cache) if (resolvePrefetchCacheEntryExpiresAt(entry) <= now) deletePrefetchCacheEntry(cache, prefetched, key, entry, true);
+	totalSize = getPrefetchCacheByteSize(cache);
+	if (totalSize <= 52428800) return;
+	let inspectedEntries = 0;
+	while (totalSize > PREFETCH_CACHE_EVICTION_TARGET_SIZE && inspectedEntries < cache.size) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) {
+			const entry = cache.get(oldest);
+			if (entry) {
+				const entrySize = getPrefetchCacheEntrySize(entry);
+				if (entry.pending !== void 0 && entrySize === 0) {
+					touchPrefetchCacheEntry(cache, oldest, entry);
+					inspectedEntries += 1;
+					continue;
+				}
+				totalSize -= entrySize;
+				deletePrefetchCacheEntry(cache, prefetched, oldest, entry, true);
+				inspectedEntries = 0;
+			} else {
+				cache.delete(oldest);
+				prefetched.delete(oldest);
+				inspectedEntries += 1;
+			}
+		} else break;
+	}
+}
+const pendingPrefetchSetups = /* @__PURE__ */ new Set();
+function beginPrefetchSetup(destination) {
+	const setup = {
+		destination,
+		cancelled: false
+	};
+	pendingPrefetchSetups.add(setup);
+	return setup;
+}
+/** Passing `null` cancels every pending setup regardless of destination. */
+function cancelPendingPrefetchSetups(destination) {
+	for (const setup of pendingPrefetchSetups) if (destination === null || setup.destination === destination) setup.cancelled = true;
+}
+/**
+* Normalize a navigation or prefetch target to the browser href both sides
+* compare on. Returns null when the target is not same-origin — no same-origin
+* prefetch can be a duplicate of it — and on the server, where
+* `navigateClientSide` can still be reached but there is nothing to cancel.
+*/
+function toAppPrefetchDestination(href) {
+	if (isServer) return null;
+	let localHref = href;
+	if (isExternalUrl(href)) {
+		const localPath = toSameOriginAppPath(href, __basePath);
+		if (localPath == null) return null;
+		localHref = localPath;
+	}
+	const browserHref = toCanonicalBrowserNavigationHref(localHref, window.location.href, __basePath, __trailingSlash);
+	try {
+		return formatRscRequestPath(new URL(browserHref, window.location.href));
+	} catch {
+		return browserHref.split("#", 1)[0];
+	}
+}
+function clearPrefetchInvalidation(entry) {
+	if (entry.invalidationTimer !== void 0) {
+		clearTimeout(entry.invalidationTimer);
+		entry.invalidationTimer = void 0;
+	}
+}
+function runInvalidationCallback(onInvalidate) {
+	try {
+		onInvalidate();
+	} catch (error) {
+		if (typeof reportError === "function") reportError(error);
+		else console.error(error);
+	}
+}
+function notifyPrefetchInvalidated(entry) {
+	clearPrefetchInvalidation(entry);
+	const callbacks = entry.onInvalidateCallbacks;
+	entry.onInvalidateCallbacks = void 0;
+	if (callbacks === void 0) return;
+	for (const onInvalidate of callbacks) runInvalidationCallback(onInvalidate);
+}
+const retainedPrefetchInvalidations = /* @__PURE__ */ new Set();
+function retainPrefetchInvalidationAfterConsume(entry) {
+	const callbacks = entry.onInvalidateCallbacks;
+	if (callbacks === void 0 || callbacks.size === 0) return;
+	retainPrefetchInvalidation(callbacks, resolvePrefetchCacheEntryExpiresAt(entry));
+}
+function retainPrefetchInvalidation(callbacks, expiresAt, forVisitedResponse = false) {
+	const delay = Math.max(0, expiresAt - Date.now());
+	const retained = {
+		callbacks,
+		...forVisitedResponse ? { forVisitedResponse: true } : {},
+		timer: setTimeout(() => fireRetainedPrefetchInvalidation(retained), delay)
+	};
+	retainedPrefetchInvalidations.add(retained);
+}
+function fireRetainedPrefetchInvalidation(retained) {
+	if (!retainedPrefetchInvalidations.delete(retained)) return;
+	clearTimeout(retained.timer);
+	for (const onInvalidate of retained.callbacks) runInvalidationCallback(onInvalidate);
+}
+function deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, notify) {
+	const cacheKeys = entry.cacheKeys ?? /* @__PURE__ */ new Set([cacheKey]);
+	let removedOwnedKey = false;
+	for (const key of cacheKeys) if (cache.get(key) === entry) {
+		cache.delete(key);
+		prefetched.delete(key);
+		removedOwnedKey = true;
+	}
+	if (!removedOwnedKey) return;
+	adjustPrefetchCacheByteSize(cache, -getPrefetchCacheEntrySize(entry));
+	entry.cacheKeys = void 0;
+	if (notify) notifyPrefetchInvalidated(entry);
+	else {
+		clearPrefetchInvalidation(entry);
+		entry.onInvalidateCallbacks = void 0;
+	}
+}
+function discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext = null, mountedSlotsHeader = null) {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const normalizedTarget = normalizeRscCacheLookupUrl(rscUrl);
+	if (normalizedTarget === null) return false;
+	const superseded = [];
+	for (const [cacheKey, entry] of cache) {
+		if (entry.cacheForNavigation !== false || entry.prefetchKind !== "navigation") continue;
+		const source = AppElementsWire.decodeCacheKey(cacheKey);
+		if (source.interceptionContext !== interceptionContext) continue;
+		if (normalizeRscCacheLookupUrl(source.rscUrl) !== normalizedTarget) continue;
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) continue;
+		superseded.push([cacheKey, entry]);
+	}
+	for (const [cacheKey, entry] of superseded) {
+		cancelAppPrefetchFetch(entry.fetchPromise);
+		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+	}
+	return superseded.length > 0;
+}
+/**
+* Make a prefetch reusable by a navigation, as an `unstable_dynamicOnHover`
+* hover does. A pending one that would be kept as learning-only becomes a full
+* prefetch and takes the full-prefetch lifetime. One already kept as
+* learning-only because its page rendered dynamically is left for the full
+* prefetch to replace: Next.js refetches it with `FetchStrategy.Full`, so the
+* page reflects the cookies and headers at hover time.
+*/
+function promotePrefetchCacheEntryForNavigation(cacheKey, entry) {
+	if (entry.dynamicStaleTime !== "learning-only") {
+		entry.cacheForNavigation = true;
+		return;
+	}
+	if (entry.cacheForNavigation === false) return;
+	entry.dynamicStaleTime = "full-prefetch";
+	if (entry.snapshot === void 0) return;
+	entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, entry.fallbackTtlMs ?? PREFETCH_CACHE_TTL, "full-prefetch");
+	schedulePrefetchInvalidation(cacheKey, entry);
+}
+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 delay = Math.max(0, resolvePrefetchCacheEntryExpiresAt(entry) - Date.now());
+	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);
+}
+/**
+* Attach `onInvalidate` to an entry the caller already holds. A settled entry
+* needs its invalidation timer started here — nothing else will schedule one
+* once `prefetchRscResponse` has finished with it.
+*/
+function attachPrefetchInvalidationToEntry(cacheKey, entry, onInvalidate) {
+	if (onInvalidate === void 0) return;
+	addPrefetchInvalidationCallback(entry, onInvalidate);
+	if (entry.outcome === "cache-seeded") schedulePrefetchInvalidation(cacheKey, entry);
+}
+function attachPrefetchInvalidationCallback(cacheKey, onInvalidate) {
+	if (onInvalidate === void 0) return;
+	const entry = getPrefetchCache().get(cacheKey);
+	if (!entry) return;
+	attachPrefetchInvalidationToEntry(cacheKey, entry, onInvalidate);
+}
+function invalidatePrefetchCache(options = {}) {
+	cancelPendingPrefetchSetups(null);
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	for (const [cacheKey, entry] of cache) deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+	prefetched.clear();
+	for (const retained of retainedPrefetchInvalidations) fireRetainedPrefetchInvalidation(retained);
+	if (!isServer && options.pingVisibleLinks !== false) getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
+/**
+* Evict the prefetch entries that may hold dynamic data, for a Server Action
+* that called `refresh()`. Like Next.js's dynamic-only revalidation, which
+* evicts its BFCache but keeps its prefetch cache, this keeps route trees,
+* static prefetches and full prefetches. It drops navigation responses, and
+* automatic prefetches whose page rendered dynamically or hasn't finished
+* rendering, including those only kept to learn a route: Next.js's automatic
+* prefetches never hold dynamic data.
+*/
+function invalidateDynamicPrefetchCache() {
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const evicted = [];
+	for (const [cacheKey, entry] of cache) if (!(entry.prefetchKind === "route-tree" || entry.prefetchKind !== void 0 && (entry.dynamicStaleTime === "full-prefetch" || entry.snapshot !== void 0 && !isStaleTimeSeconds(entry.snapshot.dynamicStaleTimeSeconds)))) evicted.push([cacheKey, entry]);
+	for (const [cacheKey, entry] of evicted) deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, true);
+}
+/**
+* Notify the prefetches that stood in for a visited response (see
+* `hasNavigationFreshVisitedResponse`), as the visited responses are cleared.
+*/
+function invalidateVisitedResponsePrefetches() {
+	for (const retained of retainedPrefetchInvalidations) if (retained.forVisitedResponse === true) fireRetainedPrefetchInvalidation(retained);
+}
+/**
+* Prevent completed navigation responses from becoming authoritative again
+* after restoring a history snapshot. Explicit Link/router prefetches remain
+* consumable. Responses with a positive cache lifetime and interception
+* responses retain the cache reuse licensed by Next's segment cache.
+*/
+function disableNavigationResponsePrefetchCacheReuse() {
+	let didDemote = false;
+	for (const entry of new Set(getPrefetchCache().values())) if (entry.prefetchKind === void 0 && entry.reuseAfterHistoryRestore !== true) {
+		didDemote ||= entry.cacheForNavigation !== false;
+		entry.cacheForNavigation = false;
+	}
+	if (didDemote && !isServer) getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
+function seedPrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null, mountedSlotsHeader = null, fallbackTtlMs = DYNAMIC_NAVIGATION_CACHE_TTL, reuseAfterHistoryRestore = false, expiresAt = resolveCachedRscResponseExpiresAt(Date.now(), snapshot, fallbackTtlMs)) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const existing = cache.get(cacheKey);
+	if (existing) deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, existing, false);
+	const timestamp = Date.now();
+	const entry = {
+		cacheForNavigation: true,
+		cacheKeys: /* @__PURE__ */ new Set([cacheKey]),
+		expiresAt,
+		mountedSlotsHeader,
+		outcome: "cache-seeded",
+		reuseAfterHistoryRestore,
+		size: snapshot.buffer.byteLength,
+		snapshot,
+		timestamp
+	};
+	cache.set(cacheKey, entry);
+	adjustPrefetchCacheByteSize(cache, snapshot.buffer.byteLength);
+	getPrefetchedUrls().add(cacheKey);
+	schedulePrefetchInvalidation(cacheKey, entry);
+	evictPrefetchCacheIfNeeded();
+}
+/**
+* Fulfill a full prefetch from the visited response of an earlier navigation,
+* as Next.js does from its BFCache, instead of issuing a request. The data is
+* fresh for the static stale time from the navigation, not the dynamic one
+* (`attemptToFulfillDynamicSegmentFromBFCache`).
+*/
+function seedFullPrefetchFromVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = [], onInvalidate) {
+	const visited = getNavigationRuntime()?.functions.readVisitedResponseForFullPrefetch?.([rscUrl, ...additionalRscUrls], interceptionContext, mountedSlotsHeader);
+	if (!visited) return false;
+	const expiresAt = visited.navigatedAt + Math.max(PREFETCH_CACHE_TTL, MIN_PREFETCH_STALE_TIME_MS);
+	if (expiresAt <= Date.now()) return false;
+	seedPrefetchResponseSnapshot(rscUrl, visited.response, interceptionContext, mountedSlotsHeader, void 0, true, expiresAt);
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	if (getPrefetchCache().get(cacheKey)?.snapshot !== visited.response) return false;
+	attachPrefetchInvalidationCallback(cacheKey, onInvalidate);
+	return true;
+}
+/**
+* Whether a navigation to the URL would reuse the response of an earlier one,
+* so a prefetch has nothing to fetch. Like Next.js, whose navigation keeps the
+* route and its segments for `staleTimes.dynamic`. `onInvalidate` fires when
+* that reuse ends.
+*/
+function hasNavigationFreshVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls = [], onInvalidate) {
+	const freshUntil = getNavigationRuntime()?.functions.readVisitedResponseForFullPrefetch?.([rscUrl, ...additionalRscUrls], interceptionContext, mountedSlotsHeader)?.navigationFreshUntil;
+	if (freshUntil === void 0 || freshUntil === null) return false;
+	if (onInvalidate !== void 0) retainPrefetchInvalidation(/* @__PURE__ */ new Set([onInvalidate]), freshUntil, true);
+	return true;
+}
+function deletePrefetchResponseSnapshot(rscUrl, snapshot, interceptionContext = null) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const entry = cache.get(cacheKey);
+	if (entry?.snapshot !== snapshot) return;
+	deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
+}
+function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
+	const headerDynamicStaleTimeSeconds = parseStaleTimeSecondsHeader(response.headers.get(VINEXT_DYNAMIC_STALE_TIME_HEADER));
+	const completionMode = response.headers.get(VINEXT_RSC_COMPLETION_METADATA_HEADER);
+	const extracted = completionMode === "1" ? extractRscCompletionMetadata(buffer) : { buffer };
+	const completedDynamicStaleTimeSeconds = completionMode === "resolved" ? headerDynamicStaleTimeSeconds : extracted.metadata?.dynamicStaleTimeSeconds ?? headerDynamicStaleTimeSeconds;
+	const dynamicStaleTimeSeconds = completedDynamicStaleTimeSeconds ?? headerDynamicStaleTimeSeconds;
+	const parsedServerStaleTime = parseServerStaleTimeHeaders(response.headers);
+	const serverStaleTime = extracted.metadata !== void 0 && Object.hasOwn(extracted.metadata, "serverStaleTimeSeconds") ? extracted.metadata?.serverStaleTimeSeconds === null ? void 0 : {
+		kind: "resolved",
+		seconds: extracted.metadata.serverStaleTimeSeconds
+	} : parsedServerStaleTime;
+	const redirectHeader = response.headers.get(VINEXT_RSC_REDIRECT_HEADER);
+	const redirectTypeHeader = response.headers.get(VINEXT_RSC_REDIRECT_TYPE_HEADER);
+	return {
+		compatibilityIdHeader: response.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
+		buffer: extracted.buffer,
+		...completedDynamicStaleTimeSeconds !== void 0 ? { completedDynamicStaleTimeSeconds } : {},
+		contentType: response.headers.get("content-type") ?? "text/x-component",
+		...dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds } : {},
+		mountedSlotsHeader: response.headers.get(VINEXT_MOUNTED_SLOTS_HEADER),
+		paramsHeader: response.headers.get(VINEXT_PARAMS_HEADER),
+		receivedAt: Date.now(),
+		...redirectHeader === null ? {} : { redirectHeader },
+		...redirectTypeHeader === null ? {} : { redirectTypeHeader },
+		renderedPathAndSearch: parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)),
+		...serverStaleTime === void 0 ? {} : { serverStaleTime },
+		url: responseUrl ?? response.url
+	};
+}
+/**
+* Collapse the two mutually-exclusive wire headers into one state. A pending
+* marker wins: it says the render committed headers before `cacheLife` settled,
+* so any resolved value alongside it cannot describe the completed render.
+*/
+function parseServerStaleTimeHeaders(headers) {
+	if (headers.get("X-Vinext-Stale-Time-Pending") === "1") return { kind: "pending" };
+	const seconds = parseStaleTimeSecondsHeader(headers.get(NEXT_ROUTER_STALE_TIME_HEADER));
+	return seconds === void 0 ? void 0 : {
+		kind: "resolved",
+		seconds
+	};
+}
+/** Decode an `X-Vinext-Rendered-Path-And-Search` header value. */
+function parseRenderedPathAndSearchHeader(value) {
+	if (value === null || value === "") return null;
+	try {
+		const decoded = decodeURIComponent(value);
+		return decoded.startsWith("/") ? decoded : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 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) {
+	try {
+		const snapshot = createCachedRscResponseSnapshot(response, await response.arrayBuffer());
+		const expiresAt = restoredRscResponseExpiresAt.get(response);
+		return expiresAt === void 0 ? snapshot : {
+			...snapshot,
+			expiresAt
+		};
+	} finally {
+		releaseAppPrefetchFetchSlot(response);
+	}
+}
+const restoredRscResponseExpiresAt = /* @__PURE__ */ new WeakMap();
+/**
+* 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.mountedSlotsHeader != null) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, cached.mountedSlotsHeader);
+	if (cached.compatibilityIdHeader != null) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, cached.compatibilityIdHeader);
+	if (isStaleTimeSeconds(cached.dynamicStaleTimeSeconds)) headers.set(VINEXT_DYNAMIC_STALE_TIME_HEADER, String(cached.dynamicStaleTimeSeconds));
+	if (isStaleTimeSeconds(cached.completedDynamicStaleTimeSeconds)) headers.set(VINEXT_RSC_COMPLETION_METADATA_HEADER, "resolved");
+	if (cached.serverStaleTime?.kind === "pending") headers.set(VINEXT_STALE_TIME_PENDING_HEADER, "1");
+	else if (cached.serverStaleTime !== void 0) headers.set(NEXT_ROUTER_STALE_TIME_HEADER, String(cached.serverStaleTime.seconds));
+	if (cached.paramsHeader != null) headers.set(VINEXT_PARAMS_HEADER, cached.paramsHeader);
+	if (cached.redirectHeader !== void 0) headers.set(VINEXT_RSC_REDIRECT_HEADER, cached.redirectHeader);
+	if (cached.redirectTypeHeader !== void 0) headers.set(VINEXT_RSC_REDIRECT_TYPE_HEADER, cached.redirectTypeHeader);
+	if (cached.renderedPathAndSearch != null) headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(cached.renderedPathAndSearch));
+	const response = new Response(copy ? cached.buffer.slice(0) : cached.buffer, {
+		status: 200,
+		headers
+	});
+	if (isCacheExpiresAt(cached.expiresAt)) restoredRscResponseExpiresAt.set(response, cached.expiresAt);
+	return response;
+}
+/**
+* `prefetchRscResponse`'s `prepareSnapshot` for navigation-reusable entries:
+* decode the cached payload through the App Router runtime so a later
+* navigation can commit it without re-parsing. Shared by `<Link>` and
+* `router.prefetch()`.
+*/
+async function prepareNavigationPrefetchSnapshot(snapshot) {
+	const preparePrefetchResponse = getNavigationRuntime()?.functions.preparePrefetchResponse;
+	if (!preparePrefetchResponse) throw new Error("App Router prefetch preparation is unavailable");
+	return await preparePrefetchResponse(restoreRscResponse(snapshot));
+}
+/**
+* Gate a navigation-reusable prefetch behind the route-tree request shared by
+* `<Link>` and `router.prefetch()`. Callers retain control of fetch scheduling
+* and request-only options while freshness, deduplication, and alias reuse stay
+* identical across both entry points.
+*/
+async function fetchRouteTreeGatedPrefetch(options) {
+	const { fetchFullRscPayload, fetchRouteTree, fullHref, headers, interceptionContext, mountedSlotsHeader } = options;
+	const routeTreeHeaders = new Headers(headers);
+	routeTreeHeaders.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+	routeTreeHeaders.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "/_tree");
+	const routeTreeRscUrl = await createRscRequestUrl(fullHref, routeTreeHeaders);
+	const routeTreeCacheKey = AppElementsWire.encodeCacheKey(routeTreeRscUrl, interceptionContext);
+	let routeTreeEntry = getFreshPrefetchCacheEntry(routeTreeCacheKey);
+	if (routeTreeEntry === void 0) {
+		getPrefetchedUrls().add(routeTreeCacheKey);
+		prefetchRscResponse(routeTreeRscUrl, fetchRouteTree(routeTreeRscUrl, routeTreeHeaders), interceptionContext, mountedSlotsHeader, void 0, {
+			cacheForNavigation: false,
+			optimisticRouteShell: false,
+			prefetchKind: "route-tree"
+		});
+		routeTreeEntry = getFreshPrefetchCacheEntry(routeTreeCacheKey);
+	}
+	await routeTreeEntry?.pending?.catch(() => {});
+	routeTreeEntry = getFreshPrefetchCacheEntry(routeTreeCacheKey);
+	const renderedPathAndSearch = routeTreeEntry?.snapshot?.renderedPathAndSearch;
+	if (renderedPathAndSearch) {
+		const cachedRenderedResponse = peekPrefetchResponseForNavigation(await createRscRequestUrl(renderedPathAndSearch, headers), interceptionContext, mountedSlotsHeader);
+		if (cachedRenderedResponse) return restoreRscResponse(cachedRenderedResponse);
+	}
+	return fetchFullRscPayload();
+}
+/**
+* Whether a prefetch response may be decoded as Flight. A successful response
+* that is not Flight (e.g. a Route Handler's text download) is a miss: decoding
+* its bytes would let text shaped like Flight resource hints insert scripts.
+* Navigation then fetches it and falls back to a document navigation.
+*
+* Ported from Next.js: fetchPrefetchResponse in
+* packages/next/src/client/components/segment-cache/cache.ts, which skips the
+* check in `output: "export"` because a static host, not Next.js, chooses the
+* MIME type of the exported `.txt` payloads.
+*/
+function isFlightPrefetchResponse(response) {
+	if (!response.ok) return false;
+	if (process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") return true;
+	return response.headers.get("content-type")?.toLowerCase().startsWith(VINEXT_RSC_CONTENT_TYPE) === true;
+}
+/**
+* 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, interceptionContext = null, mountedSlotsHeader = null, options, behavior = {}) {
+	const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const cache = getPrefetchCache();
+	const prefetched = getPrefetchedUrls();
+	const now = Date.now();
+	const existing = cache.get(cacheKey);
+	const cacheForNavigation = behavior.cacheForNavigation ?? true;
+	if (existing) deletePrefetchCacheEntry(cache, prefetched, cacheKey, existing, false);
+	const entry = {
+		cacheForNavigation,
+		cacheKeys: /* @__PURE__ */ new Set([cacheKey]),
+		mountedSlotsHeader,
+		optimisticRouteShell: behavior.optimisticRouteShell === true,
+		outcome: "pending",
+		prefetchKind: behavior.prefetchKind ?? (behavior.optimisticRouteShell === true ? "loading-shell" : "navigation"),
+		searchAgnosticShell: behavior.searchAgnosticShell === true,
+		timestamp: now
+	};
+	if (behavior.dynamicStaleTime === "learning-only" && behavior.searchAgnosticShell !== true) {
+		entry.dynamicStaleTime = "learning-only";
+		entry.fallbackTtlMs = behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL;
+	} else if (behavior.dynamicStaleTime === "full-prefetch") entry.dynamicStaleTime = "full-prefetch";
+	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
+	entry.fetchPromise = fetchPromise;
+	entry.pending = fetchPromise.then(async (response) => {
+		if (isFlightPrefetchResponse(response)) {
+			const snapshot = await snapshotRscResponse(response);
+			if (cache.get(cacheKey) !== entry) return;
+			const previousSize = getPrefetchCacheEntrySize(entry);
+			entry.snapshot = snapshot;
+			entry.size = snapshot.buffer.byteLength;
+			adjustPrefetchCacheByteSize(cache, entry.size - previousSize);
+			const fallbackTtlMs = behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL;
+			const dynamicStaleTime = behavior.searchAgnosticShell === true ? "ignore" : entry.dynamicStaleTime ?? behavior.dynamicStaleTime ?? (behavior.optimisticRouteShell === true ? "ignore" : "verbatim");
+			if (dynamicStaleTime === "learning-only" && isStaleTimeSeconds(snapshot.dynamicStaleTimeSeconds)) {
+				entry.cacheForNavigation = false;
+				entry.expiresAt = entry.timestamp + Math.max(fallbackTtlMs, MIN_PREFETCH_STALE_TIME_MS);
+			} else entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, fallbackTtlMs, dynamicStaleTime === "learning-only" ? "verbatim" : dynamicStaleTime);
+			if (behavior.prepareSnapshot && entry.cacheForNavigation && snapshot.redirectHeader === void 0) try {
+				const preparedElements = await behavior.prepareSnapshot(snapshot);
+				if (cache.get(cacheKey) !== entry) return;
+				entry.preparedElements = preparedElements;
+			} catch {}
+			addRenderedPathAndSearchPrefetchAlias(cache, prefetched, cacheKey, entry);
+			evictPrefetchCacheIfNeeded();
+		} else {
+			releaseAppPrefetchFetchSlot(response);
+			response.body?.cancel().catch(() => {});
+			deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
+		}
+	}).catch(() => {
+		deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
+	}).finally(() => {
+		if (cache.get(cacheKey) !== entry) return;
+		entry.pending = void 0;
+		entry.fetchPromise = void 0;
+		if (entry.snapshot) {
+			entry.outcome = "cache-seeded";
+			schedulePrefetchInvalidation(cacheKey, entry);
+		}
+	});
+	cache.set(cacheKey, entry);
+	evictPrefetchCacheIfNeeded();
+}
+function addRenderedPathAndSearchPrefetchAlias(cache, prefetched, primaryCacheKey, entry) {
+	if (entry.cacheForNavigation === false) return;
+	const renderedPathAndSearch = entry.snapshot?.renderedPathAndSearch;
+	if (!renderedPathAndSearch) return;
+	const source = AppElementsWire.decodeCacheKey(primaryCacheKey);
+	const aliasCacheKey = AppElementsWire.encodeCacheKey(renderedPathAndSearch, source.interceptionContext);
+	if (aliasCacheKey === primaryCacheKey) return;
+	const existing = cache.get(aliasCacheKey);
+	if (existing && existing !== entry) deletePrefetchCacheEntry(cache, prefetched, aliasCacheKey, existing, false);
+	entry.cacheKeys ??= /* @__PURE__ */ new Set([primaryCacheKey]);
+	entry.cacheKeys.add(aliasCacheKey);
+	cache.set(aliasCacheKey, entry);
+	prefetched.add(aliasCacheKey);
+}
+function peekPrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options) {
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
+	if (!match) return null;
+	const { cacheKey, entry } = match;
+	if (entry.pending || entry.outcome !== "cache-seeded") return null;
+	if (entry.cacheForNavigation === false || !entry.snapshot) return null;
+	if (resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) {
+		deletePrefetchCacheEntry(getPrefetchCache(), getPrefetchedUrls(), cacheKey, entry, true);
+		return null;
+	}
+	if (entry.expiresAt !== void 0 || entry.snapshot.expiresAt !== void 0) return {
+		...entry.snapshot,
+		expiresAt: resolvePrefetchCacheEntryExpiresAt(entry)
+	};
+	return entry.snapshot;
+}
+/**
+* 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, interceptionContext = null, mountedSlotsHeader = null, options) {
+	const cache = getPrefetchCache();
+	const exactCacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+	const exactEntry = cache.get(exactCacheKey);
+	if (exactEntry && exactEntry.cacheForNavigation !== false && !isPrefetchCacheEntryCompatibleWithMountedSlots(exactEntry, mountedSlotsHeader)) deletePrefetchCacheEntry(cache, getPrefetchedUrls(), exactCacheKey, exactEntry, false);
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
+	if (!match) return null;
+	const { cacheKey, entry } = match;
+	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader);
+}
+function consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader, allowExpiredInFlightHandoff = false) {
+	const cache = getPrefetchCache();
+	if (entry.pending || entry.outcome !== "cache-seeded") return null;
+	if (entry.cacheForNavigation === false) return null;
+	if (entry.snapshot) {
+		if (!isPrefetchCacheEntryCompatibleWithMountedSlots(entry, mountedSlotsHeader)) return null;
+		if (!allowExpiredInFlightHandoff && resolvePrefetchCacheEntryExpiresAt(entry) <= Date.now()) {
+			deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, true);
+			return null;
+		}
+		retainPrefetchInvalidationAfterConsume(entry);
+		deletePrefetchCacheEntry(cache, getPrefetchedUrls(), cacheKey, entry, false);
+		const snapshot = entry.snapshot;
+		if (entry.expiresAt !== void 0 || entry.snapshot.expiresAt !== void 0) return {
+			...snapshot,
+			expiresAt: resolvePrefetchCacheEntryExpiresAt(entry),
+			...entry.preparedElements ? { preparedElements: entry.preparedElements } : {}
+		};
+		return entry.preparedElements ? {
+			...snapshot,
+			preparedElements: entry.preparedElements
+		} : snapshot;
+	}
+	return null;
+}
+async function consumePrefetchResponseForNavigation(rscUrl, interceptionContext = null, mountedSlotsHeader = null, options) {
+	const cache = getPrefetchCache();
+	const match = findPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, options?.additionalRscUrls);
+	if (!match) return null;
+	const { cacheKey, entry } = match;
+	if (options?.shouldConsume?.() === false) return null;
+	const allowExpiredInFlightHandoff = entry.pending !== void 0;
+	if (entry.pending !== void 0) {
+		const releaseClaim = promoteAppPrefetchFetch(entry.fetchPromise, options?.shouldConsume);
+		try {
+			await entry.pending.catch(() => {});
+		} finally {
+			releaseClaim();
+		}
+		if (cache.get(cacheKey) !== entry) return null;
+		if (options?.shouldConsume?.() === false) return null;
+	}
+	return consumeMatchedPrefetchResponse(cacheKey, entry, mountedSlotsHeader, allowExpiredInFlightHandoff);
+}
+const _MOUNTED_SLOTS_HEADER_KEY = Symbol.for("vinext.mountedSlotsHeader");
+function setMountedSlotsHeader(header) {
+	if (isServer) return;
+	const globalState = window;
+	globalState[_MOUNTED_SLOTS_HEADER_KEY] = header;
+}
+function getMountedSlotsHeader() {
+	if (isServer) return null;
+	return window[_MOUNTED_SLOTS_HEADER_KEY] ?? null;
+}
+function withSuppressedUrlNotifications(fn) {
+	const state = getClientNavigationState();
+	if (!state) return fn();
+	state.suppressUrlNotifyCount += 1;
+	try {
+		return fn();
+	} finally {
+		state.suppressUrlNotifyCount -= 1;
+	}
+}
+/** Whether a history entry's state is the data written to it, cloned by the browser. */
+function isSameHistoryStateData(historyState, data) {
+	try {
+		return JSON.stringify(historyState) === JSON.stringify(data);
+	} catch {
+		return false;
+	}
+}
+/** Writes the in-progress router write if this call is it, consuming its marker. */
+function forwardRouterHistoryWrite(state, method, data, unused, url) {
+	const write = state.routerHistoryWrite;
+	if (write?.method !== method) return false;
+	if (write.threw) {
+		if (url == null || new URL(url, window.location.href).href !== write.href) return false;
+		if (write.data !== data && !(isAppOwnedHistoryState(data) && readHistoryStateTraversalIndex(data) === readHistoryStateTraversalIndex(write.data))) return false;
+	} else if (write.data !== data || write.url !== url) return false;
+	if (write.landed) return true;
+	state.routerHistoryWrite = null;
+	const landing = write.land?.(data);
+	const original = method === "pushState" ? state.originalPushState : state.originalReplaceState;
+	const writtenData = landing ? landing.data : data;
+	const historyStateBeforeWrite = window.history.state;
+	try {
+		original.call(window.history, writtenData, unused, url);
+	} catch (error) {
+		const landed = window.history.state !== historyStateBeforeWrite && window.location.href === write.href && isSameHistoryStateData(window.history.state, writtenData);
+		if (landed) landing?.commit();
+		state.routerHistoryWrite = {
+			...write,
+			threw: true,
+			landed
+		};
+		throw error;
+	}
+	landing?.commit();
+	if (write.threw) state.routerHistoryWrite = {
+		...write,
+		landed: true
+	};
+	return true;
+}
+function writeRouterHistoryState(method, data, unused, url, land) {
+	withSuppressedUrlNotifications(() => {
+		const state = getClientNavigationState();
+		if (!state) return;
+		if (url == null) {
+			(method === "pushState" ? state.originalPushState : state.originalReplaceState).call(window.history, data, unused, url);
+			return;
+		}
+		const previousWrite = state.routerHistoryWrite;
+		state.routerHistoryWriteDepth += 1;
+		state.routerHistoryWrite = {
+			method,
+			data,
+			url,
+			href: new URL(url, window.location.href).href,
+			land,
+			threw: false,
+			landed: false
+		};
+		try {
+			window.history[method](data, unused, url);
+		} finally {
+			state.routerHistoryWriteDepth -= 1;
+			state.routerHistoryWrite = previousWrite;
+		}
+	});
+}
+function pushHistoryStateWithoutNotify(data, unused, url, land) {
+	writeRouterHistoryState("pushState", data, unused, url, land);
+}
+function replaceHistoryStateWithoutNotify(data, unused, url, land) {
+	writeRouterHistoryState("replaceState", data, unused, url, land);
+}
+/**
+* Save the current scroll position into the current history state.
+* Called before every navigation to enable scroll restoration on back/forward.
+*
+* Uses replaceHistoryStateWithoutNotify to avoid triggering the patched
+* history.replaceState interception (which would cause spurious re-renders).
+*/
+function saveScrollPosition() {
+	replaceHistoryStateWithoutNotify({
+		...window.history.state ?? {},
+		__vinext_scrollX: window.scrollX,
+		__vinext_scrollY: window.scrollY
+	}, "");
+}
+function commitHashOnlyHistoryState(href, mode, scroll) {
+	const commitAppRouterHashNavigation = getNavigationRuntime()?.functions.commitHashNavigation;
+	if (commitAppRouterHashNavigation) {
+		commitAppRouterHashNavigation(href, mode, scroll);
+		return;
+	}
+	const historyState = createHashOnlyHistoryStatePreservingNavigationMetadata(window.history.state);
+	if (mode === "replace") replaceHistoryStateWithoutNotify(historyState, "", href);
+	else pushHistoryStateWithoutNotify(historyState, "", href);
+}
+function applyAppRouterScrollFallback(intent) {
+	if (typeof document === "undefined" || typeof window === "undefined") return;
+	if (intent.hash !== null) {
+		const hash = intent.hash;
+		requestAnimationFrame(() => {
+			if (!isLatestAppRouterScrollIntent(intent)) return;
+			disableSmoothScrollDuringRouteTransition(() => {
+				scrollToHashTarget(hash);
+			});
+		});
+		return;
+	}
+	if (intent.targetHoistedInHead) return;
+	disableSmoothScrollDuringRouteTransition(() => {
+		document.documentElement.scrollTop = 0;
+	});
+}
+function scheduleAppRouterScrollFallback(intent) {
+	queueMicrotask(() => {
+		const pendingIntent = getPendingAppRouterScrollIntent();
+		if (pendingIntent === null || pendingIntent.id !== intent.id) return;
+		const fallbackIntent = consumeAppRouterScrollIntent(intent);
+		if (fallbackIntent) applyAppRouterScrollFallback(fallbackIntent);
+	});
+}
+/**
+* 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 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.
+*
+* 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__. 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) {
+		const { __vinext_scrollX: x, __vinext_scrollY: y } = state;
+		Promise.resolve().then(() => {
+			const pending = window.__VINEXT_RSC_PENDING__ ?? null;
+			if (pending) pending.then(() => retryScrollTo(x, y));
+			else retryScrollTo(x, y);
+		});
+	}
+}
+/**
+* Hard-navigate to a URL via `window.location`, preserving push/replace
+* semantics. Used for URLs the App Router cannot serve (Pages-owned
+* targets in a hybrid build) and for catch-all RSC failures.
+*/
+function hardNavigateTo(fullHref, mode) {
+	if (mode === "replace") window.location.replace(fullHref);
+	else window.location.assign(fullHref);
+}
+/**
+* Reset any link still showing a `useLinkStatus()` pending state that did not
+* initiate the navigation now starting (e.g. a programmatic router.push, a form
+* submit, or a raw history update). A <Link> click registers itself first, so
+* the hook keeps that link pending.
+*/
+function resetStaleLinkStatus() {
+	getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
+}
+/**
+* Signal that a navigation to `href` is starting, for the callers that will
+* fetch the destination. Separate from `resetStaleLinkStatus()` because a raw
+* `history.pushState` also supersedes a pending link but issues no request —
+* cancelling a prefetch there would drop it with nothing to take its place.
+*/
+function notifyAppNavigationStart(href) {
+	const destination = toAppPrefetchDestination(href);
+	if (destination !== null && !isHashOnlyBrowserUrlChange(href, window.location.href, __basePath)) cancelPendingPrefetchSetups(destination);
+	resetStaleLinkStatus();
+}
+/**
+* popstate variant. The browser has already applied the history entry by the
+* time this runs, so the pre-navigation URL that `isHashOnlyBrowserUrlChange`
+* needs is gone. Back/forward across a route boundary does drive an RSC fetch
+* (`app-browser-entry.ts`'s popstate handler), so cancelling by destination is
+* right; a hash-only entry over-cancels, which costs one re-prefetch and can
+* never cause a duplicate request.
+*/
+function notifyAppPopstateNavigationStart() {
+	const destination = toAppPrefetchDestination(window.location.href);
+	if (destination !== null) cancelPendingPrefetchSetups(destination);
+	resetStaleLinkStatus();
+}
+/**
+* Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
+*/
+async function navigateClientSide(href, mode, scroll, programmaticTransition = false, visibleCommitMode = "transition") {
+	notifyAppNavigationStart(href);
+	let normalizedHref = href;
+	if (isExternalUrl(href)) {
+		const localPath = toSameOriginAppPath(href, __basePath);
+		if (localPath == null) {
+			notifyAppRouterTransitionStart(href, mode);
+			const externalNavigate = getNavigationRuntime()?.functions.navigateExternal;
+			if (externalNavigate) {
+				await externalNavigate(href, mode);
+				return;
+			}
+			hardNavigateTo(href, mode);
+			await new Promise(() => {});
+			return;
+		}
+		normalizedHref = localPath;
+	}
+	const hybridOwner = resolveHybridClientRouteOwner(normalizedHref);
+	if (hybridOwner === "pages" || hybridOwner === "document") {
+		const fullHref = toCanonicalBrowserNavigationHref(normalizedHref, window.location.href, __basePath, __trailingSlash);
+		notifyAppRouterTransitionStart(fullHref, mode);
+		if (mode === "push") saveScrollPosition();
+		const mpaNavigate = getNavigationRuntime()?.functions.navigateExternal;
+		if (mpaNavigate) {
+			await mpaNavigate(fullHref, mode);
+			return;
+		}
+		hardNavigateTo(fullHref, mode);
+		await new Promise(() => {});
+		return;
+	}
+	const fullHref = toCanonicalBrowserNavigationHref(normalizedHref, window.location.href, __basePath, __trailingSlash);
+	stageAppNavigationFailureTarget(fullHref);
+	notifyAppRouterTransitionStart(fullHref, mode);
+	if (mode === "push") saveScrollPosition();
+	const earlyIntent = navigationPlanner.classifyEarlyNavigationIntent({
+		basePath: __basePath,
+		currentUrlSpace: "browser",
+		currentHref: window.location.href,
+		mode,
+		scroll,
+		targetHref: fullHref
+	});
+	if (earlyIntent.kind === "sameDocumentScroll") {
+		clearAppRouterScrollIntent();
+		commitHashOnlyHistoryState(fullHref, earlyIntent.mode, earlyIntent.scroll);
+		clearAppNavigationFailureTarget(fullHref);
+		commitClientNavigationState();
+		if (earlyIntent.scroll) scrollToHashTarget(earlyIntent.hash);
+		return;
+	}
+	if (hasPendingAppRouterPageRedirect(typeof document === "undefined" ? void 0 : document)) {
+		const mpaNavigate = getNavigationRuntime()?.functions.navigateExternal;
+		if (mpaNavigate) {
+			await mpaNavigate(fullHref, mode);
+			return;
+		}
+		hardNavigateTo(fullHref, mode);
+		await new Promise(() => {});
+		return;
+	}
+	const hashIdx = fullHref.indexOf("#");
+	const hash = hashIdx !== -1 ? fullHref.slice(hashIdx) : "";
+	const scrollIntent = scroll ? beginAppRouterScrollIntent(hash || null) : null;
+	if (!scroll) clearAppRouterScrollIntent();
+	const appNavigate = getNavigationRuntime()?.functions.navigate;
+	try {
+		if (appNavigate) await appNavigate(fullHref, 0, "navigate", mode, void 0, programmaticTransition, void 0, scrollIntent, visibleCommitMode, earlyIntent.bypassNavigationCache);
+		else {
+			if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
+			else pushHistoryStateWithoutNotify(null, "", fullHref);
+			commitClientNavigationState();
+		}
+	} catch (error) {
+		if (scrollIntent) consumeAppRouterScrollIntent(scrollIntent);
+		throw error;
+	}
+	if (scrollIntent) scheduleAppRouterScrollFallback(scrollIntent);
+}
+let scheduledAppRouterNavigationCount = 0;
+function trackScheduledAppRouterNavigation() {
+	scheduledAppRouterNavigationCount += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		scheduledAppRouterNavigationCount = Math.max(0, scheduledAppRouterNavigationCount - 1);
+	};
+}
+function hasScheduledAppRouterNavigation() {
+	return scheduledAppRouterNavigationCount > 0;
+}
+function releaseScheduledAppRouterNavigationAfterCurrentTask(release) {
+	queueMicrotask(release);
+}
+let inFlightAppRouterNavigationCount = 0;
+let visibleLinkPingAwaitsNavigations = false;
+/**
+* Called by the App Router browser entry for each RSC navigation it runs.
+* Returns a release callback for the navigation's settlement.
+*/
+function trackAppRouterNavigationInFlight() {
+	inFlightAppRouterNavigationCount += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		inFlightAppRouterNavigationCount = Math.max(0, inFlightAppRouterNavigationCount - 1);
+		if (inFlightAppRouterNavigationCount === 0 && visibleLinkPingAwaitsNavigations) {
+			visibleLinkPingAwaitsNavigations = false;
+			getNavigationRuntime()?.functions.pingVisibleLinks?.();
+		}
+	};
+}
+function pingVisibleLinksOnceNavigationsSettle() {
+	if (inFlightAppRouterNavigationCount > 0) {
+		visibleLinkPingAwaitsNavigations = true;
+		return;
+	}
+	getNavigationRuntime()?.functions.pingVisibleLinks?.();
+}
+/**
+* App Router public router instance. Mirrors Next.js's
+* `publicAppRouterInstance` from
+* `packages/next/src/client/components/app-router-instance.ts`.
+*
+* 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.
+*/
+const _appRouter = {
+	bfcacheId: "0",
+	push(href, options) {
+		assertSafeNavigationUrl(href);
+		if (isServer) return;
+		notifyAppNavigationStart(href);
+		const releaseNavigation = trackScheduledAppRouterNavigation();
+		try {
+			React$1.startTransition(() => {
+				navigateClientSide(href, "push", options?.scroll !== false, true);
+			});
+		} catch (error) {
+			releaseNavigation();
+			throw error;
+		}
+		releaseScheduledAppRouterNavigationAfterCurrentTask(releaseNavigation);
+	},
+	replace(href, options) {
+		assertSafeNavigationUrl(href);
+		if (isServer) return;
+		notifyAppNavigationStart(href);
+		const releaseNavigation = trackScheduledAppRouterNavigation();
+		try {
+			React$1.startTransition(() => {
+				navigateClientSide(href, "replace", options?.scroll !== false, true);
+			});
+		} catch (error) {
+			releaseNavigation();
+			throw error;
+		}
+		releaseScheduledAppRouterNavigationAfterCurrentTask(releaseNavigation);
+	},
+	back() {
+		if (isServer) return;
+		window.history.back();
+	},
+	forward() {
+		if (isServer) return;
+		window.history.forward();
+	},
+	refresh() {
+		if (isServer) return;
+		getNavigationRuntime()?.functions.clearNavigationCaches?.({ pingVisibleLinks: false });
+		const rscNavigate = getNavigationRuntime()?.functions.navigate;
+		if (hasScheduledAppRouterNavigation() || !rscNavigate) {
+			getNavigationRuntime()?.functions.pingVisibleLinks?.();
+			return;
+		}
+		const navigate = () => {
+			rscNavigate(window.location.href, 0, "refresh", void 0, void 0, true).finally(pingVisibleLinksOnceNavigationsSettle);
+		};
+		React$1.startTransition(navigate);
+	},
+	prefetch(href, options) {
+		assertSafeNavigationUrl(href);
+		if (isServer) return;
+		if (isBotUserAgent(window.navigator?.userAgent ?? "")) return;
+		try {
+			new URL(withBasePath(href, __basePath), window.location.href);
+		} catch {
+			throw new Error(`Cannot prefetch '${href}' because it cannot be converted to a URL.`);
+		}
+		const prefetchHref = isExternalUrl(href) ? toSameOriginAppPath(href, __basePath) : href;
+		if (prefetchHref == null) return;
+		const fullHref = toAppPrefetchDestination(prefetchHref);
+		if (fullHref === null) return;
+		const currentPathname = window.location.pathname;
+		let interceptionContext = getPrefetchInterceptionContext(fullHref, currentPathname);
+		const mountedSlotsHeader = getMountedSlotsHeader();
+		const headers = createAppPrefetchRequestHeaders({
+			fetchPriority: "low",
+			interceptionContext,
+			mountedSlotsHeader: mountedSlotsHeader || null
+		});
+		const setup = beginPrefetchSetup(fullHref);
+		(async () => {
+			const routeManifestLoad = loadNavigationRuntimeRouteManifest();
+			if (routeManifestLoad !== null) {
+				if (!await routeManifestLoad || setup.cancelled) return;
+				interceptionContext = getPrefetchInterceptionContext(fullHref, currentPathname);
+				if (interceptionContext !== null) headers.set(VINEXT_INTERCEPTION_CONTEXT_HEADER, interceptionContext);
+			}
+			if (HAS_CLIENT_REWRITES) await preloadHybridClientRouteOwner();
+			const hybridOwner = resolveHybridClientRouteOwner(fullHref);
+			if (hybridOwner === "pages" || hybridOwner === "document") return;
+			const rewrittenPrefetchHref = HAS_CLIENT_REWRITES ? resolveLoadedHybridClientRewriteHref(fullHref, __basePath) : null;
+			const kind = options?.kind === "full" ? "full" : "auto";
+			const [{ resolveAutoAppRoutePrefetch, resolveFullAppRoutePrefetch }, { resolveAppPrefetchRscRequest }] = await Promise.all([import("./internal/app-route-prefetch-policy.js"), import("./internal/app-prefetch-rsc-request.js")]);
+			if (setup.cancelled) return;
+			const policy = kind === "full" ? resolveFullAppRoutePrefetch() : resolveAutoAppRoutePrefetch(rewrittenPrefetchHref ?? fullHref, interceptionContext);
+			const reusable = policy.shouldPrefetch && policy.cacheForNavigation;
+			const requiresRouteTreePrefetch = policy.requiresRouteTreePrefetch === true;
+			if (reusable && kind === "full") headers.delete(NEXT_ROUTER_PREFETCH_HEADER);
+			if (reusable && kind === "auto") {
+				headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+				headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, __prefetchInlining || requiresRouteTreePrefetch ? "/__PAGE__" : "1");
+			}
+			const hasSearchParams = new URL(fullHref, window.location.href).search !== "";
+			if (!reusable && kind === "auto") {
+				headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+				headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+				headers.set(VINEXT_RSC_RENDER_MODE_HEADER, hasSearchParams && String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && policy.rendersDynamically !== true ? APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL : APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL);
+			}
+			const { additionalRscUrls, rscUrl } = await resolveAppPrefetchRscRequest({
+				fullHref,
+				headers,
+				rewrittenPrefetchHref
+			});
+			if (setup.cancelled) return;
+			const cacheKey = AppElementsWire.encodeCacheKey(rscUrl, interceptionContext);
+			const prefetched = getPrefetchedUrls();
+			if (policy.dynamicStaleTime !== "full-prefetch" && hasFreshLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext)) {
+				attachPrefetchInvalidationCallback(cacheKey, options?.onInvalidate);
+				return;
+			}
+			if (reusable) {
+				discardLearningOnlyPrefetchCacheEntry(rscUrl, interceptionContext, mountedSlotsHeader);
+				if (hasPrefetchCacheEntryForNavigation(rscUrl, interceptionContext, mountedSlotsHeader, {
+					additionalRscUrls,
+					onInvalidate: options?.onInvalidate,
+					onReuse: policy.dynamicStaleTime === "full-prefetch" ? (entry, matchedCacheKey) => promotePrefetchCacheEntryForNavigation(matchedCacheKey, entry) : void 0
+				})) return;
+				if (policy.dynamicStaleTime === "full-prefetch" && seedFullPrefetchFromVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls, options?.onInvalidate)) return;
+			}
+			if (policy.dynamicStaleTime !== "full-prefetch" && hasNavigationFreshVisitedResponse(rscUrl, interceptionContext, mountedSlotsHeader, additionalRscUrls, options?.onInvalidate)) return;
+			prefetched.add(cacheKey);
+			const fetchFullRscPayload = () => scheduleAppPrefetchFetch((signal) => fetch(rscUrl, {
+				headers,
+				credentials: "include",
+				priority: "low",
+				signal
+			}), "low");
+			const fetchPromise = reusable && kind === "auto" && requiresRouteTreePrefetch ? fetchRouteTreeGatedPrefetch({
+				fetchFullRscPayload,
+				fetchRouteTree: (routeTreeRscUrl, routeTreeHeaders) => scheduleAppPrefetchFetch((signal) => fetch(routeTreeRscUrl, {
+					headers: routeTreeHeaders,
+					credentials: "include",
+					priority: "low",
+					signal
+				}), "low"),
+				fullHref,
+				headers,
+				interceptionContext,
+				mountedSlotsHeader
+			}) : fetchFullRscPayload();
+			const sharedBehavior = {
+				fallbackTtlMs: policy.fallbackTtl === "dynamic" ? DYNAMIC_NAVIGATION_CACHE_TTL : PREFETCH_CACHE_TTL,
+				dynamicStaleTime: policy.dynamicStaleTime,
+				prefetchKind: "navigation"
+			};
+			prefetchRscResponse(rscUrl, fetchPromise, interceptionContext, mountedSlotsHeader, options, reusable ? {
+				...sharedBehavior,
+				cacheForNavigation: true,
+				optimisticRouteShell: false,
+				prepareSnapshot: prepareNavigationPrefetchSnapshot
+			} : {
+				...sharedBehavior,
+				cacheForNavigation: false,
+				optimisticRouteShell: true
+			});
+		})().catch((error) => {
+			console.error("[vinext] RSC prefetch setup error:", error);
+		}).finally(() => {
+			pendingPrefetchSetups.delete(setup);
+		});
+	}
+};
+if (process.env.__NEXT_GESTURE_TRANSITION) _appRouter.experimental_gesturePush = (href, options) => {
+	assertSafeNavigationUrl(href);
+	if (isServer) return;
+	if (!getNavigationRuntime()?.functions.navigate) return;
+	let appHref = href;
+	if (isExternalUrl(href)) {
+		const localPath = toSameOriginAppPath(href, __basePath);
+		if (localPath === null) return;
+		appHref = localPath;
+	}
+	const releaseNavigation = trackScheduledAppRouterNavigation();
+	navigateClientSide(appHref, "push", options?.scroll !== false, false, "synchronous");
+	releaseScheduledAppRouterNavigationAfterCurrentTask(releaseNavigation);
+};
+/**
+* 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;
+if (!isServer) {
+	const state = getClientNavigationState();
+	if (state && !state.patchInstalled) {
+		state.patchInstalled = true;
+		state.originalPushState = window.history.pushState.bind(window.history);
+		state.originalReplaceState = window.history.replaceState.bind(window.history);
+		window.addEventListener("popstate", () => {
+			notifyAppPopstateNavigationStart();
+		});
+		window.addEventListener("popstate", (event) => {
+			if (!hasAppNavigationRuntime()) {
+				commitClientNavigationState();
+				restoreScrollPosition(event.state);
+			}
+		});
+		window.history.pushState = function patchedPushState(data, unused, url) {
+			if (forwardRouterHistoryWrite(state, "pushState", data, unused, url)) return;
+			if (state.routerHistoryWriteDepth === 0) getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
+			if (isAppOwnedHistoryState(data)) {
+				const previousHistoryState = window.history.state;
+				state.originalPushState.call(window.history, data, unused, url);
+				getNavigationRuntime()?.functions.commitAppOwnedHistoryStateWrite?.("push", previousHistoryState);
+				return;
+			}
+			const previousHistoryState = window.history.state;
+			state.originalPushState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), unused, url);
+			getNavigationRuntime()?.functions.claimCurrentHistoryTreeSnapshot?.("push", previousHistoryState);
+			if (state.suppressUrlNotifyCount === 0) {
+				resetStaleLinkStatus();
+				if (url) getNavigationRuntime()?.functions.discardPendingNavigation?.();
+				commitClientNavigationState();
+			}
+		};
+		window.history.replaceState = function patchedReplaceState(data, unused, url) {
+			if (forwardRouterHistoryWrite(state, "replaceState", data, unused, url)) return;
+			if (state.routerHistoryWriteDepth === 0) getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
+			if (isAppOwnedHistoryState(data)) {
+				const previousHistoryState = window.history.state;
+				state.originalReplaceState.call(window.history, data, unused, url);
+				getNavigationRuntime()?.functions.commitAppOwnedHistoryStateWrite?.("replace", previousHistoryState);
+				return;
+			}
+			const previousHistoryState = window.history.state;
+			state.originalReplaceState.call(window.history, createExternalHistoryStatePreservingMetadata(data, window.history.state), unused, url);
+			getNavigationRuntime()?.functions.claimCurrentHistoryTreeSnapshot?.("replace", previousHistoryState);
+			if (state.suppressUrlNotifyCount === 0) {
+				resetStaleLinkStatus();
+				if (url) getNavigationRuntime()?.functions.discardPendingNavigation?.();
+				commitClientNavigationState();
+			}
+		};
+	}
+}
+export { DYNAMIC_NAVIGATION_CACHE_TTL, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, appRouterInstance, applyAppRouterScrollFallback, consumePrefetchResponse, consumePrefetchResponseForNavigation, createAppPrefetchRequestHeaders, createCachedRscResponseSnapshot, deletePrefetchResponseSnapshot, disableNavigationResponsePrefetchCacheReuse, discardLearningOnlyPrefetchCacheEntry, fetchRouteTreeGatedPrefetch, getCurrentInterceptionContext, getCurrentNextUrl, getFreshPrefetchCacheEntry, getMountedSlotsHeader, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasFreshLearningOnlyPrefetchCacheEntry, hasNavigationFreshVisitedResponse, hasPrefetchCacheEntryForNavigation, hasSearchAgnosticPrefetchShellForRoute, invalidateDynamicPrefetchCache, invalidatePrefetchCache, invalidateVisitedResponsePrefetches, navigateClientSide, parseRenderedPathAndSearchHeader, peekPrefetchResponseForNavigation, prefetchRscResponse, preloadHybridClientRouteOwner, prepareNavigationPrefetchSnapshot, promotePrefetchCacheEntryForNavigation, pushHistoryStateWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolveLoadedHybridClientRewriteHref, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, seedFullPrefetchFromVisitedResponse, seedPrefetchResponseSnapshot, setMountedSlotsHeader, snapshotRscResponse, trackAppRouterNavigationInFlight };