cloudflare-next-intl 0.9.6 → 0.9.9

package/bin/check_dynamic_pages.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Usage: cfni-check-dynamic-pages [--app-dir=src/app] [--mode=off|report|fix] [--skip=a/page.tsx,b/page.tsx]
+// Env equivalents: CFNI_DYNAMIC_PAGES_APP_DIR, CFNI_DYNAMIC_PAGES_MODE, CFNI_DYNAMIC_PAGES_SKIP (comma-separated).
+import { resolve } from 'node:path';
+import { checkDynamicPages } from '../dist/src/dynamic_pages_check/check_dynamic_pages.js';
+
+function argValue(name) {
+    const prefix = `--${name}=`;
+    const arg = process.argv.slice(2).find((a) => a.startsWith(prefix));
+    return arg ? arg.slice(prefix.length) : undefined;
+}
+
+const appDir = resolve(argValue('app-dir') ?? process.env.CFNI_DYNAMIC_PAGES_APP_DIR ?? 'src/app');
+const mode = argValue('mode') ?? process.env.CFNI_DYNAMIC_PAGES_MODE ?? 'report';
+const skipRaw = argValue('skip') ?? process.env.CFNI_DYNAMIC_PAGES_SKIP ?? '';
+const skip = skipRaw.split(',').map((s) => s.trim()).filter(Boolean).map((s) => resolve(s));
+
+const reports = await checkDynamicPages({ appDir, mode, skip });
+
+if (reports.length === 0) {
+    console.log(mode === 'off' ? 'checkDynamicPages: disabled (mode=off).' : `checkDynamicPages: no page/route files found under ${appDir}.`);
+} else {
+    for (const { file, action } of reports) console.log(`${action.padEnd(24)} ${file}`);
+}

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

@@ -2,7 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables.js";
 import { createContext, useMemo } from "react";
-import dynamic from "next/dynamic";
+import dynamic from "next/dynamic.js";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override.js";
 import installGlobalErrorOverride from "../../error_handling/install_global_error_override.js";

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

@@ -2,7 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { setLocaleCache, setMessageForLocaleCache } from "../../general/cache_variables.js";
 import { createContext, useMemo } from "react";
-import dynamic from "next/dynamic";
+import dynamic from "next/dynamic.js";
 import config from "@intl-config";
 import installConsoleErrorOverride from "../../error_handling/install_console_error_override.js";
 import installGlobalErrorOverride from "../../error_handling/install_global_error_override.js";

package/dist/src/client/components/locale_link.d.ts

@@ -1,4 +1,4 @@
-import { type LinkProps } from 'next/link';
+import { type LinkProps } from 'next/link.js';
 import { type ComponentProps } from 'react';
 type NextLinkProps = Omit<ComponentProps<'a'>, keyof LinkProps> & Omit<LinkProps, 'locale' | 'href' | 'prefetch' | 'onNavigate' | 'hrefLang' | 'replace' | 'scroll'>;
 export type LocaleLinkProps = NextLinkProps & {

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

@@ -5,7 +5,7 @@ import config from '../../config/intl_config.js';
 import usePathname from '../hooks/use_path_name.js';
 import { localeCookieName } from '../../config/cookie_key.js';
 import setCookie from '../functions/set_cookie.js';
-import { useSearchParams } from 'next/navigation';
+import { useSearchParams } from 'next/navigation.js';
 function ClientLocaleLinkComponent({ locale, className, ...rest }, ref) {
     const pathname = usePathname();
     const searchParams = useSearchParams();

package/dist/src/client/hooks/use_path_name.js

@@ -1,5 +1,5 @@
 "use client";
-import { usePathname as nextUsePathname } from "next/navigation";
+import { usePathname as nextUsePathname } from "next/navigation.js";
 import { useLocale } from "./client_hooks.js";
 export default function usePathname() {
     const pathname = nextUsePathname();

package/dist/src/cloudflare_email/escape_html.d.ts

@@ -0,0 +1 @@
+export declare function escapeHtml(value: string): string;

package/dist/src/cloudflare_email/escape_html.js

@@ -0,0 +1,7 @@
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}

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

@@ -0,0 +1,3 @@
+export { sendTransactionalEmail, type TransactionalEmailOutcome, type TransactionalEmailContent, type SendTransactionalEmailOptions } from './send_transactional_email.js';
+export { resolveEmailBinding, type EmailBindingLike } from './resolve_email_binding.js';
+export { escapeHtml } from './escape_html.js';

package/dist/src/cloudflare_email/index.js

@@ -0,0 +1,3 @@
+export { sendTransactionalEmail } from './send_transactional_email.js';
+export { resolveEmailBinding } from './resolve_email_binding.js';
+export { escapeHtml } from './escape_html.js';

package/dist/src/cloudflare_email/resolve_email_binding.d.ts

@@ -0,0 +1,11 @@
+import type { GenerateRoutingConfig } from '../types/types.js';
+export interface EmailBindingLike {
+    send(message: {
+        to: string;
+        from: string;
+        subject: string;
+        html?: string;
+        text?: string;
+    }): Promise<unknown>;
+}
+export declare function resolveEmailBinding(generate?: GenerateRoutingConfig, bindingName?: string): Promise<EmailBindingLike | null>;

package/dist/src/cloudflare_email/resolve_email_binding.js

@@ -0,0 +1,8 @@
+import { resolveEnv } from '../server/functions/geo.js';
+export async function resolveEmailBinding(generate, bindingName = 'EMAIL') {
+    const env = await resolveEnv(generate);
+    const candidate = env?.[bindingName];
+    if (!candidate || typeof candidate !== 'object')
+        return null;
+    return typeof candidate.send === 'function' ? candidate : null;
+}

package/dist/src/cloudflare_email/send_transactional_email.d.ts

@@ -0,0 +1,18 @@
+import { type ReportErrorConfig } from '../error_handling/report_error.js';
+import type { GenerateRoutingConfig } from '../types/types.js';
+export type TransactionalEmailOutcome = 'sent' | 'unavailable' | 'failed';
+export interface TransactionalEmailContent {
+    subject: string;
+    text: string;
+    html: string;
+}
+export interface SendTransactionalEmailOptions extends ReportErrorConfig {
+    generate?: GenerateRoutingConfig;
+    senderAddress: string;
+    bindingName?: string;
+    restAccountId?: string;
+    restToken?: string;
+}
+export declare function sendTransactionalEmail(message: {
+    to: string;
+} & TransactionalEmailContent, options: SendTransactionalEmailOptions, reportAs: string): Promise<TransactionalEmailOutcome>;

package/dist/src/cloudflare_email/send_transactional_email.js

@@ -0,0 +1,36 @@
+import { resolveEmailBinding } from './resolve_email_binding.js';
+import reportError from '../error_handling/report_error.js';
+function isUsableCredential(value) {
+    return value.length > 0 && !value.includes('$(');
+}
+async function sendOverRest(message, options, reportAs) {
+    const accountId = (options.restAccountId ?? process.env.CLOUDFLARE_ACCOUNT_ID ?? '').trim();
+    const token = (options.restToken ?? process.env.CLOUDFLARE_EMAIL_TOKEN ?? '').trim();
+    if (!isUsableCredential(accountId) || !isUsableCredential(token))
+        return 'unavailable';
+    const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}/email/sending/send`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(message),
+    });
+    if (!response.ok) {
+        await reportError(options, { error: new Error(`email/sending/send responded ${response.status}`), classOrMethodName: `${reportAs}.rest` });
+        return 'failed';
+    }
+    return 'sent';
+}
+export async function sendTransactionalEmail(message, options, reportAs) {
+    try {
+        const binding = await resolveEmailBinding(options.generate, options.bindingName);
+        const fullMessage = { ...message, from: options.senderAddress };
+        if (binding) {
+            await binding.send(fullMessage);
+            return 'sent';
+        }
+        return await sendOverRest(fullMessage, options, reportAs);
+    }
+    catch (error) {
+        await reportError(options, { error, classOrMethodName: reportAs });
+        return 'failed';
+    }
+}

package/dist/src/cloudflare_fetch/fetch_text.d.ts

@@ -0,0 +1,5 @@
+import { type ReportErrorConfig } from '../error_handling/report_error.js';
+import type { GenerateRoutingConfig } from '../types/types.js';
+export declare function fetchText(input: RequestInfo | URL, init: RequestInit, config: (ReportErrorConfig & {
+    generate?: GenerateRoutingConfig;
+}) | undefined, reportAs: string): Promise<string | null>;

package/dist/src/cloudflare_fetch/fetch_text.js

@@ -0,0 +1,17 @@
+import { fetchWithCloudflareFallback } from './fetch_with_fallback.js';
+import reportError from '../error_handling/report_error.js';
+const MAX_ERROR_BODY_LENGTH = 500;
+export async function fetchText(input, init, config, reportAs) {
+    try {
+        const response = await fetchWithCloudflareFallback(input, init, config?.generate);
+        if (!response.ok) {
+            const body = (await response.text()).slice(0, MAX_ERROR_BODY_LENGTH);
+            throw new Error(body || `HTTP ${response.status}`);
+        }
+        return await response.text();
+    }
+    catch (error) {
+        await reportError(config, { error, classOrMethodName: reportAs, params: { input: String(input) } });
+        return null;
+    }
+}

package/dist/src/cloudflare_fetch/fetch_with_fallback.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateRoutingConfig } from '../types/types.js';
+export declare function fetchWithCloudflareFallback(input: RequestInfo | URL, init: RequestInit, generate?: GenerateRoutingConfig): Promise<Response>;

package/dist/src/cloudflare_fetch/fetch_with_fallback.js

@@ -0,0 +1,7 @@
+import { resolveAssetsBinding } from './resolve_assets_binding.js';
+export async function fetchWithCloudflareFallback(input, init, generate) {
+    const binding = await resolveAssetsBinding(generate);
+    if (binding)
+        return binding.fetch(input, init);
+    return fetch(input, { ...init, cache: 'no-store' });
+}

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

@@ -0,0 +1,3 @@
+export { fetchText } from './fetch_text.js';
+export { fetchWithCloudflareFallback } from './fetch_with_fallback.js';
+export { resolveAssetsBinding, type AssetsBindingLike } from './resolve_assets_binding.js';

package/dist/src/cloudflare_fetch/index.js

@@ -0,0 +1,3 @@
+export { fetchText } from './fetch_text.js';
+export { fetchWithCloudflareFallback } from './fetch_with_fallback.js';
+export { resolveAssetsBinding } from './resolve_assets_binding.js';

package/dist/src/cloudflare_fetch/resolve_assets_binding.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateRoutingConfig } from '../types/types.js';
+export interface AssetsBindingLike {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export declare function resolveAssetsBinding(generate?: GenerateRoutingConfig): Promise<AssetsBindingLike | null>;

package/dist/src/cloudflare_fetch/resolve_assets_binding.js

@@ -0,0 +1,9 @@
+import { resolveEnv } from '../server/functions/geo.js';
+export async function resolveAssetsBinding(generate) {
+    const env = await resolveEnv(generate);
+    const candidate = env?.ASSETS;
+    if (!candidate || typeof candidate !== 'object')
+        return null;
+    const fetchFn = candidate.fetch;
+    return typeof fetchFn === 'function' ? candidate : null;
+}

package/dist/src/config/middleware.d.ts

@@ -1,5 +1,5 @@
-import type { NextRequest } from 'next/server';
-import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server.js';
+import { NextResponse } from 'next/server.js';
 import type { MiddlewareCustomHandler } from '../types/types.js';
 export declare const localesSet: Set<string>;
 export default function intlMiddleware(request: NextRequest, options?: {

package/dist/src/config/middleware.js

@@ -1,4 +1,4 @@
-import { NextResponse } from 'next/server';
+import { NextResponse } from 'next/server.js';
 import { languageDetecotr } from '../server/functions/get_user_locale.js';
 import config from './intl_config.js';
 import { isBotCookieKey, localeCookieName } from './cookie_key.js';

package/dist/src/cookie_consent/client/components/auto_analytics_events.js

@@ -1,5 +1,5 @@
 'use client';
-import { usePathname } from 'next/navigation';
+import { usePathname } from 'next/navigation.js';
 import { useReportWebVitals } from 'next/web-vitals';
 import { useEffect } from 'react';
 import useCookieConsent from '../use_cookie_consent.js';

package/dist/src/cookie_consent/client/components/cookie_consent_analytics.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect } from 'react';
-import dynamic from 'next/dynamic';
+import dynamic from 'next/dynamic.js';
 import useCookieConsent from '../use_cookie_consent.js';
 const ClarityScript = dynamic(() => import('./clarity_script.js'));
 export default function CookieConsentAnalytics({ config }) {

package/dist/src/cookie_consent/client/components/default_privacy_policy_link.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import NextLink from 'next/link';
+import NextLink from 'next/link.js';
 import config from '../../../config/intl_config.js';
 import { getLocaleCache } from '../../../general/cache_variables.js';
 export default function DefaultPrivacyPolicyLink({ privacyPolicyPath, text, className, style }) {

package/dist/src/cookie_consent/client/cookie_consent_provider.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useEffect, useMemo, useState } from 'react';
-import { usePathname } from 'next/navigation';
+import { usePathname } from 'next/navigation.js';
 import config from '../../config/intl_config.js';
 import requireCookieConsentConfig from '../require_config.js';
 import getCookie from '../../client/functions/get_cookie.js';

package/dist/src/db/connection.js

@@ -1,7 +1,7 @@
 import reportError from '../error_handling/report_error.js';
 import requireDbConfig from './require_config.js';
 import resolveConfigValue from './resolve_config_value.js';
-import { resolveEnv } from '../server/functions/geo.js';
+import { resolveHyperdriveConnectionString } from './resolve_hyperdrive_connection_string.js';
 const BENIGN_DISCONNECT_PATTERN = /(connection terminated|connection closed|socket closed|unexpected eof)/i;
 let pgModule;
 function loadPg() {
@@ -12,15 +12,23 @@ async function resolveConnectionString(db, generate) {
     const configured = await resolveConfigValue(db.connectionString);
     if (configured)
         return configured;
-    const env = await resolveEnv(generate);
-    const hyperdriveConn = env?.HYPERDRIVE?.connectionString;
-    if (hyperdriveConn && hyperdriveConn !== 'postgresql://user:pass@localhost:5432/db') {
-        return hyperdriveConn;
+    if (db.autoHyperdrive !== false) {
+        const hyperdriveConn = await resolveHyperdriveConnectionString(generate);
+        if (hyperdriveConn)
+            return hyperdriveConn;
     }
     throw new Error('db: could not resolve a Postgres connection string. Set `db.connectionString` ' +
         'to a connection string, or to a function returning one (e.g. reading a ' +
         'Hyperdrive binding off `env` or `getCloudflareContext().env`).');
 }
+async function resetSessionState(client) {
+    try {
+        await client.query('discard all');
+    }
+    catch {
+        await client.query('reset role').catch(() => undefined);
+    }
+}
 export async function withDbClient(config, queryFn) {
     const db = config.db;
     requireDbConfig(db);
@@ -33,6 +41,7 @@ export async function withDbClient(config, queryFn) {
         try {
             await client.connect();
             connected = true;
+            await resetSessionState(client);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error ?? '');
@@ -83,6 +92,7 @@ export async function connectToPostgres(config) {
         void reportError({ errorHandling: config.errorHandling, generate: config.generate }, { error, classOrMethodName: 'db.connectToPostgres.clientError' });
     });
     await client.connect();
+    await resetSessionState(client);
     return client;
 }
 export async function disconnectPostgres(client) {

package/dist/src/db/context.js

@@ -100,7 +100,7 @@ export async function withPublicDb(fn, dbOverride) {
     const config = await resolveDbConfig(dbOverride);
     const db = config.db;
     requireDbConfig(db);
-    const resolved = await resolveDbMode(db);
+    const resolved = await resolveDbMode(db, config.generate);
     if (resolved.mode === 'supabase') {
         const { anonKey } = await resolveSupabaseEndpoint(resolved.supabase);
         return fn(await supabaseDb(resolved.supabase, anonKey));
@@ -130,7 +130,7 @@ export async function withUserDb(fn, uid, dbOverride) {
     const config = await resolveDbConfig(dbOverride);
     const db = config.db;
     requireDbConfig(db);
-    const resolved = await resolveDbMode(db);
+    const resolved = await resolveDbMode(db, config.generate);
     if (resolved.mode === 'supabase') {
         const token = await resolveAccessToken(config);
         return fn(await supabaseDb(resolved.supabase, token));

package/dist/src/db/resolve_hyperdrive_connection_string.d.ts

@@ -0,0 +1,5 @@
+import type { GenerateRoutingConfig } from '../types/types.js';
+export interface HyperdriveBindingLike {
+    connectionString: string;
+}
+export declare function resolveHyperdriveConnectionString(generate?: GenerateRoutingConfig): Promise<string | undefined>;

package/dist/src/db/resolve_hyperdrive_connection_string.js

@@ -0,0 +1,10 @@
+import { resolveEnv } from '../server/functions/geo.js';
+const WRANGLER_DEV_PLACEHOLDER = 'postgresql://user:pass@localhost:5432/db';
+export async function resolveHyperdriveConnectionString(generate) {
+    const env = await resolveEnv(generate);
+    const binding = env?.HYPERDRIVE;
+    const connectionString = binding?.connectionString;
+    if (!connectionString || connectionString === WRANGLER_DEV_PLACEHOLDER)
+        return undefined;
+    return connectionString;
+}

package/dist/src/db/resolve_mode.d.ts

@@ -1,4 +1,4 @@
-import type { DbRoutingConfig, SupabaseDbConfig } from '../types/types.js';
+import type { DbRoutingConfig, GenerateRoutingConfig, SupabaseDbConfig } from '../types/types.js';
 export type DbMode = 'postgres' | 'supabase';
 export type ResolvedDbMode = {
     mode: 'postgres';
@@ -7,4 +7,4 @@ export type ResolvedDbMode = {
     mode: 'supabase';
     supabase: SupabaseDbConfig;
 };
-export default function resolveDbMode(db: DbRoutingConfig): Promise<ResolvedDbMode>;
+export default function resolveDbMode(db: DbRoutingConfig, generate?: GenerateRoutingConfig): Promise<ResolvedDbMode>;

package/dist/src/db/resolve_mode.js

@@ -1,8 +1,14 @@
 import resolveConfigValue from './resolve_config_value.js';
-export default async function resolveDbMode(db) {
+import { resolveHyperdriveConnectionString } from './resolve_hyperdrive_connection_string.js';
+export default async function resolveDbMode(db, generate) {
     const connectionString = await resolveConfigValue(db.connectionString);
     if (connectionString)
         return { mode: 'postgres', connectionString };
+    if (db.autoHyperdrive !== false) {
+        const hyperdriveConnectionString = await resolveHyperdriveConnectionString(generate);
+        if (hyperdriveConnectionString)
+            return { mode: 'postgres', connectionString: hyperdriveConnectionString };
+    }
     if (db.supabase)
         return { mode: 'supabase', supabase: db.supabase };
     return { mode: 'postgres', connectionString: undefined };

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

@@ -0,0 +1,16 @@
+export type DynamicPagesCheckMode = 'off' | 'report' | 'fix';
+export interface CheckDynamicPagesOptions {
+    appDir: string;
+    mode?: DynamicPagesCheckMode;
+    skip?: readonly string[];
+}
+export interface CheckDynamicPagesReport {
+    file: string;
+    action: 'added-force-dynamic' | 'would-add-force-dynamic' | 'already-declared' | 'no-dynamic-usage-detected' | 'skipped';
+}
+export interface CheckDynamicPagesIo {
+    findPageFiles?: (appDir: string) => string[];
+    readFile?: (file: string) => string;
+    writeFile?: (file: string, contents: string) => void;
+}
+export declare function checkDynamicPages(options: CheckDynamicPagesOptions, io?: CheckDynamicPagesIo): Promise<CheckDynamicPagesReport[]>;

package/dist/src/dynamic_pages_check/check_dynamic_pages.js

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { findPageFiles as findPageFilesImpl } from './find_page_files.js';
+import { detectDynamicUsage } from './detect_dynamic_usage.js';
+import { insertDynamicExport } from './insert_dynamic_export.js';
+export async function checkDynamicPages(options, io = {}) {
+    const mode = options.mode ?? 'report';
+    if (mode === 'off')
+        return [];
+    const findPageFiles = io.findPageFiles ?? findPageFilesImpl;
+    const readFile = io.readFile ?? ((file) => readFileSync(file, 'utf8'));
+    const writeFile = io.writeFile ?? ((file, contents) => writeFileSync(file, contents, 'utf8'));
+    const skipSet = new Set(options.skip ?? []);
+    const reports = [];
+    for (const file of findPageFiles(options.appDir)) {
+        if (skipSet.has(file)) {
+            reports.push({ file, action: 'skipped' });
+            continue;
+        }
+        const source = readFile(file);
+        const detection = detectDynamicUsage(source);
+        if (detection.hasExplicitDynamicExport) {
+            reports.push({ file, action: 'already-declared' });
+            continue;
+        }
+        if (detection.detectedDynamicApis.length === 0) {
+            reports.push({ file, action: 'no-dynamic-usage-detected' });
+            continue;
+        }
+        if (mode === 'fix') {
+            writeFile(file, insertDynamicExport(source, 'force-dynamic'));
+            reports.push({ file, action: 'added-force-dynamic' });
+        }
+        else {
+            reports.push({ file, action: 'would-add-force-dynamic' });
+        }
+    }
+    return reports;
+}

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

@@ -0,0 +1,5 @@
+export interface DynamicDetectionResult {
+    hasExplicitDynamicExport: boolean;
+    detectedDynamicApis: string[];
+}
+export declare function detectDynamicUsage(sourceText: string): DynamicDetectionResult;

package/dist/src/dynamic_pages_check/detect_dynamic_usage.js

@@ -0,0 +1,16 @@
+const DYNAMIC_API_CHECKS = [
+    { name: 'cookies()', pattern: /\bcookies\s*\(/ },
+    { name: 'headers()', pattern: /\bheaders\s*\(\s*\)/ },
+    { name: 'searchParams', pattern: /\bsearchParams\b/ },
+    { name: 'unstable_noStore()', pattern: /\bunstable_noStore\s*\(/ },
+    { 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*[,}]/ },
+];
+const EXPLICIT_DYNAMIC_EXPORT = /export\s+const\s+dynamic\s*=/;
+export function detectDynamicUsage(sourceText) {
+    return {
+        hasExplicitDynamicExport: EXPLICIT_DYNAMIC_EXPORT.test(sourceText),
+        detectedDynamicApis: DYNAMIC_API_CHECKS.filter(({ pattern }) => pattern.test(sourceText)).map(({ name }) => name),
+    };
+}

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

@@ -0,0 +1 @@
+export declare function findPageFiles(appDir: string): string[];

package/dist/src/dynamic_pages_check/find_page_files.js

@@ -0,0 +1,24 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const PAGE_FILE_NAMES = new Set(['page.tsx', 'page.ts', 'page.jsx', 'page.js', 'route.ts', 'route.js']);
+export function findPageFiles(appDir) {
+    let entries;
+    try {
+        entries = readdirSync(appDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.'))
+                continue;
+            files.push(...findPageFiles(join(appDir, entry.name)));
+        }
+        else if (PAGE_FILE_NAMES.has(entry.name)) {
+            files.push(join(appDir, entry.name));
+        }
+    }
+    return files;
+}

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

@@ -0,0 +1,3 @@
+export { checkDynamicPages, type DynamicPagesCheckMode, type CheckDynamicPagesOptions, type CheckDynamicPagesReport, type CheckDynamicPagesIo } from './check_dynamic_pages.js';
+export { findPageFiles } from './find_page_files.js';
+export { detectDynamicUsage, type DynamicDetectionResult } from './detect_dynamic_usage.js';

package/dist/src/dynamic_pages_check/index.js

@@ -0,0 +1,3 @@
+export { checkDynamicPages } from './check_dynamic_pages.js';
+export { findPageFiles } from './find_page_files.js';
+export { detectDynamicUsage } from './detect_dynamic_usage.js';

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

@@ -0,0 +1 @@
+export declare function insertDynamicExport(sourceText: string, value: 'force-static' | 'force-dynamic'): string;

package/dist/src/dynamic_pages_check/insert_dynamic_export.js

@@ -0,0 +1,43 @@
+function findLeadingImportBlockEnd(sourceText) {
+    const lines = sourceText.split('\n');
+    let offset = 0;
+    let lastImportEnd = -1;
+    let depth = 0;
+    let inImport = false;
+    for (const line of lines) {
+        const lineEnd = offset + line.length;
+        const trimmed = line.trim();
+        if (!inImport) {
+            if (trimmed === '' || trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+                offset = lineEnd + 1;
+                continue;
+            }
+            if (!/^import\b/.test(trimmed))
+                break;
+            inImport = true;
+            depth = 0;
+        }
+        for (const char of line) {
+            if (char === '{' || char === '(' || char === '[')
+                depth += 1;
+            else if (char === '}' || char === ')' || char === ']')
+                depth -= 1;
+        }
+        if (inImport && depth <= 0 && /;\s*$/.test(line)) {
+            inImport = false;
+            lastImportEnd = lineEnd;
+        }
+        offset = lineEnd + 1;
+    }
+    return lastImportEnd;
+}
+export function insertDynamicExport(sourceText, value) {
+    const block = `// Auto-inserted by cloudflare-next-intl's checkDynamicPages (mode: "fix") — remove this line, or set \`dynamic\` yourself, to override.\nexport const dynamic = "${value}";\n`;
+    const lastImportEnd = findLeadingImportBlockEnd(sourceText);
+    if (lastImportEnd === -1) {
+        return `${block}\n${sourceText}`;
+    }
+    const before = sourceText.slice(0, lastImportEnd).replace(/\n+$/, '');
+    const after = sourceText.slice(lastImportEnd).replace(/^\n+/, '');
+    return `${before}\n\n${block}\n${after}`;
+}

package/dist/src/error_handling/create_server_error_action.js

@@ -2,7 +2,7 @@ import reportError from './report_error.js';
 import stringifyUnknown from './stringify_unknown.js';
 async function resolveRequestContext() {
     try {
-        const { headers } = await import('next/headers');
+        const { headers } = await import('next/headers.js');
         const headerList = await headers();
         return {
             path: headerList.get('x-pathname') ?? undefined,

package/dist/src/errors_board/client/error_detail_view.d.ts

@@ -0,0 +1,7 @@
+import type { ErrorRow } from '../server/errors_repository.js';
+import type { ErrorsActions } from '../server/actions_factory.js';
+export default function ErrorDetailView({ row, actions, onDeleted, }: {
+    row: ErrorRow;
+    actions: ErrorsActions;
+    onDeleted: () => void;
+}): Component;