cloudflare-next-intl 0.9.45 → 0.9.47

package/README.md

@@ -266,6 +266,7 @@ export default defineConfig({
 4. **User-Agent Stub (`userAgentStub`)**: Prevents Next.js `user-agent` from importing `node:fs` during workerd runtime execution (which otherwise causes runtime 404 / 500 crashes in Workers proxy/middleware).
 5. **Cloudflare Workers Client Stub (`cfWorkersClientStub`)**: Stubs `cloudflare:workers` in client builds so shared modules can be referenced without client bundling errors.
 6. **Build ID Asset Emission (`buildIdAsset`)**: Emits `BUILD_ID` static asset in the client build directory from `process.env.__VINEXT_SHARED_BUILD_ID` or `process.env.__VINEXT_BUILD_ID`.
+7. **Vinext Route Wiring & Optimistic Prefetch Fix (`vinextRouteWiringFix`)**: Patches Vinext runtime route wiring, route matching, optimistic route template resolution, and prefetch learning so pending prefetches with already cached templates don't block navigation, and leading `:locale` segments route correctly.
 
 ##### Plugin Options
 All features are enabled by default, and can be individually configured or toggled off:
@@ -297,13 +298,14 @@ export default defineConfig({
             localeFiles: true,                    // Enable @locale-file & glob bundling (default: true)
             userAgentStub: true,                  // Enable regex-based user-agent stub (default: true)
             cfWorkersClientStub: true,            // Enable client cloudflare:workers stub (default: true)
+            vinextRouteWiringFix: true,           // Enable vinext route wiring, matching, and prefetch fixes (default: true, or options object)
         }),
     ],
 });
 ```
 
 Individual standalone plugins are also exported if you only need a specific feature:
-`imageOptimizerPlugin` (or `imageOptimizer`), `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`.
+`imageOptimizerPlugin` (or `imageOptimizer`), `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`, `vinextRouteWiringFixPlugin`.
 
 ##### Per-Image Optimizer Settings
 

package/dist/src/dynamic_pages_check/resolve_local_imports.js

@@ -22,8 +22,6 @@ function bindingsFromClause(clause) {
     const namespaceMatch = /^\*\s*as\s+(\w+)$/.exec(clause.trim());
     if (namespaceMatch)
         return [namespaceMatch[1]];
-    if (clause.trim() === '*')
-        return [];
     const braceMatch = /\{([^}]*)\}/.exec(clause);
     if (braceMatch) {
         for (const rawItem of braceMatch[1].split(',')) {

package/dist/src/vite/vinext_route_wiring_fix.d.ts

@@ -7,6 +7,10 @@ export declare function patchRouteMatching(code: string): string;
 export declare function isOptimisticRoutingFile(id: string): boolean;
 export declare function isOptimisticRoutingAlreadyFixed(code: string): boolean;
 export declare function patchOptimisticRouting(code: string): string;
+export declare function isPrefetchLearningFile(id: string): boolean;
+export declare function isPrefetchLearningAlreadyFixed(code: string): boolean;
+export declare function patchPrefetchLearning(code: string): string;
+export declare function resolveVinextBrowserEntryPath(root?: string): string | null;
 export declare function isAppPageRouteWiringFile(id: string): boolean;
 export declare function resolveVinextAppPageRouteWiringPath(root?: string): string | null;
 export declare function resolveVinextRouteMatchingPath(root?: string): string | null;
@@ -15,11 +19,14 @@ export interface SyncPatchVinextOnDiskOptions {
     routeWiring?: boolean;
     routeMatching?: boolean;
     optimisticRouting?: boolean;
+    prefetchLearning?: boolean;
 }
 export declare function syncPatchVinextOnDisk(root?: string, options?: SyncPatchVinextOnDiskOptions): boolean;
+export declare function bustVinextOptimizeDepsCache(cacheDir: string): boolean;
 export interface VinextRouteWiringFixPluginOptions {
     routeWiring?: boolean;
     routeMatching?: boolean;
     optimisticRouting?: boolean;
+    prefetchLearning?: boolean;
 }
 export declare function vinextRouteWiringFixPlugin(options?: VinextRouteWiringFixPluginOptions): Plugin;

package/dist/src/vite/vinext_route_wiring_fix.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
 const PREFETCH_LOADING_FN_RE = /function\s+getPrefetchLoadingEntry\s*\(\s*route\s*\)\s*\{[\s\S]*?return\s+getDefaultExport\s*\(\s*route\.loading\s*\)\s*\?[\s\S]*?:\s*null\s*;\s*\}/;
 const FIXED_PREFETCH_LOADING_FN = `function getPrefetchLoadingEntry(route) {
@@ -113,14 +113,17 @@ export function isOptimisticRoutingAlreadyFixed(code) {
     const hasRawPartsFix = code.includes("options.rawUrlParts[0] !== options.match.params.locale");
     return hasLocalePrefixFirst && hasRawPartsFix;
 }
-const MATCH_OPTIMISTIC_ROUTE_RE = /function\s+matchOptimisticRouteManifestRoute\s*\(\s*options\s*\)\s*\{[\s\S]*?const\s+trie\s*=\s*getRouteTrie\([\s\S]*?\);[\s\S]*?const\s+match\s*=\s*matchNode\([\s\S]*?\);[\s\S]*?return\s+null;\s*\}/;
-const FIXED_MATCH_OPTIMISTIC_ROUTE = `function matchOptimisticRouteManifestRoute(options) {
+const MATCH_OPTIMISTIC_ROUTE_RE = /function\s+matchOptimisticRouteManifestRoute\s*\(\s*options\s*\)\s*\{[\s\S]*?getRouteTrie\([\s\S]*?\)[\s\S]*?\n\}/;
+const FIXED_MATCH_OPTIMISTIC_ROUTE = `function getActiveRouteLocale() {
+	return (typeof document !== "undefined" && (document.documentElement?.lang || document.cookie.match(/__user_locale_key__=([^;]+)/)?.[1])) || (typeof window !== "undefined" && window.__VINEXT_LOCALE__) || "en";
+}
+function matchOptimisticRouteManifestRoute(options) {
 	const urlParts = hrefToRouteParts(options.href, options.basePath);
 	if (urlParts === null) return null;
 	const trie = getRouteTrie(options.routeManifest);
 	const hasLeadingLocaleParam = Array.from(options.routeManifest?.segmentGraph?.routes?.values() ?? []).some((r) => r.patternParts?.[0] === ":locale");
 	if (hasLeadingLocaleParam) {
-		const activeLocale = (typeof document !== "undefined" && (document.documentElement?.lang || document.cookie.match(/__user_locale_key__=([^;]+)/)?.[1])) || (typeof window !== "undefined" && window.__VINEXT_LOCALE__) || "en";
+		const activeLocale = getActiveRouteLocale();
 		if (urlParts.normalized[0] !== activeLocale) {
 			const localeMatch = matchNode(trie, [activeLocale, ...urlParts.normalized], 0, []);
 			if (localeMatch !== null) {
@@ -147,14 +150,109 @@ export function patchOptimisticRouting(code) {
         return code;
     }
     let result = code;
-    if (MATCH_OPTIMISTIC_ROUTE_RE.test(result)) {
+    if (!result.includes("hasLeadingLocaleParam") && MATCH_OPTIMISTIC_ROUTE_RE.test(result)) {
         result = result.replace(MATCH_OPTIMISTIC_ROUTE_RE, FIXED_MATCH_OPTIMISTIC_ROUTE);
     }
-    if (RESOLVE_OPTIMISTIC_NAV_PARAMS_RE.test(result)) {
+    if (!result.includes("options.rawUrlParts[0] !== options.match.params.locale") && RESOLVE_OPTIMISTIC_NAV_PARAMS_RE.test(result)) {
         result = result.replace(RESOLVE_OPTIMISTIC_NAV_PARAMS_RE, FIXED_RESOLVE_OPTIMISTIC_NAV_PARAMS);
     }
     return result;
 }
+export function isPrefetchLearningFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-browser-entry.js") || cleanId.endsWith("/app-browser-entry.ts");
+}
+export function isPrefetchLearningAlreadyFixed(code) {
+    const hasFixedFunction = code.includes("stripRsc(parsePrefetchCacheKey(cacheKey).rscUrl)") && code.includes("hasOptimisticTemplate");
+    const hasFixedCallSite = code.includes("targetHref: currentHref,") && code.includes("targetRscUrl: rscUrl,") && !LEARN_TEMPLATES_CALL_RE.test(code);
+    return hasFixedFunction && hasFixedCallSite;
+}
+const LEARN_TEMPLATES_FN_RE = /async\s+function\s+learnOptimisticRouteTemplatesFromPrefetchCache\s*\(\s*options\s*\)\s*\{[\s\S]*?await\s+Promise\.allSettled\(\s*learning\s*\);\s*\}/;
+const FIXED_LEARN_TEMPLATES_FN = `async function learnOptimisticRouteTemplatesFromPrefetchCache(options) {
+	if (options.routeManifest === null) return;
+	const hasOptimisticTemplate = options.targetHref !== void 0 && resolveOptimisticNavigationPayload({
+		basePath: __basePath,
+		href: options.targetHref,
+		interceptionContext: options.interceptionContext,
+		mountedSlotsHeader: options.mountedSlotsHeader,
+		routeManifest: options.routeManifest,
+		templates: optimisticRouteTemplates
+	}) !== null;
+	const stripRsc = (u) => {
+		if (!u) return "";
+		const q = u.indexOf("?");
+		if (q === -1) return u;
+		const sp = new URLSearchParams(u.slice(q + 1));
+		sp.delete("_rsc");
+		sp.delete("%5Frsc");
+		const s = sp.toString();
+		return s ? \`\${u.slice(0, q)}?\${s}\` : u.slice(0, q);
+	};
+	const learning = [...optimisticRouteTemplateLearning.values()];
+	for (const [cacheKey, entry] of getPrefetchCache()) {
+		const sourceKey = getOptimisticPrefetchSourceKey({
+			cacheKey,
+			interceptionContext: options.interceptionContext,
+			mountedSlotsHeader: options.mountedSlotsHeader
+		});
+		if (optimisticRouteTemplateSources.has(sourceKey)) continue;
+		if (optimisticRouteTemplateLearning.has(sourceKey)) continue;
+		if (entry.prefetchKind === "route-tree") continue;
+		const isPendingNavigationTarget = !hasOptimisticTemplate && !isSettledPrefetchCacheEntry(entry) && entry.pending !== void 0 && options.targetRscUrl !== void 0 && stripRsc(parsePrefetchCacheKey(cacheKey).rscUrl) === stripRsc(options.targetRscUrl);
+		if (!isSettledPrefetchCacheEntry(entry) && !isPendingNavigationTarget) continue;
+		const promise = (async () => {
+			let settledEntry = entry;
+			if (!isSettledPrefetchCacheEntry(settledEntry)) {
+				await Promise.race([
+					settledEntry.pending?.catch(() => {}),
+					new Promise((resolve) => setTimeout(resolve, 3000))
+				]);
+				settledEntry = getPrefetchCache().get(cacheKey) ?? settledEntry;
+				if (!isSettledPrefetchCacheEntry(settledEntry)) return;
+			}
+			return learnOptimisticRouteTemplateFromPrefetch({
+				cacheKey,
+				entry: settledEntry,
+				interceptionContext: options.interceptionContext,
+				mountedSlotsHeader: options.mountedSlotsHeader,
+				routeManifest: options.routeManifest
+			});
+		})().then((learned) => {
+			if (learned) optimisticRouteTemplateSources.add(sourceKey);
+		}).finally(() => {
+			optimisticRouteTemplateLearning.delete(sourceKey);
+		});
+		optimisticRouteTemplateLearning.set(sourceKey, promise);
+		learning.push(promise);
+	}
+	if (learning.length === 0) return;
+	await Promise.allSettled(learning);
+}`;
+const LEARN_TEMPLATES_CALL_RE = /await\s+learnOptimisticRouteTemplatesFromPrefetchCache\(\s*\{\s*interceptionContext:\s*requestInterceptionContext,\s*(targetRscUrl:\s*rscUrl,\s*)?mountedSlotsHeader,[\s\S]*?routeManifest\s*\n\s*\}\);/;
+const FIXED_LEARN_TEMPLATES_CALL = `await learnOptimisticRouteTemplatesFromPrefetchCache({
+							interceptionContext: requestInterceptionContext,
+							targetHref: currentHref,
+							targetRscUrl: rscUrl,
+							mountedSlotsHeader,
+							routeManifest
+						});`;
+export function patchPrefetchLearning(code) {
+    if (isPrefetchLearningAlreadyFixed(code)) {
+        return code;
+    }
+    let result = code;
+    if (!result.includes("hasOptimisticTemplate") && LEARN_TEMPLATES_FN_RE.test(result)) {
+        result = result.replace(LEARN_TEMPLATES_FN_RE, FIXED_LEARN_TEMPLATES_FN);
+    }
+    if (LEARN_TEMPLATES_CALL_RE.test(result)) {
+        result = result.replace(LEARN_TEMPLATES_CALL_RE, FIXED_LEARN_TEMPLATES_CALL);
+    }
+    return result;
+}
+export function resolveVinextBrowserEntryPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-browser-entry.js");
+    return existsSync(directPath) ? directPath : null;
+}
 export function isAppPageRouteWiringFile(id) {
     const cleanId = id.split("?")[0].replace(/\\/g, "/");
     return cleanId.endsWith("/app-page-route-wiring.js") || cleanId.endsWith("/app-page-route-wiring.tsx") || cleanId.endsWith("/app-page-route-wiring.ts");
@@ -172,7 +270,7 @@ export function resolveVinextOptimisticRoutingPath(root = process.cwd()) {
     return existsSync(directPath) ? directPath : null;
 }
 export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
-    const { routeWiring = true, routeMatching = true, optimisticRouting = true } = options;
+    const { routeWiring = true, routeMatching = true, optimisticRouting = true, prefetchLearning = true } = options;
     let changed = false;
     const wiringPath = routeWiring ? resolveVinextAppPageRouteWiringPath(root) : null;
     if (wiringPath) {
@@ -184,6 +282,9 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
                     writeFileSync(wiringPath, patched, "utf8");
                     changed = true;
                 }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${wiringPath} does not match the expected shape for patchAppPageRouteWiring — this vinext version may have changed; the route-wiring fix was NOT applied.`);
+                }
             }
         }
         catch {
@@ -199,6 +300,9 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
                     writeFileSync(matchingPath, patched, "utf8");
                     changed = true;
                 }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${matchingPath} does not match the expected shape for patchRouteMatching — this vinext version may have changed; the route-matching fix was NOT applied.`);
+                }
             }
         }
         catch {
@@ -214,6 +318,27 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
                     writeFileSync(optimisticPath, patched, "utf8");
                     changed = true;
                 }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${optimisticPath} does not match the expected shape for patchOptimisticRouting — this vinext version may have changed; the optimistic-routing fix was NOT applied.`);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const browserEntryPath = prefetchLearning ? resolveVinextBrowserEntryPath(root) : null;
+    if (browserEntryPath) {
+        try {
+            const content = readFileSync(browserEntryPath, "utf8");
+            if (!isPrefetchLearningAlreadyFixed(content)) {
+                const patched = patchPrefetchLearning(content);
+                if (patched !== content) {
+                    writeFileSync(browserEntryPath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${browserEntryPath} does not match the expected shape for patchPrefetchLearning — this vinext version may have changed; the prefetch-learning fix was NOT applied.`);
+                }
             }
         }
         catch {
@@ -221,16 +346,39 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
     }
     return changed;
 }
+export function bustVinextOptimizeDepsCache(cacheDir) {
+    let removed = false;
+    for (const sub of ["deps", "deps_ssr", "deps_rsc"]) {
+        const dir = resolve(cacheDir, sub);
+        if (!existsSync(dir))
+            continue;
+        try {
+            rmSync(dir, { recursive: true, force: true });
+            removed = true;
+        }
+        catch {
+        }
+    }
+    return removed;
+}
 export function vinextRouteWiringFixPlugin(options = {}) {
     const routeWiring = options.routeWiring !== false;
     const routeMatching = options.routeMatching !== false;
     const optimisticRouting = options.optimisticRouting !== false;
+    const prefetchLearning = options.prefetchLearning !== false;
     return {
         name: "cfni:vinext-route-wiring-fix",
         enforce: "pre",
         configResolved(config) {
             const root = config.root || process.cwd();
-            syncPatchVinextOnDisk(root, { routeWiring, routeMatching, optimisticRouting });
+            const changed = syncPatchVinextOnDisk(root, { routeWiring, routeMatching, optimisticRouting, prefetchLearning });
+            if (changed) {
+                const cacheDir = config.cacheDir || resolve(root, "node_modules/.vite");
+                const busted = bustVinextOptimizeDepsCache(cacheDir);
+                if (busted) {
+                    console.log("[cfni:vinext-route-wiring-fix] patched vinext on disk and cleared its stale Vite optimizeDeps cache — dependencies will re-bundle on next request.");
+                }
+            }
         },
         transform(code, id) {
             if (routeWiring && isAppPageRouteWiringFile(id)) {
@@ -253,6 +401,16 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     map: null,
                 };
             }
+            if (prefetchLearning && isPrefetchLearningFile(id)) {
+                if (isPrefetchLearningAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchPrefetchLearning(code);
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
             if (optimisticRouting && isOptimisticRoutingFile(id)) {
                 if (isOptimisticRoutingAlreadyFixed(code)) {
                     return;

package/llms.txt

@@ -27,7 +27,7 @@ other subpath can be used.
 - `./db` — `withPublicDb(fn)` / `withUserDb(fn, uid?)` server-side Postgres/Drizzle context helpers (require `db` set on your `RoutingConfig`; direct Postgres or Supabase Data API with automatic PostgREST REST translation and `cfni_exec` fallback, see below).
 - `./dbEslint` — flat-config ESLint fragment banning direct `@supabase/supabase-js`, `pg`, `postgres`, and deep `dist/` imports in application code.
 - `./dbHelpers` — generic Drizzle SQL helper functions (`excluded`, `onConflictSet`, `ago`, `currentDate`, `windowCount`, `unnestLateral`, `ascNullsLast`, `alwaysTrue`, `lateral`, `aliasColumn`, `minOf`, `maxOf`, `roundReal`, `multiply`, `scalarFromCte`) for use with `./db`.
-- `./vite` — `cloudflareNextIntl(options?)` / `cloudflareNextIntlPlugin`, `imageOptimizerPlugin(options?)` / `imageOptimizer`, `buildIdAsset(fileName?)`, `localeFilePlugin(options?)`, `userAgentStubPlugin()`, `cfWorkersClientStubPlugin()`: All-in-one Vite plugin required for Vinext/Cloudflare Workers environments (bundles `@locale-file/*` via eager glob, resolves `@intl-config`, stubs Node.js `user-agent` to prevent runtime `node:fs` errors, stubs `cloudflare:workers` for client builds, emits client `BUILD_ID`, and runs build-time/dev Image Optimizer with Next.js blur placeholder shimming).
+- `./vite` — `cloudflareNextIntl(options?)` / `cloudflareNextIntlPlugin`, `imageOptimizerPlugin(options?)` / `imageOptimizer`, `buildIdAsset(fileName?)`, `localeFilePlugin(options?)`, `userAgentStubPlugin()`, `cfWorkersClientStubPlugin()`, `vinextRouteWiringFixPlugin(options?)`: All-in-one Vite plugin required for Vinext/Cloudflare Workers environments (bundles `@locale-file/*` via eager glob, resolves `@intl-config`, stubs Node.js `user-agent` to prevent runtime `node:fs` errors, stubs `cloudflare:workers` for client builds, emits client `BUILD_ID`, runs build-time/dev Image Optimizer with Next.js blur placeholder shimming, and fixes vinext route wiring, matching, and non-blocking optimistic prefetch learning).
 - `./image-optimizer` / `./imageOptimizer` — image optimization suite: `imageOptimizerPlugin`, `imageOptimizer`, `resolveOptions`, `resolveImageConfig`, `resolveBlurOptions`, `processImage`, `makeBlurDataURL`, `getImageBlurSvg`, `renderManifest`, `writeManifest`, `isFresh`, `loadCache`, `saveCache`, `collectImages`, `run`.
 - `./errorHandling` — error reporting & stale deploy recovery barrel: `reportError`, `withErrorHandling`, `installConsoleErrorOverride`, `installGlobalErrorOverride`, `stringifyUnknown`, `formatErrorMessage`, `defaultIgnoredConsoleErrors`, `createServerErrorAction`, `isStaleDeployError`, `defaultStaleDeployPatterns`, `setStaleDeployPatterns`, `getStaleDeployPatterns`, `clearClientCache`, `useStaleDeployRecovery`, `shouldRecoverFromStaleDeploy`, `isRecentBuild`.
 - `./isStaleDeployError` — `isStaleDeployError(error, patterns?)`, `setStaleDeployPatterns(patterns)`, `getStaleDeployPatterns()`: detector returning `true` for version skew / chunk load / dynamic import / server action 404 / hydration errors (ChunkLoadError, UnrecognizedActionError, server action not found, failed to fetch, dynamically imported module failure, loading CSS chunk, connection closed, RSC payload failure, minified error #412, or missing stream error `undefined`) with fast pre-lowercased pattern cache and intl-config integration (`errorHandling.staleDeployPatterns`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.45",
+  "version": "0.9.47",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",