@sigloch/contracts 10.10.0 → 10.12.0

package/dist/se/conformance-rules.d.ts

@@ -24,6 +24,7 @@ export declare const FileFactsSchema: z.ZodObject<{
     testCases: z.ZodDefault<z.ZodArray<z.ZodString>>;
     importedSymbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
     parsedSymbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    zodSymbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type FileFacts = z.infer<typeof FileFactsSchema>;
 /** One file→file import edge (repo-relative paths) — the module-drift evidence (CR-212). */
@@ -44,6 +45,7 @@ export declare const CodeFactsSchema: z.ZodObject<{
         testCases: z.ZodDefault<z.ZodArray<z.ZodString>>;
         importedSymbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
         parsedSymbols: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        zodSymbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     importEdges: z.ZodOptional<z.ZodArray<z.ZodObject<{
         from: z.ZodString;
@@ -54,6 +56,10 @@ export declare const CodeFactsSchema: z.ZodObject<{
         open: "open";
         done: "done";
     }>>>;
+    fileScope: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        referenced: "referenced";
+    }>>;
 }, z.core.$strip>;
 export type CodeFacts = z.infer<typeof CodeFactsSchema>;
 /** A conformance rule: pure over (graph, facts) — never touches I/O itself. */
@@ -103,7 +109,6 @@ export interface ImportCoverage {
     unassigned: string[];
 }
 export declare function importCoverage(graph: OntologyGraph, facts: CodeFacts): ImportCoverage;
-/** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
 export declare const CODE_CONFORMANCE_RULES: ConformanceRuleDefinition[];
 /** Run all RC rules against a graph + extracted code facts. */
 export declare function evaluateConformanceRules(graph: OntologyGraph, facts: CodeFacts): RuleViolation[];

package/dist/se/conformance-rules.js

@@ -15,7 +15,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { RealRefSchema, TestRefsSchema } from './ontology.js';
+import { readTestRefs, readRealRef } from './ontology.js';
 import { CLOSED_STATUS } from './cr-quality-rules.js';
 /** Parser facts about one source file (extracted by the executor). */
 export const FileFactsSchema = z.object({
@@ -29,6 +29,12 @@ export const FileFactsSchema = z.object({
     importedSymbols: z.array(z.string()).default([]),
     /** Symbols X invoked as `X.parse(` / `X.safeParse(` — the schema is actually used (CR-211). */
     parsedSymbols: z.array(z.string()).default([]),
+    /**
+     * Exported consts whose initializer is a Zod schema (`export const X = z.…`) — for RC-08
+     * (CR-SM-358). Optional, ABSENT = silence: the extractor did not look, which is not the
+     * same as "this file declares no schema" (same asymmetry as `declaredDependencies`).
+     */
+    zodSymbols: z.array(z.string()).optional(),
 });
 /** One file→file import edge (repo-relative paths) — the module-drift evidence (CR-212). */
 export const ImportEdgeSchema = z.object({
@@ -67,6 +73,13 @@ export const CodeFactsSchema = z.object({
      * `docs/cr/` was never looked at, it does not "have no CRs".
      */
     crFiles: z.record(z.string(), z.enum(['open', 'done'])).optional(),
+    /**
+     * Which files `files` covers (CR-SM-358): `referenced` = only files a realRef/testRefs
+     * entry names (the contract above), `all` = every source file of the repo. RC-09 asks
+     * "who ELSE parses this contract" and can only answer it over `all` — a partial scan
+     * would report the absence of what it never looked at. ABSENT = `referenced`.
+     */
+    fileScope: z.enum(['referenced', 'all']).optional(),
 });
 const missingFile = (facts, file) => facts.files[file]?.exists !== true;
 // RC-01: every valid FUNC realRef must resolve — file on disk, symbol declared in
@@ -81,10 +94,10 @@ function codeRefMustResolve(graph, facts) {
             continue;
         if (el.attributes?.concept === true || el.attributes?.external === true)
             continue;
-        const parsed = RealRefSchema.safeParse(el.attributes?.realRef);
-        if (!parsed.success)
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // no/invalid binding → R-20 territory
-        const ref = parsed.data;
+        const ref = parsed.value;
         if (missingFile(facts, ref.file)) {
             violations.push({
                 rule_id: 'RC-01',
@@ -125,10 +138,10 @@ function testRefMustResolve(graph, facts) {
             continue;
         if (el.attributes?.concept === true)
             continue;
-        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
-        if (!parsed.success)
+        const parsed = readTestRefs(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // no/invalid binding → R-19 territory
-        for (const ref of parsed.data) {
+        for (const ref of parsed.value) {
             if (missingFile(facts, ref.file)) {
                 violations.push({
                     rule_id: 'RC-02',
@@ -169,10 +182,10 @@ function schemaRefMustResolve(graph, facts) {
             continue;
         if (el.attributes?.concept === true || el.attributes?.external === true)
             continue;
-        const parsed = RealRefSchema.safeParse(el.attributes?.realRef);
-        if (!parsed.success)
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // no/invalid binding → R-26 territory
-        const ref = parsed.data;
+        const ref = parsed.value;
         if (missingFile(facts, ref.file)) {
             violations.push({
                 rule_id: 'RC-03',
@@ -199,6 +212,61 @@ function schemaRefMustResolve(graph, facts) {
     }
     return violations;
 }
+// The files the MODEL names as a SCHEMA's interface: realRef files of the FUNCs io-connected
+// (producer or consumer) to a FLOW whose data format is this SCHEMA (FUNC ─io→ FLOW
+// ─relation→ SCHEMA), restricted to files that exist. RC-04 asks whether one of them parses
+// the schema, RC-09 whether anyone ELSE does — one derivation, so both ask the same question.
+function interfaceFiles(graph, schemaId, facts, typeOf) {
+    const flowIds = new Set(graph.traces
+        .filter(t => t.type === 'relation' && t.target === schemaId && typeOf.get(t.source) === 'FLOW')
+        .map(t => t.source));
+    if (flowIds.size === 0)
+        return [];
+    const funcIds = new Set(graph.traces
+        .filter(t => t.type === 'io' &&
+        ((flowIds.has(t.target) && typeOf.get(t.source) === 'FUNC') ||
+            (flowIds.has(t.source) && typeOf.get(t.target) === 'FUNC')))
+        .map(t => (flowIds.has(t.target) ? t.source : t.target)));
+    const files = [];
+    for (const fnId of funcIds) {
+        const fn = graph.elements.find(e => e.id === fnId);
+        const cr = readRealRef(fn?.attributes);
+        if (cr.state === 'bound' && !missingFile(facts, cr.value.file))
+            files.push(cr.value.file);
+    }
+    return files;
+}
+// Does `file` parse the schema? It must call `.parse`/`.safeParse` on the symbol AND have it in
+// scope — imported, or declared right there: the definition file does not import its own schema
+// (CR-SM-358, found by the positive control on graphcode's Format-E door, where the modelled
+// translator lives in the schema's own file).
+function parsesAt(facts, file, ref) {
+    const f = facts.files[file];
+    if (f?.exists !== true || !f.parsedSymbols.includes(ref.symbol))
+        return false;
+    return f.importedSymbols.includes(ref.symbol) || file === ref.file;
+}
+// Files outside `allowed` that import AND parse the symbol — the parsers the model does not
+// name. Test files (testCases present) are exempt; consumer ratchets cover them. Empty unless
+// the extractor saw every file (`fileScope: 'all'`): a partial scan cannot name who else parses.
+function foreignParsers(facts, symbol, allowed) {
+    if (facts.fileScope !== 'all')
+        return [];
+    return Object.entries(facts.files)
+        .filter(([file, f]) => f.exists && !allowed.has(file) && f.testCases.length === 0 &&
+        f.importedSymbols.includes(symbol) && f.parsedSymbols.includes(symbol))
+        .map(([file]) => file)
+        .sort();
+}
+// A SCHEMA whose realRef symbol is declared but, by the extractor's own account, not a Zod
+// schema. False when the extractor did not report `zodSymbols` (silence, not a verdict) or
+// when the symbol is not declared at all (RC-03's finding, not this one).
+function boundToNonZod(facts, ref) {
+    const f = facts.files[ref.file];
+    if (f?.exists !== true || f.zodSymbols === undefined)
+        return false;
+    return f.declaredSymbols.includes(ref.symbol) && !f.zodSymbols.includes(ref.symbol);
+}
 // RC-04: a bound SCHEMA that the graph says is realized at an interface must
 // actually be parsed there (CR-211). The graph gives the check LOCATIONS: FUNCs
 // io-connected to a FLOW whose data format IS this SCHEMA (FUNC ─io→ FLOW
@@ -218,43 +286,29 @@ function schemaRefMustBeUsed(graph, facts) {
             continue;
         if (el.attributes?.concept === true)
             continue;
-        const parsed = RealRefSchema.safeParse(el.attributes?.realRef);
-        if (!parsed.success || parsed.data.symbol === undefined)
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
             continue;
-        const ref = parsed.data;
-        // The FLOWs whose data format is this SCHEMA (FLOW ─relation→ SCHEMA).
-        const flowIds = new Set(graph.traces
-            .filter(t => t.type === 'relation' && t.target === el.id && typeOf.get(t.source) === 'FLOW')
-            .map(t => t.source));
-        if (flowIds.size === 0)
-            continue;
-        // FUNCs io-connected to those FLOWs (producer or consumer).
-        const funcIds = new Set(graph.traces
-            .filter(t => t.type === 'io' &&
-            ((flowIds.has(t.target) && typeOf.get(t.source) === 'FUNC') ||
-                (flowIds.has(t.source) && typeOf.get(t.target) === 'FUNC')))
-            .map(t => (flowIds.has(t.target) ? t.source : t.target)));
-        // Realized FUNCs among them: a resolvable realRef whose file exists.
-        const realizedFiles = [];
-        for (const fnId of funcIds) {
-            const fn = graph.elements.find(e => e.id === fnId);
-            const cr = RealRefSchema.safeParse(fn?.attributes?.realRef);
-            if (cr.success && !missingFile(facts, cr.data.file))
-                realizedFiles.push(cr.data.file);
-        }
+        const ref = parsed.value;
+        if (boundToNonZod(facts, ref))
+            continue; // RC-08 owns this cause (CR-SM-358)
+        const realizedFiles = interfaceFiles(graph, el.id, facts, typeOf);
         if (realizedFiles.length === 0)
             continue; // nothing realized to check against
-        const usedSomewhere = realizedFiles.some(file => {
-            const f = facts.files[file];
-            return f.importedSymbols.includes(ref.symbol) && f.parsedSymbols.includes(ref.symbol);
-        });
+        const usedSomewhere = realizedFiles.some(file => parsesAt(facts, file, ref));
         if (!usedSomewhere) {
+            // CR-SM-358: where it IS parsed, if the extractor saw every file — then the finding says
+            // where the binding has to point, and RC-09 stays quiet about the same cause.
+            const actual = foreignParsers(facts, ref.symbol, new Set([ref.file, ...realizedFiles]));
             violations.push({
                 rule_id: 'RC-04',
                 severity: 'warning',
                 element_id: el.id,
-                message: `${el.id} schema '${ref.symbol}' is not parsed in any realized FUNC at its modelled interface`,
-                fix_hint: `Import and call ${ref.symbol}.parse()/.safeParse() in one of the io-connected FUNC's code files — or mark the SCHEMA concept:true if no code realizes it yet`,
+                message: `${el.id} schema '${ref.symbol}' is not parsed in any realized FUNC at its modelled interface` +
+                    (actual.length > 0 ? ` — it is parsed in: ${actual.join(', ')}` : ''),
+                fix_hint: actual.length > 0
+                    ? `The parse sits in ${actual.join(', ')}: point the FUNC realRef at that file, or move the parse into the modelled FUNC`
+                    : `Import and call ${ref.symbol}.parse()/.safeParse() in one of the io-connected FUNC's code files — or mark the SCHEMA concept:true if no code realizes it yet`,
                 context: { element_type: el.type, element_name: el.name },
             });
         }
@@ -295,12 +349,12 @@ function buildModResolver(graph) {
     for (const el of graph.elements) {
         if (el.type !== 'FUNC')
             continue;
-        const cr = RealRefSchema.safeParse(el.attributes?.realRef);
-        if (!cr.success)
+        const cr = readRealRef(el.attributes);
+        if (cr.state !== 'bound')
             continue;
         const modTrace = graph.traces.find(t => t.source === el.id && t.type === 'allocate' && typeOf.get(t.target) === 'MOD');
         if (modTrace)
-            fileToMod.set(cr.data.file, modTrace.target);
+            fileToMod.set(cr.value.file, modTrace.target);
     }
     // MOD.path longest-prefix fallback for files with no direct binding.
     const modPaths = graph.elements
@@ -439,10 +493,10 @@ function externalRefMustNameDependency(graph, facts) {
         // `concept: true` has no binding that could rot — a concept node claims nothing about code.
         if (el.attributes?.external !== true || el.attributes?.concept === true)
             continue;
-        const parsed = RealRefSchema.safeParse(el.attributes?.realRef);
-        if (!parsed.success)
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound')
             continue;
-        const match = WORKSPACE_PATH.exec(parsed.data.file);
+        const match = WORKSPACE_PATH.exec(parsed.value.file);
         if (!match)
             continue; // not the shape this rule can decide
         const pkg = `${WORKSPACE_SCOPE}/${match[1]}`;
@@ -452,7 +506,7 @@ function externalRefMustNameDependency(graph, facts) {
             rule_id: 'RC-06',
             severity: 'warning',
             element_id: el.id,
-            message: `${el.id} binds to '${parsed.data.file}', but '${pkg}' is not a declared dependency`,
+            message: `${el.id} binds to '${parsed.value.file}', but '${pkg}' is not a declared dependency`,
             fix_hint: `Add '${pkg}' to dependencies, or re-point the realRef at the package that now owns the symbol`,
             context: { element_type: el.type, element_name: el.name },
         });
@@ -514,6 +568,91 @@ function crNodeMatchesFile(graph, facts) {
     return violations;
 }
 /** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
+// ---------------------------------------------------------------------------
+// RC-08 / RC-09 (CR-SM-358) — the contract has a checker, and only the modelled places use it.
+//
+// Why these two replace ND-01 in substance: parallel paths are not similar to each other
+// (spike CR-GC-637: name similarity 0.000 in 7 of 7 documented pairs); they share a CONTRACT.
+// A second translator of the same contract is found by asking who parses it, not what it
+// looks like. RC-01..RC-07 ask model → code ("does the binding resolve?"); RC-09 is the
+// first rule that asks code → model ("does the model know everyone who reads this?").
+// ---------------------------------------------------------------------------
+// RC-08: a bound SCHEMA must bind a Zod schema, not a type. A type is checked by the
+// compiler and gone at runtime: whatever produces the data cannot prove it, and whoever
+// reads it cannot check it. Data that nobody parses yet only has a reader nobody knows yet.
+function schemaRefMustBeZod(graph, facts) {
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'SCHEMA')
+            continue;
+        if (el.attributes?.concept === true)
+            continue;
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
+            continue;
+        const ref = parsed.value;
+        if (!boundToNonZod(facts, ref))
+            continue;
+        violations.push({
+            rule_id: 'RC-08',
+            severity: 'warning',
+            element_id: el.id,
+            message: `${el.id} realRef '${ref.symbol}' in '${ref.file}' is not a Zod schema — the contract cannot be checked at runtime`,
+            fix_hint: `Declare the contract as a Zod schema (export const ${ref.symbol}Schema = z.…) and bind the SCHEMA to it — a producer needs a checkable schema even while no reader is known`,
+            context: { element_type: el.type, element_name: el.name },
+        });
+    }
+    return violations;
+}
+// RC-09: a Zod-bound SCHEMA may be parsed only where the model says — in the realRef files
+// of its producers/translators (the same set RC-04 checks) or in its own definition file.
+// Any other file that imports AND parses the symbol is a translator the model does not
+// know: a second path. The definition may live in another package (no facts entry) — only a
+// proven type binding (RC-08) silences the rule. One finding per SCHEMA, listing the files — the count must not grow
+// with usage (Gate 7, class CR-GC-315). Test files (testCases present) are exempt; ratchets
+// in the consumer cover them. Runs only when the extractor saw every file (`fileScope:'all'`).
+function schemaParsedOnlyAtInterface(graph, facts) {
+    if (facts.fileScope !== 'all')
+        return [];
+    // (foreignParsers repeats this guard; checking here skips the graph walk entirely.)
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'SCHEMA')
+            continue;
+        if (el.attributes?.concept === true)
+            continue;
+        const parsed = readRealRef(el.attributes);
+        if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
+            continue;
+        const ref = parsed.value;
+        // Only a PROVEN type binding silences RC-09 (RC-08 owns it). A definition outside this
+        // repo — the family's shared contracts live in @sigloch/contracts — has no facts entry,
+        // and those are exactly the contracts reused most; a `.parse()` on the symbol is already
+        // the evidence that it is a runtime checker.
+        if (boundToNonZod(facts, ref))
+            continue;
+        const iface = interfaceFiles(graph, el.id, facts, typeOf);
+        // One cause, one finding (Gate 4): if the model names an interface and NONE of it parses,
+        // the parse merely sits elsewhere — that is RC-04's finding (which names the file), not a
+        // second path. A second path needs a first one: a modelled parser AND a foreign one.
+        const ifaceParses = iface.some(file => parsesAt(facts, file, ref));
+        if (iface.length > 0 && !ifaceParses)
+            continue;
+        const foreign = foreignParsers(facts, ref.symbol, new Set([ref.file, ...iface]));
+        if (foreign.length === 0)
+            continue;
+        violations.push({
+            rule_id: 'RC-09',
+            severity: 'warning',
+            element_id: el.id,
+            message: `${el.id} schema '${ref.symbol}' is parsed in ${foreign.length} file(s) the model does not know as its producer or translator: ${foreign.join(', ')}`,
+            fix_hint: 'Route the caller through the modelled translator — or, if it is a translator in its own right, model it: FUNC ─io→ FLOW ─relation→ this SCHEMA, with the FUNC realRef on that file',
+            context: { element_type: el.type, element_name: el.name },
+        });
+    }
+    return violations;
+}
 export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-01', name: 'FUNC realRef resolves to a declared symbol', severity: 'warning', domain: ['FUNC'], evaluate: codeRefMustResolve },
     { id: 'RC-02', name: 'testRefs entries resolve to runnable tests', severity: 'warning', domain: ['TEST'], evaluate: testRefMustResolve },
@@ -522,6 +661,8 @@ export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', domain: ['MOD'], evaluate: importDriftConformance },
     { id: 'RC-06', name: 'external realRef names a declared dependency', severity: 'warning', domain: ['FUNC', 'MOD', 'SCHEMA'], evaluate: externalRefMustNameDependency },
     { id: 'RC-07', name: 'CR node agrees with docs/cr', severity: 'warning', domain: ['CR', 'SYS'], evaluate: crNodeMatchesFile },
+    { id: 'RC-08', name: 'SCHEMA realRef is a Zod schema', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaRefMustBeZod },
+    { id: 'RC-09', name: 'SCHEMA is parsed only at its modelled interface', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaParsedOnlyAtInterface },
 ];
 /** Run all RC rules against a graph + extracted code facts. */
 export function evaluateConformanceRules(graph, facts) {

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

@@ -8,6 +8,11 @@ import type { MetricPolicy } from './policy.js';
 /**
  * Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit.
  * Exportiert fuer RC-07 (CR-SM-329), das dieselbe Frage gegen `docs/cr/done/` stellt.
+ *
+ * CR-SM-362 (ITEM-2026-536): nur noch `done`. Die Menge kannte `dropped`/`rejected`, der
+ * Element-Vertrag (`OntologyElement.status`) nicht — die Regeln rechneten mit Werten, die der
+ * Vertrag verbietet. Verworfen ist eine Begruendung im CR-Text, kein eigener Zustand: das
+ * Verzeichnis `done/` schliesst ihn, der Knoten spiegelt `done`.
  */
 export declare const CLOSED_STATUS: ReadonlySet<string>;
 export declare const CR_RULES: RuleDefinition[];

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

@@ -36,8 +36,13 @@ const SCOPE_TYPES = new Set(['FUNC', 'MOD', 'SCHEMA', 'REQ', 'UC']);
 /**
  * Abgeschlossen heisst: nicht mehr steuerbar. Alles andere ist Grundgesamtheit.
  * Exportiert fuer RC-07 (CR-SM-329), das dieselbe Frage gegen `docs/cr/done/` stellt.
+ *
+ * CR-SM-362 (ITEM-2026-536): nur noch `done`. Die Menge kannte `dropped`/`rejected`, der
+ * Element-Vertrag (`OntologyElement.status`) nicht — die Regeln rechneten mit Werten, die der
+ * Vertrag verbietet. Verworfen ist eine Begruendung im CR-Text, kein eigener Zustand: das
+ * Verzeichnis `done/` schliesst ihn, der Knoten spiegelt `done`.
  */
-export const CLOSED_STATUS = new Set(['done', 'dropped', 'rejected']);
+export const CLOSED_STATUS = new Set(['done']);
 function crMustTrack(graph) {
     const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
     const crs = graph.elements.filter(e => {

package/dist/se/fmea-rules.js

@@ -7,7 +7,7 @@
  *   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 { readTestRefs } from './ontology.js';
 import { actionPriority, apMethod } from './action-priority.js';
 const PHYSICAL_BUDGET_PAIRS = [
     ['costBudget', 'measuredCost', 'cost'],
@@ -106,10 +106,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

@@ -13,16 +13,16 @@ export declare const GRAMMAR_SNAPSHOT: {
     readonly versions: {
         readonly ontology: "9.1.0";
         readonly metaModel: "5.2.0";
-        readonly rules: "31.0.0";
+        readonly rules: "33.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 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 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 (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]", "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)"];
     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", "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", "RC-08", "RC-09", "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", "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_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", "readRealRef", "readTestRefs", "sc02IsReferenced", "schemaSimilarity", "setBQ04SimilarityMatrix", "subtreeFuncs", "taskOf", "toElementUid", "toEvaluableGraph", "tokens", "traceRejection", "tradeDecisionRecorded", "tryParseElementUid", "uc01HasRequirements", "uc02HasActor", "uc03HasScenario", "uc04GoalDefined", "vr01TestNoResult", "whiteboxContractCount"];
 };