Layered edge labels: grow canvas + fit self-loop captions; harden linter + tests

Address PR #6 review feedback (re-verified against d0bac93):

- DiagramLayout.swift: the state/class/ER (layered) router finalized its
  canvas size before placeRunLabels, so a caption on the rightmost/bottom-most
  run — or one nudged perpendicular off it — could extend past the scene and
  trip the off-canvas rule. Grow the canvas around the placed label anchors,
  the same post-placement expansion layoutFlat already does. (chatgpt-codex
  P2 / coderabbit Major)

- DiagramLayout.swift: a labeled self-loop routed a fixed 24pt loop regardless
  of caption length, cramming the word onto too short a run (label-crowds-edge,
  e.g. `A --> A: retry`). Grow the loop's vertical return run to the label
  height plus a stub on each side; keep the top/bottom bars short so a wide
  loop never gores a neighbouring box (the er fixture's NODE/EDGE pair).

- DiagramScene.swift: validate anchorEdge against edges.indices, not just
  `< count`, so a negative anchor can't trap on the subscript. (coderabbit
  Major, stability)

- EdgeLabelLayoutTests.swift: fail (XCTUnwrap) when a labeled edge has no
  anchor instead of silently skipping, assert the full flowchartLabelStub (14)
  rather than a hard-coded 10, and add a layered self-loop lint-clean
  regression. (coderabbit Minor)

Declined the flowchart placeRunLabels "hard-reject runs / drop perpendicular
nudges / reserve geometry" rewrite: median-dummy widening already reserves
label space, the label-on-fixture/label-crowds-edge linter rules enforce the
contract over 30 lint-clean fixtures, and the one real geometry gap (self-loop
captions) is fixed above. A wholesale rewrite risks regressing the just-landed
placement work with no demonstrated defect.

swift build + full swift test green (198 tests, 2 skipped); 30 fixtures
lint-clean.

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

Author: clintecker

Sources/MermaidLayout/DiagramLayout.swift

@@ -940,18 +940,24 @@ public enum DiagramLayoutEngine {
 
         // Route each edge through its chain waypoints.
         var routes: [[CGPoint]] = []
-        for chain in chains {
+        for (ci, chain) in chains.enumerated() {
             guard chain.count >= 2, let fromFrame = frames[chain[0]], let toFrame = frames[chain[chain.count - 1]] else {
                 routes.append([.zero, .zero]); continue
             }
             // Self-loop (an edge from a box back to itself, e.g. an ER
             // "subcategory of" parent_id): route it as a small loop off the
-            // right side, never a straight line through the box interior.
+            // right side, never a straight line through the box interior. The
+            // top/bottom bars stay short (a wider loop would gore a neighbour);
+            // the caption rides the vertical return run, which we grow to the
+            // label height plus a stub on each side so a word like "retry" isn't
+            // crammed onto the default span (`label-crowds-edge`).
             if chain[0] == chain[chain.count - 1] {
                 let f = fromFrame
                 let ext: CGFloat = 24
-                let yHi = f.midY - min(f.height * 0.24, 13)
-                let yLo = f.midY + min(f.height * 0.24, 13)
+                let labelH = (edgeLabelSizes?[ci] ?? nil)?.height ?? 0
+                let vHalf = max(min(f.height * 0.24, 13), labelH / 2 + flowchartLabelStub)
+                let yHi = f.midY - vHalf
+                let yLo = f.midY + vHalf
                 routes.append([
                     CGPoint(x: f.maxX, y: yHi),
                     CGPoint(x: f.maxX + ext, y: yHi),
@@ -1065,7 +1071,7 @@ public enum DiagramLayoutEngine {
 
         var routeMaxX = crossExtent + margin
         for pts in routes { for p in pts { routeMaxX = max(routeMaxX, p.x) } }
-        let size = CGSize(width: max(crossExtent, routeMaxX - margin) + margin * 2, height: y - layerGap + margin)
+        var size = CGSize(width: max(crossExtent, routeMaxX - margin) + margin * 2, height: y - layerGap + margin)
         // Place every caption on the longest clean straight run of its final
         // route, collision-avoiding node boxes, other captions, bends, and
         // crossings — the same run-based placement the flowchart pipeline uses,
@@ -1077,6 +1083,15 @@ public enum DiagramLayoutEngine {
         let labelSizes: [CGSize?] = routingEdges.indices.map { edgeLabelSizes?[$0] ?? nil }
         let labelAnchors = placeRunLabels(routes: routes, labelSizes: labelSizes,
                                           nodeFrames: realFrameList)
+        // Grow the canvas for any caption nudged past the content box — the same
+        // post-placement expansion layoutFlat performs — so a label on the
+        // rightmost/bottom-most run (or a perpendicular nudge off it) is never
+        // clipped or flagged off-canvas.
+        for (i, anchor) in labelAnchors.enumerated() {
+            guard let lp = anchor, let sz = labelSizes[i] else { continue }
+            size.width = max(size.width, lp.x + sz.width / 2 + margin)
+            size.height = max(size.height, lp.y + sz.height / 2 + margin)
+        }
         // Dummy frames are internal scaffolding — don't leak them.
         for dummy in dummies { frames[dummy] = nil }
         return (frames, size, routes, labelAnchors)

Sources/MermaidLayout/DiagramScene.swift

@@ -407,7 +407,7 @@ public enum DiagramLayoutLinter {
             // Crowding: measure the stub left on each side of the caption on the
             // straight run it sits on (the nearest segment of its own route).
             for (_, label) in edgeLabels {
-                guard let ae = label.anchorEdge, ae < scene.edges.count else { continue }
+                guard let ae = label.anchorEdge, scene.edges.indices.contains(ae) else { continue }
                 let poly = scene.edges[ae].polyline
                 guard poly.count >= 2 else { continue }
                 let c = CGPoint(x: label.frame.midX, y: label.frame.midY)

Tests/MermaidLayoutTests/EdgeLabelLayoutTests.swift

@@ -59,7 +59,8 @@ final class EdgeLabelLayoutTests: XCTestCase {
             guard case .flowchart(let chart) = MermaidParser.parse(src) else { return XCTFail("parse") }
             let layout = DiagramLayoutEngine.layout(chart, measure: measure)
             for edge in layout.edges {
-                guard let label = edge.label, !label.isEmpty, let lp = edge.labelPoint else { continue }
+                guard let label = edge.label, !label.isEmpty else { continue }
+                let lp = try XCTUnwrap(edge.labelPoint, "\(label): missing label anchor")
                 let sz = measure(label, DiagramLayoutEngine.labelFontSize)
                 // Nearest segment (the run the caption sits on).
                 var run: (a: CGPoint, b: CGPoint, d: CGFloat)?
@@ -79,12 +80,33 @@ final class EdgeLabelLayoutTests: XCTestCase {
                 let along = horiz ? sz.width + 6 : sz.height + 2
                 let c = horiz ? lp.x : lp.y
                 let stub = min((c - along / 2) - lo, hi - (c + along / 2))
-                XCTAssertGreaterThanOrEqual(stub, 10,
+                XCTAssertGreaterThanOrEqual(stub, DiagramLayoutEngine.flowchartLabelStub,
                     "label \"\(label)\" leaves only \(Int(stub))pt of connector")
             }
         }
     }
 
+    /// A labeled self-loop in the layered (state/class/ER) router must host its
+    /// caption without clipping or crowding: the loop is widened to the label
+    /// plus a stub on each side, and the canvas grows for the label frame. Before
+    /// the fix, `A --> A: retry` placed the word beside a fixed 24pt loop — off
+    /// the canvas (no size growth) and then crammed onto too short a run.
+    func testLayeredSelfLoopLabelsAreClean() {
+        let sources = [
+            "stateDiagram-v2\n    A --> A: retry",
+            "classDiagram\n    A --> A : self",
+            "stateDiagram-v2\n    [*] --> A\n    A --> A: retry\n    A --> B: go",
+            "erDiagram\n    CUSTOMER ||--o{ CUSTOMER : refers",
+        ]
+        for src in sources {
+            guard let diagram = MermaidParser.parse(src) else { return XCTFail("parse: \(src)") }
+            let scene = DiagramScene.lower(diagram, measure: measure)
+            let errors = DiagramLayoutLinter.lint(scene).filter { $0.severity == .error }
+            XCTAssertTrue(errors.isEmpty,
+                "self-loop \"\(src)\" not clean:\n" + errors.map { "  \($0.kind): \($0.detail)" }.joined(separator: "\n"))
+        }
+    }
+
     // MARK: - Linter rejects the OLD (unfixed) geometry
 
     /// `label-crowds-edge`: the OLD short-edge placement centered "records" on a