@3f-consulting/spec-controller-core 0.1.0-alpha.4 → 0.1.0-alpha.5

package/dist/parse/corpusClaimFaults.d.ts

@@ -1,104 +0,0 @@
-/**
- * THE CLAIM RULE of `spec-controller tags` — how many checks ONE scenario may claim. Its siblings
- * hold the other two questions: `corpusCodeFaults.ts` whether a feature code binds to one feature
- * file, `corpusGrammarFaults.ts` whether a tag means anything at all. `corpusFaults.ts` composes
- * the three and is the only entry point any of them has.
- *
- * WHY IT IS NOT A GRAMMAR RULE, WHICH IS THE SEAM THIS MODULE IS DRAWN ON. The grammar arm asks
- * *does this word mean something here*, and answers it one tag at a time against a set. This asks
- * *does this scenario claim too many of the words that do* — a different question, over the same
- * set, whose verdict belongs to the SCENARIO rather than to any tag on it. A grammar rule that
- * redded a legitimate word would be wrong; this one reds two legitimate words for being on one
- * line. Two questions, two modules — and the joined module would have carried the grammar clauses
- * past the 400-line `max-lines` ceiling, which canon answers with a split and never with an
- * exception entry (@SCN-CPX-001).
- *
- * THE SET IS NOT ASSEMBLED HERE. `checkTagsOf` is the grammar module's, and it is imported rather
- * than rebuilt: a rule counting a NARROWER set than the grammar admits would green a corpus
- * claiming two checks by one of the words the grammar had just called legitimate, and a WIDER one
- * would red a word no obligation is ever raised from. That is not a hypothetical — the floor and
- * the obligation rule each assembled their own copy of this set, came to disagree about it, and
- * cost a slice to bring back (3F-3126). One assembly, two questions asked over it.
- */
-import type { CorpusFault, CorpusFile, TargetManifest } from "./corpusFaults.js";
-import { type KillFloorReader } from "./targetManifest.js";
-/**
- * A scenario whose tags name more than one check (@SCN-STG-007).
- *
- * ONE CHECK PER FITNESS SCENARIO is canon (`fitness-functions.md`). @SCN-LNT-008 already enforces
- * it from the CREDIT side — one run is not evidence for two scenarios, and the runner-up reads
- * missing — but that arm only ever sees two scenarios reaching one check. The fault running the
- * other way is invisible to it: two runs citing one scenario are two honest credits, and nothing
- * about them says the corpus is wrong.
- *
- * AND THE LEDGER IS BLIND TO IT, MEASURED RATHER THAN ARGUED. A stepless scenario carrying two
- * registered bare check tags, both handles wired in CI, reconciles BALANCED at exit 0 — two
- * Evidence Obligations, two Evidence Observations, nothing out of balance and nothing pending.
- * Every other assertion this command makes has some cell of a reconciliation that already names
- * the fault; this one has none, in any cut, at any exit status. That measurement is the whole
- * reason the rule ships rather than being left to the ledger beside it.
- *
- * IT DOES NOT MAKE THE MODEL'S SOUNDNESS OPTIONAL. A registry mapping two handles onto one check
- * reaches the same collision with no corpus fault for this to see, which is why @SCN-LNT-012
- * stamps each credit with its own bare tag as well. Mechanism and model, not one or the other;
- * what this adds is that the collision becomes unconstructible from a feature file, at the moment
- * the author is looking at it and the fix is one line.
- *
- * NOTHING ABOUT SHAPE (3F-3126). It first shipped asking only about a STEPLESS scenario, on the
- * argument that a stepped row riding two check tags has a different fault — it names no tier — so
- * telling it "two checks" would send the author to delete a tag when what they owe is a tier. That
- * argument was downstream of the tier floor and true only while the floor redded such a row as
- * tier-less; 3F-3133 stopped it doing that, and the shipped command carries no floor at all. Steps
- * are a fact about how a row is written; the check tag is the claim about which axis it is on
- * (3F-3115). A scenario carrying two check tags meant two scenarios however it was written.
- *
- * DISTINCT WORDS, NOT TAG OCCURRENCES, and this clause is new rather than moved. The walk here is
- * `parseTaggedScenarios`, which inherits Feature- and Rule-level tags onto every scenario beneath
- * exactly as cucumber does — so a check tag hoisted to a `Rule:` and repeated on one of its
- * scenarios arrives TWICE in one tag list. Counting occurrences would red that scenario for
- * claiming `@complexity` and `@complexity`, a finding whose own message reads as nonsense. The
- * private check this rule replaced never met the case because it read a scenario's own tag block
- * and nothing above it — which is precisely the second reading `parseTaggedScenarios` exists to
- * end, arriving here as a fault of its own rather than as a missed one.
- *
- * BOTH TAGS NAMED, IN DOCUMENT ORDER. The author has to choose which scenario keeps which check,
- * and a message naming one of them has already chosen for them; the order is the walk's own —
- * a scenario's OWN tags first, then what it inherits — so the message reads like the line.
- *
- * AND THE REMEDY NAMES NO SHAPE (3F-3133). It read "Split it into one stepless scenario per
- * check", which was sound only while the floor redded a stepped check-tagged row as tier-less: an
- * author who split into two STEPPED rows would have been sent back by it. Both halves of the split
- * are admissible however they are written, and an instruction to strip the steps would be this
- * rule prescribing the very shape 3F-3097 exists to stop assuming.
- *
- * ASKED OF UNPARKED SCENARIOS ONLY (operator ruling, 3F-2655). This rule first shipped saying the
- * opposite — that a parking tag defers what a scenario OWES and so has nothing to say about what
- * it IS. Both readings agree the split is the same edit whenever it happens; they disagree about
- * whether an author who has already said "not yet" should be made to do it now, and canon says no:
- * parking is a SKIP-SIGNAL, and out of scope is not a place where some questions still get asked.
- * The skip is not an ERASURE, which is a separate claim and a separate arm: unpark the scenario
- * and the same two tags red again, unchanged.
- *
- * THE SCOPE IS A CLAUSE HERE, AND IT USED TO BE A POSITION. Inside the private check the rules
- * shared one walk, so parking was enforced by where this rule sat in it — below the grammar
- * question, above everything else — and the rule never had to know what parking was. Three rule
- * functions over one corpus have no shared walk to be positioned in, so the clause is written out.
- * What the position bought is unchanged and is now structural rather than remembered: the grammar
- * arm has no parking clause AT ALL, so a parked scenario's tags are still read for well-formedness
- * — parking defers what a scenario owes and what shape it must have, never whether its tags are
- * spelled right, and the deferral set is the very thing that lets that arm recognise the parking
- * tag. `@wip @untit` cannot go quiet.
- *
- * @param features the target's discovered feature files, read once at the edge.
- * @param packageJson the TARGET's manifest, read HERE through the same resolvers the grammar arm
- * reads it with — one reading of `specController.deferralTags` (@SCN-PND-021), and `checkTagsOf`
- * for the three sources of what names a check.
- * @param starterDeferralTags the APPLICATION layer's starter set, which a target's config may only
- * extend and never replace. A parameter because it is product policy; a copy held in core would be
- * a second statement of it.
- * @param killFloor the reader over the TARGET's mutation records, threaded through to the
- * threshold resolution inside `checkTagsOf` because a bar may name a gate rather than a figure
- * (@SCN-MUT-012).
- */
-export declare function multipleCheckTags(features: readonly CorpusFile[], packageJson: TargetManifest, starterDeferralTags: readonly string[], killFloor: KillFloorReader): CorpusFault[];
-//# sourceMappingURL=corpusClaimFaults.d.ts.map

package/dist/parse/corpusClaimFaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpusClaimFaults.d.ts","sourceRoot":"","sources":["../../src/parse/corpusClaimFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGjF,OAAO,EAAE,KAAK,eAAe,EAAuB,MAAM,qBAAqB,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,WAAW,EAAE,cAAc,EAC3B,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,SAAS,EAAE,eAAe,GACzB,WAAW,EAAE,CAsBf"}

package/dist/parse/corpusClaimFaults.js

@@ -1,128 +0,0 @@
-/**
- * THE CLAIM RULE of `spec-controller tags` — how many checks ONE scenario may claim. Its siblings
- * hold the other two questions: `corpusCodeFaults.ts` whether a feature code binds to one feature
- * file, `corpusGrammarFaults.ts` whether a tag means anything at all. `corpusFaults.ts` composes
- * the three and is the only entry point any of them has.
- *
- * WHY IT IS NOT A GRAMMAR RULE, WHICH IS THE SEAM THIS MODULE IS DRAWN ON. The grammar arm asks
- * *does this word mean something here*, and answers it one tag at a time against a set. This asks
- * *does this scenario claim too many of the words that do* — a different question, over the same
- * set, whose verdict belongs to the SCENARIO rather than to any tag on it. A grammar rule that
- * redded a legitimate word would be wrong; this one reds two legitimate words for being on one
- * line. Two questions, two modules — and the joined module would have carried the grammar clauses
- * past the 400-line `max-lines` ceiling, which canon answers with a split and never with an
- * exception entry (@SCN-CPX-001).
- *
- * THE SET IS NOT ASSEMBLED HERE. `checkTagsOf` is the grammar module's, and it is imported rather
- * than rebuilt: a rule counting a NARROWER set than the grammar admits would green a corpus
- * claiming two checks by one of the words the grammar had just called legitimate, and a WIDER one
- * would red a word no obligation is ever raised from. That is not a hypothetical — the floor and
- * the obligation rule each assembled their own copy of this set, came to disagree about it, and
- * cost a slice to bring back (3F-3126). One assembly, two questions asked over it.
- */
-import { checkTagsOf } from "./corpusGrammarFaults.js";
-import { parseTaggedScenarios } from "./scenarios.js";
-import { resolveDeferralTags } from "./targetManifest.js";
-/**
- * A scenario whose tags name more than one check (@SCN-STG-007).
- *
- * ONE CHECK PER FITNESS SCENARIO is canon (`fitness-functions.md`). @SCN-LNT-008 already enforces
- * it from the CREDIT side — one run is not evidence for two scenarios, and the runner-up reads
- * missing — but that arm only ever sees two scenarios reaching one check. The fault running the
- * other way is invisible to it: two runs citing one scenario are two honest credits, and nothing
- * about them says the corpus is wrong.
- *
- * AND THE LEDGER IS BLIND TO IT, MEASURED RATHER THAN ARGUED. A stepless scenario carrying two
- * registered bare check tags, both handles wired in CI, reconciles BALANCED at exit 0 — two
- * Evidence Obligations, two Evidence Observations, nothing out of balance and nothing pending.
- * Every other assertion this command makes has some cell of a reconciliation that already names
- * the fault; this one has none, in any cut, at any exit status. That measurement is the whole
- * reason the rule ships rather than being left to the ledger beside it.
- *
- * IT DOES NOT MAKE THE MODEL'S SOUNDNESS OPTIONAL. A registry mapping two handles onto one check
- * reaches the same collision with no corpus fault for this to see, which is why @SCN-LNT-012
- * stamps each credit with its own bare tag as well. Mechanism and model, not one or the other;
- * what this adds is that the collision becomes unconstructible from a feature file, at the moment
- * the author is looking at it and the fix is one line.
- *
- * NOTHING ABOUT SHAPE (3F-3126). It first shipped asking only about a STEPLESS scenario, on the
- * argument that a stepped row riding two check tags has a different fault — it names no tier — so
- * telling it "two checks" would send the author to delete a tag when what they owe is a tier. That
- * argument was downstream of the tier floor and true only while the floor redded such a row as
- * tier-less; 3F-3133 stopped it doing that, and the shipped command carries no floor at all. Steps
- * are a fact about how a row is written; the check tag is the claim about which axis it is on
- * (3F-3115). A scenario carrying two check tags meant two scenarios however it was written.
- *
- * DISTINCT WORDS, NOT TAG OCCURRENCES, and this clause is new rather than moved. The walk here is
- * `parseTaggedScenarios`, which inherits Feature- and Rule-level tags onto every scenario beneath
- * exactly as cucumber does — so a check tag hoisted to a `Rule:` and repeated on one of its
- * scenarios arrives TWICE in one tag list. Counting occurrences would red that scenario for
- * claiming `@complexity` and `@complexity`, a finding whose own message reads as nonsense. The
- * private check this rule replaced never met the case because it read a scenario's own tag block
- * and nothing above it — which is precisely the second reading `parseTaggedScenarios` exists to
- * end, arriving here as a fault of its own rather than as a missed one.
- *
- * BOTH TAGS NAMED, IN DOCUMENT ORDER. The author has to choose which scenario keeps which check,
- * and a message naming one of them has already chosen for them; the order is the walk's own —
- * a scenario's OWN tags first, then what it inherits — so the message reads like the line.
- *
- * AND THE REMEDY NAMES NO SHAPE (3F-3133). It read "Split it into one stepless scenario per
- * check", which was sound only while the floor redded a stepped check-tagged row as tier-less: an
- * author who split into two STEPPED rows would have been sent back by it. Both halves of the split
- * are admissible however they are written, and an instruction to strip the steps would be this
- * rule prescribing the very shape 3F-3097 exists to stop assuming.
- *
- * ASKED OF UNPARKED SCENARIOS ONLY (operator ruling, 3F-2655). This rule first shipped saying the
- * opposite — that a parking tag defers what a scenario OWES and so has nothing to say about what
- * it IS. Both readings agree the split is the same edit whenever it happens; they disagree about
- * whether an author who has already said "not yet" should be made to do it now, and canon says no:
- * parking is a SKIP-SIGNAL, and out of scope is not a place where some questions still get asked.
- * The skip is not an ERASURE, which is a separate claim and a separate arm: unpark the scenario
- * and the same two tags red again, unchanged.
- *
- * THE SCOPE IS A CLAUSE HERE, AND IT USED TO BE A POSITION. Inside the private check the rules
- * shared one walk, so parking was enforced by where this rule sat in it — below the grammar
- * question, above everything else — and the rule never had to know what parking was. Three rule
- * functions over one corpus have no shared walk to be positioned in, so the clause is written out.
- * What the position bought is unchanged and is now structural rather than remembered: the grammar
- * arm has no parking clause AT ALL, so a parked scenario's tags are still read for well-formedness
- * — parking defers what a scenario owes and what shape it must have, never whether its tags are
- * spelled right, and the deferral set is the very thing that lets that arm recognise the parking
- * tag. `@wip @untit` cannot go quiet.
- *
- * @param features the target's discovered feature files, read once at the edge.
- * @param packageJson the TARGET's manifest, read HERE through the same resolvers the grammar arm
- * reads it with — one reading of `specController.deferralTags` (@SCN-PND-021), and `checkTagsOf`
- * for the three sources of what names a check.
- * @param starterDeferralTags the APPLICATION layer's starter set, which a target's config may only
- * extend and never replace. A parameter because it is product policy; a copy held in core would be
- * a second statement of it.
- * @param killFloor the reader over the TARGET's mutation records, threaded through to the
- * threshold resolution inside `checkTagsOf` because a bar may name a gate rather than a figure
- * (@SCN-MUT-012).
- */
-export function multipleCheckTags(features, packageJson, starterDeferralTags, killFloor) {
-    // Both sets are resolved ONCE, before the walk, for the grammar arm's reasons: the manifest
-    // cannot change mid-corpus, and one resolution keeps the target's mutation record opened once.
-    const deferralTags = resolveDeferralTags(packageJson, starterDeferralTags);
-    const checkTags = checkTagsOf(packageJson, killFloor);
-    const faults = [];
-    for (const file of features) {
-        for (const scenario of parseTaggedScenarios(file.source)) {
-            if (scenario.tags.some((tag) => deferralTags.includes(tag)))
-                continue;
-            const claimed = [...new Set(scenario.tags.filter((tag) => checkTags.includes(tag)))];
-            if (claimed.length < 2)
-                continue;
-            faults.push({
-                kind: "multiple-check-tags",
-                message: `multiple-check-tags: ${file.slug}.feature scenario @${scenario.scnId} carries ` +
-                    `${claimed.length} check tags — ${claimed.map((tag) => `@${tag}`).join(", ")} — but a ` +
-                    `scenario names ONE check: one run is one credit, and a scenario claiming two owes ` +
-                    `evidence it cannot tell apart. Split it into one scenario per check.`,
-            });
-        }
-    }
-    return faults;
-}
-//# sourceMappingURL=corpusClaimFaults.js.map

package/dist/parse/corpusClaimFaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpusClaimFaults.js","sourceRoot":"","sources":["../../src/parse/corpusClaimFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAwB,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,MAAM,UAAU,iBAAiB,CAC/B,QAA+B,EAC/B,WAA2B,EAC3B,mBAAsC,EACtC,SAA0B;IAE1B,4FAA4F;IAC5F,+FAA+F;IAC/F,MAAM,YAAY,GAAG,mBAAmB,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC;IAC3E,MAAM,SAAS,GAAG,WAAW,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACtD,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,KAAK,MAAM,QAAQ,IAAI,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACzD,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAAE,SAAS;YACtE,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;gBAAE,SAAS;YACjC,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,qBAAqB;gBAC3B,OAAO,EACL,wBAAwB,IAAI,CAAC,IAAI,sBAAsB,QAAQ,CAAC,KAAK,WAAW;oBAChF,GAAG,OAAO,CAAC,MAAM,iBAAiB,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;oBACvF,oFAAoF;oBACpF,sEAAsE;aACzE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/parse/measurements.d.ts

@@ -1,47 +0,0 @@
-/**
- * THE MEASUREMENT READER — the measurement artefact read into citing Evidence Observations
- * (@SCN-CIP-003).
- *
- * The third evidence stream, and it belongs to neither of the other two. A runtime credit is read
- * from a runner's result JSON; a static credit is read from a target's CI config and manifest. A
- * measurement is neither a test result nor a fact about the tree: it is what the wrapper around a
- * timed step measured while the step ran, and nothing else in the pipeline is in a position to
- * know it.
- *
- * THE ARTEFACT:
- *
- *     { "measurements": [ { "scnId": "SCN-CIP-001", "checkTag": "ci-run-time", "measured": 42.1 } ] }
- *
- * NO CITATION IS RESOLVED HERE, and that is the shape of the axis rather than an omission. The
- * static axis needs two hops — script handle to bare tag through the registry, bare tag to scenario
- * through the corpus — because a run of a script does not know what it is FOR. A measurement does:
- * canon puts the check-to-scenario mapping in the runner that measures (`double-entry-manifesto.md`
- * → Fitness Scenario), so the credit arrives already carrying both terms and this reader only has
- * to read them.
- *
- * TOLERANT ROW BY ROW, like every reader at this edge. A malformed row is dropped rather than
- * thrown on: the run's job is to produce a verdict, and one bad row costing the whole verdict is
- * loud nowhere, while a dropped measurement is loud on the ledger as the obligation it leaves
- * unanswered (@SCN-CIP-006).
- */
-import type { MeasuredEvidenceObservation } from "../model.js";
-/** The measurement artefact, as the reader takes it — validated row by row below. */
-export interface MeasurementReport {
-    measurements?: unknown;
-}
-/**
- * Read the artefact into one `MeasuredEvidenceObservation` per well-formed row, in artefact order.
- *
- * A ROW MISSING EITHER TERM OF ITS ADDRESS IS DROPPED, NOT SENT TO SUSPENSE. An uncited STATIC
- * credit is a real and meaningful fact — a check ran that no scenario names — and suspense is where
- * it belongs. A measurement without a citation is a different thing: stamping the citation is the
- * wrapper's whole job, so a row without one says the artefact is broken, not that a check went
- * unattributed. Posting it to suspense would report a check as having run uncited when what
- * actually happened is that its row could not be read.
- *
- * A NaN MEASUREMENT IS DROPPED FOR A SHARPER REASON. Every comparison against NaN is false, so
- * `measured <= threshold` is false and the row would read `failing` — blaming an honestly-fast
- * suite for a fault in the artefact that measured it.
- */
-export declare function parseMeasuredEvidenceObservations(report: MeasurementReport): MeasuredEvidenceObservation[];
-//# sourceMappingURL=measurements.d.ts.map

package/dist/parse/measurements.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"measurements.d.ts","sourceRoot":"","sources":["../../src/parse/measurements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE/D,qFAAqF;AACrF,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,iBAAiB,GACxB,2BAA2B,EAAE,CAY/B"}

package/dist/parse/measurements.js

@@ -1,65 +0,0 @@
-/**
- * THE MEASUREMENT READER — the measurement artefact read into citing Evidence Observations
- * (@SCN-CIP-003).
- *
- * The third evidence stream, and it belongs to neither of the other two. A runtime credit is read
- * from a runner's result JSON; a static credit is read from a target's CI config and manifest. A
- * measurement is neither a test result nor a fact about the tree: it is what the wrapper around a
- * timed step measured while the step ran, and nothing else in the pipeline is in a position to
- * know it.
- *
- * THE ARTEFACT:
- *
- *     { "measurements": [ { "scnId": "SCN-CIP-001", "checkTag": "ci-run-time", "measured": 42.1 } ] }
- *
- * NO CITATION IS RESOLVED HERE, and that is the shape of the axis rather than an omission. The
- * static axis needs two hops — script handle to bare tag through the registry, bare tag to scenario
- * through the corpus — because a run of a script does not know what it is FOR. A measurement does:
- * canon puts the check-to-scenario mapping in the runner that measures (`double-entry-manifesto.md`
- * → Fitness Scenario), so the credit arrives already carrying both terms and this reader only has
- * to read them.
- *
- * TOLERANT ROW BY ROW, like every reader at this edge. A malformed row is dropped rather than
- * thrown on: the run's job is to produce a verdict, and one bad row costing the whole verdict is
- * loud nowhere, while a dropped measurement is loud on the ledger as the obligation it leaves
- * unanswered (@SCN-CIP-006).
- */
-import { bareTerm } from "../lib/bareTerm.js";
-/** Both terms bare, so an artefact may spell either the way a feature file does (@SCN-TRM-001). */
-function bare(value) {
-    return typeof value === "string" ? bareTerm(value) : "";
-}
-/** A measurement is a finite, non-negative number. Zero is legal — a step can take no time. */
-function isMeasurement(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-/**
- * Read the artefact into one `MeasuredEvidenceObservation` per well-formed row, in artefact order.
- *
- * A ROW MISSING EITHER TERM OF ITS ADDRESS IS DROPPED, NOT SENT TO SUSPENSE. An uncited STATIC
- * credit is a real and meaningful fact — a check ran that no scenario names — and suspense is where
- * it belongs. A measurement without a citation is a different thing: stamping the citation is the
- * wrapper's whole job, so a row without one says the artefact is broken, not that a check went
- * unattributed. Posting it to suspense would report a check as having run uncited when what
- * actually happened is that its row could not be read.
- *
- * A NaN MEASUREMENT IS DROPPED FOR A SHARPER REASON. Every comparison against NaN is false, so
- * `measured <= threshold` is false and the row would read `failing` — blaming an honestly-fast
- * suite for a fault in the artefact that measured it.
- */
-export function parseMeasuredEvidenceObservations(report) {
-    const rows = Array.isArray(report.measurements) ? report.measurements : [];
-    const observations = [];
-    for (const row of rows) {
-        if (typeof row !== "object" || row === null)
-            continue;
-        const { scnId: rawScn, checkTag: rawTag, measured } = row;
-        const scnId = bare(rawScn);
-        const checkTag = bare(rawTag);
-        if (scnId === "" || checkTag === "" || !isMeasurement(measured))
-            continue;
-        observations.push({ qualityCheck: "lint", scnId, checkTag, measured });
-    }
-    return observations;
-}
-//# sourceMappingURL=measurements.js.map

package/dist/parse/measurements.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"measurements.js","sourceRoot":"","sources":["../../src/parse/measurements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAQ9C,mGAAmG;AACnG,SAAS,IAAI,CAAC,KAAc;IAC1B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC1D,CAAC;AAED,+FAA+F;AAC/F,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iCAAiC,CAC/C,MAAyB;IAEzB,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,MAAM,YAAY,GAAkC,EAAE,CAAC;IACvD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;YAAE,SAAS;QACtD,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,GAA8B,CAAC;QACrF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,IAAI,KAAK,KAAK,EAAE,IAAI,QAAQ,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;YAAE,SAAS;QAC1E,YAAY,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/dist/render/measuredItem.d.ts

@@ -1,30 +0,0 @@
-/**
- * THE MEASURED ITEM'S WHERE-TO-FIX (@SCN-CIP-008) — the two numbers a measured reconciling item
- * carries into the report: the check, what was measured, and the bar it was held to.
- *
- * AND WHICH SIDE OF THAT BAR IT HAD TO BE ON (@SCN-MUT-006). "91.4 against 91.87" reads as a
- * comfortable pass to a reader who has met this axis as a ceiling and as a red to one who has met
- * it as a floor, so the comparison is named in words beside the number. Both directions, because
- * naming one and leaving the other bare leaves the second reader in the ambiguity the first was
- * rescued from. It is read off the obligation and never off the check tag: which side satisfies is
- * half of what the bar says, and an engine that knew `mutation` to be a floor would be holding the
- * roster of tag meanings @SCN-LNT-005 puts in the target's hands.
- *
- * WHY THIS IS NOT A CREDIT-SIDE SUFFIX. Every other where-to-fix on a reconciling item belongs to
- * an unmatched CREDIT — a test file's locator, or the handle of a check nobody named. A measured
- * item's belongs to the PAIR: a reader needs the bar and the number together, and on a `missing`
- * row there is no credit at all, only the bar the suite was supposed to meet. Rendering nothing
- * there would leave the loudest row on the ledger the least informative one.
- *
- * NO BAR SAYS SO IN WORDS, and names no comparison — there is no number to name a side of.
- * Rendered as a blank a reader has to interpret, the fault @SCN-CIP-002 makes loud on the DATA goes
- * quiet again on the PAGE; rendered as a zero it reads as a bar OF zero, which is a different and
- * much louder claim than nobody having set one.
- *
- * Its own module rather than a further function in `markdown.ts`, which sits at a `max-lines`
- * exception — and an exception excuses existing debt, never headroom (complexity-threshold.feature).
- */
-import type { ScenarioReconciliation } from "../model.js";
-/** The parenthesised where-to-fix for a measured item, or "" for any other item. */
-export declare function measuredSuffix(item: ScenarioReconciliation["reconcilingItems"][number]): string;
-//# sourceMappingURL=measuredItem.d.ts.map

package/dist/render/measuredItem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"measuredItem.d.ts","sourceRoot":"","sources":["../../src/render/measuredItem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE1D,oFAAoF;AACpF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,GACvD,MAAM,CAcR"}

package/dist/render/measuredItem.js

@@ -1,43 +0,0 @@
-/**
- * THE MEASURED ITEM'S WHERE-TO-FIX (@SCN-CIP-008) — the two numbers a measured reconciling item
- * carries into the report: the check, what was measured, and the bar it was held to.
- *
- * AND WHICH SIDE OF THAT BAR IT HAD TO BE ON (@SCN-MUT-006). "91.4 against 91.87" reads as a
- * comfortable pass to a reader who has met this axis as a ceiling and as a red to one who has met
- * it as a floor, so the comparison is named in words beside the number. Both directions, because
- * naming one and leaving the other bare leaves the second reader in the ambiguity the first was
- * rescued from. It is read off the obligation and never off the check tag: which side satisfies is
- * half of what the bar says, and an engine that knew `mutation` to be a floor would be holding the
- * roster of tag meanings @SCN-LNT-005 puts in the target's hands.
- *
- * WHY THIS IS NOT A CREDIT-SIDE SUFFIX. Every other where-to-fix on a reconciling item belongs to
- * an unmatched CREDIT — a test file's locator, or the handle of a check nobody named. A measured
- * item's belongs to the PAIR: a reader needs the bar and the number together, and on a `missing`
- * row there is no credit at all, only the bar the suite was supposed to meet. Rendering nothing
- * there would leave the loudest row on the ledger the least informative one.
- *
- * NO BAR SAYS SO IN WORDS, and names no comparison — there is no number to name a side of.
- * Rendered as a blank a reader has to interpret, the fault @SCN-CIP-002 makes loud on the DATA goes
- * quiet again on the PAGE; rendered as a zero it reads as a bar OF zero, which is a different and
- * much louder claim than nobody having set one.
- *
- * Its own module rather than a further function in `markdown.ts`, which sits at a `max-lines`
- * exception — and an exception excuses existing debt, never headroom (complexity-threshold.feature).
- */
-import { isMeasuredObservation } from "../model.js";
-/** The parenthesised where-to-fix for a measured item, or "" for any other item. */
-export function measuredSuffix(item) {
-    const obligation = item.evidenceObligation;
-    if (obligation?.measured !== true)
-        return "";
-    const check = item.staticCheck ?? "";
-    const bar = obligation.threshold === undefined
-        ? "no threshold configured"
-        : `${obligation.atLeast === true ? "at least" : "at most"} ${obligation.threshold}`;
-    const observation = item.evidenceObservation;
-    const measured = observation !== undefined && isMeasuredObservation(observation)
-        ? `measured ${observation.measured} against `
-        : "";
-    return ` (${check}: ${measured}${bar})`;
-}
-//# sourceMappingURL=measuredItem.js.map

package/dist/render/measuredItem.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"measuredItem.js","sourceRoot":"","sources":["../../src/render/measuredItem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAGpD,oFAAoF;AACpF,MAAM,UAAU,cAAc,CAC5B,IAAwD;IAExD,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC;IAC3C,IAAI,UAAU,EAAE,QAAQ,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC;IACrC,MAAM,GAAG,GACP,UAAU,CAAC,SAAS,KAAK,SAAS;QAChC,CAAC,CAAC,yBAAyB;QAC3B,CAAC,CAAC,GAAG,UAAU,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,EAAE,CAAC;IACxF,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,CAAC;IAC7C,MAAM,QAAQ,GACZ,WAAW,KAAK,SAAS,IAAI,qBAAqB,CAAC,WAAW,CAAC;QAC7D,CAAC,CAAC,YAAY,WAAW,CAAC,QAAQ,WAAW;QAC7C,CAAC,CAAC,EAAE,CAAC;IACT,OAAO,KAAK,KAAK,KAAK,QAAQ,GAAG,GAAG,GAAG,CAAC;AAC1C,CAAC"}