@tangle-network/agent-eval 0.221.7 → 0.222.0

package/dist/{types-6Lfdlshp.d.ts → types-DzCO-S1m.d.ts}

@@ -1,10 +1,9 @@
-import { o as CostLedgerHandle, u as CostProvenance } from "./cost-ledger-C1W3ICmP.js";
-import { a as RunRecord, d as RunTokenUsage } from "./run-record-C3awiXPf.js";
-import { l as JudgeInput, x as ChatClient } from "./types-B_IFcKp5.js";
+import { o as CostLedgerHandle, u as CostProvenance } from "./cost-ledger-Czro9wmo.js";
+import { a as RunRecord, d as RunTokenUsage } from "./run-record-D2BFMPGl.js";
+import { l as JudgeInput, x as ChatClient } from "./types-0KglnQ9o.js";
 import { z } from "zod";
 import { SpanKind } from "@tangle-network/agent-trace-contract";
 import { RE2JS } from "re2js";
-//#region src/trace-analyst/types.d.ts
 /**
  * A span's declared OpenInference kind, as `@tangle-network/agent-trace-contract`
  * spells it. A span that declares no recognised kind is `UNKNOWN`: the analyst
@@ -185,8 +184,6 @@ interface TraceAnalystByteBudgets {
   perMatchTextBudget: number;
 }
 declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
-//#endregion
-//#region src/trace-analyst/store-contract.d.ts
 declare const TRACE_ANALYSIS_LIMITS: {
   readonly sampleTraceIds: 20;
   readonly queryTraces: 200;
@@ -282,39 +279,35 @@ interface TraceAnalysisStore {
 interface BoundedTraceAnalysisStoreOptions {
   budgets?: Partial<TraceAnalystByteBudgets>;
 }
-//#endregion
-//#region src/trace-analyst/store-boundary.d.ts
 /** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
 declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, options?: BoundedTraceAnalysisStoreOptions): TraceAnalysisStore;
-//#endregion
-//#region src/analyst/finding-composition.d.ts
 /** What was deliberately changed; this is separate from a finding's event-to-meta scope. */
-declare const TREATMENT_LAYERS: readonly ['Task', 'Model', 'Budget', 'Team', 'Roles', 'Tools', 'Memory', 'Process', 'Oversight'];
+declare const TREATMENT_LAYERS: readonly ["Task", "Model", "Budget", "Team", "Roles", "Tools", "Memory", "Process", "Oversight"];
 type TreatmentLayer = (typeof TREATMENT_LAYERS)[number];
 declare const findingTreatmentSchema: z.ZodObject<{
   id: z.ZodString;
   definition_digest: z.ZodString;
   definition_refs: z.ZodArray<z.ZodObject<{
     kind: z.ZodEnum<{
-      artifact: "artifact";
       event: "event";
+      span: "span";
+      artifact: "artifact";
       finding: "finding";
       metric: "metric";
-      span: "span";
     }>;
     uri: z.ZodString;
     excerpt: z.ZodOptional<z.ZodString>;
   }, z.core.$strict>>;
   layers: z.ZodArray<z.ZodEnum<{
-    Budget: "Budget";
-    Memory: "Memory";
-    Model: "Model";
-    Oversight: "Oversight";
-    Process: "Process";
-    Roles: "Roles";
     Task: "Task";
+    Model: "Model";
+    Budget: "Budget";
     Team: "Team";
+    Roles: "Roles";
     Tools: "Tools";
+    Memory: "Memory";
+    Process: "Process";
+    Oversight: "Oversight";
   }>>;
 }, z.core.$strict>;
 /** Required nullable values distinguish an unavailable observation from observed absence. */
@@ -324,11 +317,11 @@ declare const findingConditionsSchema: z.ZodObject<{
   observed_at: z.ZodString;
   evidence_refs: z.ZodArray<z.ZodObject<{
     kind: z.ZodEnum<{
-      artifact: "artifact";
       event: "event";
+      span: "span";
+      artifact: "artifact";
       finding: "finding";
       metric: "metric";
-      span: "span";
     }>;
     uri: z.ZodString;
     excerpt: z.ZodOptional<z.ZodString>;
@@ -346,11 +339,11 @@ declare const findingConditionsSchema: z.ZodObject<{
     planned: z.ZodNullable<z.ZodBoolean>;
     evidence_ref: z.ZodObject<{
       kind: z.ZodEnum<{
-        artifact: "artifact";
         event: "event";
+        span: "span";
+        artifact: "artifact";
         finding: "finding";
         metric: "metric";
-        span: "span";
       }>;
       uri: z.ZodString;
       excerpt: z.ZodOptional<z.ZodString>;
@@ -359,14 +352,12 @@ declare const findingConditionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type FindingTreatment = z.infer<typeof findingTreatmentSchema>;
 type FindingConditions = z.infer<typeof findingConditionsSchema>;
-//#endregion
-//#region src/analyst/finding-scope.d.ts
 /**
  * The layer ladder, lowest first. `problem` is what discovery-lab calls a
  * theatre. `meta` sits outside the ladder: it is about the instrument, not the
  * agents, so it never promotes and never bounds another layer.
  */
-declare const FINDING_LAYERS: readonly ['event', 'turn', 'agent', 'team', 'run', 'play', 'problem', 'domain', 'lab', 'meta'];
+declare const FINDING_LAYERS: readonly ["event", "turn", "agent", "team", "run", "play", "problem", "domain", "lab", "meta"];
 type FindingLayer = (typeof FINDING_LAYERS)[number];
 interface FindingScope {
   /**
@@ -432,20 +423,20 @@ declare const ProposalFindingSchema: z.ZodObject<{
   severity: z.ZodEnum<{
     critical: "critical";
     high: "high";
-    info: "info";
-    low: "low";
     medium: "medium";
+    low: "low";
+    info: "info";
   }>;
   area: z.ZodString;
   claim: z.ZodString;
   rationale: z.ZodOptional<z.ZodString>;
   evidence_refs: z.ZodArray<z.ZodObject<{
     kind: z.ZodEnum<{
-      artifact: "artifact";
       event: "event";
+      span: "span";
+      artifact: "artifact";
       finding: "finding";
       metric: "metric";
-      span: "span";
     }>;
     uri: z.ZodString;
     excerpt: z.ZodOptional<z.ZodString>;
@@ -457,16 +448,16 @@ declare const ProposalFindingSchema: z.ZodObject<{
   derived_from_judge: z.ZodOptional<z.ZodBoolean>;
   metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   layer: z.ZodOptional<z.ZodEnum<{
+    event: "event";
+    turn: "turn";
     agent: "agent";
+    team: "team";
+    run: "run";
+    play: "play";
+    problem: "problem";
     domain: "domain";
-    event: "event";
     lab: "lab";
     meta: "meta";
-    play: "play";
-    problem: "problem";
-    run: "run";
-    team: "team";
-    turn: "turn";
   }>>;
   scope: z.ZodOptional<z.ZodObject<{
     population: z.ZodArray<z.ZodString>;
@@ -480,8 +471,8 @@ declare const ProposalFindingSchema: z.ZodObject<{
   method: z.ZodOptional<z.ZodObject<{
     kind: z.ZodEnum<{
       computed: "computed";
-      judged: "judged";
       measured: "measured";
+      judged: "judged";
     }>;
     name: z.ZodString;
     version: z.ZodString;
@@ -504,16 +495,16 @@ declare const ProposalFindingSchema: z.ZodObject<{
   evidence_units: z.ZodOptional<z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     layer: z.ZodEnum<{
+      event: "event";
+      turn: "turn";
       agent: "agent";
+      team: "team";
+      run: "run";
+      play: "play";
+      problem: "problem";
       domain: "domain";
-      event: "event";
       lab: "lab";
       meta: "meta";
-      play: "play";
-      problem: "problem";
-      run: "run";
-      team: "team";
-      turn: "turn";
     }>;
     derived_from: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   }, z.core.$strict>>>;
@@ -522,25 +513,25 @@ declare const ProposalFindingSchema: z.ZodObject<{
     definition_digest: z.ZodString;
     definition_refs: z.ZodArray<z.ZodObject<{
       kind: z.ZodEnum<{
-        artifact: "artifact";
         event: "event";
+        span: "span";
+        artifact: "artifact";
         finding: "finding";
         metric: "metric";
-        span: "span";
       }>;
       uri: z.ZodString;
       excerpt: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     layers: z.ZodArray<z.ZodEnum<{
-      Budget: "Budget";
-      Memory: "Memory";
-      Model: "Model";
-      Oversight: "Oversight";
-      Process: "Process";
-      Roles: "Roles";
       Task: "Task";
+      Model: "Model";
+      Budget: "Budget";
       Team: "Team";
+      Roles: "Roles";
       Tools: "Tools";
+      Memory: "Memory";
+      Process: "Process";
+      Oversight: "Oversight";
     }>>;
   }, z.core.$strict>>>;
   conditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -549,11 +540,11 @@ declare const ProposalFindingSchema: z.ZodObject<{
     observed_at: z.ZodString;
     evidence_refs: z.ZodArray<z.ZodObject<{
       kind: z.ZodEnum<{
-        artifact: "artifact";
         event: "event";
+        span: "span";
+        artifact: "artifact";
         finding: "finding";
         metric: "metric";
-        span: "span";
       }>;
       uri: z.ZodString;
       excerpt: z.ZodOptional<z.ZodString>;
@@ -571,11 +562,11 @@ declare const ProposalFindingSchema: z.ZodObject<{
       planned: z.ZodNullable<z.ZodBoolean>;
       evidence_ref: z.ZodObject<{
         kind: z.ZodEnum<{
-          artifact: "artifact";
           event: "event";
+          span: "span";
+          artifact: "artifact";
           finding: "finding";
           metric: "metric";
-          span: "span";
         }>;
         uri: z.ZodString;
         excerpt: z.ZodOptional<z.ZodString>;
@@ -583,8 +574,8 @@ declare const ProposalFindingSchema: z.ZodObject<{
     }, z.core.$strict>>>;
   }, z.core.$strict>>>;
   proposal_origin: z.ZodEnum<{
-    production: "production";
     search: "search";
+    production: "production";
   }>;
 }, z.core.$strict>;
 type FindingParseOutcome = {
@@ -627,8 +618,6 @@ declare function readFindingScope(finding: AnalystFinding): FindingScopeReading;
 declare function lineageRoots(units: ReadonlyArray<FindingEvidenceUnit>): Map<string, string>;
 /** Units with distinct lineage roots. */
 declare function independentUnitCount(units: ReadonlyArray<FindingEvidenceUnit>): number;
-//#endregion
-//#region src/analyst/types.d.ts
 /**
  * Unified envelope every analyst emits. Schema-versioned so renderers
  * and time-series diffs survive future field additions.
@@ -705,11 +694,11 @@ interface AnalystFinding {
   conditions?: FindingConditions[];
 }
 /** Every finding schema this package reads. Writers emit 1.1.0 only when a 1.1.0 field is set. */
-declare const ANALYST_FINDING_SCHEMA_VERSIONS: readonly ['1.0.0', '1.1.0'];
+declare const ANALYST_FINDING_SCHEMA_VERSIONS: readonly ["1.0.0", "1.1.0"];
 type AnalystFindingSchemaVersion = (typeof ANALYST_FINDING_SCHEMA_VERSIONS)[number];
 /** Finding severity. `AnalystSeverity` derives from this array, so the type
  *  and the schema that validates a finding cannot name different levels. */
-declare const ANALYST_SEVERITIES: readonly ['critical', 'high', 'medium', 'low', 'info'];
+declare const ANALYST_SEVERITIES: readonly ["critical", "high", "medium", "low", "info"];
 type AnalystSeverity = (typeof ANALYST_SEVERITIES)[number];
 /** Data sources that candidate generation may intentionally learn from. */
 type ProposalFindingOrigin = 'search' | 'production';
@@ -1006,6 +995,5 @@ type AnalystRunEvent = {
   type: 'run-completed';
   result: AnalystRunResult;
 };
-//#endregion
 export { QueryTracesPage as $, FindingReaderLabel as A, TREATMENT_LAYERS as B, FINDING_LAYERS as C, FindingMeasure as D, FindingLayer as E, lineageRoots as F, ReadSpanSourceResult as G, createBoundedTraceAnalysisStore as H, parseAnalystFinding as I, TraceAnalysisStore as J, SpanSourceReader as K, readFindingScope as L, FindingScopeReading as M, ProposalFindingSchema as N, FindingMethod as O, independentUnitCount as P, ErrorCluster as Q, FindingConditions as R, makeProposalFinding as S, FindingEvidenceUnit as T, BoundedTraceAnalysisStoreOptions as U, TreatmentLayer as V, ReadSpanSourceInput as W, DEFAULT_TRACE_ANALYST_BUDGETS as X, TraceAnalysisStoreContext as Y, DatasetOverview as Z, ExecutionProbeRequest as _, AnalystFindingSchemaVersion as a, TraceAnalystSpan as at, computeFindingId as b, AnalystRunEvent as c, TraceAnalystTraceSummary as ct, AnalystRunSummary as d, ViewTraceResult as dt, SearchSpanResult as et, AnalystSeverity as f, ExecutionProbeOutcome as g, ExecutionProbe as h, AnalystFinding as i, TraceAnalystFilters as it, FindingScope as j, FindingParseOutcome as k, AnalystRunInputs as l, ViewSpansResult as lt, EvidenceRef as m, AnalystContext as n, SpanMatchRecord as nt, AnalystInputKind as o, TraceAnalystSpanKind as ot, AnalystUsageReceipt as p, TRACE_ANALYSIS_LIMITS as q, AnalystCost as r, TraceAnalystByteBudgets as rt, AnalystRequirements as s, TraceAnalystSpanStatus as st, Analyst as t, SearchTraceResult as tt, AnalystRunResult as u, ViewTraceOversized as ut, ProposalFinding as v, FindingCalibration as w, makeFinding as x, ProposalFindingOrigin as y, FindingTreatment as z };
-//# sourceMappingURL=types-6Lfdlshp.d.ts.map
+//# sourceMappingURL=types-DzCO-S1m.d.ts.map

package/dist/types-DzCO-S1m.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DzCO-S1m.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/trace-analyst/store-boundary.ts","../src/analyst/finding-composition.ts","../src/analyst/finding-scope.ts","../src/analyst/types.ts"],"mappings":"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"}

package/dist/{verdict-BGQmxQ8A.js → verdict-C8TcdwfD.js}

@@ -1,5 +1,5 @@
-import { n as contentHash } from "./verdict-cache-CL_7tePD.js";
-//#region src/verdict.ts
+import { n as contentHash } from "./verdict-cache-BVH-fl18.js";
+// src/verdict.ts
 /**
 * Validator-output verdict — substrate primitive for "did this output pass,
 * and how well?"
@@ -55,7 +55,6 @@ function equivalenceVerdict(record) {
 		} } : {}
 	};
 }
-//#endregion
 export { equivalenceVerdict as n, certificationEvidenceDigest as t };
 
-//# sourceMappingURL=verdict-BGQmxQ8A.js.map
+//# sourceMappingURL=verdict-C8TcdwfD.js.map

package/dist/{verdict-BGQmxQ8A.js.map → verdict-C8TcdwfD.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-BGQmxQ8A.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See AGENTS.md \"Dependency and evidence boundaries\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}
+{"version":3,"file":"verdict-C8TcdwfD.js","names":[],"sources":["../src/verdict.ts"],"sourcesContent":["/**\n * Validator-output verdict — substrate primitive for \"did this output pass,\n * and how well?\"\n *\n * Used by:\n *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.\n *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.\n *     Runtime keeps `Validator` because it's coupled to runtime-shaped\n *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE\n *     itself is a substrate concept and lives here.\n *\n * Repo layering: agent-eval is the substrate (no upward deps). Both\n * agent-runtime and agent-knowledge consume this type FROM agent-eval —\n * never the other way around. See AGENTS.md \"Dependency and evidence boundaries\" for the rule.\n */\n\nimport { contentHash } from './verdict-cache'\nimport type {\n  CheckerIdentity,\n  EquivalenceRecord,\n  VerificationStrategySource,\n} from './verification-strategy'\n\n/**\n * What certified a verdict — the epistemics a bare `valid` + `score` pair\n * cannot carry. A kernel-checked proof and an LLM judge can produce the\n * same `{ valid: true, score: 1 }`; this record is what tells them apart.\n *\n * Every field is required on purpose. A certification without a checker\n * identity or an evidence digest is exactly the unverifiable claim this\n * record exists to kill.\n */\nexport interface VerdictCertification {\n  /**\n   * Which verification-strategy member produced the certificate. Each\n   * member's failure mode is documented on the family type and in\n   * `VERIFICATION_STRATEGIES` (src/verification-strategy.ts).\n   */\n  strategy: VerificationStrategySource\n  /**\n   * Exact checker identity, e.g. `{ name: 'lean4', version: '4.33.0',\n   * pins: { mathlib: 'db584cd6d46c' } }` for a kernel, or a judge model\n   * id + snapshot for a judge.\n   */\n  checker: CheckerIdentity\n  /**\n   * Every step the certificate rests on that the checker did NOT verify,\n   * e.g. 'diagonal embedding argued in prose' or 'agreement arms share\n   * training-corpus blind spots'. An empty array is the producer's\n   * explicit, auditable claim that there are none — it is not a default.\n   */\n  assumptions: string[]\n  /** Digest (e.g. sha256) of the evidence artifact the checker consumed or produced. */\n  evidenceDigest: string\n}\n\n/**\n * Minimal verdict shape — `valid` + `score` are required; `scores` +\n * `notes` are optional surface. Validators that need richer shapes\n * parameterise `Validator<Output, MyVerdict>` with their own type.\n *\n * Need structured extras? Extend DefaultVerdict with typed fields — never\n * serialize extras into `notes`.\n */\nexport interface DefaultVerdict {\n  /** Whether the output meets the validator's pass criteria. */\n  valid: boolean\n  /** Aggregate score in [0, 1]. Drivers use this for winner selection. */\n  score: number\n  /** Per-dimension scores. Free-form; weighted into `score` by the validator. */\n  scores?: Record<string, number>\n  /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */\n  notes?: string\n  /**\n   * What certified this verdict, when anything did. Absent = uncertified:\n   * scored, but no strategy vouches for it. A consumer that cares reads\n   * `certification.strategy` to tell a kernel-checked verdict from a\n   * judge-scored one; a consumer that does not read it sees the exact\n   * verdict it always saw.\n   */\n  certification?: VerdictCertification\n}\n\n/**\n * Digest a certification's evidence artifact: sha-256 over the canonical\n * JSON of the evidence AS SERIALIZED. The JSON round-trip drops\n * `undefined`-valued fields on purpose — certified verdicts persist as\n * JSON, so the digest must cover exactly what a reader of the persisted\n * artifact can re-digest, nothing the wire cannot carry. Throws when the\n * evidence has no JSON form at all.\n */\nexport function certificationEvidenceDigest(evidence: unknown): string {\n  const serialized = JSON.stringify(evidence)\n  if (serialized === undefined) {\n    throw new Error(\n      'certificationEvidenceDigest: evidence has no JSON form — a certificate over nothing is the unverifiable claim this record exists to kill',\n    )\n  }\n  return contentHash(JSON.parse(serialized))\n}\n\n/**\n * Land a finished statement-equivalence record in the shared verdict\n * spine. `valid` answers the protocol's question — are the two blind\n * statements equivalent — so a refutation is `valid: false` even though a\n * separating witness in hand is a successful protocol outcome.\n *\n * Certification is present exactly when the obligation was discharged\n * (proved or refuted): the checker vouches for the discharge either way.\n * An unresolved obligation certifies nothing and keeps its reason in\n * `notes`.\n */\nexport function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict {\n  const { obligation, spec, arms } = record\n  const discharged = obligation.status !== 'unresolved'\n  const notes =\n    obligation.status === 'proved'\n      ? `statements equivalent: ${spec.artifact}`\n      : obligation.status === 'refuted-with-separating-witness'\n        ? `formalization gap witnessed: ${obligation.separatingWitness}`\n        : `obligation undischarged: ${obligation.unresolvedReason}`\n  return {\n    valid: obligation.status === 'proved',\n    score: obligation.status === 'proved' ? 1 : 0,\n    notes,\n    ...(discharged && obligation.evidenceDigest !== undefined\n      ? {\n          certification: {\n            strategy: spec.source,\n            checker: obligation.checker,\n            // The arms' blindness declarations are attested by the arms,\n            // never verified by the checker — the one step every\n            // equivalence certificate rests on.\n            assumptions: [\n              `arm '${arms[0].armId}' and arm '${arms[1].armId}' self-declare blind derivation`,\n            ],\n            evidenceDigest: obligation.evidenceDigest,\n          } satisfies VerdictCertification,\n        }\n      : {}),\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,4BAA4B,UAA2B;CACrE,MAAM,aAAa,KAAK,UAAU,QAAQ;CAC1C,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MACR,0IACF;CAEF,OAAO,YAAY,KAAK,MAAM,UAAU,CAAC;AAC3C;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,QAA2C;CAC5E,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,aAAa,WAAW,WAAW;CACzC,MAAM,QACJ,WAAW,WAAW,WAClB,0BAA0B,KAAK,aAC/B,WAAW,WAAW,oCACpB,gCAAgC,WAAW,sBAC3C,4BAA4B,WAAW;CAC/C,OAAO;EACL,OAAO,WAAW,WAAW;EAC7B,OAAO,WAAW,WAAW,WAAW,IAAI;EAC5C;EACA,GAAI,cAAc,WAAW,mBAAmB,KAAA,IAC5C,EACE,eAAe;GACb,UAAU,KAAK;GACf,SAAS,WAAW;GAIpB,aAAa,CACX,QAAQ,KAAK,EAAE,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,MAAM,gCACnD;GACA,gBAAgB,WAAW;EAC7B,EACF,IACA,CAAC;CACP;AACF"}

package/dist/{verdict-C24NELtN.d.ts → verdict-D_qiBQ6_.d.ts}

@@ -1,4 +1,3 @@
-//#region src/verification-strategy.d.ts
 /**
  * Verification-strategy family — the shared vocabulary for "what certified
  * this result", covering tasks with an answer key and tasks without one.
@@ -293,8 +292,6 @@ declare function defineEquivalenceCheck(spec: EquivalenceCheckSpec): Equivalence
  * honest record of an undischarged check.
  */
 declare function runEquivalenceCheck(definition: EquivalenceCheckDefinition, arms: readonly [EquivalenceArm, EquivalenceArm], checker: EquivalenceChecker): Promise<EquivalenceRecord>;
-//#endregion
-//#region src/verdict.d.ts
 /**
  * What certified a verdict — the epistemics a bare `valid` + `score` pair
  * cannot carry. A kernel-checked proof and an LLM judge can produce the
@@ -374,6 +371,5 @@ declare function certificationEvidenceDigest(evidence: unknown): string;
  * `notes`.
  */
 declare function equivalenceVerdict(record: EquivalenceRecord): DefaultVerdict;
-//#endregion
 export { runEquivalenceCheck as C, defineEquivalenceCheck as S, StrategyChecker as _, CheckerIdentity as a, VerificationStrategyProfile as b, EquivalenceCheckDefinition as c, EquivalenceCheckerInput as d, EquivalenceCheckerResult as f, EquivalenceRecord as g, EquivalenceProtocolError as h, equivalenceVerdict as i, EquivalenceCheckSpec as l, EquivalenceObligationStatus as m, VerdictCertification as n, CheckerOutcome as o, EquivalenceObligation as p, certificationEvidenceDigest as r, EquivalenceArm as s, DefaultVerdict as t, EquivalenceChecker as u, VERIFICATION_STRATEGIES as v, VerificationStrategySource as x, VERIFICATION_STRATEGY_SOURCES as y };
-//# sourceMappingURL=verdict-C24NELtN.d.ts.map
+//# sourceMappingURL=verdict-D_qiBQ6_.d.ts.map

package/dist/verdict-D_qiBQ6_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-D_qiBQ6_.d.ts","names":[],"sources":["../src/verification-strategy.ts","../src/verdict.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqEY;;;;;;;;;UAoBK;;EAEf;;EAEA;;;;;;;;cASW,yBAAyB,OACpC,4BACA;;cAkDW,wCAEC;;;;;;UAOG;;EAEf;;EAEA;;;;;EAKA,OAAO;;;;;;;KAQG,eAAe;EACrB;EAAiB,OAAO;;EACxB;EAAkB;;;;;;;;;;;;;UAaP,gBAAgB,OAAO;;EAEtC,UAAU;EACV,UAAU;;EAEV;EACA,MAAM,OAAO,QAAQ,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmC7B;;;;;;EAMf,QAAQ;;;;;;EAMR;;EAEA;;;;;;EAMA;;;UAIe;WACN,MAAM,SAAS;;;UAIT;EACf;;EAEA;;;;;;;EAOA;;;;;;EAMA;;IAEE;;IAEA;;;KAIQ;;;;;;;;;;;;;UAiBK;EACf,QAAQ;;EAER;;EAEA;;EAEA,SAAS;;EAET;;;UAIe;EACf,MAAM,SAAS;EACf,gBAAgB,gBAAgB;EAChC,YAAY;;;UAIG;EACf;EACA;;;;;;;;UASe;EACf;;EAEA;EACA;;;KAIU,qBAAqB,gBAAgB,yBAAyB;;cAG7D,iCAAiC;WACnC;EAeG,YAAA,MAAM,kCAAkC;;;;;;;;;iBActC,uBAAuB,MAAM,uBAAuB;;;;;;;;;;;;;;iBAmE9C,oBACpB,YAAY,4BACZ,gBAAgB,gBAAgB,iBAChC,SAAS,qBACR,QAAQ;;;;;;;;;;UCjaM;;;;;;EAMf,UAAU;;;;;;EAMV,SAAS;;;;;;;EAOT;;EAEA;;;;;;;;;;UAWe;;EAEf;;EAEA;;EAEA,SAAS;;EAET;;;;;;;;EAQA,gBAAgB;;;;;;;;;;iBAWF,4BAA4B;;;;;;;;;;;;iBAqB5B,mBAAmB,QAAQ,oBAAoB"}

package/dist/{verdict-cache-CL_7tePD.js → verdict-cache-BVH-fl18.js}

@@ -1,6 +1,6 @@
-import { a as hashCanonical, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
+import { a as hashCanonical, r as canonicalString } from "./canonical-CicJlINA.js";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
-//#region src/verdict-cache.ts
+// src/verdict-cache.ts
 /**
 * Content-addressed judge-verdict caching.
 *
@@ -82,7 +82,6 @@ function fileVerdictCache(path) {
 		}
 	};
 }
-//#endregion
 export { contentHash as n, fileVerdictCache as r, canonicalJson as t };
 
-//# sourceMappingURL=verdict-cache-CL_7tePD.js.map
+//# sourceMappingURL=verdict-cache-BVH-fl18.js.map

package/dist/{verdict-cache-CL_7tePD.js.map → verdict-cache-BVH-fl18.js.map}

@@ -1 +1 @@
-{"version":3,"file":"verdict-cache-CL_7tePD.js","names":[],"sources":["../src/verdict-cache.ts"],"sourcesContent":["/**\n * Content-addressed judge-verdict caching.\n *\n * LAW: cache JUDGE VERDICTS only — judging the same artifact with the same\n * judge+rubric is pure. NEVER cache agent rollouts. (A router that cached\n * identical fanout prompts silently destroyed best-of-N diversity; rollout\n * caching reintroduces that failure class. Judging has no diversity to\n * destroy — same artifact + same rubric ⇒ same verdict is the desired\n * property, not a bug.)\n *\n * The cache key is `v2:` + a sha-256 over the canonical JSON of everything\n * that can change a verdict: the artifact content, the scenario id, the judge\n * name, the full dimension list (key + description — the description IS the\n * rubric text shown to the judge), and a caller-supplied `judgeVersion`.\n * `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes\n * without a version bump would otherwise silently serve stale verdicts.\n * The `v2:` prefix names the key scheme; a store written under another scheme\n * misses once and repopulates.\n *\n * Canonical JSON is RFC 8785 from `ledger-core/canonical` — the package's one\n * identity scheme. It refuses `undefined`, functions, symbols, non-finite\n * numbers, class instances (including `Date`), `Map`, `Set`, cycles, and\n * unpaired surrogates: an artifact that cannot be unambiguously serialized\n * cannot be content-addressed, and coercing it would let two different\n * artifacts collide on one key. Pass timestamps as ISO strings.\n */\n\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeScore } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n\n\n/**\n * Canonical JSON (RFC 8785): object keys sorted recursively, so two\n * semantically equal values produce byte-identical output regardless of key\n * insertion order. Throws `LedgerCanonicalizationError` on any value with no\n * faithful JSON form — see `ledger-core/canonical`.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalString(value)\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. Equals `hashCanonical(value)` with\n *  the `sha256:` prefix removed. */\nexport function contentHash(value: unknown): string {\n  return hashCanonical(value).slice('sha256:'.length)\n}\n\n// ── store contract ─────────────────────────────────────────────────────────\n\n/** Pluggable verdict store. Sync or async on both legs — `cachedJudge`\n *  awaits the results either way. */\nexport interface VerdictCacheStore {\n  get(key: string): Promise<JudgeScore | undefined> | JudgeScore | undefined\n  set(key: string, score: JudgeScore): Promise<void> | void\n}\n\n\n\ninterface VerdictCacheLine {\n  key: string\n  score: JudgeScore\n}\n\nfunction parseCacheLine(line: string, path: string, lineNo: number): VerdictCacheLine {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(line)\n  } catch (err) {\n    throw new Error(\n      `fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n  const rec = parsed as Partial<VerdictCacheLine>\n  if (\n    typeof rec !== 'object' ||\n    rec === null ||\n    typeof rec.key !== 'string' ||\n    typeof rec.score !== 'object' ||\n    rec.score === null ||\n    typeof rec.score.composite !== 'number' ||\n    typeof rec.score.dimensions !== 'object'\n  ) {\n    throw new Error(\n      `fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`,\n    )\n  }\n  return rec as VerdictCacheLine\n}\n\n/**\n * JSONL-file-backed store: the full file is loaded into an in-memory index at\n * construction; every `set` appends one line synchronously (durable before\n * the verdict is returned). A corrupt or malformed line throws at load with\n * file:line — a skipped line would silently re-judge (cost) or, worse, mask\n * a half-written file that needs operator attention.\n */\nexport function fileVerdictCache(path: string): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  if (existsSync(path)) {\n    const lines = readFileSync(path, 'utf8').split('\\n')\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i]\n      if (line === undefined || line.trim() === '') continue\n      const rec = parseCacheLine(line, path, i + 1)\n      entries.set(rec.key, rec.score)\n    }\n  }\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      appendFileSync(path, `${JSON.stringify({ key, score })}\\n`, 'utf8')\n      entries.set(key, score)\n    },\n  }\n}\n\n// ── cached judge wrapper ───────────────────────────────────────────────────\n\n\n\n\n\n\n\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AAkBA,SAAS,eAAe,MAAc,MAAc,QAAkC;CACpF,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,IAAI;CAC1B,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,sCAAsC,KAAK,GAAG,OAAO,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAC3G;CACF;CACA,MAAM,MAAM;CACZ,IACE,OAAO,QAAQ,YACf,QAAQ,QACR,OAAO,IAAI,QAAQ,YACnB,OAAO,IAAI,UAAU,YACrB,IAAI,UAAU,QACd,OAAO,IAAI,MAAM,cAAc,YAC/B,OAAO,IAAI,MAAM,eAAe,UAEhC,MAAM,IAAI,MACR,6CAA6C,KAAK,GAAG,OAAO,wDAC9D;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,iBAAiB,MAAiC;CAChE,MAAM,0BAAU,IAAI,IAAwB;CAC5C,IAAI,WAAW,IAAI,GAAG;EACpB,MAAM,QAAQ,aAAa,MAAM,MAAM,CAAC,CAAC,MAAM,IAAI;EACnD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,SAAS,KAAA,KAAa,KAAK,KAAK,MAAM,IAAI;GAC9C,MAAM,MAAM,eAAe,MAAM,MAAM,IAAI,CAAC;GAC5C,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;EAChC;CACF;CACA,OAAO;EACL,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,MAAM,KAAK,UAAU;GACnB,eAAe,MAAM,GAAG,KAAK,UAAU;IAAE;IAAK;GAAM,CAAC,EAAE,KAAK,MAAM;GAClE,QAAQ,IAAI,KAAK,KAAK;EACxB;CACF;AACF"}
+{"version":3,"file":"verdict-cache-BVH-fl18.js","names":[],"sources":["../src/verdict-cache.ts"],"sourcesContent":["/**\n * Content-addressed judge-verdict caching.\n *\n * LAW: cache JUDGE VERDICTS only — judging the same artifact with the same\n * judge+rubric is pure. NEVER cache agent rollouts. (A router that cached\n * identical fanout prompts silently destroyed best-of-N diversity; rollout\n * caching reintroduces that failure class. Judging has no diversity to\n * destroy — same artifact + same rubric ⇒ same verdict is the desired\n * property, not a bug.)\n *\n * The cache key is `v2:` + a sha-256 over the canonical JSON of everything\n * that can change a verdict: the artifact content, the scenario id, the judge\n * name, the full dimension list (key + description — the description IS the\n * rubric text shown to the judge), and a caller-supplied `judgeVersion`.\n * `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes\n * without a version bump would otherwise silently serve stale verdicts.\n * The `v2:` prefix names the key scheme; a store written under another scheme\n * misses once and repopulates.\n *\n * Canonical JSON is RFC 8785 from `ledger-core/canonical` — the package's one\n * identity scheme. It refuses `undefined`, functions, symbols, non-finite\n * numbers, class instances (including `Date`), `Map`, `Set`, cycles, and\n * unpaired surrogates: an artifact that cannot be unambiguously serialized\n * cannot be content-addressed, and coercing it would let two different\n * artifacts collide on one key. Pass timestamps as ISO strings.\n */\n\nimport { appendFileSync, existsSync, readFileSync } from 'node:fs'\nimport type { JudgeScore } from './campaign/types'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\n// ── canonical JSON + content hash ─────────────────────────────────────────\n\n\n\n/**\n * Canonical JSON (RFC 8785): object keys sorted recursively, so two\n * semantically equal values produce byte-identical output regardless of key\n * insertion order. Throws `LedgerCanonicalizationError` on any value with no\n * faithful JSON form — see `ledger-core/canonical`.\n */\nexport function canonicalJson(value: unknown): string {\n  return canonicalString(value)\n}\n\n/** Hex sha-256 over `canonicalJson(value)`. The content address used by the\n *  verdict cache and report attestation. Equals `hashCanonical(value)` with\n *  the `sha256:` prefix removed. */\nexport function contentHash(value: unknown): string {\n  return hashCanonical(value).slice('sha256:'.length)\n}\n\n// ── store contract ─────────────────────────────────────────────────────────\n\n/** Pluggable verdict store. Sync or async on both legs — `cachedJudge`\n *  awaits the results either way. */\nexport interface VerdictCacheStore {\n  get(key: string): Promise<JudgeScore | undefined> | JudgeScore | undefined\n  set(key: string, score: JudgeScore): Promise<void> | void\n}\n\n\n\ninterface VerdictCacheLine {\n  key: string\n  score: JudgeScore\n}\n\nfunction parseCacheLine(line: string, path: string, lineNo: number): VerdictCacheLine {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(line)\n  } catch (err) {\n    throw new Error(\n      `fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`,\n    )\n  }\n  const rec = parsed as Partial<VerdictCacheLine>\n  if (\n    typeof rec !== 'object' ||\n    rec === null ||\n    typeof rec.key !== 'string' ||\n    typeof rec.score !== 'object' ||\n    rec.score === null ||\n    typeof rec.score.composite !== 'number' ||\n    typeof rec.score.dimensions !== 'object'\n  ) {\n    throw new Error(\n      `fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`,\n    )\n  }\n  return rec as VerdictCacheLine\n}\n\n/**\n * JSONL-file-backed store: the full file is loaded into an in-memory index at\n * construction; every `set` appends one line synchronously (durable before\n * the verdict is returned). A corrupt or malformed line throws at load with\n * file:line — a skipped line would silently re-judge (cost) or, worse, mask\n * a half-written file that needs operator attention.\n */\nexport function fileVerdictCache(path: string): VerdictCacheStore {\n  const entries = new Map<string, JudgeScore>()\n  if (existsSync(path)) {\n    const lines = readFileSync(path, 'utf8').split('\\n')\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i]\n      if (line === undefined || line.trim() === '') continue\n      const rec = parseCacheLine(line, path, i + 1)\n      entries.set(rec.key, rec.score)\n    }\n  }\n  return {\n    get: (key) => entries.get(key),\n    set: (key, score) => {\n      appendFileSync(path, `${JSON.stringify({ key, score })}\\n`, 'utf8')\n      entries.set(key, score)\n    },\n  }\n}\n\n// ── cached judge wrapper ───────────────────────────────────────────────────\n\n\n\n\n\n\n\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK;AAC9B;;;;AAKA,SAAgB,YAAY,OAAwB;CAClD,OAAO,cAAc,KAAK,CAAC,CAAC,MAAM,CAAgB;AACpD;AAkBA,SAAS,eAAe,MAAc,MAAc,QAAkC;CACpF,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,IAAI;CAC1B,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,sCAAsC,KAAK,GAAG,OAAO,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAC3G;CACF;CACA,MAAM,MAAM;CACZ,IACE,OAAO,QAAQ,YACf,QAAQ,QACR,OAAO,IAAI,QAAQ,YACnB,OAAO,IAAI,UAAU,YACrB,IAAI,UAAU,QACd,OAAO,IAAI,MAAM,cAAc,YAC/B,OAAO,IAAI,MAAM,eAAe,UAEhC,MAAM,IAAI,MACR,6CAA6C,KAAK,GAAG,OAAO,wDAC9D;CAEF,OAAO;AACT;;;;;;;;AASA,SAAgB,iBAAiB,MAAiC;CAChE,MAAM,0BAAU,IAAI,IAAwB;CAC5C,IAAI,WAAW,IAAI,GAAG;EACpB,MAAM,QAAQ,aAAa,MAAM,MAAM,CAAC,CAAC,MAAM,IAAI;EACnD,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,SAAS,KAAA,KAAa,KAAK,KAAK,MAAM,IAAI;GAC9C,MAAM,MAAM,eAAe,MAAM,MAAM,IAAI,CAAC;GAC5C,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;EAChC;CACF;CACA,OAAO;EACL,MAAM,QAAQ,QAAQ,IAAI,GAAG;EAC7B,MAAM,KAAK,UAAU;GACnB,eAAe,MAAM,GAAG,KAAK,UAAU;IAAE;IAAK;GAAM,CAAC,EAAE,KAAK,MAAM;GAClE,QAAQ,IAAI,KAAK,KAAK;EACxB;CACF;AACF"}