vinext 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/shims/router.js

@@ -1,27 +1,30 @@
-import { splitPathSegments } from "../routing/utils.js";
-import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { isUnknownRecord } from "../utils/record.js";
 import { parseCookieHeader } from "../utils/parse-cookie.js";
-import { assertSafeNavigationUrl } from "./url-safety.js";
 import { isExternalUrl } from "../utils/external-url.js";
+import { sortRoutes, splitPathSegments } from "../routing/utils.js";
+import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
+import { assertSafeNavigationUrl } from "./url-safety.js";
 import { addLocalePrefix, getDomainLocaleUrl, getLocalePathPrefix } from "../utils/domain-locale.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";
-import { fillRoutePatternSegments, matchRoutePattern, routePatternParts } from "../routing/route-pattern.js";
+import { matchRoutePattern, routePattern, routePatternParts } from "../routing/route-pattern.js";
 import { NEXT_DEPLOYMENT_ID_HEADER, getDeploymentId } from "../utils/deployment-id.js";
 import { dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, getPagesStaticDataCache } from "./internal/pages-data-fetch-dedup.js";
-import { getPagesMiddlewareDataHref, prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
+import { getPagesMiddlewareDataHref, matchesPagesMiddlewarePath, prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
 import { getPagesRouterComponentsMap } from "./internal/pages-router-components.js";
 import { markAppRouteDetectedOnPrefetch } from "./internal/app-route-detection.js";
 import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-route-owner-direct.js";
 import { installWindowNext } from "../client/window-next.js";
-import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
-import { addQueryParam, appendSearchParamsToUrl, mergeRewriteQuery, mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
+import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath } from "./url-utils.js";
+import { addQueryParam, mergeRewriteQuery, mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
 import { scrollToHashTarget } from "./hash-scroll.js";
 import { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState } from "./pages-router-runtime.js";
-import { interpolateDynamicRouteHref } from "./internal/interpolate-as.js";
+import { interpolateDynamicRouteHref, resolveDynamicRouteHref } from "./internal/interpolate-as.js";
+import { formatUrlObject, formatUrlObjectWithValidation } from "./internal/format-url-object.js";
+import { normalizeRouterHref, resolvePagesRouterHref } from "./internal/normalize-router-href.js";
+import { getCurrentRoutePathnameForWarning } from "./internal/route-pattern-for-warning.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
 import { Component, Fragment, StrictMode, createElement, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
@@ -217,36 +220,69 @@ function getPagesRouterRuntimeComponents() {
 	routerRuntimeState.components = components;
 	return components;
 }
-function resolveUrl(url) {
+function resolvePagesUrlPath(formatted) {
+	if (typeof window === "undefined") return formatted;
+	const routePathname = window.__NEXT_DATA__?.page ?? stripBasePath(window.location.pathname, __basePath);
+	const visibleAsPath = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	return resolvePagesRouterHref(formatted, {
+		pathname: routePathname,
+		asPath: formatted.startsWith("#") ? visibleAsPath : routePathname
+	}, __basePath);
+}
+function hasUrlObjectAuthority(url) {
+	return Boolean(url.host || url.hostname || url.slashes);
+}
+function resolveUrl(url, resolveQueryFromRoute = false) {
 	if (typeof url === "string") return url;
-	const query = url.query && typeof url.query === "object" ? url.query : void 0;
-	const hasQuery = query !== void 0 && Object.keys(query).length > 0;
-	const hasSearch = typeof url.search === "string" && url.search.length > 0;
-	const hasHash = typeof url.hash === "string" && url.hash.length > 0;
-	const inheritsVisiblePath = url.pathname === void 0 && (hasQuery || hasSearch || hasHash);
-	let result = url.pathname ?? (typeof window !== "undefined" ? inheritsVisiblePath ? stripBasePath(window.location.pathname, __basePath) : window.__NEXT_DATA__?.page ?? stripBasePath(window.location.pathname, __basePath) : "/");
-	if (hasSearch) {
-		const search = url.search.startsWith("?") ? url.search : `?${url.search}`;
-		const hashIndex = search.indexOf("#");
-		result += hashIndex === -1 ? search : `${search.slice(0, hashIndex)}%23${search.slice(hashIndex + 1)}`;
-	} else if (hasQuery) {
-		const params = urlQueryToSearchParams(query);
-		result = appendSearchParamsToUrl(result, params);
-	} else if (hasHash && typeof window !== "undefined") result += window.location.search;
-	if (hasHash) result += url.hash.startsWith("#") ? url.hash : `#${url.hash}`;
-	return result;
+	const formatted = formatUrlObject(url);
+	if (url.protocol || hasUrlObjectAuthority(url) || url.pathname) return resolvePagesUrlPath(formatted);
+	const visiblePathname = typeof window === "undefined" ? "/" : stripBasePath(window.location.pathname, __basePath);
+	const routePathname = typeof window === "undefined" ? void 0 : window.__NEXT_DATA__?.page;
+	const matchingDynamicRoute = resolveQueryFromRoute && formatted.startsWith("?") && routePathname && extractRouteParamNames(routePathname).length > 0 && extractRouteParamsFromPath(routePathname, removeNavigationLocalePrefix(visiblePathname)) !== null ? routePathname : void 0;
+	return resolvePagesUrlPath((typeof window === "undefined" ? "/" : matchingDynamicRoute ?? (formatted ? visiblePathname : routePathname ?? visiblePathname)) + (formatted.startsWith("#") && typeof window !== "undefined" ? window.location.search : "") + formatted);
+}
+function toPreparedSameOriginPath(url) {
+	const appPath = toSameOriginAppPath(url, __basePath);
+	if (appPath !== null) return appPath;
+	if (!isAbsoluteUrl(url)) return null;
+	const localPath = toSameOriginPath(url);
+	if (localPath === null) return null;
+	const parsed = new URL(url);
+	return parsed.username || parsed.password ? null : localPath;
+}
+/** Next.js only strips a same-origin URL when the origin is a literal prefix. */
+function credentialedSameOriginHref(url) {
+	if (!url) return void 0;
+	const href = resolveUrl(url);
+	try {
+		const parsed = new URL(href, window.location.href);
+		if (!parsed.username && !parsed.password) return void 0;
+	} catch {
+		return;
+	}
+	return toSameOriginPath(href) !== null ? href : void 0;
 }
-/**
-* When `as` is provided, use it as the navigation target. This is a
-* simplification: Next.js keeps `url` and `as` as separate values (url for
-* data fetching, as for the browser URL). We collapse them because vinext's
-* navigateClient() fetches HTML from the target URL, so `as` must be a
-* server-resolvable path. Purely decorative `as` values are not supported.
-* Pages error routes are handled as a narrow exception below because Next.js
-* treats their href as the component route while preserving `as` in history.
-*/
-function resolveNavigationTarget(url, as, locale, replaceExistingLocale = false) {
-	return applyNavigationLocale(as ?? resolveUrl(url), locale, replaceExistingLocale);
+function hasUrlObjectQuery(url) {
+	return typeof url.query === "string" ? url.query.length > 0 : url.query !== null && typeof url.query === "object" && Object.keys(url.query).length > 0;
+}
+function inheritsVisiblePath(url) {
+	return !url.pathname && (hasUrlObjectQuery(url) || typeof url.search === "string" && url.search.length > 0 || typeof url.hash === "string" && url.hash.length > 0);
+}
+function prepareUrl(url) {
+	const routePathname = getCurrentRoutePathnameForWarning();
+	if (typeof url === "string") {
+		const normalized = normalizeRouterHref(url, routePathname);
+		return normalized === url ? url : resolvePagesUrlPath(normalized);
+	}
+	const formatted = formatUrlObjectWithValidation(url);
+	const normalized = normalizeRouterHref(formatted, routePathname);
+	if (normalized === formatted) return url;
+	if (!hasUrlObjectAuthority(url) && (url.protocol || url.pathname)) return resolvePagesUrlPath(normalized);
+	if (!url.pathname && normalized.startsWith("#")) return {
+		...url,
+		hash: normalized
+	};
+	return normalized;
 }
 /**
 * Next.js's internal `_h` replacement receives browser-visible URLs, which may
@@ -266,35 +302,43 @@ function normalizeHydrationNavigationUrl(url) {
 	}
 }
 var HrefInterpolationError = class extends Error {};
-function interpolateCurrentDynamicRoute(resolved) {
-	if (typeof window === "undefined") return resolved;
+function getHrefInterpolationError(href, routePattern, query) {
+	const missingParams = routePatternParts(routePattern).filter((part) => part.startsWith(":") && !part.endsWith("*")).map((part) => part.slice(1, part.endsWith("+") ? -1 : void 0)).filter((paramName) => {
+		const value = query[paramName];
+		return value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
+	});
+	return missingParams.length > 0 ? new HrefInterpolationError(`The provided \`href\` (${href}) value is missing query values (${missingParams.join(", ")}) to be interpolated properly. Read more: https://nextjs.org/docs/messages/href-interpolation-failed`) : null;
+}
+function resolveCurrentDynamicRoute(resolved, displayHref) {
+	if (typeof window === "undefined") return null;
 	const routePattern = window.__NEXT_DATA__?.page;
-	if (!routePattern || extractRouteParamNames(routePattern).length === 0) return resolved;
+	if (!routePattern || extractRouteParamNames(routePattern).length === 0) return null;
 	try {
 		const target = new URL(resolved, "http://vinext.local");
 		const currentOrigin = getWindowOrigin();
-		if (currentOrigin && target.origin !== "http://vinext.local" && target.origin !== currentOrigin) return resolved;
+		if (currentOrigin && target.origin !== "http://vinext.local" && target.origin !== currentOrigin) return null;
 		const visiblePath = stripBasePath(window.location.pathname, __basePath);
 		const visibleLocale = getLocalePathPrefix(visiblePath, window.__VINEXT_LOCALES__);
-		if (extractRouteParamsFromPath(routePattern, visibleLocale ? visiblePath.slice(visibleLocale.length + 1) || "/" : visiblePath) === null) return resolved;
-		const query = parseQueryString(target.search);
-		const missingParams = routePatternParts(routePattern).filter((part) => part.startsWith(":") && !part.endsWith("*")).map((part) => part.slice(1, part.endsWith("+") ? -1 : void 0)).filter((paramName) => {
-			const value = query[paramName];
-			return value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
-		});
-		if (missingParams.length > 0) throw new HrefInterpolationError(`The provided \`href\` (${`${routePattern}${target.search}${target.hash}`}) value is missing query values (${missingParams.join(", ")}) to be interpolated properly. Read more: https://nextjs.org/docs/messages/href-interpolation-failed`);
-		const routeParams = getRouteParamsFromQuery(routePattern, query);
-		if (!routeParams) return resolved;
-		const encodedRouteParams = Object.fromEntries(Object.entries(routeParams).map(([key, value]) => [key, Array.isArray(value) ? value.map(encodeURIComponent) : encodeURIComponent(value)]));
-		const pathname = fillRoutePatternSegments(routePattern, encodedRouteParams);
-		if (!pathname) return resolved;
+		if (extractRouteParamsFromPath(routePattern, visibleLocale ? visiblePath.slice(visibleLocale.length + 1) || "/" : visiblePath) === null) return null;
+		const href = routePattern + target.search + target.hash;
+		if (displayHref !== void 0) return {
+			href,
+			as: interpolateDynamicRouteHref(href, displayHref)?.href || null
+		};
+		const dynamicRoute = resolveDynamicRouteHref(href);
+		if (!dynamicRoute) {
+			const error = getHrefInterpolationError(href, routePattern, parseQueryString(target.search));
+			if (error) throw error;
+			return null;
+		}
 		const targetLocale = getLocalePathPrefix(target.pathname, window.__VINEXT_LOCALES__);
-		target.pathname = targetLocale ? `/${targetLocale}${pathname}` : pathname;
-		for (const paramName of extractRouteParamNames(routePattern)) target.searchParams.delete(paramName);
-		return target.href.slice(target.origin.length);
+		return {
+			href,
+			as: targetLocale ? `/${targetLocale}${dynamicRoute.as}` : dynamicRoute.as
+		};
 	} catch (error) {
 		if (error instanceof HrefInterpolationError) throw error;
-		return resolved;
+		return null;
 	}
 }
 function getCurrentUrlLocale() {
@@ -363,7 +407,11 @@ function getDomainLocalePath(url, locale) {
 */
 function applyNavigationLocale(url, locale, replaceExistingLocale = false) {
 	if (!locale || typeof window === "undefined") return url;
-	if (isAbsoluteOrProtocolRelativeUrl(url)) return url;
+	if (isAbsoluteOrProtocolRelativeUrl(url)) {
+		const localPath = window.location ? toSameOriginAppPath(url, __basePath) : null;
+		if (localPath == null) return url;
+		url = localPath;
+	}
 	if (!replaceExistingLocale && getLocalePathPrefix(url, window.__VINEXT_LOCALES__)) return url;
 	const normalizedUrl = replaceExistingLocale ? removeNavigationLocalePrefix(url) : url;
 	const domainLocalePath = getDomainLocalePath(normalizedUrl, locale);
@@ -416,6 +464,15 @@ function isHashOnlyChange(href) {
 	if (typeof window === "undefined") return false;
 	return isHashOnlyBrowserUrlChange(href, window.location.href, __basePath);
 }
+function toHistoryAppPath(url) {
+	const localUrl = isAbsoluteUrl(url) ? toSameOriginPath(url) ?? url : url;
+	if (!localUrl.startsWith("/") || localUrl.startsWith("//")) return url;
+	if (!__basePath) return localUrl;
+	const suffixIndex = localUrl.search(/[?#]/);
+	const pathname = suffixIndex === -1 ? localUrl : localUrl.slice(0, suffixIndex);
+	if (!hasBasePath(pathname, __basePath)) return localUrl;
+	return stripBasePath(pathname, __basePath) + (suffixIndex === -1 ? "" : localUrl.slice(suffixIndex));
+}
 /**
 * Build router-shaped state for the initial document entry. Captures the
 * active locale (from `window.__VINEXT_LOCALE__`) so a back-navigation
@@ -424,12 +481,18 @@ function isHashOnlyChange(href) {
 * navigates back.
 */
 function buildInitialRouterState() {
-	const appPath = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	const browserPath = window.location.pathname + window.location.search;
+	const nextData = window.__NEXT_DATA__;
+	const middlewareMatches = nextData?.__vinext?.hasMiddleware && matchesPagesMiddlewarePath(stripBasePath(window.location.pathname, __basePath));
+	const routeUrl = normalizePathTrailingSlash(nextData?.page && !middlewareMatches ? withBasePath(formatUrlObject({
+		pathname: nextData.page,
+		query: mergeRouteParamsIntoQuery(parseQueryString(browserPath), nextData.query ?? {})
+	}), __basePath) : browserPath, __trailingSlash);
 	const options = {};
 	if (window.__VINEXT_LOCALE__ !== void 0) options.locale = window.__VINEXT_LOCALE__;
 	return {
-		url: appPath,
-		as: appPath,
+		url: routeUrl,
+		as: browserPath,
 		options,
 		__N: true,
 		key: createHistoryKey()
@@ -437,8 +500,8 @@ function buildInitialRouterState() {
 }
 /**
 * 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.
+* state is present). An early next/router import may precede the generated
+* entry's __NEXT_DATA__ and matcher setup, so the ready transition retries it.
 */
 function stampInitialHistoryState() {
 	installManualScrollRestoration();
@@ -448,6 +511,8 @@ function stampInitialHistoryState() {
 		routerRuntimeState.currentHistoryKey = getRouterStateKey(existingState) ?? routerRuntimeState.currentHistoryKey;
 		return;
 	}
+	const nextData = window.__NEXT_DATA__;
+	if (!nextData || nextData.__vinext?.hasMiddleware && !Object.hasOwn(window, "__VINEXT_MIDDLEWARE_MATCHER__")) return;
 	const initialState = buildInitialRouterState();
 	routerRuntimeState.currentHistoryKey = initialState.key;
 	window.history.replaceState(initialState, "");
@@ -742,12 +807,13 @@ function getCurrentHistoryAsPath() {
 	try {
 		const browserUrl = new URL(window.location.href);
 		const stateLocale = state.options.locale === false ? void 0 : state.options.locale;
-		const localizedStateAs = applyNavigationLocale(state.as, stateLocale);
+		const stateAs = toHistoryAppPath(state.as);
+		const localizedStateAs = applyNavigationLocale(stateAs, stateLocale);
 		const stateUrl = new URL(toBrowserNavigationHref(localizedStateAs, window.location.href, __basePath), window.location.href);
 		if (stateUrl.pathname !== browserUrl.pathname || stateUrl.search !== browserUrl.search) return null;
-		const stateAs = removeNavigationLocalePrefix(stripHash(state.as));
+		const appAs = removeNavigationLocalePrefix(stripHash(stateAs));
 		const visibleAs = `${removeNavigationLocalePrefix(stripBasePath(window.location.pathname, __basePath))}${window.location.search}`;
-		return `${stateAs || visibleAs}${window.location.hash}`;
+		return `${appAs || visibleAs}${window.location.hash}`;
 	} catch {
 		return null;
 	}
@@ -783,6 +849,7 @@ function markPagesRouterReady() {
 }
 function initializePagesRouterReadyFromNextData(nextData, forceReady = false) {
 	if (typeof window === "undefined") return;
+	stampInitialHistoryState();
 	routerRuntimeState.pagesRouterReady = forceReady || getPagesNavigationIsReadyFromSerializedState(nextData.page, window.location.search, nextData);
 }
 function markPagesRouterHydrated() {
@@ -1098,8 +1165,8 @@ async function resolveClientConfigRewrite(href) {
 		kind: "rewrite"
 	} : null;
 }
-function getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget) {
-	const middlewareDataHref = getPagesMiddlewareDataHref(browserUrl, __basePath, dataTarget?.prefetchLocale ? { locale: dataTarget.prefetchLocale } : void 0);
+function getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget, routeUrl = browserUrl) {
+	const middlewareDataHref = getPagesMiddlewareDataHref(browserUrl, __basePath, dataTarget?.prefetchLocale ? { locale: dataTarget.prefetchLocale } : void 0, routeUrl);
 	if (!middlewareDataHref) return null;
 	if (dataTarget?.dataKind === "static" && dataTarget.middlewareDataHref === middlewareDataHref && dataTarget.prefetchDataHref) return dataTarget.prefetchDataHref;
 	return middlewareDataHref;
@@ -1114,8 +1181,8 @@ function getPagesDataCacheHref(dataHref) {
 function shouldEvictMiddlewareDataCache(middlewareEffect, dataTarget) {
 	return middlewareEffect?.redirectLocation != null || dataTarget?.dataKind !== "static";
 }
-async function resolveMiddlewareDataEffect(browserUrl, signal, dataTarget) {
-	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget);
+async function resolveMiddlewareDataEffect(browserUrl, signal, dataTarget, routeUrl = browserUrl) {
+	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget, routeUrl);
 	if (!dataUrl) return null;
 	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
 	try {
@@ -1413,6 +1480,7 @@ async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillC
 		scheduleHardNavigationAndThrow(url, "Navigation failed: missing __NEXT_DATA__ in response");
 	}
 	const nextData = parseVinextNextDataJson(nextDataJson);
+	if (options.routePattern && nextData.page !== options.routePattern) scheduleHardNavigationAndThrow(browserUrl, "Navigation fallback resolved a different page");
 	let nextDataRouteState = options.nextDataRouteState;
 	let isDevelopmentNotFound = false;
 	if (res.status === 404 && options.allowNotFoundResponse !== true && (nextData.page === "/404" || nextData.page === "/_error") && typeof nextData.notFoundSrcPage === "string") {
@@ -1459,6 +1527,19 @@ async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillC
 	assertStillCurrent();
 	const PageComponent = pageModule.default;
 	if (!isPageComponent(PageComponent)) scheduleHardNavigationAndThrow(browserUrl, "Navigation failed: page module default export is not a component");
+	const pageLoaders = window.__VINEXT_PAGE_LOADERS__ ??= {};
+	pageLoaders[nextData.page] ??= () => Promise.resolve(pageModule);
+	const pagePatterns = window.__VINEXT_PAGE_PATTERNS__ ??= [];
+	if (!pagePatterns.includes(nextData.page)) {
+		pagePatterns.push(nextData.page);
+		const sortedPatterns = sortRoutes(pagePatterns.map((pagePattern) => ({
+			pagePattern,
+			pattern: routePattern(pagePattern)
+		})));
+		pagePatterns.splice(0, pagePatterns.length, ...sortedPatterns.map(({ pagePattern }) => pagePattern));
+		_cachedPagesRoutePatternKey = null;
+		_cachedPagesRoutePattern = void 0;
+	}
 	const React = (await import("react")).default;
 	assertStillCurrent();
 	let AppComponent = window.__VINEXT_APP__;
@@ -1524,6 +1605,7 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 		else {
 			let browserUrl = url;
 			let htmlFetchUrl = fetchUrl;
+			const routeMasked = options.routeMasked ?? routeUrl !== url;
 			const configRedirect = hasClientRedirectRules() && clientConfigRedirectCouldMatch(browserUrl) ? await resolveClientConfigRedirect(browserUrl) : null;
 			if (configRedirect) {
 				const redirectedUrl = resolveLocalRedirectUrl(configRedirect);
@@ -1531,30 +1613,37 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 				throw new InternalNavigationRedirect(redirectedUrl);
 			}
 			let routeLookupUrl = routeUrl;
-			if (routeUrl === url && hasClientRewriteRules()) {
+			let routePattern = options.routePattern;
+			if (!routeMasked && hasClientRewriteRules()) {
 				const syncConfigRewrite = hasClientAppRouteManifest() ? void 0 : resolveClientConfigRewriteSync(browserUrl);
 				const configRewrite = syncConfigRewrite === void 0 ? await resolveClientConfigRewrite(browserUrl) : syncConfigRewrite;
 				if (configRewrite?.kind === "document") scheduleHardNavigationAndThrow(browserUrl, "Navigation rewritten to a document route");
 				else if (configRewrite?.kind === "rewrite") {
 					routeLookupUrl = configRewrite.href;
 					htmlFetchUrl = configRewrite.href;
+					routePattern = void 0;
 				}
 			}
-			const pagesDataTargetOptions = { locale: options.locale };
+			const pagesDataTargetOptions = {
+				locale: options.locale,
+				routePattern
+			};
+			const middlewareTargetOptions = { locale: options.locale };
 			let dataTarget = resolvePagesDataNavigationTarget(routeLookupUrl, __basePath, pagesDataTargetOptions);
 			let middlewareDataResponse;
 			let middlewareEffect = null;
 			let middlewareRewrittenTarget;
-			const middlewareProbeDataHref = getMiddlewarePagesDataFetchUrl(browserUrl, dataTarget);
+			const middlewareUrl = routeMasked ? browserUrl : routeUrl;
+			const middlewareProbeDataHref = getMiddlewarePagesDataFetchUrl(middlewareUrl, dataTarget, routeUrl);
 			if (middlewareProbeDataHref !== null) {
 				middlewareDataCacheEvictHref = getPagesDataCacheHref(middlewareProbeDataHref);
 				try {
-					middlewareEffect = await resolveMiddlewareDataEffect(browserUrl, controller.signal, dataTarget);
+					middlewareEffect = await resolveMiddlewareDataEffect(middlewareUrl, controller.signal, dataTarget, routeUrl);
 				} catch (err) {
 					if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(browserUrl);
 					throw err;
 				}
-				if (middlewareEffect?.rewriteTarget) middlewareRewrittenTarget = resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, pagesDataTargetOptions);
+				if (middlewareEffect?.rewriteTarget) middlewareRewrittenTarget = resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, middlewareTargetOptions);
 				if (middlewareEffect) {
 					if (shouldEvictMiddlewareDataCache(middlewareEffect, middlewareRewrittenTarget !== void 0 ? middlewareRewrittenTarget : dataTarget)) middlewareDataCacheEvictHref = middlewareEffect.dataHref;
 					else middlewareDataCacheEvictHref = null;
@@ -1567,14 +1656,14 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 				if (!redirectedUrl) scheduleHardNavigationAndThrow(redirectLocation, "Navigation redirected externally");
 				throw new InternalNavigationRedirect(redirectedUrl);
 			} else if (middlewareEffect) {
-				if (middlewareEffect.rewriteTarget || routeUrl === url) middlewareDataResponse = middlewareEffect.response;
+				if (middlewareEffect.rewriteTarget || !routeMasked) middlewareDataResponse = middlewareEffect.response;
 				if (middlewareEffect.rewriteTarget) {
 					const rewrittenOwner = resolveDirectHybridClientRouteOwner(middlewareEffect.rewriteTarget, __basePath);
 					if (rewrittenOwner === "app" || rewrittenOwner === "document") {
 						options.beforeHistoryChange?.();
 						scheduleHardNavigationAndThrow(browserUrl, "Navigation rewritten to a non-Pages route");
 					}
-					const rewrittenTarget = middlewareRewrittenTarget ?? resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, pagesDataTargetOptions);
+					const rewrittenTarget = middlewareRewrittenTarget ?? resolvePagesDataNavigationTarget(middlewareEffect.rewriteTarget, __basePath, middlewareTargetOptions);
 					if (!rewrittenTarget) {
 						options.beforeHistoryChange?.();
 						scheduleHardNavigationAndThrow(browserUrl, "Navigation rewritten to a non-Pages route");
@@ -1584,9 +1673,13 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 			}
 			if (middlewareEffect && shouldEvictMiddlewareDataCache(middlewareEffect, dataTarget)) middlewareDataCacheEvictHref = middlewareEffect.dataHref;
 			else if (middlewareEffect) middlewareDataCacheEvictHref = null;
+			if (middlewareEffect?.rewriteTarget) routePattern = void 0;
 			if (dataTarget?.dataKind === "static" || dataTarget?.dataKind === "server") await navigateClientData(browserUrl, dataTarget, controller, navId, assertStillCurrent, options, middlewareDataResponse);
 			else if (dataTarget) await navigateClientNoData(browserUrl, dataTarget, controller, assertStillCurrent, options);
-			else await navigateClientHtml(browserUrl, htmlFetchUrl, controller, navId, assertStillCurrent, options);
+			else await navigateClientHtml(browserUrl, htmlFetchUrl, controller, navId, assertStillCurrent, {
+				...options,
+				routePattern
+			});
 		}
 	} finally {
 		if (navId === routerRuntimeState.navigationId) routerRuntimeState.activeAbortController = null;
@@ -1677,7 +1770,7 @@ function dispatchNavigateEvent() {
 * @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.
+*        locale and the Next-compatible basePath-prefixed `as` path.
 */
 function updateHistory(mode, fullUrl, navState) {
 	const previousKey = getRouterStateKey(window.history.state);
@@ -1719,9 +1812,8 @@ function throwNoRouterInstance() {
 /**
 * Shared client-side navigation flow used by both `useRouter()` and the
 * `Router` singleton. The only differences between push/replace are the
-* history method (`pushState` vs `replaceState`), the external-URL fallback
-* (`assign` vs `replace`), and the fact that push saves scroll position for
-* back/forward restoration while replace does not.
+* history method (`pushState` vs `replaceState`) and the fact that push saves
+* scroll position for back/forward restoration while replace does not.
 *
 * `onStateUpdate` lets the hook trigger a `setState` re-render at the same
 * point that hashChangeComplete/routeChangeComplete fires; the singleton
@@ -1729,36 +1821,69 @@ function throwNoRouterInstance() {
 */
 async function performNavigation(url, as, options, mode, onStateUpdate, redirectBrowserHref) {
 	if (typeof window === "undefined") throwNoRouterInstance();
+	const inputHref = resolveUrl(url);
+	const sameOriginPath = isAbsoluteUrl(inputHref) ? toSameOriginPath(inputHref) : null;
+	const origin = getWindowOrigin();
+	const absoluteHistoryUrl = sameOriginPath === null ? void 0 : origin && inputHref.startsWith(origin) ? inputHref.slice(origin.length) : sameOriginPath;
+	const currentRoute = window.__NEXT_DATA__?.page ?? stripBasePath(window.location.pathname, __basePath);
+	const currentAs = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	const preparedHistoryHref = (isAbsoluteUrl(inputHref) ? toSameOriginAppPath(inputHref, __basePath) : null) ?? absoluteHistoryUrl ?? resolvePagesRouterHref(inputHref, {
+		pathname: currentRoute,
+		asPath: currentAs
+	}, __basePath);
+	const isQueryOnlyString = typeof url === "string" && url.startsWith("?");
+	const urlInheritsCurrentPath = typeof url === "string" && (isQueryOnlyString || options?._vinextInterpolateDynamicRoute === true) || typeof url !== "string" && !url.pathname && (hasUrlObjectQuery(url) || typeof url.search === "string" && url.search.length > 0);
+	const replaceInheritedLocale = options?.locale !== void 0 && (!as ? urlInheritsCurrentPath || typeof url !== "string" && inheritsVisiblePath(url) : typeof as !== "string" && inheritsVisiblePath(as));
+	const credentialedHistoryHref = credentialedSameOriginHref(url);
+	const credentialedDisplayHref = credentialedSameOriginHref(as) ?? (!as ? credentialedHistoryHref : void 0);
+	as = as ? resolveUrl(as, true) : void 0;
 	assertSafeNavigationUrl(resolveUrl(url));
-	if (as !== void 0) assertSafeNavigationUrl(String(as));
+	if (as !== void 0) assertSafeNavigationUrl(as);
 	const isHydrationQueryUpdate = options?._h === 1;
 	const navigationLocale = resolveTransitionLocale(options?.locale);
-	const replaceInheritedLocale = as === void 0 && options?.locale !== void 0 && typeof url !== "string" && url.pathname === void 0 && (url.query !== null && typeof url.query === "object" && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0 || typeof url.hash === "string" && url.hash.length > 0);
-	let resolved = isHydrationQueryUpdate ? normalizeHydrationNavigationUrl(as ?? resolveUrl(url)) : resolveNavigationTarget(url, as, navigationLocale, replaceInheritedLocale);
-	let resolvedRoute = isHydrationQueryUpdate ? normalizeHydrationNavigationUrl(resolveUrl(url)) : applyNavigationLocale(resolveUrl(url), navigationLocale, replaceInheritedLocale);
-	if (as === void 0 && (typeof url === "string" && options?._vinextInterpolateDynamicRoute === true || typeof url !== "string" && url.pathname === void 0 && (url.query !== null && typeof url.query === "object" && Object.keys(url.query).length > 0 || typeof url.search === "string" && url.search.length > 0))) {
-		resolved = interpolateCurrentDynamicRoute(resolved);
-		resolvedRoute = interpolateCurrentDynamicRoute(resolvedRoute);
+	const unlocalizedRouteHref = resolveUrl(isQueryOnlyString ? `${stripBasePath(window.location.pathname, __basePath)}${url}` : url);
+	const localRouteHref = isExternalUrl(unlocalizedRouteHref) ? toSameOriginAppPath(unlocalizedRouteHref, __basePath) : unlocalizedRouteHref;
+	const implicitDynamicRoute = !isHydrationQueryUpdate && as === void 0 && localRouteHref !== null ? resolveDynamicRouteHref(localRouteHref) : null;
+	const routeForNavigation = implicitDynamicRoute?.as ?? unlocalizedRouteHref;
+	let resolved = isHydrationQueryUpdate ? normalizeHydrationNavigationUrl(as ?? resolveUrl(url)) : applyNavigationLocale(as ?? resolveUrl(routeForNavigation), navigationLocale, replaceInheritedLocale);
+	let resolvedRoute = isHydrationQueryUpdate ? normalizeHydrationNavigationUrl(resolveUrl(url)) : applyNavigationLocale(routeForNavigation, navigationLocale, replaceInheritedLocale);
+	let routeIdentityHref = implicitDynamicRoute ? removeNavigationLocalePrefix(implicitDynamicRoute.href) : void 0;
+	if (urlInheritsCurrentPath) {
+		const internalDynamicRoute = resolveCurrentDynamicRoute(unlocalizedRouteHref, as);
+		if (internalDynamicRoute) {
+			if (internalDynamicRoute.as) {
+				const localizedRoute = applyNavigationLocale(internalDynamicRoute.as, navigationLocale, replaceInheritedLocale);
+				if (as === void 0) resolved = localizedRoute;
+				resolvedRoute = localizedRoute;
+			} else resolvedRoute = internalDynamicRoute.href;
+			routeIdentityHref = internalDynamicRoute.href;
+		}
+	}
+	if (isExternalUrl(resolvedRoute)) {
+		const localPath = toPreparedSameOriginPath(resolvedRoute);
+		if (localPath == null) {
+			window.location.href = resolvedRoute;
+			return false;
+		}
+		resolvedRoute = localPath;
 	}
 	if (isExternalUrl(resolved)) {
-		const localPath = toSameOriginAppPath(resolved, __basePath);
+		const localPath = toPreparedSameOriginPath(resolved);
 		if (localPath == null) {
-			if (mode === "push") window.location.assign(resolved);
-			else window.location.replace(resolved);
-			return true;
+			if (process.env.NODE_ENV !== "production") throw new Error(`Invalid href: "${toBrowserNavigationHref(resolvedRoute, window.location.href, __basePath)}" and as: "${resolved}", received relative href and external as
+See more info: https://nextjs.org/docs/messages/invalid-relative-url-external-as`);
+			window.location.href = resolved;
+			return false;
 		}
 		resolved = localPath;
 	}
-	if (isExternalUrl(resolvedRoute)) {
-		const localPath = toSameOriginAppPath(resolvedRoute, __basePath);
-		if (localPath != null) resolvedRoute = localPath;
-	}
 	resolved = normalizePathTrailingSlash(resolved, __trailingSlash);
 	resolvedRoute = normalizePathTrailingSlash(resolvedRoute, __trailingSlash);
 	let interpolatedRoute = resolvedRoute;
 	if (resolvedRoute.includes("[")) {
-		const projection = interpolateDynamicRouteHref(resolvedRoute, resolved, typeof url === "string" || !url.query || typeof url.query === "string" ? void 0 : url.query);
+		const projection = interpolateDynamicRouteHref(resolvedRoute, resolved, typeof url === "string" || url.search || !url.query || typeof url.query === "string" ? void 0 : url.query);
 		if (projection?.href) {
+			routeIdentityHref ??= removeNavigationLocalePrefix(resolvedRoute);
 			interpolatedRoute = projection.href;
 			if (as === void 0 && stripHash(resolved).split("?", 1)[0] === projection.routePathname) {
 				const remaining = new URLSearchParams();
@@ -1774,16 +1899,14 @@ async function performNavigation(url, as, options, mode, onStateUpdate, redirect
 				resolved = normalizePathTrailingSlash(`${projection.href.split(/[?#]/, 1)[0]}${searchStr ? `?${searchStr}` : ""}${hashStr}`, __trailingSlash);
 			}
 		} else {
-			const missingParams = projection ? routePatternParts(projection.routePathname).filter((part) => part.startsWith(":") && !part.endsWith("*")).map((part) => part.slice(1, part.endsWith("+") ? -1 : void 0)).filter((paramName) => {
-				const value = projection.query[paramName];
-				return value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
-			}) : [];
-			const hasExplicitHrefPathname = typeof url === "string" || url.pathname !== void 0;
+			const hrefInterpolationError = projection ? getHrefInterpolationError(resolvedRoute, projection.routePathname, projection.query) : null;
+			const hasExplicitHrefPathname = typeof url === "string" || !urlInheritsCurrentPath;
 			const isMiddlewareMatch = options?.shallow !== true && getPagesMiddlewareDataHref(resolved, __basePath, { locale: navigationLocale }) !== null;
-			if (missingParams.length > 0 && hasExplicitHrefPathname && !isMiddlewareMatch) {
+			if (hrefInterpolationError && hasExplicitHrefPathname && !isMiddlewareMatch) {
 				const asPathname = stripHash(resolved).split("?", 1)[0];
 				const routePathname = projection?.routePathname ?? stripHash(resolvedRoute).split("?", 1)[0];
-				throw new HrefInterpolationError(asPathname === routePathname ? `The provided \`href\` (${resolvedRoute}) value is missing query values (${missingParams.join(", ")}) to be interpolated properly. Read more: https://nextjs.org/docs/messages/href-interpolation-failed` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${routePathname}). Read more: https://nextjs.org/docs/messages/incompatible-href-as`);
+				if (asPathname === routePathname) throw hrefInterpolationError;
+				throw new HrefInterpolationError(`The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${routePathname}). Read more: https://nextjs.org/docs/messages/incompatible-href-as`);
 			}
 			interpolatedRoute = resolved;
 		}
@@ -1795,50 +1918,59 @@ async function performNavigation(url, as, options, mode, onStateUpdate, redirect
 		if (parsed.origin === getWindowOrigin()) browserEventUrl = parsed.pathname + parsed.search + parsed.hash;
 	} catch {}
 	const fullRouteUrl = interpolatedRoute !== resolved ? normalizePathTrailingSlash(toBrowserNavigationHref(interpolatedRoute, window.location.href, __basePath), __trailingSlash) : full;
+	if (routeIdentityHref && !routeIdentityHref.startsWith("/") && !isAbsoluteUrl(routeIdentityHref)) routeIdentityHref = resolvePagesRouterHref(routeIdentityHref, {
+		pathname: currentRoute,
+		asPath: currentAs
+	}, __basePath);
+	const routeFetchUrl = routeIdentityHref ? replaceUrlPathname(routeIdentityHref, new URL(fullRouteUrl, window.location.href).pathname) : void 0;
 	const errorRouteHtmlFetchUrl = resolvePagesErrorHtmlFetchUrl(url, navigationLocale);
-	const htmlFetchUrl = errorRouteHtmlFetchUrl ?? getPagesHtmlFetchUrl(fullRouteUrl, navigationLocale);
+	const htmlFetchUrl = errorRouteHtmlFetchUrl ?? getPagesHtmlFetchUrl(routeFetchUrl ?? fullRouteUrl, navigationLocale);
 	const shallow = options?.shallow ?? false;
 	const doScroll = options?.scroll !== false;
 	const hash = extractHash(resolved);
-	const scrollTarget = doScroll ? {
-		x: 0,
-		y: 0
-	} : null;
-	const navigateOptions = errorRouteHtmlFetchUrl ? {
-		allowNotFoundResponse: true,
-		locale: navigationLocale,
-		mode,
-		scroll: scrollTarget,
-		isHydrationQueryUpdate: options?._h === 1
-	} : {
+	const navigateOptions = {
+		allowNotFoundResponse: errorRouteHtmlFetchUrl !== null,
 		locale: navigationLocale,
 		mode,
-		scroll: scrollTarget,
+		scroll: doScroll ? {
+			x: 0,
+			y: 0
+		} : null,
 		isHydrationQueryUpdate: options?._h === 1
 	};
 	if (redirectBrowserHref !== void 0) navigateOptions.redirectBrowserHref = redirectBrowserHref;
-	const currentLocale = getCurrentUrlLocale();
-	if (mode === "push" && interpolatedRoute !== resolved && stripHash(full) === routerRuntimeState.lastPathnameAndSearch && navigationLocale === currentLocale) mode = "replace";
+	navigateOptions.routeMasked = as !== void 0 && stripHash(interpolatedRoute).split("?", 1)[0] !== stripHash(resolved).split("?", 1)[0];
+	if (routeIdentityHref) navigateOptions.routePattern = removeTrailingSlash(stripHash(routeIdentityHref).split("?", 1)[0]);
+	const isHashOnlyNavigation = options?._h !== 1 && isHashOnlyChange(full);
 	const navStateOptions = { shallow };
 	if (navigationLocale !== void 0) navStateOptions.locale = navigationLocale;
-	const resolvedNoHash = stripHash(resolved);
+	const currentAppUrl = stripBasePath(window.location.pathname, __basePath) + window.location.search;
+	const historyRouteUrl = routeIdentityHref ?? (redirectBrowserHref === void 0 ? preparedHistoryHref : interpolatedRoute);
+	const absoluteInputHistoryUrl = redirectBrowserHref === void 0 && absoluteHistoryUrl !== void 0 && (__basePath === "" || !hasBasePath(new URL(absoluteHistoryUrl, window.location.href).pathname, __basePath)) ? absoluteHistoryUrl : void 0;
+	const historyUrl = historyRouteUrl.startsWith("#") ? currentAppUrl + historyRouteUrl : historyRouteUrl;
+	const preparedHistoryAs = resolved.startsWith("#") ? currentAppUrl + resolved : redirectBrowserHref !== void 0 || resolved.startsWith("//") ? resolved : resolvePagesRouterHref(resolved, {
+		pathname: currentRoute,
+		asPath: currentAs
+	}, __basePath);
 	const navState = {
-		url: stripHash(interpolatedRoute),
-		as: resolvedNoHash,
+		url: credentialedHistoryHref ?? normalizePathTrailingSlash(absoluteInputHistoryUrl === void 0 ? withBasePath(historyUrl, __basePath) : historyUrl, __trailingSlash),
+		as: credentialedDisplayHref ?? normalizePathTrailingSlash(withBasePath(preparedHistoryAs, __basePath), __trailingSlash),
 		options: navStateOptions
 	};
 	if (options?._h !== 1) cancelActiveNavigationEvent({ shallow });
-	if (options?._h !== 1 && interpolatedRoute === resolved && isHashOnlyChange(full)) {
+	if (isHashOnlyNavigation) {
 		if (mode === "push") saveScrollPosition();
 		const eventUrl = resolveHashUrl(browserEventUrl);
 		routerEvents.emit("hashChangeStart", eventUrl, { shallow });
-		updateHistory(mode, resolved.startsWith("#") ? resolved : redirectBrowserHref ?? full, navState);
+		updateHistory(mode, resolved.startsWith("#") ? resolved : redirectBrowserHref ?? credentialedDisplayHref ?? full, navState);
 		if (doScroll) scrollToHashTarget(extractHash(resolved));
 		onStateUpdate?.();
 		routerEvents.emit("hashChangeComplete", eventUrl, { shallow });
 		dispatchNavigateEvent();
 		return true;
 	}
+	const currentLocale = getCurrentUrlLocale();
+	if (mode === "push" && interpolatedRoute !== resolved && stripHash(full) === routerRuntimeState.lastPathnameAndSearch && navigationLocale === currentLocale) mode = "replace";
 	const appPath = getLocalPathname(resolved);
 	const appPathNorm = appPath !== null ? removeTrailingSlash(appPath) : null;
 	const appPathEntry = appPathNorm !== null ? getPagesRouterComponentsMap()[appPathNorm] : void 0;
@@ -1867,12 +1999,12 @@ async function performNavigation(url, as, options, mode, onStateUpdate, redirect
 		if (beforeHistoryChangeEmitted) return;
 		beforeHistoryChangeEmitted = true;
 		routerEvents.emit("beforeHistoryChange", browserEventUrl, { shallow });
-		updateHistory(mode, redirectBrowserHref ?? full, navState);
+		updateHistory(mode, redirectBrowserHref ?? credentialedDisplayHref ?? full, navState);
 	};
 	if (!shallow) {
 		if (reusesMountedConfigRewritePage(full)) emitBeforeHistoryChange();
 		navigateOptions.beforeHistoryChange = emitBeforeHistoryChange;
-		const result = await runNavigateClient(full, browserEventUrl, redirectBrowserHref ?? htmlFetchUrl, navigateOptions, fullRouteUrl, eventContext);
+		const result = await runNavigateClient(full, browserEventUrl, redirectBrowserHref ?? htmlFetchUrl, navigateOptions, routeFetchUrl ?? fullRouteUrl, eventContext);
 		if (typeof result === "object") {
 			if (eventContext) clearActiveNavigationEvent(eventContext);
 			return performNavigation(result.redirectDestination, void 0, {
@@ -1921,7 +2053,7 @@ async function prefetchUrl(url, as) {
 	const displayUrl = as ?? url;
 	const dataTarget = resolvePagesDataNavigationTarget(url, __basePath);
 	if (dataTarget) {
-		const middlewareDataHref = displayUrl === url ? dataTarget.middlewareDataHref : getPagesMiddlewareDataHref(displayUrl, __basePath) ?? void 0;
+		const middlewareDataHref = displayUrl === url ? dataTarget.middlewareDataHref : getPagesMiddlewareDataHref(displayUrl, __basePath, {}, url) ?? void 0;
 		prefetchPagesData({
 			...dataTarget,
 			middlewareDataHref
@@ -2027,7 +2159,8 @@ function handlePagesRouterPopState(e) {
 	if (state !== null && state !== void 0 && !isNextRouterState(state)) return;
 	if (wasFirst && !routerRuntimeState.routerDidNavigate && isNextRouterState(state)) {
 		const currentLocale = window.__VINEXT_LOCALE__;
-		if (state.options?.locale === currentLocale && typeof state.as === "string" && state.as === getTrackedPagesRouterAsPath()) return;
+		const stateAs = typeof state.as === "string" ? removeNavigationLocalePrefix(stripHash(toHistoryAppPath(state.as))) : void 0;
+		if (state.options?.locale === currentLocale && stateAs === getTrackedPagesRouterAsPath()) return;
 	}
 	const currentHash = window.location.hash;
 	const isHashOnly = browserUrl === routerRuntimeState.lastPathnameAndSearch && (currentHash !== routerRuntimeState.lastHash || currentHash !== "");
@@ -2085,14 +2218,28 @@ function handlePagesRouterPopState(e) {
 			x: 0,
 			y: 0
 		} : readScrollPosition(state);
-		const stateRouteUrl = (() => {
-			if (isNextRouterState(state) && typeof state.url === "string" && typeof state.as === "string" && state.url !== state.as) return normalizePathTrailingSlash(withBasePath(state.url, __basePath), __trailingSlash);
-			return browserUrl;
-		})();
-		const result = await runNavigateClient(browserUrl, fullEventUrl, getPagesHtmlFetchUrl(stateRouteUrl, effectiveLocale), {
+		let stateFetchUrl = browserUrl;
+		let routePattern;
+		let routeMasked = false;
+		if (isNextRouterState(state) && typeof state.url === "string" && typeof state.as === "string" && stripHash(state.url) !== stripHash(state.as)) {
+			const stateUrl = toHistoryAppPath(state.url);
+			const stateAs = toHistoryAppPath(state.as);
+			const dynamicRoute = interpolateDynamicRouteHref(stateUrl, removeNavigationLocalePrefix(stateAs));
+			const concreteRouteUrl = dynamicRoute?.href || stateUrl;
+			const fetchRouteUrl = applyNavigationLocale(concreteRouteUrl, effectiveLocale);
+			stateFetchUrl = normalizePathTrailingSlash(withBasePath(fetchRouteUrl, __basePath), __trailingSlash);
+			if (dynamicRoute?.href) routePattern = removeTrailingSlash(stripHash(removeNavigationLocalePrefix(stateUrl)).split("?", 1)[0]);
+			const routePathname = getLocalPathname(concreteRouteUrl);
+			const displayPathname = getLocalPathname(stateAs);
+			routeMasked = routePathname === null || displayPathname === null || removeNavigationLocalePrefix(routePathname) !== removeNavigationLocalePrefix(displayPathname);
+		}
+		const result = await runNavigateClient(browserUrl, fullEventUrl, getPagesHtmlFetchUrl(stateFetchUrl, effectiveLocale), {
+			locale: effectiveLocale,
+			routePattern,
+			routeMasked,
 			scroll: scrollTarget,
 			beforeHistoryChange: emitBeforeHistoryChange
-		}, stateRouteUrl, eventContext);
+		}, stateFetchUrl, eventContext);
 		if (typeof result === "object") {
 			clearActiveNavigationEvent(eventContext);
 			await performNavigation(result.redirectDestination, void 0, { locale: false }, "replace", void 0, isAbsoluteOrProtocolRelativeUrl(result.redirectDestination) ? result.redirectDestination : void 0);
@@ -2165,6 +2312,33 @@ function withRouter(ComposedComponent) {
 	if (process.env.NODE_ENV !== "production") WithRouterWrapper.displayName = `withRouter(${composed.displayName || composed.name || "Unknown"})`;
 	return WithRouterWrapper;
 }
+/**
+* Pages Router `components` map exposed on the singleton.
+*
+* In Next.js, `Router.components` doubles as (a) the cached `PrivateRouteInfo`
+* keyed by route pattern after a real page render, and (b) a marker store
+* (`{ __appRouter: true }`) for App Router routes detected via prefetch (see
+* `packages/next/src/shared/lib/router/router.ts:2525`). The Next.js deploy
+* test suite asserts the latter through `window.next.router.components`.
+*
+* vinext only writes the marker variant — the cached-page-info side is handled
+* by Vite's module graph + our own loader manifest — but the property must be
+* present and mutable so the deploy assertion can find it. The map lives
+* behind a `Symbol.for` global so the Link shim's Pages-mode prefetch branch
+* writes to the same instance even when Vite resolves the router shim and
+* the link shim through different module IDs.
+*
+* Issue: https://github.com/cloudflare/vinext/issues/1526
+*/
+const _components = getPagesRouterComponentsMap();
+function navigatePagesRouter(url, as, options, mode) {
+	if (typeof window === "undefined") throwNoRouterInstance();
+	const preparedUrl = prepareUrl(url);
+	const preparedAs = as ? prepareUrl(as) : void 0;
+	assertSafeNavigationUrl(resolveUrl(preparedUrl));
+	if (preparedAs) assertSafeNavigationUrl(resolveUrl(preparedAs));
+	return performNavigation(preparedUrl, preparedAs, options, mode);
+}
 const RouterMethods = {
 	router: null,
 	readyCallbacks: [],
@@ -2172,20 +2346,10 @@ const RouterMethods = {
 		callback();
 	},
 	/** See `_components` comment above for the dual role this map plays. */
-	components: getPagesRouterComponentsMap(),
+	components: _components,
 	sdc: getPagesStaticDataCache(),
-	push: (url, as, options) => {
-		if (typeof window === "undefined") throwNoRouterInstance();
-		assertSafeNavigationUrl(resolveUrl(url));
-		if (as !== void 0) assertSafeNavigationUrl(String(as));
-		return performNavigation(url, as, options, "push");
-	},
-	replace: (url, as, options) => {
-		if (typeof window === "undefined") throwNoRouterInstance();
-		assertSafeNavigationUrl(resolveUrl(url));
-		if (as !== void 0) assertSafeNavigationUrl(String(as));
-		return performNavigation(url, as, options, "replace");
-	},
+	push: (url, as, options) => navigatePagesRouter(url, as, options, "push"),
+	replace: (url, as, options) => navigatePagesRouter(url, as, options, "replace"),
 	back: () => {
 		if (typeof window === "undefined") throwNoRouterInstance();
 		window.history.back();