@bpmnkit/core 0.0.8

package/dist/layout/crossing.d.ts

@@ -0,0 +1,8 @@
+import type { DirectedGraph } from "./graph.js";
+/**
+ * Minimize edge crossings using the barycenter heuristic.
+ * For each layer, order nodes by the average position of their neighbors
+ * in the adjacent layer. Iterates a fixed number of passes.
+ */
+export declare function minimizeCrossings(layerGroups: string[][], graph: DirectedGraph, iterations?: number): string[][];
+//# sourceMappingURL=crossing.d.ts.map

package/dist/layout/crossing.js

@@ -0,0 +1,60 @@
+/**
+ * Minimize edge crossings using the barycenter heuristic.
+ * For each layer, order nodes by the average position of their neighbors
+ * in the adjacent layer. Iterates a fixed number of passes.
+ */
+export function minimizeCrossings(layerGroups, graph, iterations = 4) {
+    const result = layerGroups.map((layer) => [...layer]);
+    for (let iter = 0; iter < iterations; iter++) {
+        // Forward sweep (left to right): order by predecessor positions
+        for (let i = 1; i < result.length; i++) {
+            orderByBarycenter(result, i, graph, "predecessors");
+        }
+        // Backward sweep (right to left): order by successor positions
+        for (let i = result.length - 2; i >= 0; i--) {
+            orderByBarycenter(result, i, graph, "successors");
+        }
+    }
+    return result;
+}
+function orderByBarycenter(layers, layerIndex, graph, direction) {
+    const layer = layers[layerIndex];
+    if (!layer)
+        return;
+    const adjacentLayer = direction === "predecessors" ? layers[layerIndex - 1] : layers[layerIndex + 1];
+    if (!adjacentLayer || adjacentLayer.length === 0)
+        return;
+    // Build position index for the adjacent layer
+    const posIndex = new Map();
+    for (let i = 0; i < adjacentLayer.length; i++) {
+        const adjNode = adjacentLayer[i];
+        if (!adjNode)
+            continue;
+        posIndex.set(adjNode, i);
+    }
+    // Compute barycenter for each node in current layer
+    const barycenters = new Map();
+    for (const nodeId of layer) {
+        const neighbors = direction === "predecessors"
+            ? (graph.predecessors.get(nodeId) ?? [])
+            : (graph.successors.get(nodeId) ?? []);
+        const adjacentPositions = [];
+        for (const neighbor of neighbors) {
+            const pos = posIndex.get(neighbor);
+            if (pos !== undefined) {
+                adjacentPositions.push(pos);
+            }
+        }
+        if (adjacentPositions.length > 0) {
+            const sum = adjacentPositions.reduce((a, b) => a + b, 0);
+            barycenters.set(nodeId, sum / adjacentPositions.length);
+        }
+        else {
+            // Keep original position for nodes without connections
+            barycenters.set(nodeId, layer.indexOf(nodeId));
+        }
+    }
+    // Sort by barycenter, preserving relative order for equal values
+    layer.sort((a, b) => (barycenters.get(a) ?? 0) - (barycenters.get(b) ?? 0));
+}
+//# sourceMappingURL=crossing.js.map

package/dist/layout/graph.d.ts

@@ -0,0 +1,28 @@
+import type { BpmnFlowElement, BpmnSequenceFlow } from "../bpmn/bpmn-model.js";
+/** Adjacency list representation of a directed graph. */
+export interface DirectedGraph {
+    /** Node IDs. */
+    nodes: string[];
+    /** Adjacency: nodeId → list of successor nodeIds. */
+    successors: Map<string, string[]>;
+    /** Reverse adjacency: nodeId → list of predecessor nodeIds. */
+    predecessors: Map<string, string[]>;
+}
+/** Back-edge detected during DFS. */
+export interface BackEdge {
+    flowId: string;
+    sourceRef: string;
+    targetRef: string;
+}
+/** Build a directed graph from BPMN flow nodes and sequence flows. */
+export declare function buildGraph(flowNodes: BpmnFlowElement[], sequenceFlows: BpmnSequenceFlow[]): DirectedGraph;
+/**
+ * Detect back-edges via DFS.
+ * A back-edge is an edge where the target is an ancestor of the source in the DFS tree.
+ */
+export declare function detectBackEdges(graph: DirectedGraph, sequenceFlows: BpmnSequenceFlow[]): BackEdge[];
+/** Reverse back-edges in the graph to make it a DAG. Returns the modified graph. */
+export declare function reverseBackEdges(graph: DirectedGraph, backEdges: BackEdge[]): DirectedGraph;
+/** Topological sort of a DAG. Throws if cycles remain. */
+export declare function topologicalSort(graph: DirectedGraph): string[];
+//# sourceMappingURL=graph.d.ts.map

package/dist/layout/graph.js

@@ -0,0 +1,126 @@
+/** Build a directed graph from BPMN flow nodes and sequence flows. */
+export function buildGraph(flowNodes, sequenceFlows) {
+    const nodes = flowNodes.map((n) => n.id);
+    const successors = new Map();
+    const predecessors = new Map();
+    for (const id of nodes) {
+        successors.set(id, []);
+        predecessors.set(id, []);
+    }
+    for (const flow of sequenceFlows) {
+        const succs = successors.get(flow.sourceRef);
+        if (succs)
+            succs.push(flow.targetRef);
+        const preds = predecessors.get(flow.targetRef);
+        if (preds)
+            preds.push(flow.sourceRef);
+    }
+    return { nodes, successors, predecessors };
+}
+/**
+ * Detect back-edges via DFS.
+ * A back-edge is an edge where the target is an ancestor of the source in the DFS tree.
+ */
+export function detectBackEdges(graph, sequenceFlows) {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    for (const id of graph.nodes) {
+        color.set(id, WHITE);
+    }
+    const backEdges = [];
+    const flowIndex = new Map();
+    for (const flow of sequenceFlows) {
+        flowIndex.set(`${flow.sourceRef}->${flow.targetRef}`, flow);
+    }
+    function dfs(nodeId) {
+        color.set(nodeId, GRAY);
+        const succs = graph.successors.get(nodeId) ?? [];
+        for (const succ of succs) {
+            const c = color.get(succ);
+            if (c === GRAY) {
+                const flow = flowIndex.get(`${nodeId}->${succ}`);
+                if (flow) {
+                    backEdges.push({
+                        flowId: flow.id,
+                        sourceRef: nodeId,
+                        targetRef: succ,
+                    });
+                }
+            }
+            else if (c === WHITE) {
+                dfs(succ);
+            }
+        }
+        color.set(nodeId, BLACK);
+    }
+    for (const id of graph.nodes) {
+        if (color.get(id) === WHITE) {
+            dfs(id);
+        }
+    }
+    return backEdges;
+}
+/** Reverse back-edges in the graph to make it a DAG. Returns the modified graph. */
+export function reverseBackEdges(graph, backEdges) {
+    const successors = new Map();
+    const predecessors = new Map();
+    for (const id of graph.nodes) {
+        successors.set(id, [...(graph.successors.get(id) ?? [])]);
+        predecessors.set(id, [...(graph.predecessors.get(id) ?? [])]);
+    }
+    for (const be of backEdges) {
+        // Remove forward direction
+        const succs = successors.get(be.sourceRef);
+        if (succs) {
+            const idx = succs.indexOf(be.targetRef);
+            if (idx >= 0)
+                succs.splice(idx, 1);
+        }
+        const preds = predecessors.get(be.targetRef);
+        if (preds) {
+            const idx = preds.indexOf(be.sourceRef);
+            if (idx >= 0)
+                preds.splice(idx, 1);
+        }
+        // Add reversed direction
+        const revSuccs = successors.get(be.targetRef);
+        if (revSuccs)
+            revSuccs.push(be.sourceRef);
+        const revPreds = predecessors.get(be.sourceRef);
+        if (revPreds)
+            revPreds.push(be.targetRef);
+    }
+    return { nodes: [...graph.nodes], successors, predecessors };
+}
+/** Topological sort of a DAG. Throws if cycles remain. */
+export function topologicalSort(graph) {
+    const inDegree = new Map();
+    for (const id of graph.nodes) {
+        inDegree.set(id, (graph.predecessors.get(id) ?? []).length);
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node)
+            break;
+        sorted.push(node);
+        for (const succ of graph.successors.get(node) ?? []) {
+            const newDeg = (inDegree.get(succ) ?? 1) - 1;
+            inDegree.set(succ, newDeg);
+            if (newDeg === 0)
+                queue.push(succ);
+        }
+    }
+    if (sorted.length !== graph.nodes.length) {
+        throw new Error(`Layout error: graph contains cycles after back-edge reversal (sorted ${sorted.length} of ${graph.nodes.length} nodes)`);
+    }
+    return sorted;
+}
+//# sourceMappingURL=graph.js.map

package/dist/layout/index.d.ts

@@ -0,0 +1,7 @@
+export { layoutProcess, layoutFlowNodes } from "./layout-engine.js";
+export { benchmarkLayout, compareLayouts, formatBenchmarkResult, generateAutoLayout, parseReferenceLayout, } from "./bench.js";
+export type { BenchmarkResult, BoundingBox, ElementComparison, ElementPosition, FlowOrderViolation, } from "./bench.js";
+export { assertNoOverlap } from "./overlap.js";
+export type { Bounds, LayoutEdge, LayoutNode, LayoutResult, Waypoint } from "./types.js";
+export { ELEMENT_SIZES, GRID_CELL_HEIGHT, GRID_CELL_WIDTH, HORIZONTAL_SPACING, LABEL_CHAR_WIDTH, LABEL_HEIGHT, LABEL_MIN_WIDTH, LABEL_VERTICAL_OFFSET, SUBPROCESS_PADDING, VERTICAL_SPACING, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/layout/index.js

@@ -0,0 +1,5 @@
+export { layoutProcess, layoutFlowNodes } from "./layout-engine.js";
+export { benchmarkLayout, compareLayouts, formatBenchmarkResult, generateAutoLayout, parseReferenceLayout, } from "./bench.js";
+export { assertNoOverlap } from "./overlap.js";
+export { ELEMENT_SIZES, GRID_CELL_HEIGHT, GRID_CELL_WIDTH, HORIZONTAL_SPACING, LABEL_CHAR_WIDTH, LABEL_HEIGHT, LABEL_MIN_WIDTH, LABEL_VERTICAL_OFFSET, SUBPROCESS_PADDING, VERTICAL_SPACING, } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/layout/layers.d.ts

@@ -0,0 +1,13 @@
+import type { DirectedGraph } from "./graph.js";
+/**
+ * Assign layers using longest-path algorithm.
+ * Each node gets a layer equal to the longest path from any source to it.
+ * This produces a left-to-right layout where layers represent columns.
+ */
+export declare function assignLayers(graph: DirectedGraph): Map<string, number>;
+/**
+ * Group nodes by their assigned layer.
+ * Returns an array of arrays, where index = layer number.
+ */
+export declare function groupByLayer(layers: Map<string, number>): string[][];
+//# sourceMappingURL=layers.d.ts.map

package/dist/layout/layers.js

@@ -0,0 +1,49 @@
+import { topologicalSort } from "./graph.js";
+/**
+ * Assign layers using longest-path algorithm.
+ * Each node gets a layer equal to the longest path from any source to it.
+ * This produces a left-to-right layout where layers represent columns.
+ */
+export function assignLayers(graph) {
+    const sorted = topologicalSort(graph);
+    const layers = new Map();
+    // Initialize all nodes at layer 0
+    for (const id of sorted) {
+        layers.set(id, 0);
+    }
+    // Forward pass: each node's layer = max(predecessor layers) + 1
+    for (const id of sorted) {
+        const preds = graph.predecessors.get(id) ?? [];
+        if (preds.length > 0) {
+            let maxPredLayer = 0;
+            for (const pred of preds) {
+                const predLayer = layers.get(pred) ?? 0;
+                if (predLayer >= maxPredLayer) {
+                    maxPredLayer = predLayer + 1;
+                }
+            }
+            layers.set(id, maxPredLayer);
+        }
+    }
+    return layers;
+}
+/**
+ * Group nodes by their assigned layer.
+ * Returns an array of arrays, where index = layer number.
+ */
+export function groupByLayer(layers) {
+    let maxLayer = 0;
+    for (const layer of layers.values()) {
+        if (layer > maxLayer)
+            maxLayer = layer;
+    }
+    const groups = [];
+    for (let i = 0; i <= maxLayer; i++) {
+        groups.push([]);
+    }
+    for (const [id, layer] of layers) {
+        groups[layer]?.push(id);
+    }
+    return groups;
+}
+//# sourceMappingURL=layers.js.map

package/dist/layout/layout-engine.d.ts

@@ -0,0 +1,21 @@
+import type { BpmnFlowElement, BpmnProcess, BpmnSequenceFlow } from "../bpmn/bpmn-model.js";
+import type { LayoutResult } from "./types.js";
+/**
+ * Auto-layout a BPMN process using the Sugiyama/layered algorithm.
+ *
+ * Phases:
+ * 1. Cycle removal — DFS back-edge detection and reversal
+ * 2. Layer assignment — Longest-path layering
+ * 3. Crossing minimization — Barycenter heuristic
+ * 4. Coordinate assignment — Fixed element sizes with spacing
+ * 5. Sub-process layout — Recursive nested passes
+ * 6. Edge routing — Orthogonal waypoints
+ * 7. Overlap assertion — Post-condition validation
+ */
+export declare function layoutProcess(process: BpmnProcess): LayoutResult;
+/**
+ * Layout a set of flow nodes and sequence flows.
+ * Used both for top-level processes and recursively for sub-processes.
+ */
+export declare function layoutFlowNodes(flowNodes: BpmnFlowElement[], sequenceFlows: BpmnSequenceFlow[]): LayoutResult;
+//# sourceMappingURL=layout-engine.d.ts.map

package/dist/layout/layout-engine.js

@@ -0,0 +1,191 @@
+import { alignBaselinePath, alignBranchBaselines, alignSplitJoinPairs, assignCoordinates, distributeSplitBranches, ensureEarlyReturnOffBaseline, resolveLayerOverlaps, } from "./coordinates.js";
+import { minimizeCrossings } from "./crossing.js";
+import { buildGraph, detectBackEdges, reverseBackEdges } from "./graph.js";
+import { assignLayers, groupByLayer } from "./layers.js";
+import { assertNoOverlap } from "./overlap.js";
+import { routeEdges } from "./routing.js";
+import { layoutSubProcesses } from "./subprocess.js";
+/**
+ * Auto-layout a BPMN process using the Sugiyama/layered algorithm.
+ *
+ * Phases:
+ * 1. Cycle removal — DFS back-edge detection and reversal
+ * 2. Layer assignment — Longest-path layering
+ * 3. Crossing minimization — Barycenter heuristic
+ * 4. Coordinate assignment — Fixed element sizes with spacing
+ * 5. Sub-process layout — Recursive nested passes
+ * 6. Edge routing — Orthogonal waypoints
+ * 7. Overlap assertion — Post-condition validation
+ */
+export function layoutProcess(process) {
+    const result = layoutFlowNodes(process.flowElements, process.sequenceFlows);
+    assertNoOverlap(result);
+    return result;
+}
+/**
+ * Layout a set of flow nodes and sequence flows.
+ * Used both for top-level processes and recursively for sub-processes.
+ */
+export function layoutFlowNodes(flowNodes, sequenceFlows) {
+    if (flowNodes.length === 0) {
+        return { nodes: [], edges: [] };
+    }
+    // Build node index
+    const nodeIndex = new Map();
+    for (const node of flowNodes) {
+        nodeIndex.set(node.id, node);
+    }
+    // Phase 1: Build graph and detect/remove cycles
+    const graph = buildGraph(flowNodes, sequenceFlows);
+    const backEdges = detectBackEdges(graph, sequenceFlows);
+    const dag = backEdges.length > 0 ? reverseBackEdges(graph, backEdges) : graph;
+    // Phase 2: Layer assignment
+    const layers = assignLayers(dag);
+    // Phase 3: Group by layer and minimize crossings
+    const layerGroups = groupByLayer(layers);
+    const orderedLayers = minimizeCrossings(layerGroups, dag);
+    // Phase 4: Coordinate assignment
+    const layoutNodes = assignCoordinates(orderedLayers, nodeIndex);
+    // Phase 4b: Align linear sequences to a common y-baseline
+    alignBranchBaselines(layoutNodes, dag);
+    // Phase 4c: Align split/join gateway pairs to same y-coordinate
+    alignSplitJoinPairs(layoutNodes, dag, backEdges);
+    // Phase 4d: Align all baseline-path nodes to the same center-Y
+    alignBaselinePath(layoutNodes, dag, backEdges);
+    // Phase 4e: Ensure early-return branches are never on the baseline
+    ensureEarlyReturnOffBaseline(layoutNodes, dag, backEdges);
+    // Phase 4f: Distribute split gateway branches symmetrically
+    distributeSplitBranches(layoutNodes, dag, backEdges);
+    // Phase 4g: Resolve any layer overlaps from redistribution
+    resolveLayerOverlaps(layoutNodes);
+    // Phase 4h: Re-align baseline after overlap resolution (overlap resolution may push
+    // baseline nodes off-center when they share a layer with branch nodes)
+    alignBaselinePath(layoutNodes, dag, backEdges);
+    // Phase 4i: Final overlap resolution — baseline re-alignment may pull a node back into
+    // an overlap that resolveLayerOverlaps already fixed; one more pass eliminates these.
+    resolveLayerOverlaps(layoutNodes);
+    // Phase 5: Sub-process layout — expand containers and lay out children
+    const childResults = layoutSubProcesses(layoutNodes, nodeIndex);
+    // After subprocess expansion, push nodes that now overlap with expanded containers
+    resolveSubProcessOverlaps(layoutNodes);
+    // Phase 5b: Resolve Y-direction overlaps caused by subprocess expansion.
+    // Expanded subprocesses grow in-place and can overlap same-layer siblings.
+    resolveLayerOverlaps(layoutNodes);
+    // Phase 5c: Sync child positions to their subprocess containers.
+    // resolveLayerOverlaps (including its Y-normalization pass) may have shifted
+    // subprocess containers after their children were already translated to
+    // absolute coordinates — children must follow.
+    syncSubProcessChildren(childResults, layoutNodes);
+    // Phase 6: Edge routing (uses original back-edges for routing, not reversed)
+    const nodeMap = new Map();
+    for (const node of layoutNodes) {
+        nodeMap.set(node.id, node);
+    }
+    const edges = routeEdges(sequenceFlows, nodeMap, backEdges);
+    // Flatten child results into the main layout
+    const allNodes = [...layoutNodes];
+    const allEdges = [...edges];
+    for (const child of childResults) {
+        for (const cn of child.result.nodes) {
+            allNodes.push(cn);
+        }
+        for (const ce of child.result.edges) {
+            allEdges.push(ce);
+        }
+    }
+    return { nodes: allNodes, edges: allEdges };
+}
+/**
+ * After subprocess expansion, cascade-shift all subsequent layers
+ * so that inter-layer spacing is preserved.
+ */
+function resolveSubProcessOverlaps(nodes) {
+    const expanded = nodes.filter((n) => n.isExpanded);
+    if (expanded.length === 0)
+        return;
+    // Group nodes by layer
+    const byLayer = new Map();
+    for (const n of nodes) {
+        const arr = byLayer.get(n.layer);
+        if (arr)
+            arr.push(n);
+        else
+            byLayer.set(n.layer, [n]);
+    }
+    const layers = [...byLayer.keys()].sort((a, b) => a - b);
+    const MIN_GAP = 50;
+    // Cascade: ensure each layer starts after previous layer's rightmost edge
+    for (let i = 1; i < layers.length; i++) {
+        const prevKey = layers[i - 1];
+        const curKey = layers[i];
+        if (prevKey === undefined || curKey === undefined)
+            continue;
+        const prevNodes = byLayer.get(prevKey);
+        const curNodes = byLayer.get(curKey);
+        if (!prevNodes || !curNodes)
+            continue;
+        // Find rightmost edge in previous layer (including labels)
+        let prevRight = 0;
+        for (const n of prevNodes) {
+            prevRight = Math.max(prevRight, n.bounds.x + n.bounds.width);
+            if (n.labelBounds) {
+                prevRight = Math.max(prevRight, n.labelBounds.x + n.labelBounds.width);
+            }
+        }
+        // Find leftmost edge in current layer
+        let curLeft = Number.POSITIVE_INFINITY;
+        for (const n of curNodes) {
+            curLeft = Math.min(curLeft, n.bounds.x);
+        }
+        const gap = curLeft - prevRight;
+        if (gap < MIN_GAP) {
+            const dx = MIN_GAP - gap;
+            for (const n of curNodes) {
+                n.bounds.x += dx;
+                if (n.labelBounds) {
+                    n.labelBounds.x += dx;
+                }
+            }
+        }
+    }
+}
+/**
+ * After post-expansion adjustments (resolveSubProcessOverlaps, resolveLayerOverlaps),
+ * subprocess containers may have been shifted. Translate their children by the same
+ * delta so that children remain correctly positioned inside their parent.
+ */
+function syncSubProcessChildren(childResults, layoutNodes) {
+    if (childResults.length === 0)
+        return;
+    const nodeMap = new Map();
+    for (const n of layoutNodes)
+        nodeMap.set(n.id, n);
+    for (const cr of childResults) {
+        const parent = nodeMap.get(cr.parentId);
+        if (!parent)
+            continue;
+        const dx = parent.bounds.x - cr.parentX;
+        const dy = parent.bounds.y - cr.parentY;
+        if (dx === 0 && dy === 0)
+            continue;
+        for (const child of cr.result.nodes) {
+            child.bounds.x += dx;
+            child.bounds.y += dy;
+            if (child.labelBounds) {
+                child.labelBounds.x += dx;
+                child.labelBounds.y += dy;
+            }
+        }
+        for (const edge of cr.result.edges) {
+            for (const wp of edge.waypoints) {
+                wp.x += dx;
+                wp.y += dy;
+            }
+            if (edge.labelBounds) {
+                edge.labelBounds.x += dx;
+                edge.labelBounds.y += dy;
+            }
+        }
+    }
+}
+//# sourceMappingURL=layout-engine.js.map

package/dist/layout/overlap.d.ts

@@ -0,0 +1,10 @@
+import type { LayoutResult } from "./types.js";
+/**
+ * Assert that no two element bounding boxes overlap and
+ * no element overlaps a label.
+ * Label-vs-label overlaps are allowed when both labels belong to
+ * a node and an edge connected to that node.
+ * Throws if any overlap is detected.
+ */
+export declare function assertNoOverlap(result: LayoutResult): void;
+//# sourceMappingURL=overlap.d.ts.map

package/dist/layout/overlap.js

@@ -0,0 +1,70 @@
+/**
+ * Assert that no two element bounding boxes overlap and
+ * no element overlaps a label.
+ * Label-vs-label overlaps are allowed when both labels belong to
+ * a node and an edge connected to that node.
+ * Throws if any overlap is detected.
+ */
+export function assertNoOverlap(result) {
+    const allBounds = [];
+    for (const node of result.nodes) {
+        allBounds.push({ id: node.id, kind: "element", bounds: node.bounds });
+        if (node.labelBounds) {
+            allBounds.push({ id: `${node.id}-label`, kind: "label", bounds: node.labelBounds });
+        }
+    }
+    // Track which nodes are connected to which edges
+    const edgeEndpoints = new Set();
+    for (const edge of result.edges) {
+        if (edge.labelBounds) {
+            allBounds.push({ id: `${edge.id}-label`, kind: "label", bounds: edge.labelBounds });
+        }
+        edgeEndpoints.add(`${edge.id}:${edge.sourceRef}`);
+        edgeEndpoints.add(`${edge.id}:${edge.targetRef}`);
+    }
+    for (let i = 0; i < allBounds.length; i++) {
+        for (let j = i + 1; j < allBounds.length; j++) {
+            const a = allBounds[i];
+            if (!a)
+                continue;
+            const b = allBounds[j];
+            if (!b)
+                continue;
+            // Skip label-to-same-element overlap checks (labels belong to their element)
+            if (a.id.replace("-label", "") === b.id.replace("-label", ""))
+                continue;
+            // Skip label-vs-label overlaps between a node and its connected edge
+            if (a.kind === "label" && b.kind === "label") {
+                if (areConnectedLabels(a.id, b.id, edgeEndpoints))
+                    continue;
+            }
+            // Skip checking elements that are in a parent-child relationship
+            // (sub-process children are inside the sub-process bounds by design)
+            if (boundsOverlap(a.bounds, b.bounds)) {
+                // Check if one is a sub-process containing the other
+                if (isContainedWithin(a.bounds, b.bounds) || isContainedWithin(b.bounds, a.bounds)) {
+                    continue;
+                }
+                throw new Error(`Layout overlap detected: ${a.kind} "${a.id}" overlaps with ${b.kind} "${b.id}"`);
+            }
+        }
+    }
+}
+/** Check if two labels belong to a node and an edge connected to that node. */
+function areConnectedLabels(idA, idB, edgeEndpoints) {
+    const baseA = idA.replace("-label", "");
+    const baseB = idB.replace("-label", "");
+    return edgeEndpoints.has(`${baseA}:${baseB}`) || edgeEndpoints.has(`${baseB}:${baseA}`);
+}
+/** Check if two bounding boxes overlap (exclusive of touching edges). */
+function boundsOverlap(a, b) {
+    return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+/** Check if bounds `inner` is fully contained within `outer`. */
+function isContainedWithin(inner, outer) {
+    return (inner.x >= outer.x &&
+        inner.y >= outer.y &&
+        inner.x + inner.width <= outer.x + outer.width &&
+        inner.y + inner.height <= outer.y + outer.height);
+}
+//# sourceMappingURL=overlap.js.map

package/dist/layout/routing.d.ts

@@ -0,0 +1,26 @@
+import type { BpmnSequenceFlow } from "../bpmn/bpmn-model.js";
+import type { BackEdge } from "./graph.js";
+import type { LayoutEdge, LayoutNode } from "./types.js";
+/** Port side for gateway edge connection. */
+export type PortSide = "right" | "top" | "bottom";
+/**
+ * Determine which side of the target a forward edge should connect to.
+ * Non-gateway targets always receive edges from the left side.
+ * Split gateways (starting): incoming always from the left.
+ * Join gateways (closing): incoming based on relative position (top/bottom/left).
+ */
+export declare function resolveTargetPort(source: LayoutNode, target: LayoutNode, joinGateways: ReadonlySet<string>): "left" | "top" | "bottom";
+/**
+ * Assign source ports for outgoing edges of a gateway.
+ * - Single output: right port.
+ * - Odd count: middle (by target y) → right, upper half → top, lower half → bottom.
+ * - Even count: upper half → top, lower half → bottom, no right port.
+ */
+export declare function assignGatewayPorts(outgoingFlows: BpmnSequenceFlow[], nodeMap: Map<string, LayoutNode>): Map<string, PortSide>;
+/**
+ * Route edges with orthogonal (horizontal + vertical) segments.
+ * Forward edges go left-to-right; back-edges route above or below.
+ * Gateway sources use port-based routing (top/right/bottom).
+ */
+export declare function routeEdges(sequenceFlows: BpmnSequenceFlow[], nodeMap: Map<string, LayoutNode>, backEdges: BackEdge[]): LayoutEdge[];
+//# sourceMappingURL=routing.d.ts.map