draftwright 0.2.8__tar.gz → 0.2.10__tar.gz

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

@@ -1,5 +1,87 @@
 # Changelog
 
+## v0.2.10 — 2026-07-07
+
+**Declarative-surface fidelity and layout-engine unification.** Editing and re-running a
+declarative `Sheet` script now reproduces more of the drawing (title block, layout, PMI on the
+declared path), a new lint catches stale declarations, and an intentional scale is respected.
+Internally the annotation placer moves further onto the single collect-then-solve (ADR 0009),
+and `kiwisolver` is dropped as a dependency.
+
+### Added
+
+- **Declaration-vs-geometry reconciliation lint** — `lint()` now flags a declared cylindrical
+  feature (hole/boss/step) with **no matching geometry** in the part (`declared_feature_absent`):
+  a callout drawn over empty space because the part was edited but the declaration went stale.
+  Closes the last gap in the "did my edit break the drawing?" loop (over-declaration; coverage
+  lint already caught under-declaration). Matches on axis + ⌀ + in-plane position + bore/boss
+  polarity. Gated on a caller-supplied `model=` (detection can't over-declare). (#487)
+- **Title-block + layout aspects on the `Sheet` DSL** — `Sheet(drawn_by=…, tolerance=…, scale=…,
+  page=…)`; the generated `--script` reproduces them, and the CLI forwards
+  `--drawn-by`/`--tolerance`/`--scale`/`--page` on the sheet path (no more inert-flag warning). (#474)
+- **PMI reproduced on the declared-model path** — `build_drawing(path, model=…, pmi="annotate")`
+  synthesises the STEP AP242 PMI into the declared model, so a declared build draws the same PMI
+  dimensions as the detection path. (#472)
+
+### Changed
+
+- **An intentional explicit `scale=` below the legibility floor is honoured with a warning**
+  rather than rejected. A part deliberately drawn at 1:1 (or `Sheet(scale="1:10")`) whose smallest
+  feature falls under the 10 mm legibility floor now renders (annotations may crowd) instead of
+  raising `ValueError`; only a genuinely degenerate scale (< 0.1 mm projected, where OCCT arcs
+  collapse) is rejected. The floor now binds only the *automatic* scale. (#489)
+- **`kiwisolver` is no longer a dependency.** The 1-D strip solve delegates to the built-in
+  deterministic minimum-total-leader-length PAVA algorithm, which supersedes the Cassowary
+  solver — same placement contract, one fewer third-party dependency. (#507)
+
+### Fixed
+
+- **Dimension placement is more robust under contention.** Candidate **priority** is plumbed
+  through the shared corridor solve, so an authored GD&T frame is kept over a lower-value
+  automatic dimension when a strip is over capacity (#357). Rotational concentric-bore leaders
+  are now bounded to the front-view height with ranked drops, and pitch dimensions are placed
+  onto the obstacle-aware per-side zone-strip solve — retiring the last fixed-offset,
+  count-based stacking placers (the shape behind earlier dense-sheet overruns). (#374)
+
+## 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.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.8
+Version: 0.2.10
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -685,7 +685,6 @@ Requires-Python: <3.15,>=3.10
 Requires-Dist: build123d-drafting-helpers>=0.13.0
 Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
 Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
-Requires-Dist: kiwisolver<2,>=1.4
 Requires-Dist: numpy>=1.24
 Requires-Dist: reportlab>=4.0
 Requires-Dist: svglib>=1.5
@@ -769,6 +768,37 @@ 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").note("M3x0.5 TAP")  # ⌀8 bore, Ra 1.6, tapped
+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`/…), plus `sheet.note(text, ref)`
+/ `.note(text)` for free-text shop callouts (thread specs, `DEBURR`, knurl). 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.10}/README.md

@@ -75,6 +75,37 @@ 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").note("M3x0.5 TAP")  # ⌀8 bore, Ra 1.6, tapped
+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`/…), plus `sheet.note(text, ref)`
+/ `.note(text)` for free-text shop callouts (thread specs, `DEBURR`, knurl). 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.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.2.8"
+version = "0.2.10"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,6 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.13.0",
-    "kiwisolver>=1.4,<2",
     "numpy>=1.24",
     "reportlab>=4.0",
     "svglib>=1.5",

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

@@ -255,10 +255,21 @@ _SLOT_DIM_HEIGHT = 2 * _FONT_SIZE + 2 * _PAD  # fv_zones.right: overall height d
 
 
 _MIN_VIEW_MM = (
-    10.0  # min projected view dimension; below it annotation geometry degenerates (#129)
+    10.0  # legibility floor: the projected size below which an *explicit* scale earns a warning.
+    # It is NOT a bound on the auto scale (choose_scale is a pure geometric page fit) and does NOT
+    # gate which annotations exist (step/location legibility use _MIN_STEP_*/_MIN_LOC_SEP_MM). Its
+    # only use is the explicit-scale advisory in analysis.py: below it a user scale is honoured
+    # with a warning, not rejected (#489).
 )
 
 
+# Hard geometry floor: below this projected size OCCT's annotation arcs collapse
+# (Geom_TrimmedCurve U1==U2), which happens near 1e-4 mm empirically — 0.1 mm is a conservative
+# floor far above that and far below any real drawing. An explicit scale under it is rejected with
+# a clean message rather than a cryptic OCP error (#489).
+_MIN_RENDER_MM = 0.1
+
+
 _SLOT_DIM_STEP = 4 * _FONT_SIZE + _PAD  # fv_zones.right: step-height dimension
 
 
@@ -557,8 +568,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 +596,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.10}/src/draftwright/analysis.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import logging
 import math
+import warnings
 
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
@@ -22,6 +23,7 @@ from draftwright._core import (
     _DIM_PAD,
     _FONT_SIZE,
     _MARGIN,
+    _MIN_RENDER_MM,
     _MIN_VIEW_MM,
     Analysis,
     _legible_steps,
@@ -341,21 +343,41 @@ def _analyse(
             break
         n_for_sizing = n_next
     if scale is not None:
+        # An explicit scale is the user's call — honour it (#489). Two floors apply:
+        #  - _MIN_RENDER_MM: a hard geometry limit; below it OCCT's annotation arcs degenerate
+        #    (Geom_TrimmedCurve U1==U2, ~1e-4 mm empirically — 0.1 mm is a conservative floor).
+        #    Reject with a clean message; there is no meaningful drawing this small anyway.
+        #  - _MIN_VIEW_MM: a legibility floor; below it annotations crowd but the drawing is
+        #    valid, so honour the scale with a warning. This floor does NOT bound the auto scale
+        #    (choose_scale is a pure geometric page fit), so a warning is only useful when a
+        #    legible page-fitting scale actually exists — i.e. the auto scale is itself legible.
+        min_dim = min(x_size, y_size, z_size)
+        min_view = min_dim * SCALE
+        if min_view < _MIN_RENDER_MM:
+            safe = _MIN_RENDER_MM / min_dim
+            raise ValueError(
+                f"scale {SCALE!r} projects the smallest part dimension "
+                f"({min_dim:.0f} mm) to {min_view:.3g} mm — the drawing geometry degenerates "
+                f"below {_MIN_RENDER_MM:g} mm (OCCT arc construction fails). "
+                f"Use scale ≥ {safe:.3g} or omit the scale for automatic selection."
+            )
         auto_scale, _, _, _ = choose_scale(
             x_size, y_size, z_size, n_steps=n_for_sizing, scale=None, page=page, strips=strips_i
         )
-        if SCALE < auto_scale:
-            min_dim = min(x_size, y_size, z_size)
-            min_view = min_dim * SCALE
-            if min_view < _MIN_VIEW_MM:
-                safe = _MIN_VIEW_MM / min_dim
-                raise ValueError(
-                    f"scale {SCALE!r} projects the smallest part dimension "
-                    f"({min_dim:.0f} mm) to {min_view:.1f} mm — "
-                    f"annotation geometry degenerates below {_MIN_VIEW_MM:.0f} mm "
-                    f"(OCCT Standard_DomainError / SIGABRT). "
-                    f"Use scale ≥ {safe:.3g} or omit --scale for automatic selection."
-                )
+        # Warn only when omitting the scale would truly give a legible fit (auto scale itself is
+        # legible) but the requested scale is below the floor. A part illegible at every
+        # page-fitting scale can't be helped by a bigger one, so nagging there would be false.
+        if min_view < _MIN_VIEW_MM <= auto_scale * min_dim:
+            safe = _MIN_VIEW_MM / min_dim
+            # No stacklevel that reaches user code: this fires deep in _analyse, and the public
+            # entry points (make_drawing, Sheet.export, build_drawing) sit at different depths.
+            # The message is self-contained (names the scale, the projection, and the fix).
+            warnings.warn(
+                f"scale {SCALE!r} projects the smallest part dimension ({min_dim:.0f} mm) to "
+                f"{min_view:.1f} mm, below the {_MIN_VIEW_MM:.0f} mm legibility floor — "
+                f"annotations may crowd or overlap. Honouring the requested scale; use "
+                f"scale ≥ {safe:.3g} or omit the scale for an automatic legible fit."
+            )
     DIM_PAD = _DIM_PAD
     margin = _MARGIN
     # Refine: apply the same legibility gate _auto_annotate uses for dim_step.

{draftwright-0.2.8 → draftwright-0.2.10}/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.10}/src/draftwright/annotations/_common.py

@@ -288,6 +288,11 @@ class CorridorCandidate:
             the same physical dimension; the higher-``precedence`` one survives (#345).
         precedence: dedup survivor rank — a hole *location* dim (feeds coverage/table
             escalation) outranks a coincident slot *position* line.
+        priority:   over-capacity survival rank (#357). When a strip cannot hold every
+            candidate, :func:`plan_strip` drops the lowest ``(priority, key)`` — so a higher
+            ``priority`` is kept. An authored GD&T frame sets this above the auto dims so it
+            is not dropped in favour of a lower-value auto dim purely by stacking-key order.
+            Default 0 (every auto dim) → key order, unchanged.
         on_place/on_drop: the pass's own post-placement bookkeeping — coverage
             registration / drop lint + `Escalation`, or a slot's below-side fallthrough.
         force:      policy-B force-keep after the corridor-respecting pass (locations have
@@ -301,10 +306,21 @@ class CorridorCandidate:
     on_drop: object
     dedup: tuple | None = None
     precedence: int = 0
+    priority: float = 0
     force: bool = False
     # 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 +373,40 @@ 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)
+    prio = {c.name: c.priority for c in kept if c.priority}  # over-capacity survival rank (#357)
     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,
+            priorities=prio,
+        )
     }
     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,
+                priorities=prio,
             )
         }
         if force_pairs
@@ -399,7 +440,20 @@ 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,
+    priorities=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 +472,17 @@ 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.
+
+    *priorities* maps a candidate's name to its over-capacity survival rank (#357);
+    absent names default to 0. When a segment is over capacity :func:`plan_strip` drops
+    the lowest ``(priority, key)``, so a higher priority is kept — an authored GD&T frame
+    is not dropped for a lower-value auto dim purely by stacking-key order.
+
     ``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 +491,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 +550,10 @@ 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)),
+                    priority=(priorities or {}).get(nb[0], 0.0),
                 ),
                 nb,
             )
@@ -487,6 +569,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))