stdraw 0.7.13__py3-none-any.whl

stdraw/spinewinglayout.py

@@ -0,0 +1,329 @@
+# -*- coding: utf-8 -*-
+"""Spine-wing (central spine + midline wings) placement (2026-11-06 jacky's
+final call, B-limited edition, t_8f211f74).
+
+> jacky hand-laid the classic-cld-growth-and-burden diagram: the central
+> spine adopters (top) / rate (bottom) sits strictly vertical on the canvas
+> centerline; left wings word/potential and the right cluster crowding sit
+> on the same horizontal midline (y exactly equal); quickfix upper-right /
+> sideeffect lower-right are near-mirrored (x differs by 6px); fundamental
+> sits lower-right inside, on the same row as rate. The second form of
+> "topology should decide the layout" — a hub-pair spine + a horizontal
+> wing band + mirrored clusters beyond the wings.
+
+Trigger detection (deterministic topological metrics, written into the
+docs/layout-modes.md priority chain; this module is the source of truth):
+  - **Spine**: enumerate directed edges and take the pair with the most
+    common neighbors of the endpoints as the hub pair (ties: more
+    declared-loop co-occurrences -> smaller canonical (u,v)). The
+    "rate->adopters" diffusion hub pair of a classic CLD wins naturally
+    (measured 3 common neighbors in classic-cld; at most 2 in the rest of
+    the corpus).
+  - **Wings**: the common neighbors of the hub pair — each forms a 3-ring
+    with the hub pair (left wings word in R1 / potential in B1, right wing
+    crowding in B2), pressed onto the midline horizontal band.
+  - **Trigger conditions (all must hold):
+    (1) 3 <= |wings| <= 4 (the midline wing band needs >= 3 slots to be a
+        "band"; > 4 overloads the hub pair);
+    (2) 1 <= |rest| <= 6 AND all adjacencies of rest are within
+        spine∪wings∪rest (secondary clusters hang only on wings/hub —
+        double-axis symmetry constructibility; limits-to-growth has an
+        isomorphic spine but rest=0, a pure growth core, no trigger);
+    (3) spine length ratio = |spine| / n <= 0.5 (the hub is a compact
+        node pair; long-chain shapes belong to the column-chain criteria);
+    (4) rest is pairable: sorted by "restricted neighborhood key
+        (adjacency set against wings∪spine) -> canonical form", then
+        paired two by two with at most 1 leftover (mirror
+        constructibility — quickfix/sideeffect pair up, fundamental is
+        the leftover inside).
+  - Corpus hits (measured on a full 19-diagram sweep): only
+    classic-cld-growth-and-burden. Pure-ring family (arms-race etc.,
+    maxCN<=1), the three bowtie-vertex diagrams (maxCN=1), the two
+    bowtie-pair diagrams (maxCN=2), and the column family (maxCN<=2) all
+    miss — see the card evidence list.
+
+Placement (place_spine_wing, constructed constraints — cross-checked
+against the sample's relative geometry, not global objective-function
+terms):
+  - Spine: the hub pair is strictly vertical along layout axis x=0, edge
+    head (adopters) on top at y=-Hs and tail (rate) below at y=+Hs, with
+    Hs = 2*(card_h+GAP) (=160 @card_h 44, matching the sample's spine
+    half-distance 160);
+  - Midline wings: all wings sit at y=0 on the midline. The rest
+    cluster's anchor wing (the one with the most adjacencies to rest;
+    crowding in the sample) takes the nearest right slot; the other wings
+    are sorted by (loop kind R<B<other -> canonical form) and placed
+    left, inside-out (sample: word inside / potential outside);
+  - Rest mirror pairs: the first of each pair goes to the upper wing row
+    y=-(card_h+GAP), the second to the lower wing row y=+(card_h+GAP)
+    (=±80, idealized from the sample's ±82), stacked in one column at
+    whole pitches right of the anchor wing; a leftover goes lower-right
+    inside at y=+2*(card_h+GAP) (=+160, on rate's row; sample
+    fundamental y=532 vs rate 534, the same row band);
+  - All coordinates are even (2px grid); uniform translation to center at
+    the delivery layer is handled by layout_auto.
+
+Routing (constructed-constraint injection, not via the candidate pool):
+  - The spine edge (tail->head) is constructed as a vertical straight
+    line (bottom-edge midpoint of the top card -> top-edge midpoint of
+    the bottom card);
+  - All other edges go through the same Router candidate pool (straight
+    and arc lines as equals); line styles inside the symmetric band are
+    pressed toward straight lines by the Router tier costs (vg+120/
+    poly+40) — cross-checked against the all-straight sample;
+  - Inter-loop pairs (crowding<->quickfix, crowding<->fundamental) are
+    separated by the Router inter-loop corridor mechanism (>= 4px gate).
+
+Trial gate: reuses layout_auto._constructed_gates (box press / clearance /
+anchor smoothness / card gap / inter-loop separation / crossings <= 2); any
+failure silently falls back to the existing pattern chain (negative cases
+byte-for-byte unchanged).
+"""
+import math
+
+from . import columnlayout
+from .routing import border_point
+
+SYM_GAP = 36              # breathing-room target clearance (same tier as bowtie/symmetric)
+MAX_SPINE_WING_N = 12     # trigger upper bound: small graphs
+MIN_WINGS, MAX_WINGS = 3, 4
+MAX_REST = 6
+
+
+class InfeasibleSpineWing(Exception):
+    pass
+
+
+def _adjacency(edges):
+    adj = {v: set() for a, b in edges for v in (a, b)}
+    for a, b in edges:
+        adj[a].add(b)
+        adj[b].add(a)
+    return adj
+
+
+def _canon(seq):
+    return columnlayout._canon(seq)
+
+
+def detect_spine_wing(graph, why=None):
+    """Spine-wing detection. Returns a plan dict or None.
+
+    plan = {"spine_tail", "spine_head", "wings": {"left": [...], "anchor": w},
+            "rest_pairs": [[up, down], ...], "rest_single": [v] or [],
+            "deg0": [isolated nodes]}
+
+    why: optional dict — receives a deterministic one-line reason for the
+    outcome (mode decision trace, certificate mode_decision_trace field).
+    """
+    nodes = list(graph.node_ids())
+    edges = [(e.a, e.b) for e in graph.edges]
+    adj = _adjacency(edges)
+    core = [v for v in nodes if adj[v]]
+    deg0 = [v for v in nodes if not adj[v]]
+    if len(core) < 6 or len(core) > MAX_SPINE_WING_N:
+        if why is not None:
+            why["reason"] = (f"core n={len(core)} "
+                             f"(need 6..{MAX_SPINE_WING_N})")
+        return None
+
+    # Spine candidates: the directed edge whose endpoints have the most common neighbors (deterministic tie-break chain)
+    loop_sets = []
+    for lp in graph.loops:
+        loop_sets.append((getattr(lp, "kind", None), set(lp.nodes)))
+    best = None
+    for e in sorted(set(edges)):
+        u, v = e
+        cn = adj[u] & adj[v]
+        if not (MIN_WINGS <= len(cn) <= MAX_WINGS):
+            continue
+        co_loops = sum(1 for _k, s in loop_sets if {u, v} <= s)
+        key = (-len(cn), -co_loops, _canon((u, v)))
+        if best is None or key < best[0]:
+            best = (key, u, v, cn)
+    if best is None:
+        if why is not None:
+            why["reason"] = ("no hub-pair candidate: no directed edge whose "
+                             f"endpoints share {MIN_WINGS}..{MAX_WINGS} "
+                             "common neighbors")
+        return None
+    _key, u, v, wings_set = best
+    wings = sorted(wings_set)
+    rest = sorted(set(core) - {u, v} - wings_set)
+    # (1) wing band + (2) secondary clusters (a pure growth core with empty rest does not trigger — limits-to-growth)
+    if not (1 <= len(rest) <= MAX_REST):
+        if why is not None:
+            why["reason"] = (f"rest cluster n={len(rest)} "
+                             f"(need 1..{MAX_REST}; 0 = pure growth core, "
+                             "e.g. limits-to-growth — no burden side)")
+        return None
+    # (3) spine length ratio: hub-pair nodes / core nodes <= 0.5 — a compact hub pair
+    #     (long-chain shapes go to column-chain; 2-node hub pairs measured 0.22-0.33 corpus-wide)
+    if len({u, v}) / max(1, len(core)) > 0.5:
+        if why is not None:
+            why["reason"] = (f"spine length ratio "
+                             f"{len({u, v}) / max(1, len(core)):.2f} > 0.5 "
+                             "(long-chain shapes go to column-chain)")
+        return None
+    # (2)' double-axis constructibility: rest hangs only on spine∪wings∪rest (no outsiders)
+    allowed = {u, v} | wings_set | set(rest)
+    if not all(adj[r] <= allowed for r in rest):
+        if why is not None:
+            why["reason"] = ("rest adjacency reaches outside "
+                             "spine∪wings∪rest (double-axis "
+                             "constructibility fails)")
+        return None
+    # (4) rest mirror constructibility: first pair rest nodes sharing a declared loop
+    #     (sample quickfix/sideeffect both in R2 become a mirror pair, while
+    #     fundamental shares a loop only with the anchor wing -> leftover inside);
+    #     the rest pair by "restricted neighborhood key (against wings∪spine) -> canonical form", leftovers <= 1.
+    def _restrict_key(r):
+        return (tuple(sorted(adj[r] & (wings_set | {u, v}))),
+                _canon((r,)))
+    shared_loop = {}
+    for i, r1 in enumerate(rest):
+        for r2 in rest[i + 1:]:
+            sl = [set(lp.nodes) for lp in graph.loops
+                  if r1 in set(lp.nodes) and r2 in set(lp.nodes)]
+            if sl:
+                shared_loop[(r1, r2)] = tuple(sorted(
+                    s for s in sl for x in (r1, r2) if x in s))
+    pairs, used = [], set()
+    for (r1, r2) in sorted(shared_loop,
+                           key=lambda p: (_canon(p),)):
+        if r1 in used or r2 in used:
+            continue
+        pairs.append((r1, r2))
+        used |= {r1, r2}
+    rest_left = sorted((r for r in rest if r not in used),
+                       key=_restrict_key)
+    for i in range(0, len(rest_left) - 1, 2):
+        pairs.append((rest_left[i], rest_left[i + 1]))
+        used |= {rest_left[i], rest_left[i + 1]}
+    single = sorted((r for r in rest if r not in used), key=_restrict_key)
+    if len(pairs) > 3 or len(single) > 1:
+        if why is not None:
+            why["reason"] = (f"rest mirror pairing infeasible: "
+                             f"pairs={len(pairs)} (max 3), "
+                             f"leftovers={len(single)} (max 1)")
+        return None
+
+    # Wing assignment: the rest cluster's anchor wing (most adjacencies to rest; ties -> smaller canon) -> right side
+    def _canon1(w):
+        return _canon((w,))
+    anchor = sorted(wings, key=lambda w: (-len(adj[w] & set(rest)),
+                                          _canon1(w)))[0]
+    left_wings = [w for w in wings if w != anchor]
+
+    def _wing_kind(w):
+        kind_rank = {"R": 0, "B": 1}
+        k = 2
+        for lp in graph.loops:
+            s = set(lp.nodes)
+            if w in s and {u, v} <= s:
+                kind = getattr(lp, "kind", None)
+                if kind is not None:
+                    k = kind_rank.get(kind, 2)
+                break
+        return k
+    left_wings.sort(key=lambda w: (_wing_kind(w), _canon1(w)))
+    # Pair first goes to the upper wing, second to the lower; a leftover goes lower-inside (sample fundamental)
+    rest_pairs = [[p[0], p[1]] for p in pairs]
+    if why is not None:
+        why["reason"] = (f"hub pair {u}->{v} with W={len(wings_set)} common "
+                         f"neighbors, rest n={len(rest)} mirror-pairable "
+                         f"({len(pairs)} pairs / {len(single)} leftover)")
+    return {"spine_tail": u, "spine_head": v,
+            "wings_left": left_wings, "wing_anchor": anchor,
+            "rest_pairs": rest_pairs, "rest_single": single,
+            "deg0": deg0}
+
+
+def place_spine_wing(plan, widths, card_h, cfg, edges):
+    """Spine-wing constructed placement -> ({v: x}, {v: y}, meta, constructed_routes).
+
+    Constructed constraints (relative geometry cross-checked against jacky's
+    hand-laid classic-cld sample; see the module docstring).
+    """
+    u, v = plan["spine_tail"], plan["spine_head"]
+    GAP = SYM_GAP
+    row = card_h + GAP                        # wing row pitch (=80 @card_h 44)
+    Hs = 2 * row                              # spine half-distance (=160, sample 160)
+
+    def _r2(x):
+        return int(round(x / 2) * 2)
+
+    pos, y = {}, {}
+    pos[v], y[v] = 0, -Hs                     # head on top (sample adopters)
+    pos[u], y[u] = 0, Hs                      # tail at the bottom (sample rate)
+
+    # Right-side anchor wing (sample crowding x=+134 ~= half spine width + half wing width + 36)
+    anchor = plan["wing_anchor"]
+    x_anchor = (widths[u] + widths[anchor]) / 2 + GAP
+    pos[anchor], y[anchor] = _r2(x_anchor), 0
+
+    # Left wings: inside-out (sample: word inside / potential outside)
+    prev_half = widths[u] / 2
+    cur = -(prev_half + GAP)
+    for w in plan["wings_left"]:
+        xw = cur - widths[w] / 2
+        pos[w], y[w] = _r2(xw), 0
+        cur = xw - widths[w] / 2 - GAP
+
+    # Rest mirror pairs: whole-pitch stack right of the anchor wing at ±row (sample
+    # y=±82~=±row; x near-mirrored, idealized to an exact column, 0px deviation)
+    pair_col_x = x_anchor + widths[anchor] / 2 + GAP
+    mirror_pairs = []
+    for up, down in plan["rest_pairs"]:
+        pair_x = pair_col_x + widths[up] / 2      # column set by the first member's width
+        pos[up], y[up] = _r2(pair_x), -row
+        pos[down], y[down] = _r2(pair_x), row
+        mirror_pairs.append([up, down])
+    # Leftover: lower-right inside (sample fundamental on rate's row y=+2row; x keeps
+    # >= GAP clearance from the spine bottom card — sample x=594 vs rate right edge 460)
+    if plan["rest_single"]:
+        s = plan["rest_single"][0]
+        xs = widths[u] / 2 + GAP + widths[s] / 2
+        pos[s], y[s] = _r2(xs), 2 * row
+
+    if plan["deg0"]:
+        total = sum(widths[w] for w in plan["deg0"]) + 18 * (len(plan["deg0"]) + 1)
+        cur0 = -total / 2
+        for w in plan["deg0"]:
+            pos[w] = int(round((cur0 + widths[w] / 2) / 2) * 2)
+            y[w] = cfg.park_y
+            cur0 += widths[w] + 18
+
+    # Constructed routes: the spine edge as a vertical straight line (not via the candidate pool); other edges via the Router
+    constructed = {}
+    eset = set(edges)
+    for e in ((u, v), (v, u)):
+        if e in eset:
+            a, b = e
+            na = (pos[a], y[a], widths[a], card_h)
+            nb = (pos[b], y[b], widths[b], card_h)
+            pa = border_point(na[0], na[1], na[2] / 2, na[3] / 2,
+                              nb[0] - na[0], nb[1] - na[1])
+            pb = border_point(nb[0], nb[1], nb[2] / 2, nb[3] / 2,
+                              na[0] - nb[0], na[1] - nb[1])
+            constructed[e] = {"kind": "line", "points": [pa, pb]}
+            break
+
+    meta = {
+        "placement": "spine-wing",
+        "spine_wing": {
+            "axis_x": 0,
+            "axis_y": 0,
+            "spine": [v, u],
+            "wings_left": list(plan["wings_left"]),
+            "wing_anchor": anchor,
+            "wings": [w for w in plan["wings_left"]] + [anchor],
+            "mirror_pairs": mirror_pairs,
+            "rest_single": list(plan["rest_single"]),
+            "row_pitch": row,
+            "spine_half": Hs,
+            "gap": GAP,
+            "line_style_rule": "spine vertical straight + router lines/arcs",
+        },
+    }
+    return pos, y, meta, constructed

stdraw/symlayout.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+"""Bowtie-pair (two triangles sharing an edge) symmetric placement
+(2026-11-06 jacky layout aesthetics v2, t_c6ab760d).
+
+> #11 learning-flywheel "could be symmetric yet leans left" — symmetric
+> structures should be explicitly symmetric.
+
+Trigger detection (deterministic local structure, checked before ring
+detection):
+  The core graph is exactly "two triangles sharing one edge" (bowtie):
+  4 nodes, 5 edges, degree sequence {3,3,2,2}, with the two degree-3
+  nodes adjacent (shared-edge endpoints) and the two degree-2 nodes
+  non-adjacent (left/right apexes). Corpus hits: learning-flywheel /
+  fixes-that-fail (a directed-isomorphic pair -> the same layout
+  template).
+
+Placement (place_bowtie):
+  - Shared-edge endpoints A (upper row) / B (lower row) sit on the
+    vertical axis; the two apexes mirror left (-D) / right (+D) on the
+    middle row — explicit geometric symmetry;
+  - Line-style consistency hard rule: the axis edge A->B is a straight
+    line; all 4 side edges are constructed as mirrored arcs (ctrl offset
+    symmetrically outward) — "line styles stay consistent within one
+    symmetric structure (no straight/arc/bend mixing)".
+
+Centering normalization: the bounding-box center of A/B/apex is the
+canvas center (layout-layer axis x=0; the delivery layer translates
+uniformly to center — see layout_auto's centering post-process).
+"""
+import math
+
+SYM_GAP = 36              # breathing-room target clearance
+ARC_K_FALLBACK = 0.22     # side-arc k fallback tier (unreachable when side_geom is empty; defensive)
+
+
+class InfeasibleBowtie(Exception):
+    pass
+
+
+def _adjacency(edges):
+    adj = {v: set() for a, b in edges for v in (a, b)}
+    for a, b in edges:
+        adj[a].add(b)
+        adj[b].add(a)
+    return adj
+
+
+def detect_bowtie(graph, why=None):
+    """Bowtie detection. Returns {"A","B","L","R","deg0"} or None.
+
+    why: optional dict — receives a deterministic one-line reason for the
+    outcome (mode decision trace, certificate mode_decision_trace field).
+    """
+    nodes = list(graph.node_ids())
+    edges = [(e.a, e.b) for e in graph.edges]
+    adj = _adjacency(edges)
+    core = [v for v in nodes if adj.get(v)]
+    deg0 = [v for v in nodes if not adj.get(v)]
+    if len(core) != 4 or len(edges) != 5:
+        if why is not None:
+            why["reason"] = (f"core n={len(core)}, edges m={len(edges)} "
+                             "(need exactly 4 core nodes / 5 edges)")
+        return None
+    d3 = sorted(v for v in core if len(adj[v]) == 3)
+    d2 = sorted(v for v in core if len(adj[v]) == 2)
+    if len(d3) != 2 or len(d2) != 2:
+        if why is not None:
+            why["reason"] = ("degree sequence not {3,3,2,2} "
+                             f"(deg-3: {len(d3)}, deg-2: {len(d2)})")
+        return None
+    a, b = d3
+    l, r = d2
+    if b not in adj[a] or r in adj[l]:
+        if why is not None:
+            why["reason"] = ("the two degree-3 nodes are not adjacent, or the "
+                             "degree-2 pair is adjacent (not a shared-edge bowtie)")
+        return None
+    # Structural self-check: exactly two triangles = {a,b,l} and {a,b,r}, sharing edge a-b
+    if not (l in adj[a] and l in adj[b] and r in adj[a] and r in adj[b]):
+        if why is not None:
+            why["reason"] = ("triangles {{a,b,l}} / {{a,b,r}} not complete "
+                             "(not two triangles sharing edge a-b)")
+        return None
+    if why is not None:
+        why["reason"] = ("two triangles sharing edge "
+                         f"{a}-{b} (deg sequence {{3,3,2,2}})")
+    # A = upper-row node: deterministic (id order; a/b sit at swap-symmetric positions, geometry invariant)
+    return {"A": a, "B": b, "L": l, "R": r, "deg0": deg0}
+
+
+from .routing import border_point as _border_point
+
+
+def _quad_points(p0, ctrl, p1, seg=24):
+    return [[(1 - t) ** 2 * p0[0] + 2 * (1 - t) * t * ctrl[0] + t ** 2 * p1[0],
+             (1 - t) ** 2 * p0[1] + 2 * (1 - t) * t * ctrl[1] + t ** 2 * p1[1]]
+            for t in (i / seg for i in range(seg + 1))]
+
+
+def _own_press(pts, na, nb):
+    """Whether the arc's intermediate sample points enter either end's own box
+    (with 1px margin; same criteria as check2).
+
+    Diagnostic aid (normally not triggered under the ctrl-translation
+    convention; kept for debugging recomputation).
+    """
+    from .routing import dist_point_rect
+    for p in pts[1:-1]:
+        for bx, by, bw, bh in (na, nb):
+            if dist_point_rect(p[0], p[1], bx, by, bw / 2 + 1, bh / 2 + 1) <= 0:
+                return True
+    return False
+
+
+def _natural_border(cx, cy, hw, hh, dx, dy):
+    """The ray's natural intersection with the box edge (no band clamping; used to compute the anchor clamping delta)."""
+    if abs(dx) < 1e-9 and abs(dy) < 1e-9:
+        return [cx, cy]
+    if abs(dx) < 1e-9:
+        return [cx, cy + (hh if dy > 0 else -hh)]
+    if abs(dy) < 1e-9:
+        return [cx + (hw if dx > 0 else -hw), cy]
+    t = min(hw / abs(dx), hh / abs(dy))
+    return [cx + dx * t, cy + dy * t]
+
+
+def _clamp_band(p, nx, ny, nw, nh):
+    """Anchor clamped to the owning edge's midpoint ± 1/4 edge-length band (corners excluded; connection-point delivery convention)."""
+    hw, hh = nw / 2.0, nh / 2.0
+    dxo, dyo = p[0] - nx, p[1] - ny
+    on_x = abs(abs(dxo) - hw) <= abs(abs(dyo) - hh)
+    if on_x:
+        return [p[0], ny + max(-hh / 2, min(hh / 2, dyo))]
+    return [nx + max(-hw / 2, min(hw / 2, dxo)), p[1]]
+
+
+def place_bowtie(plan, widths, card_h, cfg, edges):
+    """Bowtie symmetric placement -> ({v: x}, {v: y}, meta, constructed_routes).
+
+    constructed_routes: {(a,b): route dict} — axis edge as a straight line
+    + 4 side edges as mirrored arcs, constructively injected (not via the
+    candidate pool), guaranteeing mirror symmetry and line-style
+    consistency.
+    """
+    A, B, L, R = plan["A"], plan["B"], plan["L"], plan["R"]
+    pitch = cfg.pitch
+    yA = cfg.top
+    yB = cfg.top + pitch
+    yMid = cfg.top + pitch / 2
+    wmax = max(widths.values())
+    # D: apex distance from the axis — axis card half-width + clearance + apex half-width; also L/R apex mutual distance >= SYM_GAP
+    D = max(widths[A] / 2 + SYM_GAP + max(widths[L], widths[R]) / 2,
+            (SYM_GAP + (widths[L] + widths[R]) / 2) / 2,
+            wmax / 2 + SYM_GAP / 2)
+    D = int(round(D / 2) * 2)
+
+    pos = {A: 0, B: 0, L: -D, R: D}
+    y = {A: int(yA), B: int(yB), L: int(round(yMid / 2) * 2),
+         R: int(round(yMid / 2) * 2)}
+
+    if plan["deg0"]:
+        total = sum(widths[v] for v in plan["deg0"]) + 18 * (len(plan["deg0"]) + 1)
+        cur = -total / 2
+        for v in plan["deg0"]:
+            pos[v] = int(round((cur + widths[v] / 2) / 2) * 2)
+            y[v] = cfg.park_y
+            cur += widths[v] + 18
+
+    def _np(v):
+        return (pos[v], y[v], widths[v], card_h)
+
+    constructed = {}
+    eset = {(a, b) for a, b in edges}
+    # Axis edge: straight line (A->B / B->A per the graph's directed edges; anchors face the peer's box edge)
+    for u, v in ((A, B), (B, A)):
+        if (u, v) not in eset:
+            continue
+        dy_u = 1 if y[v] > y[u] else -1
+        dy_v = 1 if y[u] > y[v] else -1
+        pa = _border_point(pos[u], y[u], widths[u] / 2, card_h / 2, 0, dy_u)
+        pb = _border_point(pos[v], y[v], widths[v] / 2, card_h / 2, 0, dy_v)
+        constructed[(u, v)] = {"kind": "line", "points": [pa, pb]}
+    # Side edges: mirrored arcs (apex <-> axis node; ctrl offset outward, mirrors share |ctrl|).
+    # t_7fe64f08 arc parameterization: k takes the adaptive median tier of the 4 side chord lengths —
+    # consistent curvature within one symmetric structure ("same-ring arc consistency" hard rule).
+    # Connection-point convention: the arc is shaped on **natural anchors** (the old ray convention)
+    # first, then mapped to clamped anchors — ctrl via chord coordinate transform (alpha ratio +
+    # beta perpendicular kept): shape and departure tangent preserved, never flipping into its own box.
+    side_geom = []
+    for apex, s in ((L, -1), (R, 1)):
+        for axis_v in (A, B):
+            for e in ((apex, axis_v), (axis_v, apex)):
+                if e not in eset:
+                    continue
+                a, b = e
+                na, nb = _np(a), _np(b)
+                dx, dy = nb[0] - na[0], nb[1] - na[1]
+                pa_n = _natural_border(na[0], na[1], na[2] / 2, na[3] / 2,
+                                       dx, dy)
+                pb_n = _natural_border(nb[0], nb[1], nb[2] / 2, nb[3] / 2,
+                                       -dx, -dy)
+                pa_c = _clamp_band(pa_n, na[0], na[1], na[2], na[3])
+                pb_c = _clamp_band(pb_n, nb[0], nb[1], nb[2], nb[3])
+                dist = math.hypot(pb_n[0] - pa_n[0], pb_n[1] - pa_n[1])
+                side_geom.append((e, pa_n, pb_n, pa_c, pb_c, dist, s))
+    from .routing import adaptive_arc_k
+    k_uni = ARC_K_FALLBACK
+    if side_geom:
+        dists = sorted(g[5] for g in side_geom)
+        med = dists[len(dists) // 2] if len(dists) % 2 else \
+            (dists[len(dists) // 2 - 1] + dists[len(dists) // 2]) / 2
+        k_uni = adaptive_arc_k(med)
+    for e, pa, pb, pa_c, pb_c, dist, s in side_geom:
+        vx, vy = pb[0] - pa[0], pb[1] - pa[1]
+        ux, uy = -vy / dist, vx / dist
+        # Outward normal: chosen vs. the "apex -> axis" direction so ctrl moves away from the vertical axis
+        mx, my = (pa[0] + pb[0]) / 2, (pa[1] + pb[1]) / 2
+        cx = mx + ux * k_uni * dist * s
+        cy = my + uy * k_uni * dist * s
+        if (cx - 0) * s < (mx - 0) * s:      # ctrl must sit further out than the midpoint
+            cx = mx - ux * k_uni * dist * s
+            cy = my - uy * k_uni * dist * s
+        # Map chord coordinates onto the clamped anchors: ctrl = pa_c + alpha*(pb_c-pa_c) + beta_vec
+        wx, wy = cx - pa[0], cy - pa[1]
+        alpha = (wx * vx + wy * vy) / (dist * dist)
+        betax = wx - alpha * vx
+        betay = wy - alpha * vy
+        v2x, v2y = pb_c[0] - pa_c[0], pb_c[1] - pa_c[1]
+        cx2 = pa_c[0] + alpha * v2x + betax
+        cy2 = pa_c[1] + alpha * v2y + betay
+        constructed[e] = {"kind": "arc",
+                          "points": _quad_points(pa_c, [cx2, cy2], pb_c),
+                          "ctrl": [cx2, cy2]}
+    meta = {
+        "placement": "symmetric",
+        "symmetry": {
+            "axis": "vertical",
+            "axis_x": 0,
+            "shared_edge": [A, B],
+            "mirror_pairs": [[L, R]],
+            "gap": SYM_GAP,
+            "line_style_rule": "axis-straight + mirrored-arcs",
+        },
+    }
+    return pos, y, meta, constructed

stdraw/textmetrics.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""Bounding-box ground-truth layer (1, layout side): measure card text width with the real font; conservative padding.
+
+Background (root cause of the v0.2 quality rework): the old text_px estimated width as character count x font size,
+which inevitably deviates from actual browser rendering -- bounds measured too small -> wires hug/press the box while the certificate still passes (same-source distortion).
+
+Principles of this layer:
+    - Measuring font = rendering font (render.py font-family prefers Microsoft YaHei);
+    - Worst case: titles measured at the bold upper bound; take the larger of "measured" vs "analytic";
+    - Conservative padding: >= 12px on each side, plus a 6% stretch margin;
+    - When PIL is unavailable, fall back to a conservative analytic formula (CJK 1.10x fs / others 0.62x fs, times a 1.08 safety factor).
+
+The CI side (the second layer) is rendercheck.py comparing actual DOM bounds after real rendering -- both layers are indispensable.
+"""
+import os
+
+# same rendering font as render.py (worst case measured with bold)
+_FONT_CANDIDATES = [
+    "C:/Windows/Fonts/msyhbd.ttc",   # Microsoft YaHei Bold (widest)
+    "C:/Windows/Fonts/msyh.ttc",     # Microsoft YaHei
+    "C:/Windows/Fonts/simhei.ttf",   # SimHei fallback
+]
+_FALLBACK_PATHS = [
+    "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",   # Linux CI fallback
+]
+
+PAD_SIDE_MIN = 12      # minimum per-side padding px
+SAFETY = 1.06          # measurement stretch safety factor
+
+_cache = {}
+
+
+def _load_font(px: int):
+    """Load a font by pixel size (cached); returns None on failure."""
+    key = px
+    if key in _cache:
+        return _cache[key]
+    font = None
+    try:
+        from PIL import ImageFont
+        for path in _FONT_CANDIDATES + _FALLBACK_PATHS:
+            if os.path.exists(path):
+                try:
+                    font = ImageFont.truetype(path, px)
+                    break
+                except Exception:
+                    continue
+    except Exception:
+        font = None
+    _cache[key] = font
+    return font
+
+
+def _analytic(s: str, fs: float) -> float:
+    """Conservative analytic formula when no font file is available (safety factor tightened vs the old text_px)."""
+    w = 0.0
+    for ch in s:
+        w += fs * 1.10 if ord(ch) > 0x2E7F else fs * 0.62
+    return w
+
+
+def text_width(s: str, fs: float, bold: bool = False) -> float:
+    """Rendered width of a single line of text (px, conservative upper bound). Empty string returns 0."""
+    if not s:
+        return 0.0
+    est = _analytic(s, fs)
+    font = _load_font(max(8, int(round(fs))))
+    if font is not None:
+        try:
+            m = font.getlength(s) * (1.06 if bold else 1.0)
+            return max(m, est) * SAFETY
+        except Exception:
+            pass
+    return est * SAFETY
+
+
+def card_size(label: str, value: str, fs_title: float, fs_value: float,
+              pad: float = None, min_w: int = 96, min_h: int = 44,
+              value_pad: float = None):
+    """Planned card bounds: worst-case width of the two text lines + conservative padding, on a 2px grid.
+
+    Returns (w, h). Height is generous per line count (title line + value line); a single line still keeps the visual height.
+
+    value_pad: extra per-side padding px reserved for the second (value) text
+    line, on top of the historical pad-4 baseline. Default None keeps the
+    historical behavior byte-for-byte (zero drift); callers that render long
+    ticker/price strings (e.g. "7741.T 22,395.00 JPY" measured ~120px vs a
+    108px card) opt in via AutoConfig.value_pad_extra / CLI --value-pad.
+    """
+    pad_side = pad if pad is not None else PAD_SIDE_MIN + 6
+    value_pad_side = (pad_side - 4) if value_pad is None else value_pad
+    w = max(text_width(label, fs_title, bold=True) + 2 * pad_side,
+            text_width(value, fs_value, bold=True) + 2 * value_pad_side,
+            min_w)
+    two_line = bool(value)
+    h = max(min_h, 46 if two_line else 44)
+    return int((w + 1) // 2 * 2), h