cloudflare-next-intl 0.6.5 → 0.6.7

package/dist/src/client/components/client_provider.js

@@ -5,6 +5,7 @@ import { createContext, useMemo } from "react";
 import dynamic from "next/dynamic";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override";
+import installGlobalErrorOverride from "../../error_handling/install_global_error_override";
 export const LocaleContext = createContext(undefined);
 // Hoisted to module scope — calling `dynamic()` inside the component body
 // creates a brand-new component identity every render, forcing React to
@@ -22,6 +23,7 @@ export default function LocationzationClientProvider({ language, messages, initi
     setLocaleCache(language);
     setMessageForLocaleCache(language, messages);
     installConsoleErrorOverride(config, true);
+    installGlobalErrorOverride(config);
     // `LocaleContext.Provider` stays the outermost element here — the
     // client `AuthUserProvider` (and its descendants calling
     // usePathname()/useLocale()) must render as a CHILD of it, not a

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

@@ -3,6 +3,7 @@ export type { WithErrorHandlingOptions } from './with_error_handling';
 export { default as reportError } from './report_error';
 export type { ReportErrorConfig } from './report_error';
 export { default as installConsoleErrorOverride } from './install_console_error_override';
+export { default as installGlobalErrorOverride } from './install_global_error_override';
 export { default as stringifyUnknown } from './stringify_unknown';
 export { default as formatErrorMessage } from './format_error_message';
 export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';

package/dist/src/error_handling/index.js

@@ -1,6 +1,7 @@
 export { default as withErrorHandling } from './with_error_handling';
 export { default as reportError } from './report_error';
 export { default as installConsoleErrorOverride } from './install_console_error_override';
+export { default as installGlobalErrorOverride } from './install_global_error_override';
 export { default as stringifyUnknown } from './stringify_unknown';
 export { default as formatErrorMessage } from './format_error_message';
 export { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';

package/dist/src/error_handling/install_console_error_override.d.ts

@@ -2,11 +2,29 @@ import { type ReportErrorConfig } from './report_error';
 /**
  * Replaces the global `console.error` so every `console.error(...)` call is
  * also routed through `config.errorHandling.onError`/`reportError` — the
- * original `console.error` still runs afterwards, nothing is swallowed.
- * Safe to call more than once (a no-op after the first call in this JS
- * realm — call it separately on the server and on the client, each has its
- * own `console`). Only takes effect when `config.errorHandling.overrideConsoleError`
- * is `true`.
+ * original `console.error` still runs afterwards, nothing is swallowed by
+ * default. Safe to call more than once (a no-op after the first call in
+ * this JS realm — call it separately on the server and on the client, each
+ * has its own `console`). Only takes effect when
+ * `config.errorHandling.overrideConsoleError` is `true`.
+ *
+ * On the client ONLY (`isClient: true`), passing
+ * `config.errorHandling.suppressClientConsoleError: true` skips the
+ * browser's own `console.error` output entirely once a call has been
+ * routed to `onError`/`reportError` — the error is still reported, it just
+ * never shows up in browser devtools. Has no effect server-side.
+ *
+ * Sets `consoleOverrideState.active = true` in `report_error.ts` — once
+ * installed, THIS override becomes the sole place that ever calls the real
+ * console for a report (it already logs the raw message below, before
+ * calling `reportError`), and `reportError`'s own console-logging step
+ * stays out of the loop entirely. Without that, `reportError`'s own
+ * fallback log would call `console.error` again — landing right back on
+ * this override and recursing. (An "original console.error, captured once
+ * at module load" reference does NOT reliably dodge this: Next.js's own
+ * dev-mode console interception forwards through whatever `console.error`
+ * is CURRENT at call time, not the function it originally wrapped, so a
+ * stale capture can still loop back into a patched `console.error`.)
  *
  * A component stuck in a render-error loop calls `console.error` on every
  * render — `reportError`'s own dedup/cap (on by default, see

package/dist/src/error_handling/install_console_error_override.js

@@ -1,14 +1,32 @@
-import reportError from './report_error';
+import reportError, { consoleOverrideState } from './report_error';
 import stringifyUnknown from './stringify_unknown';
 import { defaultIgnoredConsoleErrors } from './default_ignored_console_errors';
 /**
  * Replaces the global `console.error` so every `console.error(...)` call is
  * also routed through `config.errorHandling.onError`/`reportError` — the
- * original `console.error` still runs afterwards, nothing is swallowed.
- * Safe to call more than once (a no-op after the first call in this JS
- * realm — call it separately on the server and on the client, each has its
- * own `console`). Only takes effect when `config.errorHandling.overrideConsoleError`
- * is `true`.
+ * original `console.error` still runs afterwards, nothing is swallowed by
+ * default. Safe to call more than once (a no-op after the first call in
+ * this JS realm — call it separately on the server and on the client, each
+ * has its own `console`). Only takes effect when
+ * `config.errorHandling.overrideConsoleError` is `true`.
+ *
+ * On the client ONLY (`isClient: true`), passing
+ * `config.errorHandling.suppressClientConsoleError: true` skips the
+ * browser's own `console.error` output entirely once a call has been
+ * routed to `onError`/`reportError` — the error is still reported, it just
+ * never shows up in browser devtools. Has no effect server-side.
+ *
+ * Sets `consoleOverrideState.active = true` in `report_error.ts` — once
+ * installed, THIS override becomes the sole place that ever calls the real
+ * console for a report (it already logs the raw message below, before
+ * calling `reportError`), and `reportError`'s own console-logging step
+ * stays out of the loop entirely. Without that, `reportError`'s own
+ * fallback log would call `console.error` again — landing right back on
+ * this override and recursing. (An "original console.error, captured once
+ * at module load" reference does NOT reliably dodge this: Next.js's own
+ * dev-mode console interception forwards through whatever `console.error`
+ * is CURRENT at call time, not the function it originally wrapped, so a
+ * stale capture can still loop back into a patched `console.error`.)
  *
  * A component stuck in a render-error loop calls `console.error` on every
  * render — `reportError`'s own dedup/cap (on by default, see
@@ -34,8 +52,12 @@ export default function installConsoleErrorOverride(config, isClient) {
     if (console.error.__isErrorHandlingOverride)
         return;
     const originalConsoleError = console.error.bind(console);
+    consoleOverrideState.active = true;
+    const suppressOnClient = isClient === true && config.errorHandling?.suppressClientConsoleError === true;
     const override = (message, ...optionalParams) => {
-        originalConsoleError(message, ...optionalParams);
+        if (!suppressOnClient) {
+            originalConsoleError(message, ...optionalParams);
+        }
         const stringified = stringifyUnknown(message, isClient);
         const ignoreList = config.errorHandling?.ignoreConsoleErrors ?? defaultIgnoredConsoleErrors;
         if (ignoreList.some((ignored) => stringified.includes(ignored)))

package/dist/src/error_handling/install_global_error_override.d.ts

@@ -0,0 +1,20 @@
+import { type ReportErrorConfig } from './report_error';
+/**
+ * Client-only: attaches `window.addEventListener('error'|'unhandledrejection', ...)`
+ * handlers that route through `config.errorHandling.onError`/`reportError` —
+ * catches uncaught exceptions and unhandled promise rejections that never go
+ * through `console.error` at all (unlike `installConsoleErrorOverride`),
+ * e.g. Next.js's own internal "Failed to fetch RSC payload" navigation
+ * fallback. Neither handler calls `event.preventDefault()` — the browser's
+ * own default handling (logging to the console) still happens, nothing is
+ * swallowed. Safe to call more than once (a no-op after the first call in
+ * this JS realm). Takes effect when `config.errorHandling.overrideWindowErrors`
+ * is `true`, or when it's omitted and `overrideConsoleError` is `true` (so
+ * enabling `overrideConsoleError` alone catches everything by default; pass
+ * `overrideWindowErrors: false` explicitly to opt out of just this part).
+ * No-op when `window` doesn't exist (server-side).
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function installGlobalErrorOverride(config: ReportErrorConfig | undefined): void;

package/dist/src/error_handling/install_global_error_override.js

@@ -0,0 +1,44 @@
+import reportError from './report_error';
+import stringifyUnknown from './stringify_unknown';
+/**
+ * Client-only: attaches `window.addEventListener('error'|'unhandledrejection', ...)`
+ * handlers that route through `config.errorHandling.onError`/`reportError` —
+ * catches uncaught exceptions and unhandled promise rejections that never go
+ * through `console.error` at all (unlike `installConsoleErrorOverride`),
+ * e.g. Next.js's own internal "Failed to fetch RSC payload" navigation
+ * fallback. Neither handler calls `event.preventDefault()` — the browser's
+ * own default handling (logging to the console) still happens, nothing is
+ * swallowed. Safe to call more than once (a no-op after the first call in
+ * this JS realm). Takes effect when `config.errorHandling.overrideWindowErrors`
+ * is `true`, or when it's omitted and `overrideConsoleError` is `true` (so
+ * enabling `overrideConsoleError` alone catches everything by default; pass
+ * `overrideWindowErrors: false` explicitly to opt out of just this part).
+ * No-op when `window` doesn't exist (server-side).
+ *
+ * @param config Pass the relevant slices of your `RoutingConfig` directly —
+ *   `{ errorHandling: config.errorHandling, generate: config.generate }`.
+ */
+export default function installGlobalErrorOverride(config) {
+    const enabled = config?.errorHandling?.overrideWindowErrors ?? config?.errorHandling?.overrideConsoleError;
+    if (enabled !== true)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    if (window.__isGlobalErrorOverrideInstalled)
+        return;
+    window.__isGlobalErrorOverrideInstalled = true;
+    window.addEventListener('error', (event) => {
+        void reportError(config, {
+            error: event.error ?? stringifyUnknown(event.message, true),
+            classOrMethodName: 'Global Window Error Handler',
+            isClient: true,
+        });
+    });
+    window.addEventListener('unhandledrejection', (event) => {
+        void reportError(config, {
+            error: event.reason,
+            classOrMethodName: 'Global Unhandled Rejection Handler',
+            isClient: true,
+        });
+    });
+}

package/dist/src/error_handling/report_error.d.ts

@@ -3,14 +3,23 @@ export interface ReportErrorConfig {
     errorHandling?: ErrorHandlingRoutingConfig;
     generate?: GenerateRoutingConfig;
 }
+export declare const consoleOverrideState: {
+    active: boolean;
+};
 /**
- * Reports `params` via `config.errorHandling.onError` (default
- * `console.error(params.formattedMessage)`), unless
+ * Reports `params`: logs `params.formattedMessage` via `console.error`
+ * (unless `config.errorHandling.logToConsole` is `false`, or
+ * `installConsoleErrorOverride` is active — in which case IT already did
+ * the console logging before calling this) AND calls
+ * `config.errorHandling.onError` when set — both run, not one instead of
+ * the other, so wiring `onError` (Sentry, Telegram, etc) never silently
+ * loses the console output. Skips reporting entirely when
  * `config.errorHandling.enable === false`, `params.consent` is set and not
  * `true` (reporting to a third party without cookie consent can itself be
  * GDPR-relevant), or dedup throttles it (on by default — see
  * `errorHandling.dedup`/`throttleMs`/`resetDedup`). Never throws — a broken
- * reporter must not mask the original error.
+ * `onError` must not mask the original error (falls back to logging via
+ * `console.error` instead, when the override isn't already handling that).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line
@@ -18,15 +27,20 @@ export interface ReportErrorConfig {
  * instead of the raw `error`/`params` object, for a default reporter (or a
  * simple `onError`) to print directly.
  *
- * When `config.generate?.getCloudflareContext` is set, `waitUntil` is called
- * SYNCHRONOUSLY, in the same tick, with the `callOnError(...)` promise —
- * Cloudflare Workers only extends the request's lifetime for work already
- * registered with `waitUntil` by the time the handler returns; deferring
- * that call through an extra microtask (e.g. `Promise.resolve().then(...)`)
- * risks the isolate tearing down the request before `waitUntil` is ever
- * actually invoked, silently dropping the report. Falls back to awaiting
- * `onError` directly when `getCloudflareContext`/`ctx.waitUntil` is unset or
- * unavailable (e.g. outside a Cloudflare Worker).
+ * When `config.generate?.getCloudflareContext` is set AND `params.isClient`
+ * is not `true`, `waitUntil` is called SYNCHRONOUSLY, in the same tick, with
+ * the `callOnError(...)` promise — Cloudflare Workers only extends the
+ * request's lifetime for work already registered with `waitUntil` by the
+ * time the handler returns; deferring that call through an extra microtask
+ * (e.g. `Promise.resolve().then(...)`) risks the isolate tearing down the
+ * request before `waitUntil` is ever actually invoked, silently dropping
+ * the report. `getCloudflareContext` is never called at all for a
+ * client-originated report (`params.isClient: true`) — it only exists
+ * server-side inside a Cloudflare Worker and throws synchronously (not a
+ * rejected promise) when called anywhere else, including the browser.
+ * Falls back to awaiting `onError` directly when `getCloudflareContext`/
+ * `ctx.waitUntil` is unset, unavailable (e.g. outside a Cloudflare Worker),
+ * or skipped for a client report.
  *
  * Passing `params.error` as `null`/`undefined` with `errorHandling.resetDedup: true`
  * and nothing else is a valid "reset-only" call: the dedup state clears and

package/dist/src/error_handling/report_error.js

@@ -1,6 +1,22 @@
 import formatErrorMessage from './format_error_message';
 import stringifyUnknown from './stringify_unknown';
 const DEFAULT_THROTTLE_MS = 5000;
+// Set by `installConsoleErrorOverride` once it patches `console.error`.
+// When active, THAT override is the sole place that ever calls the real
+// console for a report — it already logs the raw message itself, before
+// calling `reportError` — so `callOnError`'s own console-logging step must
+// stay OUT of the loop entirely rather than trying to detect and skip a
+// recursive call after the fact. Attempting the latter (capturing "the
+// original console.error" at module load, or tagging messages with a
+// marker) is unreliable: Next.js's own dev-mode console interception
+// forwards through whatever `console.error` is CURRENT at call time, not
+// the function it originally wrapped, so any capture-then-call-through
+// strategy can still loop back into a patched `console.error`. Removing
+// the second caller removes the race entirely — not a per-module boolean
+// (that would only cover one bundle chunk's module instance of this file;
+// this constant is exported so `installConsoleErrorOverride` can mutate it
+// via a live binding regardless of chunk).
+export const consoleOverrideState = { active: false };
 // Module-scope dedup state — safe by default only because a fresh JS realm
 // (isolate/Worker instance) starts with it cleared. In a long-lived server
 // process reused across many requests, pass `resetDedup: true` on the first
@@ -13,26 +29,39 @@ function buildDedupKey(params) {
 }
 async function callOnError(config, params) {
     const paramsWithFormattedMessage = { ...params, formattedMessage: formatErrorMessage(params) };
-    try {
-        if (config?.onError) {
+    // When `installConsoleErrorOverride` is active, it already logged the
+    // raw message to the real console BEFORE calling `reportError` — logging
+    // `formattedMessage` here too would be a second, redundant console
+    // write (differently formatted) for the exact same call, not a fix for
+    // a missing one.
+    if (config?.logToConsole !== false && !consoleOverrideState.active) {
+        console.error(paramsWithFormattedMessage.formattedMessage);
+    }
+    if (config?.onError) {
+        try {
             await config.onError(paramsWithFormattedMessage);
         }
-        else {
-            console.error(paramsWithFormattedMessage.formattedMessage);
+        catch {
+            if (!consoleOverrideState.active) {
+                console.error(paramsWithFormattedMessage.formattedMessage);
+            }
         }
     }
-    catch {
-        console.error(paramsWithFormattedMessage.formattedMessage);
-    }
 }
 /**
- * Reports `params` via `config.errorHandling.onError` (default
- * `console.error(params.formattedMessage)`), unless
+ * Reports `params`: logs `params.formattedMessage` via `console.error`
+ * (unless `config.errorHandling.logToConsole` is `false`, or
+ * `installConsoleErrorOverride` is active — in which case IT already did
+ * the console logging before calling this) AND calls
+ * `config.errorHandling.onError` when set — both run, not one instead of
+ * the other, so wiring `onError` (Sentry, Telegram, etc) never silently
+ * loses the console output. Skips reporting entirely when
  * `config.errorHandling.enable === false`, `params.consent` is set and not
  * `true` (reporting to a third party without cookie consent can itself be
  * GDPR-relevant), or dedup throttles it (on by default — see
  * `errorHandling.dedup`/`throttleMs`/`resetDedup`). Never throws — a broken
- * reporter must not mask the original error.
+ * `onError` must not mask the original error (falls back to logging via
+ * `console.error` instead, when the override isn't already handling that).
  *
  * Always overwrites `params.formattedMessage` with a fresh
  * `formatErrorMessage(params)` before reporting — a human-readable one-line
@@ -40,15 +69,20 @@ async function callOnError(config, params) {
  * instead of the raw `error`/`params` object, for a default reporter (or a
  * simple `onError`) to print directly.
  *
- * When `config.generate?.getCloudflareContext` is set, `waitUntil` is called
- * SYNCHRONOUSLY, in the same tick, with the `callOnError(...)` promise —
- * Cloudflare Workers only extends the request's lifetime for work already
- * registered with `waitUntil` by the time the handler returns; deferring
- * that call through an extra microtask (e.g. `Promise.resolve().then(...)`)
- * risks the isolate tearing down the request before `waitUntil` is ever
- * actually invoked, silently dropping the report. Falls back to awaiting
- * `onError` directly when `getCloudflareContext`/`ctx.waitUntil` is unset or
- * unavailable (e.g. outside a Cloudflare Worker).
+ * When `config.generate?.getCloudflareContext` is set AND `params.isClient`
+ * is not `true`, `waitUntil` is called SYNCHRONOUSLY, in the same tick, with
+ * the `callOnError(...)` promise — Cloudflare Workers only extends the
+ * request's lifetime for work already registered with `waitUntil` by the
+ * time the handler returns; deferring that call through an extra microtask
+ * (e.g. `Promise.resolve().then(...)`) risks the isolate tearing down the
+ * request before `waitUntil` is ever actually invoked, silently dropping
+ * the report. `getCloudflareContext` is never called at all for a
+ * client-originated report (`params.isClient: true`) — it only exists
+ * server-side inside a Cloudflare Worker and throws synchronously (not a
+ * rejected promise) when called anywhere else, including the browser.
+ * Falls back to awaiting `onError` directly when `getCloudflareContext`/
+ * `ctx.waitUntil` is unset, unavailable (e.g. outside a Cloudflare Worker),
+ * or skipped for a client report.
  *
  * Passing `params.error` as `null`/`undefined` with `errorHandling.resetDedup: true`
  * and nothing else is a valid "reset-only" call: the dedup state clears and
@@ -80,9 +114,13 @@ export default async function reportError(config, params) {
         lastDedupKey = dedupKey;
         lastReportedAt = now;
     }
-    const waitUntil = config?.generate?.getCloudflareContext?.({ async: false })?.ctx?.waitUntil;
-    if (waitUntil) {
-        waitUntil(callOnError(errorHandling, params));
+    // `getCloudflareContext` only exists server-side inside a Cloudflare
+    // Worker (with `initOpenNextCloudflareForDev` set up in dev) — calling
+    // it at all for a client-originated report throws synchronously, before
+    // any "is it available" check can run.
+    const ctx = params.isClient ? undefined : config?.generate?.getCloudflareContext?.({ async: false })?.ctx;
+    if (ctx?.waitUntil) {
+        ctx.waitUntil(callOnError(errorHandling, params));
         return;
     }
     await callOnError(errorHandling, params);

package/dist/src/error_handling/stringify_unknown.js

@@ -1,4 +1,10 @@
 const MAX_FUNCTION_RESOLUTION_ATTEMPTS = 5;
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_CODE_PATTERN = /\x1b\[[0-9;]*m/g;
+/** Strips ANSI color/style escape codes (e.g. from Next.js's own pretty-printed terminal errors) — unreadable once JSON-escaped into a report. */
+function stripAnsiCodes(value) {
+    return value.replace(ANSI_ESCAPE_CODE_PATTERN, '');
+}
 function resolveFunctionError(value) {
     let result = value;
     try {
@@ -24,9 +30,9 @@ function resolveFunctionError(value) {
  */
 export default function stringifyUnknown(value, isClient, isNested = false) {
     if (typeof value === 'string')
-        return value;
+        return stripAnsiCodes(value);
     if (value instanceof Error)
-        return `${value.name}: ${value.message}\n\n${value.stack ?? ''}`;
+        return stripAnsiCodes(`${value.name}: ${value.message}\n\n${value.stack ?? ''}`);
     if (typeof value === 'function') {
         if (isClient)
             return '[Function]';
@@ -34,7 +40,7 @@ export default function stringifyUnknown(value, isClient, isNested = false) {
         return typeof resolved !== 'function' ? stringifyUnknown(resolved, isClient) : '[Function]';
     }
     try {
-        return isNested ? JSON.stringify(value) : JSON.stringify(value, null, 2);
+        return stripAnsiCodes(isNested ? JSON.stringify(value) : JSON.stringify(value, null, 2));
     }
     catch {
         return '[Unserializable value]';

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

@@ -183,7 +183,7 @@ export default function AuthUserProvider({ initialUser = null, children }) {
         }
         finally {
             await clearSession(sessionCookieName, refreshTokenCookieName);
-            window.location.assign(fa.redirectAuthPath);
+            router.push(fa.redirectAuthPath);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [fa.redirectAuthPath, sessionCookieName, refreshTokenCookieName]);

package/dist/src/types/types.d.ts

@@ -167,11 +167,22 @@ export interface ErrorHandlingRoutingConfig {
      */
     enable?: boolean;
     /**
-     * Called with the caught error whenever one is reported. Defaults to
-     * `console.error`. Use this to wire your own error-tracking/logging
-     * transport (Sentry, Telegram, etc).
+     * Called with the caught error whenever one is reported, in ADDITION to
+     * the always-on `console.error(params.formattedMessage)` (see
+     * `logToConsole` to disable that). Use this to wire your own
+     * error-tracking/logging transport (Sentry, Telegram, etc) alongside the
+     * console log, not instead of it. Omit to just log to the console.
      */
     onError?: (params: ErrorHandlingParams) => void | Promise<void>;
+    /**
+     * Whether `reportError` also logs `params.formattedMessage` via the
+     * real, unpatched `console.error` (captured at module load, before
+     * `installConsoleErrorOverride` can touch it — so this never loops back
+     * into `reportError` even when the override is installed). Defaults to
+     * `true`. Set `false` if `onError` is your only sink and you don't want
+     * console output at all.
+     */
+    logToConsole?: boolean;
     /**
      * Whether `reportError`/`withErrorHandling` replace the global
      * `console.error` so every `console.error(...)` call in your app is
@@ -183,6 +194,18 @@ export interface ErrorHandlingRoutingConfig {
      * bigger behavior change than a plain function call.
      */
     overrideConsoleError?: boolean;
+    /**
+     * On the CLIENT only (`installConsoleErrorOverride(config, true)`),
+     * suppresses the browser's own `console.error(...)` output for a call
+     * once it's been routed to `onError`/`reportError` — the error is still
+     * reported (server-side logging, Sentry, etc), it just never shows up
+     * in browser devtools. Has no effect server-side (the server override
+     * always keeps logging normally — there's no "hide it from the
+     * terminal" use case). Only consulted when `overrideConsoleError` is
+     * `true`. Defaults to `false` (nothing is swallowed anywhere, matching
+     * `overrideConsoleError`'s own doc).
+     */
+    suppressClientConsoleError?: boolean;
     /**
      * Substrings matched against the stringified message of each
      * `console.error(...)` call (only consulted when `overrideConsoleError`
@@ -201,6 +224,20 @@ export interface ErrorHandlingRoutingConfig {
      * substring match.
      */
     ignoreConsoleError?: (message: string) => boolean;
+    /**
+     * Whether the client `LocationzationClientProvider` also installs
+     * `window.addEventListener('error'|'unhandledrejection', ...)` handlers
+     * that route through `onError`/`reportError` the same way
+     * `overrideConsoleError` does for `console.error(...)` calls. Catches
+     * uncaught exceptions and unhandled promise rejections that never go
+     * through `console.error` at all — e.g. Next.js's own internal
+     * "Failed to fetch RSC payload" navigation-fallback error. Defaults to
+     * `overrideConsoleError`'s value (so setting just `overrideConsoleError:
+     * true` catches everything by default) — pass `false` explicitly to
+     * enable console overriding without the window listeners. No-op on the
+     * server (no `window` there).
+     */
+    overrideWindowErrors?: boolean;
     /**
      * Dedup: `reportError` skips reporting an error whose key (`dedupKey`,
      * or a built-in key derived from `classOrMethodName`/`error`/`params`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -148,6 +148,10 @@
       "types": "./dist/src/error_handling/install_console_error_override.d.ts",
       "import": "./dist/src/error_handling/install_console_error_override.js"
     },
+    "./installGlobalErrorOverride": {
+      "types": "./dist/src/error_handling/install_global_error_override.d.ts",
+      "import": "./dist/src/error_handling/install_global_error_override.js"
+    },
     "./stringifyUnknown": {
       "types": "./dist/src/error_handling/stringify_unknown.d.ts",
       "import": "./dist/src/error_handling/stringify_unknown.js"