@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{search-summary-CBvz3u_S.js.map → search-summary-DQIvJsSB.js.map}

@@ -1 +1 @@
-{"version":3,"file":"search-summary-CBvz3u_S.js","names":[],"sources":["../src/campaign/search-summary.ts"],"sourcesContent":["/**\n * The agent's view of a search: the same projection a human reads.\n *\n * `renderSearchSummary` turns a `SearchStateView` into compact text — the\n * leading nodes with their estimates, the most recently discarded ideas with\n * why they were discarded, and a log of recent proposals — as AIDE's journal\n * summary does for its own search. `agent-eval search show <ledger>` prints\n * the same text for a terminal; `runOptimization` puts it on every\n * `ProposeContext` a proposer receives.\n *\n * `searchProposerView` is the train-only read `ProposeContext.train` carries.\n * It has no parameter that can select another split, so a proposer built on\n * it cannot reach the selection or test split even by mistake: the sealed\n * splits (§6.6 of the search-tree design) are unreachable by construction,\n * not by convention.\n */\n\nimport { minimumPairsForPairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N } from '../statistics'\nimport { estimateNode } from './estimate-node'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type { NodeEstimate, SearchSplit } from './search-ledger-types'\nimport type { SearchNode, SearchScoredCell, SearchStateView, SearchUnitScore } from './search-state'\n\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(0.95)\n\n/** The proposer's own read of a search: its node's cells on the train split,\n * the only split a proposer may ever see. */\nexport interface SearchProposerView {\n  readonly searchId: string\n  readonly direction: 'maximize' | 'minimize'\n  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in\n   * flight) are absent, never zero. */\n  scoredCells(nodeId: string): readonly SearchScoredCell[]\n  /** Per-unit train-split means of `nodeId`, in unitId order. */\n  unitScores(nodeId: string): readonly SearchUnitScore[]\n}\n\n/** The train-only view `ProposeContext.train` carries. */\nexport function searchProposerView(state: SearchStateView): SearchProposerView {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  return {\n    searchId: state.searchId,\n    direction: header.objective.direction,\n    scoredCells: (nodeId) => state.scoredCells(nodeId, 'train'),\n    unitScores: (nodeId) => state.unitScores(nodeId, 'train'),\n  }\n}\n\nexport interface SearchSummaryOptions {\n  /**\n   * The split every estimate in the summary is computed on. A proposer's\n   * context must always pass `'train'`: the selection and test splits stay\n   * unread by anything a proposer's text can reach. The CLI passes the\n   * search's own ranking split, `'selection'` when the search declares one\n   * else `'train'`, matching `searchPolicyView`.\n   */\n  split: SearchSplit\n  /** Nodes shown under \"Leading\" and under \"Recently discarded\". Default 5. */\n  limit?: number\n}\n\n/**\n * `SearchState` as compact text: a header line with the search's shape and\n * spend, the leading nodes against the root with their estimates, the most\n * recently discarded nodes with the measurement that discarded them, and a\n * log of recent proposals (operator and label — the ledger's inline,\n * redacted summary of each rationale; the full rationale is a blob this\n * function never reads, so it stays a pure, I/O-free projection of the\n * state already in hand).\n */\nexport function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string {\n  const header = state.header\n  if (!header) return `search ${state.searchId}: not yet opened`\n  const limit = options.limit ?? 5\n  if (limit < 1 || !Number.isInteger(limit)) {\n    throw new SearchLedgerError(\n      `renderSearchSummary: limit must be a positive integer, got ${limit}`,\n    )\n  }\n  const split = options.split\n  const direction = header.objective.direction\n  const root = state.rootNodeId\n  const lines: string[] = [headerLine(state), spendLine(state), statusLine(state)]\n\n  if (root === null) {\n    lines.push('', 'No nodes yet.')\n    return lines.join('\\n')\n  }\n\n  const others = state.nodes().filter((node) => node.nodeId !== root)\n  const estimated = others\n    .filter((node) => node.status !== 'invalid')\n    .map((node) => ({ node, estimate: estimateNode(state, node.nodeId, { against: root, split }) }))\n\n  const leading = estimated\n    .filter(({ estimate }) => estimate.delta !== null)\n    .sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction))\n    .slice(0, limit)\n  lines.push('', `Leading nodes (vs root, ${split} split):`)\n  if (leading.length === 0) lines.push('  none measured yet')\n  for (const { node, estimate } of leading)\n    lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`)\n\n  const discarded = others\n    .filter(\n      (node) => node.status === 'pruned' || node.status === 'rejected' || node.status === 'invalid',\n    )\n    .sort((a, b) => b.updatedSequence - a.updatedSequence)\n    .slice(0, limit)\n  lines.push('', 'Recently discarded:')\n  if (discarded.length === 0) lines.push('  none yet')\n  for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`)\n\n  const recent = [...state.edges()].reverse().slice(0, limit)\n  lines.push('', 'Recent proposals:')\n  if (recent.length === 0) lines.push('  none yet')\n  for (const edge of recent) {\n    const childId = edge.childNodeId\n    const label = edge.label.length > 0 ? edge.label : '(no label)'\n    lines.push(`  ${edge.operator} → ${childId}: ${label}`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction headerLine(state: SearchStateView): string {\n  const header = state.header!\n  return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`\n}\n\nfunction spendLine(state: SearchStateView): string {\n  const { audit } = state\n  const known = audit.spend.knownUsd.toFixed(2)\n  const floor = audit.spend.floorUsd.toFixed(2)\n  const unknown = audit.spend.unknownCostCells\n  const floorPart =\n    unknown > 0\n      ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? '' : 's'}`\n      : ''\n  return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`\n}\n\nfunction statusLine(state: SearchStateView): string {\n  if (!state.closed) return '  status: open'\n  const claim = state.closed.claim\n  const claimText =\n    claim === null\n      ? ''\n      : claim.decision === 'ship'\n        ? ` · claim: ship ${claim.selected}`\n        : ` · claim: ${claim.decision}`\n  return `  status: closed (${state.closed.reason})${claimText}`\n}\n\nfunction nodeLine(node: SearchNode): string {\n  const rung = node.status === 'advanced' ? ` rung ${node.rung}` : ''\n  return `${node.nodeId} (${node.status ?? 'undecided'}${rung})`\n}\n\nfunction discardLine(node: SearchNode): string {\n  const decision = node.decisions.at(-1)\n  if (!decision) return 'no decision recorded'\n  const basis = decision.basis === null ? 'no measured basis' : formatEstimate(decision.basis)\n  return `${basis} — ${decision.rule}: ${decision.reason}`\n}\n\n/** `estimate.delta` in the objective's own units; positive is always better. */\nfunction signed(estimate: NodeEstimate, direction: 'maximize' | 'minimize'): number {\n  if (estimate.delta === null) return Number.NEGATIVE_INFINITY\n  return direction === 'maximize' ? estimate.delta : -estimate.delta\n}\n\n/** The display rules of search-tree-design §6.4: no whisker below 6 shared\n * units, a dashed descriptive interval with its exact sign p from 6 to 19,\n * a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */\nfunction formatEstimate(estimate: NodeEstimate): string {\n  const unit = (n: number) => `${n} unit${n === 1 ? '' : 's'}`\n  if (estimate.method === 'none') return `unknown (${unit(estimate.pairs)})`\n  if (estimate.indeterminate)\n    return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`\n  const delta =\n    estimate.delta === null ? 'null' : (estimate.delta >= 0 ? '+' : '') + estimate.delta.toFixed(4)\n  if (estimate.method === 'insufficient') {\n    return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`\n  }\n  const interval = estimate.interval\n    ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]`\n    : ''\n  if (estimate.method === 'descriptive') {\n    const signP = estimate.exactSignP === null ? 'null' : estimate.exactSignP.toPrecision(3)\n    return `Δ=${delta}${interval} dashed, sign p=${signP} (${unit(estimate.pairs)})`\n  }\n  return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥${BOOTSTRAP_GATE_MIN_N})`\n}\n"],"mappings":"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"}
+{"version":3,"file":"search-summary-DQIvJsSB.js","names":[],"sources":["../src/campaign/search-summary.ts"],"sourcesContent":["/**\n * The agent's view of a search: the same projection a human reads.\n *\n * `renderSearchSummary` turns a `SearchStateView` into compact text — the\n * leading nodes with their estimates, the most recently discarded ideas with\n * why they were discarded, and a log of recent proposals — as AIDE's journal\n * summary does for its own search. `agent-eval search show <ledger>` prints\n * the same text for a terminal; `runOptimization` puts it on every\n * `ProposeContext` a proposer receives.\n *\n * `searchProposerView` is the train-only read `ProposeContext.train` carries.\n * It has no parameter that can select another split, so a proposer built on\n * it cannot reach the selection or test split even by mistake: the sealed\n * splits (§6.6 of the search-tree design) are unreachable by construction,\n * not by convention.\n */\n\nimport { minimumPairsForPairedDeltaTest } from '../paired-delta-test'\nimport { BOOTSTRAP_GATE_MIN_N } from '../statistics'\nimport { estimateNode } from './estimate-node'\nimport { SearchLedgerError } from './search-ledger-errors'\nimport type { NodeEstimate, SearchSplit } from './search-ledger-types'\nimport type { SearchNode, SearchScoredCell, SearchStateView, SearchUnitScore } from './search-state'\n\nconst DESCRIPTIVE_FROM = minimumPairsForPairedDeltaTest(0.95)\n\n/** The proposer's own read of a search: its node's cells on the train split,\n * the only split a proposer may ever see. */\nexport interface SearchProposerView {\n  readonly searchId: string\n  readonly direction: 'maximize' | 'minimize'\n  /** `nodeId`'s scored train cells. Unscored cells (errored, cancelled or in\n   * flight) are absent, never zero. */\n  scoredCells(nodeId: string): readonly SearchScoredCell[]\n  /** Per-unit train-split means of `nodeId`, in unitId order. */\n  unitScores(nodeId: string): readonly SearchUnitScore[]\n}\n\n/** The train-only view `ProposeContext.train` carries. */\nexport function searchProposerView(state: SearchStateView): SearchProposerView {\n  const header = state.header\n  if (!header) throw new SearchLedgerError(`search ${state.searchId} has not been opened`)\n  return {\n    searchId: state.searchId,\n    direction: header.objective.direction,\n    scoredCells: (nodeId) => state.scoredCells(nodeId, 'train'),\n    unitScores: (nodeId) => state.unitScores(nodeId, 'train'),\n  }\n}\n\nexport interface SearchSummaryOptions {\n  /**\n   * The split every estimate in the summary is computed on. A proposer's\n   * context must always pass `'train'`: the selection and test splits stay\n   * unread by anything a proposer's text can reach. The CLI passes the\n   * search's own ranking split, `'selection'` when the search declares one\n   * else `'train'`, matching `searchPolicyView`.\n   */\n  split: SearchSplit\n  /** Nodes shown under \"Leading\" and under \"Recently discarded\". Default 5. */\n  limit?: number\n}\n\n/**\n * `SearchState` as compact text: a header line with the search's shape and\n * spend, the leading nodes against the root with their estimates, the most\n * recently discarded nodes with the measurement that discarded them, and a\n * log of recent proposals (operator and label — the ledger's inline,\n * redacted summary of each rationale; the full rationale is a blob this\n * function never reads, so it stays a pure, I/O-free projection of the\n * state already in hand).\n */\nexport function renderSearchSummary(state: SearchStateView, options: SearchSummaryOptions): string {\n  const header = state.header\n  if (!header) return `search ${state.searchId}: not yet opened`\n  const limit = options.limit ?? 5\n  if (limit < 1 || !Number.isInteger(limit)) {\n    throw new SearchLedgerError(\n      `renderSearchSummary: limit must be a positive integer, got ${limit}`,\n    )\n  }\n  const split = options.split\n  const direction = header.objective.direction\n  const root = state.rootNodeId\n  const lines: string[] = [headerLine(state), spendLine(state), statusLine(state)]\n\n  if (root === null) {\n    lines.push('', 'No nodes yet.')\n    return lines.join('\\n')\n  }\n\n  const others = state.nodes().filter((node) => node.nodeId !== root)\n  const estimated = others\n    .filter((node) => node.status !== 'invalid')\n    .map((node) => ({ node, estimate: estimateNode(state, node.nodeId, { against: root, split }) }))\n\n  const leading = estimated\n    .filter(({ estimate }) => estimate.delta !== null)\n    .sort((a, b) => signed(b.estimate, direction) - signed(a.estimate, direction))\n    .slice(0, limit)\n  lines.push('', `Leading nodes (vs root, ${split} split):`)\n  if (leading.length === 0) lines.push('  none measured yet')\n  for (const { node, estimate } of leading)\n    lines.push(`  ${nodeLine(node)}: ${formatEstimate(estimate)}`)\n\n  const discarded = others\n    .filter(\n      (node) => node.status === 'pruned' || node.status === 'rejected' || node.status === 'invalid',\n    )\n    .sort((a, b) => b.updatedSequence - a.updatedSequence)\n    .slice(0, limit)\n  lines.push('', 'Recently discarded:')\n  if (discarded.length === 0) lines.push('  none yet')\n  for (const node of discarded) lines.push(`  ${nodeLine(node)}: ${discardLine(node)}`)\n\n  const recent = [...state.edges()].reverse().slice(0, limit)\n  lines.push('', 'Recent proposals:')\n  if (recent.length === 0) lines.push('  none yet')\n  for (const edge of recent) {\n    const childId = edge.childNodeId\n    const label = edge.label.length > 0 ? edge.label : '(no label)'\n    lines.push(`  ${edge.operator} → ${childId}: ${label}`)\n  }\n\n  return lines.join('\\n')\n}\n\nfunction headerLine(state: SearchStateView): string {\n  const header = state.header!\n  return `search ${state.searchId} — ${header.subject} — ${header.objective.direction} ${header.objective.metric}`\n}\n\nfunction spendLine(state: SearchStateView): string {\n  const { audit } = state\n  const known = audit.spend.knownUsd.toFixed(2)\n  const floor = audit.spend.floorUsd.toFixed(2)\n  const unknown = audit.spend.unknownCostCells\n  const floorPart =\n    unknown > 0\n      ? ` + floor $${floor} across ${unknown} unknown-cost cell${unknown === 1 ? '' : 's'}`\n      : ''\n  return `  ${audit.nodes} nodes · ${audit.cells.settled} settled cells (${audit.cells.open} open) · $${known} known${floorPart}`\n}\n\nfunction statusLine(state: SearchStateView): string {\n  if (!state.closed) return '  status: open'\n  const claim = state.closed.claim\n  const claimText =\n    claim === null\n      ? ''\n      : claim.decision === 'ship'\n        ? ` · claim: ship ${claim.selected}`\n        : ` · claim: ${claim.decision}`\n  return `  status: closed (${state.closed.reason})${claimText}`\n}\n\nfunction nodeLine(node: SearchNode): string {\n  const rung = node.status === 'advanced' ? ` rung ${node.rung}` : ''\n  return `${node.nodeId} (${node.status ?? 'undecided'}${rung})`\n}\n\nfunction discardLine(node: SearchNode): string {\n  const decision = node.decisions.at(-1)\n  if (!decision) return 'no decision recorded'\n  const basis = decision.basis === null ? 'no measured basis' : formatEstimate(decision.basis)\n  return `${basis} — ${decision.rule}: ${decision.reason}`\n}\n\n/** `estimate.delta` in the objective's own units; positive is always better. */\nfunction signed(estimate: NodeEstimate, direction: 'maximize' | 'minimize'): number {\n  if (estimate.delta === null) return Number.NEGATIVE_INFINITY\n  return direction === 'maximize' ? estimate.delta : -estimate.delta\n}\n\n/** The display rules of search-tree-design §6.4: no whisker below 6 shared\n * units, a dashed descriptive interval with its exact sign p from 6 to 19,\n * a decision-grade whisker from `BOOTSTRAP_GATE_MIN_N`. */\nfunction formatEstimate(estimate: NodeEstimate): string {\n  const unit = (n: number) => `${n} unit${n === 1 ? '' : 's'}`\n  if (estimate.method === 'none') return `unknown (${unit(estimate.pairs)})`\n  if (estimate.indeterminate)\n    return `no measurable difference (indeterminate, ${unit(estimate.pairs)})`\n  const delta =\n    estimate.delta === null ? 'null' : (estimate.delta >= 0 ? '+' : '') + estimate.delta.toFixed(4)\n  if (estimate.method === 'insufficient') {\n    return `Δ=${delta} (${estimate.pairs} of ${DESCRIPTIVE_FROM} units, insufficient)`\n  }\n  const interval = estimate.interval\n    ? ` [${estimate.interval[0].toFixed(4)}, ${estimate.interval[1].toFixed(4)}]`\n    : ''\n  if (estimate.method === 'descriptive') {\n    const signP = estimate.exactSignP === null ? 'null' : estimate.exactSignP.toPrecision(3)\n    return `Δ=${delta}${interval} dashed, sign p=${signP} (${unit(estimate.pairs)})`\n  }\n  return `Δ=${delta}${interval} (${unit(estimate.pairs)}, ≥${BOOTSTRAP_GATE_MIN_N})`\n}\n"],"mappings":"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"}

package/dist/{sequential-CzK5DarL.js → sequential-BVv1sjsw.js}

@@ -68,36 +68,6 @@ function pairedEvalueSequence(deltas, opts = {}) {
 		clipped
 	};
 }
-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;
-	const initialBetShrinkage = opts.initialBetShrinkage ?? .5;
-	const maxPairs = opts.maxPairs ?? 1e4;
-	assertSequentialScalarConfiguration(bound, alpha, initialBetShrinkage, "sequentialCrossingHorizon");
-	if (!Number.isSafeInteger(maxPairs) || maxPairs < 1) throw new Error("sequentialCrossingHorizon: maxPairs must be a positive safe integer");
-	if (maxPairs > MAX_SEQUENTIAL_CROSSING_PAIRS) throw new Error(`sequentialCrossingHorizon: maxPairs must be <= ${MAX_SEQUENTIAL_CROSSING_PAIRS}`);
-	const sequence = pairedEvalueSequence(Array(maxPairs).fill(bound), {
-		bound,
-		alpha,
-		initialBetShrinkage
-	});
-	const { evidenceThreshold, decisionThreshold } = sequentialThresholds(alpha);
-	const evidencePairs = sequence.steps.find((step) => step.evalue >= evidenceThreshold)?.t ?? null;
-	return Object.freeze({
-		evidencePairs,
-		decisionPairs: sequence.decisionFiredAt,
-		evidenceThreshold,
-		decisionThreshold,
-		maxPairs
-	});
-}
 /**
 * Run interim sequential analyses across many candidates at once,
 * preserving the time-uniform α guarantee for each candidate's series and
@@ -185,6 +155,6 @@ function empiricalBernsteinCs(sum, sumSq, n, bound, alpha) {
 	};
 }
 //#endregion
-export { pairedEvalueSequence as n, sequentialCrossingHorizon as r, evaluateInterimReleaseConfidence as t };
+export { pairedEvalueSequence as n, evaluateInterimReleaseConfidence as t };
 
-//# sourceMappingURL=sequential-CzK5DarL.js.map
+//# sourceMappingURL=sequential-BVv1sjsw.js.map

package/dist/{sequential-CzK5DarL.js.map → sequential-BVv1sjsw.js.map}

@@ -1 +1 @@
-{"version":3,"file":"sequential-CzK5DarL.js","names":[],"sources":["../src/sequential.ts"],"sourcesContent":["/**\n * Always-valid sequential evaluation.\n *\n * `researchReport` assumes a single pre-specified analysis. Real\n * consumers run campaigns weekly / nightly / per-PR; each new run silently\n * inflates the false-discovery rate, because the BH-FDR guarantee is for\n * the *first* look, not the 47th. Without time-uniform inference,\n * launch-decision teams either (a) don't peek, which forfeits the cost\n * advantage of stop-when-decisive, or (b) peek and pretend they didn't,\n * which forfeits scientific validity.\n *\n * This module ships **e-value-based confidence sequences** for paired\n * bounded outcomes. The methodology is the predictable plug-in betting\n * martingale of Waudby-Smith & Ramdas (2024) — provably valid at *any*\n * stopping time. Concretely:\n *\n *   For paired deltas D_1, D_2, … ∈ [-c, c] with the null H_0: E[D] ≤ 0,\n *   a betting fraction λ_i is chosen using only D_{1..i-1} (predictable\n *   plug-in), and the running e-value is\n *\n *     E_t = ∏_{i=1}^{t} (1 + λ_i · D_i)\n *\n *   E_t is a non-negative martingale under H_0 with E[E_t] ≤ 1, so by\n *   Ville's inequality, P(∃ t : E_t ≥ 1/α) ≤ α — we can reject the null\n *   at any time without inflating the type-I error.\n *\n * Combined with `runEvalCampaign`, every consumer running rolling\n * campaigns gains the ability to ship the moment evidence is decisive,\n * stop-early on dead-on-arrival variants, and accumulate evidence across\n * partial runs without spending the FDR budget. No new sweep is wasted.\n *\n * References:\n *   - Howard, S. R., Ramdas, A., McAuliffe, J., Sekhon, J. (2021).\n *     Time-uniform, nonparametric, nonasymptotic confidence sequences.\n *     Annals of Statistics, 49(2), 1055–1080.\n *   - Waudby-Smith, I., Ramdas, A. (2024). Estimating means of bounded\n *     random variables by betting. JRSS B, 86(1), 1–27.\n */\n\nexport type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent'\n\nexport interface PairedEvalueOptions {\n  /**\n   * Bound on |delta|. Default 1 (matching most score scales). Must satisfy\n   * c > 0; deltas outside [-c, c] are clipped with a warning attached to\n   * the return value.\n   */\n  bound?: number\n  /** Target Type-I error. Default 0.05. */\n  alpha?: number\n  /**\n   * Region of Practical Equivalence on the *mean* paired delta. When\n   * supplied, the verdict can return `'equivalent'` once the running\n   * confidence sequence on the mean is fully contained in [low, high].\n   */\n  rope?: { low: number; high: number }\n  /** Initial bet shrinkage (0 < scale ≤ 1). Default 0.5 — empirically robust. */\n  initialBetShrinkage?: number\n}\n\nexport interface PairedEvalueStep {\n  /** 1-indexed observation count. */\n  t: number\n  delta: number\n  /** Running e-value E_t = ∏ (1 + λ_i · D_i). */\n  evalue: number\n  /** Time-uniform p-value at stopping time t. */\n  pValue: number\n  /** Lower bound of the empirical Bernstein confidence sequence at level 1-α. */\n  csLow: number\n  csHigh: number\n  /** Verdict at this stopping time. */\n  decision: SequentialDecision\n}\n\nexport interface PairedEvalueSequence {\n  steps: PairedEvalueStep[]\n  /** The decision at the final step. */\n  finalDecision: SequentialDecision\n  /** Index (1-based) at which a non-`continue` decision first fired, or null. */\n  decisionFiredAt: number | null\n  /** True if any deltas were clipped to [-bound, bound]. */\n  clipped: boolean\n}\n\n/**\n * Run the paired e-value sequence over an in-order delta stream.\n *\n * Use for *streaming* / interim analyses: pass the deltas you have so\n * far, get the verdict at every prefix length. The decision is\n * monotone-stable in the sense that once `'reject_now'` or `'promote_now'`\n * fires, the verdict at later steps remains decisive (the e-value is a\n * non-negative martingale; once it crosses the threshold, it's crossed).\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  // Running statistics (using only D_{1..i-1} for the bet → predictable plug-in).\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    // Predictable plug-in bet (positive λ tests for E[D] > 0; we run a two-sided\n    // test by tracking the symmetric e-value via |bet|).\n    // λ_i ∝ mean / (variance + bound^2). Shrink early to avoid overbetting.\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) // anneal toward 1\n    let lambda = (muHat / (varHat + c * c)) * shrink\n    // Clip to ensure 1 + λ·D > 0 for all |D| ≤ c (so the e-value stays non-negative).\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    // Empirical Bernstein confidence sequence on the mean. Howard et al.\n    // (2021), Theorem 4.4 with σ̂² the running sample variance and a\n    // calibration constant tuned for two-sided coverage at level 1 - α.\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\n/** Configuration for the best-case reachability preflight. */\nexport interface SequentialCrossingHorizonOptions\n  extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {\n  /** Maximum pairs to simulate before returning `null`. Default 10,000. */\n  maxPairs?: number\n}\n\n/**\n * Best-case horizons under the exact betting policy used by\n * {@link pairedEvalueSequence}.\n *\n * `evidencePairs` is the first all-at-bound pair count whose e-value reaches\n * `1/alpha`. `decisionPairs` is the first count whose actual two-sided\n * sequence verdict fires (`2/alpha` in the current policy). A design whose\n * pair cap is below either relevant horizon is undecidable by construction and\n * should be refused before model spend.\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\n/**\n * Compute the minimum pair count at which even perfect, all-at-bound data can\n * reach the evidence and decision thresholds. The calculation intentionally\n * calls the canonical sequence implementation rather than maintaining a\n * second approximation that can drift from its bet schedule.\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  /**\n   * One delta series per candidate (paired deltas vs comparator). Order\n   * within a series is the order the campaigns were run.\n   */\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  /**\n   * Campaign-level recommendation: pick the strongest 'promote_now', else\n   * 'continue' if any candidate is still live, else 'reject_now' if every\n   * candidate is dead, else 'equivalent'.\n   */\n  recommendation: { decision: SequentialDecision; candidateId: string | null }\n}\n\n/**\n * Run interim sequential analyses across many candidates at once,\n * preserving the time-uniform α guarantee for each candidate's series and\n * synthesising a campaign-level recommendation. Designed to be called on\n * every campaign tick — the recommendation is anytime-valid.\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\n// ── Internals ────────────────────────────────────────────────────────────\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\n/**\n * Empirical Bernstein confidence sequence on the mean of bounded variables.\n * Adapted from Howard et al. (2021) §4.4. Provides a time-uniform CI on\n * the running mean; valid at every stopping time.\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  // Iterated-log calibration constant. The 1.7 exponent matches the\n  // recommended choice in Howard et al. for two-sided coverage at level\n  // 1 - α with mild log-corrections; tightening further requires a\n  // tuned mixture and is out of scope.\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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"}
+{"version":3,"file":"sequential-BVv1sjsw.js","names":[],"sources":["../src/sequential.ts"],"sourcesContent":["/**\n * Always-valid sequential evaluation.\n *\n * `researchReport` assumes a single pre-specified analysis. Real\n * consumers run campaigns weekly / nightly / per-PR; each new run silently\n * inflates the false-discovery rate, because the BH-FDR guarantee is for\n * the *first* look, not the 47th. Without time-uniform inference,\n * launch-decision teams either (a) don't peek, which forfeits the cost\n * advantage of stop-when-decisive, or (b) peek and pretend they didn't,\n * which forfeits scientific validity.\n *\n * This module ships **e-value-based confidence sequences** for paired\n * bounded outcomes. The methodology is the predictable plug-in betting\n * martingale of Waudby-Smith & Ramdas (2024) — provably valid at *any*\n * stopping time. Concretely:\n *\n *   For paired deltas D_1, D_2, … ∈ [-c, c] with the null H_0: E[D] ≤ 0,\n *   a betting fraction λ_i is chosen using only D_{1..i-1} (predictable\n *   plug-in), and the running e-value is\n *\n *     E_t = ∏_{i=1}^{t} (1 + λ_i · D_i)\n *\n *   E_t is a non-negative martingale under H_0 with E[E_t] ≤ 1, so by\n *   Ville's inequality, P(∃ t : E_t ≥ 1/α) ≤ α — we can reject the null\n *   at any time without inflating the type-I error.\n *\n * Combined with `runEvalCampaign`, every consumer running rolling\n * campaigns gains the ability to ship the moment evidence is decisive,\n * stop-early on dead-on-arrival variants, and accumulate evidence across\n * partial runs without spending the FDR budget. No new sweep is wasted.\n *\n * References:\n *   - Howard, S. R., Ramdas, A., McAuliffe, J., Sekhon, J. (2021).\n *     Time-uniform, nonparametric, nonasymptotic confidence sequences.\n *     Annals of Statistics, 49(2), 1055–1080.\n *   - Waudby-Smith, I., Ramdas, A. (2024). Estimating means of bounded\n *     random variables by betting. JRSS B, 86(1), 1–27.\n */\n\nexport type SequentialDecision = 'promote_now' | 'continue' | 'reject_now' | 'equivalent'\n\nexport interface PairedEvalueOptions {\n  /**\n   * Bound on |delta|. Default 1 (matching most score scales). Must satisfy\n   * c > 0; deltas outside [-c, c] are clipped with a warning attached to\n   * the return value.\n   */\n  bound?: number\n  /** Target Type-I error. Default 0.05. */\n  alpha?: number\n  /**\n   * Region of Practical Equivalence on the *mean* paired delta. When\n   * supplied, the verdict can return `'equivalent'` once the running\n   * confidence sequence on the mean is fully contained in [low, high].\n   */\n  rope?: { low: number; high: number }\n  /** Initial bet shrinkage (0 < scale ≤ 1). Default 0.5 — empirically robust. */\n  initialBetShrinkage?: number\n}\n\nexport interface PairedEvalueStep {\n  /** 1-indexed observation count. */\n  t: number\n  delta: number\n  /** Running e-value E_t = ∏ (1 + λ_i · D_i). */\n  evalue: number\n  /** Time-uniform p-value at stopping time t. */\n  pValue: number\n  /** Lower bound of the empirical Bernstein confidence sequence at level 1-α. */\n  csLow: number\n  csHigh: number\n  /** Verdict at this stopping time. */\n  decision: SequentialDecision\n}\n\nexport interface PairedEvalueSequence {\n  steps: PairedEvalueStep[]\n  /** The decision at the final step. */\n  finalDecision: SequentialDecision\n  /** Index (1-based) at which a non-`continue` decision first fired, or null. */\n  decisionFiredAt: number | null\n  /** True if any deltas were clipped to [-bound, bound]. */\n  clipped: boolean\n}\n\n/**\n * Run the paired e-value sequence over an in-order delta stream.\n *\n * Use for *streaming* / interim analyses: pass the deltas you have so\n * far, get the verdict at every prefix length. The decision is\n * monotone-stable in the sense that once `'reject_now'` or `'promote_now'`\n * fires, the verdict at later steps remains decisive (the e-value is a\n * non-negative martingale; once it crosses the threshold, it's crossed).\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  // Running statistics (using only D_{1..i-1} for the bet → predictable plug-in).\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    // Predictable plug-in bet (positive λ tests for E[D] > 0; we run a two-sided\n    // test by tracking the symmetric e-value via |bet|).\n    // λ_i ∝ mean / (variance + bound^2). Shrink early to avoid overbetting.\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) // anneal toward 1\n    let lambda = (muHat / (varHat + c * c)) * shrink\n    // Clip to ensure 1 + λ·D > 0 for all |D| ≤ c (so the e-value stays non-negative).\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    // Empirical Bernstein confidence sequence on the mean. Howard et al.\n    // (2021), Theorem 4.4 with σ̂² the running sample variance and a\n    // calibration constant tuned for two-sided coverage at level 1 - α.\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\n/** Configuration for the best-case reachability preflight. */\nexport interface SequentialCrossingHorizonOptions\n  extends Pick<PairedEvalueOptions, 'alpha' | 'bound' | 'initialBetShrinkage'> {\n  /** Maximum pairs to simulate before returning `null`. Default 10,000. */\n  maxPairs?: number\n}\n\n/**\n * Best-case horizons under the exact betting policy used by\n * {@link pairedEvalueSequence}.\n *\n * `evidencePairs` is the first all-at-bound pair count whose e-value reaches\n * `1/alpha`. `decisionPairs` is the first count whose actual two-sided\n * sequence verdict fires (`2/alpha` in the current policy). A design whose\n * pair cap is below either relevant horizon is undecidable by construction and\n * should be refused before model spend.\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\n/**\n * Compute the minimum pair count at which even perfect, all-at-bound data can\n * reach the evidence and decision thresholds. The calculation intentionally\n * calls the canonical sequence implementation rather than maintaining a\n * second approximation that can drift from its bet schedule.\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  /**\n   * One delta series per candidate (paired deltas vs comparator). Order\n   * within a series is the order the campaigns were run.\n   */\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  /**\n   * Campaign-level recommendation: pick the strongest 'promote_now', else\n   * 'continue' if any candidate is still live, else 'reject_now' if every\n   * candidate is dead, else 'equivalent'.\n   */\n  recommendation: { decision: SequentialDecision; candidateId: string | null }\n}\n\n/**\n * Run interim sequential analyses across many candidates at once,\n * preserving the time-uniform α guarantee for each candidate's series and\n * synthesising a campaign-level recommendation. Designed to be called on\n * every campaign tick — the recommendation is anytime-valid.\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\n// ── Internals ────────────────────────────────────────────────────────────\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\n/**\n * Empirical Bernstein confidence sequence on the mean of bounded variables.\n * Adapted from Howard et al. (2021) §4.4. Provides a time-uniform CI on\n * the running mean; valid at every stopping time.\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  // Iterated-log calibration constant. The 1.7 exponent matches the\n  // recommended choice in Howard et al. for two-sided coverage at level\n  // 1 - α with mild log-corrections; tightening further requires a\n  // tuned mixture and is out of scope.\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/{sequential-D-1PPCmM.js → sequential-CimQrbjv.js}

@@ -1,7 +1,7 @@
-import { m as manifestContentDigest } from "./agent-profile-cell-BYc0bxsL.js";
-import { t as mulberry32 } from "./random-Dn5fPWkt.js";
-import { t as eProcess } from "./sequential-eprocess-D1jKoihe.js";
-import { n as aggregatePairedHoldout, o as pairHoldout } from "./statistical-heldout-1Gbmex7v.js";
+import { u as manifestContentDigest } from "./agent-profile-cell-B1V1gUZs.js";
+import { t as mulberry32 } from "./random-DDDcC7YU.js";
+import { t as eProcess } from "./sequential-eprocess-DodI6RoF.js";
+import { n as aggregatePairedHoldout, o as pairHoldout } from "./statistical-heldout-Bksv92Th.js";
 //#region src/campaign/gates/sequential.ts
 /**
 * Anytime-valid sequential promotion gate — an e-process (betting
@@ -338,4 +338,4 @@ function sequentialDecide(options = {}) {
 //#endregion
 export { sequentialPairedGate as n, sequentialDecide as t };
 
-//# sourceMappingURL=sequential-D-1PPCmM.js.map
+//# sourceMappingURL=sequential-CimQrbjv.js.map

package/dist/sequential-CimQrbjv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential-CimQrbjv.js","names":[],"sources":["../src/campaign/gates/sequential.ts"],"sourcesContent":["/**\n * Anytime-valid sequential promotion gate — an e-process (betting\n * test-martingale, see `eProcess` in `statistics.ts`) over paired\n * per-scenario deltas, so a campaign stops the MOMENT evidence decides\n * instead of burning a fixed-n budget. Decisions remain valid at any\n * data-dependent stopping time (Ville's inequality), which is exactly what\n * fixed-n machinery cannot offer: peeking at a bootstrap CI after every\n * observation and stopping on the first significant peek inflates type-I\n * error far beyond alpha.\n *\n * REPLACES, never layers on, a fixed-n gate. Running `heldoutSignificance`\n * or `paretoSignificanceGate` repeatedly on a growing sample and stopping\n * early is optional stopping no matter how it is dressed up; this gate is\n * the valid way to stop early. Use one or the other per evidence stream.\n *\n * Pre-registration binding: anytime validity holds only for the\n * PRE-REGISTERED statistic. When a `SignedManifest` is bound, the gate takes\n * alpha from `manifest.alpha`, the observation budget from\n * `manifest.preRegisteredN`, orients deltas by `manifest.direction`, and\n * shifts the null boundary by `manifest.minEffect` — re-deciding the same\n * stream under different parameters after seeing data would reopen optional\n * stopping under a fancier name. The manifest's content hash is verified at\n * construction with the canonical RFC 8785 digest used by signManifest.\n *\n * The supermartingale guarantee requires E[delta_t | past] ≤ the null\n * boundary under H0. Independent sampling with that mean bound suffices.\n * Exchangeability or shuffling alone does not: one fair sign repeated many\n * times is exchangeable and has marginal mean zero, but its conditional mean\n * becomes the revealed sign. A seeded shuffle cannot remove that dependence.\n * `decide(ctx)` pairs cells, then averages repetitions within each scenario\n * before testing. Pass independentUnitByScenarioId for scenarios sharing a\n * latent source or incident. Units must still satisfy the conditional-mean null.\n * Direct `observe()` callers own this sampling and aggregation contract.\n */\n\nimport { manifestContentDigest, type SignedManifest } from '../../pre-registration'\nimport { type EProcessState, eProcess, mulberry32 } from '../../statistics'\nimport type { Gate, GateContext, GateResult, GenerationRecord, Scenario } from '../types'\nimport { aggregatePairedHoldout, pairHoldout } from './statistical-heldout'\n\nexport type SequentialGateDecision = 'promote' | 'continue' | 'undecided-at-maxN'\n\nexport interface SequentialObservation {\n  decision: SequentialGateDecision\n  /** Current e-value (the betting wealth) against H0. */\n  eValue: number\n  /** Paired deltas consumed so far. */\n  n: number\n  /** Names the decision basis. For 'undecided-at-maxN' it states explicitly\n   *  that exhausting the budget is NOT evidence of no effect. */\n  reason: string\n}\n\nexport interface SequentialPairedGateOptions {\n  /** Type-I budget. With `preRegistration` bound this MUST match\n   *  `manifest.alpha` (conflict throws). Default 0.05. */\n  alpha?: number\n  /** Minimum independent paired units before a promote may fire. The stopping rule is\n   *  \"first n ≥ minN with e-value ≥ 1/alpha\" — still a valid stopping time.\n   *  Default 5. */\n  minN?: number\n  /** Pre-registered independent-unit budget (scenarios by default in decide()). Required unless `preRegistration`\n   *  supplies it via `preRegisteredN` (conflict throws). */\n  maxN?: number\n  /** Bet truncation forwarded to `eProcess`. Default 0.5. */\n  maxBet?: number\n  /** Bound on |delta| in the judge's native scale; deltas are mapped to\n   *  x = (d/scale + 1)/2 ∈ [0,1]. A delta outside ±scale throws (use\n   *  `detectScale` to pick 1 vs 100 BEFORE streaming). Default 1. */\n  scale?: number\n  /** Seed for reproducible ordering of scenario deltas in decide().\n   *  Shuffling does not establish the conditional-mean null. Default 1337. */\n  shuffleSeed?: number\n  /** Independent unit for every scenario passed to decide(). Full cell pairs\n   *  are averaged within each unit before testing. Defaults to scenario IDs.\n   *  The mapping is copied at construction. Direct observe() is unchanged. */\n  independentUnitByScenarioId?: ReadonlyMap<string, string>\n  /** Bind the pre-registered hypothesis. Verified (content hash) at\n   *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */\n  preRegistration?: SignedManifest\n  /** Override the gate name in reports. */\n  name?: string\n  /** Continue the observe-stream from a `state()` snapshot taken before a\n   *  restart. The gate's parameters still resolve from this options object\n   *  (and the manifest); the snapshot must have been recorded under the same\n   *  alpha, maxBet, and null boundary, and its decision must be one this\n   *  configuration could have reached at its n, or construction throws.\n   *  `decide(ctx)` is unaffected — it always runs on a fresh stream. */\n  resume?: SequentialStreamState\n}\n\n/** Snapshot of one observe-stream: the e-process state plus the gate's own\n *  decision, which applies `minN` and `maxN` on top of the core latch. A\n *  gate rebuilt with `resume` from this value continues exactly where the\n *  snapshot was taken. */\nexport type SequentialStreamState = EProcessState & { decision: SequentialGateDecision }\n\nexport interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>\n  extends Gate<TArtifact, TScenario> {\n  /** Streaming entry point: feed one paired independent-unit delta\n   *  (candidate − baseline, native scale). Aggregate correlated repetitions\n   *  before calling; the caller must justify E[delta_t | past] under H0.\n   *  Each gate instance carries ONE\n   *  observe-stream; `decide(ctx)` runs on its own fresh stream and never\n   *  consumes or advances this one. 'promote' is sticky; observing past the\n   *  pre-registered maxN throws (extending a finished stream after seeing\n   *  the result reopens optional stopping — start a NEW pre-registered\n   *  test). */\n  observe(delta: number): SequentialObservation\n  /** Read-only snapshot of the observe-stream. Pass it back as\n   *  `resume` to continue the stream after a restart. */\n  state(): SequentialStreamState\n}\n\ninterface ResolvedConfig {\n  alpha: number\n  minN: number\n  maxN: number\n  maxBet: number\n  scale: number\n  shuffleSeed: number\n  /** 'decrease' negates deltas so \"better\" is always positive. */\n  direction: 'increase' | 'decrease'\n  /** H0 boundary in x-space: 1/2 + minEffect/(2·scale). */\n  nullMean: number\n  minEffect: number\n}\n\n/** Sync twin of `verifyManifest`, so gate construction stays synchronous and\n *  fails loud before any observation is consumed. The digest scheme belongs to\n *  `pre-registration`; this gate only compares. */\nfunction verifyManifestSync(m: SignedManifest): boolean {\n  return manifestContentDigest(m) === m.contentHash\n}\n\nfunction resolveConfig(opts: SequentialPairedGateOptions): ResolvedConfig {\n  const m = opts.preRegistration\n  let alpha: number\n  let maxN: number\n  let direction: 'increase' | 'decrease'\n  let minEffect: number\n  if (m) {\n    if (!verifyManifestSync(m)) {\n      throw new Error(\n        `sequentialPairedGate: pre-registration manifest '${m.id}' content hash mismatch (tampered)`,\n      )\n    }\n    if (opts.alpha !== undefined && opts.alpha !== m.alpha) {\n      throw new Error(\n        `sequentialPairedGate: alpha ${opts.alpha} conflicts with pre-registered alpha ${m.alpha} — ` +\n          `the registered statistic is the only one anytime validity covers`,\n      )\n    }\n    if (opts.maxN !== undefined && opts.maxN !== m.preRegisteredN) {\n      throw new Error(\n        `sequentialPairedGate: maxN ${opts.maxN} conflicts with pre-registered N ${m.preRegisteredN}`,\n      )\n    }\n    alpha = m.alpha\n    maxN = m.preRegisteredN\n    direction = m.direction\n    minEffect = m.minEffect\n  } else {\n    alpha = opts.alpha ?? 0.05\n    if (opts.maxN === undefined) {\n      throw new Error(\n        'sequentialPairedGate: maxN is required (or bind a preRegistration manifest whose ' +\n          'preRegisteredN is the budget) — an unbounded stream has no pre-registered budget',\n      )\n    }\n    maxN = opts.maxN\n    direction = 'increase'\n    minEffect = 0\n  }\n  const scale = opts.scale ?? 1\n  if (!Number.isFinite(scale) || scale <= 0) {\n    throw new Error(`sequentialPairedGate: scale must be > 0, got ${scale}`)\n  }\n  if (!Number.isInteger(maxN) || maxN < 1) {\n    throw new Error(`sequentialPairedGate: maxN must be a positive integer, got ${maxN}`)\n  }\n  const minN = opts.minN ?? 5\n  if (!Number.isInteger(minN) || minN < 1 || minN > maxN) {\n    throw new Error(\n      `sequentialPairedGate: minN must be an integer in [1, maxN=${maxN}], got ${minN}`,\n    )\n  }\n  if (!Number.isFinite(minEffect) || minEffect < 0 || minEffect >= scale) {\n    throw new Error(\n      `sequentialPairedGate: minEffect must be in [0, scale=${scale}), got ${minEffect}`,\n    )\n  }\n  // H0: mean delta ≤ minEffect. In x = (d/scale + 1)/2 space that is\n  // E[x] ≤ 1/2 + minEffect/(2·scale) — a shifted null boundary, NOT a clamp\n  // of the observations (clamping is mean-distorting for skewed deltas).\n  const nullMean = 0.5 + minEffect / (2 * scale)\n  return {\n    alpha,\n    minN,\n    maxN,\n    maxBet: opts.maxBet ?? 0.5,\n    scale,\n    shuffleSeed: opts.shuffleSeed ?? 1337,\n    direction,\n    nullMean,\n    minEffect,\n  }\n}\n\ninterface SequentialStream {\n  observe(delta: number): SequentialObservation\n  state(): SequentialStreamState\n}\n\nconst SEQUENTIAL_DECISIONS: readonly SequentialGateDecision[] = [\n  'promote',\n  'continue',\n  'undecided-at-maxN',\n]\n\n/** Refuse a snapshot whose gate decision this configuration could not have\n *  reached at the snapshot's n. The e-process parameters are checked by\n *  `eProcess` itself; this covers the gate's own stopping rule. */\nfunction assertResumableStream(resume: SequentialStreamState, cfg: ResolvedConfig): void {\n  const fail = (detail: string): never => {\n    throw new Error(`sequentialPairedGate: cannot resume — ${detail}`)\n  }\n  if (!SEQUENTIAL_DECISIONS.includes(resume.decision)) {\n    fail(`unknown decision '${String(resume.decision)}'`)\n  }\n  if (resume.n > cfg.maxN) {\n    fail(`snapshot n=${resume.n} exceeds the pre-registered maxN=${cfg.maxN}`)\n  }\n  const threshold = 1 / cfg.alpha\n  switch (resume.decision) {\n    case 'promote':\n      if (resume.n < cfg.minN) {\n        fail(`decision 'promote' at n=${resume.n} is below minN=${cfg.minN}`)\n      }\n      break\n    case 'undecided-at-maxN':\n      if (resume.n !== cfg.maxN) {\n        fail(`decision 'undecided-at-maxN' at n=${resume.n} does not match maxN=${cfg.maxN}`)\n      }\n      break\n    case 'continue':\n      if (resume.n >= cfg.maxN) {\n        fail(`decision 'continue' at n=${resume.n} with maxN=${cfg.maxN}; the stream is finished`)\n      }\n      if (resume.n >= cfg.minN && resume.wealth >= threshold) {\n        fail(\n          `decision 'continue' at n=${resume.n} ≥ minN=${cfg.minN} with e-value ` +\n            `${resume.wealth} ≥ 1/α=${threshold}; this stream would have promoted`,\n        )\n      }\n      break\n  }\n}\n\nfunction makeStream(cfg: ResolvedConfig, resume?: SequentialStreamState): SequentialStream {\n  if (resume !== undefined) assertResumableStream(resume, cfg)\n  const proc = eProcess({\n    alpha: cfg.alpha,\n    maxBet: cfg.maxBet,\n    nullMean: cfg.nullMean,\n    ...(resume === undefined ? {} : { resume }),\n  })\n  const threshold = 1 / cfg.alpha\n  let terminal: SequentialGateDecision | undefined =\n    resume === undefined || resume.decision === 'continue' ? undefined : resume.decision\n  return {\n    observe(delta: number): SequentialObservation {\n      if (terminal === 'undecided-at-maxN') {\n        throw new Error(\n          `sequentialPairedGate: pre-registered maxN=${cfg.maxN} exhausted — extending the ` +\n            'stream after seeing the result reopens optional stopping; start a NEW ' +\n            'pre-registered test',\n        )\n      }\n      if (!Number.isFinite(delta) || Math.abs(delta) > cfg.scale) {\n        throw new Error(\n          `sequentialPairedGate: delta ${delta} outside ±scale=${cfg.scale} — pass the judge's ` +\n            `native scale explicitly (detectScale helps pick 1 vs 100)`,\n        )\n      }\n      const d = cfg.direction === 'decrease' ? -delta : delta\n      const step = proc.update((d / cfg.scale + 1) / 2)\n      // Stopping rule: FIRST n ≥ minN with current wealth ≥ 1/alpha — a valid\n      // stopping time (measurable w.r.t. the past), sticky once latched. The\n      // core's own `decided` latch ignores minN, so the gate re-derives the\n      // decision from current wealth here.\n      if (terminal === undefined && step.n >= cfg.minN && step.wealth >= threshold) {\n        terminal = 'promote'\n      }\n      if (terminal === 'promote') {\n        return {\n          decision: 'promote',\n          eValue: step.wealth,\n          n: step.n,\n          reason:\n            `e-value ${step.wealth.toFixed(2)} ≥ 1/α=${threshold.toFixed(2)} at n=${step.n} ` +\n            `(minN=${cfg.minN}): the paired improvement exceeds ${cfg.minEffect} at anytime-valid ` +\n            `level α=${cfg.alpha}`,\n        }\n      }\n      if (step.n >= cfg.maxN) {\n        terminal = 'undecided-at-maxN'\n        return {\n          decision: 'undecided-at-maxN',\n          eValue: step.wealth,\n          n: step.n,\n          reason:\n            `undecided at pre-registered maxN=${cfg.maxN} (e-value ${step.wealth.toFixed(2)} < ` +\n            `1/α=${threshold.toFixed(2)}). This is NOT evidence of no effect — the effect may be ` +\n            'real but smaller than this budget can detect; re-register with a larger N to test that',\n        }\n      }\n      return {\n        decision: 'continue',\n        eValue: step.wealth,\n        n: step.n,\n        reason: `e-value ${step.wealth.toFixed(2)} < 1/α=${threshold.toFixed(2)} at n=${step.n}/${cfg.maxN} — keep observing`,\n      }\n    },\n    state() {\n      return { ...proc.state(), decision: terminal ?? 'continue' }\n    },\n  }\n}\n\n/** Data-independent in-place Fisher–Yates with a seeded PRNG — the permutation\n *  depends only on the seed, never the values, so bet predictability survives. */\nfunction seededShuffle<T>(items: T[], seed: number): T[] {\n  const rng = mulberry32(seed)\n  for (let i = items.length - 1; i > 0; i--) {\n    const j = Math.floor(rng() * (i + 1))\n    const tmp = items[i]!\n    items[i] = items[j]!\n    items[j] = tmp\n  }\n  return items\n}\n\n/**\n * Anytime-valid sequential paired gate. Conforms to the existing `Gate`\n * contract: decide(ctx) pairs candidate and baseline by full cellId, then\n * averages deltas within each configured unit (scenario by default). The\n * e-process consumes one observation per unit, with equal unit weights.\n * The streaming observe(delta) entry consumes caller-aggregated independent\n * units. Repetitions improve a unit's precision and do not increase n.\n *\n * Decision mapping onto the substrate's five-valued `GateDecision`:\n *   - 'promote'            → 'ship'\n *   - 'continue'           → 'need_more_work' (stream ended before maxN with\n *                            the e-value undecided — more independent units needed)\n *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT\n *                            evidence of no effect (never a silent default)\n */\nexport function sequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(\n  options: SequentialPairedGateOptions,\n): SequentialPairedGate<TArtifact, TScenario> {\n  const cfg = resolveConfig(options)\n  const name = options.name ?? 'sequentialPairedGate'\n  const manifest = options.preRegistration\n  const observeStream = makeStream(cfg, options.resume)\n  const independentUnitByScenarioId =\n    options.independentUnitByScenarioId === undefined\n      ? undefined\n      : new Map(options.independentUnitByScenarioId)\n\n  return {\n    name,\n    observe(delta: number): SequentialObservation {\n      return observeStream.observe(delta)\n    },\n    state() {\n      return observeStream.state()\n    },\n    async decide(ctx: GateContext<TArtifact, TScenario>): Promise<GateResult> {\n      if (!ctx.baselineJudgeScores) {\n        throw new Error(\n          `${name}: ctx.baselineJudgeScores is required — falling back to the candidate's own ` +\n            'scores would compare the candidate against itself (delta 0, silent no-op)',\n        )\n      }\n      const scenarioIds = new Set(ctx.scenarios.map((s) => s.id))\n      const unitMap = independentUnitByScenarioId ?? new Map([...scenarioIds].map((id) => [id, id]))\n      for (const id of scenarioIds) {\n        const unit = unitMap.get(id)\n        if (typeof unit !== 'string' || unit.length === 0 || unit.trim() !== unit) {\n          throw new Error(`${name}: missing independent unit for scenario '${id}'`)\n        }\n      }\n      const paired = pairHoldout(\n        ctx.judgeScores,\n        ctx.baselineJudgeScores,\n        scenarioIds,\n        (s) => s.composite,\n      )\n      for (let i = 0; i < paired.cellIds.length; i++) {\n        const delta = paired.after[i]! - paired.before[i]!\n        if (Math.abs(delta) > cfg.scale) {\n          throw new Error(\n            `${name}: cell '${paired.cellIds[i]}' delta ${delta} outside ±scale=${cfg.scale}`,\n          )\n        }\n      }\n      const observations = aggregatePairedHoldout(paired, unitMap)\n      const deltas = observations.after.map((after, i) => after - observations.before[i]!)\n      seededShuffle(deltas, cfg.shuffleSeed)\n\n      const stream = makeStream(cfg)\n      let last: SequentialObservation | undefined\n      for (const d of deltas) {\n        last = stream.observe(d)\n        if (last.decision !== 'continue') break\n      }\n\n      const detail = {\n        ...stream.state(),\n        minN: cfg.minN,\n        maxN: cfg.maxN,\n        scale: cfg.scale,\n        shuffleSeed: cfg.shuffleSeed,\n        direction: cfg.direction,\n        minEffect: cfg.minEffect,\n        pairedN: deltas.length,\n        pairedCellN: paired.cellIds.length,\n        observationUnit: independentUnitByScenarioId === undefined ? 'scenario' : 'registered',\n        unitIds: observations.unitIds,\n        ...(manifest ? { preRegisteredId: manifest.id, metric: manifest.metric } : {}),\n      }\n      const meanDelta =\n        deltas.length === 0 ? undefined : deltas.reduce((s, d) => s + d, 0) / deltas.length\n\n      if (last === undefined) {\n        return {\n          decision: 'need_more_work',\n          reasons: [`${name}: no paired holdout observations — nothing to test`],\n          contributingGates: [{ name, status: 'not_evaluated', detail }],\n        }\n      }\n      const decision =\n        last.decision === 'promote'\n          ? 'ship'\n          : last.decision === 'continue'\n            ? 'need_more_work'\n            : 'hold'\n      return {\n        decision,\n        reasons: [`${name}: ${last.reason}`],\n        contributingGates: [\n          {\n            name,\n            status:\n              decision === 'ship'\n                ? 'pass'\n                : decision === 'need_more_work'\n                  ? 'not_evaluated'\n                  : 'fail',\n            detail,\n          },\n        ],\n        delta: meanDelta,\n      }\n    },\n  }\n}\n\nexport interface SequentialDecideOptions {\n  /** Type-I budget for the early-stop evidence. Default 0.05. */\n  alpha?: number\n  /** Minimum paired deltas before a stop may fire. Default 5. */\n  minN?: number\n  /** Bet truncation forwarded to `eProcess`. Default 0.5. */\n  maxBet?: number\n  /** Bound on |per-scenario composite delta|. Default 1. */\n  scale?: number\n}\n\nexport interface SequentialDecideFn {\n  (args: { history: GenerationRecord[] }): { stop: boolean; reason?: string }\n  /** Read-only snapshot of the accumulated e-process (observability + tests). */\n  state(): EProcessState\n}\n\n/**\n * SurfaceProposer.decide adapter that stops exploration at an e-value threshold.\n * The selected candidate still requires an independent held-out decision.\n *\n * Stream: for each generation g ≥ 1, the per-scenario composite deltas of\n * generation g's top candidate vs the generation-0 top candidate (the\n * incumbent the loop set out to beat), paired by scenarioId. H0: no proposed\n * surface improves any scenario's expected composite over the incumbent —\n * under it every delta has conditional mean ≤ 0 and the e-process is valid.\n * Once wealth ≥ 1/alpha the loop stops and hands the winner to the promotion\n * gate (which re-scores on HELD-OUT data — this adapter only spends the\n * exploration budget, it never promotes).\n *\n * This is an exploration stopping heuristic. Selection of the best measured\n * candidate and reuse of measured incumbent scores generally violate the\n * conditional-mean null, even when the candidates have no true improvement.\n * More repetitions reduce noise but do not establish exact type-I control.\n * An UNDECIDED process never stops the loop — absence of a\n * crossing is NOT evidence of no effect, so the loop simply runs its normal\n * course. Calling the adapter repeatedly with a growing history consumes each\n * generation exactly once (re-feeding an already-seen record would double-count\n * evidence).\n */\nexport function sequentialDecide(options: SequentialDecideOptions = {}): SequentialDecideFn {\n  const alpha = options.alpha ?? 0.05\n  const minN = options.minN ?? 5\n  const scale = options.scale ?? 1\n  if (!Number.isFinite(scale) || scale <= 0) {\n    throw new Error(`sequentialDecide: scale must be > 0, got ${scale}`)\n  }\n  const proc = eProcess({ alpha, maxBet: options.maxBet ?? 0.5, nullMean: 0.5 })\n  const threshold = 1 / alpha\n  let processedGenerations = 0\n  let reference: Map<string, number> | undefined\n  let stopped: { stop: true; reason: string } | undefined\n\n  const topCandidate = (record: GenerationRecord) => {\n    if (record.candidates.length === 0) {\n      throw new Error(\n        `sequentialDecide: generation ${record.generationIndex} has no candidates — ` +\n          'cannot extract a top candidate',\n      )\n    }\n    return record.candidates.reduce((best, candidate) => {\n      if (best.composite === null) return candidate\n      if (candidate.composite === null) return best\n      return candidate.composite > best.composite ? candidate : best\n    })\n  }\n\n  const decide: SequentialDecideFn = ({ history }) => {\n    if (stopped) return stopped\n    if (history.length === 0) return { stop: false }\n    if (reference === undefined) {\n      reference = new Map(\n        topCandidate(history[0]!).scenarios.map((s) => [s.scenarioId, s.composite]),\n      )\n    }\n    // Consume only generations not yet seen; start at 1 — generation 0 IS the\n    // reference and would contribute all-zero deltas (pure wealth dilution).\n    for (let g = Math.max(1, processedGenerations); g < history.length; g++) {\n      const top = topCandidate(history[g]!)\n      const byScenario = new Map(top.scenarios.map((s) => [s.scenarioId, s.composite]))\n      for (const [scenarioId, refComposite] of reference) {\n        const candComposite = byScenario.get(scenarioId)\n        if (candComposite === undefined) {\n          throw new Error(\n            `sequentialDecide: generation ${history[g]!.generationIndex} top candidate is missing ` +\n              `scenario '${scenarioId}' — generations must score the same scenario set to pair`,\n          )\n        }\n        const delta = candComposite - refComposite\n        if (!Number.isFinite(delta) || Math.abs(delta) > scale) {\n          throw new Error(\n            `sequentialDecide: paired delta ${delta} outside ±scale=${scale} on scenario ` +\n              `'${scenarioId}' — pass the composite scale explicitly`,\n          )\n        }\n        const step = proc.update((delta / scale + 1) / 2)\n        if (step.n >= minN && step.wealth >= threshold) {\n          stopped = {\n            stop: true,\n            reason:\n              `sequential e-process decided at generation ${history[g]!.generationIndex}: ` +\n              `e-value ${step.wealth.toFixed(2)} ≥ 1/α=${threshold.toFixed(2)} after n=${step.n} ` +\n              'paired deltas vs the generation-0 incumbent; stop exploring and require ' +\n              'an independent held-out promotion decision',\n          }\n          processedGenerations = history.length\n          return stopped\n        }\n      }\n    }\n    processedGenerations = history.length\n    return { stop: false }\n  }\n  decide.state = () => proc.state()\n  return decide\n}\n"],"mappings":"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"}

package/dist/{sequential-BhsrMupG.d.ts → sequential-KwGspfeR.d.ts}

@@ -114,13 +114,6 @@ interface SequentialCrossingHorizon {
   readonly decisionThreshold: number;
   readonly maxPairs: number;
 }
-/**
- * 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.
- */
-declare function sequentialCrossingHorizon(opts?: SequentialCrossingHorizonOptions): SequentialCrossingHorizon;
 interface InterimReleaseConfidenceInput {
   /**
    * One delta series per candidate (paired deltas vs comparator). Order
@@ -166,5 +159,5 @@ interface InterimReleaseConfidence {
  */
 declare function evaluateInterimReleaseConfidence(input: InterimReleaseConfidenceInput): InterimReleaseConfidence;
 //#endregion
-export { PairedEvalueStep as a, SequentialDecision as c, sequentialCrossingHorizon as d, PairedEvalueSequence as i, evaluateInterimReleaseConfidence as l, InterimReleaseConfidenceInput as n, SequentialCrossingHorizon as o, PairedEvalueOptions as r, SequentialCrossingHorizonOptions as s, InterimReleaseConfidence as t, pairedEvalueSequence as u };
-//# sourceMappingURL=sequential-BhsrMupG.d.ts.map
+export { PairedEvalueStep as a, SequentialDecision as c, PairedEvalueSequence as i, evaluateInterimReleaseConfidence as l, InterimReleaseConfidenceInput as n, SequentialCrossingHorizon as o, PairedEvalueOptions as r, SequentialCrossingHorizonOptions as s, InterimReleaseConfidence as t, pairedEvalueSequence as u };
+//# sourceMappingURL=sequential-KwGspfeR.d.ts.map

package/dist/{sequential-BhsrMupG.d.ts.map → sequential-KwGspfeR.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"sequential-BhsrMupG.d.ts","names":[],"sources":["../src/sequential.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCY;UAEK;;;;;;EAMf;;EAEA;;;;;;EAMA;IAAS;IAAa;;;EAEtB;;UAGe;;EAEf;EACA;;EAEA;;EAEA;;EAEA;EACA;;EAEA,UAAU;;UAGK;EACf,OAAO;;EAEP,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBAYc,qBACd,kBACA,OAAM,sBACL;;UA0Ec,yCACP,KAAK;;EAEb;;;;;;;;;;;;UAae;WACN;WACA;WACA;WACA;WACA;;;;;;;;iBAWK,0BACd,OAAM,mCACL;UAmCc;;;;;EAKf,aAAa;IAAQ;IAAqB;;EAC1C;EACA;EACA;IAAS;IAAa;;;UAGP;EACf,YAAY;IACV;IACA,UAAU;IACV;IACA;IACA;IACA;IACA;IACA;;;;;;;EAOF;IAAkB,UAAU;IAAoB;;;;;;;;;iBASlC,iCACd,OAAO,gCACN"}
+{"version":3,"file":"sequential-KwGspfeR.d.ts","names":[],"sources":["../src/sequential.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCY;UAEK;;;;;;EAMf;;EAEA;;;;;;EAMA;IAAS;IAAa;;;EAEtB;;UAGe;;EAEf;EACA;;EAEA;;EAEA;;EAEA;EACA;;EAEA,UAAU;;UAGK;EACf,OAAO;;EAEP,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBAYc,qBACd,kBACA,OAAM,sBACL;;UA0Ec,yCACP,KAAK;;EAEb;;;;;;;;;;;;UAae;WACN;WACA;WACA;WACA;WACA;;UAgDM;;;;;EAKf,aAAa;IAAQ;IAAqB;;EAC1C;EACA;EACA;IAAS;IAAa;;;UAGP;EACf,YAAY;IACV;IACA,UAAU;IACV;IACA;IACA;IACA;IACA;IACA;;;;;;;EAOF;IAAkB,UAAU;IAAoB;;;;;;;;;iBASlC,iCACd,OAAO,gCACN"}

package/dist/{sequential-eprocess-D1jKoihe.js → sequential-eprocess-DodI6RoF.js}

@@ -1,4 +1,4 @@
-import { s as ValidationError } from "./errors-Dngq5h35.js";
+import { s as ValidationError } from "./errors-BcOs5MKW.js";
 //#region src/statistics/sequential-eprocess.ts
 /**
 * Betting test-martingale for bounded observations — the e-process core of
@@ -127,4 +127,4 @@ function assertResumable(resume, params) {
 //#endregion
 export { eProcess as t };
 
-//# sourceMappingURL=sequential-eprocess-D1jKoihe.js.map
+//# sourceMappingURL=sequential-eprocess-DodI6RoF.js.map

package/dist/{sequential-eprocess-D1jKoihe.js.map → sequential-eprocess-DodI6RoF.js.map}

@@ -1 +1 @@
-{"version":3,"file":"sequential-eprocess-D1jKoihe.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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"}
+{"version":3,"file":"sequential-eprocess-DodI6RoF.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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"}