@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/statistics-CnnxdpOg.js

@@ -0,0 +1,1437 @@
+import { s as ValidationError } from "./errors-8YnH8WlF.js";
+//#region src/judge-calibration.ts
+/**
+* Judge calibration — measure judge quality against human gold + bias.
+*
+* Workflow:
+*   1. Build a golden set: {itemId, humanScore}[].
+*   2. Run candidate judges; each produces {itemId, score}.
+*   3. `calibrateJudge(golden, candidate)` reports κ + Pearson + MAE.
+*   4. `calibrateJudgeContinuous(golden, candidate)` adds quadratic-weighted
+*      κ over the un-rounded [0,1] scores plus ICC(2,1), Pearson, Spearman,
+*      and bootstrap CIs — use this for fine-grained judges where rounding
+*      to int discards information (e.g. 0.78 vs 0.81 both round to 1 and
+*      look "perfectly agreed" to integer κ).
+*   5. Run bias probes (positional, verbosity, self-preference) to
+*      detect systematic score inflation.
+*   6. For N≥2 judges on the same items, `continuousAgreement(scores)`
+*      reports ICC(2,1) + κ_w + Pearson + Spearman with bootstrap CIs.
+*
+* Returns actionable diagnostics, not a single number. Consumers then
+* decide whether to trust the judge, retrain it, or add a tie-breaker.
+*/
+/**
+* Measure judge quality against human gold labels: computes Cohen's κ, Pearson correlation, and MAE over matched item ids.
+*/
+function calibrateJudge(golden, candidate) {
+	const map = /* @__PURE__ */ new Map();
+	for (const g of golden) map.set(g.itemId, {
+		h: g.humanScore,
+		j: NaN
+	});
+	for (const c of candidate) {
+		const entry = map.get(c.itemId);
+		if (entry) entry.j = c.score;
+	}
+	const common = [...map.values()].filter((v) => Number.isFinite(v.j));
+	const n = common.length;
+	if (n < 2) return {
+		n,
+		pearson: NaN,
+		kappa: NaN,
+		mae: NaN,
+		worstItems: []
+	};
+	const humans = common.map((c) => c.h);
+	const judges = common.map((c) => c.j);
+	return {
+		n,
+		pearson: pearsonR(humans, judges),
+		kappa: weightedKappa(humans.map(Math.round), judges.map(Math.round)),
+		mae: common.map((c) => Math.abs(c.j - c.h)).reduce((a, b) => a + b, 0) / n,
+		worstItems: [...map.entries()].filter(([, v]) => Number.isFinite(v.j)).map(([itemId, v]) => ({
+			itemId,
+			judge: v.j,
+			human: v.h,
+			delta: Math.abs(v.j - v.h)
+		})).sort((a, b) => b.delta - a.delta).slice(0, 5)
+	};
+}
+/**
+* Feed the same items to the judge twice with A/B swapped and pass all
+* results here. Items that don't appear in both positions are ignored.
+*/
+function positionalBias(scores) {
+	const pairs = /* @__PURE__ */ new Map();
+	for (const s of scores) {
+		const slot = pairs.get(s.itemId) ?? {};
+		if (s.positionOfAInput === "first") slot.first = s.score;
+		else if (s.positionOfAInput === "second") slot.second = s.score;
+		pairs.set(s.itemId, slot);
+	}
+	const deltas = [];
+	for (const { first, second } of pairs.values()) if (first !== void 0 && second !== void 0) deltas.push(first - second);
+	if (deltas.length === 0) return {
+		avgDelta: 0,
+		n: 0
+	};
+	return {
+		avgDelta: deltas.reduce((a, b) => a + b, 0) / deltas.length,
+		n: deltas.length
+	};
+}
+function verbosityBias(samples) {
+	const n = samples.length;
+	if (n < 3) return {
+		pearson: NaN,
+		n
+	};
+	return {
+		pearson: pearsonR(samples.map((s) => s.outputLen), samples.map((s) => s.score)),
+		n
+	};
+}
+/**
+* Pass the same scenarios scored with judge-model X grading outputs from
+* model X (in-family) and model Y (out-of-family). Non-zero delta
+* indicates self-preference.
+*/
+function selfPreference(samples) {
+	const inF = samples.filter((s) => s.inFamily).map((s) => s.score);
+	const outF = samples.filter((s) => !s.inFamily).map((s) => s.score);
+	if (inF.length === 0 || outF.length === 0) return {
+		inFamilyMean: 0,
+		outOfFamilyMean: 0,
+		deltaMean: 0,
+		n: 0
+	};
+	const inMean = inF.reduce((a, b) => a + b, 0) / inF.length;
+	const outMean = outF.reduce((a, b) => a + b, 0) / outF.length;
+	return {
+		inFamilyMean: inMean,
+		outOfFamilyMean: outMean,
+		deltaMean: inMean - outMean,
+		n: samples.length
+	};
+}
+/** Quadratic weighted Cohen's κ over bounded integer scores. */
+function weightedKappa(a, b) {
+	if (a.length !== b.length || a.length === 0) return NaN;
+	const min = Math.min(...a, ...b);
+	const K = Math.max(...a, ...b) - min + 1;
+	if (K < 2) return 1;
+	const observed = Array.from({ length: K }, () => new Array(K).fill(0));
+	const rowMarg = new Array(K).fill(0);
+	const colMarg = new Array(K).fill(0);
+	for (let i = 0; i < a.length; i++) {
+		const ai = a[i] - min;
+		const bi = b[i] - min;
+		const row = observed[ai];
+		row[bi] = (row[bi] ?? 0) + 1;
+		rowMarg[ai]++;
+		colMarg[bi]++;
+	}
+	let num = 0;
+	let den = 0;
+	for (let i = 0; i < K; i++) for (let j = 0; j < K; j++) {
+		const w = (i - j) ** 2 / (K - 1) ** 2;
+		const expected = rowMarg[i] * colMarg[j] / a.length;
+		num += w * observed[i][j];
+		den += w * expected;
+	}
+	if (den === 0) return 1;
+	return 1 - num / den;
+}
+/**
+* Inter-rater agreement on continuous (typically [0,1]) scores.
+*
+* `scores` has shape [n_items][n_raters]. Rows with any non-finite entry
+* are dropped. Returns NaN metrics if fewer than 2 raters or 2 complete
+* items remain.
+*/
+function continuousAgreement(scores, opts = {}) {
+	const bootstrap = opts.bootstrap ?? 1e3;
+	const weights = opts.weights ?? "quadratic";
+	const seed = opts.seed ?? 12648430;
+	const ciLevel = opts.ciLevel ?? .95;
+	const matrix = scores.filter((row) => row.length >= 2 && row.every((v) => Number.isFinite(v)));
+	const raters = matrix[0]?.length ?? 0;
+	const clean = matrix.filter((row) => row.length === raters);
+	const nClean = clean.length;
+	if (nClean < 2 || raters < 2) return {
+		weightedKappa: NaN,
+		icc: NaN,
+		pearson: NaN,
+		spearman: NaN,
+		ci: {
+			icc: [NaN, NaN],
+			weightedKappa: [NaN, NaN]
+		},
+		n: nClean,
+		raters
+	};
+	const kappa = continuousWeightedKappa(clean, weights);
+	const icc = icc21(clean);
+	const pearson = avgPairwise(clean, pearsonR);
+	const spearman = avgPairwise(clean, spearmanR);
+	const ciIcc = [NaN, NaN];
+	const ciKappa = [NaN, NaN];
+	if (bootstrap > 0) {
+		const rng = mulberry32$1(seed);
+		const iccs = [];
+		const kappas = [];
+		for (let b = 0; b < bootstrap; b++) {
+			const sample = new Array(nClean);
+			for (let i = 0; i < nClean; i++) sample[i] = clean[Math.floor(rng() * nClean)];
+			const iccB = icc21(sample);
+			const kB = continuousWeightedKappa(sample, weights);
+			if (Number.isFinite(iccB)) iccs.push(iccB);
+			if (Number.isFinite(kB)) kappas.push(kB);
+		}
+		const [lo, hi] = percentileBounds(ciLevel);
+		if (iccs.length > 0) {
+			iccs.sort((a, b) => a - b);
+			ciIcc[0] = quantile(iccs, lo);
+			ciIcc[1] = quantile(iccs, hi);
+		}
+		if (kappas.length > 0) {
+			kappas.sort((a, b) => a - b);
+			ciKappa[0] = quantile(kappas, lo);
+			ciKappa[1] = quantile(kappas, hi);
+		}
+	}
+	return {
+		weightedKappa: kappa,
+		icc,
+		pearson,
+		spearman,
+		ci: {
+			icc: ciIcc,
+			weightedKappa: ciKappa
+		},
+		n: nClean,
+		raters
+	};
+}
+/**
+* Extends `calibrateJudge` with continuous-value agreement metrics while
+* retaining its base calibration summary.
+*/
+function calibrateJudgeContinuous(golden, candidate, opts = {}) {
+	const base = calibrateJudge(golden, candidate);
+	const map = /* @__PURE__ */ new Map();
+	for (const g of golden) map.set(g.itemId, {
+		h: g.humanScore,
+		j: NaN
+	});
+	for (const c of candidate) {
+		const entry = map.get(c.itemId);
+		if (entry) entry.j = c.score;
+	}
+	const rows = [];
+	for (const v of map.values()) if (Number.isFinite(v.j)) rows.push([v.h, v.j]);
+	const agreement = continuousAgreement(rows, opts);
+	return {
+		...base,
+		weightedKappaContinuous: agreement.weightedKappa,
+		icc: agreement.icc,
+		spearman: agreement.spearman,
+		ci: agreement.ci
+	};
+}
+/**
+* Quadratic-weighted κ on continuous scores. With weights w(x,y) = (x-y)^2
+* (or |x-y| for linear) the formula collapses to:
+*
+*   κ_w = 1 − E_obs[w] / E_exp[w]
+*
+* where E_obs averages w over paired (a_i, b_i) and E_exp averages w over
+* the independent product distribution (sum_{i,j} w(a_i, b_j) / n^2).
+* The normalisation by (max-min)^2 in the integer version cancels in the
+* ratio, so we don't need it here. Generalises to N raters by averaging κ_w
+* over all rater pairs (mean pairwise weighted agreement).
+*/
+function continuousWeightedKappa(rows, scheme) {
+	if (rows.length === 0) return NaN;
+	const raters = rows[0].length;
+	if (raters < 2) return NaN;
+	const wFn = scheme === "linear" ? (x, y) => Math.abs(x - y) : (x, y) => (x - y) ** 2;
+	let sum = 0;
+	let pairs = 0;
+	for (let r1 = 0; r1 < raters; r1++) for (let r2 = r1 + 1; r2 < raters; r2++) {
+		const a = rows.map((row) => row[r1]);
+		const b = rows.map((row) => row[r2]);
+		const n = a.length;
+		let obs = 0;
+		for (let i = 0; i < n; i++) obs += wFn(a[i], b[i]);
+		obs /= n;
+		let exp = 0;
+		for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) exp += wFn(a[i], b[j]);
+		exp /= n * n;
+		if (exp === 0) sum += obs === 0 ? 1 : 0;
+		else sum += 1 - obs / exp;
+		pairs++;
+	}
+	return pairs === 0 ? NaN : sum / pairs;
+}
+/**
+* ICC(2,1) — two-way random effects, absolute agreement, single rater.
+*
+*   ICC(2,1) = (MSR − MSE) / (MSR + (k−1)·MSE + k·(MSC − MSE)/n)
+*
+* where MSR = between-rows MS, MSC = between-columns MS, MSE = residual MS,
+* n = rows (items), k = columns (raters).
+*/
+function icc21(rows) {
+	const n = rows.length;
+	if (n < 2) return NaN;
+	const k = rows[0].length;
+	if (k < 2) return NaN;
+	const rowMeans = rows.map((row) => row.reduce((s, v) => s + v, 0) / k);
+	const colMeans = new Array(k).fill(0);
+	for (let j = 0; j < k; j++) {
+		let s = 0;
+		for (let i = 0; i < n; i++) s += rows[i][j];
+		colMeans[j] = s / n;
+	}
+	let grand = 0;
+	for (let i = 0; i < n; i++) grand += rowMeans[i];
+	grand /= n;
+	let ssR = 0;
+	for (let i = 0; i < n; i++) ssR += (rowMeans[i] - grand) ** 2;
+	ssR *= k;
+	let ssC = 0;
+	for (let j = 0; j < k; j++) ssC += (colMeans[j] - grand) ** 2;
+	ssC *= n;
+	let ssT = 0;
+	for (let i = 0; i < n; i++) for (let j = 0; j < k; j++) ssT += (rows[i][j] - grand) ** 2;
+	const ssE = ssT - ssR - ssC;
+	const dfR = n - 1;
+	const dfC = k - 1;
+	const dfE = (n - 1) * (k - 1);
+	const msR = ssR / dfR;
+	const msC = ssC / dfC;
+	const msE = dfE > 0 ? ssE / dfE : 0;
+	const denom = msR + (k - 1) * msE + k * (msC - msE) / n;
+	if (denom === 0) return msR === 0 && msE === 0 ? 1 : 0;
+	return (msR - msE) / denom;
+}
+/** Average pairwise statistic over all rater pairs. */
+function avgPairwise(rows, fn) {
+	const k = rows[0]?.length ?? 0;
+	if (k < 2) return NaN;
+	let sum = 0;
+	let pairs = 0;
+	for (let i = 0; i < k; i++) for (let j = i + 1; j < k; j++) {
+		const r = fn(rows.map((row) => row[i]), rows.map((row) => row[j]));
+		if (Number.isFinite(r)) {
+			sum += r;
+			pairs++;
+		}
+	}
+	return pairs === 0 ? NaN : sum / pairs;
+}
+/** Seeded PRNG — Mulberry32. Deterministic across platforms. */
+function mulberry32$1(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+function percentileBounds(ciLevel) {
+	const tail = (1 - ciLevel) / 2;
+	return [tail, 1 - tail];
+}
+/** Linear-interpolated quantile of a pre-sorted ascending array. */
+function quantile(sorted, q) {
+	if (sorted.length === 0) return NaN;
+	if (sorted.length === 1) return sorted[0];
+	const pos = q * (sorted.length - 1);
+	const lo = Math.floor(pos);
+	const hi = Math.ceil(pos);
+	if (lo === hi) return sorted[lo];
+	const frac = pos - lo;
+	return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+//#endregion
+//#region src/statistics.ts
+/** Identity: dimensions already follow "higher = better" by prompt convention
+*  (inverted dims like hallucination are scored 10 = best at the source). */
+const normalizeScores = (scores) => scores;
+/** Weighted mean — falls back to uniform weights when omitted */
+function weightedMean(scores) {
+	if (scores.length === 0) return 0;
+	let totalWeight = 0;
+	let weightedSum = 0;
+	for (const { score, weight } of scores) {
+		const w = weight ?? 1;
+		weightedSum += score * w;
+		totalWeight += w;
+	}
+	return totalWeight > 0 ? weightedSum / totalWeight : 0;
+}
+/** Bootstrap confidence interval */
+function confidenceInterval(scores, confidence = .95, opts = {}) {
+	if (scores.length === 0) return {
+		mean: 0,
+		lower: 0,
+		upper: 0
+	};
+	if (scores.length === 1) return {
+		mean: scores[0],
+		lower: scores[0],
+		upper: scores[0]
+	};
+	const n = scores.length;
+	const mean = scores.reduce((a, b) => a + b, 0) / n;
+	const B = opts.resamples ?? 1e3;
+	const rng = makeRng(opts.seed);
+	const bootstrapMeans = [];
+	for (let i = 0; i < B; i++) {
+		let sum = 0;
+		for (let j = 0; j < n; j++) sum += scores[Math.floor(rng() * n)];
+		bootstrapMeans.push(sum / n);
+	}
+	bootstrapMeans.sort((a, b) => a - b);
+	const alpha = 1 - confidence;
+	const lowerIdx = Math.floor(alpha / 2 * B);
+	const upperIdx = Math.floor((1 - alpha / 2) * B) - 1;
+	return {
+		mean,
+		lower: bootstrapMeans[lowerIdx],
+		upper: bootstrapMeans[Math.min(upperIdx, B - 1)]
+	};
+}
+/**
+* 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).
+*/
+function interRaterReliability(judgeScores) {
+	if (judgeScores.length < 2) return 1;
+	const dimensionMap = /* @__PURE__ */ new Map();
+	for (const judgeSet of judgeScores) for (const s of judgeSet) {
+		if (!dimensionMap.has(s.dimension)) dimensionMap.set(s.dimension, []);
+		const arr = dimensionMap.get(s.dimension);
+		if (arr.length === 0 || arr[arr.length - 1].length >= judgeScores.length) arr.push([s.score]);
+		else arr[arr.length - 1].push(s.score);
+	}
+	const allValues = [];
+	const pairDiffs = [];
+	for (const items of dimensionMap.values()) for (const ratings of items) {
+		if (ratings.length < 2) continue;
+		for (const v of ratings) allValues.push(v);
+		for (let i = 0; i < ratings.length; i++) for (let j = i + 1; j < ratings.length; j++) pairDiffs.push((ratings[i] - ratings[j]) ** 2);
+	}
+	if (pairDiffs.length === 0 || allValues.length < 2) return 1;
+	const observedDisagreement = pairDiffs.reduce((a, b) => a + b, 0) / pairDiffs.length;
+	let expectedDisagreement = 0;
+	let expectedCount = 0;
+	for (let i = 0; i < allValues.length; i++) for (let j = i + 1; j < allValues.length; j++) {
+		expectedDisagreement += (allValues[i] - allValues[j]) ** 2;
+		expectedCount++;
+	}
+	expectedDisagreement = expectedCount > 0 ? expectedDisagreement / expectedCount : 0;
+	if (expectedDisagreement === 0) return 1;
+	return 1 - observedDisagreement / expectedDisagreement;
+}
+/**
+* Mann-Whitney U test for comparing two independent groups.
+* Returns U statistic and approximate p-value (normal approximation).
+*/
+function mannWhitneyU(a, b) {
+	if (a.length === 0 || b.length === 0) return {
+		u: 0,
+		p: 1
+	};
+	const n1 = a.length;
+	const n2 = b.length;
+	const combined = [...a.map((v) => ({
+		v,
+		group: "a"
+	})), ...b.map((v) => ({
+		v,
+		group: "b"
+	}))].sort((x, y) => x.v - y.v);
+	const ranks = new Array(combined.length);
+	let i = 0;
+	while (i < combined.length) {
+		let j = i;
+		while (j < combined.length && combined[j].v === combined[i].v) j++;
+		const avgRank = (i + 1 + j) / 2;
+		for (let k = i; k < j; k++) ranks[k] = avgRank;
+		i = j;
+	}
+	let r1 = 0;
+	for (let k = 0; k < combined.length; k++) if (combined[k].group === "a") r1 += ranks[k];
+	const u1 = r1 - n1 * (n1 + 1) / 2;
+	const u2 = n1 * n2 - u1;
+	const u = Math.min(u1, u2);
+	const mu = n1 * n2 / 2;
+	const sigma = Math.sqrt(n1 * n2 * (n1 + n2 + 1) / 12);
+	if (sigma === 0) return {
+		u,
+		p: 1
+	};
+	return {
+		u,
+		p: 2 * (1 - normalCdf(Math.abs(u - mu) / sigma))
+	};
+}
+/** Partial credit: returns 0-1 ratio of current toward target */
+function partialCredit(current, target) {
+	if (target <= 0) return 1;
+	return Math.min(1, Math.max(0, current / target));
+}
+/**
+* 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.
+*/
+function pairedTTest(before, after) {
+	if (before.length !== after.length) throw new ValidationError(`pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`);
+	const n = before.length;
+	if (n < 2) return {
+		t: 0,
+		df: 0,
+		p: 1
+	};
+	const diffs = before.map((b, i) => after[i] - b);
+	const mean = diffs.reduce((a, b) => a + b, 0) / n;
+	const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1);
+	const se = Math.sqrt(variance / n);
+	if (se === 0) return {
+		t: mean === 0 ? 0 : Infinity,
+		df: n - 1,
+		p: mean === 0 ? 1 : 0
+	};
+	const t = mean / se;
+	const df = n - 1;
+	return {
+		t,
+		df,
+		p: 2 * (1 - studentTCdf(Math.abs(t), df))
+	};
+}
+/**
+* Wilcoxon signed-rank test — paired non-parametric alternative.
+* Use when the differences aren't normally distributed.
+*/
+function wilcoxonSignedRank(before, after) {
+	if (before.length !== after.length) throw new ValidationError(`wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`);
+	const diffs = before.map((b, i) => after[i] - b).filter((d) => d !== 0);
+	const n = diffs.length;
+	if (n < 6) return {
+		w: 0,
+		p: 1
+	};
+	const absRanks = diffs.map((d, i) => ({
+		abs: Math.abs(d),
+		sign: Math.sign(d),
+		i
+	})).sort((a, b) => a.abs - b.abs);
+	const ranks = new Array(n);
+	let i = 0;
+	while (i < n) {
+		let j = i;
+		while (j < n && absRanks[j].abs === absRanks[i].abs) j++;
+		const avg = (i + 1 + j) / 2;
+		for (let k = i; k < j; k++) ranks[absRanks[k].i] = avg;
+		i = j;
+	}
+	let wPlus = 0;
+	for (let k = 0; k < n; k++) if (diffs[k] > 0) wPlus += ranks[k];
+	const mean = n * (n + 1) / 4;
+	const variance = n * (n + 1) * (2 * n + 1) / 24;
+	const z = (wPlus - mean) / Math.sqrt(variance);
+	const p = 2 * (1 - normalCdf(Math.abs(z)));
+	return {
+		w: wPlus,
+		p
+	};
+}
+/**
+* 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.
+*/
+function cohensD(a, b) {
+	if (a.length < 2 || b.length < 2) return 0;
+	const meanA = a.reduce((x, y) => x + y, 0) / a.length;
+	const meanB = b.reduce((x, y) => x + y, 0) / b.length;
+	const varA = a.reduce((acc, x) => acc + (x - meanA) ** 2, 0) / (a.length - 1);
+	const varB = b.reduce((acc, x) => acc + (x - meanB) ** 2, 0) / (b.length - 1);
+	const pooled = Math.sqrt(((a.length - 1) * varA + (b.length - 1) * varB) / (a.length + b.length - 2));
+	if (pooled === 0) return 0;
+	return (meanB - meanA) / pooled;
+}
+/**
+* Cohen's dz for paired observations: mean(after - before) divided by the
+* sample standard deviation of those within-pair deltas.
+*
+* Returns null when fewer than two pairs exist or a non-zero constant delta
+* has zero observed variance. In that case the standardized effect is
+* undefined, not an arbitrarily large finite number.
+*/
+function pairedCohensDz(before, after) {
+	if (before.length !== after.length) throw new ValidationError(`pairedCohensDz: unequal sample sizes (${before.length} vs ${after.length})`);
+	if (before.length < 2) return null;
+	const deltas = before.map((value, index) => after[index] - value);
+	if (deltas.some((value) => !Number.isFinite(value))) throw new ValidationError("pairedCohensDz: all paired values must be finite");
+	const meanDelta = deltas.reduce((sum, value) => sum + value, 0) / deltas.length;
+	const variance = deltas.reduce((sum, value) => sum + (value - meanDelta) ** 2, 0) / (deltas.length - 1);
+	const standardDeviation = Math.sqrt(variance);
+	const scale = Math.max(1, Math.abs(meanDelta), ...deltas.map(Math.abs));
+	if (standardDeviation <= Number.EPSILON * scale) return meanDelta === 0 ? 0 : null;
+	return meanDelta / standardDeviation;
+}
+/**
+* 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.
+*/
+function cliffsDelta(before, after) {
+	const n = before.length * after.length;
+	if (n === 0) return 0;
+	let dominance = 0;
+	for (const a of after) for (const b of before) if (a > b) dominance += 1;
+	else if (a < b) dominance -= 1;
+	return dominance / n;
+}
+/**
+* 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.
+*/
+function interpretCliffs(delta) {
+	const d = Math.abs(delta);
+	if (d < .147) return "negligible";
+	if (d < .33) return "small";
+	if (d < .474) return "medium";
+	return "large";
+}
+/**
+* Average-rank-with-ties transform (1-indexed). Tied values receive the mean
+* of the ranks they span, the standard correction for Spearman's ρ.
+*/
+function ranks(xs) {
+	const indexed = xs.map((v, i) => ({
+		v,
+		i
+	})).sort((a, b) => a.v - b.v);
+	const r = new Array(xs.length);
+	let i = 0;
+	while (i < indexed.length) {
+		let j = i;
+		while (j + 1 < indexed.length && indexed[j + 1].v === indexed[i].v) j++;
+		const avg = (i + j) / 2 + 1;
+		for (let k = i; k <= j; k++) r[indexed[k].i] = avg;
+		i = j + 1;
+	}
+	return r;
+}
+/**
+* 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.
+*/
+function pearsonR(a, b) {
+	if (a.length !== b.length || a.length < 2) return NaN;
+	const n = a.length;
+	const meanA = a.reduce((s, v) => s + v, 0) / n;
+	const meanB = b.reduce((s, v) => s + v, 0) / n;
+	let num = 0;
+	let varA = 0;
+	let varB = 0;
+	for (let i = 0; i < n; i++) {
+		const da = a[i] - meanA;
+		const db = b[i] - meanB;
+		num += da * db;
+		varA += da * da;
+		varB += db * db;
+	}
+	if (varA === 0 || varB === 0) return varA === 0 && varB === 0 ? 1 : 0;
+	return num / Math.sqrt(varA * varB);
+}
+/**
+* Spearman's rank correlation ρ — Pearson over the average-rank-with-ties
+* transform of each series. Same edge-case contract as {@link pearsonR}.
+*/
+function spearmanR(a, b) {
+	if (a.length !== b.length || a.length < 2) return NaN;
+	return pearsonR(ranks(a), ranks(b));
+}
+/**
+* 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.
+*/
+function weightedComposite(input) {
+	const entries = Object.entries(input.weights);
+	if (entries.length === 0) throw new Error("weightedComposite: `weights` is empty — nothing to combine");
+	let weightedSum = 0;
+	let weightTotal = 0;
+	for (const [dim, weight] of entries) {
+		if (weight < 0) throw new Error(`weightedComposite: weight for '${dim}' is negative (${weight})`);
+		if (!(dim in input.dims)) throw new Error(`weightedComposite: weighted dimension '${dim}' is absent from \`dims\` — refusing to renormalise onto a different denominator`);
+		weightedSum += input.dims[dim] * weight;
+		weightTotal += weight;
+	}
+	if (weightTotal === 0) throw new Error("weightedComposite: weights sum to 0 — composite is undefined");
+	const composite = weightedSum / weightTotal;
+	return input.threshold === void 0 ? { composite } : {
+		composite,
+		pass: composite >= input.threshold
+	};
+}
+/**
+* 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.
+*/
+function corpusInterRaterAgreement(records, opts = {}) {
+	if (records.length === 0) throw new ValidationError("corpusInterRaterAgreement: no score records supplied");
+	const judgesSeen = /* @__PURE__ */ new Set();
+	const dimsSeen = /* @__PURE__ */ new Set();
+	const grid = /* @__PURE__ */ new Map();
+	for (const r of records) {
+		if (!Number.isFinite(r.score)) throw new ValidationError(`corpusInterRaterAgreement: non-finite score for (item=${r.itemId}, judge=${r.judgeName}, dim=${r.dimension})`);
+		judgesSeen.add(r.judgeName);
+		dimsSeen.add(r.dimension);
+		const byJudge = grid.get(r.dimension) ?? /* @__PURE__ */ new Map();
+		const byItem = byJudge.get(r.judgeName) ?? /* @__PURE__ */ new Map();
+		if (byItem.has(r.itemId)) throw new ValidationError(`corpusInterRaterAgreement: duplicate record for (item=${r.itemId}, judge=${r.judgeName}, dim=${r.dimension})`);
+		byItem.set(r.itemId, r.score);
+		byJudge.set(r.judgeName, byItem);
+		grid.set(r.dimension, byJudge);
+	}
+	const targetDims = opts.dimensions ?? [...dimsSeen].sort();
+	for (const d of targetDims) if (!dimsSeen.has(d)) throw new ValidationError(`corpusInterRaterAgreement: dimension '${d}' was requested but no records carry it`);
+	const targetJudges = opts.judges ? [...opts.judges] : [...judgesSeen].sort();
+	for (const j of targetJudges) if (!judgesSeen.has(j)) throw new ValidationError(`corpusInterRaterAgreement: judge '${j}' was requested but produced no records`);
+	if (targetJudges.length < 2) throw new ValidationError(`corpusInterRaterAgreement: need ≥2 judges, got ${targetJudges.length}`);
+	const perDimension = [];
+	const iccs = [];
+	const kappas = [];
+	for (const dim of targetDims) {
+		const byJudge = grid.get(dim);
+		const judgeItemCounts = {};
+		for (const j of targetJudges) judgeItemCounts[j] = byJudge.get(j)?.size ?? 0;
+		const emptyJudges = targetJudges.filter((j) => judgeItemCounts[j] === 0);
+		if (emptyJudges.length > 0) throw new ValidationError(`corpusInterRaterAgreement: dimension '${dim}' has no scores from judge(s) ${emptyJudges.join(", ")} (counts: ${JSON.stringify(judgeItemCounts)})`);
+		let commonItems = null;
+		for (const j of targetJudges) {
+			const ids = new Set(byJudge.get(j).keys());
+			if (commonItems === null) commonItems = ids;
+			else commonItems = new Set([...commonItems].filter((x) => ids.has(x)));
+		}
+		const sortedItems = [...commonItems ?? /* @__PURE__ */ new Set()].sort();
+		if (sortedItems.length < 2) throw new ValidationError(`corpusInterRaterAgreement: dimension '${dim}' has ${sortedItems.length} item(s) rated by all ${targetJudges.length} judges (need ≥2)`);
+		const agreement = continuousAgreement(sortedItems.map((itemId) => targetJudges.map((j) => byJudge.get(j).get(itemId))), opts);
+		perDimension.push({
+			...agreement,
+			dimension: dim,
+			itemIds: sortedItems,
+			judgeIds: [...targetJudges]
+		});
+		if (Number.isFinite(agreement.icc)) iccs.push(agreement.icc);
+		if (Number.isFinite(agreement.weightedKappa)) kappas.push(agreement.weightedKappa);
+	}
+	const mean = (xs) => xs.length === 0 ? NaN : xs.reduce((a, b) => a + b, 0) / xs.length;
+	return {
+		perDimension,
+		overallIcc: mean(iccs),
+		overallWeightedKappa: mean(kappas),
+		dimensions: targetDims,
+		judgeIds: targetJudges
+	};
+}
+/**
+* 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`.
+*/
+function corpusInterRaterAgreementFromJudgeScores(itemsScores, opts = {}) {
+	const records = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { itemId, scores } of itemsScores) {
+		if (seen.has(itemId)) throw new ValidationError(`corpusInterRaterAgreementFromJudgeScores: duplicate itemId '${itemId}'`);
+		seen.add(itemId);
+		for (const s of scores) records.push({
+			itemId,
+			judgeName: s.judgeName,
+			dimension: s.dimension,
+			score: s.score
+		});
+	}
+	return corpusInterRaterAgreement(records, opts);
+}
+/** Student-t CDF approximation via Abramowitz-Stegun series. */
+function studentTCdf(t, df) {
+	if (df <= 0) return .5;
+	if (df > 100) return normalCdf(t);
+	const ib = incompleteBeta(df / (df + t * t), df / 2, .5);
+	return t >= 0 ? 1 - .5 * ib : .5 * ib;
+}
+/** Regularized incomplete beta function via continued fraction (Lentz). */
+function incompleteBeta(x, a, b) {
+	if (x <= 0) return 0;
+	if (x >= 1) return 1;
+	const lnBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+	const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a;
+	const maxIter = 200;
+	const eps = 3e-7;
+	let c = 1;
+	let d = 1 - (a + b) * x / (a + 1);
+	if (Math.abs(d) < 1e-30) d = 1e-30;
+	d = 1 / d;
+	let f = d;
+	for (let m = 1; m <= maxIter; m++) {
+		const m2 = 2 * m;
+		let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
+		d = 1 + num * d;
+		if (Math.abs(d) < 1e-30) d = 1e-30;
+		c = 1 + num / c;
+		if (Math.abs(c) < 1e-30) c = 1e-30;
+		d = 1 / d;
+		f *= d * c;
+		num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
+		d = 1 + num * d;
+		if (Math.abs(d) < 1e-30) d = 1e-30;
+		c = 1 + num / c;
+		if (Math.abs(c) < 1e-30) c = 1e-30;
+		d = 1 / d;
+		const delta = d * c;
+		f *= delta;
+		if (Math.abs(delta - 1) < eps) break;
+	}
+	return front * f;
+}
+/** Lanczos approximation to ln Γ(z). */
+function lnGamma(z) {
+	const g = 7;
+	const coefs = [
+		.9999999999998099,
+		676.5203681218851,
+		-1259.1392167224028,
+		771.3234287776531,
+		-176.6150291621406,
+		12.507343278686905,
+		-.13857109526572012,
+		9984369578019572e-21,
+		1.5056327351493116e-7
+	];
+	if (z < .5) return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z);
+	z -= 1;
+	let x = coefs[0];
+	for (let i = 1; i < 9; i++) x += coefs[i] / (z + i);
+	const t = z + g + .5;
+	return .5 * Math.log(2 * Math.PI) + (z + .5) * Math.log(t) - t + Math.log(x);
+}
+function normalCdf(x) {
+	const a1 = .254829592;
+	const a2 = -.284496736;
+	const a3 = 1.421413741;
+	const a4 = -1.453152027;
+	const a5 = 1.061405429;
+	const p = .3275911;
+	const sign = x < 0 ? -1 : 1;
+	const absX = Math.abs(x);
+	const t = 1 / (1 + p * absX);
+	return .5 * (1 + sign * (1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2)));
+}
+/**
+* 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.
+*/
+function requiredSampleSize(opts) {
+	const effect = opts.effect;
+	if (!Number.isFinite(effect) || effect <= 0) return Infinity;
+	const alpha = opts.alpha ?? .05;
+	const power = opts.power ?? .8;
+	const n = 2 * ((zQuantile(opts.twoSided ?? true ? 1 - alpha / 2 : 1 - alpha) + zQuantile(power)) / effect) ** 2;
+	return Math.ceil(n);
+}
+/**
+* Required number of paired observations for a target Cohen's dz.
+* Unlike the independent-groups formula, this has no two-arm factor of two.
+*/
+function requiredPairedSampleSize(opts) {
+	const effect = opts.effect;
+	if (!Number.isFinite(effect) || effect <= 0) return Infinity;
+	const alpha = opts.alpha ?? .05;
+	const power = opts.power ?? .8;
+	const zAlpha = zQuantile(opts.twoSided ?? true ? 1 - alpha / 2 : 1 - alpha);
+	const zBeta = zQuantile(power);
+	return Math.ceil(((zAlpha + zBeta) / effect) ** 2);
+}
+/**
+* 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.
+*/
+function pairedMde(opts) {
+	if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity;
+	const alpha = opts.alpha ?? .05;
+	const power = opts.power ?? .8;
+	return (zQuantile(opts.twoSided ?? true ? 1 - alpha / 2 : 1 - alpha) + zQuantile(power)) / Math.sqrt(opts.nPaired);
+}
+/**
+* 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.
+*/
+function mcnemarRequiredN(opts) {
+	const { p10, p01 } = opts;
+	if (p10 < 0 || p01 < 0 || p10 + p01 > 1) throw new Error(`mcnemarRequiredN: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`);
+	const delta = p10 - p01;
+	if (delta === 0) return Infinity;
+	const alpha = opts.alpha ?? .05;
+	const power = opts.power ?? .8;
+	const twoSided = opts.twoSided ?? true;
+	const pDisc = p10 + p01;
+	const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
+	const zBeta = zQuantile(power);
+	const n = (zAlpha * Math.sqrt(pDisc) + zBeta * Math.sqrt(Math.max(0, pDisc - delta * delta))) ** 2 / (delta * delta);
+	return Math.ceil(n);
+}
+/**
+* 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.
+*/
+function mcnemarPower(opts) {
+	const { p10, p01, nPairs } = opts;
+	if (p10 < 0 || p01 < 0 || p10 + p01 > 1) throw new Error(`mcnemarPower: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`);
+	const alpha = opts.alpha ?? .05;
+	const twoSided = opts.twoSided ?? true;
+	const delta = p10 - p01;
+	if (delta === 0 || nPairs <= 0) return alpha;
+	const pDisc = p10 + p01;
+	const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
+	const denom = Math.sqrt(Math.max(1e-12, pDisc - delta * delta));
+	const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom;
+	return Math.min(1, Math.max(0, normalCdf(zBeta)));
+}
+/** Bonferroni adjustment: multiply every p-value by the test count, clamp at 1. */
+function bonferroni(pValues, alpha = .05) {
+	const k = pValues.length;
+	const adjusted = pValues.map((p) => Math.min(1, p * k));
+	return {
+		adjusted,
+		significant: adjusted.map((p) => p < alpha)
+	};
+}
+/**
+* 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.
+*/
+function holm(pValues, alpha = .05) {
+	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new ValidationError(`holm: alpha must be in (0,1), got ${alpha}`);
+	for (const [index, pValue] of pValues.entries()) if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) throw new ValidationError(`holm: pValues[${index}] must be in [0,1], got ${pValue}`);
+	const count = pValues.length;
+	if (count === 0) return {
+		adjusted: [],
+		significant: []
+	};
+	const ordered = pValues.map((pValue, index) => ({
+		pValue,
+		index
+	})).sort((a, b) => a.pValue - b.pValue || a.index - b.index);
+	const adjusted = new Array(count);
+	let previous = 0;
+	for (let rank = 0; rank < count; rank++) {
+		const entry = ordered[rank];
+		const stepAdjusted = Math.min(1, entry.pValue * (count - rank));
+		previous = Math.max(previous, stepAdjusted);
+		adjusted[entry.index] = previous;
+	}
+	return {
+		adjusted,
+		significant: adjusted.map((pValue) => pValue <= alpha)
+	};
+}
+/**
+* Benjamini–Hochberg false discovery rate. Returns adjusted q-values and
+* significance at the target FDR; handles ties and preserves q monotonicity.
+*/
+function benjaminiHochberg(pValues, fdr = .05) {
+	const n = pValues.length;
+	if (n === 0) return {
+		qValues: [],
+		significant: []
+	};
+	const indexed = pValues.map((p, i) => ({
+		p,
+		i
+	})).sort((a, b) => a.p - b.p);
+	const q = new Array(n);
+	let minRight = 1;
+	for (let k = n - 1; k >= 0; k--) {
+		const rank = k + 1;
+		const entry = indexed[k];
+		const raw = entry.p * n / rank;
+		const bounded = Math.min(minRight, raw);
+		minRight = bounded;
+		q[entry.i] = Math.min(1, bounded);
+	}
+	return {
+		qValues: q,
+		significant: q.map((v) => v < fdr)
+	};
+}
+/**
+* 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.
+*/
+function pairedBootstrap(before, after, opts = {}) {
+	if (before.length !== after.length) throw new Error(`pairedBootstrap: unequal sample sizes (${before.length} vs ${after.length})`);
+	const confidence = opts.confidence ?? .95;
+	const resamples = opts.resamples ?? 2e3;
+	const statistic = opts.statistic ?? "median";
+	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedBootstrap: confidence must be in (0,1), got ${confidence}`);
+	const n = before.length;
+	const deltas = before.map((b, i) => after[i] - b);
+	if (n === 0) return {
+		n: 0,
+		median: 0,
+		mean: 0,
+		low: 0,
+		high: 0,
+		confidence,
+		resamples
+	};
+	if (n === 1) {
+		const d = deltas[0];
+		return {
+			n: 1,
+			median: d,
+			mean: d,
+			low: d,
+			high: d,
+			confidence,
+			resamples
+		};
+	}
+	const rng = makeRng(opts.seed);
+	const samples = new Array(resamples);
+	for (let b = 0; b < resamples; b++) if (statistic === "mean") {
+		let sum = 0;
+		for (let k = 0; k < n; k++) sum += deltas[Math.floor(rng() * n)];
+		samples[b] = sum / n;
+	} else {
+		const acc = new Array(n);
+		for (let k = 0; k < n; k++) acc[k] = deltas[Math.floor(rng() * n)];
+		samples[b] = medianInPlace(acc);
+	}
+	samples.sort((a, b) => a - b);
+	const alpha = 1 - confidence;
+	const lowIdx = Math.floor(alpha / 2 * resamples);
+	const highIdx = Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1);
+	return {
+		n,
+		median: medianInPlace([...deltas]),
+		mean: deltas.reduce((s, x) => s + x, 0) / n,
+		low: samples[lowIdx],
+		high: samples[Math.max(highIdx, lowIdx)],
+		confidence,
+		resamples
+	};
+}
+/**
+* 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.
+*/
+function pairedSignTest(differences, alternative) {
+	if (alternative !== "greater" && alternative !== "less") throw new ValidationError(`pairedSignTest: alternative must be 'greater' or 'less', got ${alternative}`);
+	let positive = 0;
+	let negative = 0;
+	let ties = 0;
+	for (let i = 0; i < differences.length; i++) {
+		const difference = differences[i];
+		if (!Number.isFinite(difference)) throw new ValidationError(`pairedSignTest: difference at index ${i} must be finite, got ${difference}`);
+		if (difference > 0) positive++;
+		else if (difference < 0) negative++;
+		else ties++;
+	}
+	const nNonTies = positive + negative;
+	const successes = alternative === "greater" ? positive : negative;
+	return {
+		n: differences.length,
+		positive,
+		negative,
+		ties,
+		nNonTies,
+		alternative,
+		pValue: binomialHalfUpperTail(successes, nNonTies)
+	};
+}
+/**
+* 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}`.
+*/
+function wilson(successes, n, confidence = .95) {
+	if (n <= 0) return {
+		estimate: 0,
+		lower: 0,
+		upper: 0
+	};
+	if (successes < 0 || successes > n) throw new Error(`wilson: successes (${successes}) must be in [0, ${n}]`);
+	const z = zQuantile(1 - (1 - confidence) / 2);
+	const p = successes / n;
+	const z2 = z * z;
+	const denom = 1 + z2 / n;
+	const center = (p + z2 / (2 * n)) / denom;
+	const half = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n) / denom;
+	return {
+		estimate: p,
+		lower: Math.max(0, center - half),
+		upper: Math.min(1, center + half)
+	};
+}
+/**
+* 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.
+*/
+function mcnemar(control, treatment) {
+	if (control.length !== treatment.length) throw new Error(`mcnemar: unequal sample sizes (${control.length} vs ${treatment.length})`);
+	const n = control.length;
+	let b = 0;
+	let c = 0;
+	for (let i = 0; i < n; i++) {
+		const ctrl = control[i] ? 1 : 0;
+		const treat = treatment[i] ? 1 : 0;
+		if (treat === 1 && ctrl === 0) b++;
+		else if (treat === 0 && ctrl === 1) c++;
+	}
+	const nDiscordant = b + c;
+	const statistic = nDiscordant === 0 ? 0 : (Math.abs(b - c) - 1) ** 2 / nDiscordant;
+	return {
+		n,
+		nDiscordant,
+		b,
+		c,
+		statistic,
+		pValue: binomialSignTwoSided(b, c)
+	};
+}
+/**
+* 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.
+*/
+function pairedRiskDifference(control, treatment, confidence = .95) {
+	if (control.length !== treatment.length) throw new Error(`pairedRiskDifference: unequal sample sizes (${control.length} vs ${treatment.length})`);
+	const n = control.length;
+	if (n === 0) return {
+		n: 0,
+		b: 0,
+		c: 0,
+		riskDifference: 0,
+		lower: 0,
+		upper: 0,
+		confidence
+	};
+	let b = 0;
+	let c = 0;
+	for (let i = 0; i < n; i++) {
+		const ctrl = control[i] ? 1 : 0;
+		const treat = treatment[i] ? 1 : 0;
+		if (treat === 1 && ctrl === 0) b++;
+		else if (treat === 0 && ctrl === 1) c++;
+	}
+	const rd = (b - c) / n;
+	const variance = (b + c - (b - c) ** 2 / n) / (n * n);
+	const half = zQuantile(1 - (1 - confidence) / 2) * Math.sqrt(Math.max(0, variance));
+	return {
+		n,
+		b,
+		c,
+		riskDifference: rd,
+		lower: Math.max(-1, rd - half),
+		upper: Math.min(1, rd + half),
+		confidence
+	};
+}
+/**
+* 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.
+*/
+function passAtK(n, c, k) {
+	if (!Number.isInteger(n) || !Number.isInteger(c) || !Number.isInteger(k)) throw new Error(`passAtK: n, c, k must be integers (got n=${n}, c=${c}, k=${k})`);
+	if (k < 1 || k > n || c < 0 || c > n) throw new Error(`passAtK: require 1 ≤ k ≤ n and 0 ≤ c ≤ n (got n=${n}, c=${c}, k=${k})`);
+	if (n - c < k) return 1;
+	let prob = 1;
+	for (let i = n - c + 1; i <= n; i++) prob *= 1 - k / i;
+	return 1 - prob;
+}
+/**
+* Two-sided exact p-value for b successes out of (b + c) Bernoulli(0.5) trials —
+* the exact-binomial core of {@link mcnemar}. `min(1, 2·P(X ≤ min(b,c)))`. No
+* discordant pairs ⇒ no evidence ⇒ p = 1. Summed in log space (lnGamma) so it
+* stays exact at large discordant counts without overflow.
+*/
+function binomialSignTwoSided(b, c) {
+	const nd = b + c;
+	if (nd === 0) return 1;
+	return Math.min(1, 2 * binomialHalfLowerTail(Math.min(b, c), nd));
+}
+/** P(X >= successes) for X ~ Binomial(n, 0.5). */
+function binomialHalfUpperTail(successes, n) {
+	if (successes <= 0) return 1;
+	if (successes > n) return 0;
+	if (successes <= n / 2) return Math.max(0, 1 - binomialHalfLowerTail(successes - 1, n));
+	return binomialHalfLowerTail(n - successes, n);
+}
+/** P(X <= maxSuccesses) for X ~ Binomial(n, 0.5), accumulated in log space. */
+function binomialHalfLowerTail(maxSuccesses, n) {
+	if (maxSuccesses < 0) return 0;
+	if (maxSuccesses >= n) return 1;
+	if (maxSuccesses === 0) return 2 ** -n;
+	const logHalfN = n * Math.log(.5);
+	let logTail = Number.NEGATIVE_INFINITY;
+	for (let i = 0; i <= maxSuccesses; i++) {
+		const logChoose = lnGamma(n + 1) - lnGamma(i + 1) - lnGamma(n - i + 1);
+		logTail = logAddExp(logTail, logChoose + logHalfN);
+	}
+	return Math.min(1, Math.exp(logTail));
+}
+function logAddExp(a, b) {
+	if (a === Number.NEGATIVE_INFINITY) return b;
+	if (b === Number.NEGATIVE_INFINITY) return a;
+	const max = Math.max(a, b);
+	return max + Math.log1p(Math.exp(Math.min(a, b) - max));
+}
+/**
+* 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.
+*/
+function eProcess(opts = {}) {
+	const alpha = opts.alpha ?? .05;
+	const maxBet = opts.maxBet ?? .5;
+	const nullMean = opts.nullMean ?? .5;
+	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new ValidationError(`eProcess: alpha must be in (0,1), got ${alpha}`);
+	if (!Number.isFinite(nullMean) || nullMean <= 0 || nullMean >= 1) throw new ValidationError(`eProcess: nullMean must be in (0,1), got ${nullMean}`);
+	if (!Number.isFinite(maxBet) || maxBet <= 0 || maxBet >= 1 / nullMean) throw new ValidationError(`eProcess: maxBet must be in (0, 1/nullMean=${(1 / nullMean).toFixed(4)}) so wealth factors stay positive, got ${maxBet}`);
+	const threshold = 1 / alpha;
+	let wealth = 1;
+	let n = 0;
+	let decided = false;
+	let decidedAtN;
+	let sumX = 0;
+	let varSum = 0;
+	return {
+		update(x) {
+			if (typeof x !== "number" || !Number.isFinite(x) || x < 0 || x > 1) throw new ValidationError(`eProcess: observation must be a finite number in [0,1], got ${x}`);
+			const muPrev = (.5 + sumX) / (n + 1);
+			const varPrev = (.25 + varSum) / (n + 1);
+			const edge = muPrev - nullMean;
+			const lambda = Math.min(maxBet, Math.max(0, edge / (varPrev + edge * edge)));
+			wealth *= 1 + lambda * (x - nullMean);
+			n += 1;
+			sumX += x;
+			const muNow = (.5 + sumX) / (n + 1);
+			varSum += (x - muNow) ** 2;
+			if (!decided && wealth >= threshold) {
+				decided = true;
+				decidedAtN = n;
+			}
+			return {
+				wealth,
+				n,
+				decided
+			};
+		},
+		state() {
+			return {
+				wealth,
+				n,
+				decided,
+				alpha,
+				maxBet,
+				nullMean,
+				threshold,
+				decidedAtN
+			};
+		}
+	};
+}
+/** Standard-normal inverse CDF (Acklam approximation). */
+function zQuantile(p) {
+	if (p <= 0 || p >= 1) {
+		if (p === 0) return -Infinity;
+		if (p === 1) return Infinity;
+		return NaN;
+	}
+	const a = [
+		-39.69683028665376,
+		220.9460984245205,
+		-275.9285104469687,
+		138.357751867269,
+		-30.66479806614716,
+		2.506628277459239
+	];
+	const b = [
+		-54.47609879822406,
+		161.5858368580409,
+		-155.6989798598866,
+		66.80131188771972,
+		-13.28068155288572
+	];
+	const c = [
+		-.007784894002430293,
+		-.3223964580411365,
+		-2.400758277161838,
+		-2.549732539343734,
+		4.374664141464968,
+		2.938163982698783
+	];
+	const d = [
+		.007784695709041462,
+		.3224671290700398,
+		2.445134137142996,
+		3.754408661907416
+	];
+	const pLow = .02425;
+	const pHigh = 1 - pLow;
+	let q;
+	let r;
+	if (p < pLow) {
+		q = Math.sqrt(-2 * Math.log(p));
+		return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+	}
+	if (p <= pHigh) {
+		q = p - .5;
+		r = q * q;
+		return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+	}
+	q = Math.sqrt(-2 * Math.log(1 - p));
+	return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+}
+function medianInPlace(xs) {
+	if (xs.length === 0) return 0;
+	xs.sort((a, b) => a - b);
+	const mid = Math.floor(xs.length / 2);
+	return xs.length % 2 === 0 ? (xs[mid - 1] + xs[mid]) / 2 : xs[mid];
+}
+function makeRng(seed) {
+	if (seed === void 0) return Math.random;
+	return mulberry32(seed);
+}
+/** 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). */
+function mulberry32(seed) {
+	let s = seed | 0 || 2654435769;
+	return () => {
+		s = s + 1831565813 | 0;
+		let t = s;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+//#endregion
+export { spearmanR as A, verbosityBias as B, pairedTTest as C, ranks as D, pearsonR as E, calibrateJudge as F, calibrateJudgeContinuous as I, continuousAgreement as L, weightedMean as M, wilcoxonSignedRank as N, requiredPairedSampleSize as O, wilson as P, positionalBias as R, pairedSignTest as S, passAtK as T, normalizeScores as _, confidenceInterval as a, pairedMde as b, eProcess as c, interpretCliffs as d, mannWhitneyU as f, mulberry32 as g, mcnemarRequiredN as h, cohensD as i, weightedComposite as j, requiredSampleSize as k, holm as l, mcnemarPower as m, bonferroni as n, corpusInterRaterAgreement as o, mcnemar as p, cliffsDelta as r, corpusInterRaterAgreementFromJudgeScores as s, benjaminiHochberg as t, interRaterReliability as u, pairedBootstrap as v, partialCredit as w, pairedRiskDifference as x, pairedCohensDz as y, selfPreference as z };
+
+//# sourceMappingURL=statistics-CnnxdpOg.js.map