@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/experiment/index.d.ts

@@ -1,15 +1,335 @@
-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, At as EProcess, B as PowerPreflight, C as hashJson, Ct as FinalEvidenceError, Dt as FinalEvidenceRecord, E as verifyManifest, Et as FinalEvidenceOutcome, Gt as pairedRiskDifferenceScore, H as powerPreflight, K as EvidenceVector, L as comparePairedArms, Lt as ProportionInterval, Mt as EProcessState, N as PairedArmRow, Nt as EProcessStep, O as MatchedPair, Ot as FinalEvidenceReservation, Pt as eProcess, Q as paretoPolicy, R as pairArms, S as evaluateHypothesis, St as FinalEvidenceConflictError, T as signManifest, Tt as FinalEvidenceMeasurement, Ut as pairedRiskDifference, V as PowerPreflightOptions, Vt as mcnemar, Wt as pairedRiskDifferenceExact, X as PromotionPolicy, Z as buildEvidenceVector, _ as sequentialPairedGate, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EvidenceAuthority, d as SequentialDecision, dt as EvidenceReceipt, f as SequentialObservation, ft as EvidenceReceiptVerification, g as sequentialDecide, ht as verifyEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as EProcessOptions, kt as openFinalEvidenceLedger, lt as EvidenceAuthorityKind, m as SequentialPairedGateOptions, mt as isIndependentEvidence, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as createEvidenceReceipt, qt as wilson, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_RECEIPT_VERSION, ut as EvidenceBinding, v as HypothesisManifest, w as manifestContentDigest, wt as FinalEvidenceLedger, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords } from "../statistical-heldout-BeR4bOdg.js";
-import { c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, h as pairedBootstrap, u as PairedBootstrapOptions } from "../paired-promotion-decision-DPKz8ZnF.js";
+import { At as EProcessStep, B as powerPreflight, Bt as pairedRiskDifferenceScore, C as signManifest, Ct as FinalEvidenceOutcome, Dt as EProcess, E as MatchedPair, Et as openFinalEvidenceLedger, F as comparePairedArms, Ht as wilson, I as pairArms, J as PromotionPolicy, L as pairRunRecords, Lt as mcnemar, O as PairArmsOptions, Ot as EProcessOptions, Pt as ProportionInterval, R as PowerPreflight, Rt as pairedRiskDifference, S as manifestContentDigest, St as FinalEvidenceMeasurement, Tt as FinalEvidenceReservation, W as EvidenceVector, X as paretoPolicy, Y as buildEvidenceVector, Z as paretoSignificanceGate, _ as HypothesisManifest, at as EvidenceAuthority, b as SignedManifestAlgo, bt as FinalEvidenceError, ct as EvidenceReceipt, d as SequentialObservation, dt as isIndependentEvidence, f as SequentialPairedGate, ft as verifyEvidenceReceipt, g as sequentialPairedGate, h as sequentialDecide, i as PairedHoldout, it as CreateEvidenceReceiptInput, j as PairedArmRow, jt as eProcess, k as PairArmsResult, kt as EProcessState, lt as EvidenceReceiptVerification, n as HeldoutSignificance, nt as CampaignEvidenceContext, o as heldoutSignificance, ot as EvidenceAuthorityKind, p as SequentialPairedGateOptions, r as HeldoutSignificanceOptions, rt as createCampaignEvidenceReceipt, s as pairHoldout, st as EvidenceBinding, u as SequentialGateDecision, ut as createEvidenceReceipt, v as HypothesisResult, w as verifyManifest, wt as FinalEvidenceRecord, x as hashJson, xt as FinalEvidenceLedger, y as SignedManifest, yt as FinalEvidenceConflictError, z as PowerPreflightOptions, zt as pairedRiskDifferenceExact } from "../statistical-heldout-C9AbgREN.js";
+import { c as BOOTSTRAP_GATE_MIN_N, l as PairedBootstrapOptions, m as pairedBootstrap, u as PairedBootstrapResult } from "../paired-promotion-decision-CQMJ5xGN.js";
 import { a as requiredPairedSampleSize, i as pairedMde, n as mcnemarPower, o as requiredSampleSize, r as mcnemarRequiredN, t as mulberry32 } from "../random-DGEyr3zG.js";
 import { at as summarizeEvaluationUnits, it as defineEvaluationClaim, nt as EvaluationClaim, rt as EvaluationUnitSummary } from "../search-ledger-types-p2xKfiDJ.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 { a as PairedEvalueStep, i as PairedEvalueSequence, o as SequentialCrossingHorizon, r as PairedEvalueOptions, s as SequentialCrossingHorizonOptions, u as pairedEvalueSequence } from "../sequential-KwGspfeR.js";
+import { a as JsonValue, i as EvidenceRecord, n as IntervalSpec, r as computeInterval, t as ComputedInterval } from "../interval-ohuOJurX.js";
 import { z } from "zod";
+//#region src/experiment/ast/predicate.d.ts
+/**
+ * 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`. */
+export declare function readField(record: EvidenceRecord, path: string): unknown;
+//#endregion
+//#region src/experiment/ast/validity.d.ts
+/** 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;
+  /** Minimum worthwhile effect; must be represented exactly in effectGrid. */
+  minimumEffect: number;
+  effectGrid: number[];
+  sim: {
+    trials: number;
+    resamples: number;
+    seed: number;
+  };
+} | {
+  kind: 'identity';
+  field: 'served-model';
+  op: 'basename-eq';
+  onFail: 'abort';
+};
+interface ValidityGateResult {
+  id: string;
+  passed: boolean;
+  evidence: JsonValue;
+}
+/**
+ * The design's power at minimumEffect must reach the registered target.
+ * The curve must cover the registered effect grid exactly — a curve
+ * computed on a different grid is different evidence and is refused.
+ */
+export declare function evaluatePowerFloorGate(id: string, gate: Extract<ValidityGate, {
+  kind: 'power-floor';
+}>, curve: readonly {
+  effect: number;
+  power: number;
+}[]): ValidityGateResult;
+//#endregion
+//#region src/experiment/ast/budget.d.ts
+/** 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[];
+}
+/**
+ * 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;
+}
+interface NLadderProjection {
+  chosenN: number | null;
+  projections: {
+    n: number;
+    projectedUsd: number;
+    affordable: boolean;
+  }[];
+  refusal: null | {
+    onExhaust: 'refuse-report-projection';
+    reason: string;
+  };
+}
+/** Arm budget matching as a refusal, not prose. Verified by `verifyMatchedBudgets`. */
+interface MatchedBudgetRule {
+  measure: 'realized-tokens';
+  tolerance: number;
+  onFail: 'refuse-contrast';
+}
+//#endregion
+//#region src/experiment/ast/decision.d.ts
+/** 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>;
+}
+export 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[];
+}
+export declare function executeDecisionRule(rule: DecisionRule, evidence: DerivedQuantities): DecisionOutcome;
+//#endregion
+//#region src/experiment/ast/estimand.d.ts
+/** 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;
+}
+//#endregion
+//#region src/experiment/ast/reissue.d.ts
+/** 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';
+//#endregion
+//#region src/experiment/ast/selection.d.ts
+/**
+ * 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';
+  };
+};
+//#endregion
 //#region src/experiment/budget.d.ts
-/** Arms whose realized budgets diverge past the registered tolerance. */
-export declare class MatchedBudgetError extends CaptureIntegrityError {}
 interface ArmRealizedBudget {
   armId: string;
   /** Realized prompt + completion tokens the arm actually consumed. */
@@ -39,8 +359,6 @@ export declare function verifyMatchedBudgets(rule: MatchedBudgetRule, arms: read
 export declare function assertMatchedBudgets(rule: MatchedBudgetRule, arms: readonly ArmRealizedBudget[]): MatchedBudgetVerdict;
 //#endregion
 //#region src/experiment/funnel.d.ts
-/** A funnel stage gained rows, double-counted them, or failed to reconcile. */
-export declare class FunnelIntegrityError extends CaptureIntegrityError {}
 interface FunnelStageCount {
   id: string;
   entering: number;
@@ -92,8 +410,6 @@ export declare function buildFunnel(input: {
     count: number;
   }[];
 }): ExperimentFunnel;
-/** A chain that does not add up is a broken denominator, so this throws. */
-export declare function assertFunnelReconciles(funnel: ExperimentFunnel): void;
 interface AdmissionExecution {
   funnel: ExperimentFunnel;
   survivors: EvidenceRecord[];
@@ -121,8 +437,6 @@ export declare function composeFunnels(first: ExperimentFunnel, second: Experime
 export declare function renderFunnelTable(funnel: ExperimentFunnel): string;
 //#endregion
 //#region src/experiment/define.d.ts
-/** A sealed experiment whose digest no longer matches its spec. */
-export declare class SealIntegrityError extends ValidationError {}
 interface ArmSpec {
   id: string;
   role: 'treatment' | 'control';
@@ -233,7 +547,7 @@ export declare function amendExperiment(sealed: SealedExperiment, amendment: {
 /** True when the supported seal matches its canonical spec. */
 export declare function verifySealedExperiment(sealed: SealedExperiment): Promise<boolean>;
 /** Evidence a gate executor consumes, discriminated to match the gate kind. */
-type GateEvidence = {
+type ExperimentGateEvidence = {
   kind: 'oracle-determinism';
   repsByState: Record<string, readonly boolean[]>;
 } | {
@@ -271,9 +585,9 @@ interface RegisteredExperiment {
     idField: string;
   }): string[];
   /** Evaluate a registered validity gate on evidence of the matching kind. */
-  gate(name: string, evidence: GateEvidence): GateResult;
+  gate(name: string, evidence: ExperimentGateEvidence): ValidityGateResult;
   /** Evaluate the registered halt rule over gate results. */
-  halt(gates: readonly GateResult[]): HaltOutcome;
+  halt(gates: readonly ValidityGateResult[]): HaltOutcome;
   /** Execute the registered uniform-pass budget schedule. */
   runUniformPassBudget(measuredPassCosts: readonly number[]): UniformPassSchedule;
   /** Project the registered n-ladder budget. */
@@ -357,24 +671,8 @@ export declare const evidenceRegistryRecordSchema: z.ZodObject<{
   notes: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type EvidenceRegistryRecord = z.infer<typeof evidenceRegistryRecordSchema>;
-/** Parse one record; throws with the zod issue list on any violation. */
-export declare function parseEvidenceRegistryRecord(raw: unknown): EvidenceRegistryRecord;
-/**
- * Validate a set of records as one registry: every record parses, ids are
- * unique, and every `supersedes` target exists. Returns records sorted in
- * the registry's canonical order (trust ladder, then date desc, then id).
- */
-export declare function validateEvidenceRegistry(raws: readonly unknown[]): EvidenceRegistryRecord[];
-/**
- * Render the registry's human index from records. Deterministic: identical
- * records always produce identical output, so a byte diff against the
- * committed index is the freshness check. No clocks, no environment.
- */
-export declare function renderEvidenceIndex(raws: readonly unknown[]): string;
 //#endregion
 //#region src/experiment/power.d.ts
-/** A design refused at configuration time, before any spend. */
-export declare class DesignRefusalError extends ValidationError {}
 interface ClusteredPowerOptions {
   /** Rows per independent cluster, e.g. [6, 3, 3, 2]. */
   clusterSizes: number[];
@@ -664,5 +962,5 @@ interface ProspectiveCanaryJoinInput {
  */
 export declare function joinProspectiveCanaryReceipts(input: ProspectiveCanaryJoinInput): CanaryObservation[];
 //#endregion
-export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type CanaryArm, type CanaryAssignmentReceipt, type CanaryCohortReceipt, type CanaryCohortVerifier, type CanaryObservation, type CanaryRefusal, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, EVIDENCE_RECEIPT_VERSION, 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 ExperimentFunnel, type ExperimentSpec, FinalEvidenceConflictError, FinalEvidenceError, type FinalEvidenceLedger, type FinalEvidenceMeasurement, type FinalEvidenceOutcome, type FinalEvidenceRecord, type FinalEvidenceReservation, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type GateEvidence, type GateResult, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, type IntervalSpec, type JsonValue, 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 ProspectiveCanaryAssignment, type ProspectiveCanaryBilling, type ProspectiveCanaryExecution, type ProspectiveCanaryJoinInput, type ProspectiveCanaryOutcome, type RandomizedCanaryDecision, type RandomizedCanaryRule, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, type SealedExperiment, type SealedRandomizedCanaryRule, 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, benjaminiHochberg, bonferroni, buildEvidenceVector, classifyReissue, comparePairedArms, computeEstimand, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, eProcess, evaluateCondition, evaluateHaltRule, evaluateHypothesis, evaluateIdentityGate, evaluateOracleDeterminismGate, evaluatePopulationReproducibilityGate, evaluatePowerFloorGate, evaluatePredicate, evaluateProvenanceGate, executeDecisionRule, hashJson, heldoutSignificance, holm, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, powerPreflight, projectNLadderBudget, readField, requiredPairedSampleSize, requiredSampleSize, runSelectionRule, runUniformPassBudget, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, verifyEvidenceReceipt, verifyManifest, wilson };
+export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type CanaryArm, type CanaryAssignmentReceipt, type CanaryCohortReceipt, type CanaryCohortVerifier, type CanaryObservation, type CanaryRefusal, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, 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 ExperimentFunnel, type ExperimentGateEvidence, type ExperimentSpec, FinalEvidenceConflictError, FinalEvidenceError, type FinalEvidenceLedger, type FinalEvidenceMeasurement, type FinalEvidenceOutcome, type FinalEvidenceRecord, type FinalEvidenceReservation, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, type IntervalSpec, type JsonValue, 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 ProspectiveCanaryAssignment, type ProspectiveCanaryBilling, type ProspectiveCanaryExecution, type ProspectiveCanaryJoinInput, type ProspectiveCanaryOutcome, type RandomizedCanaryDecision, type RandomizedCanaryRule, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, type SealedExperiment, type SealedRandomizedCanaryRule, type SeedDerivation, type SelectionRule, type SequentialCrossingHorizon, type SequentialCrossingHorizonOptions, type SequentialGateDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SetExpr, type SignFlipFloor, type SignedManifest, type SignedManifestAlgo, type UniformPassDecision, type UniformPassSchedule, type ValidityGate, type ValidityGateResult, benjaminiHochberg, bonferroni, buildEvidenceVector, comparePairedArms, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, eProcess, hashJson, heldoutSignificance, holm, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, powerPreflight, requiredPairedSampleSize, requiredSampleSize, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, verifyEvidenceReceipt, verifyManifest, 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/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts","../../src/experiment/randomized-canary.ts","../../src/experiment/prospective-canary-join.ts"],"mappings":"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UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;;KAIU,wBACV,SAAS,qBACT,UAAU;EAGN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAiB;;UAEN;EACf,MAAM;EACN;EACA;;KAGU;UASK;EACf;EACA;EACA;EACA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,UAAU,OACR;IAEE;IACA;IACA;IACA;;EAGJ;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAqB;IAAa;;EAClC;EACA;IAA0B;IAAa;;EACvC;;EAEA;EACA;EACA;EACA;EACA;EACA,SAAS;;EAET;;;wBAwBc,6BAA6B,eAAe;;wBA6B5C,kCAAkC,eAAe;;wBAiFjD,yBAAyB,MAAM,uBAAuB;;wBAOtD,uBACd,QAAQ,4BACR,QAAQ,qBACR,eAAe,qBACf,cAAc,uBACb;;;;UC3Sc,oCAAoC;EACnD;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;EACA,QAAQ;;EAER;;EAEA;EACA,sBAAsB;EACtB,mBAAmB;EACnB,qBAAqB;EACrB,kBAAkB;;;;;;;wBA4DJ,8BACd,OAAO,6BACN"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/experiment/ast/predicate.ts","../../src/experiment/ast/validity.ts","../../src/experiment/ast/budget.ts","../../src/experiment/ast/decision.ts","../../src/experiment/ast/estimand.ts","../../src/experiment/ast/reissue.ts","../../src/experiment/ast/selection.ts","../../src/experiment/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts","../../src/experiment/randomized-canary.ts","../../src/experiment/prospective-canary-join.ts"],"mappings":"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CA;EACA,KAAK;;UAGU,0BAA0B;;EAEzC;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;;KAIU,wBACV,SAAS,qBACT,UAAU;EAGN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAiB;;UAEN;EACf,MAAM;EACN;EACA;;KAGU;UASK;EACf;EACA;EACA;EACA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,UAAU,OACR;IAEE;IACA;IACA;IACA;;EAGJ;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAqB;IAAa;;EAClC;EACA;IAA0B;IAAa;;EACvC;;EAEA;EACA;EACA;EACA;EACA;EACA,SAAS;;EAET;;;wBAwBc,6BAA6B,eAAe;;wBA6B5C,kCAAkC,eAAe;;wBAiFjD,yBAAyB,MAAM,uBAAuB;;wBAOtD,uBACd,QAAQ,4BACR,QAAQ,qBACR,eAAe,qBACf,cAAc,uBACb;;;;UC3Sc,oCAAoC;EACnD;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;EACA,QAAQ;;EAER;;EAEA;EACA,sBAAsB;EACtB,mBAAmB;EACnB,qBAAqB;EACrB,kBAAkB;;;;;;;wBA4DJ,8BACd,OAAO,6BACN"}