@sigloch/contracts 6.1.0 → 9.1.0

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

@@ -1,10 +1,13 @@
+import { indexOf } from './graph-index.js';
 // ---------------------------------------------------------------------------
 // UC-01: UC must have compose→REQ trace (CR-165: satisfy UC→REQ is invalid per meta-model)
 // ---------------------------------------------------------------------------
 export function uc01HasRequirements(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' && graph.elements.some(e => e.id === t.target && e.type === 'REQ')))
+    // CR-SM-264: compose-Kanten je UC aus dem Index. Vorher ein Vollscan ueber alle Traces je UC,
+    // darin ein Vollscan ueber alle Elemente je Treffer — `UC x T x E`.
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => idx.typeOf(t.target) === 'REQ'))
         .map(uc => ({
         rule_id: 'UC-01',
         severity: 'error',
@@ -18,20 +21,56 @@ export function uc01HasRequirements(graph) {
 // UC-02: UC FCHAIN must have an ACTOR with io trace
 // ---------------------------------------------------------------------------
 export function uc02HasActor(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => {
-        // Check if any ACTOR has io trace to this UC or to a FCHAIN/FLOW in this UC
-        return !graph.traces.some(t => t.type === 'io' &&
-            graph.elements.some(e => e.id === t.source && e.type === 'ACTOR') &&
-            (t.target === uc.id || graph.traces.some(ct => ct.source === uc.id && ct.type === 'compose' && ct.target === t.target)));
-    })
+    // CR-SM-261: dieselbe Frage, einmal statt je UC neu.
+    //
+    // Die alte Fassung scannte je UC alle Traces, darin je io-Trace alle ELEMENTE (die
+    // ACTOR-Suche) und noch einmal alle Traces (die compose-Suche) — `UC × T × (E + T)`. Das
+    // Profil aus CR-SM-260 hat sie mit 50,8 % des gesamten Regellaufs und einem Wachstum von
+    // n^3,05 gemessen, kubisch statt quadratisch und damit die teuerste Regel des Katalogs.
+    //
+    // Die Umkehrung: erst die Menge der io-Ziele bilden, die von einem ACTOR ausgehen (einmal
+    // 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');
+    // 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 => !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 },
     }));
 }
@@ -39,10 +78,9 @@ export function uc02HasActor(graph) {
 // UC-03: UC must have compose→FCHAIN (scenario)
 // ---------------------------------------------------------------------------
 export function uc03HasScenario(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'FCHAIN')))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => idx.typeOf(t.target) === 'FCHAIN'))
         .map(uc => ({
         rule_id: 'UC-03',
         severity: 'warning',
@@ -77,10 +115,12 @@ export function uc04GoalDefined(graph) {
 // UC-05: UC should have postcondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
 // ---------------------------------------------------------------------------
 export function uc05HasPostcondition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'REQ' && e.kinds?.includes('postcondition'))))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
+        const target = idx.byId.get(t.target);
+        return target?.type === 'REQ' && target.kinds?.includes('postcondition');
+    }))
         .map(uc => ({
         rule_id: 'UC-05',
         severity: 'info',
@@ -94,10 +134,12 @@ export function uc05HasPostcondition(graph) {
 // UC-06: UC should have precondition REQ (CR-165: compose only, satisfy UC→REQ invalid)
 // ---------------------------------------------------------------------------
 export function uc06HasPrecondition(graph) {
-    return graph.elements
-        .filter(e => e.type === 'UC')
-        .filter(uc => !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
-        graph.elements.some(e => e.id === t.target && e.type === 'REQ' && e.kinds?.includes('precondition'))))
+    const idx = indexOf(graph);
+    return idx.elementsOfType('UC')
+        .filter(uc => !idx.out(uc.id, 'compose').some(t => {
+        const target = idx.byId.get(t.target);
+        return target?.type === 'REQ' && target.kinds?.includes('precondition');
+    }))
         .map(uc => ({
         rule_id: 'UC-06',
         severity: 'info',

package/package.json

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