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

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

@@ -1,210 +0,0 @@
-/**
- * A GATE'S RECORD — the pair of counts it last banked, and the allowance stated against them
- * (@SCN-RAT-001, 3F-2790).
- *
- * THE RECORD IS TWO COUNTS, NEVER A BARE SCORE, and that is the load-bearing choice this whole
- * module exists to make possible. A mutation score is detected over total, so it falls 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. One number reds on both, and the only cheap way out of a red for the second is to widen
- * the bar — which is how a floor loses its teeth. Keeping `detected` and `total` apart is what
- * lets the verdict tell them apart: kills lost is stated directly, and a growing population moves
- * `total` while leaving `detected` alone.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The record's text
- * arrives as a string and the name it is filed under arrives beside it, because which file holds a
- * project's bars, and what its gates are called, are that project's own facts. This module has an
- * opinion about the SHAPE of a record and none about whose it is.
- *
- * MALFORMED MEANS NO BAR, NEVER A DEFAULTED ONE. Every refusal below is a record a lenient reader
- * answers with a bar nobody wrote — an absent section read as "no gates to enforce", a gate that
- * measured nothing read as scoring zero, an allowance nobody justified read as justified. The bar
- * is then enforced as though somebody had written it, and the only symptom is a build that has
- * quietly stopped being able to red. So each one is refused by name, and the refusal says which
- * record it read and where in that record the fault is (@SCN-RAT-002, 3F-2792).
- *
- * IT IS NOT A STATIC CHECK, and takes no `static-check:` prefix. A static check is a pure function
- * of the checked-out tree; the record this reads feeds a reconciler that judges a MEASUREMENT,
- * which by construction is not in the tree — the standing ruling every scheduled-sweep reader in
- * this portfolio already carries.
- */
-/**
- * The section of a record file that holds every gate's counts.
- *
- * EXPORTED SO THE RECORDER CANNOT HOLD A SECOND COPY OF IT. `ratchet.ts` finds the same section in
- * the same text in order to rewrite two of its lines, and two spellings of one name is the
- * agreeing-until-somebody-edits-one shape this whole library exists to remove.
- *
- * The SECTION name is this module's, and the gate names inside it are the project's. A record file
- * is a project's own document and may hold whatever else that project keeps in it; what this module
- * asks of it is one section, under one name, so a project can file its mutation bars beside the
- * rest of its policy rather than in a file of their own.
- */
-export declare const MUTATION_GATES = "mutation-gates";
-/**
- * The field a refusal names when the fault is the ASK rather than a field of a gate's block — a
- * gate the record does not hold at all.
- *
- * EXPORTED FOR THE SAME REASON AS THE SECTION NAME: `ratchet.ts` refuses the same way when it is
- * asked to raise a gate no block is written for, and a refusal a reader has to recognise in two
- * spellings is one they will eventually parse wrongly.
- */
-export declare const WHOLE_GATE = "<gate>";
-/**
- * Raised when a record cannot be read as a bar.
- *
- * IT NAMES THE SECTION, THE GATE AND THE FIELD, because a record file is a wall of near-identical
- * gate blocks and a bare "invalid config" over one of them leaves a reader opening the file and
- * reading every block to find out which. The four together are enough to put a cursor on the line.
- *
- * ONE TYPE FOR EVERY FAULT, INCLUDING THE ONES THIS MODULE DOES NOT DETECT ITSELF. A caller is
- * told to catch this and nothing else, so anything it does not cover is something that caller
- * sails past — which is why the YAML parser's own errors are normalised into it rather than left
- * to travel under their own name. That is what makes "a malformed record fails loudly" a property
- * of the reader rather than a property of the field checks alone.
- */
-export declare class MalformedRecordError extends Error {
-    /** The name the record was filed under, as the caller handed it over. */
-    readonly recordFile: string;
-    /** The section the fault sits in, or `<document>` when it sits above every section. */
-    readonly section: string;
-    /** The gate the fault sits under, or a placeholder when the fault is the section itself. */
-    readonly key: string;
-    /** The field the fault sits at. */
-    readonly field: string;
-    constructor(
-    /** The name the record was filed under, as the caller handed it over. */
-    recordFile: string, 
-    /** The section the fault sits in, or `<document>` when it sits above every section. */
-    section: string, 
-    /** The gate the fault sits under, or a placeholder when the fault is the section itself. */
-    key: string, 
-    /** The field the fault sits at. */
-    field: string, detail: string);
-}
-/**
- * The allowance a record STATES against a gate's counts — how many kills may be lost before the
- * gate reds, and why that many.
- *
- * COUNTED IN MUTANTS, WITH ITS REASON, and the unit is the point. A mutant is the unit the fault
- * arrives in, so the arithmetic downstream is exact rather than a rounding argument; and a
- * non-zero allowance that cannot say why it exists is head-room rather than tolerance, which is
- * why the reason travels with the number rather than in a comment beside it.
- */
-export interface GateAllowance {
-    /** Whole mutants of tolerance. Zero seats the floor exactly on the record. */
-    readonly mutants: number;
-    /** Why the allowance exists. */
-    readonly reason: string;
-}
-/** One gate's last-banked measurement, and the allowance stated against it. */
-export interface GateRecord {
-    /** The gate's name, as the record files it — the project's own word, never this module's. */
-    readonly gate: string;
-    /** Mutants the suite detected. */
-    readonly detected: number;
-    /** Every mutant the gate measured, detected or not. */
-    readonly total: number;
-    readonly allowance: GateAllowance;
-}
-/** A mutation score, as a percentage, computed from counts rather than read off a report. */
-export declare function scoreOf(detected: number, total: number): number;
-/** A percentage, at the one precision every figure in this library is stated to. */
-export declare function pct(value: number): string;
-/**
- * `detected/total (score%)` — the one shape every count pair in this library is stated in.
- *
- * BOTH HALVES, ALWAYS, AND THE SCORE BESIDE THEM. A message naming only the figure that moved
- * leaves its reader unable to see WHICH of the two moved, which is the single distinction this
- * library exists to make.
- *
- * IT LIVES HERE, BESIDE THE COUNTS, BECAUSE TWO READERS STATE IT. The reconciler prints it in every
- * verdict and the recorder prints it in its refusal, and one sentence spelled twice is the
- * agreeing-until-somebody-edits-one shape this library was built to remove.
- */
-export declare function counts(detected: number, total: number): string;
-/**
- * Whether one pair of counts scores strictly ABOVE another.
- *
- * CROSS-MULTIPLIED RATHER THAN DIVIDED, so the comparison is exact. Two scores equal as ratios can
- * differ in their last bit once each has been through a division, and a pair that did not move would
- * then read as one that did. The counts are whole and small enough that the products are exact.
- *
- * ONE FUNCTION READ BOTH WAYS ROUND, WHICH IS WHAT LEAVES EQUAL UNCLAIMED. Above and below are the
- * same two products with the arguments swapped, so no run can be claimed by both, and — the case
- * that matters — none can be claimed by neither. Two comparisons reached by different arithmetic
- * could each answer `false` for a run that is genuinely one or the other, and the run would fall out
- * of every reader here at once.
- */
-export declare function scoreRoseOver(detected: number, total: number, overDetected: number, overTotal: number): boolean;
-/**
- * The failing floor: the record's counts with its allowance spent out of the DETECTED count.
- *
- * SPENT FROM THE NUMERATOR, not subtracted from the score, because the allowance is counted in
- * mutants and a mutant is worth a different number of points in every gate — the same allowance
- * taken off two scores would mean two different things in two gates of different sizes.
- *
- * A REPORTED FIGURE, NOT THE DECISION VARIABLE. The verdict decides on COUNTS — fewer kills than
- * the record less its allowance — and prints this floor beside it so a reader has the bar in the
- * units the sweep speaks. The two agree exactly while the mutant population is unchanged, and part
- * company the moment it moves: a grown population drags the measured score below this floor with
- * no kill lost at all, and that case is green. Reading this floor AS the gate would put the
- * judgement back on the score, which is the confusion the counts model exists to prevent.
- */
-export declare function floorOf(record: GateRecord): number;
-/**
- * The failing floor in MUTANTS: the record's kills with its allowance spent out of them.
- *
- * `floorOf`'s TWIN WITHOUT THE DIVISION, and the division is the whole difference. A percentage is
- * two facts folded into one, and folding them is what makes a floor fall when new mutable code
- * arrives carrying survivors — no kill lost, and the bar missed anyway. Subtracting the allowance
- * and stopping leaves a whole number of mutants that moves only when a mutant this suite used to
- * kill stops dying, which is the one fact a bar on this axis is about.
- *
- * `total` NEVER ENTERS IT, and that is the population-independence rather than a simplification.
- * A reader holding this number can be handed a run over any population at all and still be asking
- * the only question worth asking of it.
- *
- * HERE RATHER THAN AT ITS CALLER, for the reason `floorOf` is here: how an allowance is spent is a
- * fact about the record, and a caller computing `detected - slack` itself would be a second place
- * holding it — agreeing until the day one of them is edited.
- */
-export declare function killFloorOf(record: GateRecord): number;
-/** The score the record itself states — what the ratchet raises and the verdict compares against. */
-export declare function recordedScoreOf(record: GateRecord): number;
-/**
- * Read every gate's record out of a record file's text.
- *
- * @param text the record file's own bytes, as authored
- * @param recordFile the name the record is filed under, so a refusal can say which file it read
- * @throws MalformedRecordError when the text cannot be read as a bar — one type for every fault,
- *   the YAML parser's own included, so a caller told to catch this catches all of them.
- */
-export declare function parseGateRecords(text: string, recordFile: string): Map<string, GateRecord>;
-/**
- * The bar the record holds for one named gate, refused when the record holds no such gate.
- *
- * A GATE WITH NO RECORD IS THE ONE FAULT IN THIS MODULE THAT LOOKS LIKE NOTHING AT ALL. Every
- * refusal above is a record somebody wrote badly, sitting in the file a reader would go and open.
- * This one is a record that reads perfectly, asked for a gate it never held — a gate name mistyped
- * where the caller states it. The lenient answer is not a wrong bar but NO bar, which reads
- * downstream as a gate with nothing to enforce, and it greens for as long as the typo survives.
- * Nothing about the record is wrong, so nobody is ever sent to look at it (@SCN-RAT-003, 3F-2793).
- *
- * AND THE REFUSAL LISTS THE GATES THE RECORD DOES HOLD. A record's gates are near-neighbours by
- * construction — a project names them after the scopes it is quarantining from each other — so a
- * refusal naming only the gate that was asked for sends its reader to open the file and compare
- * spellings by eye. Listing what is held turns the typo into a one-line diagnosis.
- *
- * UNDER THE ONE REFUSAL TYPE, like every fault above it. A caller is told to catch
- * `MalformedRecordError` and nothing else, so an unrecorded gate raised under a second type is a
- * fault that caller sails straight past — the very hole the YAML parser's own errors are
- * normalised to close.
- *
- * @param gate the gate to resolve, as the caller names it — never a name this module knows
- * @param records every gate the record holds, as `parseGateRecords` read them
- * @param recordFile the name the record is filed under, so a refusal can say which file it read
- * @throws MalformedRecordError when the record holds no such gate, listing the gates it does hold
- */
-export declare function gateRecordFor(gate: string, records: Map<string, GateRecord>, recordFile: string): GateRecord;
-//# sourceMappingURL=record.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAkB/C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,WAAW,CAAC;AAEnC;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM;;IAPtB,yEAAyE;IAChE,UAAU,EAAE,MAAM;IAC3B,uFAAuF;IAC9E,OAAO,EAAE,MAAM;IACxB,4FAA4F;IACnF,GAAG,EAAE,MAAM;IACpB,mCAAmC;IAC1B,KAAK,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;CAKjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACzB,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;CACnC;AAED,6FAA6F;AAC7F,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,oFAAoF;AACpF,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GAChB,OAAO,CAET;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAElD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEtD;AAED,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE1D;AAiLD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAI1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAChC,UAAU,EAAE,MAAM,GACjB,UAAU,CAYZ"}

package/dist/mutation-ratchet/record.js

@@ -1,330 +0,0 @@
-/**
- * A GATE'S RECORD — the pair of counts it last banked, and the allowance stated against them
- * (@SCN-RAT-001, 3F-2790).
- *
- * THE RECORD IS TWO COUNTS, NEVER A BARE SCORE, and that is the load-bearing choice this whole
- * module exists to make possible. A mutation score is detected over total, so it falls 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. One number reds on both, and the only cheap way out of a red for the second is to widen
- * the bar — which is how a floor loses its teeth. Keeping `detected` and `total` apart is what
- * lets the verdict tell them apart: kills lost is stated directly, and a growing population moves
- * `total` while leaving `detected` alone.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The record's text
- * arrives as a string and the name it is filed under arrives beside it, because which file holds a
- * project's bars, and what its gates are called, are that project's own facts. This module has an
- * opinion about the SHAPE of a record and none about whose it is.
- *
- * MALFORMED MEANS NO BAR, NEVER A DEFAULTED ONE. Every refusal below is a record a lenient reader
- * answers with a bar nobody wrote — an absent section read as "no gates to enforce", a gate that
- * measured nothing read as scoring zero, an allowance nobody justified read as justified. The bar
- * is then enforced as though somebody had written it, and the only symptom is a build that has
- * quietly stopped being able to red. So each one is refused by name, and the refusal says which
- * record it read and where in that record the fault is (@SCN-RAT-002, 3F-2792).
- *
- * IT IS NOT A STATIC CHECK, and takes no `static-check:` prefix. A static check is a pure function
- * of the checked-out tree; the record this reads feeds a reconciler that judges a MEASUREMENT,
- * which by construction is not in the tree — the standing ruling every scheduled-sweep reader in
- * this portfolio already carries.
- */
-import { parse } from "yaml";
-/**
- * The section of a record file that holds every gate's counts.
- *
- * EXPORTED SO THE RECORDER CANNOT HOLD A SECOND COPY OF IT. `ratchet.ts` finds the same section in
- * the same text in order to rewrite two of its lines, and two spellings of one name is the
- * agreeing-until-somebody-edits-one shape this whole library exists to remove.
- *
- * The SECTION name is this module's, and the gate names inside it are the project's. A record file
- * is a project's own document and may hold whatever else that project keeps in it; what this module
- * asks of it is one section, under one name, so a project can file its mutation bars beside the
- * rest of its policy rather than in a file of their own.
- */
-export const MUTATION_GATES = "mutation-gates";
-/**
- * The document itself, when the fault is above any one gate — a record whose top level is not a
- * mapping of sections, or one the YAML parser could not read at all.
- *
- * A PLACEHOLDER RATHER THAN A GATE NAME, and it is spelled here so the two readers that use it
- * cannot drift apart. A refusal always names a section and a key so that a reader who has one
- * message in front of them never has to work out which shape of message they are holding.
- */
-const WHOLE_DOCUMENT = "<document>";
-/** The key a document-level refusal names, there being no gate to name. */
-const DOCUMENT_ROOT = "root";
-/** The key a section-level refusal names, the fault being the section itself rather than a gate. */
-const WHOLE_SECTION = "<section>";
-/**
- * The field a refusal names when the fault is the ASK rather than a field of a gate's block — a
- * gate the record does not hold at all.
- *
- * EXPORTED FOR THE SAME REASON AS THE SECTION NAME: `ratchet.ts` refuses the same way when it is
- * asked to raise a gate no block is written for, and a refusal a reader has to recognise in two
- * spellings is one they will eventually parse wrongly.
- */
-export const WHOLE_GATE = "<gate>";
-/**
- * Raised when a record cannot be read as a bar.
- *
- * IT NAMES THE SECTION, THE GATE AND THE FIELD, because a record file is a wall of near-identical
- * gate blocks and a bare "invalid config" over one of them leaves a reader opening the file and
- * reading every block to find out which. The four together are enough to put a cursor on the line.
- *
- * ONE TYPE FOR EVERY FAULT, INCLUDING THE ONES THIS MODULE DOES NOT DETECT ITSELF. A caller is
- * told to catch this and nothing else, so anything it does not cover is something that caller
- * sails past — which is why the YAML parser's own errors are normalised into it rather than left
- * to travel under their own name. That is what makes "a malformed record fails loudly" a property
- * of the reader rather than a property of the field checks alone.
- */
-export class MalformedRecordError extends Error {
-    recordFile;
-    section;
-    key;
-    field;
-    constructor(
-    /** The name the record was filed under, as the caller handed it over. */
-    recordFile, 
-    /** The section the fault sits in, or `<document>` when it sits above every section. */
-    section, 
-    /** The gate the fault sits under, or a placeholder when the fault is the section itself. */
-    key, 
-    /** The field the fault sits at. */
-    field, detail) {
-        super(`${recordFile}: ${section} "${key}" is malformed at ${field}: ${detail}`);
-        this.recordFile = recordFile;
-        this.section = section;
-        this.key = key;
-        this.field = field;
-        this.name = "MalformedRecordError";
-    }
-}
-/** A mutation score, as a percentage, computed from counts rather than read off a report. */
-export function scoreOf(detected, total) {
-    return (detected / total) * 100;
-}
-/** A percentage, at the one precision every figure in this library is stated to. */
-export function pct(value) {
-    return value.toFixed(4);
-}
-/**
- * `detected/total (score%)` — the one shape every count pair in this library is stated in.
- *
- * BOTH HALVES, ALWAYS, AND THE SCORE BESIDE THEM. A message naming only the figure that moved
- * leaves its reader unable to see WHICH of the two moved, which is the single distinction this
- * library exists to make.
- *
- * IT LIVES HERE, BESIDE THE COUNTS, BECAUSE TWO READERS STATE IT. The reconciler prints it in every
- * verdict and the recorder prints it in its refusal, and one sentence spelled twice is the
- * agreeing-until-somebody-edits-one shape this library was built to remove.
- */
-export function counts(detected, total) {
-    return `${detected}/${total} (${pct(scoreOf(detected, total))}%)`;
-}
-/**
- * Whether one pair of counts scores strictly ABOVE another.
- *
- * CROSS-MULTIPLIED RATHER THAN DIVIDED, so the comparison is exact. Two scores equal as ratios can
- * differ in their last bit once each has been through a division, and a pair that did not move would
- * then read as one that did. The counts are whole and small enough that the products are exact.
- *
- * ONE FUNCTION READ BOTH WAYS ROUND, WHICH IS WHAT LEAVES EQUAL UNCLAIMED. Above and below are the
- * same two products with the arguments swapped, so no run can be claimed by both, and — the case
- * that matters — none can be claimed by neither. Two comparisons reached by different arithmetic
- * could each answer `false` for a run that is genuinely one or the other, and the run would fall out
- * of every reader here at once.
- */
-export function scoreRoseOver(detected, total, overDetected, overTotal) {
-    return detected * overTotal > overDetected * total;
-}
-/**
- * The failing floor: the record's counts with its allowance spent out of the DETECTED count.
- *
- * SPENT FROM THE NUMERATOR, not subtracted from the score, because the allowance is counted in
- * mutants and a mutant is worth a different number of points in every gate — the same allowance
- * taken off two scores would mean two different things in two gates of different sizes.
- *
- * A REPORTED FIGURE, NOT THE DECISION VARIABLE. The verdict decides on COUNTS — fewer kills than
- * the record less its allowance — and prints this floor beside it so a reader has the bar in the
- * units the sweep speaks. The two agree exactly while the mutant population is unchanged, and part
- * company the moment it moves: a grown population drags the measured score below this floor with
- * no kill lost at all, and that case is green. Reading this floor AS the gate would put the
- * judgement back on the score, which is the confusion the counts model exists to prevent.
- */
-export function floorOf(record) {
-    return scoreOf(record.detected - record.allowance.mutants, record.total);
-}
-/**
- * The failing floor in MUTANTS: the record's kills with its allowance spent out of them.
- *
- * `floorOf`'s TWIN WITHOUT THE DIVISION, and the division is the whole difference. A percentage is
- * two facts folded into one, and folding them is what makes a floor fall when new mutable code
- * arrives carrying survivors — no kill lost, and the bar missed anyway. Subtracting the allowance
- * and stopping leaves a whole number of mutants that moves only when a mutant this suite used to
- * kill stops dying, which is the one fact a bar on this axis is about.
- *
- * `total` NEVER ENTERS IT, and that is the population-independence rather than a simplification.
- * A reader holding this number can be handed a run over any population at all and still be asking
- * the only question worth asking of it.
- *
- * HERE RATHER THAN AT ITS CALLER, for the reason `floorOf` is here: how an allowance is spent is a
- * fact about the record, and a caller computing `detected - slack` itself would be a second place
- * holding it — agreeing until the day one of them is edited.
- */
-export function killFloorOf(record) {
-    return record.detected - record.allowance.mutants;
-}
-/** The score the record itself states — what the ratchet raises and the verdict compares against. */
-export function recordedScoreOf(record) {
-    return scoreOf(record.detected, record.total);
-}
-/**
- * Read the record's text into a document mapping.
- *
- * THE YAML PARSER'S OWN DETECTIONS ARE REAL, AND THEY ARRIVE UNDER SOMEONE ELSE'S NAME. A gate
- * recorded twice raises `YAMLParseError` before this module sees a mapping at all — a genuine
- * catch, and one a caller that was told to catch `MalformedRecordError` walks straight past. So it
- * is caught here and re-raised as this module's own refusal, carrying the parser's message as the
- * detail so nothing about WHAT was wrong is lost on the way across.
- */
-function documentOf(text, recordFile) {
-    let read;
-    try {
-        read = parse(text);
-    }
-    catch (cause) {
-        const detail = cause instanceof Error ? cause.message : String(cause);
-        throw new MalformedRecordError(recordFile, WHOLE_DOCUMENT, DOCUMENT_ROOT, "yaml", detail);
-    }
-    if (!isMapping(read)) {
-        throw new MalformedRecordError(recordFile, WHOLE_DOCUMENT, DOCUMENT_ROOT, DOCUMENT_ROOT, "the top level must be a mapping of sections.");
-    }
-    return read;
-}
-/** Whether a value read out of the record is a block of named fields, rather than a list or scalar. */
-function isMapping(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * The section holding every gate, refused when it is absent or holds no gate.
- *
- * REQUIRED, NEVER DEFAULTED, and the two refusals are one fault at two depths. A record with no
- * section reads as "no gates to enforce"; a section with no gate reads as a bar that enforces
- * nothing. Both hand back a green that was never earned, which is the vacuous pass this whole
- * apparatus exists to close, so neither is allowed to be the answer.
- */
-function gatesSectionOf(text, recordFile) {
-    const section = documentOf(text, recordFile)[MUTATION_GATES];
-    if (!isMapping(section)) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, WHOLE_SECTION, MUTATION_GATES, "the section is missing, or is not a mapping of gate name to record.");
-    }
-    const entries = Object.entries(section);
-    if (entries.length === 0) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, WHOLE_SECTION, MUTATION_GATES, "at least one gate must be recorded — an empty section is a bar that enforces nothing.");
-    }
-    return entries;
-}
-/**
- * One field, read as a whole, non-negative count of mutants.
- *
- * THE UNIT IS THE MUTANT, so a fraction is not a smaller count — it is a number that came from
- * somewhere other than counting, and the arithmetic downstream is exact precisely because nothing
- * here ever rounds.
- */
-function countAt(gate, entry, field, recordFile) {
-    const raw = entry[field];
-    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, field, "expected a whole number of mutants.");
-    }
-    return raw;
-}
-/**
- * The allowance the record states, refused when it cannot be spent or cannot say why it exists.
- *
- * AN ALLOWANCE NOBODY CAN JUSTIFY IS HEAD-ROOM, NOT TOLERANCE, and head-room admitted at read time
- * is a bar nobody wrote being enforced as though somebody had. It is refused HERE rather than left
- * to the reconciler, because by the time a verdict is being computed the unjustified allowance has
- * already become part of the bar. A ZERO allowance needs no reason: there is nothing to justify.
- *
- * WIDER THAN THE KILLS IT IS SPENT FROM IS THE OTHER WAY THE SAME BAR VANISHES. The allowance comes
- * out of the recorded kills, so one wider than them puts the floor below zero, and a gate whose
- * floor is below zero cannot red for any measurement at all.
- */
-function allowanceOf(gate, entry, detected, recordFile) {
-    const mutants = countAt(gate, entry, "slack-mutants", recordFile);
-    if (mutants > detected) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, "slack-mutants", `${mutants} is wider than the ${detected} kills it is spent from.`);
-    }
-    const stated = entry["slack-reason"];
-    const reason = typeof stated === "string" ? stated.trim() : "";
-    if (mutants > 0 && reason === "") {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, "slack-reason", "a non-zero allowance must say why it exists — one nobody can justify is head-room.");
-    }
-    return { mutants, reason };
-}
-/**
- * One gate's entry, read into its record.
- *
- * `total` IS READ AND REFUSED BEFORE `detected`, WHICH IS THE ORDER AND NOT AN ACCIDENT. A gate
- * that measured no mutants has no score — the division is undefined — so there is nothing for a
- * kill count to be compared against, and refusing at `detected` first would name the wrong field
- * in the message a reader is trying to act on.
- */
-function recordOf(gate, raw, recordFile) {
-    if (!isMapping(raw)) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, "<entry>", "expected a block of fields.");
-    }
-    const total = countAt(gate, raw, "total", recordFile);
-    if (total === 0) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, "total", "a gate that measured no mutants has no score.");
-    }
-    const detected = countAt(gate, raw, "detected", recordFile);
-    if (detected > total) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, "detected", `${detected} kills over ${total} mutants — a gate cannot detect more than it measured.`);
-    }
-    return { gate, detected, total, allowance: allowanceOf(gate, raw, detected, recordFile) };
-}
-/**
- * Read every gate's record out of a record file's text.
- *
- * @param text the record file's own bytes, as authored
- * @param recordFile the name the record is filed under, so a refusal can say which file it read
- * @throws MalformedRecordError when the text cannot be read as a bar — one type for every fault,
- *   the YAML parser's own included, so a caller told to catch this catches all of them.
- */
-export function parseGateRecords(text, recordFile) {
-    return new Map(gatesSectionOf(text, recordFile).map(([gate, raw]) => [gate, recordOf(gate, raw, recordFile)]));
-}
-/**
- * The bar the record holds for one named gate, refused when the record holds no such gate.
- *
- * A GATE WITH NO RECORD IS THE ONE FAULT IN THIS MODULE THAT LOOKS LIKE NOTHING AT ALL. Every
- * refusal above is a record somebody wrote badly, sitting in the file a reader would go and open.
- * This one is a record that reads perfectly, asked for a gate it never held — a gate name mistyped
- * where the caller states it. The lenient answer is not a wrong bar but NO bar, which reads
- * downstream as a gate with nothing to enforce, and it greens for as long as the typo survives.
- * Nothing about the record is wrong, so nobody is ever sent to look at it (@SCN-RAT-003, 3F-2793).
- *
- * AND THE REFUSAL LISTS THE GATES THE RECORD DOES HOLD. A record's gates are near-neighbours by
- * construction — a project names them after the scopes it is quarantining from each other — so a
- * refusal naming only the gate that was asked for sends its reader to open the file and compare
- * spellings by eye. Listing what is held turns the typo into a one-line diagnosis.
- *
- * UNDER THE ONE REFUSAL TYPE, like every fault above it. A caller is told to catch
- * `MalformedRecordError` and nothing else, so an unrecorded gate raised under a second type is a
- * fault that caller sails straight past — the very hole the YAML parser's own errors are
- * normalised to close.
- *
- * @param gate the gate to resolve, as the caller names it — never a name this module knows
- * @param records every gate the record holds, as `parseGateRecords` read them
- * @param recordFile the name the record is filed under, so a refusal can say which file it read
- * @throws MalformedRecordError when the record holds no such gate, listing the gates it does hold
- */
-export function gateRecordFor(gate, records, recordFile) {
-    const record = records.get(gate);
-    if (record === undefined) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, WHOLE_GATE, `no bar is recorded for this gate (recorded: ${[...records.keys()].join(", ")}).`);
-    }
-    return record;
-}
-//# sourceMappingURL=record.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"record.js","sourceRoot":"","sources":["../../src/mutation-ratchet/record.ts"],"names":[],"mappings":"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"}

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

@@ -1,83 +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 type { MutationMeasurement } from "./verdict.js";
-/**
- * A report read: the measurement, or the reason there is not one (@SCN-RAT-009, 3F-2800).
- *
- * A REFUSAL IS A RESULT, NEVER AN EXCEPTION THE CALLER MAY FORGET TO CATCH. Reading a report is the
- * one step of this library that reaches for something outside its own arguments, so it is the one
- * step that can fail for reasons nothing in the record explains. A throw would be a fault every
- * caller has to remember to catch, and the caller who forgets reports whatever their surroundings
- * do with an uncaught one — on a good day a red nobody can read, on a bad one a step never reached.
- * Handed back as a value, the refusal is impossible to drop by omission: there is no measurement to
- * read out of it until its `ok` has been asked about.
- */
-export type MutationReportRead = {
-    readonly ok: true;
-    readonly measurement: MutationMeasurement;
-} | {
-    readonly ok: false;
-    readonly reason: string;
-};
-/**
- * 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 declare function measurementFromReport(gate: string, text: string, reportPath: string): MutationReportRead;
-/**
- * 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 declare function readMutationReport(gate: string, reportPath: string): MutationReportRead;
-//# sourceMappingURL=report.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AA+DpD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,kBAAkB,CAoBpB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAWvF"}