@mark1russell7/rigor-bench 0.2.12 → 0.2.14

package/README.md

@@ -206,6 +206,62 @@ const shards = controlFactor(shardRows);
 - The fields `low` and `high` are the quartiles of the ratios. A wide spread means that one factor does not explain the load.
 - The function refuses a group with fewer usable keys than `minPairs`. The default is 5.
 
+## Check that a trick does not buy a measure
+
+A control is a strategy made to win one measure and nothing else. A real entry can win that measure by the same trick. So `checkMeasures` reads the controls of a bench, and `winClaim` tells a page what to show beside a win. Each project keeps its own controls.
+
+```ts
+import { checkMeasures, winClaim } from "@mark1russell7/rigor-bench";
+
+const check = checkMeasures(rows, {
+  asOf: "2026-11-05",
+  controls: ["only-fill"],
+  rules: [
+    { measure: "fill", sense: "higher", controls: ["only-fill"], partners: ["order"] },
+    { measure: "order", sense: "lower", controls: [], partners: [], noControl: { because: "The control has no code yet.", until: "2026-11-20" } },
+  ],
+});
+if (check.findings.length > 0) process.exitCode = 1;
+const claim = winClaim(check, "fill", "my-entry");
+```
+
+Each row has a `measure`, a `group`, a `key` and a `value`. The optional fields are `censored`, `method` and `stratum`. The function throws a `RangeError` for a repeat of a measure, a group and a key. The caller states how repeats reduce to one row.
+
+- **Beats:** the Holm-corrected sign test passes. With a `resolution`, the median paired difference is also over it. Without one, the output says `test only`.
+- **A control wins** when no real entry beats it. A tie counts for the control.
+- **A control loses a partner** when one real entry beats it on that partner, at the level divided by the count of partners. One passed partner clears `uncaught`, so each partner is one more chance.
+- **Families:** one Holm family holds one control on one measure, over all real entries and all strata. A second family holds the same tests in the other direction, and `beatsEntries` of `of` gives its count. One family holds the spread of one measure.
+- **Too few:** the need comes from `signTestPower` at the level of that family, over the untied keys. So 31 real entries need 10 untied keys at the level 0.05. A test under the need beats nothing. A pair with enough keys that ties reads as equal.
+- **Strata:** the keys of one stratum come from one family of inputs, so they are not independent draws. A result is about these keys.
+
+Strata make a family larger, so each stratum needs more keys:
+
+| The family | Tests | Sides | Untied keys for each test |
+| --- | --- | --- | --- |
+| 31 entries, no strata | 31 | 1 | 10 |
+| 14 entries, 15 strata | 210 | 1 | 13 |
+| 30 entries, 20 strata | 600 | 1 | 14 |
+| The spread of 31 entries, 20 strata | 9,300 | 2 | 19 |
+
+So a stratum of 10 keys reads `too-few` by construction. That result is true, and the check keeps it. A caller gets the pooled read when the rows have no `stratum`. A sign test needs independent signs and not equal distributions, so a read can pool the keys of different families. A bench reads pooled for its gate, and by stratum where the keys are sufficient.
+
+Each finding fails a gate, and each one carries its tests with `n`, `ties`, `p` and the Holm result.
+
+| Finding | Meaning |
+| --- | --- |
+| `uncaught` | A control wins the measure and loses no partner. The trick pays. |
+| `weak-control` | A control with power beats no real entry on its measure, in any stratum. The trick buys nothing. A control in second place that beats other entries is not weak. |
+| `censored-win` | A control wins with more censored keys than an entry it is read against. |
+| `no-spread` | No pair of real entries separates on the measure. |
+| `too-few` | No read of the controls or of the spread has enough keys. A control that wins and has a partner with too few keys also gives it. A small stratum alone gives only a row. |
+| `mixed-method` | The rows mix methods, or a method and no method. The check has no read of the measure. |
+| `no-rule` | The rows hold a measure with no rule. |
+| `no-rows` | A rule names a measure or a control with no rows. This does not read as "not beaten". |
+| `no-control` | A rule has no control and no `noControl`. |
+| `control-late` | The date of `noControl` is before `asOf`. |
+
+`winClaim(check, measure, entry, stratum)` gives `alone`, `show`, `likeControl`, `censored` and `open`. The fields are about this entry. The field `likeControl` is true when this entry does not beat a control on the measure and beats it on no partner. A win by another entry clears nothing. The field `alone` is true only when this entry itself beats each control on the measure, so a measure with no control is not `alone`.
+
 ## The fresh runner
 
 The entry `@mark1russell7/rigor-bench/fresh` starts child processes, so it is for Node only. The root entry stays free of `node:child_process`.
@@ -265,7 +321,7 @@ const result = await superviseCases({
 The child calls `caseProgress(file).start(id, stage)` before each stage, and `end(id)` after the result is on the disk.
 
 - A stage over its budget gives `over-budget`. This time is a lower bound, so a statistic treats it as censored, not as a value. The next child runs the cases that are left.
-- After 2 overruns in one group (the option `overruns`), each other case of the group gives `not-run`, with the ids of the 2 overruns. An overrun is measured, and a skip is not. Keep these tags different.
+- After 2 overruns in one group (the option `overruns`), each other case of the group gives `not-run`, with the ids of the 2 overruns. When cases have a `rank`, for example an input size, the count is for each rank. The stop is for that rank and above, and a smaller rank goes on. An overrun is measured, and a skip is not. Keep these tags different.
 - An overrun counts for the group of its stage only. A slow router thus does not count against the packer of its cases.
 - A case in `done` does not run, so a resume runs no case two times.
 - The option `earlier` takes the ends of a stopped run. Its overruns count for their groups, so a stop and a resume give the same ends as a run with no stop. Keep each case in `cases`, and put the ids of the finished cases in `done`.

package/build/index.d.ts

@@ -1,5 +1,5 @@
 import { a as checkPairedTime, i as caseRatios, n as CaseRatio, o as firstArm, r as PairedTime, t as Arm } from "./paired.js";
-import { BootstrapOptions, Comparison, Interval } from "@mark1russell7/rigor-statistics";
+import { BootstrapOptions, Comparison as Comparison$1, Interval } from "@mark1russell7/rigor-statistics";
 /** One value of one build on one case. The value is finite and 0 or more. */
 interface BudgetRound {
   /** The name of the case: one input of the bench. */
@@ -498,7 +498,7 @@ interface TimeVerdict {
    * The counts of the cases out of the band, or undefined without a band.
    * The comparison uses the value `1 + log(ratio)` of each case and the noise of the band, so its two sides are the ends of the band.
    */
-  readonly comparison: Comparison | undefined;
+  readonly comparison: Comparison$1 | undefined;
   /** The facts of the pooled band. The verdict has this field only with the option `pool`. */
   readonly pool?: PoolFacts;
   /** The noise cap. The verdict has this field only with the option `noiseCap`. */
@@ -698,6 +698,226 @@ interface RunPairs {
  * It balances the records of each pair with `balanceOrders` first. It refuses an `aaPair` that the run does not have.
  */
 export declare function armVerdicts(run: RunPairs, aaPair: string, options?: VerdictOptions): Record<string, TimeVerdict>;
+/** One value of one measure, for one entry and one input. */
+interface MeasureRow {
+  /** The name of the measure. */
+  readonly measure: string;
+  /** The name of the entry: a real strategy or a control. */
+  readonly group: string;
+  /** The name of the input. Equal keys in two groups name equal work, so the two values make a pair. */
+  readonly key: string;
+  /** The value. It is finite. No test reads the value of a censored row. */
+  readonly value: number;
+  /** This field is true when the entry did not finish this input, for example over its budget. */
+  readonly censored?: boolean;
+  /** The way that the value was made, for example a sample or a full count. Two ways in one measure do not compare. */
+  readonly method?: string;
+  /** The family of the input. A key has one stratum in all its rows. Rows without a stratum make one group. */
+  readonly stratum?: string;
+}
+/** A measure with no control yet: the reason and the date of the control. */
+interface NoControl {
+  /** The reason that the measure has no control at this time. */
+  readonly because: string;
+  /** The date of the control, as `YYYY-MM-DD`. A date before `asOf` gives the finding `control-late`. */
+  readonly until: string;
+}
+/** The rule of one measure. */
+interface MeasureRule {
+  readonly measure: string;
+  /** The direction of a better value. */
+  readonly sense: "higher" | "lower";
+  /** The controls made to win this measure. Each one is in `controls` of the options. */
+  readonly controls: readonly string[];
+  /** The measures that a control of this measure is to lose. Each one has its own rule. */
+  readonly partners: readonly string[];
+  /** The smallest median paired difference that counts. Without it, only the test decides, and the output says so. It has no default. */
+  readonly resolution?: number;
+  /** The reason and the date, for a rule with no controls. */
+  readonly noControl?: NoControl;
+}
+/** The options of `checkMeasures`. */
+interface MeasureCheckOptions {
+  readonly rules: readonly MeasureRule[];
+  /** Each group that is a control. Each other group is a real entry. */
+  readonly controls: readonly string[];
+  /** The date of the check, as `YYYY-MM-DD`. The caller gives it, so the function stays pure. */
+  readonly asOf: string;
+  /** The level of each family of tests. The default is 0.05. */
+  readonly alpha?: number;
+}
+/** One test: `better` beats `other` on the keys that the two finished. */
+interface Comparison {
+  readonly better: string;
+  readonly other: string;
+  readonly stratum: string | undefined;
+  /** The keys that both finished. */
+  readonly shared: number;
+  /** The shared keys with different values. The test reads only these. */
+  readonly n: number;
+  readonly ties: number;
+  /** The keys where `better` has the better value. */
+  readonly wins: number;
+  /** The keys where `other` has the better value. */
+  readonly losses: number;
+  /** The median paired difference over the shared keys, with ties. A positive value favours `better`. */
+  readonly medianDifference: number;
+  /** The p of the sign test. */
+  readonly p: number;
+  /** The p after the Holm correction. */
+  readonly adjusted: number;
+  /** The size of the Holm family. */
+  readonly family: number;
+  /** The least count of untied keys with the power to pass in this family. */
+  readonly needs: number;
+  /** This field is true when `n` is under `needs`. Such a test beats nothing. */
+  readonly tooFew: boolean;
+  /** This field is true when the shared keys reach `needs` and ties took them under it. So the two read as equal, not as unread. */
+  readonly tied: boolean;
+  /** The test passes, and the median difference is over the resolution when the measure has one. */
+  readonly beats: boolean;
+}
+/** The read of one control on one measure and one stratum. */
+interface ControlRead {
+  readonly measure: string;
+  readonly control: string;
+  readonly stratum: string | undefined;
+  /**
+   * The state of the read. `wins`: no real entry with enough pairs beats the control. `beaten`: a real entry beats it.
+   * `too-few`: no real entry has enough shared keys. `no-rows`: no real entry shares a finished key with it.
+   */
+  readonly status: "wins" | "beaten" | "too-few" | "no-rows";
+  /** The real entries with fewer winning keys than the control. It is a plain count with no test. */
+  readonly aheadOf: number;
+  /** One test for each real entry: `better` is the real entry, and `other` is the control. */
+  readonly comparisons: readonly Comparison[];
+  /** The real entries that the control beats by test on this stratum. */
+  readonly beatsEntries: number;
+  /** The tests of the control against the real entries that have power on this stratum. */
+  readonly of: number;
+  /** One test for each real entry: `better` is the control, and `other` is the real entry. This family is apart from `comparisons`. */
+  readonly against: readonly Comparison[];
+}
+/** The counts of one entry on one measure and one stratum. */
+interface EntryCount {
+  readonly group: string;
+  readonly stratum: string | undefined;
+  readonly finished: number;
+  readonly censored: number;
+}
+/** The read of the spread of one measure on one stratum, over the pairs of real entries. */
+interface SpreadRead {
+  readonly stratum: string | undefined;
+  /** The pairs of real entries that share a finished key. */
+  readonly pairs: number;
+  /** The pairs with a test that passes in one direction. */
+  readonly separated: number;
+  /** The pairs with too few shared keys for the test. A pair that ties on enough keys does not count here. */
+  readonly tooFew: number;
+  /** The largest absolute median paired difference of a pair. */
+  readonly widest: number | undefined;
+}
+/** The result of one control and one partner on one stratum. */
+interface PartnerRead {
+  readonly partner: string;
+  /**
+   * `lost`: a real entry beats the control at the level divided by the count of partners. Each partner is one more chance to clear the control.
+   * `not-lost`: no real entry does. `too-few`: no test has the power at that level. `no-rows`: nothing to read.
+   */
+  readonly status: "lost" | "not-lost" | "too-few" | "no-rows";
+}
+/** The result of one control on its measure and one stratum, with its partners. */
+interface GuardRead {
+  readonly control: string;
+  readonly stratum: string | undefined;
+  readonly status: ControlRead["status"];
+  readonly partners: readonly PartnerRead[];
+}
+/** The read of one measure. */
+interface MeasureCheck {
+  readonly measure: string;
+  readonly sense: "higher" | "lower";
+  /** `test only`: a measure with no resolution. `test and resolution`: a measure with one. */
+  readonly basis: "test only" | "test and resolution";
+  /** The only method of the rows. It is undefined when the rows give none. */
+  readonly method: string | undefined;
+  /** This field is true when the rows mix methods. The check then has no read of the measure. */
+  readonly mixed: boolean;
+  readonly guards: readonly GuardRead[];
+  readonly spread: readonly SpreadRead[];
+  readonly entries: readonly EntryCount[];
+  /** The partners that the rule names. */
+  readonly partners: readonly string[];
+  /** The reason and the date, for a measure with no control. */
+  readonly open: NoControl | undefined;
+}
+/** The kind of a finding. Each finding fails a gate. */
+type MeasureFindingKind = "uncaught" | "weak-control" | "censored-win" | "no-spread" | "too-few" | "mixed-method" | "no-rule" | "no-rows" | "no-control" | "control-late";
+/** One finding of the check, with the numbers behind it. */
+interface MeasureFinding {
+  readonly kind: MeasureFindingKind;
+  readonly measure: string;
+  readonly stratum?: string | undefined;
+  readonly control?: string;
+  /** The count of the partners of the rule, for a finding about the partners of a control. */
+  readonly partners?: number;
+  /** The finding in plain words, with its numbers. */
+  readonly text: string;
+  /** The tests behind the finding. */
+  readonly comparisons: readonly Comparison[];
+}
+/** The result of `checkMeasures`. */
+interface MeasureChecks {
+  /** The level of each family of tests. */
+  readonly alpha: number;
+  readonly measures: readonly MeasureCheck[];
+  /** Each read of a control, on its own measures and on their partners. */
+  readonly reads: readonly ControlRead[];
+  readonly findings: readonly MeasureFinding[];
+}
+/** What a page says about the win of one entry on one measure. */
+interface WinClaim {
+  /** This field is true only when a control was read on this measure and this entry beats each control on it. A win by another entry does not count. */
+  readonly alone: boolean;
+  /** The partners that a winning control loses. When this entry does not beat a control that does not win, or with no read of a control, all partners of the rule. */
+  readonly show: readonly string[];
+  /** This field is true when this entry does not beat a control on this measure and beats it on no partner. The win then reads the same as the trick. The status of the control does not change this. */
+  readonly likeControl: boolean;
+  /** The censored keys of this entry and of each control that it does not beat. A page shows them beside the win. */
+  readonly censored: {
+    readonly entry: number;
+    readonly controls: readonly {
+      readonly control: string;
+      readonly censored: number;
+    }[];
+  };
+  /** The reason and the date, for a measure with no control. */
+  readonly open: NoControl | undefined;
+}
+/**
+ * This function reads the controls and the spread of each measure of a bench.
+ *
+ * - A control wins a measure when no real entry beats it on the keys that both finished. A tie counts for the control.
+ * - A real entry beats a control when the Holm-corrected sign test passes and the median paired difference is over the resolution.
+ * - One Holm family holds the tests of one control on one measure over all real entries and all strata.
+ * - One more Holm family holds the tests of one control against the real entries, with the same need and resolution. A control that beats none of them is weak.
+ * - One Holm family holds the tests of the spread of one measure over all pairs of real entries and all strata.
+ * - A test with fewer untied keys than `signTestPower` needs for that family reads `tooFew` and beats nothing.
+ * - A test with enough shared keys and too few untied keys is `tied`. The two entries read as equal, so a constant measure is `no-spread` and not `too-few`.
+ * - A control loses a partner only at the level divided by the count of its partners. One passed partner clears `uncaught`, so each partner is one more chance.
+ *
+ * The function throws a `RangeError` for a value that is not finite, a repeat of measure, group and key, or a key in two strata.
+ * It also throws one for rules that contradict each other.
+ * The rules, the controls and the date are stated, so the result depends only on the arguments.
+ */
+export declare function checkMeasures(rows: readonly MeasureRow[], options: MeasureCheckOptions): MeasureChecks;
+/**
+ * This function tells what a page says about the win of one real entry on one measure.
+ * The claim is about this entry: only this entry beating the control, on this measure or on a partner, clears the entry. A win by another entry clears nothing.
+ * With a stratum, the function reads that stratum. Without one, it reads the rows with no stratum.
+ * The function throws a `RangeError` for a measure with no read and for an entry that the rows do not hold.
+ */
+export declare function winClaim(check: MeasureChecks, measure: string, entry: string, stratum?: string): WinClaim;
 /** The options of a power test. */
 interface PowerOptions {
   /** The count of the cases of the candidate and of the A/A arm. */
@@ -760,5 +980,5 @@ interface Rounds {
  * keeps the work.
  */
 export declare function timeRounds(arms: Readonly<Record<Arm, () => number>>, options: RoundsOptions): Rounds;
-export { type Arm, type Balanced, type Band, type BandKind, type BandOptions, type BudgetLook, type BudgetLooksOptions, type BudgetLooksVerdict, type BudgetMore, type BudgetOptions, type BudgetOutcome, type BudgetResult, type BudgetRound, type BudgetVerdict, type CaseBudget, type CaseInterval, type CaseLimit, type CaseRatio, type ControlFactors, type ControlOptions, type ControlRow, type GroupCounts, type GroupFactor, type JobLimitVerdict, type JobRecords, type JobVerdict, type Ladder, type LadderDimension, type LadderOptions, type LadderVerdict, type LimitOptions, type LimitOutcome, type LimitVerdict, type MeasuredFactor, type MedianBudget, type NoFactor, type NoiseCheck, type PairedTime, type PoolFacts, type PoolOptions, type PooledJob, type PooledLimitVerdict, type PooledRecords, type PooledVerdict, type Power, type PowerOptions, type QuantileBudget, type RateBudget, type Rounds, type RoundsOptions, type RunPairs, type Rung, type RungBudget, type RungEvidence, type RungRecord, type RungVerdict, type TimeOutcome, type TimeVerdict, type VerdictOptions, type VerdictRule, type WorstBudget, caseRatios, checkPairedTime, firstArm };
+export { type Arm, type Balanced, type Band, type BandKind, type BandOptions, type BudgetLook, type BudgetLooksOptions, type BudgetLooksVerdict, type BudgetMore, type BudgetOptions, type BudgetOutcome, type BudgetResult, type BudgetRound, type BudgetVerdict, type CaseBudget, type CaseInterval, type CaseLimit, type CaseRatio, type Comparison, type ControlFactors, type ControlOptions, type ControlRead, type ControlRow, type EntryCount, type GroupCounts, type GroupFactor, type GuardRead, type JobLimitVerdict, type JobRecords, type JobVerdict, type Ladder, type LadderDimension, type LadderOptions, type LadderVerdict, type LimitOptions, type LimitOutcome, type LimitVerdict, type MeasureCheck, type MeasureCheckOptions, type MeasureChecks, type MeasureFinding, type MeasureFindingKind, type MeasureRow, type MeasureRule, type MeasuredFactor, type MedianBudget, type NoControl, type NoFactor, type NoiseCheck, type PairedTime, type PartnerRead, type PoolFacts, type PoolOptions, type PooledJob, type PooledLimitVerdict, type PooledRecords, type PooledVerdict, type Power, type PowerOptions, type QuantileBudget, type RateBudget, type Rounds, type RoundsOptions, type RunPairs, type Rung, type RungBudget, type RungEvidence, type RungRecord, type RungVerdict, type SpreadRead, type TimeOutcome, type TimeVerdict, type VerdictOptions, type VerdictRule, type WinClaim, type WorstBudget, caseRatios, checkPairedTime, firstArm };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/budget.ts","../src/control.ts","../src/ladder.ts","../src/verdict.ts","../src/limit.ts","../src/merge.ts","../src/power.ts","../src/rounds.ts"],"mappings":";;;UAQiB;;WAEN;;WAEA;WACA;;;KAIC;;UAGK;;WAEN;;WAEA;;WAEA;;;UAIM;WACN;;WAEA;;WAEA;WACA;;WAEA;;WAEA;;WAEA;WACA;;WAEA;WACA,SAAS;;WAET;;;UAIM;WACN,SAAS;;WAET;WACA;WACA;WACA;WACA,gBAAgB;;;;;;;;;;;;wBAyDX,cAAc,iBAAiB,eAAe,aAAa,eAAe,SAAS,gBAAgB;;UAyBlG;WACN;WACA;;;;;;qBAOE,uBAAuB;;UAOnB;;WAEN;;WAEA;;WAEA,iBAAiB;;WAEjB;;;UAIM;WACN;WACA;;;UAIM,2BAA2B;;WAEjC;;WAEA,eAAe;;WAEf;;;;;;wBAOK,gBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;wBAoDhC,mBAAmB,iBAAiB,eAAe,aAAa,eAAe,SAAS,qBAAqB;;UCxO5G;;WAEN;;WAEA;;WAEA;;WAEA;;;UAIM;;WAEN;;WAEA;;;UAIM;WACN;;WAEA;;WAEA;;WAEA;;;UAIM,uBAAuB;;WAE7B;;WAEA;WACA;;;UAIM,iBAAiB;WACvB;;WAEA;;;KAIC,cAAc,iBAAiB;;UAG1B;;WAEN;WACA,kBAAkB;;;;;;;;;;;;wBAuFb,cAAc,eAAe,cAAc,UAAS,iBAAsB;;qBC3I7E;;UAGI;WACN;;WAEA;;;UAIM;WACN;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;;UAIM;WACN;WACA;;WAEA;;;UAIM;WACN;WACA;WACA;;WAEA;;WAEA;;;;;;;;;;;;UAaM;WACN;WACA;;WAEA;;WAEA;;WAEA;;WAEA;;;KAIC,aAAa,eAAe,iBAAiB,aAAa;;UAGrD;;WAEN;;WAEA,IAAI,SAAS;WACb,kBAAkB;;WAElB;;WAEA;;;UAIM;WACN,eAAe;;WAEf;WACA,qBAAqB;WACrB,gBAAgB;;;KAIf;WACG;WAAyB;WAA0B,iBAAiB;WAAwB,aAAa;;WACzG;WAA2B;WAA0B;WAAoC;;WACzF;WAAuB;WAA0B;WAA2B;;WAC5E;WAAwB;WAA0B;;;UAGhD;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;WACA,mBAAmB;;;UAIb;WACN;WACA,SAAS;;WAET;;;UAIM;WACN;WACA;WACA;WACA,SAAS;;WAET;WACA,kBAAkB;;WAElB;WACA;WACA;;;UAIM;WACN;;WAEA;;WAEA;;WAEA;;WAEA;WACA,gBAAgB;;;UAIV;;WAEN;;WAEA;;;;;;;wBAkDK,YAAY,QAAQ;;wBAyFpB,YAAY,MAAM,MAAM,QAAQ,wBAAwB,SAAS,gBAAgB;;;;;;wBA6BjF,cAAc,QAAQ,QAAQ,kBAAkB,cAAc,SAAS,gBAAgB;;;;;;KC9T3F;;UAGK;;WAEN,OAAO;;WAEP;;WAEA;;WAEA,YAAY;;;UAIN;;WAEN;WACA,MAAM;;;;;;WAMN;;WAEA;WACA;;WAEA;;;wBAIK,OAAO,aAAa,cAAc,UAAS,cAAmB;;;;;wBAoB9D,SAAS,aAAa,cAAc;;UAWnC;;WAEN,kBAAkB;;WAElB;;WAEA;;;;;WAKA,OAAO,QAAQ;;;UAIT;;WAEN;;WAEA;;WAEA;WACA;;WAEA;;;;;;;;wBASK,WAAW,MAAM,aAAa,iBAAc;;KAmBhD;;;;;;;KAQA;;UAGK,uBAAuB;;WAE7B,OAAO;;;;;WAKP;;;;;;WAMA;;WAEA;;;;;WAKA,OAAO;;;UAID;;WAEN;WACA;;WAEA;;WAEA;;;;;WAKA;;;UAIM;WACN,SAAS;;WAET;WACA,gBAAgB;WAChB,MAAM;;;;;;;WAON,UAAU;;WAEV,MAAM;;;;;WAKN,YAAY;;WAEZ,OAAO;;WAEP,QAAQ;;;;;;;;;;;;;;wBAeH,YAAY,oBAAoB,cAAc,aAAa,cAAc,UAAS,iBAAsB;;;;;;;wBA+CxG,cAAc,UAAS;;UChQtB,qBAAqB;;WAE3B;WACA;;WAEA;;;;;;wBAOK,cAAc,kBAAkB,cAAc,iBAAe;;KAcjE;;UAGK,qBAAqB;;WAE3B;;WAEA;;;;;WAKA;;;UAIM,kBAAkB;;WAExB;;WAEA;WACA,SAAS;;;UAIH;WACN,SAAS;;WAET;WACA;WACA,gBAAgB;;WAEhB,MAAM;;WAEN;;WAEA;;;;;;;;;;wBAWK,aAAa,oBAAoB,cAAc,aAAa,cAAc,SAAS,eAAe;;UCzEjG,SAAS,UAAU;WACzB,SAAS;;WAET;;;;;;;wBAQK,cAAc,UAAU,YAAY,kBAAkB,MAAM,SAAS;;UAkBpE;;WAEN;WACA,oBAAoB;WACpB,aAAa;;WAEb;aAA8B;;;;UAIxB;WACN;WACA,WAAW;WACX,IAAI;;;UAIE;;WAEN,WAAW;;WAEX,IAAI;;WAEJ,eAAe;;WAEf;;WAEA;;;;;;;;wBASK,YAAY,eAAe,eAAe;;UAsEzC;WACN;WACA,SAAS;;;UAIH;;WAEN,SAAS;;WAET,QAAQ;;WAER,eAAe;;WAEf;;WAEA;;WAEA;;WAEA;;;;;;;;wBAWK,cAAc,eAAe,cAAc,UAAS,iBAAsB;;UASzE;WACN;WACA,SAAS;;;UAIH;;WAEN,SAAS;;WAET,QAAQ;;WAER,eAAe;;WAEf;;WAEA;;WAEA;;WAEA;;;;;;;;wBAWK,mBAAmB,eAAe,cAAc,SAAS,eAAe;;UASvE;WACN,OAAO,SAAS,wBAAwB;;;;;;wBAOnC,YAAY,KAAK,UAAU,gBAAgB,UAAS,iBAAsB,eAAe;;UC/NxF;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,UAAU;;;UAIJ;WACN;WACA,UAAU,SAAS,OAAO;;;;;;WAM1B;;;;;;wBAOK,aAAa,SAAS,eAAe;;UClCpC;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;UAIM;WACN,SAAS;;WAET;;WAEA;;;;;;;wBAQK,WAAW,MAAM,SAAS,OAAO,qBAAqB,SAAS,gBAAgB"}
+{"version":3,"file":"index.d.ts","names":["Comparison"],"sources":["../src/budget.ts","../src/control.ts","../src/ladder.ts","../src/verdict.ts","../src/limit.ts","../src/merge.ts","../src/measures.ts","../src/power.ts","../src/rounds.ts"],"mappings":"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"}