vinext 0.1.2 → 0.1.4

package/dist/shims/internal/app-route-detection.js

@@ -1,7 +1,7 @@
 import { removeTrailingSlash, stripBasePath } from "../../utils/base-path.js";
-import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { resolveHybridClientRouteOwner } from "./hybrid-client-route-owner.js";
 //#region src/shims/internal/app-route-detection.ts
-const appRouteTrieCache = createRouteTrieCache();
 const _COMPONENTS_KEY = Symbol.for("vinext.pagesRouter.components");
 /**
 * Get-or-create the Pages Router `components` map. Returns the same object
@@ -32,20 +32,11 @@ function resolveSameOriginPathname(href, basePath) {
 		return null;
 	}
 	if (url.origin !== window.location.origin) return null;
-	return stripBasePath(url.pathname, basePath);
-}
-/**
-* Returns true when the prefetch href matches any route in the App Router
-* prefetch manifest (static or dynamic). Returns false when the manifest is
-* absent (Pages-Router-only build), the URL is external, or no route matches.
-*/
-function matchesAppRoute(href, basePath) {
-	if (typeof window === "undefined") return false;
-	const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
-	if (!routes || routes.length === 0) return false;
-	const pathname = resolveSameOriginPathname(href, basePath);
-	if (pathname === null) return false;
-	return matchRouteWithTrie(pathname, routes, appRouteTrieCache) !== null;
+	const pathname = stripBasePath(url.pathname, basePath);
+	const locale = getLocalePathPrefix(pathname, window.__VINEXT_LOCALES__);
+	if (!locale) return pathname;
+	const localePrefixLength = locale.length + 1;
+	return pathname.length === localePrefixLength ? "/" : pathname.slice(localePrefixLength);
 }
 /**
 * Record `components[pathname] = { __appRouter: true }` on the shared
@@ -61,7 +52,7 @@ function matchesAppRoute(href, basePath) {
 */
 function markAppRouteDetectedOnPrefetch(href, basePath) {
 	if (typeof window === "undefined") return;
-	if (!matchesAppRoute(href, basePath)) return;
+	if (resolveHybridClientRouteOwner(href, basePath) !== "app") return;
 	const rawPathname = resolveSameOriginPathname(href, basePath);
 	if (rawPathname === null) return;
 	const pathname = removeTrailingSlash(rawPathname);

package/dist/shims/internal/hybrid-client-route-owner.d.ts

@@ -0,0 +1,31 @@
+import { NextRewrite } from "../../config/next-config.js";
+import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../../client/vinext-next-data.js";
+
+//#region src/shims/internal/hybrid-client-route-owner.d.ts
+type HybridClientOwner = "app" | "document" | "pages";
+declare global {
+  interface Window {
+    __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];
+    __VINEXT_PAGES_LINK_PREFETCH_ROUTES__?: VinextPagesLinkPrefetchRoute[];
+    __VINEXT_CLIENT_REWRITES__?: {
+      afterFiles: NextRewrite[];
+      beforeFiles: NextRewrite[];
+      fallback: NextRewrite[];
+    };
+  }
+}
+/**
+ * Decide which router should own a soft-navigated URL. Returns:
+ *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
+ *   - "pages"  → Pages owns the URL; the caller must hard-navigate instead.
+ *   - null     → no router matched (preserves the existing 404 path).
+ *
+ * `basePath` must match what the page uses (typically `process.env.__NEXT_ROUTER_BASEPATH`).
+ *
+ * The lookup uses the App and Pages manifests on `window` so the same
+ * matcher trie produces the same result the server will see when the
+ * request lands.
+ */
+declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+//#endregion
+export { HybridClientOwner, resolveHybridClientRouteOwner };

package/dist/shims/internal/hybrid-client-route-owner.js

@@ -0,0 +1,143 @@
+import { compareHybridRoutePatterns } from "../../routing/utils.js";
+import { stripBasePath } from "../../utils/base-path.js";
+import { createRouteTrieCache, matchRouteWithTrie } from "../../routing/route-matching.js";
+import { isExternalUrl, matchRewrite, parseCookies } from "../../config/config-matchers.js";
+import { getLocalePathPrefix } from "../../utils/domain-locale.js";
+import { mergeRewriteQuery } from "../../utils/query.js";
+//#region src/shims/internal/hybrid-client-route-owner.ts
+/**
+* Client-side resolver that decides whether a URL should be soft-navigated
+* (App Router / RSC) or hard-navigated (Pages Router / document). Delegates
+* the owner decision to `compareHybridRoutePatterns` in `routing/utils.ts`
+* so the server and the client reach the same answer for the same
+* (pages pattern, app pattern) pair.
+*
+* Lives in `shims/internal/` because both `link.tsx` and the App Router
+* browser entry import it without pulling in the server route graph.
+*
+* The App + Pages route manifests are emitted once per page load by the
+* Vite plugin onto the matching `__VINEXT_*_PREFETCH_ROUTES__` window
+* globals (see `entries/app-browser-entry.ts` and
+* `entries/pages-client-entry.ts`). Hybrid builds expose both globals; a
+* single-router build only sets its own.
+*/
+function resolveClientRewrite(href, basePath, rewrites, continueAfterMatch = false) {
+	const initialUrl = new URL(href, window.location.href);
+	const basePathState = {
+		basePath,
+		hadBasePath: basePath ? initialUrl.pathname === basePath || initialUrl.pathname.startsWith(`${basePath}/`) : true
+	};
+	let currentHref = href;
+	let matched = false;
+	for (const rewrite of rewrites) {
+		const pathname = resolveSameOriginPathname(currentHref, basePath);
+		if (pathname === null) return null;
+		const url = new URL(currentHref, window.location.href);
+		const headers = new Headers({ "user-agent": globalThis.navigator?.userAgent ?? "" });
+		const context = {
+			cookies: parseCookies(globalThis.document?.cookie ?? ""),
+			headers,
+			host: url.hostname,
+			query: url.searchParams
+		};
+		const rewritten = matchRewrite(pathname, [rewrite], context, basePathState);
+		if (rewritten === null) continue;
+		if (isExternalUrl(rewritten)) return { kind: "document" };
+		currentHref = mergeRewriteQuery(currentHref, rewritten);
+		matched = true;
+		if (!continueAfterMatch) break;
+	}
+	return matched ? {
+		href: currentHref,
+		kind: "rewrite"
+	} : null;
+}
+const appRouteTrieCache = createRouteTrieCache();
+const pagesRouteTrieCache = createRouteTrieCache();
+/**
+* Build a `/`-joined pattern from a manifest's `patternParts`. Mirrors the
+* server-side route-graph shape (`{ pattern: string }`) so the
+* `compareHybridRoutePatterns` segment-rank comparator can score both Pages
+* and App patterns. The
+* `patternParts` array never includes an empty string for the static `/`
+* route (the App catch-all handles the bare path), so the simple join is
+* safe for everything the route trie actually matches.
+*/
+function patternFromParts(parts) {
+	return "/" + parts.join("/");
+}
+function resolveSameOriginPathname(href, basePath) {
+	if (typeof window === "undefined") return null;
+	let url;
+	try {
+		url = new URL(href, window.location.href);
+	} catch {
+		return null;
+	}
+	if (url.origin !== window.location.origin) return null;
+	const pathname = stripBasePath(url.pathname, basePath);
+	const locale = getLocalePathPrefix(pathname, window.__VINEXT_LOCALES__);
+	if (!locale) return pathname;
+	const localePrefixLength = locale.length + 1;
+	return pathname.length === localePrefixLength ? "/" : pathname.slice(localePrefixLength);
+}
+function matchAppRoute(href, basePath, routes) {
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return null;
+	return matchRouteWithTrie(pathname, routes, appRouteTrieCache)?.route ?? null;
+}
+function matchPagesRoute(href, basePath, routes) {
+	const pathname = resolveSameOriginPathname(href, basePath);
+	if (pathname === null) return null;
+	return matchRouteWithTrie(pathname, routes, pagesRouteTrieCache)?.route ?? null;
+}
+/**
+* Decide which router should own a soft-navigated URL. Returns:
+*   - "app"    → the App Router runtime handles the navigation (RSC fetch).
+*   - "pages"  → Pages owns the URL; the caller must hard-navigate instead.
+*   - null     → no router matched (preserves the existing 404 path).
+*
+* `basePath` must match what the page uses (typically `process.env.__NEXT_ROUTER_BASEPATH`).
+*
+* The lookup uses the App and Pages manifests on `window` so the same
+* matcher trie produces the same result the server will see when the
+* request lands.
+*/
+function resolveHybridClientRouteOwner(href, basePath) {
+	if (typeof window === "undefined") return null;
+	const appRoutes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
+	const pagesRoutes = window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__;
+	const rewrites = window.__VINEXT_CLIENT_REWRITES__;
+	if (rewrites) {
+		const beforeFilesRewrite = resolveClientRewrite(href, basePath, rewrites.beforeFiles, true);
+		if (beforeFilesRewrite?.kind === "document") return "document";
+		if (beforeFilesRewrite?.kind === "rewrite") href = beforeFilesRewrite.href;
+	}
+	let appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+	let pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+	if (rewrites && (appMatch === null || appMatch.isDynamic) && (pagesMatch === null || pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
+		const afterFilesRewrite = resolveClientRewrite(href, basePath, [rewrite]);
+		if (afterFilesRewrite?.kind === "document") return "document";
+		if (afterFilesRewrite?.kind !== "rewrite") continue;
+		href = afterFilesRewrite.href;
+		appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+		pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+		if (appMatch || pagesMatch) break;
+	}
+	if (rewrites && appMatch === null && pagesMatch === null) for (const rewrite of rewrites.fallback) {
+		const fallbackRewrite = resolveClientRewrite(href, basePath, [rewrite]);
+		if (fallbackRewrite?.kind === "document") return "document";
+		if (fallbackRewrite?.kind !== "rewrite") continue;
+		href = fallbackRewrite.href;
+		appMatch = appRoutes ? matchAppRoute(href, basePath, appRoutes) : null;
+		pagesMatch = pagesRoutes ? matchPagesRoute(href, basePath, pagesRoutes) : null;
+		if (appMatch || pagesMatch) break;
+	}
+	if (appMatch === null && pagesMatch === null) return null;
+	if (pagesMatch === null) return appMatch.documentOnly ? "document" : "app";
+	if (appMatch === null) return pagesMatch.documentOnly ? "document" : "pages";
+	const owner = compareHybridRoutePatterns(patternFromParts(pagesMatch.patternParts), pagesMatch.isDynamic, patternFromParts(appMatch.patternParts), appMatch.isDynamic);
+	return (owner === "app" ? appMatch : pagesMatch).documentOnly ? "document" : owner;
+}
+//#endregion
+export { resolveHybridClientRouteOwner };

package/dist/shims/internal/navigation-untracked.d.ts

@@ -0,0 +1,35 @@
+//#region src/shims/internal/navigation-untracked.d.ts
+/**
+ * Internal navigation-untracked pathname hook.
+ *
+ * Used by `unstable_catchError` error boundaries to avoid subscribing to
+ * pathname changes. This is NOT part of the public `next/navigation` API.
+ *
+ * Ported from Next.js:
+ *   https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/client/components/navigation-untracked.ts
+ */
+/**
+ * Returns the current pathname without registering it as a tracked render
+ * dependency. Unlike `usePathname()`, this does not use `useSyncExternalStore`
+ * and therefore does not cause the component to re-render on navigation.
+ *
+ * Server: returns the pathname from context, or `"/"` when no navigation context
+ * is available (the client will hydrate with the real value). The `"/"` fallback
+ * deliberately matches vinext's `usePathname()` behavior rather than Next.js's
+ * null context default. Returns `null` only when the render is a missing-params
+ * shell — vinext does not yet implement fallback-route-param detection, so this
+ * path is not currently reachable.
+ *
+ * Client: prefers the render snapshot **only during an active navigation**
+ * transition (`navigationSnapshotActiveCount > 0`) so the hook returns the
+ * pending URL, not the stale committed one. After commit, falls back to the
+ * cached pathname so user `pushState`/`replaceState` calls are immediately
+ * reflected.
+ *
+ * Used by `unstable_catchError` error boundaries to avoid unnecessary re-renders.
+ *
+ * @internal
+ */
+declare function useUntrackedPathname(): string | null;
+//#endregion
+export { useUntrackedPathname };

package/dist/shims/internal/navigation-untracked.js

@@ -0,0 +1,55 @@
+import { getPagesNavigationContext } from "./pages-router-accessor.js";
+import { getClientNavigationState, getNavigationContext, useClientNavigationRenderSnapshot } from "../navigation.js";
+//#region src/shims/internal/navigation-untracked.ts
+/**
+* Internal navigation-untracked pathname hook.
+*
+* Used by `unstable_catchError` error boundaries to avoid subscribing to
+* pathname changes. This is NOT part of the public `next/navigation` API.
+*
+* Ported from Next.js:
+*   https://github.com/vercel/next.js/blob/v16.2.6/packages/next/src/client/components/navigation-untracked.ts
+*/
+const isServer = typeof window === "undefined";
+function getPathnameSnapshot() {
+	const pagesCtx = getPagesNavigationContext();
+	if (pagesCtx) return pagesCtx.pathname;
+	return getClientNavigationState()?.cachedPathname ?? "/";
+}
+/**
+* Returns the current pathname without registering it as a tracked render
+* dependency. Unlike `usePathname()`, this does not use `useSyncExternalStore`
+* and therefore does not cause the component to re-render on navigation.
+*
+* Server: returns the pathname from context, or `"/"` when no navigation context
+* is available (the client will hydrate with the real value). The `"/"` fallback
+* deliberately matches vinext's `usePathname()` behavior rather than Next.js's
+* null context default. Returns `null` only when the render is a missing-params
+* shell — vinext does not yet implement fallback-route-param detection, so this
+* path is not currently reachable.
+*
+* Client: prefers the render snapshot **only during an active navigation**
+* transition (`navigationSnapshotActiveCount > 0`) so the hook returns the
+* pending URL, not the stale committed one. After commit, falls back to the
+* cached pathname so user `pushState`/`replaceState` calls are immediately
+* reflected.
+*
+* Used by `unstable_catchError` error boundaries to avoid unnecessary re-renders.
+*
+* @internal
+*/
+function useUntrackedPathname() {
+	if (isServer) {
+		const ctx = getNavigationContext();
+		if (ctx) return ctx.pathname;
+		const pagesCtx = getPagesNavigationContext();
+		return pagesCtx ? pagesCtx.pathname : "/";
+	}
+	const renderSnapshot = useClientNavigationRenderSnapshot();
+	if (renderSnapshot && (getClientNavigationState()?.navigationSnapshotActiveCount ?? 0) > 0) return renderSnapshot.pathname;
+	const pagesCtx = getPagesNavigationContext();
+	if (pagesCtx) return pagesCtx.pathname;
+	return getPathnameSnapshot();
+}
+//#endregion
+export { useUntrackedPathname };

package/dist/shims/internal/pages-data-fetch-dedup.d.ts

@@ -24,19 +24,18 @@
  *   directly by anyone, which keeps subsequent clones legal even after one
  *   caller has consumed its copy.
  *
- * - No `AbortSignal` is honored at the shared layer. Each `Router.push` cycle
- *   has its own AbortController that supersedes prior navigations via
- *   `_navigationId`; aborting the shared fetch on behalf of one caller would
- *   destroy the dedup gain for every other concurrent caller. Cancellation is
- *   handled by the caller's `assertStillCurrent()` checkpoints after `await`,
- *   not by abort propagation.
+ * - Each caller owns one waiter. Cancelling a waiter leaves the shared request
+ *   alive while another waiter remains; cancelling the final waiter aborts the
+ *   underlying fetch and evicts the entry immediately so a replacement caller
+ *   can retry without joining a doomed request.
  *
  * - The map is module-scoped (one per realm). The Pages Router runs in the
  *   browser only, so a single `Map` is sufficient.
  */
 /**
  * Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent
- * callers for the same `dataHref` share one underlying network request.
+ * callers for the same resolved URL and deployment ID share one underlying
+ * network request.
  *
  * Each call returns a freshly-cloned `Response` so consumers can read the
  * body independently. Once the in-flight Promise settles (resolve or reject)

package/dist/shims/internal/pages-data-fetch-dedup.js

@@ -1,3 +1,4 @@
+import "../../utils/deployment-id.js";
 //#region src/shims/internal/pages-data-fetch-dedup.ts
 /**
 * In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`
@@ -24,21 +25,57 @@
 *   directly by anyone, which keeps subsequent clones legal even after one
 *   caller has consumed its copy.
 *
-* - No `AbortSignal` is honored at the shared layer. Each `Router.push` cycle
-*   has its own AbortController that supersedes prior navigations via
-*   `_navigationId`; aborting the shared fetch on behalf of one caller would
-*   destroy the dedup gain for every other concurrent caller. Cancellation is
-*   handled by the caller's `assertStillCurrent()` checkpoints after `await`,
-*   not by abort propagation.
+* - Each caller owns one waiter. Cancelling a waiter leaves the shared request
+*   alive while another waiter remains; cancelling the final waiter aborts the
+*   underlying fetch and evicts the entry immediately so a replacement caller
+*   can retry without joining a doomed request.
 *
 * - The map is module-scoped (one per realm). The Pages Router runs in the
 *   browser only, so a single `Map` is sufficient.
 */
-/** Inflight fetch promises keyed by the resolved data URL. */
+/** Inflight fetch entries keyed by the resolved data request identity. */
 const inflight = /* @__PURE__ */ new Map();
+function getInflightKey(dataHref, init) {
+	let resolvedHref = dataHref;
+	if (typeof window !== "undefined") try {
+		resolvedHref = new URL(dataHref, window.location.href).href;
+	} catch {}
+	const deploymentId = new Headers(init?.headers).get("x-deployment-id") ?? "";
+	return `${resolvedHref}\n${deploymentId}`;
+}
+function cloneSharedResponse(key, entry, signal) {
+	entry.waiters += 1;
+	return new Promise((resolve, reject) => {
+		let released = false;
+		const release = (cancelled) => {
+			if (released) return;
+			released = true;
+			entry.waiters -= 1;
+			if (cancelled && entry.waiters === 0 && !entry.settled) {
+				if (inflight.get(key) === entry) inflight.delete(key);
+				entry.controller.abort();
+			}
+		};
+		const abort = () => {
+			release(true);
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		entry.promise.then((response) => {
+			signal?.removeEventListener("abort", abort);
+			release(false);
+			resolve(response.clone());
+		}, (error) => {
+			signal?.removeEventListener("abort", abort);
+			release(false);
+			reject(error);
+		});
+	});
+}
 /**
 * Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent
-* callers for the same `dataHref` share one underlying network request.
+* callers for the same resolved URL and deployment ID share one underlying
+* network request.
 *
 * Each call returns a freshly-cloned `Response` so consumers can read the
 * body independently. Once the in-flight Promise settles (resolve or reject)
@@ -48,20 +85,36 @@ const inflight = /* @__PURE__ */ new Map();
 * dropped on failure so the next navigation can retry.
 */
 function dedupedPagesDataFetch(dataHref, init) {
-	let entry = inflight.get(dataHref);
+	const key = getInflightKey(dataHref, init);
+	const signal = init?.signal ?? void 0;
+	if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+	let entry = inflight.get(key);
 	if (!entry) {
-		entry = fetch(dataHref, init).finally(() => {
-			if (inflight.get(dataHref) === entry) inflight.delete(dataHref);
-		});
-		inflight.set(dataHref, entry);
+		const controller = new AbortController();
+		let currentEntry;
+		currentEntry = {
+			controller,
+			promise: fetch(dataHref, {
+				...init,
+				signal: controller.signal
+			}).finally(() => {
+				currentEntry.settled = true;
+				if (inflight.get(key) === currentEntry) inflight.delete(key);
+			}),
+			settled: false,
+			waiters: 0
+		};
+		inflight.set(key, currentEntry);
+		entry = currentEntry;
 	}
-	return entry.then((res) => res.clone());
+	return cloneSharedResponse(key, entry, signal);
 }
 /**
 * Drop every cached in-flight entry. Intended for tests; production code
 * does not need to call this because entries self-evict on settle.
 */
 function clearPagesDataInflight() {
+	for (const entry of inflight.values()) entry.controller.abort();
 	inflight.clear();
 }
 //#endregion

package/dist/shims/internal/pages-data-target.d.ts

@@ -43,10 +43,15 @@ type PagesDataTarget = {
  */
 declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath: string): PagesDataTarget | null;
 /**
- * Inject a `<link rel="prefetch">` for the data JSON and kick off the
- * code-split loader so the chunk is warm by the time the user clicks.
+ * Prefetch the data JSON and kick off the code-split loader so the chunk is
+ * warm by the time the user clicks.
  *
  * Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch. The
+ * JSON request uses `fetch()` rather than `<link rel="prefetch">` so it can
+ * carry Next.js's `x-deployment-id` skew-protection header. The in-flight
+ * request is shared with a racing navigation; after it settles, the browser's
+ * normal HTTP cache remains responsible for reuse.
+ *
  * loader's returned Promise is intentionally discarded — `import()` caches the
  * result, so a subsequent navigation re-invocation hits the cache without
  * paying for a second round trip. Errors are swallowed: prefetch is

package/dist/shims/internal/pages-data-target.js

@@ -1,6 +1,8 @@
 import { stripBasePath } from "../../utils/base-path.js";
 import { getLocalePathPrefix } from "../../utils/domain-locale.js";
 import { buildPagesDataHref, matchPagesPattern } from "./pages-data-url.js";
+import { NEXT_DEPLOYMENT_ID_HEADER, getDeploymentId } from "../../utils/deployment-id.js";
+import { dedupedPagesDataFetch } from "./pages-data-fetch-dedup.js";
 //#region src/shims/internal/pages-data-target.ts
 /**
 * Shared decision helper for the Pages Router `/_next/data/<id>/<page>.json`
@@ -66,10 +68,15 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 	};
 }
 /**
-* Inject a `<link rel="prefetch">` for the data JSON and kick off the
-* code-split loader so the chunk is warm by the time the user clicks.
+* Prefetch the data JSON and kick off the code-split loader so the chunk is
+* warm by the time the user clicks.
 *
 * Used by both `Router.prefetch()` and `<Link>` hover/viewport prefetch. The
+* JSON request uses `fetch()` rather than `<link rel="prefetch">` so it can
+* carry Next.js's `x-deployment-id` skew-protection header. The in-flight
+* request is shared with a racing navigation; after it settles, the browser's
+* normal HTTP cache remains responsible for reuse.
+*
 * loader's returned Promise is intentionally discarded — `import()` caches the
 * result, so a subsequent navigation re-invocation hits the cache without
 * paying for a second round trip. Errors are swallowed: prefetch is
@@ -77,12 +84,14 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 */
 function prefetchPagesData(target) {
 	if (typeof document === "undefined") return;
-	const link = document.createElement("link");
-	link.rel = "prefetch";
-	link.as = "fetch";
-	link.crossOrigin = "anonymous";
-	link.href = target.dataHref;
-	document.head.appendChild(link);
+	const headers = {
+		Accept: "application/json",
+		purpose: "prefetch",
+		"x-nextjs-data": "1"
+	};
+	const deploymentId = getDeploymentId();
+	if (deploymentId) headers[NEXT_DEPLOYMENT_ID_HEADER] = deploymentId;
+	dedupedPagesDataFetch(target.dataHref, { headers }).catch(() => {});
 	target.loader().catch(() => {});
 }
 //#endregion

package/dist/shims/internal/pages-router-accessor.d.ts

@@ -0,0 +1,19 @@
+//#region src/shims/internal/pages-router-accessor.d.ts
+/**
+ * Shared Pages Router navigation accessor.
+ *
+ * Both `next/navigation` (usePathname/useParams/useSearchParams) and the
+ * internal `useUntrackedPathname` read from the same global Symbol. Keeping
+ * the lookup in one place avoids the Symbol string and the error-handling
+ * shape from drifting across modules.
+ *
+ * @internal
+ */
+type PagesNavigationContext = {
+  pathname: string | null;
+  searchParams: URLSearchParams;
+  params: Record<string, string | string[]> | null;
+};
+declare function getPagesNavigationContext(): PagesNavigationContext | null;
+//#endregion
+export { PagesNavigationContext, getPagesNavigationContext };

package/dist/shims/internal/pages-router-accessor.js

@@ -0,0 +1,13 @@
+//#region src/shims/internal/pages-router-accessor.ts
+const PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
+function getPagesNavigationContext() {
+	const accessor = globalThis[PAGES_NAVIGATION_ACCESSOR_KEY];
+	if (!accessor) return null;
+	try {
+		return accessor();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { getPagesNavigationContext };

package/dist/shims/internal/router-context.d.ts

@@ -1,6 +1,7 @@
 import { NextRouter } from "../router.js";
+import { Context } from "react";
 
 //#region src/shims/internal/router-context.d.ts
-declare const RouterContext: import("react").Context<NextRouter | null>;
+declare const RouterContext: Context<NextRouter | null>;
 //#endregion
 export { RouterContext };

package/dist/shims/internal/router-context.js

@@ -6,6 +6,8 @@ import { createContext } from "react";
 * Used by: some testing utilities and older libraries.
 * Provides the Pages Router context.
 */
-const RouterContext = createContext(null);
+const ROUTER_CONTEXT_KEY = Symbol.for("vinext.routerContext");
+const globalState = globalThis;
+const RouterContext = globalState[ROUTER_CONTEXT_KEY] ?? (globalState[ROUTER_CONTEXT_KEY] = createContext(null));
 //#endregion
 export { RouterContext };