@tangle-network/agent-eval 1.0.19 → 1.0.20

package/dist/paired-tests-Buh6feJ4.js

@@ -1,211 +0,0 @@
-import { s as ValidationError } from "./errors-DeEEV9Vx.js";
-import { a as assertFiniteSample, l as makeRng, o as binomialHalfUpperTail, p as studentTCdf, u as medianInPlace } from "./mean-D1d6gedE.js";
-// src/statistics/paired-tests.ts
-/**
-* Paired significance tests on continuous scores: the paired t-test, the
-* promotion-gate paired bootstrap, the exact sign test, and the package-wide
-* paired-delta decision statistic.
-*/
-/**
-* Paired t-test — before/after measurements on the SAME items.
-* Pairing removes inter-item variance, giving tighter significance than
-* an unpaired test when comparing prompt v1 vs prompt v2 on identical
-* scenarios.
-*
-* Returns `t = p = null` where the statistic is undefined: fewer than two
-* pairs, or a non-zero constant delta whose observed variance is zero. A
-* constant shift carries no information about the variance it would have to
-* be compared against, so the honest answer is "undefined", not `p = 0` —
-* three observations cannot buy absolute certainty. This is the same contract
-* {@link pairedCohensDz} states for the same condition. An all-zero delta is
-* different: it is a measured null, and returns `t = 0, p = 1`.
-*/
-function pairedTTest(before, after) {
-	if (before.length !== after.length) throw new ValidationError(`pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`);
-	assertFiniteSample("pairedTTest", "before", before);
-	assertFiniteSample("pairedTTest", "after", after);
-	const n = before.length;
-	if (n < 2) return {
-		t: null,
-		df: 0,
-		p: null
-	};
-	const diffs = before.map((b, i) => after[i] - b);
-	const mean = diffs.reduce((a, b) => a + b, 0) / n;
-	const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1);
-	const se = Math.sqrt(variance / n);
-	if (se === 0) return mean === 0 ? {
-		t: 0,
-		df: n - 1,
-		p: 1
-	} : {
-		t: null,
-		df: n - 1,
-		p: null
-	};
-	const t = mean / se;
-	const df = n - 1;
-	return {
-		t,
-		df,
-		p: 2 * (1 - studentTCdf(Math.abs(t), df))
-	};
-}
-/**
-* Pairs below which a percentile bootstrap interval is descriptive spread only.
-*
-* `P(low > 0)` under a true null, against a nominal 2.5 %, measured over 4000
-* seeded trials: 13.53 % at n = 3, 3.52 % at n = 10, 3.10 % at n = 20 on the
-* median; 13.85 %, 4.90 %, 3.80 % on the mean. This is intrinsic to resampling
-* three points, not an implementation error — scipy's BCa gives 16.0 % on the
-* same n = 3 data — so no change to the estimator moves it. Below this floor
-* the decision belongs to the exact sign test or exact signed-rank test.
-*/
-const BOOTSTRAP_GATE_MIN_N = 20;
-/**
-* Paired bootstrap on (after − before) deltas. Returns a CI on the chosen
-* statistic (median by default); pairs are resampled with replacement. Throws
-* on unequal sample sizes.
-*
-* `low > threshold` carries the stated confidence ONLY at `n ≥
-* {@link BOOTSTRAP_GATE_MIN_N}`, which `gateEligible` reports. Below it the
-* check fires under a true null several times more often than nominal, so the
-* interval is descriptive spread and a promotion must not turn on it.
-*/
-function pairedBootstrap(before, after, opts = {}) {
-	if (before.length !== after.length) throw new Error(`pairedBootstrap: unequal sample sizes (${before.length} vs ${after.length})`);
-	const confidence = opts.confidence ?? .95;
-	const resamples = opts.resamples ?? 2e3;
-	const statistic = opts.statistic ?? "median";
-	if (confidence <= 0 || confidence >= 1) throw new Error(`pairedBootstrap: confidence must be in (0,1), got ${confidence}`);
-	const n = before.length;
-	const deltas = before.map((b, i) => after[i] - b);
-	const gateEligible = n >= 20;
-	if (n === 0) return {
-		n: 0,
-		median: 0,
-		mean: 0,
-		low: 0,
-		high: 0,
-		confidence,
-		resamples,
-		gateEligible
-	};
-	if (n === 1) {
-		const d = deltas[0];
-		return {
-			n: 1,
-			median: d,
-			mean: d,
-			low: d,
-			high: d,
-			confidence,
-			resamples,
-			gateEligible
-		};
-	}
-	const rng = makeRng(opts.seed, deltas);
-	const samples = new Array(resamples);
-	for (let b = 0; b < resamples; b++) if (statistic === "mean") {
-		let sum = 0;
-		for (let k = 0; k < n; k++) sum += deltas[Math.floor(rng() * n)];
-		samples[b] = sum / n;
-	} else {
-		const acc = new Array(n);
-		for (let k = 0; k < n; k++) acc[k] = deltas[Math.floor(rng() * n)];
-		samples[b] = medianInPlace(acc);
-	}
-	samples.sort((a, b) => a - b);
-	const alpha = 1 - confidence;
-	const lowIdx = Math.floor(alpha / 2 * resamples);
-	const highIdx = Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1);
-	return {
-		n,
-		median: medianInPlace([...deltas]),
-		mean: deltas.reduce((s, x) => s + x, 0) / n,
-		low: samples[lowIdx],
-		high: samples[Math.max(highIdx, lowIdx)],
-		confidence,
-		resamples,
-		gateEligible
-	};
-}
-/**
-* Exact one-sided sign test over paired differences.
-*
-* Pass `after[i] - before[i]` for each matched item. `alternative = 'greater'`
-* tests whether positive signs are more likely than negative signs and returns
-* `P(Binomial(nNonTies, 0.5) >= positive)`. `alternative = 'less'` treats
-* negative signs as successes instead. With a continuous difference
-* distribution this is the usual directional median test. Exact zero
-* differences are ties and do not enter the binomial denominator. All-tie and
-* empty inputs return p = 1. Every input difference must be finite, and the
-* direction must be chosen explicitly so a caller cannot select it after
-* seeing the signs.
-*/
-function pairedSignTest(differences, alternative) {
-	if (alternative !== "greater" && alternative !== "less") throw new ValidationError(`pairedSignTest: alternative must be 'greater' or 'less', got ${alternative}`);
-	let positive = 0;
-	let negative = 0;
-	let ties = 0;
-	for (let i = 0; i < differences.length; i++) {
-		const difference = differences[i];
-		if (!Number.isFinite(difference)) throw new ValidationError(`pairedSignTest: difference at index ${i} must be finite, got ${difference}`);
-		if (difference > 0) positive++;
-		else if (difference < 0) negative++;
-		else ties++;
-	}
-	const nNonTies = positive + negative;
-	const successes = alternative === "greater" ? positive : negative;
-	return {
-		n: differences.length,
-		positive,
-		negative,
-		ties,
-		nNonTies,
-		alternative,
-		pValue: binomialHalfUpperTail(successes, nNonTies)
-	};
-}
-/** Fraction of paired observations whose delta is an exact tie (|after − before|
-*  < 1e-9). Throws on unequal sample sizes; 0 pairs ⇒ 0. */
-function pairedDeltaTieFraction(before, after) {
-	if (before.length !== after.length) throw new Error(`pairedDeltaTieFraction: unequal sample sizes (${before.length} vs ${after.length})`);
-	const n = before.length;
-	if (n === 0) return 0;
-	let ties = 0;
-	for (let i = 0; i < n; i++) if (Math.abs(after[i] - before[i]) < 1e-9) ties++;
-	return ties / n;
-}
-/**
-* The paired-delta statistic a DECISION is computed on, package-wide.
-*
-* The mean paired delta is the estimator that answers the question a promotion
-* gate asks — "by how much did the candidate move the score" — in the caller's
-* own units, and it equals the aggregate lift everyone quotes. The MEDIAN
-* answers a different question and loses the answer to this one in every regime
-* eval data actually lands in:
-*   - TWO-POINT (pass/fail) outcomes on any encoding: the delta vector lives in
-*     {−s, 0, +s} dominated by zeros, so the median and its whole bootstrap CI
-*     are pinned at exactly 0 however large the shift. (Decide these on
-*     {@link pairedRiskDifferenceExact} instead — same estimand, exact interval.)
-*   - TIE-DOMINATED outcomes: at half the pairs tied the sample median is 0 by
-*     construction, and `ci.low > threshold` then answers "no" forever at a
-*     non-negative threshold and "yes" forever at a negative one.
-*   - LOW-CARDINALITY outcomes, even well below half ties: judge dimensions on
-*     integer 0-100, and block scores like {⅔, 1} from averaging pass/fail
-*     leaves, put the median on a coarse lattice whose bootstrap percentiles
-*     land on atoms. Measured: 26 blocks of 3 pass/fail leaves carrying a real
-*     +12.8pp lift, only 23% of pairs tied, gives a median CI of [0, 0.333] —
-*     lower bound exactly 0, so a gate at threshold 0 refuses a real lift.
-* That last case is why there is no tie-fraction threshold here: any cutoff on
-* ties leaves the lattice case open on the other side of it.
-*
-* `heldoutSignificance` has defaulted to the mean since #316 for the same
-* reason. The median remains available per call site for callers who
-* specifically want outlier robustness and accept the blindness.
-*/
-const DECISION_PAIRED_DELTA_STATISTIC = "mean";
-export { pairedSignTest as a, pairedDeltaTieFraction as i, DECISION_PAIRED_DELTA_STATISTIC as n, pairedTTest as o, pairedBootstrap as r, BOOTSTRAP_GATE_MIN_N as t };
-
-//# sourceMappingURL=paired-tests-Buh6feJ4.js.map

package/dist/paired-tests-Buh6feJ4.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paired-tests-Buh6feJ4.js","names":[],"sources":["../src/statistics/paired-tests.ts"],"sourcesContent":["/**\n * Paired significance tests on continuous scores: the paired t-test, the\n * promotion-gate paired bootstrap, the exact sign test, and the package-wide\n * paired-delta decision statistic.\n */\n\nimport { ValidationError } from '../errors'\nimport { studentTCdf } from '../math/student-t'\nimport { assertFiniteSample, binomialHalfUpperTail, makeRng, medianInPlace } from './internal'\n\nexport interface PairedTTestResult {\n  /** Null when the statistic is undefined — see {@link pairedTTest}. */\n  t: number | null\n  df: number\n  /** Null exactly when `t` is null. */\n  p: number | null\n}\n\n/**\n * Paired t-test — before/after measurements on the SAME items.\n * Pairing removes inter-item variance, giving tighter significance than\n * an unpaired test when comparing prompt v1 vs prompt v2 on identical\n * scenarios.\n *\n * Returns `t = p = null` where the statistic is undefined: fewer than two\n * pairs, or a non-zero constant delta whose observed variance is zero. A\n * constant shift carries no information about the variance it would have to\n * be compared against, so the honest answer is \"undefined\", not `p = 0` —\n * three observations cannot buy absolute certainty. This is the same contract\n * {@link pairedCohensDz} states for the same condition. An all-zero delta is\n * different: it is a measured null, and returns `t = 0, p = 1`.\n */\nexport function pairedTTest(before: number[], after: number[]): PairedTTestResult {\n  if (before.length !== after.length) {\n    throw new ValidationError(\n      `pairedTTest: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  assertFiniteSample('pairedTTest', 'before', before)\n  assertFiniteSample('pairedTTest', 'after', after)\n  const n = before.length\n  if (n < 2) return { t: null, df: 0, p: null }\n\n  const diffs = before.map((b, i) => after[i]! - b)\n  const mean = diffs.reduce((a, b) => a + b, 0) / n\n  const variance = diffs.reduce((acc, d) => acc + (d - mean) ** 2, 0) / (n - 1)\n  const se = Math.sqrt(variance / n)\n  if (se === 0) {\n    return mean === 0 ? { t: 0, df: n - 1, p: 1 } : { t: null, df: n - 1, p: null }\n  }\n\n  const t = mean / se\n  const df = n - 1\n  const p = 2 * (1 - studentTCdf(Math.abs(t), df))\n  return { t, df, p }\n}\n\n// ── Paired bootstrap (promotion-gate effect size) ────────────────────\n\nexport interface PairedBootstrapResult {\n  /** Number of paired observations. */\n  n: number\n  /** Median of paired deltas (after − before). */\n  median: number\n  /** Mean of paired deltas. */\n  mean: number\n  /** Lower bound of the bootstrap CI on the chosen statistic. */\n  low: number\n  /** Upper bound of the bootstrap CI on the chosen statistic. */\n  high: number\n  /** Confidence level used (e.g. 0.95). */\n  confidence: number\n  /** Number of bootstrap resamples used. */\n  resamples: number\n  /** False below {@link BOOTSTRAP_GATE_MIN_N}. See {@link pairedBootstrap}. */\n  gateEligible: boolean\n}\n\n/**\n * Pairs below which a percentile bootstrap interval is descriptive spread only.\n *\n * `P(low > 0)` under a true null, against a nominal 2.5 %, measured over 4000\n * seeded trials: 13.53 % at n = 3, 3.52 % at n = 10, 3.10 % at n = 20 on the\n * median; 13.85 %, 4.90 %, 3.80 % on the mean. This is intrinsic to resampling\n * three points, not an implementation error — scipy's BCa gives 16.0 % on the\n * same n = 3 data — so no change to the estimator moves it. Below this floor\n * the decision belongs to the exact sign test or exact signed-rank test.\n */\nexport const BOOTSTRAP_GATE_MIN_N = 20\n\nexport interface PairedBootstrapOptions {\n  /** Confidence level. Default 0.95. */\n  confidence?: number\n  /** Bootstrap resample count. Default 2000. */\n  resamples?: number\n  /** Statistic to bootstrap. Default 'median'. */\n  statistic?: 'median' | 'mean'\n  /** Deterministic seed. If omitted, derived from the deltas so the interval\n   *  is reproducible regardless. */\n  seed?: number\n}\n\n/**\n * Paired bootstrap on (after − before) deltas. Returns a CI on the chosen\n * statistic (median by default); pairs are resampled with replacement. Throws\n * on unequal sample sizes.\n *\n * `low > threshold` carries the stated confidence ONLY at `n ≥\n * {@link BOOTSTRAP_GATE_MIN_N}`, which `gateEligible` reports. Below it the\n * check fires under a true null several times more often than nominal, so the\n * interval is descriptive spread and a promotion must not turn on it.\n */\nexport function pairedBootstrap(\n  before: number[],\n  after: number[],\n  opts: PairedBootstrapOptions = {},\n): PairedBootstrapResult {\n  if (before.length !== after.length) {\n    throw new Error(`pairedBootstrap: unequal sample sizes (${before.length} vs ${after.length})`)\n  }\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const statistic = opts.statistic ?? 'median'\n  if (confidence <= 0 || confidence >= 1) {\n    throw new Error(`pairedBootstrap: confidence must be in (0,1), got ${confidence}`)\n  }\n\n  const n = before.length\n  const deltas = before.map((b, i) => after[i]! - b)\n  const gateEligible = n >= BOOTSTRAP_GATE_MIN_N\n  if (n === 0) {\n    return { n: 0, median: 0, mean: 0, low: 0, high: 0, confidence, resamples, gateEligible }\n  }\n  if (n === 1) {\n    const d = deltas[0]!\n    return { n: 1, median: d, mean: d, low: d, high: d, confidence, resamples, gateEligible }\n  }\n\n  const rng = makeRng(opts.seed, deltas)\n  const samples = new Array<number>(resamples)\n  for (let b = 0; b < resamples; b++) {\n    if (statistic === 'mean') {\n      let sum = 0\n      for (let k = 0; k < n; k++) {\n        sum += deltas[Math.floor(rng() * n)]!\n      }\n      samples[b] = sum / n\n    } else {\n      const acc = new Array<number>(n)\n      for (let k = 0; k < n; k++) {\n        acc[k] = deltas[Math.floor(rng() * n)]!\n      }\n      samples[b] = medianInPlace(acc)\n    }\n  }\n  samples.sort((a, b) => a - b)\n\n  const alpha = 1 - confidence\n  const lowIdx = Math.floor((alpha / 2) * resamples)\n  const highIdx = Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1)\n\n  return {\n    n,\n    median: medianInPlace([...deltas]),\n    mean: deltas.reduce((s, x) => s + x, 0) / n,\n    low: samples[lowIdx]!,\n    high: samples[Math.max(highIdx, lowIdx)]!,\n    confidence,\n    resamples,\n    gateEligible,\n  }\n}\n\n/** Pre-registered direction for a one-sided paired sign test. */\nexport type SignTestAlternative = 'greater' | 'less'\n\n/** Exact one-sided sign-test result for paired numeric differences. */\nexport interface PairedSignTestResult {\n  /** Total supplied differences, including zero ties. */\n  n: number\n  /** Strictly positive differences. */\n  positive: number\n  /** Strictly negative differences. */\n  negative: number\n  /** Zero differences excluded from the binomial test. */\n  ties: number\n  /** Non-zero differences used by the binomial test. */\n  nNonTies: number\n  /** Direction of the pre-registered alternative hypothesis. */\n  alternative: SignTestAlternative\n  /** Exact one-sided p-value under P(positive) = P(negative) = 0.5. */\n  pValue: number\n}\n\n/**\n * Exact one-sided sign test over paired differences.\n *\n * Pass `after[i] - before[i]` for each matched item. `alternative = 'greater'`\n * tests whether positive signs are more likely than negative signs and returns\n * `P(Binomial(nNonTies, 0.5) >= positive)`. `alternative = 'less'` treats\n * negative signs as successes instead. With a continuous difference\n * distribution this is the usual directional median test. Exact zero\n * differences are ties and do not enter the binomial denominator. All-tie and\n * empty inputs return p = 1. Every input difference must be finite, and the\n * direction must be chosen explicitly so a caller cannot select it after\n * seeing the signs.\n */\nexport function pairedSignTest(\n  differences: readonly number[],\n  alternative: SignTestAlternative,\n): PairedSignTestResult {\n  if (alternative !== 'greater' && alternative !== 'less') {\n    throw new ValidationError(\n      `pairedSignTest: alternative must be 'greater' or 'less', got ${alternative}`,\n    )\n  }\n\n  let positive = 0\n  let negative = 0\n  let ties = 0\n  for (let i = 0; i < differences.length; i++) {\n    const difference = differences[i]!\n    if (!Number.isFinite(difference)) {\n      throw new ValidationError(\n        `pairedSignTest: difference at index ${i} must be finite, got ${difference}`,\n      )\n    }\n    if (difference > 0) positive++\n    else if (difference < 0) negative++\n    else ties++\n  }\n\n  const nNonTies = positive + negative\n  const successes = alternative === 'greater' ? positive : negative\n  return {\n    n: differences.length,\n    positive,\n    negative,\n    ties,\n    nNonTies,\n    alternative,\n    pValue: binomialHalfUpperTail(successes, nNonTies),\n  }\n}\n\n/** Fraction of paired observations whose delta is an exact tie (|after − before|\n *  < 1e-9). Throws on unequal sample sizes; 0 pairs ⇒ 0. */\nexport function pairedDeltaTieFraction(\n  before: ArrayLike<number>,\n  after: ArrayLike<number>,\n): number {\n  if (before.length !== after.length) {\n    throw new Error(\n      `pairedDeltaTieFraction: unequal sample sizes (${before.length} vs ${after.length})`,\n    )\n  }\n  const n = before.length\n  if (n === 0) return 0\n  let ties = 0\n  for (let i = 0; i < n; i++) {\n    if (Math.abs(after[i]! - before[i]!) < 1e-9) ties++\n  }\n  return ties / n\n}\n\n/**\n * The paired-delta statistic a DECISION is computed on, package-wide.\n *\n * The mean paired delta is the estimator that answers the question a promotion\n * gate asks — \"by how much did the candidate move the score\" — in the caller's\n * own units, and it equals the aggregate lift everyone quotes. The MEDIAN\n * answers a different question and loses the answer to this one in every regime\n * eval data actually lands in:\n *   - TWO-POINT (pass/fail) outcomes on any encoding: the delta vector lives in\n *     {−s, 0, +s} dominated by zeros, so the median and its whole bootstrap CI\n *     are pinned at exactly 0 however large the shift. (Decide these on\n *     {@link pairedRiskDifferenceExact} instead — same estimand, exact interval.)\n *   - TIE-DOMINATED outcomes: at half the pairs tied the sample median is 0 by\n *     construction, and `ci.low > threshold` then answers \"no\" forever at a\n *     non-negative threshold and \"yes\" forever at a negative one.\n *   - LOW-CARDINALITY outcomes, even well below half ties: judge dimensions on\n *     integer 0-100, and block scores like {⅔, 1} from averaging pass/fail\n *     leaves, put the median on a coarse lattice whose bootstrap percentiles\n *     land on atoms. Measured: 26 blocks of 3 pass/fail leaves carrying a real\n *     +12.8pp lift, only 23% of pairs tied, gives a median CI of [0, 0.333] —\n *     lower bound exactly 0, so a gate at threshold 0 refuses a real lift.\n * That last case is why there is no tie-fraction threshold here: any cutoff on\n * ties leaves the lattice case open on the other side of it.\n *\n * `heldoutSignificance` has defaulted to the mean since #316 for the same\n * reason. The median remains available per call site for callers who\n * specifically want outlier robustness and accept the blindness.\n */\nexport const DECISION_PAIRED_DELTA_STATISTIC: 'mean' = 'mean'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,YAAY,QAAkB,OAAoC;CAChF,IAAI,OAAO,WAAW,MAAM,QAC1B,MAAM,IAAI,gBACR,sCAAsC,OAAO,OAAO,MAAM,MAAM,OAAO,EACzE;CAEF,mBAAmB,eAAe,UAAU,MAAM;CAClD,mBAAmB,eAAe,SAAS,KAAK;CAChD,MAAM,IAAI,OAAO;CACjB,IAAI,IAAI,GAAG,OAAO;EAAE,GAAG;EAAM,IAAI;EAAG,GAAG;CAAK;CAE5C,MAAM,QAAQ,OAAO,KAAK,GAAG,MAAM,MAAM,KAAM,CAAC;CAChD,MAAM,OAAO,MAAM,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;CAChD,MAAM,WAAW,MAAM,QAAQ,KAAK,MAAM,OAAO,IAAI,SAAS,GAAG,CAAC,KAAK,IAAI;CAC3E,MAAM,KAAK,KAAK,KAAK,WAAW,CAAC;CACjC,IAAI,OAAO,GACT,OAAO,SAAS,IAAI;EAAE,GAAG;EAAG,IAAI,IAAI;EAAG,GAAG;CAAE,IAAI;EAAE,GAAG;EAAM,IAAI,IAAI;EAAG,GAAG;CAAK;CAGhF,MAAM,IAAI,OAAO;CACjB,MAAM,KAAK,IAAI;CAEf,OAAO;EAAE;EAAG;EAAI,GADN,KAAK,IAAI,YAAY,KAAK,IAAI,CAAC,GAAG,EAAE;CAC5B;AACpB;;;;;;;;;;;AAiCA,MAAa,uBAAuB;;;;;;;;;;;AAwBpC,SAAgB,gBACd,QACA,OACA,OAA+B,CAAC,GACT;CACvB,IAAI,OAAO,WAAW,MAAM,QAC1B,MAAM,IAAI,MAAM,0CAA0C,OAAO,OAAO,MAAM,MAAM,OAAO,EAAE;CAE/F,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,YAAY,KAAK,aAAa;CACpC,IAAI,cAAc,KAAK,cAAc,GACnC,MAAM,IAAI,MAAM,qDAAqD,YAAY;CAGnF,MAAM,IAAI,OAAO;CACjB,MAAM,SAAS,OAAO,KAAK,GAAG,MAAM,MAAM,KAAM,CAAC;CACjD,MAAM,eAAe,KAAA;CACrB,IAAI,MAAM,GACR,OAAO;EAAE,GAAG;EAAG,QAAQ;EAAG,MAAM;EAAG,KAAK;EAAG,MAAM;EAAG;EAAY;EAAW;CAAa;CAE1F,IAAI,MAAM,GAAG;EACX,MAAM,IAAI,OAAO;EACjB,OAAO;GAAE,GAAG;GAAG,QAAQ;GAAG,MAAM;GAAG,KAAK;GAAG,MAAM;GAAG;GAAY;GAAW;EAAa;CAC1F;CAEA,MAAM,MAAM,QAAQ,KAAK,MAAM,MAAM;CACrC,MAAM,UAAU,IAAI,MAAc,SAAS;CAC3C,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAC7B,IAAI,cAAc,QAAQ;EACxB,IAAI,MAAM;EACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,OAAO,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC;EAEpC,QAAQ,KAAK,MAAM;CACrB,OAAO;EACL,MAAM,MAAM,IAAI,MAAc,CAAC;EAC/B,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,IAAI,KAAK,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC;EAEtC,QAAQ,KAAK,cAAc,GAAG;CAChC;CAEF,QAAQ,MAAM,GAAG,MAAM,IAAI,CAAC;CAE5B,MAAM,QAAQ,IAAI;CAClB,MAAM,SAAS,KAAK,MAAO,QAAQ,IAAK,SAAS;CACjD,MAAM,UAAU,KAAK,IAAI,YAAY,GAAG,KAAK,MAAM,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC;CAElF,OAAO;EACL;EACA,QAAQ,cAAc,CAAC,GAAG,MAAM,CAAC;EACjC,MAAM,OAAO,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;EAC1C,KAAK,QAAQ;EACb,MAAM,QAAQ,KAAK,IAAI,SAAS,MAAM;EACtC;EACA;EACA;CACF;AACF;;;;;;;;;;;;;;AAoCA,SAAgB,eACd,aACA,aACsB;CACtB,IAAI,gBAAgB,aAAa,gBAAgB,QAC/C,MAAM,IAAI,gBACR,gEAAgE,aAClE;CAGF,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;EAC3C,MAAM,aAAa,YAAY;EAC/B,IAAI,CAAC,OAAO,SAAS,UAAU,GAC7B,MAAM,IAAI,gBACR,uCAAuC,EAAE,uBAAuB,YAClE;EAEF,IAAI,aAAa,GAAG;OACf,IAAI,aAAa,GAAG;OACpB;CACP;CAEA,MAAM,WAAW,WAAW;CAC5B,MAAM,YAAY,gBAAgB,YAAY,WAAW;CACzD,OAAO;EACL,GAAG,YAAY;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ,sBAAsB,WAAW,QAAQ;CACnD;AACF;;;AAIA,SAAgB,uBACd,QACA,OACQ;CACR,IAAI,OAAO,WAAW,MAAM,QAC1B,MAAM,IAAI,MACR,iDAAiD,OAAO,OAAO,MAAM,MAAM,OAAO,EACpF;CAEF,MAAM,IAAI,OAAO;CACjB,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,IAAI,KAAK,IAAI,MAAM,KAAM,OAAO,EAAG,IAAI,MAAM;CAE/C,OAAO,OAAO;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,kCAA0C"}

package/dist/power-and-mde-g3vOn0XK.js

@@ -1,99 +0,0 @@
-import { o as normalCdf } from "./paired-arms-3-tsXvvC.js";
-import { f as zQuantile } from "./mean-D1d6gedE.js";
-// src/statistics/power-and-mde.ts
-/**
-* Required N per arm for a two-sample comparison at target effect size,
-* alpha, and power. Normal-approximation formula:
-*   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2
-* where d is Cohen's d. Returns Infinity for effect ≤ 0.
-*/
-function requiredSampleSize(opts) {
-	const effect = opts.effect;
-	if (!Number.isFinite(effect) || effect <= 0) return Infinity;
-	const alpha = opts.alpha ?? .05;
-	const power = opts.power ?? .8;
-	const twoSided = opts.twoSided ?? true;
-	const n = 2 * ((zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha) + zQuantile(power)) / effect) ** 2;
-	return Math.ceil(n);
-}
-/**
-* Required number of paired observations for a target Cohen's dz.
-* Unlike the independent-groups formula, this has no two-arm factor of two.
-*
-* Normal quantiles with no t correction, so treat the result as a LOWER bound:
-* it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where
-* it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller
-* consults to decide whether 3–10 repetitions suffice.
-*/
-function requiredPairedSampleSize(opts) {
-	const effect = opts.effect;
-	if (!Number.isFinite(effect) || effect <= 0) return Infinity;
-	const alpha = opts.alpha ?? .05;
-	const power = opts.power ?? .8;
-	const twoSided = opts.twoSided ?? true;
-	const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
-	const zBeta = zQuantile(power);
-	return Math.ceil(((zAlpha + zBeta) / effect) ** 2);
-}
-/**
-* Minimum detectable paired effect (standardised units) for a target paired
-* sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by
-* sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap
-* have asymptotic relative efficiency below 1 vs the t-test on heavy tails.
-*/
-function pairedMde(opts) {
-	if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity;
-	const alpha = opts.alpha ?? .05;
-	const power = opts.power ?? .8;
-	const twoSided = opts.twoSided ?? true;
-	return (zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha) + zQuantile(power)) / Math.sqrt(opts.nPaired);
-}
-/**
-* Number of paired observations needed for a McNemar test to reach a target
-* power — the pre-registration companion to {@link mcnemar}. Parametrised by the
-* expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and
-* `p01` (P[control wins]); concordant pairs carry no information, so the count
-* is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal
-* approximation: with discordant rate `pDisc = p10 + p01` and marginal effect
-* `δ = p10 − p01`,
-*   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².
-* Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the
-* tiny discordant counts where the exact {@link mcnemar} differs from the normal
-* approximation, treat the result as a lower bound and prefer the discordant-pair
-* floor.
-*/
-function mcnemarRequiredN(opts) {
-	const { p10, p01 } = opts;
-	if (p10 < 0 || p01 < 0 || p10 + p01 > 1) throw new Error(`mcnemarRequiredN: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`);
-	const delta = p10 - p01;
-	if (delta === 0) return Infinity;
-	const alpha = opts.alpha ?? .05;
-	const power = opts.power ?? .8;
-	const twoSided = opts.twoSided ?? true;
-	const pDisc = p10 + p01;
-	const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
-	const zBeta = zQuantile(power);
-	const n = (zAlpha * Math.sqrt(pDisc) + zBeta * Math.sqrt(Math.max(0, pDisc - delta * delta))) ** 2 / (delta * delta);
-	return Math.ceil(n);
-}
-/**
-* Power of a McNemar test at a given number of paired observations, the inverse
-* of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).
-* Returns a value in [0, 1]; equals `alpha` when there is no effect.
-*/
-function mcnemarPower(opts) {
-	const { p10, p01, nPairs } = opts;
-	if (p10 < 0 || p01 < 0 || p10 + p01 > 1) throw new Error(`mcnemarPower: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`);
-	const alpha = opts.alpha ?? .05;
-	const twoSided = opts.twoSided ?? true;
-	const delta = p10 - p01;
-	if (delta === 0 || nPairs <= 0) return alpha;
-	const pDisc = p10 + p01;
-	const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha);
-	const denom = Math.sqrt(Math.max(1e-12, pDisc - delta * delta));
-	const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom;
-	return Math.min(1, Math.max(0, normalCdf(zBeta)));
-}
-export { requiredSampleSize as a, requiredPairedSampleSize as i, mcnemarRequiredN as n, pairedMde as r, mcnemarPower as t };
-
-//# sourceMappingURL=power-and-mde-g3vOn0XK.js.map

package/dist/power-and-mde-g3vOn0XK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"power-and-mde-g3vOn0XK.js","names":[],"sources":["../src/statistics/power-and-mde.ts"],"sourcesContent":["import { normalCdf } from '../math/normal'\nimport { zQuantile } from './internal'\n\n// ── Power analysis + minimum detectable effect ───────────────────────\n\n/**\n * Required N per arm for a two-sample comparison at target effect size,\n * alpha, and power. Normal-approximation formula:\n *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2\n * where d is Cohen's d. Returns Infinity for effect ≤ 0.\n */\nexport function requiredSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n = 2 * ((zAlpha + zBeta) / effect) ** 2\n  return Math.ceil(n)\n}\n\n/**\n * Required number of paired observations for a target Cohen's dz.\n * Unlike the independent-groups formula, this has no two-arm factor of two.\n *\n * Normal quantiles with no t correction, so treat the result as a LOWER bound:\n * it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where\n * it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller\n * consults to decide whether 3–10 repetitions suffice.\n */\nexport function requiredPairedSampleSize(opts: {\n  effect: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const effect = opts.effect\n  if (!Number.isFinite(effect) || effect <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return Math.ceil(((zAlpha + zBeta) / effect) ** 2)\n}\n\n/**\n * Minimum detectable paired effect (standardised units) for a target paired\n * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by\n * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap\n * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.\n */\nexport function pairedMde(opts: {\n  nPaired: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  if (!Number.isFinite(opts.nPaired) || opts.nPaired <= 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  return (zAlpha + zBeta) / Math.sqrt(opts.nPaired)\n}\n\n/**\n * Number of paired observations needed for a McNemar test to reach a target\n * power — the pre-registration companion to {@link mcnemar}. Parametrised by the\n * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and\n * `p01` (P[control wins]); concordant pairs carry no information, so the count\n * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal\n * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect\n * `δ = p10 − p01`,\n *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².\n * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the\n * tiny discordant counts where the exact {@link mcnemar} differs from the normal\n * approximation, treat the result as a lower bound and prefer the discordant-pair\n * floor.\n */\nexport function mcnemarRequiredN(opts: {\n  p10: number\n  p01: number\n  alpha?: number\n  power?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01 } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarRequiredN: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const delta = p10 - p01\n  if (delta === 0) return Infinity\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const twoSided = opts.twoSided ?? true\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const zBeta = zQuantile(power)\n  const n =\n    (zAlpha * Math.sqrt(pDisc) + zBeta * Math.sqrt(Math.max(0, pDisc - delta * delta))) ** 2 /\n    (delta * delta)\n  return Math.ceil(n)\n}\n\n/**\n * Power of a McNemar test at a given number of paired observations, the inverse\n * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).\n * Returns a value in [0, 1]; equals `alpha` when there is no effect.\n */\nexport function mcnemarPower(opts: {\n  p10: number\n  p01: number\n  nPairs: number\n  alpha?: number\n  twoSided?: boolean\n}): number {\n  const { p10, p01, nPairs } = opts\n  if (p10 < 0 || p01 < 0 || p10 + p01 > 1) {\n    throw new Error(`mcnemarPower: require p10,p01 ≥ 0 and p10+p01 ≤ 1 (got ${p10}, ${p01})`)\n  }\n  const alpha = opts.alpha ?? 0.05\n  const twoSided = opts.twoSided ?? true\n  const delta = p10 - p01\n  if (delta === 0 || nPairs <= 0) return alpha\n  const pDisc = p10 + p01\n  const zAlpha = zQuantile(twoSided ? 1 - alpha / 2 : 1 - alpha)\n  const denom = Math.sqrt(Math.max(1e-12, pDisc - delta * delta))\n  const zBeta = (Math.sqrt(nPairs) * Math.abs(delta) - zAlpha * Math.sqrt(pDisc)) / denom\n  return Math.min(1, Math.max(0, normalCdf(zBeta)))\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,mBAAmB,MAKxB;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,MAAM,IAAI,MAFK,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAEnC,IADP,UAAU,KACK,KAAK,WAAW;CAC7C,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;;;;;AAWA,SAAgB,yBAAyB,MAK9B;CACT,MAAM,SAAS,KAAK;CACpB,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG,OAAO;CACpD,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,OAAO,KAAK,OAAO,SAAS,SAAS,WAAW,CAAC;AACnD;;;;;;;AAQA,SAAgB,UAAU,MAKf;CACT,IAAI,CAAC,OAAO,SAAS,KAAK,OAAO,KAAK,KAAK,WAAW,GAAG,OAAO;CAChE,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAGlC,QAFe,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAE3C,IADC,UAAU,KACH,KAAK,KAAK,KAAK,KAAK,OAAO;AAClD;;;;;;;;;;;;;;;AAgBA,SAAgB,iBAAiB,MAMtB;CACT,MAAM,EAAE,KAAK,QAAQ;CACrB,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,8DAA8D,IAAI,IAAI,IAAI,EAAE;CAE9F,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,UAAU,KAAK;CAC7B,MAAM,KACH,SAAS,KAAK,KAAK,KAAK,IAAI,QAAQ,KAAK,KAAK,KAAK,IAAI,GAAG,QAAQ,QAAQ,KAAK,CAAC,MAAM,KACtF,QAAQ;CACX,OAAO,KAAK,KAAK,CAAC;AACpB;;;;;;AAOA,SAAgB,aAAa,MAMlB;CACT,MAAM,EAAE,KAAK,KAAK,WAAW;CAC7B,IAAI,MAAM,KAAK,MAAM,KAAK,MAAM,MAAM,GACpC,MAAM,IAAI,MAAM,0DAA0D,IAAI,IAAI,IAAI,EAAE;CAE1F,MAAM,QAAQ,KAAK,SAAS;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,QAAQ,MAAM;CACpB,IAAI,UAAU,KAAK,UAAU,GAAG,OAAO;CACvC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,UAAU,WAAW,IAAI,QAAQ,IAAI,IAAI,KAAK;CAC7D,MAAM,QAAQ,KAAK,KAAK,KAAK,IAAI,OAAO,QAAQ,QAAQ,KAAK,CAAC;CAC9D,MAAM,SAAS,KAAK,KAAK,MAAM,IAAI,KAAK,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,KAAK,KAAK;CAClF,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,KAAK,CAAC,CAAC;AAClD"}

package/dist/promotion-gate-DOkgJcLW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promotion-gate-DOkgJcLW.d.ts","names":[],"sources":["../src/statistics/rank-tests.ts","../src/release-confidence.ts","../src/promotion-gate.ts"],"mappings":";;;;KAYY;;KAGA;UAEK;;EAEf,SAAS;;EAET;;;EAGA;;UAYe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER;;;;;;;;;;;;;;iBAec,aACd,aACA,aACA,OAAM,kBACL;UAuFc;;;EAGf;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;;;;;;;;iBAgBc,mBACd,kBACA,iBACA,OAAM,kBACL;;KChKE;;UAGY;;EAEf;;EAEA;EACA,WAAW;;EAEX;;EAEA;;EAEA;;EAEA;EACA,WAAW;;KAGD;KACA;UAQK;EACf;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA;EACA;;EAEA,eAAe;EACf,MAAM;EACN,WAAW;;UAGI;;EAEf;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA,UAAU;EACV,qBAAqB;EACrB,gBAAgB;EAChB,kBAAkB;EAClB,eAAe;EACf,aAAa;;UAGE;EACf,MAAM;EACN,QAAQ;EACR;EACA;;UAGe;EACf,MAAM;EACN;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,aAAa,OAAO;EACpB,cAAc;EACd,oBAAoB,QAAQ,OAAO;EACnC,0BAA0B;;;;;;;EAO1B;;UAGe;EACf;EACA;EACA;EACA,QAAQ;EACR;EACA,MAAM;EACN,QAAQ;EACR,SAAS;EACT,SAAS;EACT,cAAc;EACd;;iBAkBc,0BACd,OAAO,yBACN;;;;;;;;;;;;;;;;;;;;;;;;;KC3JS;UAEK;EACf;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,SAAS;;UAGM;;EAEf;;EAEA;;;;;;EAMA;;;EAGA;;;;;;;;;iBAUc,YACd,oBACA,qBACA,UAAS,mBACR;;;;;;;;;;;;;;;;UA0Gc,oBAAoB;EACnC,iBAAiB;EACjB,kBAAkB;;EAElB,QAAQ,QAAQ,YAAY;EAC5B;EACA;;EAEA;;EAEA;;;;;iBAMoB,gBAAgB,SACpC,MAAM,oBAAoB,WACzB,QAAQ;EAAoB;EAAyB"}

package/dist/random-BN150Q_X.d.ts

@@ -1,79 +0,0 @@
-/**
- * Required N per arm for a two-sample comparison at target effect size,
- * alpha, and power. Normal-approximation formula:
- *   n = 2 * ( (z_{1-α/2} + z_{1-β}) / d )^2
- * where d is Cohen's d. Returns Infinity for effect ≤ 0.
- */
-declare function requiredSampleSize(opts: {
-  effect: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Required number of paired observations for a target Cohen's dz.
- * Unlike the independent-groups formula, this has no two-arm factor of two.
- *
- * Normal quantiles with no t correction, so treat the result as a LOWER bound:
- * it returns 32 where the exact t-based answer is 34 at dz = 0.5, and 13 where
- * it is 15 at dz = 0.8 — a 6–13 % shortfall precisely in the range a caller
- * consults to decide whether 3–10 repetitions suffice.
- */
-declare function requiredPairedSampleSize(opts: {
-  effect: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Minimum detectable paired effect (standardised units) for a target paired
- * sample size: d_min = (z_{1-α/2} + z_β) / sqrt(n_paired). Multiply by
- * sd(deltas) for score units; treat as a lower bound — Wilcoxon and bootstrap
- * have asymptotic relative efficiency below 1 vs the t-test on heavy tails.
- */
-declare function pairedMde(opts: {
-  nPaired: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Number of paired observations needed for a McNemar test to reach a target
- * power — the pre-registration companion to {@link mcnemar}. Parametrised by the
- * expected discordant-cell probabilities `p10` (P[treatment wins on a pair]) and
- * `p01` (P[control wins]); concordant pairs carry no information, so the count
- * is driven entirely by the discordant rate. Lachin's (1992) asymptotic normal
- * approximation: with discordant rate `pDisc = p10 + p01` and marginal effect
- * `δ = p10 − p01`,
- *   n = ( z_{1-α/2}·√pDisc + z_{1-β}·√(pDisc − δ²) )² / δ².
- * Returns Infinity when there is no effect (p10 === p01). Asymptotic — at the
- * tiny discordant counts where the exact {@link mcnemar} differs from the normal
- * approximation, treat the result as a lower bound and prefer the discordant-pair
- * floor.
- */
-declare function mcnemarRequiredN(opts: {
-  p10: number;
-  p01: number;
-  alpha?: number;
-  power?: number;
-  twoSided?: boolean;
-}): number;
-/**
- * Power of a McNemar test at a given number of paired observations, the inverse
- * of {@link mcnemarRequiredN} (same Lachin asymptotic model, same parameters).
- * Returns a value in [0, 1]; equals `alpha` when there is no effect.
- */
-declare function mcnemarPower(opts: {
-  p10: number;
-  p01: number;
-  nPairs: number;
-  alpha?: number;
-  twoSided?: boolean;
-}): number;
-/** Tiny seedable PRNG (mulberry32) — deterministic resampling/shuffling, not
- *  cryptographic. Exported so e-process shuffles and bootstrap resampling
- *  share ONE PRNG implementation. Every distinct 32-bit seed gives a distinct
- *  stream, including 0. */
-declare function mulberry32(seed: number): () => number;
-export { requiredPairedSampleSize as a, pairedMde as i, mcnemarPower as n, requiredSampleSize as o, mcnemarRequiredN as r, mulberry32 as t };
-//# sourceMappingURL=random-BN150Q_X.d.ts.map

package/dist/random-BN150Q_X.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"random-BN150Q_X.d.ts","names":[],"sources":["../src/statistics/power-and-mde.ts","../src/statistics/random.ts"],"mappings":";;;;;;iBAWgB,mBAAmB;EACjC;EACA;EACA;EACA;;;;;;;;;;;iBAsBc,yBAAyB;EACvC;EACA;EACA;EACA;;;;;;;;iBAkBc,UAAU;EACxB;EACA;EACA;EACA;;;;;;;;;;;;;;;;iBAyBc,iBAAiB;EAC/B;EACA;EACA;EACA;EACA;;;;;;;iBAyBc,aAAa;EAC3B;EACA;EACA;EACA;EACA;;;;;;iBCrHc,WAAW"}

package/dist/schema-CfoA9U_U.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-CfoA9U_U.d.ts","names":[],"sources":["../src/statistics/descriptive.ts","../src/rollout/license.ts","../src/rollout/schema.ts"],"mappings":";;;;;iBAWgB,aAAa;EAAU;EAAe;;;;;;;;;;iBAoBtC,mBACd,kBACA,qBACA;EAAQ;EAAe;;EACpB;EAAc;EAAe;;;;;;;iBAqClB,iBAAiB,YAAY;;UAW5B;WACN;;WAEA;;WAEA;WACA;WACA;;WAEA;;;;;;;;;iBAUK,uBACd,4BACA,sBACC;;iBAkCa,cAAc,iBAAiB;;UAM9B;WACN;WACA;WACA;WACA;WACA;WACA;WACA,cAAc,SAAS;WACvB;aACE;aACA;aACA;aACA;aACA;aACA;aACA;;;UAII;;EAEf;;EAEA;IAAmB;;;;;;;;;;iBAUL,sBACd,2BACA,UAAU,4BACT;;;;;iBA6Ea,MAAM;;;;;;iBAmBN,SAAS,aAAa;;;;;iBAuBtB,UAAU,aAAa;UAKtB;;EAEf,MAAM;;;;;EAKN,SAAS;;EAET;;UAGe;EACf;EACA;;;;;;;;;;;iBAYc,kBAAkB,OAAO,yBAAyB;KClTtD;cACC,0BAA0B;;iBAYvB,mBAAmB,kCAAkC;;iBAQrD,eAAe,MAAM,KAAK,yBAAyB;;iBASnD,kBACd,MAAM,KAAK,wBACX,mBAAmB;cCLR;;KAGD;cACC,wBAAwB;;KAUzB;cACC,yBAAyB;iBAItB,iBAAiB,OAAO;;KAK5B;cACC,2BAA2B;KAM5B;UAGK;EACf;EACA;EACA;IACE;;IAEA;;;UAIa;EACf,MAAM;EACN;;EAEA;EACA,aAAa;;EAEb;EACA;;;;;;;;EAQA;;UAGe;EACf;EACA;IACE;IACA;IACA,aAAa;;;;;;;;UASA;EACf;EACA;;EAEA;;EAEA;EACA;EACA;;;;;EAUA;;EAEA;;EAEA;;;;;;EAMA;;UAOe;;EAEf;EACA;EACA,OAAO;;EAEP;;EAEA;;UAGe;;EAEf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,UAAU;;EAEV,gBAAgB;;UAGD;;;;;EAKf;;EAEA;;EAEA;;EAEA,SAAS;EACT;EACA;EACA;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;EAKA;;UAGe;EACf;EACA;;;EAGA;;;;;;;UAQe;;EAEf,UAAU;;EAEV;;;;;;;;;EASA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;WACN;WACA;;WAEA;WACA;WACA;;WAEA;WACA;WACA;;UAGM;EACf;EACA,SAAS;;EAET;IAAW;IAAkB;IAAgB;IAAgB;;;EAE7D,WAAW;;EAEX,8BAA8B;;EAE9B;;;;;;;EAOA;;;;;;;EAOA,iBAAiB;;UAGF;EACf,eAAe;EACf;;;EAGA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA,MAAM;EACN,MAAM;EACN,QAAQ;;EAER,UAAU;EACV,WAAW;;EAEX,QAAQ;EACR,SAAS;EACT,MAAM;EACN,WAAW;EACX,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0GE,iBAAiB,MAAM,cAAc;iBAgXrC,oBAAoB;iBAmBpB,kBACd,gBACA,2BACS,SAAS;iBAOJ,cAAc,iBAAiB,SAAS;;;;;;cAa1C;;;;;;UAOG,6BAA6B;EAC5C;;;;;;;;;;;;;;;;;;;;;;KAuBU,oBAAoB,KAAK;YACzB;EACV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCK,aAAa,gBAAgB,mBAA2B;;iBAiBxD,kBACd,4BACA,mBACC"}

package/dist/sequential-eprocess-C1YLwFaz.js

@@ -1,129 +0,0 @@
-import { s as ValidationError } from "./errors-DeEEV9Vx.js";
-// src/statistics/sequential-eprocess.ts
-/**
-* Betting test-martingale for bounded observations — the e-process core of
-* anytime-valid sequential testing (Waudby-Smith & Ramdas, "Estimating means
-* of bounded random variables by betting", JRSS-B 2024).
-*
-* Observations x_i ∈ [0,1]; H0: E[x] ≤ m₀ (`nullMean`, default 1/2). Wealth
-*
-*   W_t = Π_{i≤t} (1 + λ_i (x_i − m₀)),  W_0 = 1
-*
-* with the truncated GROW-style plug-in bet computed from PRIOR observations:
-*
-*   λ_i = clamp((μ̂_{i−1} − m₀) / (σ̂²_{i−1} + (μ̂_{i−1} − m₀)²), 0, maxBet)
-*
-* where μ̂/σ̂² are the shrunk running estimates μ̂_t = (1/2 + Σx_i)/(t+1),
-* σ̂²_t = (1/4 + Σ(x_i − μ̂_i)²)/(t+1).
-*
-* PREDICTABILITY INVARIANT (load-bearing): λ_i is a function of x_1..x_{i−1}
-* ONLY — it may never see x_i. With λ_i ≥ 0 predictable, each factor has
-* E[1 + λ_i(x_i − m₀) | past] ≤ 1 under H0, so W is a nonnegative
-* supermartingale and Ville's inequality gives P(∃t: W_t ≥ 1/α) ≤ α — the
-* type-I guarantee holds at ANY data-dependent stopping time. λ_1 is always 0
-* (no prior evidence), so the first observation never moves wealth.
-*
-* `decided` latches at the first crossing W_t ≥ 1/α and never un-latches;
-* wealth keeps updating after the crossing (the e-process remains valid), but
-* the decision time is the first crossing.
-*/
-function eProcess(opts = {}) {
-	const alpha = opts.alpha ?? .05;
-	const maxBet = opts.maxBet ?? .5;
-	const nullMean = opts.nullMean ?? .5;
-	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new ValidationError(`eProcess: alpha must be in (0,1), got ${alpha}`);
-	if (!Number.isFinite(nullMean) || nullMean <= 0 || nullMean >= 1) throw new ValidationError(`eProcess: nullMean must be in (0,1), got ${nullMean}`);
-	if (!Number.isFinite(maxBet) || maxBet <= 0 || maxBet >= 1 / nullMean) throw new ValidationError(`eProcess: maxBet must be in (0, 1/nullMean=${(1 / nullMean).toFixed(4)}) so wealth factors stay positive, got ${maxBet}`);
-	const threshold = 1 / alpha;
-	let wealth = 1;
-	let n = 0;
-	let decided = false;
-	let decidedAtN;
-	let sumX = 0;
-	let varSum = 0;
-	if (opts.resume !== void 0) {
-		const r = assertResumable(opts.resume, {
-			alpha,
-			maxBet,
-			nullMean,
-			threshold
-		});
-		wealth = r.wealth;
-		n = r.n;
-		decided = r.decided;
-		decidedAtN = r.decidedAtN;
-		sumX = r.sumX;
-		varSum = r.varSum;
-	}
-	return {
-		update(x) {
-			if (typeof x !== "number" || !Number.isFinite(x) || x < 0 || x > 1) throw new ValidationError(`eProcess: observation must be a finite number in [0,1], got ${x}`);
-			const muPrev = (.5 + sumX) / (n + 1);
-			const varPrev = (.25 + varSum) / (n + 1);
-			const edge = muPrev - nullMean;
-			const lambda = Math.min(maxBet, Math.max(0, edge / (varPrev + edge * edge)));
-			wealth *= 1 + lambda * (x - nullMean);
-			n += 1;
-			sumX += x;
-			const muNow = (.5 + sumX) / (n + 1);
-			varSum += (x - muNow) ** 2;
-			if (!decided && wealth >= threshold) {
-				decided = true;
-				decidedAtN = n;
-			}
-			return {
-				wealth,
-				n,
-				decided
-			};
-		},
-		state() {
-			return {
-				wealth,
-				n,
-				decided,
-				alpha,
-				maxBet,
-				nullMean,
-				threshold,
-				decidedAtN,
-				sumX,
-				varSum
-			};
-		}
-	};
-}
-/**
-* Refuse a snapshot that was not produced by an e-process with exactly these
-* parameters, or whose fields cannot all be true at once. Every check names
-* the field, so a refused restart reports what disagrees.
-*/
-function assertResumable(resume, params) {
-	const fail = (detail) => {
-		throw new ValidationError(`eProcess: cannot resume — ${detail}`);
-	};
-	if (typeof resume !== "object" || resume === null) fail(`resume must be an EProcessState object, got ${String(resume)}`);
-	for (const key of [
-		"alpha",
-		"maxBet",
-		"nullMean",
-		"threshold"
-	]) if (resume[key] !== params[key]) fail(`snapshot ${key}=${resume[key]} differs from the process ${key}=${params[key]}; a snapshot continues only the process it was taken from`);
-	const { wealth, n, decided, decidedAtN, sumX, varSum } = resume;
-	if (!Number.isInteger(n) || n < 0) fail(`n must be a non-negative integer, got ${n}`);
-	if (!Number.isFinite(wealth) || wealth <= 0) fail(`wealth must be a finite positive number, got ${wealth}`);
-	if (!Number.isFinite(sumX) || sumX < 0 || sumX > n) fail(`sumX must lie in [0, n=${n}] for observations in [0,1], got ${sumX}`);
-	if (!Number.isFinite(varSum) || varSum < 0) fail(`varSum must be a finite non-negative number, got ${varSum}`);
-	if (typeof decided !== "boolean") fail(`decided must be a boolean, got ${String(decided)}`);
-	if (n === 0 && (wealth !== 1 || sumX !== 0 || varSum !== 0 || decided)) fail("n=0 requires wealth=1, sumX=0, varSum=0, decided=false");
-	if (decided) {
-		if (decidedAtN === void 0 || !Number.isInteger(decidedAtN) || decidedAtN < 1 || decidedAtN > n) fail(`decided requires decidedAtN to be an integer in [1, n=${n}], got ${decidedAtN}`);
-	} else {
-		if (decidedAtN !== void 0) fail(`decidedAtN=${decidedAtN} is set while decided=false`);
-		if (wealth >= params.threshold) fail(`wealth ${wealth} ≥ threshold ${params.threshold} while decided=false; decided latches at the first crossing`);
-	}
-	return resume;
-}
-export { eProcess as t };
-
-//# sourceMappingURL=sequential-eprocess-C1YLwFaz.js.map

package/dist/sequential-eprocess-C1YLwFaz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sequential-eprocess-C1YLwFaz.js","names":[],"sources":["../src/statistics/sequential-eprocess.ts"],"sourcesContent":["import { ValidationError } from '../errors'\n\n// ── Anytime-valid e-process (betting test-martingale) ────────────────\n\nexport interface EProcessOptions {\n  /** Type-I error budget. The process decides when wealth ≥ 1/alpha\n   *  (Ville's inequality). Default 0.05. */\n  alpha?: number\n  /** Truncation bound on the predictable bet λ ∈ [0, maxBet]. Must satisfy\n   *  maxBet < 1/nullMean so every wealth factor stays strictly positive.\n   *  Default 0.5. */\n  maxBet?: number\n  /** The null boundary m₀ for H0: E[x] ≤ m₀ on x ∈ [0,1]. Default 0.5\n   *  (the paired-delta encoding x = (d+1)/2 maps \"no effect\" to 1/2).\n   *  A pre-registered minEffect shifts this — see `sequentialPairedGate`. */\n  nullMean?: number\n  /** Continue a process from a `state()` snapshot taken before a restart.\n   *  The snapshot never supplies the parameters: `alpha`, `maxBet`, and\n   *  `nullMean` resolve from this options object exactly as for a fresh\n   *  process, and a snapshot recorded under different parameters is refused\n   *  (`ValidationError`) — re-deciding the same stream under new parameters\n   *  would reopen optional stopping. A snapshot whose fields are not\n   *  mutually consistent (tampered or truncated) is refused the same way. */\n  resume?: EProcessState\n}\n\nexport interface EProcessStep {\n  /** Current wealth W_n — the e-value against H0 after n observations. */\n  wealth: number\n  /** Observations consumed so far. */\n  n: number\n  /** True from the first n where W_n ≥ 1/alpha onward (sticky). */\n  decided: boolean\n}\n\n/**\n * Complete snapshot of an e-process. Together with the parameters it is\n * sufficient to continue the process after a restart: `sumX` and `varSum`\n * are the running sums the next bet is computed from, so a process rebuilt\n * from a snapshot produces the same wealth sequence and decision as one that\n * was never interrupted. Plain data: a JSON round-trip preserves it\n * (`decidedAtN` is undefined, and therefore omitted, until decided).\n */\nexport interface EProcessState extends EProcessStep {\n  alpha: number\n  maxBet: number\n  nullMean: number\n  /** The decision boundary 1/alpha. */\n  threshold: number\n  /** Observation count at the first threshold crossing; undefined until decided. */\n  decidedAtN?: number\n  /** Σ x_i over the n observations consumed. */\n  sumX: number\n  /** Σ (x_i − μ̂_i)² over the n observations consumed, μ̂_i the shrunk running\n   *  mean after observation i. */\n  varSum: number\n}\n\nexport interface EProcess {\n  /** Consume one observation x ∈ [0,1]. Throws on non-finite / out-of-range\n   *  input — a silent clamp would corrupt the type-I guarantee. */\n  update(x: number): EProcessStep\n  state(): EProcessState\n}\n\n/**\n * Betting test-martingale for bounded observations — the e-process core of\n * anytime-valid sequential testing (Waudby-Smith & Ramdas, \"Estimating means\n * of bounded random variables by betting\", JRSS-B 2024).\n *\n * Observations x_i ∈ [0,1]; H0: E[x] ≤ m₀ (`nullMean`, default 1/2). Wealth\n *\n *   W_t = Π_{i≤t} (1 + λ_i (x_i − m₀)),  W_0 = 1\n *\n * with the truncated GROW-style plug-in bet computed from PRIOR observations:\n *\n *   λ_i = clamp((μ̂_{i−1} − m₀) / (σ̂²_{i−1} + (μ̂_{i−1} − m₀)²), 0, maxBet)\n *\n * where μ̂/σ̂² are the shrunk running estimates μ̂_t = (1/2 + Σx_i)/(t+1),\n * σ̂²_t = (1/4 + Σ(x_i − μ̂_i)²)/(t+1).\n *\n * PREDICTABILITY INVARIANT (load-bearing): λ_i is a function of x_1..x_{i−1}\n * ONLY — it may never see x_i. With λ_i ≥ 0 predictable, each factor has\n * E[1 + λ_i(x_i − m₀) | past] ≤ 1 under H0, so W is a nonnegative\n * supermartingale and Ville's inequality gives P(∃t: W_t ≥ 1/α) ≤ α — the\n * type-I guarantee holds at ANY data-dependent stopping time. λ_1 is always 0\n * (no prior evidence), so the first observation never moves wealth.\n *\n * `decided` latches at the first crossing W_t ≥ 1/α and never un-latches;\n * wealth keeps updating after the crossing (the e-process remains valid), but\n * the decision time is the first crossing.\n */\nexport function eProcess(opts: EProcessOptions = {}): EProcess {\n  const alpha = opts.alpha ?? 0.05\n  const maxBet = opts.maxBet ?? 0.5\n  const nullMean = opts.nullMean ?? 0.5\n  if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) {\n    throw new ValidationError(`eProcess: alpha must be in (0,1), got ${alpha}`)\n  }\n  if (!Number.isFinite(nullMean) || nullMean <= 0 || nullMean >= 1) {\n    throw new ValidationError(`eProcess: nullMean must be in (0,1), got ${nullMean}`)\n  }\n  if (!Number.isFinite(maxBet) || maxBet <= 0 || maxBet >= 1 / nullMean) {\n    throw new ValidationError(\n      `eProcess: maxBet must be in (0, 1/nullMean=${(1 / nullMean).toFixed(4)}) so wealth ` +\n        `factors stay positive, got ${maxBet}`,\n    )\n  }\n  const threshold = 1 / alpha\n  let wealth = 1\n  let n = 0\n  let decided = false\n  let decidedAtN: number | undefined\n  // Running sums over observations consumed so far — read BEFORE folding in\n  // the next x, so every bet is predictable.\n  let sumX = 0\n  let varSum = 0\n  if (opts.resume !== undefined) {\n    const r = assertResumable(opts.resume, { alpha, maxBet, nullMean, threshold })\n    wealth = r.wealth\n    n = r.n\n    decided = r.decided\n    decidedAtN = r.decidedAtN\n    sumX = r.sumX\n    varSum = r.varSum\n  }\n  return {\n    update(x: number): EProcessStep {\n      if (typeof x !== 'number' || !Number.isFinite(x) || x < 0 || x > 1) {\n        throw new ValidationError(\n          `eProcess: observation must be a finite number in [0,1], got ${x}`,\n        )\n      }\n      // λ from prior observations ONLY — x has not touched sumX/varSum yet.\n      const muPrev = (0.5 + sumX) / (n + 1)\n      const varPrev = (0.25 + varSum) / (n + 1)\n      const edge = muPrev - nullMean\n      const lambda = Math.min(maxBet, Math.max(0, edge / (varPrev + edge * edge)))\n      wealth *= 1 + lambda * (x - nullMean)\n      n += 1\n      sumX += x\n      const muNow = (0.5 + sumX) / (n + 1)\n      varSum += (x - muNow) ** 2\n      if (!decided && wealth >= threshold) {\n        decided = true\n        decidedAtN = n\n      }\n      return { wealth, n, decided }\n    },\n    state(): EProcessState {\n      return { wealth, n, decided, alpha, maxBet, nullMean, threshold, decidedAtN, sumX, varSum }\n    },\n  }\n}\n\ninterface ResolvedEProcessParameters {\n  alpha: number\n  maxBet: number\n  nullMean: number\n  threshold: number\n}\n\n/**\n * Refuse a snapshot that was not produced by an e-process with exactly these\n * parameters, or whose fields cannot all be true at once. Every check names\n * the field, so a refused restart reports what disagrees.\n */\nfunction assertResumable(resume: EProcessState, params: ResolvedEProcessParameters): EProcessState {\n  const fail = (detail: string): never => {\n    throw new ValidationError(`eProcess: cannot resume — ${detail}`)\n  }\n  if (typeof resume !== 'object' || resume === null) {\n    fail(`resume must be an EProcessState object, got ${String(resume)}`)\n  }\n  for (const key of ['alpha', 'maxBet', 'nullMean', 'threshold'] as const) {\n    if (resume[key] !== params[key]) {\n      fail(\n        `snapshot ${key}=${resume[key]} differs from the process ${key}=${params[key]}; ` +\n          'a snapshot continues only the process it was taken from',\n      )\n    }\n  }\n  const { wealth, n, decided, decidedAtN, sumX, varSum } = resume\n  if (!Number.isInteger(n) || n < 0) fail(`n must be a non-negative integer, got ${n}`)\n  if (!Number.isFinite(wealth) || wealth <= 0) {\n    fail(`wealth must be a finite positive number, got ${wealth}`)\n  }\n  if (!Number.isFinite(sumX) || sumX < 0 || sumX > n) {\n    fail(`sumX must lie in [0, n=${n}] for observations in [0,1], got ${sumX}`)\n  }\n  if (!Number.isFinite(varSum) || varSum < 0) {\n    fail(`varSum must be a finite non-negative number, got ${varSum}`)\n  }\n  if (typeof decided !== 'boolean') fail(`decided must be a boolean, got ${String(decided)}`)\n  if (n === 0 && (wealth !== 1 || sumX !== 0 || varSum !== 0 || decided)) {\n    fail('n=0 requires wealth=1, sumX=0, varSum=0, decided=false')\n  }\n  if (decided) {\n    if (\n      decidedAtN === undefined ||\n      !Number.isInteger(decidedAtN) ||\n      decidedAtN < 1 ||\n      decidedAtN > n\n    ) {\n      fail(`decided requires decidedAtN to be an integer in [1, n=${n}], got ${decidedAtN}`)\n    }\n  } else {\n    if (decidedAtN !== undefined) {\n      fail(`decidedAtN=${decidedAtN} is set while decided=false`)\n    }\n    if (wealth >= params.threshold) {\n      fail(\n        `wealth ${wealth} ≥ threshold ${params.threshold} while decided=false; ` +\n          'decided latches at the first crossing',\n      )\n    }\n  }\n  return resume\n}\n"],"mappings":"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"}

package/dist/statistical-heldout-C-tgpUuu.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistical-heldout-C-tgpUuu.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/arm-populations.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":"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"}