draftwright 0.3.2__tar.gz → 0.3.3__tar.gz

{draftwright-0.3.2 → draftwright-0.3.3}/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## v0.3.3 — 2026-07-18
+
+The **layout-quality release**: the occupancy model gets honest about ink shape,
+the last solver-invisible pass joins the corridor solve, and crossed labels shift
+themselves clear. Also completes the #635 consolidation epic (ADR 0005 fully
+executed; ADR 0009's no-invisible-occupant guarantee now holds by construction
+for every auto-pass).
+
+### Added
+
+- **Witness-crossing label shifts** (#690): a dimension label crossed by another
+  dimension's witness stroke now shifts along its own line to clear it — a
+  deterministic post-drain pass using the repair machinery (destination-aware,
+  axis-aligned only, pinned dims exempt).
+
+### Changed
+
+- **L-shaped occupancy** (#685): placement obstacles decompose into per-stroke
+  boxes + label box (helpers ≥0.14 `segments`) instead of one hull, with
+  preset-aware arrowhead pads. View-corner contention between perpendicular
+  strips disappears by construction (a plate-thickness dim returns to its
+  natural strip); packing tightens. The cleanliness ratchet mirrors the model —
+  only transverse stroke crossings are exempt, so parallel overprints and label
+  contacts are detected honestly (twelve hull-artifact allowlist entries burned
+  down; the legitimate shared-datum running-dimension pairs are documented).
+- **Height ladder joins the corridor solve** (#636): step heights + overall
+  height are corridor candidates (the leapfrog witness cursor survives as a
+  deterministic build-time chain; the overall height stacks outermost by
+  construction and packs tighter). An explicitly-requested crowded-step detail
+  view now *deliberately* demotes the overall-height dim when the sheet cannot
+  hold both (previously the carve dropped it silently); a Y-drilled hole's Z
+  location joins the front running ladder per the documented routing.
+- **One typed `BuildState`** (#639): the drawing's build context (analysis,
+  part model, lint geometry caches) consolidates into a single object filled at
+  one builder site, single-writer-guarded; the render passes make zero private
+  `Drawing` reads (fail-closed empty allowlist).
+
+### Fixed
+
+- A prismatic detail view no longer loses both the detail *and* the height dim
+  when space is tight (transactional demotion).
+- The GD&T alternate-strip fallback defers until every corridor has drained, so
+  it can never preempt a sibling strip's reserved corner.
+
 ## v0.3.2 — 2026-07-18
 
 The **performance release**: the #602 perf loop (six PRs) plus the

{draftwright-0.3.2 → draftwright-0.3.3}/PKG-INFO

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

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

{draftwright-0.3.2 → draftwright-0.3.3}/src/draftwright/annotations/_common.py

@@ -255,6 +255,52 @@ def clear_label_of_centerlines(label_bbox, centerlines, gap):
     return target_x - lmin_x
 
 
+def occupancy_boxes(o, stroke_pad=None):
+    """*o*'s occupancy as a list of AABBs — decomposed, not one hull (#685).
+
+    An annotation's rendered hull includes large EMPTY corner regions (a dimension's
+    ink is L-shaped: witness lines + a dim-line band), and helpers ≥0.14's honest
+    tight-span rendering made those hulls big enough to collide structurally at view
+    corners while the inks stay disjoint. For an annotation exposing ``.segments``
+    (helpers ≥0.14 reports the drawn line pieces: witness lines, shafts, box
+    strokes), return one box per stroke — inflated by ``_STROKE_PAD`` to cover line
+    width plus the arrowheads at stroke junctions — plus its ``label_bbox``.
+    Anything else (leaders, hatch, title block) keeps its single hull box.
+
+    Consumers treat the result exactly like a list of hull boxes; the
+    perpendicular-band filter in the carve then does the rest — a witness sliver
+    carves only its own sliver, and an out-of-band dim-line band stops blocking a
+    sibling strip's corner entirely.
+    """
+    segs = getattr(o, "segments", None)
+    if not segs:
+        b = _geom_box(o)
+        return [b] if b is not None else []
+    pad = _STROKE_PAD if stroke_pad is None else stroke_pad
+    out = []
+    for (x0, y0), (x1, y1) in segs:
+        out.append(
+            (
+                min(x0, x1) - pad,
+                min(y0, y1) - pad,
+                max(x0, x1) + pad,
+                max(y0, y1) + pad,
+            )
+        )
+    lb = getattr(o, "label_bbox", None)
+    if lb is not None:
+        out.append((lb[0], lb[1], lb[2], lb[3]))
+    return out
+
+
+# Fallback stroke inflation for decomposed occupancy: line_width/2 (~0.08) plus the
+# arrowhead half-width at stroke junctions at DEFAULT presets. Arrow geometry scales
+# with font_size (#688 review), so callers that know the draft derive the pad as
+# max(_STROKE_PAD, draft.arrow_length / 2) — arrow half-LENGTH bounds the head's
+# half-width (aspect < 1) AND its protrusion past an inside-arrow shaft trim (al/2).
+_STROKE_PAD = 1.2
+
+
 def strip_obstacles(dwg, view=None, *, crossable=()):
     """The COMPLETE occupancy for strip placement (ADR 0009): every placed
     annotation's full rendered footprint, optionally restricted to *view*, minus
@@ -284,6 +330,9 @@ def strip_obstacles(dwg, view=None, *, crossable=()):
 
     The occupancy source for the collect-then-solve carve — every migrated renderer's
     ``place_strip_candidates`` call wires this in (#321/#150/P3)."""
+    # Preset-aware stroke pad (#688 review): arrowheads scale with font_size.
+    al = getattr(getattr(dwg, "draft", None), "arrow_length", None)
+    pad = max(_STROKE_PAD, al / 2) if al else _STROKE_PAD
     boxes = []
     for name, o in dwg.iter_annotations():
         if view is not None:
@@ -292,9 +341,7 @@ def strip_obstacles(dwg, view=None, *, crossable=()):
                 continue  # owned by a different ortho view → its own (disjoint) block
         if type(o).__name__ in crossable:
             continue  # this consumer may cross it (centre lines/marks for a dim)
-        bb = _geom_box(o)
-        if bb is not None:
-            boxes.append(bb)
+        boxes.extend(occupancy_boxes(o, stroke_pad=pad))  # decomposed, not one hull (#685)
     return boxes
 
 

{draftwright-0.3.2 → draftwright-0.3.3}/src/draftwright/annotations/from_model.py

@@ -1846,46 +1846,40 @@ def _detect_step_repeat(step_zs, bb_min_z, bb_max_z, tol_frac=0.10):
 
 def render_height_ladder(dwg, model, a, *, ctx, include_overall: bool = True) -> int:
     """Front-view right ladder: prismatic step heights (from `StepLevelFeature`)
-    stacked inner→outer, then the overall height outermost — through `fv_zones.right`,
-    preserving the leapfrog witness cursor (#237). Replaces the engine's inline
-    `dim_step_*` + `dim_height`. A turned part has no `StepLevelFeature` (its steps are
-    the IR length chain); a Z-turned part suppresses the overall height (the chain
-    tiles it, ISO 129). Returns the count placed."""
+    stacked inner→outer, then the overall height outermost — registered as
+    :class:`CorridorCandidate`s in the shared ``(front, right)`` corridor (#636;
+    formerly the last solver-invisible `carve_free_position` auto-pass). The leapfrog
+    witness cursor (#237) survives as a *build-time chain*: candidates share a
+    ``solved`` position map, and each dim's witness anchors on its nearest already-
+    built predecessor's line (the view edge for the first) — build order follows the
+    candidate order, so the chain is deterministic. Prediction uses an analytical
+    footprint with the witness modelled from the view edge (a conservative
+    over-cover along the stack axis; the accept-time real-box validation trims any
+    drift). A turned part has no `StepLevelFeature`; a Z-turned part suppresses the
+    overall height (the chain tiles it, ISO 129). Returns the count REGISTERED."""
     draft = dwg.draft
     FX, FZ = a.proj.front_x, a.proj.front_z
-    right_ladder = FX(a.bb.max.X) + 2
-    n = 0
+    edge2 = FX(a.bb.max.X) + 2
+    zmin = FZ(a.bb.min.Z)
+    tier = draft.font_size + 2 * draft.pad_around_text
     step = next((f for f in model.features if f.kind == "step_level"), None)
     levels = list(step.levels) if step is not None else []
-    # Uniform staircase → one representative "N× rise" dim; else the per-step ladder
-    # (legibility-gated). Turned parts have no levels, so neither fires.
     rep = _detect_step_repeat(levels, a.bb.min.Z, a.bb.max.Z) if levels else None
+
+    # The chain, inner→outer: (name, page-z top, label, tier size, drop message).
+    chain: list = []
     if rep is not None:
         n_rep, rise = rep
         first = sorted(levels)[0]
-        perp = tuple(sorted((FZ(a.bb.min.Z), FZ(first))))
-        px = carve_free_position(dwg, a.fv_zones.right, "front", "x", _SLOT_DIM_STEP, perp)
-        if px is not None:
-            dwg.add(
-                _dim(
-                    (right_ladder, FZ(a.bb.min.Z), 0),
-                    (right_ladder, FZ(first), 0),
-                    "right",
-                    px - right_ladder,
-                    draft,
-                    label=f"{n_rep}× {_fmt(rise)}",
-                ),
+        chain.append(
+            (
                 "dim_step_typ",
-                view="front",
-            )
-            right_ladder = px
-            n += 1
-        else:
-            ctx.record_issue(
-                "error",
-                "placement_unsatisfiable",
+                FZ(first),
+                f"{n_rep}× {_fmt(rise)}",
+                _SLOT_DIM_STEP,
                 "representative step-height dimension dropped (front-view right strip full)",
             )
+        )
     elif levels:
         kept, n_close = _legible_steps(levels, a.bb.min.Z, a.SCALE)
         if n_close:
@@ -1896,77 +1890,96 @@ def render_height_ladder(dwg, model, a, *, ctx, include_overall: bool = True) ->
                 "(use a detail view)",
             )
             # First-class escalation alongside the lint code (ADR 0009 Amdt 1, #351
-            # PR-4b) — `_request_prismatic_detail` (sections.py) triggers the detail-view
-            # remedy on this instead of independently recomputing the same legibility
-            # gate, which previously could queue a spurious detail even when the uniform-
-            # staircase branch above already fully documented the part with one
-            # representative dim (a real bug this routing fixes as a side effect).
+            # PR-4b) — `_request_prismatic_detail` (sections.py) consumes this instead
+            # of recomputing the legibility gate.
             ctx.escalations.append(
                 Escalation(kind="step", view="front", feature=step, reason="illegible")
             )
         for col, z in enumerate(kept):
-            perp = tuple(sorted((FZ(a.bb.min.Z), FZ(z))))
-            px = carve_free_position(dwg, a.fv_zones.right, "front", "x", _SLOT_DIM_STEP, perp)
-            if px is None:
-                ctx.record_issue(
-                    "error",
-                    "placement_unsatisfiable",
-                    f"{len(kept) - col} step-height dimension(s) dropped "
-                    "(front-view right strip full)",
+            chain.append(
+                (
+                    f"dim_step_{col}",
+                    FZ(z),
+                    _fmt(z - a.bb.min.Z),
+                    _SLOT_DIM_STEP,
+                    "step-height dimension dropped (front-view right strip full)",
                 )
-                break
-            dwg.add(
-                _dim(
-                    (right_ladder, FZ(a.bb.min.Z), 0),
-                    (right_ladder, FZ(z), 0),
-                    "right",
-                    px - right_ladder,
-                    draft,
-                    label=_fmt(z - a.bb.min.Z),
-                ),
-                f"dim_step_{col}",
-                view="front",
             )
-            right_ladder = px
-            n += 1
 
-    # Overall height — placed last so it sits OUTERMOST; suppressed for a Z-turned
-    # part (its IR step-length chain already tiles the full height, ISO 129) and for
-    # an X/Y rotational body (its Z extent IS the OD, dimensioned by render_rotational
-    # — #222).
     rot = next((f for f in model.features if f.kind == "rotational"), None)
     od_is_height = rot is not None and rot.frame.axis in ("x", "y")
     suppress_height = (not include_overall) or model.orientation == "z" or od_is_height
-    px = (
-        None
-        if suppress_height
-        else carve_free_position(
-            dwg,
+    if not suppress_height:
+        chain.append(
+            (
+                "dim_height",
+                FZ(a.bb.max.Z),
+                _fmt(a.z_size),
+                _SLOT_DIM_HEIGHT,
+                "overall height dimension dropped (front-view right strip full)",
+            )
+        )
+
+    names = [c[0] for c in chain]
+    solved: dict[str, float] = {}
+    for k, (name, ztop, label, _tsize, drop_msg) in enumerate(chain):
+
+        def _build(pos, name=name, ztop=ztop, label=label, k=k):
+            base = edge2
+            for pn in reversed(names[:k]):  # nearest already-built predecessor's line
+                if pn in solved:
+                    base = solved[pn]
+                    break
+            solved[name] = pos
+            return _dim((base, zmin, 0), (base, ztop, 0), "right", pos - base, draft, label=label)
+
+        def _foot(pos, ztop=ztop, label=label, k=k):
+            # Predecessor-aware prediction (#689 review): the conservative
+            # edge-anchored witness can falsely exhaust the strip when an inner
+            # obstacle sits in the already-traversed region. Use the same solved
+            # map the build chain uses — empty on the first evaluation (edge-based,
+            # the prior behaviour), tight on later-segment retries.
+            base = edge2
+            for pn in reversed(names[:k]):
+                if pn in solved:
+                    base = solved[pn]
+                    break
+            if pos - base < 0.5:  # degenerate guard: never model a zero-length offset
+                base = edge2
+            return dim_footprint(
+                (base, zmin, 0), (base, ztop, 0), "right", pos - base, draft, label
+            )
+
+        def _drop(nm, drop_msg=drop_msg, name=name):
+            solved.pop(name, None)
+            ctx.record_issue("error", "placement_unsatisfiable", drop_msg)
+
+        register_corridor(
+            ctx,
+            ("front", "right"),
             a.fv_zones.right,
             "front",
             "x",
-            _SLOT_DIM_HEIGHT,
-            tuple(sorted((FZ(a.bb.min.Z), FZ(a.bb.max.Z)))),
-            outermost=True,
-        )
-    )
-    if px is not None:
-        dwg.add(
-            _dim(
-                (right_ladder, FZ(a.bb.min.Z), 0),
-                (right_ladder, FZ(a.bb.max.Z), 0),
-                "right",
-                px - right_ladder,
-                draft,
-                label=_fmt(a.z_size),
+            tier,
+            CorridorCandidate(
+                name=name,
+                build=_build,
+                # Steps stack inner→outer in chain order; the overall height rides the
+                # OVERALL subchain so it lands outermost by construction (as the
+                # envelope dims do), replacing the old carve's outermost=True.
+                order=(
+                    (_OVERALL_SUBCHAIN, 0, name)
+                    if name == "dim_height"
+                    else (_SIZE_SUBCHAIN, k, name)
+                ),
+                on_place=lambda nm: None,
+                on_drop=_drop,
+                force=True,  # principal dims: only a physically full strip drops them
+                feature=step if name != "dim_height" else None,
+                footprint=_foot,
             ),
-            "dim_height",
-            view="front",
         )
-        n += 1
-    elif not suppress_height:
-        _log.warning("dim_height skipped: fv_zones.right strip full")
-    return n
+    return len(chain)
 
 
 def render_step_positions(dwg, model, a, *, ctx) -> int:
@@ -2868,29 +2881,44 @@ def render_gdt(dwg, model, a, *, ctx) -> int:
         ):
             # Fallthrough (#481): the declared/derived side is full — try the OPPOSITE side of
             # the same view before dropping, so a congested default still places somewhere
-            # legible rather than vanishing. Best-effort (mirrors render_slots' below-fallthrough):
-            # carve a free tier on the alternate strip and place there; carve_free_position only
-            # ever sees already-placed annotations, so it can't collide with a not-yet-drained
-            # sibling corridor. Force semantics (no corridor-cross check) match the primary path,
-            # BUT reject a spot over the (not-yet-placed) title block — a below/right strip runs
-            # into it, and carve can't see it (#481 review).
-            alt = {"above": "below", "below": "above", "left": "right", "right": "left"}[_s]
-            alt_strip = getattr(_zones, alt, None)
-            if alt_strip is not None:
-                axis2 = "y" if alt in ("above", "below") else "x"
-                extent = _sz[1] if axis2 == "y" else _sz[0]  # the glyph's stacking-axis size
-                perp = (_px, _px + _sz[0]) if _hz else (_py - _sz[1] / 2, _py + _sz[1] / 2)
-                pos = carve_free_position(dwg, alt_strip, _v, axis2, max(tier, extent), perp)
-                if pos is not None:
-                    dim = _bld(pos)
-                    if not _box_hits(_anno_box(dim), (_tb,)):  # clear of the title block
-                        dwg.add(dim, nm, view=_v, feature=_feat)  # placed on the alternate side
-                        return
-            ctx.record_issue(
-                "warning",
-                "gdt_dropped",
-                f"{nm} not placed (no room in the {_v} {_s} strip or its opposite)",
-            )
+            # legible rather than vanishing. DEFERRED via ctx.post_drain (#636, the plate
+            # pattern): the carve then runs after EVERY corridor has drained, so it cannot
+            # preempt a corner a later sibling's force candidate needs. Force semantics
+            # (no corridor-cross check) match the primary path, BUT reject a spot over the
+            # (not-yet-placed) title block — a below/right strip runs into it, and the
+            # carve can't see it (#481 review).
+            def _retry(
+                nm=nm,
+                _v=_v,
+                _s=_s,
+                _zones=_zones,
+                _px=_px,
+                _py=_py,
+                _hz=_hz,
+                _sz=_sz,
+                _bld=_bld,
+                _feat=_feat,
+                _tb=_tb,
+            ):
+                alt = {"above": "below", "below": "above", "left": "right", "right": "left"}[_s]
+                alt_strip = getattr(_zones, alt, None)
+                if alt_strip is not None:
+                    axis2 = "y" if alt in ("above", "below") else "x"
+                    extent = _sz[1] if axis2 == "y" else _sz[0]  # the glyph's stacking-axis size
+                    perp = (_px, _px + _sz[0]) if _hz else (_py - _sz[1] / 2, _py + _sz[1] / 2)
+                    pos = carve_free_position(dwg, alt_strip, _v, axis2, max(tier, extent), perp)
+                    if pos is not None:
+                        dim = _bld(pos)
+                        if not _box_hits(_anno_box(dim), (_tb,)):  # clear of the title block
+                            dwg.add(dim, nm, view=_v, feature=_feat)  # alternate side
+                            return
+                ctx.record_issue(
+                    "warning",
+                    "gdt_dropped",
+                    f"{nm} not placed (no room in the {_v} {_s} strip or its opposite)",
+                )
+
+            ctx.post_drain.append(_retry)
 
         register_corridor(
             ctx,

{draftwright-0.3.2 → draftwright-0.3.3}/src/draftwright/annotations/orchestrator.py

@@ -72,6 +72,7 @@ from draftwright.model import (
     plan_dimensions,
     plan_sections,
 )
+from draftwright.repair import reconcile_witness_labels
 
 
 def _wrap_rows(header, data, ncols):
@@ -356,6 +357,11 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     # (ADR 0009 end state, #345/#346/#393) — dedup coincident spans, order the ladder —
     # BEFORE the section/detail views so they see the placed ladder as an obstacle.
     drain_corridors(ctx, dwg)
+    # (#690) Witness-crossing label reconciliation — after every corridor (and its
+    # deferred fallthroughs) has placed: shift any dim label a FOREIGN transverse
+    # stroke crosses, along its own line, via the repair machinery. Deterministic,
+    # runs in both build paths.
+    reconcile_witness_labels(dwg)
 
     # Turned/circlip-groove callouts (#148c): {width} WIDE × ø{dia} via a leader off each
     # groove. A groove is a secondary leader-callout on a turned shaft — exactly where the

{draftwright-0.3.2 → draftwright-0.3.3}/src/draftwright/annotations/sections.py

@@ -562,7 +562,26 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
             _log.info("detail request '%s' dropped: detail letters A–H exhausted", req.kind)
             continue
         letter = _DETAIL_LETTERS[n_placed]
-        if _render_detail(dwg, a, req, f"detail_{letter.lower()}", letter):
+        placed = _render_detail(dwg, a, req, f"detail_{letter.lower()}", letter)
+        if not placed and req.kind == "prismatic-steps" and "dim_height" in dwg.annotations():
+            # (#636) The user's explicit detail request outranks the overall-height
+            # dim: pre-migration, the solver-invisible carve silently dropped
+            # dim_height on exactly these crowded parts, and the detail took that
+            # room. The corridor solve now places dim_height when it fits — so on a
+            # no-room prismatic detail, demote it DELIBERATELY (same outcome, now
+            # explicit and logged) and retry the detail once.
+            hview = dwg.view_of("dim_height")
+            hobj = dwg.remove("dim_height")
+            placed = _render_detail(dwg, a, req, f"detail_{letter.lower()}", letter)
+            if placed:
+                _log.warning(
+                    "dim_height demoted: the requested crowded-step detail view takes its room"
+                )
+            else:
+                # Transactional (#689 review): the detail may fail for reasons other
+                # than dim_height's room — restore it rather than losing BOTH.
+                dwg.add(hobj, "dim_height", view=hview)
+        if placed:
             n_placed += 1
 
 

{draftwright-0.3.2 → draftwright-0.3.3}/src/draftwright/builder.py

@@ -265,14 +265,13 @@ def _assemble(a, out, assembly, detail_view, auto_dims, model=None, decorations=
         cyls=a.cyls,
         assembly=assembly,
     )
-    dwg._analysis = a  # expose analysis namespace for testing and future strip access
     # Detect the IR here — before the auto_dims gate — so dwg.model() and feature edits
     # work even in manual mode (#398). _auto_annotate reads this attached model rather
     # than rebuilding. On a repack this runs again on the pass-2 drawing (freshness).
     # Detected path: reuse the model _analyse already built for sizing (#584 WP1 A) —
     # detectors run once per build (ADR 0008 Amdt 5, #602). build_model(a) remains the
     # fallback for a manually-constructed Analysis with no stored model.
-    dwg._part_model = (
+    pm = (
         _coerce_model(model, a.part, decorations)
         if model is not None
         else (a.model if a.model is not None else build_model(a))
@@ -283,23 +282,25 @@ def _assemble(a, out, assembly, detail_view, auto_dims, model=None, decorations=
         # (rot furniture). Synthesise it from the (unconditional) analysis so a declared /
         # emitted-script turned part reproduces the detected drawing (#472). Gated on the
         # caller not having declared one, so an explicit choice wins.
-        pm = dwg._part_model
         if not any(f.kind == "rotational" for f in pm.features):
             rot = build_rotational_feature(a)
             if rot is not None:
-                dwg._part_model = replace(pm, features=[*pm.features, rot])
+                pm = replace(pm, features=[*pm.features, rot])
         # PMI (STEP AP242) is likewise detection-sourced, so a declared / emitted-script model
         # carries none. When PMI annotation is on, synthesise the same imported drafting
         # annotations detection would (render_pmi reads them off the model, gated on a.pmi_mode)
         # so a re-run reproduces the PMI dims (#472). Gated on the caller not having declared
         # imported authored annotations, so an explicit set wins.
-        pm = dwg._part_model
         if a.pmi_mode == "annotate" and not any(
             f.kind in ("authored_dimension", "pmi") for f in pm.features
         ):
             pmi_feats = build_pmi_features(a.pmi, a.part.bounding_box())
             if pmi_feats:
-                dwg._part_model = replace(pm, features=[*pm.features, *pmi_feats])
+                pm = replace(pm, features=[*pm.features, *pmi_feats])
+    # ADR 0005 §2 (#639): the ONE build-context attachment — analysis + finished model
+    # in a single typed BuildState; the compat properties on Drawing read through it.
+    dwg._build.analysis = a
+    dwg._build.part_model = pm
     dwg._model_declared = model is not None  # ADR 0011 #448: gate model-driven hole render
 
     part_s = a.part.scale(a.SCALE)