@qzsy/vinext 0.1.7

package/dist/shims/internal/interpolate-as.js

@@ -0,0 +1,196 @@
+import { removeTrailingSlash } from "../../utils/base-path.js";
+//#region src/shims/internal/interpolate-as.ts
+/**
+* Port of Next.js' Pages Router `interpolateAs` helper, plus the minimal
+* subset of its transitive dependencies (`getRouteRegex` + `getRouteMatcher`
+* and the parameter-pattern parsers they rely on).
+*
+* Upstream sources:
+*   - packages/next/src/shared/lib/router/utils/interpolate-as.ts
+*   - packages/next/src/shared/lib/router/utils/route-regex.ts
+*   - packages/next/src/shared/lib/router/utils/route-matcher.ts
+*   - packages/next/src/shared/lib/router/utils/get-dynamic-param.ts
+*   - packages/next/src/shared/lib/router/utils/remove-trailing-slash.ts
+*   - packages/next/src/shared/lib/escape-regexp.ts
+*
+* Used by the Pages Router shim to project a route pattern + `as` pathname +
+* query back into a fully-interpolated browser URL (the `<Link href as>`
+* masking path). Interception-route markers (`(.)`, `(..)`, `(...)`,
+* `(..)(..)`) are intentionally omitted — they only apply to App Router and
+* never appear in Pages Router patterns.
+*/
+function normalizeQuery(query) {
+	const normalized = {};
+	if (!query) return normalized;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		normalized[key] = Array.isArray(value) ? value.map(String) : String(value);
+	}
+	return normalized;
+}
+function parseRouteHrefQuery(routeHref, queryIndex, hashIndex) {
+	const query = {};
+	if (queryIndex === -1 || hashIndex !== -1 && queryIndex > hashIndex) return query;
+	const searchEnd = hashIndex === -1 ? routeHref.length : hashIndex;
+	for (const [key, value] of new URLSearchParams(routeHref.slice(queryIndex + 1, searchEnd))) {
+		const existing = query[key];
+		if (existing === void 0) query[key] = value;
+		else if (Array.isArray(existing)) existing.push(value);
+		else query[key] = [existing, value];
+	}
+	return query;
+}
+const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+function escapeStringRegexp(str) {
+	if (reHasRegExp.test(str)) return str.replace(reReplaceRegExp, "\\$&");
+	return str;
+}
+/**
+* Regular expression pattern used to match route parameters.
+* Matches both single parameters and parameter groups.
+* Examples:
+*   - `[[...slug]]` matches parameter group with key 'slug', repeat: true, optional: true
+*   - `[...slug]` matches parameter group with key 'slug', repeat: true, optional: false
+*   - `[[foo]]` matches parameter with key 'foo', repeat: false, optional: true
+*   - `[bar]` matches parameter with key 'bar', repeat: false, optional: false
+*/
+const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+/**
+* Parses a matched parameter from the PARAMETER_PATTERN regex.
+* Examples:
+*   - `[...slug]` -> `{ key: 'slug', repeat: true, optional: true }`
+*   - `...slug`   -> `{ key: 'slug', repeat: true, optional: false }`
+*   - `[foo]`     -> `{ key: 'foo',  repeat: false, optional: true }`
+*   - `bar`       -> `{ key: 'bar',  repeat: false, optional: false }`
+*/
+function parseMatchedParameter(param) {
+	const optional = param.startsWith("[") && param.endsWith("]");
+	if (optional) param = param.slice(1, -1);
+	const repeat = param.startsWith("...");
+	if (repeat) param = param.slice(3);
+	return {
+		key: param,
+		repeat,
+		optional
+	};
+}
+function getParametrizedRoute(route) {
+	const groups = {};
+	let groupIndex = 1;
+	const segments = [];
+	for (const segment of removeTrailingSlash(route).slice(1).split("/")) {
+		const paramMatches = segment.match(PARAMETER_PATTERN);
+		if (paramMatches && paramMatches[2]) {
+			const { key, repeat, optional } = parseMatchedParameter(paramMatches[2]);
+			groups[key] = {
+				pos: groupIndex++,
+				repeat,
+				optional
+			};
+			const s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+			segments.push(s);
+		} else segments.push(`/${escapeStringRegexp(segment)}`);
+	}
+	return {
+		parameterizedRoute: segments.join(""),
+		groups
+	};
+}
+/**
+* From a normalized route this function generates a regular expression and a
+* corresponding groups object intended to be used to store matching groups
+* from the regular expression.
+*/
+function getRouteRegex(normalizedRoute) {
+	const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute);
+	return {
+		re: new RegExp(`^${parameterizedRoute}(?:/)?$`),
+		groups
+	};
+}
+/**
+* Compile a route regex into a function that extracts decoded params from a
+* pathname. Returns `false` if the pathname does not match the route.
+*
+* The `safeRouteMatcher`/`stripParameterSeparators` wrapper that Next.js
+* applies (for adjacent-parameter normalization) is omitted — Pages Router
+* patterns never contain adjacent parameters, so the wrapper is a no-op for
+* this caller.
+*/
+function getRouteMatcher({ re, groups }) {
+	return (pathname) => {
+		const routeMatch = re.exec(pathname);
+		if (!routeMatch) return false;
+		const decode = (param) => {
+			try {
+				return decodeURIComponent(param);
+			} catch {
+				throw new Error("failed to decode param");
+			}
+		};
+		const params = {};
+		for (const [key, group] of Object.entries(groups)) {
+			const match = routeMatch[group.pos];
+			if (match !== void 0) if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
+			else params[key] = decode(match);
+		}
+		return params;
+	};
+}
+/**
+* Project a `(route, asPathname, query)` triple back into a fully-interpolated
+* browser URL. Used by the `<Link href as>` masking path in the Pages Router
+* shim: extract param values from the rendered `as` path when it differs from
+* the route pattern, otherwise fall back to reading them from the href query.
+*
+* Returns `{ params, result }`. `result` is the interpolated URL, or the empty
+* string when one or more required params could not be resolved. Callers warn
+* (in dev) on the empty-string case; this helper deliberately stays silent —
+* matching Next.js' behavior, where `<Link>` itself owns the dev warning.
+*/
+function interpolateAs(route, asPathname, query) {
+	let interpolatedRoute = "";
+	const dynamicRegex = getRouteRegex(route);
+	const dynamicGroups = dynamicRegex.groups;
+	const dynamicMatches = (asPathname !== route ? getRouteMatcher(dynamicRegex)(asPathname) : "") || query;
+	interpolatedRoute = route;
+	const params = Object.keys(dynamicGroups);
+	if (!params.every((param) => {
+		let value = dynamicMatches[param] || "";
+		const { repeat, optional } = dynamicGroups[param];
+		let replaced = `[${repeat ? "..." : ""}${param}]`;
+		if (optional) replaced = `${!value ? "/" : ""}[${replaced}]`;
+		if (repeat && !Array.isArray(value)) value = [value];
+		return (optional || param in dynamicMatches) && (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map((segment) => encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
+	})) interpolatedRoute = "";
+	return {
+		params,
+		result: interpolatedRoute
+	};
+}
+/**
+* Resolve a bracket-pattern route href against its displayed href. Query
+* values can be supplied directly (object-form hrefs) or parsed from the route
+* href (string-form hrefs). A `?` after `#` is part of the fragment, not a
+* query delimiter.
+*/
+function interpolateDynamicRouteHref(routeHref, asHref, queryInput) {
+	if (!routeHref.includes("[")) return null;
+	const hashIndex = routeHref.indexOf("#");
+	const queryIndex = routeHref.indexOf("?");
+	const pathEnd = [hashIndex, queryIndex].filter((index) => index !== -1).reduce((earliest, index) => Math.min(earliest, index), routeHref.length);
+	const routePathname = routeHref.slice(0, pathEnd);
+	const trailing = routeHref.slice(pathEnd);
+	const asPathname = asHref.split(/[?#]/, 1)[0];
+	const query = queryInput ? normalizeQuery(queryInput) : parseRouteHrefQuery(routeHref, queryIndex, hashIndex);
+	const { result, params } = interpolateAs(routePathname, asPathname, query);
+	return {
+		href: result ? `${result}${trailing}` : "",
+		params,
+		query,
+		routePathname
+	};
+}
+//#endregion
+export { interpolateDynamicRouteHref };

package/dist/shims/internal/link-status-registry.d.ts

@@ -0,0 +1,43 @@
+//#region src/shims/internal/link-status-registry.d.ts
+/**
+ * Link-status pending registry.
+ *
+ * Tracks the single <Link> that started the most recent App Router navigation
+ * so its `useLinkStatus()` pending state can be reset when a *different*
+ * navigation begins — a different <Link> click, `router.push`/`router.replace`,
+ * a form submission, shallow routing via raw `history.pushState`, or browser
+ * back/forward. Without this, a Link's pending indicator stays "sticky" after
+ * an interrupting navigation, because the Link's own completion handler is the
+ * only thing that would otherwise clear it.
+ *
+ * Mirrors Next.js's `linkForMostRecentNavigation` /
+ * `setLinkForCurrentNavigation` in
+ * packages/next/src/client/components/links.ts, adapted to vinext's per-<Link>
+ * React state model: instead of an optimistic-status dispatcher, we hold the
+ * link's `setPending` setter.
+ */
+type PendingLinkSetter = (pending: boolean) => void;
+/**
+ * Mark `setter` as the link that started the most recent navigation, resetting
+ * the previously-tracked link's pending state to idle so only the last-clicked
+ * link shows a pending state.
+ */
+declare function setLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+/**
+ * Stop tracking `setter` if it is the current navigation link. Called when a
+ * <Link> finishes its own navigation or unmounts so we never hold a stale
+ * reference to an unmounted component's setter.
+ */
+declare function clearLinkForCurrentNavigation(setter: PendingLinkSetter): void;
+/**
+ * Reset any link that is currently showing a pending state. Invoked at the
+ * start of every App Router navigation so that navigations not initiated by the
+ * tracked link — `router.push`/`router.replace`, form submissions, shallow
+ * routing, and browser back/forward — clear a stale pending indicator. A
+ * link-initiated navigation registers itself first via
+ * `setLinkForCurrentNavigation`; the matching call here consumes that marker and
+ * keeps the link pending.
+ */
+declare function notifyLinkNavigationStart(): void;
+//#endregion
+export { PendingLinkSetter, clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation };

package/dist/shims/internal/link-status-registry.js

@@ -0,0 +1,42 @@
+//#region src/shims/internal/link-status-registry.ts
+let linkSetterForMostRecentNavigation = null;
+let currentNavigationIsLinkInitiated = false;
+/**
+* Mark `setter` as the link that started the most recent navigation, resetting
+* the previously-tracked link's pending state to idle so only the last-clicked
+* link shows a pending state.
+*/
+function setLinkForCurrentNavigation(setter) {
+	if (linkSetterForMostRecentNavigation && linkSetterForMostRecentNavigation !== setter) linkSetterForMostRecentNavigation(false);
+	linkSetterForMostRecentNavigation = setter;
+	currentNavigationIsLinkInitiated = true;
+}
+/**
+* Stop tracking `setter` if it is the current navigation link. Called when a
+* <Link> finishes its own navigation or unmounts so we never hold a stale
+* reference to an unmounted component's setter.
+*/
+function clearLinkForCurrentNavigation(setter) {
+	if (linkSetterForMostRecentNavigation === setter) linkSetterForMostRecentNavigation = null;
+}
+/**
+* Reset any link that is currently showing a pending state. Invoked at the
+* start of every App Router navigation so that navigations not initiated by the
+* tracked link — `router.push`/`router.replace`, form submissions, shallow
+* routing, and browser back/forward — clear a stale pending indicator. A
+* link-initiated navigation registers itself first via
+* `setLinkForCurrentNavigation`; the matching call here consumes that marker and
+* keeps the link pending.
+*/
+function notifyLinkNavigationStart() {
+	if (currentNavigationIsLinkInitiated) {
+		currentNavigationIsLinkInitiated = false;
+		return;
+	}
+	if (linkSetterForMostRecentNavigation) {
+		linkSetterForMostRecentNavigation(false);
+		linkSetterForMostRecentNavigation = null;
+	}
+}
+//#endregion
+export { clearLinkForCurrentNavigation, notifyLinkNavigationStart, setLinkForCurrentNavigation };

package/dist/shims/internal/make-hanging-promise.d.ts

@@ -0,0 +1,15 @@
+//#region src/shims/internal/make-hanging-promise.d.ts
+/**
+ * makeHangingPromise — returns a promise that never resolves during prerendering.
+ *
+ * When prerendering, `io()` must return a hanging promise to prevent
+ * React from executing past the IO boundary. The promise never resolves—it only
+ * rejects if the render signal is aborted (e.g., due to a dynamic error or
+ * cache-fill completion).
+ *
+ * Ported from Next.js: packages/next/src/server/dynamic-rendering-utils.ts
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/dynamic-rendering-utils.ts
+ */
+declare function makeHangingPromise<T>(signal: AbortSignal, route: string, expression: string): Promise<T>;
+//#endregion
+export { makeHangingPromise };

package/dist/shims/internal/make-hanging-promise.js

@@ -0,0 +1,44 @@
+//#region src/shims/internal/make-hanging-promise.ts
+/**
+* makeHangingPromise — returns a promise that never resolves during prerendering.
+*
+* When prerendering, `io()` must return a hanging promise to prevent
+* React from executing past the IO boundary. The promise never resolves—it only
+* rejects if the render signal is aborted (e.g., due to a dynamic error or
+* cache-fill completion).
+*
+* Ported from Next.js: packages/next/src/server/dynamic-rendering-utils.ts
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/dynamic-rendering-utils.ts
+*/
+var HangingPromiseRejectionError = class extends Error {
+	constructor(route, expression) {
+		super(`Route ${route} used ${expression} during prerendering but the render was aborted. This is expected when prerendering is cut short (e.g. due to a dynamic access).`);
+		this.name = "HangingPromiseRejectionError";
+	}
+};
+const abortListenersBySignal = /* @__PURE__ */ new WeakMap();
+function suppressUnhandledRejection() {}
+function makeHangingPromise(signal, route, expression) {
+	if (signal.aborted) {
+		const rejected = Promise.reject(new HangingPromiseRejectionError(route, expression));
+		rejected.catch(suppressUnhandledRejection);
+		return rejected;
+	}
+	const hangingPromise = new Promise((_, reject) => {
+		const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
+		const currentListeners = abortListenersBySignal.get(signal);
+		if (currentListeners) currentListeners.push(boundRejection);
+		else {
+			const listeners = [boundRejection];
+			abortListenersBySignal.set(signal, listeners);
+			signal.addEventListener("abort", () => {
+				for (let i = 0; i < listeners.length; i++) listeners[i]();
+				listeners.length = 0;
+			}, { once: true });
+		}
+	});
+	hangingPromise.catch(suppressUnhandledRejection);
+	return hangingPromise;
+}
+//#endregion
+export { makeHangingPromise };

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,56 @@
+import { getNavigationContext } from "../navigation-context-state.js";
+import { getPagesNavigationContext } from "./pages-router-accessor.js";
+import { getClientNavigationState, 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

@@ -0,0 +1,54 @@
+//#region src/shims/internal/pages-data-fetch-dedup.d.ts
+/**
+ * In-flight request dedup for the Pages Router `/_next/data/<id>/<page>.json`
+ * endpoint.
+ *
+ * Why this exists: when a user (or app code) triggers several near-simultaneous
+ * navigations to the same gSSP route — e.g. clicking the same `<Link>` multiple
+ * times before the first navigation lands — each call to `Router.push` would
+ * otherwise enter its own `navigateClientData()` flow and dispatch its own
+ * `fetch()` against the data endpoint. That balloons server load and breaks
+ * Next.js' documented "one fetch per unique data URL" guarantee.
+ *
+ * Ported from Next.js: `fetchNextData()` in
+ * `packages/next/src/shared/lib/router/router.ts`. Next.js maintains an
+ * `inflightCache` (keyed by the resolved data URL) and reuses the existing
+ * Promise when a concurrent caller asks for the same URL. The entry is
+ * dropped once the fetch settles (success or rejection) so the next
+ * navigation re-fetches fresh.
+ *
+ * Design notes:
+ *
+ * - Callers receive a cloned Response, so each can independently consume the
+ *   body (`.json()`, `.text()`, etc.). The originating Response is never read
+ *   directly by anyone, which keeps subsequent clones legal even after one
+ *   caller has consumed its copy.
+ *
+ * - 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 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)
+ * the entry is removed, and the next call will hit the network again.
+ *
+ * Errors propagate to every concurrent caller — the in-flight entry is
+ * dropped on failure so the next navigation can retry.
+ */
+declare function dedupedPagesDataFetch(dataHref: string, init?: RequestInit): Promise<Response>;
+/**
+ * Drop every cached in-flight entry. Intended for tests; production code
+ * does not need to call this because entries self-evict on settle.
+ */
+declare function clearPagesDataInflight(): void;
+//#endregion
+export { clearPagesDataInflight, dedupedPagesDataFetch };

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

@@ -0,0 +1,121 @@
+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`
+* endpoint.
+*
+* Why this exists: when a user (or app code) triggers several near-simultaneous
+* navigations to the same gSSP route — e.g. clicking the same `<Link>` multiple
+* times before the first navigation lands — each call to `Router.push` would
+* otherwise enter its own `navigateClientData()` flow and dispatch its own
+* `fetch()` against the data endpoint. That balloons server load and breaks
+* Next.js' documented "one fetch per unique data URL" guarantee.
+*
+* Ported from Next.js: `fetchNextData()` in
+* `packages/next/src/shared/lib/router/router.ts`. Next.js maintains an
+* `inflightCache` (keyed by the resolved data URL) and reuses the existing
+* Promise when a concurrent caller asks for the same URL. The entry is
+* dropped once the fetch settles (success or rejection) so the next
+* navigation re-fetches fresh.
+*
+* Design notes:
+*
+* - Callers receive a cloned Response, so each can independently consume the
+*   body (`.json()`, `.text()`, etc.). The originating Response is never read
+*   directly by anyone, which keeps subsequent clones legal even after one
+*   caller has consumed its copy.
+*
+* - 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 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 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)
+* the entry is removed, and the next call will hit the network again.
+*
+* Errors propagate to every concurrent caller — the in-flight entry is
+* dropped on failure so the next navigation can retry.
+*/
+function dedupedPagesDataFetch(dataHref, init) {
+	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) {
+		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 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
+export { clearPagesDataInflight, dedupedPagesDataFetch };

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

@@ -0,0 +1,62 @@
+//#region src/shims/internal/pages-data-target.d.ts
+type PagesDataTarget = {
+  /** Final fetch URL for the data endpoint, including basePath and search. */dataHref: string; /** Matched route pattern (e.g. `/blog/[slug]`). */
+  pattern: string; /** Dynamic params extracted from the URL by the pattern matcher. */
+  params: Record<string, string | string[]>; /** Code-split loader thunk for the matched route's page module. */
+  loader: () => Promise<{
+    default?: unknown;
+    [key: string]: unknown;
+  }>; /** Current buildId snapshot, used by the data URL and consistency checks. */
+  buildId: string; /** Locale-prefixed (server-routable) page path. */
+  pagePath: string; /** URL search string including the leading `?`. */
+  search: string;
+  /**
+   * Locale prefix detected on the URL, or `undefined` when the URL is
+   * unprefixed (default locale, or no i18n configured). Lets the caller refresh
+   * locale state on locale transitions, which the data JSON envelope itself
+   * does not carry.
+   */
+  locale: string | undefined;
+};
+/**
+ * Decide whether the JSON data-endpoint navigation path is usable for this
+ * browser URL. We require:
+ *   - A registered code-split loader for the matched route pattern. Without
+ *     this, the client has no chunk URL to import for the new page.
+ *   - A buildId on the current `__NEXT_DATA__`, since the data URL embeds it.
+ *   - Same-origin (cross-origin URLs do not hit our data endpoint).
+ *
+ * Locale handling: route patterns in `__VINEXT_PAGE_PATTERNS__` are
+ * locale-unaware (`/about`, not `/fr/about`), but the browser URL for a
+ * locale-prefixed page is `/fr/about`. We strip the locale prefix before
+ * pattern matching so locale transitions hit the JSON fast path. The data URL
+ * itself keeps the locale prefix because the server uses it to pick
+ * locale-specific gSSP data.
+ *
+ * Returns the resolved target, or `null` to signal the caller should fall
+ * back to the HTML extraction path (dev server, or a route that exists on the
+ * server but is not in the client loader map).
+ *
+ * Ported from Next.js: `packages/next/src/client/page-loader.ts`
+ * (`getDataHref`). vinext's equivalent uses an in-memory loader map instead
+ * of Next.js' `_buildManifest.js`.
+ */
+declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath: string): PagesDataTarget | null;
+/**
+ * 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
+ * best-effort and must never break the page.
+ */
+declare function prefetchPagesData(target: PagesDataTarget): void;
+//#endregion
+export { PagesDataTarget, prefetchPagesData, resolvePagesDataNavigationTarget };