@tangle-network/agent-eval 1.0.18 → 1.0.20

package/dist/statistics-DCZIC-qT.js

@@ -0,0 +1,2627 @@
+import { s as ValidationError } from "./errors-DeEEV9Vx.js";
+import { t as interpolatedQuantile } from "./quantile-CncXP-Ss.js";
+import { t as mulberry32 } from "./random-DrzcgC7F.js";
+// src/math/special-functions.ts
+/** Lanczos approximation to ln Gamma(z). */
+function lnGamma(z) {
+	const g = 7;
+	const coefficients = [
+		.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 = coefficients[0];
+	for (let i = 1; i < 9; i++) x += coefficients[i] / (z + i);
+	const t = z + g + .5;
+	return .5 * Math.log(2 * Math.PI) + (z + .5) * Math.log(t) - t + Math.log(x);
+}
+/**
+* Regularized incomplete beta function I_x(a, b).
+*
+* The Lentz continued fraction converges only for `x < (a+1)/(a+b+2)`; outside
+* that domain it must be reached through the symmetry `I_x(a,b) = 1 −
+* I_{1−x}(b,a)`. `studentTCdf` drives `x → 1` as `|t| → 0`, so the mirrored
+* branch is the one every near-null t-statistic takes.
+*/
+function regularizedIncompleteBeta(x, a, b) {
+	if (x <= 0) return 0;
+	if (x >= 1) return 1;
+	const logBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+	const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - logBeta);
+	if (x < (a + 1) / (a + b + 2)) return front * betaContinuedFraction(x, a, b) / a;
+	return 1 - front * betaContinuedFraction(1 - x, b, a) / b;
+}
+/** Modified Lentz evaluation of the beta continued fraction at `x`. */
+function betaContinuedFraction(x, a, b) {
+	const maxIterations = 300;
+	const epsilon = 3e-15;
+	let c = 1;
+	let d = 1 - (a + b) * x / (a + 1);
+	if (Math.abs(d) < 1e-30) d = 1e-30;
+	d = 1 / d;
+	let fraction = d;
+	for (let m = 1; m <= maxIterations; m++) {
+		const m2 = 2 * m;
+		let numerator = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
+		d = 1 + numerator * d;
+		if (Math.abs(d) < 1e-30) d = 1e-30;
+		c = 1 + numerator / c;
+		if (Math.abs(c) < 1e-30) c = 1e-30;
+		d = 1 / d;
+		fraction *= d * c;
+		numerator = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
+		d = 1 + numerator * d;
+		if (Math.abs(d) < 1e-30) d = 1e-30;
+		c = 1 + numerator / c;
+		if (Math.abs(c) < 1e-30) c = 1e-30;
+		d = 1 / d;
+		const delta = d * c;
+		fraction *= delta;
+		if (Math.abs(delta - 1) < epsilon) break;
+	}
+	return fraction;
+}
+// src/math/student-t.ts
+/**
+* Student-t CDF via the regularized incomplete beta function.
+*/
+function studentTCdf(t, degreesOfFreedom) {
+	if (degreesOfFreedom <= 0) return .5;
+	const beta = regularizedIncompleteBeta(degreesOfFreedom / (degreesOfFreedom + t * t), degreesOfFreedom / 2, .5);
+	return t >= 0 ? 1 - .5 * beta : .5 * beta;
+}
+/**
+* Inverse Student-t CDF, solved against {@link studentTCdf}.
+*
+* The CDF is monotone, so bracket expansion followed by bisection is stable
+* across fractional degrees of freedom and does not need a separate
+* approximation with a different error profile.
+*/
+function studentTQuantile(probability, degreesOfFreedom) {
+	if (!Number.isFinite(probability) || probability < 0 || probability > 1) throw new RangeError(`studentTQuantile: probability must be in [0,1], got ${probability}`);
+	if (!Number.isFinite(degreesOfFreedom) || degreesOfFreedom <= 0) throw new RangeError(`studentTQuantile: degreesOfFreedom must be positive and finite, got ${degreesOfFreedom}`);
+	if (probability === 0) return Number.NEGATIVE_INFINITY;
+	if (probability === 1) return Number.POSITIVE_INFINITY;
+	if (probability === .5) return 0;
+	if (probability < .5) return -studentTQuantile(1 - probability, degreesOfFreedom);
+	let low = 0;
+	let high = 1;
+	while (studentTCdf(high, degreesOfFreedom) < probability) high *= 2;
+	for (let iteration = 0; iteration < 64; iteration++) {
+		const middle = (low + high) / 2;
+		if (studentTCdf(middle, degreesOfFreedom) < probability) low = middle;
+		else high = middle;
+	}
+	return (low + high) / 2;
+}
+// src/statistics/cluster.ts
+const DEFAULT_BOOTSTRAP_SEED = 12648430;
+/** Percentile bootstrap; degenerate resamples are omitted, with NaN bounds if none remain. */
+function clusterBootstrap(items, cluster, statistic, { resamples = 2e3, seed = DEFAULT_BOOTSTRAP_SEED, level = .95, strata } = {}) {
+	if (!Number.isSafeInteger(resamples) || resamples < 0 || !(level > 0 && level < 1)) throw new ValidationError("clusterBootstrap: requires nonnegative resamples and level in (0,1)");
+	const groups = /* @__PURE__ */ new Map();
+	items.forEach((item, index) => {
+		const key = cluster(item, index), stratum = strata?.(item, index) ?? "";
+		if (typeof key !== "string" || !key || typeof stratum !== "string") throw new ValidationError("clusterBootstrap: requires string cluster id and stratum");
+		const group = groups.get(key) ?? {
+			stratum,
+			rows: []
+		};
+		if (group.stratum !== stratum) throw new ValidationError("clusterBootstrap: cluster crosses strata");
+		group.rows.push(item);
+		groups.set(key, group);
+	});
+	const cells = /* @__PURE__ */ new Map();
+	for (const { stratum, rows } of groups.values()) {
+		if (!cells.has(stratum)) cells.set(stratum, []);
+		cells.get(stratum).push(rows);
+	}
+	const rng = mulberry32(seed), values = [];
+	for (let b = 0; b < resamples; b++) {
+		const value = statistic([...cells.values()].flatMap((clusters) => Array.from({ length: clusters.length }, () => clusters[Math.floor(rng() * clusters.length)]).flat()));
+		if (Number.isFinite(value)) values.push(value);
+	}
+	values.sort((a, b) => a - b);
+	return {
+		low: interpolatedQuantile(values, (1 - level) / 2),
+		high: interpolatedQuantile(values, (1 + level) / 2),
+		resamples,
+		clusters: groups.size
+	};
+}
+function placeboBand(history, options) {
+	const { timestamp, cluster, statistic, clustersPerArm, delta, steps = [] } = options;
+	if (!Number.isSafeInteger(clustersPerArm) || clustersPerArm < 1 || !Number.isFinite(delta) || steps.some((t) => !Number.isFinite(t))) throw new ValidationError("placeboBand: invalid cluster count, delta or step");
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of history) {
+		const ts = timestamp(row), key = cluster(row);
+		if (!Number.isFinite(ts) || typeof key !== "string" || !key) throw new ValidationError("placeboBand: invalid timestamp or cluster");
+		const group = groups.get(key) ?? {
+			start: ts,
+			end: ts,
+			rows: []
+		};
+		group.start = Math.min(group.start, ts);
+		group.end = Math.max(group.end, ts);
+		group.rows.push(row);
+		groups.set(key, group);
+	}
+	const ordered = [...groups.values()].sort((a, b) => a.start - b.start);
+	const start = ordered[0]?.start ?? 0, end = Math.max(start, ...ordered.map((g) => g.end));
+	const hour = 36e5;
+	const candidates = [...options.boundaries ?? Array.from({ length: Math.max(0, Math.floor(end / hour) - Math.ceil(start / hour) + 1) }, (_, i) => (Math.ceil(start / hour) + i) * hour)].sort((a, b) => a - b);
+	if (candidates.some((t, i) => !Number.isFinite(t) || i > 0 && t - candidates[i - 1] < hour)) throw new ValidationError("placeboBand: boundaries must be at least one hour apart");
+	const deltas = [], boundaries = [];
+	if (end - start >= 72 * hour) for (const boundary of candidates) {
+		if (ordered.some((g) => g.start < boundary && g.end >= boundary)) continue;
+		const before = ordered.filter((g) => g.end < boundary).slice(-clustersPerArm);
+		const after = ordered.filter((g) => g.start >= boundary).slice(0, clustersPerArm);
+		if (before.length !== clustersPerArm || after.length !== clustersPerArm) continue;
+		const windowEnd = Math.max(...after.map((g) => g.end));
+		if (steps.some((t) => t >= before[0].start && t <= windowEnd)) continue;
+		const value = statistic(before.flatMap((g) => g.rows), after.flatMap((g) => g.rows));
+		if (!Number.isFinite(value)) throw new ValidationError("placeboBand: statistic must be finite");
+		boundaries.push(boundary);
+		deltas.push(value);
+	}
+	const calibrated = deltas.length >= 39, sorted = [...deltas].sort((a, b) => a - b);
+	const q025 = calibrated ? interpolatedQuantile(sorted, .025) : null, q975 = calibrated ? interpolatedQuantile(sorted, .975) : null;
+	return {
+		status: calibrated ? "calibrated" : "uncalibrated",
+		n: history.length,
+		K: deltas.length,
+		clustersPerArm,
+		boundaries,
+		deltas,
+		q025,
+		q975,
+		low: q975 === null ? null : delta - q975,
+		high: q025 === null ? null : delta - q025
+	};
+}
+// src/statistics/internal.ts
+/**
+* Shared internals for the statistics modules. Nothing here is part of the
+* public statistics surface — `./index` does not re-export this module.
+*/
+/** Every rank test refuses non-finite input. Beyond the arithmetic being
+*  undefined, the tie-grouping scan compares values with `===`, and
+*  `NaN === NaN` is false, so a NaN would leave the group boundary unable to
+*  advance and spin the loop forever. */
+function assertFiniteSample(fn, label, xs) {
+	for (let i = 0; i < xs.length; i++) if (!Number.isFinite(xs[i])) throw new ValidationError(`${fn}: ${label}[${i}] must be finite, got ${xs[i]}`);
+}
+/**
+* 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));
+}
+/** 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 = .97575;
+	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);
+	return interpolatedQuantile(xs, .5);
+}
+/**
+* PRNG for every resampling path in this module.
+*
+* With no caller seed the seed is DERIVED FROM THE DATA rather than taken from
+* `Math.random`, so re-running the same input reproduces the same interval —
+* a gate verdict that cannot be re-derived is not evidence. Distinct data
+* still gets a distinct stream. Same pattern as `promotion-gate.ts`.
+*/
+function makeRng(seed, ...series) {
+	return mulberry32(seed ?? seedFromData(series));
+}
+/** FNV-1a over the IEEE-754 bytes of every observation. */
+function seedFromData(series) {
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	let hash = 2166136261;
+	for (const xs of series) {
+		for (const x of xs) {
+			view.setFloat64(0, x);
+			for (let byte = 0; byte < 8; byte++) hash = Math.imul(hash ^ view.getUint8(byte), 16777619);
+		}
+		hash = Math.imul(hash ^ 255, 16777619);
+	}
+	return hash | 0;
+}
+/** Order-independent seed for a symmetric two-sample statistic. */
+function symmetricTwoSampleSeed(a, b) {
+	const sortedA = [...a].sort((left, right) => left - right);
+	const sortedB = [...b].sort((left, right) => left - right);
+	const forward = seedFromData([sortedA, sortedB]) >>> 0;
+	const reversed = seedFromData([sortedB, sortedA]) >>> 0;
+	return Math.min(forward, reversed);
+}
+// src/statistics/mean.ts
+/** Arithmetic mean. An empty input has no mean and returns NaN. */
+function mean(values) {
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+/** Arithmetic mean, or null for an empty input. */
+function meanOrNull(values) {
+	return values.length === 0 ? null : mean(values);
+}
+/** Arithmetic mean, or 0 for an empty input. */
+function meanOrZero(values) {
+	return values.length === 0 ? 0 : mean(values);
+}
+// src/statistics/descriptive.ts
+/**
+* Descriptive statistics: means, bootstrap spread, correlation, and the
+* weighted judge-dimension composite. Nothing here is a significance test.
+*/
+/** 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;
+}
+/**
+* Percentile bootstrap confidence interval on the mean of `scores`.
+*
+* Descriptive spread. It is not a significance test, and at small n its bounds
+* are anti-conservative in the same way {@link pairedBootstrap}'s are — see
+* {@link BOOTSTRAP_GATE_MIN_N}. With no `seed` the resampling is seeded from
+* the scores themselves, so the interval is reproducible either way.
+*/
+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, scores);
+	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)]
+	};
+}
+/**
+* Two-sided Student-t critical value: the `t` with `P(|T| ≤ t) = confidence`
+* for `df` degrees of freedom. Exact, from {@link studentTQuantile}, so any
+* confidence in (0, 1) and fractional `df` are supported.
+*/
+function studentTCritical(df, confidence = .95) {
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new ValidationError(`studentTCritical: confidence must be in (0, 1), got ${confidence}`);
+	if (!Number.isFinite(df) || df <= 0) throw new ValidationError(`studentTCritical: df must be positive and finite, got ${df}`);
+	return studentTQuantile(1 - (1 - confidence) / 2, df);
+}
+/**
+* Student-t confidence interval on the mean of one sample:
+* `mean ± t(df = n − 1) · s / √n`. Below two samples there is no spread to
+* estimate, so the bounds are null rather than a zero-width interval that
+* would read as certainty. Unlike {@link confidenceInterval} (a percentile
+* bootstrap), the width keeps the small-n t penalty that z = 1.96 drops.
+*/
+function meanConfidenceInterval(samples, confidence = .95) {
+	assertFiniteSample("meanConfidenceInterval", "samples", samples);
+	const n = samples.length;
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new ValidationError(`meanConfidenceInterval: confidence must be in (0, 1), got ${confidence}`);
+	if (n < 2) return {
+		n,
+		mean: n === 0 ? null : samples[0],
+		stdev: null,
+		low: null,
+		high: null,
+		criticalValue: null
+	};
+	const center = mean(samples);
+	const sumSquares = samples.reduce((sum, value) => sum + (value - center) ** 2, 0);
+	const stdev = Math.sqrt(sumSquares / (n - 1));
+	const criticalValue = studentTCritical(n - 1, confidence);
+	const halfWidth = criticalValue * stdev / Math.sqrt(n);
+	return {
+		n,
+		mean: center,
+		stdev,
+		low: center - halfWidth,
+		high: center + halfWidth,
+		criticalValue
+	};
+}
+/** 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));
+}
+/**
+* Fold a number series into its distribution summary. Quantiles use the
+* nearest-rank definition — the `ceil(q·n)`-th order statistic — so every
+* reported quantile is a value from the series. Returns `null` for an empty
+* series: an empty series has no distribution, and a zero-filled summary
+* would read as a measured all-zero series.
+*/
+function summarizeNumberSeries(values, options) {
+	const criticalValue = options?.medianInterval?.criticalValue;
+	if (options) {
+		assertFiniteSample("summarizeNumberSeries", "values", values);
+		for (const percentile of options.percentiles ?? []) if (!Number.isFinite(percentile) || percentile < 0 || percentile > 100) throw new ValidationError("summarizeNumberSeries: percentiles must be finite and between 0 and 100");
+		if (options.medianInterval && (criticalValue === void 0 || !Number.isFinite(criticalValue) || criticalValue < 0)) throw new ValidationError("summarizeNumberSeries: median criticalValue must be finite and nonnegative");
+	}
+	if (values.length === 0) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const rank = (q) => sorted[Math.min(n - 1, Math.max(0, Math.ceil(q * n) - 1))];
+	const sum = sorted.reduce((a, b) => a + b, 0);
+	if (options && !Number.isFinite(sum)) throw new ValidationError("summarizeNumberSeries: sample sum exceeded finite range");
+	const spread = criticalValue === void 0 ? void 0 : criticalValue / 2 * Math.sqrt(n);
+	const lowRank = spread === void 0 ? 1 : Math.max(1, Math.floor(n / 2 - spread));
+	const highRank = spread === void 0 ? n : Math.min(n, Math.ceil(n / 2 + 1 + spread));
+	return {
+		n,
+		min: sorted[0],
+		p50: rank(.5),
+		p90: rank(.9),
+		max: sorted[sorted.length - 1],
+		sum,
+		...options?.percentiles === void 0 ? {} : { percentiles: Object.fromEntries(options.percentiles.map((percentile) => [percentile, rank(percentile / 100)])) },
+		...criticalValue === void 0 ? {} : { medianInterval: {
+			method: "normal-order-statistics",
+			criticalValue,
+			sampleSize: n,
+			lowRank,
+			highRank,
+			low: sorted[lowRank - 1],
+			high: sorted[highRank - 1]
+		} }
+	};
+}
+/**
+* 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
+	};
+}
+// 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 interval = (statistic) => {
+		const ci = clusterBootstrap(clean, (_, i) => String(i), statistic, {
+			resamples: bootstrap,
+			seed,
+			level: ciLevel
+		});
+		return [ci.low, ci.high];
+	};
+	return {
+		weightedKappa: kappa,
+		icc,
+		pearson,
+		spearman,
+		ci: {
+			icc: interval(icc21),
+			weightedKappa: interval((sample) => continuousWeightedKappa(sample, weights))
+		},
+		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;
+}
+// src/statistics/agreement-irr.ts
+/**
+* Inter-rater reliability — Krippendorff's α under the squared-difference
+* metric, pooled across dimensions.
+*
+* Each inner array is one judge's scores. Items are matched by position
+* WITHIN a dimension: the k-th score a judge supplies carrying dimension
+* `d` is item k of `d`, and the ratings compared against each other are
+* the ones different judges gave to the same item. Every judge that scores
+* a dimension at all must supply the same number of scores for it —
+* ragged input cannot be aligned into items and throws rather than
+* comparing mismatched items.
+*
+* α = 1 − D_observed / D_expected: D_observed averages the squared
+* difference over within-item judge pairs, D_expected over every pair of
+* ratings irrespective of item. α = 1 is perfect agreement, 0 is chance,
+* negative is systematic disagreement.
+*/
+function interRaterReliability(judgeScores) {
+	if (judgeScores.length < 2) return 1;
+	const perDimension = /* @__PURE__ */ new Map();
+	for (let judgeIndex = 0; judgeIndex < judgeScores.length; judgeIndex++) for (const s of judgeScores[judgeIndex]) {
+		let byJudge = perDimension.get(s.dimension);
+		if (byJudge === void 0) {
+			byJudge = Array.from({ length: judgeScores.length }, () => []);
+			perDimension.set(s.dimension, byJudge);
+		}
+		byJudge[judgeIndex].push(s.score);
+	}
+	const allValues = [];
+	const pairDiffs = [];
+	for (const [dimension, byJudge] of perDimension) {
+		const scoring = byJudge.filter((scores) => scores.length > 0);
+		if (scoring.length < 2) continue;
+		const itemCount = scoring[0].length;
+		if (scoring.some((scores) => scores.length !== itemCount)) throw new ValidationError(`interRaterReliability: dimension '${dimension}' has judges supplying ${scoring.map((scores) => scores.length).join("/")} scores — items cannot be aligned`);
+		for (let item = 0; item < itemCount; item++) {
+			const ratings = scoring.map((scores) => scores[item]);
+			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;
+}
+/**
+* Corpus-wide inter-rater agreement across N items × M judges × D dimensions, the
+* question `interRaterReliability`'s within-item α cannot answer.
+*
+* 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. Empty input, fewer than 2 judges or
+* items, a judge without scores on a dimension and duplicate records all throw: a silently
+* shrunk matrix would corrupt the overall metric.
+*/
+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 = Object.fromEntries(targetJudges.map((j) => [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)})`);
+		const sortedItems = targetJudges.map((j) => [...byJudge.get(j).keys()]).reduce((common, ids) => common.filter((x) => ids.includes(x))).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 `DimensionJudgeScore[]` data keyed externally by item.
+*
+* Use when you have per-item arrays of `DimensionJudgeScore[]` (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);
+}
+/**
+* Unweighted Cohen's κ for paired nominal labels. Labels carry no order, so a
+* near miss counts as a miss; use `calibrateJudge` for ordinal scores.
+*/
+function nominalAgreement(pairs, options = {}) {
+	if (options.clusters && options.clusters.length !== pairs.length) throw new ValidationError("nominalAgreement: one cluster per pair");
+	const kappaCi = clusterBootstrap(pairs, (_, index) => options.clusters?.[index] ?? String(index), (sample) => cohenKappa(sample).kappa, options);
+	return {
+		n: pairs.length,
+		...cohenKappa(pairs),
+		kappaCi
+	};
+}
+function cohenKappa(pairs) {
+	const n = pairs.length;
+	if (n === 0) return {
+		agreement: NaN,
+		kappa: NaN
+	};
+	const left = /* @__PURE__ */ new Map();
+	const right = /* @__PURE__ */ new Map();
+	let same = 0;
+	for (const [a, b] of pairs) {
+		if (typeof a !== "string" || typeof b !== "string") throw new ValidationError("nominalAgreement: every label must be a string");
+		if (a === b) same += 1;
+		left.set(a, (left.get(a) ?? 0) + 1);
+		right.set(b, (right.get(b) ?? 0) + 1);
+	}
+	const observed = same / n;
+	let expected = 0;
+	for (const [label, count] of left) expected += count / n * ((right.get(label) ?? 0) / n);
+	return {
+		agreement: observed,
+		kappa: expected === 1 ? NaN : (observed - expected) / (1 - expected)
+	};
+}
+// src/statistics/comparison-effects.ts
+function binary(values, name) {
+	if (values.some((value) => value !== 0 && value !== 1)) throw new ValidationError(`${name}: expected binary 0/1 values`);
+}
+/** Mann–Whitney ROC area: ties count half; no observed member of either class means unknown. */
+function rocAuc(scores, labels) {
+	assertFiniteSample("rocAuc", "scores", scores);
+	binary(labels, "rocAuc.labels");
+	if (scores.length !== labels.length) throw new ValidationError("rocAuc: scores and labels must have equal lengths");
+	const ranked = ranks(scores);
+	const positive = labels.reduce((sum, label) => sum + label, 0);
+	const sum = labels.reduce((total, label, index) => total + label * ranked[index], 0);
+	const negative = labels.length - positive;
+	return positive && negative ? (sum - positive * (positive + 1) / 2) / (positive * negative) : null;
+}
+// src/statistics/distribution-summary.ts
+/** Nearest-rank percentile on a sorted, non-empty sample (0-100 scale). */
+function nearestRank(sorted, percentile) {
+	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(percentile / 100 * sorted.length) - 1))];
+}
+/**
+* Nearest-rank percentile on an arbitrary sample, `percentile` on a 0-100
+* scale — the same rule `summarizeDistribution` applies, exposed for a single
+* percentile the summary struct does not carry (e.g. p99.9). Returns NaN for
+* an empty sample; callers that need a numeric floor guard it.
+*/
+function percentileNearestRank(values, percentile) {
+	if (!Array.isArray(values)) throw new ValidationError("percentileNearestRank: values must be an array");
+	if (values.length === 0) return NaN;
+	return nearestRank([...values].sort((a, b) => a - b), percentile);
+}
+function summarizeDistribution(values, options = {}) {
+	if (values.some((value) => !Number.isFinite(value))) throw new ValidationError("summarizeDistribution: samples must be finite");
+	const finite = options.lowerBound === void 0 ? values : values.filter((value) => value >= options.lowerBound);
+	if (finite.length === 0) return {
+		min: NaN,
+		p50: NaN,
+		p90: NaN,
+		p95: NaN,
+		p99: NaN,
+		max: NaN,
+		mean: NaN,
+		n: 0,
+		values: []
+	};
+	const sorted = [...finite].sort((a, b) => a - b);
+	const n = sorted.length;
+	const mean = sorted.reduce((sum, value) => sum + value / n, 0);
+	const sumSquares = sorted.map((value) => value - mean).reduce((sum, value) => sum + value ** 2, 0);
+	const summary = {
+		min: sorted[0],
+		p50: nearestRank(sorted, 50),
+		p90: nearestRank(sorted, 90),
+		p95: nearestRank(sorted, 95),
+		p99: nearestRank(sorted, 99),
+		max: sorted[n - 1],
+		mean,
+		n,
+		values: sorted
+	};
+	if (n >= 2) {
+		const stddev = Math.sqrt(sumSquares / (n - 1));
+		const margin = studentTCritical(n - 1, .95) * stddev / Math.sqrt(n);
+		summary.stddev = stddev;
+		summary.ci95Low = mean - margin;
+		summary.ci95High = mean + margin;
+	}
+	return summary;
+}
+// src/statistics/effect-sizes.ts
+/** Standardized effect sizes; undefined effects remain null. */
+/** Independent Cohen's d, oriented b − a; null below two samples or for an unbounded effect. */
+function cohensD(a, b) {
+	if (a.length < 2 || b.length < 2) return null;
+	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 meanB === meanA ? 0 : null;
+	return (meanB - meanA) / pooled;
+}
+/** Paired Cohen's dz; constant nonzero deltas have no finite standardized effect. */
+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, oriented after − before; empty samples return zero. */
+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;
+}
+/** Romano magnitude thresholds for the absolute Cliff's delta. */
+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";
+}
+// src/math/normal.ts
+/**
+* Standard normal cumulative distribution using Abramowitz and Stegun 7.1.26.
+*
+* The approximation is evaluated as erf(x / sqrt(2)). Computing the negative
+* tail from the complementary term avoids cancellation when x is far below 0.
+* The maximum absolute CDF error is approximately 7.5e-8.
+*/
+function normalCdf(x) {
+	if (x === 0) return .5;
+	const a1 = .254829592;
+	const a2 = -.284496736;
+	const a3 = 1.421413741;
+	const a4 = -1.453152027;
+	const a5 = 1.061405429;
+	const p = .3275911;
+	const scaled = Math.abs(x) / Math.SQRT2;
+	const t = 1 / (1 + p * scaled);
+	const complement = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-scaled * scaled);
+	return x < 0 ? complement / 2 : 1 - complement / 2;
+}
+// src/statistics/inference.ts
+/** Two-sided normal tail, evaluated without subtracting a near-one CDF. */
+function normalTwoSidedPValue(z) {
+	if (Number.isNaN(z)) throw new ValidationError("normalTwoSidedPValue: z must not be NaN");
+	return Math.min(1, 2 * normalCdf(-Math.abs(z)));
+}
+/** Two-sided Student-t tail, preserving small tail probabilities. */
+function studentTTwoSidedPValue(t, df) {
+	if (Number.isNaN(t) || !Number.isFinite(df) || df <= 0) throw new ValidationError("studentTTwoSidedPValue: t must not be NaN and df must be positive and finite");
+	return regularizedIncompleteBeta(df / (df + t * t), df / 2, .5);
+}
+function table(a, b, c, d) {
+	if (![
+		a,
+		b,
+		c,
+		d
+	].every((value) => Number.isSafeInteger(value) && value >= 0) || !Number.isSafeInteger(a + b + c + d)) throw new ValidationError("contingency table: counts and total must be nonnegative safe integers");
+	return a + b + c + d;
+}
+/** Pearson statistic for a 2x2 table; empty or fixed margins have statistic zero. */
+function chiSquared(a, b, c, d) {
+	const n = table(a, b, c, d);
+	if (!n) return 0;
+	const expected = [
+		(a + b) * (a + c) / n,
+		(a + b) * (b + d) / n,
+		(c + d) * (a + c) / n,
+		(c + d) * (b + d) / n
+	];
+	if (expected.some((value) => value === 0)) return 0;
+	return [
+		a,
+		b,
+		c,
+		d
+	].reduce((sum, value, i) => sum + (value - expected[i]) ** 2 / expected[i], 0);
+}
+/** One-degree-of-freedom chi-squared survival probability. */
+function chiSquaredPValue(statistic) {
+	if (Number.isNaN(statistic) || statistic < 0) throw new ValidationError("chiSquaredPValue: statistic must be nonnegative and not NaN");
+	return normalTwoSidedPValue(Math.sqrt(statistic));
+}
+/** Fisher two-sided probability: sum all fixed-margin tables no likelier than the observed table. */
+function fisherExactTwoSided(a, b, c, d) {
+	const n = table(a, b, c, d), row1 = a + b, row2 = c + d, col1 = a + c;
+	if (!n || !row1 || !row2 || !col1 || col1 === n) return 1;
+	const logChoose = (total, count) => lnGamma(total + 1) - lnGamma(count + 1) - lnGamma(total - count + 1);
+	const denominator = logChoose(n, col1);
+	const logP = (count) => logChoose(row1, count) + logChoose(row2, col1 - count) - denominator;
+	const threshold = logP(a) + 1e-7;
+	let p = 0;
+	for (let k = Math.max(0, col1 - row2); k <= Math.min(row1, col1); k++) {
+		const probability = logP(k);
+		if (probability <= threshold) p += Math.exp(probability);
+	}
+	return Math.min(1, p);
+}
+/** Fisher when any expected count is below five; otherwise Pearson's chi-squared tail. */
+function twoByTwoPValue(a, b, c, d) {
+	const n = table(a, b, c, d);
+	if (!n) return 1;
+	return Math.min((a + b) * (a + c), (a + b) * (b + d), (c + d) * (a + c), (c + d) * (b + d)) / n < 5 ? fisherExactTwoSided(a, b, c, d) : chiSquaredPValue(chiSquared(a, b, c, d));
+}
+/** Centered least-squares slope; null p-value means no slope test was possible. */
+function linearRegressionSlope(points) {
+	assertFiniteSample("linearRegressionSlope", "x", points.map((point) => point.x));
+	assertFiniteSample("linearRegressionSlope", "y", points.map((point) => point.y));
+	if (points.length < 2) return {
+		slope: 0,
+		rSquared: 0,
+		slopePValue: null
+	};
+	const n = points.length;
+	const meanX = points.reduce((sum, point) => sum + point.x / n, 0);
+	const meanY = points.reduce((sum, point) => sum + point.y / n, 0);
+	const sxx = points.reduce((sum, point) => sum + (point.x - meanX) ** 2, 0);
+	const syy = points.reduce((sum, point) => sum + (point.y - meanY) ** 2, 0);
+	const sxy = points.reduce((sum, point) => sum + (point.x - meanX) * (point.y - meanY), 0);
+	if (!sxx) return {
+		slope: 0,
+		rSquared: 0,
+		slopePValue: null
+	};
+	const slope = sxy / sxx;
+	const residual = points.reduce((sum, point) => sum + (point.y - meanY - slope * (point.x - meanX)) ** 2, 0);
+	if (![
+		slope,
+		residual,
+		sxx,
+		sxy,
+		syy
+	].every(Number.isFinite)) throw new ValidationError("linearRegressionSlope: sample arithmetic exceeded finite range");
+	return {
+		slope,
+		rSquared: syy === 0 ? 0 : Math.max(0, 1 - residual / syy),
+		slopePValue: n < 3 ? null : residual === 0 ? slope === 0 ? 1 : 0 : studentTTwoSidedPValue(slope / Math.sqrt(residual / (n - 2) / sxx), n - 2)
+	};
+}
+// src/statistics/multiplicity.ts
+/**
+* Multiple-comparison corrections: family-wise error (Bonferroni, Holm) and
+* false discovery rate (Benjamini-Hochberg), with inclusive rejection
+* boundaries throughout.
+*/
+/**
+* Bonferroni adjustment: multiply every p-value by the test count, clamp at 1.
+*
+* Rejects at `p_adjusted ≤ alpha` — the boundary is inclusive, matching
+* {@link holm}, which uniformly dominates this correction and must therefore
+* never reject less. Validates its inputs on the same terms.
+*/
+function bonferroni(pValues, alpha = .05) {
+	assertAlpha("bonferroni", "alpha", alpha);
+	assertPValues("bonferroni", pValues);
+	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) {
+	assertAlpha("holm", "alpha", alpha);
+	assertPValues("holm", pValues);
+	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.
+*
+* Rejects at `q ≤ fdr` — the BH rule is inclusive at the boundary, so an
+* exactly-`fdr` q-value is a discovery.
+*/
+function benjaminiHochberg(pValues, fdr = .05) {
+	assertAlpha("benjaminiHochberg", "fdr", fdr);
+	assertPValues("benjaminiHochberg", pValues);
+	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 = n / rank * entry.p;
+		const bounded = Math.min(minRight, raw);
+		minRight = bounded;
+		q[entry.i] = Math.min(1, bounded);
+	}
+	return {
+		qValues: q,
+		significant: q.map((v) => v <= fdr)
+	};
+}
+function assertAlpha(fn, label, value) {
+	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new ValidationError(`${fn}: ${label} must be in (0,1), got ${value}`);
+}
+function assertPValues(fn, pValues) {
+	for (const [index, pValue] of pValues.entries()) if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) throw new ValidationError(`${fn}: pValues[${index}] must be in [0,1], got ${pValue}`);
+}
+// src/statistics/paired-binary.ts
+/**
+* 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. Counts must be finite nonnegative integers, successes cannot exceed
+* n, and confidence must lie strictly between zero and one. With n = 0 the
+* interval is the full [0, 1] support: no rate is ruled out. The estimate stays
+* 0 for compatibility, not as a measured failure rate; retain n alongside it.
+*/
+function wilson(successes, n, confidence = .95) {
+	if (!Number.isSafeInteger(n) || n < 0) throw new Error("wilson: n must be a finite nonnegative integer");
+	if (!Number.isSafeInteger(successes) || successes < 0 || successes > n) throw new Error(`wilson: successes (${successes}) must be in [0, ${n}]`);
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new Error("wilson: confidence must be between zero and one");
+	if (n === 0) return {
+		estimate: 0,
+		lower: 0,
+		upper: 1
+	};
+	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. With no pairs, returns the
+* full [-1, 1] support and a compatibility point estimate of 0, not equivalence.
+*
+* REPORTING ONLY — do NOT decide a promotion on this interval. The CI is a Wald
+* normal approximation, which badly UNDERCOVERS when only a handful of pairs are
+* discordant: at n = 3 with b = 2, c = 0 it returns [0.133, 1.000], excluding 0,
+* while McNemar's exact test on the same data gives p = 0.50. A gate keying on
+* `lower > 0` would promote noise. Use {@link pairedRiskDifferenceExact}, whose
+* interval is dual to the exact test by construction, for any decision.
+*/
+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: -1,
+		upper: 1,
+		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
+	};
+}
+/**
+* Paired risk difference with the EXACT CONDITIONAL interval — the estimator a
+* promotion gate may decide on.
+*
+* Conditional on the number of discordant pairs m = b + c, the treatment-win
+* count b is Binomial(m, π) with π = P(treatment wins | discordant), and the
+* risk difference is an exact reparameterisation: RD = (2π − 1)·m/n. So a
+* Clopper-Pearson exact interval for π maps straight onto RD. This buys the
+* property the Wald interval in {@link pairedRiskDifference} does not have:
+*
+*   **`lower > 0` ⟺ McNemar's exact test rejects at α = 1 − confidence.**
+*
+* Clopper-Pearson excludes π = 0.5 exactly when the two-sided exact binomial
+* test of π = 0.5 rejects, and that test IS {@link mcnemar}'s p-value — so the
+* interval and the test can never disagree, and a gate keyed on `lower` cannot
+* promote what the exact test refuses. The exact p is returned in the same
+* object so the two are impossible to compute apart.
+*
+* The interval is conservative (exact intervals over-cover; conditioning on m
+* discards the concordant pairs' information about m itself). That is the
+* correct direction for a promotion gate: it refuses more often, never less.
+*
+* With n = 0, returns the full [-1, 1] support, p = 1, and a compatibility
+* point estimate of 0. With n > 0 and m = 0, π is not identified: the result
+* is the degenerate [0, 0] with p = 1. That is NOT evidence of equivalence —
+* callers must treat a zero-width interval as "cannot decide", not as "no
+* difference". Inputs are paired 0/1 (or boolean) arrays, control first.
+* Throws on unequal lengths.
+*/
+function pairedRiskDifferenceExact(control, treatment, confidence = .95) {
+	if (control.length !== treatment.length) throw new Error(`pairedRiskDifferenceExact: unequal sample sizes (${control.length} vs ${treatment.length})`);
+	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedRiskDifferenceExact: confidence must be in (0,1), got ${confidence}`);
+	const n = control.length;
+	if (n === 0) return {
+		n: 0,
+		b: 0,
+		c: 0,
+		nDiscordant: 0,
+		riskDifference: 0,
+		lower: -1,
+		upper: 1,
+		confidence,
+		pValue: 1
+	};
+	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 m = b + c;
+	const riskDifference = (b - c) / n;
+	const pValue = binomialSignTwoSided(b, c);
+	if (m === 0) return {
+		n,
+		b,
+		c,
+		nDiscordant: 0,
+		riskDifference: 0,
+		lower: 0,
+		upper: 0,
+		confidence,
+		pValue
+	};
+	const alpha = 1 - confidence;
+	const piLow = b === 0 ? 0 : betaQuantile(alpha / 2, b, m - b + 1);
+	const piHigh = b === m ? 1 : betaQuantile(1 - alpha / 2, b + 1, m - b);
+	const scale = m / n;
+	return {
+		n,
+		b,
+		c,
+		nDiscordant: m,
+		riskDifference,
+		lower: Math.max(-1, (2 * piLow - 1) * scale),
+		upper: Math.min(1, (2 * piHigh - 1) * scale),
+		confidence,
+		pValue
+	};
+}
+/** Inverse regularized incomplete beta by bisection on
+*  {@link regularizedIncompleteBeta}, which is monotone increasing in x. 80
+*  halvings of [0,1] resolve to ~8e-25, far past the continued fraction's own
+*  3e-15 tolerance, so the quantile is as exact as the CDF it inverts. */
+function betaQuantile(p, a, b) {
+	if (p <= 0) return 0;
+	if (p >= 1) return 1;
+	let lo = 0;
+	let hi = 1;
+	for (let i = 0; i < 80; i++) {
+		const mid = (lo + hi) / 2;
+		if (regularizedIncompleteBeta(mid, a, b) < p) lo = mid;
+		else hi = mid;
+	}
+	return (lo + hi) / 2;
+}
+/**
+* Constrained MLE of q = P(treatment loses) under the hypothesis RD = `delta`.
+*
+* Profiling the two concordant cells out of the multinomial leaves
+* `L(q) = b·log(q+delta) + c·log(q) + e·log(1 − 2q − delta)` with `e = n − b − c`,
+* whose stationary point is the positive root of
+* `2n·q² − [(b + c) − delta·(b + 3c + 2e)]·q − c·delta·(1 − delta) = 0`.
+* At `delta = 0` this returns `(b + c) / 2n`, the familiar null.
+*/
+function constrainedLossRate(b, c, n, delta) {
+	const e = n - b - c;
+	const quadratic = 2 * n;
+	const linear = -(b + c - delta * (b + 3 * c + 2 * e));
+	const constant = -c * delta * (1 - delta);
+	const discriminant = linear * linear - 4 * quadratic * constant;
+	const root = discriminant > 0 ? Math.sqrt(discriminant) : 0;
+	const q = (-linear + root) / (2 * quadratic);
+	return Math.min(Math.max(q, Math.max(0, -delta)), Math.max(0, (1 - delta) / 2));
+}
+/** Tango's score statistic for H0: RD = `delta`. `Var(b − c) = n·(2q + delta −
+*  delta²)` under that hypothesis, evaluated at the constrained MLE of q. */
+function tangoScore(b, c, n, delta) {
+	const numerator = b - c - n * delta;
+	const variance = n * (2 * constrainedLossRate(b, c, n, delta) + delta * (1 - delta));
+	if (!(variance > 0)) {
+		if (numerator === 0) return 0;
+		return numerator > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	}
+	return numerator / Math.sqrt(variance);
+}
+/**
+* Paired risk difference with TANGO'S (1998) SCORE INTERVAL — the estimator a
+* promotion gate may decide on **at a nonzero margin**.
+*
+* {@link pairedRiskDifferenceExact} conditions on the observed discordant count
+* `m = b + c`, builds a Clopper-Pearson interval for the win share among those
+* `m` pairs, and multiplies by the observed `m/n`. That is exact for testing
+* RD = 0 — it is dual to McNemar — but it is NOT a confidence interval for the
+* population risk difference at a nonzero margin, because the sampling
+* variability of `m/n` itself is discarded. The gap is not academic: with the
+* production caller's `pairedDeltaThreshold: -0.05`, a process whose true risk
+* difference sits exactly on that margin clears a nominal-95 % `lower > margin`
+* check 24.75 % of the time at n = 40 and 43.95 % at n = 76 (2000 replicates
+* each) when the conditional interval decides.
+*
+* Tango's interval inverts the score test of RD = delta, which estimates the
+* nuisance loss rate under each hypothesised delta instead of fixing it at the
+* observed value, so `m` contributes its own uncertainty. It is the method
+* `ratesci::scorepairci` uses for paired risk-difference noninferiority, and it
+* is not conditional, so it stays valid as the margin moves away from zero.
+*
+* The bounds are found by bisecting `tangoScore(delta) = ±z` — the score is
+* monotone decreasing in delta, so each crossing is unique. Inputs are paired
+* 0/1 (or boolean) arrays, control first. Throws on unequal lengths.
+*/
+function pairedRiskDifferenceScore(control, treatment, confidence = .95) {
+	if (control.length !== treatment.length) throw new Error(`pairedRiskDifferenceScore: unequal sample sizes (${control.length} vs ${treatment.length})`);
+	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedRiskDifferenceScore: confidence must be in (0,1), got ${confidence}`);
+	const n = control.length;
+	if (n === 0) return {
+		n: 0,
+		b: 0,
+		c: 0,
+		nDiscordant: 0,
+		riskDifference: 0,
+		lower: -1,
+		upper: 1,
+		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 riskDifference = (b - c) / n;
+	const z = zQuantile(1 - (1 - confidence) / 2);
+	let lo = -1;
+	let hi = riskDifference;
+	for (let i = 0; i < 64; i++) {
+		const mid = (lo + hi) / 2;
+		if (tangoScore(b, c, n, mid) > z) lo = mid;
+		else hi = mid;
+	}
+	const lower = (lo + hi) / 2;
+	let ulo = riskDifference;
+	let uhi = 1;
+	for (let i = 0; i < 64; i++) {
+		const mid = (ulo + uhi) / 2;
+		if (tangoScore(b, c, n, mid) > -z) ulo = mid;
+		else uhi = mid;
+	}
+	const upper = (ulo + uhi) / 2;
+	return {
+		n,
+		b,
+		c,
+		nDiscordant: b + c,
+		riskDifference,
+		lower: Math.max(-1, lower),
+		upper: Math.min(1, upper),
+		confidence
+	};
+}
+/**
+* The common positive level `s` such that EVERY value across both paired arms is
+* exactly 0 or `s` — i.e. the outcome is pass/fail, whatever encoding it arrived
+* in. Returns null when the outcomes are not two-point, when the two arms use
+* different levels, or when no positive value was observed at all (all-zero
+* arms: the level is not identified, and there is nothing to decide anyway).
+*
+* This is the scale-aware successor to {@link isBinaryOutcomeVector}, which only
+* recognises literal {0, 1}. Judges in this codebase emit dimensions on 0-100 as
+* well as [0,1] (see `detectScale` in `campaign/gates/statistical-heldout.ts`),
+* so a pass/fail dimension routinely arrives as {0, 100} and a {0,1}-only test
+* silently sends it down the median path that cannot see it. Any positive level
+* is accepted, not just 1 and 100: for a two-point {0, s} outcome the mean paired
+* delta is exactly s·(b − c)/n, so the binary estimators apply after dividing by
+* s and rescaling the result back into the caller's native units.
+*
+* Non-finite values ⇒ null: an unusable outcome must not be classified as a
+* clean pass/fail shape.
+*/
+function pairedBinaryScale(before, after) {
+	let level = null;
+	for (const arm of [before, after]) for (let i = 0; i < arm.length; i++) {
+		const v = arm[i];
+		if (!Number.isFinite(v)) return null;
+		if (v === 0) continue;
+		if (v < 0) return null;
+		if (level === null) level = v;
+		else if (v !== level) return null;
+	}
+	return level;
+}
+/**
+* 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;
+}
+// src/statistics/paired-tests.ts
+/**
+* Paired significance tests on continuous scores: the paired t-test, the
+* promotion-gate paired bootstrap, the exact sign test, and the package-wide
+* paired-delta decision statistic.
+*/
+/**
+* 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.
+*
+* Returns `t = p = null` where the statistic is undefined: fewer than two
+* pairs, or a non-zero constant delta whose observed variance is zero. A
+* constant shift carries no information about the variance it would have to
+* be compared against, so the honest answer is "undefined", not `p = 0` —
+* three observations cannot buy absolute certainty. This is the same contract
+* {@link pairedCohensDz} states for the same condition. An all-zero delta is
+* different: it is a measured null, and returns `t = 0, p = 1`.
+*/
+function pairedTTest(before, after) {
+	if (before.length !== after.length) throw new ValidationError(`pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`);
+	assertFiniteSample("pairedTTest", "before", before);
+	assertFiniteSample("pairedTTest", "after", after);
+	const n = before.length;
+	if (n < 2) return {
+		t: null,
+		df: 0,
+		p: null
+	};
+	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 mean === 0 ? {
+		t: 0,
+		df: n - 1,
+		p: 1
+	} : {
+		t: null,
+		df: n - 1,
+		p: null
+	};
+	const t = mean / se;
+	const df = n - 1;
+	return {
+		t,
+		df,
+		p: 2 * (1 - studentTCdf(Math.abs(t), df))
+	};
+}
+/**
+* Pairs below which a percentile bootstrap interval is descriptive spread only.
+*
+* `P(low > 0)` under a true null, against a nominal 2.5 %, measured over 4000
+* seeded trials: 13.53 % at n = 3, 3.52 % at n = 10, 3.10 % at n = 20 on the
+* median; 13.85 %, 4.90 %, 3.80 % on the mean. This is intrinsic to resampling
+* three points, not an implementation error — scipy's BCa gives 16.0 % on the
+* same n = 3 data — so no change to the estimator moves it. Below this floor
+* the decision belongs to the exact sign test or exact signed-rank test.
+*/
+const BOOTSTRAP_GATE_MIN_N = 20;
+/**
+* Paired bootstrap on (after − before) deltas. Returns a CI on the chosen
+* statistic (median by default); pairs are resampled with replacement. Throws
+* on unequal sample sizes.
+*
+* `low > threshold` carries the stated confidence ONLY at `n ≥
+* {@link BOOTSTRAP_GATE_MIN_N}`, which `gateEligible` reports. Below it the
+* check fires under a true null several times more often than nominal, so the
+* interval is descriptive spread and a promotion must not turn on it.
+*/
+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);
+	const gateEligible = n >= 20;
+	if (n === 0) return {
+		n: 0,
+		median: 0,
+		mean: 0,
+		low: 0,
+		high: 0,
+		confidence,
+		resamples,
+		gateEligible
+	};
+	if (n === 1) {
+		const d = deltas[0];
+		return {
+			n: 1,
+			median: d,
+			mean: d,
+			low: d,
+			high: d,
+			confidence,
+			resamples,
+			gateEligible
+		};
+	}
+	const rng = makeRng(opts.seed, deltas);
+	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,
+		gateEligible
+	};
+}
+/**
+* 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)
+	};
+}
+/** Fraction of paired observations whose delta is an exact tie (|after − before|
+*  < 1e-9). Throws on unequal sample sizes; 0 pairs ⇒ 0. */
+function pairedDeltaTieFraction(before, after) {
+	if (before.length !== after.length) throw new Error(`pairedDeltaTieFraction: unequal sample sizes (${before.length} vs ${after.length})`);
+	const n = before.length;
+	if (n === 0) return 0;
+	let ties = 0;
+	for (let i = 0; i < n; i++) if (Math.abs(after[i] - before[i]) < 1e-9) ties++;
+	return ties / n;
+}
+/**
+* The paired-delta statistic a DECISION is computed on, package-wide.
+*
+* The mean paired delta is the estimator that answers the question a promotion
+* gate asks — "by how much did the candidate move the score" — in the caller's
+* own units, and it equals the aggregate lift everyone quotes. The MEDIAN
+* answers a different question and loses the answer to this one in every regime
+* eval data actually lands in:
+*   - TWO-POINT (pass/fail) outcomes on any encoding: the delta vector lives in
+*     {−s, 0, +s} dominated by zeros, so the median and its whole bootstrap CI
+*     are pinned at exactly 0 however large the shift. (Decide these on
+*     {@link pairedRiskDifferenceExact} instead — same estimand, exact interval.)
+*   - TIE-DOMINATED outcomes: at half the pairs tied the sample median is 0 by
+*     construction, and `ci.low > threshold` then answers "no" forever at a
+*     non-negative threshold and "yes" forever at a negative one.
+*   - LOW-CARDINALITY outcomes, even well below half ties: judge dimensions on
+*     integer 0-100, and block scores like {⅔, 1} from averaging pass/fail
+*     leaves, put the median on a coarse lattice whose bootstrap percentiles
+*     land on atoms. Measured: 26 blocks of 3 pass/fail leaves carrying a real
+*     +12.8pp lift, only 23% of pairs tied, gives a median CI of [0, 0.333] —
+*     lower bound exactly 0, so a gate at threshold 0 refuses a real lift.
+* That last case is why there is no tie-fraction threshold here: any cutoff on
+* ties leaves the lattice case open on the other side of it.
+*
+* `heldoutSignificance` has defaulted to the mean since #316 for the same
+* reason. The median remains available per call site for callers who
+* specifically want outlier robustness and accept the blindness.
+*/
+const DECISION_PAIRED_DELTA_STATISTIC = "mean";
+// src/statistics/power-and-mde.ts
+/**
+* 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.
+*
+* Normal quantiles with no t correction, so treat the result as a LOWER bound:
+* it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where
+* it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller
+* consults to decide whether 3–10 repetitions suffice.
+*/
+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)));
+}
+// src/statistics/rank-tests.ts
+/** Maximum dynamic-programming cells used by an exact two-sample rank test. */
+const MANN_WHITNEY_EXACT_MAX_STATES = 8192;
+/** Maximum inner-loop transitions used by an exact two-sample rank test. */
+const MANN_WHITNEY_EXACT_MAX_WORK = 25e4;
+/** Non-zero differences up to which the signed-rank null is enumerated exactly. */
+const WILCOXON_EXACT_MAX_N = 20;
+/** Resamples used when a rank test falls back to Monte Carlo permutation. */
+const DEFAULT_PERMUTATIONS = 1e5;
+/**
+* Mann-Whitney U — two independent samples, no distributional assumption.
+*
+* Exact conditional (permutation) p by default when the dynamic program fits
+* {@link MANN_WHITNEY_EXACT_MAX_STATES} cells and
+* {@link MANN_WHITNEY_EXACT_MAX_WORK} transitions, seeded Monte Carlo
+* permutation above those limits. This keeps imbalanced designs such as 1+24
+* exact without admitting expensive balanced designs merely because they have
+* the same total size. Throws on non-finite input and on `method:
+* 'asymptotic'` where an exact answer is available. Empty input yields `p = 1,
+* pFloor = 1` — no design, no attainable evidence.
+*/
+function mannWhitneyU(a, b, opts = {}) {
+	assertFiniteSample("mannWhitneyU", "a", a);
+	assertFiniteSample("mannWhitneyU", "b", b);
+	const n1 = a.length;
+	const n2 = b.length;
+	if (n1 === 0 || n2 === 0) return {
+		u: 0,
+		uA: 0,
+		p: 1,
+		method: "exact",
+		pFloor: 1
+	};
+	const total = n1 + n2;
+	const combined = [...a.map((v) => ({
+		v,
+		fromA: true
+	})), ...b.map((v) => ({
+		v,
+		fromA: false
+	}))].sort((x, y) => x.v - y.v);
+	const { midranks, tieTerm } = midranksWithTieTerm(combined.map((entry) => entry.v));
+	let rankSumA = 0;
+	for (let k = 0; k < total; k++) if (combined[k].fromA) rankSumA += midranks[k];
+	const uA = rankSumA - n1 * (n1 + 1) / 2;
+	const u = Math.min(uA, n1 * n2 - uA);
+	const doubled = midranks.map((rank) => Math.round(rank * 2));
+	const doubledDeviation = Math.abs(2 * uA - n1 * n2);
+	const selectedN = Math.min(n1, n2);
+	const otherN = total - selectedN;
+	const exactCost = exactTwoSampleCost(doubled, selectedN);
+	const designFloor = exactTwoSampleFloor(doubled, selectedN);
+	const method = selectRankTestMethod("mannWhitneyU", opts.method ?? "auto", `n1=${n1}, n2=${n2}`, exactCost.states <= MANN_WHITNEY_EXACT_MAX_STATES && exactCost.work <= MANN_WHITNEY_EXACT_MAX_WORK, designFloor, `${MANN_WHITNEY_EXACT_MAX_STATES.toLocaleString("en-US")} states and ${MANN_WHITNEY_EXACT_MAX_WORK.toLocaleString("en-US")} transitions`);
+	if (method === "exact") {
+		const { p, pFloor } = exactTwoSampleP(doubled, selectedN, otherN, doubledDeviation);
+		return {
+			u,
+			uA,
+			p,
+			method,
+			pFloor
+		};
+	}
+	if (method === "asymptotic") return {
+		u,
+		uA,
+		p: asymptoticTwoSidedP(doubledDeviation / 2, twoSampleSigma(n1, n2, total, tieTerm)),
+		method,
+		pFloor: designFloor
+	};
+	const permutations = resolvePermutations("mannWhitneyU", opts.permutations);
+	const rng = opts.seed === void 0 ? makeRng(symmetricTwoSampleSeed(a, b)) : makeRng(opts.seed);
+	let atLeastAsExtreme = 0;
+	const pool = [...doubled];
+	for (let iteration = 0; iteration < permutations; iteration++) {
+		let doubledRankSum = 0;
+		for (let k = 0; k < selectedN; k++) {
+			const pick = k + Math.floor(rng() * (total - k));
+			const swapped = pool[pick];
+			pool[pick] = pool[k];
+			pool[k] = swapped;
+			doubledRankSum += swapped;
+		}
+		if (Math.abs(doubledRankSum - selectedN * (selectedN + 1) - selectedN * otherN) >= doubledDeviation) atLeastAsExtreme++;
+	}
+	const pFloor = Math.max(1 / (permutations + 1), designFloor);
+	return {
+		u,
+		uA,
+		p: Math.max((1 + atLeastAsExtreme) / (permutations + 1), pFloor),
+		method,
+		pFloor
+	};
+}
+/**
+* Wilcoxon signed-rank — paired, no distributional assumption on the deltas.
+*
+* Exact conditional (sign-flip) p by default at `n ≤
+* {@link WILCOXON_EXACT_MAX_N}` non-zero differences, seeded Monte Carlo
+* permutation above it. Throws on non-finite input and on `method:
+* 'asymptotic'` where an exact answer is available.
+*
+* `n` is the count of NON-ZERO differences: exact ties are dropped before
+* ranking, so a run of tied pairs shrinks the design and raises `pFloor`.
+* All-tied input yields `p = 1, pFloor = 1` — no attainable evidence, which
+* `pFloor` states rather than leaving `p = 1` to be read as a measured null.
+*/
+function wilcoxonSignedRank(before, after, opts = {}) {
+	if (before.length !== after.length) throw new ValidationError(`wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`);
+	assertFiniteSample("wilcoxonSignedRank", "before", before);
+	assertFiniteSample("wilcoxonSignedRank", "after", after);
+	const diffs = before.map((b, i) => after[i] - b).filter((d) => d !== 0);
+	const n = diffs.length;
+	if (n === 0) return {
+		w: 0,
+		p: 1,
+		method: "exact",
+		pFloor: 1,
+		nNonZero: 0
+	};
+	const abs = Math.abs(diffs[0]);
+	const allEqualAbs = diffs.every((d) => Math.abs(d) === abs);
+	if ((opts.method === void 0 || opts.method === "auto") && allEqualAbs) {
+		const positive = diffs.filter((d) => d > 0).length;
+		const negative = n - positive;
+		return {
+			w: positive * (n + 1) / 2,
+			p: binomialSignTwoSided(positive, negative),
+			method: "exact",
+			pFloor: Math.min(1, 2 ** (1 - n)),
+			nNonZero: n
+		};
+	}
+	const order = diffs.map((d, i) => ({
+		abs: Math.abs(d),
+		i
+	})).sort((x, y) => x.abs - y.abs);
+	const { midranks, tieTerm } = midranksWithTieTerm(order.map((entry) => entry.abs));
+	const ranks = new Array(n);
+	for (let k = 0; k < n; k++) ranks[order[k].i] = midranks[k];
+	let wPlus = 0;
+	for (let k = 0; k < n; k++) if (diffs[k] > 0) wPlus += ranks[k];
+	const doubled = midranks.map((rank) => Math.round(rank * 2));
+	const doubledDeviation = Math.abs(2 * wPlus - n * (n + 1) / 2);
+	const designFloor = Math.min(1, 2 ** (1 - n));
+	const method = selectRankTestMethod("wilcoxonSignedRank", opts.method ?? "auto", `n=${n} non-zero differences`, n <= WILCOXON_EXACT_MAX_N, designFloor, `${WILCOXON_EXACT_MAX_N} non-zero differences`);
+	if (method === "exact") {
+		const { p, pFloor } = exactSignedRankP(doubled, doubledDeviation);
+		return {
+			w: wPlus,
+			p,
+			method,
+			pFloor,
+			nNonZero: n
+		};
+	}
+	if (method === "asymptotic") {
+		const variance = n * (n + 1) * (2 * n + 1) / 24 - tieTerm / 48;
+		return {
+			w: wPlus,
+			p: asymptoticTwoSidedP(doubledDeviation / 2, Math.sqrt(variance)),
+			method,
+			pFloor: designFloor,
+			nNonZero: n
+		};
+	}
+	const permutations = resolvePermutations("wilcoxonSignedRank", opts.permutations);
+	const rng = makeRng(opts.seed, before, after);
+	const doubledCentre = n * (n + 1) / 2;
+	let atLeastAsExtreme = 0;
+	for (let iteration = 0; iteration < permutations; iteration++) {
+		let doubledWPlus = 0;
+		for (let k = 0; k < n; k++) if (rng() < .5) doubledWPlus += doubled[k];
+		if (Math.abs(doubledWPlus - doubledCentre) >= doubledDeviation) atLeastAsExtreme++;
+	}
+	return {
+		w: wPlus,
+		p: (1 + atLeastAsExtreme) / (permutations + 1),
+		method,
+		pFloor: Math.max(1 / (permutations + 1), designFloor),
+		nNonZero: n
+	};
+}
+/**
+* Average ranks over an ASCENDING-sorted array, plus `Σ(t³ − t)` over tie
+* groups of size `t` — the correction term both asymptotic rank-test variances
+* need.
+*/
+function midranksWithTieTerm(sorted) {
+	const midranks = new Array(sorted.length);
+	let tieTerm = 0;
+	let i = 0;
+	while (i < sorted.length) {
+		let j = i;
+		while (j < sorted.length && sorted[j] === sorted[i]) j++;
+		const average = (i + 1 + j) / 2;
+		for (let k = i; k < j; k++) midranks[k] = average;
+		const groupSize = j - i;
+		if (groupSize > 1) tieTerm += groupSize ** 3 - groupSize;
+		i = j;
+	}
+	return {
+		midranks,
+		tieTerm
+	};
+}
+function selectRankTestMethod(fn, request, design, exactFeasible, designFloor, threshold) {
+	if (request === "auto") return exactFeasible ? "exact" : "permutation";
+	if (request === "exact") {
+		if (exactFeasible) return "exact";
+		throw new ValidationError(`${fn}: method 'exact' is out of range at ${design} — enumeration is bounded by ${threshold}. Use 'auto' for the seeded Monte Carlo permutation, which converges to the same answer.`);
+	}
+	if (exactFeasible) throw new ValidationError(`${fn}: method 'asymptotic' is refused at ${design} — the exact p-grid at this design starts at ${formatProbability(designFloor)}, so an asymptotic p below it describes no attainable outcome. Use method 'exact' (the default) or add repetitions past ${threshold}.`);
+	return "asymptotic";
+}
+function resolvePermutations(fn, permutations) {
+	if (permutations === void 0) return DEFAULT_PERMUTATIONS;
+	if (!Number.isInteger(permutations) || permutations < 1) throw new ValidationError(`${fn}: permutations must be a positive integer, got ${permutations}`);
+	return permutations;
+}
+/** Two-sided normal-approximation tail with the continuity correction. */
+function asymptoticTwoSidedP(deviation, sigma) {
+	if (!(sigma > 0)) return 1;
+	return Math.min(1, 2 * (1 - normalCdf(Math.max(0, deviation - .5) / sigma)));
+}
+/** SD of U under the permutation null, corrected for the realised ties. The
+*  tie term reduces (N+1) and reaches it exactly when every value is tied, so
+*  the variance floors at 0 rather than going negative. */
+function twoSampleSigma(n1, n2, total, tieTerm) {
+	if (total < 2) return 0;
+	const variance = n1 * n2 / 12 * (total + 1 - tieTerm / (total * (total - 1)));
+	return Math.sqrt(Math.max(0, variance));
+}
+function logChoose(n, k) {
+	return lnGamma(n + 1) - lnGamma(k + 1) - lnGamma(n - k + 1);
+}
+function formatProbability(value) {
+	return value >= 1e-4 || value === 0 ? value.toFixed(4) : value.toExponential(3);
+}
+/**
+* Exact DP allocation and loop count for this observed rank vector.
+*
+* The smaller arm is sufficient because selecting its complement produces the
+* same two-sided U deviation while using fewer rows in the state table.
+*/
+function exactTwoSampleCost(doubledRanks, selectedN) {
+	const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0);
+	let work = 0;
+	for (let placed = 0; placed < doubledRanks.length; placed++) work += Math.min(selectedN, placed + 1) * (maxSum - doubledRanks[placed] + 1);
+	return {
+		states: (selectedN + 1) * (maxSum + 1),
+		work
+	};
+}
+/**
+* Smallest attainable two-sided p under the observed ties.
+*
+* Only subsets with the minimum or maximum rank sum can attain the largest
+* deviation. Their multiplicity is the number of ways to choose within the
+* tie group at each boundary, so this calculation is exact without allocating
+* the full null distribution.
+*/
+function exactTwoSampleFloor(doubledRanks, selectedN) {
+	const total = doubledRanks.length;
+	const otherN = total - selectedN;
+	const minimumSum = doubledRanks.slice(0, selectedN).reduce((sum, rank) => sum + rank, 0);
+	const maximumSum = doubledRanks.slice(total - selectedN).reduce((sum, rank) => sum + rank, 0);
+	if (minimumSum === maximumSum) return 1;
+	const centre = selectedN * (selectedN + 1) + selectedN * otherN;
+	const minimumDeviation = Math.abs(minimumSum - centre);
+	const maximumDeviation = Math.abs(maximumSum - centre);
+	const totalLogWays = logChoose(total, selectedN);
+	const minimumMass = Math.exp(logExtremeSubsetWays(doubledRanks, selectedN, "minimum") - totalLogWays);
+	const maximumMass = Math.exp(logExtremeSubsetWays(doubledRanks, selectedN, "maximum") - totalLogWays);
+	if (minimumDeviation > maximumDeviation) return minimumMass;
+	if (maximumDeviation > minimumDeviation) return maximumMass;
+	return Math.min(1, minimumMass + maximumMass);
+}
+function logExtremeSubsetWays(sortedRanks, selectedN, side) {
+	const boundaryIndex = side === "minimum" ? selectedN - 1 : sortedRanks.length - selectedN;
+	const boundary = sortedRanks[boundaryIndex];
+	let first = boundaryIndex;
+	let afterLast = boundaryIndex + 1;
+	while (first > 0 && sortedRanks[first - 1] === boundary) first--;
+	while (afterLast < sortedRanks.length && sortedRanks[afterLast] === boundary) afterLast++;
+	return logChoose(afterLast - first, selectedN - (side === "minimum" ? first : sortedRanks.length - afterLast));
+}
+/**
+* Exact conditional two-sided p for the two-sample rank test.
+*
+* Convolves the observed doubled midranks into the null distribution of group
+* a's rank sum over every `C(n₁+n₂, n₁)` split — identical to enumerating the
+* splits, but `O(N·n₁·ΣR)` instead of `O(C(N,n₁)·n₁n₂)`. Conditioning on the
+* realised multiset makes the tie handling exact rather than a correction.
+*
+* The null is symmetric about `n₁n₂/2` (negating every value maps `U → n₁n₂ −
+* U` and permutes the split set onto itself), so the two-sided p is the mass
+* at least as far from the centre as the observation.
+*/
+function exactTwoSampleP(doubledRanks, n1, n2, doubledDeviation) {
+	const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0);
+	const width = maxSum + 1;
+	const ways = Array.from({ length: n1 + 1 }, () => new Float64Array(width));
+	ways[0][0] = 1;
+	let placed = 0;
+	for (const rank of doubledRanks) {
+		for (let k = Math.min(n1, placed + 1); k >= 1; k--) {
+			const from = ways[k - 1];
+			const into = ways[k];
+			for (let sum = maxSum - rank; sum >= 0; sum--) {
+				const count = from[sum];
+				if (count !== 0) into[sum + rank] += count;
+			}
+		}
+		placed++;
+	}
+	const shift = n1 * (n1 + 1) + n1 * n2;
+	const chosen = ways[n1];
+	let totalWays = 0;
+	let extremeWays = 0;
+	let tailWays = 0;
+	let maxDeviation = -1;
+	for (let sum = 0; sum < width; sum++) {
+		const count = chosen[sum];
+		if (count === 0) continue;
+		totalWays += count;
+		const deviation = Math.abs(sum - shift);
+		if (deviation >= doubledDeviation) tailWays += count;
+		if (deviation > maxDeviation) {
+			maxDeviation = deviation;
+			extremeWays = count;
+		} else if (deviation === maxDeviation) extremeWays += count;
+	}
+	return {
+		p: tailWays / totalWays,
+		pFloor: extremeWays / totalWays
+	};
+}
+/**
+* Exact conditional two-sided p for the paired signed-rank test.
+*
+* Convolves the observed doubled absolute midranks over all `2ⁿ` sign
+* assignments in `O(n·ΣR)`. Probabilities rather than counts keep `2ⁿ` off the
+* arithmetic. The null is symmetric about `n(n+1)/4`.
+*/
+function exactSignedRankP(doubledRanks, doubledDeviation) {
+	const maxSum = doubledRanks.reduce((sum, rank) => sum + rank, 0);
+	const width = maxSum + 1;
+	let mass = new Float64Array(width);
+	mass[0] = 1;
+	for (const rank of doubledRanks) {
+		const next = new Float64Array(width);
+		for (let sum = 0; sum < width; sum++) {
+			const probability = mass[sum];
+			if (probability === 0) continue;
+			next[sum] += probability * .5;
+			next[sum + rank] += probability * .5;
+		}
+		mass = next;
+	}
+	const centre = maxSum / 2;
+	let tail = 0;
+	let extreme = 0;
+	let maxDeviation = -1;
+	for (let sum = 0; sum < width; sum++) {
+		const probability = mass[sum];
+		if (probability === 0) continue;
+		const deviation = Math.abs(sum - centre);
+		if (deviation >= doubledDeviation) tail += probability;
+		if (deviation > maxDeviation) {
+			maxDeviation = deviation;
+			extreme = probability;
+		} else if (deviation === maxDeviation) extreme += probability;
+	}
+	return {
+		p: Math.min(1, tail),
+		pFloor: Math.min(1, extreme)
+	};
+}
+// src/statistics/samples.ts
+/** Interpolated sample median; an empty population has no measured median. */
+function sampleMedian(values) {
+	assertFiniteSample("sampleMedian", "values", values);
+	return values.length ? medianInPlace([...values]) : null;
+}
+/** Descriptive facts, not stability policy or a significance test. */
+function summarizeSample(values, options = {}) {
+	assertFiniteSample("summarizeSample", "values", values);
+	const confidence = options.confidence ?? .95;
+	const resamples = options.resamples ?? 1e3;
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new ValidationError("summarizeSample: confidence must be between zero and one");
+	if (!Number.isSafeInteger(resamples) || resamples < 1) throw new ValidationError("summarizeSample: resamples must be a positive safe integer");
+	const rng = makeRng(options.seed, [...values]);
+	if (!values.length) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const mean = sorted.reduce((sum, value) => sum + value / n, 0);
+	const centered = sorted.map((value) => value - mean);
+	const sumSquares = centered.reduce((sum, value) => sum + value ** 2, 0);
+	const stddev = n > 1 ? Math.sqrt(sumSquares / (n - 1)) : 0;
+	const median = interpolatedQuantile(sorted, .5);
+	const q1 = interpolatedQuantile(sorted, .25);
+	const q3 = interpolatedQuantile(sorted, .75);
+	const iqr = q3 - q1;
+	const deviations = sorted.map((value) => Math.abs(value - median)).sort((a, b) => a - b);
+	const skewness = n >= 3 && stddev > 0 ? n * centered.reduce((sum, value) => sum + (value / stddev) ** 3, 0) / ((n - 1) * (n - 2)) : null;
+	const kurtosis = n >= 4 && stddev > 0 ? n * (n + 1) * centered.reduce((sum, value) => sum + (value / stddev) ** 4, 0) / ((n - 1) * (n - 2) * (n - 3)) - 3 * (n - 1) ** 2 / ((n - 2) * (n - 3)) : null;
+	const bootstrap = [];
+	if (n >= 3) {
+		for (let i = 0; i < resamples; i++) {
+			const sample = Array.from({ length: n }, () => sorted[Math.floor(rng() * n)]);
+			bootstrap.push(medianInPlace(sample));
+		}
+		bootstrap.sort((a, b) => a - b);
+	}
+	const alpha = (1 - confidence) / 2;
+	const summary = {
+		n,
+		median,
+		mean,
+		stddev,
+		q1,
+		q3,
+		iqr,
+		min: sorted[0],
+		max: sorted[n - 1],
+		range: sorted[n - 1] - sorted[0],
+		cv: mean === 0 ? null : stddev / Math.abs(mean),
+		skewness,
+		kurtosis,
+		mad: interpolatedQuantile(deviations, .5),
+		outliers: sorted.filter((value) => value < q1 - 1.5 * iqr || value > q3 + 1.5 * iqr),
+		medianInterval: n < 3 ? null : {
+			low: interpolatedQuantile(bootstrap, alpha),
+			high: interpolatedQuantile(bootstrap, 1 - alpha),
+			confidence,
+			resamples
+		}
+	};
+	if ([
+		mean,
+		stddev,
+		iqr,
+		summary.range,
+		summary.mad,
+		summary.cv,
+		skewness,
+		kurtosis,
+		summary.medianInterval?.low ?? null,
+		summary.medianInterval?.high ?? null
+	].some((value) => value !== null && !Number.isFinite(value))) throw new ValidationError("summarizeSample: sample arithmetic exceeded finite range");
+	return summary;
+}
+// src/statistics/sequential-eprocess.ts
+/**
+* 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;
+	if (opts.resume !== void 0) {
+		const r = assertResumable(opts.resume, {
+			alpha,
+			maxBet,
+			nullMean,
+			threshold
+		});
+		wealth = r.wealth;
+		n = r.n;
+		decided = r.decided;
+		decidedAtN = r.decidedAtN;
+		sumX = r.sumX;
+		varSum = r.varSum;
+	}
+	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,
+				sumX,
+				varSum
+			};
+		}
+	};
+}
+/**
+* Refuse a snapshot that was not produced by an e-process with exactly these
+* parameters, or whose fields cannot all be true at once. Every check names
+* the field, so a refused restart reports what disagrees.
+*/
+function assertResumable(resume, params) {
+	const fail = (detail) => {
+		throw new ValidationError(`eProcess: cannot resume — ${detail}`);
+	};
+	if (typeof resume !== "object" || resume === null) fail(`resume must be an EProcessState object, got ${String(resume)}`);
+	for (const key of [
+		"alpha",
+		"maxBet",
+		"nullMean",
+		"threshold"
+	]) if (resume[key] !== params[key]) fail(`snapshot ${key}=${resume[key]} differs from the process ${key}=${params[key]}; a snapshot continues only the process it was taken from`);
+	const { wealth, n, decided, decidedAtN, sumX, varSum } = resume;
+	if (!Number.isInteger(n) || n < 0) fail(`n must be a non-negative integer, got ${n}`);
+	if (!Number.isFinite(wealth) || wealth <= 0) fail(`wealth must be a finite positive number, got ${wealth}`);
+	if (!Number.isFinite(sumX) || sumX < 0 || sumX > n) fail(`sumX must lie in [0, n=${n}] for observations in [0,1], got ${sumX}`);
+	if (!Number.isFinite(varSum) || varSum < 0) fail(`varSum must be a finite non-negative number, got ${varSum}`);
+	if (typeof decided !== "boolean") fail(`decided must be a boolean, got ${String(decided)}`);
+	if (n === 0 && (wealth !== 1 || sumX !== 0 || varSum !== 0 || decided)) fail("n=0 requires wealth=1, sumX=0, varSum=0, decided=false");
+	if (decided) {
+		if (decidedAtN === void 0 || !Number.isInteger(decidedAtN) || decidedAtN < 1 || decidedAtN > n) fail(`decided requires decidedAtN to be an integer in [1, n=${n}], got ${decidedAtN}`);
+	} else {
+		if (decidedAtN !== void 0) fail(`decidedAtN=${decidedAtN} is set while decided=false`);
+		if (wealth >= params.threshold) fail(`wealth ${wealth} ≥ threshold ${params.threshold} while decided=false; decided latches at the first crossing`);
+	}
+	return resume;
+}
+export { partialCredit as $, linearRegressionSlope as A, rocAuc as B, wilson as C, chiSquared as D, holm as E, cohensD as F, calibrateJudge as G, corpusInterRaterAgreementFromJudgeScores as H, interpretCliffs as I, positionalBias as J, calibrateJudgeContinuous as K, pairedCohensDz as L, studentTTwoSidedPValue as M, twoByTwoPValue as N, chiSquaredPValue as O, cliffsDelta as P, meanConfidenceInterval as Q, percentileNearestRank as R, passAtK as S, bonferroni as T, interRaterReliability as U, corpusInterRaterAgreement as V, nominalAgreement as W, verbosityBias as X, selfPreference as Y, confidenceInterval as Z, mcnemar as _, studentTCdf as _t, wilcoxonSignedRank as a, weightedComposite as at, pairedRiskDifferenceExact as b, pairedMde as c, meanOrNull as ct, BOOTSTRAP_GATE_MIN_N as d, medianInPlace as dt, pearsonR as et, DECISION_PAIRED_DELTA_STATISTIC as f, seedFromData as ft, pairedTTest as g, placeboBand as gt, pairedSignTest as h, clusterBootstrap as ht, mannWhitneyU as i, summarizeNumberSeries as it, normalTwoSidedPValue as j, fisherExactTwoSided as k, requiredPairedSampleSize as l, meanOrZero as lt, pairedDeltaTieFraction as m, DEFAULT_BOOTSTRAP_SEED as mt, sampleMedian as n, spearmanR as nt, mcnemarPower as o, weightedMean as ot, pairedBootstrap as p, zQuantile as pt, continuousAgreement as q, summarizeSample as r, studentTCritical as rt, mcnemarRequiredN as s, mean as st, eProcess as t, ranks as tt, requiredSampleSize as u, makeRng as ut, pairedBinaryScale as v, studentTQuantile as vt, benjaminiHochberg as w, pairedRiskDifferenceScore as x, pairedRiskDifference as y, summarizeDistribution as z };
+
+//# sourceMappingURL=statistics-DCZIC-qT.js.map