@sigloch/contracts 10.10.0 → 10.13.0

package/dist/se/fchain-quality-rules.d.ts

@@ -1,5 +1,5 @@
 /**
- * FC-01..FC-03 — FCHAIN quality rules (CR-121 Phase 1).
+ * FC-02..FC-05 — FCHAIN quality rules (CR-121 Phase 1; FC-05 CR-SM-363).
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
@@ -7,5 +7,6 @@ import type { MetricPolicy } from './policy.js';
 export declare function fc02LeafUcHasFchain(graph: OntologyGraph): RuleViolation[];
 export declare function fc03FchainFlat(graph: OntologyGraph): RuleViolation[];
 export declare function fc04ActorBounded(graph: OntologyGraph): RuleViolation[];
+export declare function fc05ChainConnected(graph: OntologyGraph): RuleViolation[];
 export declare const FC_RULES: RuleDefinition[];
 export declare function evaluateFCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

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

@@ -96,6 +96,137 @@ export function fc04ActorBounded(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// FC-05: FCHAIN ist gerichtet zusammenhaengend (CR-SM-363).
+//
+// Eine FCHAIN ist grammatisch eine Menge (`FCHAIN -compose-> FUNC`); die Reihenfolge entsteht
+// erst aus Erzeuger -> Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Bilden die
+// Glieder darueber mehr als EINE (schwache) Komponente, beschreibt jede Kettenkennzahl etwas,
+// das es nicht gibt. IO-01 sieht das nicht: es verbindet zwei Glieder schon, wenn beide
+// denselben FLOW konsumieren. Gemessen (graphcode spike-kettenkennzahlen, 76 Ketten): 20
+// zerfallen ohne jede Regel.
+//
+// Je Nebenkomponente (alles ausser der groessten; Gleichstand nach kleinster ID — Gate 5) die
+// Ursache:
+//   - `missing-link`: Haupt- und Nebenteil sind ueber eine FUNC AUSSERHALB der Kette verbunden
+//     (Glied -> FLOW -> X -> FLOW -> Glied) — der verbindende Schritt gehoert in die Kette.
+//     Nur eine FUNC ist ein fehlendes Glied: ein Weg ueber einen ACTOR geht ueber die
+//     Systemgrenze, und einen ACTOR kann keine Kette aufnehmen.
+//   - `bag`: sonst — keine FUNC verbindet die Teile: ein fehlender FLOW zwischen Gliedern oder
+//     parallele Dienste an einer gemeinsamen Quelle (dann ist die Kette zu teilen).
+// Traegt die Kette ein Glied ohne io-Eingang oder -Ausgang, gehoert sie zuerst R-31 — FC-05
+// schweigt, bis alle Glieder verdrahtet sind (keine Doppelmeldung, s. u.). Eingang/Ausgang der Kette fragt FC-04 (streng: ACTOR) — eine Kette ohne
+// jeden Eingang hat auch keinen ACTOR-Eingang, FC-05 schweigt deshalb dazu (eine Ursache, ein
+// Befund). EIN Befund je Kette, die Komponenten im Kontext (CR-SM-242).
+// ---------------------------------------------------------------------------
+export function fc05ChainConnected(graph) {
+    const idx = indexOf(graph);
+    // Erzeuger/Verbraucher je FLOW — ueber alle Typen (FUNC oder ACTOR).
+    const producers = new Map();
+    const consumers = new Map();
+    const wiredIn = new Set();
+    const wiredOut = new Set();
+    for (const t of idx.tracesOfType('io')) {
+        if (idx.typeOf(t.target) === 'FLOW') {
+            (producers.get(t.target) ?? producers.set(t.target, []).get(t.target)).push(t.source);
+            wiredOut.add(t.source);
+        }
+        if (idx.typeOf(t.source) === 'FLOW') {
+            (consumers.get(t.source) ?? consumers.set(t.source, []).get(t.source)).push(t.target);
+            wiredIn.add(t.target);
+        }
+    }
+    const successors = new Map();
+    for (const [flow, ps] of producers) {
+        for (const p of ps) {
+            const set = successors.get(p) ?? successors.set(p, new Set()).get(p);
+            for (const c of consumers.get(flow) ?? [])
+                if (c !== p)
+                    set.add(c);
+        }
+    }
+    const succ = (id) => successors.get(id) ?? new Set();
+    const violations = [];
+    for (const fc of idx.elementsOfType('FCHAIN')) {
+        const members = [...new Set(idx.out(fc.id, 'compose').map(t => t.target).filter(id => idx.typeOf(id) === 'FUNC'))].sort();
+        if (members.length < 2)
+            continue;
+        // Ein Glied ohne io-Eingang oder -Ausgang ist R-31s Befund — und er kann genau die Bruecke
+        // sein, die fehlt. Solange eines da ist, urteilt FC-05 nicht (eine Ursache, ein Befund):
+        // gemessen an graphcode FCHAIN-capture, wo `FUNC-decode` ohne Ausgang sonst einen Sack vortaeuscht.
+        if (members.some(f => !wiredIn.has(f) || !wiredOut.has(f)))
+            continue;
+        const inChain = new Set(members);
+        // Schwache Komponenten ueber Glied -> Glied.
+        const adj = new Map(members.map(m => [m, new Set()]));
+        for (const a of members) {
+            for (const b of succ(a))
+                if (inChain.has(b)) {
+                    adj.get(a).add(b);
+                    adj.get(b).add(a);
+                }
+        }
+        const seen = new Set();
+        const comps = [];
+        for (const m of members) {
+            if (seen.has(m))
+                continue;
+            const comp = [m];
+            seen.add(m);
+            for (let i = 0; i < comp.length; i++) {
+                for (const n of adj.get(comp[i]))
+                    if (!seen.has(n)) {
+                        seen.add(n);
+                        comp.push(n);
+                    }
+            }
+            comps.push(comp.sort());
+        }
+        if (comps.length < 2)
+            continue;
+        comps.sort((a, b) => b.length - a.length || a[0].localeCompare(b[0]));
+        const main = new Set(comps[0]);
+        // Aussen-FUNCs X mit from -> X -> to.
+        const bridges = (from, to) => {
+            const via = new Set();
+            for (const a of from) {
+                for (const x of succ(a)) {
+                    if (inChain.has(x) || idx.typeOf(x) !== 'FUNC')
+                        continue;
+                    if ([...succ(x)].some(b => to.has(b)))
+                        via.add(x);
+                }
+            }
+            return [...via];
+        };
+        const side = [];
+        for (const comp of comps.slice(1)) {
+            const set = new Set(comp);
+            const via = [...new Set([...bridges(main, set), ...bridges(set, main)])].sort();
+            side.push({ members: comp, cause: via.length > 0 ? 'missing-link' : 'bag', via });
+        }
+        if (side.length === 0)
+            continue;
+        const missing = [...new Set(side.flatMap(c => c.via))].sort();
+        const hints = [];
+        if (missing.length > 0)
+            hints.push(`add the missing link(s) as members: ${missing.map(f => `\`${fc.id} -compose-> ${f}\``).join(', ')}`);
+        // `bag` sagt nur: KEINE Aussen-FUNC verbindet die Teile. Das ist entweder ein fehlender FLOW
+        // zwischen zwei Gliedern (gemessen: graphcode FCHAIN-generation-states, Uebergabe an
+        // graph_suggest nicht modelliert) oder ein Sack paralleler Dienste — der Hinweis nennt beides.
+        if (side.some(c => c.cause === 'bag'))
+            hints.push('connect the parts with a FLOW from a producer member to a consumer member if they are one chain of effects — otherwise split the chain, one FCHAIN per chain of effects');
+        violations.push({
+            rule_id: 'FC-05',
+            severity: 'warning',
+            element_id: fc.id,
+            message: `${fc.id} falls apart into ${comps.length} unconnected parts along producer -> consumer (${side.map(c => `${c.members.join('+')}: ${c.cause}`).join('; ')})`,
+            fix_hint: `Via graph_mutate Format-E, ${hints.join('; or ')}`,
+            context: { element_type: fc.type, element_name: fc.name, side_components: side },
+        });
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
 // Aggregated
 // ---------------------------------------------------------------------------
 export const FC_RULES = [
@@ -105,6 +236,7 @@ export const FC_RULES = [
     // eine Kette mit n verschachtelten FUNCs erzeugt n Verstoesse gegen einen Beitrag von 1.
     { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat, domain: ['FUNC'] },
     { id: 'FC-04', name: 'FCHAIN actor-bounded (trigger+consumer)', severity: 'warning', evaluate: fc04ActorBounded, domain: ['FCHAIN'] },
+    { id: 'FC-05', name: 'FCHAIN is connected (producer -> consumer)', severity: 'warning', evaluate: fc05ChainConnected, domain: ['FCHAIN'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
 // ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.

package/dist/se/fmea-rules.js

@@ -1,13 +1,16 @@
 /**
  * CR-182: FMEA/FTA Risk Rules + NFR Budget Overshoot Detection.
  * FM-01: Risk-REQ missing FMEA attributes (severity, occurrence, detection).
- * FM-02: Risk-REQ without mitigation (compose→REQ(kinds∋mitigation)).
+ * FM-02: Risk-REQ without mitigation (compose→REQ(role=mitigation)).
+ * CR-SM-365: "Risk-REQ" heisst `attributes.role === 'risk'` (Leser `readReqRole`), nicht mehr
+ *   `kinds ∋ risk` — die Rolle ist die Motivation der Anforderung, nicht ihre Art. Kein
+ *   zweiter Pfad ueber `kinds`: ein Altgraph faellt hier still, bis er migriert ist.
  * FM-03: risk REQ with Action Priority High and no passed verification.
  * NFR-01: measured exceeds budget for an NFR dimension. CR-228 splits the target
  *   by dimension nature: physical budgets (weight/power/cost) live on the part
  *   (MOD); behavioral budgets (timing/memory-throughput) on the FCHAIN/FUNC.
  */
-import { TestRefsSchema } from './ontology.js';
+import { readReqRole, readTestRefs } from './ontology.js';
 import { actionPriority, apMethod } from './action-priority.js';
 const PHYSICAL_BUDGET_PAIRS = [
     ['costBudget', 'measuredCost', 'cost'],
@@ -20,12 +23,19 @@ const BEHAVIORAL_BUDGET_PAIRS = [
 ];
 const PHYSICAL_BUDGET_TYPES = ['MOD'];
 const BEHAVIORAL_BUDGET_TYPES = ['FUNC', 'FCHAIN'];
+/** Traegt das Element die FMEA-Rolle `role`? Einziger Weg der FM-Regeln (CR-SM-365). */
+const hasRole = (e, role) => {
+    if (e.type !== 'REQ')
+        return false;
+    const r = readReqRole(e.attributes);
+    return r.state === 'bound' && r.value === role;
+};
 // ---------------------------------------------------------------------------
 // FM-01: Risk-REQ without FMEA attributes
 // ---------------------------------------------------------------------------
 export function fm01MissingFmeaAttributes(graph) {
     return graph.elements
-        .filter(e => e.type === 'REQ' && e.kinds?.includes('risk'))
+        .filter(e => hasRole(e, 'risk'))
         .filter(e => {
         const a = e.attributes ?? {};
         return a['severity'] == null || a['occurrence'] == null || a['detection'] == null;
@@ -52,20 +62,20 @@ export function fm01MissingFmeaAttributes(graph) {
 // FM-02: Risk-REQ without mitigation
 // ---------------------------------------------------------------------------
 export function fm02MissingMitigation(graph) {
-    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    const riskReqs = graph.elements.filter(e => hasRole(e, 'risk'));
     return riskReqs
         .filter(riskReq => {
-        // Check: compose trace from riskReq to a REQ with kinds∋mitigation
+        // Check: compose trace from riskReq to a REQ with role=mitigation
         return !graph.traces.some(t => t.source === riskReq.id &&
             t.type === 'compose' &&
-            graph.elements.some(el => el.id === t.target && el.type === 'REQ' && el.kinds?.includes('mitigation')));
+            graph.elements.some(el => el.id === t.target && hasRole(el, 'mitigation')));
     })
         .map(e => ({
         rule_id: 'FM-02',
         severity: 'warning',
         element_id: e.id,
-        message: `${e.id} is a risk REQ without a mitigation REQ (compose→REQ[mitigation])`,
-        fix_hint: 'Create a mitigation REQ and link via compose trace',
+        message: `${e.id} is a risk REQ without a mitigation REQ (compose→REQ[role=mitigation])`,
+        fix_hint: 'Create a REQ with attributes.role="mitigation" (kinds functional or non-functional) and link it via compose trace',
     }));
 }
 // ---------------------------------------------------------------------------
@@ -80,7 +90,7 @@ export function fm03HighRiskUnverified(graph, policy) {
     const threshold = policy.riskRpn;
     if (threshold === null)
         return [];
-    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    const riskReqs = graph.elements.filter(e => hasRole(e, 'risk'));
     return riskReqs
         .filter(riskReq => {
         const a = riskReq.attributes ?? {};
@@ -106,10 +116,10 @@ export function fm03HighRiskUnverified(graph, policy) {
             graph.elements.some(el => {
                 if (el.id !== t.source || el.type !== 'TEST')
                     return false;
-                const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
-                if (!parsed.success)
+                const parsed = readTestRefs(el.attributes);
+                if (parsed.state !== 'bound')
                     return false; // keine Bindung → keine Evidenz
-                return parsed.data.every(ref => ref.result === 'passed');
+                return parsed.value.every(ref => ref.result === 'passed');
             }));
         return !hasPassedTest;
     })

package/dist/se/function-criticality.d.ts

@@ -41,30 +41,16 @@
  *
  * @author andreas@siglochconsulting
  */
+import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
 /** Eine Zeile je FUNC — mit Schwelle oder ohne, wie `ModuleMetrics` je MOD (CR-SM-232). */
-export interface FunctionCriticality {
-    funcId: string;
-    funcName: string;
-    /**
-     * Wirkketten, die diese FUNC komponieren — R-30s Definition: direkte
-     * `FCHAIN -compose-> FUNC`-Kante, keine Vererbung ueber Vorfahren.
-     *
-     * `0` ist eine AUSSAGE, kein fehlender Wert: bei einem Blatt ist es R-30s Befund, bei einem
-     * zerlegten Block der von FC-03 erzwungene Normalzustand. Wer die beiden unterscheiden muss,
-     * fragt `decomposedFuncs()` — diese Datei tut es bewusst nicht (sie waere sonst an `rules.ts`
-     * gebunden und fuer `rules.ts` nicht mehr importierbar).
-     */
-    chains: number;
-    /**
-     * Use Cases, die ueber diese Ketten an der FUNC haengen (`UC -compose-> FCHAIN`).
-     *
-     * Nicht aus `chains` ableitbar und auch nicht dasselbe: eine FUNC in drei Ketten EINES Use
-     * Case ist etwas anderes als eine in drei Ketten dreier Use Cases. Gemessen an graphcode
-     * faellt die Zahl regelmaessig kleiner aus als `chains` (FUNC-mutate: 11 Ketten, 7 UCs).
-     */
-    useCases: number;
-}
+export declare const FunctionCriticality: z.ZodObject<{
+    funcId: z.ZodString;
+    funcName: z.ZodString;
+    chains: z.ZodNumber;
+    useCases: z.ZodNumber;
+}, z.core.$strip>;
+export type FunctionCriticality = z.infer<typeof FunctionCriticality>;
 /**
  * Kritikalitaet je FUNC, kritischste zuerst.
  *

package/dist/se/function-criticality.js

@@ -1,4 +1,72 @@
+/**
+ * CR-SM-314 — wie kritisch ist eine Funktion? Ketten und Use Cases, als ZAHL.
+ *
+ * Die Frage stammt aus dem Betrieb und hat drei Abnehmer, die bis hierher jeder fuer sich
+ * geraten haben: **Blast Radius** einer Aenderung, **Kritikalitaet** einer Funktion,
+ * **Rollout-Reihenfolge**. Alle drei fragen dasselbe: an wie vielen Wirkketten haengt dieses
+ * Stueck, und wie viele Use Cases stehen dahinter.
+ *
+ * ## Die Definition ist GELIEHEN, nicht neu
+ *
+ * "Eine FUNC ist in einer Kette" heisst hier woertlich, was R-30 darunter versteht: eine
+ * direkte `FCHAIN -compose-> FUNC`-Kante. Keine Vererbung ueber compose-Vorfahren.
+ *
+ * Der Rollup wurde GEMESSEN und VERWORFEN: ueber 17 Familiengraphen haetten Vorfahren-Ketten
+ * die Grundgesamtheit von 224 auf 227 FUNCs gehoben — drei Stueck. Er kauft nichts und waere
+ * eine ZWEITE Vorstellung davon, wozu eine Funktion gehoert, neben R-30s. Genau die Drift, gegen
+ * die `module-crossings.ts` gebaut wurde (CR-SM-276). Ein zerlegter Block misst deshalb 0, und
+ * das ist richtig: FC-03 verbietet ein Kettenglied mit verschachtelter Zerlegung, ein Block KANN
+ * die Kante gar nicht tragen.
+ *
+ * ## Diese Datei URTEILT NICHT
+ *
+ * Kein `infrastructure`-Flag, keine Schwelle, keine Severity. Ein Flag waere ein Urteil in der
+ * MESSUNG, und die Schwelle gehoert in `MetricPolicy` (`criticality.infrastructure`) — dieselbe
+ * Trennung, die `moduleMetrics` gegen MT-01/MT-02 haelt: die Zahl steht in jeder Zeile, ob eine
+ * Regel sie liest oder nicht.
+ *
+ * ## Warum sie nur `ontology` und `graph-index` importiert
+ *
+ * Damit `rules.ts` sie konsumieren darf. R-21 braucht dieselbe Kettenzahl fuer seine
+ * Infrastruktur-Ausnahme (CR-SM-313); rechnete die Regel sie selbst, haetten wir zwei
+ * Kettenbegriffe im selben Paket. EINE Rechnung, ZWEI Abnehmer — Vorbild `module-crossings.ts`,
+ * das aus demselben Grund keinen Regelcode importiert.
+ *
+ * ## Gemessen (17 Familiengraphen, 2026-09-12)
+ *
+ * 278 FUNCs liegen in mindestens einer Kette: 224 in genau einer, 37 in zwei, 6 in drei, 8 in
+ * vier, je eine in fuenf, sechs und elf. Ein duenner Schwanz ohne Plateau — aus der FORM dieser
+ * Verteilung ist keine Schwelle abzulesen (derselbe Befund wie bei `instability`, CR-SM-293).
+ * Ablesbar ist sie an ihrer WIRKUNG, und das steht bei `criticality` in der Policy.
+ *
+ * @author andreas@siglochconsulting
+ */
+import { z } from 'zod/v4';
 import { indexOf } from './graph-index.js';
+/** Eine Zeile je FUNC — mit Schwelle oder ohne, wie `ModuleMetrics` je MOD (CR-SM-232). */
+// CR-SM-361: ein Zod-Vertrag, kein Typ — `functionCriticality` prueft seine Ausgabe.
+export const FunctionCriticality = z.object({
+    funcId: z.string(),
+    funcName: z.string(),
+    /**
+     * Wirkketten, die diese FUNC komponieren — R-30s Definition: direkte
+     * `FCHAIN -compose-> FUNC`-Kante, keine Vererbung ueber Vorfahren.
+     *
+     * `0` ist eine AUSSAGE, kein fehlender Wert: bei einem Blatt ist es R-30s Befund, bei einem
+     * zerlegten Block der von FC-03 erzwungene Normalzustand. Wer die beiden unterscheiden muss,
+     * fragt `decomposedFuncs()` — diese Datei tut es bewusst nicht (sie waere sonst an `rules.ts`
+     * gebunden und fuer `rules.ts` nicht mehr importierbar).
+     */
+    chains: z.number().int().nonnegative(),
+    /**
+     * Use Cases, die ueber diese Ketten an der FUNC haengen (`UC -compose-> FCHAIN`).
+     *
+     * Nicht aus `chains` ableitbar und auch nicht dasselbe: eine FUNC in drei Ketten EINES Use
+     * Case ist etwas anderes als eine in drei Ketten dreier Use Cases. Gemessen an graphcode
+     * faellt die Zahl regelmaessig kleiner aus als `chains` (FUNC-mutate: 11 Ketten, 7 UCs).
+     */
+    useCases: z.number().int().nonnegative(),
+});
 /**
  * Kritikalitaet je FUNC, kritischste zuerst.
  *
@@ -65,7 +133,9 @@ export function functionCriticality(graph) {
                 ucs.add(uc);
         return { funcId: fn.id, funcName: fn.name, chains: chains.size, useCases: ucs.size };
     });
-    return rows.sort((a, b) => b.chains - a.chains ||
+    const sorted = rows.sort((a, b) => b.chains - a.chains ||
         b.useCases - a.useCases ||
         (a.funcId < b.funcId ? -1 : a.funcId > b.funcId ? 1 : 0));
+    z.array(FunctionCriticality).parse(sorted); // CR-SM-361: der Erzeuger prueft seinen Vertrag
+    return sorted;
 }

package/dist/se/grammar-snapshot.d.ts

@@ -11,18 +11,18 @@
  */
 export declare const GRAMMAR_SNAPSHOT: {
     readonly versions: {
-        readonly ontology: "9.1.0";
-        readonly metaModel: "5.2.0";
-        readonly rules: "31.0.0";
+        readonly ontology: "10.1.0";
+        readonly metaModel: "6.0.0";
+        readonly rules: "34.0.0";
     };
     readonly elementTypes: readonly ["ACTOR", "CR", "FCHAIN", "FLOW", "FUNC", "MOD", "MS", "REQ", "SCHEMA", "SYS", "TEST", "UC"];
     readonly traceTypes: readonly ["allocate", "compose", "io", "relation", "satisfy", "verify"];
-    readonly patterns: readonly ["ACTOR -io-> FLOW", "CR -relation-> FUNC", "CR -relation-> MOD", "CR -relation-> MS", "CR -relation-> REQ", "CR -relation-> SCHEMA", "CR -relation-> UC", "FCHAIN -compose-> FUNC [1..*]", "FCHAIN -satisfy-> REQ", "FLOW -io-> ACTOR", "FLOW -io-> FUNC", "FLOW -relation-> SCHEMA [1]", "FUNC -allocate-> MOD [0..1]", "FUNC -compose-> FUNC [0..*]", "FUNC -io-> FLOW", "FUNC -satisfy-> REQ where target.kinds in {functional,postcondition,precondition}", "MOD -compose-> MOD [0..*]", "MOD -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}", "MS -compose-> FUNC", "MS -compose-> REQ", "MS -compose-> UC", "MS -relation-> MS label=depends-on", "REQ -compose-> REQ [0..*]", "SYS -compose-> MOD [0..*]", "SYS -compose-> REQ [0..*]", "SYS -compose-> SYS [0..*]", "SYS -compose-> UC [1..*]", "SYS -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}", "TEST -verify-> REQ", "TEST -verify-> SCHEMA", "UC -compose-> FCHAIN [1..*]", "UC -compose-> REQ [1..*]"];
+    readonly patterns: readonly ["ACTOR -io-> FLOW", "CR -relation-> FUNC", "CR -relation-> MOD", "CR -relation-> MS", "CR -relation-> REQ", "CR -relation-> SCHEMA", "CR -relation-> UC", "FCHAIN -compose-> FUNC [1..*]", "FCHAIN -satisfy-> REQ where target.kinds in {non-functional}", "FLOW -io-> ACTOR", "FLOW -io-> FUNC", "FLOW -relation-> SCHEMA [1]", "FUNC -allocate-> MOD [0..1]", "FUNC -compose-> FUNC [0..*]", "FUNC -io-> FLOW", "FUNC -satisfy-> REQ where target.kinds in {functional}", "MOD -compose-> MOD [0..*]", "MOD -satisfy-> REQ where target.kinds in {non-functional}", "MS -compose-> FUNC", "MS -compose-> REQ", "MS -compose-> UC", "MS -relation-> MS label=depends-on", "REQ -compose-> REQ [0..*]", "SYS -compose-> MOD [0..*]", "SYS -compose-> REQ [0..*]", "SYS -compose-> SYS [0..*]", "SYS -compose-> UC [1..*]", "SYS -satisfy-> REQ where target.kinds in {non-functional}", "TEST -verify-> REQ", "TEST -verify-> SCHEMA", "UC -compose-> FCHAIN [1..*]", "UC -compose-> REQ [1..*]"];
     readonly elementColumns: readonly ["OntologyElement.attributes", "OntologyElement.created_at", "OntologyElement.description", "OntologyElement.id", "OntologyElement.kinds", "OntologyElement.method", "OntologyElement.name", "OntologyElement.status", "OntologyElement.type", "OntologyElement.updated_at", "Trace.attributes", "Trace.created_at", "Trace.label", "Trace.source", "Trace.target", "Trace.type", "Trace.verified_at", "Trace.weight"];
-    readonly attributes: readonly ["CR.rationale: string", "CR.spike: boolean", "CR.status: enum", "FLOW.protocol: string", "FLOW.qos: string", "FUNC.concept: boolean", "FUNC.external: boolean", "FUNC.measuredMs: number", "FUNC.realRef: object", "FUNC.safety_relevant: boolean", "FUNC.sourceFile: string", "FUNC.timingBudgetMs: number", "MOD.concept: boolean", "MOD.external: boolean", "MOD.kind: string", "MOD.path: string", "MOD.realRef: object", "REQ.detection: number", "REQ.occurrence: number", "REQ.severity: number", "SCHEMA.concept: boolean", "SCHEMA.contract: string", "SCHEMA.external: boolean", "SCHEMA.realRef: object", "TEST.concept: boolean", "TEST.sourceFile: string", "TEST.testRefs: array", "UC.operatingMode: string"];
-    readonly rules: readonly ["AF-01 (warning) domain=[graph]", "AF-02 (warning) domain=[graph]", "AF-03 (warning) domain=[graph]", "AF-04 (warning) domain=[graph]", "AF-05 (warning) domain=[graph]", "BQ-01 (warning) domain=[REQ]", "BQ-02 (warning) domain=[REQ]", "BQ-04 (warning) domain=[REQ]", "BQ-06 (warning) domain=[REQ]", "BQ-07 (warning) domain=[REQ]", "BW-02 (warning) domain=[FUNC]", "CL-01 (warning) domain=[ACTOR]", "CR-01 (warning) domain=[MOD]", "CR-R01 (warning) domain=[CR]", "CR-R02 (warning) domain=[CR]", "CR-R03 (warning) domain=[all]", "FC-02 (warning) domain=[UC]", "FC-03 (warning) domain=[FUNC]", "FC-04 (warning) domain=[FCHAIN]", "FM-01 (warning) domain=[REQ]", "FM-02 (warning) domain=[REQ]", "FM-03 (warning) domain=[REQ]", "IO-01 (warning) domain=[FUNC]", "IO-02 (error) domain=[FLOW]", "IR-01 (warning) domain=[graph]", "MS-01 (warning) domain=[MS]", "MS-02 (warning) domain=[MS]", "MS-03 (info) domain=[CR]", "MT-01 (warning) domain=[MOD]", "MT-02 (info) domain=[MOD]", "MT-04 (info) domain=[FUNC]", "ND-01 (warning) domain=[FUNC]", "ND-02 (warning) domain=[SCHEMA]", "NFR-01 (warning) domain=[FCHAIN,FUNC,MOD]", "R-01 (error) domain=[REQ]", "R-02 (warning) domain=[FUNC]", "R-04 (warning) domain=[MOD]", "R-05 (warning) domain=[TEST]", "R-08 (error) domain=[all]", "R-10 (warning) domain=[FLOW]", "R-12 (warning) domain=[FUNC]", "R-15 (warning) domain=[FCHAIN]", "R-16 (warning) domain=[ACTOR]", "R-17 (warning) domain=[SYS]", "R-18 (error) domain=[all]", "R-19 (warning) domain=[TEST]", "R-20 (warning) domain=[FUNC]", "R-21 (warning) domain=[FCHAIN,FUNC]", "R-22 (warning) domain=[FUNC]", "R-23 (warning) domain=[MOD]", "R-26 (warning) domain=[SCHEMA]", "R-29 (error) domain=[TEST]", "R-30 (warning) domain=[FUNC]", "R-31 (warning) domain=[FUNC]", "R-32 (warning) domain=[SCHEMA]", "RC-01 (warning) domain=[FUNC]", "RC-02 (warning) domain=[TEST]", "RC-03 (warning) domain=[SCHEMA]", "RC-04 (warning) domain=[SCHEMA]", "RC-05 (warning) domain=[MOD]", "RC-06 (warning) domain=[FUNC,MOD,SCHEMA]", "RC-07 (warning) domain=[CR,SYS]", "RD-01 (warning) domain=[REQ]", "RD-02 (warning) domain=[REQ]", "RD-03 (info) domain=[REQ]", "RD-04 (warning) domain=[FUNC,MOD,SYS]", "RD-05 (warning) domain=[FUNC,MOD,SYS]", "SC-02 (warning) domain=[SCHEMA]", "TR-01 (warning) domain=[graph]", "UC-01 (warning) domain=[UC]", "UC-02 (warning) domain=[UC]", "UC-03 (warning) domain=[UC]", "UC-04 (warning) domain=[UC]", "UC-05 (info) domain=[UC]", "UC-06 (info) domain=[UC]", "VR-01 (info) domain=[TEST]"];
-    readonly conformanceRules: readonly ["RC-01 (warning)", "RC-02 (warning)", "RC-03 (warning)", "RC-04 (warning)", "RC-05 (warning)", "RC-06 (warning)", "RC-07 (warning)"];
+    readonly attributes: readonly ["CR.rationale: string", "CR.spike: boolean", "CR.status: enum", "FLOW.sync: enum", "FUNC.concept: boolean", "FUNC.external: boolean", "FUNC.measuredMs: number", "FUNC.realRef: object", "FUNC.safety_relevant: boolean", "FUNC.sourceFile: string", "FUNC.timingBudgetMs: number", "MOD.concept: boolean", "MOD.external: boolean", "MOD.kind: string", "MOD.path: string", "MOD.realRef: object", "REQ.detection: number", "REQ.occurrence: number", "REQ.role: enum", "REQ.severity: number", "SCHEMA.concept: boolean", "SCHEMA.contract: string", "SCHEMA.external: boolean", "SCHEMA.realRef: object", "TEST.concept: boolean", "TEST.sourceFile: string", "TEST.testRefs: array", "UC.operatingMode: string"];
+    readonly rules: readonly ["AF-01 (warning) domain=[graph]", "AF-02 (warning) domain=[graph]", "AF-03 (warning) domain=[graph]", "AF-04 (warning) domain=[graph]", "AF-05 (warning) domain=[graph]", "BQ-01 (warning) domain=[REQ]", "BQ-02 (warning) domain=[REQ]", "BQ-04 (warning) domain=[REQ]", "BQ-06 (warning) domain=[REQ]", "BQ-07 (warning) domain=[REQ]", "BW-02 (warning) domain=[FUNC]", "CL-01 (warning) domain=[ACTOR]", "CR-01 (warning) domain=[MOD]", "CR-R01 (warning) domain=[CR]", "CR-R02 (warning) domain=[CR]", "CR-R03 (warning) domain=[all]", "CR-R05 (warning) domain=[REQ]", "FC-02 (warning) domain=[UC]", "FC-03 (warning) domain=[FUNC]", "FC-04 (warning) domain=[FCHAIN]", "FC-05 (warning) domain=[FCHAIN]", "FM-01 (warning) domain=[REQ]", "FM-02 (warning) domain=[REQ]", "FM-03 (warning) domain=[REQ]", "IO-01 (warning) domain=[FUNC]", "IO-02 (error) domain=[FLOW]", "IR-01 (warning) domain=[graph]", "MS-01 (warning) domain=[MS]", "MS-02 (warning) domain=[MS]", "MS-03 (info) domain=[CR]", "MT-01 (warning) domain=[MOD]", "MT-02 (warning) domain=[MOD]", "MT-04 (info) domain=[FUNC]", "ND-01 (warning) domain=[FUNC]", "ND-02 (warning) domain=[SCHEMA]", "NFR-01 (warning) domain=[FCHAIN,FUNC,MOD]", "R-01 (error) domain=[REQ]", "R-02 (warning) domain=[FUNC]", "R-04 (warning) domain=[MOD]", "R-05 (warning) domain=[TEST]", "R-08 (error) domain=[all]", "R-10 (warning) domain=[FLOW]", "R-12 (warning) domain=[FUNC]", "R-15 (warning) domain=[FCHAIN]", "R-16 (warning) domain=[ACTOR]", "R-17 (warning) domain=[SYS]", "R-18 (error) domain=[all]", "R-19 (warning) domain=[TEST]", "R-20 (warning) domain=[FUNC]", "R-21 (warning) domain=[FCHAIN,FUNC]", "R-22 (warning) domain=[FUNC]", "R-23 (warning) domain=[MOD]", "R-26 (warning) domain=[SCHEMA]", "R-29 (error) domain=[TEST]", "R-30 (warning) domain=[FUNC]", "R-31 (warning) domain=[FUNC]", "R-32 (warning) domain=[SCHEMA]", "RC-01 (warning) domain=[FUNC]", "RC-02 (warning) domain=[TEST]", "RC-03 (warning) domain=[SCHEMA]", "RC-04 (warning) domain=[SCHEMA]", "RC-05 (warning) domain=[MOD]", "RC-06 (warning) domain=[FUNC,MOD,SCHEMA]", "RC-07 (warning) domain=[CR,SYS]", "RC-08 (warning) domain=[SCHEMA]", "RC-09 (warning) domain=[SCHEMA]", "RC-10 (warning) domain=[MOD]", "RD-01 (warning) domain=[REQ]", "RD-02 (warning) domain=[REQ]", "RD-04 (warning) domain=[FUNC,MOD,SYS]", "RD-05 (warning) domain=[FUNC,MOD,SYS]", "SC-02 (warning) domain=[SCHEMA]", "TR-01 (warning) domain=[graph]", "UC-01 (warning) domain=[UC]", "UC-02 (warning) domain=[UC]", "UC-03 (warning) domain=[UC]", "UC-04 (warning) domain=[UC]", "VR-01 (info) domain=[TEST]"];
+    readonly conformanceRules: readonly ["RC-01 (warning)", "RC-02 (warning)", "RC-03 (warning)", "RC-04 (warning)", "RC-05 (warning)", "RC-06 (warning)", "RC-07 (warning)", "RC-08 (warning)", "RC-09 (warning)", "RC-10 (warning)"];
     readonly policy: readonly ["apTable = null", "boundaryWidth = {warning:5}", "criticality = {infrastructure:3}", "crossingFlows = {warning:3}", "decompositionBreadth = {min:3,warning:9}", "instability = null", "lcom4 = {info:4,warning:6}", "riskRpn = 100"];
-    readonly ruleHelp: readonly ["AF-01", "AF-02", "AF-03", "AF-04", "AF-05", "BQ-01", "BQ-02", "BQ-04", "BQ-06", "BQ-07", "BW-02", "CL-01", "CR-01", "CR-R01", "CR-R02", "CR-R03", "FC-02", "FC-03", "FC-04", "FM-01", "FM-02", "FM-03", "IO-01", "IO-02", "IR-01", "MS-01", "MS-02", "MS-03", "MT-01", "MT-02", "MT-04", "ND-01", "ND-02", "NFR-01", "R-01", "R-02", "R-04", "R-05", "R-08", "R-10", "R-12", "R-15", "R-16", "R-17", "R-18", "R-19", "R-20", "R-21", "R-22", "R-23", "R-26", "R-29", "R-30", "R-31", "R-32", "RC-01", "RC-02", "RC-03", "RC-04", "RC-05", "RC-06", "RC-07", "RD-01", "RD-02", "RD-03", "RD-04", "RD-05", "SC-02", "TR-01", "UC-01", "UC-02", "UC-03", "UC-04", "UC-05", "UC-06", "VR-01"];
-    readonly exports: readonly ["ACCEPTED_FINDINGS_ATTRIBUTE", "AF_RULES", "ALL_RULE_DEFS", "AO_RULES", "AcceptedFindingSchema", "ActionPriority", "AnalysisArtifactId", "AnalysisFreshnessStampSchema", "ApTableSchema", "BOUNDED_PATTERNS", "BQ_RULES", "CLOSED_STATUS", "CODE_CONFORMANCE_RULES", "CR_RULES", "CodeFactsSchema", "DEFAULT_METRIC_POLICY", "DIMENSION_READINESS_DELTA_NAME", "DIMENSION_READINESS_NAME", "ELEMENT_ATTRIBUTES", "ELEMENT_DESCRIPTIONS", "ElementType", "ElementUid", "FC_RULES", "FM_RULES", "FileFactsSchema", "ImportEdgeSchema", "MAX_SLUG_LENGTH", "META_MODEL_VERSION", "MODELING_ELEMENT_TYPES", "MT_RULES", "MetricPolicySchema", "ND_RULES", "ONTOLOGY_VERSION", "OntologyElement", "OntologyGraph", "PHASE_READINESS_NAME", "PhaseGate", "READINESS_SCORED_PROFILES", "REQUIRED_PATTERNS", "RULES_VERSION", "RULE_HELP", "RULE_TASKS", "RULE_TO_DIMENSION", "RULE_TO_PHASE", "ReadinessDimension", "ReadinessReport", "ReadinessScore", "RealRefSchema", "RepoRelativePathSchema", "ReqKind", "RuleSeverity", "RuleViolation", "SC_RULES", "SteerSpace", "SteerTerm", "TASK_ENTRY", "TASK_OUTCOME_RULES", "TASK_OWNED_RULES", "TRACE_PATTERNS", "TestRefSchema", "TestRefsSchema", "TestResult", "Trace", "TraceType", "UC_RULES", "V3_RULES", "VIEW_RULES", "VerificationMethod", "ViolationCandidate", "ViolationContext", "acceptedRuleIds", "actionPriority", "admittingAlternatives", "allocationCohesion", "apMethod", "assumptionReviewPromoted", "attributeTypeOf", "boxContracts", "bq01Unambiguous", "bq02Verifiable", "bq04Necessary", "bq06Conforming", "bq07Complete", "bw02WhiteboxWidth", "chainsByFunc", "cl01ConopsCompleteness", "cr01CrossingFlowCount", "crossingContractCount", "decomposedFuncs", "evaluateAFRules", "evaluateAORules", "evaluateAllRules", "evaluateBQRules", "evaluateCRRules", "evaluateConformanceRules", "evaluateFCRules", "evaluateFMRules", "evaluateMTRules", "evaluateNDRules", "evaluateRules", "evaluateSCRules", "evaluateTaskOutcomeRules", "evaluateUCRules", "evaluateViewRules", "extractFormatE", "fc02LeafUcHasFchain", "fc03FchainFlat", "fc04ActorBounded", "flowProducers", "fm01MissingFmeaAttributes", "fm02MissingMitigation", "fm03HighRiskUnverified", "funcSimilarity", "funcSubtree", "functionCriticality", "getRuleDefsForProfile", "hydrateAttrValue", "importCoverage", "indexOf", "io01CrossModuleCompleteness", "isElementUid", "isValidTrace", "jaccard", "maxOccurs", "minOccurs", "moduleCrossings", "moduleMetrics", "mt01Instability", "mt02Lcom4", "mt04WhiteboxLcom4", "nd01FuncNearDuplicate", "nd02SchemaNearDuplicate", "nfr01BudgetOvershoot", "normalizeReqKinds", "pairsAbove", "parseElementUid", "sc02IsReferenced", "schemaSimilarity", "setBQ04SimilarityMatrix", "subtreeFuncs", "taskOf", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tradeDecisionRecorded", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "uc05HasPostcondition", "uc06HasPrecondition", "vr01TestNoResult", "whiteboxContractCount"];
+    readonly ruleHelp: readonly ["AF-01", "AF-02", "AF-03", "AF-04", "AF-05", "BQ-01", "BQ-02", "BQ-04", "BQ-06", "BQ-07", "BW-02", "CL-01", "CR-01", "CR-R01", "CR-R02", "CR-R03", "CR-R05", "FC-02", "FC-03", "FC-04", "FC-05", "FM-01", "FM-02", "FM-03", "IO-01", "IO-02", "IR-01", "MS-01", "MS-02", "MS-03", "MT-01", "MT-02", "MT-04", "ND-01", "ND-02", "NFR-01", "R-01", "R-02", "R-04", "R-05", "R-08", "R-10", "R-12", "R-15", "R-16", "R-17", "R-18", "R-19", "R-20", "R-21", "R-22", "R-23", "R-26", "R-29", "R-30", "R-31", "R-32", "RC-01", "RC-02", "RC-03", "RC-04", "RC-05", "RC-06", "RC-07", "RC-08", "RC-09", "RC-10", "RD-01", "RD-02", "RD-04", "RD-05", "SC-02", "TR-01", "UC-01", "UC-02", "UC-03", "UC-04", "VR-01"];
+    readonly exports: readonly ["ACCEPTED_FINDINGS_ATTRIBUTE", "AF_RULES", "ALL_RULE_DEFS", "AO_RULES", "AcceptedFindingSchema", "ActionPriority", "AnalysisArtifactId", "AnalysisFreshnessStampSchema", "ApTableSchema", "BOUNDED_PATTERNS", "BQ_RULES", "CLOSED_STATUS", "CODE_CONFORMANCE_RULES", "CR_RULES", "CodeFactsSchema", "DEFAULT_METRIC_POLICY", "DIMENSION_READINESS_DELTA_NAME", "DIMENSION_READINESS_NAME", "ELEMENT_ATTRIBUTES", "ELEMENT_DESCRIPTIONS", "ElementType", "ElementUid", "FC_RULES", "FM_RULES", "FileFactsSchema", "FlowSync", "FunctionCriticality", "ImportEdgeSchema", "MAX_SLUG_LENGTH", "META_MODEL_VERSION", "MODELING_ELEMENT_TYPES", "MT_RULES", "MetricPolicySchema", "ModuleMetrics", "ND_RULES", "ONTOLOGY_VERSION", "OntologyElement", "OntologyGraph", "PHASE_READINESS_NAME", "PhaseGate", "READINESS_SCORED_PROFILES", "REQUIRED_PATTERNS", "RULES_VERSION", "RULE_HELP", "RULE_PRECONDITION", "RULE_TASKS", "RULE_TO_DIMENSION", "RULE_TO_PHASE", "ReadinessDimension", "ReadinessReport", "ReadinessScore", "RealRefSchema", "RepoRelativePathSchema", "ReqKind", "ReqRole", "RuleSeverity", "RuleViolation", "SC_RULES", "SteerSpace", "SteerTerm", "TASK_ENTRY", "TASK_OUTCOME_RULES", "TASK_OWNED_RULES", "TRACE_PATTERNS", "TestRefSchema", "TestRefsSchema", "TestResult", "Trace", "TraceType", "UC_RULES", "V3_RULES", "VIEW_RULES", "VerificationMethod", "ViolationCandidate", "ViolationContext", "acceptedRuleIds", "actionPriority", "admittingAlternatives", "allocationCohesion", "apMethod", "assumptionReviewPromoted", "attributeTypeOf", "boxContracts", "bq01Unambiguous", "bq02Verifiable", "bq04Necessary", "bq06Conforming", "bq07Complete", "bw02WhiteboxWidth", "chainsByFunc", "cl01ConopsCompleteness", "cr01CrossingFlowCount", "crossingContractCount", "decomposedFuncs", "evaluateAFRules", "evaluateAORules", "evaluateAllRules", "evaluateBQRules", "evaluateCRRules", "evaluateConformanceRules", "evaluateFCRules", "evaluateFMRules", "evaluateMTRules", "evaluateNDRules", "evaluateRules", "evaluateSCRules", "evaluateTaskOutcomeRules", "evaluateUCRules", "evaluateViewRules", "extractFormatE", "fc02LeafUcHasFchain", "fc03FchainFlat", "fc04ActorBounded", "fc05ChainConnected", "flowProducers", "fm01MissingFmeaAttributes", "fm02MissingMitigation", "fm03HighRiskUnverified", "funcSimilarity", "funcSubtree", "functionCriticality", "getRuleDefsForProfile", "hydrateAttrValue", "importCoverage", "indexOf", "io01CrossModuleCompleteness", "isElementUid", "isValidTrace", "jaccard", "maxOccurs", "minOccurs", "moduleCrossings", "moduleMetrics", "mt01Instability", "mt02Lcom4", "mt04WhiteboxLcom4", "nd01FuncNearDuplicate", "nd02SchemaNearDuplicate", "nfr01BudgetOvershoot", "normalizeReqKinds", "pairsAbove", "parseElementUid", "readFlowSync", "readRealRef", "readReqRole", "readTestRefs", "ruleApplies", "sc02IsReferenced", "schemaSimilarity", "setBQ04SimilarityMatrix", "subtreeFuncs", "taskOf", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tradeDecisionRecorded", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "vr01TestNoResult", "whiteboxContractCount"];
 };

package/dist/se/grammar-snapshot.js

@@ -11,9 +11,9 @@
  */
 export const GRAMMAR_SNAPSHOT = {
     versions: {
-        ontology: "9.1.0",
-        metaModel: "5.2.0",
-        rules: "31.0.0",
+        ontology: "10.1.0",
+        metaModel: "6.0.0",
+        rules: "34.0.0",
     },
     elementTypes: [
         "ACTOR",
@@ -46,16 +46,16 @@ export const GRAMMAR_SNAPSHOT = {
         "CR -relation-> SCHEMA",
         "CR -relation-> UC",
         "FCHAIN -compose-> FUNC [1..*]",
-        "FCHAIN -satisfy-> REQ",
+        "FCHAIN -satisfy-> REQ where target.kinds in {non-functional}",
         "FLOW -io-> ACTOR",
         "FLOW -io-> FUNC",
         "FLOW -relation-> SCHEMA [1]",
         "FUNC -allocate-> MOD [0..1]",
         "FUNC -compose-> FUNC [0..*]",
         "FUNC -io-> FLOW",
-        "FUNC -satisfy-> REQ where target.kinds in {functional,postcondition,precondition}",
+        "FUNC -satisfy-> REQ where target.kinds in {functional}",
         "MOD -compose-> MOD [0..*]",
-        "MOD -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}",
+        "MOD -satisfy-> REQ where target.kinds in {non-functional}",
         "MS -compose-> FUNC",
         "MS -compose-> REQ",
         "MS -compose-> UC",
@@ -65,7 +65,7 @@ export const GRAMMAR_SNAPSHOT = {
         "SYS -compose-> REQ [0..*]",
         "SYS -compose-> SYS [0..*]",
         "SYS -compose-> UC [1..*]",
-        "SYS -satisfy-> REQ where target.kinds in {mitigation,non-functional,risk}",
+        "SYS -satisfy-> REQ where target.kinds in {non-functional}",
         "TEST -verify-> REQ",
         "TEST -verify-> SCHEMA",
         "UC -compose-> FCHAIN [1..*]",
@@ -95,8 +95,7 @@ export const GRAMMAR_SNAPSHOT = {
         "CR.rationale: string",
         "CR.spike: boolean",
         "CR.status: enum",
-        "FLOW.protocol: string",
-        "FLOW.qos: string",
+        "FLOW.sync: enum",
         "FUNC.concept: boolean",
         "FUNC.external: boolean",
         "FUNC.measuredMs: number",
@@ -111,6 +110,7 @@ export const GRAMMAR_SNAPSHOT = {
         "MOD.realRef: object",
         "REQ.detection: number",
         "REQ.occurrence: number",
+        "REQ.role: enum",
         "REQ.severity: number",
         "SCHEMA.concept: boolean",
         "SCHEMA.contract: string",
@@ -138,9 +138,11 @@ export const GRAMMAR_SNAPSHOT = {
         "CR-R01 (warning) domain=[CR]",
         "CR-R02 (warning) domain=[CR]",
         "CR-R03 (warning) domain=[all]",
+        "CR-R05 (warning) domain=[REQ]",
         "FC-02 (warning) domain=[UC]",
         "FC-03 (warning) domain=[FUNC]",
         "FC-04 (warning) domain=[FCHAIN]",
+        "FC-05 (warning) domain=[FCHAIN]",
         "FM-01 (warning) domain=[REQ]",
         "FM-02 (warning) domain=[REQ]",
         "FM-03 (warning) domain=[REQ]",
@@ -151,7 +153,7 @@ export const GRAMMAR_SNAPSHOT = {
         "MS-02 (warning) domain=[MS]",
         "MS-03 (info) domain=[CR]",
         "MT-01 (warning) domain=[MOD]",
-        "MT-02 (info) domain=[MOD]",
+        "MT-02 (warning) domain=[MOD]",
         "MT-04 (info) domain=[FUNC]",
         "ND-01 (warning) domain=[FUNC]",
         "ND-02 (warning) domain=[SCHEMA]",
@@ -184,9 +186,11 @@ export const GRAMMAR_SNAPSHOT = {
         "RC-05 (warning) domain=[MOD]",
         "RC-06 (warning) domain=[FUNC,MOD,SCHEMA]",
         "RC-07 (warning) domain=[CR,SYS]",
+        "RC-08 (warning) domain=[SCHEMA]",
+        "RC-09 (warning) domain=[SCHEMA]",
+        "RC-10 (warning) domain=[MOD]",
         "RD-01 (warning) domain=[REQ]",
         "RD-02 (warning) domain=[REQ]",
-        "RD-03 (info) domain=[REQ]",
         "RD-04 (warning) domain=[FUNC,MOD,SYS]",
         "RD-05 (warning) domain=[FUNC,MOD,SYS]",
         "SC-02 (warning) domain=[SCHEMA]",
@@ -195,8 +199,6 @@ export const GRAMMAR_SNAPSHOT = {
         "UC-02 (warning) domain=[UC]",
         "UC-03 (warning) domain=[UC]",
         "UC-04 (warning) domain=[UC]",
-        "UC-05 (info) domain=[UC]",
-        "UC-06 (info) domain=[UC]",
         "VR-01 (info) domain=[TEST]",
     ],
     conformanceRules: [
@@ -207,6 +209,9 @@ export const GRAMMAR_SNAPSHOT = {
         "RC-05 (warning)",
         "RC-06 (warning)",
         "RC-07 (warning)",
+        "RC-08 (warning)",
+        "RC-09 (warning)",
+        "RC-10 (warning)",
     ],
     policy: [
         "apTable = null",
@@ -235,9 +240,11 @@ export const GRAMMAR_SNAPSHOT = {
         "CR-R01",
         "CR-R02",
         "CR-R03",
+        "CR-R05",
         "FC-02",
         "FC-03",
         "FC-04",
+        "FC-05",
         "FM-01",
         "FM-02",
         "FM-03",
@@ -281,9 +288,11 @@ export const GRAMMAR_SNAPSHOT = {
         "RC-05",
         "RC-06",
         "RC-07",
+        "RC-08",
+        "RC-09",
+        "RC-10",
         "RD-01",
         "RD-02",
-        "RD-03",
         "RD-04",
         "RD-05",
         "SC-02",
@@ -292,8 +301,6 @@ export const GRAMMAR_SNAPSHOT = {
         "UC-02",
         "UC-03",
         "UC-04",
-        "UC-05",
-        "UC-06",
         "VR-01",
     ],
     exports: [
@@ -322,12 +329,15 @@ export const GRAMMAR_SNAPSHOT = {
         "FC_RULES",
         "FM_RULES",
         "FileFactsSchema",
+        "FlowSync",
+        "FunctionCriticality",
         "ImportEdgeSchema",
         "MAX_SLUG_LENGTH",
         "META_MODEL_VERSION",
         "MODELING_ELEMENT_TYPES",
         "MT_RULES",
         "MetricPolicySchema",
+        "ModuleMetrics",
         "ND_RULES",
         "ONTOLOGY_VERSION",
         "OntologyElement",
@@ -338,6 +348,7 @@ export const GRAMMAR_SNAPSHOT = {
         "REQUIRED_PATTERNS",
         "RULES_VERSION",
         "RULE_HELP",
+        "RULE_PRECONDITION",
         "RULE_TASKS",
         "RULE_TO_DIMENSION",
         "RULE_TO_PHASE",
@@ -347,6 +358,7 @@ export const GRAMMAR_SNAPSHOT = {
         "RealRefSchema",
         "RepoRelativePathSchema",
         "ReqKind",
+        "ReqRole",
         "RuleSeverity",
         "RuleViolation",
         "SC_RULES",
@@ -405,6 +417,7 @@ export const GRAMMAR_SNAPSHOT = {
         "fc02LeafUcHasFchain",
         "fc03FchainFlat",
         "fc04ActorBounded",
+        "fc05ChainConnected",
         "flowProducers",
         "fm01MissingFmeaAttributes",
         "fm02MissingMitigation",
@@ -433,6 +446,11 @@ export const GRAMMAR_SNAPSHOT = {
         "normalizeReqKinds",
         "pairsAbove",
         "parseElementUid",
+        "readFlowSync",
+        "readRealRef",
+        "readReqRole",
+        "readTestRefs",
+        "ruleApplies",
         "sc02IsReferenced",
         "schemaSimilarity",
         "setBQ04SimilarityMatrix",
@@ -448,8 +466,6 @@ export const GRAMMAR_SNAPSHOT = {
         "uc02HasActor",
         "uc03HasScenario",
         "uc04GoalDefined",
-        "uc05HasPostcondition",
-        "uc06HasPrecondition",
         "vr01TestNoResult",
         "whiteboxContractCount",
     ],