@sigloch/contracts 10.14.0 → 12.0.0

package/dist/se/analysis-freshness-rules.d.ts

@@ -1,64 +1,71 @@
 /**
- * CR-SM-227: Analysis-Freshness-Legs — the third leg-kind a review gate checks
- * (rule legs, layer-presence legs [R-28, entfallen mit CR-SM-247], now analysis-freshness legs).
- * Presence/Resolution-Split (wie R-19/R-20/R-26/R-27 vs. RC-01..05): these five
- * rules are the PRÜFBARE FORM only — does a `graphVersion` stamp exist for the
- * artifact, as a graph attribute. They never compare the stamp against the
- * live graphVersion (that staleness/currency check is I/O — a consumer
- * concern, `CreationCurrencyProvider` in `@sigloch/graphcode-client`).
+ * CR-SM-227: the analysis rules — was each judgment-work artifact carried out?
+ *
+ * AF-01..04 ask for the stamp `SYS.attributes.analysisFreshness.<artifact>`: its presence is the
+ * only record that the analysis was done (an FMEA may legitimately end without a single risk, so
+ * the result cannot stand in for it). They never compare the stamp against the live graphVersion.
+ *
+ * AF-05 is different since CR-SM-395: the implementation plan is not a stamp but the set of open
+ * CRs. The rule reads "there is something unbuilt, but no open order" and falls due again with
+ * every change — which a one-time stamp could not express.
  */
 import type { OntologyGraph } from './ontology.js';
-import type { RuleViolation } from './rules.js';
+import { type RuleViolation } from './rules.js';
+/**
+ * AF-05 (CR-SM-395): es gibt Ungebautes, aber keinen offenen Auftrag → der Bauplan ist faellig.
+ *
+ * Ungebaut ist, woran die Bindungsregeln melden wuerden (`unbuiltElementIds`: TEST, FUNC, SCHEMA
+ * ohne Bindung, `external` und Zerlegungs-Eltern ausgenommen wie dort). Es reicht, dass EIN offener
+ * Auftrag existiert; er muss nicht auf die Elemente zeigen — ob er die richtigen trifft, zeigt der
+ * Git-Diff. Mit dem Auftrag verstummt diese Regel, und die Bindungsregeln der Stufe 11 werden
+ * faellig: ihre Befunde sind die Arbeitsliste. Beim ersten Bau sind das alle Elemente, bei einer
+ * Aenderung die neuen.
+ *
+ * EIN Befund je Graph, am SYS: dort wird er abgenommen („Bau nicht beauftragt"), und eine Abnahme
+ * je Element waere mit jedem neuen Element wieder offen. Die Meldung nennt die ungebauten Elemente.
+ */
+declare function buildPlanDue(graph: OntologyGraph): RuleViolation[];
 export declare const AF_RULES: readonly [{
     readonly id: "AF-01";
     readonly name: "ConOps freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 3;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-02";
     readonly name: "Trade Study freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 7;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-03";
     readonly name: "Assumption Review freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 7;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-04";
     readonly name: "FMEA freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 8;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-05";
-    readonly name: "Implementation Plan freshness stamp present";
-    readonly severity: "warning";
-    readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
-    readonly domain: readonly ["graph"];
-}];
-/** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
-export declare function tradeDecisionRecorded(graph: OntologyGraph): RuleViolation[];
-/** IR-01: every CR named by a stamped assumption review exists; an empty list is a legitimate outcome. */
-export declare function assumptionReviewPromoted(graph: OntologyGraph): RuleViolation[];
-/** CR-SM-355: the task-outcome rules — owned by trade / irr (TASK_OWNED_RULES), never in the kern focus. */
-export declare const TASK_OUTCOME_RULES: readonly [{
-    readonly id: "TR-01";
-    readonly name: "Trade decision recorded as CR";
-    readonly severity: "warning";
-    readonly evaluate: typeof tradeDecisionRecorded;
-    readonly domain: readonly ["graph"];
-}, {
-    readonly id: "IR-01";
-    readonly name: "Assumption review promoted to CR";
+    readonly name: "Unbuilt elements have an open CR";
     readonly severity: "warning";
-    readonly evaluate: typeof assumptionReviewPromoted;
+    readonly stage: 10;
+    readonly role: "existence";
+    readonly evaluate: typeof buildPlanDue;
     readonly domain: readonly ["graph"];
 }];
-/** Evaluate the task-outcome rules (CR-SM-355). */
-export declare function evaluateTaskOutcomeRules(graph: OntologyGraph): RuleViolation[];
 /** Evaluate all analysis-freshness-presence rules. */
 export declare function evaluateAFRules(graph: OntologyGraph): RuleViolation[];
+export {};

package/dist/se/analysis-freshness-rules.js

@@ -1,10 +1,11 @@
-import { AnalysisFreshnessStampSchema } from './ontology.js';
+import { readAnalysisStamp } from './ontology.js';
+import { unbuiltElementIds } from './rules.js';
+import { hasOpenOrder } from './rule-due.js';
 const ARTIFACT_LABEL = {
     conops: 'Concept of Operations',
     trade: 'Trade Study',
     'assumption-review': 'Assumption Review',
     fmea: 'FMEA',
-    implplan: 'Implementation Plan',
 };
 /**
  * CR-SM-382: was der Hinweis nennt — den Task, seinen Skill und den ersten Arbeitsschritt.
@@ -29,20 +30,16 @@ const ANALYSIS_WORK = {
     },
     trade: {
         skill: 'se-trade',
-        firstStep: 'name the open decision with its options and criteria, then record the chosen option as a CR with relation(label: decides) edges to what it decides',
+        firstStep: 'name the open decision with its options and criteria, then apply the chosen option to the model and record the decision as a done CR with relation edges to what was decided',
     },
     'assumption-review': {
         skill: 'se-irr',
-        firstStep: 'list every unproven assumption the model rests on (unmeasured numbers, unverified external dependencies) in a record under docs/records/, then promote the load-bearing ones to CRs',
+        firstStep: 'list every unproven assumption the model rests on (unmeasured numbers, unverified external dependencies) in a record under docs/records/, then write each load-bearing one as a REQ with its verifying TEST',
     },
     fmea: {
         skill: 'se-fmea',
         firstStep: 'for each FCHAIN name its failure modes and add each one as a REQ with role risk (severity, occurrence, detection) plus a mitigation REQ and its TEST',
     },
-    implplan: {
-        skill: 'se-plan',
-        firstStep: 'cut one CR per leaf REQ at its carrier and group the CRs into MS milestones in dependency order',
-    },
 };
 /** Presence-check for one analysis artifact's freshness stamp, anchored on SYS. */
 function analysisFreshnessPresence(ruleId, artifactId) {
@@ -50,8 +47,7 @@ function analysisFreshnessPresence(ruleId, artifactId) {
         const sys = graph.elements.find(e => e.type === 'SYS');
         if (!sys)
             return []; // nothing to anchor on yet (vacuous-complete exemption)
-        const stamp = sys.attributes?.analysisFreshness?.[artifactId];
-        if (AnalysisFreshnessStampSchema.safeParse(stamp).success)
+        if (readAnalysisStamp(graph, artifactId).state === 'bound')
             return [];
         const label = ARTIFACT_LABEL[artifactId];
         const work = ANALYSIS_WORK[artifactId];
@@ -69,85 +65,49 @@ const conopsFreshnessPresent = analysisFreshnessPresence('AF-01', 'conops');
 const tradeFreshnessPresent = analysisFreshnessPresence('AF-02', 'trade');
 const assumptionReviewFreshnessPresent = analysisFreshnessPresence('AF-03', 'assumption-review');
 const fmeaFreshnessPresent = analysisFreshnessPresence('AF-04', 'fmea');
-const implplanFreshnessPresent = analysisFreshnessPresence('AF-05', 'implplan');
-export const AF_RULES = [
-    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', evaluate: conopsFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', evaluate: tradeFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', evaluate: assumptionReviewFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', evaluate: fmeaFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-05', name: 'Implementation Plan freshness stamp present', severity: 'warning', evaluate: implplanFreshnessPresent, domain: ['graph'] },
-];
 /**
- * CR-SM-355: Task-Ausgangsregeln fuer trade und irr — die aus dem Task entstandenen Massnahmen sind
- * als CR dokumentiert. Traeger ist `crRefs` im Frischestempel. Ohne Stempel feuern sie nicht (dann
- * feuert der Eintritt AF-02/AF-03, und der Task ist nicht durch). `label` wird als `Trace.label`
- * gelesen wie bei MS-02 — `decides` ist kein TraceType, sondern das SP-1-Label einer relation-Kante.
+ * AF-05 (CR-SM-395): es gibt Ungebautes, aber keinen offenen Auftrag → der Bauplan ist faellig.
+ *
+ * Ungebaut ist, woran die Bindungsregeln melden wuerden (`unbuiltElementIds`: TEST, FUNC, SCHEMA
+ * ohne Bindung, `external` und Zerlegungs-Eltern ausgenommen wie dort). Es reicht, dass EIN offener
+ * Auftrag existiert; er muss nicht auf die Elemente zeigen — ob er die richtigen trifft, zeigt der
+ * Git-Diff. Mit dem Auftrag verstummt diese Regel, und die Bindungsregeln der Stufe 11 werden
+ * faellig: ihre Befunde sind die Arbeitsliste. Beim ersten Bau sind das alle Elemente, bei einer
+ * Aenderung die neuen.
+ *
+ * EIN Befund je Graph, am SYS: dort wird er abgenommen („Bau nicht beauftragt"), und eine Abnahme
+ * je Element waere mit jedem neuen Element wieder offen. Die Meldung nennt die ungebauten Elemente.
  */
-function stampedCrRefs(graph, artifactId) {
+function buildPlanDue(graph) {
     const sys = graph.elements.find(e => e.type === 'SYS');
     if (!sys)
-        return null;
-    const raw = sys.attributes?.analysisFreshness?.[artifactId];
-    const parsed = AnalysisFreshnessStampSchema.safeParse(raw);
-    if (!parsed.success)
-        return null;
-    return { sys, crRefs: parsed.data.crRefs ?? [] };
-}
-/** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
-export function tradeDecisionRecorded(graph) {
-    const stamped = stampedCrRefs(graph, 'trade');
-    if (!stamped)
+        return []; // kein Anker — R-33 meldet das fehlende System
+    if (hasOpenOrder(graph))
         return [];
-    const { sys, crRefs } = stamped;
-    const base = { rule_id: 'TR-01', severity: 'warning', context: { element_type: sys.type, element_name: sys.name } };
-    if (crRefs.length === 0) {
-        return [{
-                ...base,
-                element_id: sys.id,
-                message: 'Trade Study is stamped but names no decision CR (analysisFreshness.trade.crRefs is empty) — a trade without a recorded decision is a list, not a trade',
-                fix_hint: 'Record the decision as a CR with relation(label: decides) edges and list its id in analysisFreshness.trade.crRefs (se-trade)',
-            }];
-    }
-    const byId = new Map(graph.elements.map(e => [e.id, e]));
-    const decidesFrom = new Set(graph.traces.filter(t => t.type === 'relation' && t.label === 'decides').map(t => t.source));
-    return crRefs.flatMap(id => {
-        const cr = byId.get(id);
-        if (!cr || cr.type !== 'CR') {
-            return [{ ...base, element_id: sys.id, message: `Trade Study names ${id} as its decision, but no CR with that id exists`, fix_hint: 'Point analysisFreshness.trade.crRefs at an existing CR, or add the CR through graph_mutate (se-trade)' }];
-        }
-        if (!decidesFrom.has(id)) {
-            return [{ ...base, element_id: id, message: `${id} is named as a trade decision but carries no relation(label: decides) edge`, fix_hint: 'Add a relation edge from the CR to the element it decides, with label "decides" (se-trade)' }];
-        }
-        return [];
-    });
-}
-/** IR-01: every CR named by a stamped assumption review exists; an empty list is a legitimate outcome. */
-export function assumptionReviewPromoted(graph) {
-    const stamped = stampedCrRefs(graph, 'assumption-review');
-    if (!stamped)
+    const unbuilt = unbuiltElementIds(graph);
+    if (unbuilt.length === 0)
         return [];
-    const { sys, crRefs } = stamped;
-    const byId = new Map(graph.elements.map(e => [e.id, e]));
-    return crRefs
-        .filter(id => byId.get(id)?.type !== 'CR')
-        .map(id => ({
-        rule_id: 'IR-01',
-        severity: 'warning',
-        element_id: sys.id,
-        message: `Assumption Review names ${id} as a promoted assumption, but no CR with that id exists`,
-        fix_hint: 'Point analysisFreshness.assumption-review.crRefs at an existing CR, or add the CR through graph_mutate (se-irr)',
-        context: { element_type: sys.type, element_name: sys.name },
-    }));
+    const shown = unbuilt.slice(0, 3).join(', ') + (unbuilt.length > 3 ? ` and ${unbuilt.length - 3} more` : '');
+    return [{
+            rule_id: 'AF-05',
+            severity: 'warning',
+            element_id: sys.id,
+            message: `${unbuilt.length} ${unbuilt.length === 1 ? 'element is' : 'elements are'} not built yet (${shown}) and no open CR orders the work — the implementation plan is due`,
+            fix_hint: 'Carry out the Implementation Plan: work through the skill se-plan step by step. First step: cut one CR per leaf REQ at its carrier and group the CRs into MS milestones in dependency order. The open CRs are the plan — with the first one the binding rules list what to build',
+            context: { element_type: sys.type, element_name: sys.name },
+        }];
 }
-/** CR-SM-355: the task-outcome rules — owned by trade / irr (TASK_OWNED_RULES), never in the kern focus. */
-export const TASK_OUTCOME_RULES = [
-    { id: 'TR-01', name: 'Trade decision recorded as CR', severity: 'warning', evaluate: tradeDecisionRecorded, domain: ['graph'] },
-    { id: 'IR-01', name: 'Assumption review promoted to CR', severity: 'warning', evaluate: assumptionReviewPromoted, domain: ['graph'] },
+// CR-SM-396: AF-01 liegt auf Stufe 3, HINTER den Anforderungen — eine Ausnahme von „Stufe = spaeteste
+// Menge, die die Regel braucht" (das Einsatzkonzept braucht nur die Anwendungsfaelle, Stufe 2).
+// Entscheidung des Autors 2026-10-06: zuerst sagt der Anwendungsfall, was verlangt ist (UC-01), dann
+// folgt die Analyse des Betriebs. In einer Stufe steht die Existenz-Regel vor der Analyse.
+export const AF_RULES = [
+    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', stage: 3, role: 'analysis', evaluate: conopsFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', stage: 7, role: 'analysis', evaluate: tradeFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', stage: 7, role: 'analysis', evaluate: assumptionReviewFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', stage: 8, role: 'analysis', evaluate: fmeaFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-05', name: 'Unbuilt elements have an open CR', severity: 'warning', stage: 10, role: 'existence', evaluate: buildPlanDue, domain: ['graph'] },
 ];
-/** Evaluate the task-outcome rules (CR-SM-355). */
-export function evaluateTaskOutcomeRules(graph) {
-    return TASK_OUTCOME_RULES.flatMap(r => r.evaluate(graph));
-}
 /** Evaluate all analysis-freshness-presence rules. */
 export function evaluateAFRules(graph) {
     return AF_RULES.flatMap(r => r.evaluate(graph));

package/dist/se/ao-rules.js

@@ -260,12 +260,12 @@ export function io01CrossModuleCompleteness(graph) {
     return violations;
 }
 export const AO_RULES = [
-    { id: 'BW-02', name: 'Whitebox boundary width', severity: 'warning', evaluate: bw02WhiteboxWidth, domain: ['FUNC'] },
-    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
+    { id: 'BW-02', name: 'Whitebox boundary width', severity: 'warning', stage: 5, evaluate: bw02WhiteboxWidth, domain: ['FUNC'] },
+    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', stage: 7, evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
     // CR-SM-242: domain ist FUNC, nicht MOD — die Regel laeuft ueber FUNC-Paare in FCHAINs und
     // meldet am FUNC. Mit ['MOD'] uebertraf ihr Zaehler (21) ihren eigenen Nenner-Beitrag (10);
     // nur der Clamp verhinderte einen negativen Score.
-    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness, domain: ['FUNC'] },
+    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', stage: 5, evaluate: io01CrossModuleCompleteness, domain: ['FUNC'] },
 ];
 export function evaluateAORules(graph, policy) {
     return AO_RULES.flatMap(r => r.evaluate(graph, policy));

package/dist/se/chain-metrics.d.ts

@@ -0,0 +1,116 @@
+/**
+ * CR-SM-404 — Kennzahlen der Wirkkette: je FCHAIN eine Zahl, oder der Grund, warum es keine gibt.
+ *
+ * Die Leitlinie verlangt, die Realisierungsarchitektur AUF DER WIRKKETTE zu bewerten (graphcode
+ * `docs/graphcode_architektur_konzept.md`, „Kennzahlen der Wirkkette"). Bis hierher rechnete das
+ * nur ein Spike in graphcode (`scripts/spike-kettenkennzahlen.mjs`); von dort ist die Rechnung
+ * portiert, nicht neu erfunden. Gemessen 2026-10-09 ueber 10 Familie-Graphen: 76 Ketten, 31
+ * bewertbar.
+ *
+ * ## Diese Datei URTEILT NICHT
+ *
+ * Keine Regel, keine Schwelle, kein Katalogeintrag — dieselbe Trennung wie `moduleMetrics` und
+ * `functionCriticality`. Ob eine Laenge von 6 gut ist, sagt erst ein Profil.
+ *
+ * ## Nicht bewertbar heisst: KEINE Zahl
+ *
+ * Eine FCHAIN ist grammatisch eine Menge; die Reihenfolge entsteht erst aus Erzeuger ->
+ * Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Zerfaellt die Kette, beschriebe
+ * jede Kennzahl etwas, das es nicht gibt. Eine solche Kette traegt deshalb ihre Gruende und kein
+ * einziges Zahlenfeld — das Schema laesst es nicht zu. Sie zaehlt im NENNER der Quote
+ * (`measurability`), die neben jedem Wert stehen muss wie die Bindungsquote neben RC-*.
+ *
+ * ## Wer urteilt, ob eine Kette eine Kette ist
+ *
+ * - `FC-05`: die Regel FC-05, aufgerufen, nicht nachgebaut. Ursache (fehlendes Glied, Sack) und
+ *   die Nebenkomponenten stehen in ihrem Befund (`context.side_components`), nicht hier.
+ * - `loose-member`: ein Glied ohne io-Eingang oder -Ausgang. Das ist die Bedingung, unter der
+ *   FC-05 sich ENTHAELT (R-31 meldet das Glied) — ohne diesen Grund haette eine solche Kette weder
+ *   einen FC-05-Befund noch einen Grund und bekaeme Zahlen.
+ * - `no-entry` / `no-exit`: kein FLOW von bzw. zu einem Knoten AUSSERHALB der Kette. Weiter als
+ *   FC-04, das nur einen ACTOR gelten laesst: eine Kette, die eine andere fortsetzt, ist messbar.
+ * - `empty`: keine FUNC (R-15).
+ *
+ * ## Ein Kettenbegriff, ein Modulbegriff
+ *
+ * Glied = direkte `FCHAIN -compose-> FUNC`-Kante, ueber `chainsByFunc` (R-30s Definition).
+ * Modul einer FUNC = direkte `allocate`-Kante, wie `module-crossings.ts` und `moduleMetrics`.
+ * Der Spike erbte das Modul ueber compose-Vorfahren; gemessen sind 326 von 326 Kettengliedern
+ * des Korpus direkt alloziert — die Vererbung kauft nichts und waere eine zweite Vorstellung von
+ * Zugehoerigkeit im selben Paket.
+ *
+ * ## CR-SM-406 — die ORTE je Kette, nur erkannt
+ *
+ * Neben jeder Zahl steht, WO sie herkommt: die Mitglieder je Rueckkopplung, die geteilten
+ * Funktionen, die Grenzen je gerichtetem Modulpaar mit ihren Vertraegen, dazu Zulauf, Importe und
+ * Uebergaben. Reine Zusatzfelder — die Zahlen aus CR-SM-404 bleiben und sind die Laenge ihrer
+ * Liste. Weiter kein Urteil.
+ *
+ * - Import und Uebergabe zaehlen nur an Gliedern, die ALLEIN dieser Kette gehoeren. Was an einer
+ *   geteilten Funktion haengt, steht an der geteilten Funktion — sie ist ein eigener Ort. Ohne
+ *   diese Grenze meldete jede Kette durch Gate und Store deren Zufluesse als ihre eigenen
+ *   (gemessen am graphcode-Modell 2026-10-10: 333 statt 16).
+ * - Ein ACTOR als Erzeuger oder Verbraucher ist der Ein- und Ausgang der Kette, kein Ort.
+ * - Vertrag = `contractsOfFlow` aus `module-crossings.ts` (SCHEMA, sonst `UNBOUND:<flow>`), hier je
+ *   Kettenkante gelesen. `moduleCrossings().pairs` selbst traegt die Vertraege des GANZEN Graphen
+ *   je ungerichtetem Paar und kann „elf Kanten auf einem Vertrag" in EINER Kette nicht zeigen.
+ *
+ * @author andreas@siglochconsulting
+ */
+import { z } from 'zod/v4';
+import type { OntologyGraph } from './ontology.js';
+export declare const ChainMetrics: z.ZodObject<{
+    chains: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        measurable: z.ZodLiteral<true>;
+        length: z.ZodNumber;
+        branching: z.ZodNumber;
+        moduleBoundaries: z.ZodNullable<z.ZodNumber>;
+        feedbackLoops: z.ZodNumber;
+        sharedFuncs: z.ZodNumber;
+        bottlenecks: z.ZodNumber;
+        syncDepth: z.ZodNull;
+        errorPathDepth: z.ZodNull;
+        memberCount: z.ZodNumber;
+        fanIn: z.ZodNumber;
+        loops: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            members: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        shared: z.ZodArray<z.ZodString>;
+        boundaries: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            edges: z.ZodNumber;
+            contracts: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        imports: z.ZodArray<z.ZodObject<{
+            flow: z.ZodString;
+            func: z.ZodString;
+        }, z.core.$strict>>;
+        handovers: z.ZodArray<z.ZodObject<{
+            flow: z.ZodString;
+            func: z.ZodString;
+        }, z.core.$strict>>;
+        chainId: z.ZodString;
+        chainName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        measurable: z.ZodLiteral<false>;
+        reasons: z.ZodArray<z.ZodEnum<{
+            "FC-05": "FC-05";
+            "loose-member": "loose-member";
+            "no-entry": "no-entry";
+            "no-exit": "no-exit";
+            empty: "empty";
+        }>>;
+        chainId: z.ZodString;
+        chainName: z.ZodString;
+    }, z.core.$strict>], "measurable">>;
+    measurability: z.ZodObject<{
+        chains: z.ZodNumber;
+        measurable: z.ZodNumber;
+        ratio: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChainMetrics = z.infer<typeof ChainMetrics>;
+/** Die Kennzahlen aller FCHAINs dieses Graphen und die Quote der bewertbaren. */
+export declare function chainMetrics(graph: OntologyGraph): ChainMetrics;