termrender 4.10.0__tar.gz → 4.10.2__tar.gz

{termrender-4.10.0 → termrender-4.10.2}/CHANGELOG.md

@@ -1,6 +1,38 @@
 # CHANGELOG
 
 
+## v4.10.2 (2026-07-07)
+
+### Bug Fixes
+
+- **mermaid-flow**: Split entry anchors and cjk labels
+  ([`0d5160d`](https://github.com/crouton-labs/termrender/commit/0d5160d18f719f3045e552236e38b640ab967b13))
+
+
+## v4.10.1 (2026-07-07)
+
+### Bug Fixes
+
+- **mermaid-flow**: Constant inter-layer gap regardless of node height
+  ([`eb1726f`](https://github.com/crouton-labs/termrender/commit/eb1726fa4bd05a57d29026b10715edc067ac4113))
+
+The rank-band gap override that widens spacing to fit a labeled edge scaled with visual_len(label)
+  (the label's *text width*) even on TB/BT diagrams, where the label is drawn horizontally across a
+  vertical connector and only ever needs one clear row, not one row per character. Since ER/class
+  diagrams route almost every edge through a label (relationship text, cardinality), this made
+  compartmented-node TB layouts burn ~15-17 blank connector rows per edge hop while 1-line-node
+  flowcharts stayed compact — node height was a red herring; the real driver was label width feeding
+  a row count.
+
+_rank_gap_overrides is now direction-aware: LR/RL keeps the width-scaled gap (the transpose turns
+  that native row-band into the final horizontal run the label reads along, so it genuinely needs
+  the width). TB/BT gets a small constant, _LABELED_ROW_GAP=3, regardless of label length.
+
+Updates the two TB labeled-edge goldens in test_mermaid_flow_corpus.py to the new compact spacing,
+  and adds a regression test in test_mermaid_er.py pinning a row budget for compartmented entities
+  so this doesn't regress.
+
+
 ## v4.10.0 (2026-07-07)
 
 ### Features

{termrender-4.10.0 → termrender-4.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 4.10.0
+Version: 4.10.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.10.0 → termrender-4.10.2}/src/termrender/renderers/mermaid_flow_layout.py

@@ -831,24 +831,45 @@ _GAP_X = 3          # minimum border-to-border gap between boxes in one rank/ban
 _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.
+                     # when it forces a rank-band gap wider than _ROW_GAP
+                     # along the axis the label's text actually runs.
+_LABELED_ROW_GAP = 3  # inter-rank gap when a label sits on that band's vertical
+                      # run in *final* screen space (TB/BT): one blank row, the
+                      # label's own row, one more blank row. A constant, not
+                      # scaled by the label's text length — the label reads
+                      # horizontally on a single row regardless of how many
+                      # characters it has, so the row *count* needed is fixed.
 
 
 def _rank_gap_overrides(
-    edges: list[FlowEdge], rank_of: dict[str, int]
+    edges: list[FlowEdge], rank_of: dict[str, int], direction: Direction
 ) -> 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.
+    this gap.
+
+    The rank axis is native rows here, pre-direction-transform (see the
+    adapter docstring) — whether that ends up as *vertical* or
+    *horizontal* space on screen depends on ``direction``. For LR/RL the
+    transpose turns this band into the final horizontal run the label
+    reads along, so it genuinely needs ``visual_len(label)`` cells of
+    width — at the base ``_ROW_GAP`` a label wider than a couple of cells
+    has nowhere to go but onto the boxes it connects (the short
+    LR/adjacent-rank clipped-label bug this closes). For TB/BT the band
+    stays vertical on screen and the label is drawn horizontally *across*
+    the connector column (:func:`_draw_label_on_segment`'s vertical-segment
+    branch) — it needs a little row headroom to have its own clear row,
+    not a row per character, so it gets the small constant
+    ``_LABELED_ROW_GAP`` regardless of the label's length.
+
     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] = {}
+    horizontal_on_screen = direction in (Direction.LR, Direction.RL)
     for e in edges:
         if e.src == e.dst or not e.label:
             continue
@@ -859,7 +880,10 @@ def _rank_gap_overrides(
         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
+        if horizontal_on_screen:
+            needed = visual_len(e.label) + 2 * _LABEL_GAP_PAD
+        else:
+            needed = _LABELED_ROW_GAP
         overrides[lo_r] = max(overrides.get(lo_r, _ROW_GAP), needed)
     return overrides
 
@@ -922,7 +946,7 @@ def _place_nodes(
             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)
+        gap_overrides = _rank_gap_overrides(edges, rank_of, direction)
 
         band_top_for_rank: dict[int, int] = {}
         cursor = 0
@@ -1464,69 +1488,40 @@ def _classify_edge(
     return "forward" if forward else "back"
 
 
-def _allocate_edge_anchors(
+def _spread_group_anchors(
     rects: dict[str, BoxRect],
     direction: Direction,
     edges: list[FlowEdge],
-    nodes: list[FlowNode] | None = None,
+    node_by_id: dict[str, "FlowNode"],
+    groups: dict[tuple[str, str], list[int]],
+    is_marked,
+    other_end,
 ) -> dict[int, tuple[int, int]]:
-    """Pre-pass over every edge: group forward/back edges by the exit side
-    they share with sibling edges leaving the *same* node (``(src, exit
-    side)`` for forward edges, ``(src, lane side)`` for back-edges), and
-    spread a group's anchor points along that side's usable span (see
-    :func:`_side_interior_span`) — but **only** when 2+ of that group's
-    edges carry a source-side arrow marker (``src_arrow`` or a non-default
-    ``src_arrow_kind`` — the UML composition/aggregation case documented
-    in ``mermaid_class.py``). Left stacked on one shared anchor otherwise
-    (the overwhelming majority of groups): a plain, markerless multi-edge
-    fan-out (``A-->B; A-->C``) *relies* on sharing one exit cell for its
-    trunk-then-tee look (draw_segment's junction bitmask resolves the
-    shared point into a single ┬/┴, not two disjoint stubs) — spreading it
-    would only change this module's own aesthetic choice of where the fan
-    visually splits, not fix anything, and would break that look for every
-    existing fan-out/merge golden. A marker glyph, unlike a plain line
-    junction, has no such union — two different marker glyphs landing on
-    one cell just silently lose all but the last-drawn one, which is the
-    actual defect this closes. (The sibling label-collision defect — two
-    edges from a shared exit tying for "longest straight run" so a second
-    label lands on cells the first already claimed — is fixed separately,
-    in :func:`_longest_segment`'s tie-break, since it needs no anchor
-    change at all.) Returns a dict keyed by index into ``edges``; an edge
-    absent from it keeps the engine's single fixed exit anchor
-    (:func:`_forward_exit`/:func:`_lane_anchor`) unchanged. Same-rank
-    edges and self-loops are never grouped here — same-rank anchors are
-    already per-pair (:func:`_facing_anchor`, dynamic per destination, not
-    a fixed shared side), and self-loops already stack via their own
-    ``self_loop_counter``-driven reach.
+    """Shared spreading logic behind :func:`_allocate_edge_anchors`'s two
+    passes (source exits, destination entries): for each ``(node_id,
+    side)`` group of 2+ edges that share a border side at ``node_id``,
+    spread their anchor points along that side's usable span (see
+    :func:`_side_interior_span`) — but only when 2+ of the group's edges
+    are ``is_marked`` (carry an arrow marker on the end at ``node_id``).
+    ``other_end(edge)`` gives the node id at the *other* end of an edge,
+    used only to order the spread left-to-right/top-to-bottom by where
+    each edge's far endpoint sits off-axis, so the spread reads in the
+    same visual order the paths already fan out in. Returns a dict keyed
+    by index into ``edges``; groups left ungrouped (size < 2) or
+    under-marked (< 2 marked) are entirely absent from it.
     """
-    node_by_id = {n.id: n for n in (nodes or [])}
-    groups: dict[tuple[str, str], list[int]] = defaultdict(list)
-    for i, e in enumerate(edges):
-        if e.src == e.dst:
-            continue
-        kind = _classify_edge(rects, direction, e)
-        if kind == "forward":
-            groups[(e.src, _forward_exit_side(direction))].append(i)
-        elif kind == "back":
-            groups[(e.src, _lane_side(direction))].append(i)
-        # "same-rank" / None (dangling): no override, unchanged behavior.
-
     overrides: dict[int, tuple[int, int]] = {}
     for (node_id, side), idxs in groups.items():
         if len(idxs) < 2:
             continue
-        marked = [
-            i
-            for i in idxs
-            if edges[i].src_arrow or edges[i].src_arrow_kind != "default"
-        ]
+        marked = [i for i in idxs if is_marked(edges[i])]
         if len(marked) < 2:
             continue
         rect = rects.get(node_id)
         if rect is None:
             continue
         ordered = sorted(
-            idxs, key=lambda i: _abstract(direction, rects[edges[i].dst].center)[1]
+            idxs, key=lambda i: _abstract(direction, rects[other_end(edges[i])].center)[1]
         )
         lo, hi = _side_span_for_node(node_by_id.get(node_id), rect, side)
         spread = _spread_points(lo, hi, len(ordered))
@@ -1535,6 +1530,94 @@ def _allocate_edge_anchors(
     return overrides
 
 
+def _allocate_edge_anchors(
+    rects: dict[str, BoxRect],
+    direction: Direction,
+    edges: list[FlowEdge],
+    nodes: list[FlowNode] | None = None,
+) -> tuple[dict[int, tuple[int, int]], dict[int, tuple[int, int]]]:
+    """Pre-pass over every edge: group forward/back edges by the border
+    side they share with sibling edges at the *same* node, on **both**
+    ends independently — exit side at the source (``(src, exit side)`` for
+    forward edges, ``(src, lane side)`` for back-edges) and entry side at
+    the destination (``(dst, entry side)`` for forward edges, ``(dst, lane
+    side)`` for back-edges, since a back-edge's destination anchor is also
+    :func:`_lane_anchor`, the same physical side as its source anchor).
+    Within each group, spread the anchor points along that side's usable
+    span (see :func:`_side_interior_span`) — but **only** when 2+ of the
+    group's edges carry an arrow marker on the end at that shared node.
+    The two ends use different tests, deliberately not symmetric in *how*
+    they detect a marker even though the spreading they trigger is: an
+    exit group tests ``src_arrow or src_arrow_kind != "default"`` (a
+    source-side arrowhead of any kind is already rare — most edges have
+    none — so its mere presence is already a meaningful signal), while an
+    entry group tests only ``dst_arrow_kind != "default"`` (a
+    destination-side arrowhead is the *default* for an ordinary ``-->``
+    edge — ``dst_arrow`` is ``True`` almost everywhere — so testing its
+    bare presence would spread every ordinary fan-in; only a non-default
+    *kind*, the UML composition/aggregation diamond case documented in
+    ``mermaid_class.py``, is the actual collision this closes). Left
+    stacked on one shared anchor otherwise (the overwhelming majority of
+    groups): a plain, markerless
+    multi-edge fan-out (``A-->B; A-->C``) or fan-in (``A-->C; B-->C``)
+    *relies* on sharing one exit/entry cell for its trunk-then-tee look
+    (draw_segment's junction bitmask resolves the shared point into a
+    single ┬/┴, not two disjoint stubs) — spreading it would only change
+    this module's own aesthetic choice of where the fan visually splits,
+    not fix anything, and would break that look for every existing fan-
+    out/merge golden. A marker glyph, unlike a plain line junction, has no
+    such union — two different marker glyphs landing on one cell just
+    silently lose all but the last-drawn one, which is the actual defect
+    this closes, on whichever end (source or destination) carries the
+    colliding markers. (The sibling label-collision defect — two edges
+    from a shared exit tying for "longest straight run" so a second label
+    lands on cells the first already claimed — is fixed separately, in
+    :func:`_longest_segment`'s tie-break, since it needs no anchor change
+    at all.) Returns a ``(exit_overrides, entry_overrides)`` pair, each a
+    dict keyed by index into ``edges``; an edge absent from one keeps the
+    engine's single fixed anchor on that end (:func:`_forward_exit`/
+    :func:`_forward_entry`/:func:`_lane_anchor`) unchanged. Same-rank
+    edges and self-loops are never grouped here — same-rank anchors are
+    already per-pair (:func:`_facing_anchor`, dynamic per destination, not
+    a fixed shared side), and self-loops already stack via their own
+    ``self_loop_counter``-driven reach.
+    """
+    node_by_id = {n.id: n for n in (nodes or [])}
+    exit_groups: dict[tuple[str, str], list[int]] = defaultdict(list)
+    entry_groups: dict[tuple[str, str], list[int]] = defaultdict(list)
+    for i, e in enumerate(edges):
+        if e.src == e.dst:
+            continue
+        kind = _classify_edge(rects, direction, e)
+        if kind == "forward":
+            exit_groups[(e.src, _forward_exit_side(direction))].append(i)
+            entry_groups[(e.dst, _forward_entry_side(direction))].append(i)
+        elif kind == "back":
+            exit_groups[(e.src, _lane_side(direction))].append(i)
+            entry_groups[(e.dst, _lane_side(direction))].append(i)
+        # "same-rank" / None (dangling): no override, unchanged behavior.
+
+    exit_overrides = _spread_group_anchors(
+        rects,
+        direction,
+        edges,
+        node_by_id,
+        exit_groups,
+        lambda e: e.src_arrow or e.src_arrow_kind != "default",
+        lambda e: e.dst,
+    )
+    entry_overrides = _spread_group_anchors(
+        rects,
+        direction,
+        edges,
+        node_by_id,
+        entry_groups,
+        lambda e: e.dst_arrow_kind != "default",
+        lambda e: e.src,
+    )
+    return exit_overrides, entry_overrides
+
+
 def _abstract(direction: Direction, point: tuple[int, int]) -> tuple[int, int]:
     """``point`` decomposed into (primary, secondary) = (rank-axis coord,
     off-axis coord) — the coordinate frame the path-shape helpers reason
@@ -1657,6 +1740,53 @@ def _reserve_label_margin(canvas: Canvas, x: int, y: int) -> None:
     canvas.set_char(x, y, canvas.get_char(x, y), reserve=True)
 
 
+def _label_cell_widths(label: str) -> list[int]:
+    """Per-character visual width of ``label``, as successive
+    :func:`~termrender.style.visual_len` prefix deltas — a wide
+    CJK/fullwidth character reports ``2`` here without this module
+    needing to duplicate ``visual_len``'s own east-asian-width table (the
+    deltas telescope to ``visual_len(label)`` by construction, so this
+    always agrees with the total cell count :func:`_draw_label_on_segment`
+    already reserves for the label)."""
+    widths = []
+    prev = 0
+    for i in range(1, len(label) + 1):
+        cur = visual_len(label[: i])
+        widths.append(cur - prev)
+        prev = cur
+    return widths
+
+
+def _write_label_run(
+    canvas: Canvas, start: int, row: int, label: str, check_reserved: bool
+) -> None:
+    """Write ``label`` into row ``row`` starting at column ``start``,
+    advancing the write cursor by each character's own visual width (see
+    :func:`_label_cell_widths`) instead of one grid cell per Python code
+    point. A single-width character still occupies just its one cell; a
+    wide CJK/fullwidth character's glyph lands in its first cell only,
+    and the *next* cell it visually covers is marked reserved and left
+    blank — without this, that second cell stays unreserved and a
+    connector glyph drawn earlier (edges draw before labels, see
+    :func:`layout_flowgraph`) remains visible inside the label's own
+    visual width. ``check_reserved`` mirrors the two call sites' existing
+    behavior: the "clear run found" placement writes unconditionally (the
+    whole run was already verified clear by the caller), the
+    overflow-tolerated fallback placement instead skips any individual
+    cell that's already reserved, one cell at a time (never overwriting a
+    box).
+    """
+    x = start
+    for ch, w in zip(label, _label_cell_widths(label)):
+        if not check_reserved or not canvas.is_reserved(x, row):
+            canvas.set_char(x, row, ch, reserve=True)
+        for extra in range(1, w):
+            cx = x + extra
+            if not check_reserved or not canvas.is_reserved(cx, row):
+                canvas.set_char(cx, row, "", reserve=True)
+        x += w
+
+
 def _draw_label_on_segment(
     canvas: Canvas, a: tuple[int, int], b: tuple[int, int], label: str
 ) -> None:
@@ -1693,15 +1823,12 @@ def _draw_label_on_segment(
         for start in _label_positions(length, center, lo, hi):
             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.set_char(px, py, ch, reserve=True)
+                _write_label_run(canvas, start, row, label, check_reserved=False)
                 _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.set_char(px, py, ch, reserve=True)
+        _write_label_run(canvas, start, row, label, check_reserved=True)
         return
 
     # Vertical segment: the label still reads horizontally, centered on
@@ -1721,14 +1848,11 @@ def _draw_label_on_segment(
     for row in _label_positions(1, center_row, lo, hi):
         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.set_char(px, py, ch, reserve=True)
+            _write_label_run(canvas, start_x, row, label, check_reserved=False)
             _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.set_char(px, py, ch, reserve=True)
+    _write_label_run(canvas, start_x, center_row, label, check_reserved=True)
 
 
 def _draw_polyline(canvas: Canvas, points: list[tuple[int, int]], style: EdgeStyle) -> None:
@@ -1785,6 +1909,7 @@ def _route_edge_path(
     lane_counter: list[int],
     self_loop_counter: dict[str, int],
     exit_anchor: tuple[int, int] | None = None,
+    entry_anchor: tuple[int, int] | None = None,
 ) -> 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
@@ -1794,13 +1919,14 @@ def _route_edge_path(
     return ``None`` (defensive no-op — the parser guarantees valid
     endpoints; this module never crashes on one).
 
-    ``exit_anchor``, when given (from :func:`_allocate_edge_anchors`),
-    replaces the src border point that would otherwise come from
-    :func:`_forward_exit`/:func:`_lane_anchor` — used only when this
-    edge's exit side is shared with a sibling edge that also carries a
-    source-side arrow marker; ``None`` (the overwhelming common case)
-    reproduces the original single-anchor behavior exactly. Same-rank
-    edges and self-loops ignore it (see :func:`_allocate_edge_anchors`'s
+    ``exit_anchor``/``entry_anchor``, when given (from
+    :func:`_allocate_edge_anchors`), replace the src/dst border point that
+    would otherwise come from :func:`_forward_exit`/:func:`_forward_entry`/
+    :func:`_lane_anchor` — used only when this edge's exit/entry side is
+    shared with a sibling edge that also carries an arrow marker on that
+    same end; ``None`` (the overwhelming common case, for either) reproduces
+    the original single-anchor behavior exactly on that end. Same-rank
+    edges and self-loops ignore both (see :func:`_allocate_edge_anchors`'s
     docstring for why).
     """
     src_rect = rects.get(edge.src)
@@ -1820,7 +1946,8 @@ def _route_edge_path(
 
     if kind == "forward":
         exit_pt = exit_anchor if exit_anchor is not None else _forward_exit(direction, src_rect)
-        return _z_path(direction, exit_pt, _forward_entry(direction, dst_rect))
+        entry_pt = entry_anchor if entry_anchor is not None else _forward_entry(direction, dst_rect)
+        return _z_path(direction, exit_pt, entry_pt)
 
     lane = lane_counter[0]
     lane_counter[0] += 1
@@ -1830,9 +1957,8 @@ def _route_edge_path(
         + lane * _LANE_GAP
     )
     exit_pt = exit_anchor if exit_anchor is not None else _lane_anchor(direction, src_rect)
-    return _lane_path(
-        direction, exit_pt, _lane_anchor(direction, dst_rect), lane_secondary
-    )
+    entry_pt = entry_anchor if entry_anchor is not None else _lane_anchor(direction, dst_rect)
+    return _lane_path(direction, exit_pt, entry_pt, lane_secondary)
 
 
 # --------------------------------------------------------------------------
@@ -1909,7 +2035,9 @@ def layout_flowgraph(g: FlowGraph, width: int) -> list[str]:
         # a cell — labels are only ever safe once no more lines are coming.
         lane_counter = [0]
         self_loop_counter: dict[str, int] = {}
-        exit_overrides = _allocate_edge_anchors(rects, g.direction, g.edges, g.nodes)
+        exit_overrides, entry_overrides = _allocate_edge_anchors(
+            rects, g.direction, g.edges, g.nodes
+        )
         edge_paths: list[tuple[FlowEdge, list[tuple[int, int]]]] = []
         for i, e in enumerate(g.edges):
             points = _route_edge_path(
@@ -1919,6 +2047,7 @@ def layout_flowgraph(g: FlowGraph, width: int) -> list[str]:
                 lane_counter,
                 self_loop_counter,
                 exit_overrides.get(i),
+                entry_overrides.get(i),
             )
             if points is not None:
                 edge_paths.append((e, points))

{termrender-4.10.0 → termrender-4.10.2}/tests/test_mermaid_er.py

@@ -265,6 +265,66 @@ def test_order_example_golden_topology():
     assert cust_row < order_row < line_item_row
 
 
+# --------------------------------------------------------------------------
+# Vertical compactness (regression: constant inter-layer gap regardless of
+# node height — see mermaid_flow_layout._LABELED_ROW_GAP)
+# --------------------------------------------------------------------------
+
+
+def test_compartmented_entities_get_constant_gap_not_height_scaled():
+    # Two tall (compartmented) entities joined by one labeled relationship
+    # used to burn ~15-17 blank connector rows for this single edge hop —
+    # the inter-rank gap scaled with the edge label's *text length*
+    # (visual_len), not with node height, but on ER/class diagrams nearly
+    # every edge carries a label, so the effect showed up exactly when
+    # nodes were tall. The gap between adjacent-rank boxes must now stay a
+    # small constant: enough for a connector row, the label's own row, and
+    # one more connector row — independent of both the label's length and
+    # the boxes' height.
+    src = (
+        "erDiagram\n"
+        "    CUSTOMER ||--o{ ORDER : places\n"
+        "    CUSTOMER {\n"
+        "        string name PK\n"
+        "        string email\n"
+        "    }\n"
+        "    ORDER {\n"
+        "        int orderNumber PK\n"
+        "        string status\n"
+        "    }\n"
+    )
+    lines = _lines(src, width=100)
+    assert _has_box_glyphs(lines)
+    joined = "\n".join(lines)
+
+    # Full row budget: two 6-row compartmented boxes plus a small constant
+    # gap between them — well under the ~27 rows the scaling bug produced.
+    assert len(lines) <= 18, f"expected a compact render, got {len(lines)} rows:\n{joined}"
+
+    # The label survives in full, uncorrupted, and every box border row is
+    # single-glyph clean (no overlapping glyphs from a collapsed gap).
+    assert "places" in joined
+    for attr in ("string name PK", "string email", "int orderNumber PK", "string status"):
+        assert attr in joined
+
+    cust_row, _ = _row_col(lines, "CUSTOMER")
+    order_row, _ = _row_col(lines, "ORDER")
+    label_row, _ = _row_col(lines, "places")
+    assert cust_row < label_row < order_row
+
+    # The connector gap between the two boxes is a small constant, not
+    # scaled by the label's width: the blank/connector run directly above
+    # and below the label row is short.
+    cust_bottom = next(
+        r for r in range(cust_row, len(lines)) if "└" in lines[r]
+    )
+    order_top = next(
+        r for r in range(order_row, -1, -1) if "┌" in lines[r]
+    )
+    gap_rows = order_top - cust_bottom - 1
+    assert gap_rows <= 5, f"inter-layer gap grew to {gap_rows} rows:\n{joined}"
+
+
 # --------------------------------------------------------------------------
 # Degradation: malformed input, empty body, literal-glyph sanitization
 # --------------------------------------------------------------------------

{termrender-4.10.0 → termrender-4.10.2}/tests/test_mermaid_flow_corpus.py

@@ -195,9 +195,10 @@ 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.
+    # The rank-band gap widens past the unlabeled _ROW_GAP to a small
+    # constant (see mermaid_flow_layout._LABELED_ROW_GAP) so the label gets
+    # its own clear row — the constant does not scale with the label's
+    # text length.
     assert _lines("graph TD\nA-->|hi|B\n") == [
         "┌───┐",
         "│ A │",
@@ -205,7 +206,6 @@ def test_pipe_label_golden():
         "  │",
         " hi",
         "  │",
-        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",
@@ -213,19 +213,16 @@ def test_pipe_label_golden():
 
 
 def test_inline_label_golden():
-    # Same rank-band widening as above, scaled to the longer "go now" label.
+    # Same constant rank-band gap as above — "go now" is longer than "hi"
+    # but the vertical gap stays the same _LABELED_ROW_GAP; only the
+    # label's own row is wider.
     assert _lines("graph TD\nA -- go now --> B\n") == [
         "┌───┐",
         "│ A │",
         "└───┘",
         "  │",
-        "  │",
-        "  │",
         "go now",
         "  │",
-        "  │",
-        "  │",
-        "  │",
         "┌─▼─┐",
         "│ B │",
         "└───┘",

{termrender-4.10.0 → termrender-4.10.2}/tests/test_mermaid_flow_layout.py

@@ -474,3 +474,66 @@ def test_duplicate_edges_and_empty_labels_render_without_raising():
     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"
+
+
+# --------------------------------------------------------------------------
+# Destination-side marker anchors (regression: _allocate_edge_anchors used to
+# spread shared *source* exits only, so 2+ edges entering one node with
+# different destination-end markers all landed on the single fixed
+# _forward_entry anchor and silently lost all but the last-drawn glyph)
+# --------------------------------------------------------------------------
+
+
+def test_two_destination_side_markers_into_one_node_both_survive():
+    g = FlowGraph(
+        direction=Direction.TB,
+        nodes=[_node("A"), _node("B"), _node("C")],
+        edges=[
+            _edge("A", "C", dst_arrow_kind="diamond_filled"),
+            _edge("B", "C", dst_arrow_kind="diamond_hollow"),
+        ],
+    )
+    lines = layout_flowgraph(g, width=80)
+    text = "\n".join(lines)
+    assert "\u25c6" in text, "diamond_filled destination marker must survive"
+    assert "\u25c7" in text, "diamond_hollow destination marker must survive"
+
+
+def test_plain_arrow_fan_in_still_shares_one_entry_anchor():
+    # Guards the deliberate scoping this fix must not break: an ordinary
+    # fan-in (no non-default dst_arrow_kind — an everyday "-->" edge
+    # already sets dst_arrow=True, so the trigger must be the *kind*, not
+    # bare arrow presence) still lands on one shared entry cell so
+    # draw_segment's junction bitmask resolves it into a single ┬/┴ trunk
+    # rather than two disjoint stubs either side of the node.
+    g = FlowGraph(
+        direction=Direction.TB,
+        nodes=[_node("A"), _node("B"), _node("C")],
+        edges=[_edge("A", "C"), _edge("B", "C")],
+    )
+    lines = layout_flowgraph(g, width=80)
+    text = "\n".join(lines)
+    assert "\u252c" in text or "\u2534" in text, "plain fan-in should keep its shared trunk look"
+
+
+# --------------------------------------------------------------------------
+# CJK edge labels (regression: label placement measured visual_len(label)
+# for reservation/search but wrote/reserved one grid cell per Python code
+# point, so a wide CJK label under-reserved and a connector glyph already
+# drawn on the segment stayed visible inside the label's own visual width)
+# --------------------------------------------------------------------------
+
+
+def test_cjk_edge_label_has_no_connector_bleed_inside_its_width():
+    g = FlowGraph(
+        direction=Direction.TB,
+        nodes=[_node("A"), _node("B")],
+        edges=[_edge("A", "B", label="\u4f60\u597d")],  # "你好"
+    )
+    lines = layout_flowgraph(g, width=80)
+    label_row = next(line for line in lines if "\u4f60\u597d" in line)
+    assert not _BOX_GLYPH_RE.search(label_row), (
+        "a connector/box glyph landed inside the CJK label's own visual width: "
+        f"{label_row!r}"
+    )
+    assert label_row.strip() == "\u4f60\u597d"