draftwright 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -2,6 +2,46 @@
 
 ## 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.0
+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

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

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

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

@@ -13,6 +13,7 @@ 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
@@ -382,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.

{draftwright-0.2.0 → draftwright-0.2.1}/src/draftwright/annotations/from_model.py

@@ -27,10 +27,12 @@ from draftwright._core import (
     _DIAM_RE,
     _END_ON,
     _MARGIN,
+    _MIN_STEP_SEP_MM,
     _SLOT_DIM_DEPTH,
     _SLOT_DIM_HEIGHT,
     _SLOT_DIM_STEP,
     _SLOT_DIM_WIDTH,
+    DetailRequest,
     _dim,
     _fmt,
     _greedy_strip_ys,
@@ -584,52 +586,30 @@ def render_envelope(dwg, groups, a) -> int:
     return n
 
 
-def render_step_lengths(dwg, groups) -> int:
-    """Unified turned step-length chain (ADR 0008 #223) — one IR-driven path that
-    replaces the engine's asymmetric X-chain / Z-ladder. Each `StepFeature`'s length
-    span is projected into the front view; the chain runs *along the projected axis*
-    just outside the view — **horizontal** for an X-turned part, **vertical** for a
-    Z-turned part. Orientation is the projected span direction, not a branch, so X
-    and Z get the same complete chain. Returns the number of step dims placed.
-
-    The chain is collinear (all segments share one offset line) and tiles end to
-    end, so every shoulder is located. Crowded labels are spread along the line by
-    the ADR-0003 strip solve (the primitive the engine's X chain already used)."""
-    segs = []  # (page_lo, page_hi, value), in axis order
-    for g in groups:
-        if g.feature_kind != "step":
-            continue
-        length = next(
-            (pd.param for pd in g.dims if pd.param.kind == "length" and pd.param.span is not None),
-            None,
-        )
-        if length is None or length.span is None:
-            continue
-        a, b = length.span
-        pa, pb = dwg.at("front", *a), dwg.at("front", *b)
-        segs.append((pa, pb, length.value))
+def _draw_step_chain(dwg, view, segs, name_prefix, detail_scale=None, allow_collapse=True) -> int:
+    """Place a turned step-length chain in *view* from *segs* — each ``(pa, pb,
+    value)`` already projected to *view*'s page coords, in axis order. Orientation is
+    data (the projected span direction): horizontal → chain above the view, vertical
+    → chain to the right. A uniform run collapses to one ``N× v`` dim (#230); else a
+    per-segment chain, staggered into a near/far tier only when crowded (ISO 129-1,
+    #293); skipped if even two tiers can't separate the labels, or if any dim would
+    fall off the page. ``detail_scale`` tags the dims for label-vs-measured lint when
+    drawing inside a scaled detail view. ``allow_collapse=False`` disables the ``N× v``
+    collapse — used when the chain mixes a synthetic head-*block* with real steps, where
+    a uniform-staircase representative would be a false claim of N equal steps (#307
+    review). Returns the count placed."""
     if not segs:
         return 0
-    vb = dwg.view_bounds("front")
+    vb = dwg.view_bounds(view)
     if vb is None:
         return 0
     x0, y0, x1, y1 = vb
     draft = dwg.draft
     gap = draft.font_size + 4 * draft.pad_around_text
-    # Orientation is data: the projected span direction. Horizontal → X-turned
-    # (chain above the view); vertical → Z-turned (chain left of the view).
     horizontal = abs(segs[0][1][0] - segs[0][0][0]) >= abs(segs[0][1][1] - segs[0][0][1])
-
-    # Spread crowded labels along a horizontal chain (ADR-0003 strip solve), then
-    # carry each label back to its segment via label_offset_x (the only along-line
-    # offset the Dimension primitive supports). A vertical chain places plain dims.
-    # Uniform staircase → one representative "N× length" dim spanning the whole run
-    # (#230), instead of N identical segment dims. Mirrors the prismatic ladder's
-    # _detect_step_repeat: ≥3 segments, all within 10% of the mean (so a 2-step part
-    # or a mixed chain still dimensions each segment).
     vals = [v for *_, v in segs]
     mean_v = sum(vals) / len(vals)
-    if len(segs) >= 3 and (max(vals) - min(vals)) <= 0.10 * mean_v:
+    if allow_collapse and len(segs) >= 3 and (max(vals) - min(vals)) <= 0.10 * mean_v:
         label = f"{len(segs)}× {_fmt(mean_v)}"
         xs = [p[0] for pa, pb, _ in segs for p in (pa, pb)]
         ys = [p[1] for pa, pb, _ in segs for p in (pa, pb)]
@@ -637,48 +617,47 @@ def render_step_lengths(dwg, groups) -> int:
             dim = _dim((min(xs), y1, 0), (max(xs), y1, 0), "above", gap, draft, label=label)
         else:
             dim = _dim((x1, min(ys), 0), (x1, max(ys), 0), "right", gap, draft, label=label)
-        candidates = [("m_steplen_typ", dim)]
+        candidates = [(f"{name_prefix}_typ", dim)]
     else:
-        offsets = [0.0] * len(segs)
-        # Legibility guard (#293): a too-dense chain must SKIP, not overprint. Placing
-        # an unreadable wall of overlapping dims is worse than none — lint then reports
-        # axial_length_missing, and the user resolves it with a larger scale or a detail
-        # view. The room guard's sibling, for crowding rather than page overflow.
-        gap_min = draft.font_size + 2 * draft.pad_around_text
+        tier_step = draft.font_size + 2 * draft.pad_around_text
+        tiers = [0] * len(segs)
         if horizontal:
-            centers = [(pa[0] + pb[0]) / 2 for pa, pb, _ in segs]
-            half_w = max(len(_fmt(v)) for *_, v in segs) * draft.font_size * 0.62 / 2
-            min_gap = 2 * half_w + 2 * draft.pad_around_text
-            solved = _solve_strip_ys(
-                centers, min_gap, x0 + half_w, x1 - half_w
-            ) or _greedy_strip_ys(centers, min_gap, x0 + half_w, x1 - half_w)
-            placed = sorted(solved) if solved else sorted(centers)
-            if any(b - a < min_gap - 0.01 for a, b in zip(placed, placed[1:])):
-                _log.info("step-length chain skipped: %d labels too dense to space", len(segs))
+            cw = [
+                ((pa[0] + pb[0]) / 2, len(_fmt(v)) * draft.font_size * 0.62) for pa, pb, v in segs
+            ]
+
+            def _clear(items):  # (center, width) pairs in x order — labels don't overlap
+                return all(
+                    c2 - c1 >= (w1 + w2) / 2 + draft.pad_around_text
+                    for (c1, w1), (c2, w2) in zip(items, items[1:])
+                )
+
+            if _clear(cw):
+                pass  # one tier suffices — no needless zig-zag for a roomy chain
+            elif _clear(cw[0::2]) and _clear(cw[1::2]):
+                tiers = [i % 2 for i in range(len(segs))]  # alternate to make room
+            else:
+                _log.info("step-length chain skipped: too dense even when staggered")
                 return 0
-            if solved:
-                offsets = [s - c for s, c in zip(solved, centers)]
         else:
-            # Z-turned chain places plain dims at the shoulders (no along-line spread is
-            # available vertically), so its legibility is the raw shoulder spacing.
             shoulder_ys = sorted({c for pa, pb, _ in segs for c in (pa[1], pb[1])})
-            if any(b - a < gap_min for a, b in zip(shoulder_ys, shoulder_ys[1:])):
+            if any(b - a < tier_step for a, b in zip(shoulder_ys, shoulder_ys[1:])):
                 _log.info("step-length chain skipped: shoulders too close to dimension")
                 return 0
 
         candidates = []
         for i, (pa, pb, value) in enumerate(segs):
-            if horizontal:  # X-turned: chain above the view, witnesses rise from the top
+            if horizontal:
                 p1, p2, side = (pa[0], y1, 0), (pb[0], y1, 0), "above"
-                kw = {"label": _fmt(value), "label_offset_x": offsets[i]}
-            else:  # Z-turned: chain right of the view, witnesses from the right edge
+                dist = gap + tiers[i] * tier_step
+            else:
                 p1, p2, side = (x1, pa[1], 0), (x1, pb[1], 0), "right"
-                kw = {"label": _fmt(value)}
-            candidates.append((f"m_steplen{i}", _dim(p1, p2, side, gap, draft, **kw)))
+                dist = gap
+            candidates.append(
+                (f"{name_prefix}{i}", _dim(p1, p2, side, dist, draft, label=_fmt(value)))
+            )
 
-    # Room guard (the engine's contract): if any dim would fall off the drawable
-    # page, place NONE and let lint report axial_length_missing — never run the
-    # chain off the page edge.
+    # Room guard: if any dim would fall off the drawable page, place NONE.
     page = (_MARGIN, _MARGIN, dwg.page_w - _MARGIN, dwg.page_h - _MARGIN)
     for _, dim in candidates:
         box = _anno_box(dim)
@@ -687,10 +666,93 @@ def render_step_lengths(dwg, groups) -> int:
         ):
             return 0
     for name, dim in candidates:
-        dwg.add(dim, name, view="front")
+        if detail_scale is not None:
+            dim._dw_scale = detail_scale
+        dwg.add(dim, name, view=view)
     return len(candidates)
 
 
+def render_step_lengths(dwg, groups) -> int:
+    """Unified turned step-length chain (ADR 0008 #223): each `StepFeature`'s length
+    span projects into the front view and joins the chain that tiles the turning axis
+    so every shoulder is located. X-turned → horizontal chain above the view;
+    Z-turned → vertical chain to the right.
+
+    A crowded **X-turned head** — a contiguous run of steps too short to dimension
+    legibly even staggered (shoulders below the page arrowhead floor) — is not crammed
+    in line: the main view locates that run as one *block* dim and an enlarged
+    `DetailRequest` (#304/#307) is queued to break it down. If the detail later can't
+    place, the block still locates the head extent and lint reports the un-located
+    interior shoulders — never worse than the prior skip. Returns the count placed on
+    the front view."""
+    rows = []  # (a_world, b_world, value) in axis order
+    for g in groups:
+        if g.feature_kind != "step":
+            continue
+        length = next(
+            (pd.param for pd in g.dims if pd.param.kind == "length" and pd.param.span is not None),
+            None,
+        )
+        if length is None or length.span is None:
+            continue
+        rows.append((length.span[0], length.span[1], length.value))
+    if not rows:
+        return 0
+    draft = dwg.draft
+    fsegs = [(dwg.at("front", *a), dwg.at("front", *b), v) for a, b, v in rows]
+    horizontal = abs(fsegs[0][1][0] - fsegs[0][0][0]) >= abs(fsegs[0][1][1] - fsegs[0][0][1])
+
+    # X-turned crowded-head detour (#307): split off each contiguous *run of ≥2*
+    # sub-floor steps (segment narrower than two arrowheads on the page), locate it as
+    # a block, and queue an enlarged detail. A single isolated thin step is left in the
+    # main chain — a one-step block would just be that step at its sub-floor width
+    # (#307 review). The legible steps + blocks stay as the main chain.
+    if horizontal:
+        floor_pg = 2 * draft.arrow_length
+        sub = [i for i, (pa, pb, _) in enumerate(fsegs) if abs(pb[0] - pa[0]) < floor_pg]
+        runs: list[list[int]] = []
+        for j in sub:
+            (runs[-1].append(j) if runs and j == runs[-1][-1] + 1 else runs.append([j]))
+        heads = [run for run in runs if len(run) >= 2]
+        if heads:
+            blocks = []
+            for run in heads:
+                ra = [rows[i] for i in run]
+                hlo = min(min(a[0], b[0]) for a, b, _ in ra)
+                hhi = max(max(a[0], b[0]) for a, b, _ in ra)
+                minlen = min(v for *_, v in ra)
+                # World→page scale for the detail (no sheet factor — detail_scale is an
+                # absolute world→page scale). (#307 review)
+                scale_needed = _MIN_STEP_SEP_MM / minlen if minlen > 0 else float("inf")
+                blocks.append((dwg.at("front", hlo, 0, 0), dwg.at("front", hhi, 0, 0), hhi - hlo))
+
+                def _redraw(dwg, view, detail_scale, _hw=ra):
+                    # View-scoped name prefix so two detail views never collide (#307 review).
+                    hsegs = [(dwg.at(view, *a), dwg.at(view, *b), v) for a, b, v in _hw]
+                    return _draw_step_chain(dwg, view, hsegs, f"dim_{view}_steplen", detail_scale)
+
+                dwg._detail_requests.append(
+                    DetailRequest(
+                        axis="x",
+                        lo=hlo,
+                        hi=hhi,
+                        scale_needed=scale_needed,
+                        redraw=_redraw,
+                        pad_top=2 * (draft.font_size + 2 * draft.pad_around_text)
+                        + draft.arrow_length,
+                        kind="turned-head",
+                    )
+                )
+            head = {i for run in heads for i in run}
+            main = [fsegs[i] for i in range(len(fsegs)) if i not in head] + blocks
+            main.sort(key=lambda s: s[0][0])
+            # The chain now mixes head-block(s) with real steps — never collapse it to a
+            # uniform "N× v" representative (a block is not a repeated step, #307 review).
+            return _draw_step_chain(dwg, "front", main, "m_steplen", allow_collapse=False)
+
+    return _draw_step_chain(dwg, "front", fsegs, "m_steplen")
+
+
 def _detect_step_repeat(step_zs, bb_min_z, bb_max_z, tol_frac=0.10):
     """Return (n, rise) if *step_zs* form a uniform staircase, else None.
 

{draftwright-0.2.0 → draftwright-0.2.1}/src/draftwright/annotations/holes.py

@@ -514,6 +514,37 @@ def _annotate_holes(dwg, a: Analysis, view_of_axis, groups, feature_keys):
             return centre
         return (centre[0] + dx / norm * r, centre[1] + dy / norm * r)
 
+    def _coaxial_lift(centre, ny, view_cx, view_cy, y_min, y_max):
+        """Leader row for a hole, lifted clear of the round view's centre axis when
+        the hole is a *coaxial bore* (#305); *ny* unchanged otherwise.
+
+        A bore on the turning axis is led out along the view's horizontal centre
+        axis, so the centre mark / centreline runs straight through the "⌀… ↓…"
+        callout text. Detect that one bore — a rotational part, hole at the view
+        centre — and lift its row a clearance off the axis (an angled leader to a
+        central feature is standard practice), toward the roomier side. Off-axis
+        holes and every prismatic-part hole are untouched (front-view round parts
+        place coaxial bores as vertical shafts below the view, not along an axis,
+        so they can't hit this and are exempt by construction).
+
+        Tactical: the principled fix is to not draw the crossing line at all — a
+        centred bore is located by the axis, so its linear location dims are
+        redundant (#309) — or to make this a layout-solver separation constraint
+        (ADR 0003). This nudge becomes dead code once either lands."""
+        tol = draft.font_size  # "hole at the view centre" tolerance (page mm)
+        if not (
+            a.is_rotational and abs(centre[0] - view_cx) < tol and abs(centre[1] - view_cy) < tol
+        ):
+            return ny
+        # Lift the row a full text height + padding clear of the axis: enough for
+        # the text box (half a font tall) to sit wholly off the centre line with a
+        # pad of margin, giving a legible leader angle rather than a near-flat one.
+        lift = draft.font_size + 3 * draft.pad_around_text
+        # Toward the roomier half-view (geometric, not occupancy-aware — safe here
+        # because the round view of a coaxial bore is otherwise near-empty).
+        up = (y_max - view_cy) >= (view_cy - y_min)
+        return min(view_cy + lift, y_max) if up else max(view_cy - lift, y_min)
+
     def _add(view, i, tip, elbow, side, callout):
         dwg.add(
             Leader(
@@ -598,6 +629,12 @@ def _annotate_holes(dwg, a: Analysis, view_of_axis, groups, feature_keys):
         else:
             y_min, y_max = a.SV_Y - a.fv_hh, a.SV_Y + a.fv_hh
 
+        # Round view's horizontal centre axis — a coaxial bore led out along it has
+        # its callout text crossed by the centre mark / centreline (#305); see
+        # _coaxial_lift.
+        view_cx = a.PV_X if view == "plan" else a.SV_X
+        view_cy = a.PV_Y if view == "plan" else a.SV_Y
+
         # --- Pass 1: boundary assignment ---
         right_queue = []  # (locs, dia, callout, feat, natural_y, rep)
         left_queue = []
@@ -632,9 +669,11 @@ def _annotate_holes(dwg, a: Analysis, view_of_axis, groups, feature_keys):
                 continue
 
             if can_right and (not can_left or d_right <= d_left):
-                right_queue.append((locs, dia, callout, feat, centre_r[1], rep_r))
+                ny = _coaxial_lift(centre_r, centre_r[1], view_cx, view_cy, y_min, y_max)
+                right_queue.append((locs, dia, callout, feat, ny, rep_r))
             else:
-                left_queue.append((locs, dia, callout, feat, centre_l[1], rep_l))
+                ny = _coaxial_lift(centre_l, centre_l[1], view_cx, view_cy, y_min, y_max)
+                left_queue.append((locs, dia, callout, feat, ny, rep_l))
 
         # Sort each queue by natural Y so leaders don't cross.
         right_queue.sort(key=lambda s: s[4])

{draftwright-0.2.0 → draftwright-0.2.1}/src/draftwright/annotations/orchestrator.py

@@ -44,7 +44,11 @@ from draftwright.annotations.holes import (
     _annotate_holes,
     _locate_off_axis_holes,
 )
-from draftwright.annotations.sections import _add_detail_view, _add_section_view
+from draftwright.annotations.sections import (
+    _add_section_view,
+    _request_prismatic_detail,
+    _resolve_details,
+)
 from draftwright.model import build_part_model, plan_dimensions, plan_sections
 from draftwright.recognition import (
     full_cylinders,
@@ -99,6 +103,7 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     # not accumulate duplicate drop records.
     dwg._reset_build_issues()
     dwg._reset_dropped_callout_diams()
+    dwg._detail_requests = []  # renderers queue enlarged-detail requests here (#307)
 
     FX = a.proj.front_x
     FZ = a.proj.front_z
@@ -223,18 +228,19 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     if section is not None:
         _add_section_view(dwg, a, section)
 
-    # Detail view: only when explicitly requested via build_drawing(detail_view=True).
+    # Prismatic step-height detail: queue it (only when build_drawing(detail_view=True))
+    # — resolved with every other detail request below (#307).
     if detail_view:
-        _add_detail_view(dwg, a)
+        _request_prismatic_detail(dwg, a)
 
     # Turned-part dimensions via the IR (ADR 0008 convergence). The model is built
     # once and fed to both renderers (#229 — no per-pass rebuild):
     #  - diameters: ø leaders, row below (X) / column left (Z), one path by frame
     #    axis. Replaces _annotate_turned_diameters.
     #  - step lengths: the chain that locates every shoulder, X and Z from one path
-    #    (#223). Replaces the old X-only chain + the Z step-height ladder (skipped
-    #    above for turned parts); the envelope dim along the turning axis was
-    #    suppressed so the chain does not double-dimension the length.
+    #    (#223). A crowded X-turned head queues an enlarged detail request (#304/#307)
+    #    instead of cramming; the envelope dim along the turning axis was suppressed
+    #    so the chain does not double-dimension the length.
     render_diameters(dwg, _groups)
     if a.prof is not None:
         render_step_lengths(dwg, _groups)
@@ -249,6 +255,11 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     # after every hole/diameter pass so it claims strip space last.
     render_slots(dwg, _model, a)
 
+    # Resolve every queued enlarged-detail request (#307) — prismatic step bands and
+    # crowded turned heads alike — through the one generic detailer, now that all
+    # views and main-view annotations are placed (so the detail avoids them).
+    _resolve_details(dwg, a)
+
     # Phase 7 — strip footprint debug logging + post-placement overflow check.
     # Overflow can only occur when outer_limit was tightened after allocations
     # were already committed (e.g. iso-x tightening or iso-y cap guard).