@sigloch/contracts 6.3.0 → 9.1.0

package/dist/se/rules.js

@@ -5,7 +5,7 @@
  */
 import { z } from 'zod/v4';
 import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
-import { isValidTrace } from './meta-model.js';
+import { isValidTrace, BOUNDED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
 export const RuleSeverity = z.enum(['error', 'warning', 'info']);
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
@@ -333,8 +333,9 @@ function testMustVerifyReq(graph) {
 // ---------------------------------------------------------------------------
 function traceConsistency(graph) {
     const idx = indexOf(graph);
+    // CR-SM-266 D5: kein `category !== 'audit'`-Filter mehr — das Attribut ist weg, und mit ihm
+    // die Moeglichkeit, eine Kante per Selbstauskunft aus der Referenzintegritaet zu nehmen.
     return graph.traces
-        .filter(t => t.category !== 'audit')
         .filter(t => {
         const sourceExists = idx.byId.has(t.source);
         const targetExists = idx.byId.has(t.target);
@@ -361,7 +362,9 @@ function flowCompleteness(graph) {
     const idx = indexOf(graph);
     const flows = idx.elementsOfType('FLOW');
     // Producers/consumers of a FLOW are FUNCs or ACTORs (io endpoints on the
-    // upstream/downstream side); UC may consume too. Offer both as candidates.
+    // upstream/downstream side). CR-SM-266 D4: UC ist KEIN Konsument mehr — das Pattern
+    // `FLOW -io-> UC` ist entfallen, ein FLOW erreicht einen UC nur noch ueber ein Kettenglied.
+    // Der fix_hint hat den UC vorher noch angeboten und haette in eine R-18-Ablehnung gefuehrt.
     const sources = graph.elements.filter(e => e.type === 'FUNC' || e.type === 'ACTOR'); // Mehrtyp: ein Durchlauf ist hier billiger als vier Index-Listen zu mischen (Reihenfolge!)
     const io = idx.tracesOfType('io');
     const violations = [];
@@ -383,7 +386,7 @@ function flowCompleteness(graph) {
                 severity: 'warning',
                 element_id: f.id,
                 message: `${f.id} has no consumer (outgoing io)`,
-                fix_hint: 'Link a FUNC, ACTOR, or UC as the target via io trace',
+                fix_hint: 'Link a FUNC or ACTOR as the target via io trace',
                 context: ctx,
             });
         }
@@ -721,23 +724,72 @@ function validTracePattern(graph) {
     const idx = indexOf(graph);
     // CR-SM-264: die Typ-Map kommt aus dem Index statt je Aufruf neu gebaut zu werden.
     const typeById = { get: (id) => idx.typeOf(id) };
+    // CR-SM-266 D5: der `category !== 'audit'`-Filter ist WEG. Er war die Ausnahme fuer das
+    // einzige audit-Pattern (`SESSION -produces-> *`); mit dessen Entfernung waere er zum
+    // Schlupfloch geworden — eine Kante mit `category: 'audit'` haette die Matrix komplett
+    // umgangen. Das Attribut existiert nicht mehr (ontology.ts), hier faellt der Leser mit.
     return graph.traces
-        .filter(t => t.category !== 'audit')
         .filter(t => {
         const src = typeById.get(t.source);
         const tgt = typeById.get(t.target);
         if (!src || !tgt)
             return false; // dangling endpoint → R-08, not R-18
-        return !isValidTrace({ source: src, target: tgt, type: t.type, label: t.label });
+        // CR-SM-266 B: die where-Patterns lesen die Kinds des betroffenen Endes mit.
+        return !isValidTrace({
+            source: src, target: tgt, type: t.type, label: t.label,
+            sourceKinds: idx.byId.get(t.source)?.kinds,
+            targetKinds: idx.byId.get(t.target)?.kinds,
+        });
     })
-        .map(t => ({
+        .map((t) => ({
         rule_id: 'R-18',
         severity: 'error',
         element_id: t.source,
         message: `Invalid trace ${t.source} -${t.type}-> ${t.target}: ` +
             `${typeById.get(t.source)} → ${typeById.get(t.target)} is not a valid ${t.type} pattern`,
         fix_hint: 'Use a trace type whose TRACE_PATTERNS allows this source/target element-type pair',
-    }));
+    }))
+        .concat(cardinalityViolations(graph));
+}
+/**
+ * CR-SM-266b — das ZWEITE BEIN von R-18: die Kardinalitaets-Obergrenzen.
+ *
+ * Bewusst dieselbe `rule_id` und keine eigene, nach dem Muster von R-10 (Produzent/Konsument)
+ * und R-15 seit CR-SM-249: die Aussage ist dieselbe — "diese Kante ist nach dem Meta-Modell
+ * nicht zulaessig" —, nur ist die Bedingung hier eine ueber die MENGE statt ueber das Paar.
+ * Eine eigene ID kostete dauerhaft einen Nenner-Anteil, eine Katalogzeile, eine
+ * readiness-Zuordnung und einen Golden-File-Eintrag (Gate 6), und ein Leser muesste sie von
+ * R-18 unterscheiden, obwohl der naechste Schritt derselbe ist: Kante weg.
+ *
+ * EIN Befund je Quellknoten, nicht je ueberzaehliger Kante. Bei n Allokationen sind nicht
+ * n-1 Kanten "falsch" — es ist EINE Entscheidung offen (welches Modul), und n-1 Befunde
+ * wuerden den Zaehler ueber den Nenner-Beitrag treiben, die Fehlmessung aus CR-SM-242.
+ */
+function cardinalityViolations(graph) {
+    const idx = indexOf(graph);
+    const violations = [];
+    for (const p of BOUNDED_PATTERNS) {
+        const max = maxOccurs(p.cardinality);
+        for (const el of idx.elementsOfType(p.source)) {
+            const matching = idx.out(el.id, p.type).filter(t => idx.typeOf(t.target) === p.target);
+            if (matching.length <= max)
+                continue;
+            violations.push({
+                rule_id: 'R-18',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} has ${matching.length} ${p.type} traces to ${p.target} — ` +
+                    `the meta-model allows at most ${max} (${matching.map(t => t.target).join(', ')})`,
+                fix_hint: `Keep exactly one ${p.type} trace from ${el.id} to a ${p.target} and delete the others`,
+                context: {
+                    element_type: el.type,
+                    element_name: el.name,
+                    existing_traces: matching.map(t => ({ source: t.source, target: t.target, type: t.type })),
+                },
+            });
+        }
+    }
+    return violations;
 }
 // ---------------------------------------------------------------------------
 // R-19: Runnable TEST binding (CR-GC-205 Item 4) — a TEST that is not explicitly

package/dist/se/uc-quality-rules.js

@@ -32,26 +32,45 @@ export function uc02HasActor(graph) {
     // ueber Elemente und Traces), dann je UC nur noch Mitgliedschaft pruefen. Dieselbe Aussage,
     // dieselben Befunde in derselben Reihenfolge — die Iteration ueber `graph.elements` bleibt
     // die aeussere Schleife.
+    // CR-SM-266 D1/D4: die Regel prueft ERREICHBARKEIT statt Adjazenz.
+    //
+    // Bis hierher suchte sie einen io-Ziel-Treffer direkt am UC oder an dessen compose-Kind —
+    // also genau die beiden Kanten `ACTOR -io-> UC` und (ueber die FCHAIN) den Direktweg. Beide
+    // Patterns sind mit D1/D4 entfallen; die Regel waere damit UNERFUELLBAR geworden: sie haette
+    // einen Zustand verlangt, den R-18 im selben Lauf als ungueltige Kante ablehnt — der
+    // gegenlaeufige Fall aus Gate 4 des Grammatik-Reviews, und fuer den Nutzer eine Sackgasse
+    // statt eines Fehlers.
+    //
+    // Der tragende Pfad ist jetzt der einzige: `ACTOR -io-> FLOW -io-> FUNC`, FUNC in einer
+    // FCHAIN des UC. Zwei Sprungweiten (Actor→FLOW, FLOW→FUNC), danach Mengen-Mitgliedschaft —
+    // die CR-SM-261-Optimierung bleibt damit erhalten (kein Scan je UC, alles ueber den Index
+    // aus CR-SM-264), und die Iteration ueber `elementsOfType('UC')` bleibt die aeussere
+    // Schleife, also ist die Befundreihenfolge weiter die Graph-Reihenfolge (Gate 5).
     const idx = indexOf(graph);
     const actorIds = idx.idsOfType('ACTOR');
-    const actorIoTargets = new Set(idx.tracesOfType('io').filter(t => actorIds.has(t.source)).map(t => t.target));
-    const composeTargets = new Map();
-    for (const t of idx.tracesOfType('compose')) {
-        const list = composeTargets.get(t.source);
-        if (list)
-            list.push(t.target);
-        else
-            composeTargets.set(t.source, [t.target]);
+    // Schritt 1: die FLOWs, die ein ACTOR speist.
+    const actorFlows = new Set(idx.tracesOfType('io').filter(t => actorIds.has(t.source)).map(t => t.target));
+    // Schritt 2: die FUNCs, die an einem solchen FLOW haengen — in BEIDE Richtungen. Ein UC ist
+    // auch dann an einen Actor angebunden, wenn die Kette IHM etwas liefert (FUNC -io-> FLOW
+    // -io-> ACTOR), nicht nur wenn sie von ihm getriggert wird. Die alte Fassung sah nur die
+    // Trigger-Richtung, weil `ACTOR -io-> UC` nur so herum existierte.
+    const actorFacingFuncs = new Set();
+    for (const t of idx.tracesOfType('io')) {
+        if (actorFlows.has(t.source))
+            actorFacingFuncs.add(t.target);
+        if (actorIds.has(t.target) && idx.typeOf(t.source) === 'FLOW') {
+            for (const producer of idx.in(t.source, 'io'))
+                actorFacingFuncs.add(producer.source);
+        }
     }
     return idx.elementsOfType('UC')
-        .filter(uc => !actorIoTargets.has(uc.id) &&
-        !(composeTargets.get(uc.id) ?? []).some(target => actorIoTargets.has(target)))
+        .filter(uc => !idx.out(uc.id, 'compose').some(chain => idx.out(chain.target, 'compose').some(member => actorFacingFuncs.has(member.target))))
         .map(uc => ({
         rule_id: 'UC-02',
         severity: 'error',
         element_id: uc.id,
-        message: `${uc.id} has no ACTOR with io trace`,
-        fix_hint: 'Link an ACTOR via io trace to this UC or its FCHAIN',
+        message: `${uc.id} is not reachable from any ACTOR`,
+        fix_hint: 'Wire an ACTOR to a FLOW that feeds (or is fed by) a FUNC in one of this UC\'s function chains',
         context: { element_type: uc.type, element_name: uc.name },
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/contracts",
-  "version": "6.3.0",
+  "version": "9.1.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",