@tangle-network/agent-eval 0.95.0 → 0.96.0

package/dist/{series-convergence.d.ts → series-convergence-D5OWMBg6.d.ts}

@@ -11,7 +11,7 @@
  *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving
  *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating
  */
-export interface SeriesConvergenceOptions {
+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%). */
@@ -19,7 +19,7 @@ export interface SeriesConvergenceOptions {
     /** Minimum monotone run length to call drift (default 3). */
     driftRun?: number;
 }
-export interface SeriesConvergenceResult {
+interface SeriesConvergenceResult {
     state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data';
     windowMean: number;
     windowCv: number;
@@ -28,5 +28,6 @@ export interface SeriesConvergenceResult {
     /** True when n ≥ window AND windowCv ≤ stableCv. */
     stable: boolean;
 }
-export declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
-//# sourceMappingURL=series-convergence.d.ts.map
+declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
+
+export { type SeriesConvergenceOptions as S, type SeriesConvergenceResult as a, analyzeSeries as b };

package/dist/sink-fetch-B1Yg4Til.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Fleet telemetry envelope — agent-eval's portable observability shape.
+ *
+ * Designed so any consumer (Node CLI, Cloudflare Worker, Lambda, browser
+ * extension) can emit structured rows describing one unit of work — a page
+ * audit, a tool call, an evolve round, a full agent run — to a central sink.
+ *
+ * The schema is intentionally a strict superset of agent-eval's `Run` shape
+ * so a future TraceStore adapter can promote envelopes into traces without
+ * translation.
+ */
+declare const TELEMETRY_SCHEMA_VERSION = 1;
+/** Discriminator for the unit of work this envelope describes. */
+type TelemetryKind = 'agent-run' | 'design-audit-page' | 'design-audit-run' | 'design-evolve-round' | 'design-evolve-run' | 'gepa-trial' | 'gepa-generation' | 'tool-call' | 'judge-verdict' | 'custom';
+interface TelemetryEnvelope {
+    schemaVersion: typeof TELEMETRY_SCHEMA_VERSION;
+    envelopeId: string;
+    runId: string;
+    timestamp: string;
+    parentRunId?: string;
+    source: TelemetrySource;
+    model?: TelemetryModel;
+    kind: TelemetryKind;
+    ok: boolean;
+    durationMs: number;
+    data: Record<string, unknown>;
+    metrics: Record<string, number>;
+    tags?: Record<string, string>;
+    error?: string;
+}
+interface TelemetrySource {
+    /** Repo identity — basename of cwd plus git remote if discoverable. */
+    repo: string;
+    cwd: string;
+    gitSha?: string;
+    gitBranch?: string;
+    cliVersion: string;
+    /** What was invoked, e.g. `design-audit`, `bad run`, `gepa --target`. */
+    invocation: string;
+    /** Sanitised argv minus secrets. */
+    argv?: string[];
+    /**
+     * Multi-tenant identity. Set when the consumer runs inside a hosted
+     * product so a fleet rollup can group by tenant without leaking customer
+     * URLs or PII.
+     */
+    tenantId?: string;
+    /** Optional sub-tenant identity (project, suite, walkthrough, customer). */
+    customerId?: string;
+    /** SHA-256 (12 hex) of the API key used to authenticate this run, when applicable. */
+    apiKeyHash?: string;
+}
+interface TelemetryModel {
+    provider: string;
+    name: string;
+    /** SHA-256 (12 hex chars) of the prompt(s) used. */
+    promptHash?: string;
+    /** SHA-256 (12 hex chars) of the composed rubric body, if applicable. */
+    rubricHash?: string;
+}
+
+/**
+ * Workers-safe telemetry sinks — only `fetch` and pure JS. No `fs`, no
+ * `child_process`. Safe to import from a Cloudflare Worker, Lambda, edge
+ * function, or browser extension.
+ *
+ * For Node-only file persistence, import from '@tangle-network/agent-eval/telemetry/file'.
+ */
+
+interface TelemetrySink {
+    emit(envelope: TelemetryEnvelope): Promise<void> | void;
+    close?(): Promise<void> | void;
+}
+/** Best-effort POST to a remote collector. Fire-and-forget; never throws. */
+declare class HttpTelemetrySink implements TelemetrySink {
+    private readonly endpoint;
+    private readonly bearer?;
+    private inflight;
+    constructor(endpoint: string, bearer?: string | undefined);
+    emit(envelope: TelemetryEnvelope): void;
+    close(): Promise<void>;
+}
+/** Fanout to multiple sinks — failures in one do not affect others. */
+declare class FanoutTelemetrySink implements TelemetrySink {
+    private readonly sinks;
+    constructor(sinks: TelemetrySink[]);
+    emit(envelope: TelemetryEnvelope): void;
+    close(): Promise<void>;
+}
+/** No-op sink — used when telemetry is explicitly disabled. */
+declare class NullTelemetrySink implements TelemetrySink {
+    emit(): void;
+}
+/** In-memory sink — useful for tests + downstream adapters. */
+declare class InMemoryTelemetrySink implements TelemetrySink {
+    readonly envelopes: TelemetryEnvelope[];
+    emit(envelope: TelemetryEnvelope): void;
+    clear(): void;
+}
+
+export { FanoutTelemetrySink as F, HttpTelemetrySink as H, InMemoryTelemetrySink as I, NullTelemetrySink as N, type TelemetryKind as T, type TelemetryModel as a, type TelemetrySource as b, type TelemetrySink as c, TELEMETRY_SCHEMA_VERSION as d, type TelemetryEnvelope as e };

package/dist/{statistics.d.ts → statistics-CCJpTGOS.d.ts}

@@ -1,15 +1,16 @@
-import { type ContinuousAgreement, type ContinuousAgreementOptions } from './judge-calibration';
-import type { JudgeScore } from './types';
+import { d as ContinuousAgreementOptions, C as ContinuousAgreement } from './judge-calibration-0p2QcWNE.js';
+import { J as JudgeScore } from './types-C7DGg5ex.js';
+
 /** Identity: dimensions already follow "higher = better" by prompt convention
  *  (inverted dims like hallucination are scored 10 = best at the source). */
-export declare const normalizeScores: (scores: JudgeScore[]) => JudgeScore[];
+declare const normalizeScores: (scores: JudgeScore[]) => JudgeScore[];
 /** Weighted mean — falls back to uniform weights when omitted */
-export declare function weightedMean(scores: {
+declare function weightedMean(scores: {
     score: number;
     weight?: number;
 }[]): number;
 /** Bootstrap confidence interval */
-export declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
+declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
     seed?: number;
     resamples?: number;
 }): {
@@ -23,24 +24,24 @@ export declare function confidenceInterval(scores: number[], confidence?: number
  * Each inner array is one judge's scores for all items.
  * All arrays must have the same length (same items scored).
  */
-export declare function interRaterReliability(judgeScores: JudgeScore[][]): number;
+declare function interRaterReliability(judgeScores: JudgeScore[][]): number;
 /**
  * Mann-Whitney U test for comparing two independent groups.
  * Returns U statistic and approximate p-value (normal approximation).
  */
-export declare function mannWhitneyU(a: number[], b: number[]): {
+declare function mannWhitneyU(a: number[], b: number[]): {
     u: number;
     p: number;
 };
 /** Partial credit: returns 0-1 ratio of current toward target */
-export declare function partialCredit(current: number, target: number): number;
+declare function partialCredit(current: number, target: number): number;
 /**
  * Paired t-test — before/after measurements on the SAME items.
  * Pairing removes inter-item variance, giving tighter significance than
  * an unpaired test when comparing prompt v1 vs prompt v2 on identical
  * scenarios.
  */
-export declare function pairedTTest(before: number[], after: number[]): {
+declare function pairedTTest(before: number[], after: number[]): {
     t: number;
     df: number;
     p: number;
@@ -49,7 +50,7 @@ export declare function pairedTTest(before: number[], after: number[]): {
  * Wilcoxon signed-rank test — paired non-parametric alternative.
  * Use when the differences aren't normally distributed.
  */
-export declare function wilcoxonSignedRank(before: number[], after: number[]): {
+declare function wilcoxonSignedRank(before: number[], after: number[]): {
     w: number;
     p: number;
 };
@@ -58,8 +59,8 @@ export declare function wilcoxonSignedRank(before: number[], after: number[]): {
  * Positive d means group b has higher mean than group a.
  * Rule of thumb: |d| < 0.2 negligible, 0.2–0.5 small, 0.5–0.8 medium, > 0.8 large.
  */
-export declare function cohensD(a: number[], b: number[]): number;
-export type CliffsMagnitude = 'negligible' | 'small' | 'medium' | 'large';
+declare function cohensD(a: number[], b: number[]): number;
+type CliffsMagnitude = 'negligible' | 'small' | 'medium' | 'large';
 /**
  * Cliff's delta — a non-parametric effect size for two independent samples.
  * `δ = (#(after > before) − #(after < before)) / (n_before · n_after)`,
@@ -70,14 +71,14 @@ export type CliffsMagnitude = 'negligible' | 'small' | 'medium' | 'large';
  * `pairedBootstrap` / `wilcoxonSignedRank` for the non-parametric reporting
  * path. Returns 0 when either sample is empty.
  */
-export declare function cliffsDelta(before: number[], after: number[]): number;
+declare function cliffsDelta(before: number[], after: number[]): number;
 /**
  * Map a Cliff's delta to a qualitative magnitude using the standard
  * Romano et al. thresholds (|δ|): <0.147 negligible, <0.33 small,
  * <0.474 medium, else large.
  */
-export declare function interpretCliffs(delta: number): CliffsMagnitude;
-export interface WeightedCompositeInput {
+declare function interpretCliffs(delta: number): CliffsMagnitude;
+interface WeightedCompositeInput {
     /** Per-dimension scores (typically 0..1). */
     dims: Record<string, number>;
     /** Weight per dimension. Every weighted dimension MUST be present in
@@ -88,7 +89,7 @@ export interface WeightedCompositeInput {
     /** Optional pass threshold; when set, the result reports `pass`. */
     threshold?: number;
 }
-export interface WeightedCompositeResult {
+interface WeightedCompositeResult {
     composite: number;
     pass?: boolean;
 }
@@ -101,8 +102,8 @@ export interface WeightedCompositeResult {
  * weight is negative, or if the weights sum to 0 — none of which can produce
  * a meaningful composite.
  */
-export declare function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult;
-export interface CorpusScoreRecord {
+declare function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult;
+interface CorpusScoreRecord {
     /** Stable identifier for the rated item (scenario, span, turn, …). */
     itemId: string;
     /** Identifier for the judge that produced this score. */
@@ -112,14 +113,14 @@ export interface CorpusScoreRecord {
     /** Numeric score; must be finite. */
     score: number;
 }
-export interface CorpusAgreementPerDimension extends ContinuousAgreement {
+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[];
 }
-export interface CorpusAgreementReport {
+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). */
@@ -131,7 +132,7 @@ export interface CorpusAgreementReport {
     /** Judges seen across the corpus (sorted). */
     judgeIds: string[];
 }
-export interface CorpusAgreementOptions extends ContinuousAgreementOptions {
+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
@@ -161,7 +162,7 @@ export interface CorpusAgreementOptions extends ContinuousAgreementOptions {
  *     another dimension throws (would silently shrink the matrix).
  *   - Duplicate (itemId, judgeName, dimension) records throw.
  */
-export declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
+declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
 /**
  * Convenience adapter for `JudgeScore[]` data keyed externally by item.
  *
@@ -170,7 +171,7 @@ export declare function corpusInterRaterAgreement(records: CorpusScoreRecord[],
  * agreement without manually flattening. `itemId` must be unique per
  * row of `itemsScores`.
  */
-export declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
+declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
     itemId: string;
     scores: JudgeScore[];
 }>, opts?: CorpusAgreementOptions): CorpusAgreementReport;
@@ -180,7 +181,7 @@ export declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Ar
  *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2
  * where d is Cohen's d. Returns Infinity for effect ≤ 0.
  */
-export declare function requiredSampleSize(opts: {
+declare function requiredSampleSize(opts: {
     effect: number;
     alpha?: number;
     power?: number;
@@ -192,7 +193,7 @@ export declare function requiredSampleSize(opts: {
  * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap
  * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.
  */
-export declare function pairedMde(opts: {
+declare function pairedMde(opts: {
     nPaired: number;
     alpha?: number;
     power?: number;
@@ -212,7 +213,7 @@ export declare function pairedMde(opts: {
  * approximation, treat the result as a lower bound and prefer the discordant-pair
  * floor.
  */
-export declare function mcnemarRequiredN(opts: {
+declare function mcnemarRequiredN(opts: {
     p10: number;
     p01: number;
     alpha?: number;
@@ -224,7 +225,7 @@ export declare function mcnemarRequiredN(opts: {
  * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).
  * Returns a value in [0, 1]; equals `alpha` when there is no effect.
  */
-export declare function mcnemarPower(opts: {
+declare function mcnemarPower(opts: {
     p10: number;
     p01: number;
     nPairs: number;
@@ -232,7 +233,7 @@ export declare function mcnemarPower(opts: {
     twoSided?: boolean;
 }): number;
 /** Bonferroni adjustment: multiply every p-value by the test count, clamp at 1. */
-export declare function bonferroni(pValues: number[], alpha?: number): {
+declare function bonferroni(pValues: number[], alpha?: number): {
     adjusted: number[];
     significant: boolean[];
 };
@@ -240,11 +241,11 @@ export declare function bonferroni(pValues: number[], alpha?: number): {
  * Benjamini–Hochberg false discovery rate. Returns adjusted q-values and
  * significance at the target FDR; handles ties and preserves q monotonicity.
  */
-export declare function benjaminiHochberg(pValues: number[], fdr?: number): {
+declare function benjaminiHochberg(pValues: number[], fdr?: number): {
     qValues: number[];
     significant: boolean[];
 };
-export interface PairedBootstrapResult {
+interface PairedBootstrapResult {
     /** Number of paired observations. */
     n: number;
     /** Median of paired deltas (after − before). */
@@ -260,7 +261,7 @@ export interface PairedBootstrapResult {
     /** Number of bootstrap resamples used. */
     resamples: number;
 }
-export interface PairedBootstrapOptions {
+interface PairedBootstrapOptions {
     /** Confidence level. Default 0.95. */
     confidence?: number;
     /** Bootstrap resample count. Default 2000. */
@@ -276,9 +277,9 @@ export interface PairedBootstrapOptions {
  * lower bound is what the promotion gate checks — `low > threshold` means the
  * gain is real at the confidence level. Throws on unequal sample sizes.
  */
-export declare function pairedBootstrap(before: number[], after: number[], opts?: PairedBootstrapOptions): PairedBootstrapResult;
+declare function pairedBootstrap(before: number[], after: number[], opts?: PairedBootstrapOptions): PairedBootstrapResult;
 /** A binomial proportion estimate with a confidence interval. */
-export interface ProportionInterval {
+interface ProportionInterval {
     /** Point estimate successes / n (0 when n = 0). */
     estimate: number;
     /** Lower bound, clamped to [0, 1]. */
@@ -293,9 +294,9 @@ export interface ProportionInterval {
  * CI — the continuous `confidenceInterval` assumes the wrong distribution for a
  * proportion. `n = 0 ⇒ {0, 0, 0}`.
  */
-export declare function wilson(successes: number, n: number, confidence?: number): ProportionInterval;
+declare function wilson(successes: number, n: number, confidence?: number): ProportionInterval;
 /** Result of a McNemar paired-binary significance test. */
-export interface McNemarResult {
+interface McNemarResult {
     /** Total paired observations. */
     n: number;
     /** Discordant pairs (b + c) — the only ones that carry signal. */
@@ -321,9 +322,9 @@ export interface McNemarResult {
  * reference). Inputs are paired 0/1 (or boolean) arrays, control first to match
  * the module's (before, after) convention. Throws on unequal lengths.
  */
-export declare function mcnemar(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>): McNemarResult;
+declare function mcnemar(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>): McNemarResult;
 /** A paired binary effect size (treatment rate − control rate) with a CI. */
-export interface RiskDifferenceResult {
+interface RiskDifferenceResult {
     /** Total paired observations. */
     n: number;
     /** Discordant pairs: treatment-win count. */
@@ -347,7 +348,7 @@ export interface RiskDifferenceResult {
  * the interval by ignoring the pairing). Inputs are paired 0/1 (or boolean)
  * arrays, control first. Throws on unequal lengths.
  */
-export declare function pairedRiskDifference(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>, confidence?: number): RiskDifferenceResult;
+declare function pairedRiskDifference(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>, confidence?: number): RiskDifferenceResult;
 /**
  * Unbiased pass@k for code generation (Chen et al. 2021, "Evaluating Large
  * Language Models Trained on Code"). Given `n` independent samples for one
@@ -358,8 +359,8 @@ export declare function pairedRiskDifference(control: ArrayLike<number | boolean
  * the suite for the corpus pass@k. Computed in the numerically stable product
  * form. Requires 1 ≤ k ≤ n and 0 ≤ c ≤ n.
  */
-export declare function passAtK(n: number, c: number, k: number): number;
-export interface EProcessOptions {
+declare function passAtK(n: number, c: number, k: number): number;
+interface EProcessOptions {
     /** Type-I error budget. The process decides when wealth ≥ 1/alpha
      *  (Ville's inequality). Default 0.05. */
     alpha?: number;
@@ -372,7 +373,7 @@ export interface EProcessOptions {
      *  A pre-registered minEffect shifts this — see `sequentialPairedGate`. */
     nullMean?: number;
 }
-export interface EProcessStep {
+interface EProcessStep {
     /** Current wealth W_n — the e-value against H0 after n observations. */
     wealth: number;
     /** Observations consumed so far. */
@@ -380,7 +381,7 @@ export interface EProcessStep {
     /** True from the first n where W_n ≥ 1/alpha onward (sticky). */
     decided: boolean;
 }
-export interface EProcessState extends EProcessStep {
+interface EProcessState extends EProcessStep {
     alpha: number;
     maxBet: number;
     nullMean: number;
@@ -389,7 +390,7 @@ export interface EProcessState extends EProcessStep {
     /** Observation count at the first threshold crossing; undefined until decided. */
     decidedAtN?: number;
 }
-export interface EProcess {
+interface EProcess {
     /** Consume one observation x ∈ [0,1]. Throws on non-finite / out-of-range
      *  input — a silent clamp would corrupt the type-I guarantee. */
     update(x: number): EProcessStep;
@@ -422,10 +423,11 @@ export interface EProcess {
  * wealth keeps updating after the crossing (the e-process remains valid), but
  * the decision time is the first crossing.
  */
-export declare function eProcess(opts?: EProcessOptions): EProcess;
+declare function eProcess(opts?: EProcessOptions): EProcess;
 /** Tiny seedable PRNG (mulberry32) — deterministic resampling/shuffling, not
  *  cryptographic. Exported so e-process shuffles and bootstrap resampling
  *  share ONE PRNG implementation; a seed is REQUIRED (unseeded randomness in
  *  gate verdicts is non-reproducible by construction). */
-export declare function mulberry32(seed: number): () => number;
-//# sourceMappingURL=statistics.d.ts.map
+declare function mulberry32(seed: number): () => number;
+
+export { mulberry32 as A, normalizeScores as B, type CorpusAgreementReport as C, pairedMde as D, type EProcessState as E, pairedRiskDifference as F, pairedTTest as G, partialCredit as H, passAtK as I, requiredSampleSize as J, weightedComposite as K, weightedMean as L, type McNemarResult as M, wilson as N, type PairedBootstrapOptions as P, type RiskDifferenceResult as R, type WeightedCompositeInput as W, type PairedBootstrapResult as a, benjaminiHochberg as b, type CliffsMagnitude as c, type CorpusAgreementOptions as d, type CorpusAgreementPerDimension as e, type CorpusScoreRecord as f, type EProcess as g, type EProcessOptions as h, type EProcessStep as i, type ProportionInterval as j, type WeightedCompositeResult as k, bonferroni as l, cliffsDelta as m, cohensD as n, confidenceInterval as o, pairedBootstrap as p, corpusInterRaterAgreement as q, corpusInterRaterAgreementFromJudgeScores as r, eProcess as s, interRaterReliability as t, interpretCliffs as u, mannWhitneyU as v, wilcoxonSignedRank as w, mcnemar as x, mcnemarPower as y, mcnemarRequiredN as z };

package/dist/{trace/store.d.ts → store-BcFXE6LG.d.ts}

@@ -1,16 +1,6 @@
-/**
- * TraceStore — persistence + query over the TraceSchema v1 corpus.
- *
- * Two implementations ship in the core:
- *   - InMemoryTraceStore: dev + tests, fully in-process
- *   - FileSystemTraceStore: NDJSON append-only files per entity, suitable
- *     for long-running CI jobs; rolled over at 32MB
- *
- * Downstream adapters (DuckDB, Langfuse, R2 parquet) implement this same
- * interface — the rest of the framework is storage-agnostic.
- */
-import type { Artifact, BudgetLedgerEntry, EventKind, Run, RunStatus, Span, SpanKind, TraceEvent } from './schema';
-export interface RunFilter {
+import { R as Run, S as Span, a as TraceEvent, A as Artifact, B as BudgetLedgerEntry, f as RunStatus, g as RunLayer, c as SpanKind, E as EventKind } from './schema-m0gsnbt3.js';
+
+interface RunFilter {
     scenarioId?: string;
     variantId?: string;
     status?: RunStatus;
@@ -23,9 +13,9 @@ export interface RunFilter {
     parentRunId?: string;
     projectId?: string;
     chatId?: string;
-    layer?: import('./schema').RunLayer;
+    layer?: RunLayer;
 }
-export interface SpanFilter {
+interface SpanFilter {
     runId?: string;
     parentSpanId?: string;
     kind?: SpanKind;
@@ -35,14 +25,14 @@ export interface SpanFilter {
     since?: number;
     until?: number;
 }
-export interface EventFilter {
+interface EventFilter {
     runId?: string;
     spanId?: string;
     kind?: EventKind;
     since?: number;
     until?: number;
 }
-export interface TraceStore {
+interface TraceStore {
     appendRun(run: Run): Promise<void>;
     updateRun(runId: string, patch: Partial<Run>): Promise<void>;
     appendSpan(span: Span): Promise<void>;
@@ -57,7 +47,7 @@ export interface TraceStore {
     budget(runId: string): Promise<BudgetLedgerEntry[]>;
     artifacts(runId: string): Promise<Artifact[]>;
 }
-export declare class InMemoryTraceStore implements TraceStore {
+declare class InMemoryTraceStore implements TraceStore {
     private runs;
     private allSpans;
     private allEvents;
@@ -77,12 +67,12 @@ export declare class InMemoryTraceStore implements TraceStore {
     budget(runId: string): Promise<BudgetLedgerEntry[]>;
     artifacts(runId: string): Promise<Artifact[]>;
 }
-export interface FileSystemTraceStoreOptions {
+interface FileSystemTraceStoreOptions {
     dir: string;
     /** Roll over NDJSON files when they exceed this size in bytes. Default 32 MB. */
     maxBytes?: number;
 }
-export declare class FileSystemTraceStore implements TraceStore {
+declare class FileSystemTraceStore implements TraceStore {
     private dir;
     private maxBytes;
     /** Lazy in-memory index for queries — populated on first read. */
@@ -122,4 +112,5 @@ export declare class FileSystemTraceStore implements TraceStore {
     budget(runId: string): Promise<BudgetLedgerEntry[]>;
     artifacts(runId: string): Promise<Artifact[]>;
 }
-//# sourceMappingURL=store.d.ts.map
+
+export { type EventFilter as E, FileSystemTraceStore as F, InMemoryTraceStore as I, type RunFilter as R, type SpanFilter as S, type TraceStore as T, type FileSystemTraceStoreOptions as a };