@dforge-core/diagram 0.0.1

package/dist/SimpleDiagram/SimpleDiagram.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { DiagramNode, ResolvedEdge } from '../diagram-types';
+interface Props {
+    nodes: DiagramNode[];
+    edges: ResolvedEdge[];
+    storageKey?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    onNodeDblClick?: (nodeId: string) => void;
+}
+declare const SimpleDiagram: import("svelte").Component<Props, {}, "">;
+type SimpleDiagram = ReturnType<typeof SimpleDiagram>;
+export default SimpleDiagram;
+//# sourceMappingURL=SimpleDiagram.svelte.d.ts.map

package/dist/SimpleDiagram/SimpleDiagram.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleDiagram.svelte.d.ts","sourceRoot":"","sources":["../../src/lib/SimpleDiagram/SimpleDiagram.svelte.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAS,MAAM,kBAAkB,CAAC;AAUxE,UAAU,KAAK;IACd,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;AAohBF,QAAA,MAAM,aAAa,2CAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

package/dist/SimpleDiagram/diagram-geometry.d.ts

@@ -0,0 +1,33 @@
+import type { Point } from '../diagram-types';
+/** Build an SVG path string from a sequence of points, with rounded corners. */
+export declare function buildSvgPath(points: Point[]): string;
+/** Get the label position for an edge (midpoint of the path, offset above). */
+export declare function edgeLabelPos(points: Point[]): {
+    x: number;
+    y: number;
+};
+/** Insert clamp points before drag to prevent diagonals. */
+export declare function prepareDragPoints(pts: Point[], segIndex: number, orientation: 'H' | 'V'): {
+    points: Point[];
+    segIndex: number;
+};
+/** Remove zero-length segments and collinear midpoints. */
+export declare function consolidatePoints(pts: Point[]): Point[];
+/** Insert a rectangular jog at a segment, returns new points + segment to drag. */
+export declare function insertJog(pts: Point[], segIndex: number, orientation: 'H' | 'V'): {
+    points: Point[];
+    segIndex: number;
+    orientation: 'H' | 'V';
+};
+export interface SegHandle {
+    x: number;
+    y: number;
+    segIndex: number;
+    orientation: 'H' | 'V';
+    draggable: boolean;
+}
+/** Compute drag/split handles for each segment in a point array. */
+export declare function getSegmentHandles(points: Point[]): SegHandle[];
+/** Apply a segment drag: move both endpoints of the segment in the drag direction. */
+export declare function applySegmentDrag(pts: Point[], segIndex: number, orientation: 'H' | 'V', pos: Point): Point[];
+//# sourceMappingURL=diagram-geometry.d.ts.map

package/dist/SimpleDiagram/diagram-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/SimpleDiagram/diagram-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AA+B9C,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAQpD;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAGtE;AAID,4DAA4D;AAC5D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,GAAG,GAAG;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAyB/H;AAED,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,CAiBvD;AAED,mFAAmF;AACnF,wBAAgB,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,GAAG,GAAG;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,CAa/I;AAID,MAAM,WAAW,SAAS;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,SAAS,EAAE,OAAO,CAAC;CACnB;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,CAgB9D;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,EAAE,CAU5G"}

package/dist/SimpleDiagram/diagram-geometry.js

@@ -0,0 +1,137 @@
+const BEND_RADIUS = 8;
+const SNAP = 3;
+// --- SVG path building ---
+/** Build a quadratic Bezier corner between two orthogonal segments. */
+function roundedCorner(from, corner, to, r) {
+    const d1 = Math.max(Math.abs(corner.x - from.x), Math.abs(corner.y - from.y));
+    const d2 = Math.max(Math.abs(to.x - corner.x), Math.abs(to.y - corner.y));
+    const cr = Math.min(r, d1 / 2, d2 / 2);
+    if (cr < 1)
+        return `L ${corner.x} ${corner.y}`;
+    const d1x = corner.x - from.x, d1y = corner.y - from.y;
+    const d2x = to.x - corner.x, d2y = to.y - corner.y;
+    const h1 = Math.abs(d1x) >= Math.abs(d1y);
+    const dx1 = h1 ? Math.sign(d1x) : 0;
+    const dy1 = h1 ? 0 : Math.sign(d1y);
+    const h2 = Math.abs(d2x) >= Math.abs(d2y);
+    const dx2 = h2 ? Math.sign(d2x) : 0;
+    const dy2 = h2 ? 0 : Math.sign(d2y);
+    const ax = corner.x - dx1 * cr;
+    const ay = corner.y - dy1 * cr;
+    const bx = corner.x + dx2 * cr;
+    const by = corner.y + dy2 * cr;
+    return `L ${ax} ${ay} Q ${corner.x} ${corner.y} ${bx} ${by}`;
+}
+/** Build an SVG path string from a sequence of points, with rounded corners. */
+export function buildSvgPath(points) {
+    if (points.length < 2)
+        return '';
+    let d = `M ${points[0].x} ${points[0].y}`;
+    for (let i = 1; i < points.length - 1; i++) {
+        d += ` ${roundedCorner(points[i - 1], points[i], points[i + 1], BEND_RADIUS)}`;
+    }
+    d += ` L ${points[points.length - 1].x} ${points[points.length - 1].y}`;
+    return d;
+}
+/** Get the label position for an edge (midpoint of the path, offset above). */
+export function edgeLabelPos(points) {
+    const mid = points[Math.floor(points.length / 2)];
+    return { x: mid.x, y: mid.y - 6 };
+}
+// --- Edge segment editing ---
+/** Insert clamp points before drag to prevent diagonals. */
+export function prepareDragPoints(pts, segIndex, orientation) {
+    const result = pts.map((p) => ({ ...p }));
+    let si = segIndex;
+    if (orientation === 'H') {
+        const y = result[si].y;
+        if (si > 0 && Math.abs(result[si - 1].y - y) < SNAP && Math.abs(result[si - 1].x - result[si].x) > SNAP) {
+            result.splice(si, 0, { ...result[si] });
+            si++;
+        }
+        if (si + 2 < result.length && Math.abs(result[si + 2].y - y) < SNAP && Math.abs(result[si + 1].x - result[si + 2].x) > SNAP) {
+            result.splice(si + 2, 0, { ...result[si + 1] });
+        }
+    }
+    else {
+        const x = result[si].x;
+        if (si > 0 && Math.abs(result[si - 1].x - x) < SNAP && Math.abs(result[si - 1].y - result[si].y) > SNAP) {
+            result.splice(si, 0, { ...result[si] });
+            si++;
+        }
+        if (si + 2 < result.length && Math.abs(result[si + 2].x - x) < SNAP && Math.abs(result[si + 1].y - result[si + 2].y) > SNAP) {
+            result.splice(si + 2, 0, { ...result[si + 1] });
+        }
+    }
+    return { points: result, segIndex: si };
+}
+/** Remove zero-length segments and collinear midpoints. */
+export function consolidatePoints(pts) {
+    if (pts.length < 3)
+        return pts;
+    const result = [pts[0]];
+    for (let i = 1; i < pts.length; i++) {
+        const prev = result[result.length - 1];
+        const curr = pts[i];
+        if (Math.abs(prev.x - curr.x) < SNAP && Math.abs(prev.y - curr.y) < SNAP)
+            continue;
+        if (i < pts.length - 1) {
+            const next = pts[i + 1];
+            const sameX = Math.abs(prev.x - curr.x) < SNAP && Math.abs(curr.x - next.x) < SNAP;
+            const sameY = Math.abs(prev.y - curr.y) < SNAP && Math.abs(curr.y - next.y) < SNAP;
+            if (sameX && curr.y >= Math.min(prev.y, next.y) && curr.y <= Math.max(prev.y, next.y))
+                continue;
+            if (sameY && curr.x >= Math.min(prev.x, next.x) && curr.x <= Math.max(prev.x, next.x))
+                continue;
+        }
+        result.push(curr);
+    }
+    return result;
+}
+/** Insert a rectangular jog at a segment, returns new points + segment to drag. */
+export function insertJog(pts, segIndex, orientation) {
+    const result = pts.map((p) => ({ ...p }));
+    const a = result[segIndex], b = result[segIndex + 1];
+    if (orientation === 'H') {
+        const mx = (a.x + b.x) / 2;
+        result.splice(segIndex + 1, 0, { x: mx, y: a.y }, { x: mx, y: a.y });
+        return { points: result, segIndex: segIndex + 1, orientation: 'V' };
+    }
+    else {
+        const my = (a.y + b.y) / 2;
+        result.splice(segIndex + 1, 0, { x: a.x, y: my }, { x: a.x, y: my });
+        return { points: result, segIndex: segIndex + 1, orientation: 'H' };
+    }
+}
+/** Compute drag/split handles for each segment in a point array. */
+export function getSegmentHandles(points) {
+    if (points.length < 2)
+        return [];
+    const handles = [];
+    const lastSeg = points.length - 2;
+    for (let i = 0; i < points.length - 1; i++) {
+        const a = points[i], b = points[i + 1];
+        const isH = Math.abs(a.y - b.y) < SNAP;
+        handles.push({
+            x: (a.x + b.x) / 2,
+            y: (a.y + b.y) / 2,
+            segIndex: i,
+            orientation: isH ? 'H' : 'V',
+            draggable: i > 0 && i < lastSeg,
+        });
+    }
+    return handles;
+}
+/** Apply a segment drag: move both endpoints of the segment in the drag direction. */
+export function applySegmentDrag(pts, segIndex, orientation, pos) {
+    const result = pts.map((p) => ({ ...p }));
+    if (orientation === 'H') {
+        result[segIndex] = { ...result[segIndex], y: pos.y };
+        result[segIndex + 1] = { ...result[segIndex + 1], y: pos.y };
+    }
+    else {
+        result[segIndex] = { ...result[segIndex], x: pos.x };
+        result[segIndex + 1] = { ...result[segIndex + 1], x: pos.x };
+    }
+    return result;
+}

package/dist/SimpleDiagram/simple-layout.d.ts

@@ -0,0 +1,27 @@
+import type { DiagramNode, DiagramEdge, ResolvedEdge } from '../diagram-types';
+export type NodeLookup = (id: string) => DiagramNode | undefined;
+/**
+ * Compute node positions using topological layered placement.
+ */
+export declare function simpleLayout(nodes: DiagramNode[], edges: DiagramEdge[]): {
+    nodes: DiagramNode[];
+    edges: ResolvedEdge[];
+};
+/**
+ * Layout with module as the primary grouping axis.
+ * Each module's entities are arranged in a compact rectangle (matrix grid).
+ * Module blocks are laid out left-to-right, wrapping to avoid excessive width.
+ */
+export declare function moduleLayout(nodes: DiagramNode[], edges: DiagramEdge[]): {
+    nodes: DiagramNode[];
+    edges: ResolvedEdge[];
+};
+/**
+ * Route a single edge: compute the fully resolved point array.
+ */
+export declare function routeEdge(edge: DiagramEdge, lookup: NodeLookup): ResolvedEdge;
+/**
+ * Route all edges given the current node positions.
+ */
+export declare function routeAllEdges(nodes: DiagramNode[], edges: DiagramEdge[]): ResolvedEdge[];
+//# sourceMappingURL=simple-layout.d.ts.map

package/dist/SimpleDiagram/simple-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-layout.d.ts","sourceRoot":"","sources":["../../src/lib/SimpleDiagram/simple-layout.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAS,MAAM,kBAAkB,CAAC;AActF,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;AA0HjE;;GAEG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,WAAW,EAAE,EACpB,KAAK,EAAE,WAAW,EAAE,GAClB;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,YAAY,EAAE,CAAA;CAAE,CAejD;AAqFD;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,WAAW,EAAE,EACpB,KAAK,EAAE,WAAW,EAAE,GAClB;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,KAAK,EAAE,YAAY,EAAE,CAAA;CAAE,CAmCjD;AA0GD;;GAEG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,UAAU,GAChB,YAAY,CAcd;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,WAAW,EAAE,EACpB,KAAK,EAAE,WAAW,EAAE,GAClB,YAAY,EAAE,CAIhB"}

package/dist/SimpleDiagram/simple-layout.js

@@ -0,0 +1,364 @@
+const NODE_WIDTH = 260;
+const NODE_GAP = 40;
+const LAYER_GAP = 100;
+const STUB_LENGTH = 24;
+const LOOP_OFFSET = 40;
+const HEADER_HEIGHT = 30;
+const ROW_HEIGHT = 22;
+const MODULE_BLOCK_GAP = 80;
+const OVERLAP_MARGIN = 30;
+/** Group items by a key function into a Map of arrays. */
+function groupBy(items, key) {
+    const map = new Map();
+    for (const item of items) {
+        const k = key(item);
+        let group = map.get(k);
+        if (!group) {
+            group = [];
+            map.set(k, group);
+        }
+        group.push(item);
+    }
+    return map;
+}
+/** Build adjacency lists from a set of node IDs and edges (skipping self-edges and external nodes). */
+function buildAdjacency(nodeIds, edges) {
+    const inDeg = new Map();
+    const outList = new Map();
+    for (const id of nodeIds) {
+        inDeg.set(id, 0);
+        outList.set(id, []);
+    }
+    for (const e of edges) {
+        if (e.source === e.target || !nodeIds.has(e.source) || !nodeIds.has(e.target))
+            continue;
+        inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+        outList.get(e.source).push(e.target);
+    }
+    return { inDeg, outList };
+}
+/** Compute a row's Y center position on a node by predicate. */
+function rowY(node, predicate) {
+    const idx = Math.max(0, node.data.columns.findIndex(predicate));
+    return node.y + HEADER_HEIGHT + idx * ROW_HEIGHT + ROW_HEIGHT / 2;
+}
+// --- Topological layered layout ---
+/**
+ * Assign layers via BFS from root nodes (no incoming edges).
+ * Returns Map<nodeId, layer>.
+ */
+function assignLayers(nodes, edges) {
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const { inDeg, outList } = buildAdjacency(nodeIds, edges);
+    const layers = new Map();
+    const queue = [];
+    // Roots: nodes with no incoming edges
+    for (const n of nodes) {
+        if (inDeg.get(n.id) === 0) {
+            layers.set(n.id, 0);
+            queue.push(n.id);
+        }
+    }
+    // If all nodes have incoming edges (cycle), pick the first as root
+    if (queue.length === 0 && nodes.length > 0) {
+        layers.set(nodes[0].id, 0);
+        queue.push(nodes[0].id);
+    }
+    // BFS — push each target to max(currentLayer + 1, existing).
+    // Cap re-visits per node to handle cycles in FK relationships.
+    const visits = new Map();
+    const maxVisits = nodes.length;
+    let head = 0;
+    while (head < queue.length) {
+        const nodeId = queue[head++];
+        const layer = layers.get(nodeId);
+        for (const tgt of outList.get(nodeId) ?? []) {
+            const prev = layers.get(tgt);
+            const next = layer + 1;
+            if (prev === undefined || next > prev) {
+                const vc = (visits.get(tgt) ?? 0) + 1;
+                if (vc > maxVisits)
+                    continue; // cycle — stop propagating
+                visits.set(tgt, vc);
+                layers.set(tgt, next);
+                queue.push(tgt);
+            }
+        }
+    }
+    // Assign any remaining unvisited nodes (disconnected)
+    for (const n of nodes) {
+        if (!layers.has(n.id)) {
+            layers.set(n.id, 0);
+        }
+    }
+    return layers;
+}
+/**
+ * Position nodes in columns and center vertically.
+ */
+function positionColumns(columns) {
+    const colHeights = columns.map((col) => {
+        let h = 0;
+        for (let i = 0; i < col.length; i++) {
+            h += col[i].height;
+            if (i < col.length - 1)
+                h += NODE_GAP;
+        }
+        return h;
+    });
+    const maxH = Math.max(...colHeights, 0);
+    const positioned = [];
+    for (let ci = 0; ci < columns.length; ci++) {
+        const col = columns[ci];
+        const x = ci * (NODE_WIDTH + LAYER_GAP);
+        const offsetY = (maxH - colHeights[ci]) / 2;
+        let y = offsetY;
+        for (const n of col) {
+            positioned.push({ ...n, x, y });
+            y += n.height + NODE_GAP;
+        }
+    }
+    return positioned;
+}
+/**
+ * Compute node positions using topological layered placement.
+ */
+export function simpleLayout(nodes, edges) {
+    if (nodes.length === 0)
+        return { nodes, edges: [] };
+    const layers = assignLayers(nodes, edges);
+    const layerGroups = groupBy(nodes, (n) => layers.get(n.id) ?? 0);
+    const maxLayer = Math.max(...layers.values());
+    const columns = [];
+    for (let i = 0; i <= maxLayer; i++) {
+        columns.push(layerGroups.get(i) ?? []);
+    }
+    const positioned = positionColumns(columns);
+    const resolved = routeAllEdges(positioned, edges);
+    return { nodes: positioned, edges: resolved };
+}
+/**
+ * Sort nodes topologically within a group using intra-group FK edges.
+ */
+function topoSort(group, edges) {
+    const nodeIds = new Set(group.map((n) => n.id));
+    const { inDeg, outList } = buildAdjacency(nodeIds, edges);
+    const sorted = [];
+    const visited = new Set();
+    const queue = [];
+    for (const n of group) {
+        if (inDeg.get(n.id) === 0)
+            queue.push(n.id);
+    }
+    const nodeMap = new Map(group.map((n) => [n.id, n]));
+    while (queue.length > 0) {
+        const id = queue.shift();
+        sorted.push(nodeMap.get(id));
+        visited.add(id);
+        for (const tgt of outList.get(id) ?? []) {
+            const d = inDeg.get(tgt) - 1;
+            inDeg.set(tgt, d);
+            if (d === 0)
+                queue.push(tgt);
+        }
+    }
+    // Append any remaining (cycles)
+    for (const n of group) {
+        if (!visited.has(n.id))
+            sorted.push(n);
+    }
+    return sorted;
+}
+/** Compute grid block dimensions without positioning. */
+function gridBlockSize(group) {
+    if (group.length === 0)
+        return { cols: 0, rows: 0, rowMaxH: [], width: 0, height: 0 };
+    const cols = Math.ceil(Math.sqrt(group.length));
+    const rows = Math.ceil(group.length / cols);
+    const rowMaxH = new Array(rows).fill(0);
+    for (let i = 0; i < group.length; i++) {
+        const r = Math.floor(i / cols);
+        rowMaxH[r] = Math.max(rowMaxH[r], group[i].height);
+    }
+    const width = cols * NODE_WIDTH + (cols - 1) * LAYER_GAP;
+    let height = 0;
+    for (let r = 0; r < rows; r++) {
+        height += rowMaxH[r];
+        if (r < rows - 1)
+            height += NODE_GAP;
+    }
+    return { cols, rows, rowMaxH, width, height };
+}
+/** Position nodes in a grid block at the given origin, using pre-computed size. */
+function gridBlock(group, originX, originY, size) {
+    if (group.length === 0)
+        return [];
+    const positioned = [];
+    for (let i = 0; i < group.length; i++) {
+        const col = i % size.cols;
+        const row = Math.floor(i / size.cols);
+        let y = originY;
+        for (let r = 0; r < row; r++)
+            y += size.rowMaxH[r] + NODE_GAP;
+        positioned.push({
+            ...group[i],
+            x: originX + col * (NODE_WIDTH + LAYER_GAP),
+            y,
+        });
+    }
+    return positioned;
+}
+/**
+ * Layout with module as the primary grouping axis.
+ * Each module's entities are arranged in a compact rectangle (matrix grid).
+ * Module blocks are laid out left-to-right, wrapping to avoid excessive width.
+ */
+export function moduleLayout(nodes, edges) {
+    if (nodes.length === 0)
+        return { nodes, edges: [] };
+    // Group nodes by module, sort each topologically
+    const moduleGroups = groupBy(nodes, (n) => n.data.moduleCd);
+    for (const [mod, group] of moduleGroups) {
+        moduleGroups.set(mod, topoSort(group, edges));
+    }
+    // Lay out module blocks left-to-right, wrapping when needed
+    const positioned = [];
+    let cursorX = 0;
+    let cursorY = 0;
+    let rowHeight = 0;
+    // Target ~3 module blocks per row
+    const maxRowWidth = 3 * (3 * (NODE_WIDTH + LAYER_GAP)) + 2 * MODULE_BLOCK_GAP;
+    for (const group of moduleGroups.values()) {
+        const size = gridBlockSize(group);
+        // Wrap to next row if this block exceeds max width (unless first in row)
+        if (cursorX > 0 && cursorX + size.width > maxRowWidth) {
+            cursorX = 0;
+            cursorY += rowHeight + MODULE_BLOCK_GAP;
+            rowHeight = 0;
+        }
+        positioned.push(...gridBlock(group, cursorX, cursorY, size));
+        cursorX += size.width + MODULE_BLOCK_GAP;
+        rowHeight = Math.max(rowHeight, size.height);
+    }
+    const resolved = routeAllEdges(positioned, edges);
+    return { nodes: positioned, edges: resolved };
+}
+// --- Edge routing ---
+/** Route a self-referencing edge as a U-loop on the right side. */
+function routeSelfEdge(edge, node, srcY, tgtY) {
+    const rightEdge = node.x + node.width;
+    const src = { x: rightEdge, y: srcY };
+    const tgt = { x: rightEdge, y: tgtY };
+    const rightX = rightEdge + LOOP_OFFSET;
+    if (Math.abs(srcY - tgtY) < ROW_HEIGHT) {
+        // Same row: rectangle loop above
+        const topY = Math.min(srcY, tgtY) - LOOP_OFFSET;
+        return { ...edge, points: [
+                src,
+                { x: rightX, y: src.y },
+                { x: rightX, y: topY },
+                { x: rightEdge, y: topY },
+                tgt,
+            ] };
+    }
+    // Different rows: simple U-shape on the right
+    return { ...edge, points: [
+            src,
+            { x: rightX, y: src.y },
+            { x: rightX, y: tgt.y },
+            tgt,
+        ] };
+}
+/** Route stubs that avoid crossing through the connected nodes. */
+function stubRoute(src, tgt, dir, srcNode, tgtNode) {
+    const stubSrc = src.x + dir * STUB_LENGTH;
+    const stubTgt = tgt.x - dir * STUB_LENGTH;
+    // Find midY that doesn't cross through either node
+    const srcBottom = srcNode.y + srcNode.height;
+    const tgtTop = tgtNode.y;
+    const srcTop = srcNode.y;
+    const tgtBottom = tgtNode.y + tgtNode.height;
+    let midY;
+    if (srcBottom + OVERLAP_MARGIN < tgtTop) {
+        // Gap between nodes — route through it
+        midY = (srcBottom + tgtTop) / 2;
+    }
+    else if (tgtBottom + OVERLAP_MARGIN < srcTop) {
+        midY = (tgtBottom + srcTop) / 2;
+    }
+    else {
+        // Nodes overlap vertically — route above both
+        midY = Math.min(srcTop, tgtTop) - OVERLAP_MARGIN;
+    }
+    return [
+        src,
+        { x: stubSrc, y: src.y },
+        { x: stubSrc, y: midY },
+        { x: stubTgt, y: midY },
+        { x: stubTgt, y: tgt.y },
+        tgt,
+    ];
+}
+/** Route a normal (non-self) edge with orthogonal H→V→H path. */
+function routeNormalEdge(edge, srcNode, tgtNode, srcY, tgtY) {
+    const srcCenterX = srcNode.x + srcNode.width / 2;
+    const tgtCenterX = tgtNode.x + tgtNode.width / 2;
+    const targetIsRight = tgtCenterX >= srcCenterX;
+    const dir = targetIsRight ? 1 : -1;
+    const src = {
+        x: targetIsRight ? srcNode.x + srcNode.width : srcNode.x,
+        y: srcY,
+    };
+    const tgt = {
+        x: targetIsRight ? tgtNode.x : tgtNode.x + tgtNode.width,
+        y: tgtY,
+    };
+    const gap = (tgt.x - src.x) * dir;
+    let points;
+    if (gap > STUB_LENGTH * 2) {
+        const midX = (src.x + tgt.x) / 2;
+        // Check if the vertical segment at midX would pass through either node
+        const midXInSrc = midX > srcNode.x && midX < srcNode.x + srcNode.width;
+        const midXInTgt = midX > tgtNode.x && midX < tgtNode.x + tgtNode.width;
+        if (!midXInSrc && !midXInTgt) {
+            points = [
+                src,
+                { x: midX, y: src.y },
+                { x: midX, y: tgt.y },
+                tgt,
+            ];
+        }
+        else {
+            // midX overlaps a node — use stubs to route around
+            points = stubRoute(src, tgt, dir, srcNode, tgtNode);
+        }
+    }
+    else {
+        points = stubRoute(src, tgt, dir, srcNode, tgtNode);
+    }
+    return { ...edge, points };
+}
+/**
+ * Route a single edge: compute the fully resolved point array.
+ */
+export function routeEdge(edge, lookup) {
+    const srcNode = lookup(edge.source);
+    const tgtNode = lookup(edge.target);
+    if (!srcNode || !tgtNode) {
+        return { ...edge, points: [] };
+    }
+    const srcY = rowY(srcNode, (c) => c.columnCd === edge.sourceHandle);
+    const tgtY = rowY(tgtNode, (c) => c.isPk);
+    if (edge.source === edge.target) {
+        return routeSelfEdge(edge, srcNode, srcY, tgtY);
+    }
+    return routeNormalEdge(edge, srcNode, tgtNode, srcY, tgtY);
+}
+/**
+ * Route all edges given the current node positions.
+ */
+export function routeAllEdges(nodes, edges) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const lookup = (id) => nodeMap.get(id);
+    return edges.map((e) => routeEdge(e, lookup));
+}