draftwright 0.1.2__tar.gz → 0.1.4__tar.gz

{draftwright-0.1.2 → draftwright-0.1.4}/.gitignore

@@ -9,3 +9,4 @@ build/
 testenv/
 .coverage
 coverage.xml
+.DS_Store

{draftwright-0.1.2 → draftwright-0.1.4}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## v0.1.4 — 2026-06-15
+
+### Changed
+
+- Feature annotations (hole callouts, location dimensions, section view) now
+  fire on feature presence independent of the turned/prismatic classification,
+  so turned-and-drilled parts (e.g. flanges) get both the OD/centreline base
+  set and per-hole callouts plus bolt-circle furniture (#10).
+- Isometric view placement now uses a general largest-empty-rectangle search in
+  place of the wide/flat-on-A3 special case (#11).
+- Concentric bore-leader stacking is generalised beyond three, and the
+  step-height dimension gate is now a single derived constant (#10, #12).
+
+### Internal
+
+- Single-sourced duplicated geometry constants from the draft preset (#12).
+- Minor comment and logging cleanups.
+
 ## v0.1.0 — 2026-06-14
 
 Initial release — spun out of `build123d-drafting-helpers` v0.9.1.

{draftwright-0.1.2 → draftwright-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.1.2
+Version: 0.1.4
 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.1.2 → draftwright-0.1.4}/pyproject.toml

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

{draftwright-0.1.2 → draftwright-0.1.4}/src/draftwright/make_drawing.py

@@ -77,6 +77,8 @@ _log = logging.getLogger(__name__)
 
 _TB_W = 150.0
 _MARGIN = 10.0
+_TB_CLEAR = _MARGIN + 1.0  # title-block inset: one extra mm over _MARGIN for clearance
+_FONT_SIZE = 3.0  # annotation text height (page-mm); the draft preset is built with this
 _DIM_PAD = 18.0
 _TB_H = 35.0
 # Minimum acceptable projected view dimension (page-mm).  Below this, annotation
@@ -167,6 +169,40 @@ def _is_rotational(x_size, y_size, od_diam, od_axis_offset) -> bool:
     )
 
 
+# A hole is "concentric" with a turned part's rotation axis when its drilling
+# axis is the Z (OD) axis and its opening sits on the part centreline.  Such
+# bores are already dimensioned by the ldr_z bore leaders, so they must not
+# also receive a hole callout / location dim (#10).  Off-axis holes (a bolt
+# circle, a cross-hole) fall through to the feature-presence path.
+_CONCENTRIC_TOL_MM = 0.5
+
+
+def _is_concentric_hole(h, a, axis_letter) -> bool:
+    """True when *h* is an axial bore on the part centreline (turned base set)."""
+    if axis_letter(h) != "z":
+        return False
+    return math.hypot(h.location[0] - a.cx, h.location[1] - a.cy) <= _CONCENTRIC_TOL_MM
+
+
+def _concentric_bore_diams(a) -> list:
+    """Distinct bore diameters on the rotation axis, in z_diams order (#10).
+
+    ``a.z_diams`` carries every Z cylinder diameter — including off-axis ones
+    such as a bolt circle's holes — so the bore-leader set is restricted to
+    diameters that actually have an *internal* Z cylinder whose axis sits on
+    the part centreline.  The OD is excluded.  Returned in z_diams order so
+    label ordering is stable.
+    """
+    z_cyls, _ = a.cyls
+    concentric = {
+        c["diameter"]
+        for c in _full_cyls(z_cyls)
+        if not c["external"]
+        and math.hypot(c["axis_xyz"][0] - a.cx, c["axis_xyz"][1] - a.cy) <= _CONCENTRIC_TOL_MM
+    }
+    return [d for d in a.z_diams if d != a.od_diam and any(abs(d - c) <= 0.15 for c in concentric)]
+
+
 def lint_feature_coverage(part, annotations, tol: float = 0.15, cyls=None) -> list:
     """Coarse completeness check: report part diameters with no callout (#80).
 
@@ -425,6 +461,18 @@ _SLOT_DIM_STEP = 14.0  # fv_zones.right: step-height dimension
 _SLOT_DIM_WIDTH = 8.0  # pv_zones.below: overall width dimension
 _SLOT_DIM_DEPTH = 8.0  # sv_zones.below: overall depth dimension
 
+# Smallest projected step height (page-mm) that can still carry a *legible*
+# stacked dimension between its two extension lines.  Derived from what has to
+# fit vertically: the label (font height) plus an arrowhead at each end plus
+# the text clearance above and below — not an arbitrary page-mm cutoff (#13).
+# Used as the single gate in BOTH _analyse (n_steps) and _auto_annotate
+# (dim_step placement) so the two can never diverge.
+_MIN_STEP_DIM_MM = (
+    _FONT_SIZE
+    + 2 * draft_preset(font_size=_FONT_SIZE, decimal_precision=1).arrow_length
+    + 2 * draft_preset(font_size=_FONT_SIZE, decimal_precision=1).pad_around_text
+)
+
 # ---------------------------------------------------------------------------
 # Annotation depth estimators (Phase 2 of #118)
 #
@@ -454,6 +502,17 @@ def _est_pv_below_depth() -> float:
     return _STRIP_GAP + _SLOT_DIM_WIDTH
 
 
+# Inter-constant invariant: the gap between the front view top edge and the
+# plan view bottom edge equals _DIM_PAD.  The pv_zones.below strip occupies
+# that gap, so _DIM_PAD must be at least as wide as the depth pv_below needs.
+# If _DIM_PAD is shrunk below _est_pv_below_depth(), dim_width would silently
+# overlap the front view rather than failing an allocate().
+assert _DIM_PAD >= _est_pv_below_depth(), (
+    f"_DIM_PAD ({_DIM_PAD}) is smaller than pv_below slot depth "
+    f"({_est_pv_below_depth()}); bump _DIM_PAD or shrink the slot constants."
+)
+
+
 # ---------------------------------------------------------------------------
 # Two-pass layout — Pass 1: annotation strip depth measurement (#131)
 #
@@ -462,7 +521,9 @@ def _est_pv_below_depth() -> float:
 # ---------------------------------------------------------------------------
 
 
-def _est_bore_callout_width(holes, font_size: float = 3.0, patterns=None) -> float:
+def _est_bore_callout_width(
+    holes, font_size: float = _FONT_SIZE, patterns=None, pad_around_text: float = 2.0
+) -> float:
     """Estimate the maximum bore callout label width (page-mm) across all holes.
 
     Groups holes by machining spec (same as _annotate_holes), then estimates
@@ -471,6 +532,7 @@ def _est_bore_callout_width(holes, font_size: float = 3.0, patterns=None) -> flo
     Returns the label width only — elbow_dx and gap clearance are NOT included;
     callers that need the full strip depth should add those overheads separately.
     Returns 0.0 when the hole list is empty.
+    *pad_around_text* should come from ``draft_preset(...).pad_around_text``.
     """
     if not holes:
         return 0.0
@@ -488,7 +550,7 @@ def _est_bore_callout_width(holes, font_size: float = 3.0, patterns=None) -> flo
     h_fs = font_size
     gap = 0.45 * h_fs
     sym_w = h_fs
-    pad = 2.0  # pad_around_text (fixed in Draft for standard drawings)
+    pad = pad_around_text
     char_w = 0.6 * h_fs  # avg character width
 
     max_w = 0.0
@@ -539,18 +601,29 @@ class StripDepths:
     left: float  # horizontal corridor left of FV/PV
 
 
-def _measure_strips(holes, patterns, n_steps: int, bb, font_size: float = 3.0) -> StripDepths:
+def _measure_strips(
+    holes,
+    patterns,
+    n_steps: int,
+    bb,
+    font_size: float = _FONT_SIZE,
+    arrow_length: float = 2.7,
+    pad_around_text: float = 2.0,
+) -> StripDepths:
     """Compute annotation strip depths from hole geometry (Pass 1 of #131).
 
     All annotation sizes are scale-independent because font_size is a fixed
     page-mm constant, so there is no circularity with choose_scale().
+    *arrow_length* and *pad_around_text* should come from ``draft_preset(...)``.
     """
-    bore_depth = _est_bore_callout_width(holes, font_size, patterns=patterns)
+    bore_depth = _est_bore_callout_width(
+        holes, font_size, patterns=patterns, pad_around_text=pad_around_text
+    )
     # Add elbow clearance and leader-to-label gap so gap_fv_sv fully contains
-    # the composed leader: elbow_dx (= arrow_length ≈ 0.9×fs when a section
-    # line is present) + gap (= pad_around_text = 2.0 mm, always present).
+    # the composed leader: elbow_dx (= draft.arrow_length) + gap
+    # (= draft.pad_around_text), always present.
     if bore_depth > 0:
-        bore_depth += 2.0 + 0.9 * font_size
+        bore_depth += pad_around_text + arrow_length
     right = max(_est_right_strip_depth(n_steps), bore_depth)
     left = max(_DIM_PAD, bore_depth)
     return StripDepths(right=right, left=left)
@@ -663,6 +736,52 @@ def choose_scale(
 # ---------------------------------------------------------------------------
 
 
+def _largest_empty_rect(drawable, obstacles):
+    """Largest axis-aligned empty rectangle in *drawable* avoiding *obstacles*.
+
+    *drawable* and each obstacle are ``(x0, y0, x1, y1)`` page-mm boxes.  Returns
+    the empty sub-rectangle of *drawable* (overlapping no obstacle) that maximises
+    the side of the largest square it can hold — i.e. ``min(width, height)`` — so
+    the (near-square) iso view can be scaled up as far as possible.
+
+    The obstacle set is tiny (front/plan/side views + title block), so a
+    gap-based search over candidate edges is both exact enough and cheap: every
+    maximal empty rectangle has edges drawn from the drawable bounds and the
+    obstacle bounds, so enumerating those cut lines finds the optimum.
+    """
+    dx0, dy0, dx1, dy1 = drawable
+    xs = sorted({dx0, dx1, *(c for o in obstacles for c in (o[0], o[2]) if dx0 < c < dx1)})
+    ys = sorted({dy0, dy1, *(c for o in obstacles for c in (o[1], o[3]) if dy0 < c < dy1)})
+
+    best = None
+    best_score = 0.0
+    for i in range(len(xs) - 1):
+        for j in range(i + 1, len(xs)):
+            rx0, rx1 = xs[i], xs[j]
+            for k in range(len(ys) - 1):
+                for m in range(k + 1, len(ys)):
+                    ry0, ry1 = ys[k], ys[m]
+                    if any(
+                        rx0 < o[2] and o[0] < rx1 and ry0 < o[3] and o[1] < ry1 for o in obstacles
+                    ):
+                        continue
+                    score = min(rx1 - rx0, ry1 - ry0)
+                    if score > best_score:
+                        best_score = score
+                        best = (rx0, ry0, rx1, ry1)
+    if best is None:
+        # No empty rectangle exists (obstacles cover the drawable area). This
+        # is unreachable in practice — choose_scale always leaves a gap — but
+        # if it ever happens the iso would render over the other views, so flag
+        # it rather than fail silently.
+        _log.warning(
+            "No empty rectangle found for the iso view; obstacles fill the "
+            "drawable area — iso may overlap other views"
+        )
+        return drawable
+    return best
+
+
 def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, page=None, pmi="off"):
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
@@ -744,13 +863,26 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
     # 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
     # all annotation sizes are scale-independent — no circularity.
+    # Construct the same draft preset used later in build_drawing() to read
+    # arrow_length and pad_around_text from their authoritative source rather
+    # than re-stating them as magic literals in the estimators.
+    _draft_est = draft_preset(font_size=_FONT_SIZE, decimal_precision=1)
+    _arrow_length = _draft_est.arrow_length
+    _pad_around_text = _draft_est.pad_around_text
     holes = find_holes(part, cyls=(z_cyls, cross_cyls))
     patterns = find_hole_patterns(holes)
 
     # Conservative upper bound for page selection: count all candidate step
-    # faces without the SCALE-dependent 20 mm gate (SCALE is not yet known).
+    # faces without the SCALE-dependent _MIN_STEP_DIM_MM gate (SCALE not yet known).
     n_steps_ub = len(step_zs[:3])
-    strips_ub = _measure_strips(holes, patterns, n_steps_ub, bb)
+    strips_ub = _measure_strips(
+        holes,
+        patterns,
+        n_steps_ub,
+        bb,
+        arrow_length=_arrow_length,
+        pad_around_text=_pad_around_text,
+    )
     SCALE, PAGE_W, PAGE_H, TB_W = choose_scale(
         x_size, y_size, z_size, n_steps=n_steps_ub, scale=scale, page=page, strips=strips_ub
     )
@@ -772,9 +904,16 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
                 )
     DIM_PAD = _DIM_PAD
     margin = _MARGIN
-    # Refine: apply the same 20 mm height gate _auto_annotate uses for dim_step.
-    n_steps = len([z for z in step_zs[:3] if (z - bb.min.Z) * SCALE >= 20])
-    strips = _measure_strips(holes, patterns, n_steps, bb)
+    # Refine: apply the same legibility gate _auto_annotate uses for dim_step.
+    n_steps = len([z for z in step_zs[:3] if (z - bb.min.Z) * SCALE >= _MIN_STEP_DIM_MM])
+    strips = _measure_strips(
+        holes,
+        patterns,
+        n_steps,
+        bb,
+        arrow_length=_arrow_length,
+        pad_around_text=_pad_around_text,
+    )
     gap_fv_sv = max(DIM_PAD, strips.right)
     gap_left = max(DIM_PAD, strips.left)
 
@@ -803,12 +942,44 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
     SV_X = FV_X + fv_hw + gap_fv_sv + sv_hw
     SV_Y = FV_Y
     sv_right = SV_X + sv_hw + DIM_PAD
-    tb_top_y = margin + _TB_H
-    iso_above_tb = (PV_Y - pv_hh) > tb_top_y
-    iso_right_limit = (PAGE_W - margin) if iso_above_tb else (PAGE_W - TB_W - margin)
-    right_avail = max(0.0, iso_right_limit - sv_right)
-    ISO_X = sv_right + right_avail / 2
-    ISO_Y = PV_Y
+    # Right wall for the side-view annotation strip: full page (minus margin)
+    # when the views clear the title block, otherwise stop left of it.
+    sv_right_wall = (
+        (PAGE_W - margin) if (PV_Y - pv_hh) > (margin + _TB_H) else (PAGE_W - TB_W - margin)
+    )
+
+    # Iso placement (#11): rather than special-casing wide/flat-on-A3, find the
+    # largest empty rectangle in the drawable area after the FV/PV/SV views and
+    # the title block are positioned, and centre the iso in it.  _fit_iso_view
+    # then scales the iso to fill that rectangle.  Each view box is padded by
+    # DIM_PAD to reserve its annotation strips; the title block is padded too.
+    drawable = (margin, margin, PAGE_W - margin, PAGE_H - margin)
+    obstacles = [
+        (
+            FV_X - fv_hw - DIM_PAD,
+            FV_Y - fv_hh - DIM_PAD,
+            FV_X + fv_hw + DIM_PAD,
+            FV_Y + fv_hh + DIM_PAD,
+        ),
+        (
+            PV_X - fv_hw - DIM_PAD,
+            PV_Y - pv_hh - DIM_PAD,
+            PV_X + fv_hw + DIM_PAD,
+            PV_Y + pv_hh + DIM_PAD,
+        ),
+        (
+            SV_X - sv_hw - DIM_PAD,
+            SV_Y - fv_hh - DIM_PAD,
+            SV_X + sv_hw + DIM_PAD,
+            SV_Y + fv_hh + DIM_PAD,
+        ),
+        (PAGE_W - TB_W - 11 - DIM_PAD, margin, PAGE_W - 11 + DIM_PAD, 11 + _TB_H + DIM_PAD),
+    ]
+    iso_left_limit, iso_bottom_limit, iso_right_limit, iso_top_limit = _largest_empty_rect(
+        drawable, obstacles
+    )
+    ISO_X = (iso_left_limit + iso_right_limit) / 2
+    ISO_Y = (iso_bottom_limit + iso_top_limit) / 2
 
     # ------------------------------------------------------------------
     # Strip / zone construction.
@@ -832,7 +1003,10 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
     fv_zones = ViewZones(
         right=Strip(fv_right_edge, sv_left_edge, direction=1),
         left=Strip(fv_left_edge, margin, direction=-1),
-        above=Strip(fv_top_edge, pv_bottom_edge - 2, direction=1),
+        # Stop the front-view 'above' strip short of pv_bottom_edge by the
+        # slack the pv_below slot leaves in the gap, derived (not re-typed) so
+        # it tracks _DIM_PAD and the slot constants.
+        above=Strip(fv_top_edge, pv_bottom_edge - (_DIM_PAD - _est_pv_below_depth()), direction=1),
         below=Strip(fv_bottom_edge, margin, direction=-1),
     )
     pv_zones = ViewZones(
@@ -844,14 +1018,15 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
         right=Strip(pv_right_edge, sv_left_edge, direction=1),
         left=Strip(pv_left_edge, margin, direction=-1),
         above=Strip(pv_top_edge, PAGE_H - margin, direction=1),
-        # gap_fv_pv = DIM_PAD = 18 mm; pv_below needs 16 mm, leaving 2 mm slack.
+        # gap_fv_pv = _DIM_PAD; pv_below needs _est_pv_below_depth() mm,
+        # leaving (_DIM_PAD - _est_pv_below_depth()) mm slack (assert above).
         below=Strip(pv_bottom_edge, fv_top_edge, direction=-1),
     )
     sv_bottom_edge = SV_Y - fv_hh  # same as fv_bottom_edge; side and front share Z height
     sv_zones = ViewZones(
         # sv_right already includes DIM_PAD; anchor here so the strip never
         # places annotations inside that gap
-        right=Strip(sv_right, iso_right_limit, direction=1),
+        right=Strip(sv_right, sv_right_wall, direction=1),
         left=None,  # immediately abuts the front view's right edge
         above=Strip(sv_top_edge, PAGE_H - margin, direction=1),
         below=Strip(sv_bottom_edge, margin, direction=-1),
@@ -909,6 +1084,9 @@ def _analyse(step_file, title, number, tolerance, drawn_by, out, scale=None, pag
         SV_Y=SV_Y,
         ISO_X=ISO_X,
         ISO_Y=ISO_Y,
+        iso_left_limit=iso_left_limit,
+        iso_bottom_limit=iso_bottom_limit,
+        iso_top_limit=iso_top_limit,
         # View half-extents in page units (convenient for strip arithmetic)
         fv_hw=fv_hw,
         fv_hh=fv_hh,
@@ -1257,9 +1435,22 @@ def _auto_annotate(dwg, a):
     # that the iso has been projected and fitted.  Always apply so that any
     # future allocations are bounded; warn when the cursor has already passed
     # the limit (dims already placed may overlap the iso view).
-    _iso_x0, _, _, _ = _iso_bbox(dwg)
+    _iso_x0, _iso_y0, _, _iso_y1 = _iso_bbox(dwg)
     _iso_x_limit = _iso_x0 - 4
-    for _rs in (a.fv_zones.right, a.pv_zones.right, a.sv_zones.right):
+    # Only tighten a right strip when the iso shares the strip's y-range: a strip
+    # that abuts the iso horizontally would otherwise lose annotation space, while
+    # one sitting entirely above/below the iso (e.g. the SV strip when the iso is
+    # in an upper-right zone) must keep its full width — capping it could push the
+    # outer_limit below the strip anchor and break all its allocations.
+    _right_strips = []
+    for _rs, _y0, _y1 in (
+        (a.fv_zones.right, a.FV_Y - a.fv_hh, a.FV_Y + a.fv_hh),
+        (a.pv_zones.right, a.PV_Y - a.pv_hh, a.PV_Y + a.pv_hh),
+        (a.sv_zones.right, a.SV_Y - a.fv_hh, a.SV_Y + a.fv_hh),
+    ):
+        if _y0 < _iso_y1 and _iso_y0 < _y1:
+            _right_strips.append(_rs)
+    for _rs in _right_strips:
         _rs.outer_limit = min(_rs.outer_limit, _iso_x_limit)
         if _rs._cursor >= _iso_x_limit:
             _log.warning(
@@ -1324,16 +1515,25 @@ def _auto_annotate(dwg, a):
         )
 
     # Z-axis bore leaders to the left of the front view — these assume bores
-    # concentric with the rotation axis, so rotational only (#81)
-    bores = [d for d in a.z_diams if d != a.od_diam]
+    # concentric with the rotation axis, so rotational only (#81).  z_diams
+    # carries *every* Z cylinder diameter including off-axis ones (e.g. a bolt
+    # circle's holes), so the bore set is restricted to diameters that actually
+    # belong to an internal cylinder on the rotation axis (#10): an off-axis
+    # ø8 bolt hole must not surface as a phantom concentric bore leader.
+    bores = _concentric_bore_diams(a) if a.is_rotational else []
     if a.is_rotational and bores:
         left_edge = FX(a.bb.min.X)
         left_space = left_edge - a.margin
         if left_space >= a.DIM_PAD:
             ldr_length = a.DIM_PAD * 0.6
             elbow_x = left_edge - ldr_length
-            for i, d in enumerate(bores[:3]):
-                tip_z = FZ(a.cz) + (i - 1) * 10
+            # Stack all distinct bores, centred on the axis (generalised beyond
+            # the old hard cap of 3 — #10); any not annotated would surface via
+            # the coverage lint, but all are placed here.
+            n = len(bores)
+            pitch = max(10.0, draft.font_size * 3.0)
+            for i, d in enumerate(bores):
+                tip_z = FZ(a.cz) + (i - (n - 1) / 2) * pitch
                 dwg.add(
                     Leader(
                         tip=(FX(a.cx - d / 2), tip_z, 0),
@@ -1363,13 +1563,28 @@ def _auto_annotate(dwg, a):
         size = max(2.5, h.diameter * a.SCALE + 2.0)
         dwg.add(CenterMark(to_page(h), size, draft), f"cm_{view}{i}")
 
-    # Hole callouts, locations, and sections — prismatic parts only; turned
-    # parts keep dim_od/ldr_z
-    if not a.is_rotational and a.holes:
-        _annotate_holes(dwg, a, view_of_axis, _axis_letter, a.patterns)
-        _add_location_dims(dwg, a, _axis_letter, a.patterns)
+    # Hole callouts, location dims, and the section view fire on *feature
+    # presence*, independent of the turned/prismatic class (#10): the
+    # classification only selects the base set (OD+centreline+ldr_z vs envelope
+    # dims).  A turned flange (round OD + a bolt circle) must get BOTH.
+    #
+    # On a turned part the concentric, axis-aligned bores are already
+    # dimensioned by the ldr_z leaders, so they are excluded here to avoid a
+    # duplicate hole callout; only the off-axis features get callouts.  On a
+    # prismatic part every hole flows through unchanged.
+    feature_holes = a.holes
+    feature_patterns = a.patterns
+    if a.is_rotational:
+        feature_holes = [h for h in a.holes if not _is_concentric_hole(h, a, _axis_letter)]
+        present = set(map(id, feature_holes))
+        feature_patterns = [p for p in a.patterns if all(id(h) in present for h in p.holes)]
+    if feature_holes:
+        _annotate_holes(
+            dwg, a, view_of_axis, _axis_letter, feature_patterns, holes_in=feature_holes
+        )
+        _add_location_dims(dwg, a, _axis_letter, feature_patterns, holes_in=feature_holes)
 
-    if a.cross_diams and a.is_rotational:
+    if a.cross_diams and a.is_rotational and not feature_holes:
         _log.info(
             "Cross-hole ø%s detected but not annotated (requires section view)",
             _fmt(a.cross_diams[0]),
@@ -1378,7 +1593,9 @@ def _auto_annotate(dwg, a):
     # Step heights — only where the step is tall enough to fit a label;
     # each step witnesses from the previous dim's line (_right_ladder) so
     # extension lines are adjacent rather than coincident
-    for col, z in enumerate([z for z in a.step_zs[:3] if (z - a.bb.min.Z) * a.SCALE >= 20]):
+    for col, z in enumerate(
+        [z for z in a.step_zs[:3] if (z - a.bb.min.Z) * a.SCALE >= _MIN_STEP_DIM_MM]
+    ):
         _px = a.fv_zones.right.allocate(_SLOT_DIM_STEP)
         if _px is None:
             _log.warning("dim_step_%d skipped: fv_zones.right strip full", col)
@@ -1436,9 +1653,10 @@ def _auto_annotate(dwg, a):
 
     # The section view goes last: its room check clears every annotation
     # already placed right of the side view (callout labels, height/step
-    # dim ladders)
-    if not a.is_rotational and a.holes:
-        _add_section_view(dwg, a, _axis_letter)
+    # dim ladders).  Fires on feature presence, not class (#10); concentric
+    # bores on a turned part are excluded (the ldr_z leaders cover them).
+    if feature_holes:
+        _add_section_view(dwg, a, _axis_letter, holes=feature_holes)
 
     # Phase 7 — strip footprint debug logging + post-placement overflow check.
     # Overflow can only occur when outer_limit was tightened after allocations
@@ -1847,7 +2065,7 @@ _MAX_CALLOUTS_PER_VIEW = 4
 _MAX_LOCATION_REFS = 4
 
 
-def _add_location_dims(dwg, a, axis_letter, patterns):
+def _add_location_dims(dwg, a, axis_letter, patterns, holes_in=None):
     """Baseline X/Y location dimensions in the plan view (#93).
 
     The datum corner is a *default* — the part's minimum-X/minimum-Y corner
@@ -1860,8 +2078,9 @@ def _add_location_dims(dwg, a, axis_letter, patterns):
     never force-placed. Cross-axis holes are not located yet (logged).
     """
     draft = dwg.draft
-    z_holes = [h for h in a.holes if axis_letter(h) == "z"]
-    if len(z_holes) < len(a.holes):
+    all_holes = a.holes if holes_in is None else holes_in
+    z_holes = [h for h in all_holes if axis_letter(h) == "z"]
+    if len(z_holes) < len(all_holes):
         _log.info("Cross-axis holes present; their locations are not auto-dimensioned")
     patterned = {h for p in patterns for h in p.holes}
     refs = []  # (world_x, world_y, sort_diameter)
@@ -2042,7 +2261,7 @@ def _section_hatch_edges(face, SX, SZ, spacing):
     return result
 
 
-def _add_section_view(dwg, a, axis_letter):
+def _add_section_view(dwg, a, axis_letter, holes=None):
     """Full section A–A when blind or stepped holes hide their structure (#94).
 
     Trigger: any Z-axis hole with a counterbore/spotface or a non-through
@@ -2057,7 +2276,7 @@ def _add_section_view(dwg, a, axis_letter):
     """
     cands = [
         h
-        for h in a.holes
+        for h in (a.holes if holes is None else holes)
         if axis_letter(h) == "z" and (h.cbore or h.spotface or h.bottom != "through")
     ]
     if not cands:
@@ -2069,8 +2288,9 @@ def _add_section_view(dwg, a, axis_letter):
     )
 
     # room check: same row as the front/side views, to the right — past any
-    # side-view callout labels already placed there
-    # the caption is ~19mm wide — narrow sections are bounded by it
+    # side-view callout labels already placed there.
+    # 12.0 mm floor: conservative minimum half-width so very narrow sections
+    # have enough room for the "SECTION A–A" caption and arrows.
     half_w = max(a.x_size * a.SCALE / 2, 12.0)
     half_h = a.z_size * a.SCALE / 2
     side_vis, side_hid = dwg.views["side"]
@@ -2089,8 +2309,8 @@ def _add_section_view(dwg, a, axis_letter):
     right_limit = a.PAGE_W - a.margin
     if a.FV_Y + half_h + 6 > iso_y0 - 2:
         right_limit = min(right_limit, iso_x0 - 4)
-    tb_left = a.PAGE_W - a.TB_W - 11
-    if a.FV_Y - half_h - 10 < 11 + _TB_H and pos_x + half_w > tb_left - 4:
+    tb_left = a.PAGE_W - a.TB_W - _TB_CLEAR
+    if a.FV_Y - half_h - 10 < _TB_CLEAR + _TB_H and pos_x + half_w > tb_left - 4:
         _log.info("Section A–A skipped (would collide with the title block)")
         return
     if pos_x + half_w > right_limit:
@@ -2324,7 +2544,7 @@ def _solve_strip_ys(natural_ys, min_gap, y_min, y_max):
         return None
 
 
-def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns):
+def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns, holes_in=None):
     """Leader-attached HoleCallouts, one per distinct hole spec per view (#91).
 
     Identical holes share one callout with an ``n×`` count prefix (#92's
@@ -2348,7 +2568,7 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns):
     # different operations and get separate callouts, and a spec group's
     # hole set therefore lines up exactly with find_hole_patterns' groups.
     groups: dict = {}
-    for h in a.holes:
+    for h in a.holes if holes_in is None else holes_in:
         groups.setdefault(_spec_key(h), []).append(h)
 
     by_view: dict = {}
@@ -2360,8 +2580,8 @@ def _annotate_holes(dwg, a, view_of_axis, axis_letter, found_patterns):
     plan_left = a.PV_X + (a.bb.min.X - a.cx) * a.SCALE
     side_right = a.SV_X + (a.bb.max.Y - a.cy) * a.SCALE
     front_bottom = a.FV_Y + (a.bb.min.Z - a.cz) * a.SCALE
-    tb_left = a.PAGE_W - a.TB_W - 11
-    tb_top = 11 + _TB_H
+    tb_left = a.PAGE_W - a.TB_W - _TB_CLEAR
+    tb_top = _TB_CLEAR + _TB_H
 
     # A section line will be placed when the part has z-axis holes with
     # counterbores, spotfaces, or blind bottoms (_add_section_view trigger).
@@ -2662,25 +2882,37 @@ def _project_iso(dwg, a, scale, shape_s=None):
         dwg._coords["iso"] = ViewCoordinates(axes, a.ISO_X, a.ISO_Y, a.cx, a.cy, a.cz, scale)
 
 
-def _fit_iso_view(dwg, a):
-    """Shrink the iso view to fit its page region, captioning it NTS (#75).
+def _fit_iso_view(dwg, a, annotate: bool = True):
+    """Scale the iso view to fill its page zone, captioning it NTS when the
+    scale differs from sheet scale.  Pass ``annotate=False`` to suppress the
+    NTS note (used when ``auto_dims=False``).
 
-    The layout reserves ~0.7 × bbox_max for the iso column, but the true
-    projected extent can be wider (long prismatic parts), pushing the iso past
-    the page edge or into the side view's dimension space. When the projected
-    iso bbox overflows the region, re-project at a clean fraction of sheet
-    scale and add an "ISO VIEW (NTS)" caption below it.
+    The iso is always centred at (ISO_X, ISO_Y) which sits at the centre of
+    the available zone.  The projection is linear, so the factor needed to
+    fill the zone can be computed from the measured extents without iteration.
+
+    - Overflow (needed < 1): shrink with 2 % safety margin.
+    - Under-fill (needed > 1): grow to 90 % of zone, leaving breathing room.
+    - Within 5 % of sheet scale: leave as-is (no NTS label).
     """
-    region = (a.sv_right, a.margin, a.iso_right_limit, a.PAGE_H - a.margin)
+    # Use the precomputed iso zone (largest empty rectangle).  A section view
+    # only constrains the iso region when it shares the iso's y-range; one that
+    # sits entirely below the iso (e.g. when the iso is in an upper-right zone)
+    # leaves the region's left edge untouched.
+    region_left = a.iso_left_limit
+    if "section_aa" in dwg.views:
+        sec_vis, sec_hid = dwg.views["section_aa"]
+        sec_bb = sec_vis.bounding_box()
+        sec_right = sec_bb.max.X
+        sec_y0, sec_y1 = sec_bb.min.Y, sec_bb.max.Y
+        if sec_hid:
+            shb = sec_hid.bounding_box()
+            sec_right = max(sec_right, shb.max.X)
+            sec_y0, sec_y1 = min(sec_y0, shb.min.Y), max(sec_y1, shb.max.Y)
+        if sec_y0 < a.iso_top_limit and a.iso_bottom_limit < sec_y1:
+            region_left = max(region_left, sec_right + 4)
+    region = (region_left, a.iso_bottom_limit, a.iso_right_limit, a.iso_top_limit)
     bb = _iso_bbox(dwg)
-    # Exact check (no tolerance): the lint's view_out_of_bounds is exact, so
-    # accepting a sub-tolerance overflow here would pass the fit yet fail lint.
-    if _bbox_within(bb, region, tol=0.0):
-        return
-    # Orthographic projection is linear and the view centre maps to
-    # (ISO_X, ISO_Y), so each bbox side's offset from the centre scales
-    # exactly with the shape scale — the factor needed to fit can be computed
-    # from the measured extents, costing a single re-projection.
     ratios = [
         avail / extent
         for extent, avail in (
@@ -2692,24 +2924,32 @@ def _fit_iso_view(dwg, a):
         if extent > 0
     ]
     needed = min(ratios, default=1.0)
-    # Apply a 2 % safety margin and floor to 4 decimal places to avoid
-    # floating-point creep past the region boundary.  The iso is NTS so
-    # there is no need to constrain to "clean" fractions.
-    factor = math.floor(needed * 0.98 * 10000) / 10000
+    if needed >= 1.0:
+        # Iso fits; grow to 90 % of zone — leaves comfortable breathing room.
+        margin_pct = 0.90
+    else:
+        # Iso overflows; shrink to just fit with 2 % safety margin.
+        margin_pct = 0.98
+    factor = math.floor(needed * margin_pct * 10000) / 10000
+    if needed >= 1.0:
+        factor = max(factor, 1.0)  # grow branch must never shrink
+    if abs(factor - 1.0) < 0.05:
+        return  # within 5 % of sheet scale — no rescale, no NTS label
     _project_iso(dwg, a, a.SCALE * factor)
     bb = _iso_bbox(dwg)
-    if not _bbox_within(bb, region):
+    if factor < 1.0 and not _bbox_within(bb, region):
         _log.warning("Iso view still overflows its page region at %g× sheet scale", factor)
-    font = dwg.draft.font_size
-    dwg.add(
-        Note(
-            "ISO VIEW (NTS)",
-            (a.ISO_X, max(bb[1] - 2 * font, a.margin + font)),
-            dwg.draft,
-        ),
-        "note_iso_nts",
-    )
-    _log.info("Iso view shrunk to %g× sheet scale (NTS)", factor)
+    if annotate:
+        font = dwg.draft.font_size
+        dwg.add(
+            Note(
+                "ISO VIEW (NTS)",
+                (a.ISO_X, max(bb[1] - 2 * font, a.margin + font)),
+                dwg.draft,
+            ),
+            "note_iso_nts",
+        )
+    _log.info("Iso view scaled to %g× sheet scale%s", factor, " (NTS)" if annotate else "")
 
 
 def build_drawing(
@@ -2764,7 +3004,7 @@ def build_drawing(
         page_w=a.PAGE_W,
         page_h=a.PAGE_H,
         tb_w=a.TB_W,
-        draft=draft_preset(font_size=3.0, decimal_precision=1),
+        draft=draft_preset(font_size=_FONT_SIZE, decimal_precision=1),
         look_at=look_at,
         dist=dist,
         centroid=(a.cx, a.cy, a.cz),
@@ -2779,11 +3019,29 @@ def build_drawing(
     dwg.add_view("plan", part_s, (cxs, cys, czs + dist), (0, 1, 0), (a.PV_X, a.PV_Y), scaled=True)
     dwg.add_view("side", part_s, (cxs + dist, cys, czs), (0, 0, 1), (a.SV_X, a.SV_Y), scaled=True)
     _project_iso(dwg, a, a.SCALE, shape_s=part_s)
-    _fit_iso_view(dwg, a)
 
     if auto_dims:
+        # Snapshot outer_limits before _auto_annotate tightens them against the
+        # initial (possibly overflowing) iso.  After _fit_iso_view rescales the
+        # iso we restore all three right strips to min(original, final_iso_x_limit)
+        # so each strip reflects actual final geometry, not the transient state.
+        _fv_ol = a.fv_zones.right.outer_limit
+        _pv_ol = a.pv_zones.right.outer_limit
+        _sv_ol = a.sv_zones.right.outer_limit
         _auto_annotate(dwg, a)
+        _fit_iso_view(dwg, a)
+        _ix0, _iy0, _, _iy1 = _iso_bbox(dwg)
+        _final_iso_x_lim = _ix0 - 4
+        a.fv_zones.right.outer_limit = min(_fv_ol, _final_iso_x_lim)
+        a.pv_zones.right.outer_limit = min(_pv_ol, _final_iso_x_lim)
+        # Only re-cap the SV right strip when the iso shares its y-range (see the
+        # matching guard in _auto_annotate); otherwise restore its full width.
+        if (a.SV_Y - a.fv_hh) < _iy1 and _iy0 < (a.SV_Y + a.fv_hh):
+            a.sv_zones.right.outer_limit = min(_sv_ol, _final_iso_x_lim)
+        else:
+            a.sv_zones.right.outer_limit = _sv_ol
     else:
+        _fit_iso_view(dwg, a, annotate=False)
         _add_title_block(dwg, a)
     return dwg
 

{draftwright-0.1.2 → draftwright-0.1.4}/tests/test_make_drawing.py

@@ -1,5 +1,6 @@
 """Tests for draftwright.make_drawing."""
 
+import math
 from pathlib import Path
 
 import pytest
@@ -439,8 +440,10 @@ class TestStripZones:
 
     def test_right_strip_outer_limits_tightened_to_iso(self):
         # fv.right and pv.right are both bounded by sv_left_edge so bore callout
-        # labels cannot cross into the side view.  sv.right is tightened to the
-        # actual iso view left edge (iso_x0 - 4) by _auto_annotate().
+        # labels cannot cross into the side view.  The sv.right strip is only
+        # iso-tightened (to iso_x0 - 4) when the iso shares the side view's
+        # y-range; with the #11 free-rectangle placement the iso may instead sit
+        # above the side view, in which case sv.right keeps its full width.
         # Use a plain box (no holes) so bore callout overhead doesn't push the
         # iso view right and interfere with the sv tightening check.
         from build123d import Box
@@ -452,15 +455,19 @@ class TestStripZones:
         dwg = build_drawing(part)
         a = dwg._analysis
         sv_left = a.SV_X - a.sv_hw
-        iso_x0, _, _, _ = _iso_bbox(dwg)
+        iso_x0, iso_y0, _, iso_y1 = _iso_bbox(dwg)
         iso_limit = iso_x0 - 4
         # fv right must not extend past the side view left edge
         assert a.fv_zones.right.outer_limit == pytest.approx(sv_left, abs=0.1)
         # pv right is also bounded by sv_left so bore callout labels cannot
         # cross dim_locy extension lines in the side view corridor
         assert a.pv_zones.right.outer_limit == pytest.approx(sv_left, abs=0.1)
-        # sv right strip is iso-tightened
-        assert a.sv_zones.right.outer_limit == pytest.approx(iso_limit, abs=0.1)
+        # sv right strip is iso-tightened only when the iso overlaps its y-range.
+        sv_y0, sv_y1 = a.SV_Y - a.fv_hh, a.SV_Y + a.fv_hh
+        if sv_y0 < iso_y1 and iso_y0 < sv_y1:
+            assert a.sv_zones.right.outer_limit == pytest.approx(iso_limit, abs=0.1)
+        else:
+            assert a.sv_zones.right.outer_limit > iso_limit
 
     def test_sv_zones_below_strip_is_active(self):
         # sv_zones.below must be a Strip (not None) after _analyse().
@@ -1135,52 +1142,108 @@ def test_clear_annotations_keep_custom_and_unnamed_removed():
 
 
 @pytest.fixture(scope="module")
-def shrunk_iso_drawing():
-    # #75 fixture — NIST CTC-01-like plate at 1:5 on A3: the iso overflows at
-    # sheet scale and is auto-shrunk. Module-scoped; tests must not mutate it.
+def ctc01_a3_drawing():
+    # Fixture — NIST CTC-01-like plate at 1:5 on A3.  Module-scoped; tests must not mutate it.
     return build_drawing(Box(800, 450, 150), scale=0.2, page="A3")
 
 
 @pytest.mark.timeout(120)
-def test_iso_overflow_shrinks_with_nts_note(shrunk_iso_drawing):
-    # #75 — at sheet scale the iso would run past the A3 page edge; it must be
-    # re-projected smaller and captioned NTS.
+def test_ctc01_iso_uses_upper_right_zone(ctc01_a3_drawing):
+    # #75 updated — wide/flat part on A3: the iso is repositioned into the upper-right
+    # zone (above the SV, right of FV/PV) where it fits at sheet scale.  No NTS label.
     from draftwright.make_drawing import _iso_bbox
 
-    dwg = shrunk_iso_drawing
+    dwg = ctc01_a3_drawing
     labels = [getattr(a, "label", "") for a in dwg.annotations]
-    assert "ISO VIEW (NTS)" in labels
+    assert "ISO VIEW (NTS)" not in labels  # iso now fits at sheet scale — no NTS
     x0, y0, x1, y1 = _iso_bbox(dwg)
     assert (
         x1 <= dwg.page_w - 10 + 0.5 and x0 >= 0 and y0 >= 10 - 0.5 and y1 <= dwg.page_h - 10 + 0.5
     )
+    # iso must be significantly larger than the old 65 mm (shrunken) view
+    assert (x1 - x0) > 100
 
 
 @pytest.mark.timeout(120)
-def test_shrunk_iso_keeps_world_to_page_mapping(shrunk_iso_drawing):
-    # After the NTS shrink, dwg.at("iso", ...) must still map world points to
-    # the page: the centroid lands on the view centre and offsets scale by the
-    # shrunk view scale, not the sheet scale.
-    dwg = shrunk_iso_drawing
+def test_ctc01_iso_world_to_page_mapping(ctc01_a3_drawing):
+    # dwg.at("iso", ...) must map world points to page even after the iso is
+    # repositioned to the upper-right zone (still projected at sheet scale).
+    dwg = ctc01_a3_drawing
     cx, cy, cz = dwg.centroid
     centre = dwg.at("iso", cx, cy, cz)
     vis, _hid = dwg.views["iso"]
     bb = vis.bounding_box()
     assert bb.min.X < centre[0] < bb.max.X and bb.min.Y < centre[1] < bb.max.Y
-    # World +Z maps to page +Y; the offset must use the shrunk view scale (not
-    # the sheet scale).  Derive the actual shrunk scale from _coords so the
-    # test does not depend on a specific discretised shrink factor.
-    shrunk_scale = dwg._coords["iso"]._scale
-    assert shrunk_scale < dwg.scale, "iso should be shrunk below sheet scale"
+    iso_scale = dwg._coords["iso"]._scale
     raised = dwg.at("iso", cx, cy, cz + 100)
-    assert raised[1] - centre[1] == pytest.approx(100 * shrunk_scale)
+    assert raised[1] - centre[1] == pytest.approx(100 * iso_scale)
 
 
 @pytest.mark.timeout(60)
-def test_iso_that_fits_is_not_shrunk():
+def test_iso_stays_within_page_bounds():
+    # Whether scaled up or not, the iso must always lie within the page margin.
+    from draftwright.make_drawing import _iso_bbox
+
     dwg = build_drawing(Box(30, 20, 10))
-    labels = [getattr(a, "label", "") for a in dwg.annotations]
-    assert "ISO VIEW (NTS)" not in labels
+    x0, y0, x1, y1 = _iso_bbox(dwg)
+    margin = 10
+    assert x0 >= margin - 0.5
+    assert y0 >= margin - 0.5
+    assert x1 <= dwg.page_w - margin + 0.5
+    assert y1 <= dwg.page_h - margin + 0.5
+
+
+@pytest.mark.timeout(120)
+def test_ctc01_iso_picks_upper_right_rectangle(ctc01_a3_drawing):
+    # #11 — the general largest-empty-rectangle search must reproduce the #9
+    # outcome for the wide/flat-on-A3 case: the chosen iso zone is the
+    # upper-right region (right of the FV/PV column, above the SV row).
+    dwg = ctc01_a3_drawing
+    a = dwg._analysis
+    # FV/PV occupy the left column; SV the lower-middle.  The picked rectangle
+    # must sit to the right of the FV/PV column and above the SV row.
+    fv_right = a.FV_X + a.fv_hw
+    sv_top = a.SV_Y + a.fv_hh
+    assert a.iso_left_limit >= fv_right
+    assert a.iso_bottom_limit >= sv_top
+    # And it reaches into the upper-right corner of the drawable area.
+    assert a.iso_right_limit >= a.PAGE_W - a.margin - 0.5
+    assert a.iso_top_limit >= a.PAGE_H - a.margin - 0.5
+    assert a.ISO_X > a.PAGE_W / 2 and a.ISO_Y > a.PAGE_H / 2
+
+
+@pytest.mark.timeout(120)
+def test_tall_part_iso_in_largest_free_zone():
+    # #11 — a tall/narrow part has no per-shape branch; the iso must land in the
+    # largest empty rectangle, clear of every view bbox and the title block, and
+    # stay within the page margins.
+    from draftwright.make_drawing import _iso_bbox
+
+    dwg = build_drawing(Box(40, 40, 300))
+    a = dwg._analysis
+    x0, y0, x1, y1 = _iso_bbox(dwg)
+    margin = a.margin
+    # Within page margins.
+    assert x0 >= margin - 0.5
+    assert y0 >= margin - 0.5
+    assert x1 <= a.PAGE_W - margin + 0.5
+    assert y1 <= a.PAGE_H - margin + 0.5
+
+    iso_bb = (x0, y0, x1, y1)
+
+    def overlaps(b1, b2):
+        return b1[0] < b2[2] and b2[0] < b1[2] and b1[1] < b2[3] and b2[1] < b1[3]
+
+    # No overlap with any orthographic view bounding box.
+    for name in ("front", "plan", "side"):
+        vis, hid = dwg.views[name]
+        vb = vis.bounding_box()
+        view_bb = (vb.min.X, vb.min.Y, vb.max.X, vb.max.Y)
+        assert not overlaps(iso_bb, view_bb), f"iso overlaps {name} view"
+
+    # No overlap with the title-block region (bottom-right corner).
+    tb_bb = (a.PAGE_W - a.TB_W - 11, 11, a.PAGE_W - 11, 11 + 35)
+    assert not overlaps(iso_bb, tb_bb), "iso overlaps title block"
 
 
 @pytest.mark.timeout(60)
@@ -2035,3 +2098,113 @@ class TestIsRotational:
         dwg.lint()
         dwg.lint()
         assert calls["n"] == 0
+
+
+# ---------------------------------------------------------------------------
+# Layout-overfitting regression tests (issue #13)
+#
+# The fixtures above exercise the prismatic path well but leave the turned
+# path and several hard-coded thresholds under-tested — which is how the
+# overfitting in #10–#12 went unnoticed. These cases pin the *general*
+# behaviour the algorithm should have. Where current `main` does not yet
+# meet it, the test is marked xfail(strict=True) so it auto-flags (xpass)
+# the moment the corresponding fix lands.
+# ---------------------------------------------------------------------------
+
+
+class TestTurnedPlusDrilledFlange:
+    """A flange is turned (square envelope, dominant OD) yet carries discrete
+    off-axis holes — the most common turned-and-drilled part. The binary
+    turned/prismatic split (#10) classifies it rotational and then withholds
+    every hole callout, location dim, and bolt-circle furniture, leaving the
+    bolt holes with bare centre marks.
+    """
+
+    @staticmethod
+    def _flange():
+        # ø100 × 20 disc, ø30 central bore, 6 × ø8 holes on an ø80 bolt circle.
+        flange = Cylinder(50, 20) - Cylinder(15, 20)
+        for i in range(6):
+            ang = 2 * math.pi * i / 6
+            flange -= Pos(40 * math.cos(ang), 40 * math.sin(ang), 0) * Cylinder(4, 20)
+        return flange
+
+    @pytest.mark.timeout(60)
+    def test_flange_classifies_rotational_with_od(self):
+        # The turned base set is correct today and must stay so.
+        dwg = build_drawing(self._flange())
+        assert dwg._analysis.is_rotational
+        assert "dim_od" in dwg._named
+        assert "centerline_front" in dwg._named
+
+    @pytest.mark.timeout(60)
+    def test_flange_composes_od_with_bolt_circle_furniture(self):
+        dwg = build_drawing(self._flange())
+        # Turned base set — already works.
+        assert "dim_od" in dwg._named
+        # Feature-driven furniture for the bolt circle — withheld today.
+        assert any(n.startswith("hc_") for n in dwg._named), "expected hole callouts"
+        assert any(n.startswith("dim_loc") for n in dwg._named), "expected location dims"
+        assert any(n.startswith("bc_") for n in dwg._named), "expected bolt-circle furniture"
+
+
+class TestTurnedMultiBoreOverflow:
+    """A turned part with 4+ distinct concentric bores. The leader stack caps
+    at three (`bores[:3]`); the overflow must not vanish silently — it should
+    be annotated or surfaced through the coverage lint (#10).
+    """
+
+    @staticmethod
+    def _telescoping():
+        # ø80 OD with four concentric counterbore steps: ø60 / ø44 / ø30 / ø16.
+        part = Cylinder(40, 80)
+        part -= Pos(0, 0, 30) * Cylinder(30, 20)
+        part -= Pos(0, 0, 10) * Cylinder(22, 30)
+        part -= Pos(0, 0, -10) * Cylinder(15, 30)
+        part -= Pos(0, 0, -30) * Cylinder(8, 20)
+        return part
+
+    @pytest.mark.timeout(60)
+    def test_no_bore_silently_dropped(self):
+        dwg = build_drawing(self._telescoping())
+        a = dwg._analysis
+        bores = {d for d in a.z_diams if d != a.od_diam}
+        assert bores == {60.0, 44.0, 30.0, 16.0}
+        annotated = {
+            float(ann.label.lstrip("ø")) for n, ann in dwg._named.items() if n.startswith("ldr_z")
+        }
+        # Acceptance (#10): annotate all, or surface the overflow via lint —
+        # never drop a bore with no trace.
+        if annotated != bores:
+            assert any(i.code == "feature_not_dimensioned" for i in dwg.lint()), (
+                f"bores {bores - annotated} dropped with no lint coverage"
+            )
+
+
+class TestStepHeightThreshold:
+    """The step-height gate dimensions a step only when it projects to ≥20 mm
+    on the page (`(z - bb.min.Z) * SCALE >= 20`). That page-mm cutoff is
+    incidental: a genuine, well-separated step should be dimensioned whatever
+    its scaled height (#13).
+    """
+
+    @staticmethod
+    def _stepped(base_h):
+        # Prismatic two-level block: a base of height ``base_h`` (bottom at
+        # z=0) with a smaller platform on top. The single interior step face
+        # sits ``base_h`` above the part bottom, so at 1:1 it projects to
+        # exactly ``base_h`` mm on the page.
+        base = Pos(0, 0, base_h / 2) * Box(100, 100, base_h)
+        platform = Pos(0, 0, base_h + 5) * Box(60, 60, 10)
+        return base + platform
+
+    @pytest.mark.timeout(60)
+    def test_step_above_page_gate_is_dimensioned(self):
+        # 21 mm of page height — dimensioned. Guards the gate's upper side.
+        dwg = build_drawing(self._stepped(21), scale=1.0, page="A2")
+        assert any(n.startswith("dim_step") for n in dwg._named)
+
+    @pytest.mark.timeout(60)
+    def test_real_step_just_below_page_gate_still_dimensioned(self):
+        dwg = build_drawing(self._stepped(19), scale=1.0, page="A2")
+        assert any(n.startswith("dim_step") for n in dwg._named)