cloudflare-next-intl 0.9.7 → 0.9.9

package/dist/src/errors_board/client/errors_list_client.js

@@ -0,0 +1,92 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import ErrorRowItem from './error_row.js';
+export default function ErrorsListClient({ initialRows, initialNextCursor, filters, actions, hrefFor, }) {
+    const [rows, setRows] = useState(initialRows);
+    const [nextCursor, setNextCursor] = useState(initialNextCursor);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [selectedIds, setSelectedIds] = useState(new Set());
+    const [isPending, setIsPending] = useState(false);
+    const sentinelRef = useRef(null);
+    const latestRef = useRef({ isLoadingMore, nextCursor, filters, actions });
+    latestRef.current = { isLoadingMore, nextCursor, filters, actions };
+    useEffect(() => {
+        setRows(initialRows);
+        setNextCursor(initialNextCursor);
+    }, [initialRows, initialNextCursor]);
+    const loadMore = useCallback(() => {
+        const { isLoadingMore, nextCursor, filters, actions } = latestRef.current;
+        if (isLoadingMore || nextCursor === null)
+            return;
+        setIsLoadingMore(true);
+        void actions
+            .loadErrors({ ...filters, cursor: nextCursor })
+            .then((result) => {
+            setRows((previous) => [...previous, ...result.rows]);
+            setNextCursor(result.nextCursor);
+        })
+            .finally(() => setIsLoadingMore(false));
+    }, []);
+    useEffect(() => {
+        const sentinel = sentinelRef.current;
+        if (!sentinel)
+            return;
+        const observer = new IntersectionObserver((entries) => {
+            if (entries[0]?.isIntersecting)
+                loadMore();
+        }, { rootMargin: '400px' });
+        observer.observe(sentinel);
+        return () => observer.disconnect();
+    }, [loadMore]);
+    function toggleSelect(id, checked) {
+        setSelectedIds((previous) => {
+            const next = new Set(previous);
+            if (checked)
+                next.add(id);
+            else
+                next.delete(id);
+            return next;
+        });
+    }
+    function toggleSelectAll(checked) {
+        setSelectedIds(checked ? new Set(rows.map((row) => row.id)) : new Set());
+    }
+    async function handleBulkStatus(status) {
+        const ids = Array.from(selectedIds);
+        setIsPending(true);
+        try {
+            await actions.setErrorStatus(ids, status);
+            setSelectedIds(new Set());
+        }
+        finally {
+            setIsPending(false);
+        }
+    }
+    async function handleBulkDelete() {
+        const ids = Array.from(selectedIds);
+        if (!window.confirm(`Delete ${ids.length} error${ids.length === 1 ? '' : 's'}? This can't be undone.`))
+            return;
+        setIsPending(true);
+        try {
+            await actions.deleteErrors(ids);
+            setSelectedIds(new Set());
+        }
+        finally {
+            setIsPending(false);
+        }
+    }
+    async function handleDeleteAllResolved() {
+        if (!window.confirm("Delete every resolved error (including ones not currently loaded)? This can't be undone."))
+            return;
+        setIsPending(true);
+        try {
+            await actions.deleteAllResolved();
+        }
+        finally {
+            setIsPending(false);
+        }
+    }
+    const hasSelection = selectedIds.size > 0;
+    return (_jsxs("div", { className: "flex flex-col gap-3", children: [_jsxs("div", { className: "sticky top-2 z-10 flex flex-wrap items-center gap-2 rounded-xl border border-gray-200 bg-white/90 px-3 py-2 shadow-sm backdrop-blur dark:border-gray-800 dark:bg-gray-900/90", children: [_jsxs("label", { className: "flex items-center gap-2 text-sm text-gray-600 dark:text-gray-300", children: [_jsx("input", { type: "checkbox", checked: rows.length > 0 && selectedIds.size === rows.length, onChange: (event) => toggleSelectAll(event.target.checked), className: "size-4 accent-blue-600" }), hasSelection ? (_jsxs("span", { className: "font-medium text-gray-900 dark:text-white", children: [selectedIds.size, " selected"] })) : (_jsxs("span", { children: [rows.length, " error", rows.length === 1 ? '' : 's'] }))] }), _jsxs("div", { className: "ml-auto flex flex-wrap gap-2", children: [_jsx("button", { disabled: isPending || !hasSelection, onClick: () => handleBulkStatus('investigating'), className: "rounded-lg border border-gray-300 px-3 py-1.5 text-xs font-medium text-gray-700 hover:bg-gray-100 disabled:opacity-40 dark:border-gray-700 dark:text-gray-200 dark:hover:bg-gray-800", children: "Mark investigating" }), _jsx("button", { disabled: isPending || !hasSelection, onClick: () => handleBulkStatus('resolved'), className: "rounded-lg border border-gray-300 px-3 py-1.5 text-xs font-medium text-gray-700 hover:bg-gray-100 disabled:opacity-40 dark:border-gray-700 dark:text-gray-200 dark:hover:bg-gray-800", children: "Mark resolved" }), filters.status === 'muted' ? (_jsx("button", { disabled: isPending || !hasSelection, onClick: () => handleBulkStatus('new'), title: "Bring these back onto the board as New.", className: "rounded-lg border border-gray-300 px-3 py-1.5 text-xs font-medium text-gray-700 hover:bg-gray-100 disabled:opacity-40 dark:border-gray-700 dark:text-gray-200 dark:hover:bg-gray-800", children: "Unmute" })) : (_jsx("button", { disabled: isPending || !hasSelection, onClick: () => handleBulkStatus('muted'), title: "Hide for good. Repeats stay hidden and never reopen.", className: "rounded-lg border border-gray-300 px-3 py-1.5 text-xs font-medium text-gray-700 hover:bg-gray-100 disabled:opacity-40 dark:border-gray-700 dark:text-gray-200 dark:hover:bg-gray-800", children: "Mute" })), _jsx("button", { disabled: isPending || !hasSelection, onClick: handleBulkDelete, className: "rounded-lg border border-red-300 px-3 py-1.5 text-xs font-medium text-red-600 hover:bg-red-50 disabled:opacity-40 dark:border-red-900 dark:text-red-400 dark:hover:bg-red-950", children: "Delete selected" }), _jsx("button", { disabled: isPending, onClick: handleDeleteAllResolved, className: "rounded-lg border border-gray-300 px-3 py-1.5 text-xs font-medium text-gray-700 hover:bg-gray-100 disabled:opacity-40 dark:border-gray-700 dark:text-gray-200 dark:hover:bg-gray-800", children: "Delete all resolved" })] })] }), _jsxs("div", { className: "flex flex-col gap-2", children: [rows.map((row) => (_jsx(ErrorRowItem, { row: row, selected: selectedIds.has(row.id), onToggleSelect: toggleSelect, hrefFor: hrefFor }, row.id))), rows.length === 0 && (_jsxs("div", { className: "flex flex-col items-center gap-1 rounded-xl border border-dashed border-gray-300 py-14 text-center dark:border-gray-700", children: [_jsx("p", { className: "text-sm font-medium text-gray-600 dark:text-gray-300", children: "No errors here" }), _jsx("p", { className: "text-xs text-gray-400 dark:text-gray-500", children: "Nothing matches the current filters." })] }))] }), nextCursor !== null && (_jsx("div", { ref: sentinelRef, className: "flex justify-center py-4", children: isLoadingMore && (_jsxs("span", { className: "flex items-center gap-2 text-sm text-gray-400 dark:text-gray-500", children: [_jsx("span", { className: "size-3 animate-spin rounded-full border-2 border-gray-300 border-t-transparent dark:border-gray-600" }), "Loading more\u2026"] })) })), nextCursor === null && rows.length > 0 && (_jsx("p", { className: "py-4 text-center text-xs text-gray-400 dark:text-gray-500", children: "You've reached the end." }))] }));
+}

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

@@ -0,0 +1,5 @@
+export default function ErrorsLoginForm({ login, onSuccess, title, }: {
+    login: (password: string) => Promise<boolean>;
+    onSuccess: () => void;
+    title?: string;
+}): Component;

package/dist/src/errors_board/client/errors_login_form.js

@@ -0,0 +1,21 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useTransition } from 'react';
+export default function ErrorsLoginForm({ login, onSuccess, title = 'Error log', }) {
+    const [password, setPassword] = useState('');
+    const [error, setError] = useState(null);
+    const [isPending, startTransition] = useTransition();
+    function handleSubmit(event) {
+        event.preventDefault();
+        setError(null);
+        startTransition(async () => {
+            const ok = await login(password);
+            if (!ok) {
+                setError('Wrong password');
+                return;
+            }
+            onSuccess();
+        });
+    }
+    return (_jsxs("main", { className: "mx-auto flex min-h-screen max-w-sm flex-col justify-center gap-4 px-4", children: [_jsx("h1", { className: "text-lg font-semibold text-gray-900 dark:text-white", children: title }), _jsxs("form", { onSubmit: handleSubmit, className: "flex flex-col gap-2", children: [_jsx("input", { type: "password", autoFocus: true, value: password, onChange: (event) => setPassword(event.target.value), placeholder: "Password", className: "rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm text-gray-900 focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500 dark:border-gray-700 dark:bg-gray-800 dark:text-white" }), error && _jsx("p", { className: "text-xs text-red-600 dark:text-red-400", children: error }), _jsx("button", { type: "submit", disabled: isPending, className: "rounded-lg bg-blue-600 px-4 py-2 text-sm font-semibold text-white transition-colors hover:bg-blue-700 disabled:opacity-50", children: "Enter" })] })] }));
+}

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

@@ -0,0 +1,6 @@
+import type { ErrorStatus } from '../server/errors_repository.js';
+export default function ErrorsStatStrip({ counts, activeStatus, linkFor, }: {
+    counts: Record<ErrorStatus, number>;
+    activeStatus: string;
+    linkFor: (status: string) => string;
+}): Component;

package/dist/src/errors_board/client/errors_stat_strip.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Link from 'next/link.js';
+const STAT_CONFIG = [
+    { status: 'all', label: 'Total', dotClass: 'bg-blue-500' },
+    { status: 'new', label: 'New', dotClass: 'bg-red-500' },
+    { status: 'investigating', label: 'Investigating', dotClass: 'bg-amber-500' },
+    { status: 'resolved', label: 'Resolved', dotClass: 'bg-emerald-500' },
+    { status: 'muted', label: 'Muted', dotClass: 'bg-gray-400 dark:bg-gray-500' },
+];
+export default function ErrorsStatStrip({ counts, activeStatus, linkFor, }) {
+    const total = counts.new + counts.investigating + counts.resolved;
+    return (_jsx("div", { className: "grid grid-cols-2 gap-2 sm:grid-cols-3 lg:grid-cols-5", children: STAT_CONFIG.map(({ status, label, dotClass }) => {
+            const value = status === 'all' ? total : counts[status];
+            const isActive = activeStatus === status;
+            return (_jsxs(Link, { prefetch: false, href: linkFor(status), className: `flex items-center justify-between rounded-xl border px-3 py-2.5 transition-colors ${isActive
+                    ? 'border-blue-400 bg-blue-50 dark:border-blue-500/50 dark:bg-blue-500/10'
+                    : 'border-gray-200 bg-white hover:bg-gray-50 dark:border-gray-800 dark:bg-gray-900 dark:hover:bg-gray-800/50'}`, children: [_jsxs("span", { className: "flex items-center gap-2 text-xs font-medium text-gray-500 dark:text-gray-400", children: [_jsx("span", { className: `size-2 rounded-full ${dotClass}`, "aria-hidden": true }), label] }), _jsx("span", { className: "text-lg font-semibold tabular-nums text-gray-900 dark:text-white", children: value })] }, status));
+        }) }));
+}

package/dist/src/errors_board/server/actions_factory.d.ts

@@ -0,0 +1,24 @@
+import { type D1DatabaseLike, type ErrorsListResult, listErrors as listErrorsImpl, setErrorsStatus as setErrorsStatusImpl, deleteErrorsByIds as deleteErrorsByIdsImpl, deleteAllResolvedErrors as deleteAllResolvedErrorsImpl } from './errors_repository.js';
+export interface ErrorsActions {
+    loadErrors(rawParams: {
+        flavour?: string;
+        status?: string;
+        q?: string;
+        cursor?: string | null;
+    }): Promise<ErrorsListResult>;
+    setErrorStatus(ids: number[], status: string): Promise<void>;
+    deleteErrors(ids: number[]): Promise<void>;
+    deleteAllResolved(): Promise<void>;
+}
+export interface ErrorsActionsOptions {
+    getDb: () => Promise<D1DatabaseLike> | D1DatabaseLike;
+    requireAccess: () => Promise<void>;
+    listPath?: string;
+    repository?: {
+        listErrors?: typeof listErrorsImpl;
+        setErrorsStatus?: typeof setErrorsStatusImpl;
+        deleteErrorsByIds?: typeof deleteErrorsByIdsImpl;
+        deleteAllResolvedErrors?: typeof deleteAllResolvedErrorsImpl;
+    };
+}
+export declare function createErrorsActions(options: ErrorsActionsOptions): ErrorsActions;

package/dist/src/errors_board/server/actions_factory.js

@@ -0,0 +1,39 @@
+import { revalidatePath } from 'next/cache.js';
+import { parseErrorsListFilters, boundErrorIds, isErrorStatus, listErrors as listErrorsImpl, setErrorsStatus as setErrorsStatusImpl, deleteErrorsByIds as deleteErrorsByIdsImpl, deleteAllResolvedErrors as deleteAllResolvedErrorsImpl, } from './errors_repository.js';
+export function createErrorsActions(options) {
+    const listErrors = options.repository?.listErrors ?? listErrorsImpl;
+    const setErrorsStatus = options.repository?.setErrorsStatus ?? setErrorsStatusImpl;
+    const deleteErrorsByIds = options.repository?.deleteErrorsByIds ?? deleteErrorsByIdsImpl;
+    const deleteAllResolvedErrors = options.repository?.deleteAllResolvedErrors ?? deleteAllResolvedErrorsImpl;
+    const listPath = options.listPath ?? '/errors';
+    return {
+        async loadErrors(rawParams) {
+            await options.requireAccess();
+            const filters = parseErrorsListFilters(rawParams);
+            const db = await options.getDb();
+            return listErrors(db, filters);
+        },
+        async setErrorStatus(ids, status) {
+            await options.requireAccess();
+            if (!isErrorStatus(status))
+                throw new Error(`errors_board: unknown status "${status}"`);
+            const boundedIds = boundErrorIds(ids);
+            const db = await options.getDb();
+            await setErrorsStatus(db, boundedIds, status);
+            revalidatePath(listPath);
+        },
+        async deleteErrors(ids) {
+            await options.requireAccess();
+            const boundedIds = boundErrorIds(ids);
+            const db = await options.getDb();
+            await deleteErrorsByIds(db, boundedIds);
+            revalidatePath(listPath);
+        },
+        async deleteAllResolved() {
+            await options.requireAccess();
+            const db = await options.getDb();
+            await deleteAllResolvedErrors(db);
+            revalidatePath(listPath);
+        },
+    };
+}

package/dist/src/errors_board/server/errors_repository.d.ts

@@ -0,0 +1,83 @@
+export declare const ERROR_STATUSES: readonly ["new", "investigating", "resolved", "muted"];
+export type ErrorStatus = typeof ERROR_STATUSES[number];
+export declare const BOARD_STATUSES: readonly ["new", "investigating", "resolved"];
+declare const MAX_MESSAGE_LENGTH = 2000;
+declare const MAX_STACK_LENGTH = 8000;
+declare const MAX_PARAMS_LENGTH = 4000;
+export declare const ERRORS_PAGE_SIZE = 50;
+export declare const MAX_IDS_PER_ACTION = 200;
+export interface ErrorRow {
+    id: number;
+    fingerprint: string;
+    created_at: number;
+    updated_at: number;
+    flavour: string;
+    caller: string;
+    message: string;
+    stack: string | null;
+    params: string | null;
+    is_client: number;
+    status: ErrorStatus;
+    count: number;
+    user_email: string | null;
+    reopen_count: number;
+    resolved_at: number | null;
+}
+export interface D1PreparedStatementLike {
+    bind(...values: unknown[]): D1PreparedStatementLike;
+    run(): Promise<unknown>;
+    all<T = unknown>(): Promise<{
+        results?: T[];
+    }>;
+    first<T = unknown>(): Promise<T | null>;
+}
+export interface D1DatabaseLike {
+    prepare(sql: string): D1PreparedStatementLike;
+    batch<T = unknown>(statements: D1PreparedStatementLike[]): Promise<{
+        results?: T[];
+    }[]>;
+}
+export interface RecordErrorInput {
+    flavour: string;
+    caller: string;
+    message: string;
+    stack: string | null;
+    params: string | null;
+    isClient: boolean;
+    userEmail: string | null;
+}
+export interface ErrorsListFilters {
+    flavour: string;
+    status: ErrorStatus | 'all';
+    q: string;
+    cursor: string | null;
+}
+export interface ErrorsListResult {
+    rows: ErrorRow[];
+    nextCursor: string | null;
+}
+export interface ErrorsBoardResult extends ErrorsListResult {
+    flavours: string[];
+    counts: Record<ErrorStatus, number>;
+}
+export declare function isErrorStatus(value: string): value is ErrorStatus;
+export declare function encodeCursor(updatedAt: number, id: number): string;
+export declare function parseErrorsListFilters(raw: {
+    flavour?: string;
+    status?: string;
+    q?: string;
+    cursor?: string | null;
+}): ErrorsListFilters;
+export declare function boundErrorIds(ids: number[]): number[];
+declare function truncate(value: string, maxLength: number): string;
+export { MAX_MESSAGE_LENGTH, MAX_STACK_LENGTH, MAX_PARAMS_LENGTH, truncate };
+export declare function ensureSchema(db: D1DatabaseLike): Promise<void>;
+export declare function computeFingerprint(flavour: string, caller: string, message: string): Promise<string>;
+export declare function recordError(db: D1DatabaseLike, input: RecordErrorInput): Promise<void>;
+export declare function listErrors(db: D1DatabaseLike, filters: ErrorsListFilters): Promise<ErrorsListResult>;
+export declare function getErrorById(db: D1DatabaseLike, id: number): Promise<ErrorRow | null>;
+export declare function distinctFlavours(db: D1DatabaseLike): Promise<string[]>;
+export declare function loadErrorsBoard(db: D1DatabaseLike, filters: ErrorsListFilters): Promise<ErrorsBoardResult>;
+export declare function setErrorsStatus(db: D1DatabaseLike, ids: number[], status: ErrorStatus): Promise<void>;
+export declare function deleteErrorsByIds(db: D1DatabaseLike, ids: number[]): Promise<void>;
+export declare function deleteAllResolvedErrors(db: D1DatabaseLike): Promise<void>;

package/dist/src/errors_board/server/errors_repository.js

@@ -0,0 +1,199 @@
+export const ERROR_STATUSES = ['new', 'investigating', 'resolved', 'muted'];
+export const BOARD_STATUSES = ['new', 'investigating', 'resolved'];
+const MAX_MESSAGE_LENGTH = 2000;
+const MAX_STACK_LENGTH = 8000;
+const MAX_PARAMS_LENGTH = 4000;
+export const ERRORS_PAGE_SIZE = 50;
+export const MAX_IDS_PER_ACTION = 200;
+export function isErrorStatus(value) {
+    return ERROR_STATUSES.includes(value);
+}
+export function encodeCursor(updatedAt, id) {
+    return `${updatedAt}:${id}`;
+}
+function decodeCursor(raw) {
+    const [updatedAtPart, idPart] = raw.split(':');
+    const updatedAt = Number(updatedAtPart);
+    const id = Number(idPart);
+    if (!Number.isInteger(updatedAt) || !Number.isInteger(id) || updatedAt < 0 || id < 0)
+        return null;
+    return { updatedAt, id };
+}
+export function parseErrorsListFilters(raw) {
+    const status = raw.status === 'all' || (raw.status && isErrorStatus(raw.status)) ? raw.status : 'all';
+    const cursor = raw.cursor && decodeCursor(raw.cursor) ? raw.cursor : null;
+    return {
+        flavour: raw.flavour ?? 'all',
+        status,
+        q: (raw.q ?? '').slice(0, 200),
+        cursor,
+    };
+}
+export function boundErrorIds(ids) {
+    if (!Array.isArray(ids) || ids.length === 0)
+        throw new Error('errors_board: id list must not be empty');
+    if (!ids.every((id) => Number.isInteger(id) && id > 0)) {
+        throw new Error('errors_board: every id must be a positive integer');
+    }
+    return ids.slice(0, MAX_IDS_PER_ACTION);
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+export { MAX_MESSAGE_LENGTH, MAX_STACK_LENGTH, MAX_PARAMS_LENGTH, truncate };
+const CREATE_TABLE_SQL = `
+    CREATE TABLE IF NOT EXISTS errors (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        fingerprint TEXT    NOT NULL UNIQUE,
+        created_at  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL,
+        flavour     TEXT    NOT NULL,
+        caller      TEXT    NOT NULL,
+        message     TEXT    NOT NULL,
+        stack       TEXT,
+        params      TEXT,
+        is_client   INTEGER NOT NULL DEFAULT 0,
+        status      TEXT    NOT NULL DEFAULT 'new',
+        count       INTEGER NOT NULL DEFAULT 1,
+        user_email  TEXT,
+        reopen_count INTEGER NOT NULL DEFAULT 0,
+        resolved_at  INTEGER
+    )
+`;
+const CREATE_INDEXES_SQL = [
+    'CREATE INDEX IF NOT EXISTS idx_errors_updated_at ON errors (updated_at DESC)',
+    'CREATE INDEX IF NOT EXISTS idx_errors_flavour ON errors (flavour)',
+    'CREATE INDEX IF NOT EXISTS idx_errors_status ON errors (status)',
+];
+const schemaReadyByDb = new WeakMap();
+export function ensureSchema(db) {
+    const existing = schemaReadyByDb.get(db);
+    if (existing)
+        return existing;
+    const ready = db
+        .batch([db.prepare(CREATE_TABLE_SQL), ...CREATE_INDEXES_SQL.map((sql) => db.prepare(sql))])
+        .then(() => undefined)
+        .catch((error) => {
+        schemaReadyByDb.delete(db);
+        throw error;
+    });
+    schemaReadyByDb.set(db, ready);
+    return ready;
+}
+export async function computeFingerprint(flavour, caller, message) {
+    const data = new TextEncoder().encode(`${flavour}|${caller}|${message}`);
+    const digest = await crypto.subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+export async function recordError(db, input) {
+    await ensureSchema(db);
+    const message = truncate(input.message, MAX_MESSAGE_LENGTH);
+    const stack = input.stack ? truncate(input.stack, MAX_STACK_LENGTH) : null;
+    const params = input.params ? truncate(input.params, MAX_PARAMS_LENGTH) : null;
+    const fingerprint = await computeFingerprint(input.flavour, input.caller, message);
+    const now = Date.now();
+    await db
+        .prepare(`INSERT INTO errors (fingerprint, created_at, updated_at, flavour, caller, message, stack, params, is_client, user_email)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT (fingerprint) DO UPDATE SET
+               updated_at   = excluded.updated_at,
+               count        = errors.count + 1,
+               stack        = excluded.stack,
+               params       = excluded.params,
+               user_email   = excluded.user_email,
+               reopen_count = CASE WHEN errors.status = 'resolved' THEN errors.reopen_count + 1 ELSE errors.reopen_count END,
+               status       = CASE WHEN errors.status = 'resolved' THEN 'new' ELSE errors.status END`)
+        .bind(fingerprint, now, now, input.flavour, input.caller, message, stack, params, input.isClient ? 1 : 0, input.userEmail)
+        .run();
+}
+function buildListQuery(filters) {
+    const conditions = [];
+    const bindings = [];
+    if (filters.flavour !== 'all') {
+        conditions.push('flavour = ?');
+        bindings.push(filters.flavour);
+    }
+    if (filters.status === 'all') {
+        conditions.push("status != 'muted'");
+    }
+    else {
+        conditions.push('status = ?');
+        bindings.push(filters.status);
+    }
+    if (filters.q) {
+        conditions.push('(message LIKE ? OR caller LIKE ? OR user_email LIKE ?)');
+        const like = `%${filters.q}%`;
+        bindings.push(like, like, like);
+    }
+    if (filters.cursor !== null) {
+        const decoded = decodeCursor(filters.cursor);
+        if (decoded) {
+            conditions.push('(updated_at < ? OR (updated_at = ? AND id < ?))');
+            bindings.push(decoded.updatedAt, decoded.updatedAt, decoded.id);
+        }
+    }
+    bindings.push(ERRORS_PAGE_SIZE + 1);
+    return { sql: `SELECT * FROM errors WHERE ${conditions.join(' AND ')} ORDER BY updated_at DESC, id DESC LIMIT ?`, bindings };
+}
+function paginate(rows) {
+    const hasMore = rows.length > ERRORS_PAGE_SIZE;
+    const page = hasMore ? rows.slice(0, ERRORS_PAGE_SIZE) : rows;
+    const last = page[page.length - 1];
+    return { rows: page, nextCursor: hasMore && last ? encodeCursor(last.updated_at, last.id) : null };
+}
+export async function listErrors(db, filters) {
+    await ensureSchema(db);
+    const { sql, bindings } = buildListQuery(filters);
+    const result = await db.prepare(sql).bind(...bindings).all();
+    return paginate(result.results ?? []);
+}
+export async function getErrorById(db, id) {
+    await ensureSchema(db);
+    const row = await db.prepare('SELECT * FROM errors WHERE id = ?').bind(id).first();
+    return row ?? null;
+}
+export async function distinctFlavours(db) {
+    await ensureSchema(db);
+    const result = await db.prepare('SELECT DISTINCT flavour FROM errors ORDER BY flavour').all();
+    return (result.results ?? []).map((row) => row.flavour);
+}
+export async function loadErrorsBoard(db, filters) {
+    await ensureSchema(db);
+    const listQuery = buildListQuery(filters);
+    const [listResult, flavourResult, countResult] = await db.batch([
+        db.prepare(listQuery.sql).bind(...listQuery.bindings),
+        db.prepare('SELECT DISTINCT flavour FROM errors ORDER BY flavour'),
+        db.prepare('SELECT status, COUNT(*) as count FROM errors GROUP BY status'),
+    ]);
+    const counts = { new: 0, investigating: 0, resolved: 0, muted: 0 };
+    for (const row of (countResult.results ?? [])) {
+        counts[row.status] = row.count;
+    }
+    return {
+        ...paginate((listResult.results ?? [])),
+        flavours: (flavourResult.results ?? []).map((row) => row.flavour),
+        counts,
+    };
+}
+export async function setErrorsStatus(db, ids, status) {
+    await ensureSchema(db);
+    const boundedIds = boundErrorIds(ids);
+    const placeholders = boundedIds.map(() => '?').join(', ');
+    await db
+        .prepare(`UPDATE errors
+                SET status      = ?,
+                    resolved_at = CASE WHEN ? = 'resolved' THEN ? ELSE resolved_at END
+              WHERE id IN (${placeholders})`)
+        .bind(status, status, Date.now(), ...boundedIds)
+        .run();
+}
+export async function deleteErrorsByIds(db, ids) {
+    await ensureSchema(db);
+    const boundedIds = boundErrorIds(ids);
+    const placeholders = boundedIds.map(() => '?').join(', ');
+    await db.prepare(`DELETE FROM errors WHERE id IN (${placeholders})`).bind(...boundedIds).run();
+}
+export async function deleteAllResolvedErrors(db) {
+    await ensureSchema(db);
+    await db.prepare("DELETE FROM errors WHERE status = 'resolved'").run();
+}

package/dist/src/errors_board/server/gate.d.ts

@@ -0,0 +1,19 @@
+export interface ErrorsAccessOptions {
+    allowedEmails: readonly string[] | ((email: string | null) => boolean);
+    onDenied?: () => void | Promise<void>;
+}
+export declare function createRequireErrorsAccess(options: ErrorsAccessOptions): () => Promise<void>;
+export interface PasswordErrorsAccessOptions {
+    password: string;
+    cookieName?: string;
+    cookiePath?: string;
+    maxAgeSeconds?: number;
+    onDenied?: () => void | Promise<void>;
+}
+export interface PasswordErrorsAccess {
+    hasAccess(): Promise<boolean>;
+    requireAccess(): Promise<void>;
+    verifyPassword(password: string): Promise<boolean>;
+    setAuthCookie(): Promise<void>;
+}
+export declare function createPasswordErrorsAccess(options: PasswordErrorsAccessOptions): PasswordErrorsAccess;

package/dist/src/errors_board/server/gate.js

@@ -0,0 +1,68 @@
+import { getAuthUser } from '../../firebase_auth/server/use_auth_user_server.js';
+export function createRequireErrorsAccess(options) {
+    const allowedEmailsLower = Array.isArray(options.allowedEmails)
+        ? new Set(options.allowedEmails.map((email) => email.toLowerCase()))
+        : null;
+    const isAllowed = allowedEmailsLower
+        ? (email) => allowedEmailsLower.has((email ?? '').toLowerCase())
+        : options.allowedEmails;
+    return async function requireErrorsAccess() {
+        const { user } = await getAuthUser();
+        if (isAllowed(user?.email ?? null))
+            return;
+        if (options.onDenied) {
+            await options.onDenied();
+            return;
+        }
+        const { notFound } = await import('next/navigation.js');
+        notFound();
+    };
+}
+async function sha256Hex(input) {
+    const data = new TextEncoder().encode(input);
+    const digest = await crypto.subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+export function createPasswordErrorsAccess(options) {
+    const cookieName = options.cookieName ?? 'errors_auth';
+    const cookiePath = options.cookiePath ?? '/errors';
+    const maxAge = options.maxAgeSeconds ?? 60 * 60 * 24 * 30;
+    async function expectedCookieValue() {
+        return sha256Hex(options.password);
+    }
+    async function hasAccess() {
+        const { cookies } = await import('next/headers.js');
+        const store = await cookies();
+        const value = store.get(cookieName)?.value;
+        if (!value)
+            return false;
+        return value === (await expectedCookieValue());
+    }
+    return {
+        hasAccess,
+        async requireAccess() {
+            if (await hasAccess())
+                return;
+            if (options.onDenied) {
+                await options.onDenied();
+                return;
+            }
+            const { notFound } = await import('next/navigation.js');
+            notFound();
+        },
+        async verifyPassword(password) {
+            return password === options.password;
+        },
+        async setAuthCookie() {
+            const { cookies } = await import('next/headers.js');
+            const store = await cookies();
+            store.set(cookieName, await expectedCookieValue(), {
+                httpOnly: true,
+                secure: true,
+                sameSite: 'lax',
+                path: cookiePath,
+                maxAge,
+            });
+        },
+    };
+}

package/dist/src/errors_board/server/index.d.ts

@@ -0,0 +1,3 @@
+export { ERROR_STATUSES, BOARD_STATUSES, ERRORS_PAGE_SIZE, MAX_IDS_PER_ACTION, isErrorStatus, parseErrorsListFilters, boundErrorIds, encodeCursor, ensureSchema, computeFingerprint, recordError, listErrors, getErrorById, distinctFlavours, loadErrorsBoard, setErrorsStatus, deleteErrorsByIds, deleteAllResolvedErrors, type ErrorStatus, type ErrorRow, type D1DatabaseLike, type D1PreparedStatementLike, type RecordErrorInput, type ErrorsListFilters, type ErrorsListResult, type ErrorsBoardResult, } from './errors_repository.js';
+export { createRequireErrorsAccess, createPasswordErrorsAccess, type ErrorsAccessOptions, type PasswordErrorsAccessOptions, type PasswordErrorsAccess, } from './gate.js';
+export { createErrorsActions, type ErrorsActions, type ErrorsActionsOptions } from './actions_factory.js';

package/dist/src/errors_board/server/index.js

@@ -0,0 +1,3 @@
+export { ERROR_STATUSES, BOARD_STATUSES, ERRORS_PAGE_SIZE, MAX_IDS_PER_ACTION, isErrorStatus, parseErrorsListFilters, boundErrorIds, encodeCursor, ensureSchema, computeFingerprint, recordError, listErrors, getErrorById, distinctFlavours, loadErrorsBoard, setErrorsStatus, deleteErrorsByIds, deleteAllResolvedErrors, } from './errors_repository.js';
+export { createRequireErrorsAccess, createPasswordErrorsAccess, } from './gate.js';
+export { createErrorsActions } from './actions_factory.js';

package/dist/src/errors_board/shared/error_ui_helpers.d.ts

@@ -0,0 +1,13 @@
+import type { ErrorStatus } from '../server/errors_repository.js';
+export declare const STATUS_LABELS: Record<ErrorStatus, string>;
+export declare const STATUS_HINTS: Record<ErrorStatus, string>;
+export declare const STATUS_DOT_CLASS: Record<ErrorStatus, string>;
+export declare const STATUS_BADGE_CLASS: Record<ErrorStatus, string>;
+export declare function formatRelativeTime(timestampMs: number): string;
+export declare function formatLocalTimestamp(timestampMs: number): string;
+export interface ParsedRequestContext {
+    path?: string;
+    userAgent?: string;
+    referer?: string;
+}
+export declare function parseRequestContext(paramsJson: string | null): ParsedRequestContext | null;