draftwright 0.2.9__tar.gz → 0.2.10__tar.gz

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

@@ -1,5 +1,48 @@
 # 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.9
+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
@@ -786,7 +785,7 @@ 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
+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
 ```
@@ -794,7 +793,8 @@ sheet.export("plate")                                     # writes plate.svg + p
 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
+(`.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.

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

@@ -92,7 +92,7 @@ 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
+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
 ```
@@ -100,7 +100,8 @@ sheet.export("plate")                                     # writes plate.svg + p
 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
+(`.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.

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.2.9"
+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.9 → 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
 
 

{draftwright-0.2.9 → 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.9 → 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,6 +306,7 @@ 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.
@@ -369,10 +375,20 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
     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, sizes=sizes, forbid=forbid
+            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]
@@ -390,6 +406,7 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
                 features=feats,
                 sizes=sizes,
                 forbid=forbid,
+                priorities=prio,
             )
         }
         if force_pairs
@@ -424,7 +441,18 @@ def drain_corridors(dwg):
 
 
 def place_strip_candidates(
-    dwg, strip, view, axis, cands, tier, *, force=False, features=None, sizes=None, forbid=None
+    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,
@@ -450,6 +478,11 @@ def place_strip_candidates(
     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
@@ -520,6 +553,7 @@ def place_strip_candidates(
                     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,
             )

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

@@ -20,7 +20,7 @@ from __future__ import annotations
 
 import math
 
-from build123d_drafting import DatumFeature, FeatureControlFrame, SurfaceFinish
+from build123d_drafting import DatumFeature, FeatureControlFrame, SurfaceFinish, TextBlock
 from build123d_drafting.helpers import Centerline, CenterMark, HoleCallout, Leader, TitleBlock
 
 from draftwright._core import (
@@ -58,6 +58,7 @@ from draftwright.annotations._common import (
     strip_free_span,
     strip_obstacles,
 )
+from draftwright.layout import StripCandidate, plan_strip
 from draftwright.model.ir import HoleFeature, PatternFeature
 from draftwright.model.planner import DimensionGroup, plan_locations
 
@@ -1294,10 +1295,29 @@ def render_rotational(dwg, model, a) -> int:
             left_edge = FX(a.bb.min.X)
             if left_edge - a.margin >= a.DIM_PAD:
                 elbow_x = left_edge - a.DIM_PAD * 0.6
-                nb = len(rot.bores)
                 pitch = max(10.0, draft.font_size * 3.0)
+                # Bound the leader stack to the front-view height and space it via the shared
+                # solve (#374). The old fixed `tip_z = cz + (i-(nb-1)/2)*pitch` had no bound,
+                # so enough concentric bores overran the view (the CTC-02 defect shape). Each
+                # leader keeps that same symmetric natural, so plan_strip reproduces the old
+                # positions exactly when there is room (zero displacement) and only compresses /
+                # drops (larger bore outranks smaller, priority=d) when the band is over capacity.
+                nb = len(rot.bores)
+                z_lo, z_hi = a.FV_Y - a.fv_hh, a.FV_Y + a.fv_hh
+                cands = [
+                    StripCandidate(
+                        key=f"{i:03d}",
+                        anchor=(elbow_x, FZ(a.cz) + (i - (nb - 1) / 2) * pitch),
+                        size=(draft.font_size * 3, pitch),
+                        priority=d,
+                    )
+                    for i, d in enumerate(rot.bores)
+                ]
+                placed = plan_strip(cands, z_lo, z_hi, pitch, axis="y").placed
                 for i, d in enumerate(rot.bores):
-                    tip_z = FZ(a.cz) + (i - (nb - 1) / 2) * pitch
+                    tip_z = placed.get(f"{i:03d}")
+                    if tip_z is None:
+                        continue  # over the front-view capacity — dropped (ranked), logged below
                     dwg.add(
                         Leader(
                             tip=(FX(a.cx - d / 2), tip_z, 0),
@@ -1309,6 +1329,18 @@ def render_rotational(dwg, model, a) -> int:
                         view="front",
                     )
                     n += 1
+                dropped = [d for i, d in enumerate(rot.bores) if placed.get(f"{i:03d}") is None]
+                for d in dropped:
+                    dwg._drop_callout_diam(
+                        d
+                    )  # exclude from coverage — else double-reported (#374 rev)
+                if dropped:
+                    dwg._record_build_issue(
+                        "warning",
+                        "callout_dropped",
+                        f"{len(dropped)} concentric-bore diameter(s) {dropped} not annotated "
+                        "(front-view height full) — use a detail view",
+                    )
             else:
                 _log.info(
                     "Additional diameters %s not annotated (insufficient left margin)",
@@ -1781,12 +1813,17 @@ def render_pmi(dwg, model, a) -> int:
 
 # 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")
+# NOT through the dimension planner (their IR items carry no DimParameters). "note" is a
+# free-text manufacturing note (#488) — the same leader-into-a-strip mechanism, glyph = text.
+_GDT_KINDS = ("control_frame", "datum_ref", "finish", "note")
 # 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
+# Over-capacity survival rank for an authored GD&T frame (#357): a declared control frame /
+# datum / finish / note is deliberate intent, so on a strip too full for every candidate it is
+# kept over the auto dims (locations/slots, priority 0) rather than dropped by stacking-key order.
+_GDT_CORRIDOR_PRIORITY = 1.0
 # 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
@@ -1807,6 +1844,8 @@ def _gdt_glyph(item, draft):
         )
     if item.kind == "datum_ref":
         return DatumFeature(item.letter, draft=draft)
+    if item.kind == "note":  # free-text manufacturing note (#488) — a single-line text glyph
+        return TextBlock([item.text], position=(0.0, 0.0), draft=draft)
     return SurfaceFinish(item.ra, position=(0.0, 0.0), draft=draft)
 
 
@@ -1943,6 +1982,7 @@ def render_gdt(dwg, model, a) -> int:
                 on_drop=_drop,
                 dedup=None,
                 precedence=0,
+                priority=_GDT_CORRIDOR_PRIORITY,  # authored intent outranks auto dims (#357)
                 # 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,

{draftwright-0.2.9 → draftwright-0.2.10}/src/draftwright/annotations/holes.py

@@ -861,32 +861,71 @@ def _place_pitch_dim(dwg, a: Analysis, view, loc1, loc2, n, pitch, to_page, name
     else:
         pref = (-0.3, 1.0) if view == "plan" else (-0.3, -1.0)
         side, reach = max(cands, key=lambda c: c[0][0] * pref[0] + c[0][1] * pref[1])
-    # stack further pitch dims in this view on outer tiers
+
+    def _place(off):
+        dwg.add(
+            _dim(
+                (p1[0], p1[1], 0),
+                (p2[0], p2[1], 0),
+                side,
+                off,
+                dwg.draft,
+                label=f"{n - 1}× {_fmt(pitch)}",
+            ),
+            name,
+            view=view,
+            feature=feature,
+        )
+
+    # Place onto the zone strip for the chosen side (#374): each side is its own strip, so the
+    # obstacle-aware carve stacks this dim clear of placed content — where an arbitrary-direction
+    # 1-D search would be defeated by a dim on a *different* side (rotated/two-axis grids). An
+    # axis-aligned side maps to a populated strip; a diagonal side, the side view's absent left
+    # strip, or a genuinely full strip fall through to the bounded vector placement below
+    # (behaviour unchanged for those residual cases).
+    # Only a GENUINELY axis-aligned row uses the strip carve: its dim is a clean horizontal /
+    # vertical line occupying one strip tier, and the coord bridge is exact. `_dim` places the
+    # line at `mid + side*distance`, so the witness is the MIDPOINT component on the strip axis and
+    # `sgn` the exact outward sign (±1); `distance = sgn*(pos - mid[axis])` then lands the line at
+    # the carved `pos`. The tight threshold (≈1.6°) keeps a tilted row off this path — its dim
+    # isn't axis-aligned, so it can't cleanly occupy a tier — routing it to the vector fallback.
+    zones = {"plan": a.pv_zones, "front": a.fv_zones, "side": a.sv_zones}[view]
+    sx, sy = side[0], side[1]
+    strip = axis = perp = None
+    witness = sgn = 0.0
+    if abs(sx) > 0.9996:  # horizontal side ⟂ a vertical row → left/right strip, stacks along x
+        strip, axis, perp, witness, sgn = (
+            (zones.right if sx > 0 else zones.left),
+            "x",
+            tuple(sorted((p1[1], p2[1]))),
+            mid[0],
+            math.copysign(1.0, sx),
+        )
+    elif abs(sy) > 0.9996:  # vertical side ⟂ a horizontal row → above/below strip, stacks along y
+        strip, axis, perp, witness, sgn = (
+            (zones.above if sy > 0 else zones.below),
+            "y",
+            tuple(sorted((p1[0], p2[0]))),
+            mid[1],
+            math.copysign(1.0, sy),
+        )
+    if strip is not None:
+        tier = max(10.0, dwg.draft.font_size * 3.0)
+        pos = carve_free_position(dwg, strip, view, axis, tier, perp)
+        if pos is not None:
+            _place(sgn * (pos - witness))
+            return
+
+    # Fallback: diagonal side / absent strip / full strip → the pre-#374 bounded vector placement,
+    # count-stacked and margin-guarded, so those residual cases are byte-identical to before.
     prior = sum(1 for nm, _ in dwg.iter_annotations() if nm.startswith(f"dim_pitch_{view}"))
     offset = reach + 8 + 10 * prior
-    # never force-place: skip (and log) when the dim line would leave the page
     ox = mid[0] + side[0] * (offset + 6)
     oy = mid[1] + side[1] * (offset + 6)
     if not (a.margin <= ox <= a.PAGE_W - a.margin and a.margin <= oy <= a.PAGE_H - a.margin):
-        _log.info(
-            "Pitch dimension for the %s× %s array skipped (no room)",
-            n,
-            _fmt(pitch),
-        )
+        _log.info("Pitch dimension for the %s× %s array skipped (no room)", n, _fmt(pitch))
         return
-    dwg.add(
-        _dim(
-            (p1[0], p1[1], 0),
-            (p2[0], p2[1], 0),
-            side,
-            offset,
-            dwg.draft,
-            label=f"{n - 1}× {_fmt(pitch)}",
-        ),
-        name,
-        view=view,
-        feature=feature,
-    )
+    _place(offset)
 
 
 def build_view_of_axis(a: Analysis):

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

@@ -40,7 +40,15 @@ from draftwright.annotate import _auto_annotate, build_model, build_rotational_f
 from draftwright.annotations.sections import feature_hole_keys
 from draftwright.drawing import Drawing
 from draftwright.fonts import PLEX_MONO
-from draftwright.model import Datum, Feature, PartModel, StepFeature, display, plan_sections
+from draftwright.model import (
+    Datum,
+    Feature,
+    PartModel,
+    StepFeature,
+    build_pmi_features,
+    display,
+    plan_sections,
+)
 from draftwright.projection import (
     _fit_iso_view,
     _project_iso,
@@ -274,6 +282,15 @@ def _assemble(a, out, assembly, detail_view, auto_dims, model=None, decorations=
             rot = build_rotational_feature(a)
             if rot is not None:
                 dwg._part_model = 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 PmiFeatures 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 PMI, so an explicit set wins.
+        pm = dwg._part_model
+        if a.pmi_mode == "annotate" and not any(f.kind == "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])
     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.9 → draftwright-0.2.10}/src/draftwright/cli.py

@@ -168,34 +168,33 @@ def main(
         if style == "sheet":
             from draftwright.sheet_emit import generate_sheet_script, resolve_object_spec
 
-            # The Sheet DSL doesn't yet model the title-block / layout aspects the
-            # imperative script embeds. Warn rather than silently drop them so a
-            # `--script --drawn-by … --scale …` invocation isn't quietly a no-op.
-            ignored = [
-                flag
-                for flag, set_ in (
-                    ("--tolerance", tolerance != "ISO 2768-m"),
-                    ("--drawn-by", bool(drawn_by)),
-                    ("--scale", scale is not None),
-                    ("--page", page is not None),
-                )
-                if set_
-            ]
-            if ignored:
-                typer.echo(
-                    f"warning: {', '.join(ignored)} not supported by --style sheet; ignored "
-                    "(use --style imperative to embed them)",
-                    err=True,
-                )
+            # The Sheet DSL now carries the title-block / layout aspects (#474), so forward all
+            # four flags — the generated script reproduces them on re-run (no more inert warning).
             if _looks_like_object_spec(step_file):
                 # STEP_FILE is a `module:attr` / `file.py:attr` spec → reference a live object
                 obj, seam = resolve_object_spec(step_file)
                 py_path = generate_sheet_script(
-                    obj, out=out, title=title, number=number, part_expr=seam
+                    obj,
+                    out=out,
+                    title=title,
+                    number=number,
+                    tolerance=tolerance,
+                    drawn_by=drawn_by,
+                    scale=scale,
+                    page=page,
+                    part_expr=seam,
                 )
             else:
                 py_path = generate_sheet_script(
-                    step_file, out=out, title=title, number=number, pmi=pmi.value
+                    step_file,
+                    out=out,
+                    title=title,
+                    number=number,
+                    tolerance=tolerance,
+                    drawn_by=drawn_by,
+                    scale=scale,
+                    page=page,
+                    pmi=pmi.value,
                 )
         else:
             if _looks_like_object_spec(step_file):

{draftwright-0.2.9 → draftwright-0.2.10}/src/draftwright/drawing.py

@@ -70,6 +70,7 @@ from draftwright.linting import (
     LintIssue,
     _suggest_fix,
     lint_axial_coverage,
+    lint_declaration_reconciliation,
     lint_drawing,
     lint_feature_coverage,
     lint_location_coverage,
@@ -1649,6 +1650,12 @@ class Drawing:
                 holes=holes,
                 patterns=patterns,
             )
+            # Reverse direction (#487): a DECLARED feature with no matching geometry (a stale
+            # phantom callout). Only for a caller-supplied model — detection can't over-declare.
+            # _part_model is typed `object` (deliberately loose, #397); read features duck-typed.
+            if self._model_declared and self._part_model is not None:
+                features = getattr(self._part_model, "features", ())
+                issues += lint_declaration_reconciliation(features, cyls)
         issues += list(self._build_issues)
         # Attach a ready-to-paste fix snippet where one is computable (#29).
         # str | None — None when no concrete repair can be inferred.