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

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/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"}

package/dist/parse/corpusFaults.d.ts

@@ -1,124 +0,0 @@
-/**
- * THE `@SCN` SCHEME'S OWN RULES, asked of a target's Gherkin corpus — the rule half of
- * `spec-controller tags`.
- *
- * WHY IT SHIPS AT ALL. The tool hands a consumer the `@SCN` scheme and then made them write
- * the guards that keep it usable; 816 lines of exactly that sat in this repository's own check
- * tree, published nowhere. An adopter got the codes and inherited none of the policing, so
- * nobody's tags were policed but ours. These rules are the kind that CAN ship: every one of
- * them reads a corpus the engine already parses, rather than needing to know what a piece of
- * text IS.
- *
- * WHY IT IS IN CORE AND NOT AT THE CLI EDGE. It is `evidenceReconciliationFromSources`'s shape,
- * taken deliberately rather than by analogy. The published CLI module may reach core only
- * through the ROOT barrel — `./internal` is dropped by `publishConfig.exports` at pack time,
- * which is how an installed `balance --help` once threw ERR_PACKAGE_PATH_NOT_EXPORTED behind
- * thirteen green gates (3F-3086). So the CALLER lives on this side of the boundary and the app
- * hands over bytes; nothing internal is re-exported to buy it.
- *
- * WHAT SEPARATES A FAULT FROM A VERDICT. `balance`'s exit code IS its verdict — balanced, out of
- * balance, pending-under-strict, unsound, nothing-to-reconcile — and a corpus fault is not a
- * reconciliation verdict. It
- * is a statement that the corpus itself is malformed, which is why it is a second command with
- * its own status ladder rather than a fourth meaning bolted onto a status a consumer's CI
- * branches on.
- *
- * NOTHING HERE READS A FILE, AND NOTHING HERE RE-READS ONE. Every input arrives already read,
- * for `evidenceReconciliationFromSources`'s reason: an engine handed a reader is an engine doing
- * I/O wearing a callback, and `lint:boundaries`' `core-imports-io` rule reds over exactly that
- * (@SCN-EPG-001's `io-import` arm until 3F-3437).
- *
- * WHAT IS LEFT IN THIS MODULE, AND WHAT MOVED OUT. The rules themselves live in two siblings —
- * `corpusCodeFaults.ts` (a code binding to a file) and `corpusGrammarFaults.ts` (a tag meaning
- * something) — because the joined module reached the 400-line `max-lines` ceiling, and canon rules
- * that split rather than an exception entry (@SCN-FIT-001). A third sibling held the claim rule
- * (how many checks one scenario claims) until it left with the measured axis (3F-3516). What
- * stays here is the composition and the VOCABULARY: the fault kinds, the shape of a discovered
- * file, and the one entry point any sibling has. Splitting on any other seam would have put a
- * rule's inputs in one module and its finding's wording in another.
- */
-import type { PackageJsonScripts } from "./checkScriptsRunInCI.js";
-/**
- * A target's manifest as these rules read it — its scripts, and its `specController` block.
- *
- * Spelled here rather than imported for the reason the reconcile composition spells its own:
- * every field of it is `unknown` until a resolver narrows it, so the type is a statement about
- * what a manifest on disk IS rather than a contract owed to anybody.
- */
-export type TargetManifest = PackageJsonScripts & {
-    specController?: {
-        deferralTags?: unknown;
-        fitnessChecks?: unknown;
-    };
-};
-/**
- * One way a corpus breaks the `@SCN` scheme's own rules.
- *
- * THREE KINDS, NOT ONE, because they are three faults with three different fixes — the same
- * argument that split the tier-tag check's findings three ways. `duplicate-feature-code` says
- * *give one of these files a code of its own*; `foreign-scenario-code` says *this id names a
- * file it is not written in*; and `unrecognised-tag` says *this word means nothing here*. A
- * fourth, `multiple-check-tags`, left with the measured axis (3F-3516). Collapsing any two would
- * print one fault's remedy at the other's author, which is precisely how a mistyped tier tag
- * stayed invisible for as long as it did.
- *
- * THE UNION IS THE COMMAND'S WHOLE VOCABULARY, and it is stated once here rather than grown a
- * member at a time by whichever rule landed last. That is also why it stayed in this module when
- * the rules left it: the two rule modules each raise a subset of these kinds, and a union
- * assembled from both sides would be a statement about the command that no single file made. The
- * two CODE rules have producers — `duplicate-feature-code` (@SCN-STG-010) and
- * `foreign-scenario-code` (@SCN-STG-011); so does `unrecognised-tag` (@SCN-STG-002, and the
- * clauses that narrow what it reaches at @SCN-STG-003, @SCN-STG-004 and @SCN-STG-005). Every
- * member of the union is raised by a rule with a scenario of its own, which is the state the kinds
- * were written down ahead of.
- */
-export interface CorpusFault {
-    readonly kind: "unrecognised-tag" | "duplicate-feature-code" | "foreign-scenario-code";
-    readonly message: string;
-}
-/** One discovered feature file, as the edge read it. */
-export interface CorpusFile {
-    /** The feature-file basename without the `.feature` extension. */
-    slug: string;
-    /**
-     * The file's `@<FFF>` header code, or null where it carries none.
-     *
-     * IT ARRIVES; IT IS NEVER RE-DERIVED HERE. The header is read by exactly one thing — the
-     * ingest edge's `extractFeatureCode` — and that is also the reading a reconciliation's
-     * *Out-of-balance by feature* cut groups on. A second reading inside this module would be free
-     * to disagree with the report about the very field these rules are ABOUT, and the check could
-     * then pass clean over a corpus whose report mis-attributes a scenario. So it is a parameter.
-     */
-    featureCode: string | null;
-    /** The file's raw Gherkin source, read once at the edge. */
-    source: string;
-}
-/**
- * Every way this corpus breaks the scheme, in a stable order.
- *
- * THE ONE ENTRY POINT, and the reason the rules' own modules are not on the barrel. A consumer's
- * route to this capability is the CLI; a second route through an imported rule would be a second
- * surface to freeze, and it would let the code rules and the grammar rules be run over two
- * different readings of one corpus.
- *
- * @param input.features the target's discovered feature files — slug, header code and source,
- * read ONCE at the edge so two discoveries can never disagree about which corpus was judged.
- * @param input.packageJson the TARGET's manifest, from which the recognised deferral set is
- * resolved INSIDE this engine — through the same resolver the reconciliation reads it with, so the
- * rules here admit exactly what the reconciliation honours as a skip. READ SINCE 3F-3303, by the
- * grammar rules and only by them: the deferral set (@SCN-PND-021) is resolved from it. The
- * check-tag halves once read from it — the REGISTERED half (@SCN-STG-005) and the MEASURED half
- * — are retired (3F-3161, 3F-3516). The code rules never see it, which is the seam the module
- * split was drawn on.
- * @param input.deferralTags the application layer's STARTER deferral set, which a target's
- * config may only extend. Product policy, single-sourced there and never here — the same
- * argument, and the same parameter, as the reconcile composition's. Read since 3F-3303, and
- * handed onward unresolved: what turns it into the target's recognised set is
- * `resolveDeferralTags`, called once beside the rule that asks the question.
- */
-export declare function corpusFaults(input: {
-    features: readonly CorpusFile[];
-    packageJson: TargetManifest;
-    deferralTags: readonly string[];
-}): CorpusFault[];
-//# sourceMappingURL=corpusFaults.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"corpusFaults.d.ts","sourceRoot":"","sources":["../../src/parse/corpusFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAInE;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,kBAAkB,GAAG;IAChD,cAAc,CAAC,EAAE;QACf,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EACT,kBAAkB,GAClB,wBAAwB,GACxB,uBAAuB,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wDAAwD;AACxD,MAAM,WAAW,UAAU;IACzB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;OAQG;IACH,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IAChC,WAAW,EAAE,cAAc,CAAC;IAC5B,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,GAAG,WAAW,EAAE,CAMhB"}

package/dist/parse/corpusFaults.js

@@ -1,72 +0,0 @@
-/**
- * THE `@SCN` SCHEME'S OWN RULES, asked of a target's Gherkin corpus — the rule half of
- * `spec-controller tags`.
- *
- * WHY IT SHIPS AT ALL. The tool hands a consumer the `@SCN` scheme and then made them write
- * the guards that keep it usable; 816 lines of exactly that sat in this repository's own check
- * tree, published nowhere. An adopter got the codes and inherited none of the policing, so
- * nobody's tags were policed but ours. These rules are the kind that CAN ship: every one of
- * them reads a corpus the engine already parses, rather than needing to know what a piece of
- * text IS.
- *
- * WHY IT IS IN CORE AND NOT AT THE CLI EDGE. It is `evidenceReconciliationFromSources`'s shape,
- * taken deliberately rather than by analogy. The published CLI module may reach core only
- * through the ROOT barrel — `./internal` is dropped by `publishConfig.exports` at pack time,
- * which is how an installed `balance --help` once threw ERR_PACKAGE_PATH_NOT_EXPORTED behind
- * thirteen green gates (3F-3086). So the CALLER lives on this side of the boundary and the app
- * hands over bytes; nothing internal is re-exported to buy it.
- *
- * WHAT SEPARATES A FAULT FROM A VERDICT. `balance`'s exit code IS its verdict — balanced, out of
- * balance, pending-under-strict, unsound, nothing-to-reconcile — and a corpus fault is not a
- * reconciliation verdict. It
- * is a statement that the corpus itself is malformed, which is why it is a second command with
- * its own status ladder rather than a fourth meaning bolted onto a status a consumer's CI
- * branches on.
- *
- * NOTHING HERE READS A FILE, AND NOTHING HERE RE-READS ONE. Every input arrives already read,
- * for `evidenceReconciliationFromSources`'s reason: an engine handed a reader is an engine doing
- * I/O wearing a callback, and `lint:boundaries`' `core-imports-io` rule reds over exactly that
- * (@SCN-EPG-001's `io-import` arm until 3F-3437).
- *
- * WHAT IS LEFT IN THIS MODULE, AND WHAT MOVED OUT. The rules themselves live in two siblings —
- * `corpusCodeFaults.ts` (a code binding to a file) and `corpusGrammarFaults.ts` (a tag meaning
- * something) — because the joined module reached the 400-line `max-lines` ceiling, and canon rules
- * that split rather than an exception entry (@SCN-FIT-001). A third sibling held the claim rule
- * (how many checks one scenario claims) until it left with the measured axis (3F-3516). What
- * stays here is the composition and the VOCABULARY: the fault kinds, the shape of a discovered
- * file, and the one entry point any sibling has. Splitting on any other seam would have put a
- * rule's inputs in one module and its finding's wording in another.
- */
-import { duplicateFeatureCodes, foreignScenarioCodes } from "./corpusCodeFaults.js";
-import { unrecognisedTags } from "./corpusGrammarFaults.js";
-/**
- * Every way this corpus breaks the scheme, in a stable order.
- *
- * THE ONE ENTRY POINT, and the reason the rules' own modules are not on the barrel. A consumer's
- * route to this capability is the CLI; a second route through an imported rule would be a second
- * surface to freeze, and it would let the code rules and the grammar rules be run over two
- * different readings of one corpus.
- *
- * @param input.features the target's discovered feature files — slug, header code and source,
- * read ONCE at the edge so two discoveries can never disagree about which corpus was judged.
- * @param input.packageJson the TARGET's manifest, from which the recognised deferral set is
- * resolved INSIDE this engine — through the same resolver the reconciliation reads it with, so the
- * rules here admit exactly what the reconciliation honours as a skip. READ SINCE 3F-3303, by the
- * grammar rules and only by them: the deferral set (@SCN-PND-021) is resolved from it. The
- * check-tag halves once read from it — the REGISTERED half (@SCN-STG-005) and the MEASURED half
- * — are retired (3F-3161, 3F-3516). The code rules never see it, which is the seam the module
- * split was drawn on.
- * @param input.deferralTags the application layer's STARTER deferral set, which a target's
- * config may only extend. Product policy, single-sourced there and never here — the same
- * argument, and the same parameter, as the reconcile composition's. Read since 3F-3303, and
- * handed onward unresolved: what turns it into the target's recognised set is
- * `resolveDeferralTags`, called once beside the rule that asks the question.
- */
-export function corpusFaults(input) {
-    return [
-        ...duplicateFeatureCodes(input.features),
-        ...foreignScenarioCodes(input.features),
-        ...unrecognisedTags(input.features, input.packageJson, input.deferralTags),
-    ];
-}
-//# sourceMappingURL=corpusFaults.js.map

package/dist/parse/corpusFaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"corpusFaults.js","sourceRoot":"","sources":["../../src/parse/corpusFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AA+D5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,YAAY,CAAC,KAI5B;IACC,OAAO;QACL,GAAG,qBAAqB,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxC,GAAG,oBAAoB,CAAC,KAAK,CAAC,QAAQ,CAAC;QACvC,GAAG,gBAAgB,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,YAAY,CAAC;KAC3E,CAAC;AACJ,CAAC"}

package/dist/parse/corpusGrammarFaults.d.ts

@@ -1,71 +0,0 @@
-/**
- * THE GRAMMAR RULES of `spec-controller tags` — everything about whether a TAG on a scenario
- * means anything. Its sibling holds the other question: `corpusCodeFaults.ts` whether a feature
- * code binds to one feature file. `corpusFaults.ts` composes the two and is the only entry point
- * either of them has.
- *
- * THE SEAM, STATED FROM THIS SIDE. A grammar rule asks *is this word part of the `@SCN` scheme*,
- * and the answer is assembled from places that are not this module's: the engine's own
- * quality-check maps, the `SCN-<FFF>-<NNN>` spelling `featureCodeOf` owns, and the target's own
- * manifest. A code rule needs none of those; it reads the corpus's shape. Two questions, two
- * modules; the split happened when the joined module reached the 400-line `max-lines` ceiling
- * with four more grammar clauses still to land (@SCN-FIT-001, and never an exception entry). The
- * claim rule that once made a third sibling left with the measured axis (3F-3516): once the axis
- * word is the only word that names a check, no scenario can claim two.
- *
- * AND THE TARGET'S HALF IS RESOLVED HERE, NOT HANDED IN RESOLVED. The composition hands this
- * module a manifest rather than an answer, so the read lives beside the rule that uses it — the
- * arrangement the parent's Design settled for the check-tag union and applied here first, because
- * the whole reason the floor and the obligation rule once disagreed about a set was that each
- * assembled its own. The composition passes bytes and policy; what a word MEANS is decided in one
- * place.
- *
- * NOTHING HERE IS RESTATED. The recognised set is the whole subject of this module, and every
- * member of it is DERIVED from the place that already owns it — a list written out here would
- * agree with its source by diligence and then drift, and the check that then reds is the one
- * telling authors which words are legitimate.
- */
-import type { CorpusFault, CorpusFile, TargetManifest } from "./corpusFaults.js";
-/**
- * A tag on an `@SCN` scenario that means nothing here (@SCN-STG-002, @SCN-STG-003, @SCN-STG-004).
- *
- * ONE VERDICT, AND THE DIAGNOSIS IS SEPARATE FROM IT. Whether a tag is grammar is decided by
- * `isGrammar` alone; what the message then SAYS about it is `unrecognisedTagFault`'s. Keeping the
- * two apart is what lets the group-prefixed reading be as broad as it is (@SCN-STG-004) without
- * ever widening or narrowing what reds.
- *
- * THE TYPO THE REST OF THE MODEL CANNOT SEE, measured rather than argued. `@untit` ALONE
- * reconciles both-missing, so half of this fault a reconciliation does cover. Planted beside a
- * real tier — `@unit @untit` — the only reconciling item is the absent unit Evidence Observation:
- * the typo contributes nothing and is named nowhere, in any cell, at any exit status.
- *
- * PER TAG, NOT PER SCENARIO, because two junk tags are two things to fix and a finding naming one
- * of them leaves the author to re-run the command to discover the other.
- *
- * ONLY `@SCN` SCENARIOS ARE ASKED, which comes free from `parseTaggedScenarios` — it yields
- * nothing for a scenario carrying no id. That is the same scope the tier floor drew and it is
- * drawn for the same reason: a corpus mid-adoption has scenarios the scheme has not reached yet,
- * and policing their tag lines would make adopting the scheme a whole-corpus edit.
- *
- * AND A PARKED SCENARIO IS ASKED TOO (@SCN-STG-003). There is no clause anywhere below that
- * excuses a scenario for carrying a deferral tag, and that absence is the discipline rather than
- * an oversight: parking defers what a scenario OWES, never whether its tags are spelled right.
- * This very set is what lets the walk recognise the parking tag, so excusing the walk on a parked
- * scenario would hide `@wip @untit` — a check whose teeth come off by writing one more tag. The
- * resolve happens once, before the walk, for that reason as much as for the cost.
- *
- * @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 ingest edge
- * reads it with — one reading of `specController.deferralTags` (@SCN-PND-021), so the words this
- * rule calls legitimate are exactly the words the engine beside it honours as a skip.
- * The target's own check registry is retired and read nowhere in this assembly (@SCN-STG-005,
- * 3F-3161). A set handed in already resolved would have been a second answer travelling under the
- * first's name.
- * @param starterDeferralTags the APPLICATION layer's starter set, which a target's config may only
- * extend and never replace. It is a parameter because it is product policy — an evolvable list of
- * strings — and a copy held in core would be a second statement of it. Pass none and this clause
- * recognises nothing it was not given, which is the difference between owning a policy and
- * hard-coding someone else's.
- */
-export declare function unrecognisedTags(features: readonly CorpusFile[], packageJson: TargetManifest, starterDeferralTags: readonly string[]): CorpusFault[];
-//# sourceMappingURL=corpusGrammarFaults.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"corpusGrammarFaults.d.ts","sourceRoot":"","sources":["../../src/parse/corpusGrammarFaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA2NjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,WAAW,EAAE,cAAc,EAC3B,mBAAmB,EAAE,SAAS,MAAM,EAAE,GACrC,WAAW,EAAE,CAqBf"}