@3f-consulting/spec-controller-core 0.1.0-alpha.7 → 0.1.0-alpha.70

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

package/dist/parse/runningStaticChecks.d.ts

@@ -1,125 +0,0 @@
-/**
- * The running-check observer — emit a `GuardEvidenceObservation` for EVERY static check CI runs,
- * not just the obliged ones. This is the static analogue of the runner emitting every test result:
- * CI publishes no static check manifest, so the running set is DERIVED from the target's own
- * pipeline (@SCN-USG-001). It completes the static stream so the one reconcile engine sees every
- * running static check (a named one matches its `@lint` obligation; a no-evidence-obligation one
- * folds to the suspense row) — no derive-and-diff patch.
- *
- * WHAT A CANDIDATE IS, AND IT IS SAID BY SUBTRACTION (@SCN-USG-004, 3F-3343). A step of the
- * pipeline is a candidate fitness check UNLESS it runs a behavioural runner the target's manifest
- * named, or something took it out of discovery entirely. There is no rule about what a check is
- * CALLED, because the set of names a quality check might be given belongs to the consumer and is
- * unbounded: this observer used to read a target's scripts through an observed prefix set
- * (`lint:`, `guard:`), which is a sample of that set, and a pipeline whose scripts are `lint`,
- * `typecheck`, `audit` was one the reader could not see and said nothing about. The prefix set is
- * gone, and nothing shaped like it replaced it.
- *
- * AND THERE IS NO RULE ABOUT WHAT FORM A CHECK TAKES EITHER (@SCN-USG-013). A `uses:` step is a
- * candidate on exactly the same terms as a `run:` one: a quality check can be an action, so a
- * reader keyed on a step's shape would drop real checks as silently as one keyed on their names —
- * the same guess, one layer along. What names such a step is the action reference GitHub displays
- * for it, because it invokes no script of the consumer's to be named by.
- *
- * THE FAILURE DIRECTION IS DELIBERATE AND IS THE WHOLE ARGUMENT. Under the retired rule silence
- * hid checks a consumer HAS, and a false negative is invisible. Under this one nothing is hidden:
- * a step that reaches this reader leaves it as an observation, as a named runner, or as a step
- * something took out — each of which the report says out loud — so a false POSITIVE is visible and
- * correctable in one line of the consumer's own configuration.
- *
- * THE ONLY STATIC-CHECK OBSERVER THE RECONCILIATION COMPOSITION WIRES IN (3F-3397). Discovery and
- * attribution are one reader now: every running check reaches the books here, and the `citedScn`
- * seam below stamps the credit's row as the step is observed — there is no second, obligation-side
- * reader left to keep in agreement with it — and since 3F-3410 there is no such reader ANYWHERE:
- * the obligation-side observer this sentence used to point at has been deleted, so this is the only
- * static-check observer there is, not merely the only one wired in. The CI-parse walk still
- * comes from `checkScriptsRunInCI` (`ciWorkflowSteps`, of which `ciRunSteps` and `ciRunCommands`
- * are the projections / `commandInvokesScript`).
- *
- * `exists: true` BY CONSTRUCTION — a step the pipeline runs is a check that is there to be run.
- * `enforcedOverRealSource` is READ, not assumed (@SCN-LNT-032): a step whose red its job survives
- * runs, reds and leaves the pipeline green, so being invoked is not being enforced. The named
- * static checks' OTHER watermelon detail — a static check that does not run at all — is the OTHER
- * observer's job. `qualityCheck: "lint"` is the static-check AXIS name, and never a convention.
- *
- * AND A STEP THIS READER IS NOT LOOKING AT IS NOT READ AT ALL (@SCN-USG-015, @SCN-USG-014). Two
- * different facts take a step out of discovery — the consumer named it a non-check, or it is the
- * reconciler itself — and they reach this observer as the ONE `isExcludedFromDiscovery` seam
- * below, asked BEFORE the walk is used for anything: such a step carries no check onto the books,
- * is not consulted for a check's enforcement, and supplies no citation. What keeps that from being
- * a new silence is that the step is NAMED on the report, under whichever of the two it was — the
- * disposition is said out loud, and this reader never has to know which one it was.
- *
- * Parent: @SCN-USG-001 (the uncited static-check); @SCN-USG-004 (the inverted membership rule);
- * @SCN-USG-011 (the runner recognition); @SCN-USG-015 (the consumer's own exclusions);
- * @SCN-USG-014 (the reconciler's own steps).
- */
-import type { GuardEvidenceObservation } from "../model.js";
-import { type CiWorkflowStep, type PackageJsonScripts } from "./checkScriptsRunInCI.js";
-import type { BehaviouralRunner } from "../domain/evidenceReconciliation.js";
-import type { ScriptCitation } from "./fitnessCitations.js";
-/**
- * IS THIS STEP A CANDIDATE FITNESS CHECK — the membership rule itself, asked of one step.
- *
- * ONE RULE, TWO READERS, for the reason `namedRunnersAt` above is one function. The observer below
- * posts a check for every step this answers yes to, and the scope census (`parse/discoveryScope`,
- * @SCN-USG-020) reports how many of each job's steps it answered yes to. A census re-deriving the
- * rule for itself would be measuring its own arithmetic: it would go on agreeing with the report
- * while disagreeing with the books beneath it, which is the one disagreement a reader of a scope
- * section has no way to see.
- *
- * SAID BY SUBTRACTION, which is the inversion in one line (@SCN-USG-004). A step is a candidate
- * unless something took it out of discovery entirely, or it runs a behavioural runner the target
- * named. There is no third condition and nothing here reads a step's name.
- *
- * ASKED IN THAT ORDER. A step this reader is not looking at is not a step it decided against, so
- * the exclusion is asked before anything is read off the step for the runner rule.
- */
-export declare function isCandidateStep(step: CiWorkflowStep, packageJson: PackageJsonScripts, runners: Readonly<Record<string, string | null>>, isExcludedFromDiscovery: (step: CiWorkflowStep) => boolean): boolean;
-/**
- * DOES THIS STEP RUN A RUNNER THE TARGET NAMED — rule D as a yes or no (@SCN-USG-011).
- *
- * THE SAME COMPARISON A THIRD TIME, AND STILL ONLY ONE OF THEM. The membership rule above asks it,
- * the report's recognised-runner cut asks it, and the accounting identity (`parse/stepAccounting`,
- * @SCN-USG-018) asks it to say which disposition a step got. A count that decided "is this a
- * runner" out of its own reading of the rule could report every step accounted for while the books
- * beneath it had posted one of them twice, or not at all — and a total that agrees with itself is
- * exactly the reassurance the identity exists to refuse.
- *
- * WHICH TIERS IS THE OTHER QUESTION and is not this one. The report names the tier a step was
- * recognised for, and one step can be two tiers' runner; a count of dispositions wants the step,
- * once, whatever it was recognised as.
- */
-export declare function runsNamedRunner(step: CiWorkflowStep, packageJson: PackageJsonScripts, runners: Readonly<Record<string, string | null>>): boolean;
-export declare function runningStaticChecks(ciSources: readonly string[], packageJson: PackageJsonScripts, runners: Readonly<Record<string, string | null>>, citedScn?: (script: string, citedByStep?: string) => ScriptCitation | null, isExcludedFromDiscovery?: (step: CiWorkflowStep) => boolean): GuardEvidenceObservation[];
-/**
- * RULE D (@SCN-USG-011, 3F-3343) — the steps of a target's pipeline that run the behavioural
- * runners its manifest named, each with the tier it was named for and the step it was found at.
- *
- * IT IS THE ACCOUNT, AND SINCE @SCN-USG-004 THE SAME COMPARISON IS ALSO THE VERDICT. This reader
- * REPORTS which step ran which named runner; the membership rule above ASKS the same question of
- * each step and takes a runner's step out of discovery. Both go through `namedRunnersAt`, so the
- * report and the books cannot come to disagree — a step named here as the unit runner is the same
- * step that is not on the books as a fitness check.
- *
- * AND BEING NAMED IS WHAT LETS THE RULE BE THIS SIMPLE. A step recognised as a runner leaves the
- * reader NAMED rather than silent, so what the recognition gets wrong is visible in the report and
- * correctable in one line of the consumer's own configuration — the safe direction, in the one
- * place where the unsafe one would be invisible.
- *
- * `run:` STEPS ONLY, because the rule is about a COMMAND. A `uses:` step runs an action and states
- * no command for a runner to be a token of; what such a step is instead is a question for the
- * disposition rule, not for this one.
- *
- * ONE ENTRY PER TIER PER STEP. Two tiers sharing a runner is the ordinary case — `@integration` and
- * `@e2e` are both `cucumber-js` in three portfolio repositories — and each tier is a separate thing
- * the consumer said, so collapsing them would answer for a tier nobody asked about.
- *
- * A TIER THE TARGET SAYS HAS NONE FALLS OUT IN `namedRunnersAt` (@SCN-USG-016), and falls out
- * silently, which is right: there is no name for a whole-token match to be run against, so no step
- * can be its runner. The statement itself is not lost — the resolver keeps it, and the report says
- * it — but this reader answers only "which step runs which named runner", and a null is not an
- * answer to that.
- */
-export declare function recognisedRunners(ciSources: readonly string[], packageJson: PackageJsonScripts, runners: Readonly<Record<string, string | null>>): BehaviouralRunner[];
-//# sourceMappingURL=runningStaticChecks.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"runningStaticChecks.d.ts","sourceRoot":"","sources":["../../src/parse/runningStaticChecks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAwD5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAChD,uBAAuB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,GACzD,OAAO,CAET;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,GAC/C,OAAO,CAET;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,WAAW,EAAE,kBAAkB,EAgB/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAgChD,QAAQ,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,KAAK,cAAc,GAAG,IAAiB,EAuBtF,uBAAuB,GAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAqB,GACvE,wBAAwB,EAAE,CA8D5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,GAC/C,iBAAiB,EAAE,CAarB"}