cloudflare-next-intl 0.9.50 → 0.9.52

package/README.md

@@ -267,8 +267,9 @@ export default defineConfig({
 6. **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).
 7. **Cloudflare Workers Client Stub (`cfWorkersClientStub`)**: Stubs `cloudflare:workers` in client builds so shared modules can be referenced without client bundling errors.
 8. **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`.
-9. **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.
-10. **Lucide & Next.js Specifier Optimizer (`lucideOptimizer`)**: Auto-detects `lucide-react` in project dependencies, rewrites named imports to direct deep icon paths (`lucide-react/dist/esm/icons/<icon>.mjs`) to avoid browser socket exhaustion (`ERR_INSUFFICIENT_RESOURCES`), and normalizes Next.js `.js` specifiers (`next/dynamic.js` -> `next/dynamic`) to prevent mid-session Vite re-optimization and React dispatcher splitting.
+9. **Vinext Route Wiring & Optimistic Prefetch Fix (`vinextRouteWiringFix`)**: ⚠️ Monkey-patches Vinext's compiled runtime on disk (`node_modules/vinext/dist/**`) — **on by default** since 0.9.51 via `experimentalRouteLoadingFixes` (also defaulting to on). Fixes route wiring (a route-specific `loading.tsx` losing to an ancestor/root skeleton), route matching and optimistic (client-side) routing for leading `:locale` segments, prefetch learning (an in-flight prefetch losing the race so the previous page stays on screen), and a `refresh()` navigation cancelling an in-flight page-to-page navigation because both share the same counter. Every sub-patch is regex-based against vinext's exact compiled shape and checks that the vinext-internal identifiers it relies on (`makeThenableParams`, `trieMatch`, `getPrefetchCache`, …) are still present before touching a file — a future vinext release that renames or removes one is left unpatched (with a console warning) rather than being patched into a broken half-state. Set `experimentalRouteLoadingFixes: false` (or `vinextRouteWiringFix: false`) to opt out entirely; see **Plugin Options** below for the individual sub-patch flags (`routeWiring`, `routeMatching`, `optimisticRouting`, `prefetchLearning`, `suspenseProbe`, `renderDependency`, `optimisticLearningTimeout`, `pageInvokerSuspensionRelease`, `refreshDeferral`, `unblockRenderDependencies`, `unblockPageElementDependencies`).
+10. **Layout DB Query Check (`layoutQueriesCheck`)**: Scans each `layout.tsx`/`layout.ts` and its reachable server-component import tree (also usable standalone from `cloudflare-next-intl/checkLayoutQueries`, or via the `cfni-check-layout-queries` CLI bin) for blocking `withUserDb()` / `withPublicDb()` calls. A layout re-renders on every route transition within its group, so a DB query anywhere in that tree blocks every page switch under it — the scan stops at Client Components (`'use client'`), which don't block server layout streaming. Prints a visible terminal warning with concrete fixes (move to a Client Component, wrap in `unstable_cache`, or move the query out of the shared layout into the page) by default; pass `{ strict: true }` to fail the build instead, or `false` to disable.
+11. **Lucide & Next.js Specifier Optimizer (`lucideOptimizer`)**: Auto-detects `lucide-react` in project dependencies, rewrites named imports to direct deep icon paths (`lucide-react/dist/esm/icons/<icon>.mjs`) to avoid browser socket exhaustion (`ERR_INSUFFICIENT_RESOURCES`), and normalizes Next.js `.js` specifiers (`next/dynamic.js` -> `next/dynamic`) to prevent mid-session Vite re-optimization and React dispatcher splitting.
 
 ##### Plugin Options
 All features are enabled by default, and can be individually configured or toggled off:
@@ -299,22 +300,40 @@ export default defineConfig({
                 localeParam: "locale",             // Route param name to read (default: "locale")
                 skip: ["src/app/[locale]/(marketing)/**"], // Glob(s) to exclude from the scan
             },
+            layoutQueriesCheck: {                  // Flag blocking DB queries in the layout tree (or `false` to disable)
+                strict: false,                     // Fail the build on violations instead of just warning (default: false)
+                runOnDev: true,                    // Also run on `vite dev`, not just build (default: true)
+            },
             messagesDir: "./messages",            // Path to locale JSON files (default: './messages')
             intlConfigPath: "./src/l18n/intl_config.ts", // Path to intl config (auto-detected if omitted)
             buildIdAsset: true,                   // Emit BUILD_ID asset (or custom string filename, default: true)
             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: false,          // ⚠️ DANGER: Monkey-patches vinext on disk (default: false, or options object)
-            experimentalRouteLoadingFixes: false, // ⚠️ DANGER: Unified switch enabling both vinextRouteWiringFix and SSG on loading.* (default: false)
+            vinextRouteWiringFix: {                // ⚠️ DANGER: Monkey-patches vinext on disk (default: follows experimentalRouteLoadingFixes, i.e. true; or options object)
+                routeWiring: true,                  // Route-specific loading.tsx wins over ancestor/root skeletons (default: true)
+                routeMatching: true,                // Leading `:locale` segment tried against active locale first (default: true)
+                optimisticRouting: true,            // Same fix client-side for optimistic (instant) navigation (default: true)
+                prefetchLearning: true,             // Wait for an in-flight prefetch of the nav target instead of giving up (default: true)
+                optimisticLearningTimeout: true,    // Lower the fixed safety-cap on that wait; pass a number for a custom ms cap (default: true → 200ms)
+                suspenseProbe: true,                // Respect <Suspense> boundaries when probing for async page dependencies (default: true)
+                renderDependency: true,             // Release a render dependency when its component suspends (default: true)
+                pageInvokerSuspensionRelease: true, // Same release, unconditionally, for the page component's own barrier (default: true)
+                refreshDeferral: true,              // Defer a refresh() navigation while a normal navigation is in flight (default: true)
+                unblockRenderDependencies: true,    // Strip layout/template/slot/route dependency ordering (default: true)
+                unblockPageElementDependencies: false, // Also strip it from the PAGE element itself (default: false — see warning below)
+            },
+            experimentalRouteLoadingFixes: true,  // ⚠️ DANGER: Unified switch enabling both vinextRouteWiringFix and SSG on loading.* (default: true)
             lucideOptimizer: true,                // Auto-optimize lucide-react deep imports and normalize next/*.js (default: true, or options object)
         }),
     ],
 });
 ```
 
+> **Note:** `unblockPageElementDependencies: true` was measured, in a real app, to make page-to-page navigation noticeably slower rather than faster — it strips ordering vinext's own page-element wiring relies on. Leave it off unless you've verified otherwise for your app.
+
 Individual standalone plugins are also exported if you only need a specific feature:
-`imageOptimizerPlugin` (or `imageOptimizer`), `autoLocaleParamsPlugin`, `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`, `vinextRouteWiringFixPlugin`, `lucideOptimizerPlugin`.
+`imageOptimizerPlugin` (or `imageOptimizer`), `autoLocaleParamsPlugin`, `layoutQueriesPlugin` (or `layoutQueriesCheck`), `buildIdAsset`, `localeFilePlugin`, `userAgentStubPlugin`, `cfWorkersClientStubPlugin`, `vinextRouteWiringFixPlugin`, `lucideOptimizerPlugin`.
 
 ##### Per-Image Optimizer Settings
 
@@ -671,7 +690,7 @@ through `@intl-config`.
 
 When a new version of your application is deployed to Cloudflare Workers, users on older client sessions may encounter `ChunkLoadError` or failed dynamic imports when requesting outdated chunks.
 
-`IntlHelperScript` renders an early-catch `<script>` (production only, id `stale-deploy-early-catch`) that runs before hydration and listens for `window.error`/`unhandledrejection` events matching the same patterns as `isStaleDeployError` (inlined as JSON, so it stays in sync with `staleDeployPatterns` config), then force-reloads once per build id. This covers the case a React-level recovery (`useStaleDeployRecovery` below) cannot: when the chunk that failed to load is part of your own error boundary/global-error bundle, React never gets a chance to render the recovery UI. Both layers share the same `sessionStorage['stale-deploy-recovery-reloaded']` marker keyed by build id, so they can't double-reload each other. No setup beyond rendering `<IntlHelperScript />` is required.
+`IntlHelperScript` renders an early-catch `<script>` (production only, id `stale-deploy-early-catch`) that runs before hydration and listens for `window.error`/`unhandledrejection` events matching the same patterns as `isStaleDeployError` (inlined as JSON, so it stays in sync with `staleDeployPatterns` config), then force-reloads once per build id (throttled to once per 15s so a later build-id marker can re-arm recovery instead of being blocked indefinitely). It also listens for `error` events during the capture phase to catch resource-load failures (a chunk `<script>`/`<link>` 404ing or served with a disallowed MIME type), which fire a non-bubbling, message-less `error` event on the element itself rather than surfacing as a catchable message. This covers the case a React-level recovery (`useStaleDeployRecovery` below) cannot: when the chunk that failed to load is part of your own error boundary/global-error bundle, React never gets a chance to render the recovery UI. Both layers share the same `sessionStorage['stale-deploy-recovery-reloaded']` marker keyed by build id, so they can't double-reload each other. No setup beyond rendering `<IntlHelperScript />` is required.
 
 For errors that don't crash the module graph itself (a normal thrown error reaching an error boundary), use `isStaleDeployError` and `clearClientCache` in error boundaries or global error handlers to automatically recover:
 

package/bin/check_layout_queries.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { checkLayoutQueries } from "../dist/src/layout_queries_check/index.js";
+
+const isStrict = process.argv.includes("--strict");
+const report = checkLayoutQueries({
+  rootDir: process.cwd(),
+});
+
+if (!report.valid) {
+  console.error(report.formattedMessage);
+  if (isStrict) {
+    process.exit(1);
+  }
+} else {
+  console.log("✅ [cloudflare-next-intl] No blocking database queries found in layout tree.");
+}

package/dist/src/firebase_auth/client/firebase_client.js

@@ -157,7 +157,7 @@ export async function getFirebaseAuthClient() {
                 }
             }
             if (perfModule) {
-                cachedPerformance = perfModule.getPerformance(app);
+                cachedPerformance = perfModule.initializePerformance(app, { instrumentationEnabled: false });
             }
             const auth = getAuth(app);
             cached = { app, auth };

package/dist/src/layout_queries_check/check_layout_queries.d.ts

@@ -0,0 +1,23 @@
+export interface LayoutDbViolation {
+    layoutFile: string;
+    sourceFile: string;
+    lineNumber: number;
+    lineContent: string;
+    signal: string;
+    importTrace: string[];
+}
+export interface CheckLayoutQueriesOptions {
+    appDir?: string;
+    rootDir?: string;
+    aliases?: Record<string, string>;
+    maxDepth?: number;
+    throwOnError?: boolean;
+}
+export interface CheckLayoutQueriesReport {
+    valid: boolean;
+    violations: LayoutDbViolation[];
+    formattedMessage: string;
+}
+export declare function findLayoutFiles(dir: string): string[];
+export declare function formatLayoutDbViolationMessage(violations: LayoutDbViolation[]): string;
+export declare function checkLayoutQueries(options?: CheckLayoutQueriesOptions): CheckLayoutQueriesReport;

package/dist/src/layout_queries_check/check_layout_queries.js

@@ -0,0 +1,172 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+const DB_SIGNALS = [
+    { name: "withUserDb()", pattern: /\bwithUserDb\s*\(/ },
+    { name: "withPublicDb()", pattern: /\bwithPublicDb\s*\(/ },
+];
+const SUPPORTED_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs"];
+function isClientComponent(content) {
+    return /^\s*["']use client["']/m.test(content);
+}
+export function findLayoutFiles(dir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    function walk(currentDir) {
+        const entries = readdirSync(currentDir);
+        for (const entry of entries) {
+            if (entry.startsWith(".") || entry === "node_modules")
+                continue;
+            const fullPath = join(currentDir, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (/^layout\.(tsx|ts|jsx|js)$/.test(entry)) {
+                results.push(fullPath);
+            }
+        }
+    }
+    walk(dir);
+    return results;
+}
+function resolveImportPath(specifier, importerFile, rootDir, aliases) {
+    for (const [alias, target] of Object.entries(aliases)) {
+        if (specifier === alias || specifier.startsWith(alias + "/")) {
+            const remainder = specifier.slice(alias.length).replace(/^\//, "");
+            const basePath = resolve(rootDir, target, remainder);
+            return probeExtensions(basePath);
+        }
+    }
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        const basePath = resolve(dirname(importerFile), specifier);
+        return probeExtensions(basePath);
+    }
+    return null;
+}
+function probeExtensions(basePath) {
+    if (existsSync(basePath) && statSync(basePath).isFile()) {
+        return basePath;
+    }
+    for (const ext of SUPPORTED_EXTENSIONS) {
+        const withExt = basePath + ext;
+        if (existsSync(withExt) && statSync(withExt).isFile()) {
+            return withExt;
+        }
+    }
+    for (const ext of SUPPORTED_EXTENSIONS) {
+        const indexFile = join(basePath, "index" + ext);
+        if (existsSync(indexFile) && statSync(indexFile).isFile()) {
+            return indexFile;
+        }
+    }
+    return null;
+}
+function extractImports(content) {
+    const imports = [];
+    const importRegex = /(?:import\s+(?:[\w*\s{},]*\s+from\s+)?|import\s*\(\s*)["']([^"']+)["']/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+        if (match[1]) {
+            imports.push(match[1]);
+        }
+    }
+    return imports;
+}
+export function formatLayoutDbViolationMessage(violations) {
+    if (violations.length === 0)
+        return "";
+    const separator = "=".repeat(84);
+    const thinSeparator = "-".repeat(84);
+    const lines = [
+        "",
+        separator,
+        "🚨 [cloudflare-next-intl] BLOCKING DATABASE QUERY DETECTED IN LAYOUT",
+        separator,
+        "",
+        "⚠️  WHY THIS IS DANGEROUS:",
+        "   Layouts are re-evaluated by the server on every route transition within their group.",
+        "   Executing database queries (`withUserDb` / `withPublicDb`) inside the layout tree",
+        "   blocks the entire RSC response on every page switch. This causes page navigation",
+        "   to freeze/hang and completely breaks instant client transitions.",
+        "",
+        "📋 VIOLATIONS FOUND (" + violations.length + "):",
+        thinSeparator,
+    ];
+    violations.forEach((v, i) => {
+        lines.push(` [${i + 1}] Signal: ${v.signal}`);
+        lines.push(`     Layout:   ${v.layoutFile}`);
+        lines.push(`     File:     ${v.sourceFile}:${v.lineNumber}`);
+        lines.push(`     Line:     ${v.lineContent.trim()}`);
+        if (v.importTrace.length > 1) {
+            lines.push(`     Trace:    ${v.importTrace.join(" -> ")}`);
+        }
+        lines.push(thinSeparator);
+    });
+    lines.push("", "💡 HOW TO FIX:", "   1. Move to a Client Component ('use client'):", "      Fetch the data in useEffect / SWR / React Query or a Supabase Realtime subscription.", "      Client components do not block server layout streaming during navigation.", "", "   2. Use Cross-Request Caching (`unstable_cache`):", "      Wrap the database query with `unstable_cache` (from 'next/cache') and a cache tag.", "      This caches results in Cloudflare KV so layout renders in 0ms without hitting Postgres.", "", "   3. Move out of Shared Layout:", "      If only a specific route needs this data, move the component from layout.tsx into that", "      page's page.tsx.", separator, "");
+    return lines.join("\n");
+}
+export function checkLayoutQueries(options = {}) {
+    const rootDir = options.rootDir ?? process.cwd();
+    const appDir = options.appDir ?? resolve(rootDir, "src/app");
+    const aliases = options.aliases ?? {
+        "@": resolve(rootDir, "src"),
+    };
+    const maxDepth = options.maxDepth ?? 20;
+    const layoutFiles = findLayoutFiles(appDir);
+    const violations = [];
+    for (const layoutFile of layoutFiles) {
+        const visited = new Set();
+        function traverse(file, trace, depth) {
+            if (depth > maxDepth || visited.has(file))
+                return;
+            visited.add(file);
+            let content;
+            try {
+                content = readFileSync(file, "utf-8");
+            }
+            catch {
+                return;
+            }
+            if (isClientComponent(content)) {
+                return;
+            }
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*"))
+                    return;
+                for (const signal of DB_SIGNALS) {
+                    if (signal.pattern.test(line)) {
+                        violations.push({
+                            layoutFile,
+                            sourceFile: file,
+                            lineNumber: index + 1,
+                            lineContent: line,
+                            signal: signal.name,
+                            importTrace: [...trace, file],
+                        });
+                    }
+                }
+            });
+            const imports = extractImports(content);
+            for (const imp of imports) {
+                const resolved = resolveImportPath(imp, file, rootDir, aliases);
+                if (resolved) {
+                    traverse(resolved, [...trace, file], depth + 1);
+                }
+            }
+        }
+        traverse(layoutFile, [], 0);
+    }
+    const valid = violations.length === 0;
+    const formattedMessage = formatLayoutDbViolationMessage(violations);
+    if (!valid && options.throwOnError) {
+        throw new Error(formattedMessage);
+    }
+    return {
+        valid,
+        violations,
+        formattedMessage,
+    };
+}

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

@@ -0,0 +1 @@
+export { checkLayoutQueries, formatLayoutDbViolationMessage, findLayoutFiles, type LayoutDbViolation, type CheckLayoutQueriesOptions, type CheckLayoutQueriesReport, } from "./check_layout_queries.js";

package/dist/src/layout_queries_check/index.js

@@ -0,0 +1 @@
+export { checkLayoutQueries, formatLayoutDbViolationMessage, findLayoutFiles, } from "./check_layout_queries.js";

package/dist/src/server/components/helper_script.js

@@ -17,6 +17,8 @@ export default function HelperScript() {
                 try {
                 var patterns = ${JSON.stringify(defaultStaleDeployPatterns)};
                 var key = 'stale-deploy-recovery-reloaded';
+                var timeKey = 'stale-deploy-recovery-time';
+                var throttleMs = 15000;
                 var attemptedThisLoad = false;
                 function isStale(msg) {
                     if (msg === undefined || msg === null) return true;
@@ -34,12 +36,16 @@ export default function HelperScript() {
                         if (!stale) return;
                         var buildId = localStorage.getItem('buildId') || 'unknown';
                         var marker = sessionStorage.getItem(key);
-                        if (marker === buildId) {
+                        var lastRaw = sessionStorage.getItem(timeKey);
+                        var last = lastRaw ? Number(lastRaw) : null;
+                        var throttled = last !== null && (Date.now() - last) < throttleMs;
+                        if (marker === buildId && throttled) {
                             console.warn('[StaleDeploy early-catch] Skipping reload, already attempted for buildId:', buildId);
                             return;
                         }
                         attemptedThisLoad = true;
                         sessionStorage.setItem(key, buildId);
+                        sessionStorage.setItem(timeKey, String(Date.now()));
                         try {
                             if (document.documentElement) {
                                 document.documentElement.style.backgroundColor = '#ffffff';
@@ -61,6 +67,21 @@ export default function HelperScript() {
                     }
                 }
                 window.addEventListener('error', function(e) { recover(e.message, 'error-event'); });
+                // Resource-load failures (a chunk 404ing or served with a
+                // disallowed MIME type) fire a non-bubbling 'error' event on the
+                // element itself, so they only reach window during capture, and
+                // they carry no message. Treat a failed script/link as stale.
+                window.addEventListener('error', function(e) {
+                    try {
+                        var el = e.target;
+                        if (!el || el === window) return;
+                        var tag = (el.tagName || '').toLowerCase();
+                        if (tag !== 'script' && tag !== 'link') return;
+                        var src = el.src || el.href || '';
+                        if (!src) return;
+                        recover('chunk resource failed to load: ' + src, 'resource-error');
+                    } catch (err) {}
+                }, true);
                 window.addEventListener('unhandledrejection', function(e) {
                     recover(e.reason && (e.reason.message || e.reason), 'unhandledrejection');
                 });

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

@@ -1,9 +1,10 @@
 export { autoDynamicPagesPlugin, type AutoDynamicPagesPluginOptions } from "./auto_dynamic_pages_plugin.js";
 export { autoLocaleParamsPlugin, type AutoLocaleParamsPluginOptions } from "./auto_locale_params_plugin.js";
+export { layoutQueriesPlugin, type LayoutQueriesPluginOptions } from "./layout_queries_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, isVinextAppPageRouteWiringSafeOnDisk, type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
+export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed, isVinextAppPageRouteWiringSafeOnDisk, patchAppPageProbe, isAppPageProbeFile, isAppPageProbeAlreadyFixed, isVinextAppPageProbeSafeOnDisk, type VinextRouteWiringFixPluginOptions, } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath, type LocaleFilePluginOptions } from "./locale_file_plugin.js";
 export { lucideOptimizerPlugin, detectLucideReact, resolveLucideEsmEntry, parseLucideIconMap, transformLucideImports, transformNextJsImports, type LucideOptimizerPluginOptions, } from "./lucide_optimizer_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, type CloudflareNextIntlOptions, default } from "./plugin.js";

package/dist/src/vite/index.js

@@ -1,9 +1,10 @@
 export { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
 export { autoLocaleParamsPlugin } from "./auto_locale_params_plugin.js";
+export { layoutQueriesPlugin } from "./layout_queries_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, isVinextAppPageRouteWiringSafeOnDisk } from "./vinext_route_wiring_fix.js";
+export { vinextRouteWiringFixPlugin, patchAppPageRouteWiring, isAppPageRouteWiringFile, isAppPageRouteWiringAlreadyFixed, isVinextAppPageRouteWiringSafeOnDisk, patchAppPageProbe, isAppPageProbeFile, isAppPageProbeAlreadyFixed, isVinextAppPageProbeSafeOnDisk, } from "./vinext_route_wiring_fix.js";
 export { localeFilePlugin, resolveDefaultIntlConfigPath } from "./locale_file_plugin.js";
 export { lucideOptimizerPlugin, detectLucideReact, resolveLucideEsmEntry, parseLucideIconMap, transformLucideImports, transformNextJsImports, } from "./lucide_optimizer_plugin.js";
 export { cloudflareNextIntl, cloudflareNextIntlPlugin, default } from "./plugin.js";

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

@@ -0,0 +1,7 @@
+import type { Plugin } from "vite";
+import { type CheckLayoutQueriesOptions } from "../layout_queries_check/index.js";
+export interface LayoutQueriesPluginOptions extends CheckLayoutQueriesOptions {
+    strict?: boolean;
+    runOnDev?: boolean;
+}
+export declare function layoutQueriesPlugin(options?: LayoutQueriesPluginOptions): Plugin;

package/dist/src/vite/layout_queries_plugin.js

@@ -0,0 +1,42 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { checkLayoutQueries } from "../layout_queries_check/index.js";
+export function layoutQueriesPlugin(options = {}) {
+    let ran = false;
+    return {
+        name: "cloudflare-next-intl-layout-queries-check",
+        enforce: "pre",
+        configResolved(config) {
+            if (ran)
+                return;
+            const isBuild = config.command === "build";
+            const isDev = config.command === "serve";
+            const runOnDev = options.runOnDev ?? true;
+            if (!isBuild && !(isDev && runOnDev))
+                return;
+            const root = config.root || process.cwd();
+            const candidateAppDirs = [
+                options.appDir,
+                resolve(root, "src/app"),
+                resolve(root, "app"),
+            ].filter((dir) => !!dir && existsSync(dir));
+            const appDir = candidateAppDirs[0];
+            if (!appDir)
+                return;
+            ran = true;
+            const report = checkLayoutQueries({
+                appDir,
+                rootDir: root,
+                aliases: options.aliases,
+                maxDepth: options.maxDepth,
+                throwOnError: false,
+            });
+            if (!report.valid) {
+                console.warn(report.formattedMessage);
+                if (options.strict) {
+                    throw new Error("[cloudflare-next-intl] Build failed: Blocking database queries detected in layout tree. See details above.");
+                }
+            }
+        },
+    };
+}

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

@@ -3,6 +3,7 @@ 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 AutoLocaleParamsPluginOptions } from "./auto_locale_params_plugin.js";
+import { type LayoutQueriesPluginOptions } from "./layout_queries_plugin.js";
 import { type VinextRouteWiringFixPluginOptions } from "./vinext_route_wiring_fix.js";
 import { type LucideOptimizerPluginOptions } from "./lucide_optimizer_plugin.js";
 export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
@@ -15,6 +16,7 @@ export interface CloudflareNextIntlOptions extends LocaleFilePluginOptions {
     imageOptimizer?: boolean | ImageOptimizerPluginOptions;
     vinextRouteWiringFix?: boolean | VinextRouteWiringFixPluginOptions;
     autoLocaleParams?: boolean | AutoLocaleParamsPluginOptions;
+    layoutQueriesCheck?: boolean | LayoutQueriesPluginOptions;
     experimentalRouteLoadingFixes?: boolean;
 }
 export declare function cloudflareNextIntl(options?: CloudflareNextIntlOptions): Plugin[];

package/dist/src/vite/plugin.js

@@ -5,16 +5,22 @@ import { localeFilePlugin } from "./locale_file_plugin.js";
 import { imageOptimizerPlugin } from "../image_optimizer/index.js";
 import { autoDynamicPagesPlugin } from "./auto_dynamic_pages_plugin.js";
 import { autoLocaleParamsPlugin } from "./auto_locale_params_plugin.js";
+import { layoutQueriesPlugin } from "./layout_queries_plugin.js";
 import { vinextRouteWiringFixPlugin } from "./vinext_route_wiring_fix.js";
 import { lucideOptimizerPlugin } from "./lucide_optimizer_plugin.js";
 export function cloudflareNextIntl(options = {}) {
     const plugins = [];
+    if (options.layoutQueriesCheck !== false) {
+        plugins.push(layoutQueriesPlugin(typeof options.layoutQueriesCheck === "object"
+            ? options.layoutQueriesCheck
+            : undefined));
+    }
     if (options.lucideOptimizer !== false) {
         plugins.push(lucideOptimizerPlugin(typeof options.lucideOptimizer === "object"
             ? options.lucideOptimizer
             : { root: options.root }));
     }
-    const enableRouteLoadingFixes = options.experimentalRouteLoadingFixes === true;
+    const enableRouteLoadingFixes = options.experimentalRouteLoadingFixes !== false;
     const shouldEnableVinextFix = options.vinextRouteWiringFix !== undefined
         ? Boolean(options.vinextRouteWiringFix)
         : enableRouteLoadingFixes;

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

@@ -1,6 +1,20 @@
 import type { Plugin } from "vite";
-export declare function isAppPageRouteWiringAlreadyFixed(code: string): boolean;
-export declare function patchAppPageRouteWiring(code: string): string;
+declare const REQUIRED_SYMBOLS: {
+    readonly routeWiring: readonly ["makeThenableParams", "resolveAppPageSegmentParams", "routeLoadingComponent", "ancestorLoadingEntry", "slotParams", "ownerLoadingEntry"];
+    readonly routeMatching: readonly ["trieMatch", "getOrBuildTrie", "normalizePathnameForRouteMatch"];
+    readonly optimisticRouting: readonly ["getRouteTrie", "matchNode", "decodeMatchedParams", "hrefToRouteParts"];
+    readonly prefetchLearning: readonly ["resolveOptimisticNavigationPayload", "__basePath", "optimisticRouteTemplates", "optimisticRouteTemplateSources", "optimisticRouteTemplateLearning", "getOptimisticPrefetchSourceKey", "parsePrefetchCacheKey", "getPrefetchCache", "isSettledPrefetchCacheEntry", "learnOptimisticRouteTemplateFromPrefetch", "currentHref", "rscUrl"];
+    readonly suspenseProbe: readonly ["REACT_CLIENT_REFERENCE_TYPE"];
+};
+export type VinextPatchName = keyof typeof REQUIRED_SYMBOLS;
+export declare function hasRequiredSymbols(code: string, patchName: VinextPatchName): boolean;
+export declare function missingRequiredSymbols(code: string, patchName: VinextPatchName): string[];
+export interface AppPageRouteWiringPatchOptions {
+    unblockRenderDependencies?: boolean;
+    unblockPageElementDependencies?: boolean;
+}
+export declare function isAppPageRouteWiringAlreadyFixed(code: string, options?: AppPageRouteWiringPatchOptions): boolean;
+export declare function patchAppPageRouteWiring(code: string, options?: AppPageRouteWiringPatchOptions): string;
 export declare function isRouteMatchingFile(id: string): boolean;
 export declare function isRouteMatchingAlreadyFixed(code: string): boolean;
 export declare function patchRouteMatching(code: string): string;
@@ -11,6 +25,32 @@ 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 isAppPageProbeFile(id: string): boolean;
+export declare function isAppPageProbeAlreadyFixed(code: string): boolean;
+export declare function patchAppPageProbe(code: string): string;
+export declare function resolveVinextAppPageProbePath(root?: string): string | null;
+export declare function isVinextAppPageProbeSafeOnDisk(root?: string): boolean;
+export declare function isRenderDependencyFile(id: string): boolean;
+export declare function isRenderDependencyAlreadyFixed(code: string): boolean;
+export declare function patchRenderDependency(code: string): string;
+export declare function resolveVinextRenderDependencyPath(root?: string): string | null;
+export declare function isVinextRenderDependencySafeOnDisk(root?: string): boolean;
+export declare function isOptimisticLearningTimeoutFile(id: string): boolean;
+export declare function isOptimisticLearningTimeoutAlreadyFixed(code: string): boolean;
+export declare function patchOptimisticLearningTimeout(code: string, timeoutMs?: number): string;
+export declare function resolveVinextOptimisticLearningTimeoutPath(root?: string): string | null;
+export declare function isVinextOptimisticLearningTimeoutSafeOnDisk(root?: string): boolean;
+export declare function isPageInvokerSuspensionReleaseFile(id: string): boolean;
+export declare function isPageInvokerSuspensionReleaseAlreadyFixed(code: string): boolean;
+export declare function patchPageInvokerSuspensionRelease(code: string): string;
+export declare function resolveVinextPageInvokerSuspensionReleasePath(root?: string): string | null;
+export declare function isVinextPageInvokerSuspensionReleaseSafeOnDisk(root?: string): boolean;
+export declare function isRefreshDeferralNavControllerFile(id: string): boolean;
+export declare function isRefreshDeferralNavControllerAlreadyFixed(code: string): boolean;
+export declare function patchRefreshDeferralNavController(code: string): string;
+export declare function isRefreshDeferralEntryAlreadyFixed(code: string): boolean;
+export declare function patchRefreshDeferralEntry(code: string): string;
+export declare function resolveVinextNavControllerPath(root?: string): string | null;
 export declare function isAppPageRouteWiringFile(id: string): boolean;
 export declare function resolveVinextAppPageRouteWiringPath(root?: string): string | null;
 export declare function isVinextAppPageRouteWiringSafeOnDisk(root?: string): boolean;
@@ -18,16 +58,32 @@ export declare function resolveVinextRouteMatchingPath(root?: string): string |
 export declare function resolveVinextOptimisticRoutingPath(root?: string): string | null;
 export interface SyncPatchVinextOnDiskOptions {
     routeWiring?: boolean;
+    unblockRenderDependencies?: boolean;
+    unblockPageElementDependencies?: boolean;
+    refreshDeferral?: boolean;
     routeMatching?: boolean;
     optimisticRouting?: boolean;
     prefetchLearning?: boolean;
+    suspenseProbe?: boolean;
+    renderDependency?: boolean;
+    optimisticLearningTimeout?: boolean | number;
+    pageInvokerSuspensionRelease?: boolean;
 }
 export declare function syncPatchVinextOnDisk(root?: string, options?: SyncPatchVinextOnDiskOptions): boolean;
 export declare function bustVinextOptimizeDepsCache(cacheDir: string): boolean;
+export declare function isVinextOptimizeDepsCacheStale(root: string, cacheDir: string): boolean;
 export interface VinextRouteWiringFixPluginOptions {
     routeWiring?: boolean;
     routeMatching?: boolean;
     optimisticRouting?: boolean;
     prefetchLearning?: boolean;
+    suspenseProbe?: boolean;
+    renderDependency?: boolean;
+    optimisticLearningTimeout?: boolean | number;
+    pageInvokerSuspensionRelease?: boolean;
+    unblockRenderDependencies?: boolean;
+    unblockPageElementDependencies?: boolean;
+    refreshDeferral?: boolean;
 }
 export declare function vinextRouteWiringFixPlugin(options?: VinextRouteWiringFixPluginOptions): Plugin;
+export {};

package/dist/src/vite/vinext_route_wiring_fix.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, rmSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 const PREFETCH_LOADING_FN_RE = /function\s+getPrefetchLoadingEntry\s*\(\s*route\s*\)\s*\{[\s\S]*?firstNestedEntry[\s\S]*?route\.loadings[\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) {
@@ -26,7 +26,7 @@ const FIXED_PREFETCH_LOADING_FN = `function getPrefetchLoadingEntry(route) {
 	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 ROUTE_LOADING_GUARD_RE = /if\s*\(\s*!isPrefetchLoadingShell\s*&&\s*treePosition\s*<\s*routeSegments\.length\s*\)\s*\{/;
 const FIXED_ROUTE_LOADING_GUARD = "if (!isPrefetchLoadingShell && treePosition < routeSegments.length && !routeLoadingComponent) {";
 const PAGE_LOADING_FALLBACK_RE = /fallback:\s*\/\*\s*@__PURE__\s*\*\/\s*jsx\s*\(\s*PageLoadingComponent\s*,\s*\{\s*\}\s*\)/;
 const FIXED_PAGE_LOADING_FALLBACK = "fallback: /* @__PURE__ */ jsx(PageLoadingComponent, { params: options.makeThenableParams(options.matchedParams) })";
@@ -44,7 +44,45 @@ const SEGMENT_LOADING_FALLBACK_RE = /fallback:\s*\/\*\s*@__PURE__\s*\*\/\s*jsx\s
 const FIXED_SEGMENT_LOADING_FALLBACK = "fallback: /* @__PURE__ */ jsx(segmentLoadingComponent, { params: options.makeThenableParams(resolveAppPageSegmentParams(options.route.routeSegments, treePosition, options.matchedParams)) })";
 const PREFETCH_SLOT_LOADING_CALL_RE = /slotElement\s*=\s*\/\*\s*@__PURE__\s*\*\/\s*jsx\s*\(\s*getDefaultExport\s*\(\s*prefetchSlotLoadingEntry\.loadingModule\s*\)\s*,\s*\{\s*\}\s*\)/;
 const FIXED_PREFETCH_SLOT_LOADING_CALL = "slotElement = /* @__PURE__ */ jsx(getDefaultExport(prefetchSlotLoadingEntry.loadingModule), { params: options.makeThenableParams(slotParams) })";
-export function isAppPageRouteWiringAlreadyFixed(code) {
+const PAGE_RESULT_DEPS_RE = /pageRenderDependency\?\.setResultDependencies\(\s*pageDependencies\s*\);/;
+const PAGE_ELEMENT_BLOCKING_DEP_RE = /elements\[pageElementId\]\s*=\s*isPrefetchLoadingShell\s*\?\s*null\s*:\s*pageRenderDependency\s*\?\s*pageElement\s*:\s*renderAfterAppDependencies\s*\(\s*pageElement\s*,\s*pageDependencies\s*\);/;
+const REQUIRED_SYMBOLS = {
+    routeWiring: [
+        "makeThenableParams",
+        "resolveAppPageSegmentParams",
+        "routeLoadingComponent",
+        "ancestorLoadingEntry",
+        "slotParams",
+        "ownerLoadingEntry",
+    ],
+    routeMatching: ["trieMatch", "getOrBuildTrie", "normalizePathnameForRouteMatch"],
+    optimisticRouting: ["getRouteTrie", "matchNode", "decodeMatchedParams", "hrefToRouteParts"],
+    prefetchLearning: [
+        "resolveOptimisticNavigationPayload",
+        "__basePath",
+        "optimisticRouteTemplates",
+        "optimisticRouteTemplateSources",
+        "optimisticRouteTemplateLearning",
+        "getOptimisticPrefetchSourceKey",
+        "parsePrefetchCacheKey",
+        "getPrefetchCache",
+        "isSettledPrefetchCacheEntry",
+        "learnOptimisticRouteTemplateFromPrefetch",
+        "currentHref",
+        "rscUrl",
+    ],
+    suspenseProbe: ["REACT_CLIENT_REFERENCE_TYPE"],
+};
+export function hasRequiredSymbols(code, patchName) {
+    return REQUIRED_SYMBOLS[patchName].every((symbol) => code.includes(symbol));
+}
+export function missingRequiredSymbols(code, patchName) {
+    return REQUIRED_SYMBOLS[patchName].filter((symbol) => !code.includes(symbol));
+}
+function warnIncompatible(filePath, patchName, code) {
+    console.warn(`[cfni:vinext-route-wiring-fix] ${filePath} no longer exposes ${missingRequiredSymbols(code, patchName).join(", ")} — this vinext version may have changed; the ${patchName} fix was NOT applied.`);
+}
+export function isAppPageRouteWiringAlreadyFixed(code, options = {}) {
     const hasBuggyPrefetch = code.includes("firstNestedEntry") &&
         PREFETCH_LOADING_FN_RE.test(code);
     const hasBuggySuspense = !code.includes("!routeLoadingComponent") && ROUTE_LOADING_GUARD_RE.test(code);
@@ -56,10 +94,14 @@ export function isAppPageRouteWiringAlreadyFixed(code) {
         ROUTE_LOADING_FALLBACK_RE.test(code) ||
         SEGMENT_LOADING_FALLBACK_RE.test(code) ||
         PREFETCH_SLOT_LOADING_CALL_RE.test(code);
-    return !hasBuggyPrefetch && !hasBuggySuspense && !hasEmptyLoadingProps;
+    const hasBlockingLayoutDependencies = options.unblockRenderDependencies === true &&
+        code.includes("elements[layoutEntry.id] = renderAfterAppDependencies(layoutElement, [...pageRenderDependency");
+    const hasBlockingPageDeps = options.unblockPageElementDependencies === true &&
+        (PAGE_RESULT_DEPS_RE.test(code) || PAGE_ELEMENT_BLOCKING_DEP_RE.test(code));
+    return !hasBuggyPrefetch && !hasBuggySuspense && !hasEmptyLoadingProps && !hasBlockingLayoutDependencies && !hasBlockingPageDeps;
 }
-export function patchAppPageRouteWiring(code) {
-    if (isAppPageRouteWiringAlreadyFixed(code)) {
+export function patchAppPageRouteWiring(code, options = {}) {
+    if (isAppPageRouteWiringAlreadyFixed(code, options)) {
         return code;
     }
     let result = code;
@@ -97,6 +139,30 @@ export function patchAppPageRouteWiring(code) {
     if (PREFETCH_SLOT_LOADING_CALL_RE.test(result)) {
         result = result.replace(PREFETCH_SLOT_LOADING_CALL_RE, FIXED_PREFETCH_SLOT_LOADING_CALL);
     }
+    if (options.unblockRenderDependencies === true) {
+        const LAYOUT_DEP_RE = /elements\[layoutEntry\.id\]\s*=\s*renderAfterAppDependencies\s*\(\s*layoutElement\s*,\s*\[\s*\.\.\.pageRenderDependency\s*\?\s*\[pageRenderDependency\]\s*:\s*\[\]\s*,\s*\.\.\.layoutDependenciesBefore\[index\]\s*\?\?\s*\[\]\s*\]\s*\);/;
+        if (LAYOUT_DEP_RE.test(result)) {
+            result = result.replace(LAYOUT_DEP_RE, "elements[layoutEntry.id] = renderAfterAppDependencies(layoutElement, layoutDependenciesBefore[index] ?? []);");
+        }
+        const TEMPLATE_DEP_RE = /elements\[templateEntry\.id\]\s*=\s*renderAfterAppDependencies\s*\(\s*templateElement\s*,\s*\[\s*\.\.\.pageRenderDependency\s*\?\s*\[pageRenderDependency\]\s*:\s*\[\]\s*,\s*\.\.\.templateDependenciesBeforeById\.get\(templateEntry\.id\)\s*\?\?\s*\[\]\s*\]\s*\);/;
+        if (TEMPLATE_DEP_RE.test(result)) {
+            result = result.replace(TEMPLATE_DEP_RE, "elements[templateEntry.id] = renderAfterAppDependencies(templateElement, templateDependenciesBeforeById.get(templateEntry.id) ?? []);");
+        }
+        const SLOT_DEP_RE = /elements\[slotId\]\s*=\s*renderAfterAppDependencies\s*\(\s*slotElement\s*,\s*\[\s*\.\.\.pageRenderDependency\s*\?\s*\[pageRenderDependency\]\s*:\s*\[\]\s*,\s*\.\.\.targetIndex\s*>=\s*0\s*\?\s*slotDependenciesByLayoutIndex\[targetIndex\]\s*\?\?\s*\[\]\s*:\s*\[\]\s*\]\s*\);/;
+        if (SLOT_DEP_RE.test(result)) {
+            result = result.replace(SLOT_DEP_RE, "elements[slotId] = renderAfterAppDependencies(slotElement, targetIndex >= 0 ? slotDependenciesByLayoutIndex[targetIndex] ?? [] : []);");
+        }
+        const ROUTE_DEP_RE = /elements\[routeId\]\s*=\s*pageRenderDependency\s*\?\s*renderAfterAppDependencies\s*\(\s*routeElement\s*,\s*\[pageRenderDependency\]\s*\)\s*:\s*routeElement;/;
+        if (ROUTE_DEP_RE.test(result)) {
+            result = result.replace(ROUTE_DEP_RE, "elements[routeId] = routeElement;");
+        }
+        if (options.unblockPageElementDependencies === true && PAGE_RESULT_DEPS_RE.test(result)) {
+            result = result.replace(PAGE_RESULT_DEPS_RE, "pageRenderDependency?.setResultDependencies([]);");
+        }
+        if (options.unblockPageElementDependencies === true && PAGE_ELEMENT_BLOCKING_DEP_RE.test(result)) {
+            result = result.replace(PAGE_ELEMENT_BLOCKING_DEP_RE, "elements[pageElementId] = isPrefetchLoadingShell ? null : pageElement;");
+        }
+    }
     return result;
 }
 export function isRouteMatchingFile(id) {
@@ -153,13 +219,13 @@ export function patchRouteMatching(code) {
         return code;
     }
     let result = code;
-    if (!result.includes("hasLeadingLocaleParam") && MATCH_ROUTE_WITH_TRIE_RE.test(result)) {
+    if (MATCH_ROUTE_WITH_TRIE_RE.test(result)) {
         const replacement = result.includes("function getActiveRouteLocale")
             ? FIXED_MATCH_ROUTE_WITH_TRIE_BODY
             : `${GET_ACTIVE_ROUTE_LOCALE_FN}${FIXED_MATCH_ROUTE_WITH_TRIE_BODY}`;
         result = result.replace(MATCH_ROUTE_WITH_TRIE_RE, replacement);
     }
-    if (!result.includes("hasLeadingLocaleParam") && MATCH_ROUTE_WITH_TRIE_RAW_RE.test(result)) {
+    if (MATCH_ROUTE_WITH_TRIE_RAW_RE.test(result)) {
         const replacement = result.includes("function getActiveRouteLocale")
             ? FIXED_MATCH_ROUTE_WITH_TRIE_RAW
             : `${GET_ACTIVE_ROUTE_LOCALE_FN}${FIXED_MATCH_ROUTE_WITH_TRIE_RAW}`;
@@ -336,6 +402,169 @@ 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 isAppPageProbeFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-page-probe.js") || cleanId.endsWith("/app-page-probe.ts");
+}
+export function isAppPageProbeAlreadyFixed(code) {
+    return code.includes("react.suspense") && code.includes("REACT_SUSPENSE_TYPE");
+}
+const REACT_SUSPENSE_DECL_RE = /const\s+REACT_CLIENT_REFERENCE_TYPE\s*=\s*Symbol\.for\(["']react\.client\.reference["']\);/;
+const PROBE_VISIT_FRAGMENT_RE = /if\s*\(\s*value\.type\s*===\s*Fragment\s*\|\|\s*typeof\s+value\.type\s*===\s*["']string["']\s*\)\s*\{/;
+export function patchAppPageProbe(code) {
+    if (isAppPageProbeAlreadyFixed(code)) {
+        return code;
+    }
+    let result = code;
+    if (!result.includes("REACT_SUSPENSE_TYPE") && REACT_SUSPENSE_DECL_RE.test(result)) {
+        result = result.replace(REACT_SUSPENSE_DECL_RE, 'const REACT_CLIENT_REFERENCE_TYPE = Symbol.for("react.client.reference");\nconst REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");');
+    }
+    if (result.includes("REACT_SUSPENSE_TYPE") && PROBE_VISIT_FRAGMENT_RE.test(result)) {
+        result = result.replace(PROBE_VISIT_FRAGMENT_RE, `if (value.type === Symbol.for("react.suspense") || value.type === REACT_SUSPENSE_TYPE) {\n\t\t\tif (value.props && "fallback" in value.props) await visit(value.props.fallback, depth + 1);\n\t\t\treturn;\n\t\t}\n\t\tif (value.type === Fragment || typeof value.type === "string") {`);
+    }
+    return result;
+}
+export function resolveVinextAppPageProbePath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-page-probe.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function isVinextAppPageProbeSafeOnDisk(root = process.cwd()) {
+    const filePath = resolveVinextAppPageProbePath(root);
+    if (!filePath)
+        return false;
+    try {
+        const content = readFileSync(filePath, "utf8");
+        return isAppPageProbeAlreadyFixed(content);
+    }
+    catch {
+        return false;
+    }
+}
+const SUSPENSION_GUARDED_RELEASE_RE = /if\s*\(\s*!isAppRenderSuspension\(\s*error\s*\)\s*\)\s*dependency\.release\(\);/;
+export function isRenderDependencyFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-render-dependency.js") || cleanId.endsWith("/app-render-dependency.tsx") || cleanId.endsWith("/app-render-dependency.ts");
+}
+export function isRenderDependencyAlreadyFixed(code) {
+    if (!code.includes("renderAppComponentWithDependencyBarrier"))
+        return true;
+    return !SUSPENSION_GUARDED_RELEASE_RE.test(code);
+}
+export function patchRenderDependency(code) {
+    if (!SUSPENSION_GUARDED_RELEASE_RE.test(code))
+        return code;
+    return code.replace(SUSPENSION_GUARDED_RELEASE_RE, "dependency.release();");
+}
+export function resolveVinextRenderDependencyPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-render-dependency.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function isVinextRenderDependencySafeOnDisk(root = process.cwd()) {
+    const filePath = resolveVinextRenderDependencyPath(root);
+    if (!filePath)
+        return false;
+    try {
+        return isRenderDependencyAlreadyFixed(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+const OPTIMISTIC_LEARNING_TIMEOUT_MS = 200;
+const OPTIMISTIC_LEARNING_BLOCKING_TIMEOUT_RE = /(new Promise\(\(resolve\)\s*=>\s*setTimeout\(resolve,\s*)3000(\)\))/;
+export function isOptimisticLearningTimeoutFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-browser-entry.js") || cleanId.endsWith("/app-browser-entry.ts") || cleanId.endsWith("/app-browser-entry.tsx");
+}
+export function isOptimisticLearningTimeoutAlreadyFixed(code) {
+    return !OPTIMISTIC_LEARNING_BLOCKING_TIMEOUT_RE.test(code);
+}
+export function patchOptimisticLearningTimeout(code, timeoutMs = OPTIMISTIC_LEARNING_TIMEOUT_MS) {
+    if (!OPTIMISTIC_LEARNING_BLOCKING_TIMEOUT_RE.test(code))
+        return code;
+    return code.replace(OPTIMISTIC_LEARNING_BLOCKING_TIMEOUT_RE, `$1${timeoutMs}$2`);
+}
+export function resolveVinextOptimisticLearningTimeoutPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-browser-entry.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function isVinextOptimisticLearningTimeoutSafeOnDisk(root = process.cwd()) {
+    const filePath = resolveVinextOptimisticLearningTimeoutPath(root);
+    if (!filePath)
+        return false;
+    try {
+        return isOptimisticLearningTimeoutAlreadyFixed(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+const PAGE_INVOKER_GUARDED_RELEASE_RE = /if\s*\(renderDependency\s*&&\s*hasPageLoadingBoundary\)\s*Promise\.resolve\(\)\.then\(\(\)\s*=>\s*renderDependency\.release\(\)\);/;
+export function isPageInvokerSuspensionReleaseFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-page-element-builder.js") || cleanId.endsWith("/app-page-element-builder.ts") || cleanId.endsWith("/app-page-element-builder.tsx");
+}
+export function isPageInvokerSuspensionReleaseAlreadyFixed(code) {
+    return !PAGE_INVOKER_GUARDED_RELEASE_RE.test(code);
+}
+export function patchPageInvokerSuspensionRelease(code) {
+    if (!PAGE_INVOKER_GUARDED_RELEASE_RE.test(code))
+        return code;
+    return code.replace(PAGE_INVOKER_GUARDED_RELEASE_RE, "if (renderDependency) Promise.resolve().then(() => renderDependency.release());");
+}
+export function resolveVinextPageInvokerSuspensionReleasePath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-page-element-builder.js");
+    return existsSync(directPath) ? directPath : null;
+}
+export function isVinextPageInvokerSuspensionReleaseSafeOnDisk(root = process.cwd()) {
+    const filePath = resolveVinextPageInvokerSuspensionReleasePath(root);
+    if (!filePath)
+        return false;
+    try {
+        return isPageInvokerSuspensionReleaseAlreadyFixed(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+const NAV_CONTROLLER_BEGIN_NAVIGATION_RE = /function\s+beginNavigation\(\s*\)\s*\{(\n([\t ]*))latestHmrUpdateId\s*\+=\s*1;/;
+const NAV_CONTROLLER_STATE_DECL_RE = /(\n\s*let\s+latestHmrUpdateId\s*=\s*0;)/;
+const NAV_CONTROLLER_RETURN_RE = /(\n\s*return\s*\{\s*\n\s*beginNavigation,)/;
+const NAV_ENTRY_NAVIGATE_FN_RE = /(navigate:\s*async function navigateRsc\([^)]*\)\s*\{)(\n([\t ]*))/;
+const NAV_ENTRY_BEGIN_NAVIGATION_RE = /(\n[\t ]*const navId = browserNavigationController\.)beginNavigation\(\);/;
+const REFRESH_DEFERRAL_WINDOW_MS = 600;
+export function isRefreshDeferralNavControllerFile(id) {
+    const cleanId = id.split("?")[0].replace(/\\/g, "/");
+    return cleanId.endsWith("/app-browser-navigation-controller.js") || cleanId.endsWith("/app-browser-navigation-controller.ts");
+}
+export function isRefreshDeferralNavControllerAlreadyFixed(code) {
+    return code.includes("isRecentNonRefreshNavigationInFlight") || !NAV_CONTROLLER_BEGIN_NAVIGATION_RE.test(code);
+}
+export function patchRefreshDeferralNavController(code) {
+    if (isRefreshDeferralNavControllerAlreadyFixed(code))
+        return code;
+    if (!NAV_CONTROLLER_STATE_DECL_RE.test(code) || !NAV_CONTROLLER_RETURN_RE.test(code))
+        return code;
+    let result = code.replace(NAV_CONTROLLER_STATE_DECL_RE, "\n\tlet lastNonRefreshNavigationStartedAt = 0;$1");
+    result = result.replace(NAV_CONTROLLER_BEGIN_NAVIGATION_RE, (_m, _nl, indent) => `function beginNavigation(kind) {\n${indent}latestHmrUpdateId += 1;\n${indent}if (kind !== "refresh") lastNonRefreshNavigationStartedAt = Date.now();`);
+    result = result.replace(/(\n\s*function getActiveNavigationId\(\) \{)/, `\n\tconst REFRESH_DEFERRAL_WINDOW_MS = ${REFRESH_DEFERRAL_WINDOW_MS};\n\tfunction isRecentNonRefreshNavigationInFlight() {\n\t\treturn lastNonRefreshNavigationStartedAt !== 0 && Date.now() - lastNonRefreshNavigationStartedAt < REFRESH_DEFERRAL_WINDOW_MS;\n\t}$1`);
+    result = result.replace(NAV_CONTROLLER_RETURN_RE, "$1\n\t\tisRecentNonRefreshNavigationInFlight,");
+    return result;
+}
+export function isRefreshDeferralEntryAlreadyFixed(code) {
+    return code.includes("isRecentNonRefreshNavigationInFlight()") || !NAV_ENTRY_NAVIGATE_FN_RE.test(code);
+}
+export function patchRefreshDeferralEntry(code) {
+    if (isRefreshDeferralEntryAlreadyFixed(code))
+        return code;
+    let result = code.replace(NAV_ENTRY_NAVIGATE_FN_RE, (_m, signature, _nl, indent) => `${signature}\n${indent}if (navigationKind === "refresh") {\n${indent}\twhile (browserNavigationController.isRecentNonRefreshNavigationInFlight()) await new Promise((resolve) => setTimeout(resolve, 50));\n${indent}}\n${indent}`);
+    result = result.replace(NAV_ENTRY_BEGIN_NAVIGATION_RE, "$1beginNavigation(navigationKind);");
+    return result;
+}
+export function resolveVinextNavControllerPath(root = process.cwd()) {
+    const directPath = resolve(root, "node_modules/vinext/dist/server/app-browser-navigation-controller.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");
@@ -365,14 +594,18 @@ 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, prefetchLearning = true } = options;
+    const { routeWiring = true, routeMatching = true, optimisticRouting = true, prefetchLearning = true, suspenseProbe = true, renderDependency = true, optimisticLearningTimeout = true, pageInvokerSuspensionRelease = true, unblockRenderDependencies = true, unblockPageElementDependencies = false, refreshDeferral = true } = options;
+    const optimisticLearningTimeoutMs = typeof optimisticLearningTimeout === "number" ? optimisticLearningTimeout : undefined;
     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 (!isAppPageRouteWiringAlreadyFixed(content, { unblockRenderDependencies, unblockPageElementDependencies }) && !hasRequiredSymbols(content, "routeWiring")) {
+                warnIncompatible(wiringPath, "routeWiring", content);
+            }
+            else if (!isAppPageRouteWiringAlreadyFixed(content, { unblockRenderDependencies, unblockPageElementDependencies })) {
+                const patched = patchAppPageRouteWiring(content, { unblockRenderDependencies, unblockPageElementDependencies });
                 if (patched !== content) {
                     writeFileSync(wiringPath, patched, "utf8");
                     changed = true;
@@ -389,7 +622,10 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
     if (matchingPath) {
         try {
             const content = readFileSync(matchingPath, "utf8");
-            if (!isRouteMatchingAlreadyFixed(content)) {
+            if (!isRouteMatchingAlreadyFixed(content) && !hasRequiredSymbols(content, "routeMatching")) {
+                warnIncompatible(matchingPath, "routeMatching", content);
+            }
+            else if (!isRouteMatchingAlreadyFixed(content)) {
                 const patched = patchRouteMatching(content);
                 if (patched !== content) {
                     writeFileSync(matchingPath, patched, "utf8");
@@ -407,7 +643,10 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
     if (optimisticPath) {
         try {
             const content = readFileSync(optimisticPath, "utf8");
-            if (!isOptimisticRoutingAlreadyFixed(content)) {
+            if (!isOptimisticRoutingAlreadyFixed(content) && !hasRequiredSymbols(content, "optimisticRouting")) {
+                warnIncompatible(optimisticPath, "optimisticRouting", content);
+            }
+            else if (!isOptimisticRoutingAlreadyFixed(content)) {
                 const patched = patchOptimisticRouting(content);
                 if (patched !== content) {
                     writeFileSync(optimisticPath, patched, "utf8");
@@ -425,7 +664,10 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
     if (browserEntryPath) {
         try {
             const content = readFileSync(browserEntryPath, "utf8");
-            if (!isPrefetchLearningAlreadyFixed(content)) {
+            if (!isPrefetchLearningAlreadyFixed(content) && !hasRequiredSymbols(content, "prefetchLearning")) {
+                warnIncompatible(browserEntryPath, "prefetchLearning", content);
+            }
+            else if (!isPrefetchLearningAlreadyFixed(content)) {
                 const patched = patchPrefetchLearning(content);
                 if (patched !== content) {
                     writeFileSync(browserEntryPath, patched, "utf8");
@@ -439,6 +681,111 @@ export function syncPatchVinextOnDisk(root = process.cwd(), options = {}) {
         catch {
         }
     }
+    const probePath = suspenseProbe ? resolveVinextAppPageProbePath(root) : null;
+    if (probePath) {
+        try {
+            const content = readFileSync(probePath, "utf8");
+            if (!isAppPageProbeAlreadyFixed(content) && !hasRequiredSymbols(content, "suspenseProbe")) {
+                warnIncompatible(probePath, "suspenseProbe", content);
+            }
+            else if (!isAppPageProbeAlreadyFixed(content)) {
+                const patched = patchAppPageProbe(content);
+                if (patched !== content) {
+                    writeFileSync(probePath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${probePath} does not match the expected shape for patchAppPageProbe — this vinext version may have changed; the suspense-probe fix was NOT applied.`);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const renderDependencyPath = renderDependency ? resolveVinextRenderDependencyPath(root) : null;
+    if (renderDependencyPath) {
+        try {
+            const content = readFileSync(renderDependencyPath, "utf8");
+            if (!isRenderDependencyAlreadyFixed(content)) {
+                const patched = patchRenderDependency(content);
+                if (patched !== content) {
+                    writeFileSync(renderDependencyPath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${renderDependencyPath} does not match the expected shape for patchRenderDependency — this vinext version may have changed; the render-dependency fix was NOT applied.`);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const optimisticLearningTimeoutEnabled = optimisticLearningTimeout !== false && optimisticLearningTimeout !== undefined;
+    const optimisticLearningTimeoutPath = optimisticLearningTimeoutEnabled ? resolveVinextOptimisticLearningTimeoutPath(root) : null;
+    if (optimisticLearningTimeoutPath) {
+        try {
+            const content = readFileSync(optimisticLearningTimeoutPath, "utf8");
+            if (!isOptimisticLearningTimeoutAlreadyFixed(content)) {
+                const patched = patchOptimisticLearningTimeout(content, optimisticLearningTimeoutMs);
+                if (patched !== content) {
+                    writeFileSync(optimisticLearningTimeoutPath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${optimisticLearningTimeoutPath} does not match the expected shape for patchOptimisticLearningTimeout — this vinext version may have changed; the optimistic-learning-timeout fix was NOT applied.`);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const pageInvokerSuspensionReleasePath = pageInvokerSuspensionRelease ? resolveVinextPageInvokerSuspensionReleasePath(root) : null;
+    if (pageInvokerSuspensionReleasePath) {
+        try {
+            const content = readFileSync(pageInvokerSuspensionReleasePath, "utf8");
+            if (!isPageInvokerSuspensionReleaseAlreadyFixed(content)) {
+                const patched = patchPageInvokerSuspensionRelease(content);
+                if (patched !== content) {
+                    writeFileSync(pageInvokerSuspensionReleasePath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${pageInvokerSuspensionReleasePath} does not match the expected shape for patchPageInvokerSuspensionRelease — this vinext version may have changed; the page-invoker-suspension-release fix was NOT applied.`);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    const navControllerPath = refreshDeferral ? resolveVinextNavControllerPath(root) : null;
+    if (navControllerPath) {
+        try {
+            const content = readFileSync(navControllerPath, "utf8");
+            if (!isRefreshDeferralNavControllerAlreadyFixed(content)) {
+                const patched = patchRefreshDeferralNavController(content);
+                if (patched !== content) {
+                    writeFileSync(navControllerPath, patched, "utf8");
+                    changed = true;
+                }
+                else {
+                    console.warn(`[cfni:vinext-route-wiring-fix] ${navControllerPath} does not match the expected shape for patchRefreshDeferralNavController — this vinext version may have changed; the refresh-deferral fix was NOT applied.`);
+                }
+            }
+            const entryPath = resolveVinextBrowserEntryPath(root);
+            if (entryPath && isRefreshDeferralNavControllerAlreadyFixed(readFileSync(navControllerPath, "utf8"))) {
+                const entryContent = readFileSync(entryPath, "utf8");
+                if (!isRefreshDeferralEntryAlreadyFixed(entryContent)) {
+                    const patchedEntry = patchRefreshDeferralEntry(entryContent);
+                    if (patchedEntry !== entryContent) {
+                        writeFileSync(entryPath, patchedEntry, "utf8");
+                        changed = true;
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
     return changed;
 }
 export function bustVinextOptimizeDepsCache(cacheDir) {
@@ -456,20 +803,61 @@ export function bustVinextOptimizeDepsCache(cacheDir) {
     }
     return removed;
 }
+export function isVinextOptimizeDepsCacheStale(root, cacheDir) {
+    const patchedFiles = [
+        resolveVinextAppPageRouteWiringPath(root),
+        resolveVinextRouteMatchingPath(root),
+        resolveVinextOptimisticRoutingPath(root),
+        resolveVinextBrowserEntryPath(root),
+        resolveVinextAppPageProbePath(root),
+        resolveVinextRenderDependencyPath(root),
+        resolveVinextPageInvokerSuspensionReleasePath(root),
+    ].filter((filePath) => filePath !== null);
+    let newestPatch = 0;
+    for (const filePath of patchedFiles) {
+        try {
+            newestPatch = Math.max(newestPatch, statSync(filePath).mtimeMs);
+        }
+        catch {
+        }
+    }
+    if (newestPatch === 0)
+        return false;
+    for (const sub of ["deps", "deps_ssr", "deps_rsc"]) {
+        const dir = resolve(cacheDir, sub);
+        if (!existsSync(dir))
+            continue;
+        try {
+            if (statSync(dir).mtimeMs < newestPatch)
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
 export function vinextRouteWiringFixPlugin(options = {}) {
     console.warn("[cloudflare-next-intl] WARNING: vinextRouteWiringFix is enabled. Monkey-patching vinext on disk is dangerous and can break routing or upstream compatibility.");
     const routeWiring = options.routeWiring !== false;
     const routeMatching = options.routeMatching !== false;
     const optimisticRouting = options.optimisticRouting !== false;
     const prefetchLearning = options.prefetchLearning !== false;
+    const suspenseProbe = options.suspenseProbe !== false;
+    const renderDependency = options.renderDependency !== false;
+    const optimisticLearningTimeout = options.optimisticLearningTimeout !== false;
+    const optimisticLearningTimeoutMs = typeof options.optimisticLearningTimeout === "number" ? options.optimisticLearningTimeout : undefined;
+    const pageInvokerSuspensionRelease = options.pageInvokerSuspensionRelease !== false;
+    const unblockRenderDependencies = options.unblockRenderDependencies !== false;
+    const unblockPageElementDependencies = options.unblockPageElementDependencies === true;
+    const refreshDeferral = options.refreshDeferral !== false;
     return {
         name: "cfni:vinext-route-wiring-fix",
         enforce: "pre",
         configResolved(config) {
             const root = config.root || process.cwd();
-            const changed = syncPatchVinextOnDisk(root, { routeWiring, routeMatching, optimisticRouting, prefetchLearning });
-            if (changed) {
-                const cacheDir = config.cacheDir || resolve(root, "node_modules/.vite");
+            const changed = syncPatchVinextOnDisk(root, { routeWiring, routeMatching, optimisticRouting, prefetchLearning, suspenseProbe, renderDependency, optimisticLearningTimeout: options.optimisticLearningTimeout ?? true, pageInvokerSuspensionRelease, unblockRenderDependencies, unblockPageElementDependencies, refreshDeferral });
+            const cacheDir = config.cacheDir || resolve(root, "node_modules/.vite");
+            if (changed || isVinextOptimizeDepsCacheStale(root, cacheDir)) {
                 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.");
@@ -478,10 +866,10 @@ export function vinextRouteWiringFixPlugin(options = {}) {
         },
         transform(code, id) {
             if (routeWiring && isAppPageRouteWiringFile(id)) {
-                if (isAppPageRouteWiringAlreadyFixed(code)) {
+                if (isAppPageRouteWiringAlreadyFixed(code, { unblockRenderDependencies, unblockPageElementDependencies }) || !hasRequiredSymbols(code, "routeWiring")) {
                     return;
                 }
-                const patched = patchAppPageRouteWiring(code);
+                const patched = patchAppPageRouteWiring(code, { unblockRenderDependencies, unblockPageElementDependencies });
                 if (patched === code) {
                     return;
                 }
@@ -491,7 +879,7 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                 };
             }
             if (routeMatching && isRouteMatchingFile(id)) {
-                if (isRouteMatchingAlreadyFixed(code)) {
+                if (isRouteMatchingAlreadyFixed(code) || !hasRequiredSymbols(code, "routeMatching")) {
                     return;
                 }
                 const patched = patchRouteMatching(code);
@@ -503,11 +891,17 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     map: null,
                 };
             }
-            if (prefetchLearning && isPrefetchLearningFile(id)) {
-                if (isPrefetchLearningAlreadyFixed(code)) {
-                    return;
+            if ((prefetchLearning && isPrefetchLearningFile(id)) || (optimisticLearningTimeout && isOptimisticLearningTimeoutFile(id)) || (refreshDeferral && isPrefetchLearningFile(id))) {
+                let patched = code;
+                if (prefetchLearning && isPrefetchLearningFile(id) && !isPrefetchLearningAlreadyFixed(patched) && hasRequiredSymbols(patched, "prefetchLearning")) {
+                    patched = patchPrefetchLearning(patched);
+                }
+                if (optimisticLearningTimeout && isOptimisticLearningTimeoutFile(id)) {
+                    patched = patchOptimisticLearningTimeout(patched, optimisticLearningTimeoutMs);
+                }
+                if (refreshDeferral) {
+                    patched = patchRefreshDeferralEntry(patched);
                 }
-                const patched = patchPrefetchLearning(code);
                 if (patched === code) {
                     return;
                 }
@@ -517,7 +911,7 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                 };
             }
             if (optimisticRouting && isOptimisticRoutingFile(id)) {
-                if (isOptimisticRoutingAlreadyFixed(code)) {
+                if (isOptimisticRoutingAlreadyFixed(code) || !hasRequiredSymbols(code, "optimisticRouting")) {
                     return;
                 }
                 const patched = patchOptimisticRouting(code);
@@ -529,6 +923,58 @@ export function vinextRouteWiringFixPlugin(options = {}) {
                     map: null,
                 };
             }
+            if (renderDependency && isRenderDependencyFile(id)) {
+                if (isRenderDependencyAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchRenderDependency(code);
+                if (patched === code) {
+                    return;
+                }
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+            if (pageInvokerSuspensionRelease && isPageInvokerSuspensionReleaseFile(id)) {
+                if (isPageInvokerSuspensionReleaseAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchPageInvokerSuspensionRelease(code);
+                if (patched === code) {
+                    return;
+                }
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+            if (refreshDeferral && isRefreshDeferralNavControllerFile(id)) {
+                if (isRefreshDeferralNavControllerAlreadyFixed(code)) {
+                    return;
+                }
+                const patched = patchRefreshDeferralNavController(code);
+                if (patched === code) {
+                    return;
+                }
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
+            if (suspenseProbe && isAppPageProbeFile(id)) {
+                if (isAppPageProbeAlreadyFixed(code) || !hasRequiredSymbols(code, "suspenseProbe")) {
+                    return;
+                }
+                const patched = patchAppPageProbe(code);
+                if (patched === code) {
+                    return;
+                }
+                return {
+                    code: patched,
+                    map: null,
+                };
+            }
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.50",
+  "version": "0.9.52",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
     "cfni-image-optimizer": "bin/image_optimizer.mjs",
     "optimize-images": "bin/image_optimizer.mjs",
     "cfni-check-dynamic-pages": "bin/check_dynamic_pages.mjs",
-    "cfni-check-locale-params": "bin/check_locale_params.mjs"
+    "cfni-check-locale-params": "bin/check_locale_params.mjs",
+    "cfni-check-layout-queries": "bin/check_layout_queries.mjs"
   },
   "files": [
     "dist",
@@ -243,6 +244,10 @@
       "types": "./dist/src/locale_params_check/index.d.ts",
       "import": "./dist/src/locale_params_check/index.js"
     },
+    "./checkLayoutQueries": {
+      "types": "./dist/src/layout_queries_check/index.d.ts",
+      "import": "./dist/src/layout_queries_check/index.js"
+    },
     "./db": {
       "types": "./dist/src/db/index.d.ts",
       "import": "./dist/src/db/index.js"