fix(library): a dragged bend arm rests on the adjacent parallel arm, not through it

Squeezing a loop's arms together (e.g. diagram 83) did not collapse cleanly: dragging an
arm toward the parallel arm two segments away let it sail straight through and grow a
fresh zig-zag on the far side, which read as the geometry "pushing apart" instead of
merging. The lane had walls only at the endpoint stubs, none at the neighbouring arm.

getBendLaneBounds now also clamps a dragged arm's lane at each parallel arm two segments
away (joined to it by the perpendicular connectors i±1), on whichever side that arm
currently sits. The lane comes to rest exactly where the connector collapses to zero, so
the loop merges to the clean route and further dragging in the same direction does
nothing — matching the existing "follow the cursor, stop at a wall" model. A neighbour
already coincident imposes no bound (already merged).

Unit tests cover the clamp toward each side; the U-merge release tests, bend-drag e2e,
interactions, zoom and the routing-quality gate are unaffected (290 unit + gate green).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: FelixTJDietrich

library/lib/utils/edgeUtils.ts

@@ -2968,6 +2968,23 @@ export function getBendLaneBounds(
     constrainBy(targetPoint, targetPosition)
   }
 
+  // The two PARALLEL arms flanking this segment (two away, joined to it by the
+  // perpendicular connectors i±1) are walls too: a lane must come to REST on an
+  // adjacent arm — where the connector between them collapses to zero and the loop
+  // merges — not sail through it and grow a fresh zig-zag on the far side. This is
+  // what makes "drag the arms together" collapse the loop instead of pushing it
+  // apart. Clamp toward whichever side each neighbour currently sits on; a neighbour
+  // already coincident with this lane imposes no bound (the loop is already merged).
+  const laneCoord = points[segmentIndex][laneAxis]
+  const clampAgainstArm = (armIndex: number): void => {
+    if (armIndex < 0 || armIndex > lastSegmentIndex) return
+    const armCoord = points[armIndex][laneAxis]
+    if (armCoord > laneCoord) bounds.max = Math.min(bounds.max, armCoord)
+    else if (armCoord < laneCoord) bounds.min = Math.max(bounds.min, armCoord)
+  }
+  clampAgainstArm(segmentIndex - 2)
+  clampAgainstArm(segmentIndex + 2)
+
   return bounds
 }
 

library/tests/unit/edgeUtils.test.ts

@@ -32,6 +32,7 @@ import {
   simplifySvgPath,
   stubsWouldOverlap,
   getEffectiveStubLength,
+  getBendLaneBounds,
 } from "@/utils/edgeUtils"
 import { ConnectionLineType, Position } from "@xyflow/react"
 import { describe, expect, it } from "vitest"
@@ -1533,6 +1534,52 @@ describe("preserveOrthogonalEdgePoints", () => {
     })
   })
 
+  // A dragged arm must come to REST on the parallel arm two segments away (where the
+  // connector between them collapses and the loop merges), not sail through it and grow
+  // a fresh zig-zag on the far side — which read as the geometry "pushing apart".
+  describe("clamps a dragged arm's lane at the adjacent parallel arm", () => {
+    // A loop like diagram 83: source stub → up → over → down into target. The two
+    // vertical arms are at x=615 and x=645; the target down-run (seg 3) is dragged left.
+    const loop = [
+      { x: 565, y: 335 }, // source
+      { x: 615, y: 335 },
+      { x: 615, y: 140 }, // seg1: left arm  (x=615)
+      { x: 645, y: 140 },
+      { x: 645, y: 410 }, // seg3: right arm (x=645) — the dragged terminal down-run
+    ]
+    const S = { x: 565, y: 335 }
+    const T = { x: 645, y: 410 }
+
+    it("stops the right arm at the left arm (x=615) instead of crossing it", () => {
+      const bounds = getBendLaneBounds(
+        loop,
+        3, // the target down-run
+        "V",
+        S,
+        T,
+        Position.Right,
+        Position.Top
+      )
+      // Dragging the x=645 arm LEFT, its lane may not go below x=615 (the parallel arm).
+      expect(bounds.min).toBe(615)
+    })
+
+    it("clamps the left arm at the right arm (x=645) when dragged toward it", () => {
+      // seg1 (left arm, x=615) has its parallel neighbour on the target side (seg3 at
+      // x=645), so dragging it RIGHT stops at 645 rather than crossing.
+      const bounds = getBendLaneBounds(
+        loop,
+        1,
+        "V",
+        S,
+        T,
+        Position.Right,
+        Position.Top
+      )
+      expect(bounds.max).toBe(645)
+    })
+  })
+
   it("detects mirrored horizontal and vertical stub collisions", () => {
     expect(
       stubsWouldOverlap(