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

package/dist/corpus/cli.js

@@ -1,128 +0,0 @@
-/**
- * The `tags` command — `spec-controller tags`, the `@SCN` scheme policing itself over a
- * target's Gherkin corpus.
- *
- * THIS EDGE OWNS ONLY THE READS. The rule is `corpusFaults`, in core, reached through the ROOT
- * barrel and nothing else: `./internal` is dropped by `publishConfig.exports` at pack time, and
- * this module travels in the tarball. That is not a style preference — an installed
- * `balance --help` once threw ERR_PACKAGE_PATH_NOT_EXPORTED behind thirteen green gates because a
- * published module reached that subpath (3F-3086). So what happens here is: discover the corpus,
- * read the manifest, build the mutation-record reader, hand over the bytes.
- *
- * ITS OWN COMMAND RATHER THAN A `balance` FLAG. `balance`'s exit code IS its verdict — 0
- * balanced, 1 out of balance, 3 pending-under-strict, 4 unsound, 5 nothing to reconcile — and a
- * corpus FAULT is not a reconciliation verdict. A flag would either overload one of those codes or
- * add a further meaning to a status a consumer's CI branches on. A second command costs one registry entry and gives
- * the fault its own ladder:
- *
- *   0 — the corpus obeys the scheme.
- *   1 — findings; the corpus was read and it breaks a rule.
- *   2 — the corpus (or the manifest) could not be READ at all. Not a verdict, because nothing was
- *       concluded. Sibling to @SCN-CLI-014/015/016 on `balance`, and the same argument: an input
- *       the tool cannot read is a usage error, never a verdict.
- *
- * Usage:
- *   spec-controller tags [--features <dir>] [--package-json <path>]
- */
-import { existsSync, readFileSync } from "node:fs";
-import { corpusFaults } from "@3f-consulting/spec-controller-core";
-import { cliRegistry, renderCommandHelp } from "../cli-registry.js";
-import { checkUnknownFlags, parseArgs } from "../cli-args.js";
-import { DEFAULT_DEFERRAL_TAGS } from "../deferralTags.js";
-import { UnreadableFeatureCorpusError } from "../ingest/gherkinValidation.js";
-import { discoverFeatures } from "../ingest/ingestScenarios.js";
-import { killFloorReaderFor } from "../ingest/ingestQualityChecks.js";
-import { resolveTargetRoot, resolveToolIdentity } from "../run-management/resolveRunInputs.js";
-/**
- * Read everything the rule takes, or say why it could not be read.
- *
- * ONE PLACE, ONE STATUS, because it is one Rule. A corpus the Gherkin parser rejects, a features
- * directory that is not there, and a manifest that is not JSON are three spellings of "the tool
- * could not read its input" — and every one of them, left to escape, lands on Node's default exit
- * 1, which is this command's code for FINDINGS. A crashed invocation would then be
- * indistinguishable by status from a corpus that genuinely breaks a rule, which is exactly the
- * collision 3F-1742 closed on `balance`.
- *
- * THE PARSE REFUSAL IS INHERITED, NOT RESTATED (@SCN-GPG-001). `discoverFeatures` refuses a corpus
- * cucumber could not run rather than returning one, so this command gets that refusal by going
- * through the shared discovery — the same way `balance` does — and what is left here is turning
- * it into this command's status. Its message carries the parser's own words verbatim.
- *
- * THE SOURCES ARE READ HERE because the rule is pure and takes bytes. `DiscoveredFeature` carries
- * the header code and the scenario ids but not the file's text, and the grammar rules that follow
- * this one need the text to walk the tags.
- */
-function readCorpusInputs(featuresDir, manifestPath) {
-    try {
-        const discovered = featuresDir === undefined ? discoverFeatures() : discoverFeatures(featuresDir);
-        return {
-            ok: true,
-            features: discovered.map((f) => ({
-                slug: f.slug,
-                featureCode: f.featureCode,
-                source: readFileSync(f.path, "utf8"),
-            })),
-            packageJson: existsSync(manifestPath)
-                ? JSON.parse(readFileSync(manifestPath, "utf8"))
-                : {},
-            root: resolveTargetRoot({ features: featuresDir }),
-        };
-    }
-    catch (err) {
-        if (err instanceof UnreadableFeatureCorpusError)
-            return { ok: false, error: err.message };
-        const failure = err instanceof Error ? err.message : String(err);
-        return { ok: false, error: `The corpus could not be read: ${failure}` };
-    }
-}
-/**
- * Police a target's corpus against the `@SCN` scheme's own rules.
- *
- * `process.exitCode` RATHER THAN `process.exit`, so whatever has been written is flushed intact
- * rather than truncated mid-write — the convention `balance`'s own gate settled on.
- */
-export function runTags(argv) {
-    // Answer `--help`/`-h` from the registry BEFORE any parse, so it never falls through as a stray
-    // flag while the command runs anyway. The registry is the single source, so a flag that exists
-    // is a flag that appears in help — there is no hand-kept list here to drift.
-    if (argv.includes("--help") || argv.includes("-h")) {
-        process.stdout.write(renderCommandHelp(cliRegistry, "tags") + "\n");
-        return;
-    }
-    const args = parseArgs(argv);
-    // Registry-bounded parse (@SCN-CLI-009's rule, applied to this command's own scope): `tags`
-    // accepts ONLY the flags its registry entry lists. By construction, not by assertion — the
-    // helper is the one `balance` uses, given this command's name.
-    const unknownFlagError = checkUnknownFlags(args, cliRegistry, "tags", resolveToolIdentity().toolVersion);
-    if (unknownFlagError) {
-        process.stderr.write(unknownFlagError + "\n");
-        process.exitCode = 2;
-        return;
-    }
-    // `--package-json` defaults to the manifest at the cwd, matching `balance`'s default: the
-    // target is the tree you are standing in unless you say otherwise.
-    const inputs = readCorpusInputs(args["features"], args["package-json"] ?? "package.json");
-    if (!inputs.ok) {
-        process.stderr.write(inputs.error + "\n");
-        process.exitCode = 2;
-        return;
-    }
-    const faults = corpusFaults({
-        features: inputs.features,
-        packageJson: inputs.packageJson,
-        // The STARTER deferral set — the application layer's own policy, which a target's config may
-        // only extend. Single-sourced here for the reason the reconcile composition takes it as a
-        // parameter: which words the community recognises is the product's answer, not the engine's.
-        deferralTags: DEFAULT_DEFERRAL_TAGS,
-        killFloor: killFloorReaderFor(inputs.root),
-    });
-    if (faults.length === 0) {
-        process.stdout.write("tags: OK — every feature code names one feature file, and every tag on the corpus obeys the @SCN scheme's own rules.\n");
-        return;
-    }
-    process.stderr.write(`tags: FAILED — ${faults.length} finding(s):\n`);
-    for (const fault of faults)
-        process.stderr.write(`  ${fault.message}\n`);
-    process.exitCode = 1;
-}
-//# sourceMappingURL=cli.js.map

package/dist/corpus/cli.js.map

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

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

@@ -1,46 +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. 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 is what a PUBLISHED surface is owed, and 3F-2859
- * stopped publishing this one: 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 this barrel a
- * change to a contract nobody holds.
- */
-export { floorOf, gateRecordFor, killFloorOf, MalformedRecordError, parseGateRecords, RECORD_FILE, type GateRecord as MutationGateRecord, } from "./record.js";
-export { measurementFromReport, readMutationReport, type MutationMeasurement, type MutationReportRead, } from "./report.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EACL,OAAO,EACP,aAAa,EACb,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,KAAK,UAAU,IAAI,kBAAkB,GACtC,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,aAAa,CAAC"}

package/dist/mutation-ratchet/index.js

@@ -1,46 +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. 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 is what a PUBLISHED surface is owed, and 3F-2859
- * stopped publishing this one: 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 this barrel a
- * change to a contract nobody holds.
- */
-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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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"}