@graph-artifact/core 0.1.0

package/dist/layout/sequenceLayout.js

@@ -0,0 +1,414 @@
+/**
+ * sequenceLayout.ts — Grid-based layout for sequence diagrams.
+ *
+ * Sequence diagrams don't use dagre. Instead we lay out participants
+ * in a fixed horizontal row and create invisible anchor nodes along
+ * each lifeline at each message row. Edges connect anchor-to-anchor.
+ *
+ * Message labels are rendered as positioned node components (above the line),
+ * not as React Flow edge labels. Autonumber indicators appear as numbered
+ * circles on the source lifeline.
+ *
+ * Row heights are computed dynamically based on content — multi-line labels
+ * and notes get more vertical space so nothing overlaps.
+ *
+ * Notes span the full width between the participants they're attached to,
+ * matching standard sequence diagram rendering.
+ */
+import { MarkerType } from '@xyflow/react';
+import { getConfig } from '../config.js';
+// ─── Layout Constants ──────────────────────────────────────────────────────
+const PARTICIPANT_WIDTH = 150;
+const PARTICIPANT_HEIGHT = 40;
+const PARTICIPANT_GAP = 60;
+const BASE_MESSAGE_ROW_HEIGHT = 55;
+const SELF_MESSAGE_EXTRA = 30;
+const LABEL_LINE_HEIGHT = 16;
+const LABEL_GAP_BELOW = 6;
+const TOP_PADDING = 20;
+const LEFT_PADDING = 40;
+const LIFELINE_START_OFFSET = 40;
+const BOTTOM_PARTICIPANT_GAP = 40;
+const ANCHOR_WIDTH = 2;
+const ANCHOR_HEIGHT = 2;
+const NOTE_BASE_HEIGHT = 36;
+const NOTE_LINE_HEIGHT = 16;
+const NOTE_OFFSET_X = 10;
+const NOTE_VERTICAL_GAP = 20;
+const NOTE_PADDING_INNER = 12;
+const BLOCK_PADDING_X = 20;
+const BLOCK_PADDING_TOP = 30;
+const BLOCK_PADDING_BOTTOM = 15;
+const NUMBER_CIRCLE_SIZE = 22;
+const CHAR_WIDTH_ESTIMATE = 6;
+// ─── Helpers ───────────────────────────────────────────────────────────────
+function cleanBrTags(text) {
+    return text.replace(/<br\s*\/?>/gi, '\n');
+}
+function estimateTextHeight(text, containerWidth, lineHeight, charWidthEstimate) {
+    const lines = text.split('\n');
+    let totalLines = 0;
+    for (const line of lines) {
+        const charsPerLine = Math.max(1, Math.floor(containerWidth / charWidthEstimate));
+        totalLines += Math.max(1, Math.ceil(line.length / charsPerLine));
+    }
+    return totalLines * lineHeight;
+}
+function participantX(index, leftPadding, participantWidth, participantGap) {
+    return leftPadding + index * (participantWidth + participantGap);
+}
+function participantCenterX(index, leftPadding, participantWidth, participantGap) {
+    return participantX(index, leftPadding, participantWidth, participantGap) + participantWidth / 2;
+}
+function computeNoteGeometry(text, placement, participantIds, participantIndex, seq) {
+    const firstPIdx = participantIndex.get(participantIds[0]) ?? 0;
+    let x;
+    let width;
+    if (placement === 'over') {
+        if (participantIds.length >= 2) {
+            const lastPIdx = participantIndex.get(participantIds[participantIds.length - 1]) ?? 0;
+            const minIdx = Math.min(firstPIdx, lastPIdx);
+            const maxIdx = Math.max(firstPIdx, lastPIdx);
+            // Span between lifeline centers + small margin
+            x = participantCenterX(minIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - 10;
+            width =
+                participantCenterX(maxIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)
+                    - participantCenterX(minIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)
+                    + 20;
+        }
+        else {
+            width = seq.participantWidth + 20;
+            x = participantCenterX(firstPIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - width / 2;
+        }
+    }
+    else if (placement === 'right') {
+        width = seq.participantWidth;
+        x = participantX(firstPIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)
+            + seq.participantWidth + seq.noteOffsetX;
+    }
+    else {
+        width = seq.participantWidth;
+        x = participantX(firstPIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)
+            - seq.participantWidth - seq.noteOffsetX;
+    }
+    const textH = estimateTextHeight(text, width - seq.notePaddingInner * 2, seq.noteLineHeight, seq.textCharWidthEstimate);
+    const height = Math.max(seq.noteBaseHeight, textH + 12);
+    return { x, width, height };
+}
+// ─── Main Layout ───────────────────────────────────────────────────────────
+export function layoutSequenceDiagram(sequence, theme, metadata) {
+    const seq = getConfig().layout.sequence;
+    const nodes = [];
+    const edges = [];
+    const participantIndex = new Map();
+    sequence.participants.forEach((p, i) => {
+        participantIndex.set(p.id, i);
+    });
+    // ── Pre-compute cleaned text ──
+    const cleanedLabels = sequence.messages.map(m => cleanBrTags(m.label));
+    const cleanedNotes = sequence.notes
+        ? sequence.notes.map(n => cleanBrTags(n.text))
+        : [];
+    // ── Label heights ──
+    const labelHeights = sequence.messages.map((msg, mi) => {
+        const label = cleanedLabels[mi];
+        if (!label)
+            return 0;
+        const fromIdx = participantIndex.get(msg.from) ?? 0;
+        const toIdx = participantIndex.get(msg.to) ?? 0;
+        if (msg.from === msg.to) {
+            return estimateTextHeight(label, 120, seq.labelLineHeight, seq.textCharWidthEstimate);
+        }
+        const availableWidth = Math.abs(participantCenterX(toIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)
+            - participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap)) - 20;
+        return estimateTextHeight(label, Math.max(availableWidth, 80), seq.labelLineHeight, seq.textCharWidthEstimate);
+    });
+    // ── Note geometries ──
+    const noteGeos = sequence.notes
+        ? sequence.notes.map((note, ni) => computeNoteGeometry(cleanedNotes[ni], note.placement, note.participants, participantIndex, seq))
+        : [];
+    // ── Compute message Y positions ──
+    // Each message row is tall enough for its label above the line.
+    // Notes consume their own vertical rows before the message they precede.
+    const lifelineStartY = seq.topPadding + seq.participantHeight + seq.lifelineStartOffset;
+    const messageY = [];
+    const noteYPositions = new Map();
+    let currentY = lifelineStartY;
+    const noteSpaceBefore = new Map();
+    if (sequence.notes) {
+        for (let ni = 0; ni < sequence.notes.length; ni++) {
+            const group = noteSpaceBefore.get(sequence.notes[ni].messageIndex) ?? [];
+            group.push(ni);
+            noteSpaceBefore.set(sequence.notes[ni].messageIndex, group);
+        }
+    }
+    for (let mi = 0; mi < sequence.messages.length; mi++) {
+        // Notes that appear before this message
+        const notesBefore = noteSpaceBefore.get(mi);
+        if (notesBefore) {
+            for (const ni of notesBefore) {
+                noteYPositions.set(ni, currentY);
+                currentY += noteGeos[ni].height + seq.noteVerticalGap;
+            }
+        }
+        // The label sits ABOVE the arrow. The arrow sits at `messageY[mi]`.
+        // We need enough space above the arrow for the label, so we push
+        // the arrow down by the label height.
+        const labelH = labelHeights[mi];
+        if (labelH > seq.labelLineHeight) {
+            // Multi-line label — add extra space so the label doesn't overlap
+            // things above (like participant headers or previous message)
+            currentY += labelH - seq.labelLineHeight;
+        }
+        messageY.push(currentY);
+        const isSelf = sequence.messages[mi].from === sequence.messages[mi].to;
+        const rowHeight = Math.max(seq.baseMessageRowHeight, seq.labelLineHeight + seq.labelGapBelow + 20 + (isSelf ? seq.selfMessageExtra : 0));
+        currentY += rowHeight;
+    }
+    // Trailing notes
+    const trailingNotes = noteSpaceBefore.get(sequence.messages.length);
+    if (trailingNotes) {
+        for (const ni of trailingNotes) {
+            noteYPositions.set(ni, currentY);
+            currentY += noteGeos[ni].height + seq.noteVerticalGap;
+        }
+    }
+    const lifelineEndY = currentY + seq.bottomParticipantGap;
+    const bottomParticipantY = lifelineEndY;
+    // ── Block overlay nodes ──
+    if (sequence.blocks) {
+        for (let bi = 0; bi < sequence.blocks.length; bi++) {
+            const block = sequence.blocks[bi];
+            const startY = (messageY[block.startIndex] ?? lifelineStartY) - 25;
+            const endY = (messageY[Math.max(0, block.endIndex - 1)] ?? startY) + 25;
+            const involvedIndices = new Set();
+            for (let mi = block.startIndex; mi < block.endIndex; mi++) {
+                const msg = sequence.messages[mi];
+                if (!msg)
+                    continue;
+                const fi = participantIndex.get(msg.from);
+                const ti = participantIndex.get(msg.to);
+                if (fi !== undefined)
+                    involvedIndices.add(fi);
+                if (ti !== undefined)
+                    involvedIndices.add(ti);
+            }
+            const indices = involvedIndices.size > 0
+                ? Array.from(involvedIndices)
+                : sequence.participants.map((_, i) => i);
+            const firstX = Math.min(...indices.map((i) => participantX(i, seq.leftPadding, seq.participantWidth, seq.participantGap)));
+            const lastX = Math.max(...indices.map((i) => participantX(i, seq.leftPadding, seq.participantWidth, seq.participantGap) + seq.participantWidth));
+            const blockX = firstX - seq.blockPaddingX;
+            const blockY = startY - seq.blockPaddingTop;
+            const blockW = lastX - firstX + seq.blockPaddingX * 2;
+            const blockH = endY - startY + seq.blockPaddingTop + seq.blockPaddingBottom;
+            nodes.push({
+                id: `__block_${bi}`,
+                position: { x: blockX, y: blockY },
+                data: {
+                    label: block.type,
+                    blockLabel: block.label,
+                    blockType: block.type,
+                    sections: block.sections,
+                    blockWidth: blockW,
+                    blockHeight: blockH,
+                    messageY,
+                    blockStartY: blockY,
+                },
+                type: 'sequenceBlock',
+                draggable: false,
+                selectable: false,
+                style: { zIndex: -1 },
+            });
+        }
+    }
+    // ── Lifeline nodes ──
+    for (const p of sequence.participants) {
+        const idx = participantIndex.get(p.id);
+        nodes.push({
+            id: `__lifeline_${p.id}`,
+            position: { x: participantCenterX(idx, seq.leftPadding, seq.participantWidth, seq.participantGap) - 1, y: lifelineStartY },
+            data: { lifelineHeight: lifelineEndY - lifelineStartY },
+            type: 'sequenceLifeline',
+            draggable: false,
+            selectable: false,
+        });
+    }
+    // ── Top participant nodes ──
+    for (const p of sequence.participants) {
+        const idx = participantIndex.get(p.id);
+        nodes.push({
+            id: p.id,
+            position: { x: participantX(idx, seq.leftPadding, seq.participantWidth, seq.participantGap), y: seq.topPadding },
+            data: {
+                label: cleanBrTags(p.label),
+                participantType: p.type,
+                meta: metadata?.[p.id],
+                layoutWidth: seq.participantWidth,
+                layoutHeight: seq.participantHeight,
+            },
+            type: 'sequenceParticipant',
+        });
+    }
+    // ── Bottom participant nodes ──
+    for (const p of sequence.participants) {
+        const idx = participantIndex.get(p.id);
+        nodes.push({
+            id: `__bottom_${p.id}`,
+            position: { x: participantX(idx, seq.leftPadding, seq.participantWidth, seq.participantGap), y: bottomParticipantY },
+            data: {
+                label: cleanBrTags(p.label),
+                participantType: p.type,
+                layoutWidth: seq.participantWidth,
+                layoutHeight: seq.participantHeight,
+            },
+            type: 'sequenceParticipant',
+            draggable: false,
+            selectable: false,
+        });
+    }
+    // ── Anchors + edges + labels + numbers ──
+    for (let mi = 0; mi < sequence.messages.length; mi++) {
+        const msg = sequence.messages[mi];
+        const fromIdx = participantIndex.get(msg.from);
+        const toIdx = participantIndex.get(msg.to);
+        if (fromIdx === undefined || toIdx === undefined)
+            continue;
+        const y = messageY[mi];
+        const isSelf = msg.from === msg.to;
+        const label = cleanedLabels[mi];
+        const labelH = labelHeights[mi];
+        const sourceAnchorId = `__anchor_${msg.from}_${mi}_src`;
+        nodes.push({
+            id: sourceAnchorId,
+            position: {
+                x: participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - seq.anchorWidth / 2,
+                y: y - seq.anchorHeight / 2,
+            },
+            data: { anchor: true },
+            type: 'sequenceAnchor',
+            draggable: false,
+            selectable: false,
+        });
+        if (isSelf) {
+            const loopRightX = participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) + 40;
+            const loopBottomY = y + seq.selfMessageExtra + 10;
+            const cornerAnchorId = `__anchor_${msg.from}_${mi}_corner`;
+            const returnAnchorId = `__anchor_${msg.from}_${mi}_return`;
+            const cornerBottomId = `__anchor_${msg.from}_${mi}_cornerbot`;
+            nodes.push({ id: cornerAnchorId, position: { x: loopRightX - 1, y: y - 1 }, data: { anchor: true }, type: 'sequenceAnchor', draggable: false, selectable: false }, {
+                id: returnAnchorId,
+                position: {
+                    x: participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - 1,
+                    y: loopBottomY - 1,
+                },
+                data: { anchor: true },
+                type: 'sequenceAnchor',
+                draggable: false,
+                selectable: false,
+            }, { id: cornerBottomId, position: { x: loopRightX - 1, y: loopBottomY - 1 }, data: { anchor: true }, type: 'sequenceAnchor', draggable: false, selectable: false });
+            edges.push(buildSequenceEdge(`e-self-${mi}-a`, sourceAnchorId, cornerAnchorId, msg.arrowType, theme, false), buildSequenceEdge(`e-self-${mi}-b`, cornerAnchorId, cornerBottomId, msg.arrowType, theme, false), buildSequenceEdge(`e-self-${mi}-c`, cornerBottomId, returnAnchorId, msg.arrowType, theme, true));
+            if (label) {
+                nodes.push({
+                    id: `__msglabel_${mi}`,
+                    position: { x: loopRightX + 6, y: y - 2 },
+                    data: { label, labelWidth: 120 },
+                    type: 'sequenceMessageLabel',
+                    draggable: false,
+                    selectable: false,
+                });
+            }
+        }
+        else {
+            const targetAnchorId = `__anchor_${msg.to}_${mi}_tgt`;
+            nodes.push({
+                id: targetAnchorId,
+                position: {
+                    x: participantCenterX(toIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - seq.anchorWidth / 2,
+                    y: y - seq.anchorHeight / 2,
+                },
+                data: { anchor: true },
+                type: 'sequenceAnchor',
+                draggable: false,
+                selectable: false,
+            });
+            edges.push(buildSequenceEdge(`e-msg-${mi}`, sourceAnchorId, targetAnchorId, msg.arrowType, theme, true));
+            if (label) {
+                const fromCx = participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap);
+                const toCx = participantCenterX(toIdx, seq.leftPadding, seq.participantWidth, seq.participantGap);
+                const midX = (fromCx + toCx) / 2;
+                const labelWidth = Math.max(Math.abs(toCx - fromCx) - 20, 80);
+                nodes.push({
+                    id: `__msglabel_${mi}`,
+                    position: {
+                        x: midX - labelWidth / 2,
+                        y: y - labelH - LABEL_GAP_BELOW,
+                    },
+                    data: { label, labelWidth },
+                    type: 'sequenceMessageLabel',
+                    draggable: false,
+                    selectable: false,
+                });
+            }
+        }
+        if (sequence.autonumber) {
+            nodes.push({
+                id: `__number_${mi}`,
+                position: {
+                    x: participantCenterX(fromIdx, seq.leftPadding, seq.participantWidth, seq.participantGap) - seq.numberCircleSize / 2,
+                    y: y - seq.numberCircleSize / 2,
+                },
+                data: { number: mi + 1 },
+                type: 'sequenceNumber',
+                draggable: false,
+                selectable: false,
+            });
+        }
+    }
+    // ── Note nodes ──
+    // Notes span the full width between the participants they're attached to.
+    if (sequence.notes) {
+        for (let ni = 0; ni < sequence.notes.length; ni++) {
+            const note = sequence.notes[ni];
+            const y = noteYPositions.get(ni) ?? ((messageY[note.messageIndex] ?? lifelineStartY) - seq.noteBaseHeight / 2);
+            const geo = noteGeos[ni];
+            nodes.push({
+                id: `__note_${ni}`,
+                position: { x: geo.x, y },
+                data: {
+                    label: cleanedNotes[ni],
+                    noteWidth: geo.width,
+                    noteHeight: geo.height,
+                },
+                type: 'sequenceNote',
+                draggable: false,
+                selectable: false,
+            });
+        }
+    }
+    return { nodes, edges };
+}
+// ─── Edge Builder ──────────────────────────────────────────────────────────
+function buildSequenceEdge(id, source, target, arrowType, theme, showArrow) {
+    const isDashed = arrowType === 'dashed' || arrowType === 'dashed_open';
+    const isOpen = arrowType === 'solid_open' || arrowType === 'dashed_open';
+    return {
+        id,
+        source,
+        target,
+        type: 'straight',
+        style: {
+            stroke: theme.color.gray3,
+            strokeWidth: 1.5,
+            ...(isDashed ? { strokeDasharray: '6,4' } : {}),
+        },
+        ...(showArrow && !isOpen ? {
+            markerEnd: {
+                type: MarkerType.ArrowClosed,
+                color: theme.color.gray3,
+                width: 10,
+                height: 10,
+            },
+        } : {}),
+    };
+}

package/dist/layout/subgraph.d.ts

@@ -0,0 +1,26 @@
+/**
+ * subgraph.ts — Subgraph bounding box computation and node construction.
+ *
+ * When dagre compound clustering is used, cluster bounds come directly
+ * from dagre's computed layout. Falls back to manual bounding box
+ * calculation when cluster data isn't available.
+ */
+import dagre from '@dagrejs/dagre';
+import type { Node } from '@xyflow/react';
+import type { ParsedSubgraph } from '../types.js';
+import type { Theme } from '../ThemeContext.js';
+import type { NodePosition } from './types.js';
+interface SubgraphBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Extracts subgraph bounds from dagre's compound cluster layout.
+ * Dagre computes cluster position/size automatically when setParent is used.
+ * Falls back to manual bounding box if dagre cluster data isn't available.
+ */
+export declare function computeSubgraphBounds(subgraph: ParsedSubgraph, nodePositions: Map<string, NodePosition>, padding: number, labelOffset: number, dagreGraph?: dagre.graphlib.Graph): SubgraphBounds | null;
+export declare function buildSubgraphNode(subgraph: ParsedSubgraph, bounds: SubgraphBounds, theme: Theme): Node;
+export {};

package/dist/layout/subgraph.js

@@ -0,0 +1,63 @@
+/**
+ * subgraph.ts — Subgraph bounding box computation and node construction.
+ *
+ * When dagre compound clustering is used, cluster bounds come directly
+ * from dagre's computed layout. Falls back to manual bounding box
+ * calculation when cluster data isn't available.
+ */
+/**
+ * Extracts subgraph bounds from dagre's compound cluster layout.
+ * Dagre computes cluster position/size automatically when setParent is used.
+ * Falls back to manual bounding box if dagre cluster data isn't available.
+ */
+export function computeSubgraphBounds(subgraph, nodePositions, padding, labelOffset, dagreGraph) {
+    // Try dagre's computed cluster bounds first
+    if (dagreGraph) {
+        const clusterNode = dagreGraph.node(subgraph.id);
+        if (clusterNode && clusterNode.width && clusterNode.height) {
+            return {
+                x: clusterNode.x - clusterNode.width / 2,
+                y: clusterNode.y - clusterNode.height / 2 - labelOffset,
+                width: clusterNode.width,
+                height: clusterNode.height + labelOffset,
+            };
+        }
+    }
+    // Fallback: manual bounding box from child node positions
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const nodeId of subgraph.nodeIds) {
+        const pos = nodePositions.get(nodeId);
+        if (!pos)
+            continue;
+        minX = Math.min(minX, pos.x);
+        minY = Math.min(minY, pos.y);
+        maxX = Math.max(maxX, pos.x + pos.width);
+        maxY = Math.max(maxY, pos.y + pos.height);
+    }
+    if (!isFinite(minX))
+        return null;
+    return {
+        x: minX - padding,
+        y: minY - padding - labelOffset,
+        width: maxX - minX + padding * 2,
+        height: maxY - minY + padding * 2 + labelOffset,
+    };
+}
+// ─── Subgraph Node Builder ──────────────────────────────────────────────────
+export function buildSubgraphNode(subgraph, bounds, theme) {
+    const subgraphStyles = theme.nodeStyles.subgraph;
+    return {
+        id: subgraph.id,
+        position: { x: bounds.x, y: bounds.y },
+        data: { label: subgraph.label },
+        type: 'subgraph',
+        style: {
+            width: bounds.width,
+            height: bounds.height,
+            backgroundColor: `${theme.color.darkBg3}${subgraphStyles.bgOpacity}`,
+            border: `${subgraphStyles.borderStyle} ${theme.color.gray3}`,
+            borderRadius: theme.radius.lg,
+            padding: theme.space[2],
+        },
+    };
+}

package/dist/layout/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * types.ts — Shared type definitions for the layout engine.
+ *
+ * Centralized here (following Mermaid's rendering-util/types.ts pattern)
+ * so that any layout module can import types without pulling in
+ * implementation dependencies.
+ */
+export interface NodePosition {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface HandlePositions {
+    sourcePosition: import('@xyflow/react').Position;
+    targetPosition: import('@xyflow/react').Position;
+    backEdgeSource: import('@xyflow/react').Position;
+    backEdgeTarget: import('@xyflow/react').Position;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface EdgeWaypoints {
+    source: string;
+    target: string;
+    points: Point[];
+}
+export interface NodeBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/dist/layout/types.js

@@ -0,0 +1,8 @@
+/**
+ * types.ts — Shared type definitions for the layout engine.
+ *
+ * Centralized here (following Mermaid's rendering-util/types.ts pattern)
+ * so that any layout module can import types without pulling in
+ * implementation dependencies.
+ */
+export {};

package/dist/parsers/classDiagram.d.ts

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

package/dist/parsers/classDiagram.js

@@ -0,0 +1,105 @@
+import { prep } from './helpers.js';
+export function parseClassDiagram(syntax) {
+    const lines = prep(syntax);
+    if (!lines.some(l => /^classDiagram$/i.test(l)))
+        return null;
+    const nodeMap = new Map();
+    const edges = [];
+    const classProps = new Map();
+    const classMethods = new Map();
+    let currentClass = null;
+    for (const line of lines) {
+        if (/^classDiagram$/i.test(line))
+            continue;
+        // Class block: class ClassName {
+        const classBlock = line.match(/^class\s+(\w+)\s*\{?$/);
+        if (classBlock) {
+            const name = classBlock[1];
+            ensureClass(name);
+            currentClass = line.includes('{') ? name : null;
+            continue;
+        }
+        if (line === '}') {
+            currentClass = null;
+            continue;
+        }
+        // Member inside class block
+        if (currentClass) {
+            // Skip annotations like <<abstract>>, <<interface>>, <<enumeration>>
+            if (/^<<\w+>>$/.test(line))
+                continue;
+            if (line.includes('(')) {
+                classMethods.get(currentClass)?.push(line);
+            }
+            else {
+                classProps.get(currentClass)?.push(line);
+            }
+            continue;
+        }
+        // Relationships
+        // Each pattern captures (left, right, label?). The `swap` flag indicates
+        // whether source/target should be reversed so the arrowhead points at the
+        // correct end. In Mermaid syntax, `A <|-- B` means B inherits from A,
+        // so the arrow should go from B → A (arrowhead at A = the parent).
+        const relPatterns = [
+            // Inheritance (solid line, hollow arrowhead)
+            { pattern: /^(\w+)\s+<\|--\s+(\w+)(?:\s*:\s*(.+))?/, swap: true }, // A <|-- B → B extends A
+            { pattern: /^(\w+)\s+--\|>\s+(\w+)(?:\s*:\s*(.+))?/, swap: false }, // A --|> B → A extends B
+            // Implementation (dashed line, hollow arrowhead)
+            { pattern: /^(\w+)\s+<\|\.\.\s+(\w+)(?:\s*:\s*(.+))?/, swap: true }, // A <|.. B → B implements A
+            { pattern: /^(\w+)\s+\.\.\|>\s+(\w+)(?:\s*:\s*(.+))?/, swap: false }, // A ..|> B → A implements B
+            // Cardinality (association with labels)
+            { pattern: /^(\w+)\s+"[^"]*"\s*-->\s*"[^"]*"\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Association (solid line, arrow)
+            { pattern: /^(\w+)\s+-->\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Dependency (dashed line, arrow)
+            { pattern: /^(\w+)\s+\.\.>\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Dashed dependency (no arrow)
+            { pattern: /^(\w+)\s+\.\.\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Aggregation (hollow diamond)
+            { pattern: /^(\w+)\s+<--o\s+(\w+)(?:\s*:\s*(.+))?/, swap: true },
+            { pattern: /^(\w+)\s+o-->\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            { pattern: /^(\w+)\s+o--\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Composition (filled diamond)
+            { pattern: /^(\w+)\s+<--\*\s+(\w+)(?:\s*:\s*(.+))?/, swap: true },
+            { pattern: /^(\w+)\s+\*-->\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            { pattern: /^(\w+)\s+\*--\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+            // Plain association (solid line, no arrow)
+            { pattern: /^(\w+)\s+--\s+(\w+)(?:\s*:\s*(.+))?/, swap: false },
+        ];
+        for (const { pattern, swap } of relPatterns) {
+            const m = line.match(pattern);
+            if (m) {
+                ensureClass(m[1]);
+                ensureClass(m[2]);
+                const src = swap ? m[2] : m[1];
+                const tgt = swap ? m[1] : m[2];
+                edges.push({ source: src, target: tgt, label: m[3]?.trim(), dagreReversed: swap || undefined });
+                break;
+            }
+        }
+    }
+    if (nodeMap.size === 0)
+        return null;
+    // Attach members to nodes
+    for (const [id, props] of classProps) {
+        const node = nodeMap.get(id);
+        if (node)
+            node.properties = props;
+    }
+    for (const [id, methods] of classMethods) {
+        const node = nodeMap.get(id);
+        if (node)
+            node.methods = methods;
+    }
+    return { kind: 'graph', direction: 'TB', diagramType: 'class', nodes: Array.from(nodeMap.values()), edges };
+    function ensureClass(name) {
+        if (nodeMap.has(name))
+            return;
+        nodeMap.set(name, { id: name, label: name, shape: 'rect', properties: [], methods: [] });
+        if (!classProps.has(name))
+            classProps.set(name, []);
+        if (!classMethods.has(name))
+            classMethods.set(name, []);
+    }
+}

package/dist/parsers/er.d.ts

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