@graph-artifact/core 0.1.0

package/dist/diagrams/plugins.js

@@ -0,0 +1,45 @@
+import { parseFlowchart } from '../parsers/flowchart.js';
+import { parseStateDiagram } from '../parsers/state.js';
+import { parseErDiagram } from '../parsers/er.js';
+import { parseClassDiagram } from '../parsers/classDiagram.js';
+import { parseSequenceDiagram } from '../parsers/sequence.js';
+import { parseMindmap } from '../parsers/mindmap.js';
+const startsWith = (regex) => (syntax) => regex.test(syntax.trimStart());
+export const builtinDiagramPlugins = [
+    {
+        id: 'mindmap',
+        detect: startsWith(/^mindmap\b/i),
+        parse: parseMindmap,
+        renderer: 'graph',
+    },
+    {
+        id: 'flowchart',
+        detect: startsWith(/^(graph|flowchart)\s+/i),
+        parse: parseFlowchart,
+        renderer: 'graph',
+    },
+    {
+        id: 'state',
+        detect: startsWith(/^stateDiagram(?:-v2)?\b/i),
+        parse: parseStateDiagram,
+        renderer: 'graph',
+    },
+    {
+        id: 'er',
+        detect: startsWith(/^erDiagram\b/i),
+        parse: parseErDiagram,
+        renderer: 'graph',
+    },
+    {
+        id: 'class',
+        detect: startsWith(/^classDiagram\b/i),
+        parse: parseClassDiagram,
+        renderer: 'graph',
+    },
+    {
+        id: 'sequence',
+        detect: startsWith(/^sequenceDiagram\b/i),
+        parse: parseSequenceDiagram,
+        renderer: 'graph',
+    },
+];

package/dist/diagrams/registry.d.ts

@@ -0,0 +1,3 @@
+import type { DiagramPlugin } from './types.js';
+export declare function registerDiagramPlugin(plugin: DiagramPlugin): void;
+export declare function getDiagramPlugins(): readonly DiagramPlugin[];

package/dist/diagrams/registry.js

@@ -0,0 +1,13 @@
+import { builtinDiagramPlugins } from './plugins.js';
+const plugins = [...builtinDiagramPlugins];
+export function registerDiagramPlugin(plugin) {
+    const index = plugins.findIndex((p) => p.id === plugin.id);
+    if (index >= 0) {
+        plugins[index] = plugin;
+        return;
+    }
+    plugins.push(plugin);
+}
+export function getDiagramPlugins() {
+    return plugins;
+}

package/dist/diagrams/types.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedDiagram, DiagramType } from '../types.js';
+export interface DiagramPlugin {
+    id: DiagramType;
+    detect: (syntax: string) => boolean;
+    parse: (syntax: string) => ParsedDiagram | null;
+    renderer: 'graph' | 'custom';
+}

package/dist/diagrams/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './core.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+// Backward-compatible default entry points to core/headless APIs.
+// Use `@graph-artifact/core/react` for React renderer components.
+export * from './core.js';

package/dist/layout/dagre/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * dagre/ — Dagre layout algorithm.
+ *
+ * Builds a dagre graph from parsed data, runs the layout algorithm,
+ * and extracts node positions + edge waypoints for downstream use.
+ *
+ * Mirrors Mermaid's layout-algorithms/dagre/ pattern:
+ * the layout algorithm is isolated behind a clean module boundary.
+ */
+import dagre from '@dagrejs/dagre';
+import type { ParsedGraph, ParsedNode } from '../../types.js';
+import type { GraphConfig } from '../../config.js';
+import type { NodePosition, HandlePositions, EdgeWaypoints } from '../types.js';
+export type { NodePosition, HandlePositions, EdgeWaypoints } from '../types.js';
+/**
+ * Maps graph direction to handle positions.
+ * Forward edges use primary handles (e.g. Bottom→Top for TB).
+ * Back-edges route to side handles to avoid passing through intermediate nodes.
+ */
+export declare function directionToHandles(direction: ParsedGraph['direction']): HandlePositions;
+export declare function createDagreGraph(parsed: ParsedGraph, layoutConfig: GraphConfig['layout']): dagre.graphlib.Graph;
+/**
+ * Extracts top-left positions from dagre's center-based coordinates.
+ * Returns a Map of nodeId → { x, y, width, height }.
+ */
+export declare function extractPositions(graph: dagre.graphlib.Graph, nodes: ParsedNode[]): Map<string, NodePosition>;
+/**
+ * Extracts dagre's computed edge waypoints for every edge.
+ * These waypoints route around intermediate nodes automatically.
+ */
+export declare function extractEdgeWaypoints(graph: dagre.graphlib.Graph, parsed: ParsedGraph): EdgeWaypoints[];

package/dist/layout/dagre/index.js

@@ -0,0 +1,224 @@
+/**
+ * dagre/ — Dagre layout algorithm.
+ *
+ * Builds a dagre graph from parsed data, runs the layout algorithm,
+ * and extracts node positions + edge waypoints for downstream use.
+ *
+ * Mirrors Mermaid's layout-algorithms/dagre/ pattern:
+ * the layout algorithm is isolated behind a clean module boundary.
+ */
+import dagre from '@dagrejs/dagre';
+import { Position } from '@xyflow/react';
+import { nodeSize } from './nodeSizing.js';
+// ─── Handle Positions by Direction ──────────────────────────────────────────
+/**
+ * Maps graph direction to handle positions.
+ * Forward edges use primary handles (e.g. Bottom→Top for TB).
+ * Back-edges route to side handles to avoid passing through intermediate nodes.
+ */
+export function directionToHandles(direction) {
+    switch (direction) {
+        case 'LR':
+            return {
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+                backEdgeSource: Position.Top,
+                backEdgeTarget: Position.Top,
+            };
+        case 'RL':
+            return {
+                sourcePosition: Position.Left,
+                targetPosition: Position.Right,
+                backEdgeSource: Position.Top,
+                backEdgeTarget: Position.Top,
+            };
+        case 'BT':
+            return {
+                sourcePosition: Position.Top,
+                targetPosition: Position.Bottom,
+                backEdgeSource: Position.Right,
+                backEdgeTarget: Position.Right,
+            };
+        case 'TB':
+        default:
+            return {
+                sourcePosition: Position.Bottom,
+                targetPosition: Position.Top,
+                backEdgeSource: Position.Right,
+                backEdgeTarget: Position.Right,
+            };
+    }
+}
+// ─── Dagre Graph Construction ───────────────────────────────────────────────
+export function createDagreGraph(parsed, layoutConfig) {
+    validateParsedGraph(parsed);
+    const g = new dagre.graphlib.Graph({ multigraph: true, compound: true });
+    g.setDefaultEdgeLabel(() => ({}));
+    const rankSepByType = {
+        er: layoutConfig.erRankSep,
+        state: layoutConfig.stateRankSep,
+        flowchart: layoutConfig.rankSep,
+        class: layoutConfig.rankSep,
+        sequence: layoutConfig.rankSep,
+        mindmap: layoutConfig.rankSep,
+        gitGraph: layoutConfig.rankSep,
+    };
+    const nodeSepByType = {
+        er: layoutConfig.erNodeSep,
+        state: layoutConfig.stateNodeSep,
+        flowchart: layoutConfig.nodeSep,
+        class: layoutConfig.nodeSep,
+        sequence: layoutConfig.nodeSep,
+        mindmap: layoutConfig.nodeSep,
+        gitGraph: layoutConfig.nodeSep,
+    };
+    g.setGraph({
+        rankdir: parsed.direction,
+        ranksep: rankSepByType[parsed.diagramType] ?? layoutConfig.rankSep,
+        nodesep: nodeSepByType[parsed.diagramType] ?? layoutConfig.nodeSep,
+        marginx: 8,
+        marginy: 8,
+        ranker: 'network-simplex',
+    });
+    for (const node of parsed.nodes) {
+        const size = nodeSize(node, parsed.diagramType, layoutConfig.nodeSizing);
+        g.setNode(node.id, { width: size.width, height: size.height });
+    }
+    // Defensive: if a parser emits an edge endpoint that is missing from
+    // parsed.nodes, dagre creates an implicit node with undefined label data,
+    // which can crash rank assignment (network simplex). Materialize a fallback
+    // node shape/dimensions so layout remains stable.
+    const fallbackNode = {
+        width: layoutConfig.nodeSizing.flow.minWidth,
+        height: layoutConfig.nodeSizing.flow.height,
+    };
+    // Register subgraphs as compound parent nodes so dagre clusters
+    // their children together and adds spacing between groups.
+    if (parsed.subgraphs) {
+        const pad = layoutConfig.subgraphPadding;
+        for (const subgraph of parsed.subgraphs) {
+            g.setNode(subgraph.id, {
+                clusterLabelPos: 'top',
+                paddingTop: pad + 14, // extra for label
+                paddingBottom: pad,
+                paddingLeft: pad,
+                paddingRight: pad,
+            });
+            for (const nodeId of subgraph.nodeIds) {
+                if (!g.hasNode(nodeId))
+                    g.setNode(nodeId, fallbackNode);
+                g.setParent(nodeId, subgraph.id);
+            }
+        }
+    }
+    parsed.edges.forEach((edge, i) => {
+        // Pass label dimensions to dagre so it spaces edges apart
+        // and generates better waypoints. Without this, dagre treats
+        // all edges as zero-width and packs waypoints tight together.
+        const labelWidth = edge.label ? edge.label.length * 8 + 16 : 0;
+        const labelHeight = edge.label ? 20 : 0;
+        // For inheritance edges (dagreReversed), reverse the direction in dagre
+        // so parents rank above children, while the visual arrow stays child→parent.
+        const dagreSrc = edge.dagreReversed ? edge.target : edge.source;
+        const dagreTgt = edge.dagreReversed ? edge.source : edge.target;
+        if (!g.hasNode(dagreSrc))
+            g.setNode(dagreSrc, fallbackNode);
+        if (!g.hasNode(dagreTgt))
+            g.setNode(dagreTgt, fallbackNode);
+        // Use index as edge name for multigraph — prevents overwriting when
+        // multiple edges exist between the same source→target pair.
+        g.setEdge(dagreSrc, dagreTgt, {
+            width: labelWidth,
+            height: labelHeight,
+            labelpos: 'c',
+        }, `e${i}`);
+    });
+    try {
+        dagre.layout(g);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Layout failed for diagram type '${parsed.diagramType}'. ${msg}`);
+    }
+    return g;
+}
+function validateParsedGraph(parsed) {
+    const issues = [];
+    const nodeIds = new Set();
+    for (const node of parsed.nodes) {
+        const id = String(node.id ?? '').trim();
+        if (!id) {
+            issues.push('Found node with empty id.');
+            continue;
+        }
+        if (nodeIds.has(id))
+            issues.push(`Duplicate node id '${id}'.`);
+        nodeIds.add(id);
+    }
+    parsed.edges.forEach((edge, i) => {
+        const src = String(edge.source ?? '').trim();
+        const tgt = String(edge.target ?? '').trim();
+        if (!src)
+            issues.push(`Edge #${i} has empty source.`);
+        if (!tgt)
+            issues.push(`Edge #${i} has empty target.`);
+        if (src && !nodeIds.has(src))
+            issues.push(`Edge #${i} source '${src}' does not exist.`);
+        if (tgt && !nodeIds.has(tgt))
+            issues.push(`Edge #${i} target '${tgt}' does not exist.`);
+    });
+    if (parsed.subgraphs) {
+        for (const sg of parsed.subgraphs) {
+            for (const nid of sg.nodeIds) {
+                const id = String(nid ?? '').trim();
+                if (!id) {
+                    issues.push(`Subgraph '${sg.id}' contains empty node id.`);
+                    continue;
+                }
+                if (!nodeIds.has(id))
+                    issues.push(`Subgraph '${sg.id}' references missing node '${id}'.`);
+            }
+        }
+    }
+    if (issues.length > 0) {
+        throw new Error(`Invalid diagram graph: ${issues.join(' ')}`);
+    }
+}
+// ─── Position Extraction ────────────────────────────────────────────────────
+/**
+ * Extracts top-left positions from dagre's center-based coordinates.
+ * Returns a Map of nodeId → { x, y, width, height }.
+ */
+export function extractPositions(graph, nodes) {
+    const positions = new Map();
+    for (const node of nodes) {
+        const pos = graph.node(node.id);
+        positions.set(node.id, {
+            x: pos.x - pos.width / 2,
+            y: pos.y - pos.height / 2,
+            width: pos.width,
+            height: pos.height,
+        });
+    }
+    return positions;
+}
+// ─── Edge Waypoint Extraction ────────────────────────────────────────────────
+/**
+ * Extracts dagre's computed edge waypoints for every edge.
+ * These waypoints route around intermediate nodes automatically.
+ */
+export function extractEdgeWaypoints(graph, parsed) {
+    return parsed.edges.map((edge, i) => {
+        // Use the same source/target order we gave dagre (may be reversed for inheritance edges)
+        const dagreSrc = edge.dagreReversed ? edge.target : edge.source;
+        const dagreTgt = edge.dagreReversed ? edge.source : edge.target;
+        const dagreEdge = graph.edge(dagreSrc, dagreTgt, `e${i}`);
+        let points = dagreEdge?.points
+            ? dagreEdge.points.map((p) => ({ x: p.x, y: p.y }))
+            : [];
+        // Reverse waypoints back so they flow from visual source → visual target
+        if (edge.dagreReversed)
+            points = points.reverse();
+        return { source: edge.source, target: edge.target, points };
+    });
+}

package/dist/layout/dagre/nodeSizing.d.ts

@@ -0,0 +1,32 @@
+/**
+ * nodeSizing.ts — Per-diagram-type node dimension calculations.
+ *
+ * Each diagram type has its own sizing function. The dispatcher
+ * `nodeSize()` selects the right one based on DiagramType.
+ *
+ * These dimensions are the SINGLE SOURCE OF TRUTH for node sizes.
+ * They feed dagre for positioning, intersection math for edge routing,
+ * and are passed to components as layoutWidth/layoutHeight.
+ *
+ * DIMENSIONAL CONTRACT:
+ * Card-based nodes (ER, Class) render at their natural CSS height —
+ * no fixed height is set. The estimates here are used ONLY by dagre
+ * for node spacing and by intersection math for edge endpoints.
+ * Estimates should be generous (round up) to ensure dagre allocates
+ * enough room. React Flow measures the actual DOM height after render.
+ *
+ * Shape-based nodes (Flow, State) use layoutWidth/layoutHeight
+ * directly since their geometry is deterministic (circles, diamonds, etc).
+ *
+ * All sizing reads from config so consumers can tune dimensions
+ * via `configure({ layout: { nodeSizing: { ... } } })`.
+ */
+import type { ParsedNode, GraphDiagramType } from '../../types.js';
+import type { GraphConfig } from '../../config.js';
+type NodeSizingConfig = GraphConfig['layout']['nodeSizing'];
+interface Dimensions {
+    width: number;
+    height: number;
+}
+export declare function nodeSize(node: ParsedNode, diagramType: GraphDiagramType, sizing: NodeSizingConfig): Dimensions;
+export {};

package/dist/layout/dagre/nodeSizing.js

@@ -0,0 +1,202 @@
+/**
+ * nodeSizing.ts — Per-diagram-type node dimension calculations.
+ *
+ * Each diagram type has its own sizing function. The dispatcher
+ * `nodeSize()` selects the right one based on DiagramType.
+ *
+ * These dimensions are the SINGLE SOURCE OF TRUTH for node sizes.
+ * They feed dagre for positioning, intersection math for edge routing,
+ * and are passed to components as layoutWidth/layoutHeight.
+ *
+ * DIMENSIONAL CONTRACT:
+ * Card-based nodes (ER, Class) render at their natural CSS height —
+ * no fixed height is set. The estimates here are used ONLY by dagre
+ * for node spacing and by intersection math for edge endpoints.
+ * Estimates should be generous (round up) to ensure dagre allocates
+ * enough room. React Flow measures the actual DOM height after render.
+ *
+ * Shape-based nodes (Flow, State) use layoutWidth/layoutHeight
+ * directly since their geometry is deterministic (circles, diamonds, etc).
+ *
+ * All sizing reads from config so consumers can tune dimensions
+ * via `configure({ layout: { nodeSizing: { ... } } })`.
+ */
+import { getConfig } from '../../config.js';
+function clampWidth(px) {
+    const { layout } = getConfig();
+    return Math.max(layout.nodeSizing.common.minWidth, Math.min(layout.nodeSizing.common.maxWidth, Math.ceil(px)));
+}
+function stripMarkdown(input) {
+    return input
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/\*([^*]+)\*/g, '$1')
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1')
+        .replace(/[_~#>|-]/g, '')
+        .trim();
+}
+function labelMetrics(label) {
+    const normalized = label.replace(/\\n/g, '\n');
+    const lines = normalized.split('\n');
+    const maxChars = Math.max(1, ...lines.map((line) => stripMarkdown(line).length || 1));
+    return { maxChars, lines: Math.max(1, lines.length) };
+}
+function estimatedWrappedLineCount(label, contentCharsPerLine) {
+    const normalized = label.replace(/\\n/g, '\n');
+    const lines = normalized.split('\n');
+    let total = 0;
+    const charsPerLine = Math.max(8, contentCharsPerLine);
+    for (const rawLine of lines) {
+        const clean = stripMarkdown(rawLine);
+        const len = Math.max(1, clean.length);
+        total += Math.max(1, Math.ceil(len / charsPerLine));
+    }
+    return Math.max(1, total);
+}
+// ─── Flowchart ──────────────────────────────────────────────────────────────
+function flowchartNodeSize(node, sizing) {
+    const common = sizing.common;
+    const { maxChars } = labelMetrics(node.label);
+    const dynamicWidth = Math.max(sizing.flow.minWidth, maxChars * sizing.charWidth + sizing.flow.padding);
+    const width = clampWidth(dynamicWidth);
+    const contentCharsPerLine = Math.max(8, Math.floor((width - sizing.flow.padding) / Math.max(1, sizing.charWidth)));
+    const wrappedLines = estimatedWrappedLineCount(node.label, contentCharsPerLine);
+    const dynamicHeight = Math.max(sizing.flow.height, common.lineBaseHeight + wrappedLines * common.lineStepHeight);
+    if (node.shape === 'diamond') {
+        // The visual diamond is a rotated square — its bounding box is side * sqrt(2)
+        const baseSide = Math.max(sizing.flow.diamondSize, dynamicWidth * 0.72, dynamicHeight * 0.72);
+        const diagSize = Math.ceil(baseSide * Math.SQRT2);
+        return { width: diagSize, height: diagSize };
+    }
+    if (node.shape === 'circle') {
+        const size = Math.max(sizing.flow.circleSize, dynamicWidth * 0.85, dynamicHeight * 0.85);
+        return { width: Math.ceil(size), height: Math.ceil(size) };
+    }
+    if (node.shape === 'cylinder') {
+        return {
+            width: Math.max(sizing.flow.cylinderWidth, dynamicWidth),
+            height: Math.max(sizing.flow.cylinderHeight, dynamicHeight + 10),
+        };
+    }
+    return {
+        width,
+        height: dynamicHeight,
+    };
+}
+// ─── State Diagram ──────────────────────────────────────────────────────────
+function stateNodeSize(node, sizing) {
+    const common = sizing.common;
+    const { maxChars, lines } = labelMetrics(node.label);
+    if (node.shape === 'circle') {
+        return { width: sizing.state.circleSize, height: sizing.state.circleSize };
+    }
+    if (node.shape === 'doublecircle') {
+        // Include border in bounding box so intersection math hits the visual boundary
+        const size = sizing.state.circleSize + sizing.state.doublecirclePad
+            + sizing.state.doublecircleBorder * 2;
+        return { width: size, height: size };
+    }
+    // border-box dimensions: content + padding + border extras
+    const textWidth = Math.max(sizing.state.minWidth, maxChars * sizing.charWidth + sizing.state.padding);
+    const textHeight = Math.max(sizing.state.height, common.lineBaseHeight + lines * common.lineStepHeight);
+    return {
+        width: textWidth + sizing.state.borderExtra,
+        height: textHeight + sizing.state.borderExtra,
+    };
+}
+// ─── ER Diagram ─────────────────────────────────────────────────────────────
+function erNodeSize(node, sizing) {
+    const attrCount = node.attributes?.length ?? 0;
+    const attrs = node.attributes ?? [];
+    // Height breakdown (mirrors EntityNode CSS):
+    //   headerHeight:  header padding (space[2]*2) + font (size.lg) + line-height
+    //   sectionPad:    attribute wrapper padding (space[2]*2 = 8+8 = 16px)
+    //   rowHeight:     per-row padding (space[1]*2 = 4+4) + font (size.md) * line-height
+    //   dividers:      1px borderBottom between attribute rows
+    //   borderExtra:   card border (borderWidth.sm * 2 = 1+1 = 2px)
+    const sectionPad = attrCount > 0 ? 16 : 0;
+    const dividers = attrCount > 1 ? attrCount - 1 : 0;
+    const badgeRoom = attrs.some((attr) => {
+        const t = attr.trim().split(/\s+/);
+        return t[2] === 'PK' || t[2] === 'FK' || t[2] === 'UK';
+    }) ? 44 : 0;
+    // Width mirrors EntityNode row composition:
+    // section horizontal padding (24) + type column (90) + gap (8)
+    // + longest name content + optional badge room.
+    const headerChars = Math.max(0, node.label.length);
+    const maxNameChars = attrs.reduce((max, attr) => {
+        const t = attr.trim().split(/\s+/);
+        return Math.max(max, (t[1] ?? '').length);
+    }, 0);
+    const contentChars = Math.max(headerChars, maxNameChars);
+    const estimatedWidth = Math.max(sizing.er.width, 24 + 90 + 8 + contentChars * sizing.charWidth + badgeRoom);
+    return {
+        width: clampWidth(estimatedWidth),
+        height: sizing.er.headerHeight
+            + sectionPad
+            + attrCount * sizing.er.rowHeight
+            + dividers
+            + sizing.er.borderExtra,
+    };
+}
+// ─── Class Diagram ──────────────────────────────────────────────────────────
+function classNodeSize(node, sizing) {
+    const props = node.properties ?? [];
+    const methods = node.methods ?? [];
+    const hasBothSections = props.length > 0 && methods.length > 0;
+    const sectionCount = (props.length > 0 ? 1 : 0) + (methods.length > 0 ? 1 : 0);
+    const longestRowChars = Math.max(node.label.length, ...props.map((p) => p.length), ...methods.map((m) => m.length), 0);
+    const estimatedWidth = Math.max(sizing.class.width, 24 + longestRowChars * 7.2);
+    const classWidth = clampWidth(estimatedWidth);
+    // Estimate wrapped line count per row. The content area is the node width
+    // minus section padding (12px each side) and card border (1px each side).
+    const contentWidth = classWidth - 26;
+    const monoCharWidth = 6.6; // approximate width of 11px monospace chars
+    const charsPerLine = Math.max(8, Math.floor(contentWidth / monoCharWidth));
+    // Height breakdown (calibrated to match actual component rendering):
+    //   header: padding 8+8 + font 14px + line-height ≈ 33px
+    //   per section: wrapper padding 8 top + 8 bottom = 16px
+    //   per row: row padding 4 top + 4 bottom = 8px
+    //   per text line: 11px font * 1.4 lineHeight ≈ 16px
+    //   divider: 1px border between sections
+    //   card border: 2px (1px top + 1px bottom)
+    const HEADER = sizing.class.headerHeight;
+    const SECTION_PAD = 16;
+    const ROW_PAD = 8;
+    const LINE_H = 16;
+    const BORDER = 2;
+    function sectionHeight(rows) {
+        if (rows.length === 0)
+            return 0;
+        let totalLines = 0;
+        for (const row of rows) {
+            totalLines += Math.max(1, Math.ceil(row.length / charsPerLine));
+        }
+        return SECTION_PAD + rows.length * ROW_PAD + totalLines * LINE_H;
+    }
+    const height = HEADER
+        + sectionHeight(props)
+        + sectionHeight(methods)
+        + (hasBothSections ? 1 : 0) // divider border
+        + BORDER
+        + (sectionCount === 0 ? 30 : 0); // "(empty)" placeholder
+    return { width: classWidth, height };
+}
+// ─── Dispatcher ─────────────────────────────────────────────────────────────
+// Sequence diagrams bypass dagre entirely — they never call nodeSize().
+// This stub exists only to satisfy the DiagramType→function mapping.
+function sequenceNodeSize() {
+    return { width: 150, height: 40 };
+}
+const sizingByType = {
+    flowchart: flowchartNodeSize,
+    state: stateNodeSize,
+    er: erNodeSize,
+    class: classNodeSize,
+    sequence: sequenceNodeSize,
+    mindmap: flowchartNodeSize,
+    gitGraph: flowchartNodeSize,
+};
+export function nodeSize(node, diagramType, sizing) {
+    return sizingByType[diagramType](node, sizing);
+}

package/dist/layout/edges/buildEdges.d.ts

@@ -0,0 +1,18 @@
+/**
+ * buildEdges.ts — Main edge builder.
+ *
+ * Orchestrates: intersection → path generation → handle assignment → styling
+ * to produce React Flow Edge objects from parsed edges + dagre waypoints.
+ *
+ * For each edge:
+ *   1. Takes dagre's waypoints (which route around intermediate nodes)
+ *   2. Computes node-boundary intersection (rect or diamond) for start/end
+ *   3. Shortens the end by the arrow marker size so the tip lands at the boundary
+ *   4. Generates a rounded SVG path through all waypoints
+ *   5. Passes the pre-computed path + label position as edge data
+ */
+import type { Edge } from '@xyflow/react';
+import type { ParsedEdge, ParsedGraph } from '../../types.js';
+import type { Theme } from '../../ThemeContext.js';
+import type { NodePosition, EdgeWaypoints } from '../types.js';
+export declare function buildEdges(parsedEdges: ParsedEdge[], positions: Map<string, NodePosition>, _handles: unknown, direction: ParsedGraph['direction'], theme: Theme, diamondEdgeHandles?: Map<number, string>, edgeWaypoints?: EdgeWaypoints[], nodeShapes?: Map<string, string>): Edge[];