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

package/dist/parse/stepAccounting.js

@@ -1,66 +1,12 @@
-/**
- * THE ACCOUNTING IDENTITY (@SCN-USG-018, 3F-3343) — how many steps of the target's pipeline this
- * run read, what became of each of them, and the total those dispositions come to.
- *
- * WHY A COUNT EXISTS AT ALL, WHEN FOUR SECTIONS OF THE REPORT ALREADY NAME THE STEPS. This axis's
- * first non-negotiable is that nothing seen is dropped: a step that reaches the reader leaves it
- * as a candidate fitness check, as one of the runners the target named, as the reconciler, or as a
- * step the consumer called a non-check, and there is no fifth outcome. That is a claim about code,
- * and no reader can check it by reading. Every account beside this one names what a step BECAME —
- * so a step that became nothing is missing from no list, and all four of them read exactly as they
- * would have read had the step never existed. Only the population, counted against the
- * dispositions, can see an absence like that.
- *
- * IT ASKS WHAT WOULD STOP BEING COUNTED, NOT WHAT WOULD FAIL. A removal-shaped fault — a filter
- * dropping a step on a branch nobody enumerated — raises nothing for double-entry to miss the
- * other half of. It posts no row, names no step and reds no assertion, because what it did was to
- * not happen. This is the instrument for that shape of fault and it is the only one on the axis.
- *
- * THE SUM IS THIS READER'S, AND THAT IS THE POINT OF CARRYING IT. `accountedFor` is added up here
- * and stated beside `stepsRead`, so the two totals can be compared rather than reconstructed. A
- * report that printed the four dispositions and left the adding to whoever read it would be
- * satisfied by any four figures at all — including four produced by a reader that had lost a step.
- *
- * EVERY DISPOSITION IS THE PRODUCT'S OWN RULE, ASKED, NEVER RESTATED HERE. The candidates come
- * from `isCandidateStep`, the runners from `runsNamedRunner`, and the other two from the seams the
- * composition already built (`parse/reconcilerSteps`, `parse/stepExclusions`). A count that
- * re-derived any of them would be measuring its own arithmetic: it would go on agreeing with
- * itself while the books beneath it posted something else, which is the one disagreement a reader
- * of a total has no way to see. It is the SAME walk, too (`ciWorkflowSteps`), so the population
- * being counted is the population the observers read.
- *
- * THE FOUR ARE DISJOINT BY CONSTRUCTION AND EXHAUSTIVE BY ASSERTION, which is the asymmetry the
- * identity turns on. Each rule below carries the guards that keep a step out of a second
- * disposition, so the count can never exceed the population by accident; nothing here makes them
- * COVER the population, and whether they do is exactly what the two totals say out loud.
- *
- * THE PRECEDENCE IS THE COMPOSITION'S, NOT A PREFERENCE. The exclusion seam discovery is asked
- * through puts the reconciler ahead of the consumer's own list, and a runner is a step the
- * observer never reached the runner rule for if something had already taken it out of discovery.
- * A step that is two things at once is counted under the first of them, so the report's dispositions
- * add up to the pipeline rather than to more than it.
- *
- * NOT THE SCOPE CENSUS beside it (`parse/discoveryScope`, @SCN-USG-020), which counts the same
- * population for a different question: that one says WHICH files and WHICH jobs the steps came
- * from, this one says none of them went missing on the way. A reader satisfies either alone.
- */
 import { ciWorkflowSteps } from "./checkScriptsRunInCI.js";
 import { isCandidateStep, runsNamedRunner } from "./runningStaticChecks.js";
 export function stepAccounting(ciSources, packageJson, runners, isReconciler, isNamedANonCheck) {
     const steps = ciWorkflowSteps(ciSources);
-    // THE COMPOSED SEAM, REBUILT FROM ITS TWO HALVES RATHER THAN TAKEN WHOLE. The observer is asked
-    // one question per step and cannot tell the two facts apart; this reader has to, because "the
-    // reconciler" and "the consumer said so" are the two dispositions a report keeps separate.
     const isExcludedFromDiscovery = (step) => isReconciler(step) || isNamedANonCheck(step);
     const count = (holds) => steps.filter(holds).length;
     const candidates = count((step) => isCandidateStep(step, packageJson, runners, isExcludedFromDiscovery));
     const reconciler = count(isReconciler);
-    // NOT ALSO THE RECONCILER, so a consumer who wrote a `notChecks` entry naming a step this tool
-    // takes out of its own books does not have it counted twice — and the surplus does not read as
-    // a pipeline larger than the one that ran.
     const excluded = count((step) => !isReconciler(step) && isNamedANonCheck(step));
-    // NOT ALREADY OUT OF DISCOVERY, for the same reason and in the observer's own order: the runner
-    // rule is a question about a step the reader is still looking at.
     const runnerSteps = count((step) => !isExcludedFromDiscovery(step) && runsNamedRunner(step, packageJson, runners));
     return {
         stepsRead: steps.length,

package/dist/parse/stepAccounting.js.map

@@ -1 +1 @@
-{"version":3,"file":"stepAccounting.js","sourceRoot":"","sources":["../../src/parse/stepAccounting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAE,eAAe,EAAgD,MAAM,0BAA0B,CAAC;AACzG,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAG5E,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,WAA+B,EAC/B,OAAgD,EAChD,YAA+C,EAC/C,gBAAmD;IAEnD,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;IACzC,gGAAgG;IAChG,8FAA8F;IAC9F,2FAA2F;IAC3F,MAAM,uBAAuB,GAAG,CAAC,IAAoB,EAAW,EAAE,CAChE,YAAY,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,CAAC,KAAwC,EAAU,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAE/F,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAChC,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,uBAAuB,CAAC,CACrE,CAAC;IACF,MAAM,UAAU,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;IACvC,+FAA+F;IAC/F,+FAA+F;IAC/F,2CAA2C;IAC3C,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;IAChF,gGAAgG;IAChG,kEAAkE;IAClE,MAAM,WAAW,GAAG,KAAK,CACvB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,CACxF,CAAC;IAEF,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,MAAM;QACvB,UAAU;QACV,OAAO,EAAE,WAAW;QACpB,UAAU;QACV,QAAQ;QACR,YAAY,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ;KAC/D,CAAC;AACJ,CAAC"}
+{"version":3,"file":"stepAccounting.js","sourceRoot":"","sources":["../../src/parse/stepAccounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAgD,MAAM,0BAA0B,CAAC;AACzG,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAG5E,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,WAA+B,EAC/B,OAAgD,EAChD,YAA+C,EAC/C,gBAAmD;IAEnD,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;IACzC,MAAM,uBAAuB,GAAG,CAAC,IAAoB,EAAW,EAAE,CAChE,YAAY,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,CAAC,KAAwC,EAAU,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAE/F,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAChC,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,uBAAuB,CAAC,CACrE,CAAC;IACF,MAAM,UAAU,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;IAChF,MAAM,WAAW,GAAG,KAAK,CACvB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,CACxF,CAAC;IAEF,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,MAAM;QACvB,UAAU;QACV,OAAO,EAAE,WAAW;QACpB,UAAU;QACV,QAAQ;QACR,YAAY,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ;KAC/D,CAAC;AACJ,CAAC"}

package/dist/parse/stepExclusions.d.ts

@@ -1,54 +1,7 @@
-/**
- * THE CONSUMER'S OWN EXCLUSIONS (@SCN-USG-015, 3F-3343) — which steps of a target's pipeline its
- * manifest names non-checks, and which of the entries that named them named nothing at all.
- *
- * THE THIRD EXCLUSION, AND THE ONLY ONE THAT IS A LIST SOMEBODY WRITES. The reconciler is excluded
- * by construction and a behavioural runner by a rule over what the target named; this one is the
- * consumer saying, about their own pipeline, that a step is not a check. It is a list of THEIR
- * steps and never a list of check names of ours, which is the whole of what keeps it from being
- * the prefix rule arriving one layer along.
- *
- * AN ENTRY IS `<workflow file>:<job id>:<step name>` AND IS MATCHED EXACTLY. One form and no
- * grammar, and the form itself is stated once next door (`parse/stepNames`) because the report
- * names a step that way in every section that names one at all. Fully qualified because a bare name is ambiguous in a real tree — `Typecheck` is a
- * check in this repository's `ci.yml` and plumbing in its `release.yml`, and a bare-name entry
- * would take out both, the second of them a check deleted from the report with nothing said. The
- * job and the source are exactly what the walk was widened to carry (3F-3352), and this is what
- * that was for.
- *
- * NO PREFIX AND NO WILDCARD FORM, argued rather than omitted. A consumer wanting a whole workflow
- * out narrows `--ci`, a supported narrowing the corpus already pins (@SCN-USG-008), so a second
- * way to say the same thing buys a grammar to specify, to test and to explain. Exact-only can be
- * widened later and breaks nobody; starting wide cannot be narrowed once a manifest depends on it.
- *
- * THE PARTITION IS TOTAL, and that is this reader's shape rather than a convenience. Every entry
- * the target wrote is either one that named a step or one that named none, and both halves are
- * returned because both have to be SAID: the first is a step that leaves the report accounted for
- * rather than vanished, and the second is a stale line the consumer wrote that hides nothing —
- * a rename that has already happened, or one that is about to hide the wrong thing. An entry lost
- * between the two halves would be an exclusion nothing anywhere accounts for.
- *
- * THE SEAM IS A FUNCTION, for the reason the citation seam beside it is (`runningStaticChecks`):
- * what the discovery reader needs is one answer per step, not this module's two lists and the
- * rule for turning them into one. Handing it the lists would put the qualification rule inside an
- * observer that has no business restating it, and a second statement of that rule is a second
- * chance for the two to disagree about which step an entry names.
- *
- * NO FILESYSTEM, AND THE NAMES ARE INJECTED. `ciSources` is an array of anonymous source strings
- * — `ciSourcePaths.ts` is explicit that keeping the core that way is the point — so the mapping
- * from a step's source index back to a workflow file is made at the CLI edge, where the paths were
- * already resolved, and arrives here as data. A source this run was given no name for can be
- * named by nobody, so no entry excludes it: the safe direction, and the one that stops two
- * nameless sources answering for each other.
- */
 import { type CiWorkflowStep } from "./checkScriptsRunInCI.js";
-/** What a target's `notChecks` list yielded — the entries that named a step, and those that did not. */
 export interface StepExclusions {
-    /** The entries that named a step this run read, in the order the manifest wrote them. */
     readonly excluded: readonly string[];
-    /** The entries that named none, in the order the manifest wrote them. */
     readonly unmatchedEntries: readonly string[];
-    /** Whether the consumer named this step a non-check. */
     readonly isExcluded: (step: CiWorkflowStep) => boolean;
 }
 export declare function stepExclusions(ciSources: readonly string[], ciSourceNames: readonly string[], notChecks: readonly string[]): StepExclusions;

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

@@ -1 +1 @@
-{"version":3,"file":"stepExclusions.d.ts","sourceRoot":"","sources":["../../src/parse/stepExclusions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAGhF,wGAAwG;AACxG,MAAM,WAAW,cAAc;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,wDAAwD;IACxD,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC;CACxD;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,cAAc,CAkBhB"}
+{"version":3,"file":"stepExclusions.d.ts","sourceRoot":"","sources":["../../src/parse/stepExclusions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAGhF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAC;CACxD;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,cAAc,CAgBhB"}

package/dist/parse/stepExclusions.js

@@ -1,51 +1,6 @@
-/**
- * THE CONSUMER'S OWN EXCLUSIONS (@SCN-USG-015, 3F-3343) — which steps of a target's pipeline its
- * manifest names non-checks, and which of the entries that named them named nothing at all.
- *
- * THE THIRD EXCLUSION, AND THE ONLY ONE THAT IS A LIST SOMEBODY WRITES. The reconciler is excluded
- * by construction and a behavioural runner by a rule over what the target named; this one is the
- * consumer saying, about their own pipeline, that a step is not a check. It is a list of THEIR
- * steps and never a list of check names of ours, which is the whole of what keeps it from being
- * the prefix rule arriving one layer along.
- *
- * AN ENTRY IS `<workflow file>:<job id>:<step name>` AND IS MATCHED EXACTLY. One form and no
- * grammar, and the form itself is stated once next door (`parse/stepNames`) because the report
- * names a step that way in every section that names one at all. Fully qualified because a bare name is ambiguous in a real tree — `Typecheck` is a
- * check in this repository's `ci.yml` and plumbing in its `release.yml`, and a bare-name entry
- * would take out both, the second of them a check deleted from the report with nothing said. The
- * job and the source are exactly what the walk was widened to carry (3F-3352), and this is what
- * that was for.
- *
- * NO PREFIX AND NO WILDCARD FORM, argued rather than omitted. A consumer wanting a whole workflow
- * out narrows `--ci`, a supported narrowing the corpus already pins (@SCN-USG-008), so a second
- * way to say the same thing buys a grammar to specify, to test and to explain. Exact-only can be
- * widened later and breaks nobody; starting wide cannot be narrowed once a manifest depends on it.
- *
- * THE PARTITION IS TOTAL, and that is this reader's shape rather than a convenience. Every entry
- * the target wrote is either one that named a step or one that named none, and both halves are
- * returned because both have to be SAID: the first is a step that leaves the report accounted for
- * rather than vanished, and the second is a stale line the consumer wrote that hides nothing —
- * a rename that has already happened, or one that is about to hide the wrong thing. An entry lost
- * between the two halves would be an exclusion nothing anywhere accounts for.
- *
- * THE SEAM IS A FUNCTION, for the reason the citation seam beside it is (`runningStaticChecks`):
- * what the discovery reader needs is one answer per step, not this module's two lists and the
- * rule for turning them into one. Handing it the lists would put the qualification rule inside an
- * observer that has no business restating it, and a second statement of that rule is a second
- * chance for the two to disagree about which step an entry names.
- *
- * NO FILESYSTEM, AND THE NAMES ARE INJECTED. `ciSources` is an array of anonymous source strings
- * — `ciSourcePaths.ts` is explicit that keeping the core that way is the point — so the mapping
- * from a step's source index back to a workflow file is made at the CLI edge, where the paths were
- * already resolved, and arrives here as data. A source this run was given no name for can be
- * named by nobody, so no entry excludes it: the safe direction, and the one that stops two
- * nameless sources answering for each other.
- */
 import { ciWorkflowSteps } from "./checkScriptsRunInCI.js";
 import { qualifiedStepName } from "./stepNames.js";
 export function stepExclusions(ciSources, ciSourceNames, notChecks) {
-    // THE WALK, of which every other reader on this axis takes its own projection (3F-3352) — the
-    // same parse, so an entry can never name a step the discovery reader did not see.
     const named = new Set(ciWorkflowSteps(ciSources).flatMap((step) => {
         const name = qualifiedStepName(step, ciSourceNames);
         return name === undefined ? [] : [name];

package/dist/parse/stepExclusions.js.map

@@ -1 +1 @@
-{"version":3,"file":"stepExclusions.js","sourceRoot":"","sources":["../../src/parse/stepExclusions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,eAAe,EAAuB,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAYnD,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,aAAgC,EAChC,SAA4B;IAE5B,8FAA8F;IAC9F,kFAAkF;IAClF,MAAM,KAAK,GAAG,IAAI,GAAG,CACnB,eAAe,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1C,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QACpD,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC,CAAC,CACH,CAAC;IACF,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/D,OAAO;QACL,QAAQ;QACR,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChE,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;YACnB,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;YACpD,OAAO,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvD,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"stepExclusions.js","sourceRoot":"","sources":["../../src/parse/stepExclusions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAuB,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAQnD,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,aAAgC,EAChC,SAA4B;IAE5B,MAAM,KAAK,GAAG,IAAI,GAAG,CACnB,eAAe,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1C,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QACpD,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC,CAAC,CACH,CAAC;IACF,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/D,OAAO;QACL,QAAQ;QACR,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChE,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;YACnB,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;YACpD,OAAO,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvD,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/parse/stepNames.d.ts

@@ -1,30 +1,3 @@
-/**
- * HOW A STEP IS NAMED BACK TO THE CONSUMER — `<workflow file>:<job id>:<step name>`, stated once.
- *
- * ONE STATEMENT OF THE FORM, because two readers now depend on it and they must not be free to
- * disagree. A `notChecks` entry is written in this form and matched against it
- * (`parse/stepExclusions`), and the report names a step in this form in every section that names
- * one at all — the consumer's own exclusions, and the reconciler's own steps
- * (`parse/reconcilerSteps`). A second spelling would mean a consumer copying a name off one
- * section of the report and finding it matches nothing when they write it into the other.
- *
- * FULLY QUALIFIED, and that is what the walk was widened to carry (3F-3352). `Typecheck` is a
- * check in this repository's `ci.yml` and plumbing in its `release.yml`, so a bare name is
- * ambiguous in any real tree — as an entry it would take out both, and as a report line it would
- * leave a reader unable to tell which of the two was meant.
- *
- * THE STEP'S OWN HALF IS GITHUB'S. Its `name:`, else the action it `uses:`, else the first
- * non-blank line of its `run:` — the string GitHub itself shows in a run log, so a consumer
- * reading a report line or writing an entry copies what is already in front of them.
- *
- * NO NAME FOR THE SOURCE MEANS NO QUALIFIED NAME. `ciSources` is an array of anonymous source
- * strings and the core holds no filesystem — `ciSourcePaths.ts` is explicit that keeping it that
- * way is the point — so the names arrive as data from the CLI edge. A source this run was given
- * none for can be named by nobody, and what each caller does with that silence is its own: an
- * entry excludes no such step (the safe direction), and the reconciler account falls back to the
- * step's own identity rather than dropping a step it recognised.
- */
 import type { CiWorkflowStep } from "./checkScriptsRunInCI.js";
-/** The one string that names this step, or nothing for a step whose source has no name. */
 export declare function qualifiedStepName(step: CiWorkflowStep, ciSourceNames: readonly string[]): string | undefined;
 //# sourceMappingURL=stepNames.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stepNames.d.ts","sourceRoot":"","sources":["../../src/parse/stepNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,cAAc,EACpB,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,MAAM,GAAG,SAAS,CAGpB"}
+{"version":3,"file":"stepNames.d.ts","sourceRoot":"","sources":["../../src/parse/stepNames.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,cAAc,EACpB,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,MAAM,GAAG,SAAS,CAGpB"}

package/dist/parse/stepNames.js

@@ -1,30 +1,3 @@
-/**
- * HOW A STEP IS NAMED BACK TO THE CONSUMER — `<workflow file>:<job id>:<step name>`, stated once.
- *
- * ONE STATEMENT OF THE FORM, because two readers now depend on it and they must not be free to
- * disagree. A `notChecks` entry is written in this form and matched against it
- * (`parse/stepExclusions`), and the report names a step in this form in every section that names
- * one at all — the consumer's own exclusions, and the reconciler's own steps
- * (`parse/reconcilerSteps`). A second spelling would mean a consumer copying a name off one
- * section of the report and finding it matches nothing when they write it into the other.
- *
- * FULLY QUALIFIED, and that is what the walk was widened to carry (3F-3352). `Typecheck` is a
- * check in this repository's `ci.yml` and plumbing in its `release.yml`, so a bare name is
- * ambiguous in any real tree — as an entry it would take out both, and as a report line it would
- * leave a reader unable to tell which of the two was meant.
- *
- * THE STEP'S OWN HALF IS GITHUB'S. Its `name:`, else the action it `uses:`, else the first
- * non-blank line of its `run:` — the string GitHub itself shows in a run log, so a consumer
- * reading a report line or writing an entry copies what is already in front of them.
- *
- * NO NAME FOR THE SOURCE MEANS NO QUALIFIED NAME. `ciSources` is an array of anonymous source
- * strings and the core holds no filesystem — `ciSourcePaths.ts` is explicit that keeping it that
- * way is the point — so the names arrive as data from the CLI edge. A source this run was given
- * none for can be named by nobody, and what each caller does with that silence is its own: an
- * entry excludes no such step (the safe direction), and the reconciler account falls back to the
- * step's own identity rather than dropping a step it recognised.
- */
-/** The one string that names this step, or nothing for a step whose source has no name. */
 export function qualifiedStepName(step, ciSourceNames) {
     const source = ciSourceNames[step.sourceIndex];
     return source === undefined ? undefined : `${source}:${step.jobId}:${step.identity}`;

package/dist/parse/stepNames.js.map

@@ -1 +1 @@
-{"version":3,"file":"stepNames.js","sourceRoot":"","sources":["../../src/parse/stepNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,2FAA2F;AAC3F,MAAM,UAAU,iBAAiB,CAC/B,IAAoB,EACpB,aAAgC;IAEhC,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC/C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;AACvF,CAAC"}
+{"version":3,"file":"stepNames.js","sourceRoot":"","sources":["../../src/parse/stepNames.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAC/B,IAAoB,EACpB,aAAgC;IAEhC,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC/C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;AACvF,CAAC"}

package/dist/parse/targetCorpus.d.ts

@@ -1,85 +1,8 @@
-/**
- * The TARGET's feature corpus read into the readings one reconciliation needs — moved here from
- * the app's ingest edge (3F-3088).
- *
- * WHY IT LIVES IN THE ENGINE. Every line of it is a pure function of sources somebody else already
- * read off disk: the obligation rule is `parseScenarios`, core's own. Sitting at the app edge it
- * was the reason a PUBLISHED module imported core's unpublished `/internal` subpath for five
- * symbols — the fault 3F-3086 repairs. One line made it impure and it was the only one: the feature discovery, which now
- * happens at the edge and arrives as `sources`.
- *
- * THE REGISTRY-KEYED READING THIS FILE ONCE ALSO PRODUCED — `checkHandles` and `citedScn`, the
- * obligation-side observer's feed — RETIRED WITH THE REGISTRY ITSELF (3F-3161, @SCN-LNT-017, the
- * last registry-`scn` scenario). Every check now either states its own row's code on its CI step
- * (`citedRow`, below) or is a converted `@fitness` row read through `domain/fitnessChecks`
- * directly; there is no second discovery left to key a handle set off.
- */
-import type { FitnessCheckIndex, UnspecifiedFitnessRow } from "../domain/fitnessChecks.js";
 import { type ScriptCitation } from "./fitnessCitations.js";
 import type { Scenario } from "../model.js";
-/**
- * The target's feature corpus as ONE run reads it — the obligations it raises, the `@SCN` a run
- * whose CI step states a code cites, the scenarios on the fitness axis no configured row names,
- * and the configured rows the corpus carries no scenario for.
- *
- * THE READINGS ARE ONE, which is why they are produced together. All are derived from the same
- * bytes and the same configured rows, and the fault they exist to foreclose is precisely their
- * disagreeing: a citation resolved against a corpus the ledger was not built from names a row
- * nobody wrote (@SCN-LNT-009). Returning them separately would leave a caller free to assemble
- * them from different reads.
- *
- * EVERY INPUT IS THE TARGET'S (@SCN-LNT-005). `fitnessChecks` came from the target's manifest and
- * the sources from the target's features directory, so a configured row means what that target
- * says it means and the scenario carrying its `@SCN` is one that target wrote.
- */
 export interface TargetCorpus {
-    /** The `@SCN`-carrying scenarios, with their evidence obligations raised. */
     scenarios: Scenario[];
-    /**
-     * What a run whose CI step STATES a code cites — the configured row that code names, read for
-     * the characteristic a CI step cannot state (@SCN-LNT-031).
-     *
-     * NO CODE IS THE SAME ANSWER AS AN UNANSWERED ONE — `null`, the run cites nothing, and it posts
-     * to suspense. That is the state a consumer starts in, and this seam does not narrow it.
-     */
     citedRow: (citedScn: string | undefined) => ScriptCitation | null;
-    /**
-     * The scenarios ON the fitness axis that no configured row NAMES (@SCN-LNT-020) — the corpus's
-     * half-converted checks, in corpus order.
-     *
-     * It belongs with the other readings because it is the same one: the obligation rule raises
-     * nothing for such a scenario, and this says WHICH ones. Produced here, where the corpus walk and
-     * the configured rows are both in hand, so the naming and the raising cannot be taken from
-     * different reads — the same guarantee `citedRow` is composed here for.
-     */
-    unconfiguredFitnessScenarios: readonly string[];
-    /**
-     * The CONFIGURED ROWS the corpus carries no scenario for (@SCN-LNT-027, 3F-3472) — the other
-     * direction of the same disagreement, in manifest order, each with the characteristic its debit
-     * is owed at.
-     *
-     * IT IS HERE FOR THE MIRROR'S REASON AND NOT A WEAKER ONE. The corpus walk and the configured
-     * rows are both in hand exactly once, so the rows this names and the obligations `scenarios`
-     * raises are taken from ONE read of each side. Computed at the composition from `corpus.scenarios`
-     * it would be a second walk, free to disagree with the walk the obligations came from — which is
-     * the fault this whole reading exists to foreclose.
-     */
-    unspecifiedFitnessRows: readonly UnspecifiedFitnessRow[];
 }
-/**
- * THE SOURCES ARRIVE READ, AND THAT IS THE WHOLE OF WHAT MOVED. The edge discovers the target's
- * feature files and reads them ONCE, so the reading a citing run needs is still taken from the same
- * bytes. Two discoveries could disagree about the corpus, and a citation resolved against a corpus
- * the ledger was not built from is exactly the phantom-row fault (@SCN-LNT-009); passing one array
- * preserves that guarantee where a features directory would have re-opened the question inside the
- * engine.
- */
-export declare function readTargetCorpus(sources: readonly string[], deferralTags: readonly string[], 
-/**
- * The target's CONFIGURED ROWS (@SCN-LNT-018) — the CONVERTED route's half of the debit side. It
- * reaches `parseScenarios`, which raises the Evidence Obligations, and `citedRow`, which reads a
- * row back for a run whose CI step states its code (@SCN-LNT-031) — the same rows on both sides,
- * which is the whole reason this reading is composed here.
- */
-fitnessChecks: FitnessCheckIndex): TargetCorpus;
+export declare function readTargetCorpus(sources: readonly string[], deferralTags: readonly string[]): TargetCorpus;
 //# sourceMappingURL=targetCorpus.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"targetCorpus.d.ts","sourceRoot":"","sources":["../../src/parse/targetCorpus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAOhF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,cAAc,GAAG,IAAI,CAAC;IAClE;;;;;;;;OAQG;IACH,4BAA4B,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD;;;;;;;;;;OAUG;IACH,sBAAsB,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC1D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE;AAC/B;;;;;GAKG;AACH,aAAa,EAAE,iBAAiB,GAC/B,YAAY,CAkBd"}
+{"version":3,"file":"targetCorpus.d.ts","sourceRoot":"","sources":["../../src/parse/targetCorpus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAKhF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,cAAc,GAAG,IAAI,CAAC;CACnE;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,YAAY,CAKd"}

package/dist/parse/targetCorpus.js

@@ -1,51 +1,9 @@
-/**
- * The TARGET's feature corpus read into the readings one reconciliation needs — moved here from
- * the app's ingest edge (3F-3088).
- *
- * WHY IT LIVES IN THE ENGINE. Every line of it is a pure function of sources somebody else already
- * read off disk: the obligation rule is `parseScenarios`, core's own. Sitting at the app edge it
- * was the reason a PUBLISHED module imported core's unpublished `/internal` subpath for five
- * symbols — the fault 3F-3086 repairs. One line made it impure and it was the only one: the feature discovery, which now
- * happens at the edge and arrives as `sources`.
- *
- * THE REGISTRY-KEYED READING THIS FILE ONCE ALSO PRODUCED — `checkHandles` and `citedScn`, the
- * obligation-side observer's feed — RETIRED WITH THE REGISTRY ITSELF (3F-3161, @SCN-LNT-017, the
- * last registry-`scn` scenario). Every check now either states its own row's code on its CI step
- * (`citedRow`, below) or is a converted `@fitness` row read through `domain/fitnessChecks`
- * directly; there is no second discovery left to key a handle set off.
- */
 import { citationOfCitedRow } from "./fitnessCitations.js";
-import { parseScenarios, parseTaggedScenarios, unconfiguredFitnessScenarios, unspecifiedFitnessRows, } from "./scenarios.js";
-/**
- * THE SOURCES ARRIVE READ, AND THAT IS THE WHOLE OF WHAT MOVED. The edge discovers the target's
- * feature files and reads them ONCE, so the reading a citing run needs is still taken from the same
- * bytes. Two discoveries could disagree about the corpus, and a citation resolved against a corpus
- * the ledger was not built from is exactly the phantom-row fault (@SCN-LNT-009); passing one array
- * preserves that guarantee where a features directory would have re-opened the question inside the
- * engine.
- */
-export function readTargetCorpus(sources, deferralTags, 
-/**
- * The target's CONFIGURED ROWS (@SCN-LNT-018) — the CONVERTED route's half of the debit side. It
- * reaches `parseScenarios`, which raises the Evidence Obligations, and `citedRow`, which reads a
- * row back for a run whose CI step states its code (@SCN-LNT-031) — the same rows on both sides,
- * which is the whole reason this reading is composed here.
- */
-fitnessChecks) {
-    // NO BARE CHECK TAG RAISES AN OBLIGATION ON A TARGET'S CORPUS. The registered half of the
-    // union retired with the registry (3F-3161) and the measured half with the measured axis
-    // (3F-3516), so the bare-tag set handed to `parseScenarios` is empty: a fitness obligation is
-    // raised by the axis word and a configured row, and by nothing else.
-    const scenarios = sources.flatMap((source) => parseScenarios(source, deferralTags, [], fitnessChecks));
-    // THE TAGGED WALK THE TWO CORPUS-VS-MANIFEST READINGS SHARE. Kept as its own pass over the
-    // sources, and handed to BOTH of them — the disagreement each names is the other's direction, so
-    // taking them from one walk is what stops one reading seeing a scenario the other does not.
-    const tagged = sources.flatMap((source) => parseTaggedScenarios(source));
+import { parseScenarios, } from "./scenarios.js";
+export function readTargetCorpus(sources, deferralTags) {
     return {
-        scenarios,
-        citedRow: (citedScn) => citationOfCitedRow(citedScn, fitnessChecks),
-        unconfiguredFitnessScenarios: unconfiguredFitnessScenarios(tagged, fitnessChecks),
-        unspecifiedFitnessRows: unspecifiedFitnessRows(tagged, fitnessChecks),
+        scenarios: sources.flatMap((source) => parseScenarios(source, deferralTags)),
+        citedRow: (citedScn) => citationOfCitedRow(citedScn),
     };
 }
 //# sourceMappingURL=targetCorpus.js.map

package/dist/parse/targetCorpus.js.map

@@ -1 +1 @@
-{"version":3,"file":"targetCorpus.js","sourceRoot":"","sources":["../../src/parse/targetCorpus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,kBAAkB,EAAuB,MAAM,uBAAuB,CAAC;AAChF,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAqDxB;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAA0B,EAC1B,YAA+B;AAC/B;;;;;GAKG;AACH,aAAgC;IAEhC,0FAA0F;IAC1F,yFAAyF;IACzF,8FAA8F;IAC9F,qEAAqE;IACrE,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAC3C,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE,aAAa,CAAC,CACxD,CAAC;IACF,2FAA2F;IAC3F,iGAAiG;IACjG,4FAA4F;IAC5F,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;IACzE,OAAO;QACL,SAAS;QACT,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,QAAQ,EAAE,aAAa,CAAC;QACnE,4BAA4B,EAAE,4BAA4B,CAAC,MAAM,EAAE,aAAa,CAAC;QACjF,sBAAsB,EAAE,sBAAsB,CAAC,MAAM,EAAE,aAAa,CAAC;KACtE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"targetCorpus.js","sourceRoot":"","sources":["../../src/parse/targetCorpus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAuB,MAAM,uBAAuB,CAAC;AAChF,OAAO,EACL,cAAc,GAEf,MAAM,gBAAgB,CAAC;AAQxB,MAAM,UAAU,gBAAgB,CAC9B,OAA0B,EAC1B,YAA+B;IAE/B,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC5E,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC;KACrD,CAAC;AACJ,CAAC"}

package/dist/parse/targetManifest.d.ts

@@ -1,166 +1,28 @@
-/**
- * The TARGET's `specController.*` configuration, read into the rows and mints the
- * reconciler takes — the `resolve*` family, moved here from the app's ingest edge (3F-3087).
- *
- * WHY THEY LIVE IN THE ENGINE. Every one of them is a pure function of a manifest object
- * somebody else already read off disk, and every one of them is the ONE reading of the key it
- * names — `fitnessChecksOf` and `bareTerm` are both core's, so the reader and the
- * thing it reads through belonged on the same side of the package boundary. Sitting at the app
- * edge they were the reason a PUBLISHED module imported core's unpublished `/internal` subpath,
- * which is the fault 3F-3086 repairs; nothing about reading a parsed manifest ever needed the
- * edge that produced it.
- *
- * WHAT THE EDGE STILL OWES THEM, AND WHY IT IS A PARAMETER. One of these readings depends on
- * something the engine must not know: the deferral-tag STARTER SET is product policy the
- * application layer single-sources (`DEFAULT_DEFERRAL_TAGS`). It arrives as an argument, as data,
- * so the engine keeps knowing nothing about files (`lint:boundaries`' `core-imports-io` rule,
- * which was @SCN-EPG-001's `io-import` arm until 3F-3437; and 3F-2841's pattern: a project-owned
- * term arrives as an input).
- *
- * DEFENSIVE THROUGHOUT, AND THAT IS THE FAMILY'S STANCE RATHER THAN LOCAL CHOICES PER RESOLVER.
- * Config is data from outside: a missing, non-object or array-shaped value resolves EMPTY, and a
- * malformed entry is dropped by the reading function it is handed to rather than thrown. A check
- * that throws on a typo produces no verdict at all.
- */
-import { type FitnessCheckIndex } from "../domain/fitnessChecks.js";
-/**
- * The steps the TARGET names NON-CHECKS (@SCN-USG-015, 3F-3343) — `specController.notChecks`, read
- * as the fully-qualified `<workflow file>:<job id>:<step name>` entries the target wrote.
- *
- * IT IS THE CONSUMER'S OWN LIST, and that is the whole reason it may exist at all. Not everything
- * that is not a behavioural runner is a fitness check — a checkout, a dependency install, a deploy
- * — and this axis's standing rule is that a list of check NAMES is the drift. A list of the
- * consumer's own STEPS is the opposite thing: it is about their pipeline, it is written once, and
- * nothing in this tree has an opinion about what is on it.
- *
- * The seventh of this family's `specController.*` resolvers, and defensive like the six above it:
- * a missing or non-array value resolves EMPTY and a non-string entry is dropped rather than
- * thrown. Deduplicated, as the configured-static-check list beside it is, so a target that wrote
- * one line twice is reported one line — the account below is per ENTRY, and the same entry twice
- * is one thing the consumer said.
- *
- * WHAT AN ENTRY MEANS IS NOT DECIDED HERE. This reader takes the list off the manifest; matching it
- * against a pipeline, and saying which entries matched nothing, is `parse/stepExclusions`.
- */
+import type { WrongKindEntry } from "../domain/evidenceReconciliation.js";
 export declare function resolveNotChecks(packageJson: {
     specController?: {
         notChecks?: unknown;
     };
 }): readonly string[];
-/**
- * Resolve the recognised deferral-tag set for the target (@SCN-PND-021) — the app's single-sourced
- * starter set EXTENDED by the target `package.json`'s `specController.deferralTags`. Config
- * EXTENDS, never replaces: a project cannot un-recognise a built-in (`@wip` always defers).
- * Configured tags are bare names, `@`-stripped, consistent with the starter set; non-string /
- * non-array config is ignored defensively. `parseScenarios` then takes the union as its injected
- * `deferralTags` param.
- *
- * THE STARTER SET ARRIVES AS AN ARGUMENT AND IS NOT THE ENGINE'S TO HOLD (3F-3087). Which
- * community tags defer is product policy — an evolvable list of strings the application layer
- * single-sources as `DEFAULT_DEFERRAL_TAGS` — and a core-held copy would be a second statement of
- * it. So the union is computed here, where the config read is, and the policy is handed in.
- */
 export declare function resolveDeferralTags(packageJson: {
     specController?: {
         deferralTags?: unknown;
     };
-}, 
-/** The application layer's starter set — the built-ins a target's config may only extend. */
-starterTags: readonly string[]): readonly string[];
-/**
- * The TARGET's CONFIGURED FITNESS ROWS (@SCN-LNT-018) — `specController.fitnessChecks`, read as
- * `@SCN → the characteristic that scenario asserts` through the engine's own `fitnessChecksOf`.
- *
- * THE DEBIT SIDE OF A CONVERTED CHECK. A converted scenario carries `@fitness` and nothing about
- * its subject, so the characteristic it owes comes from here — and from the row whose `scn` is that
- * scenario's own, which is what removes the registry hop an unconverted static check needs.
- *
- * IT IS THE TARGET'S, for the reason the check registry and the ceilings are (@SCN-LNT-005): a
- * characteristic means what the target says it means, and a row resolved from this tool's own
- * manifest would put an obligation on a target's books under a word it never wrote.
- *
- * The fifth of this family's `specController.*` resolvers, and defensive like the four above it: a
- * missing or wrongly-shaped config resolves EMPTY, and a malformed row is dropped by
- * `fitnessChecksOf` rather than thrown. There is no starter set: a target that has converted
- * nothing owes nothing on this route, which is what keeps the reading inert on an unswept corpus.
- */
-export declare function resolveFitnessChecks(packageJson: {
-    specController?: {
-        fitnessChecks?: unknown;
-    };
-}): FitnessCheckIndex;
-/**
- * WHAT A TARGET'S RUNNER BLOCK YIELDED — the entries keyed by a canon tier, and the keys that are
- * not one (@SCN-USG-019).
- *
- * TWO HALVES RATHER THAN ONE RECORD, because the two are used for opposite things and neither may
- * be reached for the other. `tiers` is what a recognition can be run against; `unrecognisedKeys` is
- * what the report has to SAY, and it recognises nothing by construction — there is no tier for it
- * to be the runner of. Returning one record and filtering downstream would leave every caller free
- * to honour a key the block's closure rules out, which is the fault this partition forecloses.
- */
+}, starterTags: readonly string[]): readonly string[];
 export interface ResolvedRunners {
-    /** The runner named for each canon tier the block names one for — `null` where it says it has none. */
     readonly tiers: Readonly<Record<string, string | null>>;
-    /** The block's keys that are not one of the four canon tiers, in the order the manifest wrote them. */
     readonly unrecognisedKeys: readonly string[];
 }
-/**
- * The TARGET's BEHAVIOURAL RUNNERS (@SCN-USG-011, 3F-3343) — `specController.runners`, read as
- * `tier → the name of the binary that tier's suite runs under`.
- *
- * THE SMALL CLOSED THING, NAMED, so the open one can be inferred. The set of names a quality check
- * might go by is unbounded and belongs to the consumer; the set of behavioural runners is one per
- * tier tag and the tiers are canon. Naming the closed set and deriving the rest is the move the
- * `@fitness` collapse already made one level in (3F-3139), and it cannot go stale by omission.
- *
- * IT IS THE TARGET'S, for the reason the check registry and the ceilings are (@SCN-LNT-005): which
- * command runs a repository's unit suite is a fact about that repository, and a runner resolved
- * from this tool's own manifest would answer for a pipeline this run never looked at.
- *
- * The sixth of this family's `specController.*` resolvers, and defensive like the five above it: a
- * missing, non-object or array-shaped config resolves EMPTY, and an entry whose value is neither a
- * runner's NAME nor `null` is dropped rather than thrown. A manifest naming no runners is not an
- * error — it is a `new-client`, which is the state this axis is sold on.
- *
- * A NULL IS KEPT, AND IT IS THE THIRD STATE (@SCN-USG-016, 3F-3343). `"performance": null` is
- * something the target SAID — we have no performance suite — and a tier the block omits is
- * something it never said. Dropping the null folds the first into the second and loses a fact we
- * were given, in the one direction nothing downstream can recover: after the fold, silence and a
- * stated absence are indistinguishable. Nothing else in this reader's contract moves — a null
- * recognises no step, exactly as a missing key recognises none — so the ONLY place the two can be
- * told apart is this return value and the report rendered off it.
- *
- * THE KEY SET IS CLOSED, AND THE PARTITION IS THIS READER'S (@SCN-USG-019, 3F-3343). The block is
- * keyed by TIER and the tiers are canon, which is exactly what makes the whole inversion possible:
- * the closed set is named because it is enumerable, and the open one is inferred from what is left.
- * A key outside the four is therefore not a runner for anything, and both obvious answers to it are
- * wrong. HONOURING it is the smuggling the closure forbids — `"lint": "eslint"` is a consumer taking
- * their own checks out of discovery one key at a time, and it reinstates the silence this axis
- * exists to remove. DROPPING it silently is the same class of fault one layer along: the consumer
- * wrote something, believes it took effect, and has no line anywhere to correct it from. So the key
- * is partitioned out of the runners AND handed back to be named, and the run is not aborted over it.
- *
- * THE FOUR TIERS ARE READ, NEVER RESTATED. `RUNTIME_QUALITY_CHECKS` is the ledger's own enumeration
- * of the runtime tiers; a second copy here would agree with it by coincidence, and a list of names
- * is the drift this ticket is about.
- *
- * THE PARTITION IS ON THE KEY AND THE DEFENSIVE DROP IS ON THE VALUE, and the two are different
- * questions kept apart. A canon tier whose value is neither a runner's NAME nor `null` is malformed
- * config and is dropped, which is this family's stance about data from outside. A key that is not a
- * tier at all is not malformed — there is no tier for any value of it to name a runner for — so its
- * value is beside the point and the key is the fact worth reporting, whatever it was set to.
- */
 export declare function resolveRunners(packageJson: {
     specController?: {
         runners?: unknown;
     };
 }): ResolvedRunners;
-/**
- * ONE ACCOUNT FOR BOTH KINDS, in the order the manifest wrote them: a retired top-level key names
- * itself, and `fitnessChecks` names each bar its rows still carry.
- */
-export declare function resolveRetiredKeys(packageJson: {
+export interface ConfigurationNotRead {
+    readonly wrongKinds: readonly WrongKindEntry[];
+    readonly unknownKeys: readonly string[];
+}
+export declare function configurationNotRead(packageJson: {
     specController?: unknown;
-}): readonly string[];
+}): ConfigurationNotRead;
 //# sourceMappingURL=targetManifest.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"targetManifest.d.ts","sourceRoot":"","sources":["../../src/parse/targetManifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAWrF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE;IAC5C,cAAc,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC1C,GAAG,SAAS,MAAM,EAAE,CAIpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE;IACX,cAAc,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC7C;AACD,6FAA6F;AAC7F,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,SAAS,MAAM,EAAE,CAcnB;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE;IAChD,cAAc,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC9C,GAAG,iBAAiB,CAEpB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,uGAAuG;IACvG,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACxD,uGAAuG;IACvG,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE;IAC1C,cAAc,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACxC,GAAG,eAAe,CAclB;AAiDD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,MAAM,EAAE,CAO/F"}
+{"version":3,"file":"targetManifest.d.ts","sourceRoot":"","sources":["../../src/parse/targetManifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAY1E,wBAAgB,gBAAgB,CAAC,WAAW,EAAE;IAC5C,cAAc,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC1C,GAAG,SAAS,MAAM,EAAE,CAIpB;AAED,wBAAgB,mBAAmB,CACjC,WAAW,EAAE;IACX,cAAc,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC7C,EACD,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,SAAS,MAAM,EAAE,CASnB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,wBAAgB,cAAc,CAAC,WAAW,EAAE;IAC1C,cAAc,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACxC,GAAG,eAAe,CAWlB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAiCD,wBAAgB,oBAAoB,CAAC,WAAW,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,oBAAoB,CAUpG"}