@tangle-network/agent-eval 0.196.0 → 0.198.0

package/dist/{matrix-C1X-fIVX.d.ts → matrix-BnksRaDD.d.ts}

@@ -1,5 +1,5 @@
 import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { w as JudgeScore } from "./types-B2673PBj.js";
+import { w as JudgeScore } from "./types-EBUav9Bu.js";
 import { o as MatrixResult } from "./index-DNgf5gyG.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/types.d.ts
@@ -398,4 +398,4 @@ interface RunMultishotMatrixResult {
 declare function runMultishotMatrix<TPersona extends MultishotPersona>(opts: RunMultishotMatrixOptions<TPersona>): Promise<RunMultishotMatrixResult>;
 //#endregion
 export { MultishotToolExecutor as A, MultishotFatalToolError as C, MultishotShape as D, MultishotResult as E, assertMultishotShotResult as F, MultishotTransportRequest as M, MultishotTransportResponse as N, MultishotShotResultError as O, MultishotTransportToolCall as P, MultishotDriverEmptyError as S, MultishotPersona as T, JudgeRunResult as _, MultishotCellOutput as a, runJudge as b, RunMultishotMatrixResult as c, MultishotShot as d, RunMultishotOptions as f, JudgeDimension as g, JudgeConfig as h, ConversationJudgeInput as i, MultishotTransport as j, MultishotToolDefinition as k, computeCellComposite as l, DEFAULT_JUDGE_MODEL as m, CellCompositeInput as n, MultishotJudges as o, runMultishot as p, CellCompositeScore as r, RunMultishotMatrixOptions as s, ArtifactJudgeInput as t, runMultishotMatrix as u, renderDimensions as v, MultishotMessage as w, MultishotArtifact as x, renderJsonFooter as y };
-//# sourceMappingURL=matrix-C1X-fIVX.d.ts.map
+//# sourceMappingURL=matrix-BnksRaDD.d.ts.map

package/dist/{matrix-C1X-fIVX.d.ts.map → matrix-BnksRaDD.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"matrix-C1X-fIVX.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}
+{"version":3,"file":"matrix-BnksRaDD.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/multiplicity-D9cjmStq.js

@@ -0,0 +1,101 @@
+import { s as ValidationError } from "./errors-Dngq5h35.js";
+//#region src/statistics/multiplicity.ts
+/**
+* Multiple-comparison corrections: family-wise error (Bonferroni, Holm) and
+* false discovery rate (Benjamini-Hochberg), with inclusive rejection
+* boundaries throughout.
+*/
+/**
+* Bonferroni adjustment: multiply every p-value by the test count, clamp at 1.
+*
+* Rejects at `p_adjusted ≤ alpha` — the boundary is inclusive, matching
+* {@link holm}, which uniformly dominates this correction and must therefore
+* never reject less. Validates its inputs on the same terms.
+*/
+function bonferroni(pValues, alpha = .05) {
+	assertAlpha("bonferroni", "alpha", alpha);
+	assertPValues("bonferroni", pValues);
+	const k = pValues.length;
+	const adjusted = pValues.map((p) => Math.min(1, p * k));
+	return {
+		adjusted,
+		significant: adjusted.map((p) => p <= alpha)
+	};
+}
+/**
+* Holm step-down family-wise error adjustment.
+*
+* P-values are sorted from smallest to largest, multiplied by their remaining
+* hypothesis count, and made monotonically non-decreasing before being mapped
+* back to input order. This uniformly dominates plain Bonferroni while keeping
+* strong family-wise error control under arbitrary dependence.
+*/
+function holm(pValues, alpha = .05) {
+	assertAlpha("holm", "alpha", alpha);
+	assertPValues("holm", pValues);
+	const count = pValues.length;
+	if (count === 0) return {
+		adjusted: [],
+		significant: []
+	};
+	const ordered = pValues.map((pValue, index) => ({
+		pValue,
+		index
+	})).sort((a, b) => a.pValue - b.pValue || a.index - b.index);
+	const adjusted = new Array(count);
+	let previous = 0;
+	for (let rank = 0; rank < count; rank++) {
+		const entry = ordered[rank];
+		const stepAdjusted = Math.min(1, entry.pValue * (count - rank));
+		previous = Math.max(previous, stepAdjusted);
+		adjusted[entry.index] = previous;
+	}
+	return {
+		adjusted,
+		significant: adjusted.map((pValue) => pValue <= alpha)
+	};
+}
+/**
+* Benjamini–Hochberg false discovery rate. Returns adjusted q-values and
+* significance at the target FDR; handles ties and preserves q monotonicity.
+*
+* Rejects at `q ≤ fdr` — the BH rule is inclusive at the boundary, so an
+* exactly-`fdr` q-value is a discovery.
+*/
+function benjaminiHochberg(pValues, fdr = .05) {
+	assertAlpha("benjaminiHochberg", "fdr", fdr);
+	assertPValues("benjaminiHochberg", pValues);
+	const n = pValues.length;
+	if (n === 0) return {
+		qValues: [],
+		significant: []
+	};
+	const indexed = pValues.map((p, i) => ({
+		p,
+		i
+	})).sort((a, b) => a.p - b.p);
+	const q = new Array(n);
+	let minRight = 1;
+	for (let k = n - 1; k >= 0; k--) {
+		const rank = k + 1;
+		const entry = indexed[k];
+		const raw = n / rank * entry.p;
+		const bounded = Math.min(minRight, raw);
+		minRight = bounded;
+		q[entry.i] = Math.min(1, bounded);
+	}
+	return {
+		qValues: q,
+		significant: q.map((v) => v <= fdr)
+	};
+}
+function assertAlpha(fn, label, value) {
+	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new ValidationError(`${fn}: ${label} must be in (0,1), got ${value}`);
+}
+function assertPValues(fn, pValues) {
+	for (const [index, pValue] of pValues.entries()) if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) throw new ValidationError(`${fn}: pValues[${index}] must be in [0,1], got ${pValue}`);
+}
+//#endregion
+export { bonferroni as n, holm as r, benjaminiHochberg as t };
+
+//# sourceMappingURL=multiplicity-D9cjmStq.js.map

package/dist/multiplicity-D9cjmStq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplicity-D9cjmStq.js","names":[],"sources":["../src/statistics/multiplicity.ts"],"sourcesContent":["/**\n * Multiple-comparison corrections: family-wise error (Bonferroni, Holm) and\n * false discovery rate (Benjamini-Hochberg), with inclusive rejection\n * boundaries throughout.\n */\n\nimport { ValidationError } from '../errors'\n\n/**\n * Bonferroni adjustment: multiply every p-value by the test count, clamp at 1.\n *\n * Rejects at `p_adjusted ≤ alpha` — the boundary is inclusive, matching\n * {@link holm}, which uniformly dominates this correction and must therefore\n * never reject less. Validates its inputs on the same terms.\n */\nexport function bonferroni(\n  pValues: readonly number[],\n  alpha = 0.05,\n): { adjusted: number[]; significant: boolean[] } {\n  assertAlpha('bonferroni', 'alpha', alpha)\n  assertPValues('bonferroni', pValues)\n  const k = pValues.length\n  const adjusted = pValues.map((p) => Math.min(1, p * k))\n  return { adjusted, significant: adjusted.map((p) => p <= alpha) }\n}\n\n/**\n * Holm step-down family-wise error adjustment.\n *\n * P-values are sorted from smallest to largest, multiplied by their remaining\n * hypothesis count, and made monotonically non-decreasing before being mapped\n * back to input order. This uniformly dominates plain Bonferroni while keeping\n * strong family-wise error control under arbitrary dependence.\n */\nexport function holm(\n  pValues: readonly number[],\n  alpha = 0.05,\n): { adjusted: number[]; significant: boolean[] } {\n  assertAlpha('holm', 'alpha', alpha)\n  assertPValues('holm', pValues)\n  const count = pValues.length\n  if (count === 0) return { adjusted: [], significant: [] }\n\n  const ordered = pValues\n    .map((pValue, index) => ({ pValue, index }))\n    .sort((a, b) => a.pValue - b.pValue || a.index - b.index)\n  const adjusted = new Array<number>(count)\n  let previous = 0\n  for (let rank = 0; rank < count; rank++) {\n    const entry = ordered[rank]!\n    const stepAdjusted = Math.min(1, entry.pValue * (count - rank))\n    previous = Math.max(previous, stepAdjusted)\n    adjusted[entry.index] = previous\n  }\n  // Holm's rejection rule is inclusive at the adjusted alpha boundary.\n  return { adjusted, significant: adjusted.map((pValue) => pValue <= alpha) }\n}\n\n/**\n * Benjamini–Hochberg false discovery rate. Returns adjusted q-values and\n * significance at the target FDR; handles ties and preserves q monotonicity.\n *\n * Rejects at `q ≤ fdr` — the BH rule is inclusive at the boundary, so an\n * exactly-`fdr` q-value is a discovery.\n */\nexport function benjaminiHochberg(\n  pValues: readonly number[],\n  fdr = 0.05,\n): { qValues: number[]; significant: boolean[] } {\n  assertAlpha('benjaminiHochberg', 'fdr', fdr)\n  assertPValues('benjaminiHochberg', pValues)\n  const n = pValues.length\n  if (n === 0) return { qValues: [], significant: [] }\n  const indexed = pValues.map((p, i) => ({ p, i })).sort((a, b) => a.p - b.p)\n  const q = new Array<number>(n)\n  let minRight = 1\n  for (let k = n - 1; k >= 0; k--) {\n    const rank = k + 1\n    const entry = indexed[k]!\n    // (n/rank)·p, not (p·n)/rank: the latter lands one ULP above `fdr` at an\n    // exact boundary (p = 0.05, n = 3, rank = 3 gives 0.05000000000000001),\n    // which silently turns a discovery into a non-discovery. This is R's\n    // `p.adjust(method = \"BH\")` formulation.\n    const raw = (n / rank) * entry.p\n    const bounded = Math.min(minRight, raw)\n    minRight = bounded\n    q[entry.i] = Math.min(1, bounded)\n  }\n  return { qValues: q, significant: q.map((v) => v <= fdr) }\n}\n\nfunction assertAlpha(fn: string, label: string, value: number): void {\n  if (!Number.isFinite(value) || value <= 0 || value >= 1) {\n    throw new ValidationError(`${fn}: ${label} must be in (0,1), got ${value}`)\n  }\n}\n\nfunction assertPValues(fn: string, pValues: readonly number[]): void {\n  for (const [index, pValue] of pValues.entries()) {\n    if (!Number.isFinite(pValue) || pValue < 0 || pValue > 1) {\n      throw new ValidationError(`${fn}: pValues[${index}] must be in [0,1], got ${pValue}`)\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAgB,WACd,SACA,QAAQ,KACwC;CAChD,YAAY,cAAc,SAAS,KAAK;CACxC,cAAc,cAAc,OAAO;CACnC,MAAM,IAAI,QAAQ;CAClB,MAAM,WAAW,QAAQ,KAAK,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC,CAAC;CACtD,OAAO;EAAE;EAAU,aAAa,SAAS,KAAK,MAAM,KAAK,KAAK;CAAE;AAClE;;;;;;;;;AAUA,SAAgB,KACd,SACA,QAAQ,KACwC;CAChD,YAAY,QAAQ,SAAS,KAAK;CAClC,cAAc,QAAQ,OAAO;CAC7B,MAAM,QAAQ,QAAQ;CACtB,IAAI,UAAU,GAAG,OAAO;EAAE,UAAU,CAAC;EAAG,aAAa,CAAC;CAAE;CAExD,MAAM,UAAU,QACb,KAAK,QAAQ,WAAW;EAAE;EAAQ;CAAM,EAAE,CAAC,CAC3C,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK;CAC1D,MAAM,WAAW,IAAI,MAAc,KAAK;CACxC,IAAI,WAAW;CACf,KAAK,IAAI,OAAO,GAAG,OAAO,OAAO,QAAQ;EACvC,MAAM,QAAQ,QAAQ;EACtB,MAAM,eAAe,KAAK,IAAI,GAAG,MAAM,UAAU,QAAQ,KAAK;EAC9D,WAAW,KAAK,IAAI,UAAU,YAAY;EAC1C,SAAS,MAAM,SAAS;CAC1B;CAEA,OAAO;EAAE;EAAU,aAAa,SAAS,KAAK,WAAW,UAAU,KAAK;CAAE;AAC5E;;;;;;;;AASA,SAAgB,kBACd,SACA,MAAM,KACyC;CAC/C,YAAY,qBAAqB,OAAO,GAAG;CAC3C,cAAc,qBAAqB,OAAO;CAC1C,MAAM,IAAI,QAAQ;CAClB,IAAI,MAAM,GAAG,OAAO;EAAE,SAAS,CAAC;EAAG,aAAa,CAAC;CAAE;CACnD,MAAM,UAAU,QAAQ,KAAK,GAAG,OAAO;EAAE;EAAG;CAAE,EAAE,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC;CAC1E,MAAM,IAAI,IAAI,MAAc,CAAC;CAC7B,IAAI,WAAW;CACf,KAAK,IAAI,IAAI,IAAI,GAAG,KAAK,GAAG,KAAK;EAC/B,MAAM,OAAO,IAAI;EACjB,MAAM,QAAQ,QAAQ;EAKtB,MAAM,MAAO,IAAI,OAAQ,MAAM;EAC/B,MAAM,UAAU,KAAK,IAAI,UAAU,GAAG;EACtC,WAAW;EACX,EAAE,MAAM,KAAK,KAAK,IAAI,GAAG,OAAO;CAClC;CACA,OAAO;EAAE,SAAS;EAAG,aAAa,EAAE,KAAK,MAAM,KAAK,GAAG;CAAE;AAC3D;AAEA,SAAS,YAAY,IAAY,OAAe,OAAqB;CACnE,IAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,KAAK,SAAS,GACpD,MAAM,IAAI,gBAAgB,GAAG,GAAG,IAAI,MAAM,yBAAyB,OAAO;AAE9E;AAEA,SAAS,cAAc,IAAY,SAAkC;CACnE,KAAK,MAAM,CAAC,OAAO,WAAW,QAAQ,QAAQ,GAC5C,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,SAAS,KAAK,SAAS,GACrD,MAAM,IAAI,gBAAgB,GAAG,GAAG,YAAY,MAAM,0BAA0B,QAAQ;AAG1F"}

package/dist/multishot/golden/index.d.ts

@@ -1,4 +1,4 @@
-import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-C1X-fIVX.js";
+import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-BnksRaDD.js";
 //#region src/multishot/golden/compare.d.ts
 interface CompareOptions {
   /** Stop after this many mismatches. A structural divergence high in the

package/dist/multishot/golden/index.js

@@ -1,5 +1,5 @@
 import { n as readCellSpend } from "../../matrix-pWinRMPl.js";
-import { n as MultishotFatalToolError } from "../../types-B3jzCp0p.js";
+import { n as MultishotFatalToolError } from "../../types-B3jzCp0p2.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, posix, relative, sep } from "node:path";
 //#region src/multishot/golden/compare.ts

package/dist/multishot/index.d.ts

@@ -1,5 +1,5 @@
-import { w as JudgeScore } from "../types-B2673PBj.js";
-import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-C1X-fIVX.js";
+import { w as JudgeScore } from "../types-EBUav9Bu.js";
+import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-BnksRaDD.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/cost.d.ts
 /**

package/dist/multishot/index.js

@@ -1,6 +1,6 @@
 import { i as isModelPriced, n as estimateCost } from "../metrics-DOMpkoeb.js";
 import { r as withCellSpend, t as runAgentMatrix } from "../matrix-pWinRMPl.js";
-import { i as assertMultishotShotResult, n as MultishotFatalToolError, r as MultishotShotResultError, t as MultishotDriverEmptyError } from "../types-B3jzCp0p.js";
+import { i as assertMultishotShotResult, n as MultishotFatalToolError, r as MultishotShotResultError, t as MultishotDriverEmptyError } from "../types-B3jzCp0p2.js";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/multishot/cost.ts

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.196.0",
+    "version": "0.198.0",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.1.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/{paired-arms-JSDcs2zx.js → paired-arms-DKZFVPt8.js}

@@ -1,401 +1,7 @@
 import { s as ValidationError } from "./errors-Dngq5h35.js";
-import { c as lnGamma, i as makeRng, l as regularizedIncompleteBeta, o as symmetricTwoSampleSeed, r as binomialSignTwoSided, s as zQuantile, t as assertFiniteSample } from "./internal-BMFSR8Ns.js";
+import { c as lnGamma, i as makeRng, o as symmetricTwoSampleSeed, r as binomialSignTwoSided, t as assertFiniteSample } from "./internal-BMFSR8Ns.js";
+import { i as pairedRiskDifference, n as mcnemar } from "./paired-binary-fzkwENI4.js";
 import { r as pairedBootstrap } from "./paired-tests-C8iCsioC.js";
-//#region src/statistics/paired-binary.ts
-/**
-* Wilson score interval for a binomial proportion. Correct at small n and near
-* 0/1, where the normal (Wald) approximation produces bounds outside [0, 1] and
-* understates coverage. Use this for any pass-rate / hit-rate / realness-rate
-* CI — the continuous `confidenceInterval` assumes the wrong distribution for a
-* proportion. `n = 0 ⇒ {0, 0, 0}`.
-*/
-function wilson(successes, n, confidence = .95) {
-	if (n <= 0) return {
-		estimate: 0,
-		lower: 0,
-		upper: 0
-	};
-	if (successes < 0 || successes > n) throw new Error(`wilson: successes (${successes}) must be in [0, ${n}]`);
-	const z = zQuantile(1 - (1 - confidence) / 2);
-	const p = successes / n;
-	const z2 = z * z;
-	const denom = 1 + z2 / n;
-	const center = (p + z2 / (2 * n)) / denom;
-	const half = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n) / denom;
-	return {
-		estimate: p,
-		lower: Math.max(0, center - half),
-		upper: Math.min(1, center + half)
-	};
-}
-/**
-* Are these per-item outcomes binary (every value exactly 0 or 1)?
-*
-* The discriminator a promotion gate needs before choosing a paired statistic.
-* On binary outcomes the paired delta vector lives in {-1, 0, +1} and is
-* normally dominated by zeros (both arms solve, or both arms miss, most items),
-* so its MEDIAN is pinned at exactly 0 no matter how large the real shift in
-* success rate is — and a bootstrap CI on that median collapses to [0, 0].
-* A gate keying on `ci.low > threshold` is then structurally unable to see
-* either a gain or a regression. Detect this shape and switch to the
-* paired-binary estimators ({@link mcnemar}, {@link pairedRiskDifference})
-* instead of silently answering "no" forever.
-*
-* Empty input is NOT binary: there is no evidence of the outcome's shape, and
-* defaulting an empty vector into the binary branch would pick a statistic on
-* no data at all.
-*
-* NOT the right discriminator for a gate. It recognises the literal {0, 1}
-* encoding and nothing else, so a pass/fail dimension emitted on 0-100 — which
-* judges in this codebase do routinely — reads as non-binary, and a single
-* partial-credit score in an otherwise pass/fail vector flips it to false while
-* leaving the median just as blind. Gates want {@link pairedBinaryScale} (any
-* two-point encoding). This predicate remains for callers that specifically
-* mean "literally 0/1".
-*/
-function isBinaryOutcomeVector(values) {
-	if (values.length === 0) return false;
-	for (let i = 0; i < values.length; i++) {
-		const v = values[i];
-		if (v !== 0 && v !== 1) return false;
-	}
-	return true;
-}
-/**
-* McNemar's test for paired binary outcomes — the correct significance test for
-* "does treatment change the success rate vs control on the SAME items". Only
-* discordant pairs (one arm right, the other wrong) carry information; concordant
-* pairs are uninformative, so a paired t-test / two-proportion z-test on the raw
-* rates is wrong here. The p-value is exact: under H0 the b "treatment-wins" are
-* Binomial(b + c, 0.5), so the two-sided p is the doubled binomial tail — correct
-* at the small discordant counts typical of eval runs (no continuity-corrected
-* chi-square approximation needed, though it is returned as `statistic` for
-* reference). Inputs are paired 0/1 (or boolean) arrays, control first to match
-* the module's (before, after) convention. Throws on unequal lengths.
-*/
-function mcnemar(control, treatment) {
-	if (control.length !== treatment.length) throw new Error(`mcnemar: unequal sample sizes (${control.length} vs ${treatment.length})`);
-	const n = control.length;
-	let b = 0;
-	let c = 0;
-	for (let i = 0; i < n; i++) {
-		const ctrl = control[i] ? 1 : 0;
-		const treat = treatment[i] ? 1 : 0;
-		if (treat === 1 && ctrl === 0) b++;
-		else if (treat === 0 && ctrl === 1) c++;
-	}
-	const nDiscordant = b + c;
-	const statistic = nDiscordant === 0 ? 0 : (Math.abs(b - c) - 1) ** 2 / nDiscordant;
-	return {
-		n,
-		nDiscordant,
-		b,
-		c,
-		statistic,
-		pValue: binomialSignTwoSided(b, c)
-	};
-}
-/**
-* Paired risk difference (the effect-size companion to {@link mcnemar}): the
-* change in success rate p(treatment) − p(control) on matched items, which for
-* paired binary data equals (b − c) / n. The CI uses the paired variance from
-* the discordant counts, not the independent-samples formula (which overstates
-* the interval by ignoring the pairing). Inputs are paired 0/1 (or boolean)
-* arrays, control first. Throws on unequal lengths.
-*
-* REPORTING ONLY — do NOT decide a promotion on this interval. The CI is a Wald
-* normal approximation, which badly UNDERCOVERS when only a handful of pairs are
-* discordant: at n = 3 with b = 2, c = 0 it returns [0.133, 1.000], excluding 0,
-* while McNemar's exact test on the same data gives p = 0.50. A gate keying on
-* `lower > 0` would promote noise. Use {@link pairedRiskDifferenceExact}, whose
-* interval is dual to the exact test by construction, for any decision.
-*/
-function pairedRiskDifference(control, treatment, confidence = .95) {
-	if (control.length !== treatment.length) throw new Error(`pairedRiskDifference: unequal sample sizes (${control.length} vs ${treatment.length})`);
-	const n = control.length;
-	if (n === 0) return {
-		n: 0,
-		b: 0,
-		c: 0,
-		riskDifference: 0,
-		lower: 0,
-		upper: 0,
-		confidence
-	};
-	let b = 0;
-	let c = 0;
-	for (let i = 0; i < n; i++) {
-		const ctrl = control[i] ? 1 : 0;
-		const treat = treatment[i] ? 1 : 0;
-		if (treat === 1 && ctrl === 0) b++;
-		else if (treat === 0 && ctrl === 1) c++;
-	}
-	const rd = (b - c) / n;
-	const variance = (b + c - (b - c) ** 2 / n) / (n * n);
-	const half = zQuantile(1 - (1 - confidence) / 2) * Math.sqrt(Math.max(0, variance));
-	return {
-		n,
-		b,
-		c,
-		riskDifference: rd,
-		lower: Math.max(-1, rd - half),
-		upper: Math.min(1, rd + half),
-		confidence
-	};
-}
-/**
-* Paired risk difference with the EXACT CONDITIONAL interval — the estimator a
-* promotion gate may decide on.
-*
-* Conditional on the number of discordant pairs m = b + c, the treatment-win
-* count b is Binomial(m, π) with π = P(treatment wins | discordant), and the
-* risk difference is an exact reparameterisation: RD = (2π − 1)·m/n. So a
-* Clopper-Pearson exact interval for π maps straight onto RD. This buys the
-* property the Wald interval in {@link pairedRiskDifference} does not have:
-*
-*   **`lower > 0` ⟺ McNemar's exact test rejects at α = 1 − confidence.**
-*
-* Clopper-Pearson excludes π = 0.5 exactly when the two-sided exact binomial
-* test of π = 0.5 rejects, and that test IS {@link mcnemar}'s p-value — so the
-* interval and the test can never disagree, and a gate keyed on `lower` cannot
-* promote what the exact test refuses. The exact p is returned in the same
-* object so the two are impossible to compute apart.
-*
-* The interval is conservative (exact intervals over-cover; conditioning on m
-* discards the concordant pairs' information about m itself). That is the
-* correct direction for a promotion gate: it refuses more often, never less.
-*
-* With m = 0 there are no discordant pairs and π is not identified: the result
-* is the degenerate [0, 0] with p = 1. That is NOT evidence of equivalence —
-* callers must treat a zero-width interval as "cannot decide", not as "no
-* difference". Inputs are paired 0/1 (or boolean) arrays, control first.
-* Throws on unequal lengths.
-*/
-function pairedRiskDifferenceExact(control, treatment, confidence = .95) {
-	if (control.length !== treatment.length) throw new Error(`pairedRiskDifferenceExact: unequal sample sizes (${control.length} vs ${treatment.length})`);
-	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedRiskDifferenceExact: confidence must be in (0,1), got ${confidence}`);
-	const n = control.length;
-	if (n === 0) return {
-		n: 0,
-		b: 0,
-		c: 0,
-		nDiscordant: 0,
-		riskDifference: 0,
-		lower: 0,
-		upper: 0,
-		confidence,
-		pValue: 1
-	};
-	let b = 0;
-	let c = 0;
-	for (let i = 0; i < n; i++) {
-		const ctrl = control[i] ? 1 : 0;
-		const treat = treatment[i] ? 1 : 0;
-		if (treat === 1 && ctrl === 0) b++;
-		else if (treat === 0 && ctrl === 1) c++;
-	}
-	const m = b + c;
-	const riskDifference = (b - c) / n;
-	const pValue = binomialSignTwoSided(b, c);
-	if (m === 0) return {
-		n,
-		b,
-		c,
-		nDiscordant: 0,
-		riskDifference: 0,
-		lower: 0,
-		upper: 0,
-		confidence,
-		pValue
-	};
-	const alpha = 1 - confidence;
-	const piLow = b === 0 ? 0 : betaQuantile(alpha / 2, b, m - b + 1);
-	const piHigh = b === m ? 1 : betaQuantile(1 - alpha / 2, b + 1, m - b);
-	const scale = m / n;
-	return {
-		n,
-		b,
-		c,
-		nDiscordant: m,
-		riskDifference,
-		lower: Math.max(-1, (2 * piLow - 1) * scale),
-		upper: Math.min(1, (2 * piHigh - 1) * scale),
-		confidence,
-		pValue
-	};
-}
-/** Inverse regularized incomplete beta by bisection on
-*  {@link regularizedIncompleteBeta}, which is monotone increasing in x. 80
-*  halvings of [0,1] resolve to ~8e-25, far past the continued fraction's own
-*  3e-15 tolerance, so the quantile is as exact as the CDF it inverts. */
-function betaQuantile(p, a, b) {
-	if (p <= 0) return 0;
-	if (p >= 1) return 1;
-	let lo = 0;
-	let hi = 1;
-	for (let i = 0; i < 80; i++) {
-		const mid = (lo + hi) / 2;
-		if (regularizedIncompleteBeta(mid, a, b) < p) lo = mid;
-		else hi = mid;
-	}
-	return (lo + hi) / 2;
-}
-/**
-* Constrained MLE of q = P(treatment loses) under the hypothesis RD = `delta`.
-*
-* Profiling the two concordant cells out of the multinomial leaves
-* `L(q) = b·log(q+delta) + c·log(q) + e·log(1 − 2q − delta)` with `e = n − b − c`,
-* whose stationary point is the positive root of
-* `2n·q² − [(b + c) − delta·(b + 3c + 2e)]·q − c·delta·(1 − delta) = 0`.
-* At `delta = 0` this returns `(b + c) / 2n`, the familiar null.
-*/
-function constrainedLossRate(b, c, n, delta) {
-	const e = n - b - c;
-	const quadratic = 2 * n;
-	const linear = -(b + c - delta * (b + 3 * c + 2 * e));
-	const constant = -c * delta * (1 - delta);
-	const discriminant = linear * linear - 4 * quadratic * constant;
-	const root = discriminant > 0 ? Math.sqrt(discriminant) : 0;
-	const q = (-linear + root) / (2 * quadratic);
-	return Math.min(Math.max(q, Math.max(0, -delta)), Math.max(0, (1 - delta) / 2));
-}
-/** Tango's score statistic for H0: RD = `delta`. `Var(b − c) = n·(2q + delta −
-*  delta²)` under that hypothesis, evaluated at the constrained MLE of q. */
-function tangoScore(b, c, n, delta) {
-	const numerator = b - c - n * delta;
-	const variance = n * (2 * constrainedLossRate(b, c, n, delta) + delta * (1 - delta));
-	if (!(variance > 0)) {
-		if (numerator === 0) return 0;
-		return numerator > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-	}
-	return numerator / Math.sqrt(variance);
-}
-/**
-* Paired risk difference with TANGO'S (1998) SCORE INTERVAL — the estimator a
-* promotion gate may decide on **at a nonzero margin**.
-*
-* {@link pairedRiskDifferenceExact} conditions on the observed discordant count
-* `m = b + c`, builds a Clopper-Pearson interval for the win share among those
-* `m` pairs, and multiplies by the observed `m/n`. That is exact for testing
-* RD = 0 — it is dual to McNemar — but it is NOT a confidence interval for the
-* population risk difference at a nonzero margin, because the sampling
-* variability of `m/n` itself is discarded. The gap is not academic: with the
-* production caller's `pairedDeltaThreshold: -0.05`, a process whose true risk
-* difference sits exactly on that margin clears a nominal-95 % `lower > margin`
-* check 24.75 % of the time at n = 40 and 43.95 % at n = 76 (2000 replicates
-* each) when the conditional interval decides.
-*
-* Tango's interval inverts the score test of RD = delta, which estimates the
-* nuisance loss rate under each hypothesised delta instead of fixing it at the
-* observed value, so `m` contributes its own uncertainty. It is the method
-* `ratesci::scorepairci` uses for paired risk-difference noninferiority, and it
-* is not conditional, so it stays valid as the margin moves away from zero.
-*
-* The bounds are found by bisecting `tangoScore(delta) = ±z` — the score is
-* monotone decreasing in delta, so each crossing is unique. Inputs are paired
-* 0/1 (or boolean) arrays, control first. Throws on unequal lengths.
-*/
-function pairedRiskDifferenceScore(control, treatment, confidence = .95) {
-	if (control.length !== treatment.length) throw new Error(`pairedRiskDifferenceScore: unequal sample sizes (${control.length} vs ${treatment.length})`);
-	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedRiskDifferenceScore: confidence must be in (0,1), got ${confidence}`);
-	const n = control.length;
-	if (n === 0) return {
-		n: 0,
-		b: 0,
-		c: 0,
-		nDiscordant: 0,
-		riskDifference: 0,
-		lower: -1,
-		upper: 1,
-		confidence
-	};
-	let b = 0;
-	let c = 0;
-	for (let i = 0; i < n; i++) {
-		const ctrl = control[i] ? 1 : 0;
-		const treat = treatment[i] ? 1 : 0;
-		if (treat === 1 && ctrl === 0) b++;
-		else if (treat === 0 && ctrl === 1) c++;
-	}
-	const riskDifference = (b - c) / n;
-	const z = zQuantile(1 - (1 - confidence) / 2);
-	let lo = -1;
-	let hi = riskDifference;
-	for (let i = 0; i < 64; i++) {
-		const mid = (lo + hi) / 2;
-		if (tangoScore(b, c, n, mid) > z) lo = mid;
-		else hi = mid;
-	}
-	const lower = (lo + hi) / 2;
-	let ulo = riskDifference;
-	let uhi = 1;
-	for (let i = 0; i < 64; i++) {
-		const mid = (ulo + uhi) / 2;
-		if (tangoScore(b, c, n, mid) > -z) ulo = mid;
-		else uhi = mid;
-	}
-	const upper = (ulo + uhi) / 2;
-	return {
-		n,
-		b,
-		c,
-		nDiscordant: b + c,
-		riskDifference,
-		lower: Math.max(-1, lower),
-		upper: Math.min(1, upper),
-		confidence
-	};
-}
-/**
-* The common positive level `s` such that EVERY value across both paired arms is
-* exactly 0 or `s` — i.e. the outcome is pass/fail, whatever encoding it arrived
-* in. Returns null when the outcomes are not two-point, when the two arms use
-* different levels, or when no positive value was observed at all (all-zero
-* arms: the level is not identified, and there is nothing to decide anyway).
-*
-* This is the scale-aware successor to {@link isBinaryOutcomeVector}, which only
-* recognises literal {0, 1}. Judges in this codebase emit dimensions on 0-100 as
-* well as [0,1] (see `detectScale` in `campaign/gates/statistical-heldout.ts`),
-* so a pass/fail dimension routinely arrives as {0, 100} and a {0,1}-only test
-* silently sends it down the median path that cannot see it. Any positive level
-* is accepted, not just 1 and 100: for a two-point {0, s} outcome the mean paired
-* delta is exactly s·(b − c)/n, so the binary estimators apply after dividing by
-* s and rescaling the result back into the caller's native units.
-*
-* Non-finite values ⇒ null: an unusable outcome must not be classified as a
-* clean pass/fail shape.
-*/
-function pairedBinaryScale(before, after) {
-	let level = null;
-	for (const arm of [before, after]) for (let i = 0; i < arm.length; i++) {
-		const v = arm[i];
-		if (!Number.isFinite(v)) return null;
-		if (v === 0) continue;
-		if (v < 0) return null;
-		if (level === null) level = v;
-		else if (v !== level) return null;
-	}
-	return level;
-}
-/**
-* Unbiased pass@k for code generation (Chen et al. 2021, "Evaluating Large
-* Language Models Trained on Code"). Given `n` independent samples for one
-* problem of which `c` pass, the probability that at least one of a random k of
-* them passes is 1 − C(n−c, k) / C(n, k). Estimating pass@k as "did any of the
-* first k pass" is biased high at small n; this is the variance-reduced estimator
-* averaged implicitly over all k-subsets. Average the per-problem values across
-* the suite for the corpus pass@k. Computed in the numerically stable product
-* form. Requires 1 ≤ k ≤ n and 0 ≤ c ≤ n.
-*/
-function passAtK(n, c, k) {
-	if (!Number.isInteger(n) || !Number.isInteger(c) || !Number.isInteger(k)) throw new Error(`passAtK: n, c, k must be integers (got n=${n}, c=${c}, k=${k})`);
-	if (k < 1 || k > n || c < 0 || c > n) throw new Error(`passAtK: require 1 ≤ k ≤ n and 0 ≤ c ≤ n (got n=${n}, c=${c}, k=${k})`);
-	if (n - c < k) return 1;
-	let prob = 1;
-	for (let i = n - c + 1; i <= n; i++) prob *= 1 - k / i;
-	return 1 - prob;
-}
-//#endregion
 //#region src/math/normal.ts
 /**
 * Standard normal cumulative distribution using Abramowitz and Stegun 7.1.26.
@@ -1053,6 +659,6 @@ function metricValue(row, name) {
 	return v;
 }
 //#endregion
-export { passAtK as _, MANN_WHITNEY_EXACT_MAX_STATES as a, mannWhitneyU as c, isBinaryOutcomeVector as d, mcnemar as f, pairedRiskDifferenceScore as g, pairedRiskDifferenceExact as h, DEFAULT_PERMUTATIONS as i, wilcoxonSignedRank as l, pairedRiskDifference as m, pairArms as n, MANN_WHITNEY_EXACT_MAX_WORK as o, pairedBinaryScale as p, pairRunRecords as r, WILCOXON_EXACT_MAX_N as s, comparePairedArms as t, normalCdf as u, wilson as v };
+export { MANN_WHITNEY_EXACT_MAX_STATES as a, mannWhitneyU as c, DEFAULT_PERMUTATIONS as i, wilcoxonSignedRank as l, pairArms as n, MANN_WHITNEY_EXACT_MAX_WORK as o, pairRunRecords as r, WILCOXON_EXACT_MAX_N as s, comparePairedArms as t, normalCdf as u };
 
-//# sourceMappingURL=paired-arms-JSDcs2zx.js.map
+//# sourceMappingURL=paired-arms-DKZFVPt8.js.map