spec-controller 0.1.0-alpha.3 → 0.1.0-alpha.5

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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"}

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

@@ -1,109 +0,0 @@
-/**
- * THE MEASUREMENT — a gate's run, counted out of its mutation report's own mutants
- * (@SCN-MUT-007, 3F-2799, 3F-3337).
- *
- * THE RATCHET THAT RECONCILED THIS IS GONE; THE READER IS NOT (3F-3337). Its one remaining caller
- * is `tests/checks/mutationScoreCli.ts` — `pnpm mutation:score`, the producer that posts
- * SCN-FIT-002's number — which takes the two counts out of this and divides them. @SCN-MUT-007 and
- * @SCN-MUT-008 are what specify it now, and they state the same two things this file states: the
- * valid population is the killed and the timed-out over those plus the survived and the
- * never-covered, and a run with no readable report posts nothing rather than a count of zero.
- *
- * 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
- * (SCN-FIT-002's own row, which `stryker.config.mjs` reads back), 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-MUT-008). 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.
- */
-/**
- * One gate's measured run, in the two counts the metric is defined over.
- *
- * IT MOVED HERE FROM `verdict.ts` WHEN THE RATCHET LEFT (3F-3337), unchanged. It sat beside the
- * comparison while there was one; what produces it now is this module alone, so it sits where it
- * is made.
- *
- * TWO COUNTS AND NOT A SCORE. A measurement that arrived as a score would already have folded the
- * two events a reader has to tell apart — a kill lost, and a population that grew — into one
- * number, before any caller could look at either.
- */
-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;
-}
-/**
- * A report read: the measurement, or the reason there is not one (@SCN-MUT-008, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH;;;;;;;;;;GAUG;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;;;;;;;;;;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"}

package/dist/mutation-ratchet/report.js

@@ -1,156 +0,0 @@
-/**
- * THE MEASUREMENT — a gate's run, counted out of its mutation report's own mutants
- * (@SCN-MUT-007, 3F-2799, 3F-3337).
- *
- * THE RATCHET THAT RECONCILED THIS IS GONE; THE READER IS NOT (3F-3337). Its one remaining caller
- * is `tests/checks/mutationScoreCli.ts` — `pnpm mutation:score`, the producer that posts
- * SCN-FIT-002's number — which takes the two counts out of this and divides them. @SCN-MUT-007 and
- * @SCN-MUT-008 are what specify it now, and they state the same two things this file states: the
- * valid population is the killed and the timed-out over those plus the survived and the
- * never-covered, and a run with no readable report posts nothing rather than a count of zero.
- *
- * 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
- * (SCN-FIT-002's own row, which `stryker.config.mjs` reads back), 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-MUT-008). 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":"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"}