fix(library): collapse a loop only when its arms actually meet, not at proximity

A loop between perpendicular endpoints (diagram 84) collapsed to a side-jutting L-route
the moment its arms came within ~10px of each other — so even a small drag "pushed the
edge to the side" instead of just narrowing the loop. That 10px-proximity rule
(hasArmCollapse) also auto-straightened any hand-drawn detour between facing endpoints.

Removed the proximity collapse entirely. A loop now collapses only when its arms actually
FOLD onto each other (the path reverses on itself) or squeeze so tight a stub no longer
fits — a real "collapse this loop" gesture. A narrow-but-open loop, and a hand-drawn
detour between facing endpoints, are kept exactly as drawn (per user request: "only
collapse when there really is a spike", "stay as I drew it"). The fold-collapse and the
adjacent-arm lane clamp still turn a full squeeze into the clean direct route.

Updated the U-merge / near-overlap / facing-detour unit tests to the new "meet, don't
graze" threshold. Full-drag collapse verified for diagrams 83 and 84; routing-quality
gate, fresh-bend, interactions and reset e2e green; 1525 unit.

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

Author: FelixTJDietrich

library/lib/utils/edgeUtils.ts

@@ -2740,43 +2740,6 @@ const hasReducedTerminalStub = (
   )
 }
 
-const hasArmCollapse = (points: IPoint[], proximityPx: number): boolean => {
-  if (points.length < 4) return false
-
-  for (let i = 0; i < points.length - 1; i++) {
-    const aStart = points[i]
-    const aEnd = points[i + 1]
-    const aIsH = aStart.y === aEnd.y
-    const aIsV = aStart.x === aEnd.x
-    if (!aIsH && !aIsV) continue
-
-    for (let j = i + 2; j < points.length - 1; j++) {
-      const bStart = points[j]
-      const bEnd = points[j + 1]
-      const bIsH = bStart.y === bEnd.y
-      const bIsV = bStart.x === bEnd.x
-
-      if (aIsH && bIsH && Math.abs(aStart.y - bStart.y) <= proximityPx) {
-        const aMinX = Math.min(aStart.x, aEnd.x)
-        const aMaxX = Math.max(aStart.x, aEnd.x)
-        const bMinX = Math.min(bStart.x, bEnd.x)
-        const bMaxX = Math.max(bStart.x, bEnd.x)
-        if (Math.max(aMinX, bMinX) < Math.min(aMaxX, bMaxX)) return true
-      }
-
-      if (aIsV && bIsV && Math.abs(aStart.x - bStart.x) <= proximityPx) {
-        const aMinY = Math.min(aStart.y, aEnd.y)
-        const aMaxY = Math.max(aStart.y, aEnd.y)
-        const bMinY = Math.min(bStart.y, bEnd.y)
-        const bMaxY = Math.max(bStart.y, bEnd.y)
-        if (Math.max(aMinY, bMinY) < Math.min(aMaxY, bMaxY)) return true
-      }
-    }
-  }
-
-  return false
-}
-
 const collapseTinyOrthogonalDoglegs = (
   points: IPoint[],
   proximityPx: number
@@ -3089,7 +3052,6 @@ export function normalizeOrthogonalEdgePoints(
       sourcePosition,
       targetPosition
     ) ||
-    hasArmCollapse(sanitized, EDGES.ORTHOGONAL_ARM_OVERLAP_PX) ||
     hasStubCollision
   ) {
     return fallback
@@ -3127,20 +3089,20 @@ export function resolveOrthogonalEdgeReleasePoints(
     targetPosition
   )
 
-  // When a release is invalid *because the user dragged the two parallel arms
-  // of a U together (or past each other)*, that is a deliberate "merge the U"
-  // gesture, not a bad drag — collapse the released geometry rather than
-  // snapping back to the pre-drag wide route. normalizeOrthogonalEdgePoints
-  // already routes overlapping input to the clean safe path and re-validates
-  // stubs, so any other invalidity still falls back safely.
+  // A release that FOLDS an arm flat onto its neighbour (a spike where the path reverses
+  // on itself) is a deliberate "collapse this loop" gesture, not a bad drag — keep the
+  // released geometry so normalizeOrthogonalEdgePoints routes it to the clean path rather
+  // than snapping back. Any other invalidity still falls back safely. A merely NARROW
+  // loop (arms close but not touching) is NOT a fold: it is kept exactly as drawn and
+  // only collapses once the arms actually meet.
   const sanitized = sanitizeReleasedPoints(
     releasedPoints,
     sourcePoint,
     targetPoint
   )
-  const armOverlap = hasArmCollapse(sanitized, EDGES.ORTHOGONAL_ARM_OVERLAP_PX)
+  const folded = hasAxisFold(sanitized)
   const pointsToNormalize =
-    invalid && !armOverlap ? lastValidPoints : releasedPoints
+    invalid && !folded ? lastValidPoints : releasedPoints
 
   return normalizeOrthogonalEdgePoints(
     pointsToNormalize,
@@ -3522,8 +3484,7 @@ export function preserveOrthogonalEdgePoints(
       targetPoint,
       sourcePosition,
       targetPosition
-    ) ||
-    hasArmCollapse(result, EDGES.ORTHOGONAL_ARM_OVERLAP_PX)
+    )
   ) {
     return safePoints
   }

library/tests/unit/edgeUtils.test.ts

@@ -1081,28 +1081,27 @@ describe("preserveOrthogonalEdgePoints", () => {
     expectOrthogonalSegments(result)
   })
 
-  it("draws a straight line between facing endpoints on a shared lane, however close", () => {
-    // Collinear stubs cannot fold back on each other, so proximity is irrelevant
-    // here — detouring two nodes that a straight line already connects is noise.
+  it("keeps a hand-drawn detour between facing endpoints as drawn (no auto-straighten)", () => {
+    // A detour the user drew is theirs to keep: we no longer flatten a loop between
+    // facing endpoints just because a straight line would also connect them. It only
+    // collapses when its arms actually fold onto each other.
+    const detour = [
+      { x: 0, y: 200 },
+      { x: 30, y: 200 },
+      { x: 30, y: 250 },
+      { x: 20, y: 250 },
+      { x: 20, y: 200 },
+      { x: 50, y: 200 },
+    ]
     const result = normalizeOrthogonalEdgePoints(
-      [
-        { x: 0, y: 200 },
-        { x: 30, y: 200 },
-        { x: 30, y: 250 },
-        { x: 20, y: 250 },
-        { x: 20, y: 200 },
-        { x: 50, y: 200 },
-      ],
+      detour,
       { x: 0, y: 200 },
       { x: 50, y: 200 },
       Position.Right,
       Position.Left
     )
 
-    expect(result).toEqual([
-      { x: 0, y: 200 },
-      { x: 50, y: 200 },
-    ])
+    expect(result).toEqual(detour)
     expectOrthogonalSegments(result)
   })
 
@@ -1320,26 +1319,26 @@ describe("preserveOrthogonalEdgePoints", () => {
     expectOrthogonalSegments(result)
   })
 
-  it("collapses near-overlapping parallel arms only in release normalization", () => {
+  it("keeps near-but-not-touching parallel arms as drawn (collapses only when they meet)", () => {
+    // Arms 10px apart are a narrow loop the user drew, not a spike — preserved. They
+    // only collapse once dragged together far enough that a stub can no longer fit.
+    const narrow = [
+      { x: 0, y: 200 },
+      { x: 360, y: 200 },
+      { x: 360, y: 250 },
+      { x: 370, y: 250 },
+      { x: 370, y: 200 },
+      { x: 400, y: 200 },
+    ]
     const result = normalizeOrthogonalEdgePoints(
-      [
-        { x: 0, y: 200 },
-        { x: 360, y: 200 },
-        { x: 360, y: 250 },
-        { x: 370, y: 250 },
-        { x: 370, y: 200 },
-        { x: 400, y: 200 },
-      ],
+      narrow,
       { x: 0, y: 200 },
       { x: 400, y: 200 },
       Position.Right,
       Position.Left
     )
 
-    expect(result).toEqual([
-      { x: 0, y: 200 },
-      { x: 400, y: 200 },
-    ])
+    expect(result).toEqual(narrow)
     expectOrthogonalSegments(result)
   })
 
@@ -1477,10 +1476,11 @@ describe("preserveOrthogonalEdgePoints", () => {
     expect(result).toEqual(tightened)
   })
 
-  // Dragging a U's arm so the two parallel arms meet or cross is a deliberate
-  // "merge the U" gesture and must collapse the route — not snap back to the
-  // pre-drag wide U. Arms still clearly apart stay a (narrow) U.
-  describe("collapses a U when its arms are dragged together", () => {
+  // A U collapses only once its arms actually MEET (touch/cross), where the loop folds
+  // onto itself or a stub can no longer fit — a real "collapse this loop" gesture. A U
+  // whose arms are merely close stays exactly as drawn, so a partial drag never snaps the
+  // loop into a straight line.
+  describe("collapses a U only when its arms actually meet", () => {
     const S = { x: 0, y: 200 }
     const T = { x: 400, y: 200 }
     const wideU = [
@@ -1500,9 +1500,10 @@ describe("preserveOrthogonalEdgePoints", () => {
       { x: 400, y: 200 },
     ]
 
-    // Arm gap 5px / 10px (boundary) / crossed: all collapse to a straight line.
-    for (const lx of [365, 360, 375]) {
-      it(`collapses when the dragged arm lands at x=${lx} (gap ${370 - lx}px)`, () => {
+    // Touching (0px), essentially touching (5px, a stub can no longer fit), and crossed
+    // all collapse to a straight line.
+    for (const lx of [365, 370, 375]) {
+      it(`collapses when the dragged arm reaches x=${lx} (gap ${370 - lx}px)`, () => {
         const result = resolveOrthogonalEdgeReleasePoints(
           releaseWithLeftArmAt(lx),
           wideU,
@@ -1519,19 +1520,22 @@ describe("preserveOrthogonalEdgePoints", () => {
       })
     }
 
-    it("preserves a deliberate narrow U whose arms are still 15px apart", () => {
-      const released = releaseWithLeftArmAt(355)
-      const result = resolveOrthogonalEdgeReleasePoints(
-        released,
-        wideU,
-        S,
-        T,
-        Position.Right,
-        Position.Left
-      )
-      expect(result).toEqual(released)
-      expectOrthogonalSegments(result)
-    })
+    // Still clearly apart (10px, 15px): the narrow U is kept exactly as drawn.
+    for (const lx of [360, 355]) {
+      it(`preserves a narrow U whose arms are ${370 - lx}px apart`, () => {
+        const released = releaseWithLeftArmAt(lx)
+        const result = resolveOrthogonalEdgeReleasePoints(
+          released,
+          wideU,
+          S,
+          T,
+          Position.Right,
+          Position.Left
+        )
+        expect(result).toEqual(released)
+        expectOrthogonalSegments(result)
+      })
+    }
   })
 
   // A dragged arm must come to REST on the parallel arm two segments away (where the