vinext 0.0.55 → 0.1.1

package/dist/shims/router.js

@@ -1,3 +1,4 @@
+import { splitPathSegments } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { matchRoutePattern, routePatternParts } from "../routing/route-pattern.js";
@@ -12,10 +13,10 @@ import { prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/
 import { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.js";
 import { dedupedPagesDataFetch } from "./internal/pages-data-fetch-dedup.js";
 import { installWindowNext } from "../client/window-next.js";
-import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
+import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { addQueryParam, appendSearchParamsToUrl, mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { scrollToHashTarget } from "./hash-scroll.js";
-import { setPagesRouterPopStateHandler } from "./pages-router-runtime.js";
+import { setPagesRouterPopStateHandler, setStampInitialHistoryState } from "./pages-router-runtime.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { createElement, useContext, useEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
@@ -175,13 +176,52 @@ function isHashOnlyChange(href) {
 	if (typeof window === "undefined") return false;
 	return isHashOnlyBrowserUrlChange(href, window.location.href, __basePath);
 }
-/** Save current scroll position into history state for back/forward restoration */
+/**
+* Build router-shaped state for the initial document entry. Captures the
+* active locale (from `window.__VINEXT_LOCALE__`) so a back-navigation
+* popstate to this entry can recover its locale instead of falling back to
+* the live window global — the locale may have changed by the time the user
+* navigates back.
+*/
+function buildInitialRouterState() {
+	const appPath = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	const options = {};
+	if (window.__VINEXT_LOCALE__ !== void 0) options.locale = window.__VINEXT_LOCALE__;
+	return {
+		url: appPath,
+		as: appPath,
+		options,
+		__N: true,
+		key: createHistoryKey()
+	};
+}
+/**
+* Stamp the initial document entry with router-shaped state (only if no
+* state is present). Called once at runtime install so the entry has a
+* locale stamped before any push could overwrite the active locale global.
+*/
+function stampInitialHistoryState() {
+	if (window.history.state !== null && window.history.state !== void 0) return;
+	window.history.replaceState(buildInitialRouterState(), "");
+}
+setStampInitialHistoryState(stampInitialHistoryState);
+/** Save current scroll position into history state for back/forward restoration.
+*
+* Merging into the existing state preserves any router-owned fields (`__N`,
+* `url`, `as`, `options`, `key`). If the install-time stamp didn't run
+* (Router.push called before installPagesRouterRuntime), fall back to
+* minting the same shape here so the entry isn't treated as foreign.
+*/
 function saveScrollPosition() {
-	const state = window.history.state ?? {};
-	window.history.replaceState({
-		...state,
+	const existing = typeof window.history.state === "object" && window.history.state !== null ? window.history.state : null;
+	const scroll = {
 		__vinext_scrollX: window.scrollX,
 		__vinext_scrollY: window.scrollY
+	};
+	const base = existing ?? buildInitialRouterState();
+	window.history.replaceState({
+		...base,
+		...scroll
 	}, "");
 }
 /** Restore scroll position from history state */
@@ -207,15 +247,19 @@ function _registerRouterStateAccessors(accessors) {
 function setSSRContext(ctx) {
 	_setSSRContextImpl(ctx);
 }
+const PAGES_NAVIGATION_NOTIFY_KEY = Symbol.for("vinext.navigation.pagesNavigationNotify");
 let _cachedClientPagesNavCtx = null;
 let _cachedClientPagesNavCtxKey = null;
-function _buildClientPagesNavigationContext(routePattern, resolvedPath, searchString) {
-	const cacheKey = `${routePattern}|${resolvedPath}|${searchString}`;
+function _buildClientPagesNavigationContext(routePattern, resolvedPath, searchString, isReady, nextData) {
+	const cacheKey = `${isReady ? "1" : "0"}|${routePattern}|${resolvedPath}|${searchString}`;
 	if (_cachedClientPagesNavCtxKey === cacheKey && _cachedClientPagesNavCtx) return _cachedClientPagesNavCtx;
+	const searchParams = isReady ? new URLSearchParams(searchString) : new URLSearchParams();
+	const params = isReady ? extractRouteParamsFromPath(routePattern, resolvedPath) ?? getRouteParamsFromQuery(routePattern, nextData?.query ?? {}) ?? {} : null;
+	const isAutoExportDynamic = nextData?.autoExport === true && extractRouteParamNames(routePattern).length > 0;
 	const ctx = {
-		pathname: resolvedPath,
-		searchParams: new URLSearchParams(searchString),
-		params: routePattern ? extractRouteParamsFromPath(routePattern, resolvedPath) ?? {} : {}
+		pathname: resolvePagesNavigationPathname(resolvedPath, nextData?.isFallback === true, isAutoExportDynamic, isReady),
+		searchParams,
+		params
 	};
 	_cachedClientPagesNavCtx = ctx;
 	_cachedClientPagesNavCtxKey = cacheKey;
@@ -244,27 +288,33 @@ function getPagesNavigationContext() {
 		if (!ssrCtx) return null;
 		const cached = _ssrPagesNavCtxCache.get(ssrCtx);
 		if (cached) return cached;
-		let searchParams;
+		let searchString = "";
 		let resolvedPath;
 		try {
 			const url = new URL(ssrCtx.asPath, "http://_");
-			searchParams = url.searchParams;
+			searchString = url.search;
 			resolvedPath = url.pathname;
 		} catch {
-			searchParams = new URLSearchParams();
 			resolvedPath = ssrCtx.pathname;
 		}
-		const params = extractRouteParamsFromPath(ssrCtx.pathname, resolvedPath) ?? {};
+		const isReady = ssrCtx.navigationIsReady ?? true;
+		const searchParams = isReady ? new URLSearchParams(searchString) : new URLSearchParams();
+		const params = isReady ? extractRouteParamsFromPath(ssrCtx.pathname, resolvedPath) ?? getRouteParamsFromQuery(ssrCtx.pathname, ssrCtx.query) ?? {} : null;
+		const isAutoExportDynamic = ssrCtx.nextData?.autoExport === true && extractRouteParamNames(ssrCtx.pathname).length > 0;
 		const ctx = {
-			pathname: resolvedPath,
+			pathname: resolvePagesNavigationPathname(resolvedPath, ssrCtx.isFallback === true, isAutoExportDynamic, isReady),
 			searchParams,
 			params
 		};
 		_ssrPagesNavCtxCache.set(ssrCtx, ctx);
 		return ctx;
 	}
+	if (!isPagesRouterDocumentActive()) return null;
 	const resolvedPath = stripBasePath(window.location.pathname, __basePath);
-	return _buildClientPagesNavigationContext(window.__NEXT_DATA__?.page ?? "", resolvedPath, window.location.search);
+	const nextData = window.__NEXT_DATA__;
+	const pattern = resolvePagesRoutePatternForPath(nextData?.page, resolvedPath);
+	if (!pattern) return null;
+	return _buildClientPagesNavigationContext(pattern, resolvedPath, window.location.search, isPagesRouterReady(), nextData);
 }
 /**
 * Extract param names from a Next.js route pattern.
@@ -281,12 +331,52 @@ function extractRouteParamNames(pattern) {
 	for (const m of colonMatches) names.push(m[1]);
 	return names;
 }
-function splitPathSegments(pathname) {
-	return pathname.split("/").filter(Boolean);
+/**
+* Resolve the `pathname` snapshot for the Pages Router navigation context.
+* Shared by the client and SSR branches of `getPagesNavigationContext` so both
+* runtimes derive identical null-ness — diverging here would reintroduce a
+* hydration mismatch. Returns `null` for a `getStaticPaths` fallback shell or a
+* pre-ready auto-export dynamic route (the live path is published once the
+* client router becomes ready).
+*/
+function resolvePagesNavigationPathname(resolvedPath, isFallback, isAutoExportDynamic, isReady) {
+	return isFallback || isAutoExportDynamic && !isReady ? null : resolvedPath;
+}
+let _cachedPagesRoutePatternKey = null;
+let _cachedPagesRoutePattern;
+function resolvePagesRoutePatternForPath(nextDataPage, resolvedPath) {
+	if (nextDataPage && extractRouteParamNames(nextDataPage).length > 0) return nextDataPage;
+	const cacheKey = `${nextDataPage ?? ""}|${resolvedPath}`;
+	if (_cachedPagesRoutePatternKey === cacheKey) return _cachedPagesRoutePattern;
+	let resolved = nextDataPage;
+	for (const pattern of window.__VINEXT_PAGE_PATTERNS__ ?? []) if (matchRoutePattern(splitPathSegments(resolvedPath), routePatternParts(pattern))) {
+		resolved = pattern;
+		break;
+	}
+	_cachedPagesRoutePatternKey = cacheKey;
+	_cachedPagesRoutePattern = resolved;
+	return resolved;
 }
 function extractRouteParamsFromPath(pattern, pathname) {
 	return matchRoutePattern(splitPathSegments(pathname), routePatternParts(pattern));
 }
+function getRouteParamsFromQuery(pattern, query) {
+	const names = extractRouteParamNames(pattern);
+	if (names.length === 0) return null;
+	const params = {};
+	let hasParam = false;
+	for (const name of names) {
+		const value = query[name];
+		if (typeof value === "string") {
+			params[name] = value;
+			hasParam = true;
+		} else if (Array.isArray(value)) {
+			params[name] = [...value];
+			hasParam = true;
+		}
+	}
+	return hasParam ? params : null;
+}
 function getRouteQueryFromNextData(nextData, resolvedPath) {
 	const routeQuery = {};
 	if (!nextData?.query || !nextData.page) return routeQuery;
@@ -335,6 +425,47 @@ function getPathnameAndQuery() {
 		asPath: resolvedPath + window.location.search + window.location.hash
 	};
 }
+function getPagesNavigationIsReadyFromSerializedState(routePattern, searchString, nextData) {
+	if (!routePattern) return true;
+	if (nextData?.gssp === true || nextData?.gip === true || nextData?.isExperimentalCompile === true || nextData?.appGip === true && nextData.gsp !== true) return true;
+	const autoExportDynamic = nextData?.autoExport === true && extractRouteParamNames(routePattern).length > 0;
+	const hasSearch = searchString.length > 0;
+	const hasRewrites = nextData?.__vinext?.hasRewrites === true;
+	return !autoExportDynamic && !hasSearch && !hasRewrites;
+}
+function shouldDeferInitialPagesRouterReady() {
+	if (typeof window === "undefined") return false;
+	const nextData = window.__NEXT_DATA__;
+	if (!nextData) return false;
+	return !getPagesNavigationIsReadyFromSerializedState(nextData.page, window.location.search, nextData);
+}
+let _pagesRouterReady = typeof window === "undefined" ? true : !shouldDeferInitialPagesRouterReady();
+function isPagesRouterReady() {
+	return _pagesRouterReady;
+}
+function isPagesRouterDocumentActive() {
+	if (typeof window === "undefined") return true;
+	if (window.__VINEXT_PAGE_LOADERS__) return true;
+	if (window.next?.appDir === true) return false;
+	if (window.next?.router) return true;
+	return Boolean(window.__VINEXT_APP__ || window.__VINEXT_APP_LOADER__);
+}
+function markPagesRouterReady() {
+	if (typeof window === "undefined" || _pagesRouterReady) return false;
+	_pagesRouterReady = true;
+	return true;
+}
+function getRouterSnapshot() {
+	const isReady = typeof window === "undefined" ? _getSSRContext()?.navigationIsReady ?? true : isPagesRouterReady();
+	return {
+		...getPathnameAndQuery(),
+		isReady
+	};
+}
+function notifyNextNavigationPagesContext() {
+	const notify = globalThis[PAGES_NAVIGATION_NOTIFY_KEY];
+	notify?.();
+}
 /**
 * Error thrown when a navigation is superseded by a newer one.
 * Matches Next.js's convention of an Error with `.cancelled = true`.
@@ -449,6 +580,25 @@ async function resolveMiddlewareDataRedirect(browserUrl, signal) {
 	}
 }
 /**
+* React to a gSSP/gSP `__N_REDIRECT` marker returned on a client data
+* navigation.
+*
+* Internal destinations (absolute paths, unless the redirect opted out of
+* basePath via `__N_REDIRECT_BASE_PATH === false`) are followed with a fresh
+* client-side navigation that preserves the originating push/replace mode. The
+* fresh navigation increments the navigation id, so the navigation that
+* produced this redirect is superseded and never commits the intermediate
+* page. External (or non-absolute) destinations fall back to a hard navigation.
+*
+* Ported from Next.js: packages/next/src/shared/lib/router/router.ts
+* (`pageProps.__N_REDIRECT` handling — internal `this.change` vs
+* `handleHardNavigation`).
+*/
+function handleDataRedirect(destination, redirectBasePath, mode = "push") {
+	if (!(destination.startsWith("/") && redirectBasePath !== false)) scheduleHardNavigationAndThrow(destination, "Navigation redirected externally");
+	performNavigation(destination, void 0, { locale: false }, mode);
+}
+/**
 * Perform client-side navigation via the `/_next/data/<id>/<page>.json`
 * endpoint. Used when `__VINEXT_PAGE_LOADERS__` has a matching code-split
 * loader for the target pattern (the prod hot path). Falls back to the
@@ -461,7 +611,7 @@ async function resolveMiddlewareDataRedirect(browserUrl, signal) {
 * data endpoint returns 404 and the client lands on the new build via a
 * full document load.
 */
-async function navigateClientData(url, target, controller, navId, assertStillCurrent) {
+async function navigateClientData(url, target, controller, navId, assertStillCurrent, options = {}) {
 	const root = window.__VINEXT_ROOT__;
 	if (!root) {
 		window.location.href = url;
@@ -497,6 +647,11 @@ async function navigateClientData(url, target, controller, navId, assertStillCur
 	}
 	assertStillCurrent();
 	const pageProps = body.pageProps && typeof body.pageProps === "object" ? body.pageProps : {};
+	const redirectDestination = pageProps.__N_REDIRECT;
+	if (typeof redirectDestination === "string") {
+		handleDataRedirect(redirectDestination, pageProps.__N_REDIRECT_BASE_PATH, options.mode);
+		throw new NavigationCancelledError(url);
+	}
 	let pageModule;
 	try {
 		pageModule = await target.loader();
@@ -683,7 +838,7 @@ async function navigateClient(url, fetchUrl = url, options = {}) {
 					htmlFetchUrl = redirectedUrl;
 				}
 			}
-			if (dataTarget) await navigateClientData(browserUrl, dataTarget, controller, navId, assertStillCurrent);
+			if (dataTarget) await navigateClientData(browserUrl, dataTarget, controller, navId, assertStillCurrent, options);
 			else await navigateClientHtml(browserUrl, htmlFetchUrl, controller, navId, assertStillCurrent, options);
 		}
 	} finally {
@@ -718,7 +873,7 @@ async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, optio
 * and a set of navigation methods. Shared by the Pages Router context provider
 * and tests so the public router shape stays in sync.
 */
-function buildRouterValue(pathname, query, asPath, methods) {
+function buildRouterValue(pathname, query, asPath, isReady, methods) {
 	const _ssrState = _getSSRContext();
 	const nextData = typeof window !== "undefined" ? window.__NEXT_DATA__ : void 0;
 	const locale = typeof window === "undefined" ? _ssrState?.locale : window.__VINEXT_LOCALE__;
@@ -735,7 +890,7 @@ function buildRouterValue(pathname, query, asPath, methods) {
 		locales,
 		defaultLocale,
 		domainLocales,
-		isReady: true,
+		isReady,
 		isPreview: false,
 		isFallback: typeof window !== "undefined" ? nextData?.isFallback === true : _ssrState?.isFallback === true,
 		...methods,
@@ -747,18 +902,50 @@ function extractHash(url) {
 	const i = url.indexOf("#");
 	return i === -1 ? "" : url.slice(i);
 }
+/** Return the URL with any trailing `#fragment` removed. */
+function stripHash(url) {
+	const i = url.indexOf("#");
+	return i === -1 ? url : url.slice(0, i);
+}
 /** Notify in-page listeners (e.g. useRouter hooks) that navigation occurred. */
 function dispatchNavigateEvent() {
+	notifyNextNavigationPagesContext();
 	window.dispatchEvent(new CustomEvent("vinext:navigate"));
 }
 /**
 * Update history with the new URL and refresh the hash-only-detection tracker.
 * Centralises the `pushState`/`replaceState` branch so callers don't repeat it.
+*
+* Writes a Next.js-compatible state shape so popstate can detect non-router
+* entries, ignore stale Safari-style replays, and recover the active locale
+* across browser back/forward. Mirrors `Router.changeState` in
+* .nextjs-ref/packages/next/src/shared/lib/router/router.ts (around L1916).
+*
+* @param mode push or replace
+* @param fullUrl absolute URL committed to the browser (with basePath)
+* @param navState router-level metadata (`url`, `as`, `options`) the popstate
+*        handler needs to honour stickiness — most importantly the active
+*        locale and the canonical app-relative `as` path.
 */
-function updateHistory(mode, url) {
-	if (mode === "push") window.history.pushState({}, "", url);
-	else window.history.replaceState({}, "", url);
+function updateHistory(mode, fullUrl, navState) {
+	const previousState = typeof window.history.state === "object" && window.history.state !== null ? window.history.state : null;
+	const key = mode === "push" ? createHistoryKey() : previousState?.key ?? createHistoryKey();
+	const state = {
+		url: navState?.url ?? fullUrl,
+		as: navState?.as ?? fullUrl,
+		options: navState?.options ?? {},
+		__N: true,
+		key
+	};
+	if (mode === "push") window.history.pushState(state, "", fullUrl);
+	else window.history.replaceState(state, "", fullUrl);
 	_lastPathnameAndSearch = window.location.pathname + window.location.search;
+	_routerDidNavigate = true;
+}
+let _historyKeyCounter = 0;
+function createHistoryKey() {
+	_historyKeyCounter += 1;
+	return `vinext_${_historyKeyCounter.toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
 }
 /**
 * Throw the canonical "no router instance" error used when a Pages Router
@@ -806,13 +993,24 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	const full = normalizePathTrailingSlash(toBrowserNavigationHref(resolved, window.location.href, __basePath), __trailingSlash);
 	const errorRouteHtmlFetchUrl = resolvePagesErrorHtmlFetchUrl(url, navigationLocale);
 	const htmlFetchUrl = errorRouteHtmlFetchUrl ?? getPagesHtmlFetchUrl(full, navigationLocale);
-	const navigateOptions = errorRouteHtmlFetchUrl ? { allowNotFoundResponse: true } : {};
+	const navigateOptions = errorRouteHtmlFetchUrl ? {
+		allowNotFoundResponse: true,
+		mode
+	} : { mode };
 	const shallow = options?.shallow ?? false;
 	const doScroll = options?.scroll !== false;
+	const navStateOptions = { shallow };
+	if (navigationLocale !== void 0) navStateOptions.locale = navigationLocale;
+	const resolvedNoHash = stripHash(resolved);
+	const navState = {
+		url: resolvedNoHash,
+		as: resolvedNoHash,
+		options: navStateOptions
+	};
 	if (isHashOnlyChange(full)) {
 		const eventUrl = resolveHashUrl(full);
 		routerEvents.emit("hashChangeStart", eventUrl, { shallow });
-		updateHistory(mode, resolved.startsWith("#") ? resolved : full);
+		updateHistory(mode, resolved.startsWith("#") ? resolved : full, navState);
 		if (doScroll) scrollToHashTarget(extractHash(resolved));
 		onStateUpdate?.();
 		routerEvents.emit("hashChangeComplete", eventUrl, { shallow });
@@ -822,7 +1020,7 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	if (mode === "push") saveScrollPosition();
 	routerEvents.emit("routeChangeStart", resolved, { shallow });
 	routerEvents.emit("beforeHistoryChange", resolved, { shallow });
-	updateHistory(mode, full);
+	updateHistory(mode, full, navState);
 	if (!shallow) {
 		const result = await runNavigateClient(full, resolved, htmlFetchUrl, navigateOptions);
 		if (result === "cancelled") return true;
@@ -881,15 +1079,25 @@ function useRouter() {
 	return router;
 }
 function PagesRouterProvider({ children }) {
-	const [{ pathname, query, asPath }, setState] = useState(getPathnameAndQuery);
+	const [{ pathname, query, asPath, isReady }, setState] = useState(getRouterSnapshot);
 	useEffect(() => {
 		const onNavigate = ((_e) => {
-			setState(getPathnameAndQuery());
+			setState(getRouterSnapshot());
 		});
 		window.addEventListener("vinext:navigate", onNavigate);
-		return () => window.removeEventListener("vinext:navigate", onNavigate);
+		let cancelled = false;
+		const readyTimer = window.setTimeout(() => {
+			if (cancelled || !markPagesRouterReady()) return;
+			setState(getRouterSnapshot());
+			notifyNextNavigationPagesContext();
+		}, 0);
+		return () => {
+			cancelled = true;
+			window.clearTimeout(readyTimer);
+			window.removeEventListener("vinext:navigate", onNavigate);
+		};
 	}, []);
-	const router = useMemo(() => buildRouterValue(pathname, query, asPath, {
+	const router = useMemo(() => buildRouterValue(pathname, query, asPath, isReady, {
 		push: Router.push,
 		replace: Router.replace,
 		back: Router.back,
@@ -899,7 +1107,8 @@ function PagesRouterProvider({ children }) {
 	}), [
 		pathname,
 		query,
-		asPath
+		asPath,
+		isReady
 	]);
 	const appRouter = useMemo(() => ({
 		bfcacheId: "0",
@@ -928,9 +1137,22 @@ function PagesRouterProvider({ children }) {
 }
 let _beforePopStateCb;
 let _lastPathnameAndSearch = typeof window !== "undefined" ? window.location.pathname + window.location.search : "";
+let _isFirstPopStateEvent = true;
+let _routerDidNavigate = false;
+function isNextRouterState(state) {
+	return typeof state === "object" && state !== null && "__N" in state && state.__N === true;
+}
 function handlePagesRouterPopState(e) {
 	const browserUrl = window.location.pathname + window.location.search;
 	const appUrl = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	const state = e.state;
+	const wasFirst = _isFirstPopStateEvent;
+	_isFirstPopStateEvent = false;
+	if (state !== null && state !== void 0 && !isNextRouterState(state)) return;
+	if (wasFirst && !_routerDidNavigate && isNextRouterState(state)) {
+		const currentLocale = window.__VINEXT_LOCALE__;
+		if (state.options?.locale === currentLocale && typeof state.as === "string" && withBasePath(state.as, __basePath) === _lastPathnameAndSearch) return;
+	}
 	const isHashOnly = browserUrl === _lastPathnameAndSearch;
 	if (_beforePopStateCb !== void 0) {
 		if (!_beforePopStateCb({
@@ -948,11 +1170,12 @@ function handlePagesRouterPopState(e) {
 		dispatchNavigateEvent();
 		return;
 	}
+	const effectiveLocale = (isNextRouterState(state) ? state.options?.locale : void 0) ?? window.__VINEXT_LOCALE__;
 	const fullAppUrl = appUrl + window.location.hash;
 	routerEvents.emit("routeChangeStart", fullAppUrl, { shallow: false });
 	routerEvents.emit("beforeHistoryChange", fullAppUrl, { shallow: false });
 	(async () => {
-		if (await runNavigateClient(browserUrl, fullAppUrl, getPagesHtmlFetchUrl(browserUrl, window.__VINEXT_LOCALE__)) === "completed") {
+		if (await runNavigateClient(browserUrl, fullAppUrl, getPagesHtmlFetchUrl(browserUrl, effectiveLocale)) === "completed") {
 			routerEvents.emit("routeChangeComplete", fullAppUrl, { shallow: false });
 			restoreScrollPosition(e.state);
 			dispatchNavigateEvent();
@@ -1098,8 +1321,9 @@ const Router = Object.defineProperties(RouterMethods, {
 	},
 	isReady: {
 		enumerable: true,
-		value: true,
-		writable: false
+		get() {
+			return isPagesRouterReady();
+		}
 	},
 	isPreview: {
 		enumerable: true,
@@ -1118,6 +1342,4 @@ if (typeof window !== "undefined") installWindowNext({ router: Router });
 const _PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
 globalThis[_PAGES_NAVIGATION_ACCESSOR_KEY] = getPagesNavigationContext;
 //#endregion
-export { _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };
-
-//# sourceMappingURL=router.js.map
+export { _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, getPagesNavigationIsReadyFromSerializedState, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };

package/dist/shims/script-nonce-context.d.ts

@@ -8,5 +8,4 @@ declare function ScriptNonceProvider(props: React.PropsWithChildren<{
 declare function withScriptNonce(element: React.ReactElement, nonce?: string): React.ReactElement;
 declare function useScriptNonce(): string | undefined;
 //#endregion
-export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };
-//# sourceMappingURL=script-nonce-context.d.ts.map
+export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };

package/dist/shims/script-nonce-context.js

@@ -13,5 +13,3 @@ function useScriptNonce() {
 }
 //#endregion
 export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };
-
-//# sourceMappingURL=script-nonce-context.js.map

package/dist/shims/script.d.ts

@@ -40,5 +40,4 @@ declare function handleClientScriptLoad(props: ScriptProps): void;
 declare function initScriptLoader(scripts: ScriptProps[]): void;
 declare function Script(props: ScriptProps): React.ReactElement | null;
 //#endregion
-export { ScriptProps, Script as default, handleClientScriptLoad, initScriptLoader };
-//# sourceMappingURL=script.d.ts.map
+export { ScriptProps, Script as default, handleClientScriptLoad, initScriptLoader };

package/dist/shims/script.js

@@ -364,5 +364,3 @@ function Script(props) {
 }
 //#endregion
 export { Script as default, handleClientScriptLoad, initScriptLoader };
-
-//# sourceMappingURL=script.js.map

package/dist/shims/server.d.ts

@@ -289,5 +289,4 @@ declare function connection(): Promise<void>;
  */
 declare const URLPattern: typeof globalThis.URLPattern;
 //#endregion
-export { MiddlewareResponseInit, NextFetchEvent, NextMiddleware, NextMiddlewareResult, NextRequest, NextResponse, NextURL, NextURLConfig, RequestCookies, ResponseCookies, URLPattern, UserAgent, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };
-//# sourceMappingURL=server.d.ts.map
+export { MiddlewareResponseInit, NextFetchEvent, NextMiddleware, NextMiddlewareResult, NextRequest, NextResponse, NextURL, NextURLConfig, RequestCookies, ResponseCookies, URLPattern, UserAgent, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };

package/dist/shims/server.js

@@ -670,5 +670,3 @@ const URLPattern = globalThis.URLPattern ?? (() => {
 });
 //#endregion
 export { NextFetchEvent, NextRequest, NextResponse, NextURL, RequestCookies, ResponseCookies, URLPattern, after, connection, sealRequestCookies, sealRequestHeaders, userAgent, userAgentFromString };
-
-//# sourceMappingURL=server.js.map

package/dist/shims/slot.d.ts

@@ -1,6 +1,5 @@
 import { AppElementValue, AppElements, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import * as React$1 from "react";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/shims/slot.d.ts
 /**
@@ -11,12 +10,21 @@ import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 declare const ElementsContext: React$1.Context<Readonly<Record<string, AppElementValue>>>;
 declare const ChildrenContext: React$1.Context<React$1.ReactNode>;
 declare const ParallelSlotsContext: React$1.Context<Readonly<Record<string, React$1.ReactNode>> | null>;
+declare const BfcacheStateKeyMapContext: React$1.Context<Readonly<Record<string, string>>>;
+type BfcacheSlotEntry = {
+  content: React$1.ReactNode;
+  elements?: AppElements;
+  segmentId?: string;
+  stateKey: string;
+  stateKeyMap?: Readonly<Record<string, string>>;
+};
 type MergeElementsOptions = {
   clearAbsentSlots?: boolean;
   preserveAbsentSlots?: boolean;
   preserveElementIds?: readonly string[];
   preservePreviousSlotIds?: readonly string[];
 };
+declare function updateBfcacheSlotEntryOrder(previousOrder: readonly string[], activeStateKey: string, maxEntries?: number): string[];
 declare function mergeElements(prev: AppElements, next: AppElements, options?: MergeElementsOptions | boolean): AppElements;
 declare function Slot({
   id,
@@ -26,7 +34,7 @@ declare function Slot({
   id: string;
   children?: React$1.ReactNode;
   parallelSlots?: Readonly<Record<string, React$1.ReactNode>>;
-}): _$react_jsx_runtime0.JSX.Element | null;
+}): React$1.JSX.Element | null;
 declare function Children(): React$1.ReactNode;
 declare function ParallelSlot({
   name
@@ -34,5 +42,4 @@ declare function ParallelSlot({
   name: string;
 }): string | number | bigint | boolean | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null;
 //#endregion
-export { Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements };
-//# sourceMappingURL=slot.d.ts.map
+export { BfcacheSlotEntry, BfcacheStateKeyMapContext, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, Slot, UNMATCHED_SLOT, mergeElements, updateBfcacheSlotEntryOrder };