@untangle-code/complexity 0.0.0-stage → 0.1.0

package/dist/scope-aggregate.js

@@ -0,0 +1,588 @@
+/**
+ * Aggregation ueber einen Scope-BAUM, ohne Doppelzaehlung (WP-82; spec.md
+ * §16.10, docs/BUILD_PLAN.md E4).
+ *
+ * ## Das Problem
+ *
+ * `aggregate()` in `aggregator.ts` dedupliziert ueber `metricsScopeId` und
+ * loest damit genau einen Fall: dasselbe Retrieval-Fragment zweimal in der
+ * Eingabe. Es loest NICHT den Fall, um den es hier geht — verschachtelte
+ * Scopes. `buildSymbolIR()` bezieht bewusst jeden Nachfahren-Scope in die IR
+ * des Zielscopes ein (siehe `ir/build-ir.ts`, "documented nesting context"
+ * nach spec.md §16.4): der `file`-Scope traegt also den Kontrollfluss ALLER
+ * Klassen, Methoden und Closures der Datei, die Methode den ihrer Closures.
+ * Jeder dieser Scopes hat eine eigene, gueltige `metricsScopeId` — die
+ * Deduplizierung greift nicht, und `sum` zaehlt denselben Quelltext einmal
+ * je umschliessendem Scope.
+ *
+ * Am eigenen Repo gemessen (siehe `scripts/complexity-report.mjs`): naiv
+ * summiert ergibt cognitive rund das Dreifache der Summe, die jeden Scope
+ * genau einmal zaehlt. Eine Hotspot-Liste auf dieser Basis steuert in die
+ * falsche Richtung.
+ *
+ * ## Die drei Lesarten
+ *
+ * "Summe ueber ein Paket" ist ohne Angabe der Lesart bedeutungslos. Dieses
+ * Modul kennt genau drei, alle drei zaehlen jeden Scope GENAU EINMAL, und
+ * sie unterscheiden sich ausschliesslich darin, wie viel Nesting-Kontext ein
+ * Konstrukt mitbekommt:
+ *
+ * - `"top_level"` (Datei-Lesart): Summe der `inclusiveValue` ueber die
+ *   Wurzel-Scopes. Jedes Konstrukt zaehlt einmal, mit dem VOLLEN
+ *   Nesting-Kontext bis zur Wurzel — jede umschliessende Funktion zaehlt als
+ *   Nesting-Ebene. Beantwortet: "wie schwer ist diese Datei am Stueck zu
+ *   lesen".
+ * - `"execution_unit"` (Funktions-Lesart, DEFAULT): Summe der
+ *   `inclusiveValue` ueber die AEUSSERSTEN Ausfuehrungseinheiten (Funktion,
+ *   Methode, Konstruktor) plus die `selfValue` aller Scopes, die selbst keine
+ *   Ausfuehrungseinheit sind und auch keine ueber sich haben (Datei, Klasse,
+ *   Interface, Namespace). Der Nesting-Zaehler startet bei jeder aeussersten
+ *   Funktion neu; verschachtelte Closures bleiben — wie von spec.md §16.4
+ *   verlangt — Teil ihrer umschliessenden Funktion. Das ist die Lesart, die
+ *   der verbreiteten "cognitive complexity je Funktion, danach aufsummiert"
+ *   Konvention entspricht und damit die einzige, die einer Gegenprobe gegen
+ *   ein etabliertes Werkzeug (X8) standhaelt.
+ * - `"self"` (Eigenanteil-Lesart): Summe der `selfValue` ueber ALLE Scopes.
+ *   Der Nesting-Zaehler startet in jedem Scope neu, auch in einer Closure.
+ *   Untere Schranke; nuetzlich, um den Anteil sichtbar zu machen, den reines
+ *   Nesting am Gesamtwert hat.
+ *
+ * Fuer eine Metrik OHNE Sockel je Scope (`perScopeBase === 0`, also cognitive)
+ * gilt strukturell `self <= execution_unit <= top_level`, und zwar als Folge
+ * der Kerninvariante: die Differenzen sind nicht Rauschen, sondern genau der
+ * Nesting-Aufschlag der jeweils zusaetzlich beruecksichtigten Ebenen (belegt
+ * in `scope-aggregate.test.ts`).
+ *
+ * ## Woraus die Doppelzaehlungsfreiheit tatsaechlich folgt
+ *
+ * Nicht aus `checkScopeTreeInvariants`. Deren Kernpruefung
+ * `children_exceed_parent` ist eine EINSEITIGE Schranke
+ * (`self + Summe Kinder <= inclusive`): sie faengt einen zu KLEINEN
+ * Elternwert, also fehlenden Inhalt. Ein zu GROSSER Elternwert — der Fall, in
+ * dem ein Kindbeitrag zweimal im Elternwert steckt — erfuellt sie erst recht
+ * und bleibt damit unentdeckt. Aus Werten allein ist er auch nicht
+ * entscheidbar: ein aufgeblaehter `inclusiveValue` sieht genauso aus wie ein
+ * Scope, der im eigenen Koerper einfach viel Kontrollfluss traegt.
+ *
+ * Was dieses Modul stattdessen ZUSICHERT und mit `checkScopeCoverage`
+ * NACHPRUEFT, ist die strukturelle Aussage: in jeder der drei Lesarten geht
+ * jeder Scope in GENAU EINEN Summanden ein — entweder als eigener Summand
+ * oder als Nachfahre genau eines Summanden, der mit `inclusiveValue` zaehlt.
+ * Damit kann keine Lesart denselben Quelltext zweimal aufaddieren. Das ist
+ * die Zusicherung, die die Summen tragen; die Werttreue der einzelnen
+ * `inclusiveValue`s liegt beim Aufrufer, der sie berechnet hat.
+ *
+ * Fuer eine Metrik MIT Sockel (`perScopeBase > 0`, also cyclomatic:
+ * `M = 1 + decision_points`) kehrt sich die Reihenfolge um, und das ist
+ * korrekt: die `self`-Lesart zaehlt den Sockel einmal JE SCOPE, die
+ * `top_level`-Lesart nur einmal je Datei. Die drei Zahlen bleiben
+ * doppelzaehlungsfrei — sie beantworten nur verschiedene Fragen. Wer sie
+ * nebeneinander zeigt, muss den Sockel dazusagen.
+ *
+ * ## Warum es KEINE Blatt-Lesart gibt
+ *
+ * "Summe der Blatt-Scopes" waere die naheliegende vierte Lesart und ist
+ * FALSCH: der Kontrollfluss, der direkt im Koerper eines Scopes MIT Kindern
+ * steht (eine `if`-Kette in einer Methode, die ausserdem eine Closure
+ * definiert), gehoert keinem Blatt und faellt ersatzlos weg. Das ist kein
+ * Deduplizieren, sondern stilles Verlieren von Inhalt — genau das, was E4
+ * verbietet. `ScopeTreeAggregateV1.leafOnlySum` weist die Zahl trotzdem aus,
+ * aber ausdruecklich als Diagnose zusammen mit `leafOnlyDroppedAmount`, dem
+ * Betrag, den sie verschluckt.
+ *
+ * ## Determinismus
+ *
+ * Kein `localeCompare`, kein `Date.now()`, kein `Math.random()`. Reihenfolgen
+ * werden ueber `compareCodepoints` aus `@untangle-code/domain` hergestellt.
+ */
+import { compareCodepoints, UntangleError } from "@untangle-code/domain";
+/** Die drei definierten Lesarten einer Scope-Summe. */
+export const SCOPE_SUM_READINGS = ["top_level", "execution_unit", "self"];
+/** Geschlossene Menge der Invariantenverstoesse. Ein Verstoss ist ein Fehler, kein Hinweis. */
+export const SCOPE_INVARIANT_CODES = [
+    "duplicate_scope_id",
+    "unknown_parent",
+    "parent_cycle",
+    "negative_value",
+    "self_exceeds_inclusive",
+    "children_exceed_parent",
+    "leaf_self_differs_from_inclusive",
+    "scope_counted_twice",
+    "scope_uncounted",
+];
+/**
+ * Die Felder, in denen sich zwei Eintraege mit derselben `metricsScopeId`
+ * unterscheiden — als LISTE, nicht als Ja/Nein.
+ *
+ * WP-186: Die Begruendung im Verstoss darf nicht behaupten, „die Werte
+ * weichen ab", und dann zweimal dieselbe Zahl drucken. Genau das geschah,
+ * sobald der Unterschied in `parentScopeId` oder `executionUnit` lag: der
+ * Text nannte `inclusive`/`self`, die dort identisch waren, und das
+ * tatsaechlich abweichende Feld kam nirgends vor. Wer so etwas liest, sucht
+ * einen Fehler in einer Zahl, die stimmt.
+ *
+ * WP-200: `sloc` gehoert dazu. Es blieb ausserhalb des Vergleichs, obwohl es
+ * das GEWICHT im SLOC-gewichteten Mittel von `aggregate()` stellt: zwei
+ * Eintraege mit derselben Id und verschiedenem `sloc` galten als identisch,
+ * der zweite wurde ohne Verstoss verworfen — und mit ihm sein Gewicht. Der
+ * Mittelwert verschob sich, und nichts sagte es.
+ */
+function differingFields(a, b) {
+    const differing = [];
+    if (a.inclusiveValue !== b.inclusiveValue) {
+        differing.push(`inclusive ${String(b.inclusiveValue)} vs. ${String(a.inclusiveValue)}`);
+    }
+    if (a.selfValue !== b.selfValue) {
+        differing.push(`self ${String(b.selfValue)} vs. ${String(a.selfValue)}`);
+    }
+    if (a.executionUnit !== b.executionUnit) {
+        differing.push(`executionUnit ${String(b.executionUnit)} vs. ${String(a.executionUnit)}`);
+    }
+    if (a.parentScopeId !== b.parentScopeId) {
+        differing.push(`parentScopeId ${b.parentScopeId ?? "(none)"} vs. ${a.parentScopeId ?? "(none)"}`);
+    }
+    if (a.sloc !== b.sloc) {
+        differing.push(`sloc ${String(b.sloc ?? "(none)")} vs. ${String(a.sloc ?? "(none)")}`);
+    }
+    return differing;
+}
+/**
+ * Dedupliziert nach `metricsScopeId` (erstes Vorkommen gewinnt, wie
+ * `aggregate()`, spec.md §16.10: doppelte Retrieval-Fragmente MUESSEN ueber
+ * `metrics_scope_id` dedupliziert werden) und meldet dabei jede
+ * WIDERSPRUECHLICHE Wiederholung als Verstoss: zwei gleiche Ids mit
+ * verschiedenen Werten sind keine harmlose Dublette, sondern ein Zeichen,
+ * dass die Ids nicht das identifizieren, was sie sollen.
+ *
+ * ACHTUNG FUER AUFRUFER — was `duplicatesDropped` bedeutet: eine
+ * Wiederholung mit ZUFAELLIG gleichen Werten ist von einer echten Dublette
+ * nicht zu unterscheiden und wird deshalb ohne Verstoss verworfen. Wer keine
+ * wiederholten Retrieval-Fragmente in der Eingabe hat — wer also einen ECHTEN
+ * Scope-Baum aggregiert, in dem jede Id genau einen Scope bezeichnen MUSS —
+ * fuer den ist jedes `duplicatesDropped > 0` verlorener Inhalt und muss als
+ * Fehler behandelt werden. Die Zahl steht deshalb in
+ * `ScopeTreeAggregateV1.duplicatesDropped`; sie zu ignorieren waere ein
+ * stilles Ueberspringen (E4). `scripts/complexity-report.mjs` bricht darauf
+ * ab.
+ */
+function resolveTree(nodes) {
+    const byId = new Map();
+    const deduped = [];
+    const duplicateConflicts = [];
+    let duplicatesDropped = 0;
+    for (const node of nodes) {
+        const existing = byId.get(node.metricsScopeId);
+        if (existing !== undefined) {
+            duplicatesDropped++;
+            const differing = differingFields(existing, node);
+            if (differing.length > 0) {
+                duplicateConflicts.push({
+                    code: "duplicate_scope_id",
+                    metricsScopeId: node.metricsScopeId,
+                    observed: node.inclusiveValue,
+                    limit: existing.inclusiveValue,
+                    detail: `metricsScopeId "${node.metricsScopeId}" appears more than once with differing ` +
+                        `${differing.length === 1 ? "field" : "fields"}: ` +
+                        `${differing.join(", ")}. The ID therefore does not identify exactly one scope; ` +
+                        `a total over this set would be meaningless.`,
+                });
+            }
+            continue;
+        }
+        byId.set(node.metricsScopeId, node);
+        deduped.push(node);
+    }
+    deduped.sort((a, b) => compareCodepoints(a.metricsScopeId, b.metricsScopeId));
+    const childrenByParent = new Map();
+    for (const node of deduped) {
+        if (node.parentScopeId === undefined)
+            continue;
+        const siblings = childrenByParent.get(node.parentScopeId) ?? [];
+        siblings.push(node);
+        childrenByParent.set(node.parentScopeId, siblings);
+    }
+    return { nodes: deduped, byId, childrenByParent, duplicatesDropped, duplicateConflicts };
+}
+/** True, wenn `node` in einer Elternkette liegt, die sich schliesst oder ins Leere laeuft. */
+function ancestryProblem(node, byId) {
+    const seen = new Set([node.metricsScopeId]);
+    let current = node;
+    for (;;) {
+        const parentId = current.parentScopeId;
+        if (parentId === undefined)
+            return null;
+        if (seen.has(parentId))
+            return "cycle";
+        const parent = byId.get(parentId);
+        if (parent === undefined)
+            return "unknown_parent";
+        seen.add(parentId);
+        current = parent;
+    }
+}
+/**
+ * Prueft alle Invarianten des Scope-Baums und liefert JEDEN Verstoss mit
+ * Begruendung. Leere Liste heisst: der Baum traegt eine sinnvolle Summe.
+ *
+ * Geprueft wird:
+ * 1. `duplicate_scope_id` — dieselbe Id mit abweichenden Werten.
+ * 2. `unknown_parent` — `parentScopeId` zeigt auf einen Scope, der nicht in
+ *    der Menge ist. Ihn stillschweigend als Wurzel zu behandeln waere ein
+ *    E4-Verstoss: der Elternwert, gegen den geprueft werden muesste, fehlt.
+ * 3. `parent_cycle` — die Elternkette schliesst sich.
+ * 4. `negative_value` — negative Metrikwerte.
+ * 5. `self_exceeds_inclusive` — der Eigenanteil ist groesser als der Wert
+ *    mit Nachfahren. Der Eigenanteil ist per Definition ein Teil davon.
+ * 6. `children_exceed_parent` — der Eigenanteil eines Scopes plus die Summe
+ *    seiner direkten Kinder darf seinen eigenen Wert nicht ueberschreiten.
+ *
+ *    WAS DIESE PRUEFUNG LEISTET UND WAS NICHT — sie ist eine EINSEITIGE
+ *    Schranke (`self + Summe Kinder <= inclusive`) und darf deshalb nicht als
+ *    Doppelzaehlungspruefung gelesen werden:
+ *    - Sie schlaegt an, wenn der Elternwert ZU KLEIN ist, dem Elternwert
+ *      also Inhalt seiner Kinder FEHLT (oder ein Kindwert zu gross ist).
+ *      Ein Verstoss heisst: der Baum verliert Inhalt, nicht: er zaehlt
+ *      doppelt.
+ *    - Sie schlaegt NICHT an, wenn der Elternwert ZU GROSS ist — genau der
+ *      Fall, in dem ein Kindbeitrag zweimal im Elternwert steckt. Ein
+ *      aufgeblaehter `inclusiveValue` ist aus Werten allein nicht von einem
+ *      Scope zu unterscheiden, der im eigenen Koerper viel Kontrollfluss
+ *      traegt.
+ *
+ *    Die Zusicherung "jeder Beitrag zaehlt genau einmal" leistet
+ *    `checkScopeCoverage` auf der Struktur der jeweiligen Lesart, nicht
+ *    diese Wertschranke.
+ * 7. `leaf_self_differs_from_inclusive` — ein Scope ohne Kinder hat keine
+ *    Nachfahren, sein Eigenanteil MUSS also sein Gesamtwert sein. Weicht er
+ *    ab, hat der Aufrufer die beiden Werte nicht aus demselben Scope
+ *    berechnet.
+ *
+ * NICHT geprueft (und mit Absicht hier benannt statt verschwiegen): ein zu
+ * grosser `inclusiveValue` eines Scopes MIT Kindern. Siehe Punkt 6 und die
+ * Modul-Doku, Abschnitt "Woraus die Doppelzaehlungsfreiheit tatsaechlich
+ * folgt".
+ *
+ * Alle Wertvergleiche laufen auf `wert - perScopeBase` (siehe
+ * `ScopeTreeOptions.perScopeBase`).
+ */
+export function checkScopeTreeInvariants(nodes, options = {}) {
+    const perScopeBase = options.perScopeBase ?? 0;
+    const epsilon = options.epsilon ?? 1e-9;
+    const tree = resolveTree(nodes);
+    const violations = [...tree.duplicateConflicts];
+    for (const node of tree.nodes) {
+        if (node.inclusiveValue < 0 || node.selfValue < 0) {
+            violations.push({
+                code: "negative_value",
+                metricsScopeId: node.metricsScopeId,
+                observed: Math.min(node.inclusiveValue, node.selfValue),
+                limit: 0,
+                detail: `Scope "${node.metricsScopeId}" has a negative metric value ` +
+                    `(inclusive ${String(node.inclusiveValue)}, self ${String(node.selfValue)}). ` +
+                    `Complexity metrics are non-negative.`,
+            });
+        }
+        const problem = ancestryProblem(node, tree.byId);
+        if (problem === "unknown_parent") {
+            violations.push({
+                code: "unknown_parent",
+                metricsScopeId: node.metricsScopeId,
+                observed: 0,
+                limit: 0,
+                detail: `Scope "${node.metricsScopeId}" references a scope through its parent chain ` +
+                    `that is absent from the set. It is not treated as a root: without the parent value, ` +
+                    `we cannot determine whether its contribution is already included there (E4).`,
+            });
+        }
+        else if (problem === "cycle") {
+            violations.push({
+                code: "parent_cycle",
+                metricsScopeId: node.metricsScopeId,
+                observed: 0,
+                limit: 0,
+                detail: `The parent chain of scope "${node.metricsScopeId}" closes a cycle. ` +
+                    `A scope tree with a cycle has no root or well-defined total.`,
+            });
+        }
+        const inclusive = node.inclusiveValue - perScopeBase;
+        const own = node.selfValue - perScopeBase;
+        if (own > inclusive + epsilon) {
+            violations.push({
+                code: "self_exceeds_inclusive",
+                metricsScopeId: node.metricsScopeId,
+                observed: own,
+                limit: inclusive,
+                detail: `Scope "${node.metricsScopeId}": self contribution ${String(node.selfValue)} exceeds ` +
+                    `the inclusive value ${String(node.inclusiveValue)}. The self contribution is part ` +
+                    `of the total and cannot exceed it.`,
+            });
+        }
+        const children = tree.childrenByParent.get(node.metricsScopeId) ?? [];
+        if (children.length === 0) {
+            if (Math.abs(node.inclusiveValue - node.selfValue) > epsilon) {
+                violations.push({
+                    code: "leaf_self_differs_from_inclusive",
+                    metricsScopeId: node.metricsScopeId,
+                    observed: node.selfValue,
+                    limit: node.inclusiveValue,
+                    detail: `Scope "${node.metricsScopeId}" has no child scopes, but its self contribution ` +
+                        `${String(node.selfValue)} differs from the inclusive value ${String(node.inclusiveValue)}. ` +
+                        `Without descendants, both values must be identical.`,
+                });
+            }
+            continue;
+        }
+        const childrenSum = children.reduce((sum, child) => sum + (child.inclusiveValue - perScopeBase), 0);
+        if (own + childrenSum > inclusive + epsilon) {
+            const childList = children
+                .map((child) => `${child.metricsScopeId}=${String(child.inclusiveValue)}`)
+                .join(", ");
+            violations.push({
+                code: "children_exceed_parent",
+                metricsScopeId: node.metricsScopeId,
+                observed: own + childrenSum,
+                limit: inclusive,
+                detail: `Scope "${node.metricsScopeId}": self contribution ${String(own)} plus the sum of ` +
+                    `${String(children.length)} direct children ${String(childrenSum)} equals ` +
+                    `${String(own + childrenSum)} and exceeds the parent value ${String(inclusive)} ` +
+                    `(values after subtracting perScopeBase=${String(perScopeBase)}). Children: ${childList}. ` +
+                    `The parent value is missing child content, or a child value is too large; ` +
+                    `a root total would be too small. This one-sided bound cannot detect ` +
+                    `a parent value that is too large; checkScopeCoverage checks that separately.`,
+            });
+        }
+    }
+    violations.sort((a, b) => compareCodepoints(a.metricsScopeId, b.metricsScopeId) || compareCodepoints(a.code, b.code));
+    return violations;
+}
+/**
+ * Wirft bei jedem Invariantenverstoss. Die Meldung nennt Anzahl und die
+ * ersten Verstoesse im Klartext; `context.violations` traegt die volle Liste.
+ *
+ * Geprueft wird in ZWEI Stufen: erst die Wert- und Bauminvarianten
+ * (`checkScopeTreeInvariants`), danach — nur wenn der Baum ueberhaupt
+ * wohlgeformt ist — die strukturelle Zaehlpruefung ueber alle drei Lesarten
+ * (`checkAllScopeCoverage`). Erst beide zusammen tragen die Aussage, dass die
+ * ausgegebenen Summen jeden Scope genau einmal enthalten; die Wertschranke
+ * allein taete es nicht (siehe Punkt 6 oben).
+ */
+export function assertScopeTreeInvariants(nodes, options = {}) {
+    const treeViolations = checkScopeTreeInvariants(nodes, options);
+    const violations = treeViolations.length > 0 ? treeViolations : checkAllScopeCoverage(nodes);
+    if (violations.length === 0)
+        return;
+    const preview = violations
+        .slice(0, 3)
+        .map((violation) => `${violation.code}: ${violation.detail}`)
+        .join(" | ");
+    throw new UntangleError("ANALYSIS_INCOMPLETE", `scope tree invariants violated (${String(violations.length)} violation(s)): ${preview}`, { operation: "complexity.aggregateScopeTree", context: { violations } });
+}
+/**
+ * Liefert genau die Eintraege, die eine Lesart zaehlt — jeder Scope hoechstens
+ * einmal, jeweils mit dem fuer die Lesart richtigen Wert. Das Ergebnis geht
+ * unveraendert in `aggregate()`; damit gelten count/mean/median/p90/p95/max/
+ * Schwellenzaehlung (spec.md §16.10) auf einer doppelzaehlungsfreien Basis.
+ *
+ * Prueft KEINE Invarianten — dafuer ist `checkScopeTreeInvariants` da. Ein
+ * `unknown_parent` wird hier zwangslaeufig wie eine Wurzel behandelt; genau
+ * deshalb meldet die Pruefung ihn als Fehler, statt ihn zu tolerieren.
+ */
+export function selectScopeEntries(nodes, reading) {
+    const tree = resolveTree(nodes);
+    const selection = selectionFor(tree, reading);
+    const entries = [];
+    for (const node of tree.nodes) {
+        const kind = selection.get(node.metricsScopeId);
+        if (kind === undefined)
+            continue;
+        const entry = {
+            metricsScopeId: node.metricsScopeId,
+            value: kind === "inclusive" ? node.inclusiveValue : node.selfValue,
+        };
+        if (node.sloc !== undefined)
+            entry.sloc = node.sloc;
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Die Auswahl einer Lesart. Einzige Quelle der Wahrheit fuer
+ * `selectScopeEntries` UND `checkScopeCoverage`: die Pruefung soll dieselbe
+ * Auswahl sehen, die auch summiert wird, sonst prueft sie etwas anderes als
+ * das, was ausgegeben wird.
+ */
+export function selectionForReading(nodes, reading) {
+    return selectionFor(resolveTree(nodes), reading);
+}
+function selectionFor(tree, reading) {
+    const selection = new Map();
+    for (const node of tree.nodes) {
+        switch (reading) {
+            case "self":
+                selection.set(node.metricsScopeId, "self");
+                break;
+            case "top_level":
+                if (node.parentScopeId === undefined || !tree.byId.has(node.parentScopeId)) {
+                    selection.set(node.metricsScopeId, "inclusive");
+                }
+                break;
+            case "execution_unit":
+                // Ein Scope MIT umschliessender Ausfuehrungseinheit ist bereits in
+                // deren `inclusiveValue` enthalten und darf nicht erneut zaehlen.
+                if (enclosingExecutionUnit(node, tree.byId) === null) {
+                    selection.set(node.metricsScopeId, node.executionUnit ? "inclusive" : "self");
+                }
+                break;
+        }
+    }
+    return selection;
+}
+/**
+ * Prueft STRUKTURELL, dass eine Lesart jeden Scope genau einmal zaehlt — die
+ * Zusicherung, die `children_exceed_parent` NICHT leisten kann (siehe die
+ * Modul-Doku, Abschnitt "Woraus die Doppelzaehlungsfreiheit tatsaechlich
+ * folgt", und Punkt 6 von `checkScopeTreeInvariants`).
+ *
+ * Fuer jeden Scope wird gezaehlt, wie viele Summanden der Lesart seinen
+ * Beitrag tragen: er selbst, falls er ausgewaehlt ist, plus jeder echte
+ * Vorfahre, der mit `inclusiveValue` ausgewaehlt ist (dessen Summand deckt
+ * den ganzen Teilbaum ab). Genau EINER muss es sein.
+ *
+ * Was die Pruefung NICHT leisten kann: sie sieht die Struktur, nicht die
+ * Werte. Ein `inclusiveValue`, der den Beitrag eines Kindes intern doppelt
+ * enthaelt, ist aus Zahlen allein nicht erkennbar — dafuer haftet der
+ * Aufrufer, der die Werte berechnet hat.
+ */
+export function checkScopeCoverage(nodes, reading) {
+    return checkSelectionCoverage(nodes, selectionForReading(nodes, reading), reading);
+}
+/**
+ * Dieselbe Zaehlpruefung wie `checkScopeCoverage`, aber gegen eine BELIEBIGE
+ * Auswahl. Sie ist der eigentliche Kern; `checkScopeCoverage` ist nur die
+ * Anwendung auf die Auswahl, die eine der drei Lesarten trifft.
+ *
+ * Getrennt exportiert, weil die Zusicherung sonst nicht vorfuehrbar waere:
+ * die Auswahlen der drei Lesarten koennen `scope_counted_twice` per
+ * Konstruktion nicht ausloesen (dort ist ein Scope ausgewaehlt GENAU DANN,
+ * wenn er keinen ausgewaehlten `inclusive`-Vorfahren hat). Eine Pruefung,
+ * deren Alarmfall ueber die oeffentliche Schnittstelle nicht erreichbar ist,
+ * waere eine Behauptung statt einer Pruefung — mit dieser Funktion laesst er
+ * sich zeigen, und der Waechter greift, sobald jemand `selectionFor` aendert.
+ *
+ * @param label Erscheint im Detailtext an der Stelle der Lesart.
+ */
+export function checkSelectionCoverage(nodes, selection, label) {
+    const tree = resolveTree(nodes);
+    const violations = [];
+    for (const node of tree.nodes) {
+        const carriers = [];
+        if (selection.has(node.metricsScopeId))
+            carriers.push(node.metricsScopeId);
+        const seen = new Set([node.metricsScopeId]);
+        let parentId = node.parentScopeId;
+        while (parentId !== undefined && !seen.has(parentId)) {
+            seen.add(parentId);
+            const parent = tree.byId.get(parentId);
+            if (parent === undefined)
+                break;
+            if (selection.get(parentId) === "inclusive")
+                carriers.push(parentId);
+            parentId = parent.parentScopeId;
+        }
+        if (carriers.length === 1)
+            continue;
+        if (carriers.length > 1) {
+            violations.push({
+                code: "scope_counted_twice",
+                metricsScopeId: node.metricsScopeId,
+                observed: carriers.length,
+                limit: 1,
+                detail: `Selection "${label}": the contribution of scope "${node.metricsScopeId}" appears in ` +
+                    `${String(carriers.length)} contributing terms simultaneously (${carriers.join(", ")}). ` +
+                    `The total counts the same source text more than once.`,
+            });
+            continue;
+        }
+        violations.push({
+            code: "scope_uncounted",
+            metricsScopeId: node.metricsScopeId,
+            observed: 0,
+            limit: 1,
+            detail: `Selection "${label}": the contribution of scope "${node.metricsScopeId}" belongs to no ` +
+                `contributing term. Its content is lost from the total without a replacement; ` +
+                `silently losing content is forbidden by E4.`,
+        });
+    }
+    violations.sort((a, b) => compareCodepoints(a.metricsScopeId, b.metricsScopeId) || compareCodepoints(a.code, b.code));
+    return violations;
+}
+/**
+ * `checkScopeCoverage` fuer ALLE drei Lesarten, Verstoesse deterministisch
+ * nach Lesart und Scope sortiert.
+ */
+export function checkAllScopeCoverage(nodes) {
+    return SCOPE_SUM_READINGS.flatMap((reading) => checkScopeCoverage(nodes, reading));
+}
+/** Naechster Vorfahre, der Ausfuehrungseinheit ist; `null`, wenn es keinen gibt. */
+function enclosingExecutionUnit(node, byId) {
+    const seen = new Set([node.metricsScopeId]);
+    let parentId = node.parentScopeId;
+    while (parentId !== undefined && !seen.has(parentId)) {
+        seen.add(parentId);
+        const parent = byId.get(parentId);
+        if (parent === undefined)
+            return null;
+        if (parent.executionUnit)
+            return parent;
+        parentId = parent.parentScopeId;
+    }
+    return null;
+}
+/**
+ * Summiert einen Scope-Baum in allen drei Lesarten, ohne Doppelzaehlung.
+ *
+ * WIRFT bei jedem Invariantenverstoss (`UntangleError`, Code
+ * `ANALYSIS_INCOMPLETE`): eine Summe ueber einen widerspruechlichen Baum ist
+ * keine Zahl mit Bedeutung, und ein Hinweis waere hier zu wenig. Wer die
+ * Verstoesse anzeigen statt abbrechen will, ruft vorher
+ * `checkScopeTreeInvariants` auf.
+ */
+export function aggregateScopeTree(nodes, options = {}) {
+    assertScopeTreeInvariants(nodes, options);
+    const tree = resolveTree(nodes);
+    const sumOf = (reading) => selectScopeEntries(nodes, reading).reduce((sum, entry) => sum + entry.value, 0);
+    let rootCount = 0;
+    let executionUnitRootCount = 0;
+    let leafCount = 0;
+    let naiveSum = 0;
+    let leafOnlySum = 0;
+    for (const node of tree.nodes) {
+        naiveSum += node.inclusiveValue;
+        if (node.parentScopeId === undefined)
+            rootCount++;
+        if (node.executionUnit && enclosingExecutionUnit(node, tree.byId) === null) {
+            executionUnitRootCount++;
+        }
+        if ((tree.childrenByParent.get(node.metricsScopeId) ?? []).length === 0) {
+            leafCount++;
+            leafOnlySum += node.inclusiveValue;
+        }
+    }
+    const topLevelSum = sumOf("top_level");
+    const selfSum = sumOf("self");
+    return {
+        scopeCount: tree.nodes.length,
+        duplicatesDropped: tree.duplicatesDropped,
+        rootCount,
+        executionUnitRootCount,
+        leafCount,
+        topLevelSum,
+        executionUnitSum: sumOf("execution_unit"),
+        selfSum,
+        naiveSum,
+        doubleCountedAmount: naiveSum - topLevelSum,
+        leafOnlySum,
+        leafOnlyDroppedAmount: selfSum - leafOnlySum,
+    };
+}
+//# sourceMappingURL=scope-aggregate.js.map

package/dist/scope-aggregate.js.map

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