@3f-consulting/spec-controller-core 0.1.0-alpha.6 → 0.1.0-alpha.61

package/dist/domain/fitnessChecks.d.ts

@@ -1,79 +0,0 @@
-/**
- * THE FITNESS CHECK ROWS — what a CONVERTED check says about itself, keyed by the `@SCN` it is
- * about.
- *
- *     @SCN          the row                       what the corpus then reads
- *     SCN-FIT-001   { characteristic: complexity } a @fitness scenario owes `complexity`
- *
- * THE TAG NAMES THE AXIS AND THE ROW NAMES THE SUBJECT. A bare characteristic tag answered two
- * questions at once — how a claim is proved, and what it is about — and the tier tags answer only
- * the first. So a converted scenario carries `@fitness` alone, and the characteristic moves here,
- * where it stays a first-class word the roll-up still groups by.
- *
- * NOT A SECOND OBLIGATION SHAPE. What a `@fitness` scenario raises is the same
- * `{ qualityCheck: "lint", staticCheck: <characteristic> }` a registered bare tag raises today, so
- * the pair key, the reconciler's static arm and the report's roll-up are all untouched. What
- * changed is only where the word came from.
- *
- * NOT THE (RETIRED) CHECK REGISTRY, AND THE DIFFERENCE IS THE SEAM THIS RETIRES. That registry
- * answered "which check is this runnable script handle", because a handle does not know what it
- * is for; the `@SCN`
- * is then resolved through the corpus, a second hop. A converted check is never discovered as a
- * handle — it is a scenario that ran, carrying its own tag line — so the `@SCN` is the KEY here
- * rather than something a lookup has to recover.
- *
- * PURE AND INJECTED — the rows arrive as data, read from the TARGET's own manifest at the app edge
- * (`specController.fitnessChecks`), the stance the retired `thresholdsOf` took. A target that
- * configures nothing raises nothing, so the reading is inert on a corpus
- * nobody has converted.
- */
-/**
- * ONE CONFIGURED ROW as the obligation rule reads it.
- *
- * The `scn` a row states is not a member here: it is this index's KEY, so a row cannot name one
- * scenario and be filed under another. The command a row states is not a member either — it is the
- * COMMAND half of the row and nothing on the debit side reads it. Every row is credited by its own
- * step's outcome in the run's record, so the characteristic is the whole of what the ledger reads.
- */
-export interface FitnessCheck {
-    /** The bare characteristic this check asserts (`complexity`). */
-    readonly characteristic: string;
-}
-/** The rows as the rule reads them — bare `@SCN` → the row naming that scenario's check. */
-export type FitnessCheckIndex = ReadonlyMap<string, FitnessCheck>;
-/**
- * Build the index from the rows a manifest holds.
- *
- * A LIST, NOT A BLOCK KEYED BY `@SCN`, and the shape is the row's own argument: a row is what a
- * check says about ITSELF — its `@SCN`, its characteristic, its command — so no one of those three
- * is promoted above the others by being the key somebody has to write it under. The `@SCN` becomes
- * the key HERE, where a lookup needs one.
- *
- * A MALFORMED ROW IS DROPPED, NOT TRUSTED AND NOT THROWN ON — the defensive stance the whole
- * `specController.*` family takes. Config is data from outside, and a reader that throws on a typo
- * turns one bad character into a run that produces no verdict at all, which is loud nowhere; a
- * dropped row leaves its scenario naming no characteristic, which the corpus reports.
- */
-export declare function fitnessChecksOf(entries: unknown): FitnessCheckIndex;
-/**
- * ONE CONFIGURED ROW THE TARGET'S CORPUS CARRIES NO SCENARIO FOR (3F-3472) — a check the manifest
- * declares and nothing in the corpus specifies.
- *
- * THE MIRROR OF `unconfiguredFitnessScenarios`, AND THE HALF THE BOOKS COULD NOT SEE. That one
- * reads a `@fitness` scenario no row names; this reads a row no scenario names. The asymmetry
- * between what each EARNS is the two facts' own: a scenario naming no row names no characteristic,
- * so there is nothing to put on the books and the census says who — a row names one, so there IS a
- * debit, and `features/fitness-checks.feature` promises it as "an Evidence Obligation nothing
- * observed".
- *
- * IT CARRIES THE CHARACTERISTIC BECAUSE THE OBLIGATION IT RAISES NAMES ONE. The `@SCN` alone would
- * leave the reader of this reading to go back to the index for the other half, which is the second
- * read `readTargetCorpus` composes its readings together to foreclose.
- */
-export interface UnspecifiedFitnessRow {
-    /** The `@SCN` the row states, which no scenario in the target's corpus carries. */
-    readonly scnId: string;
-    /** The bare characteristic the row asserts (`complexity`) — what its debit is owed at. */
-    readonly characteristic: string;
-}
-//# sourceMappingURL=fitnessChecks.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fitnessChecks.d.ts","sourceRoot":"","sources":["../../src/domain/fitnessChecks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,4FAA4F;AAC5F,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AA2BlE;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAQnE;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,qBAAqB;IACpC,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC"}

package/dist/domain/fitnessChecks.js

@@ -1,81 +0,0 @@
-/**
- * THE FITNESS CHECK ROWS — what a CONVERTED check says about itself, keyed by the `@SCN` it is
- * about.
- *
- *     @SCN          the row                       what the corpus then reads
- *     SCN-FIT-001   { characteristic: complexity } a @fitness scenario owes `complexity`
- *
- * THE TAG NAMES THE AXIS AND THE ROW NAMES THE SUBJECT. A bare characteristic tag answered two
- * questions at once — how a claim is proved, and what it is about — and the tier tags answer only
- * the first. So a converted scenario carries `@fitness` alone, and the characteristic moves here,
- * where it stays a first-class word the roll-up still groups by.
- *
- * NOT A SECOND OBLIGATION SHAPE. What a `@fitness` scenario raises is the same
- * `{ qualityCheck: "lint", staticCheck: <characteristic> }` a registered bare tag raises today, so
- * the pair key, the reconciler's static arm and the report's roll-up are all untouched. What
- * changed is only where the word came from.
- *
- * NOT THE (RETIRED) CHECK REGISTRY, AND THE DIFFERENCE IS THE SEAM THIS RETIRES. That registry
- * answered "which check is this runnable script handle", because a handle does not know what it
- * is for; the `@SCN`
- * is then resolved through the corpus, a second hop. A converted check is never discovered as a
- * handle — it is a scenario that ran, carrying its own tag line — so the `@SCN` is the KEY here
- * rather than something a lookup has to recover.
- *
- * PURE AND INJECTED — the rows arrive as data, read from the TARGET's own manifest at the app edge
- * (`specController.fitnessChecks`), the stance the retired `thresholdsOf` took. A target that
- * configures nothing raises nothing, so the reading is inert on a corpus
- * nobody has converted.
- */
-import { bareTerm } from "../lib/bareTerm.js";
-/**
- * One entry as a manifest spells it, read into the pair a lookup can use, or `null` where it names
- * nothing one can.
- *
- * BOTH TERMS ARE STORED BARE. A manifest written by hand will sooner or later spell an `@SCN` — and
- * a characteristic — the way a feature file does, and both lookups match bare; stripping once here
- * rather than at every call site is the stance the retired `thresholdsOf` took.
- *
- * A ROW NAMING NEITHER TERM IS DROPPED WHOLE, never half-read. The two terms make one claim
- * together — THIS scenario asserts THIS characteristic — so a row missing either says nothing a
- * lookup can act on, and there is no lenient reading that does not invent one of them.
- */
-function fitnessCheckOf(entry) {
-    // THE TWO STRING READS ARE THE WHOLE GUARD, and a shape test ahead of them would add no teeth: a
-    // string, a number, a list and a function all answer `undefined` here, so each is refused by the
-    // read that matters rather than by a clause restating it. The optional chain is what covers the
-    // two values a property read would throw on.
-    const named = entry;
-    if (typeof named?.scn !== "string" || typeof named.characteristic !== "string")
-        return null;
-    const scnId = bareTerm(named.scn);
-    const characteristic = bareTerm(named.characteristic);
-    if (scnId === "" || characteristic === "")
-        return null;
-    return [scnId, { characteristic }];
-}
-/**
- * Build the index from the rows a manifest holds.
- *
- * A LIST, NOT A BLOCK KEYED BY `@SCN`, and the shape is the row's own argument: a row is what a
- * check says about ITSELF — its `@SCN`, its characteristic, its command — so no one of those three
- * is promoted above the others by being the key somebody has to write it under. The `@SCN` becomes
- * the key HERE, where a lookup needs one.
- *
- * A MALFORMED ROW IS DROPPED, NOT TRUSTED AND NOT THROWN ON — the defensive stance the whole
- * `specController.*` family takes. Config is data from outside, and a reader that throws on a typo
- * turns one bad character into a run that produces no verdict at all, which is loud nowhere; a
- * dropped row leaves its scenario naming no characteristic, which the corpus reports.
- */
-export function fitnessChecksOf(entries) {
-    if (!Array.isArray(entries))
-        return new Map();
-    const index = new Map();
-    for (const entry of entries) {
-        const row = fitnessCheckOf(entry);
-        if (row !== null)
-            index.set(row[0], row[1]);
-    }
-    return index;
-}
-//# sourceMappingURL=fitnessChecks.js.map

package/dist/domain/fitnessChecks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fitnessChecks.js","sourceRoot":"","sources":["../../src/domain/fitnessChecks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAkB9C;;;;;;;;;;;GAWG;AACH,SAAS,cAAc,CAAC,KAAc;IACpC,iGAAiG;IACjG,iGAAiG;IACjG,gGAAgG;IAChG,6CAA6C;IAC7C,MAAM,KAAK,GAAG,KAAuE,CAAC;IACtF,IAAI,OAAO,KAAK,EAAE,GAAG,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC5F,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAClC,MAAM,cAAc,GAAG,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACtD,IAAI,KAAK,KAAK,EAAE,IAAI,cAAc,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IACvD,OAAO,CAAC,KAAK,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAAC,OAAgB;IAC9C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,GAAG,EAAE,CAAC;IAC9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAwB,CAAC;IAC9C,KAAK,MAAM,KAAK,IAAI,OAA6B,EAAE,CAAC;QAClD,MAAM,GAAG,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,GAAG,KAAK,IAAI;YAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/domain/qualityCheckFaultMessages.d.ts

@@ -1,43 +0,0 @@
-/**
- * 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 +0,0 @@
-{"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"}

package/dist/domain/qualityCheckFaultMessages.js

@@ -1,38 +0,0 @@
-/**
- * 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 ` +
-        `${fault.actual}.`,
-    [QualityCheckFaultCode.ObservationSideDivergesFromCanon]: (fault) => `QualityCheckReconciliation invariant (@SCN-LDG-030): outcome "${fault.outcome}" requires the ` +
-        `evidence observation (credit) side to be ${fault.required}, but it was ` +
-        `${fault.actual}.`,
-};
-//# sourceMappingURL=qualityCheckFaultMessages.js.map

package/dist/domain/qualityCheckFaultMessages.js.map

@@ -1 +0,0 @@
-{"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"}

package/dist/lib/featureCode.d.ts

@@ -1,21 +0,0 @@
-/**
- * The `scnId → feature-code` grammar helper — the pure core of the feature-code
- * registry (split out of the old spec/featureCodes.ts). Per Evidence
- * Manifesto §9A a scenario id is `SCN-<FFF>-<NNN>` where `<FFF>` is 2–5 uppercase
- * alphanumerics. This is the ONE engine-side owner of parsing the `<FFF>` off a bare
- * scenario id; the impure feature-file discovery (`discoverFeatures`) lives in
- * ingest/ingestScenarios.ts. The duplicate-code lint was product-side in
- * tests/checks/featureCodes.ts until 3F-3313 and is now @SCN-STG-010, a rule of the shipped
- * `spec-controller tags` command in parse/corpusFaults.ts.
- *
- * Reused by the by-feature report grouping (@SCN-RPT-006).
- */
-/**
- * Parse the feature code (the `<FFF>`) from a bare scenario id of the form
- * `SCN-<FFF>-<NNN>` (no leading `@`). Returns null when the id is malformed. The
- * single owner of `scnId → feature-code` parsing — callers reuse this rather than
- * re-deriving a regex (Evidence Manifesto §9A: a scenario id is `SCN-<FFF>-<NNN>`
- * where `<FFF>` is 2–5 uppercase alphanumerics).
- */
-export declare function featureCodeOf(scnId: string): string | null;
-//# sourceMappingURL=featureCode.d.ts.map

package/dist/lib/featureCode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"featureCode.d.ts","sourceRoot":"","sources":["../../src/lib/featureCode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG1D"}

package/dist/lib/featureCode.js

@@ -1,24 +0,0 @@
-/**
- * The `scnId → feature-code` grammar helper — the pure core of the feature-code
- * registry (split out of the old spec/featureCodes.ts). Per Evidence
- * Manifesto §9A a scenario id is `SCN-<FFF>-<NNN>` where `<FFF>` is 2–5 uppercase
- * alphanumerics. This is the ONE engine-side owner of parsing the `<FFF>` off a bare
- * scenario id; the impure feature-file discovery (`discoverFeatures`) lives in
- * ingest/ingestScenarios.ts. The duplicate-code lint was product-side in
- * tests/checks/featureCodes.ts until 3F-3313 and is now @SCN-STG-010, a rule of the shipped
- * `spec-controller tags` command in parse/corpusFaults.ts.
- *
- * Reused by the by-feature report grouping (@SCN-RPT-006).
- */
-/**
- * Parse the feature code (the `<FFF>`) from a bare scenario id of the form
- * `SCN-<FFF>-<NNN>` (no leading `@`). Returns null when the id is malformed. The
- * single owner of `scnId → feature-code` parsing — callers reuse this rather than
- * re-deriving a regex (Evidence Manifesto §9A: a scenario id is `SCN-<FFF>-<NNN>`
- * where `<FFF>` is 2–5 uppercase alphanumerics).
- */
-export function featureCodeOf(scnId) {
-    const match = /^SCN-([A-Z0-9]{2,5})-\d+$/.exec(scnId);
-    return match ? match[1] : null;
-}
-//# sourceMappingURL=featureCode.js.map

package/dist/lib/featureCode.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"featureCode.js","sourceRoot":"","sources":["../../src/lib/featureCode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,MAAM,KAAK,GAAG,2BAA2B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtD,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAClC,CAAC"}

package/dist/parse/corpusCodeFaults.d.ts

@@ -1,76 +0,0 @@
-/**
- * THE CODE RULES of `spec-controller tags` — everything about a feature CODE binding to a feature
- * FILE. Its sibling holds the other question: `corpusGrammarFaults.ts` whether a tag on a scenario
- * means anything. `corpusFaults.ts` composes the two and is the only entry point either of them
- * has.
- *
- * WHY THE MODULE IS SPLIT AT ALL, AND WHY ON THIS SEAM. The rules were authored in one module and
- * that module reached the 400-line `max-lines` ceiling with four more grammar clauses still to
- * land. The ceiling is not negotiable and an exception entry would have bought silence rather than
- * a smaller module (@SCN-FIT-001), so the split is the answer canon already named. The seam is the
- * one the rules themselves have: a code rule asks *does this code name exactly one file, and is
- * this scenario written in the file its own code names* — questions answered from the corpus's
- * SHAPE, needing nothing about the target. A grammar rule asks *does this word mean anything
- * here*, and answers it off the target's own manifest. Two questions, two inputs, two modules.
- *
- * THE PAIR BELOW IS ONE RULE READ FROM BOTH ENDS. `duplicateFeatureCodes` holds one code to one
- * file; `foreignScenarioCodes` holds a file's scenarios to the code that file carries. Together
- * they are what the hand-kept 33-entry allocation table was really enforcing — this code belongs
- * to this file — asked of the corpus about itself rather than of a second list a consumer has
- * never seen.
- */
-import type { CorpusFault, CorpusFile } from "./corpusFaults.js";
-/**
- * A feature code carried by more than one feature file (@SCN-STG-010).
- *
- * THE FAULT IS THE PAIR, NOT EITHER FILE, which is why one finding names them all rather than
- * one finding naming each. Neither file is the offender: what is wrong is that a code names two
- * of them, and a message naming one has already decided which of the two should change.
- *
- * WHAT GOES WRONG WITHOUT IT, MEASURED. Over a corpus whose `one.feature` and `two.feature` both
- * carry `@TGT`, `balance` runs clean through and prints ONE by-feature row — `two (TGT)` —
- * claiming a scenario that lives in `one`. Not a red and not a warning: a report cell that says
- * something false, in the section a reader goes to first.
- *
- * AN UNCODED FILE IS NOT A FAULT HERE, and that is a scope line rather than an omission. A file
- * carrying no header code while its scenarios carry `@SCN` ids is admitted unchanged; whether
- * that should red is a policy question about gradual adoption, filed as its own ticket (3F-3314).
- * `null` is therefore skipped rather than treated as a code two files could share.
- */
-export declare function duplicateFeatureCodes(features: readonly CorpusFile[]): CorpusFault[];
-/**
- * A scenario whose `@SCN` names a feature its own file is not (@SCN-STG-011).
- *
- * THE OTHER HALF OF THE PAIR ABOVE. That rule holds one code to one file; this one holds a
- * file's scenarios to the code that file carries.
- *
- * WHAT GOES WRONG WITHOUT IT, MEASURED. Over a corpus whose `@TGT`-headed file holds
- * `@SCN-ZZZ-001`, `balance` runs clean through and prints a by-feature row for a feature `ZZZ`
- * it INVENTED from the id alone — no file in the corpus carries that code — and the
- * feature-code lint over the same tree reports every code a header names unique and registered.
- * Silent in both readers, which is exactly the pair of places a reader looks.
- *
- * THE FINDING NAMES THREE THINGS AND ONE SCENARIO. The file and the id say where to go; the
- * code the file CARRIES is the half of the disagreement the author cannot read off the id, and
- * it is what decides which of the two remedies they want — re-code the scenario, or move it.
- * And it is raised per offending scenario, never per file: a file may hold many scenarios of
- * which one is wrong, and a finding naming the file alone convicts the rest of them.
- *
- * AN UNCODED FILE RAISES NOTHING, deliberately rather than by omission. A file carrying no
- * header code has nothing for an id to be foreign TO. Whether that should red is a policy
- * question about gradual adoption, filed as its own ticket (3F-3314) — and it is the same
- * `null`-is-not-a-code line the duplicate rule draws, drawn once more here so the two cannot
- * come to disagree about what an uncoded file is.
- *
- * AND A MALFORMED ID RAISES NOTHING EITHER, because something else already does. `featureCodeOf`
- * is the ONE owner of the `SCN-<FFF>-<NNN>` grammar in this engine, and an id it cannot parse
- * has no feature part to compare — that fault is `no-scn-code`, which a reconciliation raises
- * and names by id. A second diagnostic here would print one fault's remedy at the other's author.
- *
- * The tag walk is `parseTaggedScenarios`, which inherits Feature- and Rule-level tags exactly as
- * cucumber does. A hand-rolled scan of the tag lines is the second reading that walk was
- * extracted to end, and it is what a rule ABOUT ids can least afford: an id hoisted to a `Rule:`
- * belongs to every scenario beneath it, and a scan that missed that would pass over the file.
- */
-export declare function foreignScenarioCodes(features: readonly CorpusFile[]): CorpusFault[];
-//# sourceMappingURL=corpusCodeFaults.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"corpusCodeFaults.d.ts","sourceRoot":"","sources":["../../src/parse/corpusCodeFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,CAuBpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,CAoBnF"}

package/dist/parse/corpusCodeFaults.js

@@ -1,121 +0,0 @@
-/**
- * THE CODE RULES of `spec-controller tags` — everything about a feature CODE binding to a feature
- * FILE. Its sibling holds the other question: `corpusGrammarFaults.ts` whether a tag on a scenario
- * means anything. `corpusFaults.ts` composes the two and is the only entry point either of them
- * has.
- *
- * WHY THE MODULE IS SPLIT AT ALL, AND WHY ON THIS SEAM. The rules were authored in one module and
- * that module reached the 400-line `max-lines` ceiling with four more grammar clauses still to
- * land. The ceiling is not negotiable and an exception entry would have bought silence rather than
- * a smaller module (@SCN-FIT-001), so the split is the answer canon already named. The seam is the
- * one the rules themselves have: a code rule asks *does this code name exactly one file, and is
- * this scenario written in the file its own code names* — questions answered from the corpus's
- * SHAPE, needing nothing about the target. A grammar rule asks *does this word mean anything
- * here*, and answers it off the target's own manifest. Two questions, two inputs, two modules.
- *
- * THE PAIR BELOW IS ONE RULE READ FROM BOTH ENDS. `duplicateFeatureCodes` holds one code to one
- * file; `foreignScenarioCodes` holds a file's scenarios to the code that file carries. Together
- * they are what the hand-kept 33-entry allocation table was really enforcing — this code belongs
- * to this file — asked of the corpus about itself rather than of a second list a consumer has
- * never seen.
- */
-import { featureCodeOf } from "../lib/featureCode.js";
-import { parseTaggedScenarios } from "./scenarios.js";
-/**
- * A feature code carried by more than one feature file (@SCN-STG-010).
- *
- * THE FAULT IS THE PAIR, NOT EITHER FILE, which is why one finding names them all rather than
- * one finding naming each. Neither file is the offender: what is wrong is that a code names two
- * of them, and a message naming one has already decided which of the two should change.
- *
- * WHAT GOES WRONG WITHOUT IT, MEASURED. Over a corpus whose `one.feature` and `two.feature` both
- * carry `@TGT`, `balance` runs clean through and prints ONE by-feature row — `two (TGT)` —
- * claiming a scenario that lives in `one`. Not a red and not a warning: a report cell that says
- * something false, in the section a reader goes to first.
- *
- * AN UNCODED FILE IS NOT A FAULT HERE, and that is a scope line rather than an omission. A file
- * carrying no header code while its scenarios carry `@SCN` ids is admitted unchanged; whether
- * that should red is a policy question about gradual adoption, filed as its own ticket (3F-3314).
- * `null` is therefore skipped rather than treated as a code two files could share.
- */
-export function duplicateFeatureCodes(features) {
-    const filesByCode = new Map();
-    for (const file of features) {
-        if (file.featureCode === null)
-            continue;
-        filesByCode.set(file.featureCode, [
-            ...(filesByCode.get(file.featureCode) ?? []),
-            `${file.slug}.feature`,
-        ]);
-    }
-    const faults = [];
-    for (const [code, files] of filesByCode) {
-        if (files.length < 2)
-            continue;
-        faults.push({
-            kind: "duplicate-feature-code",
-            message: `duplicate-feature-code: the feature code @${code} is carried by ${files.length} feature ` +
-                `files — ${files.join(", ")}. A feature code names exactly one feature file: a ` +
-                `reconciliation's by-feature cut groups on it, so two files sharing a code report as one ` +
-                `row and attribute one file's scenarios to the other. Give one of them a code of its own.`,
-        });
-    }
-    return faults;
-}
-/**
- * A scenario whose `@SCN` names a feature its own file is not (@SCN-STG-011).
- *
- * THE OTHER HALF OF THE PAIR ABOVE. That rule holds one code to one file; this one holds a
- * file's scenarios to the code that file carries.
- *
- * WHAT GOES WRONG WITHOUT IT, MEASURED. Over a corpus whose `@TGT`-headed file holds
- * `@SCN-ZZZ-001`, `balance` runs clean through and prints a by-feature row for a feature `ZZZ`
- * it INVENTED from the id alone — no file in the corpus carries that code — and the
- * feature-code lint over the same tree reports every code a header names unique and registered.
- * Silent in both readers, which is exactly the pair of places a reader looks.
- *
- * THE FINDING NAMES THREE THINGS AND ONE SCENARIO. The file and the id say where to go; the
- * code the file CARRIES is the half of the disagreement the author cannot read off the id, and
- * it is what decides which of the two remedies they want — re-code the scenario, or move it.
- * And it is raised per offending scenario, never per file: a file may hold many scenarios of
- * which one is wrong, and a finding naming the file alone convicts the rest of them.
- *
- * AN UNCODED FILE RAISES NOTHING, deliberately rather than by omission. A file carrying no
- * header code has nothing for an id to be foreign TO. Whether that should red is a policy
- * question about gradual adoption, filed as its own ticket (3F-3314) — and it is the same
- * `null`-is-not-a-code line the duplicate rule draws, drawn once more here so the two cannot
- * come to disagree about what an uncoded file is.
- *
- * AND A MALFORMED ID RAISES NOTHING EITHER, because something else already does. `featureCodeOf`
- * is the ONE owner of the `SCN-<FFF>-<NNN>` grammar in this engine, and an id it cannot parse
- * has no feature part to compare — that fault is `no-scn-code`, which a reconciliation raises
- * and names by id. A second diagnostic here would print one fault's remedy at the other's author.
- *
- * The tag walk is `parseTaggedScenarios`, which inherits Feature- and Rule-level tags exactly as
- * cucumber does. A hand-rolled scan of the tag lines is the second reading that walk was
- * extracted to end, and it is what a rule ABOUT ids can least afford: an id hoisted to a `Rule:`
- * belongs to every scenario beneath it, and a scan that missed that would pass over the file.
- */
-export function foreignScenarioCodes(features) {
-    const faults = [];
-    for (const file of features) {
-        if (file.featureCode === null)
-            continue;
-        for (const scenario of parseTaggedScenarios(file.source)) {
-            const named = featureCodeOf(scenario.scnId);
-            if (named === null || named === file.featureCode)
-                continue;
-            faults.push({
-                kind: "foreign-scenario-code",
-                message: `foreign-scenario-code: ${file.slug}.feature carries the feature code ` +
-                    `@${file.featureCode}, but holds the scenario @${scenario.scnId}, whose feature part ` +
-                    `names ${named}. A scenario's code names the file it is written in: a ` +
-                    `reconciliation's by-feature cut groups on the id, so this one opens a row for a ` +
-                    `feature no file in the corpus carries and files the scenario under it. Re-code the ` +
-                    `scenario for @${file.featureCode}, or move it to the file headed @${named}.`,
-            });
-        }
-    }
-    return faults;
-}
-//# sourceMappingURL=corpusCodeFaults.js.map

package/dist/parse/corpusCodeFaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpusCodeFaults.js","sourceRoot":"","sources":["../../src/parse/corpusCodeFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAA+B;IACnE,MAAM,WAAW,GAAG,IAAI,GAAG,EAAoB,CAAC;IAChD,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI;YAAE,SAAS;QACxC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE;YAChC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;YAC5C,GAAG,IAAI,CAAC,IAAI,UAAU;SACvB,CAAC,CAAC;IACL,CAAC;IAED,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,WAAW,EAAE,CAAC;QACxC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,SAAS;QAC/B,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,wBAAwB;YAC9B,OAAO,EACL,6CAA6C,IAAI,kBAAkB,KAAK,CAAC,MAAM,WAAW;gBAC1F,WAAW,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,qDAAqD;gBAChF,0FAA0F;gBAC1F,0FAA0F;SAC7F,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAA+B;IAClE,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI;YAAE,SAAS;QACxC,KAAK,MAAM,QAAQ,IAAI,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACzD,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC,WAAW;gBAAE,SAAS;YAC3D,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EACL,0BAA0B,IAAI,CAAC,IAAI,oCAAoC;oBACvE,IAAI,IAAI,CAAC,WAAW,6BAA6B,QAAQ,CAAC,KAAK,uBAAuB;oBACtF,SAAS,KAAK,yDAAyD;oBACvE,kFAAkF;oBAClF,qFAAqF;oBACrF,iBAAiB,IAAI,CAAC,WAAW,oCAAoC,KAAK,GAAG;aAChF,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}