draftwright 0.4.4__tar.gz → 0.4.6__tar.gz

{draftwright-0.4.4 → draftwright-0.4.6}/CHANGELOG.md

@@ -1,6 +1,44 @@
 # Changelog
 
-## Unreleased
+## v0.4.6 — 2026-08-15
+
+### Changed
+
+- **Geometry recognition is supplied by the standalone Apache-2.0
+  [`b123d-recognisers`](https://github.com/pzfreo/b123d-recognisers) package.** The cutover
+  pins the published stable release `v0.1.0` (built from commit
+  `9e622716c14d491729b5191aa6e5d8351c982a51`), removes the
+  duplicate embedded implementation, and keeps only identity-preserving
+  `draftwright.recognition` / `draftwright.score` compatibility re-exports until 0.6.0.
+  Draftwright continues to own the one-result build/lint cache, record→IR conversion, drafting
+  policy, placement, and critique. The package migration is manifest-pinned and golden-backed;
+  its sole normalization makes an exact dominant-axis tie deterministic across operating
+  systems without changing feature policy.
+
+### Fixed
+
+- Hole-callout obstacle checks now account for the rendered leader shaft width and
+  tip-local arrowhead flare instead of treating the leader as a zero-width centreline
+  (#367). The analytical check remains geometry-only and does not over-reserve the
+  arrowhead's clearance along the whole shaft.
+- Exact X/Z slanted flats retain their established lint-clean side-view callout after the
+  recogniser package's cross-platform semantic-axis normalization. The normalized recognition
+  record remains unchanged; `FlatFeature.presentation_axis` carries the downstream drawing-view
+  choice, preventing a leader/silhouette crossing without duplicating recognition.
+
+## v0.4.5 — 2026-08-15
+
+**A focused technical-drawing correctness patch.** Cross-drilled hole locations now remain
+complete and ordered, datum-starting pocket annotations avoid redundant dimensions, and repeated
+equal-radius fillets collapse into one manufacturing callout.
+
+### Fixed
+
+- Side-drilled hole heights that relocate around callout leaders now join the alternate
+  view's shared dimension ladder before placement, preserving every height and keeping
+  feature locations inside the overall dimension. Datum-starting open pockets no longer
+  print a redundant half-length centre offset, and equal-radius fillets across different
+  edge axes collapse into one counted ``n× R`` callout.
 
 ## v0.4.4 — 2026-08-15
 

{draftwright-0.4.4 → draftwright-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.4
+Version: 0.4.6
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,6 +684,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: antlr4-python3-runtime<4.10
+Requires-Dist: b123d-recognisers==0.1.0
 Requires-Dist: build123d-drafting-helpers>=0.14.1
 Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
 Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
@@ -967,17 +968,20 @@ or declared features converge on a `PartModel` IR, then planner-fed and
 sanctioned model-routed render intents feed shared placement, projection, and
 export. Coverage lint independently compares recognised geometry with the
 placed drawing, so an upstream omission cannot hide from verification. It
-builds on two libraries:
+builds on three libraries:
 
 ```
 draftwright
+    └── b123d-recognisers          — deterministic geometry recognition
     └── build123d-drafting-helpers  — Dimension, Leader, HoleCallout, …
     └── build123d                   — CAD kernel
 ```
 
-It owns feature recognition (`recognition/`) and linting (`linting/`); annotation
-primitives (`Dimension`, `Leader`, etc.) live in `build123d-drafting-helpers` and can
-be used independently. The compiler is largely converged in production — turned
+Geometry recognition lives in the Apache-2.0 `b123d-recognisers` package. Draftwright owns
+the per-build recognition cache, record→IR conversion, drafting policy, and linting
+(`linting/`); annotation primitives (`Dimension`, `Leader`, etc.) live in
+`build123d-drafting-helpers` and can be used independently. The compiler is largely converged
+in production — turned
 dims/lengths, centre marks, envelope, slots, holes (callouts/locations/grouping),
 the section A–A trigger, the prismatic step-ladder + rotational furniture, and PMI/GD&T
 are all on the IR. See

{draftwright-0.4.4 → draftwright-0.4.6}/README.md

@@ -268,17 +268,20 @@ or declared features converge on a `PartModel` IR, then planner-fed and
 sanctioned model-routed render intents feed shared placement, projection, and
 export. Coverage lint independently compares recognised geometry with the
 placed drawing, so an upstream omission cannot hide from verification. It
-builds on two libraries:
+builds on three libraries:
 
 ```
 draftwright
+    └── b123d-recognisers          — deterministic geometry recognition
     └── build123d-drafting-helpers  — Dimension, Leader, HoleCallout, …
     └── build123d                   — CAD kernel
 ```
 
-It owns feature recognition (`recognition/`) and linting (`linting/`); annotation
-primitives (`Dimension`, `Leader`, etc.) live in `build123d-drafting-helpers` and can
-be used independently. The compiler is largely converged in production — turned
+Geometry recognition lives in the Apache-2.0 `b123d-recognisers` package. Draftwright owns
+the per-build recognition cache, record→IR conversion, drafting policy, and linting
+(`linting/`); annotation primitives (`Dimension`, `Leader`, etc.) live in
+`build123d-drafting-helpers` and can be used independently. The compiler is largely converged
+in production — turned
 dims/lengths, centre marks, envelope, slots, holes (callouts/locations/grouping),
 the section A–A trigger, the prismatic step-ladder + rotational furniture, and PMI/GD&T
 are all on the IR. See

{draftwright-0.4.4 → draftwright-0.4.6}/docs/adr/README.md

@@ -25,15 +25,15 @@ architecture** table; open retired or superseded records only for design history
 | [0004](0004-compose-then-pack-view-blocks.md) | Compose-then-pack: views as blocks carrying their annotation footprint | Compose each view with its annotation footprint, then pack fixed-topology blocks. | Accepted | `test_layout.py`, `test_layout_cleanliness.py`, `test_refactor_golden.py` |
 | [0005](0005-pipeline-architecture-and-state-ownership.md) | Compiler-pipeline module boundaries and single-owner build state | Give compiler stages explicit module homes and build-time state explicit owners. | Accepted; implemented; compatibility aliases tracked by #720 | `test_import_boundaries.py`, `test_drawing_encapsulation.py`, `test_registry.py` |
 | [0006](0006-deterministic-layout-via-bundled-fonts.md) | Deterministic cross-platform layout via bundled, path-pinned fonts | Pin bundled font files so text measurement and layout are cross-platform deterministic. | Accepted | `test_refactor_golden.py`, `test_layout_cleanliness.py` |
-| [0007](0007-own-recognition-and-linting.md) | draftwright owns feature recognition and linting; helpers becomes the rendering library | draftwright owns recognition and linting; helpers remains a rendering library. | Accepted | `test_import_boundaries.py`, `test_recognition.py`, `test_linting.py` |
+| [0007](0007-own-recognition-and-linting.md) | draftwright owns feature recognition and linting; helpers becomes the rendering library | Draftwright owns linting, recognition lifecycle, IR conversion, and drafting policy; `b123d-recognisers` owns geometry recognition; helpers remains the rendering library. | Accepted; extraction deployed by Amendment 2 | `test_import_boundaries.py`, `test_external_recognition_boundary.py`, `test_linting.py` |
 | [0010](0010-annotation-provenance-seam.md) | Annotation provenance: record intent → annotation once, at the render seam | Record annotation provenance once at the render/add seam. | Accepted; landed | `test_render_seam.py`, `test_registry.py` |
 | [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 (with `b123d-recognisers` as its deferred shared deployment) | Enforce a uniform geometry-only recogniser contract internally; defer package extraction until there is a second consumer. | Accepted; Phase 1 in progress; extraction deferred | `test_recogniser_contract.py`, `test_import_boundaries.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. | Accepted; supersedes 0009 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.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 explicit recognition result owned by `BuildState`; require vertical-slice evidence before generalising correspondence, identity, requirements, outcomes, or reconciliation. | Accepted; ownership phase landed, extensions gated by #1018 | `test_recognition_manifest.py`, `test_recognition_result.py`, `test_declared_recognition_gate.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` |
 | [0018](0018-requirement-driven-view-planning-and-editable-sheet-layout.md) | Requirement-driven view planning and editable sheet layout | Use one `ViewSpec` vocabulary and planner with distinct authored `ViewConstraints` and immutable `ResolvedViewPlan`; jointly validate views, typography, convention, scale, paper and layout against requirement survival. If accepted, supersedes ADR 0004's fixed-topology assumption while retaining compose-then-pack. | Proposed; tracked by #1130 | Required guards are listed in the ADR |
 
 ## Historical records

{draftwright-0.4.4 → draftwright-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.4"
+version = "0.4.6"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,6 +18,7 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.14.1",
+    "b123d-recognisers==0.1.0",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2
     # Apache-2.0 wrapping Google PDFium BSD-3) and ship pre-built wheels with NO native system
@@ -163,6 +164,7 @@ dev = [
     "pytest-timeout>=2",
     "pytest-xdist>=3",
     "ruff>=0.4",
+    "tomli>=2; python_version < '3.11'",
 ]
 
 [tool.codespell]

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/_core.py

@@ -25,8 +25,9 @@ from types import SimpleNamespace
 from typing import TYPE_CHECKING, Literal
 
 if TYPE_CHECKING:
+    from b123d_recognisers import RecognitionResult, TurnedProfile
+
     from draftwright.compose import StripDepths
-    from draftwright.recognition import RecognitionResult, TurnedProfile
 
 from build123d import Align, BoundBox, Compound, Edge, Location, Mode, Shape, Text, Vector
 from build123d_drafting.helpers import (

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/_geometry.py

@@ -327,6 +327,94 @@ 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_polygon_overlaps_box(points, box) -> bool:
+    """Whether a convex page-plane polygon has positive-area overlap with an AABB.
+
+    This is the small separating-axis primitive used by
+    :func:`_leader_ink_crosses_box`.  Keeping it here makes the rendered-ink model pure
+    rectangle/vector maths: placement does not build temporary OCC geometry merely to ask
+    whether a candidate is clear (ADRs 0004/0014).
+    """
+    corners = (
+        (box[0], box[1]),
+        (box[2], box[1]),
+        (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)
+    )
+    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_crosses_box(
+    tip,
+    elbow,
+    box,
+    *,
+    arrow_length: float,
+    line_width: float,
+) -> bool:
+    """Whether a rendered leader's tip-to-elbow ink overlaps *box*.
+
+    A leader is not a zero-width segment.  Its shaft is a swept rectangle of
+    ``line_width`` and each supported arrowhead style is contained by the triangle from
+    the tip to a base ``arrow_length`` along the shaft, with the helper's
+    ``arrow_length / 3`` lateral flare.  Testing those two local convex footprints keeps
+    the arrow clearance near the tip; inflating the entire shaft by the arrow size would
+    reject genuinely clear obstacles near the elbow (#367).
+
+    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),
+        )
+        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:
     """Whether two page-plane segments cross or overlap beyond a shared endpoint.
 

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/analysis.py

@@ -17,6 +17,14 @@ from collections.abc import Callable
 from dataclasses import dataclass, replace
 from typing import cast
 
+from b123d_recognisers import (
+    RecognitionResult,
+    TurnedProfile,
+    TurnedStep,
+    analyse_cylinders,
+    build_recognition_result,
+    full_cylinders,
+)
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
 from OCP.IFSelect import IFSelect_ReturnStatus
@@ -47,14 +55,6 @@ from draftwright.compose import (
 from draftwright.model import build_part_model
 from draftwright.model.ir import Datum, PartModel, StepFeature, StepLevelFeature
 from draftwright.model.planner import plan_dimensions
-from draftwright.recognition import (
-    RecognitionResult,
-    TurnedProfile,
-    TurnedStep,
-    analyse_cylinders,
-    build_recognition_result,
-    full_cylinders,
-)
 
 _log = logging.getLogger(__name__)
 

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/annotations/from_model.py

@@ -1759,16 +1759,16 @@ def _fillet_label(radius_text, count) -> str:
 
 def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
     """Fillet radius callouts (#561): a leader from an external edge fillet to its
-    ``R{radius}`` label — the arc analog of :func:`render_chamfers`. Equal-radius fillets on
-    the same edge axis share ONE ``n× R`` callout (#561 acceptance), placed in the view
-    normal to the rounded edge, led diagonally out of the corner into clear margin, and
+    ``R{radius}`` label — the arc analog of :func:`render_chamfers`. Equal-radius fillets
+    share ONE ``n× R`` callout (#561 acceptance), placed in the view normal to a
+    representative rounded edge, led diagonally out of the corner into clear margin, and
     dropped (lint, not silently) if it would overprint placed geometry. Returns the count.
 
     Planner-fed (#725 / #698): the radius VALUE + its tolerance come from the planner's
     ``DimParameter`` (as in ``render_chamfers``), bound explicitly by ``(role, kind)``,
     never positionally — formatting ``fl.radius`` directly dropped an authored tolerance
     (the #629 class). The equal-radius ``n× R`` COLLAPSE stays render-side (grouping by
-    ``(axis, value)`` here, as before) — planner-side grouping is a structural change,
+    radius here) — planner-side grouping is a structural change,
     explicitly out of scope for this migration (#698). Where grouped members' authored
     tolerances differ, the first (member-order) authored one wins — the documented
     ``render_diameters`` shared-ø precedent. ``g.view`` is safe: a FilletFeature's frame
@@ -1785,9 +1785,9 @@ def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
         )
         if pd is None:
             continue
-        collapse.setdefault((g.facts.axis, round(pd.value, 3)), []).append((g, pd))
+        collapse.setdefault(round(pd.value, 3), []).append((g, pd))
     jobs = []
-    for gi, ((axis, _radius), members) in enumerate(sorted(collapse.items())):
+    for gi, (_radius, members) in enumerate(sorted(collapse.items())):
         if only is not None:
             # #426 Ph2b subset (finalize): filter members AFTER the collapse is enumerated so
             # gi stays the full-drawing group index — a survivor keeps its m_fillet name even
@@ -1795,10 +1795,15 @@ def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
             members = [gp for gp in members if gp[0].ref in only]
             if not members:
                 continue
-        # One grouped ``n× R`` callout, but its leader may anchor at ANY of the equal fillets
-        # — _corner_candidates tries each corner (nearest-clear first) so the group is not
-        # dropped just because its first corner leads into an occupied region.
-        ordered = sorted(members, key=lambda gp: gp[0].facts.frame.origin)
+        # Point the leader at one coherent visible set. Members on other edge axes still
+        # contribute to the printed count and semantic measurements, but mixing their 3-D
+        # origins into this view could point at unrelated projected corners. Prefer the
+        # axis with the most members; ties are deterministic.
+        by_axis: dict[str, list] = {}
+        for gp in members:
+            by_axis.setdefault(gp[0].facts.axis, []).append(gp)
+        axis, visible = min(by_axis.items(), key=lambda item: (-len(item[1]), item[0]))
+        ordered = sorted(visible, key=lambda gp: gp[0].facts.frame.origin)
         view = ordered[0][0].view
         vb = dwg.view_bounds(view)
         if vb is None:
@@ -1812,7 +1817,7 @@ def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
                 f"m_fillet_{axis}{gi}",
                 view,
                 vb,
-                _fillet_label(members[0][1].value_text, len(ordered)) + _tol_suffix(tol, draft),
+                _fillet_label(members[0][1].value_text, len(members)) + _tol_suffix(tol, draft),
                 _corner_candidates(
                     dwg,
                     view,
@@ -1823,7 +1828,7 @@ def render_fillets(dwg, plan, a, *, ctx, only=None) -> int:
                 ),
                 # One `n× R` callout stands for EVERY collapsed member, so it draws all of
                 # their radii — the tuple storage exists for exactly this (#1002).
-                tuple(pd.id for _, pd in ordered),
+                tuple(pd.id for _, pd in members),
             )
         )
     return _leader_callout_pass(dwg, a, jobs, noun="fillet", drop_code="fillet_dropped", ctx=ctx)
@@ -1876,6 +1881,7 @@ def render_flats(dwg, plan, a, *, ctx, only=None) -> int:
         collapse.setdefault(
             (
                 g.facts.axis,
+                g.facts.presentation_axis,
                 g.facts.axis_direction,
                 g.facts.axis_line,
                 g.facts.stock_span,
@@ -1884,7 +1890,7 @@ def render_flats(dwg, plan, a, *, ctx, only=None) -> int:
             [],
         ).append((g, pd))
     jobs = []
-    for gi, ((axis, _direction, _line, _span, _across), members) in enumerate(
+    for gi, ((_axis, presentation_axis, _direction, _line, _span, _across), members) in enumerate(
         sorted(collapse.items())
     ):
         if only is not None:
@@ -1915,7 +1921,7 @@ def render_flats(dwg, plan, a, *, ctx, only=None) -> int:
         )
         jobs.append(
             (
-                f"m_flat_{axis}{gi}",
+                f"m_flat_{presentation_axis}{gi}",
                 view,
                 vb,
                 _flat_label(members[0][1].value_text, _tol_suffix(tol, draft)),

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/annotations/holes.py

@@ -33,7 +33,7 @@ from draftwright._core import (
     _iso_bbox,
     _log,
 )
-from draftwright._geometry import plane_axes
+from draftwright._geometry import _leader_ink_crosses_box, plane_axes
 from draftwright.annotations._common import (
     CROSSABLE_TYPES,
     CorridorCandidate,
@@ -42,17 +42,18 @@ from draftwright.annotations._common import (
     _geom_box,
     _hole_location_coverage_fact,
     _same_location_ordinate,
-    _segment_crosses_box,
     _with_hole_center_coverage,
     _with_hole_location_coverage,
     box_within_page_and_clear,
     carve_free_position,
     carve_free_segments,
     clear_label_of_centerlines,
+    corridor_blockers,
     dim_footprint,
     leader_footprint,
     place_strip_candidates,
     register_corridor,
+    strip_free_span,
     strip_obstacles,
 )
 from draftwright.annotations.from_model import (
@@ -967,6 +968,42 @@ def _locate_along_z(dwg, ctx, a: Analysis, off):
         strip, view, p_lo, p_hi, edge = primary
         primary_cand = _zc(view, p_lo, p_hi, edge)
 
+        # Choose the alternate BEFORE the shared corridor solve when the natural
+        # witness corridor is already known to cross a placed leader. A post-drain
+        # relocation cannot join the alternate view's existing ladder, so it used to
+        # land outside the overall height and cross its witness line. The inner-tier
+        # footprint is decisive: moving a right-side dimension farther out only grows
+        # the corridor back to the view and therefore cannot clear an existing blocker.
+        if strip is not None and alternates:
+            _lo, _hi, inner = strip_free_span(strip)
+            blocked = _box_hits(_geom_box(primary_cand[1](inner)), corridor_blockers(dwg, view))
+            if blocked:
+                alt_strip, alt_view, alt_p_lo, alt_p_hi, alt_edge = alternates[0]
+                alt_cand = _zc(alt_view, alt_p_lo, alt_p_hi, alt_edge)
+                alt_blocked = alt_strip is None
+                if alt_strip is not None:
+                    _alo, _ahi, alt_inner = strip_free_span(alt_strip)
+                    alt_blocked = _box_hits(
+                        _geom_box(alt_cand[1](alt_inner)),
+                        corridor_blockers(dwg, alt_view),
+                    )
+                    # Do not pre-route into a corridor that cannot hold its existing
+                    # shared ladder plus this candidate. In that case the historical
+                    # alternate/force path remains the honest policy-B fallback.
+                    existing = len(
+                        ctx.corridor_batch.get((alt_view, "right"), {}).get("cands", ())
+                    )
+                    pad = tier + alt_strip.spacing
+                    usable = max(0.0, _ahi - _alo - tier)
+                    capacity = int(usable / pad) + 1
+                    alt_blocked = alt_blocked or capacity < existing + 1
+                if not alt_blocked:
+                    original = primary
+                    primary = alternates[0]
+                    alternates = [original, *alternates[1:]]
+                    strip, view, p_lo, p_hi, edge = primary
+                    primary_cand = alt_cand
+
         def _fallback(
             _nm,
             _primary=primary,
@@ -974,10 +1011,14 @@ def _locate_along_z(dwg, ctx, a: Analysis, off):
             _cand=primary_cand,
             _feature_map=_zf,
             _measurement_map=_zm,
+            _candidate_factory=_zc,
             _zo=zo,
         ):
             for alt_strip, alt_view, alt_p_lo, alt_p_hi, alt_edge in _alts:
-                alt = _zc(alt_view, alt_p_lo, alt_p_hi, alt_edge)
+                # Capture this loop member's factory. Referring to `_zc` directly
+                # late-bound every callback to the final height, so two dropped hole
+                # heights retried the last one twice and silently lost the first.
+                alt = _candidate_factory(alt_view, alt_p_lo, alt_p_hi, alt_edge)
                 if not _off_axis_emit(
                     dwg,
                     tier,
@@ -1843,15 +1884,25 @@ def _needs_section(feat: HoleFeature | PatternFeature):
     return bore.cbore is not None or bore.spotface is not None or not bore.through
 
 
-def _leader_hits(leader, tip, elbow, side, obstacles):
+def _leader_hits(leader, tip, elbow, side, obstacles, draft):
     """True when *leader*'s rendered footprint truly overlaps any *obstacles* box — split into
-    the diagonal tip→elbow SHAFT (checked precisely via `_segment_crosses_box`, since its AABB
-    over-claims the empty triangle it doesn't occupy — #305) and the elbow→label shelf+text
-    (axis-aligned, so the coarse AABB check there is already exact). Promoted (#638; pure)."""
+    the diagonal tip→elbow SHAFT + ARROWHEAD (checked against their analytical rendered ink,
+    since the composite AABB over-claims the empty triangle it doesn't occupy — #305/#367) and
+    the elbow→label shelf+text (axis-aligned, so the coarse AABB check there is already exact).
+    Promoted (#638; pure)."""
     full_box = _geom_box(leader)
     if full_box is None or not _box_hits(full_box, obstacles):
         return False  # fast reject: nowhere near any obstacle
-    if any(_segment_crosses_box(tip, elbow, o) for o in obstacles):
+    if any(
+        _leader_ink_crosses_box(
+            tip,
+            elbow,
+            obstacle,
+            arrow_length=draft.arrow_length,
+            line_width=draft.line_width,
+        )
+        for obstacle in obstacles
+    ):
         return True
     label_box = (
         (elbow[0], full_box[1], full_box[2], full_box[3])
@@ -2391,7 +2442,7 @@ def _place_queue(
             continue
         y = final_y[tid]
         leader, tip, elbow = _build_leader_at(s, edge, side, y, to_page, elbow_dx, draft, a.SCALE)
-        if _leader_hits(leader, tip, elbow, side, occupied):
+        if _leader_hits(leader, tip, elbow, side, occupied, draft):
             crossing.append((s, y, leader))
         else:
             placed.append((s, y, leader))

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/drawing.py

@@ -20,7 +20,7 @@ from dataclasses import field as dataclasses_field
 from typing import TYPE_CHECKING, Any, NamedTuple
 
 if TYPE_CHECKING:
-    from draftwright.recognition import RecognitionResult
+    from b123d_recognisers import RecognitionResult
 
 # PEP 702 @deprecated. A `sys.version_info` guard (not try/except) so the type checker,
 # which targets the 3.10 floor, resolves the backport branch instead of `warnings.deprecated`
@@ -30,6 +30,7 @@ if sys.version_info >= (3, 13):
 else:
     from typing_extensions import deprecated
 
+from b123d_recognisers import analyse_cylinders
 from build123d import (
     Color,
     ExportSVG,
@@ -98,7 +99,7 @@ from draftwright.linting.quality import quality_components
 from draftwright.projection import (
     project_view_geometry,
 )
-from draftwright.recognition import analyse_cylinders, build_recognition_result
+from draftwright.recognition_cache import RecognitionCache
 from draftwright.registry import AnnotationRegistry
 from draftwright.repair import repair_drawing
 
@@ -320,7 +321,7 @@ class BuildState:
     """
 
     analysis: Analysis | None = None
-    recognition: RecognitionResult | None = None
+    recognition_cache: RecognitionCache = dataclasses_field(default_factory=RecognitionCache)
     part_model: object | None = None
     view_edge_cache: dict = dataclasses_field(default_factory=dict)
     ann_box_cache: dict = dataclasses_field(default_factory=dict)
@@ -335,6 +336,16 @@ class BuildState:
     #: suppression rule produced four issue reports before anyone found the rule (#997).
     omissions: tuple = ()
 
+    @property
+    def recognition(self) -> RecognitionResult | None:
+        """The immutable result held by Draftwright's consumer-owned lifecycle cache."""
+
+        return self.recognition_cache.result
+
+    @recognition.setter
+    def recognition(self, value: RecognitionResult | None) -> None:
+        self.recognition_cache.result = value
+
     def clear_geometry_caches(self) -> None:
         """The one invalidation seam (finalize rollback): view edges + annotation
         boxes together — a rolled-back drawing must re-measure everything."""
@@ -353,9 +364,7 @@ class BuildState:
         On a detected build ``recognition`` is already filled by the builder, so this returns
         it and recognises nothing.
         """
-        if self.recognition is None:
-            self.recognition = build_recognition_result(part)
-        return self.recognition
+        return self.recognition_cache.ensure(part)
 
 
 class Drawing:

{draftwright-0.4.4 → draftwright-0.4.6}/src/draftwright/linting/channel_coverage.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal
 
+from b123d_recognisers import RecognitionResult, has_multi_axis_plates
+
 from draftwright.linting.issues import LintIssue
-from draftwright.recognition import RecognitionResult, has_multi_axis_plates
 
 ChannelRequirementState = Literal["placed", "suppressed", "dropped", "missing", "unverifiable"]