@tangle-network/agent-eval 1.0.21 → 1.0.23

package/dist/sequential-BCzXKQab.d.ts

@@ -0,0 +1,246 @@
+import { o as PairedPromotionDecisionOptions, t as PairedDecisionMethod } from "./paired-promotion-decision-DJU3fZxH.js";
+/** A serializable law for one scalar draw. */
+type PairedValueLaw = {
+  kind: 'point';
+  value: number;
+} | {
+  kind: 'atoms';
+  atoms: ReadonlyArray<{
+    value: number;
+    probability: number;
+  }>;
+} | {
+  kind: 'normal';
+  mean: number;
+  sd: number;
+};
+interface PairedPromotionAlternativeCell {
+  /** Probability of this cell. The cells' probabilities sum to 1. */
+  probability: number;
+  /** Pass/fail outcome of each arm in this cell. Required by every call whose
+   *  `outcome` is `'pass'`; ignored otherwise. */
+  pass?: {
+    control: boolean;
+    treatment: boolean;
+  };
+  /** Law of the candidate-minus-baseline delta on the continuous scale, given
+   *  this cell. A tie is `{ kind: 'point', value: 0 }`. */
+  delta: PairedValueLaw;
+}
+interface PairedPromotionAlternative {
+  /** The registered joint law: the cell is drawn first, then the delta given
+   *  the cell, so pass/fail and delta are dependent exactly as registered. */
+  cells: ReadonlyArray<PairedPromotionAlternativeCell>;
+  /**
+   * Law of the control arm's value on the continuous scale; the candidate is
+   * control plus delta. Default `{ kind: 'point', value: 0 }`. The mean and
+   * median bootstraps read only the deltas, so the baseline changes nothing
+   * there; it matters only when a `'delta'` call infers its shape from the
+   * observed values (see `continuous` on {@link PairedPromotionDecisionOptions}).
+   */
+  baseline?: PairedValueLaw;
+}
+interface PairedPromotionPowerCall {
+  /** What the call reads from each simulated pair: `'delta'` gives it
+   *  `(control, control + delta)` on the continuous scale, `'pass'` gives it
+   *  each arm's pass/fail as `0` or `options.binaryScale ?? 1`. */
+  outcome: 'delta' | 'pass';
+  /** The call's options, exactly as the caller will run it. `minPairs`
+   *  defaults to the simulated n, the value a gate seals; a caller-supplied
+   *  value is kept, and one above n refuses every simulation. A `'pass'` call
+   *  must declare `binaryScale`: the simulation never declares one on the
+   *  caller's behalf, because a declared scale routes an all-zero sample to
+   *  the score interval where an inferred one refuses it. */
+  options: PairedPromotionDecisionOptions;
+}
+interface PairedPromotionPowerOptions {
+  /** Total paired episodes, ties included. */
+  n: number;
+  alternative: PairedPromotionAlternative;
+  /** Every call must return `promote: true` for a simulation to count as a
+   *  promotion. At least one call. */
+  calls: ReadonlyArray<PairedPromotionPowerCall>;
+  /** Simulated data sets. Default 1000. */
+  simulations?: number;
+  /** PRNG seed for the simulated draws (not the bootstrap's seed, which each
+   *  call carries in its own options). Default 1. */
+  seed?: number;
+}
+interface PairedPromotionCallRates {
+  outcome: 'delta' | 'pass';
+  /** Fraction of simulations in which this call alone promoted. */
+  promote: number;
+  /** Fractions of simulations in which each refusal channel fired. */
+  insufficient: number;
+  indeterminate: number;
+  exactTestVetoes: number;
+  /** Fraction in which the call was sufficient, determinate, not vetoed, and
+   *  still did not clear its threshold. */
+  hold: number;
+  /** Fraction of simulations decided by each method; the regime the call
+   *  actually ran in at this n. */
+  methods: Partial<Record<PairedDecisionMethod, number>>;
+}
+interface PairedPromotionPowerResult {
+  n: number;
+  simulations: number;
+  seed: number;
+  /** Fraction of simulations in which every call promoted: the joint power. */
+  power: number;
+  /** Monte Carlo standard error of `power`. */
+  standardError: number;
+  /** Wilson 95% interval on `power`. */
+  low: number;
+  high: number;
+  /** Fraction in which at least one call refused (insufficient, indeterminate
+   *  or vetoed); the rest of the non-promotions are holds. */
+  refuse: number;
+  hold: number;
+  /** Per-call rates, in the order the calls were supplied. */
+  calls: PairedPromotionCallRates[];
+}
+interface RequiredPairsForPairedPromotionOptions {
+  /** Target joint power. Default 0.8. */
+  target?: number;
+  alternative: PairedPromotionAlternative;
+  calls: ReadonlyArray<PairedPromotionPowerCall>;
+  /** Smallest n to consider. Default 1. */
+  minPairs?: number;
+  /** Largest n to consider; the scan stops there with `n: null` if the target
+   *  is never reached. Default 200. */
+  maxPairs?: number;
+  simulations?: number;
+  seed?: number;
+}
+interface RequiredPairsForPairedPromotionResult {
+  target: number;
+  /** First n scanned whose estimated joint power reaches the target, or null
+   *  when no n up to `maxPairs` does. Descriptive only: power is not monotone
+   *  in n on the exact and discrete routes, the scan reads one noisy estimate
+   *  per n, and the first crossing of many is biased low. Read the curve. */
+  n: number | null;
+  /**
+   * The conservative choice, which a preregistration should prefer: the first
+   * scanned n whose Wilson lower bound reaches the target AND whose
+   * independent confirmation (a second simulation at that n on a fresh seed,
+   * `confirmation` below) also has its lower bound at or above the target. The
+   * confirmation is what keeps the 95 % coverage: a scan over many n gives
+   * Monte Carlo noise many chances to push one bound across, so the scan's own
+   * bound selects a candidate and never certifies it. Never set while `n` is
+   * null. Null when not reached by `maxPairs`.
+   */
+  nAtLowerBound: number | null;
+  /** The independent simulation at `nAtLowerBound`; null when not reached. */
+  confirmation: PairedPromotionPowerResult | null;
+  /** Every n scanned, in order, with its scan estimate; candidates whose
+   *  confirmation failed are in `rejected`. The scan stops at `nAtLowerBound`
+   *  when that is reached, else at `maxPairs`. */
+  curve: PairedPromotionPowerResult[];
+  /** Candidates the scan's bound selected and the confirmation refused. */
+  rejected: PairedPromotionPowerResult[];
+}
+/**
+ * Joint power of the configured calls at `n` under the registered alternative:
+ * the fraction of simulated data sets on which every call promotes.
+ */
+declare function pairedPromotionPower(options: PairedPromotionPowerOptions): PairedPromotionPowerResult;
+/**
+ * First n at which {@link pairedPromotionPower} reaches the target, scanning
+ * every n from `minPairs` upward. Both the point-estimate answer and the
+ * confirmed lower-bound answer are returned; the scan runs until the latter is
+ * reached (so the curve past `n` is retained) or `maxPairs` is exhausted. A
+ * candidate selected by the scan's bound is certified only by an independent
+ * simulation at that n on a different seed; a candidate that fails it is
+ * recorded and the scan continues.
+ */
+declare function requiredPairsForPairedPromotion(options: RequiredPairsForPairedPromotionOptions): RequiredPairsForPairedPromotionResult;
+type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent';
+interface PairedEvalueOptions {
+  bound?: number;
+  alpha?: number;
+  rope?: {
+    low: number;
+    high: number;
+  };
+  initialBetShrinkage?: number;
+}
+interface PairedEvalueStep {
+  t: number;
+  delta: number;
+  evalue: number;
+  pValue: number;
+  csLow: number;
+  csHigh: number;
+  decision: SequentialDecision;
+}
+interface PairedEvalueSequence {
+  steps: PairedEvalueStep[];
+  finalDecision: SequentialDecision;
+  decisionFiredAt: number | null;
+  clipped: boolean;
+}
+declare function pairedEvalueSequence(deltas: number[], opts?: PairedEvalueOptions): PairedEvalueSequence;
+interface SequentialCrossingHorizonOptions extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {
+  maxPairs?: number;
+}
+interface SequentialCrossingHorizon {
+  readonly evidencePairs: number | null;
+  readonly decisionPairs: number | null;
+  readonly evidenceThreshold: number;
+  readonly decisionThreshold: number;
+  readonly maxPairs: number;
+}
+declare function sequentialCrossingHorizon(opts?: SequentialCrossingHorizonOptions): SequentialCrossingHorizon;
+interface InterimReleaseConfidenceInput {
+  deltaSeries: Array<{
+    candidateId: string;
+    deltas: number[];
+  }>;
+  alpha?: number;
+  bound?: number;
+  rope?: {
+    low: number;
+    high: number;
+  };
+}
+interface InterimReleaseConfidence {
+  candidates: Array<{
+    candidateId: string;
+    decision: SequentialDecision;
+    decisionFiredAt: number | null;
+    finalEvalue: number;
+    finalPValue: number;
+    pairs: number;
+    csLow: number;
+    csHigh: number;
+  }>;
+  recommendation: {
+    decision: SequentialDecision;
+    candidateId: string | null;
+  };
+}
+declare function evaluateInterimReleaseConfidence(input: InterimReleaseConfidenceInput): InterimReleaseConfidence;
+interface SequentialPairedPowerOptions {
+  alpha?: number;
+  bound: number;
+  power?: number;
+  alternative: PairedValueLaw;
+  maxPairs?: number;
+  trials?: number;
+  seed?: number;
+}
+interface SequentialPairedPower {
+  capForPower: number | null;
+  decisionRateByCap: Array<{
+    cap: number;
+    rate: number;
+    lower95: number;
+  }>;
+  realized: {
+    mean: number;
+    sd: number;
+  };
+}
+declare function sequentialPairedPower(opts: SequentialPairedPowerOptions): SequentialPairedPower;
+export { requiredPairsForPairedPromotion as C, pairedPromotionPower as S, PairedPromotionPowerOptions as _, PairedEvalueStep as a, RequiredPairsForPairedPromotionOptions as b, SequentialDecision as c, sequentialCrossingHorizon as d, sequentialPairedPower as f, PairedPromotionPowerCall as g, PairedPromotionCallRates as h, PairedEvalueSequence as i, evaluateInterimReleaseConfidence as l, PairedPromotionAlternativeCell as m, InterimReleaseConfidenceInput as n, SequentialCrossingHorizon as o, PairedPromotionAlternative as p, PairedEvalueOptions as r, SequentialCrossingHorizonOptions as s, InterimReleaseConfidence as t, pairedEvalueSequence as u, PairedPromotionPowerResult as v, RequiredPairsForPairedPromotionResult as x, PairedValueLaw as y };
+//# sourceMappingURL=sequential-BCzXKQab.d.ts.map

package/dist/sequential-BCzXKQab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential-BCzXKQab.d.ts","names":[],"sources":["../src/paired-promotion-power.ts","../src/sequential.ts"],"mappings":";;KA8CY;EACN;EAAe;;EACf;EAAe,OAAO;IAAgB;IAAe;;;EACrD;EAAgB;EAAc;;UAEnB;;EAEf;;;EAGA;IAAS;IAAkB;;;;EAG3B,OAAO;;UAGQ;;;EAGf,OAAO,cAAc;;;;;;;;EAQrB,WAAW;;UAGI;;;;EAIf;;;;;;;EAOA,SAAS;;UAGM;;EAEf;EACA,aAAa;;;EAGb,OAAO,cAAc;;EAErB;;;EAGA;;UAGe;EACf;;EAEA;;EAEA;EACA;EACA;;;EAGA;;;EAGA,SAAS,QAAQ,OAAO;;UAGT;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;EACA;;;EAGA;EACA;;EAEA,OAAO;;UAGQ;;EAEf;EACA,aAAa;EACb,OAAO,cAAc;;EAErB;;;EAGA;EACA;EACA;;UAGe;EACf;;;;;EAKA;;;;;;;;;;;EAWA;;EAEA,cAAc;;;;EAId,OAAO;;EAEP,UAAU;;;;;;iBAOI,qBACd,SAAS,8BACR;;;;;;;;;;iBA4Fa,gCACd,SAAS,yCACR;KCrRS;UAEK;EACf;EACA;EACA;IAAS;IAAa;;EACtB;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA,UAAU;;UAGK;EACf,OAAO;EACP,eAAe;EACf;EACA;;iBAGc,qBACd,kBACA,OAAM,sBACL;UAiEc,yCACP,KAAK;EACb;;UAGe;WACN;WACA;WACA;WACA;WACA;;iBAKK,0BACd,OAAM,mCACL;UAmCc;EACf,aAAa;IAAQ;IAAqB;;EAC1C;EACA;EACA;IAAS;IAAa;;;UAGP;EACf,YAAY;IACV;IACA,UAAU;IACV;IACA;IACA;IACA;IACA;IACA;;EAEF;IAAkB,UAAU;IAAoB;;;iBAGlC,iCACd,OAAO,gCACN;UAwCc;EACf;EACA;EACA;EACA,aAAa;EACb;EACA;EACA;;UAGe;EACf;EACA,mBAAmB;IAAQ;IAAa;IAAc;;EACtD;IAAY;IAAc;;;iBAGZ,sBAAsB,MAAM,+BAA+B"}

package/dist/{sequential-CAksw6EU.js → sequential-Ko7T-zvu.js}

@@ -1,13 +1,7 @@
+import { w as wilson } from "./statistics-CvvC-MPv.js";
+import { t as mulberry32 } from "./random-DrzcgC7F.js";
+import { t as drawValue } from "./paired-promotion-power-D03cUj9E.js";
 // src/sequential.ts
-/**
-* Run the paired e-value sequence over an in-order delta stream.
-*
-* Use for *streaming* / interim analyses: pass the deltas you have so
-* far, get the verdict at every prefix length. The decision is
-* monotone-stable in the sense that once `'reject_now'` or `'promote_now'`
-* fires, the verdict at later steps remains decisive (the e-value is a
-* non-negative martingale; once it crosses the threshold, it's crossed).
-*/
 function pairedEvalueSequence(deltas, opts = {}) {
 	const c = opts.bound ?? 1;
 	const alpha = opts.alpha ?? .05;
@@ -69,12 +63,6 @@ function pairedEvalueSequence(deltas, opts = {}) {
 	};
 }
 const MAX_SEQUENTIAL_CROSSING_PAIRS = 1e6;
-/**
-* Compute the minimum pair count at which even perfect, all-at-bound data can
-* reach the evidence and decision thresholds. The calculation intentionally
-* calls the canonical sequence implementation rather than maintaining a
-* second approximation that can drift from its bet schedule.
-*/
 function sequentialCrossingHorizon(opts = {}) {
 	const bound = opts.bound ?? 1;
 	const alpha = opts.alpha ?? .05;
@@ -98,12 +86,6 @@ function sequentialCrossingHorizon(opts = {}) {
 		maxPairs
 	});
 }
-/**
-* Run interim sequential analyses across many candidates at once,
-* preserving the time-uniform α guarantee for each candidate's series and
-* synthesising a campaign-level recommendation. Designed to be called on
-* every campaign tick — the recommendation is anytime-valid.
-*/
 function evaluateInterimReleaseConfidence(input) {
 	const candidates = input.deltaSeries.map((s) => {
 		const seq = pairedEvalueSequence(s.deltas, {
@@ -154,6 +136,66 @@ function evaluateInterimReleaseConfidence(input) {
 		}
 	};
 }
+const MAX_SEQUENTIAL_POWER_PAIRS = 1e4;
+const MAX_SEQUENTIAL_POWER_TRIALS = 1e4;
+function sequentialPairedPower(opts) {
+	const alpha = opts.alpha ?? .05;
+	const power = opts.power ?? .8;
+	const maxPairs = opts.maxPairs ?? 256;
+	const trials = opts.trials ?? 200;
+	const seed = opts.seed ?? 1;
+	assertSequentialScalarConfiguration(opts.bound, alpha, .5, "sequentialPairedPower");
+	if (!Number.isFinite(power) || power <= 0 || power >= 1) throw new Error(`sequentialPairedPower: power must be in (0,1), got ${power}`);
+	if (!Number.isSafeInteger(maxPairs) || maxPairs < 1 || maxPairs > MAX_SEQUENTIAL_POWER_PAIRS) throw new Error(`sequentialPairedPower: maxPairs must be a safe integer in [1, ${MAX_SEQUENTIAL_POWER_PAIRS}]`);
+	if (!Number.isSafeInteger(trials) || trials < 1 || trials > MAX_SEQUENTIAL_POWER_TRIALS) throw new Error(`sequentialPairedPower: trials must be a safe integer in [1, ${MAX_SEQUENTIAL_POWER_TRIALS}]`);
+	if (!Number.isFinite(seed)) throw new Error(`sequentialPairedPower: seed must be finite, got ${seed}`);
+	if (opts.alternative.kind === "atoms" && opts.alternative.atoms.length === 0) throw new Error("sequentialPairedPower: atoms must be non-empty");
+	const rng = mulberry32(seed);
+	const bound = opts.bound;
+	let sum = 0;
+	let sumSq = 0;
+	const firedAt = new Array(trials);
+	for (let trial = 0; trial < trials; trial++) {
+		const deltas = new Array(maxPairs);
+		for (let i = 0; i < maxPairs; i++) {
+			const raw = drawValue(opts.alternative, rng);
+			if (!Number.isFinite(raw)) throw new Error("sequentialPairedPower: alternative produced a non-finite draw");
+			const clipped = Math.max(-bound, Math.min(bound, raw));
+			deltas[i] = clipped;
+			sum += clipped;
+			sumSq += clipped * clipped;
+		}
+		const sequence = pairedEvalueSequence(deltas, {
+			alpha,
+			bound
+		});
+		firedAt[trial] = sequence.decisionFiredAt ?? maxPairs + 1;
+	}
+	const n = trials * maxPairs;
+	const mean = sum / n;
+	const sd = Math.sqrt(Math.max(0, sumSq / n - mean * mean));
+	const decisionRateByCap = [];
+	let capForPower = null;
+	for (let cap = 1; cap <= maxPairs; cap++) {
+		let hits = 0;
+		for (let trial = 0; trial < trials; trial++) if (firedAt[trial] <= cap) hits += 1;
+		const interval = wilson(hits, trials);
+		decisionRateByCap.push({
+			cap,
+			rate: interval.estimate,
+			lower95: interval.lower
+		});
+		if (capForPower === null && interval.lower >= power) capForPower = cap;
+	}
+	return {
+		capForPower,
+		decisionRateByCap,
+		realized: {
+			mean,
+			sd
+		}
+	};
+}
 function assertSequentialScalarConfiguration(bound, alpha, initialBetShrinkage, context) {
 	if (!Number.isFinite(bound) || bound <= 0) throw new Error(`${context}: bound must be a finite number > 0`);
 	if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) throw new Error(`${context}: alpha must be a finite number in (0,1)`);
@@ -165,11 +207,6 @@ function sequentialThresholds(alpha) {
 		decisionThreshold: 2 / alpha
 	};
 }
-/**
-* Empirical Bernstein confidence sequence on the mean of bounded variables.
-* Adapted from Howard et al. (2021) §4.4. Provides a time-uniform CI on
-* the running mean; valid at every stopping time.
-*/
 function empiricalBernsteinCs(sum, sumSq, n, bound, alpha) {
 	if (n === 0) return {
 		low: -bound,
@@ -184,6 +221,6 @@ function empiricalBernsteinCs(sum, sumSq, n, bound, alpha) {
 		high: mean + radius
 	};
 }
-export { pairedEvalueSequence as n, sequentialCrossingHorizon as r, evaluateInterimReleaseConfidence as t };
+export { sequentialPairedPower as i, pairedEvalueSequence as n, sequentialCrossingHorizon as r, evaluateInterimReleaseConfidence as t };
 
-//# sourceMappingURL=sequential-CAksw6EU.js.map
+//# sourceMappingURL=sequential-Ko7T-zvu.js.map

package/dist/sequential-Ko7T-zvu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential-Ko7T-zvu.js","names":[],"sources":["../src/sequential.ts"],"sourcesContent":["import { drawValue, type PairedValueLaw } from './paired-promotion-power'\nimport { wilson } from './statistics/paired-binary'\nimport { mulberry32 } from './statistics/random'\n\nexport type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent'\n\nexport interface PairedEvalueOptions {\n  bound?: number\n  alpha?: number\n  rope?: { low: number; high: number }\n  initialBetShrinkage?: number\n}\n\nexport interface PairedEvalueStep {\n  t: number\n  delta: number\n  evalue: number\n  pValue: number\n  csLow: number\n  csHigh: number\n  decision: SequentialDecision\n}\n\nexport interface PairedEvalueSequence {\n  steps: PairedEvalueStep[]\n  finalDecision: SequentialDecision\n  decisionFiredAt: number | null\n  clipped: boolean\n}\n\nexport function pairedEvalueSequence(\n  deltas: number[],\n  opts: PairedEvalueOptions = {},\n): PairedEvalueSequence {\n  const c = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialShrink = opts.initialBetShrinkage ?? 0.5\n  const rope = opts.rope ?? null\n  assertSequentialScalarConfiguration(c, alpha, initialShrink, 'pairedEvalueSequence')\n  if (rope && !(Number.isFinite(rope.low) && Number.isFinite(rope.high) && rope.low <= rope.high)) {\n    throw new Error('pairedEvalueSequence: rope must satisfy low ≤ high')\n  }\n  const { decisionThreshold } = sequentialThresholds(alpha)\n\n  const steps: PairedEvalueStep[] = []\n  let clipped = false\n  let evalue = 1\n  let decisionFiredAt: number | null = null\n\n  let sum = 0\n  let sumSq = 0\n  let count = 0\n\n  for (let i = 0; i < deltas.length; i++) {\n    let d = deltas[i]!\n    if (!Number.isFinite(d)) {\n      throw new Error(`pairedEvalueSequence: delta[${i}] must be finite`)\n    }\n    if (d < -c || d > c) {\n      d = Math.max(-c, Math.min(c, d))\n      clipped = true\n    }\n\n    const muHat = count === 0 ? 0 : sum / count\n    const varHat = count === 0 ? c * c : Math.max(1e-12, sumSq / count - muHat * muHat)\n    const t = i + 1\n    const shrink = initialShrink * Math.min(1, count / 32)\n    let lambda = (muHat / (varHat + c * c)) * shrink\n    const lambdaMax = 0.99 / c\n    if (lambda > lambdaMax) lambda = lambdaMax\n    if (lambda < -lambdaMax) lambda = -lambdaMax\n\n    evalue = evalue * (1 + lambda * d)\n    if (!Number.isFinite(evalue) || evalue < 0) evalue = 0\n\n    sum += d\n    sumSq += d * d\n    count += 1\n\n    const pValue = Math.min(1, 1 / Math.max(evalue, 1e-300))\n\n    const cs = empiricalBernsteinCs(sum, sumSq, count, c, alpha)\n\n    let decision: SequentialDecision = 'continue'\n    if (rope && cs.low >= rope.low && cs.high <= rope.high) decision = 'equivalent'\n    else if (evalue >= decisionThreshold && muHat > 0) decision = 'promote_now'\n    else if (evalue >= decisionThreshold && muHat < 0) decision = 'reject_now'\n    else if (rope && cs.high < rope.low) decision = 'reject_now'\n\n    if (decision !== 'continue' && decisionFiredAt === null) decisionFiredAt = t\n\n    steps.push({ t, delta: d, evalue, pValue, csLow: cs.low, csHigh: cs.high, decision })\n  }\n\n  const finalDecision = steps.length === 0 ? 'continue' : steps[steps.length - 1]!.decision\n  return { steps, finalDecision, decisionFiredAt, clipped }\n}\n\nexport interface SequentialCrossingHorizonOptions\n  extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {\n  maxPairs?: number\n}\n\nexport interface SequentialCrossingHorizon {\n  readonly evidencePairs: number | null\n  readonly decisionPairs: number | null\n  readonly evidenceThreshold: number\n  readonly decisionThreshold: number\n  readonly maxPairs: number\n}\n\nconst MAX_SEQUENTIAL_CROSSING_PAIRS = 1_000_000\n\nexport function sequentialCrossingHorizon(\n  opts: SequentialCrossingHorizonOptions = {},\n): SequentialCrossingHorizon {\n  const bound = opts.bound ?? 1\n  const alpha = opts.alpha ?? 0.05\n  const initialBetShrinkage = opts.initialBetShrinkage ?? 0.5\n  const maxPairs = opts.maxPairs ?? 10_000\n  assertSequentialScalarConfiguration(\n    bound,\n    alpha,\n    initialBetShrinkage,\n    'sequentialCrossingHorizon',\n  )\n  if (!Number.isSafeInteger(maxPairs) || maxPairs < 1) {\n    throw new Error('sequentialCrossingHorizon: maxPairs must be a positive safe integer')\n  }\n  if (maxPairs > MAX_SEQUENTIAL_CROSSING_PAIRS) {\n    throw new Error(\n      `sequentialCrossingHorizon: maxPairs must be <= ${MAX_SEQUENTIAL_CROSSING_PAIRS}`,\n    )\n  }\n  const sequence = pairedEvalueSequence(Array<number>(maxPairs).fill(bound), {\n    bound,\n    alpha,\n    initialBetShrinkage,\n  })\n  const { evidenceThreshold, decisionThreshold } = sequentialThresholds(alpha)\n  const evidencePairs = sequence.steps.find((step) => step.evalue >= evidenceThreshold)?.t ?? null\n  return Object.freeze({\n    evidencePairs,\n    decisionPairs: sequence.decisionFiredAt,\n    evidenceThreshold,\n    decisionThreshold,\n    maxPairs,\n  })\n}\n\nexport interface InterimReleaseConfidenceInput {\n  deltaSeries: Array<{ candidateId: string; deltas: number[] }>\n  alpha?: number\n  bound?: number\n  rope?: { low: number; high: number }\n}\n\nexport interface InterimReleaseConfidence {\n  candidates: Array<{\n    candidateId: string\n    decision: SequentialDecision\n    decisionFiredAt: number | null\n    finalEvalue: number\n    finalPValue: number\n    pairs: number\n    csLow: number\n    csHigh: number\n  }>\n  recommendation: { decision: SequentialDecision; candidateId: string | null }\n}\n\nexport function evaluateInterimReleaseConfidence(\n  input: InterimReleaseConfidenceInput,\n): InterimReleaseConfidence {\n  const candidates = input.deltaSeries.map((s) => {\n    const seq = pairedEvalueSequence(s.deltas, {\n      alpha: input.alpha,\n      bound: input.bound,\n      rope: input.rope,\n    })\n    const last = seq.steps[seq.steps.length - 1]\n    return {\n      candidateId: s.candidateId,\n      decision: seq.finalDecision,\n      decisionFiredAt: seq.decisionFiredAt,\n      finalEvalue: last?.evalue ?? 1,\n      finalPValue: last?.pValue ?? 1,\n      pairs: seq.steps.length,\n      csLow: last?.csLow ?? Number.NEGATIVE_INFINITY,\n      csHigh: last?.csHigh ?? Number.POSITIVE_INFINITY,\n    }\n  })\n\n  const promote = candidates.find((c) => c.decision === 'promote_now')\n  if (promote)\n    return {\n      candidates,\n      recommendation: { decision: 'promote_now', candidateId: promote.candidateId },\n    }\n  const live = candidates.find((c) => c.decision === 'continue')\n  if (live) return { candidates, recommendation: { decision: 'continue', candidateId: null } }\n  const equiv = candidates.find((c) => c.decision === 'equivalent')\n  if (equiv)\n    return {\n      candidates,\n      recommendation: { decision: 'equivalent', candidateId: equiv.candidateId },\n    }\n  return { candidates, recommendation: { decision: 'reject_now', candidateId: null } }\n}\n\nconst MAX_SEQUENTIAL_POWER_PAIRS = 10_000\nconst MAX_SEQUENTIAL_POWER_TRIALS = 10_000\n\nexport interface SequentialPairedPowerOptions {\n  alpha?: number\n  bound: number\n  power?: number\n  alternative: PairedValueLaw\n  maxPairs?: number\n  trials?: number\n  seed?: number\n}\n\nexport interface SequentialPairedPower {\n  capForPower: number | null\n  decisionRateByCap: Array<{ cap: number; rate: number; lower95: number }>\n  realized: { mean: number; sd: number }\n}\n\nexport function sequentialPairedPower(opts: SequentialPairedPowerOptions): SequentialPairedPower {\n  const alpha = opts.alpha ?? 0.05\n  const power = opts.power ?? 0.8\n  const maxPairs = opts.maxPairs ?? 256\n  const trials = opts.trials ?? 200\n  const seed = opts.seed ?? 1\n  assertSequentialScalarConfiguration(opts.bound, alpha, 0.5, 'sequentialPairedPower')\n  if (!Number.isFinite(power) || power <= 0 || power >= 1) {\n    throw new Error(`sequentialPairedPower: power must be in (0,1), got ${power}`)\n  }\n  if (!Number.isSafeInteger(maxPairs) || maxPairs < 1 || maxPairs > MAX_SEQUENTIAL_POWER_PAIRS) {\n    throw new Error(\n      `sequentialPairedPower: maxPairs must be a safe integer in [1, ${MAX_SEQUENTIAL_POWER_PAIRS}]`,\n    )\n  }\n  if (!Number.isSafeInteger(trials) || trials < 1 || trials > MAX_SEQUENTIAL_POWER_TRIALS) {\n    throw new Error(\n      `sequentialPairedPower: trials must be a safe integer in [1, ${MAX_SEQUENTIAL_POWER_TRIALS}]`,\n    )\n  }\n  if (!Number.isFinite(seed)) {\n    throw new Error(`sequentialPairedPower: seed must be finite, got ${seed}`)\n  }\n  if (opts.alternative.kind === 'atoms' && opts.alternative.atoms.length === 0) {\n    throw new Error('sequentialPairedPower: atoms must be non-empty')\n  }\n  const rng = mulberry32(seed)\n  const bound = opts.bound\n  let sum = 0\n  let sumSq = 0\n  const firedAt = new Array<number>(trials)\n  for (let trial = 0; trial < trials; trial++) {\n    const deltas = new Array<number>(maxPairs)\n    for (let i = 0; i < maxPairs; i++) {\n      const raw = drawValue(opts.alternative, rng)\n      if (!Number.isFinite(raw)) {\n        throw new Error('sequentialPairedPower: alternative produced a non-finite draw')\n      }\n      const clipped = Math.max(-bound, Math.min(bound, raw))\n      deltas[i] = clipped\n      sum += clipped\n      sumSq += clipped * clipped\n    }\n    const sequence = pairedEvalueSequence(deltas, { alpha, bound })\n    firedAt[trial] = sequence.decisionFiredAt ?? maxPairs + 1\n  }\n  const n = trials * maxPairs\n  const mean = sum / n\n  const sd = Math.sqrt(Math.max(0, sumSq / n - mean * mean))\n  const decisionRateByCap: SequentialPairedPower['decisionRateByCap'] = []\n  let capForPower: number | null = null\n  for (let cap = 1; cap <= maxPairs; cap++) {\n    let hits = 0\n    for (let trial = 0; trial < trials; trial++) if (firedAt[trial]! <= cap) hits += 1\n    const interval = wilson(hits, trials)\n    decisionRateByCap.push({ cap, rate: interval.estimate, lower95: interval.lower })\n    if (capForPower === null && interval.lower >= power) capForPower = cap\n  }\n  return { capForPower, decisionRateByCap, realized: { mean, sd } }\n}\n\nfunction assertSequentialScalarConfiguration(\n  bound: number,\n  alpha: number,\n  initialBetShrinkage: number,\n  context: string,\n): void {\n  if (!Number.isFinite(bound) || bound <= 0) {\n    throw new Error(`${context}: bound must be a finite number > 0`)\n  }\n  if (!Number.isFinite(alpha) || alpha <= 0 || alpha >= 1) {\n    throw new Error(`${context}: alpha must be a finite number in (0,1)`)\n  }\n  if (\n    !Number.isFinite(initialBetShrinkage) ||\n    initialBetShrinkage <= 0 ||\n    initialBetShrinkage > 1\n  ) {\n    throw new Error(`${context}: initialBetShrinkage must be a finite number in (0,1]`)\n  }\n}\n\nfunction sequentialThresholds(alpha: number): {\n  evidenceThreshold: number\n  decisionThreshold: number\n} {\n  return { evidenceThreshold: 1 / alpha, decisionThreshold: 2 / alpha }\n}\n\nfunction empiricalBernsteinCs(\n  sum: number,\n  sumSq: number,\n  n: number,\n  bound: number,\n  alpha: number,\n): { low: number; high: number } {\n  if (n === 0) return { low: -bound, high: bound }\n  const mean = sum / n\n  const variance = Math.max(0, sumSq / n - mean * mean)\n  const psi = Math.log(2 / alpha) + 1.7 * Math.log(Math.log(Math.max(Math.E, n)) + 1)\n  const radius = Math.sqrt((2 * variance * psi) / n) + (3 * bound * psi) / n\n  return { low: mean - radius, high: mean + radius }\n}\n"],"mappings":"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"}

package/dist/{skillopt-optimization-method-QO1nU8Kz.js → skillopt-optimization-method-B1Hkfexf.js}

@@ -4,13 +4,13 @@ import { t as decidePairedPromotion } from "./paired-promotion-decision-Bi9__RQS
 import { a as heldoutSignificance, o as pairHoldout } from "./statistical-heldout-DLO4Ebos.js";
 import { d as mapConcurrent } from "./journal-CTX5uK-n.js";
 import { n as contentHash, t as canonicalJson } from "./verdict-cache-BVH-fl18.js";
-import { $ as resolveRunDir, C as surfaceDiff, G as assertIndependentEvaluationSplit, J as exposeFinalEvidence, K as captureFinalEvidencePolicy, R as captureJudge, T as assertSearchHistoryAdmissionOptions, Y as reserveFinalEvidence, Z as runCampaign, b as SearchRecorder, c as readGepaCandidatePopulationArtifact, d as optimizationTokenUsageFromSummary, l as combineComparisonCosts, o as executeOptimizationMethod, q as evaluationUnitMap, s as assertGepaCandidatePopulationSummary, u as costFromLedgerSummary, w as surfaceNode, x as developmentClaim } from "./llm-judge-C813vmpc.js";
-import { D as assertCompleteCampaign, T as assertCampaignDesign, f as campaignBreakdown, t as createCampaignEvidenceReceipt } from "./campaign-evidence-NtH29ctt.js";
+import { $ as resolveRunDir, C as surfaceDiff, G as assertIndependentEvaluationSplit, J as exposeFinalEvidence, K as captureFinalEvidencePolicy, R as captureJudge, T as assertSearchHistoryAdmissionOptions, Y as reserveFinalEvidence, Z as runCampaign, b as SearchRecorder, c as readGepaCandidatePopulationArtifact, d as optimizationTokenUsageFromSummary, l as combineComparisonCosts, o as executeOptimizationMethod, q as evaluationUnitMap, s as assertGepaCandidatePopulationSummary, u as costFromLedgerSummary, w as surfaceNode, x as developmentClaim } from "./llm-judge-Cbh7OHaO.js";
+import { D as assertCompleteCampaign, T as assertCampaignDesign, f as campaignBreakdown, t as createCampaignEvidenceReceipt } from "./campaign-evidence-CVNKiK0q.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CK8-2W7p.js";
 import { M as fsCampaignStorage, _ as resolveExternalOptimizerCallbackLimits, d as assertExternalOptimizerModelBudget, f as assertJsonValue, g as removeCredentialEnvironment, h as isExternalTextCandidate, i as startExternalOptimizerModelProxy, j as createRunCostLedger, m as isCandidateText, n as closeExternalOptimizerResources, p as assertNoCredentialValues, r as runWithCleanup, t as runExternalOptimizerProcess, v as resolveExternalOptimizerProcessLimits, y as safePathComponent } from "./external-optimizer-subprocess-_C_2yriN.js";
 import { s as surfaceContentHash } from "./json-recovery-DK4MDm5r.js";
 import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-Dod_mjk3.js";
-import { n as openSearchLedger } from "./search-ledger-Dk-yk5Li.js";
+import { n as openSearchLedger } from "./search-ledger-9liYyZf5.js";
 import { t as acquireSingleRunLock } from "./single-run-lock-CUj2tjxT.js";
 import { n as isRecord } from "./json-DtvZNAU9.js";
 import { c as combineAbortSignals, f as assertServedModelPolicy } from "./llm-client-DMMSg-Ro.js";
@@ -3223,4 +3223,4 @@ async function finishSkillOptRun(context, result, outputDir, modelProxy) {
 }
 export { importExternalEvaluations as a, composeGate as c, readExternalOptimizerObservationArtifact as d, externalSurface as i, externalTextOptimizationMethod as l, compareOptimizationMethods as n, importGepaPopulation as o, gepaOptimizationMethod as r, heldOutGate as s, skillOptOptimizationMethod as t, decodeExternalTextCandidate as u };
 
-//# sourceMappingURL=skillopt-optimization-method-QO1nU8Kz.js.map
+//# sourceMappingURL=skillopt-optimization-method-B1Hkfexf.js.map