fix(library): collapse a squeezed loop to the clean route, not a residual jog

Dragging a loop's arms together is meant to collapse it. Squeezing the free inner arm
already produced the clean direct route, but squeezing the PINNED terminal arm left a
30px jog: its port is fixed, so the arm folds back on itself rather than merging, and no
simplify pass removes the fold — it read as "it pushes to 30px and never collapses".

normalizeOrthogonalEdgePoints now detects a fold (a point where the path reverses on
itself along one axis) and hands the collapsed edge to the router for the clean direct
path. Placing it here — the shared normalizer used by BOTH the bend release AND the
post-drag geometry re-projection — is what makes it stick: doing it only at release let
the re-projection (which also normalizes) re-introduce the jog a frame later.

Together with the adjacent-arm lane clamp, dragging either arm now collapses the loop to
a straight line the moment the arms meet (0px), with no push-apart and no leftover jog.
Ordinary S-jogs that never reverse on themselves are untouched. 1523 unit + fresh-bend,
interactions, zoom, reset and the routing-quality gate green.

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

Author: FelixTJDietrich

library/lib/utils/edgeUtils.ts

@@ -3004,6 +3004,27 @@ const getDegenerateRoute = (
   targetPoint: IPoint
 ): IPoint[] => [{ ...sourcePoint }, { ...targetPoint }]
 
+/**
+ * A point where the path REVERSES on itself along one axis — the two segments meeting
+ * there are collinear but point in opposite directions (a spike/fold). This is what a
+ * squeezed loop leaves once an arm is dragged flat onto its neighbour: dragging the
+ * PINNED terminal arm cannot merge into that neighbour cleanly (its port is fixed), so
+ * it folds and leaves a residual jog no simplify pass removes. A fold is never a shape
+ * worth keeping, so its presence marks a "collapse this loop" gesture.
+ */
+const hasAxisFold = (points: IPoint[]): boolean => {
+  for (let i = 1; i < points.length - 1; i++) {
+    const a = points[i - 1]
+    const b = points[i]
+    const c = points[i + 1]
+    const collinear =
+      (a.x === b.x && b.x === c.x) || (a.y === b.y && b.y === c.y)
+    const reverses = (b.x - a.x) * (c.x - b.x) + (b.y - a.y) * (c.y - b.y) < 0
+    if (collinear && reverses) return true
+  }
+  return false
+}
+
 export function normalizeOrthogonalEdgePoints(
   points: IPoint[],
   sourcePoint: IPoint,
@@ -3016,6 +3037,25 @@ export function normalizeOrthogonalEdgePoints(
     return getDegenerateRoute(sourcePoint, targetPoint)
   }
 
+  // A fold means an arm was squeezed flat onto its neighbour (the loop collapsed). A
+  // pinned terminal arm folds rather than merging cleanly, leaving a jog that survives
+  // simplify — so hand the collapsed edge back to the router for the clean direct route,
+  // exactly as squeezing the inner arm already produces. Done here (not only at release)
+  // so the geometry re-projection that runs after a drag cannot re-introduce the jog.
+  if (hasAxisFold(points)) {
+    return sanitizeReleasedPoints(
+      routeOrthogonalPath(
+        sourcePoint,
+        targetPoint,
+        sourcePosition,
+        targetPosition,
+        obstacles
+      ),
+      sourcePoint,
+      targetPoint
+    )
+  }
+
   const hasStubCollision = stubsWouldOverlap(
     sourcePoint,
     targetPoint,

library/tests/unit/edgeUtils.test.ts

@@ -1580,6 +1580,60 @@ describe("preserveOrthogonalEdgePoints", () => {
     })
   })
 
+  // Dragging a PINNED terminal arm flat onto its neighbour folds the path back on
+  // itself (a spike). No simplify pass removes the residual jog, so normalize hands the
+  // collapsed edge to the router for the clean direct route — the same result squeezing
+  // the free inner arm already produces. Done in normalize (not just at release) so the
+  // post-drag geometry re-projection cannot re-introduce the jog.
+  describe("collapses a folded (squeezed-flat) route to the clean direct path", () => {
+    const S = { x: 565, y: 335 }
+    const T = { x: 645, y: 410 }
+
+    it("routes a folded terminal squeeze straight instead of keeping the jog", () => {
+      // The terminal down-run folded onto the source arm at x=615: 615,335 → up to 140 →
+      // back down to 380 reverses on itself.
+      const folded = [
+        { x: 565, y: 335 },
+        { x: 615, y: 335 },
+        { x: 615, y: 140 },
+        { x: 615, y: 380 },
+        { x: 645, y: 380 },
+        { x: 645, y: 410 },
+      ]
+      const result = normalizeOrthogonalEdgePoints(
+        folded,
+        S,
+        T,
+        Position.Right,
+        Position.Top
+      )
+      expect(result).toEqual([
+        { x: 565, y: 335 },
+        { x: 645, y: 335 },
+        { x: 645, y: 410 },
+      ])
+      expectOrthogonalSegments(result)
+    })
+
+    it("leaves an ordinary jog (no fold) untouched", () => {
+      // A genuine S-jog that never reverses on itself is preserved, not flattened.
+      const jog = [
+        { x: 0, y: 0 },
+        { x: 40, y: 0 },
+        { x: 40, y: 60 },
+        { x: 100, y: 60 },
+      ]
+      const result = normalizeOrthogonalEdgePoints(
+        jog,
+        { x: 0, y: 0 },
+        { x: 100, y: 60 },
+        Position.Right,
+        Position.Left
+      )
+      expect(result).toEqual(jog)
+    })
+  })
+
   it("detects mirrored horizontal and vertical stub collisions", () => {
     expect(
       stubsWouldOverlap(