cloudflare-next-intl 0.9.13 → 0.9.16

package/README.md

@@ -256,7 +256,11 @@ export default defineConfig({
 ```
 
 ##### What `cloudflareNextIntl()` Does
-1. **Auto Dynamic Pages for SSG (`autoDynamicPages`)**: Automatically scans your Next.js/Vinext App Router pages during Vite configuration (`configResolved`) and inserts `export const dynamic = "force-static"` for all static pages that do not access dynamic APIs. This ensures Vinext builds all public marketing and static pages into SSG HTML automatically without extra build scripts or manually writing `export const dynamic = "force-static"`.
+1. **Auto Dynamic Pages for SSG (`autoDynamicPages`)**: Automatically scans your Next.js/Vinext App Router pages during Vite configuration (`configResolved`) and inserts `export const dynamic = "force-static"` for all static pages that do not access dynamic APIs, or `export const dynamic = "force-dynamic"` for pages that do. This ensures Vinext builds all public marketing and static pages into SSG HTML automatically without extra build scripts or manually writing `export const dynamic`.
+
+   The scan (`checkDynamicPages`, also usable standalone from `cloudflare-next-intl/checkDynamicPages`) is a text heuristic, not a real parser, so it's deliberately conservative and follows a page's own local (relative/`@/`-alias) imports transitively — cycle-safe, capped at 300 files — so a signal several files away (a component's repository calling `cookies()`) still marks the page dynamic, not just literal text in the page file itself. Recognized signals: `cookies()`, `headers()`, `searchParams`, `unstable_noStore()`, `connection()`, `cache: "no-store"`, `next: { revalidate: 0 }`, and this package's own `getAuthUser()`/`useAuthUser()`/`withUserDb()` (each of which reads `cookies()` internally). Set `resolveImports: false` on `checkDynamicPages` to restore the original single-file-only scan, or pass `aliases` to override the default `@/` → `<appDir>/..` mapping.
+
+   Being text-only and transitive, it can over-flag: any local file the page reaches — however many imports away — that merely *calls* a recognized signal counts, even along a branch that never runs in production (a `Config.isDev`-gated `fetch(..., { cache: "no-store" })`) or one that's optional/best-effort (a `try`/`catch`-wrapped `getAuthUser()` used only to tag a log line). It cannot see that a call is conditional or swallowed. For a page whose only reason for being flagged is that kind of optional read — attaching "whoever's signed in, if anyone" to an error report, analytics event, or log line — switch that read to `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`, see Firebase Auth below): it wraps `getAuthUser()` the same way but, being an npm-package import, is a boundary the scan doesn't open, so it contributes no signal. If that read lives in a shared `onError` sink used by many pages at once, `resolveErrorReportingUser(useAuthUser?)` (same subpath) is the more precise fix: it's off (`{ user: null }`, no `getAuthUser()` call) by default, and only a `reportError({ ..., useAuthUser: true })` call site that actually wants the user on that report opts in per-call — instead of every page reaching that sink getting flagged.
 2. **Build-Time & Dev Image Optimizer (`imageOptimizer`)**: Automatically scans your image directories (`public/images`, `public/icons`), downscales oversized assets, produces sibling formats (`webp` by default; also supports `avif`, `png`, `jpeg`, `gif`, `tiff`, `heif`, `jp2`, `jxl`), generates 8px `.blur.webp` thumbnails with Next.js-matching SVG Gaussian blur placeholders, and provides transparent `<Image placeholder="blur" />` shimming via virtual modules. When more than one format is generated for an image, the shim renders a `<picture>` with one `<source>` per format — ordered exactly as configured — so the browser picks the best format it supports, with the original untouched file as an `onError` fallback if a generated asset fails to load. When the same image is used at different widths across the codebase, each size gets its own generated variant, and each `<Image>` usage automatically resolves to the closest matching size.
 3. **Locale File Bundling & Resolution (`localeFiles`)**: Resolves `@locale-file/*` to your `./messages` directory and transforms dynamic imports into `import.meta.glob('/messages/*.json', { eager: true })` for lightning-fast locale loading on Cloudflare Workers.
 4. **User-Agent Stub (`userAgentStub`)**: Prevents Next.js `user-agent` from importing `node:fs` during workerd runtime execution (which otherwise causes runtime 404 / 500 crashes in Workers proxy/middleware).
@@ -475,6 +479,24 @@ Features include:
 - `sendVerificationEmail(actionCodeSettings?)` on `useAuthUser()`: Custom action email settings when resending email verification.
 - `followSameOriginContinueUrl`: Automatically forwards emailed action links with `continueUrl` to the specified path (or external URL) directly from `intlMiddleware` (default `true`; set `false` on `firebaseAuth` config to disable). If `continueUrl` points to home root (`/`), it resolves to `actionLinkPath` (if set) or the mode target path (e.g. `/reset-password`).
 - `appCheck`: Firebase App Check integration supporting reCAPTCHA Enterprise (`recaptchaEnterpriseSiteKey`) and reCAPTCHA v3 (`recaptchaV3SiteKey`). For reCAPTCHA v3, defaults to a `CustomProvider` using `IntlHelperScript`'s explicit script tag to avoid iframe/webworker CDN integrity issues in private windows (`useExplicitRecaptchaScript: false` to opt out). Supports server-side token minting via service accounts.
+- `resolveOptionalAuthUser()` (`cloudflare-next-intl/resolveOptionalAuthUser`): best-effort variant of `getAuthUser()` for callers that want to *attach* the current user when one happens to be known — error/telemetry reporting, analytics, logging — without failing or changing behavior when no request/session context is available. Swallows every failure and resolves `{ user: null }` instead of throwing. Use `getAuthUser()` (not this) whenever your own output actually depends on who's signed in — `checkDynamicPages` (below) treats `getAuthUser()`/`useAuthUser()`/`withUserDb()` as page-blocking dynamic-API signals but does not follow into this helper, so it's also the way to read "whoever's signed in, if anyone" from a page or a module it imports without forcing that page dynamic.
+- `resolveErrorReportingUser(useAuthUser?)` (same subpath): gated form of `resolveOptionalAuthUser()` for an `onError` sink — pass `ErrorHandlingParams.useAuthUser` straight through. Defaults to `false`: when not `true`, resolves `{ user: null }` immediately without calling `getAuthUser()` at all, so a page reached only through your `onError` sink's default path stays static-eligible. A specific `reportError({ ..., useAuthUser: true })` call site opts in per-call when it actually wants the user on that report.
+
+  ```ts
+  // your onError sink
+  import { resolveErrorReportingUser } from "cloudflare-next-intl/resolveOptionalAuthUser";
+
+  export default async function onError(params: ErrorHandlingParams) {
+      const { user } = await resolveErrorReportingUser(params.useAuthUser);
+      // ...write params + user?.email to your error store
+  }
+  ```
+
+  A specific call site rarely needs to set `useAuthUser: true` by hand: `syncErrorReportingAuthUser` (`cloudflare-next-intl/checkDynamicPages`, also `checkDynamicPages`'s and the Vite plugin's `syncErrorReportingAuthUser` option, default `false`) does it for you — it finds every `reportError()` call reached *only* from pages already confirmed `force-dynamic` and inserts `useAuthUser: true` there automatically, leaving alone any call reachable from even one static/unknown-status page. Opt in explicitly (it mutates call-site arguments across your app, a bigger change than the top-of-file `export const dynamic` insertion `checkDynamicPages` does by default):
+
+  ```ts
+  await checkDynamicPages({ appDir, mode: "fix", syncErrorReportingAuthUser: true });
+  ```
 
 ```tsx
 import ThemeSwitcher from "cloudflare-next-intl/ThemeSwitcher";

package/dist/src/dynamic_pages_check/check_dynamic_pages.d.ts

@@ -1,9 +1,14 @@
+import { type SyncErrorReportingAuthUserReport } from './sync_error_reporting_auth_user.js';
+import type { AliasConfig } from './resolve_local_imports.js';
 export type DynamicPagesCheckMode = 'off' | 'report' | 'fix';
 export interface CheckDynamicPagesOptions {
     appDir: string;
     mode?: DynamicPagesCheckMode;
     target?: 'next' | 'vinext';
     skip?: readonly string[];
+    resolveImports?: boolean;
+    aliases?: readonly AliasConfig[];
+    syncErrorReportingAuthUser?: boolean;
 }
 export interface CheckDynamicPagesReport {
     file: string;
@@ -13,5 +18,6 @@ export interface CheckDynamicPagesIo {
     findPageFiles?: (appDir: string) => string[];
     readFile?: (file: string) => string;
     writeFile?: (file: string, contents: string) => void;
+    isFile?: (file: string) => boolean;
 }
-export declare function checkDynamicPages(options: CheckDynamicPagesOptions, io?: CheckDynamicPagesIo): Promise<CheckDynamicPagesReport[]>;
+export declare function checkDynamicPages(options: CheckDynamicPagesOptions, io?: CheckDynamicPagesIo): Promise<(CheckDynamicPagesReport | SyncErrorReportingAuthUserReport)[]>;

package/dist/src/dynamic_pages_check/check_dynamic_pages.js

@@ -1,16 +1,32 @@
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { findPageFiles as findPageFilesImpl } from './find_page_files.js';
 import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { traceDynamicUsage } from './trace_dynamic_usage.js';
 import { insertDynamicExport } from './insert_dynamic_export.js';
+import { syncErrorReportingAuthUser } from './sync_error_reporting_auth_user.js';
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 export async function checkDynamicPages(options, io = {}) {
     const mode = options.mode ?? 'report';
     if (mode === 'off')
         return [];
     const target = options.target ?? 'next';
+    const resolveImports = options.resolveImports ?? true;
     const findPageFiles = io.findPageFiles ?? findPageFilesImpl;
     const readFile = io.readFile ?? ((file) => readFileSync(file, 'utf8'));
     const writeFile = io.writeFile ?? ((file, contents) => writeFileSync(file, contents, 'utf8'));
+    const isFile = io.isFile ?? defaultIsFile;
     const skipSet = new Set(options.skip ?? []);
+    const aliases = options.aliases ?? [
+        { prefix: '@/', replacement: resolve(options.appDir, '..') },
+    ];
     const reports = [];
     for (const file of findPageFiles(options.appDir)) {
         if (skipSet.has(file)) {
@@ -18,7 +34,9 @@ export async function checkDynamicPages(options, io = {}) {
             continue;
         }
         const source = readFile(file);
-        const detection = detectDynamicUsage(source);
+        const detection = resolveImports
+            ? traceDynamicUsage(file, source, aliases, { readFile, isFile })
+            : detectDynamicUsage(source);
         if (detection.hasExplicitDynamicExport) {
             reports.push({ file, action: 'already-declared' });
             continue;
@@ -45,5 +63,9 @@ export async function checkDynamicPages(options, io = {}) {
             reports.push({ file, action: 'would-add-force-dynamic' });
         }
     }
+    if (options.syncErrorReportingAuthUser === true) {
+        const syncReports = await syncErrorReportingAuthUser({ appDir: options.appDir, mode: options.mode, target: options.target, skip: options.skip, aliases: options.aliases }, { findPageFiles, readFile, writeFile, isFile });
+        reports.push(...syncReports);
+    }
     return reports;
 }

package/dist/src/dynamic_pages_check/collect_reachable_files.d.ts

@@ -0,0 +1,7 @@
+import { type AliasConfig } from './resolve_local_imports.js';
+export interface CollectReachableFilesIo {
+    readFile: (file: string) => string;
+    isFile?: (file: string) => boolean;
+}
+export declare const MAX_FILES_VISITED = 300;
+export declare function collectReachableFiles(entryFile: string, entrySource: string, aliases: readonly AliasConfig[], io: CollectReachableFilesIo): Map<string, string>;

package/dist/src/dynamic_pages_check/collect_reachable_files.js

@@ -0,0 +1,30 @@
+import { extractImportSpecifiers, resolveLocalImport } from './resolve_local_imports.js';
+export const MAX_FILES_VISITED = 300;
+export function collectReachableFiles(entryFile, entrySource, aliases, io) {
+    const isFile = io.isFile ?? (() => false);
+    const files = new Map([[entryFile, entrySource]]);
+    const queue = [entryFile];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (files.size >= MAX_FILES_VISITED)
+            continue;
+        const source = files.get(current);
+        for (const specifier of extractImportSpecifiers(source)) {
+            if (files.size >= MAX_FILES_VISITED)
+                break;
+            const resolved = resolveLocalImport(specifier, current, aliases, isFile);
+            if (resolved === null || files.has(resolved))
+                continue;
+            let importedSource;
+            try {
+                importedSource = io.readFile(resolved);
+            }
+            catch {
+                continue;
+            }
+            files.set(resolved, importedSource);
+            queue.push(resolved);
+        }
+    }
+    return files;
+}

package/dist/src/dynamic_pages_check/detect_dynamic_usage.d.ts

@@ -3,3 +3,4 @@ export interface DynamicDetectionResult {
     detectedDynamicApis: string[];
 }
 export declare function detectDynamicUsage(sourceText: string): DynamicDetectionResult;
+export declare function readExplicitDynamicValue(sourceText: string): 'force-static' | 'force-dynamic' | 'auto' | 'error' | null;

package/dist/src/dynamic_pages_check/detect_dynamic_usage.js

@@ -6,6 +6,9 @@ const DYNAMIC_API_CHECKS = [
     { name: 'connection()', pattern: /\bconnection\s*\(\s*\)/ },
     { name: 'cache: "no-store"', pattern: /cache:\s*['"]no-store['"]/ },
     { name: 'next: { revalidate: 0 }', pattern: /next:\s*\{\s*revalidate:\s*0\s*[,}]/ },
+    { name: 'getAuthUser()', pattern: /\bgetAuthUser\s*\(/ },
+    { name: 'useAuthUser()', pattern: /\buseAuthUser\s*\(/ },
+    { name: 'withUserDb()', pattern: /\bwithUserDb\s*\(/ },
 ];
 const EXPLICIT_DYNAMIC_EXPORT = /export\s+const\s+dynamic\s*=/;
 export function detectDynamicUsage(sourceText) {
@@ -14,3 +17,13 @@ export function detectDynamicUsage(sourceText) {
         detectedDynamicApis: DYNAMIC_API_CHECKS.filter(({ pattern }) => pattern.test(sourceText)).map(({ name }) => name),
     };
 }
+const EXPLICIT_DYNAMIC_EXPORT_VALUE = /export\s+const\s+dynamic\s*=\s*['"]([^'"]+)['"]/;
+export function readExplicitDynamicValue(sourceText) {
+    const match = EXPLICIT_DYNAMIC_EXPORT_VALUE.exec(sourceText);
+    if (match === null)
+        return null;
+    const value = match[1];
+    if (value === 'force-static' || value === 'force-dynamic' || value === 'auto' || value === 'error')
+        return value;
+    return null;
+}

package/dist/src/dynamic_pages_check/find_report_error_calls.d.ts

@@ -0,0 +1,5 @@
+export interface ReportErrorCall {
+    insertPos: number | null;
+    hasExplicitUseAuthUser: boolean;
+}
+export declare function findReportErrorCalls(sourceText: string): ReportErrorCall[];

package/dist/src/dynamic_pages_check/find_report_error_calls.js

@@ -0,0 +1,71 @@
+const REPORT_ERROR_CALL = /\breportError\s*\(/g;
+export function findReportErrorCalls(sourceText) {
+    const calls = [];
+    REPORT_ERROR_CALL.lastIndex = 0;
+    let match;
+    while ((match = REPORT_ERROR_CALL.exec(sourceText)) !== null) {
+        calls.push(parseCallArgs(sourceText, match.index + match[0].length));
+    }
+    return calls;
+}
+function parseCallArgs(sourceText, start) {
+    let depth = 1;
+    let i = start;
+    let firstArgEnd = -1;
+    let callEnd = -1;
+    while (i < sourceText.length && callEnd === -1) {
+        const ch = sourceText[i];
+        if (ch === '"' || ch === "'" || ch === '`') {
+            i = skipStringLiteral(sourceText, i, ch);
+            continue;
+        }
+        if (ch === '/' && sourceText[i + 1] === '/') {
+            const nextNewline = sourceText.indexOf('\n', i);
+            i = nextNewline === -1 ? sourceText.length : nextNewline;
+            continue;
+        }
+        if (ch === '/' && sourceText[i + 1] === '*') {
+            const end = sourceText.indexOf('*/', i + 2);
+            i = end === -1 ? sourceText.length : end + 2;
+            continue;
+        }
+        if (ch === '(' || ch === '{' || ch === '[') {
+            depth += 1;
+        }
+        else if (ch === ')' || ch === '}' || ch === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                callEnd = i;
+                break;
+            }
+        }
+        else if (ch === ',' && depth === 1 && firstArgEnd === -1) {
+            firstArgEnd = i;
+        }
+        i += 1;
+    }
+    if (firstArgEnd === -1 || callEnd === -1) {
+        return { insertPos: null, hasExplicitUseAuthUser: false };
+    }
+    const paramsText = sourceText.slice(firstArgEnd + 1, callEnd);
+    const hasExplicitUseAuthUser = /\buseAuthUser\b/.test(paramsText);
+    const leadingWhitespace = paramsText.length - paramsText.trimStart().length;
+    const paramsStart = firstArgEnd + 1 + leadingWhitespace;
+    if (sourceText[paramsStart] !== '{') {
+        return { insertPos: null, hasExplicitUseAuthUser };
+    }
+    return { insertPos: paramsStart + 1, hasExplicitUseAuthUser };
+}
+function skipStringLiteral(sourceText, start, quote) {
+    let i = start + 1;
+    while (i < sourceText.length) {
+        if (sourceText[i] === '\\') {
+            i += 2;
+            continue;
+        }
+        if (sourceText[i] === quote)
+            return i + 1;
+        i += 1;
+    }
+    return sourceText.length;
+}

package/dist/src/dynamic_pages_check/resolve_local_imports.d.ts

@@ -0,0 +1,6 @@
+export interface AliasConfig {
+    prefix: string;
+    replacement: string;
+}
+export declare function extractImportSpecifiers(sourceText: string): string[];
+export declare function resolveLocalImport(specifier: string, fromFile: string, aliases: readonly AliasConfig[], isFile?: (file: string) => boolean): string | null;

package/dist/src/dynamic_pages_check/resolve_local_imports.js

@@ -0,0 +1,55 @@
+import { statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+const FROM_SPECIFIER = /\bfrom\s*['"]([^'"]+)['"]/g;
+const BARE_IMPORT_SPECIFIER = /(?:^|\n|;)\s*import\s*['"]([^'"]+)['"]/g;
+export function extractImportSpecifiers(sourceText) {
+    const specifiers = [];
+    FROM_SPECIFIER.lastIndex = 0;
+    let match;
+    while ((match = FROM_SPECIFIER.exec(sourceText)) !== null) {
+        specifiers.push(match[1]);
+    }
+    BARE_IMPORT_SPECIFIER.lastIndex = 0;
+    while ((match = BARE_IMPORT_SPECIFIER.exec(sourceText)) !== null) {
+        specifiers.push(match[1]);
+    }
+    return specifiers;
+}
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveLocalImport(specifier, fromFile, aliases, isFile = defaultIsFile) {
+    let base = null;
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        base = resolve(dirname(fromFile), specifier);
+    }
+    else {
+        for (const alias of aliases) {
+            if (specifier.startsWith(alias.prefix)) {
+                base = join(alias.replacement, specifier.slice(alias.prefix.length));
+                break;
+            }
+        }
+    }
+    if (base === null)
+        return null;
+    if (isFile(base))
+        return base;
+    for (const ext of FILE_EXTENSIONS) {
+        const candidate = `${base}${ext}`;
+        if (isFile(candidate))
+            return candidate;
+    }
+    for (const ext of FILE_EXTENSIONS) {
+        const candidate = join(base, `index${ext}`);
+        if (isFile(candidate))
+            return candidate;
+    }
+    return null;
+}

package/dist/src/dynamic_pages_check/sync_error_reporting_auth_user.d.ts

@@ -0,0 +1,21 @@
+import type { AliasConfig } from './resolve_local_imports.js';
+import type { DynamicPagesCheckMode } from './check_dynamic_pages.js';
+export interface SyncErrorReportingAuthUserOptions {
+    appDir: string;
+    mode?: DynamicPagesCheckMode;
+    target?: 'next' | 'vinext';
+    skip?: readonly string[];
+    aliases?: readonly AliasConfig[];
+}
+export interface SyncErrorReportingAuthUserReport {
+    file: string;
+    action: 'added-use-auth-user' | 'would-add-use-auth-user';
+    callCount: number;
+}
+export interface SyncErrorReportingAuthUserIo {
+    findPageFiles?: (appDir: string) => string[];
+    readFile?: (file: string) => string;
+    writeFile?: (file: string, contents: string) => void;
+    isFile?: (file: string) => boolean;
+}
+export declare function syncErrorReportingAuthUser(options: SyncErrorReportingAuthUserOptions, io?: SyncErrorReportingAuthUserIo): Promise<SyncErrorReportingAuthUserReport[]>;

package/dist/src/dynamic_pages_check/sync_error_reporting_auth_user.js

@@ -0,0 +1,73 @@
+import { readFileSync, statSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { findPageFiles as findPageFilesImpl } from './find_page_files.js';
+import { detectDynamicUsage, readExplicitDynamicValue } from './detect_dynamic_usage.js';
+import { collectReachableFiles } from './collect_reachable_files.js';
+import { findReportErrorCalls } from './find_report_error_calls.js';
+function defaultIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isConfirmedDynamic(source, reachableApis, target) {
+    const explicit = readExplicitDynamicValue(source);
+    if (explicit !== null)
+        return explicit === 'force-dynamic';
+    if (target === 'vinext')
+        return reachableApis.length > 0;
+    return false;
+}
+export async function syncErrorReportingAuthUser(options, io = {}) {
+    const mode = options.mode ?? 'report';
+    if (mode === 'off')
+        return [];
+    const target = options.target ?? 'next';
+    const findPageFiles = io.findPageFiles ?? findPageFilesImpl;
+    const readFile = io.readFile ?? ((file) => readFileSync(file, 'utf8'));
+    const writeFile = io.writeFile ?? ((file, contents) => writeFileSync(file, contents, 'utf8'));
+    const isFile = io.isFile ?? defaultIsFile;
+    const skipSet = new Set(options.skip ?? []);
+    const aliases = options.aliases ?? [
+        { prefix: '@/', replacement: resolve(options.appDir, '..') },
+    ];
+    const dynamicReachable = new Set();
+    const notConfirmedReachable = new Set();
+    const fileSources = new Map();
+    for (const page of findPageFiles(options.appDir)) {
+        if (skipSet.has(page))
+            continue;
+        const source = readFile(page);
+        const files = collectReachableFiles(page, source, aliases, { readFile, isFile });
+        const apis = new Set();
+        for (const [file, fileSource] of files) {
+            fileSources.set(file, fileSource);
+            detectDynamicUsage(fileSource).detectedDynamicApis.forEach((api) => apis.add(api));
+        }
+        const bucket = isConfirmedDynamic(source, [...apis], target) ? dynamicReachable : notConfirmedReachable;
+        for (const file of files.keys())
+            bucket.add(file);
+    }
+    const safeFiles = [...dynamicReachable].filter((file) => !notConfirmedReachable.has(file));
+    const reports = [];
+    for (const file of safeFiles) {
+        const source = fileSources.get(file);
+        const calls = findReportErrorCalls(source).filter((call) => call.insertPos !== null && !call.hasExplicitUseAuthUser);
+        if (calls.length === 0)
+            continue;
+        if (mode === 'fix') {
+            let rewritten = source;
+            for (const call of [...calls].sort((a, b) => b.insertPos - a.insertPos)) {
+                rewritten = `${rewritten.slice(0, call.insertPos)}useAuthUser: true, ${rewritten.slice(call.insertPos)}`;
+            }
+            writeFile(file, rewritten);
+            reports.push({ file, action: 'added-use-auth-user', callCount: calls.length });
+        }
+        else {
+            reports.push({ file, action: 'would-add-use-auth-user', callCount: calls.length });
+        }
+    }
+    return reports;
+}

package/dist/src/dynamic_pages_check/trace_dynamic_usage.d.ts

@@ -0,0 +1,5 @@
+import { type DynamicDetectionResult } from './detect_dynamic_usage.js';
+import { type CollectReachableFilesIo } from './collect_reachable_files.js';
+import type { AliasConfig } from './resolve_local_imports.js';
+export type TraceDynamicUsageIo = CollectReachableFilesIo;
+export declare function traceDynamicUsage(entryFile: string, entrySource: string, aliases: readonly AliasConfig[], io: TraceDynamicUsageIo): DynamicDetectionResult;

package/dist/src/dynamic_pages_check/trace_dynamic_usage.js

@@ -0,0 +1,17 @@
+import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { collectReachableFiles } from './collect_reachable_files.js';
+export function traceDynamicUsage(entryFile, entrySource, aliases, io) {
+    const files = collectReachableFiles(entryFile, entrySource, aliases, io);
+    let hasExplicitDynamicExport = false;
+    const detectedApis = new Set();
+    let first = true;
+    for (const source of files.values()) {
+        const detection = detectDynamicUsage(source);
+        if (first) {
+            hasExplicitDynamicExport = detection.hasExplicitDynamicExport;
+            first = false;
+        }
+        detection.detectedDynamicApis.forEach((api) => detectedApis.add(api));
+    }
+    return { hasExplicitDynamicExport, detectedDynamicApis: [...detectedApis] };
+}

package/dist/src/firebase_auth/server/resolve_optional_auth_user.d.ts

@@ -0,0 +1,7 @@
+import type { User } from '@firebase/auth';
+export default function resolveOptionalAuthUser(): Promise<{
+    user: User | null;
+}>;
+export declare function resolveErrorReportingUser(useAuthUser?: boolean): Promise<{
+    user: User | null;
+}>;

package/dist/src/firebase_auth/server/resolve_optional_auth_user.js

@@ -0,0 +1,15 @@
+import { getAuthUser } from './use_auth_user_server.js';
+export default async function resolveOptionalAuthUser() {
+    try {
+        const { user } = await getAuthUser();
+        return { user };
+    }
+    catch {
+        return { user: null };
+    }
+}
+export async function resolveErrorReportingUser(useAuthUser) {
+    if (useAuthUser !== true)
+        return { user: null };
+    return resolveOptionalAuthUser();
+}

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

@@ -54,6 +54,7 @@ export interface ErrorHandlingParams {
     consent?: ConsentValue;
     formattedMessage?: string;
     dedupKey?: string;
+    useAuthUser?: boolean;
 }
 export interface ErrorHandlingRoutingConfig {
     enable?: boolean;

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

@@ -4,5 +4,6 @@ export interface AutoDynamicPagesPluginOptions {
     appDir?: string;
     mode?: DynamicPagesCheckMode;
     target?: 'next' | 'vinext';
+    syncErrorReportingAuthUser?: boolean;
 }
 export declare function autoDynamicPagesPlugin(options?: AutoDynamicPagesPluginOptions): Plugin;

package/dist/src/vite/auto_dynamic_pages_plugin.js

@@ -28,6 +28,7 @@ export function autoDynamicPagesPlugin(options = {}) {
                     appDir,
                     mode: options.mode ?? "fix",
                     target: options.target ?? "vinext",
+                    syncErrorReportingAuthUser: options.syncErrorReportingAuthUser ?? false,
                 });
             }
             catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.9.13",
+  "version": "0.9.16",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -142,6 +142,10 @@
       "types": "./dist/src/firebase_auth/server/use_auth_user_server.d.ts",
       "import": "./dist/src/firebase_auth/server/use_auth_user_server.js"
     },
+    "./resolveOptionalAuthUser": {
+      "types": "./dist/src/firebase_auth/server/resolve_optional_auth_user.d.ts",
+      "import": "./dist/src/firebase_auth/server/resolve_optional_auth_user.js"
+    },
     "./firebaseAuthActions": {
       "types": "./dist/src/firebase_auth/client/auth_actions.d.ts",
       "import": "./dist/src/firebase_auth/client/auth_actions.js"