fix(library): compare port seats exactly so both flanks of a fan nest alike

The reported "right side is off, like stmt -> }": a symmetric diagram was drawn
lopsided. Its left flank nested its two detours on different corner rings while
the right flank collapsed both onto one shared elbow.

Root cause is a floating-point comparison on a decision path — the exact hazard
this subsystem's "integer, exactly computed" rule exists to prevent, introduced by
the ring selection added in the previous commit. A seat and its mirror image lie
the same distance from their side's centre in exact arithmetic but not in binary
floating point: for a seven-way band,

  0.5 - 1/7 = 0.35714285714285715
  6/7 - 0.5 = 0.3571428571428571     (smaller in the final bit)

Ring choice compared each seat's distance against the largest on its side, so the
right-hand member of every mirror pair failed the test by one ulp, lost the roomy
ring, and fell back onto the tight corner its neighbour already used. Rounding the
distance to whole permille before comparing makes reflection exact — far finer
than any seat spacing, far coarser than the artefact. Both flanks now nest
identically: bends land at (30,360)/(45,375) and mirror to (350,360)/(335,375).

Covered by a regression test that fails on the previous arithmetic.

Known remaining limitation, unchanged by this fix: when many edges share one short
node side (five on a 70px side seats them 12px apart) a fan leaves the node too
narrow to read as separate lines until the routes have travelled some distance.
Widening it means letting a crowded side overflow onto its neighbours, which is a
change to the shared port-assignment stage rather than to straight edges alone.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H4AtGeJaSWiGooNonpVcxN

Author: FelixTJDietrich

library/lib/utils/geometry/edgeGeometrySolver.ts

@@ -1353,8 +1353,15 @@ function computeAllEdgeGeometryPass(
 
   // How far off its side's centre each seat sits, and the largest such offset on
   // every occupied (node, side). Used to nest a fan — see `straightCornerRing`.
+  // QUANTISED, and that is the whole point. A seat and its mirror image are the same
+  // distance from their side's centre in exact arithmetic, but not in binary
+  // floating point: for a seven-way band, 0.5 - 1/7 and 6/7 - 0.5 differ in the last
+  // bit. Comparing raw distances therefore made one flank of a symmetric diagram
+  // take the roomy corner ring and the other the tight one — a visible asymmetry
+  // from a rounding artefact. Rounding to whole permille is far finer than any seat
+  // spacing yet coarse enough that reflection is exact.
   const seatOffset = (anchor: FreeformEdgeAnchor): number =>
-    Math.abs(anchor.ratio - 0.5)
+    Math.round(Math.abs(anchor.ratio - 0.5) * 1000)
   const outermostSeatOffset = new Map<string, number>()
   for (const edge of coordinationEdges) {
     for (const [end, nodeId] of [

library/tests/unit/straightHookRouting.test.ts

@@ -342,6 +342,53 @@ describe("straight-hook edge routing", () => {
     expect(shared).toEqual([])
   })
 
+  it("nests both flanks of a symmetric fan identically", () => {
+    // Regression: the corner-ring choice compared each seat's distance from its
+    // side's centre against the largest on that side. Mirror-paired seats are the
+    // same distance out in exact arithmetic but NOT in binary floating point — for a
+    // seven-way band, 0.5 - 1/7 and 6/7 - 0.5 differ in the final bit. One flank
+    // therefore took the roomy corner ring and the other the tight one, and the
+    // drawing was visibly lopsided even though every input was symmetric.
+    const AXIS = 190
+    const parent = makeNode("stmt", 155, 215, 70, 50)
+    const columns = [
+      makeNode("colL", 55, 385, 70, 50),
+      makeNode("colR", 255, 385, 70, 50),
+    ]
+    const kids = [
+      makeNode("outerL", -35, 550, 50, 50),
+      makeNode("innerL", 15, 550, 50, 50),
+      makeNode("mid", 155, 310, 70, 50),
+      makeNode("innerR", 315, 550, 50, 50),
+      makeNode("outerR", 365, 550, 50, 50),
+    ]
+    const edges: Edge[] = kids.map((k, i) => ({
+      id: `e${i}`,
+      source: "stmt",
+      target: k.node.id,
+      type: "SyntaxTreeLink",
+      data: {},
+    }))
+    const { routeById } = computeAllEdgeGeometry(
+      solverInput([parent, ...columns, ...kids], edges)
+    )
+    // e0/e4 are the outer pair, e1/e3 the inner pair.
+    for (const [left, right] of [
+      ["e0", "e4"],
+      ["e1", "e3"],
+    ]) {
+      const l = routeById[left]
+      const r = routeById[right]
+      expect(l.length).toBe(r.length)
+      for (let i = 0; i < l.length; i++) {
+        expect(Math.abs(2 * AXIS - l[i].x - r[i].x)).toBeLessThanOrEqual(1)
+        expect(l[i].y).toBe(r[i].y)
+      }
+    }
+    // And the two members of one flank still turn at different points.
+    expect(routeById["e0"][1]).not.toEqual(routeById["e1"][1])
+  })
+
   it("routes a mirror-symmetric diagram symmetrically", () => {
     // Everything below is an exact reflection about x = AXIS, including the
     // obstacles, so every route must be the reflection of its partner. Asymmetry