@tangle-network/agent-eval 0.209.1 → 0.211.0

package/dist/judge-gate-B1_O0QIs.d.ts

@@ -0,0 +1,454 @@
+import { a as JudgeError } from "./errors-DEE6u6ot.js";
+import { u as JudgeScore } from "./types-Lub7o6bN.js";
+import { a as ContinuousCalibrationResult, i as ContinuousAgreementOptions, n as CandidateScore, o as GoldenItem, r as ContinuousAgreement, t as CalibrationResult } from "./judge-calibration-DFtEMlde.js";
+import { a as ComputedInterval } from "./ast-hI-vjW6J.js";
+//#region src/statistics/agreement-irr.d.ts
+/**
+ * Inter-rater reliability — Krippendorff's α under the squared-difference
+ * metric, pooled across dimensions.
+ *
+ * Each inner array is one judge's scores. Items are matched by position
+ * WITHIN a dimension: the k-th score a judge supplies carrying dimension
+ * `d` is item k of `d`, and the ratings compared against each other are
+ * the ones different judges gave to the same item. Every judge that scores
+ * a dimension at all must supply the same number of scores for it —
+ * ragged input cannot be aligned into items and throws rather than
+ * comparing mismatched items.
+ *
+ * α = 1 − D_observed / D_expected: D_observed averages the squared
+ * difference over within-item judge pairs, D_expected over every pair of
+ * ratings irrespective of item. α = 1 is perfect agreement, 0 is chance,
+ * negative is systematic disagreement.
+ */
+declare function interRaterReliability(judgeScores: JudgeScore[][]): number;
+interface CorpusScoreRecord {
+  /** Stable identifier for the rated item (scenario, span, turn, …). */
+  itemId: string;
+  /** Identifier for the judge that produced this score. */
+  judgeName: string;
+  /** Dimension name (matches `JudgeScore.dimension`). */
+  dimension: string;
+  /** Numeric score; must be finite. */
+  score: number;
+}
+interface CorpusAgreementPerDimension extends ContinuousAgreement {
+  dimension: string;
+  /** Item IDs that contributed to this dimension's matrix (every judge scored them). */
+  itemIds: string[];
+  /** Judge IDs that contributed to this dimension's matrix. */
+  judgeIds: string[];
+}
+interface CorpusAgreementReport {
+  /** Per-dimension ICC(2,1) + κ_w + Pearson + Spearman + bootstrap CIs. */
+  perDimension: CorpusAgreementPerDimension[];
+  /** Mean ICC across dimensions (NaN if no dimension yielded a finite ICC). */
+  overallIcc: number;
+  /** Mean weighted κ across dimensions (NaN if none finite). */
+  overallWeightedKappa: number;
+  /** Dimensions evaluated (sorted). */
+  dimensions: string[];
+  /** Judges seen across the corpus (sorted). */
+  judgeIds: string[];
+}
+interface CorpusAgreementOptions extends ContinuousAgreementOptions {
+  /**
+   * Restrict the audit to these dimensions. Default = every dimension
+   * that appears in the input. A dimension named here but absent from
+   * the input throws — silent omission would corrupt the overall metric.
+   */
+  dimensions?: string[];
+  /**
+   * Restrict the audit to these judges. Default = every judge that
+   * appears in the input. A judge named here but absent from a
+   * dimension throws (see "fail loud" below).
+   */
+  judges?: string[];
+}
+/**
+ * Corpus-wide inter-rater agreement across N items × M judges × D dimensions.
+ *
+ * For each dimension, builds the [n_items][n_judges] matrix of scores
+ * (keeping only items every judge rated on that dimension), then runs
+ * `continuousAgreement` to get ICC(2,1), κ_w, Pearson, Spearman, and
+ * bootstrap CIs. Reports a pooled mean across dimensions as a single
+ * "is this judge panel reliable on this corpus?" number.
+ *
+ * Fail-loud contract:
+ *   - Empty input throws.
+ *   - Fewer than 2 judges or fewer than 2 items per dimension throws.
+ *   - A judge present in some dimensions but with zero scored items on
+ *     another dimension throws (would silently shrink the matrix).
+ *   - Duplicate (itemId, judgeName, dimension) records throw.
+ */
+declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
+/**
+ * Convenience adapter for `JudgeScore[]` data keyed externally by item.
+ *
+ * Use when you have per-item arrays of `JudgeScore[]` (e.g. one
+ * `ScenarioResult.judgeScores` per scenario) and want corpus-wide
+ * agreement without manually flattening. `itemId` must be unique per
+ * row of `itemsScores`.
+ */
+declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
+  itemId: string;
+  scores: JudgeScore[];
+}>, opts?: CorpusAgreementOptions): CorpusAgreementReport;
+//#endregion
+//#region src/series-convergence.d.ts
+/**
+ * Series convergence — detects whether a sequence of scalar measurements
+ * is stabilizing, drifting, or noisy. It reads drift *across* runs, e.g.
+ * "are my nightly eval scores stabilizing?".
+ *
+ * Three signals:
+ *   - stabilized: last K values have low variance (< epsilon) — done
+ *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving
+ *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating
+ */
+interface SeriesConvergenceOptions {
+  /** Window size for "recent" analysis (default 5). */
+  window?: number;
+  /** Coefficient-of-variation threshold below which the window is stabilized (default 0.05 = 5%). */
+  stableCv?: number;
+  /** Minimum monotone run length to call drift (default 3). */
+  driftRun?: number;
+}
+interface SeriesConvergenceResult {
+  state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data';
+  windowMean: number;
+  windowCv: number;
+  /** Longest monotonic run at the tail of the series (positive for up, negative for down). */
+  tailRun: number;
+  /** True when n ≥ window AND windowCv ≤ stableCv. */
+  stable: boolean;
+}
+declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
+//#endregion
+//#region src/meta-eval/sentinel.d.ts
+declare const SENTINEL_METRIC_NAMES: readonly ['irr', 'calibrationKappa', 'sentinelPassRate'];
+type SentinelMetricName = (typeof SENTINEL_METRIC_NAMES)[number];
+interface SentinelMetrics {
+  /** Inter-rater reliability — ICC(2,1) from agreement instruments. */
+  irr?: number;
+  /** Weighted κ vs the human golden set (`calibrateJudge*`). */
+  calibrationKappa?: number;
+  /** Fraction of a fixed sentinel golden set the judge still scores within tolerance. */
+  sentinelPassRate?: number;
+}
+interface SentinelSnapshot {
+  /** Caller-supplied ISO-8601 timestamp — the module never reads a clock. */
+  at: string;
+  judgeId: string;
+  /** Exact model identity behind the judge (pin the full version string). */
+  judgeModel: string;
+  /**
+   * Metrics measured at `at`. May be empty: an empty-metrics snapshot is a
+   * model-change marker — it records the new `judgeModel` immediately and
+   * the silent-upgrade alarm stays raised until a golden-grounded snapshot
+   * (calibrationKappa or sentinelPassRate) follows.
+   */
+  metrics: SentinelMetrics;
+}
+/** Identity + timestamp the caller supplies alongside an instrument output. */
+interface SnapshotMeta {
+  at: string;
+  judgeId: string;
+  judgeModel: string;
+}
+/** Shape guard for snapshots crossing a boundary (store append, JSONL load, report input). */
+declare function validateSentinelSnapshot(snapshot: SentinelSnapshot, source?: string): void;
+/**
+ * From `calibrateJudge` / `calibrateJudgeContinuous` output. Prefers the
+ * un-rounded continuous κ_w when the report carries one (integer κ
+ * discards information for [0,1] judges).
+ */
+declare function snapshotFromCalibration(report: CalibrationResult | ContinuousCalibrationResult, meta: SnapshotMeta): SentinelSnapshot;
+/**
+ * From `corpusInterRaterAgreement` (statistics.ts) or `continuousAgreement`
+ * (judge-calibration.ts) output. IRR = ICC(2,1) — the reliability
+ * coefficient both instruments compute. For ensemble-level agreement,
+ * `meta.judgeId` names the ensemble and `meta.judgeModel` pins its
+ * composition (e.g. a joined list of member model strings).
+ */
+declare function snapshotFromAgreement(report: CorpusAgreementReport | ContinuousAgreement, meta: SnapshotMeta): SentinelSnapshot;
+interface SentinelSetOptions {
+  /** Max |judge − human| for an item to count as passed. Default 0.1 (tuned for [0,1] scores). */
+  tolerance?: number;
+}
+/**
+ * From a rerun of a fixed sentinel golden set: the same `GoldenItem`s the
+ * judge was originally calibrated on, re-scored periodically. Pass rate =
+ * fraction of joined items where the judge stays within `tolerance` of the
+ * human score. Items the judge didn't score are excluded from the
+ * denominator; zero joined items is an error, not a 0% pass rate.
+ */
+declare function snapshotFromSentinelSet(scores: CandidateScore[], golden: GoldenItem[], meta: SnapshotMeta, options?: SentinelSetOptions): SentinelSnapshot;
+interface SentinelStore {
+  append(snapshot: SentinelSnapshot): Promise<void>;
+  /** All snapshots (optionally for one judge), in append order. */
+  history(judgeId?: string): Promise<SentinelSnapshot[]>;
+}
+declare function inMemorySentinelStore(initial?: SentinelSnapshot[]): SentinelStore;
+/**
+ * JSONL store — one snapshot per line, appended atomically per call.
+ * A corrupt or shape-invalid line is a loud error naming the file and
+ * line number: a sentinel history that silently drops records would
+ * defeat the drift detection it exists to provide.
+ */
+declare function fileSentinelStore(path: string): SentinelStore;
+interface SentinelThresholds {
+  /** Floor for irr — below it the judge ensemble is unreliable regardless of trend. Default 0.6. */
+  minIrr?: number;
+  /** Max tolerated calibrationKappa drop vs the series baseline. Default 0.15. */
+  maxKappaDrop?: number;
+  /** Max tolerated sentinelPassRate drop vs the series baseline. Default 0.1. */
+  maxSentinelDrop?: number;
+  /** Newest snapshot older than this (days, vs asOf) = the sentinel itself went blind. Default 30. */
+  staleAfterDays?: number;
+}
+interface JudgeSentinelOptions {
+  /** Caller-supplied ISO timestamp staleness is measured against. */
+  asOf: string;
+  thresholds?: SentinelThresholds;
+  /** Forwarded to `analyzeSeries` (window, stableCv, driftRun). */
+  convergence?: SeriesConvergenceOptions;
+}
+interface SentinelTrend {
+  judgeId: string;
+  metric: SentinelMetricName;
+  /** Verbatim `analyzeSeries` state for this judge×metric history. */
+  state: SeriesConvergenceResult['state'];
+  /** Newest value in the series. */
+  current: number;
+  /** Oldest value in the series — the reference the drop thresholds compare against. */
+  baseline: number;
+  /** current − baseline (signed; negative = decayed). */
+  drift: number;
+  alarmed: boolean;
+  reason?: string;
+}
+interface SentinelReport {
+  perJudge: SentinelTrend[];
+  alarms: string[];
+  healthy: boolean;
+  /**
+   * `judgeId:metric` pairs with too few snapshots for the convergence
+   * machine. Named, not counted — a blind spot you can't see is a blind
+   * spot you won't fix. Floor/drop checks still apply to thin series, so
+   * insufficient history alone never masks an alarm.
+   */
+  insufficientHistory: string[];
+}
+declare function judgeSentinelReport(history: SentinelSnapshot[], opts: JudgeSentinelOptions): SentinelReport;
+interface EvalHealthStamp {
+  healthy: boolean;
+  alarms: string[];
+}
+/**
+ * The object a campaign attaches to its verdicts. Compute it from the
+ * sentinel report in a post-campaign hook (or a nightly job feeding the
+ * next day's campaigns) and store it alongside the verdict payload.
+ * `healthy: false` means the judges that produced those verdicts have an
+ * unresolved drift / decay / silent-upgrade / staleness alarm — treat the
+ * verdicts as carrying an integrity warning until recalibration clears it.
+ */
+declare function evalHealthStamp(report: SentinelReport): EvalHealthStamp;
+//#endregion
+//#region src/meta-eval/judge-gate.d.ts
+type OwnerVerdict = 'pass' | 'fail';
+/** One item the owner decided, with where that decision is recorded. */
+interface CalibrationExample {
+  /** Stable id of the decided item; a judge run names it in `exampleId`. */
+  id: string;
+  verdict: OwnerVerdict;
+  /** The person whose verdict this is. Never a model. */
+  labeledBy: string;
+  /** ISO-8601 time the verdict was given. */
+  labeledAt: string;
+  /** Where the verdict is recorded, e.g. `gtm:asset_decision:<id>`. */
+  source: string;
+  /** What the owner judged (an image digest, a run id), so a replay judges the same thing. */
+  evidenceRef?: string;
+  note?: string;
+}
+interface JudgeCalibrationSet {
+  judgeId: string;
+  /** Whose verdicts the judge stands in for. */
+  owner: string;
+  examples: readonly CalibrationExample[];
+}
+/**
+ * Validate a calibration set and return a normalized copy ordered by example
+ * id. Every verdict needs its person, time and source; ids are unique.
+ */
+declare function registerCalibrationSet(set: JudgeCalibrationSet): JudgeCalibrationSet;
+interface CalibrationMerge {
+  set: JudgeCalibrationSet;
+  /** Ids that joined the set. */
+  added: string[];
+  /** Ids whose verdict a later decision replaced. */
+  superseded: string[];
+  /** Ids whose incoming verdict was already recorded, or older than the recorded one. */
+  unchanged: string[];
+}
+/**
+ * Join new owner verdicts to a set. A verdict already recorded from the same
+ * source is unchanged, so ingestion can rerun. A later verdict on an item
+ * replaces an earlier one: the owner changed their mind, and the set keeps
+ * what they decided last.
+ */
+declare function addCalibrationVerdicts(set: JudgeCalibrationSet, verdicts: readonly CalibrationExample[]): CalibrationMerge;
+/** One gate decision the judge made on a calibration example. */
+interface JudgeRun {
+  exampleId: string;
+  /** The judge's decision after its own sample aggregation (median, majority). */
+  verdict: OwnerVerdict;
+  /** The per-sample verdicts behind that decision, when the judge samples. */
+  samples?: readonly OwnerVerdict[];
+}
+interface JudgeRunMeta {
+  judgeId: string;
+  /** Exact model identity, or `deterministic` for a grader without one. */
+  judgeModel: string;
+  rubricVersion: string;
+  measuredAt: string;
+}
+interface JudgeConfusion {
+  /** Judge pass, owner pass. */
+  truePass: number;
+  /** Judge fail, owner fail. */
+  trueFail: number;
+  /** Judge pass, owner fail: the judge let through what the owner rejected. */
+  falsePass: number;
+  /** Judge fail, owner pass: the judge blocked what the owner accepted. */
+  falseFail: number;
+}
+interface JudgeExampleAgreement {
+  id: string;
+  verdict: OwnerVerdict;
+  runs: number;
+  /** Share of runs that passed. */
+  passRate: number;
+  /** Share of runs that reached the owner's verdict. */
+  agreement: number;
+}
+interface JudgeAgreement extends JudgeRunMeta {
+  owner: string;
+  /** Examples in the calibration set. */
+  examples: number;
+  /** Examples the judge ran on at least once. */
+  judged: number;
+  /** Judged examples per owner verdict. */
+  judgedByVerdict: Record<OwnerVerdict, number>;
+  runs: number;
+  /** Runs that reached the owner's verdict, over all runs; null with no runs. */
+  accuracy: number | null;
+  /**
+   * Exact (Clopper-Pearson) 95% interval for the share of judged examples on
+   * which every run reached the owner's verdict. Examples, not runs, are the
+   * independent units.
+   */
+  exampleAccuracy: {
+    agreed: number;
+    judged: number;
+    interval: ComputedInterval;
+  } | null;
+  /**
+   * Cohen's κ between the judge and the owner over runs. Null when undefined:
+   * no runs, or both sides used a single verdict.
+   */
+  kappa: number | null;
+  /** Runs that failed what the owner passed, over runs on owner passes; null with none. A veto judge is held to this. */
+  falseFailRate: number | null;
+  /** Runs that failed what the owner failed, over runs on owner fails; null with none. */
+  catchRate: number | null;
+  confusion: JudgeConfusion;
+  variance: {
+    /** Mean over judged examples of p(1 − p), p the example's run pass rate. 0 = no run changed its mind. */
+    betweenRuns: number | null;
+    /** Mean over runs that reported samples of p(1 − p) across those samples; null when none did. */
+    withinRun: number | null;
+    /** Examples whose runs disagree with each other. */
+    unstable: string[];
+  };
+  /** Examples with at least one run against the owner, least agreement first. */
+  disagreements: JudgeExampleAgreement[];
+  /** Examples without any run. */
+  unjudged: string[];
+}
+/**
+ * Agreement between a judge's runs and the owner's verdicts on one
+ * calibration set. A run that names an example outside the set is an error:
+ * a silently dropped run would overstate agreement.
+ */
+declare function measureJudgeAgreement(set: JudgeCalibrationSet, runs: readonly JudgeRun[], meta: JudgeRunMeta): JudgeAgreement;
+interface JudgeGatePolicy {
+  /**
+   * `verdict`: the judge passes and blocks, so accuracy and κ must hold.
+   * `veto`: it only blocks, so its false-fail rate on owner passes must hold.
+   */
+  decides: 'verdict' | 'veto';
+  /** Judged examples required before the judge may gate; for a veto judge, owner passes. */
+  minExamples: number;
+  /** Judged examples required of each owner verdict, so κ is defined. */
+  minPerVerdict: number;
+  /** Floor on run accuracy. */
+  minAccuracy: number;
+  /** Floor on Cohen's κ. */
+  minKappa: number;
+  /** Ceiling on a veto judge's false-fail rate. */
+  maxFalseFailRate: number;
+  /** A report older than this (days, vs `asOf`) no longer calibrates the judge. */
+  maxAgeDays: number;
+  /** Drift thresholds forwarded to `judgeSentinelReport` over the history. */
+  drift?: SentinelThresholds;
+}
+declare const DEFAULT_JUDGE_GATE_POLICY: Readonly<JudgeGatePolicy>;
+type JudgeGateStatus = 'calibrated' | 'uncalibrated' | 'below-threshold' | 'drifted';
+interface JudgeGateDecision {
+  judgeId: string;
+  judgeModel: string;
+  rubricVersion: string;
+  /** True only for `calibrated`. */
+  mayGate: boolean;
+  status: JudgeGateStatus;
+  /** Why the judge may not gate; empty when it may. */
+  reasons: string[];
+  agreement: JudgeAgreement | null;
+  policy: JudgeGatePolicy;
+}
+interface JudgeGateInput {
+  judgeId: string;
+  /** The model the judge runs now. */
+  judgeModel: string;
+  /** The rubric the judge runs now. */
+  rubricVersion: string;
+  /** The latest calibration report; null when the judge was never measured. */
+  agreement: JudgeAgreement | null;
+  asOf: string;
+  /** Sentinel snapshots for this judge, oldest first or in any order. */
+  history?: readonly SentinelSnapshot[];
+  policy?: Partial<JudgeGatePolicy>;
+}
+/** Whether a judge may gate now, and every reason it may not. */
+declare function judgeGateDecision(input: JudgeGateInput): JudgeGateDecision;
+/** Thrown by `assertJudgeMayGate`; carries the refused decision. */
+declare class JudgeGateRefusedError extends JudgeError {
+  readonly decision: JudgeGateDecision;
+  constructor(decision: JudgeGateDecision);
+}
+/** Throw unless the decision lets the judge gate. */
+declare function assertJudgeMayGate(decision: JudgeGateDecision): void;
+/**
+ * The sentinel snapshot for one calibration run. A deciding judge records
+ * accuracy as `sentinelPassRate` and κ as `calibrationKappa` when it is
+ * defined; a veto judge records the share of owner passes it let through as
+ * `sentinelPassRate`. Append it to the judge's `SentinelStore`; the gate reads
+ * drift from that history.
+ */
+declare function snapshotFromJudgeAgreement(agreement: JudgeAgreement, options?: {
+  decides?: JudgeGatePolicy['decides'];
+}): SentinelSnapshot;
+//#endregion
+export { SentinelThresholds as A, validateSentinelSnapshot as B, JudgeSentinelOptions as C, SentinelSetOptions as D, SentinelReport as E, inMemorySentinelStore as F, CorpusAgreementPerDimension as G, SeriesConvergenceResult as H, judgeSentinelReport as I, corpusInterRaterAgreement as J, CorpusAgreementReport as K, snapshotFromAgreement as L, SnapshotMeta as M, evalHealthStamp as N, SentinelSnapshot as O, fileSentinelStore as P, snapshotFromCalibration as R, EvalHealthStamp as S, SentinelMetrics as T, analyzeSeries as U, SeriesConvergenceOptions as V, CorpusAgreementOptions as W, interRaterReliability as X, corpusInterRaterAgreementFromJudgeScores as Y, assertJudgeMayGate as _, JudgeCalibrationSet as a, registerCalibrationSet as b, JudgeGateDecision as c, JudgeGateRefusedError as d, JudgeGateStatus as f, addCalibrationVerdicts as g, OwnerVerdict as h, JudgeAgreement as i, SentinelTrend as j, SentinelStore as k, JudgeGateInput as l, JudgeRunMeta as m, CalibrationMerge as n, JudgeConfusion as o, JudgeRun as p, CorpusScoreRecord as q, DEFAULT_JUDGE_GATE_POLICY as r, JudgeExampleAgreement as s, CalibrationExample as t, JudgeGatePolicy as u, judgeGateDecision as v, SentinelMetricName as w, snapshotFromJudgeAgreement as x, measureJudgeAgreement as y, snapshotFromSentinelSet as z };
+//# sourceMappingURL=judge-gate-B1_O0QIs.d.ts.map

package/dist/judge-gate-B1_O0QIs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"judge-gate-B1_O0QIs.d.ts","names":[],"sources":["../src/statistics/agreement-irr.ts","../src/series-convergence.ts","../src/meta-eval/sentinel.ts","../src/meta-eval/judge-gate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAyBgB,sBAAsB,aAAa;UA0ElC;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe,oCAAoC;EACnD;;EAEA;;EAEA;;UAGe;;EAEf,cAAc;;EAEd;;EAEA;;EAEA;;EAEA;;UAGe,+BAA+B;;;;;;EAM9C;;;;;;EAMA;;;;;;;;;;;;;;;;;;iBAmBc,0BACd,SAAS,qBACT,OAAM,yBACL;;;;;;;;;iBA0Ha,yCACd,aAAa;EAAQ;EAAgB,QAAQ;IAC7C,OAAM,yBACL;;;;;;;;;;;;;UCvRc;;EAEf;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;iBAGc,cACd,kBACA,UAAS,2BACR;;;cCoBG;KAEM,6BAA6B;UAExB;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;EACA;;EAEA;;;;;;;EAOA,SAAS;;;UAIM;EACf;EACA;EACA;;;iBAcc,yBAAyB,UAAU,kBAAkB;;;;;;iBAiCrD,wBACd,QAAQ,oBAAoB,6BAC5B,MAAM,eACL;;;;;;;;iBAmBa,sBACd,QAAQ,wBAAwB,qBAChC,MAAM,eACL;UAYc;;EAEf;;;;;;;;;iBAUc,wBACd,QAAQ,kBACR,QAAQ,cACR,MAAM,cACN,UAAS,qBACR;UA4Cc;EACf,OAAO,UAAU,mBAAmB;;EAEpC,QAAQ,mBAAmB,QAAQ;;iBAGrB,sBAAsB,UAAS,qBAA0B;;;;;;;iBAqBzD,kBAAkB,eAAe;UA0ChC;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;EACA,aAAa;;EAEb,cAAc;;UAGC;EACf;EACA,QAAQ;;EAER,OAAO;;EAEP;;EAEA;;EAEA;EACA;EACA;;UAGe;EACf,UAAU;EACV;EACA;;;;;;;EAOA;;iBAKc,oBACd,SAAS,oBACT,MAAM,uBACL;UA6Gc;EACf;EACA;;;;;;;;;;iBAWc,gBAAgB,QAAQ,iBAAiB;;;KChb7C;;UAGK;;EAEf;EACA,SAAS;;EAET;;EAEA;;EAEA;;EAEA;EACA;;UAGe;EACf;;EAEA;EACA,mBAAmB;;;;;;iBAuDL,uBAAuB,KAAK,sBAAsB;UAwBjD;EACf,KAAK;;EAEL;;EAEA;;EAEA;;;;;;;;iBASc,uBACd,KAAK,qBACL,mBAAmB,uBAClB;;UAkCc;EACf;;EAEA,SAAS;;EAET,mBAAmB;;UAGJ;EACf;;EAEA;EACA;EACA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA,SAAS;EACT;;EAEA;;EAEA;;UAGe,uBAAuB;EACtC;;EAEA;;EAEA;;EAEA,iBAAiB,OAAO;EACxB;;EAEA;;;;;;EAMA;IAAmB;IAAgB;IAAgB,UAAU;;;;;;EAK7D;;EAEA;;EAEA;EACA,WAAW;EACX;;IAEE;;IAEA;;IAEA;;;EAGF,eAAe;;EAEf;;;;;;;iBAyBc,sBACd,KAAK,qBACL,eAAe,YACf,MAAM,eACL;UA+Gc;;;;;EAKf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,QAAQ;;cAGG,2BAA2B,SAAS;KAUrC;UAEK;EACf;EACA;EACA;;EAEA;EACA,QAAQ;;EAER;EACA,WAAW;EACX,QAAQ;;UAGO;EACf;;EAEA;;EAEA;;EAEA,WAAW;EACX;;EAEA,mBAAmB;EACnB,SAAS,QAAQ;;;iBAUH,kBAAkB,OAAO,iBAAiB;;cA2G7C,8BAA8B;WAChC,UAAU;EAEnB,YAAY,UAAU;;;iBASR,mBAAmB,UAAU;;;;;;;;iBAW7B,2BACd,WAAW,gBACX;EAAW,UAAU;IACpB"}