@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/pre-registration.d.ts

@@ -1,125 +0,0 @@
-/**
- * Pre-registered hypotheses — declare what you're testing BEFORE the
- * run, check it AFTER. Prevents p-hacking, optional stopping, and the
- * "we ran until it looked good" failure mode.
- *
- * Manifest is a plain JSON-friendly object. Sign it with a content hash
- * + timestamp; the registered record becomes immutable. Post-run,
- * evaluate the manifest against observed results — the library refuses
- * to let you re-interpret a different metric as the declared one.
- */
-export interface HypothesisManifest {
-    id: string;
-    /** Human prose — goes into the audit trail. */
-    hypothesis: string;
-    /** Metric the hypothesis claims to move. */
-    metric: string;
-    /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */
-    direction: 'increase' | 'decrease';
-    /** Minimum effect size to count (same units as the metric). */
-    minEffect: number;
-    /** Alpha threshold. */
-    alpha: number;
-    /** Target statistical power at which sample size was pre-computed. */
-    power: number;
-    /** Declared N per arm before running. */
-    preRegisteredN: number;
-    /** ISO8601 timestamp the manifest was registered. */
-    registeredAt: string;
-    /** Optional identifiers to tie into the trace corpus. */
-    baselineLabel?: string;
-    candidateLabel?: string;
-}
-/**
- * Identifier for the hashing scheme used to produce `contentHash`.
- *
- * `'sha256-content'` — sha256 hex over the canonicalized manifest with
- * the `contentHash` and `algo` fields stripped. Held as a string union
- * so future schemes can be added without breaking parsers; SignedManifest
- * values without `algo` deserialize cleanly because the field is optional.
- */
-export type SignedManifestAlgo = 'sha256-content';
-export interface SignedManifest extends HypothesisManifest {
-    /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */
-    contentHash: string;
-    /**
-     * Algorithm string describing how `contentHash` was produced.
-     *
-     * Optional on the type so serialized manifests without it still parse,
-     * but ALWAYS populated by {@link signManifest}. Consumers that want to
-     * enforce a known algorithm should reject manifests where this field
-     * is missing or unrecognized.
-     */
-    algo?: SignedManifestAlgo;
-}
-export interface HypothesisResult {
-    manifest: SignedManifest;
-    observedN: number;
-    observedEffect: number;
-    observedPValue: number;
-    /** True iff the observed effect hits the pre-declared direction with
-     *  magnitude ≥ minEffect AND p < alpha. */
-    confirmed: boolean;
-    /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */
-    rejectionReasons: Array<'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'>;
-    notes?: string;
-}
-/**
- * Deterministic JSON canonicalization — sort object keys recursively.
- *
- * Two semantically-equal objects produce byte-identical canonicalized output;
- * this is what makes a content-hash stable across encoders, key insertion
- * orders, and runtime versions. Exported for any consumer that needs the same
- * canonicalization guarantee outside the manifest-signing path (e.g., signing
- * an artifact bundle, hashing a dataset version, etc.).
- */
-export declare function canonicalize(v: unknown): unknown;
-/**
- * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
- *
- * The same primitive `signManifest` and `verifyManifest` are built on, exposed
- * directly so consumers signing arbitrary structured content (artifact bundles,
- * production packets, dataset manifests, etc.) don't have to re-derive
- * canonicalize+sha256 from scratch.
- *
- * Stable across:
- *   - object key insertion order (canonicalization sorts keys recursively)
- *   - encoder choice (UTF-8 via TextEncoder, fixed)
- *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
- *
- * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,
- * which takes a string input and returns a truncated 12-char prompt id.
- * Use `hashJson` when you mean "canonicalize then hash."
- *
- * @example
- *   const hash = await hashJson({ id: '1', kind: 'spec' })
- *   // 'a3f1...' (64 hex chars)
- */
-export declare function hashJson<T>(obj: T): Promise<string>;
-/**
- * Sign a manifest with a SHA-256 content hash.
- *
- * The hash covers the canonicalized manifest with the `contentHash`
- * and `algo` fields stripped; this lets verifiers re-sign the rest and
- * compare. Returned manifest always carries `algo: 'sha256-content'`
- * so downstream consumers can identify the scheme; manifests without
- * `algo` still verify because it is stripped before hashing on both sides.
- */
-export declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
-/**
- * Verify that a signed manifest has not been tampered with.
- *
- * Strips `contentHash` and `algo` before re-signing so manifests without
- * `algo` verify identically to ones that carry it.
- */
-export declare function verifyManifest(m: SignedManifest): Promise<boolean>;
-/**
- * Evaluate a pre-registered hypothesis against observed results.
- * Mechanical — no re-interpretation permitted.
- */
-export declare function evaluateHypothesis(manifest: SignedManifest, observed: {
-    n: number;
-    effect: number;
-    pValue: number;
-}): Promise<HypothesisResult>;
-//# sourceMappingURL=pre-registration.d.ts.map

package/dist/pre-registration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pre-registration.d.ts","sourceRoot":"","sources":["../src/pre-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAA;IACd,oFAAoF;IACpF,SAAS,EAAE,UAAU,GAAG,UAAU,CAAA;IAClC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAA;IACjB,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAA;IACtB,qDAAqD;IACrD,YAAY,EAAE,MAAM,CAAA;IACpB,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,CAAA;AAEjD,MAAM,WAAW,cAAe,SAAQ,kBAAkB;IACxD,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAA;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,cAAc,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB;+CAC2C;IAC3C,SAAS,EAAE,OAAO,CAAA;IAClB,2EAA2E;IAC3E,gBAAgB,EAAE,KAAK,CACrB,iBAAiB,GAAG,kBAAkB,GAAG,iBAAiB,GAAG,cAAc,CAC5E,CAAA;IACD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAOhD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzD;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAGjF;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAKxE;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtD,OAAO,CAAC,gBAAgB,CAAC,CAkB3B"}

package/dist/prm/builtin-rubrics.d.ts

@@ -1,33 +0,0 @@
-/**
- * Built-in reference rubrics. Consumers combine these with domain
- * rubrics. All are deterministic, rule-based — cheap to run + easy
- * to unit-test. LLM-based rubrics are trivially authored by
- * following the StepRubric contract.
- */
-import type { StepRubric } from './rubric';
-/** Penalize very short or very long assistant outputs. */
-export declare function outputLengthRubric(args?: {
-    minChars?: number;
-    maxChars?: number;
-    weight?: number;
-}): StepRubric;
-/** Reward tool calls that succeeded (status='ok') with an informative result. */
-export declare function toolSuccessRubric(args?: {
-    weight?: number;
-}): StepRubric;
-/** Penalize tool calls that duplicate a prior call with identical args. */
-export declare function toolNonRedundantRubric(args?: {
-    weight?: number;
-}): StepRubric;
-/** Penalize LLM outputs that contain common refusal markers when a refusal
- *  is NOT expected (caller inverts weight for scenarios where refusal IS expected). */
-export declare function nonRefusalRubric(args?: {
-    markers?: RegExp[];
-    weight?: number;
-}): StepRubric;
-/** Reward outputs that invoke the next-step tool the trajectory actually uses
- *  (i.e. the LLM span announced "I will call X" and the following tool span IS X). */
-export declare function toolIntentAlignmentRubric(args?: {
-    weight?: number;
-}): StepRubric;
-//# sourceMappingURL=builtin-rubrics.d.ts.map

package/dist/prm/builtin-rubrics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtin-rubrics.d.ts","sourceRoot":"","sources":["../../src/prm/builtin-rubrics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,0DAA0D;AAC1D,wBAAgB,kBAAkB,CAChC,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GACnE,UAAU,CAqBZ;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAAC,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,UAAU,CAgB5E;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,UAAU,CAsBjF;AAED;uFACuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,UAAU,CAmB/F;AAED;sFACsF;AACtF,wBAAgB,yBAAyB,CAAC,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,UAAU,CAiBpF"}

package/dist/prm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prm/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,cAAc,mBAAmB,CAAA"}

package/dist/prm/inference.d.ts

@@ -1,29 +0,0 @@
-/**
- * Inference-time PRM scoring — pick the best of N candidate trajectories
- * using a trained reward model (or a rule-based PRM as a proxy).
- *
- * The canonical Best-of-N pattern: generate N completions, score each
- * with a PRM, pick the winner. Here the scoring loop is framework-agnostic
- * — supply a TraceStore + PrmGrader + N run IDs → get ranking + winner.
- */
-import type { TraceStore } from '../trace/store';
-import type { PrmGradedTrace, PrmGrader } from './rubric';
-export interface BestOfNResult {
-    winner: PrmGradedTrace;
-    ranked: PrmGradedTrace[];
-    /** Standard deviation of aggregate scores — small = candidates were homogenous. */
-    stdDev: number;
-}
-export interface PrmBestOfNOptions {
-    /** Max concurrent `grader.grade` calls. Default 4. */
-    concurrency?: number;
-}
-export declare function prmBestOfN(store: TraceStore, grader: PrmGrader, runIds: string[], options?: PrmBestOfNOptions): Promise<BestOfNResult>;
-/**
- * Weighted vote across multiple graders — use when you want a PRM ensemble
- * (e.g. rule-based + LLM-based + trained model). Each grader produces its
- * own ranking; we aggregate via rank-sum (Borda count) so no single grader
- * dominates via a different score scale.
- */
-export declare function prmEnsembleBestOfN(store: TraceStore, graders: PrmGrader[], runIds: string[], options?: PrmBestOfNOptions): Promise<BestOfNResult>;
-//# sourceMappingURL=inference.d.ts.map

package/dist/prm/inference.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/prm/inference.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAA;CACf;AAMD,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wBAAsB,UAAU,CAC9B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAiBxB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,SAAS,EAAE,EACpB,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAwExB"}

package/dist/prm/inference.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=inference.test.d.ts.map

package/dist/prm/inference.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inference.test.d.ts","sourceRoot":"","sources":["../../src/prm/inference.test.ts"],"names":[],"mappings":""}

package/dist/prm/rubric.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rubric.d.ts","sourceRoot":"","sources":["../../src/prm/rubric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAmB,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAErF,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,UAAU,CAAA;IACtB,IAAI,EAAE,cAAc,CAAA;IACpB,kDAAkD;IAClD,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,8BAA8B;IAC9B,IAAI,EAAE,cAAc,EAAE,CAAA;CACvB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,sDAAsD;IACtD,KAAK,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;4DACwD;IACxD,KAAK,EAAE,CACL,GAAG,EAAE,WAAW,KACb,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;CAC9E;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAA;IACtB,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAA;IACnB,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,qBAAa,SAAS;IACR,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,UAAU,EAAE;IAIzC;;;;OAIG;IACG,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;CAgDvE;AAED;uEACuE;AACvE,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAExD"}

package/dist/prm/training-export.d.ts

@@ -1,38 +0,0 @@
-/**
- * Export PRM-graded traces as training data for downstream reward-model
- * fine-tuning. Canonical format is NDJSON of
- * `{ trajectory_text, step_index, rubric, score }` so a small model can
- * learn to predict step rewards from step context.
- *
- * The framework doesn't train the model — we emit the data; callers
- * plug it into their preferred trainer (TRL, Unsloth, custom).
- */
-import type { Span } from '../trace/schema';
-import type { TraceStore } from '../trace/store';
-import type { PrmGradedTrace } from './rubric';
-export interface PrmTrainingSample {
-    runId: string;
-    spanId: string;
-    rubricId: string;
-    score: number;
-    /** Serialized step context — step + surrounding conversation. */
-    context: {
-        priorTurns: Array<{
-            role: string;
-            content: string;
-        }>;
-        step: {
-            kind: Span['kind'];
-            text: string;
-        };
-    };
-    /** Optional evidence + rationale for auditability. */
-    rationale?: string;
-    evidence?: string;
-}
-export declare function exportTrainingData(store: TraceStore, graded: PrmGradedTrace[], options?: {
-    contextWindow?: number;
-}): Promise<PrmTrainingSample[]>;
-/** NDJSON serialization — write to file or stream directly to a trainer. */
-export declare function toNdjson(samples: PrmTrainingSample[]): string;
-//# sourceMappingURL=training-export.d.ts.map

package/dist/prm/training-export.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"training-export.d.ts","sourceRoot":"","sources":["../../src/prm/training-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9C,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,OAAO,EAAE;QACP,UAAU,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;QACpD,IAAI,EAAE;YAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAC3C,CAAA;IACD,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,cAAc,EAAE,EACxB,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GACvC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA4B9B;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAE7D"}

package/dist/produced-state.d.ts

@@ -1,63 +0,0 @@
-/**
- * Produced-state extraction — normalize a run's runtime event stream into the
- * typed `ProducedState` the completion oracle consumes.
- *
- * `ProducedState` answers "what did the agent actually produce" — vault
- * artifacts, proposals, tool calls. The runtime emits these as a stream of
- * events; this module is the single normalization point from that stream to
- * the shape `verifyCompletion` expects.
- *
- * Input is structurally typed (`RuntimeEventLike`) so this module does not
- * depend on agent-runtime — agent-runtime's `RuntimeStreamEvent` satisfies it
- * structurally. The `content` on `ArtifactEventLike` and the whole
- * `proposal_created` variant are the runtime-side enrichments this contract
- * requires; the runtime emits them, this module consumes them.
- */
-import type { ProducedState } from './completion-verifier';
-/** A tool the agent invoked. */
-export interface ToolCallEventLike {
-    type: 'tool_call';
-    toolName: string;
-}
-/**
- * An artifact the agent produced. `content` is the enriched field — the
- * runtime's base `artifact` event carries only metadata; the completion
- * oracle needs the body to verify the deliverable, so the runtime emits it.
- */
-export interface ArtifactEventLike {
-    type: 'artifact';
-    artifactId: string;
-    name?: string;
-    mimeType?: string;
-    uri?: string;
-    content?: string;
-}
-/** A proposal / filing the agent created. */
-export interface ProposalEventLike {
-    type: 'proposal_created';
-    proposalId: string;
-    title: string;
-    status?: 'pending' | 'approved' | 'rejected';
-    content?: string;
-}
-/**
- * The subset of runtime stream events `extractProducedState` consumes.
- * agent-runtime's full `RuntimeStreamEvent` union satisfies this structurally;
- * the `{ type: string }` catch-all keeps the input permissive so callers can
- * pass the whole unfiltered telemetry stream — unrecognized events are skipped.
- */
-export type RuntimeEventLike = ToolCallEventLike | ArtifactEventLike | ProposalEventLike | {
-    type: string;
-};
-/**
- * Normalize a run's runtime event stream into `ProducedState`.
- *
- * Pure and total — unrecognized event types are skipped. `toolCalls` is
- * deduplicated by name in first-seen order (completion cares about a tool's
- * presence, not its call count). An artifact with neither a name nor a uri
- * still yields an entry keyed by its `artifactId` so it is never silently
- * dropped; an artifact with no `content` yields empty content, which the
- * completion oracle's structural check then rejects on its own.
- */
-export declare function extractProducedState(events: readonly RuntimeEventLike[]): ProducedState;
-//# sourceMappingURL=produced-state.d.ts.map

package/dist/produced-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"produced-state.d.ts","sourceRoot":"","sources":["../src/produced-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAoB,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE5E,gCAAgC;AAChC,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,UAAU,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,kBAAkB,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAA;IAI5C,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AASpB;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,aAAa,CAgCvF"}

package/dist/produced-state.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * extractProducedState is the single normalization point from a run's event
- * stream to the `ProducedState` the completion oracle consumes. These tests
- * pin that mapping — a regression here silently corrupts every completion
- * verdict downstream.
- */
-export {};
-//# sourceMappingURL=produced-state.test.d.ts.map

package/dist/produced-state.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"produced-state.test.d.ts","sourceRoot":"","sources":["../src/produced-state.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/profile/baselines.d.ts

@@ -1,37 +0,0 @@
-/**
- * Strong, generically-useful baseline ROLES — the top zone of an `AgentProfile`
- * before any domain layer. A product composes one of these with its own
- * environment description (its sandbox) and its domain guidance, which lives in
- * the product repo (not here): a profile is `<baseline role> + <environment> +
- * <domain sections>`. Domain strength is NOT generalized into the substrate —
- * it is lifted here only once ≥2 products genuinely reuse it.
- *
- * Three roles cover the common shapes:
- *   - `engineerRole`   — builds + verifies real artifacts in a sandbox. Distilled
- *                        from agent-runtime's `coderProfile` doctrine (minimal
- *                        correct change, run the checks, fix the root cause,
- *                        never weaken a test or hide an error).
- *   - `researcherRole` — gathers from real sources and grounds every claim
- *                        (cite or mark inferred; never fabricate).
- *   - `generalistRole` — a strong default: helpful, grounded, verify-before-assert.
- *
- * All three are verification-first and domain-agnostic. They describe HOW a
- * capable IC operates, not WHAT domain it works in.
- */
-/** Senior-IC engineer operating in a sandbox — produces real artifacts and
- *  verifies them before declaring done. The shared operator foundation for any
- *  file-producing, tool-using product agent. */
-export declare const engineerRole: string;
-/** Researcher who grounds every claim in real sources — gathers, cites, and
- *  distinguishes verified fact from inference. */
-export declare const researcherRole: string;
-/** Strong general-purpose default — helpful, grounded, verifies before asserting. */
-export declare const generalistRole: string;
-/** The named baseline roles, for selection by key (e.g. from a product config). */
-export declare const BASELINE_ROLES: {
-    readonly engineer: string;
-    readonly researcher: string;
-    readonly generalist: string;
-};
-export type BaselineRoleKey = keyof typeof BASELINE_ROLES;
-//# sourceMappingURL=baselines.d.ts.map

package/dist/profile/baselines.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"baselines.d.ts","sourceRoot":"","sources":["../../src/profile/baselines.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;gDAEgD;AAChD,eAAO,MAAM,YAAY,EAAE,MASf,CAAA;AAEZ;kDACkD;AAClD,eAAO,MAAM,cAAc,EAAE,MASjB,CAAA;AAEZ,qFAAqF;AACrF,eAAO,MAAM,cAAc,EAAE,MASjB,CAAA;AAEZ,mFAAmF;AACnF,eAAO,MAAM,cAAc;;;;CAIjB,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,cAAc,CAAA"}

package/dist/profile/index.d.ts

@@ -1,105 +0,0 @@
-/**
- * Structured prompt profile — the system prompt as named, addressable sections
- * instead of one opaque blob. The self-improvement loop targets ONE evolvable
- * `domain` section at a time (via `applyDomainPatch`); the role, environment,
- * tool conventions, and skill roster stay fixed so a candidate diff is
- * attributable to a single section rather than a whole-prompt rewrite.
- *
- * `renderProfile` emits the prompt in a fixed five-zone order — role,
- * Environment, Tool conventions, Skills, Domain guidance — mirroring the layout
- * of Harvey LAB's `harness/system_prompt.md` (workspace root, read-only
- * documents, output dir, skills dir). `profileToSurface` is the bridge to the
- * loop's string `MutableSurface`: a profile renders to exactly the text a
- * candidate is scored on.
- *
- * Distinct from the canonical `AgentProfile` exported by
- * `@tangle-network/agent-interface`. This helper builds prompt content that can
- * be rendered into an agent-interface profile's `prompt.systemPrompt`.
- */
-import { type BaselineRoleKey } from './baselines';
-export { BASELINE_ROLES, type BaselineRoleKey, engineerRole, generalistRole, researcherRole, } from './baselines';
-/** A named, addressable region of the system prompt. `evolvable` marks whether
- *  the self-improvement loop is allowed to patch its body; fixed scaffolding
- *  (e.g. a compliance preamble) sets `evolvable: false`. */
-export interface AgentProfileSection {
-    id: string;
-    title: string;
-    body: string;
-    evolvable: boolean;
-}
-/** A skill the agent can invoke. `triggers` are the phrases/conditions that
- *  should activate it; `scriptsDir` points at its executable scripts when the
- *  skill ships code (mirrors Harvey's `skills/<name>/scripts/`). */
-export interface ProfileSkill {
-    name: string;
-    description: string;
-    triggers: string[];
-    scriptsDir?: string;
-}
-/** The structured system prompt. The first four fields are fixed scaffolding;
- *  `domain` is the evolvable surface the loop optimizes. */
-export interface PromptProfile {
-    role: string;
-    environment: string;
-    toolConventions: string;
-    skills: ProfileSkill[];
-    domain: AgentProfileSection[];
-}
-/**
- * Emit the sectioned system prompt in fixed order: role text, then
- * `## Environment`, `## Tool conventions`, `## Skills` (each skill as
- * `### <name>` + description + triggers), `## Domain guidance` (each section as
- * `### <title>` + body). The order is load-bearing — the loop diffs rendered
- * text, and reordering would make every candidate look like a full rewrite.
- */
-export declare function renderProfile(p: PromptProfile): string;
-/** The string `MutableSurface` the self-improvement loop scores — a profile
- *  renders to exactly the text a candidate is graded on. */
-export declare function profileToSurface(p: PromptProfile): string;
-/**
- * The fixed-scaffolding baseline: a `role`/`environment`/`toolConventions`
- * profile with the stock skill roster and NO domain guidance. The
- * production profile is this plus shipped domain sections.
- */
-export declare function baselineProfile(args: {
-    role: string;
-    environment?: string;
-    toolConventions?: string;
-    skills?: ProfileSkill[];
-}): PromptProfile;
-/**
- * Baseline from one of the strong generic roles (`'engineer' | 'researcher' |
- * 'generalist'`) — the common case: pick a role foundation, optionally override
- * the environment to describe THIS product's sandbox, then layer domain via
- * `prodProfile`. Domain guidance stays in the product repo; this only supplies
- * the generically-useful role + stock scaffolding.
- */
-export declare function baselineProfileFromRole(role: BaselineRoleKey, args?: {
-    environment?: string;
-    toolConventions?: string;
-    skills?: ProfileSkill[];
-}): PromptProfile;
-/** The production profile: the baseline scaffolding plus the domain sections
- *  shipped after self-improvement. Differs from the baseline ONLY in `domain`
- *  (and any skills the caller layered into the baseline) — the role,
- *  environment, and tool conventions are carried through unchanged. */
-export declare function prodProfile(baseline: PromptProfile, shipped: AgentProfileSection[]): PromptProfile;
-/**
- * Section-scoped edit — replace the body of ONE domain section by id, leaving
- * every other section byte-identical. This is how the loop targets a single
- * evolvable surface. Throws on an unknown section id (a patch that hits no
- * section is a silent no-op otherwise — fail loud). Throws when the targeted
- * section is `evolvable: false`.
- */
-export declare function applyDomainPatch(p: PromptProfile, sectionId: string, newBody: string): PromptProfile;
-/**
- * Content hash of a single section — its loop identity. Delegates to the
- * campaign provenance `surfaceContentHash` (the same helper the loop's
- * provenance record uses for full surfaces), so a section hash is byte-for-byte
- * comparable with the `sha256:`-prefixed content hashes that record carries.
- * Two sections that render identically (same title + body) share a hash; the
- * `id` and `evolvable` flag are excluded — they are routing metadata, not
- * content.
- */
-export declare function sectionHash(section: AgentProfileSection): string;
-//# sourceMappingURL=index.d.ts.map

package/dist/profile/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/profile/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAA;AAElE,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,YAAY,EACZ,cAAc,EACd,cAAc,GACf,MAAM,aAAa,CAAA;AAEpB;;4DAE4D;AAC5D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;CACnB;AAED;;oEAEoE;AACpE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;4DAC4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAC9B;AAaD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAetD;AAED;4DAC4D;AAC5D,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAEzD;AAgCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CACxB,GAAG,aAAa,CAQhB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,eAAe,EACrB,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAO,GACrF,aAAa,CAEf;AAED;;;uEAGuE;AACvE,wBAAgB,WAAW,CACzB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,mBAAmB,EAAE,GAC7B,aAAa,CAEf;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,aAAa,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,aAAa,CAmBf;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAEhE"}

package/dist/promotion-gate.d.ts

@@ -1,93 +0,0 @@
-/**
- * Bootstrap-CI promotion gate.
- *
- * In any iterative-improvement loop (GEPA, prompt evolution, dataset
- * curation), the question is "did this generation actually improve, or are
- * we celebrating noise?". With small N and noisy outcomes, point-estimate
- * deltas lie. Bootstrap confidence intervals tell the operator whether the
- * delta is real before code or prompts get promoted.
- *
- * This module is pure functions — no I/O, no model calls. Easy to unit-test
- * and to compose into any verdict gate.
- *
- * Default gate:
- *   - Bootstrap mean baseline vs candidate (1k resamples).
- *   - Compute the delta distribution; pass if the lower CI bound > 0.
- *   - Tunable confidence (default 95%) and resample count.
- *
- * Verdict semantics intentionally match the existing `experiments.jsonl`
- * vocabulary:
- *   - ADVANCE: candidate's CI lower bound > baseline mean (real win)
- *   - KEEP:    overlap, but candidate point estimate >= baseline (neutral)
- *   - REVERT:  candidate's CI upper bound < baseline mean (real regression)
- *   - INCONCLUSIVE: not enough samples or CI straddles zero with no signal
- */
-export type Verdict = 'ADVANCE' | 'KEEP' | 'REVERT' | 'INCONCLUSIVE';
-export interface BootstrapResult {
-    baselineMean: number;
-    candidateMean: number;
-    /** candidateMean - baselineMean, point estimate. */
-    delta: number;
-    /** Lower bound of the (1 - alpha) CI on the delta. */
-    ciLower: number;
-    /** Upper bound of the (1 - alpha) CI on the delta. */
-    ciUpper: number;
-    /** Number of bootstrap resamples used. */
-    iterations: number;
-    alpha: number;
-    verdict: Verdict;
-}
-export interface BootstrapOptions {
-    /** Confidence level alpha (default 0.05 → 95% CI). */
-    alpha?: number;
-    /** Number of resamples (default 1000). */
-    iterations?: number;
-    /**
-     * Minimum total samples (baseline + candidate) below which we always
-     * return INCONCLUSIVE — bootstrap with too few samples is meaningless.
-     * Default 6 (combined).
-     */
-    minTotalSamples?: number;
-    /** RNG seed for reproducibility. Default: Math.random. */
-    seed?: number;
-}
-/**
- * Compute the bootstrap CI on (candidateMean - baselineMean) and a verdict.
- *
- * Uses simple percentile bootstrap on the difference of resampled means.
- * That's the standard non-parametric primitive — no distributional
- * assumptions, robust to skew, easy to reason about.
- */
-export declare function bootstrapCi(baseline: number[], candidate: number[], options?: BootstrapOptions): BootstrapResult;
-/**
- * Judge-replay promotion gate.
- *
- * The cheap inner-loop judge that drives an evolution run is by definition
- * fast and noisy. When you're about to promote a winning variant to the
- * canonical default, you want a STRONGER judge (a more expensive model, a
- * human grader, a separately-trained reward model) to confirm the win
- * generalises beyond the inner loop.
- *
- * This helper takes raw winner + baseline outputs, scores both through the
- * stronger judge, and applies `bootstrapCi`. ADVANCE means the stronger
- * judge agrees the winner is real with the configured confidence. Doesn't
- * matter what shape your "output" is — pass a string, an object, anything
- * the judge can read.
- */
-export interface JudgeReplayGateArgs<TOutput> {
-    baselineOutputs: TOutput[];
-    candidateOutputs: TOutput[];
-    /** Stronger judge — async to allow LLM calls. Return a 0..N scalar score. */
-    judge: (output: TOutput) => Promise<number> | number;
-    alpha?: number;
-    iterations?: number;
-    /** RNG seed for reproducibility. */
-    seed?: number;
-    /** Maximum concurrent judge calls. Default 4. */
-    judgeConcurrency?: number;
-}
-export declare function judgeReplayGate<TOutput>(args: JudgeReplayGateArgs<TOutput>): Promise<BootstrapResult & {
-    baselineSamples: number;
-    candidateSamples: number;
-}>;
-//# sourceMappingURL=promotion-gate.d.ts.map

package/dist/promotion-gate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promotion-gate.d.ts","sourceRoot":"","sources":["../src/promotion-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,cAAc,CAAA;AAEpE,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAA;IACf,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAA;IACf,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CAuDjB;AAyCD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB,CAAC,OAAO;IAC1C,eAAe,EAAE,OAAO,EAAE,CAAA;IAC1B,gBAAgB,EAAE,OAAO,EAAE,CAAA;IAC3B,6EAA6E;IAC7E,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IACpD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,oCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,wBAAsB,eAAe,CAAC,OAAO,EAC3C,IAAI,EAAE,mBAAmB,CAAC,OAAO,CAAC,GACjC,OAAO,CAAC,eAAe,GAAG;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,CAAC,CAclF"}

package/dist/prompt-registry.d.ts

@@ -1,41 +0,0 @@
-/**
- * Versioned prompt registry.
- *
- * Every prompt used in an eval run is registered with an explicit version.
- * Reports include the content hash so A/B compares are rigorous: if the
- * hash changes between two reports, the prompt actually changed; if it
- * matches, the variance is elsewhere.
- *
- * Hash is SHA-256(content), truncated to 12 hex chars for readability.
- * Uses the Web Crypto API (works in Workers, Node 22+, browsers).
- */
-export interface PromptHandle {
-    /** Stable human-readable id, e.g. 'browser.system' */
-    id: string;
-    /** Caller-chosen version string, e.g. 'v3' or '2026-04-20' */
-    version: string;
-    /** SHA-256 of content, 12-hex-char prefix */
-    hash: string;
-    /** Full prompt body */
-    content: string;
-}
-export declare class PromptRegistry {
-    private readonly entries;
-    /**
-     * Register a prompt. Re-registering the same id+version with DIFFERENT
-     * content throws — versions are immutable. Re-registering with the SAME
-     * content is a no-op (idempotent).
-     */
-    register(id: string, version: string, content: string): Promise<PromptHandle>;
-    /** Look up a registered prompt. Throws if unknown — no implicit defaults. */
-    get(id: string, version: string): PromptHandle;
-    /** Return all versions of an id, newest-first (lex-descending on version). */
-    listVersions(id: string): PromptHandle[];
-    /** Snapshot the whole registry — useful for including in reports. */
-    list(): PromptHandle[];
-    /** Verify a hash against registered content. Returns null if not found. */
-    verifyHash(id: string, version: string, expectedHash: string): boolean | null;
-}
-/** SHA-256(content) → first 12 hex chars. Stable across runtimes. */
-export declare function hashContent(content: string): Promise<string>;
-//# sourceMappingURL=prompt-registry.d.ts.map

package/dist/prompt-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-registry.d.ts","sourceRoot":"","sources":["../src/prompt-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,EAAE,EAAE,MAAM,CAAA;IACV,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAA;IACf,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAE1D;;;;OAIG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAoBnF,6EAA6E;IAC7E,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY;IAO9C,8EAA8E;IAC9E,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,EAAE;IAMxC,qEAAqE;IACrE,IAAI,IAAI,YAAY,EAAE;IAItB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;CAK9E;AAED,qEAAqE;AACrE,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOlE"}