@tangle-network/agent-eval 0.133.1 → 0.133.3

package/dist/{statistics-DWM_AyLe.js → statistics-RwRNu2__.js}

@@ -402,14 +402,26 @@ function lnGamma(z) {
 	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 via a Lentz continued fraction. */
+/**
+* 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) / a;
-	const maxIterations = 200;
-	const epsilon = 3e-7;
+	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;
@@ -434,17 +446,42 @@ function regularizedIncompleteBeta(x, a, b) {
 		fraction *= delta;
 		if (Math.abs(delta - 1) < epsilon) break;
 	}
-	return front * fraction;
+	return fraction;
 }
 //#endregion
 //#region src/math/student-t.ts
-/** Student-t CDF via the regularized incomplete beta function. */
+/**
+* Student-t CDF via the regularized incomplete beta function.
+*/
 function studentTCdf(t, degreesOfFreedom) {
 	if (degreesOfFreedom <= 0) return .5;
-	if (degreesOfFreedom > 100) return normalCdf(t);
 	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;
+}
 //#endregion
 //#region src/statistics.ts
 /** Identity: dimensions already follow "higher = better" by prompt convention
@@ -462,7 +499,14 @@ function weightedMean(scores) {
 	}
 	return totalWeight > 0 ? weightedSum / totalWeight : 0;
 }
-/** Bootstrap confidence interval */
+/**
+* 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,
@@ -477,7 +521,7 @@ function confidenceInterval(scores, confidence = .95, opts = {}) {
 	const n = scores.length;
 	const mean = scores.reduce((a, b) => a + b, 0) / n;
 	const B = opts.resamples ?? 1e3;
-	const rng = makeRng(opts.seed);
+	const rng = makeRng(opts.seed, scores);
 	const bootstrapMeans = [];
 	for (let i = 0; i < B; i++) {
 		let sum = 0;
@@ -495,26 +539,45 @@ function confidenceInterval(scores, confidence = .95, opts = {}) {
 	};
 }
 /**
-* Inter-rater reliability — simplified Krippendorff's alpha.
+* 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.
 *
-* Each inner array is one judge's scores for all items.
-* All arrays must have the same length (same items scored).
+* α = 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 dimensionMap = /* @__PURE__ */ new Map();
-	for (const judgeSet of judgeScores) for (const s of judgeSet) {
-		if (!dimensionMap.has(s.dimension)) dimensionMap.set(s.dimension, []);
-		const arr = dimensionMap.get(s.dimension);
-		if (arr.length === 0 || arr[arr.length - 1].length >= judgeScores.length) arr.push([s.score]);
-		else arr[arr.length - 1].push(s.score);
+	const 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 items of dimensionMap.values()) for (const ratings of items) {
-		if (ratings.length < 2) continue;
-		for (const v of ratings) allValues.push(v);
-		for (let i = 0; i < ratings.length; i++) for (let j = i + 1; j < ratings.length; j++) pairDiffs.push((ratings[i] - ratings[j]) ** 2);
+	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;
@@ -528,47 +591,97 @@ function interRaterReliability(judgeScores) {
 	if (expectedDisagreement === 0) return 1;
 	return 1 - observedDisagreement / expectedDisagreement;
 }
+/** 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 test for comparing two independent groups.
-* Returns U statistic and approximate p-value (normal approximation).
+* 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) {
-	if (a.length === 0 || b.length === 0) return {
-		u: 0,
-		p: 1
-	};
+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,
-		group: "a"
+		fromA: true
 	})), ...b.map((v) => ({
 		v,
-		group: "b"
+		fromA: false
 	}))].sort((x, y) => x.v - y.v);
-	const ranks = new Array(combined.length);
-	let i = 0;
-	while (i < combined.length) {
-		let j = i;
-		while (j < combined.length && combined[j].v === combined[i].v) j++;
-		const avgRank = (i + 1 + j) / 2;
-		for (let k = i; k < j; k++) ranks[k] = avgRank;
-		i = j;
+	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 <= 8192 && exactCost.work <= 25e4, 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
+		};
 	}
-	let r1 = 0;
-	for (let k = 0; k < combined.length; k++) if (combined[k].group === "a") r1 += ranks[k];
-	const u1 = r1 - n1 * (n1 + 1) / 2;
-	const u2 = n1 * n2 - u1;
-	const u = Math.min(u1, u2);
-	const mu = n1 * n2 / 2;
-	const sigma = Math.sqrt(n1 * n2 * (n1 + n2 + 1) / 12);
-	if (sigma === 0) return {
+	if (method === "asymptotic") return {
 		u,
-		p: 1
+		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,
-		p: 2 * (1 - normalCdf(Math.abs(u - mu) / sigma))
+		uA,
+		p: Math.max((1 + atLeastAsExtreme) / (permutations + 1), pFloor),
+		method,
+		pFloor
 	};
 }
 /** Partial credit: returns 0-1 ratio of current toward target */
@@ -581,23 +694,37 @@ function partialCredit(current, target) {
 * 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: 0,
+		t: null,
 		df: 0,
-		p: 1
+		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 {
-		t: mean === 0 ? 0 : Infinity,
+	if (se === 0) return mean === 0 ? {
+		t: 0,
+		df: n - 1,
+		p: 1
+	} : {
+		t: null,
 		df: n - 1,
-		p: mean === 0 ? 1 : 0
+		p: null
 	};
 	const t = mean / se;
 	const df = n - 1;
@@ -608,55 +735,101 @@ function pairedTTest(before, after) {
 	};
 }
 /**
-* Wilcoxon signed-rank test — paired non-parametric alternative.
-* Use when the differences aren't normally distributed.
+* 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) {
+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 < 6) return {
+	if (n === 0) return {
 		w: 0,
-		p: 1
+		p: 1,
+		method: "exact",
+		pFloor: 1,
+		nNonZero: 0
 	};
-	const absRanks = diffs.map((d, i) => ({
+	const order = diffs.map((d, i) => ({
 		abs: Math.abs(d),
-		sign: Math.sign(d),
 		i
-	})).sort((a, b) => a.abs - b.abs);
+	})).sort((x, y) => x.abs - y.abs);
+	const { midranks, tieTerm } = midranksWithTieTerm(order.map((entry) => entry.abs));
 	const ranks = new Array(n);
-	let i = 0;
-	while (i < n) {
-		let j = i;
-		while (j < n && absRanks[j].abs === absRanks[i].abs) j++;
-		const avg = (i + 1 + j) / 2;
-		for (let k = i; k < j; k++) ranks[absRanks[k].i] = avg;
-		i = j;
-	}
+	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 mean = n * (n + 1) / 4;
-	const variance = n * (n + 1) * (2 * n + 1) / 24;
-	const z = (wPlus - mean) / Math.sqrt(variance);
-	const p = 2 * (1 - normalCdf(Math.abs(z)));
+	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 <= 20, designFloor, `20 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
+		p: (1 + atLeastAsExtreme) / (permutations + 1),
+		method,
+		pFloor: Math.max(1 / (permutations + 1), designFloor),
+		nNonZero: n
 	};
 }
 /**
 * Cohen's d — standardized effect size for two independent groups.
 * Positive d means group b has higher mean than group a.
 * Rule of thumb: |d| < 0.2 negligible, 0.2–0.5 small, 0.5–0.8 medium, > 0.8 large.
+*
+* Returns null where the standardized effect is undefined: fewer than two
+* observations in either group, or a zero pooled standard deviation with
+* unequal means. Null is NOT "no effect" — zero within-group spread across a
+* real mean gap is an unbounded effect, the opposite of negligible. Equal
+* means with zero spread is a genuine 0. Same contract as
+* {@link pairedCohensDz}.
 */
 function cohensD(a, b) {
-	if (a.length < 2 || b.length < 2) return 0;
+	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 0;
+	if (pooled === 0) return meanB === meanA ? 0 : null;
 	return (meanB - meanA) / pooled;
 }
 /**
@@ -900,6 +1073,11 @@ function requiredSampleSize(opts) {
 /**
 * 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;
@@ -968,13 +1146,21 @@ function mcnemarPower(opts) {
 	const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom;
 	return Math.min(1, Math.max(0, normalCdf(zBeta)));
 }
-/** Bonferroni adjustment: multiply every p-value by the test count, clamp at 1. */
+/**
+* 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)
+		significant: adjusted.map((p) => p <= alpha)
 	};
 }
 /**
@@ -986,8 +1172,8 @@ function bonferroni(pValues, alpha = .05) {
 * strong family-wise error control under arbitrary dependence.
 */
 function holm(pValues, alpha = .05) {
-	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new ValidationError(`holm: alpha must be in (0,1), got ${alpha}`);
-	for (const [index, pValue] of pValues.entries()) if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) throw new ValidationError(`holm: pValues[${index}] must be in [0,1], got ${pValue}`);
+	assertAlpha("holm", "alpha", alpha);
+	assertPValues("holm", pValues);
 	const count = pValues.length;
 	if (count === 0) return {
 		adjusted: [],
@@ -1013,8 +1199,13 @@ function holm(pValues, alpha = .05) {
 /**
 * 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: [],
@@ -1029,21 +1220,42 @@ function benjaminiHochberg(pValues, fdr = .05) {
 	for (let k = n - 1; k >= 0; k--) {
 		const rank = k + 1;
 		const entry = indexed[k];
-		const raw = entry.p * n / rank;
+		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)
+		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}`);
+}
+/**
+* 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. The
-* lower bound is what the promotion gate checks — `low > threshold` means the
-* gain is real at the confidence level. Throws on unequal sample sizes.
+* 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})`);
@@ -1053,6 +1265,7 @@ function pairedBootstrap(before, after, opts = {}) {
 	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,
@@ -1060,7 +1273,8 @@ function pairedBootstrap(before, after, opts = {}) {
 		low: 0,
 		high: 0,
 		confidence,
-		resamples
+		resamples,
+		gateEligible
 	};
 	if (n === 1) {
 		const d = deltas[0];
@@ -1071,10 +1285,11 @@ function pairedBootstrap(before, after, opts = {}) {
 			low: d,
 			high: d,
 			confidence,
-			resamples
+			resamples,
+			gateEligible
 		};
 	}
-	const rng = makeRng(opts.seed);
+	const rng = makeRng(opts.seed, deltas);
 	const samples = new Array(resamples);
 	for (let b = 0; b < resamples; b++) if (statistic === "mean") {
 		let sum = 0;
@@ -1096,7 +1311,8 @@ function pairedBootstrap(before, after, opts = {}) {
 		low: samples[lowIdx],
 		high: samples[Math.max(highIdx, lowIdx)],
 		confidence,
-		resamples
+		resamples,
+		gateEligible
 	};
 }
 /**
@@ -1369,6 +1585,209 @@ function eProcess(opts = {}) {
 		}
 	};
 }
+/** 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]}`);
+}
+/**
+* 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)
+	};
+}
 /** Standard-normal inverse CDF (Acklam approximation). */
 function zQuantile(p) {
 	if (p <= 0 || p >= 1) {
@@ -1427,16 +1846,45 @@ function medianInPlace(xs) {
 	const mid = Math.floor(xs.length / 2);
 	return xs.length % 2 === 0 ? (xs[mid - 1] + xs[mid]) / 2 : xs[mid];
 }
-function makeRng(seed) {
-	if (seed === void 0) return Math.random;
-	return mulberry32(seed);
+/**
+* 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);
 }
 /** Tiny seedable PRNG (mulberry32) — deterministic resampling/shuffling, not
 *  cryptographic. Exported so e-process shuffles and bootstrap resampling
-*  share ONE PRNG implementation; a seed is REQUIRED (unseeded randomness in
-*  gate verdicts is non-reproducible by construction). */
+*  share ONE PRNG implementation. Every distinct 32-bit seed gives a distinct
+*  stream, including 0. */
 function mulberry32(seed) {
-	let s = seed | 0 || 2654435769;
+	if (!Number.isFinite(seed)) throw new ValidationError(`mulberry32: seed must be a finite number, got ${seed}`);
+	let s = seed | 0;
 	return () => {
 		s = s + 1831565813 | 0;
 		let t = s;
@@ -1446,6 +1894,6 @@ function mulberry32(seed) {
 	};
 }
 //#endregion
-export { spearmanR as A, positionalBias as B, pairedTTest as C, ranks as D, pearsonR as E, studentTCdf as F, verbosityBias as H, normalCdf as I, calibrateJudge as L, weightedMean as M, wilcoxonSignedRank as N, requiredPairedSampleSize as O, wilson as P, calibrateJudgeContinuous as R, pairedSignTest as S, passAtK as T, selfPreference as V, normalizeScores as _, confidenceInterval as a, pairedMde as b, eProcess as c, interpretCliffs as d, mannWhitneyU as f, mulberry32 as g, mcnemarRequiredN as h, cohensD as i, weightedComposite as j, requiredSampleSize as k, holm as l, mcnemarPower as m, bonferroni as n, corpusInterRaterAgreement as o, mcnemar as p, cliffsDelta as r, corpusInterRaterAgreementFromJudgeScores as s, benjaminiHochberg as t, interRaterReliability as u, pairedBootstrap as v, partialCredit as w, pairedRiskDifference as x, pairedCohensDz as y, continuousAgreement as z };
+export { passAtK as A, studentTCdf as B, pairedBootstrap as C, pairedSignTest as D, pairedRiskDifference as E, spearmanR as F, continuousAgreement as G, normalCdf as H, weightedComposite as I, verbosityBias as J, positionalBias as K, weightedMean as L, ranks as M, requiredPairedSampleSize as N, pairedTTest as O, requiredSampleSize as P, wilcoxonSignedRank as R, normalizeScores as S, pairedMde as T, calibrateJudge as U, studentTQuantile as V, calibrateJudgeContinuous as W, mannWhitneyU as _, WILCOXON_EXACT_MAX_N as a, mcnemarRequiredN as b, cliffsDelta as c, corpusInterRaterAgreement as d, corpusInterRaterAgreementFromJudgeScores as f, interpretCliffs as g, interRaterReliability as h, MANN_WHITNEY_EXACT_MAX_WORK as i, pearsonR as j, partialCredit as k, cohensD as l, holm as m, DEFAULT_PERMUTATIONS as n, benjaminiHochberg as o, eProcess as p, selfPreference as q, MANN_WHITNEY_EXACT_MAX_STATES as r, bonferroni as s, BOOTSTRAP_GATE_MIN_N as t, confidenceInterval as u, mcnemar as v, pairedCohensDz as w, mulberry32 as x, mcnemarPower as y, wilson as z };
 
-//# sourceMappingURL=statistics-DWM_AyLe.js.map
+//# sourceMappingURL=statistics-RwRNu2__.js.map