@tangle-network/agent-eval 0.117.1 → 0.118.1

package/dist/sequential-5iSVfzl2.d.ts

@@ -1,139 +0,0 @@
-/**
- * Always-valid sequential evaluation.
- *
- * `researchReport` assumes a single pre-specified analysis. Real
- * consumers run campaigns weekly / nightly / per-PR; each new run silently
- * inflates the false-discovery rate, because the BH-FDR guarantee is for
- * the *first* look, not the 47th. Without time-uniform inference,
- * launch-decision teams either (a) don't peek, which forfeits the cost
- * advantage of stop-when-decisive, or (b) peek and pretend they didn't,
- * which forfeits scientific validity.
- *
- * This module ships **e-value-based confidence sequences** for paired
- * bounded outcomes. The methodology is the predictable plug-in betting
- * martingale of Waudby-Smith & Ramdas (2024) — provably valid at *any*
- * stopping time. Concretely:
- *
- *   For paired deltas D_1, D_2, … ∈ [-c, c] with the null H_0: E[D] ≤ 0,
- *   a betting fraction λ_i is chosen using only D_{1..i-1} (predictable
- *   plug-in), and the running e-value is
- *
- *     E_t = ∏_{i=1}^{t} (1 + λ_i · D_i)
- *
- *   E_t is a non-negative martingale under H_0 with E[E_t] ≤ 1, so by
- *   Ville's inequality, P(∃ t : E_t ≥ 1/α) ≤ α — we can reject the null
- *   at any time without inflating the type-I error.
- *
- * Combined with `runEvalCampaign`, every consumer running rolling
- * campaigns gains the ability to ship the moment evidence is decisive,
- * stop-early on dead-on-arrival variants, and accumulate evidence across
- * partial runs without spending the FDR budget. No new sweep is wasted.
- *
- * References:
- *   - Howard, S. R., Ramdas, A., McAuliffe, J., Sekhon, J. (2021).
- *     Time-uniform, nonparametric, nonasymptotic confidence sequences.
- *     Annals of Statistics, 49(2), 1055–1080.
- *   - Waudby-Smith, I., Ramdas, A. (2024). Estimating means of bounded
- *     random variables by betting. JRSS B, 86(1), 1–27.
- */
-type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent';
-interface PairedEvalueOptions {
-    /**
-     * Bound on |delta|. Default 1 (matching most score scales). Must satisfy
-     * c > 0; deltas outside [-c, c] are clipped with a warning attached to
-     * the return value.
-     */
-    bound?: number;
-    /** Target Type-I error. Default 0.05. */
-    alpha?: number;
-    /**
-     * Region of Practical Equivalence on the *mean* paired delta. When
-     * supplied, the verdict can return `'equivalent'` once the running
-     * confidence sequence on the mean is fully contained in [low, high].
-     */
-    rope?: {
-        low: number;
-        high: number;
-    };
-    /** Initial bet shrinkage (0 < scale ≤ 1). Default 0.5 — empirically robust. */
-    initialBetShrinkage?: number;
-}
-interface PairedEvalueStep {
-    /** 1-indexed observation count. */
-    t: number;
-    delta: number;
-    /** Running e-value E_t = ∏ (1 + λ_i · D_i). */
-    evalue: number;
-    /** Time-uniform p-value at stopping time t. */
-    pValue: number;
-    /** Lower bound of the empirical Bernstein confidence sequence at level 1-α. */
-    csLow: number;
-    csHigh: number;
-    /** Verdict at this stopping time. */
-    decision: SequentialDecision;
-}
-interface PairedEvalueSequence {
-    steps: PairedEvalueStep[];
-    /** The decision at the final step. */
-    finalDecision: SequentialDecision;
-    /** Index (1-based) at which a non-`continue` decision first fired, or null. */
-    decisionFiredAt: number | null;
-    /** True if any deltas were clipped to [-bound, bound]. */
-    clipped: boolean;
-}
-/**
- * Run the paired e-value sequence over an in-order delta stream.
- *
- * Use for *streaming* / interim analyses: pass the deltas you have so
- * far, get the verdict at every prefix length. The decision is
- * monotone-stable in the sense that once `'reject_now'` or `'promote_now'`
- * fires, the verdict at later steps remains decisive (the e-value is a
- * non-negative martingale; once it crosses the threshold, it's crossed).
- */
-declare function pairedEvalueSequence(deltas: number[], opts?: PairedEvalueOptions): PairedEvalueSequence;
-interface InterimReleaseConfidenceInput {
-    /**
-     * One delta series per candidate (paired deltas vs comparator). Order
-     * within a series is the order the campaigns were run.
-     */
-    deltaSeries: Array<{
-        candidateId: string;
-        deltas: number[];
-    }>;
-    alpha?: number;
-    bound?: number;
-    rope?: {
-        low: number;
-        high: number;
-    };
-}
-interface InterimReleaseConfidence {
-    candidates: Array<{
-        candidateId: string;
-        decision: SequentialDecision;
-        decisionFiredAt: number | null;
-        finalEvalue: number;
-        finalPValue: number;
-        pairs: number;
-        csLow: number;
-        csHigh: number;
-    }>;
-    /**
-     * Campaign-level recommendation: pick the strongest 'promote_now', else
-     * 'continue' if any candidate is still live, else 'reject_now' if every
-     * candidate is dead, else 'equivalent'.
-     */
-    recommendation: {
-        decision: SequentialDecision;
-        candidateId: string | null;
-    };
-}
-/**
- * Run interim sequential analyses across many candidates at once,
- * preserving the time-uniform α guarantee for each candidate's series and
- * synthesising a campaign-level recommendation. Designed to be called on
- * every campaign tick — the recommendation is anytime-valid.
- */
-declare function evaluateInterimReleaseConfidence(input: InterimReleaseConfidenceInput): InterimReleaseConfidence;
-
-export { type InterimReleaseConfidence as I, type PairedEvalueOptions as P, type SequentialDecision as S, type InterimReleaseConfidenceInput as a, type PairedEvalueSequence as b, type PairedEvalueStep as c, evaluateInterimReleaseConfidence as e, pairedEvalueSequence as p };

package/dist/series-convergence-D5OWMBg6.d.ts

@@ -1,33 +0,0 @@
-/**
- * Series convergence — detects whether a sequence of scalar measurements
- * is stabilizing, drifting, or noisy.
- *
- * Lifted from ADC convergence.ts. The per-turn `ConvergenceTracker` is
- * about progress *within* a single run; this module is about drift
- * *across* runs (e.g. "are my nightly eval scores stabilizing?").
- *
- * Three signals:
- *   - stabilized: last K values have low variance (< epsilon) — done
- *   - drifting:   recent trend is monotonic and beyond noise — regressing or improving
- *   - noisy:      neither — keep iterating, but flag as untrustworthy for gating
- */
-interface SeriesConvergenceOptions {
-    /** Window size for "recent" analysis (default 5). */
-    window?: number;
-    /** Coefficient-of-variation threshold below which the window is stabilized (default 0.05 = 5%). */
-    stableCv?: number;
-    /** Minimum monotone run length to call drift (default 3). */
-    driftRun?: number;
-}
-interface SeriesConvergenceResult {
-    state: 'stabilized' | 'drifting-up' | 'drifting-down' | 'noisy' | 'insufficient-data';
-    windowMean: number;
-    windowCv: number;
-    /** Longest monotonic run at the tail of the series (positive for up, negative for down). */
-    tailRun: number;
-    /** True when n ≥ window AND windowCv ≤ stableCv. */
-    stable: boolean;
-}
-declare function analyzeSeries(values: number[], options?: SeriesConvergenceOptions): SeriesConvergenceResult;
-
-export { type SeriesConvergenceOptions as S, type SeriesConvergenceResult as a, analyzeSeries as b };

package/dist/statistics-KUnG73jH.d.ts

@@ -1,494 +0,0 @@
-import { d as ContinuousAgreementOptions, C as ContinuousAgreement } from './judge-calibration-7C-IDmKr.js';
-import { J as JudgeScore } from './types-BkfcQnxV.js';
-
-/** Identity: dimensions already follow "higher = better" by prompt convention
- *  (inverted dims like hallucination are scored 10 = best at the source). */
-declare const normalizeScores: (scores: JudgeScore[]) => JudgeScore[];
-/** Weighted mean — falls back to uniform weights when omitted */
-declare function weightedMean(scores: {
-    score: number;
-    weight?: number;
-}[]): number;
-/** Bootstrap confidence interval */
-declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
-    seed?: number;
-    resamples?: number;
-}): {
-    mean: number;
-    lower: number;
-    upper: number;
-};
-/**
- * Inter-rater reliability — simplified Krippendorff's alpha.
- *
- * Each inner array is one judge's scores for all items.
- * All arrays must have the same length (same items scored).
- */
-declare function interRaterReliability(judgeScores: JudgeScore[][]): number;
-/**
- * Mann-Whitney U test for comparing two independent groups.
- * Returns U statistic and approximate p-value (normal approximation).
- */
-declare function mannWhitneyU(a: number[], b: number[]): {
-    u: number;
-    p: number;
-};
-/** Partial credit: returns 0-1 ratio of current toward target */
-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.
- */
-declare function pairedTTest(before: number[], after: number[]): {
-    t: number;
-    df: number;
-    p: number;
-};
-/**
- * Wilcoxon signed-rank test — paired non-parametric alternative.
- * Use when the differences aren't normally distributed.
- */
-declare function wilcoxonSignedRank(before: number[], after: number[]): {
-    w: number;
-    p: number;
-};
-/**
- * Cohen's d — standardized effect size for two independent groups.
- * 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.
- */
-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)`,
- * ranging [-1, 1]. Positive ⇒ `after` tends to exceed `before` (improvement).
- *
- * Distribution-free counterpart to Cohen's d: no normality assumption, robust
- * to the bounded/skewed score distributions judges produce. Pairs with
- * `pairedBootstrap` / `wilcoxonSignedRank` for the non-parametric reporting
- * path. Returns 0 when either sample is empty.
- */
-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.
- */
-declare function interpretCliffs(delta: number): CliffsMagnitude;
-/**
- * Average-rank-with-ties transform (1-indexed). Tied values receive the mean
- * of the ranks they span, the standard correction for Spearman's ρ.
- */
-declare function ranks(xs: number[]): number[];
-/**
- * Pearson product-moment correlation coefficient r ∈ [-1, 1] between two
- * equal-length series. See the edge-case contract above: NaN for n < 2 or
- * unequal lengths, 1 when both series are constant, 0 when exactly one is.
- */
-declare function pearsonR(a: number[], b: number[]): number;
-/**
- * Spearman's rank correlation ρ — Pearson over the average-rank-with-ties
- * transform of each series. Same edge-case contract as {@link pearsonR}.
- */
-declare function spearmanR(a: number[], b: number[]): number;
-interface WeightedCompositeInput {
-    /** Per-dimension scores (typically 0..1). */
-    dims: Record<string, number>;
-    /** Weight per dimension. Every weighted dimension MUST be present in
-     *  `dims` — a weight for an absent dimension is a config error and throws,
-     *  because silently dropping it would renormalise the composite onto a
-     *  different denominator than intended. */
-    weights: Record<string, number>;
-    /** Optional pass threshold; when set, the result reports `pass`. */
-    threshold?: number;
-}
-interface WeightedCompositeResult {
-    composite: number;
-    pass?: boolean;
-}
-/**
- * Weighted composite over judge dimensions: `Σ(score_d · w_d) / Σ(w_d)` across
- * the weighted dimensions. The canonical replacement for the per-consumer
- * hand-rolled composite math (tax/legal/creative/gtm each ship a copy).
- *
- * Fail-loud: throws if a weighted dimension is missing from `dims`, if any
- * weight is negative, or if the weights sum to 0 — none of which can produce
- * a meaningful composite.
- */
-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. */
-    judgeName: string;
-    /** Dimension name (matches `JudgeScore.dimension`). */
-    dimension: string;
-    /** Numeric score; must be finite. */
-    score: number;
-}
-interface CorpusAgreementPerDimension extends ContinuousAgreement {
-    dimension: string;
-    /** Item IDs that contributed to this dimension's matrix (every judge scored them). */
-    itemIds: string[];
-    /** Judge IDs that contributed to this dimension's matrix. */
-    judgeIds: string[];
-}
-interface CorpusAgreementReport {
-    /** Per-dimension ICC(2,1) + κ_w + Pearson + Spearman + bootstrap CIs. */
-    perDimension: CorpusAgreementPerDimension[];
-    /** Mean ICC across dimensions (NaN if no dimension yielded a finite ICC). */
-    overallIcc: number;
-    /** Mean weighted κ across dimensions (NaN if none finite). */
-    overallWeightedKappa: number;
-    /** Dimensions evaluated (sorted). */
-    dimensions: string[];
-    /** Judges seen across the corpus (sorted). */
-    judgeIds: string[];
-}
-interface CorpusAgreementOptions extends ContinuousAgreementOptions {
-    /**
-     * Restrict the audit to these dimensions. Default = every dimension
-     * that appears in the input. A dimension named here but absent from
-     * the input throws — silent omission would corrupt the overall metric.
-     */
-    dimensions?: string[];
-    /**
-     * Restrict the audit to these judges. Default = every judge that
-     * appears in the input. A judge named here but absent from a
-     * dimension throws (see "fail loud" below).
-     */
-    judges?: string[];
-}
-/**
- * Corpus-wide inter-rater agreement across N items × M judges × D dimensions.
- *
- * For each dimension, builds the [n_items][n_judges] matrix of scores
- * (keeping only items every judge rated on that dimension), then runs
- * `continuousAgreement` to get ICC(2,1), κ_w, Pearson, Spearman, and
- * bootstrap CIs. Reports a pooled mean across dimensions as a single
- * "is this judge panel reliable on this corpus?" number.
- *
- * Fail-loud contract:
- *   - Empty input throws.
- *   - Fewer than 2 judges or fewer than 2 items per dimension throws.
- *   - A judge present in some dimensions but with zero scored items on
- *     another dimension throws (would silently shrink the matrix).
- *   - Duplicate (itemId, judgeName, dimension) records throw.
- */
-declare function corpusInterRaterAgreement(records: CorpusScoreRecord[], opts?: CorpusAgreementOptions): CorpusAgreementReport;
-/**
- * Convenience adapter for `JudgeScore[]` data keyed externally by item.
- *
- * Use when you have per-item arrays of `JudgeScore[]` (e.g. one
- * `ScenarioResult.judgeScores` per scenario) and want corpus-wide
- * agreement without manually flattening. `itemId` must be unique per
- * row of `itemsScores`.
- */
-declare function corpusInterRaterAgreementFromJudgeScores(itemsScores: Array<{
-    itemId: string;
-    scores: JudgeScore[];
-}>, opts?: CorpusAgreementOptions): CorpusAgreementReport;
-/**
- * Required N per arm for a two-sample comparison at target effect size,
- * alpha, and power. Normal-approximation formula:
- *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2
- * where d is Cohen's d. Returns Infinity for effect ≤ 0.
- */
-declare function requiredSampleSize(opts: {
-    effect: number;
-    alpha?: number;
-    power?: number;
-    twoSided?: boolean;
-}): number;
-/**
- * Minimum detectable paired effect (standardised units) for a target paired
- * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by
- * 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.
- */
-declare function pairedMde(opts: {
-    nPaired: number;
-    alpha?: number;
-    power?: number;
-    twoSided?: boolean;
-}): number;
-/**
- * Number of paired observations needed for a McNemar test to reach a target
- * power — the pre-registration companion to {@link mcnemar}. Parametrised by the
- * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and
- * `p01` (P[control wins]); concordant pairs carry no information, so the count
- * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal
- * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect
- * `δ = p10 − p01`,
- *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².
- * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the
- * tiny discordant counts where the exact {@link mcnemar} differs from the normal
- * approximation, treat the result as a lower bound and prefer the discordant-pair
- * floor.
- */
-declare function mcnemarRequiredN(opts: {
-    p10: number;
-    p01: number;
-    alpha?: number;
-    power?: number;
-    twoSided?: boolean;
-}): number;
-/**
- * Power of a McNemar test at a given number of paired observations, the inverse
- * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).
- * Returns a value in [0, 1]; equals `alpha` when there is no effect.
- */
-declare function mcnemarPower(opts: {
-    p10: number;
-    p01: number;
-    nPairs: number;
-    alpha?: number;
-    twoSided?: boolean;
-}): number;
-/** Bonferroni adjustment: multiply every p-value by the test count, clamp at 1. */
-declare function bonferroni(pValues: number[], alpha?: number): {
-    adjusted: number[];
-    significant: boolean[];
-};
-/**
- * Holm step-down family-wise error adjustment.
- *
- * P-values are sorted from smallest to largest, multiplied by their remaining
- * hypothesis count, and made monotonically non-decreasing before being mapped
- * back to input order. This uniformly dominates plain Bonferroni while keeping
- * strong family-wise error control under arbitrary dependence.
- */
-declare function holm(pValues: readonly number[], alpha?: number): {
-    adjusted: number[];
-    significant: boolean[];
-};
-/**
- * Benjamini–Hochberg false discovery rate. Returns adjusted q-values and
- * significance at the target FDR; handles ties and preserves q monotonicity.
- */
-declare function benjaminiHochberg(pValues: number[], fdr?: number): {
-    qValues: number[];
-    significant: boolean[];
-};
-interface PairedBootstrapResult {
-    /** Number of paired observations. */
-    n: number;
-    /** Median of paired deltas (after − before). */
-    median: number;
-    /** Mean of paired deltas. */
-    mean: number;
-    /** Lower bound of the bootstrap CI on the chosen statistic. */
-    low: number;
-    /** Upper bound of the bootstrap CI on the chosen statistic. */
-    high: number;
-    /** Confidence level used (e.g. 0.95). */
-    confidence: number;
-    /** Number of bootstrap resamples used. */
-    resamples: number;
-}
-interface PairedBootstrapOptions {
-    /** Confidence level. Default 0.95. */
-    confidence?: number;
-    /** Bootstrap resample count. Default 2000. */
-    resamples?: number;
-    /** Statistic to bootstrap. Default 'median'. */
-    statistic?: 'median' | 'mean';
-    /** Deterministic seed. If omitted, uses Math.random(). */
-    seed?: number;
-}
-/**
- * Paired bootstrap on (after − before) deltas. Returns a CI on the chosen
- * statistic (median by default); pairs are resampled with replacement. The
- * lower bound is what the promotion gate checks — `low > threshold` means the
- * gain is real at the confidence level. Throws on unequal sample sizes.
- */
-declare function pairedBootstrap(before: number[], after: number[], opts?: PairedBootstrapOptions): PairedBootstrapResult;
-/** Pre-registered direction for a one-sided paired sign test. */
-type SignTestAlternative = 'greater' | 'less';
-/** Exact one-sided sign-test result for paired numeric differences. */
-interface PairedSignTestResult {
-    /** Total supplied differences, including zero ties. */
-    n: number;
-    /** Strictly positive differences. */
-    positive: number;
-    /** Strictly negative differences. */
-    negative: number;
-    /** Zero differences excluded from the binomial test. */
-    ties: number;
-    /** Non-zero differences used by the binomial test. */
-    nNonTies: number;
-    /** Direction of the pre-registered alternative hypothesis. */
-    alternative: SignTestAlternative;
-    /** Exact one-sided p-value under P(positive) = P(negative) = 0.5. */
-    pValue: number;
-}
-/**
- * Exact one-sided sign test over paired differences.
- *
- * Pass `after[i] - before[i]` for each matched item. `alternative = 'greater'`
- * tests whether positive signs are more likely than negative signs and returns
- * `P(Binomial(nNonTies, 0.5) >= positive)`. `alternative = 'less'` treats
- * negative signs as successes instead. With a continuous difference
- * distribution this is the usual directional median test. Exact zero
- * differences are ties and do not enter the binomial denominator. All-tie and
- * empty inputs return p = 1. Every input difference must be finite, and the
- * direction must be chosen explicitly so a caller cannot select it after
- * seeing the signs.
- */
-declare function pairedSignTest(differences: readonly number[], alternative: SignTestAlternative): PairedSignTestResult;
-/** A binomial proportion estimate with a confidence interval. */
-interface ProportionInterval {
-    /** Point estimate successes / n (0 when n = 0). */
-    estimate: number;
-    /** Lower bound, clamped to [0, 1]. */
-    lower: number;
-    /** Upper bound, clamped to [0, 1]. */
-    upper: number;
-}
-/**
- * Wilson score interval for a binomial proportion. Correct at small n and near
- * 0/1, where the normal (Wald) approximation produces bounds outside [0, 1] and
- * understates coverage. Use this for any pass-rate / hit-rate / realness-rate
- * CI — the continuous `confidenceInterval` assumes the wrong distribution for a
- * proportion. `n = 0 ⇒ {0, 0, 0}`.
- */
-declare function wilson(successes: number, n: number, confidence?: number): ProportionInterval;
-/** Result of a McNemar paired-binary significance test. */
-interface McNemarResult {
-    /** Total paired observations. */
-    n: number;
-    /** Discordant pairs (b + c) — the only ones that carry signal. */
-    nDiscordant: number;
-    /** Pairs where treatment succeeded and control failed ("newly correct"). */
-    b: number;
-    /** Pairs where control succeeded and treatment failed ("newly wrong"). */
-    c: number;
-    /** Continuity-corrected chi-square statistic (reference; exact p drives the call). */
-    statistic: number;
-    /** Two-sided p-value. Exact (binomial sign test on discordant pairs). */
-    pValue: number;
-}
-/**
- * McNemar's test for paired binary outcomes — the correct significance test for
- * "does treatment change the success rate vs control on the SAME items". Only
- * discordant pairs (one arm right, the other wrong) carry information; concordant
- * pairs are uninformative, so a paired t-test / two-proportion z-test on the raw
- * rates is wrong here. The p-value is exact: under H0 the b "treatment-wins" are
- * Binomial(b + c, 0.5), so the two-sided p is the doubled binomial tail — correct
- * at the small discordant counts typical of eval runs (no continuity-corrected
- * chi-square approximation needed, though it is returned as `statistic` for
- * reference). Inputs are paired 0/1 (or boolean) arrays, control first to match
- * the module's (before, after) convention. Throws on unequal lengths.
- */
-declare function mcnemar(control: ArrayLike<number | boolean>, treatment: ArrayLike<number | boolean>): McNemarResult;
-/** A paired binary effect size (treatment rate − control rate) with a CI. */
-interface RiskDifferenceResult {
-    /** Total paired observations. */
-    n: number;
-    /** Discordant pairs: treatment-win count. */
-    b: number;
-    /** Discordant pairs: control-win count. */
-    c: number;
-    /** Paired risk difference p(treatment) − p(control) = (b − c) / n. */
-    riskDifference: number;
-    /** Lower bound of the CI, clamped to [-1, 1]. */
-    lower: number;
-    /** Upper bound of the CI, clamped to [-1, 1]. */
-    upper: number;
-    /** Confidence level used. */
-    confidence: number;
-}
-/**
- * Paired risk difference (the effect-size companion to {@link mcnemar}): the
- * change in success rate p(treatment) − p(control) on matched items, which for
- * paired binary data equals (b − c) / n. The CI uses the paired variance from
- * the discordant counts, not the independent-samples formula (which overstates
- * the interval by ignoring the pairing). Inputs are paired 0/1 (or boolean)
- * arrays, control first. Throws on unequal lengths.
- */
-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
- * problem of which `c` pass, the probability that at least one of a random k of
- * them passes is 1 − C(n−c, k) / C(n, k). Estimating pass@k as "did any of the
- * first k pass" is biased high at small n; this is the variance-reduced estimator
- * averaged implicitly over all k-subsets. Average the per-problem values across
- * the suite for the corpus pass@k. Computed in the numerically stable product
- * form. Requires 1 ≤ k ≤ n and 0 ≤ c ≤ n.
- */
-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;
-    /** Truncation bound on the predictable bet λ ∈ [0, maxBet]. Must satisfy
-     *  maxBet < 1/nullMean so every wealth factor stays strictly positive.
-     *  Default 0.5. */
-    maxBet?: number;
-    /** The null boundary m₀ for H0: E[x] ≤ m₀ on x ∈ [0,1]. Default 0.5
-     *  (the paired-delta encoding x = (d+1)/2 maps "no effect" to 1/2).
-     *  A pre-registered minEffect shifts this — see `sequentialPairedGate`. */
-    nullMean?: number;
-}
-interface EProcessStep {
-    /** Current wealth W_n — the e-value against H0 after n observations. */
-    wealth: number;
-    /** Observations consumed so far. */
-    n: number;
-    /** True from the first n where W_n ≥ 1/alpha onward (sticky). */
-    decided: boolean;
-}
-interface EProcessState extends EProcessStep {
-    alpha: number;
-    maxBet: number;
-    nullMean: number;
-    /** The decision boundary 1/alpha. */
-    threshold: number;
-    /** Observation count at the first threshold crossing; undefined until decided. */
-    decidedAtN?: number;
-}
-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;
-    state(): EProcessState;
-}
-/**
- * Betting test-martingale for bounded observations — the e-process core of
- * anytime-valid sequential testing (Waudby-Smith & Ramdas, "Estimating means
- * of bounded random variables by betting", JRSS-B 2024).
- *
- * Observations x_i ∈ [0,1]; H0: E[x] ≤ m₀ (`nullMean`, default 1/2). Wealth
- *
- *   W_t = Π_{i≤t} (1 + λ_i (x_i − m₀)),  W_0 = 1
- *
- * with the truncated GROW-style plug-in bet computed from PRIOR observations:
- *
- *   λ_i = clamp((μ̂_{i−1} − m₀) / (σ̂²_{i−1} + (μ̂_{i−1} − m₀)²), 0, maxBet)
- *
- * where μ̂/σ̂² are the shrunk running estimates μ̂_t = (1/2 + Σx_i)/(t+1),
- * σ̂²_t = (1/4 + Σ(x_i − μ̂_i)²)/(t+1).
- *
- * PREDICTABILITY INVARIANT (load-bearing): λ_i is a function of x_1..x_{i−1}
- * ONLY — it may never see x_i. With λ_i ≥ 0 predictable, each factor has
- * E[1 + λ_i(x_i − m₀) | past] ≤ 1 under H0, so W is a nonnegative
- * supermartingale and Ville's inequality gives P(∃t: W_t ≥ 1/α) ≤ α — the
- * type-I guarantee holds at ANY data-dependent stopping time. λ_1 is always 0
- * (no prior evidence), so the first observation never moves wealth.
- *
- * `decided` latches at the first crossing W_t ≥ 1/α and never un-latches;
- * wealth keeps updating after the crossing (the e-process remains valid), but
- * the decision time is the first crossing.
- */
-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). */
-declare function mulberry32(seed: number): () => number;
-
-export { mcnemarPower as A, mcnemarRequiredN as B, type CorpusAgreementReport as C, mulberry32 as D, type EProcessState as E, normalizeScores as F, pairedMde as G, pairedRiskDifference as H, pairedSignTest as I, pairedTTest as J, partialCredit as K, passAtK as L, type McNemarResult as M, pearsonR as N, ranks as O, type PairedBootstrapOptions as P, requiredSampleSize as Q, type RiskDifferenceResult as R, type SignTestAlternative as S, spearmanR as T, weightedComposite as U, weightedMean as V, type WeightedCompositeInput as W, wilson as X, 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 PairedSignTestResult as j, type ProportionInterval as k, type WeightedCompositeResult as l, bonferroni as m, cliffsDelta as n, cohensD as o, pairedBootstrap as p, confidenceInterval as q, corpusInterRaterAgreement as r, corpusInterRaterAgreementFromJudgeScores as s, eProcess as t, holm as u, interRaterReliability as v, wilcoxonSignedRank as w, interpretCliffs as x, mannWhitneyU as y, mcnemar as z };