@tangle-network/agent-eval 0.179.0 → 0.181.0

package/dist/experiment/index.d.ts

@@ -1,462 +1,11 @@
 import { c as ValidationError, r as CaptureIntegrityError } from "../errors-DEE6u6ot.js";
 import { n as bonferroni, r as holm, t as benjaminiHochberg } from "../multiplicity-DIWHvysC.js";
-import { $ as paretoSignificanceGate, A as PairArmsOptions, B as PowerPreflight, C as hashJson, Dt as EProcessStep, E as verifyManifest, Et as EProcessState, Ft as mcnemar, H as powerPreflight, K as EvidenceVector, L as comparePairedArms, Lt as pairedRiskDifference, N as PairedArmRow, O as MatchedPair, Ot as eProcess, Q as paretoPolicy, R as pairArms, Rt as pairedRiskDifferenceExact, S as evaluateHypothesis, T as signManifest, Tt as EProcessOptions, V as PowerPreflightOptions, Vt as wilson, X as PromotionPolicy, Z as buildEvidenceVector, _ as sequentialPairedGate, _t as verifyEvidenceReceipt, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EVIDENCE_RECEIPT_VERSION, d as SequentialDecision, dt as EvidenceBinding, f as SequentialObservation, ft as EvidenceReceipt, g as sequentialDecide, gt as isIndependentEvidence, ht as createEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as ProportionInterval, lt as EvidenceAuthority, m as SequentialPairedGateOptions, mt as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as EvidenceReceiptVerification, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_AUTHORITY_KINDS, ut as EvidenceAuthorityKind, v as HypothesisManifest, w as manifestContentDigest, wt as EProcess, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords, zt as pairedRiskDifferenceScore } from "../statistical-heldout-0La5ZTlv.js";
-import { c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, h as pairedBootstrap, u as PairedBootstrapOptions } from "../paired-promotion-decision-CGzg0cI_.js";
-import { _ as requiredSampleSize, a as ExperimentVerdict, d as inMemoryExperimentStore, f as mulberry32, g as requiredPairedSampleSize, h as pairedMde, i as ExperimentTracker, l as fileExperimentStore, m as mcnemarRequiredN, n as ExperimentRep, p as mcnemarPower, r as ExperimentStats, t as Experiment } from "../experiment-tracker-B3TiF5-u.js";
+import { $ as paretoSignificanceGate, $t as wilson, A as PairArmsOptions, At as FinalEvidenceReservation, B as PowerPreflight, Bt as eProcess, C as hashJson, Dt as FinalEvidenceMeasurement, E as verifyManifest, Et as FinalEvidenceLedger, Ft as summarizeEvaluationUnits, H as powerPreflight, It as EProcess, K as EvidenceVector, L as comparePairedArms, Lt as EProcessOptions, Mt as EvaluationClaim, N as PairedArmRow, Nt as EvaluationUnitSummary, O as MatchedPair, Ot as FinalEvidenceOutcome, Pt as defineEvaluationClaim, Q as paretoPolicy, R as pairArms, Rt as EProcessState, S as evaluateHypothesis, T as signManifest, Tt as FinalEvidenceError, Ut as ProportionInterval, V as PowerPreflightOptions, X as PromotionPolicy, Xt as pairedRiskDifferenceExact, Yt as pairedRiskDifference, Z as buildEvidenceVector, Zt as pairedRiskDifferenceScore, _ as sequentialPairedGate, _t as verifyEvidenceReceipt, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EVIDENCE_RECEIPT_VERSION, d as SequentialDecision, dt as EvidenceBinding, f as SequentialObservation, ft as EvidenceReceipt, g as sequentialDecide, gt as isIndependentEvidence, ht as createEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as openFinalEvidenceLedger, kt as FinalEvidenceRecord, lt as EvidenceAuthority, m as SequentialPairedGateOptions, mt as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as EvidenceReceiptVerification, qt as mcnemar, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_AUTHORITY_KINDS, ut as EvidenceAuthorityKind, v as HypothesisManifest, w as manifestContentDigest, wt as FinalEvidenceConflictError, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords, zt as EProcessStep } from "../statistical-heldout-CpVd6FmY.js";
+import { c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, h as pairedBootstrap, u as PairedBootstrapOptions } from "../paired-promotion-decision-DPsMQm-0.js";
+import { _ as requiredSampleSize, a as ExperimentVerdict, d as inMemoryExperimentStore, f as mulberry32, g as requiredPairedSampleSize, h as pairedMde, i as ExperimentTracker, l as fileExperimentStore, m as mcnemarRequiredN, n as ExperimentRep, p as mcnemarPower, r as ExperimentStats, t as Experiment } from "../experiment-tracker-C7PfnF4b.js";
 import { a as PairedEvalueStep, d as sequentialCrossingHorizon, i as PairedEvalueSequence, o as SequentialCrossingHorizon, r as PairedEvalueOptions, s as SequentialCrossingHorizonOptions, u as pairedEvalueSequence } from "../sequential-BhsrMupG.js";
+import { A as classifyReissue, B as evaluateProvenanceGate, C as ReissuePolicy, D as UniformPassDecision, E as SetExpr, F as evaluateIdentityGate, G as runUniformPassBudget, H as projectNLadderBudget, I as evaluateOracleDeterminismGate, L as evaluatePopulationReproducibilityGate, M as computeInterval, N as evaluateCondition, O as UniformPassSchedule, P as evaluateHaltRule, R as evaluatePowerFloorGate, S as Predicate, T as SelectionRule, U as readField, V as executeDecisionRule, W as runSelectionRule, _ as IntervalSpec, a as ComputedInterval, b as NLadderProjection, c as DecisionOutcome, d as Estimand, f as EstimandResult, g as HaltRule, h as HaltOutcome, i as BudgetRule, j as computeEstimand, k as ValidityGate, l as DecisionRule, m as GateResult, n as AdmissionRule, o as Condition, p as EvidenceRecord, r as AdmissionStage, s as DecisionBranch, t as AdmissionPartition, u as DerivedQuantities, v as JsonValue, w as ReissueVerdict, x as Obligation, y as MatchedBudgetRule, z as evaluatePredicate } from "../ast-hI-vjW6J.js";
 import { z } from "zod";
-//#region src/experiment/ast.d.ts
-/**
- * The registered-rule AST: every rule an experiment registers is DATA.
- *
- * A closure cannot be canonicalized or hashed; a node tree can. `sealExperiment`
- * hashes the whole tree, and every interpreter in this file takes only a node
- * plus evidence records — no parameter for alpha, threshold, metric, or
- * stopping rule exists on any executable surface. The registered object and
- * the executed object are therefore the same object, and registered-vs-ran
- * drift is unrepresentable rather than checked.
- *
- * Node families:
- *   Predicate       closed-key comparisons — the only leaf
- *   AdmissionRule   monotone funnel stages with registered waivers
- *   SelectionRule   deterministic subsets over a closed field set
- *   Estimand        what the experiment measures
- *   IntervalSpec    how uncertainty is computed, seed included
- *   Condition       decision guards over named derived quantities
- *   DecisionRule    ordered verdict table, or a registered absence of one
- *   Obligation      a control that must exist before a verdict class is read
- *   ValidityGate    pre-spend design checks
- *   HaltRule        gates as prerequisites — failure refuses the spend
- *   BudgetRule      spend schedules with a named ledger
- *   MatchedBudgetRule  arm budget matching as a refusal
- *   ReissuePolicy   carrier faults are reissued; model outcomes stand
- */
-/** JSON-serializable value — everything a sealed node may carry. */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [k: string]: JsonValue;
-};
-/** Evidence row shape. Fields are addressed by dot-separated paths. */
-type EvidenceRecord = Record<string, unknown>;
-/**
- * Closed-key comparison over a declared record schema. The only leaf node.
- * `field` is a dot-separated path into an evidence record.
- */
-type Predicate = {
-  kind: 'compare';
-  field: string;
-  op: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte';
-  value: JsonValue;
-} | {
-  kind: 'in';
-  field: string;
-  values: JsonValue[];
-} | {
-  kind: 'all';
-  of: Predicate[];
-} | {
-  kind: 'any';
-  of: Predicate[];
-} | {
-  kind: 'not';
-  of: Predicate;
-};
-/** Read a dot-separated field path. Missing segments yield `undefined`. */
-declare function readField(record: EvidenceRecord, path: string): unknown;
-/** Evaluate a predicate against one evidence record. */
-declare function evaluatePredicate(predicate: Predicate, record: EvidenceRecord): boolean;
-/**
- * One monotone funnel stage. `waives` names substrate admission conditions
- * deliberately NOT applied, so a waiver is registered, never implicit.
- */
-interface AdmissionStage {
-  id: string;
-  keep: Predicate;
-  waives?: string[];
-}
-/** A partition is a set reported separately and never pooled. */
-interface AdmissionPartition {
-  id: string;
-  /** Stage whose dropped rows this partition draws from. */
-  from: string;
-  keep: Predicate;
-  pooling: 'never';
-}
-/** Declarative row-admission funnel. Stages only remove rows. */
-interface AdmissionRule {
-  population: string;
-  stages: AdmissionStage[];
-  partitions?: AdmissionPartition[];
-}
-/**
- * Deterministic subset selection. `reads` is the closed field set the rule
- * may touch — outcome-contaminated selection is unrepresentable because an
- * outcome field is simply not in the list.
- */
-type SelectionRule = {
-  kind: 'round-robin';
-  groupBy: string;
-  groupOrder: 'lex-asc';
-  withinOrder: {
-    field: string;
-    dir: 'asc' | 'desc';
-  };
-  take: number;
-  reads: string[];
-} | {
-  kind: 'filter-of';
-  /** Name of the sealed subset or selection this rule filters. */
-  base: string;
-  keep: Predicate;
-  order: {
-    field: string;
-    dir: 'asc' | 'desc';
-  };
-};
-/**
- * Execute a selection rule.
- *
- * Round-robin walks groups in lexicographic order and takes ids in
- * within-group order until `take` ids are chosen. Filter-of keeps the ids of
- * `bases[rule.base]` whose record satisfies the predicate, in the registered
- * order. Ids absent from `records` are evaluated on their id alone (fields
- * derived from the id via `idFields`), so a sealed base outlives its source
- * records.
- */
-declare function runSelectionRule(rule: SelectionRule, records: readonly EvidenceRecord[], options: {
-  /** Field carrying a row's identity. */
-  idField: string;
-  /** Sealed or previously-computed subsets, by name. */
-  bases?: Record<string, readonly string[]>;
-  /** Derive predicate-readable fields from a bare id when its record is absent. */
-  idFields?: (id: string) => EvidenceRecord;
-}): string[];
-/** A named set of row identities, built from arm rows and an event predicate. */
-type SetExpr = {
-  kind: 'rows-where';
-  arm: string;
-  event: Predicate;
-} | {
-  kind: 'intersect';
-  of: SetExpr[];
-};
-/**
- * What the experiment measures. Every estimand names the fields it reads, so
- * the sealed tree records the full data dependency of the number.
- */
-type Estimand = {
-  kind: 'rate';
-  event: Predicate;
-  over: 'rollouts';
-} | {
-  kind: 'rate-at-least-once';
-  event: Predicate;
-  groupBy: string;
-} | {
-  kind: 'paired-mean-diff';
-  armField: string;
-  treatment: string;
-  control: string;
-  pairBy: string;
-  /**
-   * Field path to the per-row outcome. A boolean reads as 1 or 0, so a
-   * binary pass/fail outcome gives the risk difference directly.
-   */
-  value: string;
-  /** A pair one arm did not answer contributes a difference of exactly zero. */
-  missing: 'zero-diff';
-} | {
-  kind: 'set-ratio';
-  armField: string;
-  idField: string;
-  numerator: SetExpr;
-  denominator: SetExpr;
-};
-interface EstimandResult {
-  value: number;
-  numerator: number;
-  denominator: number;
-}
-/** Compute an estimand over evidence rows. Pure; reads only registered fields. */
-declare function computeEstimand(estimand: Estimand, rows: readonly EvidenceRecord[]): EstimandResult;
-/** How uncertainty is computed. The seed is part of the registration. */
-type IntervalSpec = {
-  kind: 'cluster-bootstrap';
-  clusterBy: string;
-  resamples: number;
-  seed: number;
-  level: number;
-  method: 'percentile';
-} | {
-  kind: 'clopper-pearson';
-  level: number;
-};
-interface ComputedInterval {
-  lower: number;
-  upper: number;
-  level: number;
-}
-/**
- * Execute an interval spec.
- *
- * Cluster-bootstrap resamples whole clusters of the per-row `value` field and
- * takes percentile bounds of the pooled mean. Clopper-Pearson computes the
- * exact binomial interval and requires `successes`/`trials` evidence instead
- * of rows.
- */
-declare function computeInterval(spec: IntervalSpec, evidence: {
-  kind: 'rows';
-  rows: readonly EvidenceRecord[];
-  value: string;
-} | {
-  kind: 'binomial';
-  successes: number;
-  trials: number;
-}): ComputedInterval;
-/** Decision guards read only named derived quantities — never raw rows. */
-type Condition = {
-  kind: 'interval-excludes-zero';
-  interval: string;
-  sign: 'positive' | 'negative';
-} | {
-  kind: 'interval-includes-zero';
-  interval: string;
-} | {
-  kind: 'quantity-threshold';
-  quantity: string;
-  op: 'gte' | 'lte' | 'gt' | 'lt';
-  value: number;
-} | {
-  kind: 'obligation-met';
-  obligation: string;
-} | {
-  kind: 'all';
-  of: Condition[];
-} | {
-  kind: 'any';
-  of: Condition[];
-} | {
-  kind: 'not';
-  of: Condition;
-};
-/** The named quantities a decision rule may read. Nothing else reaches it. */
-interface DerivedQuantities {
-  intervals: Record<string, {
-    lower: number;
-    upper: number;
-  }>;
-  quantities: Record<string, number>;
-  obligationsMet: Record<string, boolean>;
-}
-declare function evaluateCondition(condition: Condition, evidence: DerivedQuantities): boolean;
-interface DecisionBranch {
-  when: Condition;
-  verdict: string;
-  report: string[];
-}
-/**
- * Ordered decision table: the first branch whose condition holds fires, and a
- * table no branch matches throws — a non-total registration is a defect, not
- * an implicit verdict. `report-only` registers the ABSENCE of a verdict
- * branch: the estimate and the per-row table are the finding, and the
- * registered meaning prose rides as non-executable interpretation data.
- */
-type DecisionRule = {
-  kind: 'table';
-  branches: DecisionBranch[];
-} | {
-  kind: 'report-only';
-  estimands: string[];
-  intervals: string[];
-  perRow: string[];
-  interpretation?: {
-    onQualitative: string;
-    consequence: string;
-  }[];
-};
-interface DecisionOutcome {
-  verdict: string;
-  report: string[];
-}
-declare function executeDecisionRule(rule: DecisionRule, evidence: DerivedQuantities): DecisionOutcome;
-/** A registered control that must exist before a class of verdicts is read. */
-interface Obligation {
-  id: string;
-  appliesToVerdicts: string[];
-  control: string;
-}
-/** Pre-spend design checks. Each returns pass/fail plus its evidence. */
-type ValidityGate = {
-  kind: 'oracle-determinism';
-  unit: 'suite' | 'assertion';
-  replicates: number;
-  maxFlipRate: number;
-} | {
-  kind: 'population-reproducibility';
-  joinOn: string;
-  compare: string[];
-  maxChangedRows: number;
-} | {
-  kind: 'provenance-assertion';
-  claim: Predicate;
-} | {
-  kind: 'power-floor';
-  target: number;
-  effectGrid: number[];
-  sim: {
-    trials: number;
-    resamples: number;
-    seed: number;
-  };
-} | {
-  kind: 'identity';
-  field: 'served-model';
-  op: 'basename-eq';
-  onFail: 'abort';
-};
-interface GateResult {
-  id: string;
-  passed: boolean;
-  evidence: JsonValue;
-}
-/**
- * Replicate-flip counting over graded states. A state whose replicates split
- * between pass and fail is flipping; its flip rate is the minority share.
- */
-declare function evaluateOracleDeterminismGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'oracle-determinism';
-}>, repsByState: Record<string, readonly boolean[]>): GateResult;
-/**
- * Join two population snapshots on `joinOn` and compare the registered fields.
- * Only rows present in both snapshots are compared; a presence change is a
- * different failure and needs its own gate.
- */
-declare function evaluatePopulationReproducibilityGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'population-reproducibility';
-}>, populations: {
-  left: readonly EvidenceRecord[];
-  right: readonly EvidenceRecord[];
-}): GateResult;
-/** The registered claim about provenance must hold on the provenance record. */
-declare function evaluateProvenanceGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'provenance-assertion';
-}>, provenance: EvidenceRecord): GateResult;
-/** Final path segment equality between the pinned and the served identity. */
-declare function evaluateIdentityGate(id: string, _gate: Extract<ValidityGate, {
-  kind: 'identity';
-}>, identities: {
-  pinned: string;
-  served: string;
-}): GateResult;
-/**
- * The design's power curve must reach the registered target at some grid
- * effect. The curve must cover the registered effect grid exactly — a curve
- * computed on a different grid is different evidence and is refused.
- */
-declare function evaluatePowerFloorGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'power-floor';
-}>, curve: readonly {
-  effect: number;
-  power: number;
-}[]): GateResult;
-/** Checks as prerequisites: any named gate failing refuses the spend. */
-interface HaltRule {
-  when: {
-    kind: 'any-gate-failed';
-    gates: string[];
-  };
-  action: 'refuse-spend';
-  report: 'settling-n';
-}
-interface HaltOutcome {
-  fired: boolean;
-  action: 'refuse-spend' | null;
-  failedGates: string[];
-}
-declare function evaluateHaltRule(halt: HaltRule, gates: readonly GateResult[]): HaltOutcome;
-/**
- * Spend schedules as data. `ledger` names every entry the ceiling counts, so
- * what the gate reads is registered, not improvised at gate time.
- */
-type BudgetRule = {
-  kind: 'uniform-pass';
-  ceilingUsd: number;
-  maxPasses: number;
-  projection: 'last-pass-cost';
-  costSource: 'priced-per-call';
-  ledger: {
-    id: string;
-    usd: number;
-  }[];
-  partialPass: 'report-never-lift';
-} | {
-  kind: 'n-ladder';
-  steps: number[];
-  ceilingUsd: number;
-  projection: 'unit-cost-times-rows-times-n';
-  onExhaust: 'refuse-report-projection';
-};
-interface UniformPassDecision {
-  pass: number;
-  cumulativeBefore: number;
-  projected: number;
-  go: boolean;
-}
-interface UniformPassSchedule {
-  decisions: UniformPassDecision[];
-  uniformN: number;
-}
-/**
- * Execute the uniform-pass schedule against measured pass costs. Pass 1 always
- * runs; each later pass runs only when the cumulative spend plus the last
- * measured pass cost stays at or under the registered ceiling. The registered
- * ledger is the pre-spend the ceiling counts.
- */
-declare function runUniformPassBudget(rule: Extract<BudgetRule, {
-  kind: 'uniform-pass';
-}>, measuredPassCosts: readonly number[]): UniformPassSchedule;
-interface NLadderProjection {
-  chosenN: number | null;
-  projections: {
-    n: number;
-    projectedUsd: number;
-    affordable: boolean;
-  }[];
-  refusal: null | {
-    onExhaust: 'refuse-report-projection';
-    reason: string;
-  };
-}
-/**
- * Walk the registered n-ladder and pick the first affordable step. When no
- * step fits the ceiling, the rule refuses and reports the projection instead
- * of shrinking the row set — "never subset rows" is the registered invariant.
- */
-declare function projectNLadderBudget(rule: Extract<BudgetRule, {
-  kind: 'n-ladder';
-}>, measured: {
-  unitCostUsd: number;
-  rows: number;
-}): NLadderProjection;
-/** Arm budget matching as a refusal, not prose. Verified by `verifyMatchedBudgets`. */
-interface MatchedBudgetRule {
-  measure: 'realized-tokens';
-  tolerance: number;
-  onFail: 'refuse-contrast';
-}
-/** Carrier faults are reissued; model outcomes stand. Closed enumeration. */
-interface ReissuePolicy {
-  carrierEvents: ('http-status' | 'transport-error' | 'deadline' | 'empty-content')[];
-  modelOutcomesStand: true;
-  maxIssues: number;
-}
-type ReissueVerdict = 'reissue' | 'stands' | 'exhausted';
-/**
- * Classify one rollout event under the registered reissue policy. A carrier
- * event within the issue budget is reissued; a model outcome always stands;
- * a carrier event past `maxIssues` is exhausted and reported, never retried.
- */
-declare function classifyReissue(policy: ReissuePolicy, event: string, issuesSoFar: number): ReissueVerdict;
-//#endregion
 //#region src/experiment/budget.d.ts
 /** Arms whose realized budgets diverge past the registered tolerance. */
 declare class MatchedBudgetError extends CaptureIntegrityError {}
@@ -607,6 +156,8 @@ interface SeedDerivation {
 }
 interface ExperimentSpec {
   id: string;
+  /** Population and independent observation unit for the intended use of this result. */
+  claim?: EvaluationClaim;
   /** Human prose for the audit trail — never executable. */
   hypothesis?: string;
   arms: ArmSpec[];
@@ -650,21 +201,13 @@ interface SealAmendment {
   /** Digest of the spec after this amendment. */
   digest: string;
 }
-/**
- * Digest scheme of a sealed experiment. Both are sha256 hex over the
- * serialized spec and differ only in the serialization: `'sha256-rfc8785'` is
- * RFC 8785 canonical JSON, `'sha256-content'` is key-sorted `JSON.stringify`.
- */
-type SealAlgo = 'sha256-content' | 'sha256-rfc8785';
+/** SHA-256 over the RFC 8785 canonical JSON encoding of the experiment. */
+type SealAlgo = 'sha256-rfc8785';
 interface SealedExperiment {
   spec: ExperimentSpec;
   /** sha256 over the serialized spec, under the scheme `algo` names. */
   digest: string;
-  /**
-   * Digest scheme of `digest`. `'sha256-rfc8785'` is what {@link sealExperiment}
-   * emits; `'sha256-content'` is read-only, carried by seals from an earlier
-   * release, and still verifies.
-   */
+  /** Required digest scheme. Unsupported or missing schemes cannot execute. */
   algo: SealAlgo;
   sealedAt: string;
   /** Digest of the original registration, before any amendment. */
@@ -686,8 +229,7 @@ declare function amendExperiment(sealed: SealedExperiment, amendment: {
   blind: string[];
   at?: string;
 }): Promise<SealedExperiment>;
-/** True when the sealed digest still matches the spec it carries, under the
- *  scheme the seal declares. */
+/** True when the supported seal matches its canonical spec. */
 declare function verifySealedExperiment(sealed: SealedExperiment): Promise<boolean>;
 /** Evidence a gate executor consumes, discriminated to match the gate kind. */
 type GateEvidence = {
@@ -717,6 +259,8 @@ type GateEvidence = {
  */
 interface RegisteredExperiment {
   readonly sealed: SealedExperiment;
+  /** Count independent units separately from repeated observations under the sealed claim. */
+  units(records: readonly EvidenceRecord[]): EvaluationUnitSummary;
   /** Execute the registered decision rule on derived quantities. */
   decide(evidence: DerivedQuantities): DecisionOutcome;
   /** Run the registered admission funnel over evidence rows. */
@@ -744,12 +288,14 @@ interface RegisteredExperiment {
   interval(name: string, evidence: {
     kind: 'rows';
     rows: readonly EvidenceRecord[];
-    value: string;
   } | {
     kind: 'binomial';
     successes: number;
     trials: number;
-  }): ComputedInterval;
+    unitIds?: readonly string[];
+  }): ComputedInterval & {
+    units?: EvaluationUnitSummary;
+  };
 }
 /**
  * Verify the seal and return executors bound to it. This is the module's only
@@ -831,8 +377,10 @@ declare class DesignRefusalError extends ValidationError {}
 interface ClusteredPowerOptions {
   /** Rows per independent cluster, e.g. [6, 3, 3, 2]. */
   clusterSizes: number[];
-  /** Per-row effect grid: each effect is P(win) - P(loss) added to the base rates. */
+  /** P(win) − P(loss) in signal clusters; noisy clusters retain zero expected contrast. */
   effects: number[];
+  /** Minimum worthwhile effect under the declared outcome model; must occur in effects. */
+  minimumEffect: number;
   /** Deterministic seed for outcome draws and bootstrap resampling. */
   seed: number;
   /** Simulated experiments per effect. Default 2000. */
@@ -843,11 +391,11 @@ interface ClusteredPowerOptions {
   confidence?: number;
   /** Sign-flip alpha the closed-form floor is checked against. Default 0.05. */
   alpha?: number;
-  /** Power the design must reach at some grid effect. Default 0.8. */
+  /** Power required at minimumEffect. Default 0.8. */
   targetPower?: number;
-  /** Base P(row favors treatment) with no effect. Default 0.10 (tie-heavy rows). */
+  /** P(row favors treatment) under the zero-effect model. Must equal baseLossRate. Default 0.10. */
   baseWinRate?: number;
-  /** Base P(row favors control). Default 0.10. */
+  /** P(row favors control) under the zero-effect model. Must equal baseWinRate. Default 0.10. */
   baseLossRate?: number;
   /**
    * Clusters whose rows carry outcome noise instead of signal: each row wins
@@ -888,22 +436,24 @@ interface ClusteredPowerResult {
   seed: number;
   confidence: number;
   targetPower: number;
+  minimumEffect: number;
+  powerAtMinimumEffect: number;
   curve: ClusteredPowerPoint[];
   /** Maximum simulated power across the effect grid. */
   maxPower: number;
   signFlipFloor: SignFlipFloor;
-  /** True only when the sign-flip floor certifies AND simulation reaches target. */
+  /** True when the sign-flip floor certifies and power at minimumEffect reaches target. */
   adequate: boolean;
   /** Populated exactly when `adequate` is false. The refusal lives in the artifact. */
   refusal: ClusteredPowerRefusal | null;
 }
 /**
  * Simulate the power of a whole-cluster percentile-bootstrap design and refuse
- * a structure that cannot reach the target at any registered effect.
+ * a structure that cannot reach target power at the declared minimum effect.
  */
 declare function clusteredPower(options: ClusteredPowerOptions): ClusteredPowerResult;
 /** Throw the refusal for callers that want configuration-time failure. */
 declare function assertDesignAdequate(result: ClusteredPowerResult): void;
 //#endregion
-export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, DesignRefusalError, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, EVIDENCE_AUTHORITY_KINDS, EVIDENCE_RECEIPT_VERSION, EVIDENCE_STATES, type Estimand, type EstimandResult, type EvidenceAuthority, type EvidenceAuthorityKind, type EvidenceBinding, type EvidenceDenominator, type EvidenceReceipt, type EvidenceReceiptVerification, type EvidenceRecord, type EvidenceRegistryRecord, type EvidenceState, type EvidenceVector, type Experiment, type ExperimentFunnel, type ExperimentRep, type ExperimentSpec, type ExperimentStats, ExperimentTracker, type ExperimentVerdict, FunnelIntegrityError, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type GateEvidence, type GateResult, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, type IntervalSpec, type JsonValue, MatchedBudgetError, type MatchedBudgetRule, type MatchedBudgetVerdict, type MatchedPair, type NLadderProjection, type Obligation, type OutcomeSpec, type PairArmsOptions, type PairArmsResult, type PairedArmRow, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedHoldout, type PowerPreflight, type PowerPreflightOptions, type Predicate, type PromotionPolicy, type ProportionInterval, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, SealIntegrityError, type SealedExperiment, type SeedDerivation, type SelectionRule, type SequentialCrossingHorizon, type SequentialCrossingHorizonOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SetExpr, type SignFlipFloor, type SignedManifest, type SignedManifestAlgo, type UniformPassDecision, type UniformPassSchedule, type ValidityGate, amendExperiment, assertDesignAdequate, assertFunnelReconciles, assertMatchedBudgets, benjaminiHochberg, bonferroni, buildEvidenceVector, buildFunnel, classifyReissue, clusteredPower, comparePairedArms, composeFunnels, computeEstimand, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineExperiment, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, evidenceRegistryRecordSchema, executeAdmissionRule, executeDecisionRule, fileExperimentStore, hashJson, heldoutSignificance, holm, inMemoryExperimentStore, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openSealedExperiment, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, parseEvidenceRegistryRecord, powerPreflight, projectNLadderBudget, readField, renderEvidenceIndex, renderFunnelTable, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sealExperiment, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, validateEvidenceRegistry, verifyEvidenceReceipt, verifyManifest, verifyMatchedBudgets, verifySealedExperiment, wilson };
+export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, DesignRefusalError, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, EVIDENCE_AUTHORITY_KINDS, EVIDENCE_RECEIPT_VERSION, EVIDENCE_STATES, type Estimand, type EstimandResult, type EvaluationClaim, type EvaluationUnitSummary, type EvidenceAuthority, type EvidenceAuthorityKind, type EvidenceBinding, type EvidenceDenominator, type EvidenceReceipt, type EvidenceReceiptVerification, type EvidenceRecord, type EvidenceRegistryRecord, type EvidenceState, type EvidenceVector, type Experiment, type ExperimentFunnel, type ExperimentRep, type ExperimentSpec, type ExperimentStats, ExperimentTracker, type ExperimentVerdict, FinalEvidenceConflictError, FinalEvidenceError, type FinalEvidenceLedger, type FinalEvidenceMeasurement, type FinalEvidenceOutcome, type FinalEvidenceRecord, type FinalEvidenceReservation, FunnelIntegrityError, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type GateEvidence, type GateResult, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, type IntervalSpec, type JsonValue, MatchedBudgetError, type MatchedBudgetRule, type MatchedBudgetVerdict, type MatchedPair, type NLadderProjection, type Obligation, type OutcomeSpec, type PairArmsOptions, type PairArmsResult, type PairedArmRow, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedHoldout, type PowerPreflight, type PowerPreflightOptions, type Predicate, type PromotionPolicy, type ProportionInterval, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, SealIntegrityError, type SealedExperiment, type SeedDerivation, type SelectionRule, type SequentialCrossingHorizon, type SequentialCrossingHorizonOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SetExpr, type SignFlipFloor, type SignedManifest, type SignedManifestAlgo, type UniformPassDecision, type UniformPassSchedule, type ValidityGate, amendExperiment, assertDesignAdequate, assertFunnelReconciles, assertMatchedBudgets, benjaminiHochberg, bonferroni, buildEvidenceVector, buildFunnel, classifyReissue, clusteredPower, comparePairedArms, composeFunnels, computeEstimand, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, defineExperiment, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, evidenceRegistryRecordSchema, executeAdmissionRule, executeDecisionRule, fileExperimentStore, hashJson, heldoutSignificance, holm, inMemoryExperimentStore, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, openSealedExperiment, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, parseEvidenceRegistryRecord, powerPreflight, projectNLadderBudget, readField, renderEvidenceIndex, renderFunnelTable, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sealExperiment, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, validateEvidenceRegistry, verifyEvidenceReceipt, verifyManifest, verifyMatchedBudgets, verifySealedExperiment, wilson };
 //# sourceMappingURL=index.d.ts.map

package/dist/experiment/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/experiment/ast.ts","../../src/experiment/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/experiment/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts"],"mappings":"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"}