draftwright 0.4.7__tar.gz → 0.4.8__tar.gz

{draftwright-0.4.7 → draftwright-0.4.8}/CHANGELOG.md

@@ -46,6 +46,46 @@
   reached, placement retains the legacy greedy result or a result no worse than it
   rather than losing additional callouts. Pre-drain diameter clearance ranking and
   its Policy-B fallback remain unchanged.
+- Compatible automatic/deferred sparse ordinary side/plan hole and post-drain
+  machined-feature callouts now share one bounded same-view leader inventory
+  (#1166). Pattern, profiled-bore, and dense table-eligible hole queues retain
+  their specialised established paths because their winners affect downstream
+  furniture/table semantics or await #798 silhouette-aware routing. The solve
+  preserves required/priority-ranked evidence, rejects new-leader crossings,
+  checks complete leader ink against actual-width fixed dimension/witness,
+  arrow, label, and centre-furniture components (including rendered arrows on
+  shifted dimensions and component-local dashed circular centre furniture);
+  fixed residual faces and the selected survivor both require each tessellation
+  triangle to fit one same analytical component rather than merely the union,
+  plus exact continuous OCC containment for curved faces; residual lowering
+  also retains filled datum/GD&T faces absent from segment metadata; if candidate
+  or selected-survivor construction raises, or a survivor fails validation, the
+  bad alternative fails closed and the canonical lazy producer tail is replayed
+  instead of falsely dropping an otherwise valid callout; an all-invalid tail is
+  reported as validation-stage geometry failure rather than no clear room (so
+  scale fallback does not retry a non-spatial helper defect), while compiler
+  invariant violations such as a missing semantic callout label remain loud;
+  only explicitly marked global turning axes permit an arrow-local leader-tip
+  attachment; near-collinear shaft travel and ownerless section/cutting lines
+  remain fixed ink. The solve prefers
+  clear routes over explicit Policy-B fallbacks, and then minimises real leader
+  length. Provisional sections cannot veto that primary result: one separately
+  bounded refinement may choose an equally complete leader inventory that clears
+  their exact components, after which the final section performs one bounded
+  end-symbol repair and yields if exact ink still conflicts. The selected OCC survivor is validated against the same analytical
+  ink contract. A retained fixed-ink crossing now emits the machine-readable
+  `feature_leader_crossing` info finding instead of appearing lint-clean. Candidate,
+  fixed-component lowering, fixed-obstacle-probe, pair, and exact-search work is
+  bounded; the fixed inventory is lowered once and reused with the producer's
+  legacy lazy result as the floor, including state-cap exhaustion; page,
+  own-silhouette, and title-reservation constraints remain hard in every fallback.
+  A replay that exhausts exact fixed-probe classification is retained visibly as
+  `feature_leader_fixed_ink_unverified` rather than rescanning past the cap, and
+  that uncertainty participates in the legibility quality inventory.
+  Trace output preserves an abandoned fully admitted inventory when state search
+  exhausts, records the producer-floor replay separately, and names exact committed/provisional components,
+  refinement status, and competing blockers; live
+  single-callout edits remain immediate.
 
 ## v0.4.6 — 2026-08-15
 

{draftwright-0.4.7 → draftwright-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.7
+Version: 0.4.8
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.4.7 → draftwright-0.4.8}/docs/adr/README.md

@@ -30,7 +30,7 @@ architecture** table; open retired or superseded records only for design history
 | [0011](0011-ir-as-public-input.md) | The IR as a public input: declare features, don't only detect them | Accept the feature IR as public input through declarations and the `Sheet` façade. | Accepted; core landed; #62/#462/#495 remain | `test_declare.py`, `test_object_aspects.py`, `test_sheet_gdt.py` |
 | [0012](0012-edits-as-pinned-priority-candidates-in-the-global-solve.md) | User annotation edits are pinned, priority-ranked corridor candidates | Drain recorded semantic edits through corridor placement with pin and priority. | Accepted; partially landed; full recomposition/parity remains #426/#707 (#661 detail views landed) | `test_make_drawing.py`, `test_sheet_emit.py` |
 | [0013](0013-uniform-recognition-and-shared-package.md) | A uniform recogniser/feature contract and shared `b123d-recognisers` deployment | Enforce the geometry-only contract in the shared package and consume it through Draftwright's record→IR boundary. | Accepted; Phases 1–2 deployed | `test_external_recognition_boundary.py`, `test_detect_registry.py`, package semantic goldens |
-| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering; post-drain feature leaders also assign jointly within each pass. | Accepted; supersedes 0009; #740 Amendment 1 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_issue_740_leader_assignment.py`, `test_import_boundaries.py` |
+| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering; compatible sparse ordinary side/plan hole and post-drain machined leaders share one bounded late inventory. | Accepted; supersedes 0009; #740 Amendment 1; #1166 Amendment 2 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_issue_740_leader_assignment.py`, `test_issue_1166_cross_pass_feature_leaders.py`, `test_import_boundaries.py` |
 | [0015](0015-part-drawing-compiler-as-built.md) | The part-drawing compiler, as built | Use one detected-or-declared feature IR and planner-fed dimension groups as the compiler waist. | Accepted; supersedes 0008 | `test_part_model.py`, `test_detect_once.py`, `test_import_boundaries.py` |
 | [0016](0016-declared-dimensioning-intent.md) | Declared dimensioning intent: capture what to measure, let the engine place it | Declare which measurements matter as scale-independent intent routed through the planner and corridor solve; never hardcode dimension geometry. | Accepted; epic #867 complete; phase 6 landed (#940) | `test_compiled_plan_boundary.py`, `test_label_provenance.py`, `test_sheet_emit.py`, `test_add_dimension.py` |
 | [0017](0017-recognition-inventory-correspondence-and-measurement-provenance.md) | One recognition result per run; correspondence is evidence-gated | Produce one external immutable recognition result held by Draftwright's per-run cache; require vertical-slice evidence before generalising correspondence, identity, requirements, outcomes, or reconciliation. | Accepted; external cache ownership clarified, extensions gated by #1018 | `test_external_recognition_boundary.py`, `test_recognition_manifest.py`, `test_declared_recognition_gate.py` |

{draftwright-0.4.7 → draftwright-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.7"
+version = "0.4.8"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }

{draftwright-0.4.7 → draftwright-0.4.8}/src/draftwright/_geometry.py

@@ -327,6 +327,33 @@ def _segment_clips_box(p, q, box, pad=0.0) -> bool:
     return _segment_clip_extent(p, q, box, pad=pad) is not None
 
 
+def _convex_polygons_overlap(left, right) -> bool:
+    """Whether two convex page-plane polygons have positive-area overlap.
+
+    The separating-axis test is strict: touching edges/vertices are clear, the
+    same placement convention as :func:`_boxes_overlap`.
+    """
+
+    if len(left) < 3 or len(right) < 3:
+        return False
+    axes: list[tuple[float, float]] = []
+    for points in (left, right):
+        axes.extend(
+            (-(second[1] - first[1]), second[0] - first[0])
+            for first, second in zip(points, (*points[1:], points[0]), strict=True)
+        )
+    for ax, ay in axes:
+        if abs(ax) + abs(ay) <= 1e-12:
+            continue
+        left_projection = [x * ax + y * ay for x, y in left]
+        right_projection = [x * ax + y * ay for x, y in right]
+        if max(left_projection) <= min(right_projection) or max(right_projection) <= min(
+            left_projection
+        ):
+            return False
+    return True
+
+
 def _convex_polygon_overlaps_box(points, box) -> bool:
     """Whether a convex page-plane polygon has positive-area overlap with an AABB.
 
@@ -341,21 +368,63 @@ def _convex_polygon_overlaps_box(points, box) -> bool:
         (box[2], box[3]),
         (box[0], box[3]),
     )
-    axes = [(1.0, 0.0), (0.0, 1.0)]
-    axes.extend(
-        (-(second[1] - first[1]), second[0] - first[0])
-        for first, second in zip(points, (*points[1:], points[0]), strict=True)
+    return _convex_polygons_overlap(points, corners)
+
+
+def _stroke_polygon(first, second, width: float):
+    """The exact swept rectangle for one rendered straight stroke, or ``None``."""
+
+    dx, dy = float(second[0]) - float(first[0]), float(second[1]) - float(first[1])
+    length = math.hypot(dx, dy)
+    half = max(0.0, float(width)) / 2.0
+    if length <= 1e-12 or half <= 0.0:
+        return None
+    vx, vy = -dy / length * half, dx / length * half
+    return (
+        (float(first[0]) + vx, float(first[1]) + vy),
+        (float(second[0]) + vx, float(second[1]) + vy),
+        (float(second[0]) - vx, float(second[1]) - vy),
+        (float(first[0]) - vx, float(first[1]) - vy),
     )
-    for ax, ay in axes:
-        if abs(ax) + abs(ay) <= 1e-12:
-            continue
-        polygon_projection = [x * ax + y * ay for x, y in points]
-        box_projection = [x * ax + y * ay for x, y in corners]
-        if max(polygon_projection) <= min(box_projection) or max(box_projection) <= min(
-            polygon_projection
-        ):
-            return False
-    return True
+
+
+def _leader_ink_polygons(tip, elbow, *, arrow_length: float, line_width: float):
+    """Convex components of a leader's rendered tip→elbow shaft and arrow."""
+
+    dx, dy = float(elbow[0]) - float(tip[0]), float(elbow[1]) - float(tip[1])
+    length = math.hypot(dx, dy)
+    half_line = max(0.0, float(line_width)) / 2.0
+    head_length = max(0.0, float(arrow_length))
+    if length <= 1e-12:
+        half = max(half_line, head_length / 3.0)
+        if half <= 0.0:
+            return ()
+        return (
+            (
+                (float(tip[0]) - half, float(tip[1]) - half),
+                (float(tip[0]) + half, float(tip[1]) - half),
+                (float(tip[0]) + half, float(tip[1]) + half),
+                (float(tip[0]) - half, float(tip[1]) + half),
+            ),
+        )
+
+    ux, uy = dx / length, dy / length
+    vx, vy = -uy, ux
+    polygons = []
+    shaft = _stroke_polygon(tip, elbow, line_width)
+    if shaft is not None:
+        polygons.append(shaft)
+    if head_length > 0.0:
+        half_head = head_length / 3.0
+        base_x, base_y = tip[0] + ux * head_length, tip[1] + uy * head_length
+        polygons.append(
+            (
+                (float(tip[0]), float(tip[1])),
+                (base_x + vx * half_head, base_y + vy * half_head),
+                (base_x - vx * half_head, base_y - vy * half_head),
+            )
+        )
+    return tuple(polygons)
 
 
 def _leader_ink_crosses_box(
@@ -378,41 +447,15 @@ def _leader_ink_crosses_box(
     Touching boundaries are clear, matching :func:`_boxes_overlap` and the placement-side
     semantics of :func:`_segment_crosses_box`.
     """
-    dx, dy = float(elbow[0]) - float(tip[0]), float(elbow[1]) - float(tip[1])
-    length = math.hypot(dx, dy)
-    half_line = max(0.0, float(line_width)) / 2.0
-    head_length = max(0.0, float(arrow_length))
-
-    if length <= 1e-12:
-        half = max(half_line, head_length / 3.0)
-        point_box = (tip[0] - half, tip[1] - half, tip[0] + half, tip[1] + half)
-        return _boxes_overlap(point_box, box)
-
-    ux, uy = dx / length, dy / length
-    vx, vy = -uy, ux
-
-    if half_line > 0.0:
-        shaft = (
-            (tip[0] + vx * half_line, tip[1] + vy * half_line),
-            (elbow[0] + vx * half_line, elbow[1] + vy * half_line),
-            (elbow[0] - vx * half_line, elbow[1] - vy * half_line),
-            (tip[0] - vx * half_line, tip[1] - vy * half_line),
+    return any(
+        _convex_polygon_overlaps_box(polygon, box)
+        for polygon in _leader_ink_polygons(
+            tip,
+            elbow,
+            arrow_length=arrow_length,
+            line_width=line_width,
         )
-        if _convex_polygon_overlaps_box(shaft, box):
-            return True
-
-    if head_length > 0.0:
-        half_head = head_length / 3.0
-        base_x, base_y = tip[0] + ux * head_length, tip[1] + uy * head_length
-        arrow = (
-            (tip[0], tip[1]),
-            (base_x + vx * half_head, base_y + vy * half_head),
-            (base_x - vx * half_head, base_y - vy * half_head),
-        )
-        if _convex_polygon_overlaps_box(arrow, box):
-            return True
-
-    return False
+    )
 
 
 def _segments_cross_or_overlap(a1, a2, b1, b2) -> bool:

{draftwright-0.4.7 → draftwright-0.4.8}/src/draftwright/annotations/_common.py

@@ -786,6 +786,43 @@ def dim_footprint(p1, p2, side, distance, draft, label):
     return (min(xs) - pad, min(ys) - pad, max(xs) + pad, max(ys) + pad)
 
 
+def leader_callout_geometry(tip, elbow, draft, *, text_side="auto", callout_box=None):
+    """Exact cheap label box and line segments for a callout-bearing ``Leader``.
+
+    This is the position-dependent subset of :func:`leader_footprint` needed by
+    the shared feature-leader solve.  It mirrors the helper's two input edges and
+    the translation of the already-measured callout sketch, without constructing
+    the arrow/shelf OCC faces.  ``None`` matches the helper's forced-side guard.
+    """
+
+    gap = draft.pad_around_text
+    if text_side == "auto":
+        shelf_dir = 1.0 if elbow[0] >= tip[0] else -1.0
+    else:
+        shelf_dir = 1.0 if text_side == "right" else -1.0
+    shelf_end = (elbow[0] + shelf_dir * gap, elbow[1])
+    segments = (
+        ((float(tip[0]), float(tip[1])), (float(elbow[0]), float(elbow[1]))),
+        ((float(elbow[0]), float(elbow[1])), (float(shelf_end[0]), float(shelf_end[1]))),
+    )
+
+    label_box = None
+    if callout_box is not None:
+        cw = callout_box[2] - callout_box[0]
+        ch = callout_box[3] - callout_box[1]
+        if shelf_dir > 0:
+            cx0, cx1 = shelf_end[0], shelf_end[0] + cw
+        else:
+            cx0, cx1 = shelf_end[0] - cw, shelf_end[0]
+        cy0, cy1 = elbow[1] - ch / 2.0, elbow[1] + ch / 2.0
+        label_box = (cx0, cy0, cx1, cy1)
+        if text_side != "auto" and _segment_crosses_box(
+            (tip[0], tip[1]), (elbow[0], elbow[1]), label_box
+        ):
+            return None
+    return label_box, segments
+
+
 def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     """Analytical page-mm AABB ``(x0, y0, x1, y1)`` of the :class:`Leader` that
     ``Leader(tip, elbow, label="", draft, text_side=…, callout=…)`` would build —
@@ -811,12 +848,17 @@ def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     that runs the shaft through the label — so callers omit the candidate exactly
     as the built-geometry probe's except-handler did.
     """
-    gap = draft.pad_around_text
-    if text_side == "auto":
-        shelf_dir = 1.0 if elbow[0] >= tip[0] else -1.0
-    else:
-        shelf_dir = 1.0 if text_side == "right" else -1.0
-    shelf_end_x = elbow[0] + shelf_dir * gap
+    geometry = leader_callout_geometry(
+        tip,
+        elbow,
+        draft,
+        text_side=text_side,
+        callout_box=callout_box,
+    )
+    if geometry is None:
+        return None
+    label_box, segments = geometry
+    shelf_end_x = segments[1][1][0]
 
     # The arrowhead bounds the shaft only while it is the wider of the two; a style with a
     # heavy line and a small arrow inverts that, and a diagonal shaft then pushes its stroke
@@ -829,22 +871,9 @@ def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     xs += [min(elbow[0], shelf_end_x) - half_line, max(elbow[0], shelf_end_x) + half_line]
     ys += [elbow[1] - half_line, elbow[1] + half_line]
 
-    if callout_box is not None:
-        cw = callout_box[2] - callout_box[0]
-        ch = callout_box[3] - callout_box[1]
-        if shelf_dir > 0:
-            cx0, cx1 = shelf_end_x, shelf_end_x + cw
-        else:
-            cx0, cx1 = shelf_end_x - cw, shelf_end_x
-        cy0, cy1 = elbow[1] - ch / 2.0, elbow[1] + ch / 2.0
-        # Leader raises rather than draw a shaft through its own label; a forced side
-        # is the only way to get there, matching helpers' own guard condition.
-        if text_side != "auto" and _segment_crosses_box(
-            (tip[0], tip[1]), (elbow[0], elbow[1]), (cx0, cy0, cx1, cy1)
-        ):
-            return None
-        xs += [cx0, cx1]
-        ys += [cy0, cy1]
+    if label_box is not None:
+        xs += [label_box[0], label_box[2]]
+        ys += [label_box[1], label_box[3]]
 
     return (min(xs), min(ys), max(xs), max(ys))
 
@@ -1495,6 +1524,11 @@ class PlacementContext:
     # drained (#684 review): a mid-drain carve could occupy space a later sibling
     # corridor's force candidate needs; deferral makes "post-drain" literally true.
     post_drain: list = field(default_factory=list)
+    # Compatible automatic/deferred feature-callout jobs collected across the
+    # hole + post-drain machined passes (#1166). ``None`` is intentional: direct
+    # renderer calls and finished-sheet live verbs keep their immediate behavior;
+    # the orchestrator/finalize paths opt in with ``[]`` and drain once.
+    feature_leaders: list | None = None
     # The opt-in solve-trace recorder (#736) — a :class:`SolveTrace` threaded off the
     # drawing's build state by both entry paths, or ``None`` (the default: tracing off,
     # every hook a bare None check). Ctx state, not a module global, so the finalize

{draftwright-0.4.7 → draftwright-0.4.8}/src/draftwright/annotations/from_model.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 
 import math
 from dataclasses import dataclass, replace
-from itertools import chain, islice
+from itertools import chain, islice, tee
 from typing import Any
 
 from build123d_drafting import DatumFeature, FeatureControlFrame, SurfaceFinish, TextBlock
@@ -82,6 +82,7 @@ from draftwright.annotations._common import (
     strip_free_span,
     strip_obstacles,
 )
+from draftwright.annotations.leaders import FeatureLeaderJob, collect_feature_leader
 from draftwright.layout import (
     _LEADER_ASSIGN_MAX_JOBS,
     StripCandidate,
@@ -1604,6 +1605,38 @@ def _corner_candidates(dwg, view, vb, members, reach, *, provenances=None):
         yield (tip, elbow, owner)
 
 
+def _corner_escape_candidates(dwg, view, vb, members, reach, *, provenances=None):
+    """Corner leaders plus silhouette-outward horizontal/vertical escapes.
+
+    The diagonal remains the stable first choice.  The two axis-aligned rays
+    leave the same corner away from the view centre, so they add boundary/lane
+    alternatives without introducing #798's through-silhouette routing problem.
+    """
+
+    members = list(members)
+    owners = list(provenances if provenances is not None else members)
+    yield from _corner_candidates(dwg, view, vb, members, reach, provenances=owners)
+    x0, y0, x1, y1 = vb
+    cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
+    for member, owner in zip(members, owners, strict=True):
+        tip = dwg.at(view, *member.frame.origin)
+        directions = (
+            (1.0 if tip[0] >= cx else -1.0, 0.0),
+            (0.0, 1.0 if tip[1] >= cy else -1.0),
+        )
+        for ux, uy in directions:
+            exit_distance = _ray_exit_dist(tip[0], tip[1], ux, uy, vb)
+            yield (
+                tip,
+                (
+                    tip[0] + ux * (exit_distance + reach),
+                    tip[1] + uy * (exit_distance + reach),
+                    0,
+                ),
+                owner,
+            )
+
+
 def _flat_candidates(dwg, view, vb, members, reach, *, provenances):
     """Keep the established centre-out lead first, then try true margin escapes.
 
@@ -1706,6 +1739,88 @@ def _leader_callout_pass(
     jobs = [(*job[:4], iter(job[4]), job[5]) for job in jobs]
     if not jobs:
         return 0
+    if joint and getattr(ctx, "feature_leaders", None) is not None:
+        for name, view, vb, label, raw_candidates, measurement in jobs:
+            joint_candidates, fallback_candidates = tee(raw_candidates)
+
+            def _lane_candidates(_raw=joint_candidates):
+                spacing = dwg.draft.font_size + 2 * dwg.draft.pad_around_text
+                for tip, elbow, feature in _raw:
+                    dx, dy = float(elbow[0]) - float(tip[0]), float(elbow[1]) - float(tip[1])
+                    length = math.hypot(dx, dy)
+                    if length <= 1e-12:
+                        yield (tip, elbow, feature)
+                        continue
+                    ux, uy = dx / length, dy / length
+                    px, py = -dy / length, dx / length
+                    for outward, lane in (
+                        (0, 0),
+                        (0, 1),
+                        (0, -1),
+                        (0, 2),
+                        (0, -2),
+                        (1, 0),
+                        (2, 0),
+                        (1, 1),
+                        (1, -1),
+                    ):
+                        yield (
+                            tip,
+                            (
+                                float(elbow[0]) + ux * spacing * outward + px * spacing * lane,
+                                float(elbow[1]) + uy * spacing * outward + py * spacing * lane,
+                                0,
+                            ),
+                            feature,
+                        )
+
+            def _build(tip, elbow, _feature, *, _label=label):
+                return Leader(
+                    tip=(tip[0], tip[1], 0),
+                    elbow=elbow,
+                    label=_label,
+                    draft=dwg.draft,
+                )
+
+            def _fallback_accept(
+                candidate,
+                obstacles,
+                page,
+                *,
+                _vb=vb,
+                _geom_clear=geom_clear,
+            ):
+                return _label_lands_clear(
+                    candidate.annotation,
+                    obstacles,
+                    _vb,
+                    page,
+                    geom_clear=_geom_clear,
+                )
+
+            collect_feature_leader(
+                ctx,
+                FeatureLeaderJob(
+                    name=name,
+                    view=view,
+                    silhouette=vb,
+                    label=label,
+                    candidates=_lane_candidates(),
+                    build=_build,
+                    measurement=tuple(measurement),
+                    noun=noun,
+                    drop_code=drop_code,
+                    fallback_candidates=fallback_candidates,
+                    fallback_accept=_fallback_accept,
+                    # Fixed dimensions/witnesses are exact-ink constraints in
+                    # the shared solve.  If every relocation is worse, retain
+                    # the established semantic callout only through explicit
+                    # Policy B: the solver penalises the crossing and the
+                    # emitter records a machine-readable warning (#1166).
+                    allow_policy_b_fixed=True,
+                ),
+            )
+        return 0
     trace = getattr(ctx, "trace", None)
     ev = trace.pass_event(f"{noun}_callouts") if trace is not None else None
     page = (a.margin, a.margin, a.PAGE_W - a.margin, a.PAGE_H - a.margin)
@@ -1980,7 +2095,7 @@ def render_chamfers(dwg, plan, a, *, ctx, only=None) -> int:
                 view,
                 vb,
                 _chamfer_label(pd.value_text, pd.value, ch) + _tol_suffix(pd.tolerance, draft),
-                _corner_candidates(dwg, view, vb, [ch], reach, provenances=[g.ref]),
+                _corner_escape_candidates(dwg, view, vb, [ch], reach, provenances=[g.ref]),
                 (pd.id,),
             )
         )
@@ -2063,7 +2178,7 @@ def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
                 view,
                 vb,
                 _fillet_label(members[0][1].value_text, len(members)) + _tol_suffix(tol, draft),
-                _corner_candidates(
+                _corner_escape_candidates(
                     dwg,
                     view,
                     vb,
@@ -4074,6 +4189,14 @@ def render_step_positions(dwg, plan, frame, *, ctx) -> int:
     return n
 
 
+def _global_axis_centerline(first, second):
+    """A turning-axis centreline whose tip attachment is intentional (#1166)."""
+
+    centerline = Centerline(first, second)
+    centerline.is_global_axis_centerline = True
+    return centerline
+
+
 def render_rotational(dwg, plan, a, *, ctx) -> int:
     """Rotational furniture from the IR `RotationalFeature` (#237): the OD dim (above
     the front view), the rotation-axis centrelines (front + side), and the concentric
@@ -4117,12 +4240,18 @@ def render_rotational(dwg, plan, a, *, ctx) -> int:
             )
             n += 1
         ctx.place(
-            Centerline((FX(a.cx), FZ(a.bb.min.Z) - 5, 0), (FX(a.cx), FZ(a.bb.max.Z) + 5, 0)),
+            _global_axis_centerline(
+                (FX(a.cx), FZ(a.bb.min.Z) - 5, 0),
+                (FX(a.cx), FZ(a.bb.max.Z) + 5, 0),
+            ),
             "centerline_front",
             view="front",
         )
         ctx.place(
-            Centerline((SX(a.cy), SZ(a.bb.min.Z) - 5, 0), (SX(a.cy), SZ(a.bb.max.Z) + 5, 0)),
+            _global_axis_centerline(
+                (SX(a.cy), SZ(a.bb.min.Z) - 5, 0),
+                (SX(a.cy), SZ(a.bb.max.Z) + 5, 0),
+            ),
             "centerline_side",
             view="side",
         )
@@ -4207,12 +4336,18 @@ def render_rotational(dwg, plan, a, *, ctx) -> int:
             )
             n += 1
         ctx.place(
-            Centerline((FX(a.bb.min.X) - 5, FZ(a.cz), 0), (FX(a.bb.max.X) + 5, FZ(a.cz), 0)),
+            _global_axis_centerline(
+                (FX(a.bb.min.X) - 5, FZ(a.cz), 0),
+                (FX(a.bb.max.X) + 5, FZ(a.cz), 0),
+            ),
             "centerline_front",
             view="front",
         )
         ctx.place(
-            Centerline((PX(a.bb.min.X) - 5, PY(a.cy), 0), (PX(a.bb.max.X) + 5, PY(a.cy), 0)),
+            _global_axis_centerline(
+                (PX(a.bb.min.X) - 5, PY(a.cy), 0),
+                (PX(a.bb.max.X) + 5, PY(a.cy), 0),
+            ),
             "centerline_plan",
             view="plan",
         )
@@ -4236,12 +4371,18 @@ def render_rotational(dwg, plan, a, *, ctx) -> int:
             )
             n += 1
         ctx.place(
-            Centerline((SX(a.bb.min.Y) - 5, SZ(a.cz), 0), (SX(a.bb.max.Y) + 5, SZ(a.cz), 0)),
+            _global_axis_centerline(
+                (SX(a.bb.min.Y) - 5, SZ(a.cz), 0),
+                (SX(a.bb.max.Y) + 5, SZ(a.cz), 0),
+            ),
             "centerline_side",
             view="side",
         )
         ctx.place(
-            Centerline((PX(a.cx), PY(a.bb.min.Y) - 5, 0), (PX(a.cx), PY(a.bb.max.Y) + 5, 0)),
+            _global_axis_centerline(
+                (PX(a.cx), PY(a.bb.min.Y) - 5, 0),
+                (PX(a.cx), PY(a.bb.max.Y) + 5, 0),
+            ),
             "centerline_plan",
             view="plan",
         )
@@ -4275,23 +4416,35 @@ def render_local_turned_centerlines(dwg, a, *, ctx) -> int:
 
     if axis == "x":
         _place(
-            Centerline((FX(a.bb.min.X) - 5, FZ(a.cz), 0), (FX(a.bb.max.X) + 5, FZ(a.cz), 0)),
+            _global_axis_centerline(
+                (FX(a.bb.min.X) - 5, FZ(a.cz), 0),
+                (FX(a.bb.max.X) + 5, FZ(a.cz), 0),
+            ),
             "centerline_front",
             "front",
         )
         _place(
-            Centerline((PX(a.bb.min.X) - 5, PY(a.cy), 0), (PX(a.bb.max.X) + 5, PY(a.cy), 0)),
+            _global_axis_centerline(
+                (PX(a.bb.min.X) - 5, PY(a.cy), 0),
+                (PX(a.bb.max.X) + 5, PY(a.cy), 0),
+            ),
             "centerline_plan",
             "plan",
         )
     elif axis == "y":
         _place(
-            Centerline((SX(a.bb.min.Y) - 5, SZ(a.cz), 0), (SX(a.bb.max.Y) + 5, SZ(a.cz), 0)),
+            _global_axis_centerline(
+                (SX(a.bb.min.Y) - 5, SZ(a.cz), 0),
+                (SX(a.bb.max.Y) + 5, SZ(a.cz), 0),
+            ),
             "centerline_side",
             "side",
         )
         _place(
-            Centerline((PX(a.cx), PY(a.bb.min.Y) - 5, 0), (PX(a.cx), PY(a.bb.max.Y) + 5, 0)),
+            _global_axis_centerline(
+                (PX(a.cx), PY(a.bb.min.Y) - 5, 0),
+                (PX(a.cx), PY(a.bb.max.Y) + 5, 0),
+            ),
             "centerline_plan",
             "plan",
         )