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

package/dist/parse/ciStepRecord.d.ts

@@ -1,123 +1,9 @@
-/**
- * THE CI RUN'S OWN RECORD of what each of its steps did — the observation side of the fitness
- * axis, and the second of this axis's two readers (@SCN-LNT-021, @SCN-LNT-028).
- *
- * THE OTHER ONE READS A DIFFERENT DOCUMENT AND ANSWERS A DIFFERENT QUESTION. `runningStaticChecks`
- * and `checkScriptsRunInCI` read the workflow FILE and answer "is this check wired into this
- * pipeline, and which row does its step cite" — a fact about a repository, true between runs. This
- * reads the RUN's record and answers "did it run this time, and what did it find" — a fact about
- * one afternoon. Neither can be got from the other's document, which is why there are two.
- *
- * THE RECORD IS THE CONSUMER'S, WRITTEN BY NEITHER PARTY. It is what a job's own `toJSON(steps)`
- * dumps: one entry per step that carried an `id:`, keyed by that id, each carrying the step's
- * `outcome` and its `conclusion`. Nothing here executes a check, and nothing asks a consumer to
- * move a command out of their pipeline — the check already ran, as their own CI step.
- *
- * THE KEY IS THE CITATION AND THE ROW SUPPLIES THE REST. A step's `id:` is a CODE and never a
- * characteristic, so an entry naming a configured row is read for its verdict and the row it names
- * is read for the characteristic that verdict answers — two terms from two places, the same
- * arrangement the derivation side takes off a step's `id:`. An entry no configured row answers is
- * not this reader's business: `checkout` and `setup-node` are not checks, and silence about them
- * is the correct report rather than a gap in one.
- *
- * AND THE ROWS ARE READ TOO, NOT ONLY THE RECORD (@SCN-LNT-027). An entry is one half of the
- * reading; the other is every configured row the record held no entry for, which is broken evidence
- * naming that row. It is the one comparison on this axis that survives its own subject vanishing:
- * the rows come from the target's manifest and the enumeration from the run's own record, so
- * emptying either leaves the other standing. Every other reading here loses both sides at once when
- * a check stops being wired, and a run over nothing balances.
- *
- * A RECORD NEVER HANDED OVER IS NOT A RECORD CARRYING NOTHING, AND THE OPTIONALITY REACHES THIS
- * MODULE rather than being flattened at the call site. `undefined` is a consumer whose pipeline
- * dumps no record, or a run nobody recorded: nothing is raised, the rows reconcile missing by
- * absence and the run is out of balance, exactly as before. An EMPTY record is a run that happened
- * and named not one of these steps, which is every configured check that did not run. Calling the
- * first consumer's set-up broken over a file they have no reason to own is the fault the
- * self-reconciliation gate already refuses one level up.
- *
- * PURE AND INJECTED, like every reader on this axis: the record arrives as data, parsed at the app
- * edge from the target's own evidence, and the rows arrive from the target's own manifest.
- */
-import type { FitnessCheckIndex } from "../domain/fitnessChecks.js";
-import type { GuardEvidenceObservation } from "../model.js";
-/**
- * ONE STEP'S ENTRY in the record, as the dump wrote it.
- *
- * BOTH FIELDS ARE OPTIONAL BECAUSE THE DOCUMENT IS SOMEBODY ELSE'S. It is JSON a consumer's CI
- * wrote and this reader was handed; a shape that declared either field present would be asserting
- * something about a file nobody here validated, and the first record written by a provider that
- * spells things differently would be a type error wearing a crash.
- */
-export interface CiStepRecordEntry {
-    /**
-     * WHAT THE STEP ACTUALLY DID — pre-`continue-on-error`, and the field this axis reads.
-     *
-     * `success`, `failure`, `skipped` or `cancelled` on the provider this reader was built against.
-     * It is a string rather than a union for the reason the two fields are optional: the document is
-     * the consumer's, and a status nobody anticipated is a reading to fall through rather than a
-     * value the type system can forbid a foreign file from containing.
-     */
+import type { FitnessEvidenceObservation } from "../model.js";
+interface CiStepRecordEntry {
     readonly outcome?: string;
-    /**
-     * WHAT THE JOB WAS TOLD — post-`continue-on-error`, and the laundered value.
-     *
-     * Carried on the type because it is in the document, and read by nothing: a step marked
-     * `continue-on-error: true` that failed reports `success` here, so a reader taking this field is
-     * green over a masked failure. WHICH of the two fields a reader must take is its own claim with
-     * its own scenario (3F-3264); what this type does is stop the laundered one being reachable by
-     * accident under a name that reads like the real one.
-     */
     readonly conclusion?: string;
 }
-/**
- * THE RECORD — every step that carried an `id:`, keyed by that id.
- *
- * A step with no `id:` is absent from it entirely, which is the provider's own arrangement and not
- * a loss: a step nobody named cites nothing, and the record has no key to file it under.
- */
 export type CiStepRecord = Readonly<Record<string, CiStepRecordEntry>>;
-/**
- * The credits a CI RUN'S OWN RECORD raises — one per entry naming a configured row, carrying
- * WHAT ITS STEP DID: `satisfied` off a step that succeeded (@SCN-LNT-021) and `failing` off one
- * that failed (@SCN-LNT-028). There is no third answer: a step the record says was skipped is
- * broken evidence, whatever its row says (3F-3252).
- *
- * AND BROKEN EVIDENCE OFF EVERY OTHER READING (@SCN-LNT-026), which is why this is one per configured
- * entry rather than one per entry that said something. The credit set is CLOSED to the three readings
- * that say what the check did; a skip no row asked for, a `cancelled` step, a status nobody
- * anticipated are each a step whose running this reader cannot vouch for, and the safe answer is the
- * loud one — no Evidence Observation, the obligation reconciling missing by absence, and the run
- * stamped unsound. Raising nothing at all would leave a check that stopped running indistinguishable
- * from one nobody ever wrote, and send the reader to write it.
- *
- * THE CREDIT ARRIVES ALREADY CITING, WHICH IS THE SEAM THIS ROUTE RETIRES (@SCN-LNT-021). A
- * DISCOVERED check is found as a runnable script handle, and a handle does not know what it is
- * for — hence the (now-retired) registry, and hence the corpus lookup behind it. Here the
- * entry's key IS the code of the row it answers and that row carries the characteristic: two
- * terms from two places, neither resolved onto the other and no registry consulted at all.
- *
- * `failing`, AND THE THREE NEIGHBOURS IT IS NOT. `broken` is the never-ran case: it carries no
- * Evidence Observation and stamps the run unsound, so reading a failed step as broken would throw
- * away the one thing the check actually said. `missing` says no evidence, and there is evidence.
- * A credit that said only "it ran" leaves the row balanced over a check that found violations,
- * which is this axis's own headline fault arriving by the front door. What is left is the word
- * every other axis already uses for present-and-failing.
- *
- * THE VERDICT TRAVELS ON THE OBSERVATION BECAUSE NOTHING ELSE CARRIES IT ANY MORE. While a runner
- * ran the checks, a check that found violations reddened the run through the runner's exit code
- * and the credit only had to say the check ran. A CI step's exit code reaches this ledger nowhere.
- *
- * BOTH `exists` AND `enforcedOverRealSource` ARE OBSERVED HERE, NOT INFERRED, which is why they
- * are asserted at all. The step RAN — that is what the record says — and it ran in the target's
- * own checkout, over the target's own tree. Neither is the manifest-mentions-a-name reading the
- * discovered route takes.
- *
- * AN ENTRY NO CONFIGURED ROW ANSWERS IS NOT THIS READER'S BUSINESS. `checkout`, `setup-node` and
- * the dump step itself are steps and not checks, and silence about them is the correct report.
- *
- * AND A CONFIGURED ROW NO ENTRY ANSWERS RAISES A BROKEN CREDIT (@SCN-LNT-027), which is why this
- * walks the ROWS as well as the record. The rows are the denominator, and a check quietly lifted
- * out of a pipeline goes dark on the side the pipeline cannot reach.
- */
-export declare function ciStepRecordCredits(record: CiStepRecord | undefined, fitnessChecks: FitnessCheckIndex): GuardEvidenceObservation[];
+export declare function ciStepRecordCredits(record: CiStepRecord | undefined): FitnessEvidenceObservation[];
+export {};
 //# sourceMappingURL=ciStepRecord.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ciStepRecord.d.ts","sourceRoot":"","sources":["../../src/parse/ciStepRecord.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAgB,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAElF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAyLvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,aAAa,EAAE,iBAAiB,GAC/B,wBAAwB,EAAE,CAqB5B"}
+{"version":3,"file":"ciStepRecord.d.ts","sourceRoot":"","sources":["../../src/parse/ciStepRecord.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAE9D,UAAU,iBAAiB;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAsDvE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,0BAA0B,EAAE,CAQlG"}

package/dist/parse/ciStepRecord.js

@@ -1,85 +1,8 @@
-/**
- * THE CI RUN'S OWN RECORD of what each of its steps did — the observation side of the fitness
- * axis, and the second of this axis's two readers (@SCN-LNT-021, @SCN-LNT-028).
- *
- * THE OTHER ONE READS A DIFFERENT DOCUMENT AND ANSWERS A DIFFERENT QUESTION. `runningStaticChecks`
- * and `checkScriptsRunInCI` read the workflow FILE and answer "is this check wired into this
- * pipeline, and which row does its step cite" — a fact about a repository, true between runs. This
- * reads the RUN's record and answers "did it run this time, and what did it find" — a fact about
- * one afternoon. Neither can be got from the other's document, which is why there are two.
- *
- * THE RECORD IS THE CONSUMER'S, WRITTEN BY NEITHER PARTY. It is what a job's own `toJSON(steps)`
- * dumps: one entry per step that carried an `id:`, keyed by that id, each carrying the step's
- * `outcome` and its `conclusion`. Nothing here executes a check, and nothing asks a consumer to
- * move a command out of their pipeline — the check already ran, as their own CI step.
- *
- * THE KEY IS THE CITATION AND THE ROW SUPPLIES THE REST. A step's `id:` is a CODE and never a
- * characteristic, so an entry naming a configured row is read for its verdict and the row it names
- * is read for the characteristic that verdict answers — two terms from two places, the same
- * arrangement the derivation side takes off a step's `id:`. An entry no configured row answers is
- * not this reader's business: `checkout` and `setup-node` are not checks, and silence about them
- * is the correct report rather than a gap in one.
- *
- * AND THE ROWS ARE READ TOO, NOT ONLY THE RECORD (@SCN-LNT-027). An entry is one half of the
- * reading; the other is every configured row the record held no entry for, which is broken evidence
- * naming that row. It is the one comparison on this axis that survives its own subject vanishing:
- * the rows come from the target's manifest and the enumeration from the run's own record, so
- * emptying either leaves the other standing. Every other reading here loses both sides at once when
- * a check stops being wired, and a run over nothing balances.
- *
- * A RECORD NEVER HANDED OVER IS NOT A RECORD CARRYING NOTHING, AND THE OPTIONALITY REACHES THIS
- * MODULE rather than being flattened at the call site. `undefined` is a consumer whose pipeline
- * dumps no record, or a run nobody recorded: nothing is raised, the rows reconcile missing by
- * absence and the run is out of balance, exactly as before. An EMPTY record is a run that happened
- * and named not one of these steps, which is every configured check that did not run. Calling the
- * first consumer's set-up broken over a file they have no reason to own is the fault the
- * self-reconciliation gate already refuses one level up.
- *
- * PURE AND INJECTED, like every reader on this axis: the record arrives as data, parsed at the app
- * edge from the target's own evidence, and the rows arrive from the target's own manifest.
- */
-/** The provider's own two words for a step that RAN, spelled once each. */
+import { SCN_CODE } from "./scenarios.js";
+import { CORE_MESSAGES, CoreMessage } from "../domain/messages.js";
 const SUCCESS = "success";
 const FAILURE = "failure";
-/** And its word for a step that did not — the one reading a ROW can ask to be credited for. */
 const SKIPPED = "skipped";
-/**
- * WHAT THE CHECK ITSELF SAID, read off the step's own result — or `null` where this reader has no
- * reading for what the record says (@SCN-LNT-021, @SCN-LNT-028).
- *
- * TWO READINGS SAY WHAT THE CHECK DID AND EVERYTHING ELSE FALLS THROUGH, which is the fail-safe
- * direction written as a shape rather than as a warning. A step that succeeded ran and found
- * nothing; a step that failed ran and found something; and both of those are facts about a check,
- * which is why both raise a credit and the credit carries WHICH. Every other reading — any skip
- * whatever its cause, `cancelled`, a status nobody anticipated, or no entry for the row at all —
- * is a step this reader cannot vouch for having run, and what such a step earns is BROKEN evidence
- * rather than the credit (@SCN-LNT-026): the `null` is a fall-through to the other shape, never a
- * silence.
- *
- * THERE IS NO THIRD READING FOR "THE COMMAND EXAMINED NOTHING", AND THE REASON IS THAT A SKIP
- * CANNOT MEAN IT (3F-3252). A row used to declare the ending its command says so with, and the
- * retired fitness pass SPAWNED that command and compared the number. Here nothing of ours spawns
- * anything: the consumer's CI runs it, and a command that examines nothing still RUNS — it exits,
- * so its step reads success or failure. It is never `skipped`. A step is skipped when a condition
- * went false, when the job was cancelled, or when somebody moved it — and none of those is the
- * check examining nothing.
- *
- * SO A READING THAT FORGAVE A SKIP ON THE STRENGTH OF A DECLARED ENDING WOULD BE A HATCH. The
- * declaration could only be read for WHETHER it was named — no code crosses a step record to check
- * it against — so `if: false` beside a declared ending would read SATISFIED for ever: a check
- * switched off, green in the ledger, through the product's own configuration, and single-entry in
- * the double-entry product. The field is gone rather than guarded.
- *
- * A CONSUMER WHOSE COMMAND GENUINELY EXAMINES NOTHING SAYS SO IN THEIR OWN `run:` LINE —
- * `eslint || [ $? -eq 3 ]` — where it becomes an honest success their CI records. That is their
- * business, on their side of the boundary, and it needs nothing from our row.
- *
- * THE VERDICT IS CARRIED RATHER THAN COLLAPSED, and that is what this route does not share with
- * the retired fitness pass's reader. While a runner ran the checks, a check that found violations
- * reddened the run through the runner's exit code and its credit only had to say the check ran — so passed
- * and failed were honestly one answer there. A CI step's exit code reaches this ledger nowhere: if
- * the credit does not carry the verdict, nothing does.
- */
 function readingOf(outcome) {
     if (outcome === SUCCESS)
         return { status: "passed" };
@@ -87,178 +10,48 @@ function readingOf(outcome) {
         return { status: "failed" };
     return null;
 }
-/**
- * WHAT THE RECORD SAID AND WHY THAT IS NOT A CREDIT — the whole of the record's answer about this
- * check, so it is written as one sentence (@SCN-LNT-026).
- *
- * IT IS ALL A READER GETS, which is why it says three things and no more. A broken item carries no
- * Evidence Observation, so this sentence names the subject, states the diagnosis, and prescribes NO
- * cure — which of a condition that went false, a cancelled job, a step somebody moved or a provider
- * that spells things differently produced the reading is not this reader's to say, and naming one
- * would send the reader to the wrong file.
- *
- * THE SKIP ARM NAMES THE THREE THINGS THAT CAUSE A SKIP, because a reader meeting this line will
- * otherwise go hunting for a broken command that is working perfectly. No row can excuse a skip:
- * a command that examines nothing still runs and still ends, so a skip is never that (3F-3252).
- */
 function checkDidNotRunMessage(scnId, outcome) {
-    if (outcome === undefined) {
-        return `${scnId}: the CI run's record carries no outcome for this check's step — so the check did not run.`;
-    }
-    if (outcome === SKIPPED) {
-        return `${scnId}: the CI run's record says this check's step was skipped — so the check did not run.`;
-    }
-    return `${scnId}: the CI run's record says this check's step ended \`${outcome}\` — so the check did not run.`;
+    if (outcome === undefined)
+        return CORE_MESSAGES[CoreMessage.CheckStepNoOutcome](scnId);
+    if (outcome === SKIPPED)
+        return CORE_MESSAGES[CoreMessage.CheckStepSkipped](scnId);
+    return CORE_MESSAGES[CoreMessage.CheckStepEnded](scnId, outcome);
 }
-/**
- * ONE ENTRY'S CREDIT — the ordinary one where the record says what the check did, and BROKEN
- * evidence where it does not (@SCN-LNT-026).
- *
- * ONE FUNCTION FOR BOTH BECAUSE IT IS ONE DECISION. The two observations differ in what they say
- * about the same check, so writing them apart would put the question in one place and its two
- * answers in two — and the day a field is added to one of them is the day they stop agreeing about
- * anything but the fields somebody remembered.
- *
- * THE BROKEN ONE CARRIES BOTH FACTS AS `false` RATHER THAN OMITTING THEM. `exists` and
- * `enforcedOverRealSource` are OBSERVATIONS on this route — the record saying a step ran is what
- * says the check exists and ran over the consumer's own checkout — and neither was observed here,
- * so the honest values are the ones that assert nothing. It is also what keeps the roll-up right: a
- * check that did not run is not a running static check.
- *
- * AND IT CARRIES ITS `@SCN` AND ITS CHARACTERISTIC, which are known and true. What stops those
- * being read as a citation is the reconciler's two fail-safes — `postingOf` takes `broken` before
- * `scnId`, and the obligation match excludes it — never their absence.
- */
-function namedOf(citedScn, row) {
+function namedOf(citedScn) {
     return {
-        qualityCheck: "lint",
-        // THE CHARACTERISTIC IN BOTH, because a check the record names has no runnable handle to put
-        // in either: the record knows a step id, and an id is a code and never a characteristic.
-        // `staticCheck` is where-to-fix and `checkTag` is what the reconciler matches on, and for this
-        // route the row's one word is the whole of what there is to name.
-        staticCheck: row.characteristic,
+        qualityCheck: "fitness",
+        fitnessFunction: citedScn,
         scnId: citedScn,
-        checkTag: row.characteristic,
     };
 }
-/**
- * The BROKEN shape, spelled once for both the readings that reach it — an entry whose outcome this
- * reader cannot vouch for (@SCN-LNT-026), and a configured row the record held no entry for at all
- * (@SCN-LNT-027).
- *
- * ONE SPELLING BECAUSE IT IS ONE OUTCOME. The two readings differ in what they say about the check
- * and in nothing else, so a second construction here would be free to omit a field the first
- * carries — and the day one of them stopped carrying `exists: false` is the day a check that did
- * not run started counting as a running one on exactly half the routes.
- */
-function brokenCreditOf(citedScn, row, message) {
+function brokenCreditOf(citedScn, message) {
     return {
-        ...namedOf(citedScn, row),
+        ...namedOf(citedScn),
         exists: false,
         enforcedOverRealSource: false,
         broken: true,
         message,
     };
 }
-function creditOf(citedScn, row, reading, outcome) {
+function creditOf(citedScn, reading, outcome) {
     if (reading === null) {
-        return brokenCreditOf(citedScn, row, checkDidNotRunMessage(citedScn, outcome));
+        return brokenCreditOf(citedScn, checkDidNotRunMessage(citedScn, outcome));
     }
     return {
-        ...namedOf(citedScn, row),
-        // OBSERVED, NOT INFERRED, which is why both are asserted at all. The step RAN — that is what
-        // the record says — and it ran in the target's own checkout, over the target's own tree.
-        // Neither is the manifest-mentions-a-name reading the discovered route takes.
+        ...namedOf(citedScn),
         exists: true,
         enforcedOverRealSource: true,
-        // THE VERDICT THE STEP REACHED, AND EVERY CREDIT CARRIES ONE. A step that ran reached either
-        // `passed` or `failed`; a step that did not is not a credit at all but broken evidence, so
-        // there is no third shape here (3F-3252).
         ...reading,
     };
 }
-/**
- * WHAT the record said about a configured row it held no entry for, which is nothing at all — the
- * message a row's own absence from the record earns (@SCN-LNT-027).
- *
- * IT NAMES THE MANIFEST RATHER THAN THE PIPELINE, because the manifest is the document this reader
- * actually held. Which step should have carried the row's code is a real question and not one the
- * record can answer: the entry it would live in is precisely what the record did not carry. Naming
- * a workflow file this reader never read would be the prescribed cure a broken item refuses.
- *
- * IT IS NOT THE SENTENCE AN ENTRY WITH NO OUTCOME EARNS, and the two are kept apart because they
- * send a reader to different places. That one is a step this run recorded and said nothing about;
- * this one is a step the run did not record at all.
- */
-function rowHasNoEntryMessage(scnId) {
-    return (`${scnId}: the CI run's record carries no step for this row of ` +
-        "`specController.fitnessChecks` — so the check did not run.");
-}
-/**
- * The credits a CI RUN'S OWN RECORD raises — one per entry naming a configured row, carrying
- * WHAT ITS STEP DID: `satisfied` off a step that succeeded (@SCN-LNT-021) and `failing` off one
- * that failed (@SCN-LNT-028). There is no third answer: a step the record says was skipped is
- * broken evidence, whatever its row says (3F-3252).
- *
- * AND BROKEN EVIDENCE OFF EVERY OTHER READING (@SCN-LNT-026), which is why this is one per configured
- * entry rather than one per entry that said something. The credit set is CLOSED to the three readings
- * that say what the check did; a skip no row asked for, a `cancelled` step, a status nobody
- * anticipated are each a step whose running this reader cannot vouch for, and the safe answer is the
- * loud one — no Evidence Observation, the obligation reconciling missing by absence, and the run
- * stamped unsound. Raising nothing at all would leave a check that stopped running indistinguishable
- * from one nobody ever wrote, and send the reader to write it.
- *
- * THE CREDIT ARRIVES ALREADY CITING, WHICH IS THE SEAM THIS ROUTE RETIRES (@SCN-LNT-021). A
- * DISCOVERED check is found as a runnable script handle, and a handle does not know what it is
- * for — hence the (now-retired) registry, and hence the corpus lookup behind it. Here the
- * entry's key IS the code of the row it answers and that row carries the characteristic: two
- * terms from two places, neither resolved onto the other and no registry consulted at all.
- *
- * `failing`, AND THE THREE NEIGHBOURS IT IS NOT. `broken` is the never-ran case: it carries no
- * Evidence Observation and stamps the run unsound, so reading a failed step as broken would throw
- * away the one thing the check actually said. `missing` says no evidence, and there is evidence.
- * A credit that said only "it ran" leaves the row balanced over a check that found violations,
- * which is this axis's own headline fault arriving by the front door. What is left is the word
- * every other axis already uses for present-and-failing.
- *
- * THE VERDICT TRAVELS ON THE OBSERVATION BECAUSE NOTHING ELSE CARRIES IT ANY MORE. While a runner
- * ran the checks, a check that found violations reddened the run through the runner's exit code
- * and the credit only had to say the check ran. A CI step's exit code reaches this ledger nowhere.
- *
- * BOTH `exists` AND `enforcedOverRealSource` ARE OBSERVED HERE, NOT INFERRED, which is why they
- * are asserted at all. The step RAN — that is what the record says — and it ran in the target's
- * own checkout, over the target's own tree. Neither is the manifest-mentions-a-name reading the
- * discovered route takes.
- *
- * AN ENTRY NO CONFIGURED ROW ANSWERS IS NOT THIS READER'S BUSINESS. `checkout`, `setup-node` and
- * the dump step itself are steps and not checks, and silence about them is the correct report.
- *
- * AND A CONFIGURED ROW NO ENTRY ANSWERS RAISES A BROKEN CREDIT (@SCN-LNT-027), which is why this
- * walks the ROWS as well as the record. The rows are the denominator, and a check quietly lifted
- * out of a pipeline goes dark on the side the pipeline cannot reach.
- */
-export function ciStepRecordCredits(record, fitnessChecks) {
+export function ciStepRecordCredits(record) {
     if (record === undefined)
         return [];
     const credits = [];
-    const recorded = new Set();
     for (const [citedScn, step] of Object.entries(record)) {
-        const row = fitnessChecks.get(citedScn);
-        if (row === undefined)
-            continue;
-        recorded.add(citedScn);
-        // NO `continue` ON A READING THIS READER HAS NONE FOR (@SCN-LNT-026). Every configured row the
-        // record holds an entry for raises something; which of the two shapes it raises is the
-        // credit builder's answer, and the fall-through reaches the loud one rather than the exit.
-        credits.push(creditOf(citedScn, row, readingOf(step.outcome), step.outcome));
-    }
-    // AND THE ROWS ARE WALKED TOO, NOT ONLY THE RECORD (@SCN-LNT-027). The rows come from the
-    // target's manifest and the enumeration from the run's own record, so a row the record held no
-    // entry for is a check that did not run — broken evidence naming that row.
-    for (const [scnId, row] of fitnessChecks) {
-        if (recorded.has(scnId))
+        if (!SCN_CODE.test(citedScn))
             continue;
-        credits.push(brokenCreditOf(scnId, row, rowHasNoEntryMessage(scnId)));
+        credits.push(creditOf(citedScn, readingOf(step.outcome), step.outcome));
     }
     return credits;
 }

package/dist/parse/ciStepRecord.js.map

@@ -1 +1 @@
-{"version":3,"file":"ciStepRecord.js","sourceRoot":"","sources":["../../src/parse/ciStepRecord.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ciStepRecord.js","sourceRoot":"","sources":["../../src/parse/ciStepRecord.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAUnE,MAAM,OAAO,GAAG,SAAS,CAAC;AAC1B,MAAM,OAAO,GAAG,SAAS,CAAC;AAC1B,MAAM,OAAO,GAAG,SAAS,CAAC;AAI1B,SAAS,SAAS,CAAC,OAA2B;IAC5C,IAAI,OAAO,KAAK,OAAO;QAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACrD,IAAI,OAAO,KAAK,OAAO;QAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACrD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAa,EAAE,OAA2B;IACvE,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,aAAa,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC,KAAK,CAAC,CAAC;IACvF,IAAI,OAAO,KAAK,OAAO;QAAE,OAAO,aAAa,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,KAAK,CAAC,CAAC;IACnF,OAAO,aAAa,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,OAAO,CAAC,QAAgB;IAC/B,OAAO;QACL,YAAY,EAAE,SAAS;QACvB,eAAe,EAAE,QAAQ;QACzB,KAAK,EAAE,QAAQ;KACP,CAAC;AACb,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB,EAAE,OAAe;IACvD,OAAO;QACL,GAAG,OAAO,CAAC,QAAQ,CAAC;QACpB,MAAM,EAAE,KAAK;QACb,sBAAsB,EAAE,KAAK;QAC7B,MAAM,EAAE,IAAI;QACZ,OAAO;KACR,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CACf,QAAgB,EAChB,OAAoB,EACpB,OAA2B;IAE3B,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO,cAAc,CAAC,QAAQ,EAAE,qBAAqB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO;QACL,GAAG,OAAO,CAAC,QAAQ,CAAC;QACpB,MAAM,EAAE,IAAI;QACZ,sBAAsB,EAAE,IAAI;QAC5B,GAAG,OAAO;KACX,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAgC;IAClE,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IACpC,MAAM,OAAO,GAAiC,EAAE,CAAC;IACjD,KAAK,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QACtD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,SAAS;QACvC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/parse/commandRuns.d.ts

@@ -1,41 +1,2 @@
-/**
- * DOES THIS COMMAND RUN THAT — the one comparison every recognition rule on this axis makes, and
- * it is made in one place because two of them now make it.
- *
- * WHOLE TOKENS, NEVER A SUBSTRING, and that is the whole of what keeps a recognition rule safe.
- * Measured over 113 `run:` steps in five real pipelines (3F-3343) the substring form recognises 2
- * and BOTH are false: one of them is the reconciler's own `balance` step, matched on the filename
- * `vitest.json` inside its `--vitest` argument. Excluding a fitness check as something else is the
- * one direction this axis cannot tolerate, because it is silent.
- *
- * THE SCRIPT HOP IS THE RULE, NOT A REFINEMENT OF IT. Over those same 113 steps the first clause
- * ALONE recognises zero: every pipeline in the portfolio invokes its runner through a
- * `package.json` script alias, and the binary's name is in the workflow only inside a path. A rule
- * that resolved a step's command to the executable it runs could not be built from the workflow,
- * because the executable is not there.
- *
- * WHICH SCRIPT A COMMAND INVOKES IS THE PRODUCT'S OWN QUESTION, already answered —
- * `commandInvokesScript`, the exact package-manager invocation a static check's enforcement is
- * read through. Asking it a second way here would let two readers disagree about what `pnpm test`
- * invokes.
- *
- * AN INVOCATION OF MORE THAN ONE TOKEN IS MATCHED ADJACENT AND IN ORDER, which is what lets a
- * caller name a tool AND the command it is being run for. `spec-controller balance` is the
- * reconciler; `spec-controller tags` is the same binary doing something else, and this repository's
- * own pipeline runs both — so a rule comparing the binary alone would take an ordinary step of the
- * pipeline off the books. Per LINE, because two commands on two lines are two commands.
- *
- * Its own module rather than a private helper of the runner rule: the reconciler asks the same
- * question (`parse/reconcilerSteps`), and a second implementation of "does this command run that"
- * is a second chance for the two to answer differently about one step.
- */
-/**
- * Does this command run the named invocation — itself, or through the manifest scripts it invokes?
- *
- * AN INVOCATION OF NO TOKENS RUNS NOWHERE, which is the guard rather than a formality: an empty
- * token list occurs at every position of every command, so a reader taking it as a match would
- * recognise every step of every pipeline it was handed. A caller that has been told no invocation
- * has been told nothing, and nothing is what it gets back.
- */
 export declare function commandRuns(command: string, invocation: string, scripts: Readonly<Record<string, string>>): boolean;
 //# sourceMappingURL=commandRuns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"commandRuns.d.ts","sourceRoot":"","sources":["../../src/parse/commandRuns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAoDH;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC,OAAO,CAGT"}
+{"version":3,"file":"commandRuns.d.ts","sourceRoot":"","sources":["../../src/parse/commandRuns.ts"],"names":[],"mappings":"AA2BA,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC,OAAO,CAGT"}

package/dist/parse/commandRuns.js

@@ -1,82 +1,21 @@
-/**
- * DOES THIS COMMAND RUN THAT — the one comparison every recognition rule on this axis makes, and
- * it is made in one place because two of them now make it.
- *
- * WHOLE TOKENS, NEVER A SUBSTRING, and that is the whole of what keeps a recognition rule safe.
- * Measured over 113 `run:` steps in five real pipelines (3F-3343) the substring form recognises 2
- * and BOTH are false: one of them is the reconciler's own `balance` step, matched on the filename
- * `vitest.json` inside its `--vitest` argument. Excluding a fitness check as something else is the
- * one direction this axis cannot tolerate, because it is silent.
- *
- * THE SCRIPT HOP IS THE RULE, NOT A REFINEMENT OF IT. Over those same 113 steps the first clause
- * ALONE recognises zero: every pipeline in the portfolio invokes its runner through a
- * `package.json` script alias, and the binary's name is in the workflow only inside a path. A rule
- * that resolved a step's command to the executable it runs could not be built from the workflow,
- * because the executable is not there.
- *
- * WHICH SCRIPT A COMMAND INVOKES IS THE PRODUCT'S OWN QUESTION, already answered —
- * `commandInvokesScript`, the exact package-manager invocation a static check's enforcement is
- * read through. Asking it a second way here would let two readers disagree about what `pnpm test`
- * invokes.
- *
- * AN INVOCATION OF MORE THAN ONE TOKEN IS MATCHED ADJACENT AND IN ORDER, which is what lets a
- * caller name a tool AND the command it is being run for. `spec-controller balance` is the
- * reconciler; `spec-controller tags` is the same binary doing something else, and this repository's
- * own pipeline runs both — so a rule comparing the binary alone would take an ordinary step of the
- * pipeline off the books. Per LINE, because two commands on two lines are two commands.
- *
- * Its own module rather than a private helper of the runner rule: the reconciler asks the same
- * question (`parse/reconcilerSteps`), and a second implementation of "does this command run that"
- * is a second chance for the two to answer differently about one step.
- */
 import { commandInvokesScript } from "./checkScriptsRunInCI.js";
-/**
- * How deep a script-to-script chain is followed before the walk gives up.
- *
- * THREE RATHER THAN UNBOUNDED, and the number is a judgement stated once. A chain deeper than
- * three hops is not a shape any pipeline in the portfolio has, and the manifest being walked was
- * written by the consumer — an input this tool does not control, so it does not walk it without a
- * bound.
- *
- * AND IT IS THIS BOUND, NOT THE VISITED SET BELOW, THAT MAKES A CYCLIC MANIFEST TERMINATE —
- * measured rather than reasoned: deleting the visited set leaves every arm of this rule green,
- * because a chain that loops back exhausts the depth exactly as a long one does. The set is kept
- * because the technical design names it and because it stops a manifest whose scripts cite each
- * other being re-tread inside that budget; what it cannot do is change an answer, so no arm reds
- * on its removal. Said out loud because a comment claiming a guarantee its code does not hold is
- * the kind of thing nothing typechecks.
- */
 const SCRIPT_CHAIN_DEPTH = 3;
-/** A command's whole shell tokens, one array per line — the unit every comparison here is over. */
+// Edge whitespace leaves an empty token, which no invocation token equals.
 function tokenLinesOf(command) {
-    return command
-        .split(/\r?\n/)
-        .map((line) => line.trim().split(/\s+/).filter((token) => token !== ""));
+    return command.split(/\r?\n/).map((line) => line.split(/\s+/));
 }
-/** Do these tokens occur, in this order and adjacent, among a line's? */
 function lineRuns(line, invocation) {
     return line.some((_, at) => invocation.every((token, i) => line[at + i] === token));
 }
-/** The recursion: this command's own tokens, then the manifest scripts it invokes. */
-function runs(command, invocation, scripts, depth, visited) {
+function runs(command, invocation, scripts, depth) {
     if (tokenLinesOf(command).some((line) => lineRuns(line, invocation)))
         return true;
     if (depth === 0)
         return false;
-    return Object.entries(scripts).some(([name, body]) => !visited.has(name) &&
-        commandInvokesScript(command, name) &&
-        runs(body, invocation, scripts, depth - 1, new Set([...visited, name])));
+    return Object.entries(scripts).some(([name, body]) => commandInvokesScript(command, name) && runs(body, invocation, scripts, depth - 1));
 }
-/**
- * Does this command run the named invocation — itself, or through the manifest scripts it invokes?
- *
- * AN INVOCATION OF NO TOKENS RUNS NOWHERE, which is the guard rather than a formality: an empty
- * token list occurs at every position of every command, so a reader taking it as a match would
- * recognise every step of every pipeline it was handed. A caller that has been told no invocation
- * has been told nothing, and nothing is what it gets back.
- */
 export function commandRuns(command, invocation, scripts) {
-    const tokens = invocation.trim().split(/\s+/).filter((token) => token !== "");
-    return tokens.length > 0 && runs(command, tokens, scripts, SCRIPT_CHAIN_DEPTH, new Set());
+    const text = invocation.trim();
+    return text !== "" && runs(command, text.split(/\s+/), scripts, SCRIPT_CHAIN_DEPTH);
 }
 //# sourceMappingURL=commandRuns.js.map

package/dist/parse/commandRuns.js.map

@@ -1 +1 @@
-{"version":3,"file":"commandRuns.js","sourceRoot":"","sources":["../../src/parse/commandRuns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B,mGAAmG;AACnG,SAAS,YAAY,CAAC,OAAe;IACnC,OAAO,OAAO;SACX,KAAK,CAAC,OAAO,CAAC;SACd,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,yEAAyE;AACzE,SAAS,QAAQ,CAAC,IAAuB,EAAE,UAA6B;IACtE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,sFAAsF;AACtF,SAAS,IAAI,CACX,OAAe,EACf,UAA6B,EAC7B,OAAyC,EACzC,KAAa,EACb,OAA4B;IAE5B,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAClF,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CACjC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CACf,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;QAClB,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC;QACnC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAC1E,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,OAAe,EACf,UAAkB,EAClB,OAAyC;IAEzC,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC;IAC9E,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;AAC5F,CAAC"}
+{"version":3,"file":"commandRuns.js","sourceRoot":"","sources":["../../src/parse/commandRuns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B,2EAA2E;AAC3E,SAAS,YAAY,CAAC,OAAe;IACnC,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACjE,CAAC;AAED,SAAS,QAAQ,CAAC,IAAuB,EAAE,UAA6B;IACtE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,SAAS,IAAI,CACX,OAAe,EACf,UAA6B,EAC7B,OAAyC,EACzC,KAAa;IAEb,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAClF,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CACjC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,CACf,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,GAAG,CAAC,CAAC,CACpF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,OAAe,EACf,UAAkB,EAClB,OAAyC;IAEzC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;IAC/B,OAAO,IAAI,KAAK,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC;AACtF,CAAC"}