bpmn-elk-layout 1.0.1 → 1.1.2

package/dist/index.node.js

@@ -304,7 +304,11 @@ function lineIntersection(p1, p2, p3, p4) {
 }
 
 // src/utils/debug.ts
-var DEBUG = typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
+var cliMode = false;
+function isDebugEnabled() {
+  if (cliMode) return false;
+  return typeof process !== "undefined" && process.env?.["DEBUG"] === "true";
+}
 
 // src/layout/edge-routing/edge-fixer.ts
 var EdgeFixer = class {
@@ -337,7 +341,7 @@ var EdgeFixer = class {
       const isFlowNode = flowNodePatterns.some((pattern) => pattern.test(id));
       const isPool = poolPatterns.some((pattern) => pattern.test(id));
       const bpmn = node.bpmn;
-      if (DEBUG && (id.includes("lane") || id.includes("pool") || id.includes("end_fast") || id.includes("gateway_fast"))) {
+      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}`);
       }
@@ -375,6 +379,10 @@ var EdgeFixer = class {
         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);
           }
         }
@@ -426,7 +434,7 @@ var EdgeFixer = class {
     }
     const targetPos = targetId ? nodePositions.get(targetId) : void 0;
     const sourcePos = sourceId ? nodePositions.get(sourceId) : void 0;
-    if (DEBUG && edge.id?.includes("back")) {
+    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}`);
@@ -435,7 +443,7 @@ var EdgeFixer = class {
       const lastWaypoint = waypoints[waypoints.length - 1];
       const secondLastWaypoint = waypoints[waypoints.length - 2];
       const isReturnEdge2 = targetPos.y + targetPos.height < sourcePos.y;
-      if (DEBUG && edge.id?.includes("back")) {
+      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})`);
@@ -455,7 +463,7 @@ var EdgeFixer = class {
       }
     }
     if (crossedNodes.length === 0) return;
-    if (DEBUG) {
+    if (isDebugEnabled()) {
       console.log(`[BPMN] Edge ${edge.id} crosses nodes: ${crossedNodes.join(", ")}`);
     }
     if (!sourcePos || !targetPos) return;
@@ -506,7 +514,7 @@ var EdgeFixer = class {
       y: bp.y - containerOffsetY
     }));
     section.bendPoints = relativeBendPoints.length > 0 ? relativeBendPoints : void 0;
-    if (DEBUG) {
+    if (isDebugEnabled()) {
       console.log(`[BPMN] Fixed edge ${edge.id} with ${relativeBendPoints.length} bend points`);
     }
   }
@@ -1296,7 +1304,8 @@ function applyNodeMoves(graph, movedNodes) {
 }
 
 // src/layout/post-processing/boundary-event/edge-recalculator.ts
-function recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo, debug = false) {
+function recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo) {
+  const debug = isDebugEnabled();
   const nodeMap = /* @__PURE__ */ new Map();
   const buildNodeMap2 = (node) => {
     nodeMap.set(node.id, node);
@@ -1373,7 +1382,8 @@ function recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo, deb
   };
   processEdges(graph);
 }
-function recalculateEdgeWithObstacleAvoidance(edge, source, target, obstacleIds, nodeMap, debug = false) {
+function recalculateEdgeWithObstacleAvoidance(edge, source, target, obstacleIds, nodeMap) {
+  const debug = isDebugEnabled();
   const sx = source.x ?? 0;
   const sy = source.y ?? 0;
   const sw = source.width ?? 100;
@@ -1594,8 +1604,8 @@ var BoundaryEventHandler = class {
   /**
    * Recalculate edge waypoints for edges connected to moved nodes
    */
-  recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo, debug = false) {
-    recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo, debug);
+  recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo) {
+    recalculateEdgesForMovedNodes(graph, movedNodes, boundaryEventInfo);
   }
 };
 
@@ -2482,7 +2492,7 @@ var LaneArranger = class {
       const targetId = edge.targets?.[0];
       const sourcePos = sourceId ? nodePositions.get(sourceId) : void 0;
       const targetPos = targetId ? nodePositions.get(targetId) : void 0;
-      if (DEBUG) {
+      if (isDebugEnabled()) {
         console.log(`[BPMN] recalculatePoolEdges ${edge.id}: source=${sourceId}, target=${targetId}`);
         console.log(`[BPMN]   sourcePos=${JSON.stringify(sourcePos)}`);
         console.log(`[BPMN]   targetPos=${JSON.stringify(targetPos)}`);
@@ -2492,18 +2502,26 @@ var LaneArranger = class {
         const startY = sourcePos.y + sourcePos.height / 2;
         const endX = targetPos.x;
         const endY = targetPos.y + targetPos.height / 2;
-        if (DEBUG) {
+        if (isDebugEnabled()) {
           console.log(`[BPMN]   startX=${startX}, startY=${startY}, endX=${endX}, endY=${endY}`);
         }
         const waypoints = [];
         waypoints.push({ x: startX, y: startY });
         if (Math.abs(startY - endY) > 10) {
-          const midX = (startX + endX) / 2;
+          const midX = this.findClearMidX(
+            startX,
+            endX,
+            startY,
+            endY,
+            sourceId,
+            targetId,
+            nodePositions
+          );
           waypoints.push({ x: midX, y: startY });
           waypoints.push({ x: midX, y: endY });
         }
         waypoints.push({ x: endX, y: endY });
-        if (DEBUG) {
+        if (isDebugEnabled()) {
           console.log(`[BPMN]   waypoints=${JSON.stringify(waypoints)}`);
         }
         edge._poolRelativeCoords = true;
@@ -2516,6 +2534,109 @@ var LaneArranger = class {
       }
     }
   }
+  /**
+   * 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)
+   */
+  findClearMidX(startX, endX, startY, endY, sourceId, targetId, nodePositions) {
+    const margin = 15;
+    const minY = Math.min(startY, endY);
+    const maxY = Math.max(startY, endY);
+    const rangeMinX = Math.min(startX, endX);
+    const rangeMaxX = Math.max(startX, endX);
+    if (isDebugEnabled()) {
+      console.log(`[BPMN]   findClearMidX: startX=${startX}, endX=${endX}, startY=${startY}, endY=${endY}`);
+    }
+    const allObstacles = [];
+    for (const [nodeId, pos] of nodePositions) {
+      if (nodeId === sourceId || nodeId === targetId) continue;
+      const nodeLeft = pos.x;
+      const nodeRight = pos.x + pos.width;
+      const nodeTop = pos.y;
+      const nodeBottom = pos.y + pos.height;
+      const xOverlap = nodeRight > rangeMinX && nodeLeft < rangeMaxX;
+      const yOverlapVertical = nodeBottom > minY && nodeTop < maxY;
+      const yContainsStartY = nodeTop <= startY && nodeBottom >= startY;
+      const yContainsEndY = nodeTop <= endY && nodeBottom >= endY;
+      if (xOverlap && (yOverlapVertical || yContainsStartY || yContainsEndY)) {
+        allObstacles.push({
+          x: nodeLeft,
+          y: nodeTop,
+          width: pos.width,
+          height: pos.height,
+          right: nodeRight,
+          bottom: nodeBottom,
+          id: nodeId
+        });
+        if (isDebugEnabled()) {
+          console.log(`[BPMN]   findClearMidX: obstacle ${nodeId}: x=[${nodeLeft}, ${nodeRight}], y=[${nodeTop}, ${nodeBottom}]`);
+        }
+      }
+    }
+    if (allObstacles.length === 0) {
+      return (startX + endX) / 2;
+    }
+    const isValidMidX = (midX) => {
+      for (const obs of allObstacles) {
+        const seg1MinX = Math.min(startX, midX);
+        const seg1MaxX = Math.max(startX, midX);
+        if (obs.y <= startY && obs.bottom >= startY && // Y range contains startY
+        obs.right > seg1MinX && obs.x < seg1MaxX) {
+          return false;
+        }
+        if (obs.x <= midX && obs.right >= midX && // X range contains midX
+        obs.bottom > minY && obs.y < maxY) {
+          return false;
+        }
+        const seg2MinX = Math.min(midX, endX);
+        const seg2MaxX = Math.max(midX, endX);
+        if (obs.y <= endY && obs.bottom >= endY && // Y range contains endY
+        obs.right > seg2MinX && obs.x < seg2MaxX) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const candidates = [];
+    candidates.push((startX + endX) / 2);
+    candidates.push(startX + margin);
+    candidates.push(endX - margin);
+    for (const obs of allObstacles) {
+      candidates.push(obs.x - margin);
+      candidates.push(obs.right + margin);
+    }
+    const simpleMidX = (startX + endX) / 2;
+    const validCandidates = candidates.filter((x) => x >= rangeMinX && x <= rangeMaxX).sort((a, b) => Math.abs(a - simpleMidX) - Math.abs(b - simpleMidX));
+    for (const candidate of validCandidates) {
+      if (isValidMidX(candidate)) {
+        if (isDebugEnabled()) {
+          console.log(`[BPMN]   findClearMidX: found valid position ${candidate}`);
+        }
+        return candidate;
+      }
+    }
+    const leftMost = Math.min(...allObstacles.map((o) => o.x)) - margin;
+    const rightMost = Math.max(...allObstacles.map((o) => o.right)) + margin;
+    if (leftMost >= rangeMinX && isValidMidX(leftMost)) {
+      if (isDebugEnabled()) {
+        console.log(`[BPMN]   findClearMidX: routing left of all obstacles at ${leftMost}`);
+      }
+      return leftMost;
+    }
+    if (rightMost <= rangeMaxX && isValidMidX(rightMost)) {
+      if (isDebugEnabled()) {
+        console.log(`[BPMN]   findClearMidX: routing right of all obstacles at ${rightMost}`);
+      }
+      return rightMost;
+    }
+    if (isDebugEnabled()) {
+      console.log(`[BPMN]   findClearMidX: no valid route found, using midpoint ${simpleMidX}`);
+    }
+    return simpleMidX;
+  }
 };
 
 // src/layout/post-processing/pool-arranger.ts
@@ -2596,7 +2717,7 @@ var PoolArranger = class {
       pool.y = currentY;
       if (isBlackBox) {
         pool.width = maxPoolWidth;
-        pool.height = pool.height ?? 60;
+        pool.height = 60;
       } else if (hasLanes) {
         pool.width = maxPoolWidth;
       } else {
@@ -3011,7 +3132,7 @@ var GatewayEdgeAdjuster = class {
     const gateways = /* @__PURE__ */ new Map();
     this.collectGateways(layoutedGraph, originalGraph, gateways, 0, 0);
     if (gateways.size === 0) return;
-    if (DEBUG) {
+    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})`);
@@ -3098,7 +3219,7 @@ var GatewayEdgeAdjuster = class {
     const section = edge.sections[0];
     const sourceId = edge.sources?.[0];
     const targetId = edge.targets?.[0];
-    if (DEBUG) {
+    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})`);
@@ -3110,7 +3231,7 @@ var GatewayEdgeAdjuster = class {
     }
     const targetGateway = targetId ? gateways.get(targetId) : void 0;
     if (targetGateway) {
-      if (DEBUG) {
+      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})`);
       }
@@ -3181,7 +3302,7 @@ var GatewayEdgeAdjuster = class {
           lastBend.x = newEnd.x;
         }
       }
-      if (DEBUG) {
+      if (isDebugEnabled()) {
         console.log(`[BPMN] GatewayEdgeAdjuster: Adjusted edge ${edge.id} endpoint from (${endX},${endY}) to (${targetCorner.x},${targetCorner.y})`);
       }
     } else {
@@ -3195,7 +3316,7 @@ var GatewayEdgeAdjuster = class {
           x: intersectionPoint.x - offsetX,
           y: intersectionPoint.y - offsetY
         };
-        if (DEBUG) {
+        if (isDebugEnabled()) {
           console.log(`[BPMN] GatewayEdgeAdjuster: Adjusted edge ${edge.id} endpoint to diamond intersection (${intersectionPoint.x},${intersectionPoint.y})`);
         }
       }
@@ -3455,7 +3576,7 @@ var ElkGraphPreparer = class {
     for (const startId of startEvents) {
       traverseMainFlow(startId);
     }
-    if (DEBUG) {
+    if (isDebugEnabled()) {
       console.log(`[BPMN] Main flow nodes: ${Array.from(mainFlowNodes).join(", ")}`);
     }
     return mainFlowNodes;
@@ -3790,7 +3911,7 @@ var ResultMerger = class {
     return originalEdges.map((origEdge) => {
       const layoutedEdge = layoutedEdgeMap.get(origEdge.id);
       if (layoutedEdge) {
-        if (DEBUG && layoutedEdge.sections?.[0]?.bendPoints?.length) {
+        if (isDebugEnabled() && layoutedEdge.sections?.[0]?.bendPoints?.length) {
           console.log(`[BPMN] Merge ${origEdge.id}: bendPoints=${JSON.stringify(layoutedEdge.sections[0].bendPoints)}`);
         }
         const mergedEdge = {
@@ -3928,7 +4049,7 @@ var MainFlowNormalizer = class {
       return;
     }
     const offsetY = currentMinY - TARGET_MAIN_FLOW_Y;
-    if (DEBUG) {
+    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(", ")}`);
@@ -3936,7 +4057,7 @@ var MainFlowNormalizer = class {
     for (const node of otherUpstreamNodes) {
       if (node.y !== void 0) {
         node.y -= offsetY;
-        if (DEBUG) {
+        if (isDebugEnabled()) {
           console.log(`[BPMN] Shifted upstream ${node.id} to y=${node.y}`);
         }
       }
@@ -3949,14 +4070,14 @@ var MainFlowNormalizer = class {
           const predecessorCenterY = predecessor.y + (predecessor.height ?? 80) / 2;
           const endNodeCenterY = (endNode.height ?? 36) / 2;
           endNode.y = predecessorCenterY - endNodeCenterY;
-          if (DEBUG) {
+          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 (DEBUG) {
+          if (isDebugEnabled()) {
             console.log(`[BPMN] Shifted upstream ${endNode.id} to y=${endNode.y} (no predecessor found)`);
           }
         }
@@ -3984,7 +4105,7 @@ var MainFlowNormalizer = class {
           const newY = prevBottom + MIN_SPACING;
           currNode.y = newY;
           adjustedEndEvents.set(currNode.id, newY);
-          if (DEBUG) {
+          if (isDebugEnabled()) {
             console.log(`[BPMN] Adjusted overlapping endEvent ${currNode.id} at x=${x}: y=${currNode.y}`);
           }
         }
@@ -4008,7 +4129,7 @@ var MainFlowNormalizer = class {
       for (const node of downstreamMainFlow) {
         if (node.y !== void 0) {
           node.y -= downstreamOffsetY;
-          if (DEBUG) {
+          if (isDebugEnabled()) {
             console.log(`[BPMN] Shifted downstream ${node.id} to y=${node.y}`);
           }
         }
@@ -4190,20 +4311,20 @@ var MainFlowNormalizer = class {
                     lastBend.y = newTargetY;
                     section.endPoint.y = newTargetY;
                     edgesWithAdjustedEndpoint.add(edge.id);
-                    if (DEBUG) {
+                    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 (DEBUG) {
+                    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 (DEBUG) {
+                  if (isDebugEnabled()) {
                     console.log(`[BPMN] Updated edge ${edge.id} endpoint to y=${newTargetY}`);
                   }
                 }
@@ -4317,7 +4438,7 @@ var GatewayPropagator = class {
             offset: 0,
             newX
           });
-          if (DEBUG) {
+          if (isDebugEnabled()) {
             console.log(`[BPMN] Propagating gateway movement to ${targetId}: x ${currentX} -> ${newX}`);
           }
           this.propagateDownstreamX(targetId, newX, targetNode.width ?? 100, nodeMap, edgeMap, mainFlowNodes, gatewayMoves);
@@ -4345,7 +4466,7 @@ var GatewayPropagator = class {
           offset: 0,
           newX
         });
-        if (DEBUG) {
+        if (isDebugEnabled()) {
           console.log(`[BPMN] Propagating X to ${targetId}: x ${currentX} -> ${newX}`);
         }
         this.propagateDownstreamX(targetId, newX, targetNode.width ?? 100, nodeMap, edgeMap, mainFlowNodes, moves);
@@ -4400,14 +4521,14 @@ var ElkLayouter = class {
     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, DEBUG);
+    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,
-        DEBUG
+        isDebugEnabled()
       );
       if (gatewayMoves.size > 0) {
         this.boundaryEventHandler.applyNodeMoves(layoutedElkGraph, gatewayMoves);
@@ -4416,7 +4537,7 @@ var ElkLayouter = class {
       for (const [id, move] of gatewayMoves) {
         movedNodes.set(id, move);
       }
-      this.boundaryEventHandler.recalculateEdgesForMovedNodes(layoutedElkGraph, movedNodes, boundaryEventInfo, DEBUG);
+      this.boundaryEventHandler.recalculateEdgesForMovedNodes(layoutedElkGraph, movedNodes, boundaryEventInfo);
     }
     this.artifactPositioner.reposition(layoutedElkGraph, artifactInfo);
     this.laneArranger.rearrange(layoutedElkGraph, sizedGraph);
@@ -4690,7 +4811,7 @@ function adjustGatewayEndpoint(endpoint, adjacentPoint, gatewayBounds, isSource)
   const gatewayCenterX = gatewayBounds.x + gatewayBounds.width / 2;
   const gatewayCenterY = gatewayBounds.y + gatewayBounds.height / 2;
   const tolerance = 1;
-  if (DEBUG) {
+  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}`);
@@ -4702,22 +4823,22 @@ function adjustGatewayEndpoint(endpoint, adjacentPoint, gatewayBounds, isSource)
   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 (DEBUG) console.log(`  -> Already at LEFT corner, no adjustment`);
+    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 (DEBUG) console.log(`  -> Already at RIGHT corner, no adjustment`);
+    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 (DEBUG) console.log(`  -> Already at TOP corner, no adjustment`);
+    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 (DEBUG) console.log(`  -> Already at BOTTOM corner, no adjustment`);
+    if (isDebugEnabled()) console.log(`  -> Already at BOTTOM corner, no adjustment`);
     return endpoint;
   }
-  if (DEBUG) {
+  if (isDebugEnabled()) {
     console.log(`  -> NOT at corner, will adjust`);
   }
   const result = calculateDiamondIntersection(
@@ -4728,7 +4849,7 @@ function adjustGatewayEndpoint(endpoint, adjacentPoint, gatewayBounds, isSource)
     isSource,
     adjacentPoint
   );
-  if (DEBUG) {
+  if (isDebugEnabled()) {
     console.log(`  -> Adjusted to: (${result.x}, ${result.y})`);
   }
   return result;
@@ -5033,7 +5154,7 @@ var DiagramBuilder = class {
     const targetIsGateway = this.isGatewayType(targetNode?.type);
     let waypoints = [];
     const hasPreCalculatedSections = edge.sections && edge.sections.length > 0 && edge.sections[0]?.bendPoints && edge.sections[0].bendPoints.length > 0;
-    if (DEBUG && bePosition) {
+    if (isDebugEnabled() && bePosition) {
       console.log(`[BPMN] buildEdge ${edge.id}: preCalculated=${hasPreCalculatedSections}`);
     }
     if (bePosition && targetPosition && !hasPreCalculatedSections) {
@@ -5108,6 +5229,7 @@ var DiagramBuilder = class {
         }
       }
     }
+    this.ensureOrthogonalWaypoints(waypoints);
     const edgeModel = {
       id: `${edge.id}_di`,
       bpmnElement: edge.id,
@@ -5174,6 +5296,36 @@ var DiagramBuilder = class {
       y: (lastPoint?.y ?? 0) - labelHeight - 4
     };
   }
+  /**
+   * Ensure all waypoint segments are orthogonal (horizontal or vertical)
+   * If a diagonal segment is found, insert intermediate bend points to create
+   * an L-shaped orthogonal path.
+   *
+   * Strategy: For diagonal segments, we use "horizontal first" - go horizontally
+   * to the target X, then vertically to the target Y.
+   */
+  ensureOrthogonalWaypoints(waypoints) {
+    if (waypoints.length < 2) return;
+    const tolerance = 1;
+    let i = 0;
+    while (i < waypoints.length - 1) {
+      const current = waypoints[i];
+      const next = waypoints[i + 1];
+      if (!current || !next) {
+        i++;
+        continue;
+      }
+      const dx = Math.abs(next.x - current.x);
+      const dy = Math.abs(next.y - current.y);
+      if (dx > tolerance && dy > tolerance) {
+        const bendPoint = { x: next.x, y: current.y };
+        waypoints.splice(i + 1, 0, bendPoint);
+        i++;
+      } else {
+        i++;
+      }
+    }
+  }
 };
 
 // src/transform/model-builder.ts