vinext 0.0.54 → 0.1.0

package/dist/shims/ppr-fallback-shell.js

@@ -0,0 +1,149 @@
+import { getOrCreateAls } from "./internal/als-registry.js";
+import { makeHangingPromise } from "./internal/make-hanging-promise.js";
+//#region src/shims/ppr-fallback-shell.ts
+const pprFallbackShellAls = getOrCreateAls("vinext.pprFallbackShell.als");
+const pprFallbackShellCacheTaskStackAls = getOrCreateAls("vinext.pprFallbackShell.cacheTaskStack.als");
+function noop() {}
+function scheduleAfterTask(callback) {
+	let firstTimer = setTimeout(() => {
+		firstTimer = null;
+		secondTimer = setTimeout(() => {
+			secondTimer = null;
+			callback();
+		}, 0);
+	}, 0);
+	let secondTimer = null;
+	return () => {
+		if (firstTimer !== null) {
+			clearTimeout(firstTimer);
+			firstTimer = null;
+		}
+		if (secondTimer !== null) {
+			clearTimeout(secondTimer);
+			secondTimer = null;
+		}
+	};
+}
+function resolveCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0) return;
+	const resolvers = state.cacheReadyResolvers.splice(0);
+	for (const resolve of resolvers) resolve();
+}
+function cancelPendingCacheReady(state) {
+	if (state.pendingCacheReadyCleanup === null) return;
+	state.pendingCacheReadyCleanup();
+	state.pendingCacheReadyCleanup = null;
+}
+function scheduleCacheReadyIfSettled(state) {
+	if (state.pendingCacheTasks !== 0 || state.pendingCacheReadyCleanup !== null) return;
+	state.pendingCacheReadyCleanup = scheduleAfterTask(() => {
+		state.pendingCacheReadyCleanup = null;
+		resolveCacheReadyIfSettled(state);
+		if (state.phase === "final") scheduleAbortIfReady(state);
+	});
+}
+function scheduleAbortIfReady(state) {
+	if (state.phase !== "final" || !state.hasDynamicBoundary || state.pendingCacheTasks > 0 || state.pendingCacheReadyCleanup !== null || state.isAbortScheduled) return;
+	state.isAbortScheduled = true;
+	state.pendingAbortCleanup = scheduleAfterTask(() => {
+		state.pendingAbortCleanup = null;
+		state.isAbortScheduled = false;
+		if (state.phase === "final" && state.hasDynamicBoundary && state.pendingCacheTasks === 0 && state.pendingCacheReadyCleanup === null && !state.abortController.signal.aborted) state.abortController.abort();
+	});
+}
+function completeCacheTask(state, task) {
+	if (!task.isPending) return;
+	task.isPending = false;
+	if (task.epoch !== state.cacheEpoch) return;
+	state.pendingCacheTasks--;
+	scheduleCacheReadyIfSettled(state);
+}
+function ignoreCacheTask(state, task) {
+	if (!task.isPending || task.isIgnored) return;
+	task.isIgnored = true;
+	completeCacheTask(state, task);
+}
+function createPprFallbackShellState(options) {
+	return {
+		abortController: new AbortController(),
+		cacheEpoch: 0,
+		cacheReadyResolvers: [],
+		fallbackParamNames: new Set(options.fallbackParamNames),
+		hasDynamicBoundary: false,
+		isAbortScheduled: false,
+		pendingAbortCleanup: null,
+		pendingCacheReadyCleanup: null,
+		pendingCacheTasks: 0,
+		phase: "warmup",
+		routePattern: options.routePattern
+	};
+}
+function runWithPprFallbackShellState(state, fn) {
+	return pprFallbackShellAls.run(state, fn);
+}
+function getPprFallbackShellState() {
+	return pprFallbackShellAls.getStore() ?? null;
+}
+function trackPprFallbackShellCacheTask(fn, cacheVariant) {
+	const state = getPprFallbackShellState();
+	if (state === null || cacheVariant === "private") return fn();
+	cancelPendingCacheReady(state);
+	state.pendingCacheTasks++;
+	const task = {
+		epoch: state.cacheEpoch,
+		isIgnored: false,
+		isPending: true
+	};
+	const parentStack = pprFallbackShellCacheTaskStackAls.getStore() ?? [];
+	let promise;
+	try {
+		promise = pprFallbackShellCacheTaskStackAls.run([...parentStack, task], fn);
+	} catch (error) {
+		completeCacheTask(state, task);
+		return Promise.reject(error);
+	}
+	return promise.finally(() => {
+		if (!task.isIgnored) completeCacheTask(state, task);
+	});
+}
+function createPprFallbackShellSuspensePromiseForState(state, expression) {
+	state.hasDynamicBoundary = true;
+	for (const task of pprFallbackShellCacheTaskStackAls.getStore() ?? []) ignoreCacheTask(state, task);
+	scheduleCacheReadyIfSettled(state);
+	if (state.phase === "final") scheduleAbortIfReady(state);
+	const promise = makeHangingPromise(state.abortController.signal, state.routePattern, expression);
+	promise.catch(noop);
+	return promise;
+}
+function createPprFallbackShellSuspensePromise(expression) {
+	const state = getPprFallbackShellState();
+	if (state === null) return null;
+	return createPprFallbackShellSuspensePromiseForState(state, expression);
+}
+function waitForPprFallbackShellCacheReady(state) {
+	if (state.phase !== "warmup") return Promise.resolve();
+	return new Promise((resolve) => {
+		state.cacheReadyResolvers.push(resolve);
+		scheduleCacheReadyIfSettled(state);
+	});
+}
+function preparePprFallbackShellFinalRender(state) {
+	cancelPendingCacheReady(state);
+	if (state.pendingAbortCleanup !== null) {
+		state.pendingAbortCleanup();
+		state.pendingAbortCleanup = null;
+	}
+	state.abortController = new AbortController();
+	state.cacheEpoch++;
+	state.cacheReadyResolvers.length = 0;
+	state.hasDynamicBoundary = false;
+	state.isAbortScheduled = false;
+	state.pendingCacheTasks = 0;
+	state.phase = "final";
+}
+function isPprFallbackShellAbortError(error) {
+	if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") return true;
+	return error instanceof Error && error.name === "HangingPromiseRejectionError";
+}
+//#endregion
+export { createPprFallbackShellState, createPprFallbackShellSuspensePromise, createPprFallbackShellSuspensePromiseForState, getPprFallbackShellState, isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, runWithPprFallbackShellState, trackPprFallbackShellCacheTask, waitForPprFallbackShellCacheReady };

package/dist/shims/readonly-url-search-params.d.ts

@@ -10,5 +10,4 @@ declare class ReadonlyURLSearchParams extends URLSearchParams {
   sort(): never;
 }
 //#endregion
-export { ReadonlyURLSearchParams };
-//# sourceMappingURL=readonly-url-search-params.d.ts.map
+export { ReadonlyURLSearchParams };

package/dist/shims/readonly-url-search-params.js

@@ -24,5 +24,3 @@ var ReadonlyURLSearchParams = class extends URLSearchParams {
 };
 //#endregion
 export { ReadonlyURLSearchParams };
-
-//# sourceMappingURL=readonly-url-search-params.js.map

package/dist/shims/request-context.d.ts

@@ -22,13 +22,18 @@
  *   ctx?.waitUntil(somePromise);
  */
 /**
- * Minimal ExecutionContext interface matching the Cloudflare Workers runtime.
- * Using a structural interface so this file has no runtime dependency on
- * Cloudflare types packages.
+ * Minimal structural ExecutionContext interface, kept free of any host-runtime
+ * dependency.
  */
 type ExecutionContextLike = {
   waitUntil(promise: Promise<unknown>): void;
   passThroughOnException?(): void;
+  /**
+   * Optional host-provided cache handle that some runtimes expose on the
+   * execution context. Typed as `unknown` to keep this module runtime-agnostic;
+   * CDN cache adapters that know the concrete shape narrow it themselves.
+   */
+  cache?: unknown;
 };
 /**
  * Run `fn` with the given `ExecutionContext` available via
@@ -50,5 +55,4 @@ declare function runWithExecutionContext<T>(ctx: ExecutionContextLike, fn: () =>
  */
 declare function getRequestExecutionContext(): ExecutionContextLike | null;
 //#endregion
-export { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext };
-//# sourceMappingURL=request-context.d.ts.map
+export { ExecutionContextLike, getRequestExecutionContext, runWithExecutionContext };

package/dist/shims/request-context.js

@@ -43,5 +43,3 @@ function getRequestExecutionContext() {
 }
 //#endregion
 export { getRequestExecutionContext, runWithExecutionContext };
-
-//# sourceMappingURL=request-context.js.map

package/dist/shims/request-state-types.d.ts

@@ -9,4 +9,4 @@ import { RouterState, SSRContext } from "./router-state.js";
 import { HeadState } from "./head-state.js";
 import { I18nState } from "./i18n-state.js";
 import { NavigationState } from "./navigation-state.js";
-export { type CacheLifeConfig, type CacheState, type ExecutionContextLike, type FetchCacheState, type HeadState, type HeadersAccessPhase, type HeadersContext, type I18nState, type NavigationContext, type NavigationState, type PrivateCacheState, type RootParamsState, type RouterState, type SSRContext, type VinextHeadersShimState };
+export type { CacheLifeConfig, CacheState, ExecutionContextLike, FetchCacheState, HeadState, HeadersAccessPhase, HeadersContext, I18nState, NavigationContext, NavigationState, PrivateCacheState, RootParamsState, RouterState, SSRContext, VinextHeadersShimState };

package/dist/shims/root-params.d.ts

@@ -9,5 +9,4 @@ declare function getRootParam(name: string): Promise<string | string[] | undefin
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => Promise<T>): Promise<T>;
 declare function runWithRootParamsScope<T>(params: RootParams, fn: () => T | Promise<T>): T | Promise<T>;
 //#endregion
-export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
-//# sourceMappingURL=root-params.d.ts.map
+export { RootParams, RootParamsState, getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };

package/dist/shims/root-params.js

@@ -28,5 +28,3 @@ function runWithRootParamsScope(params, fn) {
 }
 //#endregion
 export { getRootParam, pickRootParams, runWithRootParamsScope, setRootParams };
-
-//# sourceMappingURL=root-params.js.map

package/dist/shims/router-state.d.ts

@@ -28,5 +28,4 @@ type RouterState = {
 declare function runWithRouterState<T>(fn: () => Promise<T>): Promise<T>;
 declare function runWithRouterState<T>(fn: () => T | Promise<T>): T | Promise<T>;
 //#endregion
-export { RouterState, SSRContext, runWithRouterState };
-//# sourceMappingURL=router-state.d.ts.map
+export { RouterState, SSRContext, runWithRouterState };

package/dist/shims/router-state.js

@@ -35,5 +35,3 @@ _registerRouterStateAccessors({
 });
 //#endregion
 export { runWithRouterState };
-
-//# sourceMappingURL=router-state.js.map

package/dist/shims/router.d.ts

@@ -173,5 +173,4 @@ declare const RouterMethods: {
 };
 declare const Router: typeof RouterMethods & Omit<NextRouter, keyof typeof RouterMethods>;
 //#endregion
-export { ExcludeRouterProps, NextRouter, WithRouterProps, _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };
-//# sourceMappingURL=router.d.ts.map
+export { ExcludeRouterProps, NextRouter, WithRouterProps, _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };

package/dist/shims/router.js

@@ -1,7 +1,9 @@
+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";
 import { isUnknownRecord } from "../utils/record.js";
+import { AppRouterContext } from "./internal/app-router-context.js";
 import { RouterContext } from "./internal/router-context.js";
 import { applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson } from "../client/vinext-next-data.js";
 import { isValidModulePath } from "../client/validate-module-path.js";
@@ -9,11 +11,12 @@ import { addLocalePrefix, getDomainLocaleUrl, getLocalePathPrefix } from "../uti
 import { buildPagesDataHref } from "./internal/pages-data-url.js";
 import { prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
 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
@@ -173,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 */
@@ -279,9 +321,6 @@ function extractRouteParamNames(pattern) {
 	for (const m of colonMatches) names.push(m[1]);
 	return names;
 }
-function splitPathSegments(pathname) {
-	return pathname.split("/").filter(Boolean);
-}
 function extractRouteParamsFromPath(pattern, pathname) {
 	return matchRoutePattern(splitPathSegments(pathname), routePatternParts(pattern));
 }
@@ -436,20 +475,36 @@ function getMiddlewarePagesDataFetchUrl(browserUrl) {
 async function resolveMiddlewareDataRedirect(browserUrl, signal) {
 	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl);
 	if (!dataUrl) return null;
+	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
 	try {
-		return (await fetch(dataUrl, {
-			headers: {
-				Accept: "application/json",
-				"x-nextjs-data": "1"
-			},
-			signal
-		})).headers.get("x-nextjs-redirect");
-	} catch (err) {
-		if (err instanceof DOMException && err.name === "AbortError") throw err;
+		return (await dedupedPagesDataFetch(dataUrl, { headers: {
+			Accept: "application/json",
+			"x-nextjs-data": "1"
+		} })).headers.get("x-nextjs-redirect");
+	} catch {
 		return null;
 	}
 }
 /**
+* 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
@@ -462,21 +517,19 @@ 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;
 		return;
 	}
+	if (controller.signal.aborted) throw new NavigationCancelledError(url);
 	let res;
 	try {
-		res = await fetch(target.dataHref, {
-			headers: {
-				Accept: "application/json",
-				"x-nextjs-data": "1"
-			},
-			signal: controller.signal
-		});
+		res = await dedupedPagesDataFetch(target.dataHref, { headers: {
+			Accept: "application/json",
+			"x-nextjs-data": "1"
+		} });
 	} catch (err) {
 		if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(url);
 		throw err;
@@ -500,6 +553,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();
@@ -686,7 +744,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 {
@@ -750,6 +808,11 @@ 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() {
 	window.dispatchEvent(new CustomEvent("vinext:navigate"));
@@ -757,11 +820,37 @@ function dispatchNavigateEvent() {
 /**
 * 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
@@ -809,13 +898,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 });
@@ -825,7 +925,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;
@@ -904,13 +1004,49 @@ function PagesRouterProvider({ children }) {
 		query,
 		asPath
 	]);
-	return createElement(RouterContext.Provider, { value: router }, children);
+	const appRouter = useMemo(() => ({
+		bfcacheId: "0",
+		back() {
+			Router.back();
+		},
+		forward() {
+			if (typeof window === "undefined") throwNoRouterInstance();
+			window.history.forward();
+		},
+		refresh() {
+			Router.reload();
+		},
+		push(href, options) {
+			Router.push(href, void 0, { scroll: options?.scroll });
+		},
+		replace(href, options) {
+			Router.replace(href, void 0, { scroll: options?.scroll });
+		},
+		prefetch(href) {
+			Router.prefetch(href);
+		}
+	}), []);
+	const content = createElement(RouterContext.Provider, { value: router }, children);
+	return AppRouterContext ? createElement(AppRouterContext.Provider, { value: appRouter }, content) : content;
 }
 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({
@@ -928,11 +1064,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();
@@ -1099,5 +1236,3 @@ const _PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNaviga
 globalThis[_PAGES_NAVIGATION_ACCESSOR_KEY] = getPagesNavigationContext;
 //#endregion
 export { _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };
-
-//# sourceMappingURL=router.js.map

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