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

package/dist/parse/stepAccounting.d.ts

@@ -1,49 +1,3 @@
-/**
- * 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 { type CiWorkflowStep, type PackageJsonScripts } from "./checkScriptsRunInCI.js";
 import type { StepAccounting } from "../domain/evidenceReconciliation.js";
 export declare function stepAccounting(ciSources: readonly string[], packageJson: PackageJsonScripts, runners: Readonly<Record<string, string | null>>, isReconciler: (step: CiWorkflowStep) => boolean, isNamedANonCheck: (step: CiWorkflowStep) => boolean): StepAccounting;

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

@@ -1 +1 @@
-{"version":3,"file":"stepAccounting.d.ts","sourceRoot":"","sources":["../../src/parse/stepAccounting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAE1E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAChD,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,EAC/C,gBAAgB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,GAClD,cAAc,CA+BhB"}
+{"version":3,"file":"stepAccounting.d.ts","sourceRoot":"","sources":["../../src/parse/stepAccounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAE1E,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAChD,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,EAC/C,gBAAgB,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,GAClD,cAAc,CAuBhB"}

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";
+import { isCandidateStep, runsNamedRunner } from "./runningFitnessFunctions.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,8BAA8B,CAAC;AAGhF,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,CAahB"}

package/dist/parse/stepExclusions.js

@@ -1,62 +1,14 @@
-/**
- * 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];
-    }));
+    const named = new Set(ciWorkflowSteps(ciSources).map((step) => qualifiedStepName(step, ciSourceNames)));
     const excluded = notChecks.filter((entry) => named.has(entry));
     return {
         excluded,
         unmatchedEntries: notChecks.filter((entry) => !named.has(entry)),
         isExcluded: (step) => {
             const name = qualifiedStepName(step, ciSourceNames);
-            return name !== undefined && excluded.includes(name);
+            return excluded.some((entry) => entry === 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,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CACjF,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,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;QAClD,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"}