vinext 0.0.51 → 0.0.53

package/dist/shims/router.js

@@ -1,13 +1,19 @@
 import { stripBasePath } from "../utils/base-path.js";
+import { assertSafeNavigationUrl } from "./url-safety.js";
+import { addQueryParam, appendSearchParamsToUrl, mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { matchRoutePattern, routePatternParts } from "../routing/route-pattern.js";
+import { isUnknownRecord } from "../utils/record.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 { addLocalePrefix, getDomainLocaleUrl, getLocalePathPrefix } from "../utils/domain-locale.js";
+import { buildPagesDataHref } from "./internal/pages-data-url.js";
+import { prefetchPagesData, resolvePagesDataNavigationTarget } from "./internal/pages-data-target.js";
 import { installWindowNext } from "../client/window-next.js";
-import { isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
-import { addLocalePrefix, getDomainLocaleUrl } from "../utils/domain-locale.js";
-import { addQueryParam, appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.js";
+import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
 import { scrollToHashTarget } from "./hash-scroll.js";
 import { setPagesRouterPopStateHandler } from "./pages-router-runtime.js";
+import { getCurrentBrowserLocale } from "./client-locale.js";
 import { createElement, useContext, useEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
 /**
@@ -19,6 +25,8 @@ import { createElement, useContext, useEffect, useMemo, useState } from "react";
 */
 /** basePath from next.config.js, injected by the plugin at build time */
 const __basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+/** trailingSlash from next.config.js, injected by the plugin at build time */
+const __trailingSlash = process.env.__VINEXT_TRAILING_SLASH === "true";
 function createRouterEvents() {
 	const listeners = /* @__PURE__ */ new Map();
 	return {
@@ -50,10 +58,58 @@ function resolveUrl(url) {
 * 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) {
 	return applyNavigationLocale(as ?? resolveUrl(url), locale);
 }
+function getCurrentUrlLocale() {
+	return getCurrentBrowserLocale({
+		basePath: __basePath,
+		domainLocales: getDomainLocales(),
+		hostname: getCurrentHostname()
+	});
+}
+function getLocalPathname(url) {
+	if (typeof window === "undefined") return null;
+	if (isAbsoluteOrProtocolRelativeUrl(url)) {
+		const localPath = toSameOriginAppPath(url, __basePath);
+		if (localPath == null) return null;
+		return stripBasePath(new URL(localPath, window.location.href).pathname, __basePath);
+	}
+	try {
+		return stripBasePath(new URL(url, window.location.href).pathname, __basePath);
+	} catch {
+		return null;
+	}
+}
+function resolvePagesErrorHtmlFetchUrl(url, locale) {
+	const href = resolveUrl(url);
+	const errorRoutePathname = getLocalPathname(href);
+	if (errorRoutePathname !== "/404" && errorRoutePathname !== "/_error") return null;
+	const resolvedUrl = applyNavigationLocale(errorRoutePathname === "/_error" ? replaceUrlPathname(href, "/404") : href, locale);
+	let parsed;
+	try {
+		parsed = new URL(resolvedUrl, window.location.href);
+	} catch {
+		return null;
+	}
+	return normalizePathTrailingSlash(toBrowserNavigationHref(`${stripBasePath(parsed.pathname, __basePath)}${parsed.search}${parsed.hash}`, window.location.href, __basePath), __trailingSlash);
+}
+function replaceUrlPathname(url, pathname) {
+	try {
+		const parsed = new URL(url, window.location.href);
+		return `${pathname}${parsed.search}${parsed.hash}`;
+	} catch {
+		return pathname;
+	}
+}
+function resolveTransitionLocale(locale) {
+	if (typeof window === "undefined") return void 0;
+	if (locale === false) return window.__VINEXT_DEFAULT_LOCALE__;
+	return locale ?? getCurrentUrlLocale();
+}
 function getDomainLocales() {
 	return window.__NEXT_DATA__?.domainLocales;
 }
@@ -74,10 +130,27 @@ function getDomainLocalePath(url, locale) {
 function applyNavigationLocale(url, locale) {
 	if (!locale || typeof window === "undefined") return url;
 	if (isAbsoluteOrProtocolRelativeUrl(url)) return url;
+	if (getLocalePathPrefix(url, window.__VINEXT_LOCALES__)) return url;
 	const domainLocalePath = getDomainLocalePath(url, locale);
 	if (domainLocalePath) return domainLocalePath;
 	return addLocalePrefix(url, locale, window.__VINEXT_DEFAULT_LOCALE__ ?? "");
 }
+function isDefaultLocaleRootNavigation(url, locale) {
+	if (typeof window === "undefined") return false;
+	if (!locale || locale !== window.__VINEXT_DEFAULT_LOCALE__) return false;
+	let parsed;
+	try {
+		parsed = new URL(url, window.location.href);
+	} catch {
+		return false;
+	}
+	return stripBasePath(parsed.pathname, __basePath) === "/";
+}
+function getPagesHtmlFetchUrl(browserUrl, locale) {
+	if (!isDefaultLocaleRootNavigation(browserUrl, locale)) return browserUrl;
+	const parsed = new URL(browserUrl, window.location.href);
+	return normalizePathTrailingSlash(toBrowserNavigationHref(`${normalizePathTrailingSlash(`/${locale}`, __trailingSlash)}${parsed.search}${parsed.hash}`, window.location.href, __basePath), __trailingSlash);
+}
 /** Check if a URL is external (any URL scheme per RFC 3986, or protocol-relative) */
 function isExternalUrl(url) {
 	return isAbsoluteOrProtocolRelativeUrl(url);
@@ -295,21 +368,286 @@ function scheduleHardNavigationAndThrow(url, message) {
 	window.location.href = url;
 	throw new HardNavigationScheduledError(message);
 }
+function isPageComponent(value) {
+	if (typeof value === "function") return true;
+	if (!isUnknownRecord(value)) return false;
+	return value.$$typeof === Symbol.for("react.forward_ref") || value.$$typeof === Symbol.for("react.memo");
+}
+function isAppComponent(value) {
+	return isPageComponent(value);
+}
+function resolveSameOriginRedirectedUrl(responseUrl) {
+	const appPath = toSameOriginAppPath(responseUrl, __basePath);
+	if (appPath === null) return null;
+	return normalizePathTrailingSlash(toBrowserNavigationHref(appPath, window.location.href, __basePath), __trailingSlash);
+}
+function stripLocalePrefixForApiRedirect(appPath) {
+	const locales = window.__VINEXT_LOCALES__;
+	if (!locales || locales.length === 0) return appPath;
+	try {
+		const parsed = new URL(appPath, "http://vinext.local");
+		const pathname = stripBasePath(parsed.pathname, __basePath);
+		const firstSegment = pathname.split("/")[1];
+		if (!firstSegment || !locales.includes(firstSegment)) return appPath;
+		const withoutLocale = pathname.slice(firstSegment.length + 1) || "/";
+		if (withoutLocale !== "/api" && !withoutLocale.startsWith("/api/")) return appPath;
+		return `${withoutLocale}${parsed.search}${parsed.hash}`;
+	} catch {
+		return appPath;
+	}
+}
+function resolveLocalRedirectUrl(location) {
+	let appPath;
+	if (location.startsWith("/") && !location.startsWith("//")) try {
+		const parsed = new URL(location, "http://vinext.local");
+		appPath = stripBasePath(parsed.pathname, __basePath) + parsed.search + parsed.hash;
+	} catch {
+		appPath = location;
+	}
+	else appPath = toSameOriginAppPath(location, __basePath);
+	if (appPath === null) return null;
+	return normalizePathTrailingSlash(toBrowserNavigationHref(stripLocalePrefixForApiRedirect(appPath), window.location.href, __basePath), __trailingSlash);
+}
+function hasVinextMiddleware(nextData) {
+	if (!isUnknownRecord(nextData)) return false;
+	const vinext = nextData.__vinext;
+	return isUnknownRecord(vinext) && vinext.hasMiddleware === true;
+}
+function getMiddlewarePagesDataFetchUrl(browserUrl) {
+	const nextData = window.__NEXT_DATA__;
+	if (!nextData || !hasVinextMiddleware(nextData)) return null;
+	const buildId = nextData.buildId;
+	if (typeof buildId !== "string" || buildId.length === 0) return null;
+	let parsed;
+	try {
+		parsed = new URL(browserUrl, window.location.href);
+	} catch {
+		return null;
+	}
+	if (parsed.origin !== getWindowOrigin()) return null;
+	return buildPagesDataHref(__basePath, buildId, stripBasePath(parsed.pathname, __basePath), parsed.search);
+}
+async function resolveMiddlewareDataRedirect(browserUrl, signal) {
+	const dataUrl = getMiddlewarePagesDataFetchUrl(browserUrl);
+	if (!dataUrl) return null;
+	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 null;
+	}
+}
+/**
+* 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
+* HTML extraction path (`navigateClientHtml`) when this returns `null`.
+*
+* Failure modes (404, 5xx, network, parse, missing loader, soft redirect)
+* all queue a hard navigation and throw `HardNavigationScheduledError`,
+* mirroring the existing HTML-path failure protocol. The hard reload is
+* the deploy-skew safety net: when the server's buildId has rotated, the
+* 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) {
+	const root = window.__VINEXT_ROOT__;
+	if (!root) {
+		window.location.href = url;
+		return;
+	}
+	let res;
+	try {
+		res = await fetch(target.dataHref, {
+			headers: {
+				Accept: "application/json",
+				"x-nextjs-data": "1"
+			},
+			signal: controller.signal
+		});
+	} catch (err) {
+		if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(url);
+		throw err;
+	}
+	assertStillCurrent();
+	const softRedirect = res.headers.get("x-nextjs-redirect");
+	if (softRedirect) {
+		const redirectedUrl = resolveLocalRedirectUrl(softRedirect);
+		if (!redirectedUrl) scheduleHardNavigationAndThrow(softRedirect, "Navigation redirected externally");
+		window.history.replaceState(window.history.state ?? {}, "", redirectedUrl);
+		_lastPathnameAndSearch = window.location.pathname + window.location.search;
+		await navigateClientHtml(redirectedUrl, redirectedUrl, controller, navId, assertStillCurrent);
+		return;
+	}
+	if (!res.ok) scheduleHardNavigationAndThrow(url, `Data navigation failed: ${res.status} ${res.statusText}`);
+	let body;
+	try {
+		body = await res.json();
+	} catch {
+		scheduleHardNavigationAndThrow(url, "Data navigation failed: invalid JSON response");
+	}
+	assertStillCurrent();
+	const pageProps = body.pageProps && typeof body.pageProps === "object" ? body.pageProps : {};
+	let pageModule;
+	try {
+		pageModule = await target.loader();
+	} catch (err) {
+		console.error("[vinext] Page loader threw during navigation:", err);
+		scheduleHardNavigationAndThrow(url, "Data navigation failed: page loader threw");
+	}
+	assertStillCurrent();
+	const PageComponent = pageModule.default;
+	if (!isPageComponent(PageComponent)) scheduleHardNavigationAndThrow(url, "Data navigation failed: page module default export is not a component");
+	let AppComponent = window.__VINEXT_APP__;
+	if (!AppComponent && typeof window.__VINEXT_APP_LOADER__ === "function") try {
+		const appModule = await window.__VINEXT_APP_LOADER__();
+		AppComponent = isAppComponent(appModule.default) ? appModule.default : void 0;
+		if (AppComponent) window.__VINEXT_APP__ = AppComponent;
+	} catch {}
+	assertStillCurrent();
+	const React = (await import("react")).default;
+	assertStillCurrent();
+	let element;
+	if (AppComponent) element = React.createElement(AppComponent, {
+		Component: PageComponent,
+		pageProps
+	});
+	else element = React.createElement(PageComponent, pageProps);
+	element = wrapWithRouterContext(element);
+	const mergedQuery = mergeRouteParamsIntoQuery(parseQueryString(target.search), target.params);
+	const prev = window.__NEXT_DATA__;
+	const nextLocale = (window.__VINEXT_LOCALES__?.length ?? 0) > 0 ? target.locale ?? window.__VINEXT_DEFAULT_LOCALE__ : prev?.locale;
+	const nextData = {
+		...prev,
+		props: { pageProps },
+		page: target.pattern,
+		query: mergedQuery,
+		buildId: target.buildId,
+		isFallback: false,
+		...nextLocale !== void 0 ? { locale: nextLocale } : {}
+	};
+	window.__NEXT_DATA__ = nextData;
+	applyVinextLocaleGlobals(window, nextData);
+	root.render(element);
+}
 /**
-* Perform client-side navigation: fetch the target page's HTML,
-* extract __NEXT_DATA__, and re-render the React root.
+* Perform client-side navigation by fetching the page's full HTML and
+* extracting `__NEXT_DATA__` plus the page module URL. Used in dev (where
+* the per-page inline hydration script does not populate the loader map) and
+* as a generic fallback when the data path is not available.
 *
 * Throws NavigationCancelledError if a newer navigation supersedes this one.
 * Throws on hard-navigation failures (non-OK response, missing data) so the
 * caller can distinguish success from failure for event emission.
 */
-async function navigateClient(url) {
-	if (typeof window === "undefined") return;
+async function navigateClientHtml(url, fetchUrl, controller, navId, assertStillCurrent, options = {}) {
+	let browserUrl = url;
+	let pendingRedirectHistoryUrl = fetchUrl === url ? null : url;
 	const root = window.__VINEXT_ROOT__;
 	if (!root) {
-		window.location.href = url;
+		window.location.href = browserUrl;
 		return;
 	}
+	let res;
+	try {
+		res = await fetch(fetchUrl, {
+			headers: { Accept: "text/html" },
+			signal: controller.signal
+		});
+	} catch (err) {
+		if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(url);
+		throw err;
+	}
+	assertStillCurrent();
+	if (res.redirected && res.url) {
+		const redirectedUrl = resolveSameOriginRedirectedUrl(res.url);
+		if (redirectedUrl) {
+			browserUrl = redirectedUrl;
+			pendingRedirectHistoryUrl = redirectedUrl;
+		}
+	}
+	if (!res.ok && !(options.allowNotFoundResponse === true && res.status === 404)) scheduleHardNavigationAndThrow(browserUrl, `Navigation failed: ${res.status} ${res.statusText}`);
+	const html = await res.text();
+	assertStillCurrent();
+	const nextDataJson = extractVinextNextDataJson(html);
+	if (!nextDataJson) scheduleHardNavigationAndThrow(url, "Navigation failed: missing __NEXT_DATA__ in response");
+	const nextData = parseVinextNextDataJson(nextDataJson);
+	const { pageProps } = nextData.props;
+	let pageModuleUrl = nextData.__vinext?.pageModuleUrl;
+	if (!pageModuleUrl) {
+		const moduleMatch = html.match(/import\("([^"]+)"\);\s*\n\s*const PageComponent/);
+		const altMatch = html.match(/await import\("([^"]+pages\/[^"]+)"\)/);
+		pageModuleUrl = moduleMatch?.[1] ?? altMatch?.[1] ?? void 0;
+	}
+	let pageModule;
+	if (!pageModuleUrl) {
+		const loader = window.__VINEXT_PAGE_LOADERS__?.[nextData.page];
+		if (!loader) scheduleHardNavigationAndThrow(browserUrl, "Navigation failed: no page module URL found");
+		pageModule = await loader();
+	} else {
+		if (!isValidModulePath(pageModuleUrl)) {
+			console.error("[vinext] Blocked import of invalid page module path:", pageModuleUrl);
+			scheduleHardNavigationAndThrow(browserUrl, "Navigation failed: invalid page module path");
+		}
+		pageModule = await import(
+			/* @vite-ignore */
+			pageModuleUrl
+);
+	}
+	assertStillCurrent();
+	const PageComponent = pageModule.default;
+	if (!isPageComponent(PageComponent)) scheduleHardNavigationAndThrow(browserUrl, "Navigation failed: page module default export is not a component");
+	const React = (await import("react")).default;
+	assertStillCurrent();
+	let AppComponent = window.__VINEXT_APP__;
+	const appModuleUrl = nextData.__vinext?.appModuleUrl;
+	if (!AppComponent && appModuleUrl) if (!isValidModulePath(appModuleUrl)) console.error("[vinext] Blocked import of invalid app module path:", appModuleUrl);
+	else try {
+		const appModule = await import(
+			/* @vite-ignore */
+			appModuleUrl
+);
+		AppComponent = isAppComponent(appModule.default) ? appModule.default : void 0;
+		window.__VINEXT_APP__ = AppComponent;
+	} catch {}
+	assertStillCurrent();
+	let element;
+	if (AppComponent) element = React.createElement(AppComponent, {
+		Component: PageComponent,
+		pageProps
+	});
+	else element = React.createElement(PageComponent, pageProps);
+	element = wrapWithRouterContext(element);
+	if (pendingRedirectHistoryUrl) {
+		window.history.replaceState(window.history.state ?? {}, "", pendingRedirectHistoryUrl);
+		_lastPathnameAndSearch = window.location.pathname + window.location.search;
+	}
+	window.__NEXT_DATA__ = nextData;
+	applyVinextLocaleGlobals(window, nextData);
+	root.render(element);
+}
+/**
+* Perform client-side navigation. Prefers the JSON data endpoint when the
+* client has a registered code-split loader for the target route (the prod
+* hot path); otherwise falls back to fetching the page's full HTML (dev and
+* any unmapped route).
+*
+* Throws NavigationCancelledError if a newer navigation supersedes this one.
+* Throws on hard-navigation failures (non-OK response, missing data) so the
+* caller can distinguish success from failure for event emission.
+*
+* `fetchUrl` is the HTML-path fetch URL (already includes locale-root
+* fixups). The JSON path derives its own URL from the browser-facing `url`
+* because the data endpoint speaks the unprefixed path.
+*/
+async function navigateClient(url, fetchUrl = url, options = {}) {
+	if (typeof window === "undefined") return;
 	_activeAbortController?.abort();
 	const controller = new AbortController();
 	_activeAbortController = controller;
@@ -319,64 +657,32 @@ async function navigateClient(url) {
 		if (navId !== _navigationId) throw new NavigationCancelledError(url);
 	}
 	try {
-		let res;
-		try {
-			res = await fetch(url, {
-				headers: { Accept: "text/html" },
-				signal: controller.signal
-			});
-		} catch (err) {
-			if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(url);
-			throw err;
-		}
-		assertStillCurrent();
-		if (!res.ok) scheduleHardNavigationAndThrow(url, `Navigation failed: ${res.status} ${res.statusText}`);
-		const html = await res.text();
-		assertStillCurrent();
-		const match = html.match(/<script>window\.__NEXT_DATA__\s*=\s*(.*?)<\/script>/);
-		if (!match) scheduleHardNavigationAndThrow(url, "Navigation failed: missing __NEXT_DATA__ in response");
-		const nextData = JSON.parse(match[1]);
-		const { pageProps } = nextData.props;
-		let pageModuleUrl = nextData.__vinext?.pageModuleUrl;
-		if (!pageModuleUrl) {
-			const moduleMatch = html.match(/import\("([^"]+)"\);\s*\n\s*const PageComponent/);
-			const altMatch = html.match(/await import\("([^"]+pages\/[^"]+)"\)/);
-			pageModuleUrl = moduleMatch?.[1] ?? altMatch?.[1] ?? void 0;
-		}
-		if (!pageModuleUrl) scheduleHardNavigationAndThrow(url, "Navigation failed: no page module URL found");
-		if (!isValidModulePath(pageModuleUrl)) {
-			console.error("[vinext] Blocked import of invalid page module path:", pageModuleUrl);
-			scheduleHardNavigationAndThrow(url, "Navigation failed: invalid page module path");
+		if (options.allowNotFoundResponse === true) await navigateClientHtml(url, fetchUrl, controller, navId, assertStillCurrent, options);
+		else {
+			let browserUrl = url;
+			let htmlFetchUrl = fetchUrl;
+			const dataTarget = resolvePagesDataNavigationTarget(browserUrl, __basePath);
+			if (!dataTarget) {
+				let redirectLocation;
+				try {
+					redirectLocation = await resolveMiddlewareDataRedirect(browserUrl, controller.signal);
+				} catch (err) {
+					if (err instanceof DOMException && err.name === "AbortError") throw new NavigationCancelledError(browserUrl);
+					throw err;
+				}
+				assertStillCurrent();
+				if (redirectLocation) {
+					const redirectedUrl = resolveLocalRedirectUrl(redirectLocation);
+					if (!redirectedUrl) scheduleHardNavigationAndThrow(redirectLocation, "Navigation redirected externally");
+					window.history.replaceState(window.history.state ?? {}, "", redirectedUrl);
+					_lastPathnameAndSearch = window.location.pathname + window.location.search;
+					browserUrl = redirectedUrl;
+					htmlFetchUrl = redirectedUrl;
+				}
+			}
+			if (dataTarget) await navigateClientData(browserUrl, dataTarget, controller, navId, assertStillCurrent);
+			else await navigateClientHtml(browserUrl, htmlFetchUrl, controller, navId, assertStillCurrent, options);
 		}
-		const pageModule = await import(
-			/* @vite-ignore */
-			pageModuleUrl
-);
-		assertStillCurrent();
-		const PageComponent = pageModule.default;
-		if (!PageComponent) scheduleHardNavigationAndThrow(url, "Navigation failed: page module has no default export");
-		const React = (await import("react")).default;
-		assertStillCurrent();
-		let AppComponent = window.__VINEXT_APP__;
-		const appModuleUrl = nextData.__vinext?.appModuleUrl;
-		if (!AppComponent && appModuleUrl) if (!isValidModulePath(appModuleUrl)) console.error("[vinext] Blocked import of invalid app module path:", appModuleUrl);
-		else try {
-			AppComponent = (await import(
-				/* @vite-ignore */
-				appModuleUrl
-)).default;
-			window.__VINEXT_APP__ = AppComponent;
-		} catch {}
-		assertStillCurrent();
-		let element;
-		if (AppComponent) element = React.createElement(AppComponent, {
-			Component: PageComponent,
-			pageProps
-		});
-		else element = React.createElement(PageComponent, pageProps);
-		element = wrapWithRouterContext(element);
-		window.__NEXT_DATA__ = nextData;
-		root.render(element);
 	} finally {
 		if (navId === _navigationId) _activeAbortController = null;
 	}
@@ -393,9 +699,9 @@ async function navigateClient(url) {
 * - "failed" — genuine error, caller should return false (hard nav is already
 *   scheduled as recovery)
 */
-async function runNavigateClient(fullUrl, resolvedUrl) {
+async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, options = {}) {
 	try {
-		await navigateClient(fullUrl);
+		await navigateClient(fullUrl, fetchUrl, options);
 		return "completed";
 	} catch (err) {
 		routerEvents.emit("routeChangeError", err, resolvedUrl, { shallow: false });
@@ -428,7 +734,7 @@ function buildRouterValue(pathname, query, asPath, methods) {
 		domainLocales,
 		isReady: true,
 		isPreview: false,
-		isFallback: typeof window !== "undefined" && nextData?.isFallback === true,
+		isFallback: typeof window !== "undefined" ? nextData?.isFallback === true : _ssrState?.isFallback === true,
 		...methods,
 		events: routerEvents
 	};
@@ -452,6 +758,22 @@ function updateHistory(mode, url) {
 	_lastPathnameAndSearch = window.location.pathname + window.location.search;
 }
 /**
+* Throw the canonical "no router instance" error used when a Pages Router
+* navigation method (push/replace/back/reload/prefetch/beforePopState) is
+* invoked during SSR or prerendering.
+*
+* Mirrors Next.js's `ServerRouter.push`/`replace`/etc. which all call
+* `noRouter()` in `packages/next/src/server/render.tsx`. The error message
+* matches Next.js verbatim so userland error handling and docs links work
+* unchanged.
+*
+* Ported from Next.js: packages/next/src/server/render.tsx
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/render.tsx
+*/
+function throwNoRouterInstance() {
+	throw new Error("No router instance found. you should only use \"next/router\" inside the client side of your app. https://nextjs.org/docs/messages/no-router-instance");
+}
+/**
 * 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
@@ -463,7 +785,11 @@ function updateHistory(mode, url) {
 * passes no callback.
 */
 async function performNavigation(url, as, options, mode, onStateUpdate) {
-	let resolved = resolveNavigationTarget(url, as, options?.locale);
+	if (typeof window === "undefined") throwNoRouterInstance();
+	assertSafeNavigationUrl(resolveUrl(url));
+	if (as !== void 0) assertSafeNavigationUrl(String(as));
+	const navigationLocale = resolveTransitionLocale(options?.locale);
+	let resolved = resolveNavigationTarget(url, as, navigationLocale);
 	if (isExternalUrl(resolved)) {
 		const localPath = toSameOriginAppPath(resolved, __basePath);
 		if (localPath == null) {
@@ -473,7 +799,11 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 		}
 		resolved = localPath;
 	}
-	const full = toBrowserNavigationHref(resolved, window.location.href, __basePath);
+	resolved = normalizePathTrailingSlash(resolved, __trailingSlash);
+	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 shallow = options?.shallow ?? false;
 	const doScroll = options?.scroll !== false;
 	if (isHashOnlyChange(full)) {
@@ -491,7 +821,7 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	routerEvents.emit("beforeHistoryChange", resolved, { shallow });
 	updateHistory(mode, full);
 	if (!shallow) {
-		const result = await runNavigateClient(full, resolved);
+		const result = await runNavigateClient(full, resolved, htmlFetchUrl, navigateOptions);
 		if (result === "cancelled") return true;
 		if (result === "failed") return false;
 	}
@@ -503,15 +833,37 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	dispatchNavigateEvent();
 	return true;
 }
-/** Inject a `<link rel="prefetch">` for the target page. */
+/**
+* Prefetch the resources needed for a future Pages Router navigation.
+*
+* When the client has a registered code-split loader for the target route
+* (the prod hot path), we prefetch in parallel:
+*   1. The `/_next/data/<buildId>/<page>.json` payload — same URL the actual
+*      navigation will request, so a cache hit is automatic.
+*   2. The page's JS chunk — by invoking the loader thunk now. Vite's
+*      dynamic `import()` machinery is responsible for fetching + caching;
+*      the returned Promise is intentionally discarded.
+*
+* When no loader is registered (dev server, or an unmapped route), we fall
+* back to the legacy `<link rel="prefetch" as="document">` hint, which lets
+* the browser preload the HTML document. This matches the pre-`_next/data`
+* behaviour so dev doesn't regress.
+*
+* Ported from Next.js: `packages/next/src/client/page-loader.ts` `prefetch`
+* (the data + chunk parallel prefetch shape).
+*/
 async function prefetchUrl(url) {
-	if (typeof document !== "undefined") {
-		const link = document.createElement("link");
-		link.rel = "prefetch";
-		link.href = url;
-		link.as = "document";
-		document.head.appendChild(link);
+	if (typeof document === "undefined") return;
+	const dataTarget = resolvePagesDataNavigationTarget(url, __basePath);
+	if (dataTarget) {
+		prefetchPagesData(dataTarget);
+		return;
 	}
+	const link = document.createElement("link");
+	link.rel = "prefetch";
+	link.href = url;
+	link.as = "document";
+	document.head.appendChild(link);
 }
 /**
 * useRouter hook - Pages Router compatible.
@@ -573,7 +925,7 @@ function handlePagesRouterPopState(e) {
 	routerEvents.emit("routeChangeStart", fullAppUrl, { shallow: false });
 	routerEvents.emit("beforeHistoryChange", fullAppUrl, { shallow: false });
 	(async () => {
-		if (await runNavigateClient(browserUrl, fullAppUrl) === "completed") {
+		if (await runNavigateClient(browserUrl, fullAppUrl, getPagesHtmlFetchUrl(browserUrl, window.__VINEXT_LOCALE__)) === "completed") {
 			routerEvents.emit("routeChangeComplete", fullAppUrl, { shallow: false });
 			restoreScrollPosition(e.state);
 			dispatchNavigateEvent();
@@ -624,17 +976,114 @@ function withRouter(ComposedComponent) {
 	if (process.env.NODE_ENV !== "production") WithRouterWrapper.displayName = `withRouter(${composed.displayName || composed.name || "Unknown"})`;
 	return WithRouterWrapper;
 }
-const Router = {
-	push: (url, as, options) => performNavigation(url, as, options, "push"),
-	replace: (url, as, options) => performNavigation(url, as, options, "replace"),
-	back: () => window.history.back(),
-	reload: () => window.location.reload(),
-	prefetch: prefetchUrl,
+const Router = Object.defineProperties({
+	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");
+	},
+	back: () => {
+		if (typeof window === "undefined") throwNoRouterInstance();
+		window.history.back();
+	},
+	reload: () => {
+		if (typeof window === "undefined") throwNoRouterInstance();
+		window.location.reload();
+	},
+	prefetch: (url) => {
+		if (typeof window === "undefined") throwNoRouterInstance();
+		return prefetchUrl(url);
+	},
 	beforePopState: (cb) => {
+		if (typeof window === "undefined") throwNoRouterInstance();
 		_beforePopStateCb = cb;
 	},
 	events: routerEvents
-};
+}, {
+	pathname: {
+		enumerable: true,
+		get() {
+			return getPathnameAndQuery().pathname;
+		}
+	},
+	route: {
+		enumerable: true,
+		get() {
+			const { pathname } = getPathnameAndQuery();
+			if (typeof window === "undefined") return pathname;
+			return window.__NEXT_DATA__?.page ?? pathname;
+		}
+	},
+	query: {
+		enumerable: true,
+		get() {
+			return getPathnameAndQuery().query;
+		}
+	},
+	asPath: {
+		enumerable: true,
+		get() {
+			return getPathnameAndQuery().asPath;
+		}
+	},
+	basePath: {
+		enumerable: true,
+		value: __basePath,
+		writable: false
+	},
+	locale: {
+		enumerable: true,
+		get() {
+			if (typeof window === "undefined") return _getSSRContext()?.locale;
+			return window.__VINEXT_LOCALE__;
+		}
+	},
+	locales: {
+		enumerable: true,
+		get() {
+			if (typeof window === "undefined") return _getSSRContext()?.locales;
+			return window.__VINEXT_LOCALES__;
+		}
+	},
+	defaultLocale: {
+		enumerable: true,
+		get() {
+			if (typeof window === "undefined") return _getSSRContext()?.defaultLocale;
+			return window.__VINEXT_DEFAULT_LOCALE__;
+		}
+	},
+	domainLocales: {
+		enumerable: true,
+		get() {
+			if (typeof window === "undefined") return _getSSRContext()?.domainLocales;
+			return window.__NEXT_DATA__?.domainLocales;
+		}
+	},
+	isReady: {
+		enumerable: true,
+		value: true,
+		writable: false
+	},
+	isPreview: {
+		enumerable: true,
+		value: false,
+		writable: false
+	},
+	isFallback: {
+		enumerable: true,
+		get() {
+			if (typeof window === "undefined") return _getSSRContext()?.isFallback === true;
+			return window.__NEXT_DATA__?.isFallback === true;
+		}
+	}
+});
 if (typeof window !== "undefined") installWindowNext({ router: Router });
 const _PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
 globalThis[_PAGES_NAVIGATION_ACCESSOR_KEY] = getPagesNavigationContext;