@sigloch/graph-api-core 0.4.1 → 2.0.0

package/dist/format-e-codec.d.ts

@@ -8,16 +8,36 @@ export declare class FormatECodec {
     constructor(ontology: OntologyDescriptor);
     /** Extract a ```format-e block from LLM output. Returns null if not found. */
     extractFromLlm(llmOutput: string): string | null;
-    /** Parse Format E text into validated operations. */
-    parse(input: string): FormatEDiff;
+    /**
+     * Parse Format E text into validated operations.
+     *
+     * `options.resolveType` types uids this text does not declare — a mutation diff that
+     * only adds edges between existing nodes carries no `## Nodes` block. Callers bind it
+     * to their store. Without it, such a diff produces errors, never a silent skip.
+     */
+    parse(input: string, options?: {
+        resolveType?: (uid: string) => string | undefined;
+    }): FormatEDiff;
     /** Serialize a Graph to Format E text. */
     serialize(graph: Graph): string;
-    private looksLikeNode;
     private parseNodeLine;
     private parseEdgeLine;
     private parseMerge;
-    private extractNodeType;
     private parseInlineAttrs;
+    /**
+     * CR-SM-215: fan-out serialization — edges sharing `(sourceId, edgeType)` collapse
+     * onto one line `A -x-> B, C, D`. The source UID is written once instead of once per
+     * edge; on the graphcode SSOT graph that is 318 lines instead of 751.
+     *
+     * Two invariants:
+     * - **Edges carrying attributes stay single-line.** `serializeAttrs` binds to one
+     *   edge; a group would either drop `cardinality`/`constraint`/`notes` or wrongly
+     *   share one edge's attributes with its siblings.
+     * - **Deterministic order** (graphcode `REQ-deterministic-serialization`): entries
+     *   sorted by source, then edge type, then first target — code-unit order, not
+     *   `localeCompare`, which is locale-dependent.
+     */
+    private serializeEdges;
     private serializeAttrs;
     private edgeTypeToArrow;
 }

package/dist/format-e-codec.js

@@ -1,6 +1,11 @@
 /**
  * FormatECodec — ontology-agnostic Format E parser/serializer.
  * Domain-specific node types, edge types, and arrows come from OntologyDescriptor.
+ *
+ * CR-SM-216 (Format-E v2): a node's type comes from the `### <TYPE>` section it is
+ * declared under, never from the spelling of its uid. Id conventions differ across the
+ * family (`TYPE-slug`, `Name.TypeAbbr.Counter`, `cand_<hex>`); typing by spelling made
+ * every foreign convention fail silently instead of loudly.
  */
 import { isValidTrace, tracePatternsOf } from './types.js';
 // ---------------------------------------------------------------------------
@@ -42,11 +47,21 @@ export class FormatECodec {
         const m = FORMAT_E_FENCE.exec(llmOutput);
         return m ? m[1].trim() : null;
     }
-    /** Parse Format E text into validated operations. */
-    parse(input) {
+    /**
+     * Parse Format E text into validated operations.
+     *
+     * `options.resolveType` types uids this text does not declare — a mutation diff that
+     * only adds edges between existing nodes carries no `## Nodes` block. Callers bind it
+     * to their store. Without it, such a diff produces errors, never a silent skip.
+     */
+    parse(input, options = {}) {
         const operations = [];
         const errors = [];
         let section = null;
+        let currentType = null;
+        /** uid → type, declared by this text's `### <TYPE>` sections. */
+        const declared = new Map();
+        const typeOf = (uid) => declared.get(uid) ?? options.resolveType?.(uid);
         for (const rawLine of input.split('\n')) {
             const line = rawLine.trim();
             if (!line || line.startsWith('//') || line.startsWith('#!'))
@@ -68,14 +83,29 @@ export class FormatECodec {
             // Section headers
             if (/^##\s*nodes?\s*$/i.test(line)) {
                 section = 'nodes';
+                currentType = null;
                 continue;
             }
             if (/^##\s*edges?\s*$/i.test(line)) {
                 section = 'edges';
+                currentType = null;
                 continue;
             }
             if (/^##\s*merges?\s*$/i.test(line)) {
                 section = 'merges';
+                currentType = null;
+                continue;
+            }
+            // CR-SM-216: `### <TYPE>` carries the type for the nodes below it.
+            const typeSection = /^###\s+(\S+)\s*$/.exec(line);
+            if (typeSection && section === 'nodes') {
+                if (this.validNodeTypes.has(typeSection[1])) {
+                    currentType = typeSection[1];
+                }
+                else {
+                    currentType = null;
+                    errors.push(`Unknown node type section: "### ${typeSection[1]}"`);
+                }
                 continue;
             }
             if (line.startsWith('#'))
@@ -96,12 +126,17 @@ export class FormatECodec {
             // '->' (e.g. "FUNC->FUNC compose"); the arrow lives before any '|', edges
             // carry no pipe — so splitting on '|' cleanly disambiguates (CR-GC-247).
             if (line.split('|', 1)[0].includes('->')) {
-                this.parseEdgeLine(line, operations, errors);
+                this.parseEdgeLine(line, typeOf, operations, errors);
                 continue;
             }
-            // Node
-            if (section === 'nodes' || this.looksLikeNode(line)) {
-                this.parseNodeLine(line, operations, errors);
+            // Node — the `### <TYPE>` section supplies the type (CR-SM-216)
+            if (section === 'nodes') {
+                if (!currentType) {
+                    errors.push(`Node line outside a "### <TYPE>" section: "${line}"`);
+                }
+                else {
+                    this.parseNodeLine(line, currentType, declared, operations, errors);
+                }
                 continue;
             }
             if (line.length > 0)
@@ -114,32 +149,37 @@ export class FormatECodec {
         const lines = [];
         if (graph.nodes.length > 0) {
             lines.push('## Nodes');
+            // CR-SM-216: one `### <TYPE>` header per type instead of a type suffix on every
+            // uid. Measured on the graphcode SSOT graph: 12 headers ≈ 48 tokens, where a
+            // per-node type attribute would have cost ≈ 1476.
+            const byType = new Map();
             for (const node of graph.nodes) {
-                const descr = node.description ? `|${node.description}` : '';
-                const attrs = this.serializeAttrs(node.attributes);
-                lines.push(`+ ${node.uid}${descr}${attrs}`);
+                const group = byType.get(node.type);
+                if (group)
+                    group.push(node);
+                else
+                    byType.set(node.type, [node]);
+            }
+            for (const type of [...byType.keys()].sort()) {
+                lines.push(`### ${type}`);
+                for (const node of byType.get(type) ?? []) {
+                    const descr = node.description ? `|${node.description}` : '';
+                    const attrs = this.serializeAttrs(node.attributes);
+                    lines.push(`+ ${node.uid}${descr}${attrs}`);
+                }
             }
         }
         if (graph.edges.length > 0) {
             lines.push('');
             lines.push('## Edges');
-            for (const edge of graph.edges) {
-                const arrow = this.edgeTypeToArrow(edge.edgeType);
-                const attrs = this.serializeAttrs(edge.attributes);
-                lines.push(`+ ${edge.sourceId} -${arrow}-> ${edge.targetId}${attrs}`);
-            }
+            lines.push(...this.serializeEdges(graph.edges));
         }
         return lines.join('\n');
     }
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
-    looksLikeNode(line) {
-        const stripped = line.replace(/^[+\-~!]\s*/, '');
-        const dotParts = stripped.split('.');
-        return dotParts.length >= 2 && this.validNodeTypes.has(dotParts[dotParts.length - 2] ?? '');
-    }
-    parseNodeLine(line, ops, errors) {
+    parseNodeLine(line, nodeType, declared, ops, errors) {
         const opChar = OP_PREFIX[line[0]] ? line[0] : '+';
         const rest = OP_PREFIX[line[0]] ? line.slice(1).trim() : line.trim();
         const action = OP_PREFIX[opChar] ?? 'add';
@@ -155,30 +195,35 @@ export class FormatECodec {
         const pipeIdx = mainPart.indexOf('|');
         const uid = pipeIdx >= 0 ? mainPart.slice(0, pipeIdx).trim() : mainPart.trim();
         const description = pipeIdx >= 0 ? mainPart.slice(pipeIdx + 1).trim() : undefined;
-        // Validate node type from uid
-        const nodeType = this.extractNodeType(uid);
-        if (!nodeType) {
-            errors.push(`Cannot extract node type from uid: "${uid}"`);
+        if (!uid) {
+            errors.push(`Node line without a uid: "${line}"`);
             return;
         }
-        if (!this.validNodeTypes.has(nodeType)) {
-            errors.push(`Unknown node type "${nodeType}" in: "${uid}"`);
+        // CR-SM-217: with `TYPE-slug` as the family canon, the prefix restores the
+        // redundancy CR-SM-216 removed — for free, since `REQ-safety` costs fewer tokens
+        // than `REQ-safety.REQ`. A node under the wrong section is caught here. Uids with
+        // no recognisable prefix (legacy ids, graphify candidates) are not an error, only
+        // unchecked — the prefix is a cross-check, never a type source.
+        const prefix = uid.split('-', 1)[0];
+        if (prefix !== uid && this.validNodeTypes.has(prefix) && prefix !== nodeType) {
+            errors.push(`Uid prefix contradicts its section: "${uid}" under "### ${nodeType}"`);
             return;
         }
+        declared.set(uid, nodeType);
         if (action === 'remove') {
             ops.push({ type: 'remove_node', semanticId: uid });
         }
         else if (action === 'update') {
-            ops.push({ type: 'update_node', semanticId: uid, description, attributes: inlineAttrs });
+            ops.push({ type: 'update_node', semanticId: uid, elementType: nodeType, description, attributes: inlineAttrs });
         }
         else if (action === 'strict_add') {
-            ops.push({ type: 'strict_add_node', semanticId: uid, description, attributes: inlineAttrs });
+            ops.push({ type: 'strict_add_node', semanticId: uid, elementType: nodeType, description, attributes: inlineAttrs });
         }
         else {
-            ops.push({ type: 'add_node', semanticId: uid, description, attributes: inlineAttrs });
+            ops.push({ type: 'add_node', semanticId: uid, elementType: nodeType, description, attributes: inlineAttrs });
         }
     }
-    parseEdgeLine(line, ops, errors) {
+    parseEdgeLine(line, typeOf, ops, errors) {
         const opChar = OP_PREFIX[line[0]] ? line[0] : '+';
         const rest = OP_PREFIX[line[0]] ? line.slice(1).trim() : line.trim();
         const action = OP_PREFIX[opChar] ?? 'add';
@@ -205,19 +250,19 @@ export class FormatECodec {
             errors.push(`Unknown edge arrow type "${arrowType}" in: "${line}"`);
             return;
         }
-        // Validate source node type
-        const srcType = this.extractNodeType(sourceId);
+        // CR-SM-216: endpoint types come from the declared sections or the caller's
+        // resolver — never from the uid's spelling.
+        const srcType = typeOf(sourceId);
         if (!srcType) {
-            errors.push(`Cannot extract node type from source: "${sourceId}"`);
+            errors.push(`Cannot resolve type of source "${sourceId}" — not declared under a "### <TYPE>" section and no resolveType provided`);
             return;
         }
         // Handle 1:N targets
         const targets = targetsPart.split(',').map(t => t.trim()).filter(Boolean);
         for (const targetId of targets) {
-            // Validate target node type
-            const tgtType = this.extractNodeType(targetId);
+            const tgtType = typeOf(targetId);
             if (!tgtType) {
-                errors.push(`Cannot extract node type from target: "${targetId}"`);
+                errors.push(`Cannot resolve type of target "${targetId}" — not declared under a "### <TYPE>" section and no resolveType provided`);
                 continue;
             }
             // Meta-model validation (CR-GC-247: single checker, patterns SSOT — honors
@@ -255,22 +300,6 @@ export class FormatECodec {
             sourceIds: parts,
         });
     }
-    extractNodeType(uid) {
-        const parts = uid.split('.');
-        // Format: Name.TYPE or Name.TYPE.Counter
-        if (parts.length >= 2) {
-            // Type is the last segment that matches a known type, or second-to-last
-            for (let i = parts.length - 1; i >= 1; i--) {
-                if (this.validNodeTypes.has(parts[i]))
-                    return parts[i];
-            }
-            // Fallback: second segment for 3-part IDs
-            if (parts.length >= 3)
-                return parts[parts.length - 2];
-            return parts[1];
-        }
-        return null;
-    }
     parseInlineAttrs(raw) {
         const attrs = {};
         for (const pair of raw.split(',')) {
@@ -281,6 +310,48 @@ export class FormatECodec {
         }
         return attrs;
     }
+    /**
+     * CR-SM-215: fan-out serialization — edges sharing `(sourceId, edgeType)` collapse
+     * onto one line `A -x-> B, C, D`. The source UID is written once instead of once per
+     * edge; on the graphcode SSOT graph that is 318 lines instead of 751.
+     *
+     * Two invariants:
+     * - **Edges carrying attributes stay single-line.** `serializeAttrs` binds to one
+     *   edge; a group would either drop `cardinality`/`constraint`/`notes` or wrongly
+     *   share one edge's attributes with its siblings.
+     * - **Deterministic order** (graphcode `REQ-deterministic-serialization`): entries
+     *   sorted by source, then edge type, then first target — code-unit order, not
+     *   `localeCompare`, which is locale-dependent.
+     */
+    serializeEdges(edges) {
+        const entries = [];
+        const groups = new Map();
+        for (const edge of edges) {
+            const attrs = this.serializeAttrs(edge.attributes);
+            if (attrs) {
+                entries.push({ sourceId: edge.sourceId, edgeType: edge.edgeType, targets: [edge.targetId], attrs });
+                continue;
+            }
+            const key = `${edge.sourceId}${edge.edgeType}`;
+            const group = groups.get(key);
+            if (group) {
+                group.targets.push(edge.targetId);
+            }
+            else {
+                const entry = { sourceId: edge.sourceId, edgeType: edge.edgeType, targets: [edge.targetId], attrs: '' };
+                groups.set(key, entry);
+                entries.push(entry);
+            }
+        }
+        const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        for (const entry of entries)
+            entry.targets.sort(cmp);
+        entries.sort((a, b) => cmp(a.sourceId, b.sourceId)
+            || cmp(a.edgeType, b.edgeType)
+            || cmp(a.targets[0], b.targets[0])
+            || cmp(a.attrs, b.attrs));
+        return entries.map(e => `+ ${e.sourceId} -${this.edgeTypeToArrow(e.edgeType)}-> ${e.targets.join(', ')}${e.attrs}`);
+    }
     serializeAttrs(attrs) {
         const entries = Object.entries(attrs).filter(([, v]) => v != null && v !== '');
         if (entries.length === 0)

package/dist/graph-service.js

@@ -8,8 +8,18 @@ import { isValidTrace, tracePatternsOf } from './types.js';
 import { FormatECodec } from './format-e-codec.js';
 import { DefaultRuleEngine } from './rule-engine.js';
 import { InMemoryAuditLog } from './audit.js';
-import { extractFromSemanticId } from '@sigloch/contracts/se';
 import { updateEdge, mergeNodes } from './edge-ops.js';
+/**
+ * CR-SM-216: a display name for a typed node, derived from the uid's *shape* only.
+ * `MOD-harness` → "harness", `Mower.PR.01` → "Mower", anything else → the uid itself.
+ * Purely cosmetic — the type never comes from here.
+ */
+function nameFromUid(uid, type) {
+    if (uid.startsWith(`${type}-`))
+        return uid.slice(type.length + 1);
+    const dot = uid.indexOf('.');
+    return dot > 0 ? uid.slice(0, dot) : uid;
+}
 export class GraphService {
     ontology;
     codec;
@@ -461,15 +471,16 @@ export class GraphService {
     async applyNodeCreate(op, isSESchema) {
         let type;
         let name;
-        if (isSESchema) {
-            try {
-                const { type: extractedType, name: extractedName } = extractFromSemanticId(op.semanticId);
-                type = extractedType;
-                name = extractedName;
-            }
-            catch {
-                throw new Error(`Invalid semantic ID: ${op.semanticId}`);
-            }
+        if (op.elementType) {
+            // CR-SM-216: the type travels with the operation (Format-E `### <TYPE>` section).
+            type = op.elementType;
+            name = nameFromUid(op.semanticId, type);
+        }
+        else if (isSESchema) {
+            // CR-SM-217: no id-derived typing for SE any more. A hand-built SE operation must
+            // name its type — guessing it from the uid is the CR-230 failure mode, and with
+            // `TYPE-slug` as the canon there is no counter to parse out of the id either.
+            throw new Error(`Node operation for "${op.semanticId}" carries no elementType — SE nodes must declare their type (Format-E: "### <TYPE>" section)`);
         }
         else {
             const parts = op.semanticId.split('.');

package/dist/se-descriptor.d.ts

@@ -18,7 +18,7 @@ import type { Graph, OntologyDescriptor } from './types.js';
  */
 export declare function projectToOntologyGraph(graph: Graph): OntologyGraph;
 /**
- * Canonical SE OntologyDescriptor (ontology + 17 rules), version-pinned to
- * contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
+ * Canonical SE OntologyDescriptor (ontology + V3 rules + MT metrics), version-pinned
+ * to contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
  */
 export declare const SE_DESCRIPTOR: OntologyDescriptor;

package/dist/se-descriptor.js

@@ -9,7 +9,7 @@
  *   - Graph (nodes/edges)        ⟷  OntologyGraph (elements/traces)
  *   - RuleViolation (ruleId/…)   ⟷  contracts RuleViolation (rule_id/…)
  */
-import { ElementType, TraceType, TRACE_PATTERNS, V3_RULES, ONTOLOGY_VERSION, } from '@sigloch/contracts/se';
+import { ElementType, TraceType, TRACE_PATTERNS, V3_RULES, MT_RULES, ONTOLOGY_VERSION, } from '@sigloch/contracts/se';
 /**
  * Project an ontology-agnostic Graph (nodes/edges) onto the SE OntologyGraph
  * (elements/traces) that contracts/se rules evaluate against. Type-specific
@@ -42,8 +42,16 @@ export function projectToOntologyGraph(graph) {
     }));
     return { elements, traces };
 }
-/** The 17 contracts/se V3_RULES, adapted to graph-api-core's Rule shape. */
-const SE_RULES = V3_RULES.map((def) => ({
+/**
+ * The contracts/se rule catalog, adapted to graph-api-core's Rule shape.
+ *
+ * V3_RULES + MT_RULES (CR-SM-222): the architecture metrics lived in contracts since
+ * K2 but ran only in aimpro's `evaluateAllRules`, so the governed repos (graphcode,
+ * graph-view-edit) never saw them. Same adapter, no fork — they inherit by
+ * consuming this descriptor. MT severities are warning/info, so they stay advisory
+ * in graphcode's gate.
+ */
+const SE_RULES = [...V3_RULES, ...MT_RULES].map((def) => ({
     id: def.id,
     name: def.name,
     severity: def.severity,
@@ -69,8 +77,8 @@ const edgeTypes = Object.fromEntries(TraceType.options.map((tt) => {
     return [tt, { arrows: [tt], validPairs: pairs.length ? pairs : [['*', '*']] }];
 }));
 /**
- * Canonical SE OntologyDescriptor (ontology + 17 rules), version-pinned to
- * contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
+ * Canonical SE OntologyDescriptor (ontology + V3 rules + MT metrics), version-pinned
+ * to contracts/se ONTOLOGY_VERSION. Plug into GraphService / FormatECodec.
  */
 export const SE_DESCRIPTOR = {
     name: 'se',

package/dist/types.d.ts

@@ -103,8 +103,21 @@ export interface FormatEOperation {
     type: 'add_node' | 'remove_node' | 'update_node' | 'add_edge' | 'remove_edge' | 'update_edge' | 'strict_add_node' | 'strict_add_edge' | 'merge_nodes';
     /** Node uid or edge key (source->target). */
     semanticId: string;
+    /**
+     * CR-SM-216: the node type, taken from the `### <TYPE>` section the node was declared
+     * under. Set on every node-creating operation. Consumers must read this instead of
+     * re-deriving a type from the uid — uid conventions differ per repo, and guessing
+     * from the spelling fails silently on the ones it does not recognise.
+     */
+    elementType?: string;
     description?: string;
-    attributes?: Record<string, string>;
+    /**
+     * BOK-CR-026: `unknown`, not `string` — object-valued bindings (`realRef`,
+     * `testRef`) must survive a Format-E mutation as objects, or the element reads as
+     * unbound. GraphService already handled them as unknown internally; this is the
+     * public type catching up (a plain `@key value` line still yields a string).
+     */
+    attributes?: Record<string, unknown>;
     sourceId?: string;
     targetId?: string;
     edgeType?: string;
@@ -114,7 +127,7 @@ export interface FormatEOperation {
     set?: {
         edgeType?: string;
         flip?: boolean;
-        attributes?: Record<string, string>;
+        attributes?: Record<string, unknown>;
     };
 }
 export interface FormatEDiff {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigloch/graph-api-core",
-  "version": "0.4.1",
+  "version": "2.0.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,7 +21,7 @@
     "prepublishOnly": "npm run build && npm run test"
   },
   "dependencies": {
-    "@sigloch/contracts": "^0.8.0",
+    "@sigloch/contracts": "^2.0.0",
     "zod": "^4.3.6"
   },
   "license": "MIT",

package/test-fixtures/cr-007-features.format-e.md

@@ -4,19 +4,31 @@ Exercises the reserved inline attributes from CR-007:
 - Nodes: `notes`
 - Edges: `cardinality`, `constraint`, `notes`
 
+Plus both serializer branches from CR-SM-215: attributed edges stay one per line,
+attribute-free edges of the same `(source, type)` collapse into one fan-out line.
+
 Uses the minimal `TEST_ONTOLOGY` shipped from `@sigloch/graph-api-core/test-fixtures`.
 
+Format-E **v2** (CR-SM-216): Typ aus dem `### <TYPE>`-Sektionsheader.
+
 ```format-e
 ## Nodes
+### PR
 + Mower.PR.01|Riding mower R15 [notes:Phase-2-Vertical-Slice-Wurzel]
+### C
 + Engine.C.01|Combustion engine [power:gas]
 + Gearbox.C.02|Mowing-deck gearbox family [kind:family,notes:drei Varianten geplant]
++ Blade.C.03|Mowing blade
++ Deck.C.04|Cutting deck shell
+### FR
 + DFMEA-Engine-001.FR.01|Not-Stop-Funktion am Motor [external_id:DFMEA-Engine-001]
+### CTRL
 + EmergencyBrake.CTRL.01|Mechanische Bremse Stillstandszeit max 5 sec
 
 ## Edges
 + Mower.PR.01 -compose-> Engine.C.01 [cardinality:1..1]
 + Mower.PR.01 -compose-> Gearbox.C.02 [cardinality:1..n,constraint:mindestens eine Variante je Schnittbreite]
++ Gearbox.C.02 -compose-> Blade.C.03, Deck.C.04
 + Engine.C.01 -addressed_by-> DFMEA-Engine-001.FR.01 [cardinality:1..n,notes:DFMEA-Hotspot]
 + DFMEA-Engine-001.FR.01 -addressed_by-> EmergencyBrake.CTRL.01 [cardinality:1..1,constraint:Stillstandszeit <= 5 sec]
 ```

package/test-fixtures/rasentraktor.format-e.md

@@ -7,24 +7,39 @@ sigloch-weit nutzbare Variante für CI-Smokes.
 
 Validiert gegen `TEST_ONTOLOGY` aus `@sigloch/graph-api-core/test-fixtures`.
 
+Format-E **v2** (CR-SM-216): der Typ steht im `### <TYPE>`-Sektionsheader, nicht in der UID.
+Die UIDs bleiben unverändert — sie werden nur nicht mehr als Typquelle gelesen.
+
 ```format-e
 ## Nodes
+### OU
 + Konstruktion.OU.01|Konstruktion
 + Tooling.OU.02|Tooling
+### R
 + DesignLead.R.01|Design Lead
 + Tooling.R.02|Tooling
+### PR
 + R15.PR.01|Rasentraktor R15 [code:R15]
+### VAR
 + R15-1000.VAR.01|R15 mit 1000 mm Schnittbreite [attribute_key:Schnittbreite,attribute_value:1000mm]
 + R15-1500.VAR.02|R15 mit 1500 mm Schnittbreite [attribute_key:Schnittbreite,attribute_value:1500mm]
+### C
 + MaehwerkGetriebe.C.01|Maehwerk-Getriebe Familie [kind:family]
 + Getriebe-1000.C.02|Getriebe 1000 [kind:variant,part_no:MG-1000]
 + Getriebe-1500.C.03|Getriebe 1500 [kind:variant,part_no:MG-1500]
+### F
 + UnterschiedlicheMaehbreiten.F.01|Unterschiedliche Maehbreiten [customer_priority:hoch]
+### FR
 + DFMEA-MG-001.FR.01|Not-Stop-Funktion [external_id:DFMEA-MG-001,status:verifiziert]
+### CTRL
 + MechBremse.CTRL.01|Mechanische Bremse Stillstandszeit max 5 sec
+### TC
 + Stillstandszeitmessung.TC.01|Stillstandszeit-Messung nach Not-Aus [criterion:t_stop <= 5 sec]
+### TL
 + WerkzeugSetGehaeuse.TL.01|Werkzeug-Set Gehaeuse Druckguss [material:Aluminium-Druckguss]
+### MT
 + M3.MT.01|GO Milestone [sequence_no:3]
+### SL
 + PDM.SL.01|PDM-System [type:PLM]
 
 ## Edges