cloudflare-next-intl 0.9.43 → 0.9.45

package/README.md

@@ -261,7 +261,7 @@ export default defineConfig({
    The scan (`checkDynamicPages`, also usable standalone from `cloudflare-next-intl/checkDynamicPages`) is a text heuristic, not a real parser, so it's deliberately conservative and follows a page's own local (relative/`@/`-alias) imports transitively — cycle-safe, capped at 300 files — so a signal several files away (a component's repository calling `cookies()`) still marks the page dynamic, not just literal text in the page file itself. A locally-imported file that opens with a `"use server"` directive is never opened by the scan (its exports are Server Actions, invoked only on explicit call — never merely by being imported), the same treatment a bare npm-package import already gets. Recognized signals: `cookies()`, `headers()`, `searchParams`, `unstable_noStore()`, `connection()`, `cache: "no-store"`, `next: { revalidate: 0 }`, and this package's own `getAuthUser()`/`useAuthUser()`/`withUserDb()` (each of which reads `cookies()` internally) — except a `useAuthUser()` call in a file that opens with `"use client"`, which is this package's client-side hook (a different export under the same name) and contributes no signal. Set `resolveImports: false` on `checkDynamicPages` to restore the original single-file-only scan, or pass `aliases` to override the default `@/` → `<appDir>/..` mapping.
 
    Being text-only and transitive, it can over-flag: any local file the page reaches — however many imports away — that merely *calls* a recognized signal counts, even along a branch that never runs in production (a `Config.isDev`-gated `fetch(..., { cache: "no-store" })`) or one that's optional/best-effort (a `try`/`catch`-wrapped `getAuthUser()` used only to tag a log line). It cannot see that a call is conditional or swallowed. For a page whose only reason for being flagged is that kind of optional read — attaching "whoever's signed in, if anyone" to an error report, analytics event, or log line — switch that read to `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`, see Firebase Auth below): it wraps `getAuthUser()` the same way but, being an npm-package import, is a boundary the scan doesn't open, so it contributes no signal. If that read lives in a shared `onError` sink used by many pages at once, `resolveErrorReportingUser(useAuthUser?)` (same subpath) is the more precise fix: it's off (`{ user: null }`, no `getAuthUser()` call) by default, and only a `reportError({ ..., useAuthUser: true })` call site that actually wants the user on that report opts in per-call — instead of every page reaching that sink getting flagged.
-2. **Build-Time & Dev Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size.
+2. **Build-Time Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size. Runs on production build only by default (`dev: false`) — downscaling/format conversion is a build concern, and re-scanning on every dev server start slows cold starts for no dev-time benefit; the shim degrades cleanly with no manifest (plain, unoptimized `next/image` rendering, no blur placeholder). Pass `dev: true` to also run it in dev and preview real optimized output/blur.
 3. **Locale File Bundling & Resolution (`localeFiles`)**: Resolves `@locale-file/*` to your `./messages` directory and transforms dynamic imports into `import.meta.glob('/messages/*.json', { eager: true })` for lightning-fast locale loading on Cloudflare Workers.
 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.
@@ -278,6 +278,7 @@ export default defineConfig({
     plugins: [
         cloudflareNextIntl({
             imageOptimizer: {                     // Image optimizer configuration (or `false` to disable)
+                dev: false,                        // Also run the scan on dev server start, not just production build (default: false)
                 maxWidth: 1920,                   // Downscale max width limit (default: 1920, or `false`)
                 formats: ["avif", "webp"],        // Target sibling formats, in browser-preference order (default: ["webp"], or `false`).
                                                    // Also supports: "png", "jpeg", "gif", "tiff", "heif", "jp2", "jxl"

package/dist/src/image_optimizer/types.js

@@ -15,7 +15,7 @@ export const DEFAULT_OPTIONS = {
     formats: ["webp"],
     manifest: "public/generated/images.json",
     blur: DEFAULT_BLUR_OPTIONS,
-    dev: true,
+    dev: false,
     cacheDir: "node_modules/.cache/cloudflare-next-intl/image-optimizer",
     onlyUsed: true,
     overrides: {},

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

@@ -2,6 +2,7 @@ export { autoDynamicPagesPlugin, type AutoDynamicPagesPluginOptions } from "./au
 export { buildIdAsset } from "./build_id_asset.js";
 export { userAgentStubPlugin, USER_AGENT_STUB_ID, USER_AGENT_STUB_CODE } from "./user_agent_stub.js";
 export { cfWorkersClientStubPlugin, CF_WORKERS_CLIENT_STUB_ID, CF_WORKERS_CLIENT_STUB_CODE } from "./cf_workers_client_stub.js";
+export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed, type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath, type LocaleFilePluginOptions } from "./locale_file_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, type CloudflareNextIntlOptions, default } from "./plugin.js";
 export { imageOptimizer, imageOptimizerPlugin, VIRTUAL_IMAGE_SHIM_ID, type ImageFormat, type ImageBlurOptions, type ImageOverrideOptions, type ImageOptimizerPluginOptions, type ResolvedBlurOptions, type ResolvedOptions, type ResolvedImageConfig, type OptimizedImage, type ManifestData, type ManifestEntry, } from "../image_optimizer/index.js";

package/dist/src/vite/index.js

@@ -2,6 +2,7 @@ export { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
 export { buildIdAsset } from "./build_id_asset.js";
 export { userAgentStubPlugin, USER_AGENT_STUB_ID, USER_AGENT_STUB_CODE } from "./user_agent_stub.js";
 export { cfWorkersClientStubPlugin, CF_WORKERS_CLIENT_STUB_ID, CF_WORKERS_CLIENT_STUB_CODE } from "./cf_workers_client_stub.js";
+export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath } from "./locale_file_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, default } from "./plugin.js";
 export { imageOptimizer, imageOptimizerPlugin, VIRTUAL_IMAGE_SHIM_ID, } from "../image_optimizer/index.js";

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

@@ -2,6 +2,7 @@ import type { Plugin } from "vite";
 import { type LocaleFilePluginOptions } from "./locale_file_plugin.js";
 import { type ImageOptimizerPluginOptions } from "../image_optimizer/index.js";
 import { type AutoDynamicPagesPluginOptions } from "./auto_dynamic_pages_plugin.js";
+import { type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
 export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
     autoDynamicPages?: boolean | AutoDynamicPagesPluginOptions;
     buildIdAsset?: boolean | string;
@@ -9,6 +10,7 @@ export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
     userAgentStub?: boolean;
     cfWorkersClientStub?: boolean;
     imageOptimizer?: boolean | ImageOptimizerPluginOptions;
+    vinextRouteWiringFix?: boolean | VinextRouteWiringFixPluginOptions;
 }
 export declare function cloudflareNextIntl(options?: CloudflareNextIntlOptions): Plugin[];
 export declare const cloudflareNextIntlPlugin: typeof cloudflareNextIntl;

package/dist/src/vite/plugin.js

@@ -4,6 +4,7 @@ import { cfWorkersClientStubPlugin } from "./cf_workers_client_stub.js";
 import { localeFilePlugin } from "./locale_file_plugin.js";
 import { imageOptimizerPlugin } from "../image_optimizer/index.js";
 import { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
+import { vinextRouteWiringFixPlugin } from "./vinext_route_wiring_fix.js";
 export function cloudflareNextIntl(options = {}) {
     const plugins = [];
     if (options.autoDynamicPages !== false) {
@@ -26,6 +27,9 @@ export function cloudflareNextIntl(options = {}) {
     if (options.userAgentStub !== false) {
         plugins.push(userAgentStubPlugin());
     }
+    if (options.vinextRouteWiringFix !== false) {
+        plugins.push(vinextRouteWiringFixPlugin(typeof options.vinextRouteWiringFix === "object" ? options.vinextRouteWiringFix : {}));
+    }
     if (options.localeFiles !== false) {
         plugins.push(localeFilePlugin({
             messagesDir: options.messagesDir,

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

@@ -0,0 +1,25 @@
+import type { Plugin } from "vite";
+export declare function isAppPageRouteWiringAlreadyFixed(code: string): boolean;
+export declare function patchAppPageRouteWiring(code: string): string;
+export declare function isRouteMatchingFile(id: string): boolean;
+export declare function isRouteMatchingAlreadyFixed(code: string): boolean;
+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 isAppPageRouteWiringFile(id: string): boolean;
+export declare function resolveVinextAppPageRouteWiringPath(root?: string): string | null;
+export declare function resolveVinextRouteMatchingPath(root?: string): string | null;
+export declare function resolveVinextOptimisticRoutingPath(root?: string): string | null;
+export interface SyncPatchVinextOnDiskOptions {
+    routeWiring?: boolean;
+    routeMatching?: boolean;
+    optimisticRouting?: boolean;
+}
+export declare function syncPatchVinextOnDisk(root?: string, options?: SyncPatchVinextOnDiskOptions): boolean;
+export interface VinextRouteWiringFixPluginOptions {
+    routeWiring?: boolean;
+    routeMatching?: boolean;
+    optimisticRouting?: boolean;
+}
+export declare function vinextRouteWiringFixPlugin(options?: VinextRouteWiringFixPluginOptions): Plugin;

package/dist/src/vite/vinext_route_wiring_fix.js

@@ -0,0 +1,268 @@
+import { existsSync, readFileSync, writeFileSync } 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) {
+	let rootEntry = null;
+	let deepestNestedEntry = null;
+	for (const [index, loadingModule] of (route.loadings ?? []).entries()) {
+		if (!getDefaultExport(loadingModule)) continue;
+		const treePosition = route.loadingTreePositions?.[index];
+		if (treePosition === void 0) continue;
+		if (treePosition === 0) rootEntry ??= {
+			loadingModule,
+			treePosition
+		};
+		else if (deepestNestedEntry === null || treePosition > deepestNestedEntry.treePosition) deepestNestedEntry = {
+			loadingModule,
+			treePosition
+		};
+	}
+	const leafEntry = getDefaultExport(route.loading) ? {
+		loadingModule: route.loading,
+		treePosition: route.routeSegments?.length ?? 0
+	} : null;
+	if (leafEntry && (!deepestNestedEntry || leafEntry.treePosition >= deepestNestedEntry.treePosition)) return leafEntry;
+	if (deepestNestedEntry) return deepestNestedEntry;
+	if (rootEntry) return rootEntry;
+	return null;
+}`;
+const ROUTE_LOADING_GUARD_RE = /if\s*\(\s*!isPrefetchLoadingShell\s*&&\s*treePosition\s*<\s*routeSegments\.length\s*\)\s*\{/g;
+const FIXED_ROUTE_LOADING_GUARD = "if (!isPrefetchLoadingShell && treePosition < routeSegments.length && !routeLoadingComponent) {";
+export function isAppPageRouteWiringAlreadyFixed(code) {
+    const hasBuggyPrefetch = code.includes("firstNestedEntry") && PREFETCH_LOADING_FN_RE.test(code);
+    const hasBuggySuspense = !code.includes("!routeLoadingComponent") && ROUTE_LOADING_GUARD_RE.test(code);
+    return !hasBuggyPrefetch && !hasBuggySuspense;
+}
+export function patchAppPageRouteWiring(code) {
+    if (isAppPageRouteWiringAlreadyFixed(code)) {
+        return code;
+    }
+    let result = code;
+    const hasBuggyPrefetch = code.includes("firstNestedEntry") && PREFETCH_LOADING_FN_RE.test(code);
+    if (hasBuggyPrefetch && !result.includes("deepestNestedEntry")) {
+        result = result.replace(PREFETCH_LOADING_FN_RE, FIXED_PREFETCH_LOADING_FN);
+    }
+    const hasBuggySuspense = !result.includes("!routeLoadingComponent") && ROUTE_LOADING_GUARD_RE.test(result);
+    if (hasBuggySuspense) {
+        result = result.replace(ROUTE_LOADING_GUARD_RE, FIXED_ROUTE_LOADING_GUARD);
+    }
+    return result;
+}
+export function isRouteMatchingFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/routing/route-matching.js") || cleanId.endsWith("/routing/route-matching.ts");
+}
+export function isRouteMatchingAlreadyFixed(code) {
+    return code.includes("hasLeadingLocaleParam");
+}
+const MATCH_ROUTE_WITH_TRIE_RE = /function\s+matchRouteWithTrie\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?return\s+trieMatch\([\s\S]*?\);\s*\}/;
+const FIXED_MATCH_ROUTE_WITH_TRIE = `function getActiveRouteLocale() {
+	return (typeof document !== "undefined" && (document.documentElement?.lang || document.cookie.match(/__user_locale_key__=([^;]+)/)?.[1])) || (typeof window !== "undefined" && window.__VINEXT_LOCALE__) || "en";
+}
+function matchRouteWithTrie(url, routes, cache) {
+	const pathname = url.split("?")[0];
+	let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\\/$/, "");
+	normalizedUrl = normalizePathnameForRouteMatch(normalizedUrl);
+	const urlParts = normalizedUrl.split("/").filter(Boolean);
+	const trie = getOrBuildTrie(cache, routes);
+	const hasLeadingLocaleParam = routes.some((r) => r.patternParts?.[0] === ":locale");
+	if (hasLeadingLocaleParam) {
+		const activeLocale = getActiveRouteLocale();
+		if (urlParts[0] !== activeLocale) {
+			const matchWithLocale = trieMatch(trie, [activeLocale, ...urlParts]);
+			if (matchWithLocale) return matchWithLocale;
+		}
+	}
+	return trieMatch(trie, urlParts);
+}`;
+const MATCH_ROUTE_WITH_TRIE_RAW_RE = /function\s+matchRouteWithTrieRawPathname\s*\(\s*url\s*,\s*routes\s*,\s*cache\s*\)\s*\{[\s\S]*?return\s+trieMatch\([\s\S]*?\);\s*\}/;
+const FIXED_MATCH_ROUTE_WITH_TRIE_RAW = `function matchRouteWithTrieRawPathname(url, routes, cache) {
+	const pathname = url.split("?")[0];
+	const urlParts = (pathname === "/" ? "/" : pathname.replace(/\\/$/, "")).split("/").filter(Boolean);
+	const trie = getOrBuildTrie(cache, routes);
+	const hasLeadingLocaleParam = routes.some((r) => r.patternParts?.[0] === ":locale");
+	if (hasLeadingLocaleParam) {
+		const activeLocale = getActiveRouteLocale();
+		if (urlParts[0] !== activeLocale) {
+			const matchWithLocale = trieMatch(trie, [activeLocale, ...urlParts]);
+			if (matchWithLocale) return matchWithLocale;
+		}
+	}
+	return trieMatch(trie, urlParts);
+}`;
+export function patchRouteMatching(code) {
+    if (isRouteMatchingAlreadyFixed(code)) {
+        return code;
+    }
+    let result = code;
+    if (MATCH_ROUTE_WITH_TRIE_RE.test(result)) {
+        result = result.replace(MATCH_ROUTE_WITH_TRIE_RE, FIXED_MATCH_ROUTE_WITH_TRIE);
+    }
+    if (MATCH_ROUTE_WITH_TRIE_RAW_RE.test(result)) {
+        result = result.replace(MATCH_ROUTE_WITH_TRIE_RAW_RE, FIXED_MATCH_ROUTE_WITH_TRIE_RAW);
+    }
+    return result;
+}
+export function isOptimisticRoutingFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-optimistic-routing.js") || cleanId.endsWith("/app-optimistic-routing.ts");
+}
+export function isOptimisticRoutingAlreadyFixed(code) {
+    const hasLocalePrefixFirst = code.includes("hasLeadingLocaleParam") &&
+        code.indexOf("hasLeadingLocaleParam") < code.indexOf("const match = matchNode(trie, urlParts.normalized");
+    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 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";
+		if (urlParts.normalized[0] !== activeLocale) {
+			const localeMatch = matchNode(trie, [activeLocale, ...urlParts.normalized], 0, []);
+			if (localeMatch !== null) {
+				decodeMatchedParams(localeMatch.params);
+				return localeMatch;
+			}
+		}
+	}
+	const match = matchNode(trie, urlParts.normalized, 0, []);
+	if (match !== null) {
+		decodeMatchedParams(match.params);
+		return match;
+	}
+	return null;
+}`;
+const RESOLVE_OPTIMISTIC_NAV_PARAMS_RE = /function\s+resolveOptimisticNavigationParams\s*\(\s*options\s*\)\s*\{[\s\S]*?const\s+routeParams\s*=\s*extractRawRoutePatternParams\s*\(\s*options\.match\.route\.patternParts\s*,\s*options\.rawUrlParts\s*\);/;
+const FIXED_RESOLVE_OPTIMISTIC_NAV_PARAMS = `function resolveOptimisticNavigationParams(options) {
+	const rawParts = (options.match.route.patternParts?.[0] === ":locale" && options.rawUrlParts[0] !== options.match.params.locale)
+		? [options.match.params.locale, ...options.rawUrlParts]
+		: options.rawUrlParts;
+	const routeParams = extractRawRoutePatternParams(options.match.route.patternParts, rawParts);`;
+export function patchOptimisticRouting(code) {
+    if (isOptimisticRoutingAlreadyFixed(code)) {
+        return code;
+    }
+    let result = code;
+    if (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)) {
+        result = result.replace(RESOLVE_OPTIMISTIC_NAV_PARAMS_RE, FIXED_RESOLVE_OPTIMISTIC_NAV_PARAMS);
+    }
+    return result;
+}
+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");
+}
+export function resolveVinextAppPageRouteWiringPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-page-route-wiring.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function resolveVinextRouteMatchingPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/routing/route-matching.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function resolveVinextOptimisticRoutingPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-optimistic-routing.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
+    const { routeWiring = true, routeMatching = true, optimisticRouting = true } = options;
+    let changed = false;
+    const wiringPath = routeWiring ? resolveVinextAppPageRouteWiringPath(root) : null;
+    if (wiringPath) {
+        try {
+            const content = readFileSync(wiringPath, "utf8");
+            if (!isAppPageRouteWiringAlreadyFixed(content)) {
+                const patched = patchAppPageRouteWiring(content);
+                if (patched !== content) {
+                    writeFileSync(wiringPath, patched, "utf8");
+                    changed = true;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const matchingPath = routeMatching ? resolveVinextRouteMatchingPath(root) : null;
+    if (matchingPath) {
+        try {
+            const content = readFileSync(matchingPath, "utf8");
+            if (!isRouteMatchingAlreadyFixed(content)) {
+                const patched = patchRouteMatching(content);
+                if (patched !== content) {
+                    writeFileSync(matchingPath, patched, "utf8");
+                    changed = true;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const optimisticPath = optimisticRouting ? resolveVinextOptimisticRoutingPath(root) : null;
+    if (optimisticPath) {
+        try {
+            const content = readFileSync(optimisticPath, "utf8");
+            if (!isOptimisticRoutingAlreadyFixed(content)) {
+                const patched = patchOptimisticRouting(content);
+                if (patched !== content) {
+                    writeFileSync(optimisticPath, patched, "utf8");
+                    changed = true;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return changed;
+}
+export function vinextRouteWiringFixPlugin(options = {}) {
+    const routeWiring = options.routeWiring !== false;
+    const routeMatching = options.routeMatching !== false;
+    const optimisticRouting = options.optimisticRouting !== false;
+    return {
+        name: "cfni:vinext-route-wiring-fix",
+        enforce: "pre",
+        configResolved(config) {
+            const root = config.root || process.cwd();
+            syncPatchVinextOnDisk(root, { routeWiring, routeMatching, optimisticRouting });
+        },
+        transform(code, id) {
+            if (routeWiring && isAppPageRouteWiringFile(id)) {
+                if (isAppPageRouteWiringAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchAppPageRouteWiring(code);
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+            if (routeMatching && isRouteMatchingFile(id)) {
+                if (isRouteMatchingAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchRouteMatching(code);
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+            if (optimisticRouting && isOptimisticRoutingFile(id)) {
+                if (isOptimisticRoutingAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchOptimisticRouting(code);
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+        },
+    };
+}

package/package.json

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