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

package/dist/mutation-ratchet/ratchet.js

@@ -1,222 +0,0 @@
-/**
- * THE RECORDER — a measurement written into the record as a surgical text edit (@SCN-RAT-011,
- * 3F-2801), refused outright when it is not a raise (@SCN-RAT-012, 3F-2802), and kept inside the
- * block it names when a sibling gate banks the very same counts (@SCN-RAT-013, 3F-2803).
- *
- * A SURGICAL TEXT EDIT, NEVER A RE-DUMP, AND THAT IS THE WHOLE OF THIS MODULE'S DIFFICULTY.
- * Emitting the parsed document back out is the obvious way to write two figures into a record, and
- * it throws away every comment on the way through — comments are not part of the document a parser
- * hands back. A record file is MOSTLY comment: every allowance's justification lives there, and so
- * does the argument for the bar sitting where it sits. So a recorder that re-serialised would
- * delete the reasoning for the very bar it was raising, quietly, in the same commit that claims to
- * be strengthening it, and with the two figures perfectly correct.
- *
- * SO THE TEXT ARRIVES AS TEXT AND LEAVES AS TEXT. Nothing below reaches for a document model. The
- * record is split on its own line breaks, two lines are rewritten where they lie, and the pieces
- * are joined back up — which is why what comes back is the bytes it was handed with two numerals
- * different, down to the blank lines, the indent style, the quoting and the trailing newline.
- *
- * AND THE EDIT IS BOUNDED BY THE NAMED GATE'S OWN BLOCK. A record is a wall of near-identical
- * blocks holding identically-named lines, so a rewriter that took the first `detected` line it met
- * would raise whichever gate happens to be written first and report success on the one it was
- * asked about. The block runs from the gate's key line to the first line after it indented no
- * further than that key — the next gate, or the comment introducing it. The search for that key
- * starts at the gates section rather than the top of the file, because a record is a project's own
- * policy document and may hold anything else it likes above the bars.
- *
- * THE LINES ARE THEN FOUND BY POSITION INSIDE THAT BLOCK, NEVER BY THE FIGURES THEY CARRY, and the
- * difference is invisible over almost every record. A rewriter that struck the OLD numerals out
- * wherever they first appeared would be byte-preserving, would move exactly two lines, would keep
- * every comment, and would write precisely the right two lines over any record whose gates hold
- * distinct figures. It writes the WRONG gate only when two gates bank the same counts — and then
- * silently, leaving the two gates stating figures neither of the trees they describe ever measured.
- * @SCN-RAT-013's record plants that collision on purpose, and authors it with the named gate above
- * its twin and below it, because either rewriter is right by luck when the gate it wants is first.
- *
- * A LINE THE BLOCK DOES NOT HOLD IS AN ERROR NAMING THE LINE, NEVER A NO-OP. Both of the other
- * answers are worse than a refusal: skipping quietly banks half a measurement and reports a raise
- * that did not happen, and searching on past the block's end rewrites some other gate's figure with
- * this gate's count.
- *
- * EVERY FAULT IN THE RECORD IS `record.ts`'s ONE REFUSAL TYPE, and its section name and gate
- * placeholder are imported rather than respelled. A caller is told to catch `MalformedRecordError`
- * for a record it cannot read, so a record fault raised here under a second type is one that caller
- * sails past — and a second copy of the section's name is the agreeing-until-somebody-edits-one
- * shape this library exists to remove.
- *
- * AND THE UP-ONLY REFUSAL IS THE ONE THING HERE THAT IS NOT A RECORD FAULT, WHICH IS WHY IT CARRIES
- * ITS OWN TYPE. Every fault that other refusal names is a record somebody wrote badly, sitting in
- * the file its reader is being sent to open. A run that is not a raise arrives over a record that
- * reads perfectly, so borrowing that type would send its reader hunting through a file with nothing
- * wrong in it — the exact harm `record.ts` refuses to do to the caller who mistyped a gate name.
- *
- * THE RATCHET ONLY EVER RAISES, AND AN EQUAL MEASUREMENT IS REFUSED TOO. Writing the same two
- * figures back changes nothing, and a no-op that reports success reads, in a shell history or a
- * run's own log, as a ratchet that happened; the refusal is what keeps "I banked it" meaning
- * something. It is the SCORE that is compared rather than the pair, because a run can move both of
- * its counts and hold its ratio exactly — over a record already stating that score, writing it
- * raises nothing.
- *
- * AND THE REFUSAL HAS NO OVERRIDE, DELIBERATELY. A fall that is honest — code deleted, a scope
- * narrowed — is a conscious bump: a human edits the two figures and puts the reason in the commit,
- * which is the route the refusal names and the same route the shrunk-population red already sends
- * its reader down. An escape hatch a tool offers is one nobody has to justify, and it would be
- * reached for on the first red night rather than the first honest one. So there is no input here
- * that writes a fall — not a flag, not a defaulted parameter, not a setting — and @SCN-RAT-012's
- * arm asserts that over this module's own bytes rather than trusting it.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The gate, the
- * record's own name and the tree it sits in all arrive from the caller.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { counts, MalformedRecordError, MUTATION_GATES, scoreRoseOver, WHOLE_GATE, } from "./record.js";
-/**
- * Raised when a run is not a raise — the up-only refusal (@SCN-RAT-012, 3F-2802).
- *
- * A SECOND TYPE, AND DELIBERATELY NOT `MalformedRecordError`. Every fault that refusal names is a
- * record somebody wrote badly, sitting in the file its reader is being sent to open. This one is a
- * record that reads perfectly and an ASK that is not a raise, so borrowing the other type would
- * send a reader off to hunt for a fault in a file that has none.
- */
-export class FallRefusedError extends Error {
-    recordFile;
-    gate;
-    constructor(
-    /** The name the record was filed under, as the caller handed it over. */
-    recordFile, 
-    /** The gate that was to have been raised, as the caller names it. */
-    gate, banked, measurement) {
-        super(`${gate}: NOT A RAISE — measured ${counts(measurement.detected, measurement.total)} against ` +
-            `a recorded ${counts(banked.detected, banked.total)}. The ratchet only ever raises, and ` +
-            "this run does not: a measurement below the record would give the bar away, and one " +
-            "scoring exactly what the record already states would write it back unchanged — a no-op " +
-            "that reads, in a shell history or a run's own log, as a ratchet that happened. Nothing " +
-            "here lowers a record for you. If the fall is honest — code deleted, a scope narrowed — " +
-            `edit ${recordFile} by hand and put the reason in the commit, because an escape hatch a ` +
-            "tool holds open is one nobody ever has to justify.");
-        this.recordFile = recordFile;
-        this.gate = gate;
-        this.name = "FallRefusedError";
-    }
-}
-/** How far a line is indented, in characters. */
-function indentOf(line) {
-    return line.length - line.trimStart().length;
-}
-/**
- * The line one field is written on: its key at any indent, its whole-number value, and whatever
- * spacing the author put around both.
- *
- * THE SPACING IS CAPTURED SO IT CAN BE PUT BACK. `detected:   202` and `detected: 202` are the same
- * record and different bytes, and a rewriter that normalised one into the other would be re-dumping
- * one line at a time.
- */
-function fieldLine(field) {
-    return new RegExp(`^(\\s*${field}\\s*:\\s*)(\\d+)(\\s*)$`);
-}
-/** Where the gates section's own key line sits, refused when the record is not written as one. */
-function gatesSectionAt(lines, gate, recordFile) {
-    const at = lines.findIndex((line) => line.trim() === `${MUTATION_GATES}:`);
-    if (at === -1) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, MUTATION_GATES, "the section is not written as a block of gates, so it holds no block to rewrite.");
-    }
-    return at;
-}
-/**
- * The lines holding one gate's block, refused when the record writes no block for that gate.
- *
- * ENDING AT THE FIRST LINE INDENTED NO FURTHER THAN THE KEY — the next gate, or the comment
- * introducing it. That boundary is what keeps a rewrite inside the gate it was asked about when the
- * line it is looking for is not there to be found.
- */
-function gateBlockOf(lines, gate, recordFile) {
-    const section = gatesSectionAt(lines, gate, recordFile);
-    const sectionIndent = indentOf(lines[section] ?? "");
-    const key = lines.findIndex((line, at) => at > section && line.trim() === `${gate}:` && indentOf(line) > sectionIndent);
-    if (key === -1) {
-        throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, WHOLE_GATE, "the record writes no block for this gate, so there is nothing to raise.");
-    }
-    const indent = indentOf(lines[key] ?? "");
-    const ends = lines.findIndex((line, at) => at > key && line.trim() !== "" && indentOf(line) <= indent);
-    return { from: key + 1, to: ends === -1 ? lines.length : ends };
-}
-/**
- * One field's line inside a block, refused by the field's name when the block holds no such line.
- *
- * BOTH FIGURES ARE FOUND BEFORE EITHER IS COMPARED OR WRITTEN, which is what keeps this refusal
- * ahead of the up-only one: a block missing a line is a record fault, and a reader sent to argue
- * about scores over a half-written block has been sent to the wrong question.
- */
-function figureIn(lines, block, field, gate, recordFile) {
-    const pattern = fieldLine(field);
-    for (let at = block.from; at < block.to; at += 1) {
-        const written = pattern.exec(lines[at] ?? "");
-        if (written !== null)
-            return { at, value: Number(written[2]) };
-    }
-    throw new MalformedRecordError(recordFile, MUTATION_GATES, gate, field, "the gate's block holds no such line, so there is nothing to rewrite it into.");
-}
-/**
- * Refuse a measurement that is not a raise, naming both scores and the one route down.
- *
- * ASKED OF THE SCORE, NEVER OF THE PAIR. A run that moved both of its counts and held its ratio
- * exactly is a run that raises nothing, and a recorder written as "the very same two figures" writes
- * it — a record rewritten to say what it already said.
- */
-function refuseUnlessRaised(gate, banked, measurement, recordFile) {
-    if (scoreRoseOver(measurement.detected, measurement.total, banked.detected, banked.total))
-        return;
-    throw new FallRefusedError(recordFile, gate, banked, measurement);
-}
-/** One located line with its figure rewritten, and every byte of its spacing kept. */
-function rewritten(line, field, value) {
-    return line.replace(fieldLine(field), `$1${value}$3`);
-}
-/**
- * Raise a gate's two recorded figures to a measurement, leaving every other byte alone.
- *
- * @param text the record file's own bytes, as authored
- * @param gate the gate to raise, as the caller names it
- * @param measurement the run whose counts are being banked
- * @param recordFile the name the record is filed under, so a refusal can say which file it read
- * @returns the same bytes with two numerals different
- * @throws MalformedRecordError when the record writes no block for the gate, or that block holds no
- *   line to rewrite — named by the line, never passed over and never sought outside the block.
- * @throws FallRefusedError when the measurement does not score above what the gate already banks.
- *   There is no input that writes it anyway.
- */
-export function raisedRecordText(text, gate, measurement, recordFile) {
-    const lines = text.split("\n");
-    const block = gateBlockOf(lines, gate, recordFile);
-    const detected = figureIn(lines, block, "detected", gate, recordFile);
-    const total = figureIn(lines, block, "total", gate, recordFile);
-    refuseUnlessRaised(gate, { detected: detected.value, total: total.value }, measurement, recordFile);
-    lines[detected.at] = rewritten(lines[detected.at] ?? "", "detected", measurement.detected);
-    lines[total.at] = rewritten(lines[total.at] ?? "", "total", measurement.total);
-    return lines.join("\n");
-}
-/**
- * Write a raised record back over the file it was read from, resolved against the caller's tree.
- *
- * THE ROOT ARRIVES, AND IS NEVER THIS MODULE'S OWN LOCATION. A recorder that joined the directory it
- * was installed into is correct only while it sits inside the tree it is writing to, and stops
- * being so the moment it is installed as a dependency of one.
- *
- * READ AND WRITTEN IN THE SAME ENCODING, so the round trip through the filesystem is a round trip
- * rather than a transcoding — the whole promise of this module being that what comes back out is
- * what went in.
- *
- * @param root the CONSUMER'S workspace
- * @param recordFile where the record sits, relative to that root
- * @param gate the gate to raise, as the caller names it
- * @param measurement the run whose counts are being banked
- * @returns the path that was written, so a caller can say where the record now stands
- */
-export function bankRaisedRecord(root, recordFile, gate, measurement) {
-    const at = join(root, recordFile);
-    const raised = raisedRecordText(readFileSync(at, "utf8"), gate, measurement, recordFile);
-    writeFileSync(at, raised, "utf8");
-    return at;
-}
-//# sourceMappingURL=ratchet.js.map

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

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

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

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-/**
- * THE COMMAND — one gate's run reconciled against its record, and the run that asked ending on the
- * answer (@SCN-RAT-015, 3F-2805).
- *
- *     --gate <name> --report <path> [--root <dir>] [--record-file <path>]
- *                   [--bank-command <text>] [--record]
- *
- * WHY THERE IS A COMMAND AT ALL. Every module beneath this one settles what the verdict IS, and a
- * verdict handed back as a value is a verdict nobody's pipeline can read. A pipeline observes one
- * thing about a step — how it ended — so the last piece of this library is the piece that ends.
- *
- * THREE ENDINGS, AND THE THIRD IS THE ONE WORTH BUILDING FOR. A gate that stands ends cleanly and a
- * gate that does not ends in failure; between them they are what a pipeline is watching for, and
- * telling them apart is arithmetic that is already done by the time this file runs. The third is a
- * run that was CALLED wrong, and it must wear neither of the other two. A name left off, reported as
- * a gate that does not stand, sends somebody hunting through their code for a regression that never
- * happened; reported as a gate that stands, it is a bar that quietly stopped being read at all. So
- * it takes the ending this repository already reserves for "this run is broken" as against "the code
- * is wrong", which every other step here that can be misused already uses.
- *
- * A FLAG NEVER SWALLOWS THE NEXT FLAG AS ITS VALUE. `--report --record` read leniently is a report
- * sought at a path called `--record`, found missing, and answered with a sweep that never ran — a
- * reading that sends its reader to look at their runner when what happened was a typo one character
- * long. Anything beginning with two dashes is a flag, never a value.
- *
- * THE REPORT'S PATH IS REQUIRED AND THE RECORD'S NAME IS NOT, and the asymmetry is a ruling rather
- * than an oversight, carried up from the composition beneath. Where a sweep drops its output is a
- * RUNNER'S convention, so a default there would be this file naming a runner. The record's name
- * belongs to whoever owns the record, so the conventional one stands in and a caller who files their
- * bars elsewhere writes it over.
- *
- * AND THE TREE DEFAULTS TO A RELATIVE ONE RATHER THAN TO ANYWHERE THIS FILE CAN FIND. `.` is the
- * caller's own working directory, resolved by the platform at the moment of the read; a root taken
- * from where this file is INSTALLED agrees with its caller for exactly as long as it sits beside
- * that caller's code, and stops the day it ships as a dependency — resolving quietly into a package
- * folder, reading nothing, and reporting a gate that measured perfectly as a gate that never ran.
- *
- * A REFUSAL TO BANK IS AN EXPECTED ENDING RATHER THAN A CRASH. Asking whether there is anything to
- * bank is what an operator types, and most of the time the answer is no. Handed out as an unhandled
- * fall it arrives as a stack trace — a reading that says the tool broke where what happened was the
- * tool working, and one that buries the refusal's own sentence, which is the only part of it anybody
- * needed. So the refusal is caught by its own type, its reason is what the reader gets, and the run
- * ends in failure because there was nothing to bank.
- *
- * AND THERE IS NO WAY PAST THAT REFUSAL HERE EITHER. The recorder beneath takes four inputs and
- * offers no fifth; this file adds no flag that would ask it to write a fall, and @SCN-RAT-012 reads
- * these bytes to say so rather than trusting them. A record that must come down comes down by hand,
- * with the reason in the commit, because an escape hatch a tool holds open is one nobody ever has to
- * justify.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY — the usage line
- * included, which is where such a name most easily hides, being read by people rather than by tests.
- * @SCN-RAT-014 reads these bytes for that too.
- */
-export {};
-//# sourceMappingURL=ratchetCli.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ratchetCli.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/ratchetCli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG"}

package/dist/mutation-ratchet/ratchetCli.js

@@ -1,139 +0,0 @@
-#!/usr/bin/env node
-/**
- * THE COMMAND — one gate's run reconciled against its record, and the run that asked ending on the
- * answer (@SCN-RAT-015, 3F-2805).
- *
- *     --gate <name> --report <path> [--root <dir>] [--record-file <path>]
- *                   [--bank-command <text>] [--record]
- *
- * WHY THERE IS A COMMAND AT ALL. Every module beneath this one settles what the verdict IS, and a
- * verdict handed back as a value is a verdict nobody's pipeline can read. A pipeline observes one
- * thing about a step — how it ended — so the last piece of this library is the piece that ends.
- *
- * THREE ENDINGS, AND THE THIRD IS THE ONE WORTH BUILDING FOR. A gate that stands ends cleanly and a
- * gate that does not ends in failure; between them they are what a pipeline is watching for, and
- * telling them apart is arithmetic that is already done by the time this file runs. The third is a
- * run that was CALLED wrong, and it must wear neither of the other two. A name left off, reported as
- * a gate that does not stand, sends somebody hunting through their code for a regression that never
- * happened; reported as a gate that stands, it is a bar that quietly stopped being read at all. So
- * it takes the ending this repository already reserves for "this run is broken" as against "the code
- * is wrong", which every other step here that can be misused already uses.
- *
- * A FLAG NEVER SWALLOWS THE NEXT FLAG AS ITS VALUE. `--report --record` read leniently is a report
- * sought at a path called `--record`, found missing, and answered with a sweep that never ran — a
- * reading that sends its reader to look at their runner when what happened was a typo one character
- * long. Anything beginning with two dashes is a flag, never a value.
- *
- * THE REPORT'S PATH IS REQUIRED AND THE RECORD'S NAME IS NOT, and the asymmetry is a ruling rather
- * than an oversight, carried up from the composition beneath. Where a sweep drops its output is a
- * RUNNER'S convention, so a default there would be this file naming a runner. The record's name
- * belongs to whoever owns the record, so the conventional one stands in and a caller who files their
- * bars elsewhere writes it over.
- *
- * AND THE TREE DEFAULTS TO A RELATIVE ONE RATHER THAN TO ANYWHERE THIS FILE CAN FIND. `.` is the
- * caller's own working directory, resolved by the platform at the moment of the read; a root taken
- * from where this file is INSTALLED agrees with its caller for exactly as long as it sits beside
- * that caller's code, and stops the day it ships as a dependency — resolving quietly into a package
- * folder, reading nothing, and reporting a gate that measured perfectly as a gate that never ran.
- *
- * A REFUSAL TO BANK IS AN EXPECTED ENDING RATHER THAN A CRASH. Asking whether there is anything to
- * bank is what an operator types, and most of the time the answer is no. Handed out as an unhandled
- * fall it arrives as a stack trace — a reading that says the tool broke where what happened was the
- * tool working, and one that buries the refusal's own sentence, which is the only part of it anybody
- * needed. So the refusal is caught by its own type, its reason is what the reader gets, and the run
- * ends in failure because there was nothing to bank.
- *
- * AND THERE IS NO WAY PAST THAT REFUSAL HERE EITHER. The recorder beneath takes four inputs and
- * offers no fifth; this file adds no flag that would ask it to write a fall, and @SCN-RAT-012 reads
- * these bytes to say so rather than trusting them. A record that must come down comes down by hand,
- * with the reason in the commit, because an escape hatch a tool holds open is one nobody ever has to
- * justify.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY — the usage line
- * included, which is where such a name most easily hides, being read by people rather than by tests.
- * @SCN-RAT-014 reads these bytes for that too.
- */
-import { join } from "node:path";
-import { bankRaisedRecord, FallRefusedError } from "./ratchet.js";
-import { RECORD_FILE, reconcileGate } from "./reconcile.js";
-import { readMutationReport } from "./report.js";
-/**
- * What to type to bank a measurement, when the caller has not said.
- *
- * TRUE OF EVERY CALLER, WHICH IS THE ONLY KIND OF DEFAULT THIS TERM CAN HAVE. A project's real
- * instruction is its own sentence — its script, its runner, its file — so one written here would be
- * somebody else's, sitting inside a message, reached only on the runs nobody reads twice. What is
- * left that is true anywhere is this command itself, which can bank a measurement and is already in
- * the reader's hand.
- */
-const BANK_IT_WITH = "this same command, asked to bank the measurement";
-/**
- * A fault in how this was CALLED — the ending reserved for "this run is broken".
- *
- * ONLY how it was called. What the record holds and what the report measured never come here: a
- * gate that lost kills is the code being wrong, which is a verdict, and a verdict has an ending of
- * its own two lines below.
- */
-function usage(problem) {
-    console.error(`ratchet: ${problem}`);
-    console.error("ratchet: usage — --gate <name> --report <path> [--root <dir>] " +
-        "[--record-file <path>] [--bank-command <text>] [--record]");
-    process.exit(2);
-}
-/** The value a `--flag` was given, or undefined where the flag is absent. */
-function flagValue(flags, name) {
-    const at = flags.indexOf(name);
-    if (at === -1)
-        return undefined;
-    const value = flags[at + 1];
-    // Two dashes are a flag, never a value: see the argument at the head of this file.
-    if (value === undefined || value.startsWith("--"))
-        usage(`${name} needs a value`);
-    return value;
-}
-/** Read the command line into the reconciliation it names. */
-function reconciliationOf(argv) {
-    return {
-        gate: flagValue(argv, "--gate") ?? usage("--gate names the gate to reconcile"),
-        reportPath: flagValue(argv, "--report") ?? usage("--report names where this gate's run left its report"),
-        root: flagValue(argv, "--root") ?? ".",
-        recordFile: flagValue(argv, "--record-file") ?? RECORD_FILE,
-        bankCommand: flagValue(argv, "--bank-command") ?? BANK_IT_WITH,
-        banking: argv.includes("--record"),
-    };
-}
-const asked = reconciliationOf(process.argv.slice(2));
-const verdict = reconcileGate({
-    gate: asked.gate,
-    root: asked.root,
-    reportPath: asked.reportPath,
-    bankCommand: asked.bankCommand,
-    recordFile: asked.recordFile,
-});
-// EVERY RUN, AND BEFORE ANYTHING ELSE HAPPENS. The verdict is what was asked for, whichever way the
-// run goes on to end, and a reader whose run banked a measurement still wants to know what it was
-// that made banking worth doing.
-console.log(verdict.message);
-if (!asked.banking)
-    process.exit(verdict.ok ? 0 : 1);
-// A run with nothing measured has nothing to bank, and the verdict above has already said so in the
-// sentence that belongs to it. There is no second reading of the same absence to write here.
-const read = readMutationReport(asked.gate, join(asked.root, asked.reportPath));
-if (!read.ok)
-    process.exit(1);
-try {
-    const at = bankRaisedRecord(asked.root, asked.recordFile, asked.gate, read.measurement);
-    console.log(`ratchet: ${asked.gate} — the record at ${at} now states ` +
-        `${read.measurement.detected} of ${read.measurement.total}.`);
-}
-catch (raised) {
-    // BY ITS OWN TYPE, AND NOTHING WIDER. A blanket catch here would answer a record nobody can read,
-    // a tree that is not there and a fault nobody has thought of yet with the one sentence written for
-    // a run that simply had nothing to bank — which is the reading that sends its reader hunting for a
-    // measurement when what they have is a broken file.
-    if (!(raised instanceof FallRefusedError))
-        throw raised;
-    console.error(raised.message);
-    process.exit(1);
-}
-//# sourceMappingURL=ratchetCli.js.map

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

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

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

@@ -1,82 +0,0 @@
-/**
- * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
- * arriving from that project (@SCN-RAT-014, 3F-2804).
- *
- * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
- * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
- * reference implementation this library was lifted from was generic in all of them too — right up
- * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
- * next. Those four answers were written into the code there, and they are the four that arrive
- * here as a request instead.
- *
- * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
- * that fails silently rather than loudly. A module finding the tree from where it is installed
- * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
- * in the repository it was written in, and stops doing the day it is installed as a dependency,
- * when it resolves into its own directory inside a package folder and finds nothing there. There
- * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
- * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
- * path below is joined onto it.
- *
- * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
- * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
- * default there would be this module naming a runner — the exact leak the Rule above it forbids.
- * The record's name is owned by whoever owns the record, so a conventional default costs its
- * owner nothing and a caller who wants another writes one.
- *
- * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
- * be banked have to say what to type, and what to type is a sentence only the calling project can
- * write. Left to this module it would be somebody's script name, sitting inside a message, reached
- * only on the runs nobody reads twice.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
- * asserts that over this module's own bytes rather than trusting it.
- */
-import { type MutationVerdict } from "./verdict.js";
-/**
- * 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.
- */
-export declare const RECORD_FILE = "quality-thresholds.yml";
-/**
- * One reconciliation, as the calling project states it.
- *
- * EVERY FIELD IS A TERM THE PROJECT OWNS. There is nothing else here — no setting, no mode, no
- * threshold of this module's own. The bar is in the project's record and the run is in the
- * project's report; what this asks for is where those two are and what to call things.
- */
-export interface RatchetRequest {
-    /** The gate to reconcile, as the project's own record names it. */
-    readonly gate: string;
-    /**
-     * The CONSUMER'S workspace — the tree the record and the report both sit in.
-     *
-     * Never this module's own installed location, which is the same tree only by coincidence and
-     * only until the day this ships as something another repository installs.
-     */
-    readonly root: string;
-    /**
-     * Where the gate's run left its report, relative to that root.
-     *
-     * REQUIRED, AND THAT IS THE RULING. A default here would be a runner's output convention wearing
-     * this module's name.
-     */
-    readonly reportPath: string;
-    /** What the project's own people type to bank a measurement, carried into the verdicts that ask. */
-    readonly bankCommand: string;
-    /** Where the project's record sits, relative to that root. Defaults to {@link RECORD_FILE}. */
-    readonly recordFile?: string;
-}
-/**
- * Reconcile one gate's run against the bar its project's record states.
- *
- * @param request the five terms the calling project owns
- * @returns the verdict, red or green, carrying the line its reader gets
- * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
- */
-export declare function reconcileGate(request: RatchetRequest): MutationVerdict;
-//# sourceMappingURL=reconcile.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAOH,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,2BAA2B,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+FAA+F;IAC/F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAWtE"}

package/dist/mutation-ratchet/reconcile.js

@@ -1,67 +0,0 @@
-/**
- * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
- * arriving from that project (@SCN-RAT-014, 3F-2804).
- *
- * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
- * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
- * reference implementation this library was lifted from was generic in all of them too — right up
- * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
- * next. Those four answers were written into the code there, and they are the four that arrive
- * here as a request instead.
- *
- * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
- * that fails silently rather than loudly. A module finding the tree from where it is installed
- * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
- * in the repository it was written in, and stops doing the day it is installed as a dependency,
- * when it resolves into its own directory inside a package folder and finds nothing there. There
- * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
- * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
- * path below is joined onto it.
- *
- * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
- * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
- * default there would be this module naming a runner — the exact leak the Rule above it forbids.
- * The record's name is owned by whoever owns the record, so a conventional default costs its
- * owner nothing and a caller who wants another writes one.
- *
- * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
- * be banked have to say what to type, and what to type is a sentence only the calling project can
- * write. Left to this module it would be somebody's script name, sitting inside a message, reached
- * only on the runs nobody reads twice.
- *
- * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
- * asserts that over this module's own bytes rather than trusting it.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { gateRecordFor, parseGateRecords } from "./record.js";
-import { readMutationReport } from "./report.js";
-import { noMeasurement, verdictFor } from "./verdict.js";
-/**
- * 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.
- */
-export const RECORD_FILE = "quality-thresholds.yml";
-/**
- * Reconcile one gate's run against the bar its project's record states.
- *
- * @param request the five terms the calling project owns
- * @returns the verdict, red or green, carrying the line its reader gets
- * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
- */
-export function reconcileGate(request) {
-    const recordFile = request.recordFile ?? RECORD_FILE;
-    const records = parseGateRecords(readFileSync(join(request.root, recordFile), "utf8"), recordFile);
-    const record = gateRecordFor(request.gate, records, recordFile);
-    const read = readMutationReport(request.gate, join(request.root, request.reportPath));
-    // A refusal is carried through as the verdict it implies rather than as an absence: a report that
-    // is not there is a gate that produced no score, which is not a gate that passed.
-    return read.ok
-        ? verdictFor(record, read.measurement, request.bankCommand)
-        : noMeasurement(request.gate, read.reason);
-}
-//# sourceMappingURL=reconcile.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAwB,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,wBAAwB,CAAC;AAgCpD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,OAAuB;IACnD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,WAAW,CAAC;IACrD,MAAM,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC;IACnG,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAEtF,kGAAkG;IAClG,kFAAkF;IAClF,OAAO,IAAI,CAAC,EAAE;QACZ,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;QAC3D,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC"}