draftwright 0.2.8__tar.gz → 0.2.9__tar.gz

{draftwright-0.2.8 → draftwright-0.2.9}/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## v0.2.9 — 2026-07-06
+
+**Declarative GD&T, datums, and surface finish (ADR 0011 Phase 2b/2c).** The `Sheet` DSL can
+now author the drawing information geometry can't carry — geometric tolerances, datum feature
+symbols, and surface-finish marks — by pointing at a build123d feature or face. They render
+through the auto-layout engine as first-class ADR 0009 corridor candidates, placed and spaced
+crossing-free alongside the automatic dimensions (not a post-hoc overlay).
+
+```python
+sheet.datum("A", base_face)
+sheet.control(bore).position(0.1, to="A", diameter=True).perpendicularity(0.05, to="A")
+sheet.diameter(journal).finish("0.8")
+```
+
+### Added
+
+- **Feature control frames (ISO 1101)** — `sheet.control(ref)` returns a chainable builder with
+  one method per **all 14** characteristics (`position`, `flatness`, `perpendicularity`,
+  `cylindricity`, `circular_runout`, `total_runout`, …); `to=` names the referenced datum(s),
+  `diameter=` prefixes the ⌀ tolerance zone, `modifier=` adds a material-condition symbol (Ⓜ/Ⓛ/Ⓟ).
+- **Datum feature symbols (ISO 5459)** — `sheet.datum("A", face_or_feature)`.
+- **Surface finish (ISO 1302, Ra)** — `.finish("1.6")` on a hole / diameter / step handle, or
+  `sheet.finish(ra, face)`.
+- The target view + strip side are **derived from the referenced geometry** (a feature's axis →
+  face-on view, a planar face's normal → edge-on view); `view=`/`side=` override.
+- Render core: `ControlFrame` / `DatumRef` / `Finish` IR features placed by `render_gdt` as
+  first-class corridor candidates, with the real-footprint plumbing needed to space wide frames.
+
+### Fixed
+
+- A control frame referencing an **undeclared datum letter** now warns at build.
+- GD&T placement is **title-block aware** and **falls through to the opposite strip side** before
+  dropping a frame, so stacked control frames place robustly rather than vanishing or overlapping
+  the title block.
+- An invalid glyph spec / degenerate leader in a caller-supplied model **drops the one item with a
+  warning** instead of crashing the whole build (the IR is public input).
+- Turned-shaft rotational furniture now reproduces correctly through the declared-model path
+  (`model=` / `Sheet`) (#476).
+
 ## v0.2.8 — 2026-07-06
 
 **`--script` now defaults to the declarative `Sheet` DSL.** The editable script the CLI

{draftwright-0.2.8 → draftwright-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.8
+Version: 0.2.9
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -769,6 +769,36 @@ issues = dwg.lint()                       # list[LintIssue] — coverage, page b
 svg_path, dxf_path = dwg.export("my_part")
 ```
 
+### Declarative drawings — reference features, declare intent
+
+Instead of relying on detection, **reference the build123d objects you built** and declare
+only the drawing intent — geometry supplies the sizes (⌀ read off the object), you supply
+tolerances, fits, datums, GD&T, and surface finish. The fluent `Sheet` skips detection and
+dimensions exactly what you declare (ADR 0011):
+
+```python
+from build123d import Box, Cylinder, Pos
+from draftwright import Sheet
+
+plate = Box(120, 80, 20)
+bore = Pos(0, 0, 0) * Cylinder(4, 20)
+
+sheet = Sheet(plate - bore, title="Plate", number="DWG-002")
+sheet.envelope()
+sheet.datum("A", plate.faces().sort_by()[-1])             # datum A on the top face
+hole = sheet.hole(bore).finish("1.6")                     # ⌀8 bore, Ra 1.6
+sheet.control(hole).position(0.1, to="A", diameter=True)  # ⌀0.1 position wrt A
+sheet.export("plate")                                     # writes plate.svg + plate.dxf
+```
+
+Every aspect the geometry can't carry is a declared verb: `.tolerance(±)` / `.fit("H7")`
+(ISO 286), `.finish("Ra")` (ISO 1302), `sheet.datum(letter, ref)` (ISO 5459), and
+`sheet.control(ref)` with all 14 ISO 1101 characteristics
+(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…). A feature verb returns
+a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs decorate;
+targets are placed automatically — the view and strip are derived from the referenced
+feature or face, with `view=`/`side=` overrides.
+
 ## What it produces
 
 - **Three orthographic views** (front, plan, side) sized and scaled automatically to the

{draftwright-0.2.8 → draftwright-0.2.9}/README.md

@@ -75,6 +75,36 @@ issues = dwg.lint()                       # list[LintIssue] — coverage, page b
 svg_path, dxf_path = dwg.export("my_part")
 ```
 
+### Declarative drawings — reference features, declare intent
+
+Instead of relying on detection, **reference the build123d objects you built** and declare
+only the drawing intent — geometry supplies the sizes (⌀ read off the object), you supply
+tolerances, fits, datums, GD&T, and surface finish. The fluent `Sheet` skips detection and
+dimensions exactly what you declare (ADR 0011):
+
+```python
+from build123d import Box, Cylinder, Pos
+from draftwright import Sheet
+
+plate = Box(120, 80, 20)
+bore = Pos(0, 0, 0) * Cylinder(4, 20)
+
+sheet = Sheet(plate - bore, title="Plate", number="DWG-002")
+sheet.envelope()
+sheet.datum("A", plate.faces().sort_by()[-1])             # datum A on the top face
+hole = sheet.hole(bore).finish("1.6")                     # ⌀8 bore, Ra 1.6
+sheet.control(hole).position(0.1, to="A", diameter=True)  # ⌀0.1 position wrt A
+sheet.export("plate")                                     # writes plate.svg + plate.dxf
+```
+
+Every aspect the geometry can't carry is a declared verb: `.tolerance(±)` / `.fit("H7")`
+(ISO 286), `.finish("Ra")` (ISO 1302), `sheet.datum(letter, ref)` (ISO 5459), and
+`sheet.control(ref)` with all 14 ISO 1101 characteristics
+(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…). A feature verb returns
+a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs decorate;
+targets are placed automatically — the view and strip are derived from the referenced
+feature or face, with `view=`/`side=` overrides.
+
 ## What it produces
 
 - **Three orthographic views** (front, plan, side) sized and scaled automatically to the

{draftwright-0.2.8 → draftwright-0.2.9}/pyproject.toml

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

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/_core.py

@@ -557,8 +557,11 @@ def _attribution_author(drawn_by: str | None) -> str:
     return f"{author} / draftwright" if author else "draftwright"
 
 
-def _add_title_block(dwg, a: Analysis):
-    """Add the title block annotation."""
+def _make_title_block(dwg, a: Analysis):
+    """Construct + page-locate the title block, returning ``(tb, cell)`` where *cell* is its
+    drawn-by cell bbox (for the hyperlink rect). Shared by :func:`_add_title_block` (which adds
+    it, last) and :func:`_title_block_box` (which measures its footprint for GD&T avoidance, #481)
+    so the two never drift."""
     tb = TitleBlock(
         a.title,
         a.number,
@@ -582,6 +585,20 @@ def _add_title_block(dwg, a: Analysis):
     # TitleBlock layout change. Build-frame bbox; translated to page space below.
     cell = tb.drawn_by_cell_bbox()
     tb = tb.locate(Location((a.PAGE_W - a.TB_W - _TB_CLEAR, _TB_CLEAR, 0)))
+    return tb, cell
+
+
+def _title_block_box(dwg, a: Analysis):
+    """The title block's real page-space bbox ``(x0, y0, x1, y1)``. GD&T placement avoids it
+    (#481): the block is added last, so strip placement can't see it, but it's deterministic."""
+    tb, _ = _make_title_block(dwg, a)
+    b = tb.bounding_box()
+    return (b.min.X, b.min.Y, b.max.X, b.max.Y)
+
+
+def _add_title_block(dwg, a: Analysis):
+    """Add the title block annotation."""
+    tb, cell = _make_title_block(dwg, a)
     dwg.add(tb, "title_block")
 
     # Record that cell's page-space rectangle so export() can place a clickable

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/annotate.py

@@ -11,4 +11,5 @@ from draftwright.annotations.orchestrator import (  # noqa: F401
     _auto_annotate,
     _wrap_rows,
     build_model,
+    build_rotational_feature,
 )

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/annotations/_common.py

@@ -305,6 +305,16 @@ class CorridorCandidate:
     # The source IR feature this dim was rendered for — recorded as provenance when the
     # dim is placed at drain (ADR 0010). ``None`` leaves the annotation feature-less.
     feature: object | None = None
+    # Real stacking-axis + perpendicular footprint ``(w, h)`` in page-mm, or ``None`` to
+    # use the dimension default ``(tier, tier)``. Wide/tall occupants (a GD&T feature
+    # control frame is ~24×6 mm) set this so the strip solve reserves their true extent
+    # instead of one label-height (ADR 0009 real-footprint plumbing, #61). A dim leaves
+    # it ``None`` — byte-identical to the pre-plumbing placement.
+    size: tuple | None = None
+    # An ``(x0, y0, x1, y1)`` page-box this candidate must NOT overlap even when force-kept —
+    # the title block, which is placed after the corridor drain so the strip carve can't see
+    # it (#481). ``None`` (every dim) skips the check → byte-identical.
+    forbid: object | None = None
 
 
 def solve_corridor(dwg, strip, view, axis, cands, tier):
@@ -357,15 +367,29 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
         return
     pairs = [(c.name, c.build) for c in kept]
     feats = {c.name: c.feature for c in kept if c.feature is not None}  # provenance (ADR 0010)
+    sizes = {c.name: c.size for c in kept if c.size is not None}  # real footprint (#61)
+    forbid = {c.name: c.forbid for c in kept if c.forbid is not None}  # title-block box (#481)
     left = {
-        n for n, _ in place_strip_candidates(dwg, strip, view, axis, pairs, tier, features=feats)
+        n
+        for n, _ in place_strip_candidates(
+            dwg, strip, view, axis, pairs, tier, features=feats, sizes=sizes, forbid=forbid
+        )
     }
     force_pairs = [(c.name, c.build) for c in kept if c.name in left and c.force]
     still = (
         {
             n
             for n, _ in place_strip_candidates(
-                dwg, strip, view, axis, force_pairs, tier, force=True, features=feats
+                dwg,
+                strip,
+                view,
+                axis,
+                force_pairs,
+                tier,
+                force=True,
+                features=feats,
+                sizes=sizes,
+                forbid=forbid,
             )
         }
         if force_pairs
@@ -399,7 +423,9 @@ def drain_corridors(dwg):
     dwg._corridor_batch = {}
 
 
-def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False, features=None):
+def place_strip_candidates(
+    dwg, strip, view, axis, cands, tier, *, force=False, features=None, sizes=None, forbid=None
+):
     """Collect-then-solve placement of location/feature dims on one strip (ADR 0009).
     The single shared strip placer that retires the ``Strip.allocate`` cursor (#150,
     P3): each candidate in *cands* — an ``(name, build(pos)->dim)`` pair — is spaced by
@@ -418,6 +444,12 @@ def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False,
     1-D strip carve cannot represent: a leader in that corridor is crossed no matter how
     far out the dim line lands. By default such a placement is rejected so the caller can
     route the dim to the other view (its disjoint block cannot cross this leader).
+
+    *sizes* maps a candidate's name to its real page-mm footprint ``(w, h)``; absent
+    names use the dimension default ``(tier, tier)``. A wide/tall occupant (a GD&T
+    frame, #61) sets it so :func:`plan_strip` enforces its true stacking gap — over
+    capacity it is relocated to the next segment or dropped, never overlapped.
+
     ``force=True`` skips that corridor check — the caller's last resort when no view took
     the dim cleanly: keep it on its natural view and accept the (same-feature) leader
     crossing rather than drop a real dimension (policy B). Candidates that find no strip
@@ -426,17 +458,31 @@ def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False,
     if strip is None or not cands:
         return list(cands)
     lo, hi, inner = strip_free_span(strip)
-    # Reserve the outermost label's height at the strip boundary. plan_strip bounds the
-    # dim-LINE position, but the label extends `tier` OUTWARD from it — so without this
-    # the last tier's label overshoots outer_limit (into the iso view / page margin),
-    # unlike the old Strip.allocate which checked `start + tier <= outer_limit` (#338
-    # review). The strip edge is not an obstacle (obstacles carry their own footprint +
-    # pad), so only the boundary needs it; obstacle-bounded segments are unaffected.
+    idx = 1 if axis == "y" else 0
+
+    # Reserve the outermost label's OUTWARD extent at the strip boundary. plan_strip bounds
+    # the dim-LINE position, but the label extends outward from it — so without this the last
+    # tier's label overshoots outer_limit (into the iso view / page margin), unlike the old
+    # Strip.allocate which checked `start + tier <= outer_limit` (#338 review). A plain dim's
+    # label extends one `tier` outward (one-sided). A GD&T glyph (#61) hangs off a Leader that
+    # CENTRES it on the elbow for an above/below strip (real outward extent = height/2) but
+    # places it one-sided for a left/right strip (extent = full width). Reserve the MAX real
+    # outward extent among these candidates — else a glyph wider than `tier` renders off the
+    # sheet (annotation_out_of_bounds) instead of dropping when the strip is too narrow (ADR
+    # 0009 Amdt 7 fixed inter-candidate gaps but not this edge). With no `sizes` (every dim)
+    # this is `tier`, byte-identical. The strip edge is not an obstacle (obstacles carry their
+    # own footprint + pad), so only the boundary needs it.
+    def _outward(name):
+        sz = (sizes or {}).get(name)
+        if sz is None:
+            return tier  # a dim: one-sided tier reservation (unchanged)
+        return sz[idx] if axis == "x" else sz[idx] / 2  # GD&T: one-sided (L/R) vs centred (A/B)
+
+    reserve = max([tier, *(_outward(n) for n, _ in cands)])
     if inner == lo:
-        hi -= tier
+        hi -= reserve
     else:
-        lo += tier
-    idx = 1 if axis == "y" else 0
+        lo += reserve
     perp = 0 if axis == "y" else 1  # the axis the dims do NOT stack along
     pad = tier + strip.spacing  # min separation between stacked dim lines
     # Perpendicular band of these candidates. The 1-D carve projects obstacles onto the
@@ -471,7 +517,9 @@ def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False,
         triples = [
             (
                 StripCandidate(
-                    f"{(k if inner == lo else len(take) - 1 - k):04d}", anch, (tier, tier)
+                    f"{(k if inner == lo else len(take) - 1 - k):04d}",
+                    anch,
+                    (sizes or {}).get(nb[0], (tier, tier)),
                 ),
                 nb,
             )
@@ -487,6 +535,14 @@ def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False,
             if not force and _box_hits(_geom_box(dim), blockers):  # corridor crosses a leader
                 todo.append((name, build))
                 continue
+            # A forbidden box (the title block, #481) is rejected even under force — it is
+            # placed after the drain, so the strip carve can't see it; a force-kept GD&T frame
+            # must still not stack onto it. `forbid` maps names to their box (only GD&T sets it,
+            # so dims are byte-identical). Returned unplaced → the caller's on_drop fallthrough.
+            fb = (forbid or {}).get(name)
+            if fb is not None and _box_hits(_geom_box(dim), (fb,)):
+                todo.append((name, build))
+                continue
             # Record feature provenance (ADR 0010): the drain-time seam for corridor-placed
             # dims — `features` maps this batch's names to their source IR feature.
             dwg.add(dim, name, view=view, feature=(features or {}).get(name))

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/annotations/from_model.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import math
 
+from build123d_drafting import DatumFeature, FeatureControlFrame, SurfaceFinish
 from build123d_drafting.helpers import Centerline, CenterMark, HoleCallout, Leader, TitleBlock
 
 from draftwright._core import (
@@ -41,6 +42,7 @@ from draftwright._core import (
     _legible_steps,
     _log,
     _solve_strip_ys,
+    _title_block_box,
     _tol_suffix,
 )
 from draftwright.annotations._common import (
@@ -1775,3 +1777,182 @@ def render_pmi(dwg, model, a) -> int:
 
     _log.info("PMI annotate: %d/%d dims placed", emitted, len(usable))
     return emitted
+
+
+# GD&T aspect side-layer (ADR 0011 §4, #61) — declared feature control frames / datum
+# feature symbols / surface finishes. Placed as first-class ADR 0009 corridor candidates,
+# NOT through the dimension planner (their IR items carry no DimParameters).
+_GDT_KINDS = ("control_frame", "datum_ref", "finish")
+# Outer run of the shared corridor ladder: GD&T frames tier BEYOND the feature-size
+# (_SIZE_SUBCHAIN=0) and datum-location (_LOC_SUBCHAIN=1) dim runs, so a frame never lands
+# mid-ladder among the dimensions it annotates.
+_GDT_SUBCHAIN = 2
+# Minimum GD&T leader shaft length (page-mm). A zero-length Leader (site == solved tier)
+# makes OCC's edge builder raise; nudging to this keeps `_build` total (#61 review).
+_MIN_LEADER = 0.05
+
+
+def _gdt_glyph(item, draft):
+    """Build the ISO 1101/5459/1302 glyph sketch for one GD&T IR item at the origin
+    (the :class:`Leader` repositions it). A fresh sketch per call — the leader translate
+    must not alias a shared object across the strip solve's repeated probe builds."""
+    if item.kind == "control_frame":
+        return FeatureControlFrame(
+            item.characteristic,
+            item.tolerance,
+            datums=item.datums,
+            draft=draft,
+            diameter=item.diameter,
+            modifier=item.modifier,
+        )
+    if item.kind == "datum_ref":
+        return DatumFeature(item.letter, draft=draft)
+    return SurfaceFinish(item.ra, position=(0.0, 0.0), draft=draft)
+
+
+def render_gdt(dwg, model, a) -> int:
+    """Place declared GD&T frames / datum symbols / surface finishes (#61) as first-class
+    ADR 0009 corridor candidates — registered into the SAME strip the feature's dimensions
+    use, BEFORE ``drain_corridors``, so one solve orders and spaces them crossing-free with
+    the dims (not a leftover first-fit like :func:`render_pmi`). Each item carries its target
+    ``(view, side)`` strip + model-space site; the leader hangs the glyph off the site into
+    that strip. The strip footprint is the GLYPH's own box — NOT the leader+glyph box, whose
+    shaft back to the feature would inflate the stacking extent (the same reason dims reserve
+    one label-height). Cross-view separation is the compose-then-pack repack's job (ADR 0004):
+    every placed frame is ``view=``-tagged, so ``_measure_blocks`` folds it into the block.
+    Returns the count registered."""
+    items = [f for f in model.features if f.kind in _GDT_KINDS]
+    if not items:
+        return 0
+    draft = dwg.draft
+    tier = draft.font_size + 2 * draft.pad_around_text
+    # (zones, h-projector, v-projector, h-model-index, v-model-index) per view.
+    views = {
+        "plan": (a.pv_zones, a.proj.plan_x, a.proj.plan_y, 0, 1),
+        "front": (a.fv_zones, a.proj.front_x, a.proj.front_z, 0, 2),
+        "side": (a.sv_zones, a.proj.side_x, a.proj.side_z, 1, 2),
+    }
+    # The title block (bottom-right) is added AFTER drain_corridors, so strip placement can't
+    # see it — a below/right strip runs down into its region. Its box is deterministic, so
+    # reject any GD&T placement that would land on it (BOTH the primary corridor path, via the
+    # candidate's `forbid`, AND the fallthrough) else the frame overlaps 'DRAWING' (#481 review).
+    tb_box = _title_block_box(dwg, a)
+    n = 0
+    for i, item in enumerate(items):
+        name = f"m_gdt{i}"
+        vk = views.get(item.view)
+        if vk is None or item.side not in ("above", "below", "left", "right"):
+            dwg._record_build_issue(
+                "warning", "gdt_dropped", f"{name}: bad target {item.view!r}/{item.side!r}"
+            )
+            continue
+        zones, hproj, vproj, hi, vi = vk
+        strip = getattr(zones, item.side)
+        o = item.frame.origin
+        px, py = hproj(o[hi]), vproj(o[vi])
+        horizontal = item.side in ("above", "below")  # frame stacks along y
+        axis = "y" if horizontal else "x"
+        # The IR is public input (ADR 0011), so an invalid glyph spec (a mistyped
+        # characteristic, a bad tolerance) must drop THIS item with a warning — never crash
+        # the whole drawing build. The helper raises on a bad spec; catch it at the measure
+        # (the first build) and drop. `_build` below re-runs `_gdt_glyph` with the same args
+        # (so a spec error can't reappear there) AND is made total against the OTHER raise
+        # source — a zero-length Leader shaft (see the min-leader guard in `_build`).
+        try:
+            gb = _gdt_glyph(item, draft).bounding_box().size
+        except Exception as e:  # noqa: BLE001 — any glyph-spec error drops one item, not the build
+            dwg._record_build_issue(
+                "warning", "gdt_dropped", f"{name}: cannot render ({type(e).__name__}: {e})"
+            )
+            continue
+        size = (gb.X, gb.Y)
+
+        def _build(pos, _px=px, _py=py, _hz=horizontal, _it=item):
+            g = _gdt_glyph(_it, draft)
+            tip = (_px, _py)
+            # A zero-length leader shaft (the projected site coincides with the solved tier —
+            # `pos == py` above/below, `pos == px` left/right) makes OCC's edge builder raise,
+            # which would crash the whole build on a public-IR declaration. Guarantee a
+            # minimum shaft along the stacking axis (nudge outward; 0.05 mm is invisible) so
+            # `_build` is total — the drop-don't-crash invariant holds for every build() call.
+            if _hz:
+                dy = pos - _py
+                pos = (
+                    pos if abs(dy) >= _MIN_LEADER else _py + math.copysign(_MIN_LEADER, dy or 1.0)
+                )
+                elbow = (_px, pos)
+            else:
+                dx = pos - _px
+                pos = (
+                    pos if abs(dx) >= _MIN_LEADER else _px + math.copysign(_MIN_LEADER, dx or 1.0)
+                )
+                elbow = (pos, _py)
+            return Leader(tip=tip, elbow=elbow, label="", draft=draft, callout=g)
+
+        def _drop(
+            nm,
+            _v=item.view,
+            _s=item.side,
+            _zones=zones,
+            _px=px,
+            _py=py,
+            _hz=horizontal,
+            _sz=size,
+            _bld=_build,
+            _feat=item.origin,
+            _tb=tb_box,
+        ):
+            # 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
+            dwg._record_build_issue(
+                "warning",
+                "gdt_dropped",
+                f"{nm} not placed (no room in the {_v} {_s} strip or its opposite)",
+            )
+
+        register_corridor(
+            dwg,
+            (item.view, item.side),
+            strip,
+            item.view,
+            axis,
+            tier,
+            CorridorCandidate(
+                name=name,
+                build=_build,
+                order=(_GDT_SUBCHAIN, px if horizontal else py, name),
+                on_place=lambda nm: None,
+                on_drop=_drop,
+                dedup=None,
+                precedence=0,
+                # A declared frame has no alternate view — force-keep (policy B) rather than
+                # drop a user-authored annotation; only a physically full strip drops.
+                force=True,
+                feature=item.origin,  # provenance (ADR 0010): the decorated feature
+                size=size,
+                # Even a force-kept frame must not stack into the title block (#481 review) —
+                # place_strip_candidates rejects a placement hitting this box, then on_drop's
+                # fallthrough tries the other side.
+                forbid=tb_box,
+            ),
+        )
+        n += 1
+    return n

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/annotations/orchestrator.py

@@ -39,6 +39,7 @@ from draftwright.annotations.from_model import (
     render_centermarks,
     render_diameters,
     render_envelope,
+    render_gdt,
     render_height_ladder,
     render_locations,
     render_pmi,
@@ -59,8 +60,10 @@ from draftwright.annotations.sections import (
     feature_holes_of,
 )
 from draftwright.model import (
+    Frame,
     HoleFeature,
     PatternFeature,
+    RotationalFeature,
     build_part_model,
     plan_dimensions,
     plan_sections,
@@ -130,6 +133,20 @@ def build_model(a: Analysis):
     )
 
 
+def build_rotational_feature(a: Analysis):
+    """The rotational furniture feature (OD + centrelines + concentric bores) for *a*,
+    or ``None`` when the part isn't rotational. Mirrors the ``rotational`` branch of
+    :func:`build_model` / ``detect.build_part_model`` (detect.py) so the declared-model
+    path can synthesise the same furniture detection produces: a declared turned shaft
+    otherwise renders with no centrelines and its OD as a leader, not a dimension (#472).
+    Concentric bores are a Z-axis construction (as in :func:`build_model`)."""
+    if not a.is_rotational or a.od_diam is None:
+        return None
+    bores = tuple(_concentric_bore_diams(a)) if a.od_axis == "z" else ()
+    c = a.part.bounding_box().center()
+    return RotationalFeature(frame=Frame((c.X, c.Y, c.Z), a.od_axis), od=a.od_diam, bores=bores)
+
+
 def _declared_feature_keys(groups, a: Analysis) -> set:
     """The :class:`HoleRef` position keys of every DECLARED hole/pattern member (ADR 0011
     #448), so a caller-declared hole/pattern renders at its declared position even where
@@ -333,6 +350,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)
 
+    # Declared GD&T frames / datum symbols / surface finishes (ADR 0011 §4, #61) — register
+    # into the same strips as first-class candidates BEFORE the drain, so the one solve orders
+    # and spaces them crossing-free with the dims (not a leftover first-fit like render_pmi).
+    render_gdt(dwg, _model, a)
+
     # Now every feeder pass (locations + slots) has registered; solve each shared above
     # corridor once (ADR 0009 end state, #345/#346) — dedup coincident spans, order the
     # ladder — BEFORE detail views and PMI, so they see the placed ladder as an obstacle.

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/builder.py

@@ -36,7 +36,7 @@ from draftwright._core import (
     _tb_width,
 )
 from draftwright.analysis import _analyse
-from draftwright.annotate import _auto_annotate, build_model
+from draftwright.annotate import _auto_annotate, build_model, build_rotational_feature
 from draftwright.annotations.sections import feature_hole_keys
 from draftwright.drawing import Drawing
 from draftwright.fonts import PLEX_MONO
@@ -263,6 +263,17 @@ def _assemble(a, out, assembly, detail_view, auto_dims, model=None, decorations=
     dwg._part_model = (
         _coerce_model(model, a.part, decorations) if model is not None else build_model(a)
     )
+    if model is not None:
+        # A declared model skips detection, so a turned shaft carries no RotationalFeature —
+        # and that feature is the sole driver of the turned-axis centrelines + the OD dimension
+        # (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])
     dwg._model_declared = model is not None  # ADR 0011 #448: gate model-driven hole render
 
     part_s = a.part.scale(a.SCALE)

{draftwright-0.2.8 → draftwright-0.2.9}/src/draftwright/model/__init__.py

@@ -21,7 +21,17 @@ width/depth, slots) and by the lint coverage checks. Remaining engine passes
 
 from __future__ import annotations
 
-from draftwright.model.declare import boss, envelope, hole, pattern, slot, step
+from draftwright.model.declare import (
+    boss,
+    control_frame,
+    datum,
+    envelope,
+    finish,
+    hole,
+    pattern,
+    slot,
+    step,
+)
 from draftwright.model.detect import build_part_model
 from draftwright.model.ir import (
     BossFeature,
@@ -67,7 +77,10 @@ __all__ = [
     "StepLevelFeature",
     "build_part_model",
     "boss",
+    "control_frame",
+    "datum",
     "envelope",
+    "finish",
     "hole",
     "pattern",
     "slot",