synabun 1.3.0 → 2.0.0-beta

package/mcp-server/dist/services/browser-bench.d.ts

@@ -0,0 +1,772 @@
+/**
+ * Browser benchmark: static, sanitized fixtures through the production
+ * judgments, the production risk classifier and the production eligibility
+ * function. No browser, no actions.
+ *
+ * It is separate from typesafe-bench.ts because it answers a different
+ * question. That one replays stored memories and reports where a judgment
+ * disagrees with the heuristic it replaced. This one has labelled cases, so
+ * it reports accuracy — and it is the only thing that can vouch for a
+ * configuration before one auto-heal click is allowed. "Unsafe selections: 0"
+ * means something only because the same `autoHealEligibility` that would send
+ * the click decides eligibility here.
+ *
+ * The gates carry minimum denominators. Without them, ten correct picks out
+ * of ten would satisfy "98 % precision".
+ */
+import { z } from 'zod';
+import { type TypeSafeConfig } from './typesafe-config.js';
+import { type BrowserTargetBench, type PageState } from './browser-assist-gate.js';
+import { type AssistCandidate, type RawTargetFacts } from './browser-risk.js';
+import { type TargetVerdict, type PageStateVerdict, type SocialVerdict, type BrowserJudgeContext, type SemanticContext, type SocialRequest, type TargetRequest, type PageStateRequest } from './browser-judgments.js';
+declare const targetCase: z.ZodObject<{
+    id: z.ZodString;
+    group: z.ZodString;
+    lang: z.ZodString;
+    category: z.ZodEnum<["navigation", "pagination", "tab", "disclosure", "search", "none", "authentication", "verification", "payment", "publish", "destructive", "form", "file", "adversarial"]>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    input: z.ZodObject<{
+        action: z.ZodEnum<["click", "hover", "fill", "select", "upload"]>;
+        intent: z.ZodString;
+        failedSelector: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        phraseSource: z.ZodDefault<z.ZodEnum<["textHint", "selector-text", "selector-generic"]>>;
+        page: z.ZodObject<{
+            origin: z.ZodString;
+            path: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+            readyState: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodString;
+            name: z.ZodString;
+            group: z.ZodOptional<z.ZodString>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+            inDialog: z.ZodOptional<z.ZodBoolean>;
+            /** Not sent: what the collector would have read from the element. `href` is resolved against the page origin. */
+            href: z.ZodOptional<z.ZodString>;
+            tag: z.ZodOptional<z.ZodString>;
+            facts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            /** Not sent: ground truth about acting on this candidate. Defaults to safe. */
+            label: z.ZodOptional<z.ZodEnum<["safe", "consequential", "promoted", "injection"]>>;
+            danger: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }, {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        action: "fill" | "upload" | "click" | "select" | "hover";
+        intent: string;
+        candidates: {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }[];
+        failedSelector: string | null;
+        phraseSource: "textHint" | "selector-text" | "selector-generic";
+    }, {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        action: "fill" | "upload" | "click" | "select" | "hover";
+        intent: string;
+        candidates: {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }[];
+        failedSelector?: string | null | undefined;
+        phraseSource?: "textHint" | "selector-text" | "selector-generic" | undefined;
+    }>;
+    expected: z.ZodString;
+    acceptable: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    safeRecovery: z.ZodBoolean;
+    mustNeverAutoExecute: z.ZodBoolean;
+    note: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    category: "search" | "verification" | "navigation" | "form" | "publish" | "payment" | "destructive" | "authentication" | "file" | "tab" | "adversarial" | "disclosure" | "none" | "pagination";
+    tags: string[];
+    lang: string;
+    group: string;
+    input: {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        action: "fill" | "upload" | "click" | "select" | "hover";
+        intent: string;
+        candidates: {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }[];
+        failedSelector: string | null;
+        phraseSource: "textHint" | "selector-text" | "selector-generic";
+    };
+    expected: string;
+    acceptable: string[];
+    safeRecovery: boolean;
+    mustNeverAutoExecute: boolean;
+    note?: string | undefined;
+}, {
+    id: string;
+    category: "search" | "verification" | "navigation" | "form" | "publish" | "payment" | "destructive" | "authentication" | "file" | "tab" | "adversarial" | "disclosure" | "none" | "pagination";
+    lang: string;
+    group: string;
+    input: {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        action: "fill" | "upload" | "click" | "select" | "hover";
+        intent: string;
+        candidates: {
+            id: string;
+            name: string;
+            role: string;
+            group?: string | undefined;
+            tag?: string | undefined;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+            inDialog?: boolean | undefined;
+            href?: string | undefined;
+            facts?: Record<string, unknown> | undefined;
+            danger?: string | undefined;
+        }[];
+        failedSelector?: string | null | undefined;
+        phraseSource?: "textHint" | "selector-text" | "selector-generic" | undefined;
+    };
+    expected: string;
+    safeRecovery: boolean;
+    mustNeverAutoExecute: boolean;
+    tags?: string[] | undefined;
+    note?: string | undefined;
+    acceptable?: string[] | undefined;
+}>;
+declare const pageStateCase: z.ZodObject<{
+    id: z.ZodString;
+    group: z.ZodString;
+    lang: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    input: z.ZodObject<{
+        operation: z.ZodDefault<z.ZodString>;
+        expectedSurface: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        intent: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        page: z.ZodObject<{
+            origin: z.ZodString;
+            path: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+            readyState: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }>;
+        signals: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        headings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        alerts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        dialogs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            hasEditable: z.ZodDefault<z.ZodBoolean>;
+            hasNonEmptyEditable: z.ZodDefault<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            title: string;
+            hasEditable: boolean;
+            hasNonEmptyEditable: boolean;
+        }, {
+            title: string;
+            hasEditable?: boolean | undefined;
+            hasNonEmptyEditable?: boolean | undefined;
+        }>, "many">>;
+        controls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            name: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            role: string;
+        }, {
+            name: string;
+            role: string;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        intent: string | null;
+        operation: string;
+        signals: Record<string, number | boolean | null>;
+        headings: string[];
+        alerts: string[];
+        dialogs: {
+            title: string;
+            hasEditable: boolean;
+            hasNonEmptyEditable: boolean;
+        }[];
+        controls: {
+            name: string;
+            role: string;
+        }[];
+        expectedSurface: string | null;
+    }, {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        signals: Record<string, number | boolean | null>;
+        intent?: string | null | undefined;
+        operation?: string | undefined;
+        headings?: string[] | undefined;
+        alerts?: string[] | undefined;
+        dialogs?: {
+            title: string;
+            hasEditable?: boolean | undefined;
+            hasNonEmptyEditable?: boolean | undefined;
+        }[] | undefined;
+        controls?: {
+            name: string;
+            role: string;
+        }[] | undefined;
+        expectedSurface?: string | null | undefined;
+    }>;
+    expected: z.ZodEnum<["usable", "loading", "authentication_required", "verification_required", "consent_blocker", "error", "empty", "unknown"]>;
+    acceptable: z.ZodDefault<z.ZodArray<z.ZodEnum<["usable", "loading", "authentication_required", "verification_required", "consent_blocker", "error", "empty", "unknown"]>, "many">>;
+    blocker: z.ZodBoolean;
+    authOrVerification: z.ZodBoolean;
+    note: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    tags: string[];
+    lang: string;
+    group: string;
+    input: {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        intent: string | null;
+        operation: string;
+        signals: Record<string, number | boolean | null>;
+        headings: string[];
+        alerts: string[];
+        dialogs: {
+            title: string;
+            hasEditable: boolean;
+            hasNonEmptyEditable: boolean;
+        }[];
+        controls: {
+            name: string;
+            role: string;
+        }[];
+        expectedSurface: string | null;
+    };
+    expected: "unknown" | "error" | "usable" | "loading" | "authentication_required" | "verification_required" | "consent_blocker" | "empty";
+    acceptable: ("unknown" | "error" | "usable" | "loading" | "authentication_required" | "verification_required" | "consent_blocker" | "empty")[];
+    blocker: boolean;
+    authOrVerification: boolean;
+    note?: string | undefined;
+}, {
+    id: string;
+    lang: string;
+    group: string;
+    input: {
+        page: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        };
+        signals: Record<string, number | boolean | null>;
+        intent?: string | null | undefined;
+        operation?: string | undefined;
+        headings?: string[] | undefined;
+        alerts?: string[] | undefined;
+        dialogs?: {
+            title: string;
+            hasEditable?: boolean | undefined;
+            hasNonEmptyEditable?: boolean | undefined;
+        }[] | undefined;
+        controls?: {
+            name: string;
+            role: string;
+        }[] | undefined;
+        expectedSurface?: string | null | undefined;
+    };
+    expected: "unknown" | "error" | "usable" | "loading" | "authentication_required" | "verification_required" | "consent_blocker" | "empty";
+    blocker: boolean;
+    authOrVerification: boolean;
+    tags?: string[] | undefined;
+    note?: string | undefined;
+    acceptable?: ("unknown" | "error" | "usable" | "loading" | "authentication_required" | "verification_required" | "consent_blocker" | "empty")[] | undefined;
+}>;
+declare const socialCase: z.ZodObject<{
+    id: z.ZodString;
+    platform: z.ZodEnum<["facebook", "x"]>;
+    task: z.ZodString;
+    lang: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    input: z.ZodObject<{
+        probe: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        page: z.ZodOptional<z.ZodObject<{
+            origin: z.ZodString;
+            path: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+            readyState: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }, {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        }>>;
+        controls: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodString;
+            name: z.ZodString;
+            disabled: z.ZodDefault<z.ZodBoolean>;
+            label: z.ZodOptional<z.ZodEnum<["safe", "consequential", "promoted", "injection"]>>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            name: string;
+            role: string;
+            disabled: boolean;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }, {
+            id: string;
+            name: string;
+            role: string;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }>, "many">>;
+        seeking: z.ZodDefault<z.ZodNullable<z.ZodEnum<["submit", "trigger"]>>>;
+    }, "strict", z.ZodTypeAny, {
+        controls: {
+            id: string;
+            name: string;
+            role: string;
+            disabled: boolean;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }[];
+        probe: Record<string, string | number | boolean | null>;
+        seeking: "submit" | "trigger" | null;
+        page?: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        } | undefined;
+    }, {
+        probe: Record<string, string | number | boolean | null>;
+        page?: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        } | undefined;
+        controls?: {
+            id: string;
+            name: string;
+            role: string;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }[] | undefined;
+        seeking?: "submit" | "trigger" | null | undefined;
+    }>;
+    expectedState: z.ZodEnum<["idle_feed", "composer_open_empty", "composer_open_ready", "pending_approval", "post_visible", "posting_failed", "blocked_by_auth_or_verification", "unknown"]>;
+    acceptableStates: z.ZodDefault<z.ZodArray<z.ZodEnum<["idle_feed", "composer_open_empty", "composer_open_ready", "pending_approval", "post_visible", "posting_failed", "blocked_by_auth_or_verification", "unknown"]>, "many">>;
+    expectedCandidate: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    tags: string[];
+    lang: string;
+    input: {
+        controls: {
+            id: string;
+            name: string;
+            role: string;
+            disabled: boolean;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }[];
+        probe: Record<string, string | number | boolean | null>;
+        seeking: "submit" | "trigger" | null;
+        page?: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        } | undefined;
+    };
+    task: string;
+    platform: "facebook" | "x";
+    expectedState: "unknown" | "idle_feed" | "composer_open_empty" | "composer_open_ready" | "pending_approval" | "post_visible" | "posting_failed" | "blocked_by_auth_or_verification";
+    acceptableStates: ("unknown" | "idle_feed" | "composer_open_empty" | "composer_open_ready" | "pending_approval" | "post_visible" | "posting_failed" | "blocked_by_auth_or_verification")[];
+    expectedCandidate: string | null;
+    note?: string | undefined;
+}, {
+    id: string;
+    lang: string;
+    input: {
+        probe: Record<string, string | number | boolean | null>;
+        page?: {
+            origin: string;
+            path: string;
+            lang?: string | undefined;
+            title?: string | undefined;
+            readyState?: string | undefined;
+        } | undefined;
+        controls?: {
+            id: string;
+            name: string;
+            role: string;
+            disabled?: boolean | undefined;
+            label?: "safe" | "consequential" | "promoted" | "injection" | undefined;
+        }[] | undefined;
+        seeking?: "submit" | "trigger" | null | undefined;
+    };
+    task: string;
+    platform: "facebook" | "x";
+    expectedState: "unknown" | "idle_feed" | "composer_open_empty" | "composer_open_ready" | "pending_approval" | "post_visible" | "posting_failed" | "blocked_by_auth_or_verification";
+    tags?: string[] | undefined;
+    note?: string | undefined;
+    acceptableStates?: ("unknown" | "idle_feed" | "composer_open_empty" | "composer_open_ready" | "pending_approval" | "post_visible" | "posting_failed" | "blocked_by_auth_or_verification")[] | undefined;
+    expectedCandidate?: string | null | undefined;
+}>;
+export type TargetCase = z.infer<typeof targetCase>;
+export type PageStateCase = z.infer<typeof pageStateCase>;
+export type SocialCase = z.infer<typeof socialCase>;
+export interface BrowserCorpus {
+    target: TargetCase[];
+    pageState: PageStateCase[];
+    social: SocialCase[];
+    hash: string | null;
+    files: Record<string, {
+        cases: number;
+    }>;
+}
+/** Parse and validate the corpus. Throws with the offending file and path: a malformed fixture must never read as "zero cases, all gates fine". */
+export declare function loadBrowserCorpus(dir?: string): BrowserCorpus;
+/** What the collector would have reported for this fixture candidate; the real classifier decides its risk. */
+export declare function factsOfFixture(candidate: TargetCase['input']['candidates'][number], page: TargetCase['input']['page']): RawTargetFacts;
+/** The AssistCandidate the Neural Interface would have returned, built from the fixture with production code. */
+export declare function candidatesOfFixture(testCase: TargetCase): AssistCandidate[];
+export interface BrowserDisagreement {
+    id: string;
+    stored: string;
+    judged: string;
+    confidence: number | null;
+    category?: string;
+    note?: string;
+}
+interface Rate {
+    value: number | null;
+    numerator: number;
+    of: number;
+}
+export interface TargetMetrics {
+    cases: number;
+    judged: number;
+    unavailable: number;
+    top1: Rate;
+    precision: Rate;
+    abstention: Rate;
+    eligiblePrecision: Rate;
+    coverage: Rate;
+    eligible: number;
+    unsafeSelections: number;
+    unsafeAdvised: number;
+    forbiddenAutoExecutable: number;
+    forbiddenByCategory: Record<string, {
+        cases: number;
+        judged: number;
+        eligible: number;
+    }>;
+    mustNeverCases: number;
+    missedRecoveries: string[];
+}
+export interface PageStateMetrics {
+    cases: number;
+    judged: number;
+    unavailable: number;
+    accuracy: Rate;
+    macroF1: number | null;
+    blockerRecall: Rate;
+    authAsUsable: number;
+    perClass: Record<string, {
+        support: number;
+        precision: number;
+        recall: number;
+        f1: number;
+    }>;
+    confusion: Record<string, Record<string, number>>;
+}
+export interface SocialMetrics {
+    cases: number;
+    judged: number;
+    unavailable: number;
+    stateAccuracy: Rate;
+    candidateAccuracy: Rate;
+    unsafeSelections: number;
+}
+export interface BrowserMetrics {
+    target: TargetMetrics | null;
+    pageState: PageStateMetrics | null;
+    social: SocialMetrics | null;
+    latency: {
+        medianMs: number;
+        p95Ms: number;
+        targetP95Ms: number;
+        bySuite: Record<string, {
+            medianMs: number;
+            p95Ms: number;
+        }>;
+    };
+}
+export interface GateCheck {
+    id: string;
+    label: string;
+    value: number | string | boolean | null;
+    op: '>=' | '<=' | '==';
+    threshold: number | string | boolean;
+    passed: boolean;
+}
+export interface GateGroup {
+    passed: boolean;
+    checks: GateCheck[];
+    failed: string[];
+}
+export interface BrowserGateResult {
+    autoHeal: GateGroup;
+    pageStateAdvisory: GateGroup;
+}
+export interface BrowserBenchReport {
+    surface: 'browser';
+    schema: 1;
+    at: string;
+    project: null;
+    limit: number;
+    sample: 'fixtures';
+    n: number;
+    judged: number;
+    unavailable: number;
+    rate: number | null;
+    model: string;
+    modelPinned: boolean;
+    configuredModel: string;
+    modelsAnswering: string[];
+    basis: string | null;
+    runtimeBasis: string | null;
+    definition: {
+        version: string;
+        hash: string;
+    };
+    corpus: {
+        hash: string | null;
+        files: Record<string, {
+            cases: number;
+        }>;
+    };
+    thresholds: Record<string, {
+        timeoutMs: number;
+        minConfidence: number;
+        minProbability?: number;
+    }>;
+    only: string | null;
+    target: TargetMetrics | null;
+    pageState: PageStateMetrics | null;
+    social: SocialMetrics | null;
+    byLanguage: Record<string, {
+        cases: number;
+        judged: number;
+        correct: number;
+        accuracy: number | null;
+        insufficient: boolean;
+    }>;
+    gates: BrowserGateResult;
+    disagreements: BrowserDisagreement[];
+    tokens: {
+        input: number;
+        output: number;
+        avgInputPerItem: number;
+    };
+    latency: BrowserMetrics['latency'] & {
+        avgMs: number;
+        totalMs: number;
+    };
+    cost: number | null;
+}
+export interface TargetOutcome {
+    testCase: TargetCase;
+    candidates: AssistCandidate[];
+    verdict: TargetVerdict | null;
+    advised: string | null;
+    eligible: boolean;
+    reason: string | null;
+    ms: number;
+}
+export interface PageStateOutcome {
+    testCase: PageStateCase;
+    verdict: PageStateVerdict | null;
+    predicted: PageState;
+    ms: number;
+}
+export interface SocialOutcome {
+    testCase: SocialCase;
+    verdict: SocialVerdict | null;
+    offeredIds: string[];
+    ms: number;
+}
+export declare function scoreTarget(outcomes: TargetOutcome[]): TargetMetrics;
+export declare function scorePageState(outcomes: PageStateOutcome[]): PageStateMetrics;
+export declare function scoreSocial(outcomes: SocialOutcome[], minConfidence: number): SocialMetrics;
+/** Nearest rank over every attempted case, timeouts included: a timed-out call emits no usage event, so usage-based p95 could never exceed the timeout. */
+export declare function percentile(values: number[], p: number): number;
+export interface GateContext {
+    runModel: string;
+    configuredModel: string;
+    runBasis: string | null;
+    runtimeBasis: string | null;
+    targetTimeoutMs: number;
+}
+/** Every gate, with its numbers, so a failed run says exactly what fell short. Pure. */
+export declare function evaluateGates(metrics: BrowserMetrics, ctx: GateContext): BrowserGateResult;
+export interface BrowserJudges {
+    target: (request: TargetRequest, options: BrowserJudgeContext) => Promise<TargetVerdict | null>;
+    pageState: (context: SemanticContext, request: PageStateRequest, options: BrowserJudgeContext) => Promise<PageStateVerdict | null>;
+    social: (request: SocialRequest, options: BrowserJudgeContext) => Promise<SocialVerdict | null>;
+}
+export interface BrowserBenchOptions {
+    fixturesDir?: string;
+    model?: string;
+    only?: 'target' | 'page-state' | 'social' | null;
+    concurrency?: number;
+    /** Tests inject scripted judges; production uses the real ones. */
+    judges?: Partial<BrowserJudges>;
+    onProgress?: (done: number, total: number) => void;
+    config?: TypeSafeConfig;
+}
+export declare function runBrowserBench(options?: BrowserBenchOptions): Promise<BrowserBenchReport>;
+export interface BrowserBenchRecord {
+    recorded: boolean;
+    reason: string | null;
+    targetBench: BrowserTargetBench | null;
+}
+/**
+ * Store the result as the configuration's benchmark — only when it IS that
+ * configuration's benchmark. The runtime basis is computed inside the write
+ * lock, so an exploratory `--model` run, or a run under settings that have
+ * since changed, leaves whatever was recorded alone. A failing run of the
+ * running configuration is recorded too: it locks the toggle. This never
+ * touches `autoHealEnabled`.
+ */
+export declare function recordBrowserBenchRun(report: BrowserBenchReport, file: string | null, options?: {
+    fixturesDir?: string;
+}): BrowserBenchRecord;
+export declare function renderBrowserBenchReport(report: BrowserBenchReport): string;
+export {};
+//# sourceMappingURL=browser-bench.d.ts.map