draftwright 0.1.13__tar.gz → 0.2.1__tar.gz

{draftwright-0.1.13 → draftwright-0.2.1}/CHANGELOG.md

@@ -2,6 +2,114 @@
 
 ## Unreleased
 
+## v0.2.1 — 2026-06-30
+
+A patch release focused on **turned-part dimensioning legibility**: crowded
+step-length chains and fine turned heads are now drawn legibly instead of crammed.
+Drawing output changes for affected turned parts.
+
+### Added
+
+- **Automatic enlarged detail view for a crowded turned head** (#304). A turned
+  part with a fine cluster of steps near one end and a long shaft (e.g. a thumbwheel
+  drive screw) cannot have its head dimensioned legibly in line at any sensible
+  scale. The head is now located as one block on the main view and broken out into
+  an enlarged **DETAIL A — SCALE n:1** — the textbook treatment — firing
+  automatically when a head's shoulders fall below the page legibility floor.
+
+### Changed
+
+- **Crowded turned step-length chains stagger across two tiers** (#293) instead of
+  cramming or being skipped. When the labels would collide on one line, the ISO
+  129-1 staggered convention alternates them between a near and a far tier so every
+  step length stays legible at the drawing's own scale — no rescale needed. A roomy
+  chain stays on a single tier.
+- **Detail views are now one unified pipeline** (#307). The prismatic step-height
+  detail and the new turned-head detail flow through a single
+  detect → request → render path; several crowded regions become DETAIL A/B/…
+- **Output changes** for turned parts whose step chains were previously crammed, or
+  whose fine heads are now broken out into a detail view.
+
+### Fixed
+
+- **A coaxial bore callout no longer overlaps the round view's centreline** (#305):
+  its leader is angled off the centre axis so the callout text sits in clear space.
+
+### Internal
+
+- A new **layout-cleanliness invariant test** asserts that finished drawings have no
+  view/annotation collisions across representative part archetypes, and the
+  measure-and-repack pass gained a trigger for an annotation growing into a
+  neighbouring view's line-work (so the views spread to make room).
+
+## v0.2.0 — 2026-06-30
+
+A major release. draftwright took ownership of feature recognition and linting
+(ADR 0007) and was re-architected onto a feature-IR + dimensioning-planner
+"compiler" (ADR 0008), gaining a Typer CLI and a portable, pure-Python PDF path
+along the way. **Generated drawings change** versus v0.1.13: the new pipeline
+dimensions parts more completely and consistently, so placement and the set of
+dimensions can differ — output is not byte-compatible with prior releases.
+
+### Changed
+
+- **Re-architected onto a feature-IR + dimensioning planner** (ADR 0008). The
+  engine is now a compiler: detectors build one feature inventory → a typed IR /
+  `PartModel` → a dimensioning planner emits render-intents → shared
+  layout/projection/export. Orientation and feature-kind are *data in the IR*,
+  not code branches, and every feature class (holes, patterns, counterbores,
+  slots, turned diameters/steps, centre marks, location dims, envelope/OD,
+  section A–A, PMI/GD&T) was migrated onto this one path; the old parallel
+  recognisers and placement passes were deleted as each was replaced. Net effect
+  for users: more complete, more consistent drawings — but output differs from
+  v0.1.13.
+- **draftwright owns feature recognition and linting** (ADR 0007). The hole/
+  boss/cylinder/pattern recognisers, the slot/turned-step recognisers, and the
+  feature-coverage lint engine are vendored into `recognition/` and `linting.py`;
+  `build123d-drafting-helpers` is now purely the rendering library.
+- **The CLI writes a PDF by default** and takes a `--format` selector (#288).
+  Previously `draftwright part.step` emitted SVG + DXF; it now emits a single PDF.
+  Choose outputs with `--format` (a comma-list, with an `all` alias) —
+  `--format pdf,dxf`, `--format svg`, `--format all`. The library API is
+  unchanged: `make_drawing(...)` / `Drawing.export()` still write SVG + DXF.
+- **PDF export is now pure-Python and a core capability** (#288). The renderer
+  moved from `cairosvg` (which `dlopen`s the native `libcairo` system library —
+  absent on stock macOS/Windows, so PDF-by-default would have crashed there) to
+  `svglib` + `reportlab`, both pip-installable wheels with no system dependency.
+  PDF therefore works out of the box on every platform; output is visually
+  identical to the cairo renderer.
+
+### Added
+
+- **A Typer command-line interface** (#289/#291): shell completion
+  (`--install-completion` / `--show-completion`), rich `--help`, and `--version`
+  (reports the installed distribution version). All existing flags are preserved.
+- **`--format` output selector** (#288) — `pdf` (default), `svg`, `dxf`, or `all`,
+  as a comma-list.
+- **Turned-part dimensioning**: axial step-length recognition and chains
+  (#188/#189/#231), step-diameter callouts, collapse of a uniform step
+  staircase to an "N× length" note (#290), and OD of a horizontal (X/Y) round
+  body dimensioned on the profile view (#292).
+- **Slot recognition and dimensioning** converged onto the IR as `SlotFeature`
+  (#242), and **section A–A** is now triggered by the planner (#271).
+- **A Contributor License Agreement** (#183).
+
+### Removed
+
+- **The `--pdf` flag** (use `--format pdf`, the new default), the **`[pdf]`
+  install extra**, and the **`cairosvg` dependency** (#288).
+- The byte-exact golden-output test harness (#190) — regression coverage rests on
+  the geometry-level and standards suites (ADR 0005 §3 / ADR 0007).
+
+### Fixed
+
+- Locate **every** side-drilled (off-axis) hole, not just the first (#225/#286).
+- Don't mis-detect a prismatic part with incidental cylinders as a turned part
+  (#293/#294); drop phantom zero-diameter turned steps (#279/#284); skip an
+  illegibly-dense step-length chain rather than cram it (#293/#296).
+- Degraded hole-pattern callout consistency (#262/#274).
+- Windows `python -m draftwright.make_drawing` CLI smoke / entrypoint (#181/#182).
+
 ## v0.1.13 — 2026-06-27
 
 ### Changed

{draftwright-0.1.13 → draftwright-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.1.13
+Version: 0.2.1
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,8 +684,9 @@ Requires-Dist: build123d-drafting-helpers>=0.13.0
 Requires-Dist: build123d>=0.9.0
 Requires-Dist: kiwisolver<2,>=1.4
 Requires-Dist: numpy>=1.24
-Provides-Extra: pdf
-Requires-Dist: cairosvg>=2.7; extra == 'pdf'
+Requires-Dist: reportlab>=4.0
+Requires-Dist: svglib>=1.5
+Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 
 # draftwright
@@ -714,6 +715,9 @@ Or from the command line:
 
 ```
 draftwright my_part.step --title "Mounting Block" --number DWG-001
+# writes my_part.pdf (the default); add --format to choose:
+draftwright my_part.step --format pdf,dxf    # PDF + DXF
+draftwright my_part.step --format all        # PDF + SVG + DXF
 ```
 
 ## What it produces
@@ -808,7 +812,10 @@ generation, the lint→repair loop, and the constraint-based layout engine).
 
 ## Architecture
 
-draftwright is a single module (`make_drawing.py`) on top of two libraries:
+draftwright is structured as a **part-drawing compiler** (ADR 0008): feature
+detectors → a `PartModel` IR (`Feature`s exposing `DimParameter`s) → a dimensioning
+planner → renderers, feeding a shared layout/projection/export stack. It builds on
+two libraries:
 
 ```
 draftwright
@@ -816,7 +823,13 @@ draftwright
     └── build123d                   — CAD kernel
 ```
 
-The engine handles view layout (strip/zone model), scale selection, feature recognition
-(holes, bosses, bolt circles), annotation placement, and section view generation.
-Annotation primitives (`Dimension`, `Leader`, `lint_drawing`, etc.) live in
-`build123d-drafting-helpers` and can be used independently.
+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
+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 — the migration is complete (one path; the orchestrator is
+build → plan → render). See
+[`docs/target-architecture.md`](docs/target-architecture.md) and
+[`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
+selection, annotation placement, and section rendering.

{draftwright-0.1.13 → draftwright-0.2.1}/README.md

@@ -24,6 +24,9 @@ Or from the command line:
 
 ```
 draftwright my_part.step --title "Mounting Block" --number DWG-001
+# writes my_part.pdf (the default); add --format to choose:
+draftwright my_part.step --format pdf,dxf    # PDF + DXF
+draftwright my_part.step --format all        # PDF + SVG + DXF
 ```
 
 ## What it produces
@@ -118,7 +121,10 @@ generation, the lint→repair loop, and the constraint-based layout engine).
 
 ## Architecture
 
-draftwright is a single module (`make_drawing.py`) on top of two libraries:
+draftwright is structured as a **part-drawing compiler** (ADR 0008): feature
+detectors → a `PartModel` IR (`Feature`s exposing `DimParameter`s) → a dimensioning
+planner → renderers, feeding a shared layout/projection/export stack. It builds on
+two libraries:
 
 ```
 draftwright
@@ -126,7 +132,13 @@ draftwright
     └── build123d                   — CAD kernel
 ```
 
-The engine handles view layout (strip/zone model), scale selection, feature recognition
-(holes, bosses, bolt circles), annotation placement, and section view generation.
-Annotation primitives (`Dimension`, `Leader`, `lint_drawing`, etc.) live in
-`build123d-drafting-helpers` and can be used independently.
+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
+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 — the migration is complete (one path; the orchestrator is
+build → plan → render). See
+[`docs/target-architecture.md`](docs/target-architecture.md) and
+[`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
+selection, annotation placement, and section rendering.

{draftwright-0.1.13 → draftwright-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.1.13"
+version = "0.2.1"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,6 +15,9 @@ dependencies = [
     "build123d-drafting-helpers>=0.13.0",
     "kiwisolver>=1.4,<2",
     "numpy>=1.24",
+    "reportlab>=4.0",
+    "svglib>=1.5",
+    "typer>=0.12",
 ]
 keywords = ["build123d", "cad", "drafting", "engineering-drawing", "technical-drawing", "automation"]
 classifiers = [
@@ -29,11 +32,8 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 
-[project.optional-dependencies]
-pdf = ["cairosvg>=2.7"]
-
 [project.scripts]
-draftwright = "draftwright.make_drawing:_cli"
+draftwright = "draftwright.cli:app"
 
 [project.urls]
 Homepage = "https://github.com/pzfreo/draftwright"

{draftwright-0.1.13 → draftwright-0.2.1}/src/draftwright/__init__.py

@@ -11,19 +11,41 @@ Requires build123d-drafting-helpers for annotation primitives.
 Licensed under the GNU Affero General Public License v3 (AGPL-3.0).
 """
 
+import sys as _sys
+import types as _types
+
 from draftwright.analysis import analyse_face_levels, dedup_diams
-from draftwright.make_drawing import (
-    Drawing,
-    FeatureInfo,
+from draftwright.builder import (
     build_drawing,
-    fix_svg_page_size,
     generate_script,
-    lint_feature_coverage,
     make_drawing,
 )
+from draftwright.drawing import Drawing, FeatureInfo
+from draftwright.export import fix_svg_page_size
+from draftwright.linting import lint_feature_coverage
 from draftwright.pmi import PmiRecord, extract_pmi
 from draftwright.sheet import choose_scale
 
+_make_drawing_function = make_drawing
+
+
+class _DraftwrightModule(_types.ModuleType):
+    def __getattribute__(self, name):
+        if name == "make_drawing":
+            namespace = _types.ModuleType.__getattribute__(self, "__dict__")
+            value = namespace.get(name)
+            if (
+                isinstance(value, _types.ModuleType)
+                and value.__name__ == "draftwright.make_drawing"
+            ):
+                public = namespace["_make_drawing_function"]
+                _types.ModuleType.__setattr__(self, name, public)
+                return public
+        return _types.ModuleType.__getattribute__(self, name)
+
+
+_sys.modules[__name__].__class__ = _DraftwrightModule
+
 __all__ = [
     "Drawing",
     "FeatureInfo",

{draftwright-0.1.13 → draftwright-0.2.1}/src/draftwright/_core.py

@@ -13,9 +13,14 @@ from __future__ import annotations
 import functools
 import logging
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import SimpleNamespace
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from draftwright.recognition import TurnedProfile
 
 from build123d import Align, BoundBox, Location, Mode, Shape, Text
 from build123d_drafting.helpers import (
@@ -36,6 +41,38 @@ _MARGIN = 10.0
 
 _TB_CLEAR = _MARGIN + 1.0  # title-block inset: one extra mm over _MARGIN for clearance
 
+# The orthographic view a feature is dimensioned end-on in — the view normal to its
+# axis. Single source of truth shared by the planner (view choice) and the lint
+# coverage checks (where to look for a feature's dims). Orientation is data.
+_END_ON = {"x": "side", "y": "front", "z": "plan"}
+
+
+def _xyz(loc) -> tuple[float, float, float]:
+    """A build123d ``Vector`` (has ``.X/.Y/.Z``) or an ``(x, y, z)`` sequence → an
+    ``(x, y, z)`` float tuple. Shared by the detectors and the lint coverage checks
+    so the Vector-unpacking idiom lives in one place."""
+    if hasattr(loc, "X"):
+        return (loc.X, loc.Y, loc.Z)
+    x, y, z = loc
+    return (float(x), float(y), float(z))
+
+
+@dataclass(frozen=True)
+class HoleRef:
+    """A position-keyed reference to a hole — the IR-typed value the cover / hole-table
+    bookkeeping matches on, so the shared escalation never needs a recogniser ``Hole``
+    object (ADR 0008 Amendment 6). Built from any location via :meth:`of` (rounded, so
+    two references at the same position compare equal)."""
+
+    x: float
+    y: float
+    z: float
+
+    @classmethod
+    def of(cls, loc) -> HoleRef:
+        x, y, z = _xyz(loc)
+        return cls(round(x, 3), round(y, 3), round(z, 3))
+
 
 _FONT_SIZE = 3.0  # annotation text height (page-mm); the draft preset is built with this
 
@@ -277,6 +314,29 @@ def _legible_steps(step_zs, bb_min_z, scale):
     return kept, n_too_close
 
 
+def _legible_locations(positions, scale):
+    """Axis positions far enough apart on the page to dimension legibly.
+
+    Given world-coordinate *positions* along one axis, keep a position only if it
+    is at least ``_MIN_LOC_SEP_MM`` page-mm from the previously kept one;
+    consecutive holes closer than that produce baseline witness lines that read
+    as a single busy cluster (#43). Returns ``(kept, n_too_close)``: the positions
+    to dimension and the count dropped for spacing (the caller surfaces these via
+    ``location_ref_dropped`` lint; the full-fidelity answer is a detail view, #42).
+    Mirrors :func:`_legible_steps` for hole locations.
+    """
+    kept: list[float] = []
+    n_too_close = 0
+    last = None
+    for p in sorted(positions):
+        if last is not None and (p - last) * scale < _MIN_LOC_SEP_MM:
+            n_too_close += 1
+            continue
+        kept.append(p)
+        last = p
+    return kept, n_too_close
+
+
 def _largest_empty_rect(drawable, obstacles):
     """Largest axis-aligned empty rectangle in *drawable* avoiding *obstacles*.
 
@@ -323,6 +383,48 @@ def _largest_empty_rect(drawable, obstacles):
     return best
 
 
+@dataclass
+class DetailRequest:
+    """A renderer's request for an enlarged detail of a region it could not draw
+    legibly at sheet scale (#307). Renderers append these to ``dwg._detail_requests``
+    instead of building bespoke detail views; ``_resolve_details`` resolves them all
+    through one generic detailer (crop → project → place → caption → marker), then
+    calls ``redraw`` to draw the feature's own dims inside the placed detail view.
+
+    The single ``detect → request → generic render`` path that folds the prismatic
+    step detail (#42) and the turned-head detail (#304) into one, mirroring the
+    section pipeline (``plan_sections``/``SectionPlan``).
+
+    Fields:
+        axis:         part axis the band spans / is cropped along ("x"/"y"/"z").
+        lo, hi:       band bounds along ``axis`` (world mm).
+        scale_needed: detail world→page scale that makes the region legible.
+        redraw:       ``redraw(dwg, view_name, detail_scale) -> int`` — draws the
+                      detail's dimensions in the placed detail view's coordinate system
+                      and returns the count placed (0 → the detailer rolls the view
+                      back rather than leave an empty box). Called once the detail is
+                      placed; the main view always carries the located head/block
+                      inline regardless, so a placement failure loses no coverage (lint
+                      reports the un-located interior instead).
+        pad_top:      page-mm band reserved above the detail view (a horizontal
+                      chain); reserved in the fit + placement.
+        pads:         optional ``pads(detail_scale) -> (pad_right, pad_top)`` for a
+                      footprint that depends on the chosen scale (the prismatic
+                      ladder reserves one rung per *legible-at-that-scale* step, so it
+                      shrinks with the scale during the fit). Overrides ``pad_top``.
+        kind:         short label for logging.
+    """
+
+    axis: str
+    lo: float
+    hi: float
+    scale_needed: float
+    redraw: Callable[..., int]
+    pad_top: float = 0.0
+    pads: Callable[[float], tuple[float, float]] | None = None
+    kind: str = "detail"
+
+
 @dataclass(frozen=True)
 class _Projector:
     """Model → page coordinate projection for the orthographic views.
@@ -401,12 +503,15 @@ class Analysis:
     bbox_max: float
     holes: list
     patterns: list
+    bosses: list  # external bosses (find_bosses), detected once — the one inventory (#244)
     slots: list
     z_diams: list[float]
     cross_diams: list[float]
     cyls: tuple[list, list]
+    prof: TurnedProfile | None  # turned step profile (find_turned_steps), detected once
     od_diam: float | None
     is_rotational: bool
+    od_axis: str  # rotation/turning axis of a rotational part ("z" default; "x"/"y" #222)
     step_zs: list[float]
     sv_right: float
     iso_right_limit: float

{draftwright-0.1.13 → draftwright-0.2.1}/src/draftwright/analysis.py

@@ -14,17 +14,7 @@ import logging
 import math
 
 from build123d import Compound, Shape
-from build123d_drafting.features import (
-    analyse_cylinders,
-    find_hole_patterns,
-    find_holes,
-    full_cylinders,
-)
 from build123d_drafting.helpers import draft_preset
-from OCP.BRepAdaptor import BRepAdaptor_Surface
-from OCP.BRepGProp import BRepGProp
-from OCP.GeomAbs import GeomAbs_Plane
-from OCP.GProp import GProp_GProps
 from OCP.IFSelect import IFSelect_ReturnStatus
 from OCP.STEPControl import STEPControl_Reader
 
@@ -37,7 +27,16 @@ from draftwright._core import (
     _legible_steps,
     _Projector,
 )
-from draftwright.features import find_slots
+from draftwright.recognition import (
+    analyse_cylinders,
+    analyse_face_levels,
+    find_bosses,
+    find_hole_patterns,
+    find_holes,
+    find_slots,
+    find_turned_steps,
+    full_cylinders,
+)
 from draftwright.sheet import (
     _build_zones,
     _layout_geometry,
@@ -115,40 +114,6 @@ def _is_rotational(x_size, y_size, od_diam, od_axis_offset) -> bool:
 # --- lint scoring (see Drawing.lint_summary) -------------------------------
 
 
-def analyse_face_levels(part, tol: float = 0.5, min_area_frac: float = 0.0) -> list:
-    """Return sorted unique Z-coords of horizontal (normal≈±Z) planar faces.
-
-    Uses tol-bucket deduplication but returns the actual face Z, not the rounded
-    bucket centre, so dimension labels match the true geometry.
-
-    When *min_area_frac* > 0, a Z level is kept only if the total area of its
-    horizontal faces is at least ``min_area_frac × (x_size × y_size)`` (the
-    part's plan footprint). This drops sub-feature faces — e.g. fragments of
-    engraved text/numbers — that are not real steps and would otherwise be
-    dimensioned as phantom shoulders (staircase.step review).
-    """
-    buckets: dict = {}  # bucket key -> representative z
-    areas: dict = {}  # bucket key -> total horizontal-face area
-    for face in part.faces():
-        surf = BRepAdaptor_Surface(face.wrapped)
-        if surf.GetType() == GeomAbs_Plane:
-            ax = surf.Plane().Axis().Direction()
-            if abs(ax.Z()) > 0.99:
-                z = surf.Plane().Location().Z()
-                key = round(z / tol) * tol
-                buckets.setdefault(key, z)
-                if min_area_frac > 0.0:
-                    props = GProp_GProps()
-                    BRepGProp.SurfaceProperties_s(face.wrapped, props)
-                    areas[key] = areas.get(key, 0.0) + props.Mass()
-    if min_area_frac > 0.0:
-        bb = part.bounding_box()
-        footprint = (bb.max.X - bb.min.X) * (bb.max.Y - bb.min.Y)
-        threshold = min_area_frac * footprint
-        return sorted(z for key, z in buckets.items() if areas.get(key, 0.0) >= threshold)
-    return sorted(buckets.values())
-
-
 # ---------------------------------------------------------------------------
 # Strip / zone layout model
 # ---------------------------------------------------------------------------
@@ -288,11 +253,49 @@ def _analyse(
         math.hypot(od_cyl["axis_xyz"][0] - cx, od_cyl["axis_xyz"][1] - cy) if od_cyl else 0.0
     )
     is_rotational = _is_rotational(x_size, y_size, od_diam, od_axis_offset)
+    od_axis = "z"
+    if not is_rotational:
+        # Fallback: a *horizontal* (X/Y) round body — its OD is a cross-axis cylinder
+        # filling the square envelope perpendicular to that axis (#222). The Z check
+        # above is untouched, so vertical parts classify exactly as before; this only
+        # fires when Z-rotational fails and a cross-axis round body is present.
+        sizes = {"x": x_size, "y": y_size, "z": z_size}
+        ctr = {"x": cx, "y": cy, "z": cz}
+        cross_full = full_cylinders(cross_cyls)
+        for ax in ("x", "y"):
+            ext = [c for c in cross_full if c.get("axis") == ax and c["external"]]
+            # #222 targets a *single-OD* round body. A stepped shaft (multiple distinct
+            # cross diameters) stays on the turned-diameter path, not the OD furniture.
+            if len({round(c["diameter"], 1) for c in ext}) != 1:
+                continue
+            oc = max(ext, key=lambda c: c["diameter"], default=None)
+            if oc is None:
+                continue
+            p0, p1 = (a for a in "xyz" if a != ax)
+            off = math.hypot(
+                oc["axis_xyz"]["xyz".index(p0)] - ctr[p0],
+                oc["axis_xyz"]["xyz".index(p1)] - ctr[p1],
+            )
+            if _is_rotational(sizes[p0], sizes[p1], oc["diameter"], off):
+                od_diam, od_axis_offset, od_axis, is_rotational = oc["diameter"], off, ax, True
+                break
     if z_diams and not is_rotational:
         _log.info("Part classified prismatic; skipping OD/centreline/bore annotations")
 
-    face_zs = analyse_face_levels(part, min_area_frac=_STEP_MIN_AREA_FRAC)
-    step_zs = [z for z in face_zs if z > bb.min.Z + 0.6 and z < bb.max.Z - 0.6]
+    # Step Z-levels feed both the step-height ladder and the page-sizing step
+    # count. For a vertical (Z-axis) turned part, take them from the unified
+    # turned-step model (ADR 0008 step 1): it filters shoulders by the OD
+    # silhouette, so an internal feature face — a blind bore's flat floor — is
+    # never read as a phantom OD shoulder (the area-only filter in
+    # analyse_face_levels admitted it). Prismatic and other parts keep the
+    # general face-level scan, which find_turned_steps cannot replace (no
+    # cylinders → no profile).
+    _turned = find_turned_steps(part)
+    if _turned is not None and _turned.axis == "z":
+        step_zs = [z for z in _turned.shoulders if bb.min.Z + 0.6 < z < bb.max.Z - 0.6]
+    else:
+        face_zs = analyse_face_levels(part, min_area_frac=_STEP_MIN_AREA_FRAC)
+        step_zs = [z for z in face_zs if z > bb.min.Z + 0.6 and z < bb.max.Z - 0.6]
 
     # Pass 1 (two-pass layout, #131): measure annotation strip depths before
     # view positions are fixed.  font_size=3.0 is a fixed page-mm constant so
@@ -305,6 +308,7 @@ def _analyse(
     _pad_around_text = _draft_est.pad_around_text
     holes = find_holes(part, cyls=(z_cyls, cross_cyls))
     patterns = find_hole_patterns(holes)
+    bosses = find_bosses(part, cyls=(z_cyls, cross_cyls))  # detect once — the one inventory (#264)
     slots = find_slots(part)
 
     # Choose scale/page, iterating so the reserved step corridor matches the
@@ -420,12 +424,15 @@ def _analyse(
         bbox_max=bbox_max,
         holes=holes,
         patterns=patterns,
+        bosses=bosses,
         slots=slots,
         z_diams=z_diams,
         cross_diams=cross_diams,
         cyls=(z_cyls, cross_cyls),
+        prof=_turned,
         od_diam=od_diam,
         is_rotational=is_rotational,
+        od_axis=od_axis,
         step_zs=step_zs,
         sv_right=sv_right,
         iso_right_limit=iso_right_limit,

{draftwright-0.1.13 → draftwright-0.2.1}/src/draftwright/annotate.py

@@ -6,8 +6,8 @@ the orchestrator entry point and the two helpers still referenced by name elsewh
 so `from draftwright.annotate import _auto_annotate` keeps working.
 """
 
+from draftwright.annotations.from_model import _detect_step_repeat  # noqa: F401
 from draftwright.annotations.orchestrator import (  # noqa: F401
     _auto_annotate,
-    _detect_step_repeat,
     _wrap_rows,
 )

{draftwright-0.1.13 → draftwright-0.2.1}/src/draftwright/annotations/_common.py

@@ -29,7 +29,7 @@ def _occupied_boxes(dwg):
     hatch.  Bare centrelines/leaders are excluded — those legitimately cross a
     dimension and lint does not flag them."""
     boxes = []
-    for name, o in dwg._named.items():
+    for name, o in dwg.iter_annotations():
         if getattr(o, "label_bbox", None) is None and name != "section_hatch":
             continue
         bb = _anno_box(o)