@tangle-network/agent-eval 1.0.19 → 1.0.21

package/dist/paired-arms-3-tsXvvC.js

@@ -1,740 +0,0 @@
-import { s as ValidationError } from "./errors-DeEEV9Vx.js";
-import { a as findingTreatmentSchema } from "./finding-composition-Belh_qU3.js";
-import { a as assertFiniteSample, d as symmetricTwoSampleSeed, h as lnGamma, l as makeRng, s as binomialSignTwoSided } from "./mean-D1d6gedE.js";
-import { r as pairedRiskDifference, t as mcnemar } from "./paired-binary-CMzmSSd5.js";
-import { r as pairedBootstrap } from "./paired-tests-Buh6feJ4.js";
-// src/arm-populations.ts
-const keyOf = (row) => JSON.stringify([
-	row.arm,
-	row.pairKey,
-	row.repKey ?? null
-]);
-function checkIdentity(row) {
-	for (const value of [
-		row.arm,
-		row.pairKey,
-		...row.repKey === void 0 ? [] : [row.repKey]
-	]) if (typeof value !== "string" || !value.trim()) throw new TypeError("Arm assignments require nonempty identities");
-	if (row.treatment !== void 0) {
-		if (!Array.isArray(row.treatment)) throw new TypeError("Arm treatment must be an array");
-		for (const value of row.treatment) findingTreatmentSchema.parse(value);
-		if (new Set(row.treatment.map((t) => t.id)).size !== row.treatment.length) throw new TypeError("Duplicate arm treatment id");
-	}
-}
-function checkObservation(row) {
-	checkIdentity(row);
-	if (row.pass != null && typeof row.pass !== "boolean") throw new TypeError("Invalid arm pass value");
-	if (row.formation !== void 0) {
-		if (row.formation === null || typeof row.formation !== "object") throw new TypeError("Invalid formation verdict");
-		if (row.formation.formed !== null && typeof row.formation.formed !== "boolean") throw new TypeError("Invalid formation state");
-		if (row.formation.reason !== void 0 && typeof row.formation.reason !== "string") throw new TypeError("Invalid formation reason");
-	}
-	for (const value of Object.values(row.metrics ?? {})) if (value !== null && !Number.isFinite(value)) throw new TypeError("Non-finite arm metric");
-}
-/** One roster join serves comparison and both denominators; no outcomes are inferred from formation. */
-function prepareArmPopulations(observations, assignments, options) {
-	const arms = [options.baselineArm, options.treatmentArm];
-	const roster = /* @__PURE__ */ new Map();
-	for (const entry of assignments) {
-		if (!arms.includes(entry.arm)) continue;
-		checkIdentity(entry);
-		const key = keyOf(entry);
-		if (roster.has(key)) throw new TypeError("Duplicate arm assignment");
-		roster.set(key, structuredClone(entry));
-	}
-	for (const arm of arms) if (![...roster.values()].some((r) => r.arm === arm)) throw new TypeError(`No assignment roster for arm '${arm}'`);
-	const actual = /* @__PURE__ */ new Map();
-	for (const row of observations) {
-		if (!arms.includes(row.arm)) continue;
-		checkObservation(row);
-		const key = keyOf(row);
-		if (!roster.has(key)) throw new TypeError("Observed seed is outside the assignment roster");
-		if (actual.has(key)) throw new TypeError("Duplicate arm observation");
-		actual.set(key, row);
-	}
-	const ordered = [...roster.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-	const rows = ordered.map(([key, entry]) => actual.get(key) ?? entry);
-	const metricNames = options.metricNames ?? [...new Set([...actual.values()].flatMap((r) => Object.keys(r.metrics ?? {})))].sort();
-	return {
-		rows,
-		readings: arms.map((arm) => {
-			const declared = ordered.filter(([, r]) => r.arm === arm);
-			const asAssigned = declared.map(([key]) => actual.get(key));
-			const asFormed = asAssigned.filter((row) => row?.formation?.formed === true);
-			return {
-				arm,
-				assignments: declared.map(([, r]) => r),
-				missingObservations: asAssigned.filter((r) => r === void 0).length,
-				formation: {
-					formed: asFormed.length,
-					notFormed: asAssigned.filter((r) => r?.formation?.formed === false).length,
-					unknown: asAssigned.filter((r) => r?.formation?.formed == null).length
-				},
-				asAssigned: summarize(asAssigned, metricNames),
-				asFormed: summarize(asFormed, metricNames)
-			};
-		})
-	};
-}
-function summarize(rows, names) {
-	const passed = rows.filter((r) => r?.pass === true).length;
-	const failed = rows.filter((r) => r?.pass === false).length;
-	const missingOutcomes = rows.length - passed - failed;
-	const metrics = Object.fromEntries(names.map((name) => {
-		const values = rows.map((r) => r?.metrics?.[name]).filter((x) => x != null);
-		const sum = values.length ? values.reduce((s, v) => s + v, 0) : null;
-		return [name, {
-			n: values.length,
-			missing: rows.length - values.length,
-			sum,
-			mean: sum === null ? null : sum / values.length
-		}];
-	}));
-	return {
-		n: rows.length,
-		passed,
-		failed,
-		missingOutcomes,
-		passRate: rows.length && !missingOutcomes ? passed / rows.length : null,
-		metrics
-	};
-}
-// 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/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/paired-arms.ts
-/**
-* Match rows across two arms into (baseline, treatment) pairs by `pairKey`.
-*
-* A `pairKey` with at most one row per arm pairs directly, no `repKey`
-* needed. A `pairKey` with multiple reps in either arm requires `repKey` on
-* every one of its rows, and reps pair only on exact (`pairKey`, `repKey`)
-* match — pairing is keyed purely on row identity, never on outcome content
-* (outcome-keyed matching deflates discordant counts and biases McNemar), and
-* is therefore independent of input order. Reps whose `repKey` has no
-* counterpart in the other arm, and items present in only one arm, land in
-* the unpaired lists — reported, never truncated.
-*
-* Fail-loud: throws when either named arm has zero rows (an unknown arm
-* name would otherwise read as "everything unpaired"), when the two arm
-* names are equal, when a multi-rep `pairKey` has a row without `repKey`, or
-* when a (`pairKey`, arm) group repeats a `repKey` (the match would be
-* ambiguous).
-*/
-function pairArms(rows, opts) {
-	const { baselineArm, treatmentArm } = opts;
-	if (baselineArm === treatmentArm) throw new ValidationError(`pairArms: baselineArm and treatmentArm are both '${baselineArm}' — an arm cannot be compared to itself`);
-	const byArm = /* @__PURE__ */ new Map();
-	const armsSeen = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		armsSeen.add(row.arm);
-		if (row.arm !== baselineArm && row.arm !== treatmentArm) continue;
-		const byKey = byArm.get(row.arm) ?? /* @__PURE__ */ new Map();
-		const group = byKey.get(row.pairKey) ?? [];
-		group.push(row);
-		byKey.set(row.pairKey, group);
-		byArm.set(row.arm, byKey);
-	}
-	for (const arm of [baselineArm, treatmentArm]) if (!byArm.has(arm)) {
-		const seen = [...armsSeen].sort().join(", ") || "<none>";
-		throw new ValidationError(`pairArms: no rows for arm '${arm}' (arms present: ${seen})`);
-	}
-	const baselineByKey = byArm.get(baselineArm);
-	const treatmentByKey = byArm.get(treatmentArm);
-	const allKeys = [.../* @__PURE__ */ new Set([...baselineByKey.keys(), ...treatmentByKey.keys()])].sort();
-	const pairs = [];
-	const unpairedBaseline = [];
-	const unpairedTreatment = [];
-	for (const pairKey of allKeys) {
-		const b = baselineByKey.get(pairKey) ?? [];
-		const t = treatmentByKey.get(pairKey) ?? [];
-		if (b.length <= 1 && t.length <= 1) {
-			if (b.length === 1 && t.length === 1) {
-				const baseline = b[0];
-				const treatment = t[0];
-				if (baseline.repKey !== void 0 || treatment.repKey !== void 0) {
-					if (baseline.repKey === void 0 || treatment.repKey === void 0 || baseline.repKey !== treatment.repKey) {
-						unpairedBaseline.push(baseline);
-						unpairedTreatment.push(treatment);
-						continue;
-					}
-				}
-				pairs.push({
-					pairKey,
-					repIndex: 0,
-					baseline,
-					treatment
-				});
-			} else {
-				unpairedBaseline.push(...b);
-				unpairedTreatment.push(...t);
-			}
-			continue;
-		}
-		const bByRep = indexByRepKey(b, pairKey, baselineArm);
-		const tByRep = indexByRepKey(t, pairKey, treatmentArm);
-		const repKeys = [.../* @__PURE__ */ new Set([...bByRep.keys(), ...tByRep.keys()])].sort();
-		let repIndex = 0;
-		for (const repKey of repKeys) {
-			const baseline = bByRep.get(repKey);
-			const treatment = tByRep.get(repKey);
-			if (baseline !== void 0 && treatment !== void 0) pairs.push({
-				pairKey,
-				repIndex: repIndex++,
-				baseline,
-				treatment
-			});
-			else if (baseline !== void 0) unpairedBaseline.push(baseline);
-			else if (treatment !== void 0) unpairedTreatment.push(treatment);
-		}
-	}
-	return {
-		pairs,
-		unpairedBaseline,
-		unpairedTreatment
-	};
-}
-/** Index a multi-rep (pairKey, arm) group by `repKey`, enforcing that every
-*  row carries one and that no repKey repeats within the group. */
-function indexByRepKey(group, pairKey, arm) {
-	const byRep = /* @__PURE__ */ new Map();
-	for (const row of group) {
-		if (row.repKey === void 0) throw new ValidationError(`pairArms: pairKey '${pairKey}' has multiple reps in an arm, but a row in arm '${arm}' is missing repKey — multi-rep items require an explicit repKey on every row so reps pair by identity (pairing reps by outcome or by index would bias the paired statistics)`);
-		if (byRep.has(row.repKey)) throw new ValidationError(`pairArms: duplicate repKey '${row.repKey}' for pairKey '${pairKey}' in arm '${arm}' — (pairKey, repKey) must uniquely identify a rep within an arm`);
-		byRep.set(row.repKey, row);
-	}
-	return byRep;
-}
-/**
-* Full matched-pair arm comparison: pair via {@link pairArms}, then compose
-* the paired estimators from `statistics` over the matched pairs.
-*
-* Correctness uses only the pairs where both sides carry `pass` (`mcnemar.n`
-* is that subset's size); each metric uses only the pairs where both sides
-* carry a finite value for it, with the remainder counted in `nMissing`.
-* Deltas are treatment − baseline throughout. With an assignment roster, pairing
-* covers declared seed identities; missing observations remain identity-only rows
-* and never contribute fabricated outcomes or metrics. Per-arm summaries report
-* every assignment and the explicitly formed subset separately.
-*
-* Fail-loud: inherits {@link pairArms}'s unknown-arm throw, and throws on a
-* non-finite metric value — silently treating corrupt telemetry as "metric
-* absent" would misreport it as missing coverage.
-*/
-function comparePairedArms(rows, opts) {
-	const populations = opts.assignments === void 0 ? void 0 : prepareArmPopulations(rows, opts.assignments, opts);
-	const { pairs, unpairedBaseline, unpairedTreatment } = pairArms(populations?.rows ?? rows, opts);
-	let correctness = null;
-	const baselinePass = [];
-	const treatmentPass = [];
-	for (const pair of pairs) {
-		if (pair.baseline.pass == null || pair.treatment.pass == null) continue;
-		baselinePass.push(pair.baseline.pass ? 1 : 0);
-		treatmentPass.push(pair.treatment.pass ? 1 : 0);
-	}
-	if (baselinePass.length > 0) {
-		const mc = mcnemar(baselinePass, treatmentPass);
-		correctness = {
-			b10: mc.b,
-			b01: mc.c,
-			mcnemar: mc,
-			riskDifference: pairedRiskDifference(baselinePass, treatmentPass)
-		};
-	}
-	const metricDeltas = (opts.metricNames ?? [...new Set(pairs.flatMap((p) => [...Object.keys(p.baseline.metrics ?? {}), ...Object.keys(p.treatment.metrics ?? {})]))].sort()).map((name) => {
-		const before = [];
-		const after = [];
-		let nMissing = 0;
-		for (const pair of pairs) {
-			const b = metricValue(pair.baseline, name);
-			const t = metricValue(pair.treatment, name);
-			if (b === void 0 || t === void 0) {
-				nMissing++;
-				continue;
-			}
-			before.push(b);
-			after.push(t);
-		}
-		const bootstrapCi = before.length === 0 ? null : pairedBootstrap(before, after, opts.bootstrap);
-		return {
-			name,
-			n: before.length,
-			nMissing,
-			medianDelta: bootstrapCi?.median ?? null,
-			meanDelta: bootstrapCi?.mean ?? null,
-			bootstrapCi,
-			wilcoxon: before.length === 0 ? null : wilcoxonSignedRank(before, after)
-		};
-	});
-	return {
-		...populations ? { armPopulations: populations.readings } : {},
-		nPairs: pairs.length,
-		nUnpairedBaseline: unpairedBaseline.length,
-		nUnpairedTreatment: unpairedTreatment.length,
-		correctness,
-		metricDeltas
-	};
-}
-/**
-* Pair two RunRecord arms by the identity of the evaluated work:
-* `(experimentId, scenarioId, seed)`.
-*
-* Falling back to array order, candidate id, or experiment id can compare
-* different tasks and fabricate lift. Duplicate identities throw.
-*/
-function pairRunRecords(baselineRuns, treatmentRuns) {
-	const baselineRows = runRecordArmRows(baselineRuns, "baseline");
-	const treatmentRows = runRecordArmRows(treatmentRuns, "treatment");
-	validateRunRecordArmRows(baselineRows, "baseline");
-	validateRunRecordArmRows(treatmentRows, "treatment");
-	if (baselineRows.length === 0 || treatmentRows.length === 0) return {
-		pairs: [],
-		unpairedBaseline: baselineRows.map((row) => row.run),
-		unpairedTreatment: treatmentRows.map((row) => row.run)
-	};
-	const result = pairArms([...baselineRows, ...treatmentRows], {
-		baselineArm: "baseline",
-		treatmentArm: "treatment"
-	});
-	return {
-		pairs: result.pairs.map((pair) => {
-			const baseline = pair.baseline;
-			const treatment = pair.treatment;
-			return {
-				pairKey: pair.pairKey,
-				repKey: baseline.repKey,
-				baseline: baseline.run,
-				treatment: treatment.run
-			};
-		}),
-		unpairedBaseline: result.unpairedBaseline.map((row) => row.run),
-		unpairedTreatment: result.unpairedTreatment.map((row) => row.run)
-	};
-}
-function runRecordArmRows(runs, arm) {
-	return runs.map((run) => {
-		const scenarioId = run.scenarioId.trim();
-		if (!scenarioId) throw new ValidationError(`pairRunRecords: run '${run.runId}' is missing scenarioId; paired comparisons require explicit scenario identity`);
-		return {
-			pairKey: JSON.stringify([run.experimentId, scenarioId]),
-			repKey: String(run.seed),
-			arm,
-			run
-		};
-	});
-}
-function validateRunRecordArmRows(rows, arm) {
-	const byPairKey = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const group = byPairKey.get(row.pairKey) ?? [];
-		group.push(row);
-		byPairKey.set(row.pairKey, group);
-	}
-	for (const [pairKey, group] of byPairKey) if (group.length > 1) indexByRepKey(group, pairKey, arm);
-}
-function metricValue(row, name) {
-	const v = row.metrics?.[name];
-	if (v == null) return void 0;
-	if (!Number.isFinite(v)) throw new ValidationError(`comparePairedArms: non-finite value for metric '${name}' on pairKey '${row.pairKey}' (arm '${row.arm}'): ${v}`);
-	return v;
-}
-export { wilcoxonSignedRank as a, mannWhitneyU as i, pairArms as n, normalCdf as o, pairRunRecords as r, comparePairedArms as t };
-
-//# sourceMappingURL=paired-arms-3-tsXvvC.js.map