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

package/dist/domain/posting.js

@@ -1,68 +1,16 @@
-/**
- * POSTING — the rule for WHERE an entry lands. Canon gives Posting its own glossary group
- * (`strategy/double-entry-manifesto.md`, "### Posting") beside Journal, Ledger and Reconciling,
- * and this module is that group's home (module, not class), co-locating the destination type with
- * the pure rule that decides it.
- *
- * It sits BETWEEN the journal and the Ledger, which is why it is neither's: `domain/ledger` folds
- * over an ASSEMBLED Ledger, and the posting rule runs BEFORE a Ledger exists; `domain/journal`
- * owns the entry types and what a scenario NAMES. Posting reads both sides and yields the row an
- * entry lands on. (3F-2202 — extracted from the `reconcile` fold, which decided this inline.)
- *
- * ONE CLAUSE, OVER BOTH AXES (3F-2590). THE CREDIT CITES. A test carries `@SCN-XXX`; a fitness
- * check's run carries the `@SCN` of the fitness scenario that raises its obligation. So
- * one credit names one scenario and posts to EXACTLY ONE row, and a credit posting to no real
- * scenario is PHANTOM (its `@SCN` matches no scenario) or SUSPENSE (it cites nothing).
- *
- * THE BY-NAME ROUTE IS GONE, and with it the exception it forced. `lint` used to be the axis where
- * the DEBIT cited: a scenario carried `@lint=<static-check>`, the run cited nothing, and it was
- * matched BY NAME to EVERY row whose obligation named it. That is why the invariant had to be
- * written "every evidence observation posts to AT LEAST ONE account, never to none" — not *exactly*
- * one, which was the runtime property over-generalised. With both axes citing, EXACTLY ONE is true
- * universally, and it is the stronger claim: "at least one" is silent about a double-post, and a
- * double-post is a second copy of the same fact. `Posting` is total over the `EvidenceObservation`
- * union by construction: every variant yields a destination.
- *
- * POSTING IS NOT CLASSIFYING. This rule decides WHERE an entry lands, never what it reconciles TO.
- * A credit posts to its row whatever outcome it later earns — or none at all. The outcome rules
- * are the sibling concepts' (`qualityCheckReconciliation`, `scenarioReconciliation`).
- */
-// The union's OWN predicate over the `lint` quality-check — asked rather than a hand-written shape
-// test, so this rule classes an observation exactly as the reconciler does.
-// A value import, hence its own statement beside the type-only one above.
-import { isStaticCheckObservation } from "./journal.js";
+import { isFitnessObservation } from "./journal.js";
 export function postingOf(observation, scenarioIds) {
-    if (observation.qualityCheck === "lint") {
-        // THE FAIL-SAFE FIRST (@SCN-LNT-026), which is the runtime arm's own arrangement one branch
-        // down and carries its reason unchanged: broken is taken on the FLAG, before `scnId` is ever
-        // consulted, so a proof that never ran can never be citation-routed — not to a real row, not
-        // to a phantom one — and so can neither discharge nor fail the obligation it cites. The
-        // observation MAY carry an `scnId` and a `checkTag`, and does; both are ignored here.
-        //
-        // Asked through the union's own predicate, so this rule and the reconciler class a static-check
-        // observation the same way.
-        if (isStaticCheckObservation(observation) && observation.broken === true) {
+    if (observation.qualityCheck === "fitness") {
+        if (isFitnessObservation(observation) && observation.broken === true) {
             return { kind: "suspense-scenario", posted: "broken" };
         }
-        // THE CITATION ROUTE (@SCN-LNT-001) — the run carries the `@SCN` of the fitness scenario that
-        // raises its obligation, so it posts by citation like every other credit: exactly one row,
-        // real or invented. This is deliberately the SAME rule the runtime arm applies below, not a
-        // static-axis variant of it — a whole-system characteristic belongs to the one scenario that
-        // holds it, and the moment the static axis is allowed its own posting rule is the moment the
-        // smear can be reintroduced under a different name.
         if (observation.scnId !== undefined) {
             return scenarioIds.has(observation.scnId)
                 ? { kind: "scenario", scnId: observation.scnId }
                 : { kind: "phantom-scenario", scnId: observation.scnId };
         }
-        // The seam reached no `@SCN` — the handle is unregistered, or no fitness scenario carries its
-        // check — so the run cites nothing and posts to SUSPENSE, the static analogue of an uncited
-        // runtime credit. There is no by-name fallback to try: a check nobody named is meant to
-        // surface, and matching it to rows by handle is exactly the smear this route replaced.
         return { kind: "suspense-scenario", posted: "no-evidence-obligation-static-check" };
     }
-    // THE RUNTIME AXIS — the CREDIT cites, so exactly one row, resolved from the `@SCN` it carries.
-    // The fail-safe first: broken is taken on the FLAG, before scnId is ever consulted.
     if (observation.broken === true)
         return { kind: "suspense-scenario", posted: "broken" };
     if (observation.scnId === null)

package/dist/domain/posting.js.map

@@ -1 +1 @@
-{"version":3,"file":"posting.js","sourceRoot":"","sources":["../../src/domain/posting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAQH,mGAAmG;AACnG,4EAA4E;AAC5E,0EAA0E;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AA8FxD,MAAM,UAAU,SAAS,CACvB,WAAgC,EAChC,WAAgC;IAEhC,IAAI,WAAW,CAAC,YAAY,KAAK,MAAM,EAAE,CAAC;QACxC,4FAA4F;QAC5F,6FAA6F;QAC7F,6FAA6F;QAC7F,wFAAwF;QACxF,sFAAsF;QACtF,EAAE;QACF,gGAAgG;QAChG,4BAA4B;QAC5B,IAAI,wBAAwB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACzE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACzD,CAAC;QACD,8FAA8F;QAC9F,2FAA2F;QAC3F,4FAA4F;QAC5F,6FAA6F;QAC7F,6FAA6F;QAC7F,oDAAoD;QACpD,IAAI,WAAW,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC;gBACvC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE;gBAChD,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;QAC7D,CAAC;QACD,8FAA8F;QAC9F,4FAA4F;QAC5F,wFAAwF;QACxF,uFAAuF;QACvF,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC;IACtF,CAAC;IACD,gGAAgG;IAChG,oFAAoF;IACpF,IAAI,WAAW,CAAC,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACxF,IAAI,WAAW,CAAC,KAAK,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IAC9F,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;QACxC,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;IAChE,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;AACxD,CAAC"}
+{"version":3,"file":"posting.js","sourceRoot":"","sources":["../../src/domain/posting.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AA6BpD,MAAM,UAAU,SAAS,CACvB,WAAgC,EAChC,WAAgC;IAEhC,IAAI,WAAW,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;QAC3C,IAAI,oBAAoB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACrE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACzD,CAAC;QACD,IAAI,WAAW,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC;gBACvC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE;gBAChD,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;QAC7D,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC;IACtF,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACxF,IAAI,WAAW,CAAC,KAAK,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IAC9F,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;QACxC,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;IAChE,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC;AACxD,CAAC"}

package/dist/domain/qualityCheckFault.d.ts

@@ -1,59 +1,19 @@
-/**
- * The QUALITY CHECK FAULT vocabulary (@SCN-MSG-001, 3F-2872) — what a refused minting carries
- * INSTEAD of a sentence.
- *
- * Stryker mutates every string literal in the domain, so an invariant that states its refusal as
- * an interpolated template puts its prose on the mutated surface: emptying a template chunk
- * survives every test that does not pin wording, and pinning wording turns a copy-edit red. The
- * cure is to move the question rather than answer it — the throw site names a CODE and carries its
- * parameters as fields, and the prose that renders them lives in a catalogue held as data.
- *
- * THE CODE IS A NUMERIC, IMPLICITLY-VALUED ENUM, AND THAT IS THE WHOLE POINT. A string enum would
- * relocate the mutable prose onto the enum's own values — the survivors would move house rather
- * than leave it. Implicit numbering means there is no literal here for a mutator to reach, so what
- * remains on the mutated surface is exactly the logic worth mutating: WHICH fault is raised, and
- * with WHAT parameters.
- */
-import type { Outcome, SidePresence } from "./qualityCheckReconciliation.js";
-/**
- * One member per throw site in `makeQualityCheckReconciliation`.
- *
- * Numeric and implicitly valued deliberately (see the module note). The members are named for the
- * divergence they report, so a reader meets the meaning at the identifier rather than in a table.
- */
+import type { Outcome, SidePresence } from "./outcome.js";
 export declare enum QualityCheckFaultCode {
-    /** The carried evidence obligation (debit) side disagrees with the outcome's canon row. */
     ObligationSideDivergesFromCanon = 0,
-    /** The carried evidence observation (credit) side disagrees with the outcome's canon row. */
     ObservationSideDivergesFromCanon = 1
 }
-/**
- * What BOTH divergences carry: the outcome whose canon row was consulted, the side-presence that
- * row REQUIRED, and the side-presence the fields ACTUALLY carried.
- *
- * `required` and `actual` are the two halves of the comparison that failed, so a reader — and an
- * assertion — recovers the whole disagreement from the fault without reading a sentence.
- */
 interface SideDivergence {
     readonly outcome: Outcome;
     readonly required: SidePresence;
     readonly actual: SidePresence;
 }
-/** The debit side diverged: the obligation is carried where canon says None, or absent where it says Exists. */
 export interface ObligationSideDivergesFromCanonFault extends SideDivergence {
     readonly code: QualityCheckFaultCode.ObligationSideDivergesFromCanon;
 }
-/** The credit side diverged: the observation is carried where canon says None, or absent where it says Exists. */
 export interface ObservationSideDivergesFromCanonFault extends SideDivergence {
     readonly code: QualityCheckFaultCode.ObservationSideDivergesFromCanon;
 }
-/**
- * The discriminated union over every fault this concept can raise.
- *
- * Discriminated on `code` so the catalogue can be a mapped type over it (3F-2873): the compiler
- * then refuses both a code with no message and a message reaching for a parameter its fault does
- * not carry. Completeness is not asserted; it is unconstructible otherwise.
- */
 export type QualityCheckFault = ObligationSideDivergesFromCanonFault | ObservationSideDivergesFromCanonFault;
 export {};
 //# sourceMappingURL=qualityCheckFault.d.ts.map

package/dist/domain/qualityCheckFault.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualityCheckFault.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckFault.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;;;GAKG;AACH,oBAAY,qBAAqB;IAC/B,2FAA2F;IAC3F,+BAA+B,IAAA;IAC/B,6FAA6F;IAC7F,gCAAgC,IAAA;CACjC;AAED;;;;;;GAMG;AACH,UAAU,cAAc;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,gHAAgH;AAChH,MAAM,WAAW,oCAAqC,SAAQ,cAAc;IAC1E,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,+BAA+B,CAAC;CACtE;AAED,kHAAkH;AAClH,MAAM,WAAW,qCAAsC,SAAQ,cAAc;IAC3E,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,gCAAgC,CAAC;CACvE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GACzB,oCAAoC,GACpC,qCAAqC,CAAC"}
+{"version":3,"file":"qualityCheckFault.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckFault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE1D,oBAAY,qBAAqB;IAC/B,+BAA+B,IAAA;IAC/B,gCAAgC,IAAA;CACjC;AAED,UAAU,cAAc;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,oCAAqC,SAAQ,cAAc;IAC1E,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,+BAA+B,CAAC;CACtE;AAED,MAAM,WAAW,qCAAsC,SAAQ,cAAc;IAC3E,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC,gCAAgC,CAAC;CACvE;AAED,MAAM,MAAM,iBAAiB,GACzB,oCAAoC,GACpC,qCAAqC,CAAC"}

package/dist/domain/qualityCheckFault.js

@@ -1,30 +1,6 @@
-/**
- * The QUALITY CHECK FAULT vocabulary (@SCN-MSG-001, 3F-2872) — what a refused minting carries
- * INSTEAD of a sentence.
- *
- * Stryker mutates every string literal in the domain, so an invariant that states its refusal as
- * an interpolated template puts its prose on the mutated surface: emptying a template chunk
- * survives every test that does not pin wording, and pinning wording turns a copy-edit red. The
- * cure is to move the question rather than answer it — the throw site names a CODE and carries its
- * parameters as fields, and the prose that renders them lives in a catalogue held as data.
- *
- * THE CODE IS A NUMERIC, IMPLICITLY-VALUED ENUM, AND THAT IS THE WHOLE POINT. A string enum would
- * relocate the mutable prose onto the enum's own values — the survivors would move house rather
- * than leave it. Implicit numbering means there is no literal here for a mutator to reach, so what
- * remains on the mutated surface is exactly the logic worth mutating: WHICH fault is raised, and
- * with WHAT parameters.
- */
-/**
- * One member per throw site in `makeQualityCheckReconciliation`.
- *
- * Numeric and implicitly valued deliberately (see the module note). The members are named for the
- * divergence they report, so a reader meets the meaning at the identifier rather than in a table.
- */
 export var QualityCheckFaultCode;
 (function (QualityCheckFaultCode) {
-    /** The carried evidence obligation (debit) side disagrees with the outcome's canon row. */
     QualityCheckFaultCode[QualityCheckFaultCode["ObligationSideDivergesFromCanon"] = 0] = "ObligationSideDivergesFromCanon";
-    /** The carried evidence observation (credit) side disagrees with the outcome's canon row. */
     QualityCheckFaultCode[QualityCheckFaultCode["ObservationSideDivergesFromCanon"] = 1] = "ObservationSideDivergesFromCanon";
 })(QualityCheckFaultCode || (QualityCheckFaultCode = {}));
 //# sourceMappingURL=qualityCheckFault.js.map

package/dist/domain/qualityCheckFault.js.map

@@ -1 +1 @@
-{"version":3,"file":"qualityCheckFault.js","sourceRoot":"","sources":["../../src/domain/qualityCheckFault.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH;;;;;GAKG;AACH,MAAM,CAAN,IAAY,qBAKX;AALD,WAAY,qBAAqB;IAC/B,2FAA2F;IAC3F,uHAA+B,CAAA;IAC/B,6FAA6F;IAC7F,yHAAgC,CAAA;AAClC,CAAC,EALW,qBAAqB,KAArB,qBAAqB,QAKhC"}
+{"version":3,"file":"qualityCheckFault.js","sourceRoot":"","sources":["../../src/domain/qualityCheckFault.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,qBAGX;AAHD,WAAY,qBAAqB;IAC/B,uHAA+B,CAAA;IAC/B,yHAAgC,CAAA;AAClC,CAAC,EAHW,qBAAqB,KAArB,qBAAqB,QAGhC"}

package/dist/domain/qualityCheckFaultMessages.d.ts

@@ -1,43 +1,8 @@
-/**
- * THE MESSAGE CATALOGUE (@SCN-MSG-001, 3F-2872) — the human-facing prose for every
- * `QualityCheckFaultCode`, and NOTHING ELSE.
- *
- * PURE DATA, DELIBERATELY. This module holds one table and no behaviour at all: the indexing
- * that turns a fault into its sentence lives in `qualityCheckFault.ts`, on the mutated surface,
- * where it belongs. The split is what makes the mutate exclusion honest — "do not mutate this
- * file" is defensible over a table of sentences and indefensible over anything that decides
- * something. A render helper parked here would leave the deciding logic unmutated too, and the
- * exclusion would then hide more than the prose it was granted for. NOTHING NOW ASSERTS THAT IT
- * DOES NOT: a check read the real stryker config back and redded on an exclusion that had widened,
- * until 3F-3490 retired it as a claim about our own configuration rather than about the product.
- * @SCN-MSG-002 keeps the half that IS about the product — every code renders a non-blank message
- * carrying its own fault's parameters, proved in `qualityCheckFaultMessages.test.ts` beside this
- * file — and the widened-exclusion residual is stated in `features/message-catalogue.feature`'s
- * preamble, where the next reader of the exclusion meets it.
- *
- * TOTALITY IS NOT ASSERTED, IT IS UNCONSTRUCTIBLE. `QualityCheckFaultMessages` is a mapped type
- * over the code union, so the compiler refuses both a code with no message AND a message reaching
- * for a parameter its own fault does not carry. That is the same type-forced totality
- * `OUTCOME_SIDE_PROFILE` and `OUTCOME_DESCRIPTION` already rely on: a new code cannot join the
- * union without stating its sentence here.
- */
 import { QualityCheckFaultCode, type QualityCheckFault } from "./qualityCheckFault.js";
-/**
- * One renderer per code, each seeing EXACTLY its own fault member.
- *
- * `Extract<…, { code: C }>` narrows per key, so a renderer for the obligation-side code cannot
- * reach a field only the observation-side fault carries — the compiler, not a reviewer, is what
- * keeps each sentence honest about the parameters available to it.
- */
 export type QualityCheckFaultMessages = {
     readonly [C in QualityCheckFaultCode]: (fault: Extract<QualityCheckFault, {
         code: C;
     }>) => string;
 };
-/**
- * The catalogue. Prose is the one thing in this tree that may be rewritten without a ticket, and
- * this is where it may be rewritten: no test reads these sentences, and no mutant is raised over
- * them once the exclusion lands.
- */
 export declare const QUALITY_CHECK_FAULT_MESSAGES: QualityCheckFaultMessages;
 //# sourceMappingURL=qualityCheckFaultMessages.d.ts.map

package/dist/domain/qualityCheckFaultMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualityCheckFaultMessages.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckFaultMessages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,CAAC,IAAI,qBAAqB,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,iBAAiB,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,KAAK,MAAM;CAClG,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,yBAS1C,CAAC"}
+{"version":3,"file":"qualityCheckFaultMessages.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckFaultMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEvF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,CAAC,IAAI,qBAAqB,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,iBAAiB,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,KAAK,MAAM;CAClG,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,yBAS1C,CAAC"}

package/dist/domain/qualityCheckFaultMessages.js

@@ -1,32 +1,4 @@
-/**
- * THE MESSAGE CATALOGUE (@SCN-MSG-001, 3F-2872) — the human-facing prose for every
- * `QualityCheckFaultCode`, and NOTHING ELSE.
- *
- * PURE DATA, DELIBERATELY. This module holds one table and no behaviour at all: the indexing
- * that turns a fault into its sentence lives in `qualityCheckFault.ts`, on the mutated surface,
- * where it belongs. The split is what makes the mutate exclusion honest — "do not mutate this
- * file" is defensible over a table of sentences and indefensible over anything that decides
- * something. A render helper parked here would leave the deciding logic unmutated too, and the
- * exclusion would then hide more than the prose it was granted for. NOTHING NOW ASSERTS THAT IT
- * DOES NOT: a check read the real stryker config back and redded on an exclusion that had widened,
- * until 3F-3490 retired it as a claim about our own configuration rather than about the product.
- * @SCN-MSG-002 keeps the half that IS about the product — every code renders a non-blank message
- * carrying its own fault's parameters, proved in `qualityCheckFaultMessages.test.ts` beside this
- * file — and the widened-exclusion residual is stated in `features/message-catalogue.feature`'s
- * preamble, where the next reader of the exclusion meets it.
- *
- * TOTALITY IS NOT ASSERTED, IT IS UNCONSTRUCTIBLE. `QualityCheckFaultMessages` is a mapped type
- * over the code union, so the compiler refuses both a code with no message AND a message reaching
- * for a parameter its own fault does not carry. That is the same type-forced totality
- * `OUTCOME_SIDE_PROFILE` and `OUTCOME_DESCRIPTION` already rely on: a new code cannot join the
- * union without stating its sentence here.
- */
 import { QualityCheckFaultCode } from "./qualityCheckFault.js";
-/**
- * The catalogue. Prose is the one thing in this tree that may be rewritten without a ticket, and
- * this is where it may be rewritten: no test reads these sentences, and no mutant is raised over
- * them once the exclusion lands.
- */
 export const QUALITY_CHECK_FAULT_MESSAGES = {
     [QualityCheckFaultCode.ObligationSideDivergesFromCanon]: (fault) => `QualityCheckReconciliation invariant (@SCN-LDG-030): outcome "${fault.outcome}" requires the ` +
         `evidence obligation (debit) side to be ${fault.required}, but it was ` +

package/dist/domain/qualityCheckFaultMessages.js.map

@@ -1 +1 @@
-{"version":3,"file":"qualityCheckFaultMessages.js","sourceRoot":"","sources":["../../src/domain/qualityCheckFaultMessages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,qBAAqB,EAA0B,MAAM,wBAAwB,CAAC;AAavF;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAA8B;IACrE,CAAC,qBAAqB,CAAC,+BAA+B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CACjE,iEAAiE,KAAK,CAAC,OAAO,iBAAiB;QAC/F,0CAA0C,KAAK,CAAC,QAAQ,eAAe;QACvE,GAAG,KAAK,CAAC,MAAM,GAAG;IACpB,CAAC,qBAAqB,CAAC,gCAAgC,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAClE,iEAAiE,KAAK,CAAC,OAAO,iBAAiB;QAC/F,4CAA4C,KAAK,CAAC,QAAQ,eAAe;QACzE,GAAG,KAAK,CAAC,MAAM,GAAG;CACrB,CAAC"}
+{"version":3,"file":"qualityCheckFaultMessages.js","sourceRoot":"","sources":["../../src/domain/qualityCheckFaultMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAA0B,MAAM,wBAAwB,CAAC;AAMvF,MAAM,CAAC,MAAM,4BAA4B,GAA8B;IACrE,CAAC,qBAAqB,CAAC,+BAA+B,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CACjE,iEAAiE,KAAK,CAAC,OAAO,iBAAiB;QAC/F,0CAA0C,KAAK,CAAC,QAAQ,eAAe;QACvE,GAAG,KAAK,CAAC,MAAM,GAAG;IACpB,CAAC,qBAAqB,CAAC,gCAAgC,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAClE,iEAAiE,KAAK,CAAC,OAAO,iBAAiB;QAC/F,4CAA4C,KAAK,CAAC,QAAQ,eAAe;QACzE,GAAG,KAAK,CAAC,MAAM,GAAG;CACrB,CAAC"}

package/dist/domain/qualityCheckReconciliation.d.ts

@@ -1,304 +1,31 @@
-/**
- * THE QUALITY CHECK RECONCILIATION — one reconciling item in the accounting frame: the
- * per-evidence-obligation line explaining why obligation and observation disagree. This module
- * co-locates the concept's type with its OWN behaviour — the outcome vocabulary, the canon
- * descriptions, and `reconcileEvidenceObligation`, the pure derivation that computes a single
- * obligation's outcome from the observed evidence (module, not class; the rule lives WITH the
- * concept, not in the reconcile orchestration that folds it).
- */
-import type { QualityCheck, EvidenceObligation, EvidenceObservation, GuardEvidenceObservation, FitnessEvidenceObservation, RuntimeEvidenceObservation } from "./journal.js";
-/**
- * The reconciled OUTCOME of a single quality-check evidence obligation — one
- * RECONCILING ITEM in the accounting frame (the per-evidenceObligation line explaining
- * why obligation and observation disagree). The rationalisation: the
- * per-evidenceObligation axis is the OUTCOME — `satisfied` (its `balanced` retired,
- * `balanced` being the scenario VERDICT's word), and the watermelon reads plainly
- * as `watermelon`.
- */
-export type Outcome = "satisfied" | "failing" | "watermelon" | "missing" | "cites-unknown-scenario" | "cites-no-scenario" | "broken" | "no-evidence-obligation" | "no-scn-code" | "both-missing";
-/**
- * The canon description for each reconciling-item Outcome — the human-readable gloss a
- * markdown reader needs (the bare handle means nothing in a CI log). SINGLE SOURCE: the
- * markdown renderer renders this description in place of the handle EVERYWHERE an outcome
- * surfaces to a reader — the Evidence-reconciliation summary's `↳` decomposition rows, the
- * per-scenario reconciling-items list, and the lint-obligation table's Outcome column. The
- * JSON keeps the bare handle (the machine axis; a programmatic consumer uses it).
- *
- * Keyed by EVERY `Outcome` (a `Record<Outcome, …>`), so a new outcome cannot be added to the
- * union without a description here — the description can never silently diverge from the
- * outcome it names (the drift class this project has been burned by: the census, the views).
- * These phrasings ARE the original canon — later abbreviated to the handles; 3F-1626 restores
- * them. `satisfied` (the balanced outcome, excluded from the out-of-balance decomposition)
- * carries one for totality's sake.
- *
- * ⚠ KEY ORDER IS LOAD-BEARING (3F-1806). `OUT_OF_BALANCE_OUTCOMES` is DERIVED from these keys,
- * and the renderer walks that list to emit the decomposition rows — so this map's key order IS
- * the report's row order (`missing` first: the headline cause, the one carrying the bare-level
- * split as Detail). Reordering these keys is a REPORT CHANGE, not a cosmetic tidy. The order
- * follows canon, grouped by reconciling-item shape: a DEBIT block (missing, failing, watermelon,
- * no-scn-code), a CREDIT block (cites-unknown-scenario, cites-no-scenario, no-evidence-obligation), then
- * NEITHER (broken, both-missing). @SCN-RPT-019 now pins this SEQUENCE against the rendered `↳`
- * rows (3F-1926), so a reorder reds — the exhaustiveness guard alone proved MEMBERSHIP, not
- * order, and used not to catch one (which is how the order drifted before it was pinned).
- */
+import type { QualityCheck, EvidenceObligation, EvidenceObservation, FitnessEvidenceObservation, RuntimeEvidenceObservation } from "./journal.js";
+import type { Outcome, SidePresence } from "./outcome.js";
+export type { Outcome, SidePresence } from "./outcome.js";
 export declare const OUTCOME_DESCRIPTION: Record<Outcome, string>;
-/**
- * The out-of-balance reconciling-item outcomes, in report reading order — every `Outcome`
- * except `satisfied` (the BALANCED outcome, not part of the OUT-of-balance decomposition).
- * The renderer walks this to emit the summary's `↳` leaf rows (@SCN-RPT-019), each reconciling
- * to the out-of-balance total exactly once (a FLAT list: the old debit/credit/neither grouping
- * emitted a `↳ <group>-side` subtotal AND its leaves at the same indent, so a naive column-sum
- * double-counted — the live 170 vs 85).
- *
- * DERIVED from the type-forced `OUTCOME_DESCRIPTION`, never hand-listed (3F-1806). It was a
- * hand-maintained `readonly Outcome[]` in the renderer, which accepted a missing union member
- * SILENTLY: `broken` (@SCN-LDG-017) joined the union, tallied into `byOutcome`, compiled clean,
- * and would have been omitted from the table. Deriving the keys makes that omission IMPOSSIBLE
- * rather than merely CAUGHT — a new `Outcome` cannot compile without a description, and the
- * moment it has one it renders a leaf row with no change to the renderer.
- *
- * Lives in the model, not the renderer: which outcomes are out-of-balance is the model's rule,
- * not a presentation choice (`entity-owns-its-behaviour`). The @SCN-RPT-019 guard remains as the
- * end-to-end backstop — it renders real markdown and reads the rows back, deriving its
- * expectation from its OWN type-forced record (`double-entry`, not a re-read of this source).
- */
 export declare const OUT_OF_BALANCE_OUTCOMES: readonly Outcome[];
-/**
- * THE NOMINAL BRAND (@SCN-LDG-030, 3F-2016) — a module-private `unique symbol` phantom field.
- * `QualityCheckReconciliation` is `QualityCheckReconciliationFields` PLUS a required field of this
- * symbol's type, so no object literal typechecks as a `QualityCheckReconciliation` OUTSIDE this
- * module — only `makeQualityCheckReconciliation` (which casts) can mint one. The brand symbol has
- * no runtime presence; the field is a Symbol key, so `JSON.stringify` skips it (never
- * serialised) and `.toEqual` sees no runtime key (value-literal comparisons stay green). The brand
- * restricts CONSTRUCTION only — consumers only READ QCRs, so no read site changes.
- */
 declare const qualityCheckReconciliationBrand: unique symbol;
-/**
- * A single evidenceObligation's reconciliation outcome — a reconciling item. A SINGLE
- * flat shape mirroring EvidenceObligation: keyed on `qualityCheck`, with
- * `staticCheck` present IFF `qualityCheck === 'lint'` (the static-check reconciling item).
- *
- * The un-branded FIELDS (module-internal). The exported `QualityCheckReconciliation` type is this
- * intersected with the nominal brand; `makeQualityCheckReconciliation` takes these fields and mints
- * the branded value.
- */
 interface QualityCheckReconciliationFields {
-    /**
-     * The flat quality-check this reconciling item is about. ABSENT only for the degenerate
-     * `both-missing` item — the neither-side shape, blank on both sides: it names no
-     * quality-check because it is neither a debit evidence obligation nor a credit evidence observation. Present on
-     * every other outcome (debit and credit alike).
-     */
     qualityCheck?: QualityCheck;
-    /** The `staticCheck` handle — present IFF `qualityCheck === 'lint'`. */
     staticCheck?: string;
     outcome: Outcome;
-    /**
-     * The DEBIT side of the two-sided reconciling item (@SCN-LDG-026): the evidence obligation
-     * this item reconciles, carried on the reconciliation itself rather than joined from a
-     * separate scenario-level array at print time. Present IFF the obligation Exists — every
-     * debit-bearing outcome (`satisfied` / `missing` / `failing` / `watermelon`), AND `no-scn-code`,
-     * which carries a SYNTHESIZED scenario-scope obligation (an empty `{}`, no `qualityCheck` /
-     * `staticCheck`): canon (`double-entry-manifesto.md` line 39) marks `no-scn-code` Obligation
-     * Exists, Observation None — the debit twin of `cites-no-scenario` (@SCN-LDG-029). ABSENT on the
-     * credit-only outcomes (`cites-unknown-scenario` / `cites-no-scenario` / `no-evidence-obligation`) and the
-     * neither-side outcomes (`broken` / `both-missing`), where no obligation is in scope.
-     * `JSON.stringify` omits it when undefined, so a byte-identical golden is preserved everywhere the
-     * obligation is absent.
-     */
     evidenceObligation?: EvidenceObligation;
-    /**
-     * The CREDIT side of the two-sided reconciling item (@SCN-LDG-027): the evidence observation
-     * this item reconciles, carried on the reconciliation itself rather than joined from a
-     * separate scenario-level array at print time. Present IFF the observation Exists — every
-     * observation-bearing outcome: the two-sided debit outcomes (`satisfied` / `failing` /
-     * `watermelon`) whose match `reconcileEvidenceObligation` found, AND the credit-only outcomes
-     * (`cites-unknown-scenario` / `cites-no-scenario` / `no-evidence-obligation`) the fold produces from a
-     * citing observation. ABSENT on `missing` (obligation Exists, observation None) and the
-     * neither-side outcomes (`no-scn-code` / `broken` / `both-missing`), where no observation is in
-     * scope. For a lint `missing` the absent static check is FOUND as the negative fact
-     * `{exists:false}` — an ABSENCE, not an observation (@SCN-LDG-028) — so it is NOT carried here:
-     * only a REAL observation (`exists:true`) is the credit side. `JSON.stringify` omits it when
-     * undefined, so a byte-identical golden is preserved everywhere the observation is absent.
-     */
     evidenceObservation?: EvidenceObservation;
-    /**
-     * The where-to-fix for a CREDIT-side reconciling item (ruling Q5) — the
-     * evidence-observation locator (the test-file path the citing credit came from),
-     * carried so it survives the detail-arrays-into-rows move. Present only on a
-     * credit-side Quality Check Reconciliation (e.g. `cites-unknown-scenario` on a
-     * phantom scenario); a debit-side evidence obligation carries none.
-     */
     locator?: string;
-    /**
-     * The WHAT-BROKE payload of a `broken` credit-side reconciling item (@SCN-LDG-017) — the
-     * collection error the runner reported, carried alongside the `locator` (the file to fix).
-     * Present only on a `broken` item; every other outcome carries none.
-     */
     message?: string;
 }
-/**
- * A single evidenceObligation's reconciliation outcome — the branded reconciling item. The fields
- * intersected with the nominal brand (@SCN-LDG-030): mintable ONLY by
- * `makeQualityCheckReconciliation`, so every QCR in the system has passed the (outcome,
- * side-presence) consistency check. The barrel (`index.ts`) re-exports this TYPE via
- * `model.ts`; the phantom field adds no exported SYMBOL, so the symbol NAMES on the public v1
- * surface are unchanged — but constructibility is deliberately NARROWED: QCRs are engine-minted,
- * and the type is exported for READING the reconciliation the engine produced, not for external
- * CONSTRUCTION (the smart constructor is unexported). That narrowed contract is stated executably
- * by the type-level guard in `index.test.ts` (@SCN-API-002, 3F-2040), not merely asserted here.
- */
 export type QualityCheckReconciliation = QualityCheckReconciliationFields & {
     readonly [qualityCheckReconciliationBrand]: typeof qualityCheckReconciliationBrand;
 };
-/**
- * Whether a canon-correct reconciling item CARRIES a given side — the value both halves of the
- * invariant are stated in: what the canon row required, and what the fields actually carried.
- *
- * Named rather than restated inline so the fault that reports a divergence (`qualityCheckFault.ts`)
- * is typed in the reconciliation's own vocabulary instead of re-spelling the two literals a third
- * and fourth time.
- */
-export type SidePresence = "Exists" | "None";
-/**
- * THE CANON OUTCOME-SIDE PROFILE (@SCN-LDG-030, 3F-2016) — the (outcome → side-presence) table
- * transcribed from canon (`double-entry-manifesto.md` lines 35-44), keyed by EVERY `Outcome` (a
- * `Record<Outcome, …>`), so a new outcome cannot join the union without STATING its side
- * profile here — the type-forced totality that makes this map the SINGLE SOURCE the invariant is
- * checked against (mirroring `OUTCOME_DESCRIPTION`).
- *
- * `obligation`/`observation` are `"Exists" | "None"` — whether a canon-correct reconciling item
- * of that outcome CARRIES the debit (evidence obligation) and the credit (evidence observation)
- * side respectively. NOT a naive function of side-presence: `missing` and `no-scn-code` share
- * (Exists, None); the three credit outcomes (`cites-unknown-scenario` / `cites-no-scenario` /
- * `no-evidence-obligation`) share (None, Exists). So the invariant `makeQualityCheckReconciliation` enforces
- * is (outcome, side-presence) CONSISTENCY against this row, never a derivation of outcome FROM the
- * sides.
- */
 export declare const OUTCOME_SIDE_PROFILE: Record<Outcome, {
     obligation: SidePresence;
     observation: SidePresence;
 }>;
-/**
- * THE SMART CONSTRUCTOR (@SCN-LDG-030, 3F-2016) — the ONLY way to mint a
- * `QualityCheckReconciliation`. It takes `outcome` as GIVEN (a consistency check, NOT a
- * derivation — `missing`/`no-scn-code` share a profile, so the outcome cannot be recovered from
- * side-presence alone), looks up the canon row in `OUTCOME_SIDE_PROFILE`, and THROWS if the
- * carried sides disagree with it: a divergent (outcome, side-presence) pair — the watermelon class
- * this tool exists to catch, in its own output — is UNCONSTRUCTIBLE.
- *
- * Returns `fields` UNCHANGED (cast to the branded type): the producer's own key order is preserved
- * verbatim, so every unchanged row stays byte-identical (no object is reconstructed).
- */
 export declare function makeQualityCheckReconciliation(fields: QualityCheckReconciliationFields): QualityCheckReconciliation;
-/**
- * Reconcile one evidence obligation against the observed evidence, keyed on the
- * flat `qualityCheck`. `qualityCheck === "lint"` is the watermelon
- * discriminator: it routes to the STATIC-check mapping;
- * every other value routes to the RUNTIME-result mapping.
- */
 export declare function reconcileEvidenceObligation(scnId: string, req: EvidenceObligation, evidenceObservations: EvidenceObservation[]): QualityCheckReconciliation;
-/**
- * The NO-EVIDENCE-OBLIGATION items on a real scenario's row (@SCN-LDG-008) — one per credit citing THIS
- * scenario at a quality-check it never named. The credit posts to a real row against NO
- * evidence obligation, so the item is CREDIT-ONLY (no obligation is in scope).
- *
- * The pair-check is what distinguishes no-evidence-obligation from a matched credit: a credit at a NAMED
- * `(scnId, quality-check)` pair reconciles satisfied/failing via `reconcileEvidenceObligation` and
- * is NOT re-listed here. `evidenceObligationPairs` is the journal's rule (`evidenceObligationPairsOf`),
- * built once and shared — which is what makes a credit citing a PENDING pair land here rather than
- * nowhere (3F-1858: a pending obligation names nothing, so such a credit is no-evidence-obligation exactly
- * as when nothing was raised at all, and the run that used to read balanced over it now fails).
- */
 export declare function noEvidenceObligationReconciliationsOf(scnId: string, postedCredits: readonly EvidenceObservation[], evidenceObligationPairs: ReadonlySet<string>): QualityCheckReconciliation[];
-/**
- * The items on a PHANTOM row (@SCN-LDG-006) — one `cites-unknown-scenario` per credit citing an
- * `@SCN` no scenario carries, in citation order. CREDIT-ONLY: a phantom row is minted BY a credit,
- * so nothing can ever have been named of it, and no obligation is in scope.
- *
- * THE WHERE-TO-FIX IS THE WHOLE OF WHAT THIS ITEM CAN OFFER, which is why both halves ride through
- * (ruling Q5): a phantom item has no obligation to point a reader at instead. A runtime credit
- * carries its locator (the test file that cited); a FITNESS credit carries the CHECK THAT RAN —
- * it is read from a target's config, not from a test file, so it has no locator and the handle is
- * all there is. That half became reachable when the fitness axis started citing (@SCN-LNT-009);
- * the suspense arm below already carried it, and the two unmatched-credit destinations must not
- * tell a reader different amounts about the same class of fault.
- */
 export declare function citesUnknownScenarioReconciliationsOf(credits: readonly EvidenceObservation[]): QualityCheckReconciliation[];
-/**
- * The items on the SUSPENSE row (@SCN-LDG-007) — every entry that names no scenario at all,
- * in the ONE order canon fixes.
- *
- * THE ORDER IS THE RULE, not an accident of assembly. `broken` comes FIRST because a broken run's
- * other suspense items are downstream noise: the reader must be sent to the harness before being
- * asked to read anything the harness failed to produce.
- *
- * THE SPLIT (@SCN-LDG-017) is why `broken` and `cites-no-scenario` are separate arms rather than
- * one map over "everything uncited". Both land here because they name no scenario, but they are
- * distinguished by errored-vs-completed and their remedies differ: a `cites-no-scenario` test RAN
- * and forgot its citation (add the `@SCN`); a `broken` suite never ran at all (fix the harness).
- * Folding the second into the first would hide a collection failure behind the wrong cure.
- *
- * The three arms carry different payloads, each for a stated reason:
- *   - `broken` carries its WHERE-to-fix (locator) and its WHAT-broke (the runner's message), and
- *     NO `evidenceObservation` — a proof that never ran is not an observed piece of evidence.
- *   - an uncited runtime credit carries the observation it reconciles, plus its locator.
- *   - a no-evidence-obligation static check carries its handle and its observation; it has no locator (a
- *     static check is read from config, not from a test file).
- *
- * THE BROKEN STREAM TAKES EITHER AXIS SINCE @SCN-LNT-026, AND THE ARM NEEDED NO BRANCH FOR IT.
- * A converted static check that did not run carries the same two payload halves under the same
- * two names, so the map reads what the observation holds exactly as it does for a vitest suite
- * that failed to collect. What differs is only the `qualityCheck` the item then carries — `lint`
- * rather than a runtime tier — which is read off the observation and not decided here.
- */
-export declare function suspenseReconciliationsOf(brokenEvidence: readonly (RuntimeEvidenceObservation | GuardEvidenceObservation)[], uncited: readonly RuntimeEvidenceObservation[], noEvidenceObligationGuards: readonly FitnessEvidenceObservation[]): QualityCheckReconciliation[];
-/**
- * The item on an UNTAGGED scenario's row (@SCN-LDG-021) — the DEBIT twin of `cites-no-scenario`
- * (same missing link, opposite side; suspense stays credit-only).
- *
- * A scenario carrying no `@SCN` is REAL and ORDINARY — cucumber runs it — but its obligation has no
- * CODE for an observation to link to, so it could reconcile NOTHING: not satisfied, not failing,
- * not even `missing`, because an obligation never RAISED cannot be ABSENT. Without this item it
- * contributed nothing to the verdict and the run went green over work nothing proves.
- *
- * It carries NO `qualityCheck`: with no code, no observation can link at ANY tier, so the missing
- * link is SCENARIO-scope, not tier-scope (the shape `both-missing` also uses). The synthesised
- * scenario-scope obligation — an empty `{}` — lives ONLY on this item; the row's own
- * `evidenceObligations` stays empty (canon citation: double-entry-manifesto line 39, Obligation
- * Exists / Observation None).
- */
+export declare function suspenseReconciliationsOf(brokenEvidence: readonly (RuntimeEvidenceObservation | FitnessEvidenceObservation)[], uncited: readonly RuntimeEvidenceObservation[], noEvidenceObligationStaticChecks: readonly FitnessEvidenceObservation[]): QualityCheckReconciliation[];
 export declare function noScnCodeReconciliations(): QualityCheckReconciliation[];
-/**
- * The degenerate BOTH-MISSING item (@SCN-LDG-009) — the NEITHER-side outcome, blank on both sides:
- * no `qualityCheck` (it is neither a debit obligation nor a credit observation), no carried entry.
- * A scenario that reconciled to zero rows on BOTH sides posts exactly one of these, and is
- * out-of-balance through it.
- *
- * Construction lives here with the item; the rule for WHEN a row carries it instead of its sub-rows
- * is the ROW's, and lives on `scenarioReconciliation` (`qualityCheckReconciliationsOf`).
- */
+export declare function duplicateScnCodeReconciliationsOf(obligations: readonly EvidenceObligation[]): QualityCheckReconciliation[];
 export declare function bothMissingReconciliation(): QualityCheckReconciliation;
-/**
- * The item on the row a CONFIGURED ROW WITH NO SCENARIO earns (@SCN-LNT-027, 3F-3472) — canon's
- * `missing`: Obligation Exists, Observation None.
- *
- * NO NEW OUTCOME, AND THAT IS THE ARGUMENT RATHER THAN THE CONVENIENCE. A row the manifest declares
- * and no scenario specifies is a debit nothing observed, which is what `missing` already means and
- * what `features/fitness-checks.feature` promises in those words. Minting a fourth corpus-shape
- * outcome would put a second sentence beside a row canon already has a sentence for.
- *
- * THE OBLIGATION IS THE ROW'S OWN, and it is REAL — `{ qualityCheck: "lint", staticCheck: <the
- * characteristic> }`, the same shape a converted scenario raises. That is what separates this from
- * the uncoded-work item beside it: THAT one synthesises an empty `{}` because an untagged scenario
- * names no check at all, and this row names exactly one. So the row posts it as a debit too, and
- * the summary counts the obligation the manifest raised.
- *
- * NOTHING HERE CAN DISCHARGE IT, and that is structural rather than asserted: no observation is
- * offered to this item at all, and the minted row's `@SCN` is not a member of the set the citation
- * router posts credits against. A credit citing the row's code still mints a phantom row
- * (@SCN-LNT-009); there is no route by which it reaches this one.
- */
-export declare function unspecifiedRowReconciliations(characteristic: string): QualityCheckReconciliation[];
-export {};
 //# sourceMappingURL=qualityCheckReconciliation.d.ts.map

package/dist/domain/qualityCheckReconciliation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualityCheckReconciliation.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckReconciliation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,cAAc,CAAC;AAQtB;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GACf,WAAW,GACX,SAAS,GACT,YAAY,GAGZ,SAAS,GAIT,wBAAwB,GAExB,mBAAmB,GAGnB,QAAQ,GAQR,wBAAwB,GAOxB,aAAa,GAOb,cAAc,CAAC;AASnB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CA4BvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,OAAO,EAER,CAAC;AAE/C;;;;;;;;GAQG;AACH,OAAO,CAAC,MAAM,+BAA+B,EAAE,OAAO,MAAM,CAAC;AAE7D;;;;;;;;GAQG;AACH,UAAU,gCAAgC;IACxC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;;;OAYG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,0BAA0B,GAAG,gCAAgC,GAAG;IAC1E,QAAQ,CAAC,CAAC,+BAA+B,CAAC,EAAE,OAAO,+BAA+B,CAAC;CACpF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,OAAO,EACP;IAAE,UAAU,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,YAAY,CAAA;CAAE,CAYxD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,gCAAgC,GACvC,0BAA0B,CAuB5B;AA0ID;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,kBAAkB,EACvB,oBAAoB,EAAE,mBAAmB,EAAE,GAC1C,0BAA0B,CAuE5B;AA6CD;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,SAAS,mBAAmB,EAAE,EAC7C,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3C,0BAA0B,EAAE,CA6B9B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,0BAA0B,EAAE,CAY9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,SAAS,CAAC,0BAA0B,GAAG,wBAAwB,CAAC,EAAE,EAClF,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAC9C,0BAA0B,EAAE,SAAS,0BAA0B,EAAE,GAChE,0BAA0B,EAAE,CA4B9B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,IAAI,0BAA0B,EAAE,CAEvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,IAAI,0BAA0B,CAEtE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAAC,cAAc,EAAE,MAAM,GAAG,0BAA0B,EAAE,CASlG"}
+{"version":3,"file":"qualityCheckReconciliation.d.ts","sourceRoot":"","sources":["../../src/domain/qualityCheckReconciliation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE1D,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE1D,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAcvD,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,SAAS,OAAO,EAER,CAAC;AAE/C,OAAO,CAAC,MAAM,+BAA+B,EAAE,OAAO,MAAM,CAAC;AAE7D,UAAU,gCAAgC;IACxC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,0BAA0B,GAAG,gCAAgC,GAAG;IAC1E,QAAQ,CAAC,CAAC,+BAA+B,CAAC,EAAE,OAAO,+BAA+B,CAAC;CACpF,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,OAAO,EACP;IAAE,UAAU,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,YAAY,CAAA;CAAE,CAaxD,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,gCAAgC,GACvC,0BAA0B,CAmB5B;AA8DD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,kBAAkB,EACvB,oBAAoB,EAAE,mBAAmB,EAAE,GAC1C,0BAA0B,CAiB5B;AAQD,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,SAAS,mBAAmB,EAAE,EAC7C,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3C,0BAA0B,EAAE,CAe9B;AAED,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,0BAA0B,EAAE,CAU9B;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,SAAS,CAAC,0BAA0B,GAAG,0BAA0B,CAAC,EAAE,EACpF,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAC9C,gCAAgC,EAAE,SAAS,0BAA0B,EAAE,GACtE,0BAA0B,EAAE,CA2B9B;AAED,wBAAgB,wBAAwB,IAAI,0BAA0B,EAAE,CAEvE;AAED,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,SAAS,kBAAkB,EAAE,GACzC,0BAA0B,EAAE,CAa9B;AAED,wBAAgB,yBAAyB,IAAI,0BAA0B,CAEtE"}