@graph-artifact/core 0.1.0

package/dist/parsers/er.js

@@ -0,0 +1,97 @@
+import { prep } from './helpers.js';
+/**
+ * Maps Mermaid ER cardinality symbols to semantic values.
+ *
+ * Symbols (from Mermaid's JISON grammar):
+ *   ||  → ONLY_ONE
+ *   o|  → ZERO_OR_ONE
+ *   |o  → ZERO_OR_ONE
+ *   o{  → ZERO_OR_MORE
+ *   }o  → ZERO_OR_MORE
+ *   |{  → ONE_OR_MORE
+ *   }|  → ONE_OR_MORE
+ */
+function parseCardinality(symbol) {
+    switch (symbol) {
+        case '||': return 'ONLY_ONE';
+        case 'o|':
+        case '|o': return 'ZERO_OR_ONE';
+        case 'o{':
+        case '}o': return 'ZERO_OR_MORE';
+        case '|{':
+        case '}|': return 'ONE_OR_MORE';
+        default: return 'ONLY_ONE';
+    }
+}
+export function parseErDiagram(syntax) {
+    const lines = prep(syntax);
+    if (!lines.some(l => /^erDiagram$/i.test(l)))
+        return null;
+    const nodeMap = new Map();
+    const edges = [];
+    const entityAttrs = new Map();
+    let currentEntity = null;
+    for (const line of lines) {
+        if (/^erDiagram$/i.test(line))
+            continue;
+        // Relationship: ENTITY1 <cardL><relType><cardR> ENTITY2 : label
+        // cardL/cardR are 1-2 chars from |o{}
+        // relType is -- (identifying) or .. (non-identifying)
+        const rel = line.match(/^(\w+)\s+([|o}{]{1,2})(-{2}|\.{2})([|o}{]{1,2})\s+(\w+)\s*:\s*(.+)/);
+        if (rel) {
+            const src = rel[1];
+            const leftCard = rel[2];
+            const rightCard = rel[4];
+            const tgt = rel[5];
+            const label = rel[6].trim().replace(/^["']|["']$/g, '');
+            if (!nodeMap.has(src))
+                nodeMap.set(src, { id: src, label: src, shape: 'rect', attributes: [] });
+            if (!nodeMap.has(tgt))
+                nodeMap.set(tgt, { id: tgt, label: tgt, shape: 'rect', attributes: [] });
+            edges.push({
+                source: src,
+                target: tgt,
+                label,
+                // Keep token assignment aligned with source syntax adjacency:
+                // left token belongs to source entity, right token belongs to target entity.
+                cardSource: parseCardinality(leftCard),
+                cardTarget: parseCardinality(rightCard),
+                cardSourceToken: leftCard,
+                cardTargetToken: rightCard,
+            });
+            currentEntity = null;
+            continue;
+        }
+        // Entity block open
+        const blockOpen = line.match(/^(\w+)\s*\{$/);
+        if (blockOpen) {
+            const name = blockOpen[1];
+            if (!nodeMap.has(name))
+                nodeMap.set(name, { id: name, label: name, shape: 'rect', attributes: [] });
+            currentEntity = name;
+            if (!entityAttrs.has(name))
+                entityAttrs.set(name, []);
+            continue;
+        }
+        if (line === '}') {
+            currentEntity = null;
+            continue;
+        }
+        // Attribute line: type name PK/FK/UK
+        if (currentEntity) {
+            const attr = line.match(/^(\w+)\s+(\w+)(?:\s+(PK|FK|UK))?/);
+            if (attr) {
+                const marker = attr[3] ? ` ${attr[3]}` : '';
+                entityAttrs.get(currentEntity)?.push(`${attr[1]} ${attr[2]}${marker}`);
+            }
+        }
+    }
+    if (nodeMap.size === 0)
+        return null;
+    for (const [id, attrs] of entityAttrs) {
+        const node = nodeMap.get(id);
+        if (node)
+            node.attributes = attrs;
+    }
+    return { kind: 'graph', direction: 'TB', diagramType: 'er', nodes: Array.from(nodeMap.values()), edges };
+}

package/dist/parsers/flowchart.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedGraph } from '../types.js';
+export declare function parseFlowchart(syntax: string): ParsedGraph | null;

package/dist/parsers/flowchart.js

@@ -0,0 +1,191 @@
+import { prep, cleanLabel } from './helpers.js';
+export function parseFlowchart(syntax) {
+    const lines = prep(syntax);
+    const declLine = lines.find(l => /^(graph|flowchart)\s+(TB|TD|LR|BT|RL)/i.test(l));
+    if (!declLine)
+        return null;
+    const dirMatch = declLine.match(/^(?:graph|flowchart)\s+(TB|TD|LR|BT|RL)/i);
+    const direction = (dirMatch?.[1]?.toUpperCase() === 'TD' ? 'TB' : dirMatch?.[1]?.toUpperCase() ?? 'TB');
+    const nodeMap = new Map();
+    const edges = [];
+    const subgraphs = [];
+    // Tracks which subgraph owns each node (first assignment wins)
+    const nodeOwner = new Map();
+    // Subgraph parsing stack
+    const subgraphStack = [];
+    function addToCurrentSubgraph(nodeId) {
+        if (subgraphStack.length === 0)
+            return;
+        if (nodeOwner.has(nodeId))
+            return; // already claimed by another subgraph
+        const current = subgraphStack[subgraphStack.length - 1];
+        if (!current.nodeIds.includes(nodeId)) {
+            current.nodeIds.push(nodeId);
+            nodeOwner.set(nodeId, current.id);
+        }
+    }
+    for (const line of lines) {
+        if (/^(graph|flowchart)\s/i.test(line))
+            continue;
+        if (/^(classDef|class|style|click)\s/i.test(line))
+            continue;
+        if (/^direction\s/i.test(line))
+            continue;
+        // Subgraph start
+        const subgraphMatch = line.match(/^subgraph\s+([^\s[]+)(?:\s*\[([^\]]*)\])?(?:\s+(.*))?/i);
+        if (subgraphMatch) {
+            const id = subgraphMatch[1];
+            const label = subgraphMatch[2]
+                ? cleanLabel(subgraphMatch[2])
+                : subgraphMatch[3]
+                    ? cleanLabel(subgraphMatch[3])
+                    : id;
+            subgraphStack.push({ id, label, nodeIds: [] });
+            continue;
+        }
+        // Subgraph end
+        if (/^end$/i.test(line)) {
+            const completed = subgraphStack.pop();
+            if (completed)
+                subgraphs.push(completed);
+            continue;
+        }
+        const edgeResult = parseEdgeLine(line, nodeMap);
+        if (edgeResult) {
+            edges.push(...edgeResult);
+            // Track nodes in current subgraph — only claim unclaimed nodes
+            for (const edge of edgeResult) {
+                addToCurrentSubgraph(edge.source);
+                addToCurrentSubgraph(edge.target);
+            }
+            continue;
+        }
+        const node = parseNodeDef(line);
+        if (node) {
+            if (!nodeMap.has(node.id))
+                nodeMap.set(node.id, node);
+            addToCurrentSubgraph(node.id);
+        }
+    }
+    // Mermaid allows edges to/from subgraph IDs. Our internal graph expects
+    // edge endpoints to resolve to concrete node IDs, so map subgraph endpoints
+    // to representative member nodes.
+    const subgraphMap = new Map(subgraphs.map((sg) => [sg.id, sg]));
+    // Remove placeholder bare nodes that were introduced by edge parsing
+    // before we encountered `subgraph <id> ... end`.
+    for (const sg of subgraphs) {
+        nodeMap.delete(sg.id);
+    }
+    const resolvedEdges = [];
+    for (const edge of edges) {
+        const source = resolveFlowEndpoint(edge.source, 'source', nodeMap, subgraphMap);
+        const target = resolveFlowEndpoint(edge.target, 'target', nodeMap, subgraphMap);
+        if (!source || !target)
+            continue;
+        resolvedEdges.push({ ...edge, source, target });
+    }
+    return {
+        kind: 'graph',
+        direction,
+        diagramType: 'flowchart',
+        nodes: Array.from(nodeMap.values()),
+        edges: resolvedEdges,
+        subgraphs: subgraphs.length > 0 ? subgraphs : undefined,
+    };
+}
+function resolveFlowEndpoint(endpoint, role, nodeMap, subgraphMap) {
+    const sg = subgraphMap.get(endpoint);
+    if (sg && sg.nodeIds.length > 0) {
+        // Heuristic anchor selection:
+        // - source endpoint (subgraph -> node): use the last member encountered
+        // - target endpoint (node -> subgraph): use the first member encountered
+        return role === 'source'
+            ? sg.nodeIds[sg.nodeIds.length - 1]
+            : sg.nodeIds[0];
+    }
+    if (nodeMap.has(endpoint))
+        return endpoint;
+    return null;
+}
+// ─── Arrow Classification ─────────────────────────────────────────────────────
+function classifyArrow(arrow) {
+    if (/^={2,3}>$/.test(arrow))
+        return 'thick';
+    if (/^-?\.+-?>$/.test(arrow))
+        return 'dashed';
+    return 'solid';
+}
+// ─── Edge Parsing ─────────────────────────────────────────────────────────────
+function parseEdgeLine(line, nodeMap) {
+    if (!/(--+>|=+>|-?\.{1,2}-?>|--+|==[^=])/.test(line))
+        return null;
+    const results = [];
+    let prevNodeId = null;
+    let lastArrowType = 'solid';
+    let lastLabel;
+    // Split on arrow tokens: -->, ===>, -.->  AND  ==label==>  (thick with inline label)
+    // Also matches .-> and ..-> (dashed arrows without leading hyphen)
+    for (const rawPart of line.split(/(--+>|={2,3}>|-?\.+-?>|==[^=].*?=+>)/)) {
+        const part = rawPart.trim();
+        if (!part)
+            continue;
+        // Check for thick edge with inline label: ==label==>
+        const thickLabel = part.match(/^==\s*([^=].*?)\s*=+>$/);
+        if (thickLabel) {
+            lastArrowType = 'thick';
+            lastLabel = thickLabel[1].trim();
+            continue;
+        }
+        // Check if this part is a plain arrow token
+        if (/^(--+>|={2,3}>|-?\.+-?>|--+)$/.test(part)) {
+            lastArrowType = classifyArrow(part);
+            continue;
+        }
+        let label = lastLabel;
+        lastLabel = undefined;
+        let nodePart = part;
+        const lb = nodePart.match(/^\|([^|]*)\|\s*(.*)/);
+        if (lb) {
+            label = lb[1].trim();
+            nodePart = lb[2];
+        }
+        const la = nodePart.match(/(.*?)\s*\|([^|]*)\|$/);
+        if (la && !label) {
+            nodePart = la[1];
+            label = la[2].trim();
+        }
+        const node = parseNodeDef(nodePart.trim());
+        if (!node)
+            continue;
+        if (!nodeMap.has(node.id))
+            nodeMap.set(node.id, node);
+        if (prevNodeId) {
+            results.push({ source: prevNodeId, target: node.id, label, edgeType: lastArrowType });
+        }
+        prevNodeId = node.id;
+    }
+    return results.length > 0 ? results : null;
+}
+// ─── Node Definition Parsing ──────────────────────────────────────────────────
+function parseNodeDef(text) {
+    const t = text.trim();
+    if (!t)
+        return null;
+    const patterns = [
+        [/^([A-Za-z0-9_]+)\s*\{([^}]*)\}/, 'diamond'],
+        [/^([A-Za-z0-9_]+)\s*\(\(([^)]*)\)\)/, 'circle'],
+        [/^([A-Za-z0-9_]+)\s*\(\[([^\]]*)\]\)/, 'stadium'],
+        [/^([A-Za-z0-9_]+)\s*\[\(([^)]*)\)\]/, 'cylinder'],
+        [/^([A-Za-z0-9_]+)\s*\(([^)]*)\)/, 'round'],
+        [/^([A-Za-z0-9_]+)\s*\[([^\]]*)\]/, 'rect'],
+    ];
+    for (const [regex, shape] of patterns) {
+        const m = t.match(regex);
+        if (m)
+            return { id: m[1], label: cleanLabel(m[2]), shape };
+    }
+    const bare = t.match(/^([A-Za-z0-9_]+)$/);
+    if (bare)
+        return { id: bare[1], label: bare[1], shape: 'rect' };
+    return null;
+}

package/dist/parsers/helpers.d.ts

@@ -0,0 +1,4 @@
+/** Trim lines, strip blanks and comments */
+export declare function prep(syntax: string): string[];
+/** Strip surrounding quotes and HTML entities */
+export declare function cleanLabel(raw: string): string;

package/dist/parsers/helpers.js

@@ -0,0 +1,8 @@
+/** Trim lines, strip blanks and comments */
+export function prep(syntax) {
+    return syntax.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('%%'));
+}
+/** Strip surrounding quotes and HTML entities */
+export function cleanLabel(raw) {
+    return raw.replace(/^["']|["']$/g, '').replace(/#quot;/g, '"').trim();
+}

package/dist/parsers/index.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedDiagram } from '../types.js';
+/**
+ * Parse diagram syntax into a React Flow–compatible graph.
+ *
+ * Tries each parser in order. Returns null for unsupported types.
+ */
+export declare function parseMermaid(syntax: string): ParsedDiagram | null;

package/dist/parsers/index.js

@@ -0,0 +1,19 @@
+import { detectDiagramPlugin } from '../diagrams/detect.js';
+function normalizeMermaidSyntax(syntax) {
+    const trimmed = syntax.trim();
+    // Accept fenced mermaid blocks from LLM/chat outputs.
+    const fenced = trimmed.match(/^```(?:mermaid)?\s*([\s\S]*?)\s*```$/i);
+    return fenced ? fenced[1].trim() : syntax;
+}
+/**
+ * Parse diagram syntax into a React Flow–compatible graph.
+ *
+ * Tries each parser in order. Returns null for unsupported types.
+ */
+export function parseMermaid(syntax) {
+    const normalized = normalizeMermaidSyntax(syntax);
+    const plugin = detectDiagramPlugin(normalized);
+    if (!plugin)
+        return null;
+    return plugin.parse(normalized);
+}

package/dist/parsers/mindmap.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedGraph } from '../types.js';
+export declare function parseMindmap(syntax: string): ParsedGraph | null;

package/dist/parsers/mindmap.js

@@ -0,0 +1,124 @@
+import { cleanLabel } from './helpers.js';
+function parseLines(syntax) {
+    const out = [];
+    for (const raw of syntax.split('\n')) {
+        if (!raw.trim())
+            continue;
+        if (raw.trimStart().startsWith('%%'))
+            continue;
+        const leading = raw.match(/^\s*/)?.[0] ?? '';
+        const indent = leading.replace(/\t/g, '  ').length;
+        const text = raw.trim();
+        out.push({ indent, text });
+    }
+    return out;
+}
+function normalizeMindmapText(text) {
+    // Remove Mermaid mindmap decorators/classes/icons if present
+    return text
+        .replace(/::icon\([^)]*\)/g, '')
+        .replace(/:::[A-Za-z0-9_-]+/g, '')
+        .trim();
+}
+function parseNodeToken(raw) {
+    const text = normalizeMindmapText(raw);
+    // Explicit id + shaped label forms, e.g. a((Root)), b[Item], c(Item)
+    const withShape = text.match(/^([A-Za-z0-9_-]+)\s*(\(\(.+\)\)|\(.+\)|\[.+\]|\{\{.+\}\})$/);
+    if (withShape) {
+        const idHint = withShape[1];
+        const shapePart = withShape[2];
+        if (shapePart.startsWith('((') && shapePart.endsWith('))')) {
+            return { idHint, label: cleanLabel(shapePart.slice(2, -2)), shape: 'circle' };
+        }
+        if (shapePart.startsWith('(') && shapePart.endsWith(')')) {
+            return { idHint, label: cleanLabel(shapePart.slice(1, -1)), shape: 'round' };
+        }
+        if (shapePart.startsWith('[') && shapePart.endsWith(']')) {
+            return { idHint, label: cleanLabel(shapePart.slice(1, -1)), shape: 'rect' };
+        }
+        if (shapePart.startsWith('{{') && shapePart.endsWith('}}')) {
+            return { idHint, label: cleanLabel(shapePart.slice(2, -2)), shape: 'diamond' };
+        }
+    }
+    if (text.startsWith('((') && text.endsWith('))')) {
+        return { idHint: cleanLabel(text.slice(2, -2)), label: cleanLabel(text.slice(2, -2)), shape: 'circle' };
+    }
+    if (text.startsWith('(') && text.endsWith(')')) {
+        return { idHint: cleanLabel(text.slice(1, -1)), label: cleanLabel(text.slice(1, -1)), shape: 'round' };
+    }
+    if (text.startsWith('[') && text.endsWith(']')) {
+        return { idHint: cleanLabel(text.slice(1, -1)), label: cleanLabel(text.slice(1, -1)), shape: 'rect' };
+    }
+    if (text.startsWith('{{') && text.endsWith('}}')) {
+        return { idHint: cleanLabel(text.slice(2, -2)), label: cleanLabel(text.slice(2, -2)), shape: 'diamond' };
+    }
+    // Bare text or id-only node
+    const bare = cleanLabel(text);
+    return { idHint: bare, label: bare, shape: 'rect' };
+}
+function slug(input) {
+    const s = input.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    return s || 'node';
+}
+export function parseMindmap(syntax) {
+    const lines = parseLines(syntax);
+    if (lines.length === 0)
+        return null;
+    if (!/^mindmap\b/i.test(lines[0].text))
+        return null;
+    const nodeMap = new Map();
+    const edges = [];
+    const stack = [];
+    const idCounts = new Map();
+    let nextBranchIndex = 0;
+    const makeUniqueId = (hint) => {
+        const base = slug(hint);
+        const current = idCounts.get(base) ?? 0;
+        idCounts.set(base, current + 1);
+        return current === 0 ? base : `${base}_${current}`;
+    };
+    for (let i = 1; i < lines.length; i++) {
+        const { indent, text } = lines[i];
+        let nodeText = text;
+        if (/^root\b/i.test(nodeText)) {
+            nodeText = nodeText.replace(/^root\b/i, '').trim();
+            if (!nodeText)
+                nodeText = 'Root';
+        }
+        const parsed = parseNodeToken(nodeText);
+        const id = makeUniqueId(parsed.idHint || parsed.label);
+        nodeMap.set(id, {
+            id,
+            label: parsed.label,
+            shape: parsed.shape,
+        });
+        while (stack.length > 0 && indent <= stack[stack.length - 1].indent) {
+            stack.pop();
+        }
+        const parent = stack[stack.length - 1];
+        const depth = parent ? parent.depth + 1 : 0;
+        const branchIndex = parent
+            ? (depth === 1 ? nextBranchIndex++ : parent.branchIndex)
+            : -1;
+        if (parent) {
+            edges.push({
+                source: parent.id,
+                target: id,
+                edgeType: 'solid',
+                noArrow: true,
+                treeDepth: depth,
+                branchIndex,
+            });
+        }
+        stack.push({ indent, id, depth, branchIndex });
+    }
+    if (nodeMap.size === 0)
+        return null;
+    return {
+        kind: 'graph',
+        direction: 'LR',
+        diagramType: 'mindmap',
+        nodes: Array.from(nodeMap.values()),
+        edges,
+    };
+}

package/dist/parsers/sequence.d.ts

@@ -0,0 +1,18 @@
+/**
+ * sequence.ts — Parser for Mermaid sequenceDiagram syntax.
+ *
+ * Extracts participants, messages, notes, and control blocks (alt/loop/opt/etc.)
+ * into a structured SequenceData object. The parsed result uses diagramType 'sequence'
+ * and carries data in the `sequence` field rather than nodes/edges.
+ *
+ * Supported syntax:
+ *   - participant/actor declarations
+ *   - Solid arrows: ->>, ->>
+ *   - Dashed arrows: -->>, -->>
+ *   - Open arrows: ->, -->
+ *   - Notes: Note left/right/over
+ *   - Blocks: alt/else/opt/loop/par/critical/break/rect
+ *   - autonumber
+ */
+import type { ParsedGraph } from '../types.js';
+export declare function parseSequenceDiagram(syntax: string): ParsedGraph | null;

package/dist/parsers/sequence.js

@@ -0,0 +1,196 @@
+/**
+ * sequence.ts — Parser for Mermaid sequenceDiagram syntax.
+ *
+ * Extracts participants, messages, notes, and control blocks (alt/loop/opt/etc.)
+ * into a structured SequenceData object. The parsed result uses diagramType 'sequence'
+ * and carries data in the `sequence` field rather than nodes/edges.
+ *
+ * Supported syntax:
+ *   - participant/actor declarations
+ *   - Solid arrows: ->>, ->>
+ *   - Dashed arrows: -->>, -->>
+ *   - Open arrows: ->, -->
+ *   - Notes: Note left/right/over
+ *   - Blocks: alt/else/opt/loop/par/critical/break/rect
+ *   - autonumber
+ */
+import { prep } from './helpers.js';
+// ─── Arrow Classification ─────────────────────────────────────────────────────
+const ARROW_PATTERNS = [
+    [/^-->>$/, 'dashed'], // dashed with arrowhead
+    [/^->>$/, 'solid'], // solid with arrowhead
+    [/^-->$/, 'dashed_open'], // dashed open (no arrowhead)
+    [/^->$/, 'solid_open'], // solid open (no arrowhead)
+    [/^--x$/i, 'dashed'], // dashed with cross
+    [/^-x$/i, 'solid'], // solid with cross
+    [/^--\)$/, 'dashed'], // dashed async
+    [/^-\)$/, 'solid'], // solid async
+];
+function classifyArrow(arrow) {
+    for (const [regex, type] of ARROW_PATTERNS) {
+        if (regex.test(arrow))
+            return type;
+    }
+    return 'solid';
+}
+// ─── Block Type Detection ──────────────────────────────────────────────────────
+const BLOCK_KEYWORDS = [
+    'alt', 'else', 'opt', 'loop', 'par', 'critical', 'break', 'rect',
+];
+function isBlockStart(line) {
+    const lower = line.toLowerCase();
+    for (const keyword of BLOCK_KEYWORDS) {
+        if (keyword === 'else')
+            continue; // 'else' is handled as section within alt
+        if (lower.startsWith(keyword + ' ') || lower === keyword) {
+            const label = line.slice(keyword.length).trim();
+            return { type: keyword, label };
+        }
+    }
+    return null;
+}
+// ─── Main Parser ──────────────────────────────────────────────────────────────
+export function parseSequenceDiagram(syntax) {
+    const lines = prep(syntax);
+    if (!lines.some(l => /^sequenceDiagram$/i.test(l)))
+        return null;
+    const participantMap = new Map();
+    const messages = [];
+    const blocks = [];
+    const notes = [];
+    let autonumber = false;
+    // Participant ordering — tracks discovery order
+    const participantOrder = [];
+    function ensureParticipant(id, label, type = 'participant') {
+        if (participantMap.has(id))
+            return;
+        participantMap.set(id, { id, label: label ?? id, type });
+        participantOrder.push(id);
+    }
+    // Block stack for nested alt/loop/opt etc.
+    const blockStack = [];
+    // Message arrow regex: captures participant names with possible spaces
+    // Format: Alice->>Bob: Hello  OR  Alice -->> Bob : Hello
+    const messageRegex = /^(.+?)\s*(-->>|--x|->>|-->|->|-x|--\)|-\))\s*(.+?)\s*:\s*(.*)$/i;
+    // Participant/actor declaration regex
+    const participantDeclRegex = /^(participant|actor)\s+(\S+)(?:\s+as\s+(.+))?$/i;
+    // Note regex
+    const noteRegex = /^note\s+(left of|right of|over)\s+(.+?)\s*:\s*(.+)$/i;
+    for (const line of lines) {
+        // Skip the declaration line
+        if (/^sequenceDiagram$/i.test(line))
+            continue;
+        // autonumber
+        if (/^autonumber$/i.test(line)) {
+            autonumber = true;
+            continue;
+        }
+        // Skip directives and style commands
+        if (/^(title|%%|activate|deactivate|destroy)\s/i.test(line))
+            continue;
+        if (/^(title|activate|deactivate|destroy)$/i.test(line))
+            continue;
+        // Participant/actor declaration
+        const participantMatch = line.match(participantDeclRegex);
+        if (participantMatch) {
+            const type = participantMatch[1].toLowerCase();
+            const id = participantMatch[2];
+            const label = participantMatch[3]?.trim() ?? id;
+            ensureParticipant(id, label, type);
+            continue;
+        }
+        // Note
+        const noteMatch = line.match(noteRegex);
+        if (noteMatch) {
+            const placementStr = noteMatch[1].toLowerCase();
+            const participantStr = noteMatch[2].trim();
+            const text = noteMatch[3].trim();
+            let placement;
+            if (placementStr === 'left of')
+                placement = 'left';
+            else if (placementStr === 'right of')
+                placement = 'right';
+            else
+                placement = 'over';
+            // "over Alice,Bob" → multiple participants
+            const participantIds = participantStr.split(',').map(p => p.trim());
+            for (const pid of participantIds)
+                ensureParticipant(pid);
+            notes.push({
+                text,
+                placement,
+                participants: participantIds,
+                messageIndex: messages.length,
+            });
+            continue;
+        }
+        // Block end
+        if (/^end$/i.test(line)) {
+            const completed = blockStack.pop();
+            if (completed) {
+                blocks.push({
+                    type: completed.type,
+                    label: completed.label,
+                    startIndex: completed.startIndex,
+                    endIndex: messages.length,
+                    sections: completed.sections.length > 0 ? completed.sections : undefined,
+                });
+            }
+            continue;
+        }
+        // Else section (within alt/par)
+        if (/^else\b/i.test(line)) {
+            const label = line.slice(4).trim();
+            if (blockStack.length > 0) {
+                const current = blockStack[blockStack.length - 1];
+                current.sections.push({ label, startIndex: messages.length });
+            }
+            continue;
+        }
+        // Block start (alt/opt/loop/par/critical/break/rect)
+        const blockStart = isBlockStart(line);
+        if (blockStart) {
+            blockStack.push({
+                type: blockStart.type,
+                label: blockStart.label,
+                startIndex: messages.length,
+                sections: [],
+            });
+            continue;
+        }
+        // Message
+        const messageMatch = line.match(messageRegex);
+        if (messageMatch) {
+            const from = messageMatch[1].trim();
+            const arrow = messageMatch[2].trim();
+            const to = messageMatch[3].trim();
+            const label = messageMatch[4].trim();
+            ensureParticipant(from);
+            ensureParticipant(to);
+            messages.push({
+                from,
+                to,
+                label,
+                arrowType: classifyArrow(arrow),
+            });
+            continue;
+        }
+    }
+    // Need at least some participants or messages
+    if (participantMap.size === 0 && messages.length === 0)
+        return null;
+    return {
+        kind: 'graph',
+        direction: 'TB',
+        diagramType: 'sequence',
+        nodes: [],
+        edges: [],
+        sequence: {
+            participants: participantOrder.map(id => participantMap.get(id)),
+            messages,
+            blocks: blocks.length > 0 ? blocks : undefined,
+            notes: notes.length > 0 ? notes : undefined,
+            autonumber,
+        },
+    };
+}

package/dist/parsers/state.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedGraph } from '../types.js';
+export declare function parseStateDiagram(syntax: string): ParsedGraph | null;