vinext 0.0.52 → 0.0.53

package/dist/shims/router.js

@@ -1,13 +1,16 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
-import { addQueryParam, appendSearchParamsToUrl, urlQueryToSearchParams } from "../utils/query.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 { installWindowNext } from "../client/window-next.js";
-import { isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.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 { 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";
@@ -55,6 +58,8 @@ 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);
@@ -66,6 +71,40 @@ function getCurrentUrlLocale() {
 		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__;
@@ -329,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: fetch the target page's HTML,
-* extract __NEXT_DATA__, and re-render the React root.
+* 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 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, fetchUrl = 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;
@@ -353,65 +657,32 @@ async function navigateClient(url, fetchUrl = url) {
 		if (navId !== _navigationId) throw new NavigationCancelledError(url);
 	}
 	try {
-		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.ok) scheduleHardNavigationAndThrow(url, `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;
+		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);
 		}
-		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");
-		}
-		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;
-		applyVinextLocaleGlobals(window, nextData);
-		root.render(element);
 	} finally {
 		if (navId === _navigationId) _activeAbortController = null;
 	}
@@ -428,9 +699,9 @@ async function navigateClient(url, fetchUrl = url) {
 * - "failed" — genuine error, caller should return false (hard nav is already
 *   scheduled as recovery)
 */
-async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl) {
+async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, options = {}) {
 	try {
-		await navigateClient(fullUrl, fetchUrl);
+		await navigateClient(fullUrl, fetchUrl, options);
 		return "completed";
 	} catch (err) {
 		routerEvents.emit("routeChangeError", err, resolvedUrl, { shallow: false });
@@ -530,7 +801,9 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 	}
 	resolved = normalizePathTrailingSlash(resolved, __trailingSlash);
 	const full = normalizePathTrailingSlash(toBrowserNavigationHref(resolved, window.location.href, __basePath), __trailingSlash);
-	const htmlFetchUrl = getPagesHtmlFetchUrl(full, navigationLocale);
+	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)) {
@@ -548,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, htmlFetchUrl);
+		const result = await runNavigateClient(full, resolved, htmlFetchUrl, navigateOptions);
 		if (result === "cancelled") return true;
 		if (result === "failed") return false;
 	}
@@ -560,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.
@@ -684,10 +979,14 @@ function withRouter(ComposedComponent) {
 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: () => {