draftwright 0.2.12__tar.gz → 0.2.13__tar.gz

{draftwright-0.2.12 → draftwright-0.2.13}/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## v0.2.13 — 2026-07-09
+
+**Compose-then-pack is now the layout authority.** This patch finishes the
+ViewBlock footprint migration: estimated and measured layout paths now use the
+same composed block model, furniture declarations reserve their real footprint,
+and measure/repack iterates until stable instead of trusting one measured pass.
+
+### Changed
+
+- **ViewBlock footprints now drive the orthographic stack.** The old
+  estimator-only plan-view balloon lift is gone; plan balloon headroom is part
+  of the plan block in both estimated and measured/repack layout. (#112)
+- **Measure/repack iterates to a fixed point.** Repack now keeps measuring and
+  repacking while view-owned footprints continue to grow, with bounded
+  convergence and tests for multi-pass growth. (#302)
+- **Estimated view-block composition is explicit.** Scale/page fitness, repack,
+  and furniture placement share the same composed block semantics instead of
+  rebuilding corridor estimates independently.
+
+### Fixed
+
+- **Declared callout furniture reserves layout footprint.** User-declared
+  furniture is now measured and fed into the layout model, reducing post-hoc
+  collisions from declarations that previously existed only at render time.
+- **Annotation-box composition owns strip sizing.** Strip depths reduce from
+  composed annotation boxes, making footprint sizing less dependent on divergent
+  scalar estimates.
+
+### Documentation
+
+- **Layout architecture docs reflect the current state.** ADR 0004 and the
+  layout primer now mark the core layout-authority tranche complete and separate
+  remaining work into hardening, coverage, detail-view, and manual-intent phases.
+
 ## v0.2.12 — 2026-07-09
 
 **Sheet scripts now round-trip authored layout intent.** This patch finishes the next

{draftwright-0.2.12 → draftwright-0.2.13}/PKG-INFO

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

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

{draftwright-0.2.12 → draftwright-0.2.13}/src/draftwright/analysis.py

@@ -14,6 +14,7 @@ import logging
 import math
 import warnings
 from collections.abc import Callable
+from dataclasses import replace
 
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
@@ -31,6 +32,8 @@ from draftwright._core import (
     _legible_steps,
     _Projector,
 )
+from draftwright.model.ir import Datum, PartModel, StepFeature
+from draftwright.model.planner import plan_dimensions
 from draftwright.recognition import (
     analyse_cylinders,
     analyse_face_levels,
@@ -45,6 +48,7 @@ from draftwright.sheet import (
     StripDepths,
     _build_zones,
     _est_hole_table_sizes,
+    _est_planned_bore_callout_width,
     _layout_geometry,
     _measure_strips,
     _will_section,
@@ -96,6 +100,32 @@ def _declared_will_section(model, *, is_rotational=False, cx=0.0, cy=0.0) -> boo
     return False
 
 
+def _coerce_layout_model(model, part, decorations=None) -> PartModel | None:
+    """Return the caller-declared IR with authored decorations for layout sizing.
+
+    This mirrors the builder's render-time coercion, but stays local to analysis so
+    page/scale/strip selection can see the same authored callout text the renderer
+    will later place (#450).
+    """
+    if model is None:
+        return None
+    if isinstance(model, PartModel):
+        if decorations:
+            return replace(model, decorations={**model.decorations, **decorations})
+        return model
+    features = list(model)
+    bbox = part.bounding_box()
+    orientation = next((f.frame.axis for f in features if isinstance(f, StepFeature)), None)
+    datum = Datum(id="datum_xy", kind="point", at=(bbox.min.X, bbox.min.Y, bbox.min.Z))
+    return PartModel(
+        bbox=bbox,
+        orientation=orientation,
+        features=features,
+        datums=[datum],
+        decorations=decorations or {},
+    )
+
+
 def _import_step(path) -> Compound:
     """Read solid geometry from a STEP file via OCCT's ``STEPControl_Reader``.
 
@@ -299,6 +329,7 @@ def _analyse(
     page=None,
     pmi="off",
     model=None,
+    decorations=None,
 ) -> Analysis:
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
@@ -409,6 +440,17 @@ def _analyse(
     _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
+    layout_model = _coerce_layout_model(model, part, decorations)
+    declared_bore_width = (
+        _est_planned_bore_callout_width(
+            plan_dimensions(layout_model),
+            _draft_est,
+            font_size=_FONT_SIZE,
+            pad_around_text=_pad_around_text,
+        )
+        if layout_model is not None
+        else 0.0
+    )
     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)
@@ -442,6 +484,7 @@ def _analyse(
             bb,
             arrow_length=_arrow_length,
             pad_around_text=_pad_around_text,
+            declared_bore_callout_width=declared_bore_width,
         )
 
     def _pick_for_step_count(n_steps_i: int, strips_i: StripDepths) -> _ScalePick:
@@ -518,6 +561,7 @@ def _analyse(
         bb,
         arrow_length=_arrow_length,
         pad_around_text=_pad_around_text,
+        declared_bore_callout_width=declared_bore_width,
     )
     # View positions + iso empty-rectangle, shared with scale selection (_fits)
     # via _layout_geometry so placement and fit never diverge (#11).  _fit_iso_view

{draftwright-0.2.12 → draftwright-0.2.13}/src/draftwright/builder.py

@@ -77,6 +77,7 @@ _TB_W = 150.0
 # approximation error, tight enough not to round a genuinely off-axis curve.
 
 _REPACK_TOL = 0.75
+_REPACK_MAX_ITER = 3
 
 
 def _cross_view_overlaps(dwg, a) -> int:
@@ -345,6 +346,15 @@ def _repack_candidates(a, scale, page):
     return list(_LADDER)
 
 
+def _needs_repack(dwg, a) -> bool:
+    """True when the measured drawing still needs a compose-then-pack pass."""
+    return (
+        _cross_view_overlaps(dwg, a) != 0
+        or _annotation_view_overlaps(dwg, a) != 0
+        or _annotations_out_of_bounds(dwg, a)
+    )
+
+
 def _repack(
     a, dwg, out, assembly, detail_view, scale=None, page=None, model=None, decorations=None
 ):
@@ -360,11 +370,7 @@ def _repack(
     byte-identical) or when the repack would change nothing (same sheet/scale and
     no view actually moves).
     """
-    if (
-        _cross_view_overlaps(dwg, a) == 0
-        and _annotation_view_overlaps(dwg, a) == 0
-        and not _annotations_out_of_bounds(dwg, a)
-    ):
+    if not _needs_repack(dwg, a):
         return None
     blocks = _measure_blocks(dwg, a)
 
@@ -485,6 +491,40 @@ def _repack(
     return a2, dwg2
 
 
+def _repack_to_fixed_point(
+    a, dwg, out, assembly, detail_view, scale=None, page=None, model=None, decorations=None
+):
+    """Iterate measure→repack→assemble until stable or bounded (#302)."""
+    cur_a, cur_dwg = a, dwg
+    for i in range(_REPACK_MAX_ITER):
+        repacked = _repack(
+            cur_a,
+            cur_dwg,
+            out,
+            assembly,
+            detail_view,
+            scale=scale,
+            page=page,
+            model=model,
+            decorations=decorations,
+        )
+        if repacked is None:
+            if _needs_repack(cur_dwg, cur_a):
+                _log.warning(
+                    "measure-repack: stalled after %d iteration(s) with residual layout triggers",
+                    i,
+                )
+            return (cur_a, cur_dwg) if i else None
+        cur_a, cur_dwg = repacked
+
+    if _needs_repack(cur_dwg, cur_a):
+        _log.warning(
+            "measure-repack: reached iteration limit (%d) with residual layout triggers",
+            _REPACK_MAX_ITER,
+        )
+    return cur_a, cur_dwg
+
+
 def build_drawing(
     step_file: str | Path | Shape,
     out: str | None = None,
@@ -561,6 +601,7 @@ def build_drawing(
         page=page,
         pmi=pmi,
         model=model,
+        decorations=decorations,
     )
 
     # Pass 1: place + annotate from the estimated layout, then measure the real
@@ -569,7 +610,7 @@ def build_drawing(
     # measure ≈ estimate, so they skip pass 2 and stand byte-identical.
     dwg = _assemble(a, out, assembly, detail_view, auto_dims, model=model, decorations=decorations)
     if auto_dims:
-        repacked = _repack(
+        repacked = _repack_to_fixed_point(
             a,
             dwg,
             out,

{draftwright-0.2.12 → draftwright-0.2.13}/src/draftwright/sheet.py

@@ -46,6 +46,7 @@ from draftwright._core import (
     _tag_sequence,
     _tb_width,
     _text_width,
+    _tol_suffix,
 )
 from draftwright.layout import fit_box
 from draftwright.recognition import BoltCircle, HoleSpec, RectGrid
@@ -337,6 +338,80 @@ def _est_bore_callout_width(
     return max_w
 
 
+def _est_planned_bore_callout_width(
+    groups, draft, font_size: float = _FONT_SIZE, pad_around_text: float = 2.0
+) -> float:
+    """Estimate widest hole/pattern callout from planned IR dimensions.
+
+    This is the declared-model companion to :func:`_est_bore_callout_width`.
+    Detection-derived ``HoleSpec`` values cannot see authored decorations such as
+    bore tolerances; planned groups can. Keep this in the layout estimator layer
+    so page/scale selection does not import renderers just to size text (#450).
+    """
+
+    def _first(group, kind: str, *roles: str) -> float | None:
+        for role in roles:
+            for pd in group.dims:
+                if pd.param.kind == kind and pd.param.role == role:
+                    return float(pd.param.value)
+        return None
+
+    def _tol(group):
+        return next(
+            (
+                pd.param.tolerance
+                for pd in group.dims
+                if pd.param.kind == "diameter" and pd.param.role == "bore"
+            ),
+            None,
+        )
+
+    gap = 0.45 * font_size
+    sym_w = font_size
+    max_w = 0.0
+    for group in groups:
+        feat = group.feature
+        if getattr(feat, "kind", None) not in ("hole", "pattern"):
+            continue
+        bore = _first(group, "diameter", "bore")
+        if bore is None:
+            continue
+        depth = _first(group, "depth", "bore")
+        cbore_dia = _first(group, "diameter", "counterbore", "spotface")
+        cbore_depth = _first(group, "depth", "counterbore", "spotface")
+        suffix = None
+        if getattr(feat, "kind", None) == "pattern":
+            if getattr(feat, "pattern", None) == "bolt_circle" and feat.bcd is not None:
+                suffix = f"EQ SP ON ø{_fmt(feat.bcd)} BC"
+            elif getattr(feat, "pattern", None) == "grid" and feat.rows and feat.cols:
+                suffix = f"({feat.rows}×{feat.cols})"
+
+        token_w: list[float] = []
+        count = getattr(feat, "count", None)
+        if count and count > 1:
+            token_w.append(_text_width(f"{count}×", font_size))
+        token_w.append(sym_w)  # ⌀ symbol
+        token_w.append(_text_width(f"{_fmt(bore)}{_tol_suffix(_tol(group), draft)}", font_size))
+        if depth is None:
+            token_w.append(_text_width("THRU", font_size))
+        else:
+            token_w.append(sym_w)  # depth symbol
+            token_w.append(_text_width(_fmt(depth), font_size))
+        if cbore_dia is not None:
+            token_w.append(sym_w)  # counterbore/spotface symbol
+            token_w.append(sym_w)  # ⌀
+            token_w.append(_text_width(_fmt(cbore_dia), font_size))
+            if cbore_depth is not None:
+                token_w.append(sym_w)  # depth symbol
+                token_w.append(_text_width(_fmt(cbore_depth), font_size))
+        if suffix is not None:
+            token_w.append(_text_width(suffix, font_size))
+
+        n = len(token_w)
+        max_w = max(max_w, sum(token_w) + max(n - 1, 0) * gap + pad_around_text)
+    return max_w
+
+
 @dataclass
 class StripDepths:
     """Annotation strip depths (page-mm) computed before view positions are fixed.
@@ -358,26 +433,25 @@ def _measure_strips(
     font_size: float = _FONT_SIZE,
     arrow_length: float = 2.7,
     pad_around_text: float = 2.0,
+    declared_bore_callout_width: float = 0.0,
 ) -> StripDepths:
-    """Compute annotation strip depths from hole geometry (Pass 1 of #131).
+    """Compute annotation strip depths from composed annotation boxes (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, pad_around_text=pad_around_text
+    return _footprint_from_boxes(
+        _compose_anno_boxes(
+            holes,
+            patterns,
+            n_steps,
+            font_size=font_size,
+            arrow_length=arrow_length,
+            pad_around_text=pad_around_text,
+            declared_bore_callout_width=declared_bore_callout_width,
+        )
     )
-    # Add elbow clearance and leader-to-label gap so gap_fv_sv fully contains
-    # the composed leader: elbow_dx (= draft.arrow_length) + gap
-    # (= draft.pad_around_text), always present.
-    if bore_depth > 0:
-        bore_depth += pad_around_text + arrow_length
-    right = max(_est_right_strip_depth(n_steps), bore_depth)
-    left = max(_DIM_PAD, bore_depth)
-    top = _est_pv_above_depth(holes, patterns, font_size, pad_around_text)
-    pv_halo = _est_plan_halo(font_size) if _will_balloon(holes, patterns) else 0.0
-    return StripDepths(right=right, left=left, top=top, pv_halo=pv_halo)
 
 
 @dataclass(frozen=True)
@@ -409,17 +483,21 @@ def _compose_anno_boxes(
     font_size: float = _FONT_SIZE,
     arrow_length: float = 2.7,
     pad_around_text: float = 2.0,
+    declared_bore_callout_width: float = 0.0,
 ) -> list[AnnoBox]:
     """Compose a drawing's annotation bands as ``AnnoBox`` boxes (#112, Step 4a).
 
-    Mirrors ``_measure_strips`` exactly, but emits each contributing band as a
-    box rather than folding them into three scalars up front.
-    ``_footprint_from_boxes`` reduces these back to the identical
-    ``StripDepths``.
+    This is the annotation-footprint authority for scale/page layout. Each
+    contributing furniture band is emitted as a box; ``_measure_strips`` only
+    reduces these boxes to the legacy ``StripDepths`` shape. Declared-model
+    callout widths flow through the same box path as detected geometry (#540).
     """
     boxes = [AnnoBox("right", _est_right_strip_depth(n_steps))]  # FV right dim ladder
-    bore_depth = _est_bore_callout_width(
-        holes, font_size, patterns=patterns, pad_around_text=pad_around_text
+    bore_depth = max(
+        _est_bore_callout_width(
+            holes, font_size, patterns=patterns, pad_around_text=pad_around_text
+        ),
+        declared_bore_callout_width,
     )
     if bore_depth > 0:
         # elbow clearance + leader-to-label gap, as in _measure_strips
@@ -732,6 +810,65 @@ def _padded_box(cx, cy, hw, hh, pad=_DIM_PAD):
     return ViewBlock(hw, hh, pad, pad, pad, pad).footprint(cx, cy)
 
 
+def _compose_view_blocks(
+    x_size,
+    y_size,
+    z_size,
+    scale,
+    strips: StripDepths | None,
+    n_steps: int = 0,
+    *,
+    section: bool = False,
+) -> dict[str, ViewBlock]:
+    """Compose estimated orthographic view footprints (#112).
+
+    Each returned ``ViewBlock`` combines the view geometry half-extents with the
+    annotation bands reserved for that view. `_layout_geometry` packs these
+    blocks; it does not reconstruct bare-view corridor padding itself.
+    """
+    DIM_PAD = _DIM_PAD
+    fv_hw = x_size * scale / 2
+    fv_hh = z_size * scale / 2
+    pv_hh = y_size * scale / 2
+    sv_hw = y_size * scale / 2
+
+    # The front and plan views form a vertical column sharing the left/right
+    # corridors (max of the two); the side view shares the FV↔SV corridor; the
+    # front↔plan gap is the abutting pair (fv.top + pv.bottom). When the plan
+    # view is ballooned (halo > 0), its halo becomes explicit per-side bands so
+    # the ballooned plan view is positioned as a unit (#111/#112).
+    halo = strips.pv_halo if strips else 0.0
+    strip_top = strips.top if strips else 0.0
+    gap_fv_sv = max(DIM_PAD, strips.right if strips else _est_right_strip_depth(n_steps), halo)
+    gap_left = max(DIM_PAD, strips.left if strips else DIM_PAD, halo)
+    pv_below = _est_pv_below_depth()
+    # Top band above PV. When the plan view is ballooned, the ring sits beyond
+    # the tiered X-location dims, so reserve their real depth (strip_top) plus a
+    # balloon row. When not ballooned, keep the historic DIM_PAD.
+    pv_top = (max(DIM_PAD, strip_top) + halo) if halo > 0 else DIM_PAD
+    sv_right_band = max(DIM_PAD, strips.right if (section and strips) else DIM_PAD)
+
+    return {
+        "front": ViewBlock(
+            fv_hw,
+            fv_hh,
+            top=DIM_PAD - pv_below,
+            right=gap_fv_sv,
+            bottom=DIM_PAD,
+            left=gap_left,
+        ),
+        "plan": ViewBlock(
+            fv_hw,
+            pv_hh,
+            top=pv_top,
+            right=gap_fv_sv,
+            bottom=max(pv_below, halo),
+            left=gap_left,
+        ),
+        "side": ViewBlock(sv_hw, fv_hh, right=sv_right_band),
+    }
+
+
 def _layout_geometry(
     x_size,
     y_size,
@@ -766,42 +903,10 @@ def _layout_geometry(
     pv_hh = y_size * scale / 2
     sv_hw = y_size * scale / 2
 
-    # Compose each view as a block: geometry half-extents + reserved annotation
-    # bands per side (#112).  The front and plan views form a vertical column
-    # sharing the left/right corridors (max of the two); the side view shares
-    # the FV↔SV corridor; the front↔plan gap is the abutting pair
-    # (fv.top + pv.bottom).  When the plan view is ballooned (halo > 0) its halo
-    # becomes explicit per-side bands so the ballooned plan view is placed as a
-    # unit — including a BOTTOM band that pushes the front view down so balloons
-    # ring the part below it, not just left/right/top (#111/#112 Phase 2).  All
-    # bands reduce to today's arithmetic when halo = 0 (byte-identical).
-    halo = strips.pv_halo if strips else 0.0
-    strip_top = strips.top if strips else 0.0
-    gap_fv_sv = max(DIM_PAD, strips.right if strips else _est_right_strip_depth(n_steps), halo)
-    gap_left = max(DIM_PAD, strips.left if strips else DIM_PAD, halo)
-    pv_below = _est_pv_below_depth()
-    # Top band above PV. When the plan view is ballooned, the ring sits beyond the
-    # tiered X-location dims, so reserve their real depth (strip_top) PLUS a
-    # balloon row — otherwise the ring overruns the page (#121). When NOT
-    # ballooned, keep the historic DIM_PAD: the dim tiers spill harmlessly into
-    # the headroom above PV, and reserving more would needlessly grow the layout
-    # (and can starve the section view of its leftover space).
-    pv_top = (max(DIM_PAD, strip_top) + halo) if halo > 0 else DIM_PAD
-    # Estimated blocks (always built): the scale-derived geometry half-extents
-    # plus the heuristic per-side corridor depths.
-    est_fv = ViewBlock(
-        fv_hw, fv_hh, top=DIM_PAD - pv_below, right=gap_fv_sv, bottom=DIM_PAD, left=gap_left
-    )
-    est_pv = ViewBlock(
-        fv_hw,
-        pv_hh,
-        top=pv_top,
-        right=gap_fv_sv,
-        bottom=max(pv_below, halo),  # band below PV holds the width dim + a balloon row
-        left=gap_left,
+    est_blocks = _compose_view_blocks(
+        x_size, y_size, z_size, scale, strips, n_steps, section=section
     )
-    sv_right_band = max(DIM_PAD, strips.right if (section and strips) else DIM_PAD)
-    est_sv = ViewBlock(sv_hw, fv_hh, right=sv_right_band)
+    est_fv, est_pv, est_sv = est_blocks["front"], est_blocks["plan"], est_blocks["side"]
     section_hw = max(fv_hw, 12.0)
     section_hh = fv_hh
     if blocks is not None:
@@ -835,18 +940,11 @@ def _layout_geometry(
     col_left = max(fv.left, pv.left)
     col_right = max(fv.right, pv.right)
 
-    # Bottom balloon band: rather than pushing the front view down (which would
-    # cascade into the iso/table and the scale choice), LIFT the plan view up
-    # into the empty top headroom above it — the front/side views, iso and title
-    # block stay anchored, so the table is undisturbed.  The lift is implicit:
-    # the vertical stack is centred with the BASE front↔plan gap (so FV/SV centre
-    # exactly as when halo = 0), while PV is positioned with the full ballooned
-    # gap, leaving it max(0, halo - pv_below) higher.  Byte-identical when
-    # halo = 0.  (#112, ADR 0004.)
-    # FV↔PV vertical gap = fv.top + pv.bottom (abutting → sum). The estimator path
-    # keeps its lift trick (centre on the base gap, place PV on the full gap);
-    # the measured path uses the real gap directly.
-    base_gap = (fv.top + pv.bottom) if blocks is not None else (fv.top + pv_below)
+    # FV↔PV vertical gap = fv.top + pv.bottom (abutting → sum). Estimated and
+    # measured paths now use the same block footprint semantics: if the plan
+    # view carries a bottom halo, that band is part of the stacked block layout
+    # rather than a special-case lift outside the ViewBlock model (#112).
+    base_gap = fv.top + pv.bottom
     total_h = 2 * margin + fv.bottom + 2 * fv.hh + base_gap + 2 * pv.hh + pv.top
     y_offset = max(0.0, (page_h - total_h) / 2)
 
@@ -869,9 +967,7 @@ def _layout_geometry(
     FV_X = margin + x_offset + col_left + fv.hw
     FV_Y = y_offset + margin + fv.bottom + fv.hh
     PV_X = FV_X
-    # PV uses the full (ballooned) front↔plan gap while FV/SV were centred with
-    # the base gap — so the plan view sits pv_lift higher: lifted into the
-    # headroom, front view anchored.
+    # PV abuts the front-view block: gap = front top band + plan bottom band.
     PV_Y = FV_Y + fv.hh + (fv.top + pv.bottom) + pv.hh
     # SV abuts the FV/PV column: gap = column right band + SV's own left band
     # (disjoint sum). Byte-identical to the old max(fv.right, sv.left) on the

{draftwright-0.2.12 → draftwright-0.2.13}/tests/test_make_drawing.py

@@ -862,13 +862,9 @@ class TestComposeAnnoBoxes:
         from draftwright.builder import _FONT_SIZE, draft_preset
         from draftwright.sheet import _compose_anno_boxes, _footprint_from_boxes, _measure_strips
 
-        # The composer must reproduce StripDepths exactly for ANY clearance
-        # args (#112, Step 4b): the bore-band elbow+gap overhead
-        # (arrow_length + pad_around_text) is added identically on both paths,
-        # so byte-identity cannot depend on the values. We test the function
-        # defaults, the production draft preset (which today equals the
-        # defaults — a forward-guard if it ever diverges), and a deliberately
-        # divergent set that actually exercises a different overhead.
+        # The composer is the footprint authority (#112): _measure_strips is only
+        # a compatibility reducer around these boxes. Exercise defaults, the
+        # production draft preset, and deliberately divergent clearance values.
         preset = draft_preset(font_size=_FONT_SIZE, decimal_precision=1)
         arg_sets = (
             {},
@@ -880,6 +876,43 @@ class TestComposeAnnoBoxes:
             scalar = _measure_strips(holes, patterns, n_steps, bb, **kw)
             assert composed == scalar, (label, n_steps, kw)
 
+    def test_declared_bore_width_flows_through_boxes(self):
+        # #540: declared Sheet/IR callouts can be wider than detected geometry
+        # because authored tolerances live on the planned dimensions. That width
+        # must be represented as an annotation box, not as a scalar-only side
+        # channel in _measure_strips.
+        from draftwright.builder import _FONT_SIZE, draft_preset
+        from draftwright.recognition import find_hole_patterns, find_holes
+        from draftwright.sheet import _compose_anno_boxes, _footprint_from_boxes, _measure_strips
+
+        part = Box(60, 40, 12) - Pos(0, 0, 6) * Cylinder(3, 12)
+        holes = find_holes(part)
+        patterns = find_hole_patterns(holes)
+        bb = part.bounding_box()
+        draft = draft_preset(font_size=_FONT_SIZE, decimal_precision=1)
+        declared_width = 55.0
+        expected_bore_depth = declared_width + draft.pad_around_text + draft.arrow_length
+
+        boxes = _compose_anno_boxes(
+            holes,
+            patterns,
+            0,
+            arrow_length=draft.arrow_length,
+            pad_around_text=draft.pad_around_text,
+            declared_bore_callout_width=declared_width,
+        )
+        assert expected_bore_depth in [b.depth for b in boxes if b.side == "right"]
+        assert expected_bore_depth in [b.depth for b in boxes if b.side == "left"]
+        assert _footprint_from_boxes(boxes) == _measure_strips(
+            holes,
+            patterns,
+            0,
+            bb,
+            arrow_length=draft.arrow_length,
+            pad_around_text=draft.pad_around_text,
+            declared_bore_callout_width=declared_width,
+        )
+
     def test_matches_for_plain_part(self):
         from draftwright.recognition import find_hole_patterns, find_holes
 
@@ -937,8 +970,8 @@ class TestComposeAnnoBoxesCorpus:
     """Step 4b (#112): de-risk the 4c reservation switch by proving the AnnoBox
     composer is a faithful drop-in for _measure_strips across the full part
     archetype corpus, and by pinning the per-side box *structure* that 4c will
-    consume. Pure validation — nothing yet uses the composer for layout, so the
-    rendered output is byte-identical."""
+    consume. The strip estimate now reduces these boxes, so byte-identity here
+    guards the active layout path."""
 
     @staticmethod
     def _corpus():
@@ -1008,6 +1041,140 @@ class TestComposeAnnoBoxesCorpus:
                 assert bool(halos) == _will_balloon(holes, patterns), (label, n_steps)
 
 
+class TestComposeViewBlocks:
+    """#112: estimated view footprints are explicit ViewBlocks."""
+
+    def test_fallback_blocks_without_measured_strips(self):
+        from draftwright._core import _DIM_PAD
+        from draftwright.sheet import (
+            _compose_view_blocks,
+            _est_pv_below_depth,
+            _est_right_strip_depth,
+        )
+
+        blocks = _compose_view_blocks(60.0, 40.0, 20.0, 2.0, None, n_steps=3)
+        assert set(blocks) == {"front", "plan", "side"}
+        assert blocks["front"].hw == pytest.approx(60.0)
+        assert blocks["front"].hh == pytest.approx(20.0)
+        assert blocks["front"].right == pytest.approx(_est_right_strip_depth(3))
+        assert blocks["front"].left == pytest.approx(_DIM_PAD)
+        assert blocks["front"].top == pytest.approx(_DIM_PAD - _est_pv_below_depth())
+        assert blocks["plan"].bottom == pytest.approx(_est_pv_below_depth())
+        assert blocks["side"].right == pytest.approx(_DIM_PAD)
+
+    def test_ballooned_plan_halo_is_part_of_plan_block(self):
+        from draftwright._core import _DIM_PAD
+        from draftwright.sheet import StripDepths, _compose_view_blocks, _est_pv_below_depth
+
+        strips = StripDepths(right=10.0, left=12.0, top=20.0, pv_halo=30.0)
+        blocks = _compose_view_blocks(60.0, 40.0, 20.0, 1.0, strips)
+
+        # The shared column corridors must hold the plan halo, even though the
+        # scalar right/left strip estimates are smaller.
+        assert blocks["front"].right == pytest.approx(30.0)
+        assert blocks["front"].left == pytest.approx(30.0)
+        assert blocks["plan"].right == pytest.approx(30.0)
+        assert blocks["plan"].left == pytest.approx(30.0)
+        assert blocks["plan"].top == pytest.approx(max(_DIM_PAD, strips.top) + strips.pv_halo)
+        assert blocks["plan"].bottom == pytest.approx(max(_est_pv_below_depth(), strips.pv_halo))
+
+    def test_section_layout_reserves_side_right_band(self):
+        from draftwright._core import _DIM_PAD
+        from draftwright.sheet import StripDepths, _compose_view_blocks
+
+        strips = StripDepths(right=42.0, left=10.0)
+        without_section = _compose_view_blocks(60.0, 40.0, 20.0, 1.0, strips, section=False)
+        with_section = _compose_view_blocks(60.0, 40.0, 20.0, 1.0, strips, section=True)
+
+        assert without_section["side"].right == pytest.approx(_DIM_PAD)
+        assert with_section["side"].right == pytest.approx(strips.right)
+
+    def test_layout_geometry_consumes_composed_blocks(self, monkeypatch):
+        import draftwright.sheet as sheet
+
+        calls = []
+        original = sheet._compose_view_blocks
+
+        def wrapped(*args, **kwargs):
+            calls.append((args, kwargs))
+            return original(*args, **kwargs)
+
+        monkeypatch.setattr(sheet, "_compose_view_blocks", wrapped)
+        strips = sheet.StripDepths(right=42.0, left=10.0)
+        g = sheet._layout_geometry(
+            60.0,
+            40.0,
+            20.0,
+            1.0,
+            420.0,
+            297.0,
+            150.0,
+            strips,
+            n_steps=2,
+            section=True,
+        )
+
+        assert g.fits
+        assert len(calls) == 1
+        args, kwargs = calls[0]
+        assert args[:6] == (60.0, 40.0, 20.0, 1.0, strips, 2)
+        assert kwargs == {"section": True}
+
+    def test_estimator_vertical_stack_is_centred_from_composed_blocks(self):
+        from draftwright._core import _MARGIN
+        from draftwright.sheet import _compose_view_blocks, _layout_geometry
+
+        page_h = 297.0
+        blocks = _compose_view_blocks(60.0, 40.0, 20.0, 1.0, None, n_steps=3)
+        g = _layout_geometry(
+            60.0,
+            40.0,
+            20.0,
+            1.0,
+            420.0,
+            page_h,
+            150.0,
+            None,
+            n_steps=3,
+            warn_no_iso=False,
+        )
+
+        fv, pv = blocks["front"], blocks["plan"]
+        block_stack_h = fv.bottom + 2 * fv.hh + fv.top + pv.bottom + 2 * pv.hh + pv.top
+        expected_y_offset = max(0.0, (page_h - 2 * _MARGIN - block_stack_h) / 2)
+        actual_y_offset = g.FV_Y - _MARGIN - fv.bottom - fv.hh
+
+        assert actual_y_offset == pytest.approx(expected_y_offset)
+
+    def test_estimator_vertical_stack_centres_ballooned_plan_block(self):
+        from draftwright._core import _MARGIN
+        from draftwright.sheet import StripDepths, _compose_view_blocks, _layout_geometry
+
+        page_h = 297.0
+        strips = StripDepths(right=10.0, left=12.0, top=20.0, pv_halo=30.0)
+        blocks = _compose_view_blocks(60.0, 40.0, 20.0, 1.0, strips, n_steps=3)
+        g = _layout_geometry(
+            60.0,
+            40.0,
+            20.0,
+            1.0,
+            420.0,
+            page_h,
+            150.0,
+            strips,
+            n_steps=3,
+            warn_no_iso=False,
+        )
+
+        fv, pv = blocks["front"], blocks["plan"]
+        block_stack_h = fv.bottom + 2 * fv.hh + fv.top + pv.bottom + 2 * pv.hh + pv.top
+        expected_y_offset = max(0.0, (page_h - 2 * _MARGIN - block_stack_h) / 2)
+        actual_y_offset = g.FV_Y - _MARGIN - fv.bottom - fv.hh
+
+        assert pv.bottom > 20.0
+        assert actual_y_offset == pytest.approx(expected_y_offset)
+
+
 # ---------------------------------------------------------------------------
 # Phase 3 (#118): dynamic FV→SV corridor
 # ---------------------------------------------------------------------------
@@ -1463,6 +1630,77 @@ class TestComposeThenPackRepack:
         cands = _repack_candidates(a, 2.0, "A3")
         assert len(cands) == 1 and cands[0][0] == 2.0
 
+    def test_repack_to_fixed_point_iterates_until_stable(self, monkeypatch):
+        from types import SimpleNamespace
+
+        import draftwright.builder as builder
+
+        a0, d0 = SimpleNamespace(pass_id=0), SimpleNamespace(pass_id=0)
+        a1, d1 = SimpleNamespace(pass_id=1), SimpleNamespace(pass_id=1)
+        a2, d2 = SimpleNamespace(pass_id=2), SimpleNamespace(pass_id=2)
+        returns = [(a1, d1), (a2, d2), None]
+        calls = []
+
+        def fake_repack(a, dwg, *args, **kwargs):
+            calls.append((a.pass_id, dwg.pass_id))
+            return returns.pop(0)
+
+        monkeypatch.setattr(builder, "_repack", fake_repack)
+        monkeypatch.setattr(builder, "_needs_repack", lambda dwg, a: False)
+
+        out = builder._repack_to_fixed_point(a0, d0, "out", None, False)
+
+        assert out == (a2, d2)
+        assert calls == [(0, 0), (1, 1), (2, 2)]
+
+    def test_repack_to_fixed_point_warns_at_iteration_limit(self, monkeypatch, caplog):
+        from types import SimpleNamespace
+
+        import draftwright.builder as builder
+
+        calls = []
+
+        def fake_repack(a, dwg, *args, **kwargs):
+            calls.append((a.pass_id, dwg.pass_id))
+            pass_id = len(calls)
+            return SimpleNamespace(pass_id=pass_id), SimpleNamespace(pass_id=pass_id)
+
+        monkeypatch.setattr(builder, "_repack", fake_repack)
+        monkeypatch.setattr(builder, "_needs_repack", lambda dwg, a: True)
+
+        with caplog.at_level(logging.WARNING):
+            out_a, out_dwg = builder._repack_to_fixed_point(
+                SimpleNamespace(pass_id=0),
+                SimpleNamespace(pass_id=0),
+                "out",
+                None,
+                False,
+            )
+
+        assert len(calls) == builder._REPACK_MAX_ITER
+        assert out_a.pass_id == out_dwg.pass_id == builder._REPACK_MAX_ITER
+        assert "reached iteration limit" in caplog.text
+
+    def test_repack_to_fixed_point_warns_on_stalled_trigger(self, monkeypatch, caplog):
+        from types import SimpleNamespace
+
+        import draftwright.builder as builder
+
+        monkeypatch.setattr(builder, "_repack", lambda *args, **kwargs: None)
+        monkeypatch.setattr(builder, "_needs_repack", lambda dwg, a: True)
+
+        with caplog.at_level(logging.WARNING):
+            out = builder._repack_to_fixed_point(
+                SimpleNamespace(pass_id=0),
+                SimpleNamespace(pass_id=0),
+                "out",
+                None,
+                False,
+            )
+
+        assert out is None
+        assert "stalled after 0 iteration" in caplog.text
+
     @pytest.mark.timeout(120)
     def test_repack_honours_pinned_scale_on_oversized_part(self):
         # #350 review: when no candidate fits the measured layout, the repack backstop

{draftwright-0.2.12 → draftwright-0.2.13}/tests/test_tolerances.py

@@ -172,6 +172,22 @@ class TestSheetTolerance:
             self._steplen_tol(dwg, n) is None for n in dwg._named if n.startswith("m_steplen")
         )
 
+    def test_toleranced_hole_callout_participates_in_layout_sizing(self):
+        # #450: a Sheet-authored bore tolerance widens the HoleCallout. Layout
+        # sizing must reserve that declared footprint before the plan/side/iso
+        # blocks are placed; otherwise the real callout is later dropped from the
+        # iso-bounded plan strip even though a wider corridor would fit.
+        plate = Box(120, 90, 8)
+        part = plate - (Pos(0, 0, 4) * Cylinder(4, 8))
+
+        s = Sheet(part)
+        s.envelope(plate)
+        s.hole(diameter=8, at=(0, 0, 4), axis="z").tolerance(0.1)
+        dwg = s.build()
+
+        assert any(n.startswith("hc_plan") for n in dwg._named)
+        assert "callout_dropped" not in {i.code for i in dwg.lint()}
+
 
 class TestToleranceHandle:
     def test_hole_tolerance_survives_feature_replacement(self):