spec-controller 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/mutation-ratchet/report.js

@@ -1,148 +0,0 @@
-/**
- * THE MEASUREMENT — a gate's run, counted out of its mutation report's own mutants
- * (@SCN-RAT-010, 3F-2799).
- *
- * STATED, NEVER INFERRED, AND THAT IS THE WHOLE MODULE. A mutation report groups its mutants by
- * the file they were made in and gives each one a status. The metric scores two of those statuses
- * over four: the kills are the killed and the timed-out, and the population is those plus the
- * survived and the never-covered. Both sets are written down below, member by member, and the four
- * statuses left over — a mutant that would not compile, one that faulted at run time, one the run
- * was told to ignore, and one that never got as far as being tried — are in neither.
- *
- * THE LENIENT READING IS ONE SENTENCE LONG, AND IT IS WRONG. "Everything not detected is
- * undetected" reaches a population without anybody having to write a second set down, and it folds
- * all four of those statuses into the denominator. A mutant that would not compile is not a
- * survivor: nobody's assertion failed to catch it, because there was never anything there to catch.
- * So that reading answers with a score which disagrees with the one the run itself printed —
- * quietly, and in the direction of looking worse — and a reconciler holding a second opinion about
- * the very number it is reconciling has stopped being one. Naming the two sets is what makes that
- * disagreement impossible rather than merely unlikely.
- *
- * AND THE REPORT'S OWN THRESHOLDS ARE NOT READ, WHICH IS THE SAME RULING ONE ARTEFACT FURTHER OUT.
- * A report carries the thresholds its own run was configured against, and reading them would be
- * taking the runner's verdict on its own homework as the measurement. The bar lives in the record
- * (`record.ts`), and the report is only ever asked what happened. Every figure produced here is
- * counted from the mutants; every other number in the document is left where it lies, however
- * conveniently it is shaped.
- *
- * THE COUNTS ARE TAKEN ACROSS THE WHOLE REPORT RATHER THAN A FILE OF IT. The grouping is
- * presentation and nothing more — a gate's population is every mutant under it, wherever the report
- * chose to file it. A counter that stopped at the first file would be green against every report
- * holding exactly one, which is the shape a small fixture takes by default.
- *
- * AND A REPORT THAT CANNOT BE READ, OR THAT HOLDS NO SCORED MUTANT AT ALL, IS REFUSED RATHER THAN
- * SCORED ZERO (@SCN-RAT-009). Zero is a measurement — a run that mutated the scope and killed none
- * of it — and the two must not be spelled the same, because reconciling a zero reaches a regression
- * whose message sends its reader hunting kills that in this case never happened. The refusal comes
- * back as a value rather than a throw, so a caller cannot drop it by forgetting to catch.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The shape read below
- * is the report FORMAT's, which is nobody's installation, and the gate's name arrives from the
- * caller rather than out of the document.
- */
-import { existsSync, readFileSync } from "node:fs";
-/**
- * The statuses that are a kill.
- *
- * A TIMEOUT IS A KILL AND NOT A NEAR-MISS. The mutant changed the code enough that the suite never
- * finished, which is the suite noticing — the same event as an assertion firing, reached by a
- * slower road.
- */
-const DETECTED = ["Killed", "Timeout"];
-/**
- * The statuses that are in the population and are not a kill.
- *
- * NEVER-COVERED IS COUNTED, AND THAT IS THE HALF A LENIENT READER LOSES BY LEAVING IT OUT. A mutant
- * no test reached is one this suite would not have noticed, which is precisely what the metric
- * measures; dropping it from the denominator would score untested code as though it were not there.
- */
-const UNDETECTED = ["Survived", "NoCoverage"];
-/** A refusal, as the value it is. */
-function refused(reason) {
-    return { ok: false, reason };
-}
-/** Whatever an error carries by way of a sentence, whatever kind of thing was thrown. */
-function raisedBy(cause) {
-    return cause instanceof Error ? cause.message : String(cause);
-}
-/** A JSON object — not a list, and not the null a bare `typeof` reads as one. */
-function isMapping(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Every mutant in the report, flattened out of the per-file grouping it arrived in — or `null`
- * where the document holds no grouping to flatten.
- *
- * THE TWO EMPTINESSES ARE NOT THE SAME AND ARE NOT ANSWERED THE SAME. `null` is a document that
- * never had a files section; an empty list is a section that holds no mutant. Told apart, one
- * reader is sent to the shape of the artefact and the other to the sweep that filled it; folded
- * together, whichever sentence was chosen sends half of them somewhere useless.
- */
-function mutantsIn(document) {
-    const files = document["files"];
-    if (!isMapping(files))
-        return null;
-    return Object.values(files).flatMap((file) => {
-        const mutants = isMapping(file) ? file["mutants"] : undefined;
-        return Array.isArray(mutants) ? mutants : [];
-    });
-}
-/** How many of these mutants carry a status the given set names. */
-function countOf(mutants, statuses) {
-    return mutants.filter((mutant) => statuses.includes(mutant.status)).length;
-}
-/**
- * Count a gate's measurement out of its report's text, or say why there is not one.
- *
- * THE GATE IS THE CALLER'S WORD FOR IT. A report says which files were mutated and nothing about
- * which gate was being run, so a name taken from the document would be a name this module invented.
- *
- * AND SO IS THE PATH, WHICH IS CARRIED PURELY SO A REFUSAL CAN NAME IT — the same reason
- * `parseGateRecords` carries the record file's name. Text has no path of its own, and "no
- * measurement" over a path nothing writes to and "no measurement" over a sweep that never ran are
- * the same sentence with entirely different fixes.
- */
-export function measurementFromReport(gate, text, reportPath) {
-    let document;
-    try {
-        document = JSON.parse(text);
-    }
-    catch (cause) {
-        return refused(`the report at ${reportPath} is not readable JSON: ${raisedBy(cause)}`);
-    }
-    if (!isMapping(document)) {
-        return refused(`the report at ${reportPath} is not a mutation-report document.`);
-    }
-    const mutants = mutantsIn(document);
-    if (mutants === null) {
-        return refused(`the report at ${reportPath} holds no files section.`);
-    }
-    const detected = countOf(mutants, DETECTED);
-    const undetected = countOf(mutants, UNDETECTED);
-    if (detected + undetected === 0) {
-        return refused(`the report at ${reportPath} holds no scored mutant — the gate measured nothing.`);
-    }
-    return { ok: true, measurement: { gate, detected, total: detected + undetected } };
-}
-/**
- * Read a gate's measurement off the tree, refusing an absent report by the path it was sought at.
- *
- * THE PATH ARRIVES RESOLVED, AND THAT IS THE WHOLE OF THIS MODULE'S OPINION ABOUT WHERE A TREE IS.
- * A reader that joined a root of its own — its own installed location, or wherever the process
- * happened to start — is correct only while those coincide with the caller's, which they stop
- * doing the moment this ships as something another repository installs.
- */
-export function readMutationReport(gate, reportPath) {
-    if (!existsSync(reportPath)) {
-        return refused(`no report at ${reportPath} — the gate produced no score, or never ran.`);
-    }
-    let text;
-    try {
-        text = readFileSync(reportPath, "utf8");
-    }
-    catch (cause) {
-        return refused(`the report at ${reportPath} could not be read: ${raisedBy(cause)}`);
-    }
-    return measurementFromReport(gate, text, reportPath);
-}
-//# sourceMappingURL=report.js.map

package/dist/mutation-ratchet/report.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"report.js","sourceRoot":"","sources":["../../src/mutation-ratchet/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAmBnD;;;;;;GAMG;AACH,MAAM,QAAQ,GAAsB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,UAAU,GAAsB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;AAOjE,qCAAqC;AACrC,SAAS,OAAO,CAAC,MAAc;IAC7B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAC/B,CAAC;AAED,yFAAyF;AACzF,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED,iFAAiF;AACjF,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,QAAiC;IAClD,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAChC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC3C,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9D,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAE,OAAmC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5E,CAAC,CAAC,CAAC;AACL,CAAC;AAED,oEAAoE;AACpE,SAAS,OAAO,CAAC,OAAgC,EAAE,QAA2B;IAC5E,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY,EACZ,IAAY,EACZ,UAAkB;IAElB,IAAI,QAAiB,CAAC;IACtB,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,OAAO,CAAC,iBAAiB,UAAU,0BAA0B,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACzF,CAAC;IACD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,OAAO,OAAO,CAAC,iBAAiB,UAAU,qCAAqC,CAAC,CAAC;IACnF,CAAC;IACD,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IACpC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO,OAAO,CAAC,iBAAiB,UAAU,0BAA0B,CAAC,CAAC;IACxE,CAAC;IACD,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAChD,IAAI,QAAQ,GAAG,UAAU,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO,OAAO,CAAC,iBAAiB,UAAU,sDAAsD,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,UAAU,EAAE,EAAE,CAAC;AACrF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY,EAAE,UAAkB;IACjE,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC5B,OAAO,OAAO,CAAC,gBAAgB,UAAU,8CAA8C,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,IAAY,CAAC;IACjB,IAAI,CAAC;QACH,IAAI,GAAG,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,OAAO,CAAC,iBAAiB,UAAU,uBAAuB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACtF,CAAC;IACD,OAAO,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;AACvD,CAAC"}

package/dist/mutation-ratchet/verdict.d.ts

@@ -1,177 +0,0 @@
-/**
- * THE VERDICT — what a gate's run turned out to be, reconciled against the record it last banked
- * (@SCN-RAT-004, 3F-2794; @SCN-RAT-005, 3F-2795; @SCN-RAT-006, 3F-2796; @SCN-RAT-007, 3F-2797;
- * @SCN-RAT-008, 3F-2798; @SCN-RAT-016, 3F-2809).
- *
- * A BAR CAN ONLY ASK WHETHER ONE NUMBER FELL, AND THE INTERESTING QUESTION IS WHY. A mutation score
- * is detected over total, so it drops for two entirely unrelated reasons: a mutant this suite used
- * to kill now survives, which is the fault the gate exists for; or new mutable code arrived carrying
- * survivors with it, which is no fault at all. `record.ts` keeps the two counts apart so that this
- * module can tell those apart — and telling them apart is the whole product.
- *
- * THE KILLS ARE ASKED ABOUT FIRST, AND ASKED ABOUT ALONE. A run that loses kills WHILE its mutant
- * population grows is the shape every looser reading gets wrong. The growth is a true fact about
- * that run and innocent on its own, so a reconciler that notices it before it counts the kills
- * answers with the innocent half — the score fell, the population explains why, nobody looks any
- * further and a real regression ships. So the count comparison is the first thing this module does,
- * and the population's movement is never allowed to be the answer while a kill is missing.
- *
- * AND INSIDE THAT FIRST COMPARISON, THE POPULATION'S DIRECTION DECIDES WHICH RED IS PRINTED. A
- * population that held still or grew is what licenses the regression's sentence: nothing left the
- * scope, so the kills that vanished were lost. A population that SHRANK removes that licence, and
- * `population-shrank` says so rather than asserting it anyway — removing one killed mutant, and
- * removing one survivor beside a weakened assertion, move the two counts identically, and no
- * arithmetic over two whole numbers tells them apart (@SCN-RAT-016). Both readings are red and
- * both stop the gate; only the sentence differs, and the sentence is the whole point.
- *
- * AND THE SCORE HAS EXACTLY ONE JOB, WHICH IS THE SECOND COMPARISON AND NOT THE FIRST. Once the
- * kills are known to have held, the run either scored below what the record banked or it did not,
- * and only the first of those is a population that grew: a run whose kills ROSE far enough carries
- * its growth without any drop at all, and is an improvement rather than this. So the growth is not
- * what is asked about — the fallen score is, and the growth follows from it, because a run that
- * lost no kills can only score lower by measuring more mutants. That is the whole of what the score
- * is allowed to decide here, and it is why it is asked second (@SCN-RAT-006).
- *
- * THE FLOOR IS STATED, NEVER CONSULTED. `floorOf` is deliberately absent from every condition here.
- * It is the same bar expressed as a percentage, carried in the message because a reader arriving
- * from the sweep has a percentage in front of them and wants the bar in the units they are already
- * holding. The enforcement is the count comparison above it. The two agree exactly while the
- * population holds still and part company the moment it moves, so reading the floor AS the gate
- * would put the judgement back on the score — the confusion the counts model exists to prevent.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The gate's name
- * arrives on the record and on the measurement, both of them the caller's own words.
- */
-import { type GateRecord } from "./record.js";
-/**
- * One gate's measured run, in the same two counts the record is kept in.
- *
- * THE SAME PAIR AS THE RECORD, AND THAT IS WHAT MAKES THE COMPARISON POSSIBLE. A measurement that
- * arrived as a score would already have folded the two events this module exists to separate into
- * one number, before anything here could look at it.
- */
-export interface MutationMeasurement {
-    /** The gate this run measured, as the caller names it. */
-    readonly gate: string;
-    /** Mutants the suite detected. */
-    readonly detected: number;
-    /** Every mutant the gate measured, detected or not. */
-    readonly total: number;
-}
-/**
- * What a run turned out to be.
- *
- * `regression` IS THE ONE DECIDED ON KILLS, which is what makes it immune to the population moving,
- * and `within-slack` (@SCN-RAT-005) is its neighbour on the other side of the same comparison — the
- * two share one boundary and neither can pin it alone. `population-grew` (@SCN-RAT-006) is the third
- * built, and the first decided on anything but kills — it is the drop a bar shaped like a score
- * cannot express, and the reason the record keeps two counts rather than one. `unrecorded-improvement`
- * (@SCN-RAT-007) is the fourth, and the only RED one not decided on kills — it is the clause that
- * turns a ceiling into a ratchet, and without it every other arm here is a bar that quietly drifts
- * away from the tree it is meant to be holding. `at-baseline` (@SCN-RAT-008) is the fifth and the
- * one that CLOSES the set: it is what is left once those four have each declined a run, so from it
- * on there is no measurement this module can be handed that it cannot answer. `population-shrank`
- * (@SCN-RAT-016) is the sixth built and `population-grew`'s twin on the other side of the same
- * movement: it shares `regression`'s condition exactly and parts from it on the population's
- * direction alone, because the sentence `regression` is allowed to say is licensed by nothing
- * having left the scope. The last member sits
- * outside the comparison entirely — `no-measurement` (@SCN-RAT-009) is reached from a report that
- * holds nothing, before there are two counts to reconcile at all.
- */
-export type MutationVerdictKind = "no-measurement" | "regression" | "population-shrank" | "within-slack" | "population-grew" | "unrecorded-improvement" | "at-baseline";
-/**
- * A verdict: whether the run stands, and the line its reader gets.
- *
- * THE MESSAGE IS NOT DECORATION. A verdict that reds without saying which kills went missing, what
- * allowance they were measured against, and what to do next is a red somebody widens the bar to
- * clear, because widening is cheaper than a hunt with no starting point.
- */
-export interface MutationVerdict {
-    readonly kind: MutationVerdictKind;
-    /** Whether the run stands. */
-    readonly ok: boolean;
-    /** The line its reader gets, carrying every figure the verdict was reached from. */
-    readonly message: string;
-}
-/**
- * The refusal, as a verdict (@SCN-RAT-009, 3F-2800).
- *
- * IT SITS OUTSIDE `verdictFor` BECAUSE IT IS REACHED BEFORE THERE ARE COUNTS TO RECONCILE. Every
- * arm of that function compares two pairs of whole numbers; this one is what a caller has instead
- * of a pair, so handing it a fabricated one — a zero, most temptingly — would put a real verdict's
- * name on a run nobody measured.
- *
- * AND IT IS RED. A sweep that did not run produced no evidence about the tree, and a reconciler
- * that shrugs at no evidence reports success for a run that measured nothing: the build green, the
- * report absent, and the two facts never meeting.
- *
- * @param gate the gate that was to have been measured, as the caller names it
- * @param reason why there is no measurement, naming the path it was sought at
- */
-export declare function noMeasurement(gate: string, reason: string): MutationVerdict;
-/**
- * Reconcile one gate's run against the bar its record states.
- *
- * INSIDE THAT FIRST COMPARISON, `total` DECIDES WHICH RED IS PRINTED, AND IT IS ASKED THERE RATHER
- * THAN BESIDE IT. The kills must already have fallen past the allowance before the population's
- * direction is consulted at all, so a run that lost no kills is not either red however far its
- * population fell, and a run that lost a kill the allowance covers is the pass below whichever way
- * its population moved. What the direction settles is only which sentence a run that has already
- * failed on kills is told: held still or grew licenses `regression`'s claim that a mutant this
- * suite used to kill now survives, because nothing left the scope; SHRANK does not, and
- * `population-shrank` says the two look identical from here instead (@SCN-RAT-016).
- *
- * THE COUNT COMPARISON IS FIRST, AND IT IS ON `detected` ALONE. Everything below it in this
- * reconciler will be a question about the score, and the score cannot separate a lost kill from a
- * grown population — so the one verdict that must not be reachable through the score is settled
- * before the score is consulted at all. A run that loses kills and grows its population at the same
- * time is named as the regression it is, rather than as the growth that would explain it away.
- *
- * `floorOf` IS DELIBERATELY ABSENT FROM THIS CONDITION. It is the same bar as a percentage, carried
- * in the message for its reader; the enforcement is the comparison above. The two agree exactly
- * while the population holds still, so a reconciler judging on the floor greens every example of
- * this Rule and reds a grown population that lost nothing — which is the confusion the counts model
- * exists to prevent.
- *
- * THE SECOND COMPARISON IS THE SAME BOUNDARY FROM THE OTHER SIDE. A run that lost kills the
- * allowance covers is a pass, and `D == D0 - slack` is the last measurement it covers. The two arms
- * meet at that one mutant and neither pins it alone: every run the arm above judges is a regression
- * under `<` and `<=` alike, and under an allowance consulted or forgotten alike. It is the pass at
- * the boundary that reds a comparison widened by one, and the pass one kill inside it that reds a
- * comparison that dropped the allowance — which is why both examples are asserted and not one.
- *
- * THE THIRD COMPARISON IS THE FIRST ONE THE SCORE IS ALLOWED INTO, AND ONLY BECAUSE THE KILLS ARE
- * ALREADY KNOWN TO HAVE HELD. Below this line nothing that used to die is surviving, so a fallen
- * score has exactly one remaining cause — the run measured more mutants — and naming it is safe in
- * a way it was never safe above. The order is the guarantee: the same growth that explains a drop
- * here would have explained away a regression two comparisons ago, which is why it is not consulted
- * until there is no regression left for it to explain away.
- *
- * A RUN THAT LOST A KILL THE ALLOWANCE COVERS **WHILE** ITS POPULATION GREW IS THE ARM ABOVE, NOT
- * THIS ONE, and that is a ruling rather than an accident of ordering (@SCN-RAT-005 surfaced the
- * shape and asserted neither way; ruled on 2026-08-26 under @SCN-RAT-006). Its score can be far
- * below the floor, so the growth is there to be reached for. But this verdict's load-bearing
- * sentence is that no mutant which used to die now survives, and of that run the sentence is false;
- * answering with the growth would print it anyway. The allowance was also SPENT, and an allowance
- * spends in public or it does not spend at all — so the pass that must fire is the one naming the
- * kills lost and the record's own reason for tolerating them. Nothing is lost by the ruling: the
- * growth stays legible in the count pairs that pass already carries.
- *
- * AND THE LAST ARM TAKES NO CONDITION, WHICH IS WHAT MAKES THIS FUNCTION TOTAL (@SCN-RAT-008). The
- * three comparisons above leave exactly one case: kills that held, and a score that neither fell
- * nor rose. `scoreFellFrom` and `scoreRoseFrom` are the same two cross-multiplied products read the
- * two ways round, so between them they claim every inequality and EQUAL is what is left — and equal
- * is a fact about the ratio rather than about the pair, which is why the fall-through is written
- * with no condition at all. Narrowing it to "the same two counts" would leave a run of 4350/4486
- * against a record of 2175/2243 with no verdict, and a reconciler that can be handed a measurement
- * it does not answer is one whose callers must handle a case nobody named. There is no default
- * green here either: `at-baseline` is a verdict somebody wrote, with its own scenario and its own
- * message, not a shrug at the end of a chain of `if`s.
- *
- * @param record the gate's last-banked counts and the allowance stated against them
- * @param measurement the run being judged, in the same two counts
- * @param bankCommand the caller's own words for banking a measurement, carried into the verdicts
- *   that ask for it — never a script name this module invents (@SCN-RAT-006, 3F-2796)
- */
-export declare function verdictFor(record: GateRecord, measurement: MutationMeasurement, bankCommand: string): MutationVerdict;
-//# sourceMappingURL=verdict.d.ts.map

package/dist/mutation-ratchet/verdict.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/verdict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,YAAY,GACZ,mBAAmB,GACnB,cAAc,GACd,iBAAiB,GACjB,wBAAwB,GACxB,aAAa,CAAC;AAElB;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAkQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAW3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,mBAAmB,EAChC,WAAW,EAAE,MAAM,GAClB,eAAe,CAgBjB"}