spec-controller 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/mutation-ratchet/index.js

@@ -1,51 +0,0 @@
-/**
- * THE MODULE'S OWN SURFACE — curated symbol by symbol, never a re-export of the tree behind it
- * (3F-2804, 3F-3337).
- *
- * WHAT IS BEHIND THIS BARREL NOW IS TWO READERS, AND THE RATCHET THEY WERE BUILT FOR IS GONE
- * (3F-3337). `record.ts` reads a target's banked gate record and hands back the kill floor it
- * implies; `report.ts` counts a mutation report's own mutants into a measurement. What left with
- * the ratchet is everything that COMPARED the two — the verdicts, the up-only recorder, the
- * reconciliation entry and the command that ended on it — because this repository's gate is now a
- * per-mutant comparison the runner keeps, and nothing types a mutation count here any more.
- *
- * ITS TWO CONSUMERS ARE BOTH IN THIS TREE, AND THEY WANT DIFFERENT HALVES. `ingest/
- * ingestQualityChecks.ts` wants the RECORD half: the engine's `mutationGate` bar kind lets a target
- * author a fitness row naming a gate instead of a figure, which is a published capability decided
- * over a target's own record (@SCN-MUT-012, @SCN-MUT-013). `tests/checks/mutationScoreCli.ts` wants
- * the REPORT half: `pnpm mutation:score` takes the two counts out of a sweep's report and divides
- * them (@SCN-MUT-007, @SCN-MUT-008). Neither wants the other's, which is why both are named here
- * rather than the tree behind them being passed on wholesale.
- *
- * A BARREL THAT RE-EXPORTED EVERY MODULE WOULD BE A CONTRACT NOBODY WROTE. Each module below
- * exports what its own siblings need from it, and sibling-visibility is a much wider set than
- * consumer-visibility. Passing that set on wholesale would freeze every one of them as something a
- * caller may depend on, and the first refactor that moved one would be a breaking change nobody
- * meant to make. So this file names what a caller may hold and the omissions are decisions.
- *
- * THE KILL FLOOR IS THE BAR, AND IT IS NOT A SCORE (3F-2788). `killFloorOf` answers a ledger
- * holding a measured row to the figure a gate's own record implies, in mutants — a percentage would
- * fold the kill lost and the population grown into one number, which is the distinction a bar on
- * this axis exists to keep. A consumer that derived it instead would be the second place knowing
- * how an allowance is spent.
- *
- * THE TYPES ARE SPELLED FOR A CONSUMER'S NAMESPACE RATHER THAN FOR THIS MODULE'S. `GateRecord` is
- * unambiguous inside a directory about nothing else; imported into a repository that has gates of
- * several kinds it is not, so it crosses this line under the fuller name. The aliasing is
- * deliberate and one-directional: the internal spelling stays internal.
- *
- * AND NO DRIFT GUARD STANDS OVER IT, WHICH IS A DECISION RATHER THAN AN OPEN QUESTION. 3F-2859
- * stopped publishing this barrel: no manifest key resolves here, and no caller outside this
- * repository can spell the specifier at all. Freezing the list would make every refactor behind it
- * a change to a contract nobody holds.
- *
- * THE COMPARISON THIS PARAGRAPH USED TO DRAW IS GONE, AND SAYING SO IS THE POINT. It read: the
- * sibling core package's barrel IS reflected and compared against a frozen list in both directions,
- * so a symbol quietly added or dropped reds — that being what a PUBLISHED surface is owed, and this
- * one is not published. At 3F-3449 that arm was deleted with the rest of the packaging checks this
- * repository wrote for itself, so NEITHER barrel is guarded now and the contrast no longer carries
- * the argument. What still carries it is the second sentence above, which never depended on it.
- */
-export { floorOf, gateRecordFor, killFloorOf, MalformedRecordError, parseGateRecords, RECORD_FILE, } from "./record.js";
-export { measurementFromReport, readMutationReport, } from "./report.js";
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mutation-ratchet/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,OAAO,EACL,OAAO,EACP,aAAa,EACb,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,GAEZ,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,GAGnB,MAAM,aAAa,CAAC"}

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

@@ -1,178 +0,0 @@
-/**
- * A GATE'S RECORD — the pair of counts it last banked, and the allowance stated against them
- * (@SCN-MUT-012, 3F-2790, 3F-3337).
- *
- * THE RATCHET THAT ONCE RECONCILED AGAINST THIS IS GONE; THE READER IS NOT (3F-3337). What reaches
- * this module now is the engine's `mutationGate` bar kind, through `ingestQualityChecks.ts`: a
- * target may author a fitness row whose bar names a gate rather than a figure, and the kill floor
- * that gate's record implies is the bar the ledger then holds it to. That is a published
- * capability, decided over a TARGET'S record, and this repository no longer keeps one of its own.
- * @SCN-MUT-012 and @SCN-MUT-013 are what specify it — the second carrying, as its own Examples,
- * the record that holds no gate of that name, the record that is not there to be read and the
- * record holding text nothing can read as a record.
- *
- * 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-MUT-013, 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 name a record is filed under when its caller does not choose one.
- *
- * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
- * that project's own fact, and a caller naming its own is answered by that name — this is only
- * what stands in when none is given, and it is exported so a caller happy with the convention does
- * not have to respell it and get one character of it wrong.
- *
- * IT MOVED HERE FROM `reconcile.ts` WHEN THE RATCHET LEFT (3F-3337), unchanged. The entry that used
- * to sit beside it reconciled a gate against this record; what is left reading a record is this
- * module, so the default name sits with the reader that defaults to it.
- */
-export declare const RECORD_FILE = "quality-thresholds.yml";
-/**
- * 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;
-}
-/**
- * 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;
-/**
- * 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-MUT-013, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,2BAA2B,CAAC;AA0CpD;;;;;;;;;;;;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;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAElD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEtD;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,314 +0,0 @@
-/**
- * A GATE'S RECORD — the pair of counts it last banked, and the allowance stated against them
- * (@SCN-MUT-012, 3F-2790, 3F-3337).
- *
- * THE RATCHET THAT ONCE RECONCILED AGAINST THIS IS GONE; THE READER IS NOT (3F-3337). What reaches
- * this module now is the engine's `mutationGate` bar kind, through `ingestQualityChecks.ts`: a
- * target may author a fitness row whose bar names a gate rather than a figure, and the kill floor
- * that gate's record implies is the bar the ledger then holds it to. That is a published
- * capability, decided over a TARGET'S record, and this repository no longer keeps one of its own.
- * @SCN-MUT-012 and @SCN-MUT-013 are what specify it — the second carrying, as its own Examples,
- * the record that holds no gate of that name, the record that is not there to be read and the
- * record holding text nothing can read as a record.
- *
- * 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-MUT-013, 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 name a record is filed under when its caller does not choose one.
- *
- * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
- * that project's own fact, and a caller naming its own is answered by that name — this is only
- * what stands in when none is given, and it is exported so a caller happy with the convention does
- * not have to respell it and get one character of it wrong.
- *
- * IT MOVED HERE FROM `reconcile.ts` WHEN THE RATCHET LEFT (3F-3337), unchanged. The entry that used
- * to sit beside it reconciled a gate against this record; what is left reading a record is this
- * module, so the default name sits with the reader that defaults to it.
- */
-export const RECORD_FILE = "quality-thresholds.yml";
-/**
- * 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.
- */
-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.
- */
-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. */
-function scoreOf(detected, total) {
-    return (detected / total) * 100;
-}
-/**
- * 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;
-}
-/**
- * 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-MUT-013, 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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"}