bpmn-elk-layout 1.1.2 → 1.2.0

package/dist/bin/bpmn-elk-layout.js

@@ -26,10 +26,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.bun/tsup@8.5.1+83f24e8a18629abd/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.bun/tsup@8.5.1+e293d8ed4487f686/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl, importMetaUrl;
 var init_cjs_shims = __esm({
-  "../../node_modules/.bun/tsup@8.5.1+83f24e8a18629abd/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.bun/tsup@8.5.1+e293d8ed4487f686/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
     getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
     importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
@@ -42,7 +42,11 @@ function enableCliMode() {
 }
 function isDebugEnabled() {
   if (cliMode) return false;
-  return typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
+  try {
+    return typeof process !== "undefined" && typeof process.env !== "undefined" && process.env?.["DEBUG"] === "true";
+  } catch (e) {
+    return false;
+  }
 }
 var cliMode;
 var init_debug = __esm({
@@ -174,763 +178,103 @@ var init_size_calculator = __esm({
   }
 });
 
-// src/layout/edge-routing/geometry-utils.ts
-function distance(p1, p2) {
-  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
-}
-function calculatePathLength(waypoints) {
-  let length = 0;
-  for (let i = 0; i < waypoints.length - 1; i++) {
-    const p1 = waypoints[i];
-    const p2 = waypoints[i + 1];
-    if (p1 && p2) {
-      length += distance(p1, p2);
-    }
-  }
-  return length;
-}
-function segmentIntersectsRect(p1, p2, rect) {
-  const margin = 5;
-  const left = rect.x - margin;
-  const right = rect.x + rect.width + margin;
-  const top = rect.y - margin;
-  const bottom = rect.y + rect.height + margin;
-  if (p1.x < left && p2.x < left || p1.x > right && p2.x > right) return false;
-  if (p1.y < top && p2.y < top || p1.y > bottom && p2.y > bottom) return false;
-  if (Math.abs(p1.x - p2.x) < 1) {
-    const x = p1.x;
-    const minY = Math.min(p1.y, p2.y);
-    const maxY = Math.max(p1.y, p2.y);
-    return x >= left && x <= right && maxY >= top && minY <= bottom;
-  }
-  if (Math.abs(p1.y - p2.y) < 1) {
-    const y = p1.y;
-    const minX = Math.min(p1.x, p2.x);
-    const maxX = Math.max(p1.x, p2.x);
-    return y >= top && y <= bottom && maxX >= left && minX <= right;
-  }
-  return true;
-}
-function segmentCrossesNode(p1, p2, node) {
-  const margin = 5;
-  const nodeLeft = node.x - margin;
-  const nodeRight = node.x + node.width + margin;
-  const nodeTop = node.y - margin;
-  const nodeBottom = node.y + node.height + margin;
-  if (Math.abs(p1.y - p2.y) < 1) {
-    const segY = p1.y;
-    const segMinX = Math.min(p1.x, p2.x);
-    const segMaxX = Math.max(p1.x, p2.x);
-    if (segY > nodeTop && segY < nodeBottom) {
-      if (segMinX < nodeRight && segMaxX > nodeLeft) {
-        const interiorLeft = node.x + margin;
-        const interiorRight = node.x + node.width - margin;
-        if (segMinX < interiorRight && segMaxX > interiorLeft) {
-          return true;
-        }
-      }
-    }
-  }
-  if (Math.abs(p1.x - p2.x) < 1) {
-    const segX = p1.x;
-    const segMinY = Math.min(p1.y, p2.y);
-    const segMaxY = Math.max(p1.y, p2.y);
-    if (segX > nodeLeft && segX < nodeRight) {
-      if (segMinY < nodeBottom && segMaxY > nodeTop) {
-        const interiorTop = node.y + margin;
-        const interiorBottom = node.y + node.height - margin;
-        if (segMinY < interiorBottom && segMaxY > interiorTop) {
-          return true;
+// src/layout/post-processing/boundary-event/collector.ts
+function collectBoundaryEventInfo(graph) {
+  const info = /* @__PURE__ */ new Map();
+  const edgeMap = /* @__PURE__ */ new Map();
+  const collectEdges = (node) => {
+    if (node.edges) {
+      for (const edge of node.edges) {
+        const source = edge.sources?.[0];
+        const target = edge.targets?.[0];
+        if (!source || !target) continue;
+        if (!edgeMap.has(source)) {
+          edgeMap.set(source, []);
         }
+        edgeMap.get(source).push(target);
       }
     }
-  }
-  return false;
-}
-function scoreRoute(start, bendPoints, end, obstacles) {
-  let score = 0;
-  const crossingPenalty = 1e3;
-  const lengthWeight = 0.1;
-  const path = [start, ...bendPoints, end];
-  for (const obs of obstacles) {
-    for (let i = 0; i < path.length - 1; i++) {
-      const p1 = path[i];
-      const p2 = path[i + 1];
-      if (p1 && p2 && segmentIntersectsRect(p1, p2, obs)) {
-        score += crossingPenalty;
+    if (node.children) {
+      for (const child of node.children) {
+        collectEdges(child);
       }
     }
-  }
-  for (let i = 0; i < path.length - 1; i++) {
-    const p1 = path[i];
-    const p2 = path[i + 1];
-    if (p1 && p2) {
-      score += distance(p1, p2) * lengthWeight;
+  };
+  const collectBoundaryEvents = (node) => {
+    if (node.boundaryEvents) {
+      const totalBoundaries = node.boundaryEvents.length;
+      node.boundaryEvents.forEach((be, index) => {
+        const targets = edgeMap.get(be.id) || [];
+        info.set(be.id, {
+          attachedToRef: be.attachedToRef,
+          targets,
+          boundaryIndex: index,
+          totalBoundaries
+        });
+      });
     }
-  }
-  return score;
-}
-function findClearVerticalPath(x, startY, endY, obstacles) {
-  const minY = Math.min(startY, endY);
-  const maxY = Math.max(startY, endY);
-  const margin = 10;
-  for (const obs of obstacles) {
-    const obsLeft = obs.x - margin;
-    const obsRight = obs.x + obs.width + margin;
-    const obsTop = obs.y;
-    const obsBottom = obs.y + obs.height;
-    if (x >= obsLeft && x <= obsRight) {
-      if (obsBottom > minY && obsTop < maxY) {
-        const spaceAbove = obsTop - minY;
-        const spaceBelow = maxY - obsBottom;
-        if (spaceBelow > spaceAbove && obsBottom + margin < maxY) {
-          return obsBottom + margin;
-        } else if (obsTop - margin > minY) {
-          return obsTop - margin;
-        }
+    if (node.children) {
+      for (const child of node.children) {
+        collectBoundaryEvents(child);
       }
     }
+  };
+  for (const child of graph.children ?? []) {
+    collectEdges(child);
+    collectBoundaryEvents(child);
   }
-  return null;
-}
-function lineIntersection(p1, p2, p3, p4) {
-  const denom = (p4.y - p3.y) * (p2.x - p1.x) - (p4.x - p3.x) * (p2.y - p1.y);
-  if (Math.abs(denom) < 1e-4) return null;
-  const ua = ((p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x)) / denom;
-  const ub = ((p2.x - p1.x) * (p1.y - p3.y) - (p2.y - p1.y) * (p1.x - p3.x)) / denom;
-  if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
-    return {
-      x: p1.x + ua * (p2.x - p1.x),
-      y: p1.y + ua * (p2.y - p1.y)
-    };
-  }
-  return null;
+  return info;
 }
-var init_geometry_utils = __esm({
-  "src/layout/edge-routing/geometry-utils.ts"() {
+var init_collector = __esm({
+  "src/layout/post-processing/boundary-event/collector.ts"() {
     "use strict";
     init_cjs_shims();
   }
 });
 
-// src/layout/edge-routing/edge-fixer.ts
-var EdgeFixer;
-var init_edge_fixer = __esm({
-  "src/layout/edge-routing/edge-fixer.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_geometry_utils();
-    init_debug();
-    EdgeFixer = class {
-      margin = 15;
-      /**
-       * Fix edges that cross through nodes
-       */
-      fix(graph) {
-        const nodesByContainer = /* @__PURE__ */ new Map();
-        const flowNodePatterns = [
-          /^task_/,
-          /^gateway_/,
-          /^start_/,
-          /^end_/,
-          /^subprocess_/,
-          /^call_/,
-          /^intermediate_/,
-          /^event_/,
-          /^catch_/
-        ];
-        const boundaryEventPattern = /^boundary_/;
-        const poolPatterns = [
-          /^pool_/,
-          /^participant_/,
-          /^process_/
-        ];
-        const collectNodePositions = (node, offsetX = 0, offsetY = 0, containerId = "root") => {
-          const id = node.id || "";
-          const isBoundaryEvent = boundaryEventPattern.test(id);
-          const isFlowNode = flowNodePatterns.some((pattern) => pattern.test(id));
-          const isPool = poolPatterns.some((pattern) => pattern.test(id));
-          const bpmn = node.bpmn;
-          if (isDebugEnabled() && (id.includes("lane") || id.includes("pool") || id.includes("end_fast") || id.includes("gateway_fast"))) {
-            console.log(`[BPMN] EdgeFixer.collectNodePositions: id=${id}, offsetX=${offsetX}, offsetY=${offsetY}, bpmn=${JSON.stringify(bpmn)}`);
-            console.log(`[BPMN]   node.x=${node.x}, node.y=${node.y}, isFlowNode=${isFlowNode}, isPool=${isPool}`);
-          }
-          const currentContainerId = isPool ? id : containerId;
-          if (isFlowNode && !isBoundaryEvent && node.x !== void 0 && node.y !== void 0) {
-            const absX = offsetX + node.x;
-            const absY = offsetY + node.y;
-            if (!nodesByContainer.has(currentContainerId)) {
-              nodesByContainer.set(currentContainerId, /* @__PURE__ */ new Map());
-            }
-            nodesByContainer.get(currentContainerId).set(node.id, {
-              x: absX,
-              y: absY,
-              width: node.width ?? 100,
-              height: node.height ?? 80
-            });
-          }
-          const isExpandedSubprocess = bpmn?.isExpanded === true && (bpmn?.type === "subProcess" || bpmn?.type === "transaction" || bpmn?.type === "adHocSubProcess" || bpmn?.type === "eventSubProcess");
-          const isPoolOrLane = bpmn?.type === "participant" || bpmn?.type === "lane";
-          const isContainer = isExpandedSubprocess || isPoolOrLane;
-          if (node.children) {
-            const newOffsetX = isContainer ? offsetX + (node.x ?? 0) : offsetX;
-            const newOffsetY = isContainer ? offsetY + (node.y ?? 0) : offsetY;
-            for (const child of node.children) {
-              collectNodePositions(child, newOffsetX, newOffsetY, currentContainerId);
-            }
-          }
-        };
-        collectNodePositions(graph);
-        const processEdges = (node, containerOffsetX = 0, containerOffsetY = 0, containerId = "root") => {
-          const bpmn = node.bpmn;
-          const isPool = poolPatterns.some((pattern) => pattern.test(node.id || ""));
-          const currentContainerId = isPool ? node.id : containerId;
-          if (node.edges) {
-            const containerNodes = nodesByContainer.get(currentContainerId) ?? /* @__PURE__ */ new Map();
-            for (const edge of node.edges) {
-              if (edge.sections && edge.sections.length > 0) {
-                const hasPoolRelativeCoords = edge._poolRelativeCoords === true;
-                if (hasPoolRelativeCoords) {
-                  continue;
-                }
-                this.fixEdgeIfCrossing(edge, containerNodes, containerOffsetX, containerOffsetY);
-              }
-            }
-          }
-          const isExpandedSubprocess = bpmn?.isExpanded === true && (bpmn?.type === "subProcess" || bpmn?.type === "transaction" || bpmn?.type === "adHocSubProcess" || bpmn?.type === "eventSubProcess");
-          const isPoolOrLane = bpmn?.type === "participant" || bpmn?.type === "lane";
-          const isContainer = isExpandedSubprocess || isPoolOrLane;
-          if (node.children) {
-            const newOffsetX = isContainer ? containerOffsetX + (node.x ?? 0) : containerOffsetX;
-            const newOffsetY = isContainer ? containerOffsetY + (node.y ?? 0) : containerOffsetY;
-            for (const child of node.children) {
-              processEdges(child, newOffsetX, newOffsetY, currentContainerId);
-            }
-          }
-        };
-        processEdges(graph);
+// src/layout/post-processing/boundary-event/mover.ts
+function buildNodeAndEdgeMaps(graph, sizedGraph) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  const edgeMap = /* @__PURE__ */ new Map();
+  const reverseEdgeMap = /* @__PURE__ */ new Map();
+  const collectNodeTypes = (node) => {
+    if (node.bpmn?.type) {
+      nodeTypeMap.set(node.id, node.bpmn.type);
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        collectNodeTypes(child);
       }
-      /**
-       * Check if an edge crosses any node and fix it if so
-       */
-      fixEdgeIfCrossing(edge, nodePositions, containerOffsetX, containerOffsetY) {
-        const section = edge.sections?.[0];
-        if (!section) return;
-        const sourceId = edge.sources?.[0];
-        const targetId = edge.targets?.[0];
-        if (sourceId?.startsWith("boundary_")) {
-          return;
-        }
-        const waypoints = [
-          { x: containerOffsetX + section.startPoint.x, y: containerOffsetY + section.startPoint.y }
-        ];
-        if (section.bendPoints) {
-          for (const bp of section.bendPoints) {
-            waypoints.push({ x: containerOffsetX + bp.x, y: containerOffsetY + bp.y });
-          }
-        }
-        waypoints.push({ x: containerOffsetX + section.endPoint.x, y: containerOffsetY + section.endPoint.y });
-        const crossedNodes = [];
-        for (let i = 0; i < waypoints.length - 1; i++) {
-          const p1 = waypoints[i];
-          const p2 = waypoints[i + 1];
-          if (!p1 || !p2) continue;
-          for (const [nodeId, pos] of nodePositions) {
-            if (nodeId === sourceId || nodeId === targetId) continue;
-            if (segmentCrossesNode(p1, p2, pos)) {
-              crossedNodes.push(nodeId);
-            }
-          }
-        }
-        const targetPos = targetId ? nodePositions.get(targetId) : void 0;
-        const sourcePos = sourceId ? nodePositions.get(sourceId) : void 0;
-        if (isDebugEnabled() && edge.id?.includes("back")) {
-          console.log(`[BPMN] Edge ${edge.id}: sourceId=${sourceId}, targetId=${targetId}`);
-          console.log(`[BPMN] Edge ${edge.id}: sourcePos=${JSON.stringify(sourcePos)}, targetPos=${JSON.stringify(targetPos)}`);
-          console.log(`[BPMN] Edge ${edge.id}: waypoints.length=${waypoints.length}`);
-        }
-        if (targetPos && sourcePos && waypoints.length >= 2) {
-          const lastWaypoint = waypoints[waypoints.length - 1];
-          const secondLastWaypoint = waypoints[waypoints.length - 2];
-          const isReturnEdge2 = targetPos.y + targetPos.height < sourcePos.y;
-          if (isDebugEnabled() && edge.id?.includes("back")) {
-            console.log(`[BPMN] Edge ${edge.id}: isReturnEdge=${isReturnEdge2}`);
-            if (lastWaypoint) {
-              console.log(`[BPMN] Edge ${edge.id}: lastWaypoint=(${lastWaypoint.x},${lastWaypoint.y})`);
-            }
-          }
-          if (isReturnEdge2 && lastWaypoint && secondLastWaypoint) {
-            if (Math.abs(secondLastWaypoint.y - lastWaypoint.y) < 5) {
-              const segY = secondLastWaypoint.y;
-              const segMinX = Math.min(secondLastWaypoint.x, lastWaypoint.x);
-              const segMaxX = Math.max(secondLastWaypoint.x, lastWaypoint.x);
-              if (segY > targetPos.y && segY < targetPos.y + targetPos.height) {
-                if (segMinX < targetPos.x + targetPos.width && segMaxX > targetPos.x) {
-                  crossedNodes.push(targetId + " (target)");
-                }
-              }
-            }
-          }
-        }
-        if (crossedNodes.length === 0) return;
-        if (isDebugEnabled()) {
-          console.log(`[BPMN] Edge ${edge.id} crosses nodes: ${crossedNodes.join(", ")}`);
-        }
-        if (!sourcePos || !targetPos) return;
-        const obstacles = [];
-        for (const [nodeId, pos] of nodePositions) {
-          if (nodeId === sourceId || nodeId === targetId) continue;
-          obstacles.push({ ...pos, id: nodeId });
-        }
-        const isReturnEdge = targetPos.y + targetPos.height < sourcePos.y;
-        const crossesThroughTarget = crossedNodes.some((n) => n.includes("(target)"));
-        if (isReturnEdge && crossesThroughTarget) {
-          const targetWidth = targetPos.width;
-          section.endPoint = {
-            x: section.endPoint.x + targetWidth,
-            y: section.endPoint.y
-          };
-        }
-        const originalStart = {
-          x: containerOffsetX + section.startPoint.x,
-          y: containerOffsetY + section.startPoint.y
-        };
-        const originalEnd = {
-          x: containerOffsetX + section.endPoint.x,
-          y: containerOffsetY + section.endPoint.y
-        };
-        const result = this.calculatePerpendicularAvoidingPath(
-          originalStart,
-          originalEnd,
-          sourcePos,
-          targetPos,
-          obstacles,
-          isReturnEdge
-        );
-        if (result.startPoint) {
-          section.startPoint = {
-            x: result.startPoint.x - containerOffsetX,
-            y: result.startPoint.y - containerOffsetY
-          };
-        }
-        if (result.endPoint) {
-          section.endPoint = {
-            x: result.endPoint.x - containerOffsetX,
-            y: result.endPoint.y - containerOffsetY
-          };
-        }
-        const relativeBendPoints = result.bendPoints.map((bp) => ({
-          x: bp.x - containerOffsetX,
-          y: bp.y - containerOffsetY
-        }));
-        section.bendPoints = relativeBendPoints.length > 0 ? relativeBendPoints : void 0;
-        if (isDebugEnabled()) {
-          console.log(`[BPMN] Fixed edge ${edge.id} with ${relativeBendPoints.length} bend points`);
+    }
+    if (node.boundaryEvents) {
+      for (const be of node.boundaryEvents) {
+        if (be.bpmn?.type) {
+          nodeTypeMap.set(be.id, be.bpmn.type);
         }
       }
-      /**
-       * Determine connection side based on the edge direction
-       * For BPMN diagrams with left-to-right flow, we prefer horizontal connections
-       * even when vertical distance is larger, as long as target is to the right.
-       */
-      determineConnectionSide(from, to, nodeBounds, isSource) {
-        const dx = to.x - from.x;
-        const dy = to.y - from.y;
-        const absDx = Math.abs(dx);
-        const absDy = Math.abs(dy);
-        if (dx > 0) {
-          if (isSource) {
-            return "right";
-          } else {
-            if (absDy > absDx * 1.5) {
-              return dy > 0 ? "top" : "bottom";
-            }
-            return "left";
-          }
-        } else if (dx < 0) {
-          if (isSource) {
-            return "left";
-          } else {
-            return "right";
-          }
-        } else {
-          if (isSource) {
-            return dy > 0 ? "bottom" : "top";
-          } else {
-            return dy > 0 ? "top" : "bottom";
-          }
-        }
-      }
-      /**
-       * Get the connection point on a node boundary
-       */
-      getConnectionPoint(bounds, side) {
-        const centerX = bounds.x + bounds.width / 2;
-        const centerY = bounds.y + bounds.height / 2;
-        switch (side) {
-          case "top":
-            return { x: centerX, y: bounds.y };
-          case "bottom":
-            return { x: centerX, y: bounds.y + bounds.height };
-          case "left":
-            return { x: bounds.x, y: centerY };
-          case "right":
-            return { x: bounds.x + bounds.width, y: centerY };
-        }
-      }
-      /**
-       * Calculate bend points that avoid obstacles while ensuring perpendicular connections
-       * Uses LOCAL routing - only considers obstacles actually blocking the direct path
-       */
-      calculatePerpendicularAvoidingPath(originalStart, originalEnd, source, target, obstacles, isReturnEdge) {
-        const dx = originalEnd.x - originalStart.x;
-        const dy = originalEnd.y - originalStart.y;
-        const sourceSide = this.determineConnectionSide(originalStart, originalEnd, source, true);
-        const targetSide = this.determineConnectionSide(originalStart, originalEnd, target, false);
-        const startPoint = this.getConnectionPoint(source, sourceSide);
-        const endPoint = this.getConnectionPoint(target, targetSide);
-        const pathMinX = Math.min(startPoint.x, endPoint.x) - this.margin;
-        const pathMaxX = Math.max(startPoint.x, endPoint.x) + this.margin;
-        const pathMinY = Math.min(startPoint.y, endPoint.y) - this.margin;
-        const pathMaxY = Math.max(startPoint.y, endPoint.y) + this.margin;
-        const blockingObstacles = obstacles.filter((obs) => {
-          const obsRight = obs.x + obs.width;
-          const obsBottom = obs.y + obs.height;
-          const overlapX = obs.x < pathMaxX && obsRight > pathMinX;
-          const overlapY = obs.y < pathMaxY && obsBottom > pathMinY;
-          return overlapX && overlapY;
-        });
-        if (blockingObstacles.length === 0) {
-          const bendPoints2 = this.createPerpendicularPath(startPoint, endPoint, sourceSide, targetSide);
-          return { bendPoints: bendPoints2, startPoint, endPoint };
-        }
-        const targetIsRight = dx > 0;
-        const targetIsAbove = dy < 0;
-        const targetIsBelow = dy > 0;
-        let bendPoints;
-        if (targetIsRight) {
-          if (targetIsAbove) {
-            bendPoints = this.routeRightThenUp(startPoint, endPoint, blockingObstacles, source, target);
-          } else if (targetIsBelow) {
-            bendPoints = this.routeRightThenDown(startPoint, endPoint, blockingObstacles, source, target);
-          } else {
-            bendPoints = this.routeRightWithObstacleAvoidance(startPoint, endPoint, sourceSide, targetSide, blockingObstacles, source, target);
+    }
+  };
+  if (sizedGraph) {
+    for (const child of sizedGraph.children ?? []) {
+      collectNodeTypes(child);
+    }
+  }
+  const buildMaps = (node) => {
+    nodeMap.set(node.id, node);
+    if (node.edges) {
+      for (const edge of node.edges) {
+        const source = edge.sources?.[0];
+        const target = edge.targets?.[0];
+        if (source && target) {
+          if (!edgeMap.has(source)) {
+            edgeMap.set(source, []);
           }
-        } else {
-          if (targetIsAbove) {
-            bendPoints = this.routeUpWithObstacleAvoidance(startPoint, endPoint, sourceSide, targetSide, blockingObstacles, source, target);
-          } else if (targetIsBelow) {
-            bendPoints = this.routeDownWithObstacleAvoidance(startPoint, endPoint, sourceSide, targetSide, blockingObstacles, source, target);
-          } else {
-            bendPoints = this.routeLeftWithObstacleAvoidance(startPoint, endPoint, sourceSide, targetSide, blockingObstacles, source, target);
+          edgeMap.get(source).push(target);
+          if (!reverseEdgeMap.has(target)) {
+            reverseEdgeMap.set(target, []);
           }
-        }
-        return { bendPoints, startPoint, endPoint };
-      }
-      /**
-       * Route right then up - for edges going both right and up
-       * Source exits from right side, target enters from left side
-       * Strategy: go horizontally right past obstacles, then vertically to target
-       */
-      routeRightThenUp(start, end, obstacles, source, target) {
-        const bendPoints = [];
-        const blockingObstacles = obstacles.filter((obs) => {
-          const obsRight = obs.x + obs.width;
-          const obsBottom = obs.y + obs.height;
-          const pathMinY = Math.min(start.y, end.y);
-          const pathMaxY = Math.max(start.y, end.y);
-          return obs.x < end.x && obsRight > start.x - this.margin && obs.y < pathMaxY && obsBottom > pathMinY;
-        });
-        if (blockingObstacles.length === 0) {
-          bendPoints.push({ x: end.x, y: start.y });
-          return bendPoints;
-        }
-        let clearX = start.x;
-        for (const obs of blockingObstacles) {
-          clearX = Math.max(clearX, obs.x + obs.width + this.margin);
-        }
-        clearX = Math.max(clearX, end.x);
-        if (Math.abs(clearX - end.x) < 5) {
-          bendPoints.push({ x: end.x, y: start.y });
-        } else {
-          bendPoints.push({ x: clearX, y: start.y });
-          bendPoints.push({ x: clearX, y: end.y });
-        }
-        return bendPoints;
-      }
-      /**
-       * Route right then down - for edges going both right and down
-       * Source exits from right side, target enters from left side
-       * Strategy: go horizontally right past obstacles, then vertically to target
-       */
-      routeRightThenDown(start, end, obstacles, source, target) {
-        const bendPoints = [];
-        const blockingObstacles = obstacles.filter((obs) => {
-          const obsRight = obs.x + obs.width;
-          const obsBottom = obs.y + obs.height;
-          const pathMinY = Math.min(start.y, end.y);
-          const pathMaxY = Math.max(start.y, end.y);
-          return obs.x < end.x && obsRight > start.x - this.margin && obs.y < pathMaxY && obsBottom > pathMinY;
-        });
-        if (blockingObstacles.length === 0) {
-          bendPoints.push({ x: end.x, y: start.y });
-          return bendPoints;
-        }
-        let clearX = start.x;
-        for (const obs of blockingObstacles) {
-          clearX = Math.max(clearX, obs.x + obs.width + this.margin);
-        }
-        clearX = Math.max(clearX, end.x);
-        if (Math.abs(clearX - end.x) < 5) {
-          bendPoints.push({ x: end.x, y: start.y });
-        } else {
-          bendPoints.push({ x: clearX, y: start.y });
-          bendPoints.push({ x: clearX, y: end.y });
-        }
-        return bendPoints;
-      }
-      /**
-       * Create a simple perpendicular path without obstacle avoidance
-       */
-      createPerpendicularPath(start, end, sourceSide, targetSide) {
-        const bendPoints = [];
-        if (Math.abs(start.x - end.x) < 5 || Math.abs(start.y - end.y) < 5) {
-          return bendPoints;
-        }
-        const isVerticalExit = sourceSide === "top" || sourceSide === "bottom";
-        const isVerticalEntry = targetSide === "top" || targetSide === "bottom";
-        if (isVerticalExit && isVerticalEntry) {
-          const midY = (start.y + end.y) / 2;
-          bendPoints.push({ x: start.x, y: midY });
-          bendPoints.push({ x: end.x, y: midY });
-        } else if (!isVerticalExit && !isVerticalEntry) {
-          const midX = (start.x + end.x) / 2;
-          bendPoints.push({ x: midX, y: start.y });
-          bendPoints.push({ x: midX, y: end.y });
-        } else if (isVerticalExit && !isVerticalEntry) {
-          bendPoints.push({ x: start.x, y: end.y });
-        } else {
-          bendPoints.push({ x: end.x, y: start.y });
-        }
-        return bendPoints;
-      }
-      /**
-       * Route downward with obstacle avoidance, maintaining perpendicular connections
-       */
-      routeDownWithObstacleAvoidance(start, end, sourceSide, targetSide, obstacles, source, target) {
-        const bendPoints = [];
-        let avoidX = Math.min(start.x, end.x);
-        for (const obs of obstacles) {
-          if (obs.y <= end.y && obs.y + obs.height >= start.y) {
-            if (obs.x <= start.x && obs.x + obs.width >= start.x) {
-              avoidX = Math.min(avoidX, obs.x - this.margin);
-            }
-            if (obs.x <= end.x && obs.x + obs.width >= end.x) {
-              avoidX = Math.min(avoidX, obs.x - this.margin);
-            }
-          }
-        }
-        avoidX = Math.min(avoidX, source.x - this.margin);
-        avoidX = Math.min(avoidX, target.x - this.margin);
-        if (sourceSide === "bottom") {
-          const exitY = start.y + this.margin;
-          bendPoints.push({ x: start.x, y: exitY });
-          if (avoidX < start.x - 5) {
-            bendPoints.push({ x: avoidX, y: exitY });
-            bendPoints.push({ x: avoidX, y: end.y - this.margin });
-            bendPoints.push({ x: end.x, y: end.y - this.margin });
-          } else if (Math.abs(start.x - end.x) > 5) {
-            bendPoints.push({ x: end.x, y: exitY });
-          }
-        } else {
-          const midY = (start.y + end.y) / 2;
-          bendPoints.push({ x: avoidX, y: start.y });
-          bendPoints.push({ x: avoidX, y: midY });
-          bendPoints.push({ x: end.x, y: midY });
-        }
-        return bendPoints;
-      }
-      /**
-       * Route upward with obstacle avoidance, maintaining perpendicular connections
-       */
-      routeUpWithObstacleAvoidance(start, end, sourceSide, targetSide, obstacles, source, target) {
-        const bendPoints = [];
-        let clearX = Math.max(source.x + source.width, target.x + target.width) + this.margin;
-        for (const obs of obstacles) {
-          clearX = Math.max(clearX, obs.x + obs.width + this.margin);
-        }
-        if (sourceSide === "right") {
-          bendPoints.push({ x: clearX, y: start.y });
-          bendPoints.push({ x: clearX, y: end.y });
-        } else if (sourceSide === "top") {
-          const exitY = start.y - this.margin;
-          bendPoints.push({ x: start.x, y: exitY });
-          bendPoints.push({ x: clearX, y: exitY });
-          bendPoints.push({ x: clearX, y: end.y });
-        } else {
-          bendPoints.push({ x: clearX, y: start.y });
-          bendPoints.push({ x: clearX, y: end.y });
-        }
-        return bendPoints;
-      }
-      /**
-       * Route rightward with obstacle avoidance, maintaining perpendicular connections
-       */
-      routeRightWithObstacleAvoidance(start, end, sourceSide, targetSide, obstacles, source, target) {
-        const bendPoints = [];
-        const sourceRight = source.x + source.width;
-        const targetLeft = target.x;
-        let routeX = sourceRight + this.margin;
-        for (const obs of obstacles) {
-          const obsLeft = obs.x;
-          const obsRight = obs.x + obs.width;
-          if (obsRight > sourceRight && obsLeft < targetLeft) {
-            routeX = Math.max(routeX, obsRight + this.margin);
-          }
-        }
-        routeX = Math.min(routeX, targetLeft - this.margin);
-        if (routeX <= sourceRight) {
-          let clearY = Math.max(source.y + source.height, target.y + target.height) + this.margin;
-          for (const obs of obstacles) {
-            clearY = Math.max(clearY, obs.y + obs.height + this.margin);
-          }
-          if (sourceSide === "right") {
-            bendPoints.push({ x: start.x + this.margin, y: start.y });
-            bendPoints.push({ x: start.x + this.margin, y: clearY });
-            bendPoints.push({ x: end.x - this.margin, y: clearY });
-            bendPoints.push({ x: end.x - this.margin, y: end.y });
-          } else {
-            bendPoints.push({ x: start.x, y: clearY });
-            bendPoints.push({ x: end.x, y: clearY });
-          }
-        } else {
-          bendPoints.push({ x: routeX, y: start.y });
-          bendPoints.push({ x: routeX, y: end.y });
-        }
-        return bendPoints;
-      }
-      /**
-       * Route leftward with obstacle avoidance, maintaining perpendicular connections
-       */
-      routeLeftWithObstacleAvoidance(start, end, sourceSide, targetSide, obstacles, source, target) {
-        const bendPoints = [];
-        let clearX = Math.min(source.x, target.x) - this.margin;
-        for (const obs of obstacles) {
-          if (obs.x < source.x && obs.x + obs.width > target.x + target.width) {
-            clearX = Math.min(clearX, obs.x - this.margin);
-          }
-        }
-        if (sourceSide === "left") {
-          bendPoints.push({ x: clearX, y: start.y });
-          bendPoints.push({ x: clearX, y: end.y });
-        } else {
-          const exitX = start.x - this.margin;
-          bendPoints.push({ x: exitX, y: start.y });
-          bendPoints.push({ x: exitX, y: end.y });
-        }
-        return bendPoints;
-      }
-    };
-  }
-});
-
-// src/layout/post-processing/boundary-event/collector.ts
-function collectBoundaryEventInfo(graph) {
-  const info = /* @__PURE__ */ new Map();
-  const edgeMap = /* @__PURE__ */ new Map();
-  const collectEdges = (node) => {
-    if (node.edges) {
-      for (const edge of node.edges) {
-        const source = edge.sources?.[0];
-        const target = edge.targets?.[0];
-        if (!source || !target) continue;
-        if (!edgeMap.has(source)) {
-          edgeMap.set(source, []);
-        }
-        edgeMap.get(source).push(target);
-      }
-    }
-    if (node.children) {
-      for (const child of node.children) {
-        collectEdges(child);
-      }
-    }
-  };
-  const collectBoundaryEvents = (node) => {
-    if (node.boundaryEvents) {
-      const totalBoundaries = node.boundaryEvents.length;
-      node.boundaryEvents.forEach((be, index) => {
-        const targets = edgeMap.get(be.id) || [];
-        info.set(be.id, {
-          attachedToRef: be.attachedToRef,
-          targets,
-          boundaryIndex: index,
-          totalBoundaries
-        });
-      });
-    }
-    if (node.children) {
-      for (const child of node.children) {
-        collectBoundaryEvents(child);
-      }
-    }
-  };
-  for (const child of graph.children ?? []) {
-    collectEdges(child);
-    collectBoundaryEvents(child);
-  }
-  return info;
-}
-var init_collector = __esm({
-  "src/layout/post-processing/boundary-event/collector.ts"() {
-    "use strict";
-    init_cjs_shims();
-  }
-});
-
-// src/layout/post-processing/boundary-event/mover.ts
-function buildNodeAndEdgeMaps(graph, sizedGraph) {
-  const nodeMap = /* @__PURE__ */ new Map();
-  const nodeTypeMap = /* @__PURE__ */ new Map();
-  const edgeMap = /* @__PURE__ */ new Map();
-  const reverseEdgeMap = /* @__PURE__ */ new Map();
-  const collectNodeTypes = (node) => {
-    if (node.bpmn?.type) {
-      nodeTypeMap.set(node.id, node.bpmn.type);
-    }
-    if (node.children) {
-      for (const child of node.children) {
-        collectNodeTypes(child);
-      }
-    }
-    if (node.boundaryEvents) {
-      for (const be of node.boundaryEvents) {
-        if (be.bpmn?.type) {
-          nodeTypeMap.set(be.id, be.bpmn.type);
-        }
-      }
-    }
-  };
-  if (sizedGraph) {
-    for (const child of sizedGraph.children ?? []) {
-      collectNodeTypes(child);
-    }
-  }
-  const buildMaps = (node) => {
-    nodeMap.set(node.id, node);
-    if (node.edges) {
-      for (const edge of node.edges) {
-        const source = edge.sources?.[0];
-        const target = edge.targets?.[0];
-        if (source && target) {
-          if (!edgeMap.has(source)) {
-            edgeMap.set(source, []);
-          }
-          edgeMap.get(source).push(target);
-          if (!reverseEdgeMap.has(target)) {
-            reverseEdgeMap.set(target, []);
-          }
-          reverseEdgeMap.get(target).push(source);
+          reverseEdgeMap.get(target).push(source);
         }
       }
     }
@@ -1354,6 +698,22 @@ function recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo) {
   for (const [nodeId] of movedNodes) {
     obstacleIds.add(nodeId);
   }
+  const flowNodePatterns = [
+    /^task_/,
+    /^gateway_/,
+    /^start_/,
+    /^end_/,
+    /^subprocess_/,
+    /^call_/,
+    /^intermediate_/,
+    /^event_/,
+    /^catch_/
+  ];
+  for (const [nodeId] of nodeMap) {
+    if (flowNodePatterns.some((pattern) => pattern.test(nodeId))) {
+      obstacleIds.add(nodeId);
+    }
+  }
   const boundaryEventPositions = /* @__PURE__ */ new Map();
   for (const [beId, info] of boundaryEventInfo) {
     const attachedNode = nodeMap.get(info.attachedToRef);
@@ -1392,8 +752,7 @@ function recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo) {
               sourceNode,
               targetNode,
               obstacleIds,
-              nodeMap,
-              debug
+              nodeMap
             );
           }
         }
@@ -1505,9 +864,29 @@ function recalculateEdgeWithObstacleAvoidance(edge, source, target, obstacleIds,
         clearX = Math.max(clearX, obs.x + obs.width + 30);
       }
     }
-    waypoints.push({ x: clearX, y: startY });
-    waypoints.push({ x: clearX, y: endY });
-    waypoints.push({ x: endX, y: endY });
+    let horizontalClearY = endY;
+    const horizSegMinX = Math.min(clearX, endX);
+    const horizSegMaxX = Math.max(clearX, endX);
+    const margin = 20;
+    for (const obs of obstacles) {
+      const obsRight = obs.x + obs.width;
+      const obsBottom = obs.y + obs.height;
+      if (obs.x < horizSegMaxX && obsRight > horizSegMinX) {
+        if (horizontalClearY >= obs.y - margin && horizontalClearY <= obsBottom + margin) {
+          horizontalClearY = Math.max(horizontalClearY, obsBottom + margin);
+        }
+      }
+    }
+    if (horizontalClearY > endY) {
+      waypoints.push({ x: clearX, y: startY });
+      waypoints.push({ x: clearX, y: horizontalClearY });
+      waypoints.push({ x: endX, y: horizontalClearY });
+      waypoints.push({ x: endX, y: endY });
+    } else {
+      waypoints.push({ x: clearX, y: startY });
+      waypoints.push({ x: clearX, y: endY });
+      waypoints.push({ x: endX, y: endY });
+    }
   } else if (!isPrimarilyVertical && dx > 0) {
     const startX = sx + sw;
     const startY = sy + sh / 2;
@@ -1654,6 +1033,85 @@ var init_boundary_event = __esm({
   }
 });
 
+// src/layout/edge-routing/geometry-utils.ts
+function distance(p1, p2) {
+  return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+}
+function segmentIntersectsRect(p1, p2, rect) {
+  const margin = 5;
+  const left = rect.x - margin;
+  const right = rect.x + rect.width + margin;
+  const top = rect.y - margin;
+  const bottom = rect.y + rect.height + margin;
+  if (p1.x < left && p2.x < left || p1.x > right && p2.x > right) return false;
+  if (p1.y < top && p2.y < top || p1.y > bottom && p2.y > bottom) return false;
+  if (Math.abs(p1.x - p2.x) < 1) {
+    const x = p1.x;
+    const minY = Math.min(p1.y, p2.y);
+    const maxY = Math.max(p1.y, p2.y);
+    return x >= left && x <= right && maxY >= top && minY <= bottom;
+  }
+  if (Math.abs(p1.y - p2.y) < 1) {
+    const y = p1.y;
+    const minX = Math.min(p1.x, p2.x);
+    const maxX = Math.max(p1.x, p2.x);
+    return y >= top && y <= bottom && maxX >= left && minX <= right;
+  }
+  return true;
+}
+function scoreRoute(start, bendPoints, end, obstacles) {
+  let score = 0;
+  const crossingPenalty = 1e3;
+  const lengthWeight = 0.1;
+  const path = [start, ...bendPoints, end];
+  for (const obs of obstacles) {
+    for (let i = 0; i < path.length - 1; i++) {
+      const p1 = path[i];
+      const p2 = path[i + 1];
+      if (p1 && p2 && segmentIntersectsRect(p1, p2, obs)) {
+        score += crossingPenalty;
+      }
+    }
+  }
+  for (let i = 0; i < path.length - 1; i++) {
+    const p1 = path[i];
+    const p2 = path[i + 1];
+    if (p1 && p2) {
+      score += distance(p1, p2) * lengthWeight;
+    }
+  }
+  return score;
+}
+function findClearVerticalPath(x, startY, endY, obstacles) {
+  const minY = Math.min(startY, endY);
+  const maxY = Math.max(startY, endY);
+  const margin = 10;
+  for (const obs of obstacles) {
+    const obsLeft = obs.x - margin;
+    const obsRight = obs.x + obs.width + margin;
+    const obsTop = obs.y;
+    const obsBottom = obs.y + obs.height;
+    if (x >= obsLeft && x <= obsRight) {
+      if (obsBottom > minY && obsTop < maxY) {
+        const spaceAbove = obsTop - minY;
+        const spaceBelow = maxY - obsBottom;
+        if (spaceBelow > spaceAbove && obsBottom + margin < maxY) {
+          return obsBottom + margin;
+        } else if (obsTop - margin > minY) {
+          return obsTop - margin;
+        }
+      }
+    }
+  }
+  return null;
+}
+var init_geometry_utils = __esm({
+  "src/layout/edge-routing/geometry-utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // src/types/bpmn-constants.ts
 var DEFAULT_SIZES, BPMN_ELEMENT_MAP, EVENT_DEFINITION_MAP, DEFAULT_ELK_OPTIONS, EVENT_TYPES, TASK_TYPES, GATEWAY_TYPES, SUBPROCESS_TYPES, GROUP_TYPE, ARTIFACT_TYPES_SET;
 var init_bpmn_constants = __esm({
@@ -2309,9 +1767,9 @@ var init_lane_arranger = __esm({
       laneHeaderWidth = 30;
       lanePadding = 0;
       // No extra padding - tight fit
-      laneExtraWidth = 50;
+      laneExtraWidth = 130;
       // Extra width for each lane
-      laneExtraHeight = 80;
+      laneExtraHeight = 120;
       // Extra height for each lane
       /**
        * Rearrange lanes within pools to stack vertically
@@ -2387,16 +1845,21 @@ var init_lane_arranger = __esm({
       }
       /**
        * Recursively build lane structure with positioned nodes
+       * Uses ConstraintSolver for vertical stacking
        */
       buildLaneStructure(origChildren, layoutedNodes, nodeToLane, startY, maxRight) {
         const lanes = [];
-        let currentY = startY;
         const origLanes = origChildren.filter((c) => c.bpmn?.type === "lane");
         origLanes.sort((a, b) => {
           const partA = a.layoutOptions?.["elk.partitioning.partition"];
           const partB = b.layoutOptions?.["elk.partitioning.partition"];
           return (partA !== void 0 ? Number(partA) : 0) - (partB !== void 0 ? Number(partB) : 0);
         });
+        if (origLanes.length === 0) {
+          return { lanes: [], totalHeight: 0 };
+        }
+        const laneHeights = /* @__PURE__ */ new Map();
+        const laneNodes = /* @__PURE__ */ new Map();
         for (const origLane of origLanes) {
           const hasNestedLanes = origLane.children?.some((c) => c.bpmn?.type === "lane");
           if (hasNestedLanes) {
@@ -2408,22 +1871,8 @@ var init_lane_arranger = __esm({
               0,
               nestedWidth
             );
-            for (const nestedLane of nested.lanes) {
-              nestedLane.width = nestedWidth;
-            }
-            const laneNode = {
-              id: origLane.id,
-              x: this.laneHeaderWidth,
-              y: currentY,
-              width: maxRight,
-              // Fill full width
-              height: nested.totalHeight,
-              // Tight fit
-              children: nested.lanes,
-              bpmn: origLane.bpmn
-            };
-            lanes.push(laneNode);
-            currentY += laneNode.height;
+            laneHeights.set(origLane.id, nested.totalHeight);
+            laneNodes.set(origLane.id, nested.lanes);
           } else {
             const nodesInLane = [];
             if (origLane.children) {
@@ -2440,23 +1889,39 @@ var init_lane_arranger = __esm({
             const contentHeight = nodesInLane.length > 0 ? maxY - minY : 50;
             const laneHeight = contentHeight + this.laneExtraHeight;
             const yOffset = nodesInLane.length > 0 ? this.laneExtraHeight / 2 - minY : 0;
+            const xOffset = this.laneExtraWidth / 2;
             for (const node of nodesInLane) {
+              node.x = (node.x ?? 0) + xOffset;
               node.y = (node.y ?? 0) + yOffset;
             }
-            const laneNode = {
-              id: origLane.id,
-              x: this.laneHeaderWidth,
-              y: currentY,
-              width: maxRight,
-              height: laneHeight,
-              children: nodesInLane,
-              bpmn: origLane.bpmn
-            };
-            lanes.push(laneNode);
-            currentY += laneHeight;
+            laneHeights.set(origLane.id, laneHeight);
+            laneNodes.set(origLane.id, nodesInLane);
           }
         }
-        return { lanes, totalHeight: currentY - startY };
+        let currentY = startY;
+        for (const origLane of origLanes) {
+          const height = laneHeights.get(origLane.id) ?? 100;
+          const children = laneNodes.get(origLane.id) ?? [];
+          const hasNestedLanes = origLane.children?.some((c) => c.bpmn?.type === "lane");
+          if (hasNestedLanes) {
+            for (const nestedLane of children) {
+              nestedLane.width = maxRight - this.laneHeaderWidth;
+            }
+          }
+          const laneNode = {
+            id: origLane.id,
+            x: this.laneHeaderWidth,
+            y: currentY,
+            width: maxRight,
+            height,
+            children,
+            bpmn: origLane.bpmn
+          };
+          lanes.push(laneNode);
+          currentY += height;
+        }
+        const totalHeight = currentY - startY;
+        return { lanes, totalHeight };
       }
       /**
        * Rearrange nested lanes within a parent lane
@@ -2566,18 +2031,55 @@ var init_lane_arranger = __esm({
             }
             const waypoints = [];
             waypoints.push({ x: startX, y: startY });
-            if (Math.abs(startY - endY) > 10) {
-              const midX = this.findClearMidX(
-                startX,
-                endX,
-                startY,
-                endY,
-                sourceId,
-                targetId,
-                nodePositions
-              );
-              waypoints.push({ x: midX, y: startY });
-              waypoints.push({ x: midX, y: endY });
+            const obstaclesInPath = this.getObstaclesInPath(
+              startX,
+              startY,
+              endX,
+              endY,
+              sourceId,
+              targetId,
+              nodePositions
+            );
+            if (Math.abs(startY - endY) > 10 || obstaclesInPath.length > 0) {
+              if (obstaclesInPath.length > 0 && Math.abs(startY - endY) <= 10) {
+                const routePoints = this.routeAroundObstacles(
+                  startX,
+                  startY,
+                  endX,
+                  endY,
+                  obstaclesInPath,
+                  nodePositions
+                );
+                for (const pt of routePoints) {
+                  waypoints.push(pt);
+                }
+              } else {
+                const midX = this.findClearMidX(
+                  startX,
+                  endX,
+                  startY,
+                  endY,
+                  sourceId,
+                  targetId,
+                  nodePositions
+                );
+                if (midX !== null) {
+                  waypoints.push({ x: midX, y: startY });
+                  waypoints.push({ x: midX, y: endY });
+                } else {
+                  const routePoints = this.routeAroundObstacles(
+                    startX,
+                    startY,
+                    endX,
+                    endY,
+                    obstaclesInPath,
+                    nodePositions
+                  );
+                  for (const pt of routePoints) {
+                    waypoints.push(pt);
+                  }
+                }
+              }
             }
             waypoints.push({ x: endX, y: endY });
             if (isDebugEnabled()) {
@@ -2593,12 +2095,88 @@ var init_lane_arranger = __esm({
           }
         }
       }
+      /**
+       * Get obstacles in the direct path from source to target.
+       * This handles the case where source and target are at similar Y positions
+       * but there are nodes in between.
+       */
+      getObstaclesInPath(startX, startY, endX, endY, sourceId, targetId, nodePositions) {
+        const minX = Math.min(startX, endX);
+        const maxX = Math.max(startX, endX);
+        const minY = Math.min(startY, endY);
+        const maxY = Math.max(startY, endY);
+        const obstacles = [];
+        const flowNodePatterns = [
+          /^task_/,
+          /^gateway_/,
+          /^start_/,
+          /^end_/,
+          /^subprocess_/,
+          /^call_/,
+          /^intermediate_/,
+          /^event_/,
+          /^catch_/
+        ];
+        for (const [nodeId, pos] of nodePositions) {
+          if (nodeId === sourceId || nodeId === targetId) continue;
+          if (nodeId.startsWith("lane_")) continue;
+          const isFlowNode = flowNodePatterns.some((pattern) => pattern.test(nodeId));
+          if (!isFlowNode) continue;
+          const nodeLeft = pos.x;
+          const nodeRight = pos.x + pos.width;
+          const nodeTop = pos.y;
+          const nodeBottom = pos.y + pos.height;
+          const xOverlap = nodeRight > minX && nodeLeft < maxX;
+          if (xOverlap) {
+            if (nodeTop <= maxY && nodeBottom >= minY) {
+              if (isDebugEnabled()) {
+                console.log(`[BPMN]   getObstaclesInPath: found obstacle ${nodeId} at x=[${nodeLeft}, ${nodeRight}], y=[${nodeTop}, ${nodeBottom}]`);
+              }
+              obstacles.push({ id: nodeId, ...pos });
+            }
+          }
+        }
+        obstacles.sort((a, b) => a.x - b.x);
+        return obstacles;
+      }
+      /**
+       * Route around obstacles when source and target are at similar Y levels.
+       * Decides whether to go above or below based on available space.
+       */
+      routeAroundObstacles(startX, startY, endX, endY, obstacles, nodePositions) {
+        const margin = 20;
+        const points = [];
+        let minObsY = Infinity;
+        let maxObsY = -Infinity;
+        let minObsX = Infinity;
+        let maxObsX = -Infinity;
+        for (const obs of obstacles) {
+          minObsY = Math.min(minObsY, obs.y);
+          maxObsY = Math.max(maxObsY, obs.y + obs.height);
+          minObsX = Math.min(minObsX, obs.x);
+          maxObsX = Math.max(maxObsX, obs.x + obs.width);
+        }
+        const spaceAbove = minObsY - margin;
+        const spaceBelow = maxObsY + margin;
+        const obsCenterY = (minObsY + maxObsY) / 2;
+        const goAbove = startY < obsCenterY || spaceAbove > 0;
+        const routeY = goAbove ? minObsY - margin : maxObsY + margin;
+        if (isDebugEnabled()) {
+          console.log(`[BPMN]   routeAroundObstacles: goAbove=${goAbove}, routeY=${routeY}, minObsX=${minObsX}, maxObsX=${maxObsX}`);
+        }
+        points.push({ x: startX, y: routeY });
+        points.push({ x: maxObsX + margin, y: routeY });
+        points.push({ x: maxObsX + margin, y: endY });
+        return points;
+      }
       /**
        * Find a clear X position for vertical edge segment that avoids obstacles.
        * Checks all three segments of the L-shaped path:
        * 1. Horizontal from (startX, startY) to (midX, startY)
        * 2. Vertical from (midX, startY) to (midX, endY)
        * 3. Horizontal from (midX, endY) to (endX, endY)
+       *
+       * Returns null if no valid route can be found (caller should use routeAroundObstacles instead)
        */
       findClearMidX(startX, endX, startY, endY, sourceId, targetId, nodePositions) {
         const margin = 15;
@@ -2609,9 +2187,23 @@ var init_lane_arranger = __esm({
         if (isDebugEnabled()) {
           console.log(`[BPMN]   findClearMidX: startX=${startX}, endX=${endX}, startY=${startY}, endY=${endY}`);
         }
+        const flowNodePatterns = [
+          /^task_/,
+          /^gateway_/,
+          /^start_/,
+          /^end_/,
+          /^subprocess_/,
+          /^call_/,
+          /^intermediate_/,
+          /^event_/,
+          /^catch_/
+        ];
         const allObstacles = [];
         for (const [nodeId, pos] of nodePositions) {
           if (nodeId === sourceId || nodeId === targetId) continue;
+          if (nodeId.startsWith("lane_")) continue;
+          const isFlowNode = flowNodePatterns.some((pattern) => pattern.test(nodeId));
+          if (!isFlowNode) continue;
           const nodeLeft = pos.x;
           const nodeRight = pos.x + pos.width;
           const nodeTop = pos.y;
@@ -2692,14 +2284,469 @@ var init_lane_arranger = __esm({
           return rightMost;
         }
         if (isDebugEnabled()) {
-          console.log(`[BPMN]   findClearMidX: no valid route found, using midpoint ${simpleMidX}`);
+          console.log(`[BPMN]   findClearMidX: no valid route found, returning null`);
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/layout/constraint/constraint-solver.ts
+var kiwi, DEFAULT_OPTIONS, ConstraintSolver;
+var init_constraint_solver = __esm({
+  "src/layout/constraint/constraint-solver.ts"() {
+    "use strict";
+    init_cjs_shims();
+    kiwi = __toESM(require("kiwi.js"));
+    DEFAULT_OPTIONS = {
+      defaultStrength: "strong",
+      debug: false
+    };
+    ConstraintSolver = class {
+      solver = null;
+      variables;
+      pendingConstraints;
+      kiwiConstraints;
+      options;
+      solved = false;
+      constructor(options) {
+        this.variables = /* @__PURE__ */ new Map();
+        this.pendingConstraints = [];
+        this.kiwiConstraints = [];
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+      }
+      /**
+       * Add a node to the solver
+       * Note: Nodes are stored but not added to solver until solve() is called
+       */
+      addNode(id, initialX, initialY, width, height) {
+        if (this.variables.has(id)) {
+          if (this.options.debug) {
+            console.log(`[Constraint] Node ${id} already exists, skipping`);
+          }
+          return;
+        }
+        const x = new kiwi.Variable(`${id}_x`);
+        const y = new kiwi.Variable(`${id}_y`);
+        this.variables.set(id, { x, y, width, height, initialX, initialY });
+        if (this.options.debug) {
+          console.log(`[Constraint] Added node ${id} at (${initialX}, ${initialY})`);
+        }
+      }
+      /**
+       * Add a node from bounds
+       */
+      addNodeFromBounds(id, bounds) {
+        this.addNode(id, bounds.x, bounds.y, bounds.width, bounds.height);
+      }
+      /**
+       * Add multiple nodes from a map
+       */
+      addNodesFromMap(nodes) {
+        for (const [id, bounds] of nodes) {
+          this.addNodeFromBounds(id, bounds);
+        }
+      }
+      /**
+       * Add a constraint
+       * Note: Constraints are stored and applied when solve() is called
+       */
+      addConstraint(constraint) {
+        const nodeIds = this.getConstraintNodeIds(constraint);
+        for (const id of nodeIds) {
+          if (!this.variables.has(id)) {
+            if (this.options.debug) {
+              console.log(`[Constraint] Node ${id} not found for constraint`);
+            }
+            return false;
+          }
+        }
+        if (constraint.type === "noOverlap") {
+          if (this.options.debug) {
+            console.log(`[Constraint] noOverlap constraint requires special handling`);
+          }
+          return false;
+        }
+        const strength = this.getStrength(constraint.strength);
+        this.pendingConstraints.push({ constraint, strength });
+        return true;
+      }
+      /**
+       * Get node IDs referenced by a constraint
+       */
+      getConstraintNodeIds(constraint) {
+        switch (constraint.type) {
+          case "alignX":
+          case "alignY":
+            return constraint.nodes;
+          case "leftOf":
+          case "rightOf":
+          case "above":
+          case "below":
+            return [constraint.node, constraint.reference];
+          case "fixedPosition":
+            return [constraint.node];
+          case "inContainer":
+            return [constraint.node, constraint.container];
+          case "minDistance":
+            return [constraint.node1, constraint.node2];
+          case "noOverlap":
+            return constraint.nodes;
+          default:
+            return [];
+        }
+      }
+      /**
+       * Add multiple constraints
+       */
+      addConstraints(constraints) {
+        let successCount = 0;
+        for (const constraint of constraints) {
+          if (this.addConstraint(constraint)) {
+            successCount++;
+          }
+        }
+        return successCount;
+      }
+      /**
+       * Build and solve the constraint system
+       */
+      solve() {
+        if (this.solved) {
+          const result2 = /* @__PURE__ */ new Map();
+          for (const [id, vars] of this.variables) {
+            result2.set(id, {
+              x: vars.x.value(),
+              y: vars.y.value()
+            });
+          }
+          return result2;
+        }
+        this.solver = new kiwi.Solver();
+        this.kiwiConstraints = [];
+        for (const pending of this.pendingConstraints) {
+          this.applyConstraint(pending.constraint, pending.strength);
+        }
+        for (const [_id, vars] of this.variables) {
+          this.solver.addEditVariable(vars.x, kiwi.Strength.weak);
+          this.solver.addEditVariable(vars.y, kiwi.Strength.weak);
+          this.solver.suggestValue(vars.x, vars.initialX);
+          this.solver.suggestValue(vars.y, vars.initialY);
+        }
+        try {
+          this.solver.updateVariables();
+          this.solved = true;
+        } catch (error) {
+          if (this.options.debug) {
+            console.error(`[Constraint] Solver failed:`, error);
+          }
+        }
+        const result = /* @__PURE__ */ new Map();
+        for (const [id, vars] of this.variables) {
+          result.set(id, {
+            x: vars.x.value(),
+            y: vars.y.value()
+          });
+        }
+        return result;
+      }
+      /**
+       * Apply a constraint to the solver
+       */
+      applyConstraint(constraint, strength) {
+        try {
+          switch (constraint.type) {
+            case "alignX":
+              return this.addAlignXConstraint(constraint, strength);
+            case "alignY":
+              return this.addAlignYConstraint(constraint, strength);
+            case "leftOf":
+              return this.addLeftOfConstraint(constraint, strength);
+            case "rightOf":
+              return this.addRightOfConstraint(constraint, strength);
+            case "above":
+              return this.addAboveConstraint(constraint, strength);
+            case "below":
+              return this.addBelowConstraint(constraint, strength);
+            case "fixedPosition":
+              return this.addFixedPositionConstraint(constraint, strength);
+            case "inContainer":
+              return this.addInContainerConstraint(constraint, strength);
+            case "minDistance":
+              return this.addMinDistanceConstraint(constraint, strength);
+            default:
+              return false;
+          }
+        } catch (error) {
+          if (this.options.debug) {
+            console.error(`[Constraint] Failed to apply constraint:`, error);
+          }
+          return false;
+        }
+      }
+      /**
+       * Get full bounds including width and height
+       */
+      solveWithBounds() {
+        const positions = this.solve();
+        const result = /* @__PURE__ */ new Map();
+        for (const [id, pos] of positions) {
+          const vars = this.variables.get(id);
+          if (vars) {
+            result.set(id, {
+              x: pos.x,
+              y: pos.y,
+              width: vars.width,
+              height: vars.height
+            });
+          }
+        }
+        return result;
+      }
+      /**
+       * Clear all nodes and constraints
+       */
+      clear() {
+        this.solver = null;
+        this.variables.clear();
+        this.pendingConstraints = [];
+        this.kiwiConstraints = [];
+        this.solved = false;
+      }
+      // ============================================================================
+      // Private: Constraint Implementations
+      // ============================================================================
+      addAlignXConstraint(constraint, strength) {
+        const nodes = constraint.nodes.map((id) => this.variables.get(id)).filter((v) => v !== void 0);
+        if (nodes.length < 2) return false;
+        const referenceX = nodes[0].x;
+        for (let i = 1; i < nodes.length; i++) {
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(nodes[i].x, [-1, referenceX]),
+            kiwi.Operator.Eq,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        }
+        return true;
+      }
+      addAlignYConstraint(constraint, strength) {
+        const nodes = constraint.nodes.map((id) => this.variables.get(id)).filter((v) => v !== void 0);
+        if (nodes.length < 2) return false;
+        const referenceY = nodes[0].y;
+        for (let i = 1; i < nodes.length; i++) {
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(nodes[i].y, [-1, referenceY]),
+            kiwi.Operator.Eq,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        }
+        return true;
+      }
+      addLeftOfConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        const refVars = this.variables.get(constraint.reference);
+        if (!nodeVars || !refVars) return false;
+        const minSeparation = nodeVars.width + constraint.minGap;
+        const c = new kiwi.Constraint(
+          new kiwi.Expression(refVars.x, [-1, nodeVars.x], -minSeparation),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(c);
+        this.kiwiConstraints.push(c);
+        return true;
+      }
+      addRightOfConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        const refVars = this.variables.get(constraint.reference);
+        if (!nodeVars || !refVars) return false;
+        const minSeparation = refVars.width + constraint.minGap;
+        const c = new kiwi.Constraint(
+          new kiwi.Expression(nodeVars.x, [-1, refVars.x], -minSeparation),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(c);
+        this.kiwiConstraints.push(c);
+        return true;
+      }
+      addAboveConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        const refVars = this.variables.get(constraint.reference);
+        if (!nodeVars || !refVars) return false;
+        const minSeparation = nodeVars.height + constraint.minGap;
+        const c = new kiwi.Constraint(
+          new kiwi.Expression(refVars.y, [-1, nodeVars.y], -minSeparation),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(c);
+        this.kiwiConstraints.push(c);
+        return true;
+      }
+      addBelowConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        const refVars = this.variables.get(constraint.reference);
+        if (!nodeVars || !refVars) return false;
+        const minSeparation = refVars.height + constraint.minGap;
+        const c = new kiwi.Constraint(
+          new kiwi.Expression(nodeVars.y, [-1, refVars.y], -minSeparation),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(c);
+        this.kiwiConstraints.push(c);
+        return true;
+      }
+      addFixedPositionConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        if (!nodeVars) return false;
+        if (constraint.x !== void 0) {
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(nodeVars.x, -constraint.x),
+            kiwi.Operator.Eq,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        }
+        if (constraint.y !== void 0) {
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(nodeVars.y, -constraint.y),
+            kiwi.Operator.Eq,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        }
+        return true;
+      }
+      addInContainerConstraint(constraint, strength) {
+        const nodeVars = this.variables.get(constraint.node);
+        const containerVars = this.variables.get(constraint.container);
+        if (!nodeVars || !containerVars) return false;
+        const padding = constraint.padding;
+        const leftC = new kiwi.Constraint(
+          new kiwi.Expression(nodeVars.x, [-1, containerVars.x], -padding),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(leftC);
+        this.kiwiConstraints.push(leftC);
+        const topC = new kiwi.Constraint(
+          new kiwi.Expression(nodeVars.y, [-1, containerVars.y], -padding),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(topC);
+        this.kiwiConstraints.push(topC);
+        const rightC = new kiwi.Constraint(
+          new kiwi.Expression(
+            containerVars.x,
+            [-1, nodeVars.x],
+            containerVars.width - padding - nodeVars.width
+          ),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(rightC);
+        this.kiwiConstraints.push(rightC);
+        const bottomC = new kiwi.Constraint(
+          new kiwi.Expression(
+            containerVars.y,
+            [-1, nodeVars.y],
+            containerVars.height - padding - nodeVars.height
+          ),
+          kiwi.Operator.Ge,
+          0,
+          strength
+        );
+        this.solver.addConstraint(bottomC);
+        this.kiwiConstraints.push(bottomC);
+        return true;
+      }
+      addMinDistanceConstraint(constraint, strength) {
+        const node1Vars = this.variables.get(constraint.node1);
+        const node2Vars = this.variables.get(constraint.node2);
+        if (!node1Vars || !node2Vars) return false;
+        if (constraint.axis === "x") {
+          const size = node1Vars.width;
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(
+              node2Vars.x,
+              [-1, node1Vars.x],
+              -(size + constraint.minDistance)
+            ),
+            kiwi.Operator.Ge,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        } else {
+          const size = node1Vars.height;
+          const c = new kiwi.Constraint(
+            new kiwi.Expression(
+              node2Vars.y,
+              [-1, node1Vars.y],
+              -(size + constraint.minDistance)
+            ),
+            kiwi.Operator.Ge,
+            0,
+            strength
+          );
+          this.solver.addConstraint(c);
+          this.kiwiConstraints.push(c);
+        }
+        return true;
+      }
+      // ============================================================================
+      // Private: Helpers
+      // ============================================================================
+      getStrength(strength) {
+        const s = strength ?? this.options.defaultStrength ?? "strong";
+        switch (s) {
+          case "required":
+            return kiwi.Strength.required;
+          case "strong":
+            return kiwi.Strength.strong;
+          case "medium":
+            return kiwi.Strength.medium;
+          case "weak":
+            return kiwi.Strength.weak;
+          default:
+            return kiwi.Strength.strong;
         }
-        return simpleMidX;
       }
     };
   }
 });
 
+// src/layout/constraint/index.ts
+var init_constraint = __esm({
+  "src/layout/constraint/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_constraint_solver();
+  }
+});
+
 // src/layout/post-processing/pool-arranger.ts
 var PoolArranger;
 var init_pool_arranger = __esm({
@@ -2707,12 +2754,13 @@ var init_pool_arranger = __esm({
     "use strict";
     init_cjs_shims();
     init_artifact_positioner();
+    init_constraint();
     PoolArranger = class {
       poolHeaderWidth = 55;
       poolPaddingX = 25;
-      poolPaddingY = 20;
+      poolPaddingY = 40;
       minPoolHeight = 100;
-      poolExtraWidth = 50;
+      poolExtraWidth = 140;
       poolExtraHeight = 80;
       /**
        * Rearrange pools within collaborations
@@ -2774,24 +2822,41 @@ var init_pool_arranger = __esm({
             maxPoolWidth = Math.max(maxPoolWidth, (pool.width ?? 680) + this.poolExtraWidth);
           }
         }
-        let currentY = 0;
-        const nodePositions = /* @__PURE__ */ new Map();
+        const poolHeights = /* @__PURE__ */ new Map();
         for (const pool of pools) {
           const origPool = origPoolMap.get(pool.id);
           const isBlackBox = origPool?.bpmn?.isBlackBox === true;
           const hasLanes = origPool?.children?.some((c) => c.bpmn?.type === "lane");
-          pool.x = 0;
-          pool.y = currentY;
+          pool.width = maxPoolWidth;
           if (isBlackBox) {
-            pool.width = maxPoolWidth;
             pool.height = 60;
-          } else if (hasLanes) {
-            pool.width = maxPoolWidth;
-          } else {
-            pool.width = maxPoolWidth;
+          } else if (!hasLanes) {
             pool.height = (pool.height ?? 200) + this.poolExtraHeight;
-            this.offsetPoolChildren(pool, this.poolExtraHeight / 2);
+            this.offsetPoolChildren(pool, this.poolExtraWidth / 2, this.poolExtraHeight / 2);
           }
+          poolHeights.set(pool.id, pool.height ?? 200);
+        }
+        const solver = new ConstraintSolver();
+        for (const pool of pools) {
+          const height = poolHeights.get(pool.id) ?? 200;
+          solver.addNode(pool.id, 0, 0, maxPoolWidth, height);
+        }
+        for (let i = 1; i < pools.length; i++) {
+          solver.addConstraint({
+            type: "below",
+            node: pools[i].id,
+            reference: pools[i - 1].id,
+            minGap: 0,
+            strength: "required"
+          });
+        }
+        const positions = solver.solve();
+        const nodePositions = /* @__PURE__ */ new Map();
+        let totalHeight = 0;
+        for (const pool of pools) {
+          const pos = positions.get(pool.id);
+          pool.x = 0;
+          pool.y = pos?.y ?? totalHeight;
           nodePositions.set(pool.id, {
             x: pool.x,
             y: pool.y,
@@ -2799,10 +2864,10 @@ var init_pool_arranger = __esm({
             height: pool.height ?? 200
           });
           this.collectNodePositionsInPool(pool, pool.x, pool.y, nodePositions);
-          currentY += pool.height ?? 200;
+          totalHeight = pool.y + (pool.height ?? 200);
         }
         collab.width = maxPoolWidth;
-        collab.height = currentY;
+        collab.height = totalHeight;
         if (collab.edges && origCollab.edges) {
           this.recalculateMessageFlows(collab.edges, nodePositions, pools, origCollab.edges);
         }
@@ -2988,22 +3053,34 @@ var init_pool_arranger = __esm({
       /**
        * Offset all children within a pool
        */
-      offsetPoolChildren(pool, offsetY) {
+      offsetPoolChildren(pool, offsetX, offsetY) {
         if (!pool.children) return;
         for (const child of pool.children) {
+          if (child.x !== void 0) {
+            child.x += offsetX;
+          }
           if (child.y !== void 0) {
             child.y += offsetY;
           }
-          this.offsetPoolChildren(child, 0);
+          this.offsetPoolChildren(child, 0, 0);
         }
         if (pool.edges) {
           for (const edge of pool.edges) {
             if (edge.sections) {
               for (const section of edge.sections) {
-                if (section.startPoint) section.startPoint.y += offsetY;
-                if (section.endPoint) section.endPoint.y += offsetY;
+                if (section.startPoint) {
+                  section.startPoint.x += offsetX;
+                  section.startPoint.y += offsetY;
+                }
+                if (section.endPoint) {
+                  section.endPoint.x += offsetX;
+                  section.endPoint.y += offsetY;
+                }
                 if (section.bendPoints) {
-                  for (const bp of section.bendPoints) bp.y += offsetY;
+                  for (const bp of section.bendPoints) {
+                    bp.x += offsetX;
+                    bp.y += offsetY;
+                  }
                 }
               }
             }
@@ -3039,6 +3116,13 @@ var init_pool_arranger = __esm({
             }
           }
         }
+        const blackboxPoolIds = /* @__PURE__ */ new Set();
+        for (const pool of pools) {
+          const isBlackbox = !pool.children || pool.children.length === 0 || (pool.height ?? 0) <= 80;
+          if (isBlackbox) {
+            blackboxPoolIds.add(pool.id);
+          }
+        }
         for (const edge of edges) {
           const sourceId = edge.sources?.[0];
           const targetId = edge.targets?.[0];
@@ -3053,7 +3137,7 @@ var init_pool_arranger = __esm({
           if (isSequenceFlow) {
             this.createSequenceFlowWaypoints(sourcePos, targetPos, waypoints);
           } else if (isMessageFlow) {
-            this.createMessageFlowWaypoints(sourcePos, targetPos, waypoints);
+            this.createMessageFlowWaypoints(sourcePos, targetPos, waypoints, nodePositions, targetId, sourceId, blackboxPoolIds);
           } else if (isDataAssociation) {
             edge._absoluteCoords = true;
             edge.sections = [];
@@ -3136,28 +3220,203 @@ var init_pool_arranger = __esm({
       }
       /**
        * Create waypoints for message flows
+       * Routes message flows to avoid being too close to other nodes in the target pool
        */
-      createMessageFlowWaypoints(sourcePos, targetPos, waypoints) {
+      createMessageFlowWaypoints(sourcePos, targetPos, waypoints, nodePositions, targetId, sourceId, blackboxPoolIds) {
         let startX, startY, endX, endY;
-        if (sourcePos.y + sourcePos.height < targetPos.y) {
+        const goingDown = sourcePos.y + sourcePos.height < targetPos.y;
+        const isTargetBlackbox = targetId ? blackboxPoolIds?.has(targetId) ?? false : false;
+        const isSourceBlackbox = sourceId ? blackboxPoolIds?.has(sourceId) ?? false : false;
+        if (goingDown) {
           startX = sourcePos.x + sourcePos.width / 2;
           startY = sourcePos.y + sourcePos.height;
-          endX = targetPos.x + targetPos.width / 2;
+          if (isTargetBlackbox) {
+            const targetLeft = targetPos.x;
+            const targetRight = targetPos.x + targetPos.width;
+            if (startX >= targetLeft + 20 && startX <= targetRight - 20) {
+              endX = startX;
+            } else {
+              endX = targetPos.x + targetPos.width / 2;
+            }
+          } else {
+            endX = targetPos.x + targetPos.width / 2;
+          }
           endY = targetPos.y;
         } else {
           startX = sourcePos.x + sourcePos.width / 2;
           startY = sourcePos.y;
-          endX = targetPos.x + targetPos.width / 2;
+          if (isTargetBlackbox) {
+            const targetLeft = targetPos.x;
+            const targetRight = targetPos.x + targetPos.width;
+            if (startX >= targetLeft + 20 && startX <= targetRight - 20) {
+              endX = startX;
+            } else {
+              endX = targetPos.x + targetPos.width / 2;
+            }
+          } else {
+            endX = targetPos.x + targetPos.width / 2;
+          }
           endY = targetPos.y + targetPos.height;
         }
-        waypoints.push({ x: startX, y: startY });
+        if (isSourceBlackbox) {
+          const sourceLeft = sourcePos.x;
+          const sourceRight = sourcePos.x + sourcePos.width;
+          if (endX >= sourceLeft + 20 && endX <= sourceRight - 20) {
+            startX = endX;
+          }
+        }
+        const containerPatterns = [/^pool_/, /^participant_/, /^lane_/, /^process_/, /^collaboration_/];
+        const minClearance = 25;
+        const sourcePoolYMin = sourcePos.y - 50;
+        const sourcePoolYMax = sourcePos.y + sourcePos.height + 50;
+        const targetPoolYMin = targetPos.y - 50;
+        const targetPoolYMax = targetPos.y + targetPos.height + 50;
+        const fullVerticalMinY = Math.min(startY, endY);
+        const fullVerticalMaxY = Math.max(startY, endY);
+        const nodesBlockingDirectPath = [];
+        for (const [nodeId, bounds] of nodePositions) {
+          if (nodeId === targetId || nodeId === sourceId) continue;
+          const isContainer = containerPatterns.some((pattern) => pattern.test(nodeId));
+          if (isContainer) continue;
+          const nodeLeft = bounds.x;
+          const nodeRight = bounds.x + bounds.width;
+          const nodeTop = bounds.y;
+          const nodeBottom = bounds.y + bounds.height;
+          const inSourcePool = nodeTop >= sourcePoolYMin && nodeBottom <= sourcePoolYMax;
+          const inTargetPool = nodeTop >= targetPoolYMin && nodeBottom <= targetPoolYMax;
+          if (inSourcePool || inTargetPool) continue;
+          const overlapsVerticalLine = startX >= nodeLeft - minClearance && startX <= nodeRight + minClearance;
+          const nodeInVerticalRange = nodeBottom > fullVerticalMinY && nodeTop < fullVerticalMaxY;
+          if (overlapsVerticalLine && nodeInVerticalRange) {
+            nodesBlockingDirectPath.push({ id: nodeId, bounds });
+          }
+        }
+        let finalRouteX = startX;
+        if (nodesBlockingDirectPath.length > 0) {
+          const allObstacles = [];
+          for (const { bounds } of nodesBlockingDirectPath) {
+            allObstacles.push({
+              left: bounds.x - minClearance,
+              right: bounds.x + bounds.width + minClearance
+            });
+          }
+          for (const [nodeId, bounds] of nodePositions) {
+            if (nodeId === targetId || nodeId === sourceId) continue;
+            const isContainer = containerPatterns.some((pattern) => pattern.test(nodeId));
+            if (isContainer) continue;
+            const nodeTop = bounds.y;
+            const nodeBottom = bounds.y + bounds.height;
+            const inSourcePool = nodeTop >= sourcePoolYMin && nodeBottom <= sourcePoolYMax;
+            const inTargetPool = nodeTop >= targetPoolYMin && nodeBottom <= targetPoolYMax;
+            if (inSourcePool || inTargetPool) continue;
+            const nodeInVerticalRange = nodeBottom > fullVerticalMinY && nodeTop < fullVerticalMaxY;
+            if (nodeInVerticalRange) {
+              allObstacles.push({
+                left: bounds.x - minClearance,
+                right: bounds.x + bounds.width + minClearance
+              });
+            }
+          }
+          allObstacles.sort((a, b) => a.left - b.left);
+          const mergedObstacles = [];
+          for (const obs of allObstacles) {
+            if (mergedObstacles.length === 0) {
+              mergedObstacles.push({ ...obs });
+            } else {
+              const last = mergedObstacles[mergedObstacles.length - 1];
+              if (obs.left <= last.right) {
+                last.right = Math.max(last.right, obs.right);
+              } else {
+                mergedObstacles.push({ ...obs });
+              }
+            }
+          }
+          let bestRouteX = startX;
+          let bestShift = Infinity;
+          if (mergedObstacles.length > 0) {
+            const leftMost = mergedObstacles[0].left;
+            if (leftMost > 20) {
+              const shiftNeeded = Math.abs(startX - leftMost);
+              if (shiftNeeded < bestShift) {
+                bestShift = shiftNeeded;
+                bestRouteX = leftMost;
+              }
+            }
+          }
+          if (mergedObstacles.length > 0) {
+            const rightMost = mergedObstacles[mergedObstacles.length - 1].right;
+            const shiftNeeded = Math.abs(startX - rightMost);
+            if (shiftNeeded < bestShift) {
+              bestShift = shiftNeeded;
+              bestRouteX = rightMost;
+            }
+          }
+          for (let i = 0; i < mergedObstacles.length - 1; i++) {
+            const gapLeft = mergedObstacles[i].right;
+            const gapRight = mergedObstacles[i + 1].left;
+            const gapWidth = gapRight - gapLeft;
+            if (gapWidth >= 10) {
+              const gapCenter = (gapLeft + gapRight) / 2;
+              const shiftNeeded = Math.abs(startX - gapCenter);
+              if (shiftNeeded < bestShift) {
+                bestShift = shiftNeeded;
+                bestRouteX = gapCenter;
+              }
+            }
+          }
+          finalRouteX = bestRouteX;
+        }
         const horizontalDist = Math.abs(startX - endX);
-        if (horizontalDist > 5) {
-          const routeY = horizontalDist > 200 ? endY - 20 : (startY + endY) / 2;
+        waypoints.push({ x: startX, y: startY });
+        const needsObstacleAvoidance = Math.abs(finalRouteX - startX) > 5 && horizontalDist <= 5;
+        if (needsObstacleAvoidance) {
+          waypoints.push({ x: finalRouteX, y: startY });
+          waypoints.push({ x: finalRouteX, y: endY });
+          if (Math.abs(finalRouteX - endX) > 5) {
+            waypoints.push({ x: endX, y: endY });
+          }
+        } else if (horizontalDist > 5) {
+          let routeY = horizontalDist > 200 ? endY - 20 : (startY + endY) / 2;
+          if (targetId) {
+            const minX = Math.min(startX, endX);
+            const maxX = Math.max(startX, endX);
+            for (const [nodeId, bounds] of nodePositions) {
+              if (nodeId === targetId || nodeId === sourceId) continue;
+              const nodeLeft = bounds.x;
+              const nodeRight = bounds.x + bounds.width;
+              const nodeTop = bounds.y;
+              const nodeBottom = bounds.y + bounds.height;
+              const overlapsHorizontally = nodeRight > minX && nodeLeft < maxX;
+              if (overlapsHorizontally) {
+                if (goingDown) {
+                  if (routeY >= nodeTop && routeY <= nodeBottom) {
+                    routeY = Math.min(routeY, nodeTop - minClearance);
+                  } else if (nodeTop > startY && nodeTop < endY) {
+                    routeY = Math.min(routeY, nodeTop - minClearance);
+                  }
+                } else {
+                  if (routeY >= nodeTop && routeY <= nodeBottom) {
+                    routeY = Math.min(routeY, nodeTop - minClearance);
+                  } else if (nodeTop < startY && nodeBottom > endY) {
+                    routeY = Math.min(routeY, nodeTop - minClearance);
+                  }
+                }
+              }
+            }
+            if (goingDown) {
+              routeY = Math.max(routeY, startY + 10);
+              routeY = Math.min(routeY, endY - 10);
+            } else {
+              routeY = Math.max(routeY, endY + 10);
+              routeY = Math.min(routeY, startY - 10);
+            }
+          }
           waypoints.push({ x: startX, y: routeY });
           waypoints.push({ x: endX, y: routeY });
+          waypoints.push({ x: endX, y: endY });
+        } else {
+          waypoints.push({ x: endX, y: endY });
         }
-        waypoints.push({ x: endX, y: endY });
       }
       /**
        * Find the task associated with an artifact
@@ -3190,286 +3449,263 @@ var init_pool_arranger = __esm({
   }
 });
 
-// src/layout/post-processing/gateway-edge-adjuster.ts
-var GatewayEdgeAdjuster;
-var init_gateway_edge_adjuster = __esm({
-  "src/layout/post-processing/gateway-edge-adjuster.ts"() {
+// src/layout/post-processing/compactor.ts
+var DEFAULT_OPTIONS2, Compactor;
+var init_compactor = __esm({
+  "src/layout/post-processing/compactor.ts"() {
     "use strict";
     init_cjs_shims();
-    init_debug();
-    init_geometry_utils();
-    GatewayEdgeAdjuster = class {
+    DEFAULT_OPTIONS2 = {
+      minHorizontalGap: 60,
+      minVerticalGap: 40,
+      compactHorizontal: true,
+      compactVertical: true,
+      considerDependencies: true
+    };
+    Compactor = class {
+      options;
+      constructor(options) {
+        this.options = { ...DEFAULT_OPTIONS2, ...options };
+      }
       /**
-       * Adjust edges that connect to gateways
-       * @param layoutedGraph - The ELK layouted graph (contains edge coordinates)
-       * @param originalGraph - The original BPMN graph (contains bpmn metadata)
+       * Compact the graph layout
        */
-      adjust(layoutedGraph, originalGraph) {
-        const gateways = /* @__PURE__ */ new Map();
-        this.collectGateways(layoutedGraph, originalGraph, gateways, 0, 0);
-        if (gateways.size === 0) return;
-        if (isDebugEnabled()) {
-          console.log(`[BPMN] GatewayEdgeAdjuster: Found ${gateways.size} gateways`);
-          for (const [id, info] of gateways) {
-            console.log(`[BPMN]   - ${id}: bounds=(${info.bounds.x},${info.bounds.y},${info.bounds.width},${info.bounds.height})`);
-          }
-        }
-        this.processEdges(layoutedGraph, originalGraph, gateways, 0, 0);
-      }
-      /**
-       * Collect all gateway nodes and calculate their diamond corners
-       * Uses originalGraph for BPMN type info and layoutedGraph for positions
-       */
-      collectGateways(layoutedNode, originalNode, gateways, offsetX, offsetY) {
-        const bpmn = originalNode.bpmn;
-        if (this.isGateway(bpmn?.type)) {
-          const x = offsetX + (layoutedNode.x ?? 0);
-          const y = offsetY + (layoutedNode.y ?? 0);
-          const width = layoutedNode.width ?? 50;
-          const height = layoutedNode.height ?? 50;
-          gateways.set(layoutedNode.id, {
-            id: layoutedNode.id,
-            bounds: { x, y, width, height },
-            corners: {
-              left: { x, y: y + height / 2 },
-              top: { x: x + width / 2, y },
-              right: { x: x + width, y: y + height / 2 },
-              bottom: { x: x + width / 2, y: y + height }
-            }
-          });
-        }
-        if (layoutedNode.children && originalNode.children) {
-          const isContainer = this.isContainer(bpmn?.type);
-          const newOffsetX = isContainer ? offsetX + (layoutedNode.x ?? 0) : offsetX;
-          const newOffsetY = isContainer ? offsetY + (layoutedNode.y ?? 0) : offsetY;
-          const originalChildMap = /* @__PURE__ */ new Map();
-          for (const child of originalNode.children) {
-            const childNode = child;
-            if (childNode.id) {
-              originalChildMap.set(childNode.id, childNode);
-            }
+      compact(graph) {
+        if (!graph.children || graph.children.length === 0) return;
+        const nodeBounds = this.collectNodeBounds(graph);
+        if (nodeBounds.length === 0) return;
+        const edges = this.collectEdges(graph);
+        if (this.options.considerDependencies && edges.length > 0) {
+          this.compactWithDependencies(graph, nodeBounds, edges);
+        } else {
+          if (this.options.compactHorizontal) {
+            this.compactHorizontalSimple(nodeBounds);
           }
-          for (const layoutedChild of layoutedNode.children) {
-            const originalChild = originalChildMap.get(layoutedChild.id);
-            if (originalChild) {
-              this.collectGateways(layoutedChild, originalChild, gateways, newOffsetX, newOffsetY);
-            }
+          if (this.options.compactVertical) {
+            this.compactVerticalSimple(nodeBounds);
+          }
+          this.applyBounds(graph, nodeBounds);
+        }
+        for (const child of graph.children) {
+          if (child.children && child.children.length > 0) {
+            this.compact(child);
           }
         }
       }
       /**
-       * Process all edges and adjust endpoints connecting to gateways
+       * Collect node bounds from graph
        */
-      processEdges(layoutedNode, originalNode, gateways, offsetX, offsetY) {
-        const bpmn = originalNode.bpmn;
-        if (layoutedNode.edges) {
-          for (const edge of layoutedNode.edges) {
-            if (edge.sections && edge.sections.length > 0) {
-              this.adjustEdgeEndpoints(edge, gateways, offsetX, offsetY);
-            }
+      collectNodeBounds(graph) {
+        const bounds = [];
+        if (!graph.children) return bounds;
+        for (const child of graph.children) {
+          const node = child;
+          if (node.x !== void 0 && node.y !== void 0) {
+            bounds.push({
+              id: node.id,
+              x: node.x,
+              y: node.y,
+              width: node.width ?? 0,
+              height: node.height ?? 0
+            });
           }
         }
-        if (layoutedNode.children && originalNode.children) {
-          const isContainer = this.isContainer(bpmn?.type);
-          const newOffsetX = isContainer ? offsetX + (layoutedNode.x ?? 0) : offsetX;
-          const newOffsetY = isContainer ? offsetY + (layoutedNode.y ?? 0) : offsetY;
-          const originalChildMap = /* @__PURE__ */ new Map();
-          for (const child of originalNode.children) {
-            const childNode = child;
-            if (childNode.id) {
-              originalChildMap.set(childNode.id, childNode);
+        return bounds;
+      }
+      /**
+       * Collect edges from graph
+       */
+      collectEdges(graph) {
+        const edges = [];
+        const collectFromNode = (node) => {
+          if (node.edges) {
+            for (const edge of node.edges) {
+              const elkEdge = edge;
+              if (elkEdge.sources && elkEdge.targets) {
+                for (const source of elkEdge.sources) {
+                  for (const target of elkEdge.targets) {
+                    edges.push({ source, target });
+                  }
+                }
+              }
             }
           }
-          for (const layoutedChild of layoutedNode.children) {
-            const originalChild = originalChildMap.get(layoutedChild.id);
-            if (originalChild) {
-              this.processEdges(layoutedChild, originalChild, gateways, newOffsetX, newOffsetY);
+          if (node.children) {
+            for (const child of node.children) {
+              collectFromNode(child);
             }
           }
-        }
+        };
+        collectFromNode(graph);
+        return edges;
       }
       /**
-       * Adjust edge endpoints if they connect to a gateway
+       * Simple horizontal compaction - move nodes left while maintaining minimum gap
        */
-      adjustEdgeEndpoints(edge, gateways, offsetX, offsetY) {
-        const section = edge.sections[0];
-        const sourceId = edge.sources?.[0];
-        const targetId = edge.targets?.[0];
-        if (isDebugEnabled()) {
-          console.log(`[BPMN] GatewayEdgeAdjuster: Processing edge ${edge.id}, offset=(${offsetX},${offsetY})`);
-          console.log(`[BPMN]   sourceId=${sourceId}, targetId=${targetId}`);
-          console.log(`[BPMN]   startPoint=(${section.startPoint.x},${section.startPoint.y}), endPoint=(${section.endPoint.x},${section.endPoint.y})`);
-          console.log(`[BPMN]   available gateways: ${Array.from(gateways.keys()).join(", ")}`);
-        }
-        const sourceGateway = sourceId ? gateways.get(sourceId) : void 0;
-        if (sourceGateway) {
-          this.adjustStartPoint(section, sourceGateway, offsetX, offsetY);
+      compactHorizontalSimple(nodes) {
+        if (nodes.length === 0) return;
+        nodes.sort((a, b) => a.x - b.x);
+        const minX = nodes[0].x;
+        for (let i = 1; i < nodes.length; i++) {
+          const prev = nodes[i - 1];
+          const curr = nodes[i];
+          if (this.hasVerticalOverlap(prev, curr)) {
+            const minAllowedX = prev.x + prev.width + this.options.minHorizontalGap;
+            if (curr.x > minAllowedX) {
+              curr.x = minAllowedX;
+            }
+          }
         }
-        const targetGateway = targetId ? gateways.get(targetId) : void 0;
-        if (targetGateway) {
-          if (isDebugEnabled()) {
-            console.log(`[BPMN]   target gateway: ${targetId}, bounds=(${targetGateway.bounds.x},${targetGateway.bounds.y})`);
-            console.log(`[BPMN]   left corner: (${targetGateway.corners.left.x},${targetGateway.corners.left.y})`);
+        const newMinX = Math.min(...nodes.map((n) => n.x));
+        const offsetX = minX - newMinX;
+        if (offsetX > 0) {
+          for (const node of nodes) {
+            node.x += offsetX;
           }
-          this.adjustEndPoint(edge, section, targetGateway, offsetX, offsetY);
         }
       }
       /**
-       * Adjust the start point of an edge leaving a gateway
+       * Simple vertical compaction - move nodes up while maintaining minimum gap
        */
-      adjustStartPoint(section, gateway, offsetX, offsetY) {
-        const startX = offsetX + section.startPoint.x;
-        const startY = offsetY + section.startPoint.y;
-        const corner = this.findClosestCorner(
-          { x: startX, y: startY },
-          gateway
-        );
-        section.startPoint = {
-          x: corner.x - offsetX,
-          y: corner.y - offsetY
-        };
-        if (section.bendPoints && section.bendPoints.length > 0) {
-          const firstBend = section.bendPoints[0];
-          const adjustedStart = section.startPoint;
-          if (Math.abs(offsetX + firstBend.x - corner.x) < 20) {
-            firstBend.x = adjustedStart.x;
-          } else if (Math.abs(offsetY + firstBend.y - corner.y) < 20) {
-            firstBend.y = adjustedStart.y;
+      compactVerticalSimple(nodes) {
+        if (nodes.length === 0) return;
+        nodes.sort((a, b) => a.y - b.y);
+        const minY = nodes[0].y;
+        for (let i = 1; i < nodes.length; i++) {
+          const prev = nodes[i - 1];
+          const curr = nodes[i];
+          if (this.hasHorizontalOverlap(prev, curr)) {
+            const minAllowedY = prev.y + prev.height + this.options.minVerticalGap;
+            if (curr.y > minAllowedY) {
+              curr.y = minAllowedY;
+            }
+          }
+        }
+        const newMinY = Math.min(...nodes.map((n) => n.y));
+        const offsetY = minY - newMinY;
+        if (offsetY > 0) {
+          for (const node of nodes) {
+            node.y += offsetY;
           }
         }
       }
       /**
-       * Adjust the end point of an edge entering a gateway
+       * Compact with dependency consideration using topological sort
        */
-      adjustEndPoint(edge, section, gateway, offsetX, offsetY) {
-        const endX = offsetX + section.endPoint.x;
-        const endY = offsetY + section.endPoint.y;
-        let prevPoint;
-        if (section.bendPoints && section.bendPoints.length > 0) {
-          const lastBend = section.bendPoints[section.bendPoints.length - 1];
-          prevPoint = { x: offsetX + lastBend.x, y: offsetY + lastBend.y };
-        } else {
-          prevPoint = { x: offsetX + section.startPoint.x, y: offsetY + section.startPoint.y };
-        }
-        const dx = endX - prevPoint.x;
-        const dy = endY - prevPoint.y;
-        let targetCorner;
-        if (Math.abs(dx) > Math.abs(dy)) {
-          targetCorner = dx > 0 ? gateway.corners.left : gateway.corners.right;
-        } else {
-          targetCorner = dy > 0 ? gateway.corners.top : gateway.corners.bottom;
+      compactWithDependencies(graph, nodeBounds, edges) {
+        const boundsMap = /* @__PURE__ */ new Map();
+        for (const node of nodeBounds) {
+          boundsMap.set(node.id, node);
         }
-        const distToCorner = Math.sqrt(
-          Math.pow(endX - targetCorner.x, 2) + Math.pow(endY - targetCorner.y, 2)
-        );
-        if (distToCorner < 30) {
-          const oldEndX = section.endPoint.x;
-          const oldEndY = section.endPoint.y;
-          section.endPoint = {
-            x: targetCorner.x - offsetX,
-            y: targetCorner.y - offsetY
-          };
-          if (section.bendPoints && section.bendPoints.length > 0) {
-            const lastBend = section.bendPoints[section.bendPoints.length - 1];
-            const newEnd = section.endPoint;
-            if (Math.abs(offsetY + lastBend.y - (offsetY + oldEndY)) < 5) {
-              lastBend.y = newEnd.y;
-            } else if (Math.abs(offsetX + lastBend.x - (offsetX + oldEndX)) < 5) {
-              lastBend.x = newEnd.x;
+        const dependencies = /* @__PURE__ */ new Map();
+        for (const edge of edges) {
+          if (!dependencies.has(edge.target)) {
+            dependencies.set(edge.target, /* @__PURE__ */ new Set());
+          }
+          dependencies.get(edge.target).add(edge.source);
+        }
+        const sorted = this.topologicalSort([...boundsMap.keys()], dependencies);
+        if (this.options.compactHorizontal) {
+          for (const nodeId of sorted) {
+            const node = boundsMap.get(nodeId);
+            if (!node) continue;
+            const deps = dependencies.get(nodeId);
+            if (!deps || deps.size === 0) continue;
+            let maxRight = 0;
+            for (const depId of deps) {
+              const dep = boundsMap.get(depId);
+              if (dep) {
+                maxRight = Math.max(maxRight, dep.x + dep.width);
+              }
             }
-          }
-          if (isDebugEnabled()) {
-            console.log(`[BPMN] GatewayEdgeAdjuster: Adjusted edge ${edge.id} endpoint from (${endX},${endY}) to (${targetCorner.x},${targetCorner.y})`);
-          }
-        } else {
-          const intersectionPoint = this.findDiamondIntersection(
-            prevPoint,
-            { x: endX, y: endY },
-            gateway
-          );
-          if (intersectionPoint) {
-            section.endPoint = {
-              x: intersectionPoint.x - offsetX,
-              y: intersectionPoint.y - offsetY
-            };
-            if (isDebugEnabled()) {
-              console.log(`[BPMN] GatewayEdgeAdjuster: Adjusted edge ${edge.id} endpoint to diamond intersection (${intersectionPoint.x},${intersectionPoint.y})`);
+            const targetX = maxRight + this.options.minHorizontalGap;
+            if (node.x > targetX) {
+              node.x = targetX;
             }
           }
         }
+        this.applyBounds(graph, nodeBounds);
       }
       /**
-       * Find the closest corner of a gateway to a given point
+       * Apply bounds back to graph nodes
        */
-      findClosestCorner(point, gateway) {
-        const corners = [
-          gateway.corners.left,
-          gateway.corners.top,
-          gateway.corners.right,
-          gateway.corners.bottom
-        ];
-        let closest = corners[0];
-        let minDist = distance(point, closest);
-        for (let i = 1; i < corners.length; i++) {
-          const dist = distance(point, corners[i]);
-          if (dist < minDist) {
-            minDist = dist;
-            closest = corners[i];
-          }
-        }
-        return closest;
-      }
-      /**
-       * Find intersection point between a line segment and the diamond edges
-       */
-      findDiamondIntersection(from, to, gateway) {
-        const { corners } = gateway;
-        const edges = [
-          [corners.left, corners.top],
-          // top-left edge
-          [corners.top, corners.right],
-          // top-right edge
-          [corners.right, corners.bottom],
-          // bottom-right edge
-          [corners.bottom, corners.left]
-          // bottom-left edge
-        ];
-        for (const [p1, p2] of edges) {
-          const intersection = lineIntersection(from, to, p1, p2);
-          if (intersection) {
-            return intersection;
+      applyBounds(graph, bounds) {
+        const boundsMap = /* @__PURE__ */ new Map();
+        for (const b of bounds) {
+          boundsMap.set(b.id, b);
+        }
+        if (!graph.children) return;
+        for (const child of graph.children) {
+          const node = child;
+          const b = boundsMap.get(node.id);
+          if (b) {
+            node.x = b.x;
+            node.y = b.y;
           }
         }
-        return null;
       }
       /**
-       * Check if a BPMN type is a gateway
+       * Check if two nodes have vertical overlap (same horizontal band)
        */
-      isGateway(type) {
-        if (!type) return false;
-        return [
-          "exclusiveGateway",
-          "parallelGateway",
-          "inclusiveGateway",
-          "eventBasedGateway",
-          "complexGateway"
-        ].includes(type);
+      hasVerticalOverlap(a, b) {
+        const aTop = a.y;
+        const aBottom = a.y + a.height;
+        const bTop = b.y;
+        const bBottom = b.y + b.height;
+        return aTop < bBottom && bTop < aBottom;
       }
       /**
-       * Check if a BPMN type is a container
+       * Check if two nodes have horizontal overlap (same vertical band)
        */
-      isContainer(type) {
-        if (!type) return false;
-        return [
-          "lane",
-          "participant",
-          "collaboration",
-          "process",
-          "subProcess",
-          "transaction",
-          "adHocSubProcess",
-          "eventSubProcess"
-        ].includes(type);
+      hasHorizontalOverlap(a, b) {
+        const aLeft = a.x;
+        const aRight = a.x + a.width;
+        const bLeft = b.x;
+        const bRight = b.x + b.width;
+        return aLeft < bRight && bLeft < aRight;
+      }
+      /**
+       * Topological sort using Kahn's algorithm
+       */
+      topologicalSort(nodes, dependencies) {
+        const inDegree = /* @__PURE__ */ new Map();
+        const adjacencyList = /* @__PURE__ */ new Map();
+        for (const node of nodes) {
+          inDegree.set(node, 0);
+          adjacencyList.set(node, []);
+        }
+        for (const [target, sources] of dependencies) {
+          for (const source of sources) {
+            if (adjacencyList.has(source)) {
+              adjacencyList.get(source).push(target);
+              inDegree.set(target, (inDegree.get(target) ?? 0) + 1);
+            }
+          }
+        }
+        const queue = [];
+        for (const node of nodes) {
+          if ((inDegree.get(node) ?? 0) === 0) {
+            queue.push(node);
+          }
+        }
+        const sorted = [];
+        while (queue.length > 0) {
+          const node = queue.shift();
+          sorted.push(node);
+          for (const dependent of adjacencyList.get(node) ?? []) {
+            const newDegree = (inDegree.get(dependent) ?? 0) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+              queue.push(dependent);
+            }
+          }
+        }
+        for (const node of nodes) {
+          if (!sorted.includes(node)) {
+            sorted.push(node);
+          }
+        }
+        return sorted;
       }
     };
   }
@@ -3489,18 +3725,50 @@ var init_default_options = __esm({
     "use strict";
     init_cjs_shims();
     DEFAULT_ELK_OPTIONS2 = {
+      // === Basic Configuration ===
       "elk.algorithm": "layered",
       "elk.direction": "RIGHT",
-      "elk.spacing.nodeNode": 50,
-      "elk.spacing.edgeNode": 30,
-      "elk.spacing.edgeEdge": 20,
-      "elk.layered.spacing.nodeNodeBetweenLayers": 80,
-      "elk.layered.spacing.edgeNodeBetweenLayers": 30,
-      "elk.layered.spacing.edgeEdgeBetweenLayers": 20,
-      "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+      // === Layer Assignment ===
+      // NETWORK_SIMPLEX provides better layer distribution than LONGEST_PATH
+      "elk.layered.layering.strategy": "NETWORK_SIMPLEX",
+      // === Crossing Minimization ===
       "elk.layered.crossingMinimization.strategy": "LAYER_SWEEP",
+      // TWO_SIDED greedy switch improves crossing reduction
+      "elk.layered.crossingMinimization.greedySwitch.type": "TWO_SIDED",
+      // === Node Placement ===
+      // BRANDES_KOEPF provides better vertical alignment than NETWORK_SIMPLEX
       "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
-      "elk.edgeRouting": "ORTHOGONAL"
+      // Use BALANCED alignment for symmetric layouts
+      "elk.layered.nodePlacement.bk.fixedAlignment": "BALANCED",
+      // === Edge Routing ===
+      "elk.edgeRouting": "ORTHOGONAL",
+      // Distribute self-loops evenly
+      "elk.layered.edgeRouting.selfLoopDistribution": "EQUALLY",
+      // === Edge Labels ===
+      // Place edge labels at the center of the edge
+      "elk.edgeLabels.placement": "CENTER",
+      // Ensure labels don't overlap with nodes or other labels
+      "elk.spacing.labelLabel": 5,
+      "elk.spacing.labelNode": 10,
+      "elk.spacing.edgeLabel": 10,
+      // === Spacing (increased for better readability) ===
+      "elk.spacing.nodeNode": 60,
+      "elk.spacing.edgeNode": 40,
+      "elk.spacing.edgeEdge": 25,
+      "elk.layered.spacing.nodeNodeBetweenLayers": 100,
+      "elk.layered.spacing.edgeNodeBetweenLayers": 40,
+      "elk.layered.spacing.edgeEdgeBetweenLayers": 25,
+      // === Hierarchy Handling ===
+      "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+      // === Model Order ===
+      // Consider both node and edge order from the input model
+      "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+      // === Compaction ===
+      // Compact connected components together
+      "elk.layered.compaction.connectedComponents": true,
+      // === Alignment ===
+      // Center alignment for cleaner appearance
+      "elk.alignment": "CENTER"
     };
   }
 });
@@ -3677,10 +3945,10 @@ var init_elk_graph_preparer = __esm({
       /**
        * Prepare children for ELK layout
        */
-      prepareChildrenForElk(children, boundaryEventTargetIds = /* @__PURE__ */ new Set(), mainFlowNodes = /* @__PURE__ */ new Set()) {
-        if (!children) return [];
+      prepareChildrenForElk(nodes, boundaryEventTargetIds = /* @__PURE__ */ new Set(), mainFlowNodes = /* @__PURE__ */ new Set()) {
+        if (!nodes) return [];
         const result = [];
-        for (const child of children) {
+        for (const child of nodes) {
           const node = child;
           result.push(this.prepareNodeForElk(node, boundaryEventTargetIds, mainFlowNodes));
           if (node.boundaryEvents && node.boundaryEvents.length > 0) {
@@ -3712,7 +3980,7 @@ var init_elk_graph_preparer = __esm({
             "elk.layered.layering.layerConstraint": "LAST"
           };
         }
-        if (mainFlowNodes.has(node.id)) {
+        if (mainFlowNodes.has(node.id) && !boundaryEventTargetIds.has(node.id)) {
           layoutOptions = {
             ...layoutOptions,
             "elk.priority": "10"
@@ -3721,7 +3989,7 @@ var init_elk_graph_preparer = __esm({
         if (boundaryEventTargetIds.has(node.id)) {
           layoutOptions = {
             ...layoutOptions,
-            "elk.priority": "0"
+            "elk.priority": "1"
           };
         }
         const isExpandedSubprocess = node.bpmn?.isExpanded === true && (node.bpmn?.type === "subProcess" || node.bpmn?.type === "transaction" || node.bpmn?.type === "adHocSubProcess" || node.bpmn?.type === "eventSubProcess");
@@ -4047,553 +4315,6 @@ var init_result_merger = __esm({
   }
 });
 
-// src/layout/normalization/main-flow-normalizer.ts
-var TARGET_MAIN_FLOW_Y, GATEWAY_OFFSET_Y, MainFlowNormalizer;
-var init_main_flow_normalizer = __esm({
-  "src/layout/normalization/main-flow-normalizer.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_debug();
-    TARGET_MAIN_FLOW_Y = 12;
-    GATEWAY_OFFSET_Y = 150;
-    MainFlowNormalizer = class {
-      /**
-       * Normalize main flow position to keep it at the top of the diagram.
-       *
-       * Strategy:
-       * 1. Identify "upstream main flow" nodes (before converging gateway)
-       * 2. Shift these nodes up to target Y
-       * 3. Position converging gateway below the main flow
-       * 4. Position downstream nodes (after gateway) relative to gateway
-       */
-      normalize(graph, mainFlowNodes, boundaryEventTargetIds, originalGraph) {
-        const nodeMap = /* @__PURE__ */ new Map();
-        const nodesInsideContainers = /* @__PURE__ */ new Set();
-        const buildNodeMap2 = (node, parentIsContainer = false) => {
-          nodeMap.set(node.id, node);
-          if (parentIsContainer) {
-            nodesInsideContainers.add(node.id);
-          }
-          if (node.children) {
-            const nodeType = this.getNodeTypeFromOriginal(node.id, originalGraph);
-            const isContainer = nodeType === "subProcess" || nodeType === "transaction" || nodeType === "adHocSubProcess" || nodeType === "eventSubProcess";
-            for (const child of node.children) {
-              buildNodeMap2(child, isContainer || parentIsContainer);
-            }
-          }
-        };
-        buildNodeMap2(graph);
-        const convergingGatewayIds = /* @__PURE__ */ new Set();
-        const upstreamMainFlow = [];
-        const downstreamMainFlow = [];
-        for (const nodeId of mainFlowNodes) {
-          if (this.isConvergingGatewayWithBoundaryInputs(nodeId, graph, boundaryEventTargetIds)) {
-            const nodeType = this.getNodeTypeFromOriginal(nodeId, originalGraph);
-            const isEndEvent = nodeType === "endEvent";
-            if (!isEndEvent) {
-              convergingGatewayIds.add(nodeId);
-            }
-          }
-        }
-        const edgeMap = /* @__PURE__ */ new Map();
-        const collectEdges = (node) => {
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const source = edge.sources?.[0];
-              const target = edge.targets?.[0];
-              if (source && target) {
-                if (!edgeMap.has(source)) edgeMap.set(source, []);
-                edgeMap.get(source).push(target);
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              collectEdges(child);
-            }
-          }
-        };
-        collectEdges(graph);
-        const downstreamNodeIds = /* @__PURE__ */ new Set();
-        const markDownstream = (nodeId) => {
-          if (downstreamNodeIds.has(nodeId)) return;
-          downstreamNodeIds.add(nodeId);
-          const targets = edgeMap.get(nodeId) || [];
-          for (const targetId of targets) {
-            if (mainFlowNodes.has(targetId)) {
-              markDownstream(targetId);
-            }
-          }
-        };
-        for (const gatewayId of convergingGatewayIds) {
-          markDownstream(gatewayId);
-        }
-        for (const nodeId of mainFlowNodes) {
-          if (nodesInsideContainers.has(nodeId)) continue;
-          const node = nodeMap.get(nodeId);
-          if (!node || node.y === void 0) continue;
-          if (downstreamNodeIds.has(nodeId)) {
-            downstreamMainFlow.push(node);
-          } else {
-            upstreamMainFlow.push(node);
-          }
-        }
-        const endEventNodes = [];
-        const otherUpstreamNodes = [];
-        for (const node of upstreamMainFlow) {
-          const nodeType = this.getNodeTypeFromOriginal(node.id, originalGraph);
-          if (nodeType === "endEvent") {
-            endEventNodes.push(node);
-          } else {
-            otherUpstreamNodes.push(node);
-          }
-        }
-        let currentMinY = Infinity;
-        for (const node of otherUpstreamNodes) {
-          if (node.y !== void 0) {
-            currentMinY = Math.min(currentMinY, node.y);
-          }
-        }
-        if (currentMinY === Infinity || currentMinY <= TARGET_MAIN_FLOW_Y) {
-          return;
-        }
-        const offsetY = currentMinY - TARGET_MAIN_FLOW_Y;
-        if (isDebugEnabled()) {
-          console.log(`[BPMN] Normalizing main flow: currentMinY=${currentMinY}, offsetY=${offsetY}`);
-          console.log(`[BPMN] Upstream nodes: ${upstreamMainFlow.map((n) => n.id).join(", ")}`);
-          console.log(`[BPMN] Downstream nodes: ${downstreamMainFlow.map((n) => n.id).join(", ")}`);
-        }
-        for (const node of otherUpstreamNodes) {
-          if (node.y !== void 0) {
-            node.y -= offsetY;
-            if (isDebugEnabled()) {
-              console.log(`[BPMN] Shifted upstream ${node.id} to y=${node.y}`);
-            }
-          }
-        }
-        for (const endNode of endEventNodes) {
-          const predecessorId = this.findPredecessorOnMainFlow(endNode.id, graph, mainFlowNodes);
-          if (predecessorId) {
-            const predecessor = nodeMap.get(predecessorId);
-            if (predecessor && predecessor.y !== void 0) {
-              const predecessorCenterY = predecessor.y + (predecessor.height ?? 80) / 2;
-              const endNodeCenterY = (endNode.height ?? 36) / 2;
-              endNode.y = predecessorCenterY - endNodeCenterY;
-              if (isDebugEnabled()) {
-                console.log(`[BPMN] Aligned endEvent ${endNode.id} with predecessor ${predecessorId}: y=${endNode.y}`);
-              }
-            }
-          } else {
-            if (endNode.y !== void 0) {
-              endNode.y -= offsetY;
-              if (isDebugEnabled()) {
-                console.log(`[BPMN] Shifted upstream ${endNode.id} to y=${endNode.y} (no predecessor found)`);
-              }
-            }
-          }
-        }
-        const endEventsByX = /* @__PURE__ */ new Map();
-        for (const endNode of endEventNodes) {
-          const x = endNode.x ?? 0;
-          if (!endEventsByX.has(x)) {
-            endEventsByX.set(x, []);
-          }
-          endEventsByX.get(x).push(endNode);
-        }
-        const adjustedEndEvents = /* @__PURE__ */ new Map();
-        const MIN_SPACING = 50;
-        for (const [x, nodesAtX] of endEventsByX) {
-          if (nodesAtX.length <= 1) continue;
-          nodesAtX.sort((a, b) => (a.y ?? 0) - (b.y ?? 0));
-          for (let i = 1; i < nodesAtX.length; i++) {
-            const prevNode = nodesAtX[i - 1];
-            const currNode = nodesAtX[i];
-            const prevBottom = (prevNode.y ?? 0) + (prevNode.height ?? 36);
-            const currTop = currNode.y ?? 0;
-            if (currTop < prevBottom + MIN_SPACING) {
-              const newY = prevBottom + MIN_SPACING;
-              currNode.y = newY;
-              adjustedEndEvents.set(currNode.id, newY);
-              if (isDebugEnabled()) {
-                console.log(`[BPMN] Adjusted overlapping endEvent ${currNode.id} at x=${x}: y=${currNode.y}`);
-              }
-            }
-          }
-        }
-        const edgesWithAdjustedEndpoint = /* @__PURE__ */ new Set();
-        if (adjustedEndEvents.size > 0) {
-          this.updateEdgesForAdjustedEndEvents(graph, adjustedEndEvents, nodeMap, edgesWithAdjustedEndpoint);
-        }
-        const mainFlowBottom = Math.max(...upstreamMainFlow.map((n) => (n.y ?? 0) + (n.height ?? 80)));
-        const targetGatewayY = mainFlowBottom + GATEWAY_OFFSET_Y;
-        let currentGatewayY = Infinity;
-        for (const gatewayId of convergingGatewayIds) {
-          const gateway = nodeMap.get(gatewayId);
-          if (gateway && gateway.y !== void 0) {
-            currentGatewayY = Math.min(currentGatewayY, gateway.y);
-          }
-        }
-        if (currentGatewayY !== Infinity) {
-          const downstreamOffsetY = currentGatewayY - targetGatewayY;
-          for (const node of downstreamMainFlow) {
-            if (node.y !== void 0) {
-              node.y -= downstreamOffsetY;
-              if (isDebugEnabled()) {
-                console.log(`[BPMN] Shifted downstream ${node.id} to y=${node.y}`);
-              }
-            }
-          }
-        }
-        for (const [nodeId, node] of nodeMap) {
-          if (node.y !== void 0 && nodeId.startsWith("boundary_")) {
-            const attachedNodeId = this.findBoundaryAttachedNode(nodeId, graph);
-            if (attachedNodeId && mainFlowNodes.has(attachedNodeId)) {
-              const attachedNode = nodeMap.get(attachedNodeId);
-              if (attachedNode && attachedNode.y !== void 0) {
-                const attachedBottom = attachedNode.y + (attachedNode.height ?? 80);
-                node.y = attachedBottom - (node.height ?? 36) / 2;
-              }
-            }
-          }
-        }
-        this.updateEdgesAfterNormalization(graph, [...upstreamMainFlow, ...downstreamMainFlow], offsetY, edgesWithAdjustedEndpoint);
-      }
-      /**
-       * Find the predecessor node of a given node on the main flow
-       */
-      findPredecessorOnMainFlow(nodeId, graph, mainFlowNodes) {
-        const findIncoming = (node) => {
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const target = edge.targets?.[0];
-              const source = edge.sources?.[0];
-              if (target === nodeId && source && mainFlowNodes.has(source)) {
-                if (!source.includes("boundary")) {
-                  return source;
-                }
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              const result = findIncoming(child);
-              if (result) return result;
-            }
-          }
-          return void 0;
-        };
-        return findIncoming(graph);
-      }
-      /**
-       * Get the BPMN type of a node by searching the original graph (with BPMN info preserved)
-       */
-      getNodeTypeFromOriginal(nodeId, graph) {
-        const findType = (children) => {
-          if (!children) return void 0;
-          for (const child of children) {
-            const node = child;
-            if (node.id === nodeId) {
-              return node.bpmn?.type;
-            }
-            if (node.children) {
-              const result = findType(node.children);
-              if (result) return result;
-            }
-          }
-          return void 0;
-        };
-        return findType(graph.children);
-      }
-      /**
-       * Check if a node is a converging gateway that receives edges from both
-       * main flow and boundary event branches (should be positioned below main flow)
-       */
-      isConvergingGatewayWithBoundaryInputs(nodeId, graph, boundaryEventTargetIds) {
-        const incomingSources = [];
-        const collectIncoming = (node) => {
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const target = edge.targets?.[0];
-              const source = edge.sources?.[0];
-              if (target === nodeId && source) {
-                incomingSources.push(source);
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              collectIncoming(child);
-            }
-          }
-        };
-        collectIncoming(graph);
-        if (incomingSources.length <= 1) return false;
-        let hasMainFlowInput = false;
-        let hasBoundaryInput = false;
-        for (const sourceId of incomingSources) {
-          if (boundaryEventTargetIds.has(sourceId) || this.isDownstreamOfBoundaryTarget(sourceId, graph, boundaryEventTargetIds)) {
-            hasBoundaryInput = true;
-          } else if (!sourceId.startsWith("boundary_")) {
-            hasMainFlowInput = true;
-          }
-        }
-        return hasMainFlowInput && hasBoundaryInput;
-      }
-      /**
-       * Check if a node is downstream of a boundary event target
-       */
-      isDownstreamOfBoundaryTarget(nodeId, graph, boundaryEventTargetIds, visited = /* @__PURE__ */ new Set()) {
-        if (visited.has(nodeId)) return false;
-        visited.add(nodeId);
-        if (boundaryEventTargetIds.has(nodeId)) return true;
-        const findIncoming = (node) => {
-          const sources2 = [];
-          if (node.edges) {
-            for (const edge of node.edges) {
-              if (edge.targets?.[0] === nodeId) {
-                sources2.push(edge.sources?.[0] ?? "");
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              sources2.push(...findIncoming(child));
-            }
-          }
-          return sources2.filter((s) => s);
-        };
-        const sources = findIncoming(graph);
-        for (const sourceId of sources) {
-          if (this.isDownstreamOfBoundaryTarget(sourceId, graph, boundaryEventTargetIds, visited)) {
-            return true;
-          }
-        }
-        return false;
-      }
-      /**
-       * Find the node that a boundary event is attached to
-       */
-      findBoundaryAttachedNode(boundaryEventId, graph) {
-        const parts = boundaryEventId.replace("boundary_", "").split("_");
-        if (parts.length >= 2) {
-          const suffix = parts.slice(1).join("_");
-          const possibleParents = ["call_activity_" + suffix, "task_" + suffix, suffix];
-          const nodeMap = /* @__PURE__ */ new Map();
-          const buildMap = (node) => {
-            nodeMap.set(node.id, node);
-            if (node.children) {
-              for (const child of node.children) {
-                buildMap(child);
-              }
-            }
-          };
-          buildMap(graph);
-          for (const parentId of possibleParents) {
-            if (nodeMap.has(parentId)) {
-              return parentId;
-            }
-          }
-        }
-        return null;
-      }
-      /**
-       * Update edges after normalization to adjust waypoints
-       */
-      /**
-       * Update edges that connect to endEvents that were adjusted for overlap
-       */
-      updateEdgesForAdjustedEndEvents(graph, adjustedEndEvents, nodeMap, edgesWithAdjustedEndpoint) {
-        const updateEdges = (node) => {
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const targetId = edge.targets?.[0];
-              if (targetId && adjustedEndEvents.has(targetId)) {
-                const targetNode = nodeMap.get(targetId);
-                if (!targetNode) continue;
-                const newTargetY = (targetNode.y ?? 0) + (targetNode.height ?? 36) / 2;
-                if (edge.sections) {
-                  for (const section of edge.sections) {
-                    if (section.bendPoints && section.bendPoints.length > 0 && section.endPoint) {
-                      const lastBend = section.bendPoints[section.bendPoints.length - 1];
-                      const oldEndY = section.endPoint.y;
-                      if (Math.abs(lastBend.y - oldEndY) < 1) {
-                        lastBend.y = newTargetY;
-                        section.endPoint.y = newTargetY;
-                        edgesWithAdjustedEndpoint.add(edge.id);
-                        if (isDebugEnabled()) {
-                          console.log(`[BPMN] Updated edge ${edge.id} last bendPoint and endpoint to y=${newTargetY}`);
-                        }
-                      } else {
-                        section.endPoint.y = newTargetY;
-                        edgesWithAdjustedEndpoint.add(edge.id);
-                        if (isDebugEnabled()) {
-                          console.log(`[BPMN] Updated edge ${edge.id} endpoint to y=${newTargetY}`);
-                        }
-                      }
-                    } else if (section.endPoint) {
-                      section.endPoint.y = newTargetY;
-                      edgesWithAdjustedEndpoint.add(edge.id);
-                      if (isDebugEnabled()) {
-                        console.log(`[BPMN] Updated edge ${edge.id} endpoint to y=${newTargetY}`);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              updateEdges(child);
-            }
-          }
-        };
-        updateEdges(graph);
-      }
-      updateEdgesAfterNormalization(graph, movedNodes, offsetY, edgesWithAdjustedEndpoint = /* @__PURE__ */ new Set()) {
-        const movedNodeIds = new Set(movedNodes.map((n) => n.id));
-        const updateEdges = (node) => {
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const sourceId = edge.sources?.[0];
-              const targetId = edge.targets?.[0];
-              const sourceMoved = sourceId && movedNodeIds.has(sourceId);
-              const targetMoved = targetId && movedNodeIds.has(targetId);
-              const endpointAlreadyAdjusted = edgesWithAdjustedEndpoint.has(edge.id);
-              if (sourceMoved && targetMoved && edge.sections) {
-                for (const section of edge.sections) {
-                  if (section.startPoint) {
-                    section.startPoint.y -= offsetY;
-                  }
-                  if (section.endPoint && !endpointAlreadyAdjusted) {
-                    section.endPoint.y -= offsetY;
-                  }
-                  if (section.bendPoints) {
-                    const bendCount = section.bendPoints.length;
-                    for (let i = 0; i < bendCount; i++) {
-                      if (endpointAlreadyAdjusted && i === bendCount - 1) continue;
-                      section.bendPoints[i].y -= offsetY;
-                    }
-                  }
-                }
-              } else if (sourceMoved && !targetMoved && edge.sections) {
-                for (const section of edge.sections) {
-                  if (section.startPoint) {
-                    section.startPoint.y -= offsetY;
-                  }
-                }
-              } else if (!sourceMoved && targetMoved && edge.sections && !endpointAlreadyAdjusted) {
-                for (const section of edge.sections) {
-                  if (section.endPoint) {
-                    section.endPoint.y -= offsetY;
-                  }
-                }
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              updateEdges(child);
-            }
-          }
-        };
-        updateEdges(graph);
-      }
-    };
-  }
-});
-
-// src/layout/normalization/gateway-propagator.ts
-var GatewayPropagator;
-var init_gateway_propagator = __esm({
-  "src/layout/normalization/gateway-propagator.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_debug();
-    GatewayPropagator = class {
-      /**
-       * Propagate gateway movement to downstream nodes (nodes after the gateway in the flow)
-       */
-      propagate(graph, gatewayMoves, mainFlowNodes) {
-        const nodeMap = /* @__PURE__ */ new Map();
-        const edgeMap = /* @__PURE__ */ new Map();
-        const buildMaps = (node) => {
-          nodeMap.set(node.id, node);
-          if (node.edges) {
-            for (const edge of node.edges) {
-              const source = edge.sources?.[0];
-              const target = edge.targets?.[0];
-              if (source && target) {
-                if (!edgeMap.has(source)) edgeMap.set(source, []);
-                edgeMap.get(source).push(target);
-              }
-            }
-          }
-          if (node.children) {
-            for (const child of node.children) {
-              buildMaps(child);
-            }
-          }
-        };
-        buildMaps(graph);
-        for (const [gatewayId, gatewayMove] of gatewayMoves) {
-          if (gatewayMove.newX === void 0) continue;
-          const gateway = nodeMap.get(gatewayId);
-          if (!gateway) continue;
-          const gatewayRight = gatewayMove.newX + (gateway.width ?? 50);
-          const downstreamTargets = edgeMap.get(gatewayId) || [];
-          for (const targetId of downstreamTargets) {
-            if (!mainFlowNodes.has(targetId)) continue;
-            const targetNode = nodeMap.get(targetId);
-            if (!targetNode) continue;
-            const newX = gatewayRight + 50;
-            const currentX = targetNode.x ?? 0;
-            if (newX > currentX) {
-              targetNode.x = newX;
-              gatewayMoves.set(targetId, {
-                newY: targetNode.y ?? 0,
-                offset: 0,
-                newX
-              });
-              if (isDebugEnabled()) {
-                console.log(`[BPMN] Propagating gateway movement to ${targetId}: x ${currentX} -> ${newX}`);
-              }
-              this.propagateDownstreamX(targetId, newX, targetNode.width ?? 100, nodeMap, edgeMap, mainFlowNodes, gatewayMoves);
-            }
-          }
-        }
-      }
-      /**
-       * Recursively propagate X movement to downstream main flow nodes
-       */
-      propagateDownstreamX(sourceId, sourceX, sourceWidth, nodeMap, edgeMap, mainFlowNodes, moves) {
-        const targets = edgeMap.get(sourceId) || [];
-        const sourceRight = sourceX + sourceWidth;
-        for (const targetId of targets) {
-          if (!mainFlowNodes.has(targetId)) continue;
-          if (moves.has(targetId)) continue;
-          const targetNode = nodeMap.get(targetId);
-          if (!targetNode) continue;
-          const newX = sourceRight + 50;
-          const currentX = targetNode.x ?? 0;
-          if (newX > currentX) {
-            targetNode.x = newX;
-            moves.set(targetId, {
-              newY: targetNode.y ?? 0,
-              offset: 0,
-              newX
-            });
-            if (isDebugEnabled()) {
-              console.log(`[BPMN] Propagating X to ${targetId}: x ${currentX} -> ${newX}`);
-            }
-            this.propagateDownstreamX(targetId, newX, targetNode.width ?? 100, nodeMap, edgeMap, mainFlowNodes, moves);
-          }
-        }
-      }
-    };
-  }
-});
-
 // src/layout/elk-layouter.ts
 var import_elkjs, ElkLayouter;
 var init_elk_layouter = __esm({
@@ -4602,48 +4323,41 @@ var init_elk_layouter = __esm({
     init_cjs_shims();
     import_elkjs = __toESM(require("elkjs"));
     init_size_calculator();
-    init_edge_fixer();
     init_boundary_event();
     init_artifact_positioner();
     init_group_positioner();
     init_lane_arranger();
     init_pool_arranger();
-    init_gateway_edge_adjuster();
+    init_compactor();
     init_elk_graph_preparer();
     init_result_merger();
-    init_main_flow_normalizer();
-    init_gateway_propagator();
     init_debug();
     ElkLayouter = class {
       elk;
       userOptions;
+      enableCompaction;
       sizeCalculator;
-      edgeFixer;
       boundaryEventHandler;
       artifactPositioner;
       groupPositioner;
       laneArranger;
       poolArranger;
-      gatewayEdgeAdjuster;
+      compactor;
       graphPreparer;
       resultMerger;
-      mainFlowNormalizer;
-      gatewayPropagator;
       constructor(options) {
         this.elk = new import_elkjs.default();
         this.userOptions = options?.elkOptions ?? {};
+        this.enableCompaction = options?.enableCompaction ?? false;
         this.sizeCalculator = new SizeCalculator();
-        this.edgeFixer = new EdgeFixer();
         this.boundaryEventHandler = new BoundaryEventHandler();
         this.artifactPositioner = new ArtifactPositioner();
         this.groupPositioner = new GroupPositioner();
         this.laneArranger = new LaneArranger();
         this.poolArranger = new PoolArranger();
-        this.gatewayEdgeAdjuster = new GatewayEdgeAdjuster();
+        this.compactor = new Compactor();
         this.graphPreparer = new ElkGraphPreparer();
         this.resultMerger = new ResultMerger();
-        this.mainFlowNormalizer = new MainFlowNormalizer();
-        this.gatewayPropagator = new GatewayPropagator();
       }
       /**
        * Run ELK layout on the graph
@@ -4657,24 +4371,14 @@ var init_elk_layouter = __esm({
         const groupInfo = this.groupPositioner.collectInfo(sizedGraph);
         const elkGraph = this.graphPreparer.prepare(sizedGraph, this.userOptions, boundaryEventTargetIds);
         const layoutedElkGraph = await this.elk.layout(elkGraph);
-        const mainFlowNodes = this.graphPreparer.identifyMainFlowNodes(sizedGraph, boundaryEventTargetIds);
-        this.mainFlowNormalizer.normalize(layoutedElkGraph, mainFlowNodes, boundaryEventTargetIds, sizedGraph);
-        const movedNodes = this.boundaryEventHandler.identifyNodesToMove(layoutedElkGraph, boundaryEventInfo, sizedGraph, isDebugEnabled());
+        const movedNodes = this.boundaryEventHandler.identifyNodesToMove(
+          layoutedElkGraph,
+          boundaryEventInfo,
+          sizedGraph,
+          isDebugEnabled()
+        );
         if (movedNodes.size > 0) {
           this.boundaryEventHandler.applyNodeMoves(layoutedElkGraph, movedNodes);
-          const gatewayMoves = this.boundaryEventHandler.repositionConvergingGateways(
-            layoutedElkGraph,
-            movedNodes,
-            boundaryEventInfo,
-            isDebugEnabled()
-          );
-          if (gatewayMoves.size > 0) {
-            this.boundaryEventHandler.applyNodeMoves(layoutedElkGraph, gatewayMoves);
-            this.gatewayPropagator.propagate(layoutedElkGraph, gatewayMoves, mainFlowNodes);
-          }
-          for (const [id, move] of gatewayMoves) {
-            movedNodes.set(id, move);
-          }
           this.boundaryEventHandler.recalculateEdgesForMovedNodes(layoutedElkGraph, movedNodes, boundaryEventInfo);
         }
         this.artifactPositioner.reposition(layoutedElkGraph, artifactInfo);
@@ -4682,7 +4386,9 @@ var init_elk_layouter = __esm({
         this.poolArranger.rearrange(layoutedElkGraph, sizedGraph);
         this.groupPositioner.reposition(layoutedElkGraph, groupInfo, sizedGraph);
         this.artifactPositioner.recalculateWithObstacleAvoidance(layoutedElkGraph, artifactInfo);
-        this.edgeFixer.fix(layoutedElkGraph);
+        if (this.enableCompaction) {
+          this.compactor.compact(layoutedElkGraph);
+        }
         this.updateContainerBounds(layoutedElkGraph);
         return this.resultMerger.merge(sizedGraph, layoutedElkGraph);
       }
@@ -4731,6 +4437,158 @@ var init_elk_layouter = __esm({
   }
 });
 
+// src/layout/tree/tree-layouter.ts
+var init_tree_layouter = __esm({
+  "src/layout/tree/tree-layouter.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/layout/tree/index.ts
+var init_tree = __esm({
+  "src/layout/tree/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_tree_layouter();
+  }
+});
+
+// src/layout/edge-routing/pathfinding-router.ts
+var import_pathfinding;
+var init_pathfinding_router = __esm({
+  "src/layout/edge-routing/pathfinding-router.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_pathfinding = __toESM(require("pathfinding"));
+  }
+});
+
+// src/layout/edge-routing/edge-fixer.ts
+var init_edge_fixer = __esm({
+  "src/layout/edge-routing/edge-fixer.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_geometry_utils();
+    init_pathfinding_router();
+    init_debug();
+  }
+});
+
+// src/layout/edge-routing/gateway-endpoint-adjuster.ts
+function adjustGatewayEndpoint(endpoint, adjacentPoint, gatewayBounds, isSource) {
+  const gatewayCenterX = gatewayBounds.x + gatewayBounds.width / 2;
+  const gatewayCenterY = gatewayBounds.y + gatewayBounds.height / 2;
+  const tolerance = 1;
+  if (isDebugEnabled()) {
+    console.log(`[BPMN] adjustGatewayEndpoint: isSource=${isSource}`);
+    console.log(`  endpoint: (${endpoint.x}, ${endpoint.y})`);
+    console.log(`  gatewayBounds: x=${gatewayBounds.x}, y=${gatewayBounds.y}, w=${gatewayBounds.width}, h=${gatewayBounds.height}`);
+    console.log(`  gatewayCenter: (${gatewayCenterX}, ${gatewayCenterY})`);
+    console.log(`  right edge x: ${gatewayBounds.x + gatewayBounds.width}`);
+  }
+  const leftCorner = { x: gatewayBounds.x, y: gatewayCenterY };
+  const rightCorner = { x: gatewayBounds.x + gatewayBounds.width, y: gatewayCenterY };
+  const topCorner = { x: gatewayCenterX, y: gatewayBounds.y };
+  const bottomCorner = { x: gatewayCenterX, y: gatewayBounds.y + gatewayBounds.height };
+  if (Math.abs(endpoint.x - gatewayBounds.x) < tolerance && Math.abs(endpoint.y - gatewayCenterY) < tolerance) {
+    if (isDebugEnabled()) console.log(`  -> Already at LEFT corner, no adjustment`);
+    return endpoint;
+  }
+  if (Math.abs(endpoint.x - (gatewayBounds.x + gatewayBounds.width)) < tolerance && Math.abs(endpoint.y - gatewayCenterY) < tolerance) {
+    if (isDebugEnabled()) console.log(`  -> Already at RIGHT corner, no adjustment`);
+    return endpoint;
+  }
+  if (Math.abs(endpoint.y - gatewayBounds.y) < tolerance && Math.abs(endpoint.x - gatewayCenterX) < tolerance) {
+    if (isDebugEnabled()) console.log(`  -> Already at TOP corner, no adjustment`);
+    return endpoint;
+  }
+  if (Math.abs(endpoint.y - (gatewayBounds.y + gatewayBounds.height)) < tolerance && Math.abs(endpoint.x - gatewayCenterX) < tolerance) {
+    if (isDebugEnabled()) console.log(`  -> Already at BOTTOM corner, no adjustment`);
+    return endpoint;
+  }
+  if (isDebugEnabled()) {
+    console.log(`  -> NOT at corner, will adjust`);
+  }
+  const result = calculateDiamondIntersection(
+    endpoint,
+    gatewayBounds,
+    gatewayCenterX,
+    gatewayCenterY,
+    isSource,
+    adjacentPoint
+  );
+  if (isDebugEnabled()) {
+    console.log(`  -> Adjusted to: (${result.x}, ${result.y})`);
+  }
+  return result;
+}
+function calculateDiamondIntersection(endpoint, gatewayBounds, gatewayCenterX, gatewayCenterY, isSource, adjacentPoint) {
+  const tolerance = 1;
+  const leftCorner = { x: gatewayBounds.x, y: gatewayCenterY };
+  const rightCorner = { x: gatewayBounds.x + gatewayBounds.width, y: gatewayCenterY };
+  const topCorner = { x: gatewayCenterX, y: gatewayBounds.y };
+  const bottomCorner = { x: gatewayCenterX, y: gatewayBounds.y + gatewayBounds.height };
+  const isOnLeftEdge = Math.abs(endpoint.x - gatewayBounds.x) < tolerance;
+  const isOnRightEdge = Math.abs(endpoint.x - (gatewayBounds.x + gatewayBounds.width)) < tolerance;
+  const isOnTopEdge = Math.abs(endpoint.y - gatewayBounds.y) < tolerance;
+  const isOnBottomEdge = Math.abs(endpoint.y - (gatewayBounds.y + gatewayBounds.height)) < tolerance;
+  const halfWidth = gatewayBounds.width / 2;
+  const halfHeight = gatewayBounds.height / 2;
+  if (isOnLeftEdge || isOnRightEdge) {
+    const yDistFromCenter = Math.abs(endpoint.y - gatewayCenterY);
+    if (yDistFromCenter >= halfHeight) {
+      return isOnLeftEdge ? leftCorner : rightCorner;
+    }
+    const xOffsetFromCenter = halfWidth * (1 - yDistFromCenter / halfHeight);
+    const intersectX = isOnLeftEdge ? gatewayCenterX - xOffsetFromCenter : gatewayCenterX + xOffsetFromCenter;
+    return { x: intersectX, y: endpoint.y };
+  }
+  if (isOnTopEdge || isOnBottomEdge) {
+    const xDistFromCenter = Math.abs(endpoint.x - gatewayCenterX);
+    if (xDistFromCenter >= halfWidth) {
+      return isOnTopEdge ? topCorner : bottomCorner;
+    }
+    const yOffsetFromCenter = halfHeight * (1 - xDistFromCenter / halfWidth);
+    const intersectY = isOnTopEdge ? gatewayCenterY - yOffsetFromCenter : gatewayCenterY + yOffsetFromCenter;
+    return { x: endpoint.x, y: intersectY };
+  }
+  const dx = isSource ? adjacentPoint.x - endpoint.x : endpoint.x - adjacentPoint.x;
+  const dy = isSource ? adjacentPoint.y - endpoint.y : endpoint.y - adjacentPoint.y;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    if (isSource) {
+      return dx > 0 ? rightCorner : leftCorner;
+    } else {
+      return dx > 0 ? leftCorner : rightCorner;
+    }
+  } else {
+    if (isSource) {
+      return dy > 0 ? bottomCorner : topCorner;
+    } else {
+      return dy > 0 ? topCorner : bottomCorner;
+    }
+  }
+}
+var init_gateway_endpoint_adjuster = __esm({
+  "src/layout/edge-routing/gateway-endpoint-adjuster.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_debug();
+  }
+});
+
+// src/layout/edge-routing/index.ts
+var init_edge_routing = __esm({
+  "src/layout/edge-routing/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_edge_fixer();
+    init_geometry_utils();
+    init_gateway_endpoint_adjuster();
+    init_pathfinding_router();
+  }
+});
+
 // src/layout/index.ts
 var init_layout = __esm({
   "src/layout/index.ts"() {
@@ -4739,6 +4597,9 @@ var init_layout = __esm({
     init_elk_layouter();
     init_default_options();
     init_size_calculator();
+    init_tree();
+    init_constraint();
+    init_edge_routing();
   }
 });
 
@@ -4971,119 +4832,6 @@ var init_lane_resolver = __esm({
   }
 });
 
-// src/layout/edge-routing/gateway-endpoint-adjuster.ts
-function adjustGatewayEndpoint(endpoint, adjacentPoint, gatewayBounds, isSource) {
-  const gatewayCenterX = gatewayBounds.x + gatewayBounds.width / 2;
-  const gatewayCenterY = gatewayBounds.y + gatewayBounds.height / 2;
-  const tolerance = 1;
-  if (isDebugEnabled()) {
-    console.log(`[BPMN] adjustGatewayEndpoint: isSource=${isSource}`);
-    console.log(`  endpoint: (${endpoint.x}, ${endpoint.y})`);
-    console.log(`  gatewayBounds: x=${gatewayBounds.x}, y=${gatewayBounds.y}, w=${gatewayBounds.width}, h=${gatewayBounds.height}`);
-    console.log(`  gatewayCenter: (${gatewayCenterX}, ${gatewayCenterY})`);
-    console.log(`  right edge x: ${gatewayBounds.x + gatewayBounds.width}`);
-  }
-  const leftCorner = { x: gatewayBounds.x, y: gatewayCenterY };
-  const rightCorner = { x: gatewayBounds.x + gatewayBounds.width, y: gatewayCenterY };
-  const topCorner = { x: gatewayCenterX, y: gatewayBounds.y };
-  const bottomCorner = { x: gatewayCenterX, y: gatewayBounds.y + gatewayBounds.height };
-  if (Math.abs(endpoint.x - gatewayBounds.x) < tolerance && Math.abs(endpoint.y - gatewayCenterY) < tolerance) {
-    if (isDebugEnabled()) console.log(`  -> Already at LEFT corner, no adjustment`);
-    return endpoint;
-  }
-  if (Math.abs(endpoint.x - (gatewayBounds.x + gatewayBounds.width)) < tolerance && Math.abs(endpoint.y - gatewayCenterY) < tolerance) {
-    if (isDebugEnabled()) console.log(`  -> Already at RIGHT corner, no adjustment`);
-    return endpoint;
-  }
-  if (Math.abs(endpoint.y - gatewayBounds.y) < tolerance && Math.abs(endpoint.x - gatewayCenterX) < tolerance) {
-    if (isDebugEnabled()) console.log(`  -> Already at TOP corner, no adjustment`);
-    return endpoint;
-  }
-  if (Math.abs(endpoint.y - (gatewayBounds.y + gatewayBounds.height)) < tolerance && Math.abs(endpoint.x - gatewayCenterX) < tolerance) {
-    if (isDebugEnabled()) console.log(`  -> Already at BOTTOM corner, no adjustment`);
-    return endpoint;
-  }
-  if (isDebugEnabled()) {
-    console.log(`  -> NOT at corner, will adjust`);
-  }
-  const result = calculateDiamondIntersection(
-    endpoint,
-    gatewayBounds,
-    gatewayCenterX,
-    gatewayCenterY,
-    isSource,
-    adjacentPoint
-  );
-  if (isDebugEnabled()) {
-    console.log(`  -> Adjusted to: (${result.x}, ${result.y})`);
-  }
-  return result;
-}
-function calculateDiamondIntersection(endpoint, gatewayBounds, gatewayCenterX, gatewayCenterY, isSource, adjacentPoint) {
-  const tolerance = 1;
-  const leftCorner = { x: gatewayBounds.x, y: gatewayCenterY };
-  const rightCorner = { x: gatewayBounds.x + gatewayBounds.width, y: gatewayCenterY };
-  const topCorner = { x: gatewayCenterX, y: gatewayBounds.y };
-  const bottomCorner = { x: gatewayCenterX, y: gatewayBounds.y + gatewayBounds.height };
-  const isOnLeftEdge = Math.abs(endpoint.x - gatewayBounds.x) < tolerance;
-  const isOnRightEdge = Math.abs(endpoint.x - (gatewayBounds.x + gatewayBounds.width)) < tolerance;
-  const isOnTopEdge = Math.abs(endpoint.y - gatewayBounds.y) < tolerance;
-  const isOnBottomEdge = Math.abs(endpoint.y - (gatewayBounds.y + gatewayBounds.height)) < tolerance;
-  const halfWidth = gatewayBounds.width / 2;
-  const halfHeight = gatewayBounds.height / 2;
-  if (isOnLeftEdge || isOnRightEdge) {
-    const yDistFromCenter = Math.abs(endpoint.y - gatewayCenterY);
-    if (yDistFromCenter >= halfHeight) {
-      return isOnLeftEdge ? leftCorner : rightCorner;
-    }
-    const xOffsetFromCenter = halfWidth * (1 - yDistFromCenter / halfHeight);
-    const intersectX = isOnLeftEdge ? gatewayCenterX - xOffsetFromCenter : gatewayCenterX + xOffsetFromCenter;
-    return { x: intersectX, y: endpoint.y };
-  }
-  if (isOnTopEdge || isOnBottomEdge) {
-    const xDistFromCenter = Math.abs(endpoint.x - gatewayCenterX);
-    if (xDistFromCenter >= halfWidth) {
-      return isOnTopEdge ? topCorner : bottomCorner;
-    }
-    const yOffsetFromCenter = halfHeight * (1 - xDistFromCenter / halfWidth);
-    const intersectY = isOnTopEdge ? gatewayCenterY - yOffsetFromCenter : gatewayCenterY + yOffsetFromCenter;
-    return { x: endpoint.x, y: intersectY };
-  }
-  const dx = isSource ? adjacentPoint.x - endpoint.x : endpoint.x - adjacentPoint.x;
-  const dy = isSource ? adjacentPoint.y - endpoint.y : endpoint.y - adjacentPoint.y;
-  if (Math.abs(dx) > Math.abs(dy)) {
-    if (isSource) {
-      return dx > 0 ? rightCorner : leftCorner;
-    } else {
-      return dx > 0 ? leftCorner : rightCorner;
-    }
-  } else {
-    if (isSource) {
-      return dy > 0 ? bottomCorner : topCorner;
-    } else {
-      return dy > 0 ? topCorner : bottomCorner;
-    }
-  }
-}
-var init_gateway_endpoint_adjuster = __esm({
-  "src/layout/edge-routing/gateway-endpoint-adjuster.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_debug();
-  }
-});
-
-// src/layout/edge-routing/index.ts
-var init_edge_routing = __esm({
-  "src/layout/edge-routing/index.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_edge_fixer();
-    init_geometry_utils();
-    init_gateway_endpoint_adjuster();
-  }
-});
-
 // src/transform/diagram-builder.ts
 var DiagramBuilder;
 var init_diagram_builder = __esm({
@@ -5101,10 +4849,13 @@ var init_diagram_builder = __esm({
       nodeOffsets = /* @__PURE__ */ new Map();
       // Map to track node BPMN metadata for gateway detection
       nodeBpmn = /* @__PURE__ */ new Map();
+      // List of already placed edge labels for collision detection
+      placedEdgeLabels = [];
       /**
        * Build the diagram model from a layouted graph
        */
       build(graph, definitions) {
+        this.placedEdgeLabels = [];
         this.boundaryEventPositions.clear();
         this.nodePositions.clear();
         this.nodeOffsets.clear();
@@ -5112,7 +4863,10 @@ var init_diagram_builder = __esm({
         const shapes = [];
         const edges = [];
         const mainElement = definitions.rootElements[0];
-        const planeElement = mainElement?.type === "collaboration" ? mainElement.id : mainElement?.id ?? graph.id;
+        if (!mainElement) {
+          throw new Error("Cannot create BPMN diagram: definitions.rootElements is empty. The graph must contain at least one process or collaboration.");
+        }
+        const planeElement = mainElement.type === "collaboration" ? mainElement.id : mainElement.id;
         for (const child of graph.children) {
           this.collectShapesAndEdges(child, shapes, edges);
         }
@@ -5145,11 +4899,16 @@ var init_diagram_builder = __esm({
           const absoluteY = offsetY + node.y;
           const nodeWidth = node.width ?? 100;
           const nodeHeight = node.height ?? 80;
+          let effectiveHeight = nodeHeight;
+          if (this.isEventType(node.bpmn?.type) && node.labels && node.labels.length > 0) {
+            const labelHeight = node.labels[0]?.height ?? 14;
+            effectiveHeight = nodeHeight + 4 + labelHeight;
+          }
           this.nodePositions.set(node.id, {
             x: absoluteX,
             y: absoluteY,
             width: nodeWidth,
-            height: nodeHeight
+            height: effectiveHeight
           });
           if (node.bpmn) {
             this.storeNodeBpmn(node.id, { type: node.bpmn.type });
@@ -5286,47 +5045,44 @@ var init_diagram_builder = __esm({
         if (node.bpmn?.type === "participant" || node.bpmn?.type === "lane") {
           shape.isHorizontal = true;
         }
-        if (node.labels && node.labels.length > 0) {
-          const label = node.labels[0];
-          if (!label) return shape;
-          const nodeWidth = node.width ?? 36;
-          const nodeHeight = node.height ?? 36;
-          if (this.isEventType(node.bpmn?.type)) {
-            const labelWidth = label.width ?? 100;
-            const labelHeight = label.height ?? 14;
-            shape.label = {
-              bounds: {
-                x: absoluteX + (nodeWidth - labelWidth) / 2,
-                y: absoluteY + nodeHeight + 4,
-                // 4px gap below the circle
-                width: labelWidth,
-                height: labelHeight
-              }
-            };
-          } else if (this.isGatewayType(node.bpmn?.type)) {
-            const labelWidth = label?.width ?? 100;
-            const labelText = node.bpmn?.name ?? label?.text ?? "";
-            const estimatedLines = this.estimateLabelLines(labelText, labelWidth);
-            const labelHeight = estimatedLines * 14;
-            shape.label = {
-              bounds: {
-                x: absoluteX + (nodeWidth - labelWidth) / 2,
-                y: absoluteY - labelHeight - 4,
-                // 4px gap above the diamond
-                width: labelWidth,
-                height: labelHeight
-              }
-            };
-          } else if (label?.x !== void 0 && label?.y !== void 0) {
-            shape.label = {
-              bounds: {
-                x: absoluteX + label.x,
-                y: absoluteY + label.y,
-                width: label?.width ?? 100,
-                height: label?.height ?? 20
-              }
-            };
-          }
+        const nodeWidth = node.width ?? 36;
+        const nodeHeight = node.height ?? 36;
+        const label = node.labels?.[0];
+        const labelText = node.bpmn?.name ?? label?.text ?? "";
+        if (this.isEventType(node.bpmn?.type) && labelText) {
+          const labelWidth = label?.width ?? 100;
+          const labelHeight = label?.height ?? 14;
+          shape.label = {
+            bounds: {
+              x: absoluteX + (nodeWidth - labelWidth) / 2,
+              y: absoluteY + nodeHeight + 4,
+              // 4px gap below the circle
+              width: labelWidth,
+              height: labelHeight
+            }
+          };
+        } else if (this.isGatewayType(node.bpmn?.type) && labelText) {
+          const labelWidth = label?.width ?? 100;
+          const estimatedLines = this.estimateLabelLines(labelText, labelWidth);
+          const labelHeight = estimatedLines * 14;
+          shape.label = {
+            bounds: {
+              x: absoluteX + (nodeWidth - labelWidth) / 2,
+              y: absoluteY - labelHeight - 4,
+              // 4px gap above the diamond
+              width: labelWidth,
+              height: labelHeight
+            }
+          };
+        } else if (label?.x !== void 0 && label?.y !== void 0) {
+          shape.label = {
+            bounds: {
+              x: absoluteX + label.x,
+              y: absoluteY + label.y,
+              width: label?.width ?? 100,
+              height: label?.height ?? 20
+            }
+          };
         }
         return shape;
       }
@@ -5420,6 +5176,13 @@ var init_diagram_builder = __esm({
           }
         }
         this.ensureOrthogonalWaypoints(waypoints);
+        this.ensurePerpendicularEndpoints(
+          waypoints,
+          sourceId,
+          targetId,
+          sourceIsGateway,
+          targetIsGateway
+        );
         const edgeModel = {
           id: `${edge.id}_di`,
           bpmnElement: edge.id,
@@ -5429,7 +5192,19 @@ var init_diagram_builder = __esm({
           const label = edge.labels[0];
           const labelWidth = label?.width ?? 50;
           const labelHeight = label?.height ?? 14;
-          const labelPos = this.calculateEdgeLabelPosition(waypoints, labelWidth, labelHeight);
+          const labelPos = this.calculateSmartLabelPosition(
+            waypoints,
+            labelWidth,
+            labelHeight,
+            sourceId,
+            targetId
+          );
+          this.placedEdgeLabels.push({
+            x: labelPos.x,
+            y: labelPos.y,
+            width: labelWidth,
+            height: labelHeight
+          });
           edgeModel.label = {
             bounds: {
               x: labelPos.x,
@@ -5442,49 +5217,137 @@ var init_diagram_builder = __esm({
         return edgeModel;
       }
       /**
-       * Calculate label position centered on the edge
-       * Places label at the midpoint of the edge, offset above the line
+       * Calculate smart label position on the edge
+       * Strategy:
+       * 1. Find the longest segment of the edge (best visibility)
+       * 2. Place label at the midpoint of that segment
+       * 3. Offset based on segment direction, avoiding overlap with source/target nodes
        */
-      calculateEdgeLabelPosition(waypoints, labelWidth, labelHeight) {
+      calculateSmartLabelPosition(waypoints, labelWidth, labelHeight, sourceId, targetId) {
         if (waypoints.length < 2) {
           return { x: 0, y: 0 };
         }
-        const totalLength = calculatePathLength(waypoints);
-        const halfLength = totalLength / 2;
-        let accumulatedLength = 0;
+        const sourcePos = sourceId ? this.nodePositions.get(sourceId) : void 0;
+        const targetPos = targetId ? this.nodePositions.get(targetId) : void 0;
+        let bestSegmentIndex = -1;
+        let bestSegmentLength = 0;
         for (let i = 0; i < waypoints.length - 1; i++) {
           const wpCurrent = waypoints[i];
           const wpNext = waypoints[i + 1];
           if (!wpCurrent || !wpNext) continue;
-          const segmentLength = distance(wpCurrent, wpNext);
-          const nextAccumulated = accumulatedLength + segmentLength;
-          if (nextAccumulated >= halfLength) {
-            const ratio = (halfLength - accumulatedLength) / segmentLength;
-            const midX = wpCurrent.x + (wpNext.x - wpCurrent.x) * ratio;
-            const midY = wpCurrent.y + (wpNext.y - wpCurrent.y) * ratio;
-            const dx = wpNext.x - wpCurrent.x;
-            const dy = wpNext.y - wpCurrent.y;
-            if (Math.abs(dy) < Math.abs(dx)) {
-              return {
-                x: midX - labelWidth / 2,
-                y: midY - labelHeight - 4
-                // 4px above the line
-              };
-            } else {
-              return {
-                x: midX - labelWidth - 4,
-                // 4px to the left
-                y: midY - labelHeight / 2
-              };
+          const segmentLength2 = distance(wpCurrent, wpNext);
+          if (segmentLength2 < 30) continue;
+          const midX2 = (wpCurrent.x + wpNext.x) / 2;
+          const midY2 = (wpCurrent.y + wpNext.y) / 2;
+          const tooCloseToSource = sourcePos && this.isPointNearNode(midX2, midY2, sourcePos, 20);
+          const tooCloseToTarget = targetPos && this.isPointNearNode(midX2, midY2, targetPos, 20);
+          if (!tooCloseToSource && !tooCloseToTarget && segmentLength2 > bestSegmentLength) {
+            bestSegmentLength = segmentLength2;
+            bestSegmentIndex = i;
+          }
+        }
+        if (bestSegmentIndex < 0) {
+          for (let i = 0; i < waypoints.length - 1; i++) {
+            const wpCurrent = waypoints[i];
+            const wpNext = waypoints[i + 1];
+            if (!wpCurrent || !wpNext) continue;
+            const segmentLength2 = distance(wpCurrent, wpNext);
+            if (segmentLength2 > bestSegmentLength) {
+              bestSegmentLength = segmentLength2;
+              bestSegmentIndex = i;
+            }
+          }
+        }
+        if (bestSegmentIndex < 0) {
+          bestSegmentIndex = 0;
+        }
+        const wpStart = waypoints[bestSegmentIndex];
+        const wpEnd = waypoints[bestSegmentIndex + 1];
+        if (!wpStart || !wpEnd) {
+          return { x: 0, y: 0 };
+        }
+        const midX = (wpStart.x + wpEnd.x) / 2;
+        const midY = (wpStart.y + wpEnd.y) / 2;
+        const dx = wpEnd.x - wpStart.x;
+        const dy = wpEnd.y - wpStart.y;
+        const isHorizontal = Math.abs(dx) > Math.abs(dy);
+        const segmentLength = Math.sqrt(dx * dx + dy * dy);
+        const offset = 5;
+        if (isHorizontal) {
+          let labelX = midX - labelWidth / 2;
+          let labelY = midY - labelHeight - offset;
+          const labelBounds = { x: labelX, y: labelY, width: labelWidth, height: labelHeight };
+          if (this.labelOverlapsAnyNode(labelBounds)) {
+            labelY = midY + offset;
+          }
+          return { x: labelX, y: labelY };
+        } else {
+          const positions = segmentLength > 80 ? [0.35, 0.5, 0.65, 0.2, 0.8, 0.15, 0.85] : [0.5];
+          for (const ratio of positions) {
+            const testY = wpStart.y + (wpEnd.y - wpStart.y) * ratio - labelHeight / 2;
+            const boundsRight = { x: midX + offset, y: testY, width: labelWidth, height: labelHeight };
+            if (!this.labelOverlapsAnyNode(boundsRight) && !this.labelOverlapsAnyEdgeLabel(boundsRight)) {
+              return { x: midX + offset, y: testY };
+            }
+            const boundsLeft = { x: midX - labelWidth - offset, y: testY, width: labelWidth, height: labelHeight };
+            if (!this.labelOverlapsAnyNode(boundsLeft) && !this.labelOverlapsAnyEdgeLabel(boundsLeft)) {
+              return { x: midX - labelWidth - offset, y: testY };
+            }
+          }
+          let labelX = midX + offset;
+          let labelY = midY - labelHeight / 2;
+          for (let yOffset = 0; yOffset <= 100; yOffset += 20) {
+            for (const side of [1, -1]) {
+              for (const yDir of [0, 1, -1]) {
+                const testX = side === 1 ? midX + offset : midX - labelWidth - offset;
+                const testY = labelY + yDir * yOffset;
+                const testBounds = { x: testX, y: testY, width: labelWidth, height: labelHeight };
+                if (!this.labelOverlapsAnyEdgeLabel(testBounds)) {
+                  if (!this.labelOverlapsAnyNode(testBounds)) {
+                    return { x: testX, y: testY };
+                  }
+                  labelX = testX;
+                  labelY = testY;
+                }
+              }
             }
           }
-          accumulatedLength = nextAccumulated;
+          return { x: labelX, y: labelY };
         }
-        const lastPoint = waypoints[waypoints.length - 1];
-        return {
-          x: (lastPoint?.x ?? 0) - labelWidth / 2,
-          y: (lastPoint?.y ?? 0) - labelHeight - 4
-        };
+      }
+      /**
+       * Check if a point is near a node (within padding distance)
+       */
+      isPointNearNode(x, y, nodePos, padding) {
+        return x >= nodePos.x - padding && x <= nodePos.x + nodePos.width + padding && y >= nodePos.y - padding && y <= nodePos.y + nodePos.height + padding;
+      }
+      /**
+       * Check if a label bounds overlaps with any node
+       */
+      labelOverlapsAnyNode(labelBounds) {
+        for (const nodePos of this.nodePositions.values()) {
+          if (this.boundsOverlap(labelBounds, nodePos)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Check if a label bounds overlaps with any already placed edge label
+       */
+      labelOverlapsAnyEdgeLabel(labelBounds) {
+        for (const placedLabel of this.placedEdgeLabels) {
+          if (this.boundsOverlap(labelBounds, placedLabel)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Check if two rectangles overlap
+       */
+      boundsOverlap(a, b) {
+        return !(a.x + a.width < b.x || b.x + b.width < a.x || a.y + a.height < b.y || b.y + b.height < a.y);
       }
       /**
        * Ensure all waypoint segments are orthogonal (horizontal or vertical)
@@ -5516,6 +5379,135 @@ var init_diagram_builder = __esm({
           }
         }
       }
+      /**
+       * Detect which side of a node a point is connected to.
+       * Returns 'top', 'bottom', 'left', 'right', or 'unknown'.
+       *
+       * First tries exact match with tolerance, then falls back to closest edge detection.
+       */
+      detectConnectionSide(point, nodeBounds, _isGateway = false) {
+        const exactTolerance = 3;
+        const maxTolerance = 15;
+        const nodeTop = nodeBounds.y;
+        const nodeBottom = nodeBounds.y + nodeBounds.height;
+        const nodeLeft = nodeBounds.x;
+        const nodeRight = nodeBounds.x + nodeBounds.width;
+        if (Math.abs(point.y - nodeTop) <= exactTolerance) return "top";
+        if (Math.abs(point.y - nodeBottom) <= exactTolerance) return "bottom";
+        if (Math.abs(point.x - nodeLeft) <= exactTolerance) return "left";
+        if (Math.abs(point.x - nodeRight) <= exactTolerance) return "right";
+        const distToTop = Math.abs(point.y - nodeTop);
+        const distToBottom = Math.abs(point.y - nodeBottom);
+        const distToLeft = Math.abs(point.x - nodeLeft);
+        const distToRight = Math.abs(point.x - nodeRight);
+        const minDist = Math.min(distToTop, distToBottom, distToLeft, distToRight);
+        if (minDist > maxTolerance) return "unknown";
+        if (minDist === distToTop) return "top";
+        if (minDist === distToBottom) return "bottom";
+        if (minDist === distToLeft) return "left";
+        return "right";
+      }
+      /**
+       * Detect connection side for gateway based on edge direction.
+       * When point is on a diagonal edge of the diamond, use the adjacent point to determine direction.
+       */
+      detectGatewayConnectionSide(point, adjacentPoint, nodeBounds, isSource) {
+        const centerX = nodeBounds.x + nodeBounds.width / 2;
+        const centerY = nodeBounds.y + nodeBounds.height / 2;
+        const nodeTop = nodeBounds.y;
+        const nodeBottom = nodeBounds.y + nodeBounds.height;
+        const nodeLeft = nodeBounds.x;
+        const nodeRight = nodeBounds.x + nodeBounds.width;
+        const distToTopCorner = Math.abs(point.x - centerX) + Math.abs(point.y - nodeTop);
+        const distToBottomCorner = Math.abs(point.x - centerX) + Math.abs(point.y - nodeBottom);
+        const distToLeftCorner = Math.abs(point.x - nodeLeft) + Math.abs(point.y - centerY);
+        const distToRightCorner = Math.abs(point.x - nodeRight) + Math.abs(point.y - centerY);
+        const minDist = Math.min(distToTopCorner, distToBottomCorner, distToLeftCorner, distToRightCorner);
+        const tolerance = 5;
+        if (distToTopCorner <= minDist + tolerance && distToTopCorner < distToBottomCorner - tolerance && distToTopCorner < distToLeftCorner - tolerance && distToTopCorner < distToRightCorner - tolerance) {
+          return "top";
+        }
+        if (distToBottomCorner <= minDist + tolerance && distToBottomCorner < distToTopCorner - tolerance && distToBottomCorner < distToLeftCorner - tolerance && distToBottomCorner < distToRightCorner - tolerance) {
+          return "bottom";
+        }
+        if (distToLeftCorner <= minDist + tolerance && distToLeftCorner < distToTopCorner - tolerance && distToLeftCorner < distToBottomCorner - tolerance && distToLeftCorner < distToRightCorner - tolerance) {
+          return "left";
+        }
+        if (distToRightCorner <= minDist + tolerance && distToRightCorner < distToTopCorner - tolerance && distToRightCorner < distToBottomCorner - tolerance && distToRightCorner < distToLeftCorner - tolerance) {
+          return "right";
+        }
+        const dx = isSource ? adjacentPoint.x - point.x : point.x - adjacentPoint.x;
+        const dy = isSource ? adjacentPoint.y - point.y : point.y - adjacentPoint.y;
+        if (Math.abs(dx) > Math.abs(dy)) {
+          return dx > 0 ? "right" : "left";
+        } else {
+          return dy > 0 ? "bottom" : "top";
+        }
+      }
+      /**
+       * Ensure edge endpoints connect perpendicular to node borders.
+       * - Connection to top/bottom: last segment must be vertical (same x)
+       * - Connection to left/right: last segment must be horizontal (same y)
+       *
+       * When inserting bend points, we also update the previous waypoint to maintain
+       * orthogonality (no diagonal lines).
+       */
+      ensurePerpendicularEndpoints(waypoints, sourceId, targetId, sourceIsGateway = false, targetIsGateway = false) {
+        if (waypoints.length < 2) return;
+        const tolerance = 2;
+        const minBendOffset = 15;
+        if (targetId) {
+          const targetPos = this.nodePositions.get(targetId);
+          if (targetPos) {
+            const lastIdx = waypoints.length - 1;
+            const endPoint = waypoints[lastIdx];
+            const prevPoint = waypoints[lastIdx - 1];
+            if (endPoint && prevPoint) {
+              const side = targetIsGateway ? this.detectGatewayConnectionSide(endPoint, prevPoint, targetPos, false) : this.detectConnectionSide(endPoint, targetPos, false);
+              if (side === "top" || side === "bottom") {
+                if (Math.abs(endPoint.x - prevPoint.x) > tolerance) {
+                  const bendY = side === "top" ? endPoint.y - minBendOffset : endPoint.y + minBendOffset;
+                  const bendPoint = { x: endPoint.x, y: bendY };
+                  waypoints.splice(lastIdx, 0, bendPoint);
+                  prevPoint.y = bendY;
+                }
+              } else if (side === "left" || side === "right") {
+                if (Math.abs(endPoint.y - prevPoint.y) > tolerance) {
+                  const bendX = side === "left" ? endPoint.x - minBendOffset : endPoint.x + minBendOffset;
+                  const bendPoint = { x: bendX, y: endPoint.y };
+                  waypoints.splice(lastIdx, 0, bendPoint);
+                  prevPoint.x = bendX;
+                }
+              }
+            }
+          }
+        }
+        if (sourceId) {
+          const sourcePos = this.nodePositions.get(sourceId) ?? this.boundaryEventPositions.get(sourceId);
+          if (sourcePos) {
+            const startPoint = waypoints[0];
+            const nextPoint = waypoints[1];
+            if (startPoint && nextPoint) {
+              const side = sourceIsGateway ? this.detectGatewayConnectionSide(startPoint, nextPoint, sourcePos, true) : this.detectConnectionSide(startPoint, sourcePos, false);
+              if (side === "top" || side === "bottom") {
+                if (Math.abs(startPoint.x - nextPoint.x) > tolerance) {
+                  const bendY = side === "top" ? startPoint.y - minBendOffset : startPoint.y + minBendOffset;
+                  const bendPoint = { x: startPoint.x, y: bendY };
+                  waypoints.splice(1, 0, bendPoint);
+                  nextPoint.y = bendY;
+                }
+              } else if (side === "left" || side === "right") {
+                if (Math.abs(startPoint.y - nextPoint.y) > tolerance) {
+                  const bendX = side === "left" ? startPoint.x - minBendOffset : startPoint.x + minBendOffset;
+                  const bendPoint = { x: bendX, y: startPoint.y };
+                  waypoints.splice(1, 0, bendPoint);
+                  nextPoint.x = bendX;
+                }
+              }
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -5570,7 +5562,10 @@ var init_model_builder = __esm({
           rootElements: []
         };
         for (const child of graph.children) {
-          const bpmnType = child.bpmn.type;
+          const bpmnType = child.bpmn?.type;
+          if (!bpmnType) {
+            throw new Error(`Invalid graph child: missing bpmn.type property for node ${child.id}`);
+          }
           if (bpmnType === "collaboration") {
             definitions.rootElements.push(this.buildCollaboration(child));
             const collab = child;
@@ -5584,8 +5579,13 @@ var init_model_builder = __esm({
             }
           } else if (bpmnType === "process") {
             definitions.rootElements.push(this.buildProcess(child));
+          } else {
+            throw new Error(`Invalid top-level element type: "${bpmnType}". Only "process" or "collaboration" are allowed at the top level.`);
           }
         }
+        if (definitions.rootElements.length === 0) {
+          throw new Error("Cannot create BPMN definitions: no valid process or collaboration found in the graph.");
+        }
         return definitions;
       }
       /**
@@ -6453,7 +6453,10 @@ var init_converter = __esm({
       modelBuilder;
       xmlGenerator;
       constructor(options) {
-        this.layouter = new ElkLayouter({ elkOptions: options?.elkOptions });
+        this.layouter = new ElkLayouter({
+          elkOptions: options?.elkOptions,
+          enableCompaction: options?.enableCompaction
+        });
         this.modelBuilder = new ModelBuilder();
         this.xmlGenerator = new BpmnXmlGenerator();
       }