vinext 0.2.0 → 0.2.1

package/dist/shims/fetch-cache.js

@@ -3,6 +3,7 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { markDynamicUsage } from "./headers.js";
+import { _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { encodeCacheTags } from "../utils/encode-cache-tag.js";
 //#region src/shims/fetch-cache.ts
 /**
@@ -296,6 +297,7 @@ const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	currentFetchCacheMode: null,
 	currentForceDynamicFetchDefault: false,
 	dynamicFetchUrls: /* @__PURE__ */ new Set(),
+	refreshStaleFetchesInForeground: false,
 	isFetchDedupeActive: false,
 	currentFetchDedupeEntries: /* @__PURE__ */ new Map()
 };
@@ -314,6 +316,7 @@ function _resetFallbackState(isFetchDedupeActive) {
 	_fallbackState.currentFetchCacheMode = null;
 	_fallbackState.currentForceDynamicFetchDefault = false;
 	_fallbackState.dynamicFetchUrls = /* @__PURE__ */ new Set();
+	_fallbackState.refreshStaleFetchesInForeground = false;
 	_fallbackState.isFetchDedupeActive = isFetchDedupeActive;
 	_fallbackState.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 }
@@ -330,6 +333,56 @@ function markUncachedFetchForPageOutput(input) {
 function recordCacheableFetchObservation(input) {
 	_getState().cacheableFetchUrls.add(getFetchObservationUrl(input));
 }
+function recordFiniteFetchRevalidate(revalidateSeconds) {
+	if (Number.isFinite(revalidateSeconds) && revalidateSeconds > 0) _setRequestScopedCacheLife({ revalidate: revalidateSeconds });
+}
+function shouldRefreshStaleFetchInForeground() {
+	return _getState().refreshStaleFetchesInForeground;
+}
+async function buildFetchCacheValue(response, tags, revalidateSeconds, options) {
+	if (response.status !== 200) return null;
+	const responseForCache = options?.cloneForReturn === false ? response : response.clone();
+	const body = await responseForCache.text();
+	const headers = {};
+	responseForCache.headers.forEach((v, k) => {
+		if (k.toLowerCase() === "set-cookie") return;
+		headers[k] = v;
+	});
+	return {
+		kind: "FETCH",
+		data: {
+			headers,
+			body,
+			url: response.url,
+			status: responseForCache.status
+		},
+		tags,
+		revalidate: revalidateSeconds
+	};
+}
+async function writeFetchCacheResponse(handler, cacheKey, response, tags, revalidateSeconds, options) {
+	const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds, options);
+	if (!cacheValue) return;
+	await handler.set(cacheKey, cacheValue, {
+		fetchCache: true,
+		tags,
+		revalidate: revalidateSeconds
+	});
+}
+async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue, tags, revalidateSeconds) {
+	if (!Number.isFinite(revalidateSeconds) || revalidateSeconds <= 0 || typeof cachedValue.revalidate !== "number" || cachedValue.revalidate <= revalidateSeconds) return;
+	const mergedTags = Array.from(new Set([...cachedValue.tags ?? [], ...tags]));
+	const updatedValue = {
+		...cachedValue,
+		tags: mergedTags,
+		revalidate: revalidateSeconds
+	};
+	await handler.set(cacheKey, updatedValue, {
+		fetchCache: true,
+		tags: mergedTags,
+		revalidate: revalidateSeconds
+	});
+}
 function peekCacheableFetchObservations() {
 	return [..._getState().cacheableFetchUrls].sort();
 }
@@ -393,6 +446,9 @@ function setCurrentFetchCacheMode(mode) {
 function setCurrentForceDynamicFetchDefault(enabled) {
 	_getState().currentForceDynamicFetchDefault = enabled;
 }
+function setRefreshStaleFetchesInForeground(enabled) {
+	_getState().refreshStaleFetchesInForeground = enabled;
+}
 function isNoStoreFetch(cacheDirective, nextOpts) {
 	return cacheDirective === "no-store" || cacheDirective === "no-cache" || nextOpts?.revalidate === 0;
 }
@@ -562,6 +618,7 @@ function createPatchedFetch() {
 			return dedupeFetch(input, cleanInit);
 		}
 		recordCacheableFetchObservation(input);
+		recordFiniteFetchRevalidate(revalidateSeconds);
 		const reqTags = _getState().currentRequestTags;
 		const tags = encodeCacheTags(nextOpts?.tags ?? []);
 		if (tags.length > 0) {
@@ -586,39 +643,24 @@ function createPatchedFetch() {
 			const cached = await handler.get(cacheKey, {
 				kind: "FETCH",
 				tags,
-				softTags
+				softTags,
+				revalidate: revalidateSeconds
 			});
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState !== "stale") {
+				await lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cached.value, tags, revalidateSeconds);
 				const cachedData = cached.value.data;
 				return buildCachedFetchResponse(cachedData, input);
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState === "stale") {
+				if (shouldRefreshStaleFetchInForeground()) {
+					const freshResponse = await dedupeFetch(input, fetchInit);
+					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds);
+					return freshResponse;
+				}
 				const staleData = cached.value.data;
 				if (!pendingRefetches.has(cacheKey)) {
 					const refetchPromise = originalFetch(input, fetchInit).then(async (freshResp) => {
-						if (freshResp.status !== 200) return;
-						const freshBody = await freshResp.text();
-						const freshHeaders = {};
-						freshResp.headers.forEach((v, k) => {
-							if (k.toLowerCase() === "set-cookie") return;
-							freshHeaders[k] = v;
-						});
-						const freshValue = {
-							kind: "FETCH",
-							data: {
-								headers: freshHeaders,
-								body: freshBody,
-								url: freshResp.url,
-								status: freshResp.status
-							},
-							tags,
-							revalidate: revalidateSeconds
-						};
-						await handler.set(cacheKey, freshValue, {
-							fetchCache: true,
-							tags,
-							revalidate: revalidateSeconds
-						});
+						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, { cloneForReturn: false });
 					}).catch((err) => {
 						const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 						console.error(`[vinext] fetch cache background revalidation failed for ${url} (key=${cacheKey.slice(0, 12)}...):`, err);
@@ -638,33 +680,14 @@ function createPatchedFetch() {
 			console.error("[vinext] fetch cache read error:", cacheErr);
 		}
 		const response = await dedupeFetch(input, fetchInit);
-		if (response.status === 200) {
-			const cloned = response.clone();
-			const body = await cloned.text();
-			const headers = {};
-			cloned.headers.forEach((v, k) => {
-				if (k.toLowerCase() === "set-cookie") return;
-				headers[k] = v;
-			});
-			const cacheValue = {
-				kind: "FETCH",
-				data: {
-					headers,
-					body,
-					url: response.url,
-					status: cloned.status
-				},
-				tags,
-				revalidate: revalidateSeconds
-			};
-			handler.set(cacheKey, cacheValue, {
-				fetchCache: true,
-				tags,
-				revalidate: revalidateSeconds
-			}).catch((err) => {
-				console.error("[vinext] fetch cache write error:", err);
-			});
-		}
+		const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds);
+		if (cacheValue) handler.set(cacheKey, cacheValue, {
+			fetchCache: true,
+			tags,
+			revalidate: revalidateSeconds
+		}).catch((err) => {
+			console.error("[vinext] fetch cache write error:", err);
+		});
 		return response;
 	};
 }
@@ -716,6 +739,7 @@ async function runWithFetchCache(fn) {
 		uCtx.currentRequestTags = [];
 		uCtx.currentFetchSoftTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+		uCtx.refreshStaleFetchesInForeground = false;
 		uCtx.isFetchDedupeActive = true;
 		uCtx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
 	}, fn);
@@ -726,6 +750,7 @@ async function runWithFetchCache(fn) {
 		currentFetchCacheMode: null,
 		currentForceDynamicFetchDefault: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
+		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: true,
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map()
 	}, fn);
@@ -763,4 +788,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/form.d.ts

@@ -16,6 +16,6 @@ declare const Form: import("react").ForwardRefExoticComponent<{
    * In pages dir, prefetch is not supported and the prop has no effect.
    */
   prefetch?: false | null;
-} & Omit<FormHTMLAttributes<HTMLFormElement>, "method" | "encType" | "target"> & import("react").RefAttributes<HTMLFormElement>>;
+} & Omit<FormHTMLAttributes<HTMLFormElement>, "target" | "method" | "encType"> & import("react").RefAttributes<HTMLFormElement>>;
 //#endregion
 export { createFormSubmitDestinationUrl, Form as default, useActionState };

package/dist/shims/internal/app-prefetch-fetch-queue.d.ts

@@ -0,0 +1,10 @@
+//#region src/shims/internal/app-prefetch-fetch-queue.d.ts
+declare function releaseAppPrefetchFetchSlot(response: Response): void;
+/**
+ * Low-priority App Router prefetches share a small request queue. The consumer
+ * must either snapshot the returned Response with snapshotRscResponse() or call
+ * releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
+ */
+declare function scheduleAppPrefetchFetch(fetcher: () => Promise<Response>, priority: "low" | "high"): Promise<Response>;
+//#endregion
+export { releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };

package/dist/shims/internal/app-prefetch-fetch-queue.js

@@ -0,0 +1,61 @@
+"use client";
+//#region src/shims/internal/app-prefetch-fetch-queue.ts
+const APP_PREFETCH_FETCH_SLOT_RELEASE_KEY = Symbol.for("vinext.appPrefetchFetchSlotRelease");
+const MAX_DEFAULT_APP_PREFETCH_REQUESTS = 4;
+const defaultAppPrefetchQueue = [];
+let activeDefaultAppPrefetchRequests = 0;
+let defaultAppPrefetchDrainScheduled = false;
+function drainDefaultAppPrefetchQueue() {
+	defaultAppPrefetchDrainScheduled = false;
+	while (activeDefaultAppPrefetchRequests < MAX_DEFAULT_APP_PREFETCH_REQUESTS) {
+		const run = defaultAppPrefetchQueue.shift();
+		if (!run) return;
+		activeDefaultAppPrefetchRequests += 1;
+		run();
+	}
+}
+function scheduleDefaultAppPrefetchDrain() {
+	if (defaultAppPrefetchDrainScheduled) return;
+	defaultAppPrefetchDrainScheduled = true;
+	queueMicrotask(drainDefaultAppPrefetchQueue);
+}
+function releaseAppPrefetchFetchSlot(response) {
+	const release = response[APP_PREFETCH_FETCH_SLOT_RELEASE_KEY];
+	if (release === void 0) return;
+	response[APP_PREFETCH_FETCH_SLOT_RELEASE_KEY] = void 0;
+	release();
+}
+/**
+* Low-priority App Router prefetches share a small request queue. The consumer
+* must either snapshot the returned Response with snapshotRscResponse() or call
+* releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
+*/
+function scheduleAppPrefetchFetch(fetcher, priority) {
+	if (priority === "high") return fetcher();
+	return new Promise((resolve, reject) => {
+		defaultAppPrefetchQueue.push(() => {
+			let didRelease = false;
+			const release = () => {
+				if (didRelease) return;
+				didRelease = true;
+				activeDefaultAppPrefetchRequests -= 1;
+				drainDefaultAppPrefetchQueue();
+			};
+			try {
+				fetcher().then((response) => {
+					response[APP_PREFETCH_FETCH_SLOT_RELEASE_KEY] = release;
+					resolve(response);
+				}, (error) => {
+					release();
+					reject(error);
+				});
+			} catch (error) {
+				release();
+				reject(error);
+			}
+		});
+		scheduleDefaultAppPrefetchDrain();
+	});
+}
+//#endregion
+export { releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };

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

@@ -1,6 +1,7 @@
 import { HybridClientOwner } from "./hybrid-client-route-owner-direct.js";
 
 //#region src/shims/internal/hybrid-client-route-owner.d.ts
+declare function resolveHybridClientRewriteHref(href: string, basePath: string): string | null;
 /**
  * Decide which router should own a soft-navigated URL. Returns:
  *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
@@ -15,4 +16,4 @@ import { HybridClientOwner } from "./hybrid-client-route-owner-direct.js";
  */
 declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
 //#endregion
-export { type HybridClientOwner, resolveHybridClientRouteOwner };
+export { type HybridClientOwner, resolveHybridClientRewriteHref, resolveHybridClientRouteOwner };

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

@@ -49,6 +49,39 @@ function resolveClientRewrite(href, basePath, rewrites, continueAfterMatch = fal
 		kind: "rewrite"
 	} : null;
 }
+function resolveHybridClientRewriteHref(href, basePath) {
+	if (typeof window === "undefined") return null;
+	const rewrites = window.__VINEXT_CLIENT_REWRITES__;
+	if (!rewrites) return null;
+	let currentHref = href;
+	let didRewrite = false;
+	const beforeFilesRewrite = resolveClientRewrite(currentHref, basePath, rewrites.beforeFiles, true);
+	if (beforeFilesRewrite?.kind === "document") return null;
+	if (beforeFilesRewrite?.kind === "rewrite") {
+		currentHref = beforeFilesRewrite.href;
+		didRewrite = true;
+	}
+	let matches = matchDirectHybridClientRoutes(currentHref, basePath);
+	if ((matches.appMatch === null || matches.appMatch.isDynamic) && (matches.pagesMatch === null || matches.pagesMatch.isDynamic)) for (const rewrite of rewrites.afterFiles) {
+		const afterFilesRewrite = resolveClientRewrite(currentHref, basePath, [rewrite]);
+		if (afterFilesRewrite?.kind === "document") return didRewrite ? currentHref : null;
+		if (afterFilesRewrite?.kind !== "rewrite") continue;
+		currentHref = afterFilesRewrite.href;
+		didRewrite = true;
+		matches = matchDirectHybridClientRoutes(currentHref, basePath);
+		if (matches.appMatch || matches.pagesMatch) break;
+	}
+	if (matches.appMatch === null && matches.pagesMatch === null) for (const rewrite of rewrites.fallback) {
+		const fallbackRewrite = resolveClientRewrite(currentHref, basePath, [rewrite]);
+		if (fallbackRewrite?.kind === "document") return didRewrite ? currentHref : null;
+		if (fallbackRewrite?.kind !== "rewrite") continue;
+		currentHref = fallbackRewrite.href;
+		didRewrite = true;
+		matches = matchDirectHybridClientRoutes(currentHref, basePath);
+		if (matches.appMatch || matches.pagesMatch) break;
+	}
+	return didRewrite ? currentHref : null;
+}
 /**
 * Decide which router should own a soft-navigated URL. Returns:
 *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
@@ -89,4 +122,4 @@ function resolveHybridClientRouteOwner(href, basePath) {
 	return resolveMatchedHybridClientRouteOwner(matches);
 }
 //#endregion
-export { resolveHybridClientRouteOwner };
+export { resolveHybridClientRewriteHref, resolveHybridClientRouteOwner };

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

@@ -35,6 +35,7 @@
 declare function getPagesStaticDataCache(): Record<string, Promise<Response>>;
 declare function fetchCachedPagesData(dataHref: string, init?: RequestInit): Promise<Response>;
 declare function fetchStaticPagesData(dataHref: string, init?: RequestInit): Promise<Response>;
+declare function fetchUncachedPagesData(dataHref: string, init?: RequestInit): Promise<Response>;
 declare function evictPagesDataCache(dataHref: string): void;
 /**
  * Dedupe a `fetch()` against the `_next/data` endpoint. Multiple concurrent
@@ -55,4 +56,4 @@ declare function dedupedPagesDataFetch(dataHref: string, init?: RequestInit): Pr
  */
 declare function clearPagesDataInflight(): void;
 //#endregion
-export { clearPagesDataInflight, dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, getPagesStaticDataCache };
+export { clearPagesDataInflight, dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, fetchUncachedPagesData, getPagesStaticDataCache };

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

@@ -1,3 +1,4 @@
+import "../../utils/protocol-headers.js";
 import { getDeploymentId } from "../../utils/deployment-id.js";
 //#region src/shims/internal/pages-data-fetch-dedup.ts
 /**
@@ -71,7 +72,7 @@ function fetchCachedPagesData(dataHref, init) {
 		cached = dedupedPagesDataFetch(dataHref, sharedInit).then((response) => {
 			const expectedDeploymentId = getDeploymentId() ?? null;
 			const responseDeploymentId = response.headers.get("x-nextjs-deployment-id");
-			if (!response.ok || response.headers.get("x-middleware-cache") === "no-cache" || responseDeploymentId !== null && responseDeploymentId !== expectedDeploymentId) {
+			if (!response.ok || response.headers.get("x-middleware-cache") === "no-cache" || response.headers.get("x-middleware-skip") !== null || responseDeploymentId !== null && responseDeploymentId !== expectedDeploymentId) {
 				delete staticDataCache[key];
 				staticDataSources.delete(key);
 			}
@@ -91,6 +92,16 @@ function fetchCachedPagesData(dataHref, init) {
 function fetchStaticPagesData(dataHref, init) {
 	return fetchCachedPagesData(dataHref, init);
 }
+function fetchUncachedPagesData(dataHref, init) {
+	return fetch(dataHref, init).then(async (response) => {
+		const body = await response.arrayBuffer();
+		return new Response(body, {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	});
+}
 function evictPagesDataCache(dataHref) {
 	const key = getStaticDataKey(dataHref);
 	delete staticDataCache[key];
@@ -177,4 +188,4 @@ function clearPagesDataInflight() {
 	for (const key of Object.keys(staticDataCache)) delete staticDataCache[key];
 }
 //#endregion
-export { clearPagesDataInflight, dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, getPagesStaticDataCache };
+export { clearPagesDataInflight, dedupedPagesDataFetch, evictPagesDataCache, fetchCachedPagesData, fetchStaticPagesData, fetchUncachedPagesData, getPagesStaticDataCache };

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

@@ -1,6 +1,7 @@
 //#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]`). */
+  /** Final fetch URL for the data endpoint, including basePath and search. */dataHref: string; /** Locale-qualified data endpoint used by Pages Router prefetch. */
+  prefetchDataHref?: 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<{
@@ -11,7 +12,8 @@ type PagesDataTarget = {
   middlewareDataHref?: string; /** 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;
+  search: string; /** Locale selected for middleware-prefetch data URLs when the visible URL is unprefixed. */
+  prefetchLocale?: string;
   /**
    * Locale prefix detected on the URL, or `undefined` when the URL is
    * unprefixed (default locale, or no i18n configured). Lets the caller refresh
@@ -20,6 +22,9 @@ type PagesDataTarget = {
    */
   locale: string | undefined;
 };
+type PagesDataNavigationTargetOptions = {
+  locale?: string | false;
+};
 declare function getPagesMiddlewareDataHref(browserUrl: string, basePath: string): string | null;
 /**
  * Decide whether the JSON data-endpoint navigation path is usable for this
@@ -44,7 +49,7 @@ declare function getPagesMiddlewareDataHref(browserUrl: string, basePath: string
  * (`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;
+declare function resolvePagesDataNavigationTarget(browserUrl: string, basePath: string, options?: PagesDataNavigationTargetOptions): PagesDataTarget | null;
 /**
  * Kick off the code-split loader and, for SSG pages, prefetch the data JSON so
  * the chunk and payload are warm by the time the user clicks.

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

@@ -3,7 +3,7 @@ import { isUnknownRecord } from "../../utils/record.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 { fetchCachedPagesData, fetchStaticPagesData } from "./pages-data-fetch-dedup.js";
+import { fetchStaticPagesData, fetchUncachedPagesData } 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`
@@ -106,7 +106,7 @@ function getPagesMiddlewareDataHref(browserUrl, basePath) {
 * (`getDataHref`). vinext's equivalent uses an in-memory loader map instead
 * of Next.js' `_buildManifest.js`.
 */
-function resolvePagesDataNavigationTarget(browserUrl, basePath) {
+function resolvePagesDataNavigationTarget(browserUrl, basePath, options = {}) {
 	if (typeof window === "undefined") return null;
 	const loaders = window.__VINEXT_PAGE_LOADERS__;
 	const patterns = window.__VINEXT_PAGE_PATTERNS__;
@@ -129,8 +129,12 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 	const ssgPatterns = window.__VINEXT_PAGES_SSG_PATTERNS__;
 	const sspPatterns = window.__VINEXT_PAGES_SSP_PATTERNS__;
 	const dataKind = ssgPatterns?.includes(match.pattern) ? "static" : sspPatterns?.includes(match.pattern) ? "server" : ssgPatterns === void 0 || sspPatterns === void 0 ? "server" : "none";
+	const explicitLocale = options.locale === false ? window.__VINEXT_DEFAULT_LOCALE__ : options.locale;
+	const currentLocale = locale ?? explicitLocale ?? window.__VINEXT_LOCALE__;
+	const prefetchPagePath = locale || !currentLocale || !window.__VINEXT_LOCALES__?.includes(currentLocale) ? pagePath : `/${currentLocale}${pagePath === "/" ? "" : pagePath}`;
 	return {
 		dataHref: buildPagesDataHref(basePath, buildId, pagePath, parsed.search),
+		prefetchDataHref: buildPagesDataHref(basePath, buildId, prefetchPagePath, parsed.search),
 		pattern: match.pattern,
 		params: match.params,
 		loader,
@@ -139,6 +143,7 @@ function resolvePagesDataNavigationTarget(browserUrl, basePath) {
 		buildId,
 		pagePath,
 		search: parsed.search,
+		prefetchLocale: currentLocale,
 		locale
 	};
 }
@@ -168,10 +173,10 @@ function prefetchPagesData(target) {
 	const deploymentId = getDeploymentId();
 	if (deploymentId) headers[NEXT_DEPLOYMENT_ID_HEADER] = deploymentId;
 	if (target.dataKind === "static") {
-		fetchStaticPagesData(target.middlewareDataHref ?? target.dataHref, { headers }).catch(() => {});
+		fetchStaticPagesData(target.middlewareDataHref && target.middlewareDataHref !== target.dataHref ? target.middlewareDataHref : target.prefetchDataHref ?? target.middlewareDataHref ?? target.dataHref, { headers }).then((response) => response.arrayBuffer()).catch(() => {});
 		return;
 	}
-	if (target.middlewareDataHref) fetchCachedPagesData(target.middlewareDataHref, { headers }).catch(() => {});
+	if (target.middlewareDataHref) fetchUncachedPagesData(target.middlewareDataHref, { headers }).catch(() => {});
 }
 //#endregion
 export { getPagesMiddlewareDataHref, prefetchPagesData, resolvePagesDataNavigationTarget };

package/dist/shims/link.d.ts

@@ -42,7 +42,7 @@ type LinkProps = {
   onNavigate?: (event: NavigateEvent) => void;
   children?: React.ReactNode;
 } & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href">;
-type LinkPrefetchMode = "disabled" | "auto" | "full";
+type LinkPrefetchMode = "disabled" | "auto" | "full" | "full-after-shell";
 declare global {
   interface Window {
     __VINEXT_LINK_PREFETCH_ROUTES__?: VinextLinkPrefetchRoute[];