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

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

package/dist/parse/corpusGrammarFaults.js

@@ -1,292 +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 { featureCodeOf } from "../lib/featureCode.js";
-import { FITNESS_AXIS_TAG, PENDING_QUALITY_CHECK_TAGS, RUNTIME_QUALITY_CHECK_TAGS, parseTaggedScenarios, } from "./scenarios.js";
-import { resolveDeferralTags } from "./targetManifest.js";
-/**
- * The tier tags an unrecognised tag is measured against, and the set that answers whether a tag
- * NAMES a tier at all.
- *
- * DERIVED, NEVER RESTATED, which is the whole reason this rule could ship. The words live in the
- * engine's own quality-check maps; a list written out here would agree with them by diligence and
- * then drift the first time a tier is added — and the check that then reds is the one telling
- * authors which words are legitimate.
- *
- * BARE `lint` IS ONE OF THEM and is not in either map, because `@lint` is not a runtime tier: it
- * is the style-lint check, a flat peer of `@complexity`, which raises a `lint` obligation without
- * a runtime observation. It is named here rather than pushed into `TAG_TO_QUALITY_CHECK`, where
- * it would start raising runtime obligations for every scenario that carries it.
- *
- * `lintpending` ARRIVES WITH THE PENDING LIST, and that is one word wider than the private check
- * this rule moved out of. That check kept its own four-member tier list, so `@lintpending` was
- * unrecognised there while the engine beside it read the same tag as a deferred `lint`
- * obligation — two readers of one corpus disagreeing about one word, which is precisely the
- * second reading this module exists to end. Taking the engine's own lexicon closes it.
- */
-const TIER_TAGS = [
-    ...RUNTIME_QUALITY_CHECK_TAGS,
-    "lint",
-    ...PENDING_QUALITY_CHECK_TAGS,
-];
-/**
- * Every word that NAMES A CHECK on this target (@SCN-STG-005) — the set the grammar admits
- * beside the scheme's own tier tags.
- *
- * ONE ASSEMBLY, AND THAT IS THE WHOLE POINT OF ITS BEING HERE. The tier floor this rule
- * replaced assembled its own copy at a private CLI while the obligation rule assembled another
- * in the engine, and the two coming to disagree about this set cost a slice (3F-3126). Resolving
- * it beside the rule that asks the question means the words this command calls legitimate are
- * the words the engine beside it raises obligations from — there is no second answer to fall
- * behind the first, and no package boundary for one to be resolved on either side of.
- *
- * NO BARE TAG NAMES A CHECK ANY LONGER (3F-3161). The target's own check registry used to be
- * read here as the TARGET's answer for which bare words meant a check; that reading is retired,
- * and a bare check tag is grammar nowhere now, registered or not. The measured tags read off the
- * target's own thresholds left with the measured axis (3F-3516), so the one word this function
- * admits beside the scheme's own tiers is the converted axis word — and it reads no manifest to
- * find it, because the word is the model's. A target still writing a bare check tag is read
- * nowhere by this assembly, which is the whole of what @SCN-STG-005 changed.
- *
- * AND THE AXIS WORD IS NOT THE TARGET'S TO GRANT (3F-3138, 3F-3149). A CONVERTED check carries
- * one word for the whole axis and puts its CHARACTERISTIC on a configured row, so the retired
- * registry names it nowhere and never will. Which words name a CHECK is the target's
- * answer; which axis a scenario is ON is the model's, exactly as `unit` is — so the word is
- * admitted whatever the manifest holds, and a target that has converted nothing does not get to
- * spell it differently. It arrives as `FITNESS_AXIS_TAG`, the one spelling of it, because a
- * literal written out here would be a second answer travelling under the first's name.
- *
- * A CONVERTED SCENARIO NO CONFIGURED ROW NAMES IS ADMITTED, deliberately: that IS a corpus
- * fault, and it is @SCN-LNT-020's, which names the scenario by id and leaves the one remedy
- * there is. Redding it here too would print half of one fault in a second place with the wrong
- * remedy attached — *this word means nothing here*, said to an author whose scenario names the
- * one axis the model has.
- */
-function checkTagsOf() {
-    return [FITNESS_AXIS_TAG];
-}
-/** Levenshtein distance, uncapped — the strings here are tag-length. */
-function editDistance(a, b) {
-    let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-    for (let i = 1; i <= a.length; i += 1) {
-        const current = [i];
-        for (let j = 1; j <= b.length; j += 1) {
-            const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
-            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, substitution);
-        }
-        previous = current;
-    }
-    return previous[b.length];
-}
-/**
- * The tier an unrecognised tag was probably meant to be, or undefined when none is close.
- *
- * A COURTESY, NEVER THE VERDICT. The tag reds whether or not a suggestion is found, so a wrong
- * guess costs a poor message and nothing else. A guess that DECIDED the outcome would make the
- * command only as good as its edit distance.
- *
- * Distance 2 rather than 1 catches the drop-plus-transpose shapes (`@untegration`); wider than
- * that and `@e2e` starts attracting every short tag in the corpus.
- */
-function nearestTier(bare) {
-    let best;
-    let bestDistance = 3;
-    for (const tier of TIER_TAGS) {
-        const distance = editDistance(bare.toLowerCase(), tier);
-        if (distance < bestDistance) {
-            bestDistance = distance;
-            best = tier;
-        }
-    }
-    return best;
-}
-/**
- * The bare tag a group-prefixed tag should have been (@SCN-STG-004), or undefined where the tag
- * carries no value to strip a group from.
- *
- * `fitness=complexity` spells into the tag what the model already holds. There is no
- * `behavioural=unit`, so there is no `fitness=complexity` (canon 2026-08-07, the bare-tags
- * Correction) — and the author's intent survives the mistake intact: drop the group and what is
- * left is the tag they wanted.
- *
- * NO LIST OF GROUP NAMES IS CONSULTED, because there is nothing to list. The words a codebase
- * might reach for are not enumerable, and a list of the ones canon happens to name would green the
- * first group name nobody thought of. So the SHAPE is the whole of the rule: a value means a group
- * was spelled in, whatever the group is called.
- *
- * AND THE RETIRED `lint=<handle>` FORM REACHES IT, served by the same rule rather than carved out.
- * That form raises no Evidence Obligation (@SCN-LNT-007), so admitting it as a tier would let a
- * scenario look tiered while owing nothing — which is the silent slip these rules exist to close,
- * re-opened by the one shape a reader would most expect to be excused. The private check this rule
- * replaced did carve it out, for as long as the form was live; nothing here has to remember to
- * take that clause away again.
- *
- * IT DECIDES NOTHING, WHICH IS WHY IT IS SAFE TO BE THIS BROAD. `isGrammar` has already answered
- * the verdict by the time this is asked; a tag reaching here reds whatever this returns.
- */
-function groupPrefixedMember(tag) {
-    return /^[^=]+=(.+)$/.exec(tag)?.[1];
-}
-/**
- * Why an unrecognised tag is unrecognised, and what to write instead — the clause following
- * `carries @<tag>,` in the message.
- *
- * TWO SHAPES, ONE VERDICT, TWO MESSAGES. A group-prefixed tag resembles no tier, so edit distance
- * has nothing to offer it (@SCN-STG-004); what it has instead is a legible intent, and the message
- * names the bare tag rather than leaving the author to work out which half of their tag was the
- * mistake. Every other unrecognised tag falls back to the near-miss courtesy, which stays a
- * courtesy and never the verdict (@SCN-STG-002). Collapsing the two would print one fault's remedy
- * at the other's author — the wrong-message failure the fault kinds were split to avoid.
- */
-function unrecognisedTagFault(tag) {
-    const member = groupPrefixedMember(tag);
-    if (member !== undefined) {
-        return (`which spells a group into the tag — a check is named bare, its group living in the ` +
-            `model — so this should have been @${member}`);
-    }
-    const suggestion = nearestTier(tag);
-    return (`which is neither an evidence tier nor a recognised deferral tag` +
-        (suggestion === undefined ? "" : ` — did you mean @${suggestion}?`));
-}
-/**
- * Is this tag part of the `@SCN` scheme's grammar, on a scenario in this file?
- *
- * SIX CLAUSES, AND ONE OF THEM CARRIES THE WHOLE CHECK-TAG SET. What this rule reaches is the
- * scheme's own words, the target's deferral set, and `checkTagsOf`'s one word — the axis word (a
- * bare check tag is grammar nowhere now, 3F-3161, and the measured tags left with the measured
- * axis, 3F-3516). That the set grew and then shrank to one source changed nothing here, which is
- * the point of assembling it there: a clause reading one source at a time would have had to move
- * with it.
- *
- * THE FILE'S HEADER CODE IS GRAMMAR, and that clause is new rather than moved. `@TGT` sits on the
- * `Feature:` line and `parseTaggedScenarios` inherits it onto every scenario beneath, exactly as
- * cucumber does — so without this clause the rule reds every scenario in every coded file:
- * measured over this repository's own corpus, 253 scenario/tag pairs across 28 codes. The private
- * scan this rule replaced never met the case because it read a scenario's own tag block and
- * nothing above it, which is the second reading `parseTaggedScenarios` was extracted to end.
- *
- * A WELL-FORMED `@SCN` ID IS GRAMMAR WHEREVER IT SITS — `featureCodeOf` is the one owner of that
- * spelling, so an id it parses is recognised here without a second regex. An id it CANNOT parse
- * is not this fault: `no-scn-code` raises it, names it, and would print a different remedy.
- *
- * A WORD THAT NAMES A CHECK IS GRAMMAR (@SCN-STG-005), steps or none. A fitness check is named
- * by a BARE tag — a flat peer of the behavioural tiers, not a member of some group — so it
- * matches nothing in `TIER_TAGS` and would otherwise red every fitness scenario in a corpus:
- * measured over this repository's own, ten findings and exit 1 on the commit before this clause
- * landed. The set is `checkTagsOf`'s and is resolved once, before the walk.
- *
- * AND STEPS ARE NOT CONSULTED, WHICH IS STRUCTURAL RATHER THAN REMEMBERED (3F-3126). The tier
- * floor this rule replaced once keyed on steplessness, and a rule keyed on that correlate reds
- * the first converted check for writing exactly the shape the obligation rule asks for. Here
- * there is no clause to remove: the walk reads a scenario's TAGS, so the stepped and the
- * stepless row are one case rather than two that agree.
- *
- * A RECOGNISED DEFERRAL TAG IS GRAMMAR (@SCN-STG-003), and it is the first clause here whose
- * answer is the TARGET'S rather than the scheme's. Reding every tag outside the tier set would red
- * `@skip` — a tag spec-controller itself recognises, honours as a deferral signal, and lets a
- * target extend by config. A check that condemns what the product accepts is not stricter, it is
- * wrong. The set arrives RESOLVED and is never restated, so there is no second list here to fall
- * behind the first; and this module names no community tag of its own, because which words the
- * community recognises is product policy handed in from the application layer.
- */
-function isGrammar(tag, scenarioId, featureCode, deferralTags, checkTags) {
-    if (tag === scenarioId)
-        return true;
-    if (featureCodeOf(tag) !== null)
-        return true;
-    if (featureCode !== null && tag === featureCode)
-        return true;
-    if (deferralTags.includes(tag))
-        return true;
-    if (checkTags.includes(tag))
-        return true;
-    return TIER_TAGS.includes(tag);
-}
-/**
- * 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 function unrecognisedTags(features, packageJson, starterDeferralTags) {
-    const deferralTags = resolveDeferralTags(packageJson, starterDeferralTags);
-    // Both sets are resolved ONCE, before the walk, rather than per tag: the manifest cannot change
-    // mid-corpus, and one resolution is what makes "the same set the obligation rule reads" a fact
-    // about this run rather than about each tag's turn through it.
-    const checkTags = checkTagsOf();
-    const faults = [];
-    for (const file of features) {
-        for (const scenario of parseTaggedScenarios(file.source)) {
-            for (const tag of scenario.tags) {
-                if (isGrammar(tag, scenario.scnId, file.featureCode, deferralTags, checkTags))
-                    continue;
-                faults.push({
-                    kind: "unrecognised-tag",
-                    message: `unrecognised-tag: ${file.slug}.feature scenario @${scenario.scnId} carries @${tag}, ` +
-                        unrecognisedTagFault(tag),
-                });
-            }
-        }
-    }
-    return faults;
-}
-//# sourceMappingURL=corpusGrammarFaults.js.map

package/dist/parse/corpusGrammarFaults.js.map

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