@tangle-network/agent-eval 0.27.0 → 0.27.2

package/dist/chunk-R5UQJNKC.js

@@ -0,0 +1,722 @@
+import {
+  ValidationError
+} from "./chunk-NG236HPC.js";
+
+// src/judge-calibration.ts
+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);
+  const pearson = pearsonR(humans, judges);
+  const kappa = weightedKappa(humans.map(Math.round), judges.map(Math.round));
+  const absDiffs = common.map((c) => Math.abs(c.j - c.h));
+  const mae = absDiffs.reduce((a, b) => a + b, 0) / n;
+  const worst = [...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);
+  return { n, pearson, kappa, mae, worstItems: worst };
+}
+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
+  };
+}
+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
+  };
+}
+function pearsonR(a, b) {
+  if (a.length !== b.length || a.length < 2) return NaN;
+  const mA = a.reduce((s, v) => s + v, 0) / a.length;
+  const mB = b.reduce((s, v) => s + v, 0) / b.length;
+  let num = 0, dA = 0, dB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const da = a[i] - mA;
+    const db = b[i] - mB;
+    num += da * db;
+    dA += da * da;
+    dB += db * db;
+  }
+  if (dA === 0 || dB === 0) return dA === 0 && dB === 0 ? 1 : 0;
+  return num / Math.sqrt(dA * dB);
+}
+function weightedKappa(a, b) {
+  if (a.length !== b.length || a.length === 0) return NaN;
+  const min = Math.min(...a, ...b);
+  const max = Math.max(...a, ...b);
+  const K = max - 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;
+}
+function continuousAgreement(scores, opts = {}) {
+  const bootstrap = opts.bootstrap ?? 1e3;
+  const weights = opts.weights ?? "quadratic";
+  const seed = opts.seed ?? 12648430;
+  const ciLevel = opts.ciLevel ?? 0.95;
+  const matrix = scores.filter((row) => row.length >= 2 && row.every((v) => Number.isFinite(v)));
+  const raters = matrix[0]?.length ?? 0;
+  const clean = matrix.filter((row) => row.length === raters);
+  const nClean = clean.length;
+  if (nClean < 2 || raters < 2) {
+    return {
+      weightedKappa: NaN,
+      icc: NaN,
+      pearson: NaN,
+      spearman: NaN,
+      ci: { icc: [NaN, NaN], weightedKappa: [NaN, NaN] },
+      n: nClean,
+      raters
+    };
+  }
+  const kappa = continuousWeightedKappa(clean, weights);
+  const icc = icc21(clean);
+  const pearson = avgPairwise(clean, pearsonR);
+  const spearman = avgPairwise(clean, spearmanR);
+  const ciIcc = [NaN, NaN];
+  const ciKappa = [NaN, NaN];
+  if (bootstrap > 0) {
+    const rng = mulberry32(seed);
+    const iccs = [];
+    const kappas = [];
+    for (let b = 0; b < bootstrap; b++) {
+      const sample = new Array(nClean);
+      for (let i = 0; i < nClean; i++) {
+        sample[i] = clean[Math.floor(rng() * nClean)];
+      }
+      const iccB = icc21(sample);
+      const kB = continuousWeightedKappa(sample, weights);
+      if (Number.isFinite(iccB)) iccs.push(iccB);
+      if (Number.isFinite(kB)) kappas.push(kB);
+    }
+    const [lo, hi] = percentileBounds(ciLevel);
+    if (iccs.length > 0) {
+      iccs.sort((a, b) => a - b);
+      ciIcc[0] = quantile(iccs, lo);
+      ciIcc[1] = quantile(iccs, hi);
+    }
+    if (kappas.length > 0) {
+      kappas.sort((a, b) => a - b);
+      ciKappa[0] = quantile(kappas, lo);
+      ciKappa[1] = quantile(kappas, hi);
+    }
+  }
+  return {
+    weightedKappa: kappa,
+    icc,
+    pearson,
+    spearman,
+    ci: { icc: ciIcc, weightedKappa: ciKappa },
+    n: nClean,
+    raters
+  };
+}
+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
+  };
+}
+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;
+}
+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;
+}
+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 a = rows.map((row) => row[i]);
+      const b = rows.map((row) => row[j]);
+      const r = fn(a, b);
+      if (Number.isFinite(r)) {
+        sum += r;
+        pairs++;
+      }
+    }
+  }
+  return pairs === 0 ? NaN : sum / pairs;
+}
+function spearmanR(a, b) {
+  if (a.length !== b.length || a.length < 2) return NaN;
+  return pearsonR(rankWithTies(a), rankWithTies(b));
+}
+function rankWithTies(xs) {
+  const n = xs.length;
+  const indexed = xs.map((v, i2) => ({ v, i: i2 }));
+  indexed.sort((x, y) => x.v - y.v);
+  const ranks = new Array(n).fill(0);
+  let i = 0;
+  while (i < n) {
+    let j = i;
+    while (j + 1 < n && indexed[j + 1].v === indexed[i].v) j++;
+    const avg = (i + j) / 2 + 1;
+    for (let k = i; k <= j; k++) ranks[indexed[k].i] = avg;
+    i = j + 1;
+  }
+  return ranks;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function percentileBounds(ciLevel) {
+  const tail = (1 - ciLevel) / 2;
+  return [tail, 1 - tail];
+}
+function quantile(sorted, q) {
+  if (sorted.length === 0) return NaN;
+  if (sorted.length === 1) return sorted[0];
+  const pos = q * (sorted.length - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  if (lo === hi) return sorted[lo];
+  const frac = pos - lo;
+  return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+}
+
+// src/statistics.ts
+var INVERTED_DIMENSIONS = /* @__PURE__ */ new Set(["hallucination", "false_confidence", "worst_failure"]);
+function normalizeScores(scores) {
+  return scores.map((s) => {
+    if (INVERTED_DIMENSIONS.has(s.dimension)) {
+      return s;
+    }
+    return s;
+  });
+}
+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;
+}
+function confidenceInterval(scores, confidence = 0.95) {
+  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 = 1e3;
+  const bootstrapMeans = [];
+  for (let i = 0; i < B; i++) {
+    let sum = 0;
+    for (let j = 0; j < n; j++) {
+      sum += scores[Math.floor(Math.random() * 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)]
+  };
+}
+function interRaterReliability(judgeScores) {
+  if (judgeScores.length < 2) return 1;
+  const dimensionMap = /* @__PURE__ */ new Map();
+  for (const judgeSet of judgeScores) {
+    for (const s of judgeSet) {
+      if (!dimensionMap.has(s.dimension)) dimensionMap.set(s.dimension, []);
+      const arr = dimensionMap.get(s.dimension);
+      if (arr.length === 0 || arr[arr.length - 1].length >= judgeScores.length) {
+        arr.push([s.score]);
+      } else {
+        arr[arr.length - 1].push(s.score);
+      }
+    }
+  }
+  const allValues = [];
+  const pairDiffs = [];
+  for (const items of dimensionMap.values()) {
+    for (const ratings of items) {
+      if (ratings.length < 2) continue;
+      for (const v of ratings) allValues.push(v);
+      for (let i = 0; i < ratings.length; i++) {
+        for (let j = i + 1; j < ratings.length; j++) {
+          pairDiffs.push((ratings[i] - ratings[j]) ** 2);
+        }
+      }
+    }
+  }
+  if (pairDiffs.length === 0 || allValues.length < 2) return 1;
+  const observedDisagreement = pairDiffs.reduce((a, b) => a + b, 0) / pairDiffs.length;
+  let expectedDisagreement = 0;
+  let expectedCount = 0;
+  for (let i = 0; i < allValues.length; i++) {
+    for (let j = i + 1; j < allValues.length; j++) {
+      expectedDisagreement += (allValues[i] - allValues[j]) ** 2;
+      expectedCount++;
+    }
+  }
+  expectedDisagreement = expectedCount > 0 ? expectedDisagreement / expectedCount : 0;
+  if (expectedDisagreement === 0) return 1;
+  return 1 - observedDisagreement / expectedDisagreement;
+}
+function mannWhitneyU(a, b) {
+  if (a.length === 0 || b.length === 0) return { u: 0, p: 1 };
+  const n1 = a.length;
+  const n2 = b.length;
+  const combined = [
+    ...a.map((v) => ({ v, group: "a" })),
+    ...b.map((v) => ({ v, group: "b" }))
+  ].sort((x, y) => x.v - y.v);
+  const ranks = new Array(combined.length);
+  let i = 0;
+  while (i < combined.length) {
+    let j = i;
+    while (j < combined.length && combined[j].v === combined[i].v) j++;
+    const avgRank = (i + 1 + j) / 2;
+    for (let k = i; k < j; k++) ranks[k] = avgRank;
+    i = j;
+  }
+  let r1 = 0;
+  for (let k = 0; k < combined.length; k++) {
+    if (combined[k].group === "a") r1 += ranks[k];
+  }
+  const u1 = r1 - n1 * (n1 + 1) / 2;
+  const u2 = n1 * n2 - u1;
+  const u = Math.min(u1, u2);
+  const mu = n1 * n2 / 2;
+  const sigma = Math.sqrt(n1 * n2 * (n1 + n2 + 1) / 12);
+  if (sigma === 0) return { u, p: 1 };
+  const z = Math.abs(u - mu) / sigma;
+  const p = 2 * (1 - normalCdf(z));
+  return { u, p };
+}
+function partialCredit(current, target) {
+  if (target <= 0) return 1;
+  return Math.min(1, Math.max(0, current / target));
+}
+function pairedTTest(before, after) {
+  if (before.length !== after.length) {
+    throw new ValidationError(
+      `pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`
+    );
+  }
+  const n = before.length;
+  if (n < 2) return { t: 0, df: 0, p: 1 };
+  const diffs = before.map((b, i) => after[i] - b);
+  const mean = diffs.reduce((a, b) => a + b, 0) / n;
+  const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1);
+  const se = Math.sqrt(variance / n);
+  if (se === 0) return { t: mean === 0 ? 0 : Infinity, df: n - 1, p: mean === 0 ? 1 : 0 };
+  const t = mean / se;
+  const df = n - 1;
+  const p = 2 * (1 - studentTCdf(Math.abs(t), df));
+  return { t, df, p };
+}
+function wilcoxonSignedRank(before, after) {
+  if (before.length !== after.length) {
+    throw new ValidationError(
+      `wilcoxonSignedRank: unequal sample sizes (${before.length} vs ${after.length})`
+    );
+  }
+  const diffs = before.map((b, i2) => after[i2] - b).filter((d) => d !== 0);
+  const n = diffs.length;
+  if (n < 6) return { w: 0, p: 1 };
+  const absRanks = diffs.map((d, i2) => ({ abs: Math.abs(d), sign: Math.sign(d), i: i2 })).sort((a, b) => a.abs - b.abs);
+  const ranks = new Array(n);
+  let i = 0;
+  while (i < n) {
+    let j = i;
+    while (j < n && absRanks[j].abs === absRanks[i].abs) j++;
+    const avg = (i + 1 + j) / 2;
+    for (let k = i; k < j; k++) ranks[absRanks[k].i] = avg;
+    i = j;
+  }
+  let wPlus = 0;
+  for (let k = 0; k < n; k++) if (diffs[k] > 0) wPlus += ranks[k];
+  const mean = n * (n + 1) / 4;
+  const variance = n * (n + 1) * (2 * n + 1) / 24;
+  const z = (wPlus - mean) / Math.sqrt(variance);
+  const p = 2 * (1 - normalCdf(Math.abs(z)));
+  return { w: wPlus, p };
+}
+function cohensD(a, b) {
+  if (a.length < 2 || b.length < 2) return 0;
+  const meanA = a.reduce((x, y) => x + y, 0) / a.length;
+  const meanB = b.reduce((x, y) => x + y, 0) / b.length;
+  const varA = a.reduce((acc, x) => acc + (x - meanA) ** 2, 0) / (a.length - 1);
+  const varB = b.reduce((acc, x) => acc + (x - meanB) ** 2, 0) / (b.length - 1);
+  const pooled = Math.sqrt(
+    ((a.length - 1) * varA + (b.length - 1) * varB) / (a.length + b.length - 2)
+  );
+  if (pooled === 0) return 0;
+  return (meanB - meanA) / pooled;
+}
+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 \u22652 judges, got ${targetJudges.length}`
+    );
+  }
+  const perDimension = [];
+  const iccs = [];
+  const kappas = [];
+  for (const dim of targetDims) {
+    const byJudge = grid.get(dim);
+    const judgeItemCounts = {};
+    for (const j of targetJudges) {
+      const m = byJudge.get(j);
+      judgeItemCounts[j] = m?.size ?? 0;
+    }
+    const emptyJudges = targetJudges.filter((j) => judgeItemCounts[j] === 0);
+    if (emptyJudges.length > 0) {
+      throw new ValidationError(
+        `corpusInterRaterAgreement: dimension '${dim}' has no scores from judge(s) ${emptyJudges.join(", ")} (counts: ${JSON.stringify(judgeItemCounts)})`
+      );
+    }
+    let commonItems = null;
+    for (const j of targetJudges) {
+      const ids = new Set(byJudge.get(j).keys());
+      if (commonItems === null) {
+        commonItems = ids;
+      } else {
+        const prev = commonItems;
+        commonItems = new Set([...prev].filter((x) => ids.has(x)));
+      }
+    }
+    const sortedItems = [...commonItems ?? /* @__PURE__ */ new Set()].sort();
+    if (sortedItems.length < 2) {
+      throw new ValidationError(
+        `corpusInterRaterAgreement: dimension '${dim}' has ${sortedItems.length} item(s) rated by all ${targetJudges.length} judges (need \u22652)`
+      );
+    }
+    const matrix = sortedItems.map(
+      (itemId) => targetJudges.map((j) => byJudge.get(j).get(itemId))
+    );
+    const agreement = continuousAgreement(matrix, 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 ? Number.NaN : xs.reduce((a, b) => a + b, 0) / xs.length;
+  return {
+    perDimension,
+    overallIcc: mean(iccs),
+    overallWeightedKappa: mean(kappas),
+    dimensions: targetDims,
+    judgeIds: targetJudges
+  };
+}
+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);
+}
+function studentTCdf(t, df) {
+  if (df <= 0) return 0.5;
+  if (df > 100) return normalCdf(t);
+  const x = df / (df + t * t);
+  const a = df / 2;
+  const b = 0.5;
+  const ib = incompleteBeta(x, a, b);
+  return t >= 0 ? 1 - 0.5 * ib : 0.5 * ib;
+}
+function incompleteBeta(x, a, b) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  const lnBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+  const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a;
+  const maxIter = 200;
+  const eps = 3e-7;
+  let c = 1;
+  let d = 1 - (a + b) * x / (a + 1);
+  if (Math.abs(d) < 1e-30) d = 1e-30;
+  d = 1 / d;
+  let f = d;
+  for (let m = 1; m <= maxIter; m++) {
+    const m2 = 2 * m;
+    let num = m * (b - m) * x / ((a + m2 - 1) * (a + m2));
+    d = 1 + num * d;
+    if (Math.abs(d) < 1e-30) d = 1e-30;
+    c = 1 + num / c;
+    if (Math.abs(c) < 1e-30) c = 1e-30;
+    d = 1 / d;
+    f *= d * c;
+    num = -((a + m) * (a + b + m) * x) / ((a + m2) * (a + m2 + 1));
+    d = 1 + num * d;
+    if (Math.abs(d) < 1e-30) d = 1e-30;
+    c = 1 + num / c;
+    if (Math.abs(c) < 1e-30) c = 1e-30;
+    d = 1 / d;
+    const delta = d * c;
+    f *= delta;
+    if (Math.abs(delta - 1) < eps) break;
+  }
+  return front * f;
+}
+function lnGamma(z) {
+  const g = 7;
+  const coefs = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    9984369578019572e-21,
+    15056327351493116e-23
+  ];
+  if (z < 0.5) {
+    return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z);
+  }
+  z -= 1;
+  let x = coefs[0];
+  for (let i = 1; i < g + 2; i++) x += coefs[i] / (z + i);
+  const t = z + g + 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+function normalCdf(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+  return 0.5 * (1 + sign * y);
+}
+
+export {
+  calibrateJudge,
+  positionalBias,
+  verbosityBias,
+  selfPreference,
+  continuousAgreement,
+  calibrateJudgeContinuous,
+  normalizeScores,
+  weightedMean,
+  confidenceInterval,
+  interRaterReliability,
+  mannWhitneyU,
+  partialCredit,
+  pairedTTest,
+  wilcoxonSignedRank,
+  cohensD,
+  corpusInterRaterAgreement,
+  corpusInterRaterAgreementFromJudgeScores
+};
+//# sourceMappingURL=chunk-R5UQJNKC.js.map