termrender 4.6.1__tar.gz → 4.6.2__tar.gz

{termrender-4.6.1 → termrender-4.6.2}/CHANGELOG.md

@@ -1,6 +1,28 @@
 # CHANGELOG
 
 
+## v4.6.2 (2026-07-07)
+
+### Bug Fixes
+
+- **mermaid-flow**: Preserve edge labels, render self-loops, sanitize degraded echo
+  ([`263100f`](https://github.com/crouton-labs/termrender/commit/263100f16e1a7f0044497f2dedd0fd10f0831626))
+
+- Router now draws all edge polylines+arrowheads first, then all edge labels last (reserving each
+  label's cells, plus a margin), so a later edge's line can never silently erase an earlier edge's
+  label and two labels sharing a lane render with visible separation instead of concatenating. -
+  Rank-band gaps widen to fit an adjacent-rank edge's label in full (_rank_gap_overrides), fixing
+  short LR/forward-adjacent labeled edges (e.g. "hello") that were previously clipped to a couple of
+  characters. - Raw-echo degradation now strips any box-drawing/geometric glyph (\u2500-\u259f,
+  \u25a0-\u25ff) present in the malformed source itself, so a degraded echo can never be misdetected
+  as a successful render. - Hardened green-theatre tests: self-loop tests now assert real loop
+  geometry (arrowhead + glyphs past the box border) instead of "non-empty output"; the
+  edge-visibility test now inspects the guaranteed-clear inter-box gap instead of accepting
+  box-border glyphs; cycle/labeled-back-edge/direction/never-raises tests gained genuine
+  topology/degradation assertions in place of crash-only checks. - Updated the two corpus goldens
+  (pipe-label, inline-label) whose rendered height changed under the new label-aware gap widening.
+
+
 ## v4.6.1 (2026-07-07)
 
 ### Bug Fixes

{termrender-4.6.1 → termrender-4.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 4.6.1
+Version: 4.6.2
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender

{termrender-4.6.1 → termrender-4.6.2}/src/termrender/renderers/mermaid_flow.py

@@ -54,11 +54,21 @@ Known degradations (by design, not bugs)
 
 from __future__ import annotations
 
+import re
+
 from termrender.renderers.mermaid_flow_layout import layout_flowgraph
 from termrender.renderers.mermaid_flow_parser import FlowchartError, parse
 
 __all__ = ["render_flowchart"]
 
+# Same ranges the downstream attach viewer uses to detect render *success*
+# (see the module docstring's "Degradation contract"). The raw-echo path
+# must never contain one of these, even when the malformed/degenerate
+# source itself happens to contain a literal box-drawing or geometric
+# glyph (e.g. hand-typed "\u250c" in otherwise-non-flowchart text) — otherwise a
+# failed render could be misdetected as a successful one.
+_GLYPH_RANGE_RE = re.compile("[\u2500-\u259f\u25a0-\u25ff]")
+
 
 def render_flowchart(source: str, width: int) -> list[str]:
     """Render a mermaid ``graph``/``flowchart`` source to unicode lines.
@@ -113,4 +123,12 @@ def render_flowchart(source: str, width: int) -> list[str]:
 
 
 def _raw_echo(source: str) -> list[str]:
-    return [line.rstrip() for line in source.splitlines()]
+    """Plain echo of ``source``'s lines, with any box-drawing/geometric
+    glyph (the same ``\\u2500-\\u259f``/``\\u25a0-\\u25ff`` ranges the
+    downstream viewer checks for) replaced by ``?`` — the degradation
+    contract requires NO such glyph survive, even one present verbatim in
+    malformed/degenerate source, not just glyphs this renderer would have
+    drawn itself."""
+    return [
+        _GLYPH_RANGE_RE.sub("?", line.rstrip()) for line in source.splitlines()
+    ]

{termrender-4.6.1 → termrender-4.6.2}/src/termrender/renderers/mermaid_flow_layout.py

@@ -721,6 +721,38 @@ def _box_dims(label: str, shape: NodeShape = NodeShape.RECT) -> tuple[int, int]:
 _GAP_X = 3          # minimum border-to-border gap between boxes in one rank/band
 _ROW_GAP = 2         # minimum gap between rank bands
 _COMPONENT_GUTTER = 4  # gap between independently-laid-out components
+_LABEL_GAP_PAD = 1   # cells of breathing room either side of a label's own text
+                     # when it forces a rank-band gap wider than _ROW_GAP.
+
+
+def _rank_gap_overrides(
+    edges: list[FlowEdge], rank_of: dict[str, int]
+) -> dict[int, int]:
+    """Minimum inter-rank-band gap keyed by the *lower* rank of each
+    adjacent-rank transition, widened past ``_ROW_GAP`` wherever a labeled
+    edge directly connects that transition's two ranks. A forward edge
+    between adjacent ranks routes as a single straight run (or a Z path
+    that still crosses the same inter-rank band) whose only clear space is
+    this gap — at the base ``_ROW_GAP`` a label wider than a couple of
+    cells has nowhere to go but onto the boxes it connects, which is
+    exactly the short LR/adjacent-rank clipped-label bug this closes.
+    Non-adjacent-rank edges (back-edges, multi-rank spans) don't constrain
+    the gap here — they route through their own side lane, not this band.
+    """
+    overrides: dict[int, int] = {}
+    for e in edges:
+        if e.src == e.dst or not e.label:
+            continue
+        r_src = rank_of.get(e.src)
+        r_dst = rank_of.get(e.dst)
+        if r_src is None or r_dst is None:
+            continue
+        lo_r, hi_r = (r_src, r_dst) if r_src <= r_dst else (r_dst, r_src)
+        if hi_r - lo_r != 1:
+            continue
+        needed = visual_len(e.label) + 2 * _LABEL_GAP_PAD
+        overrides[lo_r] = max(overrides.get(lo_r, _ROW_GAP), needed)
+    return overrides
 
 
 def _native_extents(
@@ -780,12 +812,15 @@ def _place_nodes(
         for v in comp_vertices:
             ranks[sug.grx[v].rank].append(v)
 
+        rank_of = {v.data: sug.grx[v].rank for v in comp_vertices}
+        gap_overrides = _rank_gap_overrides(edges, rank_of)
+
         band_top_for_rank: dict[int, int] = {}
         cursor = 0
         for r in sorted(ranks):
             band_top_for_rank[r] = cursor
             max_h = max(native[v.data][1] for v in ranks[r])
-            cursor += max_h + _ROW_GAP
+            cursor += max_h + gap_overrides.get(r, _ROW_GAP)
 
         min_x = min(v.view.xy[0] for v in comp_vertices)
         provisional = {v: round(v.view.xy[0] - min_x) for v in comp_vertices}
@@ -1214,6 +1249,17 @@ def _label_positions(length: int, center: int, lo: int, hi: int) -> list[int]:
     return order
 
 
+def _reserve_label_margin(canvas: Canvas, x: int, y: int) -> None:
+    """Mark one cell just past a label's edge as reserved, without
+    altering whatever character (if any) already occupies it — a one-cell
+    buffer so a second label placed on an adjacent/overlapping segment
+    (e.g. two back-edge labels sharing a row) lands with visible separation
+    instead of butting directly up against the first label's text."""
+    if x < 0 or y < 0:
+        return
+    canvas.set_char(x, y, canvas.get_char(x, y), reserve=True)
+
+
 def _draw_label_on_segment(
     canvas: Canvas, a: tuple[int, int], b: tuple[int, int], label: str
 ) -> None:
@@ -1226,7 +1272,12 @@ def _draw_label_on_segment(
     self-loop label placement. Shifts along the search axis to the nearest
     span/row fully clear of a reserved (box) cell; if none exists, writes
     at the ideal placement anyway (overflow tolerated) but skips individual
-    reserved cells — a label never corrupts a box.
+    reserved cells — a label never corrupts a box. Every written label cell
+    is itself marked reserved (see :func:`layout_flowgraph`'s two-pass draw
+    order): labels draw only after every edge's line+arrowheads are already
+    on the canvas, so nothing draws over a label afterwards, and a *later*
+    label's own clear-run search treats an earlier label's cells the same
+    as a box's — skip, don't overwrite.
     """
     length = visual_len(label)
     if length <= 0:
@@ -1246,12 +1297,14 @@ def _draw_label_on_segment(
             run = cells(start)
             if not any(canvas.is_reserved(x, y) for x, y in run):
                 for (px, py), ch in zip(run, label):
-                    canvas.draw_glyph(px, py, ch)
+                    canvas.set_char(px, py, ch, reserve=True)
+                _reserve_label_margin(canvas, start - 1, row)
+                _reserve_label_margin(canvas, start + length, row)
                 return
         start = max(lo, min(center - length // 2, hi - length + 1))
         for (px, py), ch in zip(cells(start), label):
             if not canvas.is_reserved(px, py):
-                canvas.draw_glyph(px, py, ch)
+                canvas.set_char(px, py, ch, reserve=True)
         return
 
     # Vertical segment: the label still reads horizontally, centered on
@@ -1272,11 +1325,13 @@ def _draw_label_on_segment(
         run = row_cells(row)
         if not any(canvas.is_reserved(x, y) for x, y in run):
             for (px, py), ch in zip(run, label):
-                canvas.draw_glyph(px, py, ch)
+                canvas.set_char(px, py, ch, reserve=True)
+            _reserve_label_margin(canvas, start_x - 1, row)
+            _reserve_label_margin(canvas, start_x + length, row)
             return
     for (px, py), ch in zip(row_cells(center_row), label):
         if not canvas.is_reserved(px, py):
-            canvas.draw_glyph(px, py, ch)
+            canvas.set_char(px, py, ch, reserve=True)
 
 
 def _draw_polyline(canvas: Canvas, points: list[tuple[int, int]], style: EdgeStyle) -> None:
@@ -1322,67 +1377,61 @@ def _self_loop_points(
     return [(ax, lo), (far, lo), (far, hi), (ax, hi)]
 
 
-def _route_edge(
-    canvas: Canvas,
+def _route_edge_path(
     rects: dict[str, BoxRect],
     direction: Direction,
     edge: FlowEdge,
     lane_counter: list[int],
     self_loop_counter: dict[str, int],
-) -> None:
-    """Draw one edge's full orthogonal path: anchors chosen by relative
-    rank position, an L/Z/C path shape, arrowheads, and an edge label.
-    Dangling node-id references are a defensive no-op (the parser
-    guarantees valid endpoints; this module never crashes on one).
+) -> list[tuple[int, int]] | None:
+    """Compute one edge's polyline points: anchors chosen by relative rank
+    position, an L/Z/C path shape. Pure path computation only — drawing is
+    the caller's job, split into two passes across *all* edges (see
+    :func:`layout_flowgraph`) so that no edge's line ever overwrites
+    another edge's already-placed label. Dangling node-id references
+    return ``None`` (defensive no-op — the parser guarantees valid
+    endpoints; this module never crashes on one).
     """
     src_rect = rects.get(edge.src)
     dst_rect = rects.get(edge.dst)
     if src_rect is None or dst_rect is None:
-        return
+        return None
 
     if edge.src == edge.dst:
         lane = self_loop_counter.get(edge.src, 0)
         self_loop_counter[edge.src] = lane + 1
-        points = _self_loop_points(direction, src_rect, lane)
-    else:
-        src_extent = _rank_extent(direction, src_rect)
-        dst_extent = _rank_extent(direction, dst_rect)
-        same_rank = not (dst_extent[1] < src_extent[0] or src_extent[1] < dst_extent[0])
+        return _self_loop_points(direction, src_rect, lane)
+
+    src_extent = _rank_extent(direction, src_rect)
+    dst_extent = _rank_extent(direction, dst_rect)
+    same_rank = not (dst_extent[1] < src_extent[0] or src_extent[1] < dst_extent[0])
+
+    if same_rank:
+        return [_facing_anchor(src_rect, dst_rect), _facing_anchor(dst_rect, src_rect)]
+
+    src_center = (src_extent[0] + src_extent[1]) / 2
+    dst_center = (dst_extent[0] + dst_extent[1]) / 2
+    forward = (dst_center > src_center) == _forward_increasing(direction)
+    if forward:
+        return _z_path(
+            direction,
+            _forward_exit(direction, src_rect),
+            _forward_entry(direction, dst_rect),
+        )
 
-        if same_rank:
-            points = [_facing_anchor(src_rect, dst_rect), _facing_anchor(dst_rect, src_rect)]
-        else:
-            src_center = (src_extent[0] + src_extent[1]) / 2
-            dst_center = (dst_extent[0] + dst_extent[1]) / 2
-            forward = (dst_center > src_center) == _forward_increasing(direction)
-            if forward:
-                points = _z_path(
-                    direction,
-                    _forward_exit(direction, src_rect),
-                    _forward_entry(direction, dst_rect),
-                )
-            else:
-                lane = lane_counter[0]
-                lane_counter[0] += 1
-                lane_secondary = (
-                    _lane_secondary_base(direction, src_rect, dst_rect)
-                    + _LANE_MARGIN
-                    + lane * _LANE_GAP
-                )
-                points = _lane_path(
-                    direction,
-                    _lane_anchor(direction, src_rect),
-                    _lane_anchor(direction, dst_rect),
-                    lane_secondary,
-                )
-
-    _draw_polyline(canvas, points, edge.style)
-    _draw_arrowheads(canvas, points, edge)
-
-    if edge.label:
-        seg = _longest_segment(points)
-        if seg is not None:
-            _draw_label_on_segment(canvas, *seg, edge.label)
+    lane = lane_counter[0]
+    lane_counter[0] += 1
+    lane_secondary = (
+        _lane_secondary_base(direction, src_rect, dst_rect)
+        + _LANE_MARGIN
+        + lane * _LANE_GAP
+    )
+    return _lane_path(
+        direction,
+        _lane_anchor(direction, src_rect),
+        _lane_anchor(direction, dst_rect),
+        lane_secondary,
+    )
 
 
 # --------------------------------------------------------------------------
@@ -1451,10 +1500,27 @@ def layout_flowgraph(g: FlowGraph, width: int) -> list[str]:
             rect = rects.get(n.id)
             if rect is not None:
                 canvas.draw_box(rect, n.shape, n.label)
+        # Two passes across *all* edges, not one pass per edge: every
+        # edge's line + arrowheads draw first, then every edge's label
+        # draws last (see design doc). Interleaving line-then-label per
+        # edge (the old order) let a later edge's line silently erase an
+        # earlier edge's already-placed label whenever their paths shared
+        # a cell — labels are only ever safe once no more lines are coming.
         lane_counter = [0]
         self_loop_counter: dict[str, int] = {}
+        edge_paths: list[tuple[FlowEdge, list[tuple[int, int]]]] = []
         for e in g.edges:
-            _route_edge(canvas, rects, g.direction, e, lane_counter, self_loop_counter)
+            points = _route_edge_path(rects, g.direction, e, lane_counter, self_loop_counter)
+            if points is not None:
+                edge_paths.append((e, points))
+        for e, points in edge_paths:
+            _draw_polyline(canvas, points, e.style)
+            _draw_arrowheads(canvas, points, e)
+        for e, points in edge_paths:
+            if e.label:
+                seg = _longest_segment(points)
+                if seg is not None:
+                    _draw_label_on_segment(canvas, *seg, e.label)
         return canvas.to_lines()
     except Exception:
         return []

{termrender-4.6.1 → termrender-4.6.2}/tests/test_mermaid_flow.py

@@ -67,6 +67,33 @@ def test_inline_label_edge_shows_label_text():
     assert "go now" in text
 
 
+def test_multiple_labeled_back_edges_do_not_erase_each_other():
+    # Regression: the router used to draw each edge's line+label inline in
+    # declaration order, so a later edge's line could silently overwrite an
+    # earlier edge's already-placed label. Both r1 and r2 must survive, and
+    # with real separation — not just "r1" as a bare substring of a
+    # concatenated "r2r1" run.
+    source = "graph TD\nA-->B\nB-->C\nC-->|r1|A\nC-->|r2|B\n"
+    lines = render_flowchart(source, width=80)
+    assert lines
+    text = "\n".join(lines)
+    assert "r1" in text
+    assert "r2" in text
+    assert "r1r2" not in text and "r2r1" not in text
+
+
+def test_lr_short_edge_label_renders_in_full():
+    # Regression: the horizontal label placer used to constrain a label to
+    # the clear run between two adjacent reserved box borders, clipping
+    # "hello" down to just "el". The rank-band gap now widens to fit the
+    # label (see mermaid_flow_layout._rank_gap_overrides).
+    source = "graph LR\nA -->|hello| B\n"
+    lines = render_flowchart(source, width=80)
+    assert lines
+    text = "\n".join(lines)
+    assert "hello" in text
+
+
 # --------------------------------------------------------------------------
 # Labeled back-edge cycle — the exact shape that panics the Go binary
 # --------------------------------------------------------------------------
@@ -90,6 +117,40 @@ def test_labeled_back_edge_cycle_renders_all_boxes_label_and_arrow():
     assert row_a < row_b < row_c
 
 
+# --------------------------------------------------------------------------
+# Self-loop — a node edge back to itself
+# --------------------------------------------------------------------------
+
+
+def test_self_loop_renders_visible_loop_and_arrowhead():
+    # A renderer that silently dropped self-loops would still pass a bare
+    # "non-empty, contains A and B" smoke check — assert the loop's real
+    # geometry: an arrowhead, and glyphs extending past the node's own box
+    # border (a dropped loop renders only the bare box).
+    source = "graph TD\nA-->B\nA-->A\n"
+    lines = render_flowchart(source, width=80)
+    assert lines
+    text = "\n".join(lines)
+    assert "A" in text and "B" in text
+    assert _ARROW_RE.search(text)
+    box_right_col = max(line.index("\u2510") for line in lines if "\u2510" in line)
+    assert any(len(line.rstrip()) > box_right_col + 1 for line in lines), (
+        "expected loop glyphs extending past a node box's right border"
+    )
+
+
+def test_labeled_self_loop_renders_loop_arrowhead_and_label():
+    source = "graph TD\nA-->|again|A\n"
+    lines = render_flowchart(source, width=80)
+    assert lines
+    text = "\n".join(lines)
+    assert "A" in text
+    assert "again" in text
+    assert _ARROW_RE.search(text)
+    box_right_col = max(line.index("\u2510") for line in lines if "\u2510" in line)
+    assert any(len(line.rstrip()) > box_right_col + 1 for line in lines)
+
+
 # --------------------------------------------------------------------------
 # Multi-parent DAG — both edges attach to the shared child
 # --------------------------------------------------------------------------
@@ -161,8 +222,32 @@ def test_empty_body_headed_diagram_raw_echoes():
     assert not _BOX_GLYPH_RE.search(text)
 
 
-def test_render_flowchart_never_raises_on_garbage_input():
-    # Defensive: assorted odd inputs must never raise, always return a list.
+def test_degraded_echo_sanitizes_box_glyphs_present_in_raw_source():
+    # Regression: the raw-echo path used to be a plain rstrip of the
+    # source, so a literal box-drawing/geometric glyph typed into
+    # otherwise-malformed source (e.g. a stray "\u250c") survived into the
+    # echo, which the downstream attach viewer could misdetect as a
+    # successful render. The echo must now contain NONE of those glyphs.
+    source = "not a diagram\n\u250c\n"
+    lines = render_flowchart(source, width=80)
+    text = "\n".join(lines)
+    assert not _BOX_GLYPH_RE.search(text)
+    assert lines[0] == "not a diagram"
+    assert "\u250c" not in lines[1]
+
+
+def test_render_flowchart_never_raises_and_degrades_cleanly_on_garbage_input():
+    # Defensive: assorted odd inputs must never raise. A bare
+    # "isinstance(lines, list)" would also accept a renderer that returned
+    # `[]`, a raw echo, or a bogus boxed diagram for every case — assert
+    # the actual degradation semantics instead: whichever inputs don't
+    # render real box glyphs must be an *exact* rstripped echo of the
+    # source (the load-bearing contract), not merely "some list".
     for source in ("", "\n\n\n", "graph", "flowchart LR\n", "graph TD\nA-->\n"):
         lines = render_flowchart(source, width=80)
         assert isinstance(lines, list)
+        text = "\n".join(lines)
+        if not _BOX_GLYPH_RE.search(text):
+            assert lines == [line.rstrip() for line in source.splitlines()], (
+                f"degraded output for {source!r} must be an exact raw echo, got {lines!r}"
+            )

{termrender-4.6.1 → termrender-4.6.2}/tests/test_mermaid_flow_corpus.py

@@ -195,12 +195,17 @@ def test_edge_style_bidirectional_golden():
 
 
 def test_pipe_label_golden():
+    # The rank-band gap widens to fit the label in full (see
+    # mermaid_flow_layout._rank_gap_overrides) — a 2-char label needs a
+    # taller gap than the base _ROW_GAP alone provides.
     assert _lines("graph TD\nA-->|hi|B\n") == [
         "┌───┐",
         "│ A │",
         "└───┘",
+        "  │",
         " hi",
         "  │",
+        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",
@@ -208,12 +213,19 @@ def test_pipe_label_golden():
 
 
 def test_inline_label_golden():
+    # Same rank-band widening as above, scaled to the longer "go now" label.
     assert _lines("graph TD\nA -- go now --> B\n") == [
         "┌───┐",
         "│ A │",
         "└───┘",
+        "  │",
+        "  │",
+        "  │",
         "go now",
         "  │",
+        "  │",
+        "  │",
+        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",

{termrender-4.6.1 → termrender-4.6.2}/tests/test_mermaid_flow_layout.py

@@ -27,6 +27,14 @@ from termrender.renderers.mermaid_flow_model import (
 )
 
 _BOX_GLYPH_RE = re.compile(r"[\u2500-\u259F\u25A0-\u25FF]")
+_ARROW_RE = re.compile(r"[\u25b2\u25bc\u25b6\u25c0]")  # ▲▼▶◀
+
+
+def _row_of(lines: list[str], label: str) -> int:
+    for i, line in enumerate(lines):
+        if label in line:
+            return i
+    raise AssertionError(f"label {label!r} not found in rendered output: {lines!r}")
 
 
 def _node(id_: str, label: str | None = None, shape: NodeShape = NodeShape.RECT) -> FlowNode:
@@ -167,6 +175,10 @@ def test_wide_fanout_siblings_do_not_overlap():
 
 
 def test_cycle_lays_out_without_hanging():
+    # Real topology, not just "didn't hang": the forward chain A -> B -> C
+    # still orders top-to-bottom despite the C -> A back-edge, and a
+    # back-edge arrowhead actually lands (somewhere) rather than being
+    # silently dropped.
     g = FlowGraph(
         direction=Direction.TB,
         nodes=[_node("A"), _node("B"), _node("C")],
@@ -178,10 +190,17 @@ def test_cycle_lays_out_without_hanging():
     for label in ("A", "B", "C"):
         assert label in text
     assert any(_BOX_GLYPH_RE.search(line) for line in lines)
+    assert _ARROW_RE.search(text)
+    assert _row_of(lines, "A") < _row_of(lines, "B") < _row_of(lines, "C")
 
 
 def test_labeled_back_edge_cycle_does_not_crash():
-    # The exact shape that panics the Go binary: a labeled back-edge.
+    # The exact shape that panics the Go binary: a labeled back-edge. Real
+    # assertions: the "retry" label itself survives, an arrowhead lands,
+    # and the forward chain's top-to-bottom order is unaffected by the
+    # back-edge — a renderer that silently dropped the labeled back-edge
+    # (but kept the two forward edges) would otherwise still pass this test
+    # if it only checked "didn't crash".
     g = FlowGraph(
         direction=Direction.TB,
         nodes=[_node("A"), _node("B"), _node("C")],
@@ -193,10 +212,19 @@ def test_labeled_back_edge_cycle_does_not_crash():
     )
     lines = layout_flowgraph(g, width=80)
     assert lines
+    text = "\n".join(lines)
     assert any(_BOX_GLYPH_RE.search(line) for line in lines)
+    assert "retry" in text
+    assert _ARROW_RE.search(text)
+    assert _row_of(lines, "A") < _row_of(lines, "B") < _row_of(lines, "C")
 
 
-def test_self_loop_does_not_crash():
+def test_self_loop_renders_visible_loop_and_arrowhead():
+    # A renderer that silently dropped every self-loop would still pass a
+    # bare "non-empty output containing A and B" check — assert the loop's
+    # actual geometry instead: an arrowhead, and line glyphs extending
+    # visibly past the node box's own border (a dropped self-loop renders
+    # only the bare box, whose lines never exceed its own right border).
     g = FlowGraph(
         direction=Direction.TB,
         nodes=[_node("A"), _node("B")],
@@ -206,6 +234,27 @@ def test_self_loop_does_not_crash():
     assert lines
     text = "\n".join(lines)
     assert "A" in text and "B" in text
+    assert _ARROW_RE.search(text)
+    box_right_col = max(line.index("\u2510") for line in lines if "\u2510" in line)
+    assert any(len(line.rstrip()) > box_right_col + 1 for line in lines), (
+        "expected loop glyphs extending past a node box's right border"
+    )
+
+
+def test_labeled_self_loop_renders_loop_arrowhead_and_label():
+    g = FlowGraph(
+        direction=Direction.TB,
+        nodes=[_node("A")],
+        edges=[_edge("A", "A", label="again")],
+    )
+    lines = layout_flowgraph(g, width=80)
+    assert lines
+    text = "\n".join(lines)
+    assert "A" in text
+    assert "again" in text
+    assert _ARROW_RE.search(text)
+    box_right_col = max(line.index("\u2510") for line in lines if "\u2510" in line)
+    assert any(len(line.rstrip()) > box_right_col + 1 for line in lines)
 
 
 # --------------------------------------------------------------------------
@@ -214,7 +263,11 @@ def test_self_loop_does_not_crash():
 
 
 @pytest.mark.parametrize("direction", [Direction.TB, Direction.LR, Direction.RL, Direction.BT])
-def test_all_directions_render_without_crashing(direction):
+def test_all_directions_place_nodes_along_the_correct_axis(direction):
+    # A direction-blind renderer (e.g. one that ignored LR/RL/BT and always
+    # laid out top-to-bottom) would still pass a bare "doesn't crash, all
+    # labels present" check for every direction — assert each direction's
+    # actual rank-flow axis and sign instead.
     g = FlowGraph(
         direction=direction,
         nodes=[_node("A"), _node("B"), _node("C")],
@@ -222,11 +275,27 @@ def test_all_directions_render_without_crashing(direction):
     )
     lines = layout_flowgraph(g, width=80)
     assert lines
-    text = "\n".join(lines)
-    for label in ("A", "B", "C"):
-        assert label in text
     assert any(_BOX_GLYPH_RE.search(line) for line in lines)
 
+    row: dict[str, int] = {}
+    col: dict[str, int] = {}
+    for label in ("A", "B", "C"):
+        for i, line in enumerate(lines):
+            if label in line:
+                row[label] = i
+                col[label] = line.index(label)
+                break
+        assert label in row, f"label {label!r} not found in rendered output: {lines!r}"
+
+    if direction is Direction.TB:
+        assert row["A"] < row["B"] < row["C"]
+    elif direction is Direction.BT:
+        assert row["A"] > row["B"] > row["C"]
+    elif direction is Direction.LR:
+        assert col["A"] < col["B"] < col["C"]
+    else:  # Direction.RL
+        assert col["A"] > col["B"] > col["C"]
+
 
 def test_lr_direction_no_overlap():
     from termrender.renderers.mermaid_flow_layout import _place_nodes
@@ -278,18 +347,32 @@ def test_fully_isolated_nodes_no_edges():
 
 
 def test_edges_draw_visible_line_glyphs_between_boxes():
-    g = FlowGraph(
-        direction=Direction.TB,
-        nodes=[_node("A"), _node("B")],
-        edges=[_edge("A", "B")],
-    )
+    # The old version of this test accepted plain box-border glyphs
+    # (┌┐└┘) in its allowed set, so it passed even for a graph with NO
+    # edge at all (the two node boxes alone contain those glyphs). Tighten
+    # by inspecting the *inter-box gap rows* specifically — guaranteed
+    # clear of any box by construction (the layout enforces a non-zero
+    # rank gap) — and require a routed line/arrow glyph there; a deleted
+    # edge router would leave those rows blank.
+    from termrender.renderers.mermaid_flow_layout import _place_nodes
+
+    nodes = [_node("A"), _node("B")]
+    edges = [_edge("A", "B")]
+    rects = _place_nodes(nodes, edges, Direction.TB)
+    a, b = rects["A"], rects["B"]
+    gap_lo, gap_hi = a.y + a.h, b.y
+    assert gap_hi > gap_lo, "expected a real inter-rank gap between the two boxes"
+
+    g = FlowGraph(direction=Direction.TB, nodes=nodes, edges=edges)
     lines = layout_flowgraph(g, width=80)
-    text = "\n".join(lines)
-    # A vertical or horizontal line-run glyph should appear somewhere
-    # between the two boxes (not just the box borders themselves).
+    gap_rows = lines[gap_lo:gap_hi]
+    assert gap_rows, "expected rendered rows in the inter-box gap"
     line_glyphs = {"\u2502", "\u2500", "\u250c", "\u2510", "\u2514", "\u2518",
-                   "\u251c", "\u2524", "\u252c", "\u2534", "\u253c"}
-    assert any(ch in text for ch in line_glyphs)
+                   "\u251c", "\u2524", "\u252c", "\u2534", "\u253c",
+                   "\u25b2", "\u25bc", "\u25b6", "\u25c0"}
+    assert any(ch in row for row in gap_rows for ch in line_glyphs), (
+        f"expected a routed edge glyph strictly between the two boxes, got {gap_rows!r}"
+    )
 
 
 def test_dangling_edge_reference_is_ignored_not_raised():
@@ -375,8 +458,12 @@ def test_boxrect_anchor_points():
 # --------------------------------------------------------------------------
 
 
-def test_never_raises_on_odd_but_well_typed_input():
-    # Empty label, width-1 canvases, duplicate edges — should degrade, not raise.
+def test_duplicate_edges_and_empty_labels_render_without_raising():
+    # Empty label, width-1 canvases, duplicate edges must never raise —
+    # and, since this is otherwise a perfectly well-typed two-node graph,
+    # it should still render its two real boxes rather than silently
+    # degrading (a bare "isinstance(lines, list)" would also accept an
+    # empty-list degradation or a raised-then-caught garbage result).
     g = FlowGraph(
         direction=Direction.TB,
         nodes=[_node("A", label=""), _node("B", label="")],
@@ -384,3 +471,6 @@ def test_never_raises_on_odd_but_well_typed_input():
     )
     lines = layout_flowgraph(g, width=1)
     assert isinstance(lines, list)
+    assert lines, "a well-typed non-empty graph must still render"
+    text = "\n".join(lines)
+    assert text.count("\u250c") == 2, "expected exactly the two declared node boxes"