draftwright 0.2.11__tar.gz → 0.2.12__tar.gz

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

@@ -1,5 +1,41 @@
 # Changelog
 
+## v0.2.12 — 2026-07-09
+
+**Sheet scripts now round-trip authored layout intent.** This patch finishes the next
+slice of the layout-authority work: below/right ladders, pinned edits, height ladders,
+detected envelopes, and AP242 authored dimensions now survive the declarative Sheet path
+without being invalidated by post-hoc placement or raw imported metadata.
+
+### Added
+
+- **Pinned edit intents route through the corridor solve.** `locate(..., pin=True)` and
+  pinned dimensions now become priority-ranked candidates in the shared corridor instead
+  of fixed post-hoc edits, so user intent participates in the same ordering/spacing model
+  as automatic dimensions. (#511)
+- **AP242 dimensional PMI lowers to authored drafting dimensions.** Imported AP242
+  size/location dimensions now become `AuthoredDimension` IR and generated Sheet scripts
+  emit `sheet.dimension(...)`; unsupported PMI records remain explicit raw fallbacks.
+  (#503, #422, #62)
+
+### Changed
+
+- **`place_dim` is deprecated.** Manual dimensions should use pinned candidate/dimension
+  intent instead of the old incremental edit path.
+- **Prismatic height ladders and detected envelopes round-trip through Sheet scripts.**
+  Generated scripts now preserve `StepLevelFeature` and detected `EnvelopeFeature`
+  fallbacks, preventing CTC01-style ladder swaps and raw STEP-envelope remeasurement
+  drift.
+
+### Fixed
+
+- **Below/right corridors now share one solve.** Side-hole locations, height ladders,
+  PMI/GD&T, envelope dims, and related below/right strip occupants negotiate in the shared
+  corridor rather than competing through separate late passes. (#477)
+- **Sheet script parity is tighter.** Generated scripts preserve member positions, step
+  levels, AP242 authored dimensions, raw PMI fallbacks, and detected envelopes so
+  direct-vs-script CTC01 output has matching annotation names.
+
 ## v0.2.11 — 2026-07-08
 
 **Automatic layout now has one authority.** Page/scale selection, section placement,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.11
+Version: 0.2.12
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -842,10 +842,9 @@ automatically, so you say *what* to dimension, not *where*:
 ```python
 dwg = build_drawing(part)
 
-# Inspect detected features and add a dimension in domain terms (auto-placed):
-for f in dwg.features("plan"):
-    dwg.place_dim(f.page_pos, (f.page_pos[0] + f.diameter, f.page_pos[1]),
-                  "below", "plan", dwg.draft, name="dim_pocket")
+# Inspect detected features and add a pinned dimension in domain terms:
+env = next(f for f in dwg.model().features if f.kind == "envelope")
+dwg.dimension(env, "length", role="width", side="below", pin=True)
 
 crit = dwg.lint_summary()   # {"passed", "score", "by_code", "issues":[…suggestion]}
 dwg.repair()                # auto-fix mechanically-fixable lint; never worsens
@@ -876,6 +875,7 @@ the section A–A trigger, the prismatic step-ladder + rotational furniture, and
 are all on the IR — the migration is complete (one path; the orchestrator is
 build → plan → render). See
 [`docs/target-architecture.md`](docs/target-architecture.md) and
+[`docs/layout-algorithm-primer.md`](docs/layout-algorithm-primer.md) for a short walkthrough, plus
 [`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
 selection, annotation placement, and section rendering.
 

{draftwright-0.2.11 → draftwright-0.2.12}/README.md

@@ -149,10 +149,9 @@ automatically, so you say *what* to dimension, not *where*:
 ```python
 dwg = build_drawing(part)
 
-# Inspect detected features and add a dimension in domain terms (auto-placed):
-for f in dwg.features("plan"):
-    dwg.place_dim(f.page_pos, (f.page_pos[0] + f.diameter, f.page_pos[1]),
-                  "below", "plan", dwg.draft, name="dim_pocket")
+# Inspect detected features and add a pinned dimension in domain terms:
+env = next(f for f in dwg.model().features if f.kind == "envelope")
+dwg.dimension(env, "length", role="width", side="below", pin=True)
 
 crit = dwg.lint_summary()   # {"passed", "score", "by_code", "issues":[…suggestion]}
 dwg.repair()                # auto-fix mechanically-fixable lint; never worsens
@@ -183,6 +182,7 @@ the section A–A trigger, the prismatic step-ladder + rotational furniture, and
 are all on the IR — the migration is complete (one path; the orchestrator is
 build → plan → render). See
 [`docs/target-architecture.md`](docs/target-architecture.md) and
+[`docs/layout-algorithm-primer.md`](docs/layout-algorithm-primer.md) for a short walkthrough, plus
 [`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
 selection, annotation placement, and section rendering.
 

{draftwright-0.2.11 → draftwright-0.2.12}/pyproject.toml

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

{draftwright-0.2.11 → draftwright-0.2.12}/src/draftwright/annotations/_common.py

@@ -293,6 +293,10 @@ class CorridorCandidate:
             ``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.
+        anchored/natural: when ``anchored`` is true, the strip solve keeps this candidate
+            near its own natural stacking-axis page coordinate instead of the segment edge.
+            This is how user-authored pinned dimension intents join the shared solve
+            without being invalidated by a later first-fit pass.
         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
@@ -307,6 +311,8 @@ class CorridorCandidate:
     dedup: tuple | None = None
     precedence: int = 0
     priority: float = 0
+    anchored: bool = False
+    natural: float | None = None
     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.
@@ -376,6 +382,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
     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)
+    anchored = {c.name: c.anchored for c in kept if c.anchored}
+    naturals = {c.name: c.natural for c in kept if c.natural is not None}
     left = {
         n
         for n, _ in place_strip_candidates(
@@ -389,6 +397,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
             sizes=sizes,
             forbid=forbid,
             priorities=prio,
+            anchored=anchored,
+            naturals=naturals,
         )
     }
     force_pairs = [(c.name, c.build) for c in kept if c.name in left and c.force]
@@ -407,6 +417,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
                 sizes=sizes,
                 forbid=forbid,
                 priorities=prio,
+                anchored=anchored,
+                naturals=naturals,
             )
         }
         if force_pairs
@@ -425,10 +437,13 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
 def register_corridor(dwg, key, strip, view, axis, tier, cand):
     """Queue a :class:`CorridorCandidate` under a shared corridor *key* so one
     :func:`drain_corridors` places the whole cross-pass set together (ADR 0009 end state).
-    The first registration for a key fixes its ``(strip, view, axis, tier)``."""
+    The first registration for a key fixes its ``(strip, view, axis)``; mixed producers on
+    the same corridor use the largest requested tier so spacing is not registration-order
+    dependent."""
     b = dwg._corridor_batch.setdefault(
         key, {"strip": strip, "view": view, "axis": axis, "tier": tier, "cands": []}
     )
+    b["tier"] = max(b["tier"], tier)
     b["cands"].append(cand)
 
 
@@ -453,6 +468,8 @@ def place_strip_candidates(
     sizes=None,
     forbid=None,
     priorities=None,
+    anchored=None,
+    naturals=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,
@@ -483,6 +500,11 @@ def place_strip_candidates(
     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.
 
+    *anchored* and *naturals* opt individual candidates into the weighted anchoring
+    mode in :func:`plan_strip`. This preserves the old segment-edge natural for every
+    caller that does not pass them, while letting authored pinned candidates express the
+    page coordinate they asked for inside the same shared solve.
+
     ``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
@@ -562,7 +584,6 @@ def place_strip_candidates(
 
     def _evaluate_segment(take, seg_lo, seg_hi):
         nat = seg_lo if inner == lo else seg_hi
-        anch = (0.0, nat) if axis == "y" else (nat, 0.0)
         # Keys order the tiers so the FIRST candidate lands on the inner tier: for an
         # inner=lo strip that is the lowest position (ascending keys); for a below strip
         # (inner=hi) it is the highest, so the keys reverse.
@@ -570,9 +591,14 @@ def place_strip_candidates(
             (
                 StripCandidate(
                     f"{(k if inner == lo else len(take) - 1 - k):04d}",
-                    anch,
+                    (
+                        (0.0, (naturals or {}).get(nb[0], nat))
+                        if axis == "y"
+                        else ((naturals or {}).get(nb[0], nat), 0.0)
+                    ),
                     (sizes or {}).get(nb[0], (tier, tier)),
                     priority=(priorities or {}).get(nb[0], 0.0),
+                    anchored=(anchored or {}).get(nb[0], False),
                 ),
                 nb,
             )

{draftwright-0.2.11 → draftwright-0.2.12}/src/draftwright/annotations/from_model.py

@@ -59,7 +59,7 @@ from draftwright.annotations._common import (
     strip_obstacles,
 )
 from draftwright.layout import StripCandidate, plan_strip
-from draftwright.model.ir import HoleFeature, PatternFeature
+from draftwright.model.ir import AUTHORED_DIMENSION_KINDS, HoleFeature, PatternFeature
 from draftwright.model.planner import DimensionGroup, plan_locations
 
 
@@ -361,15 +361,32 @@ def render_slots(dwg, model, a, *, only=None) -> int:
 # by datum distance). Segregating the two runs keeps a slot length from landing mid-ladder.
 _SIZE_SUBCHAIN = 0
 _LOC_SUBCHAIN = 1
-
-
-def _location_candidate(dwg, name, *, view, span_key, distance, build, feature=None):
+_OVERALL_SUBCHAIN = 2
+_MANDATORY_OVERALL_PRIORITY = 100.0
+
+
+def _location_candidate(
+    dwg,
+    name,
+    *,
+    view,
+    span_key,
+    distance,
+    build,
+    feature=None,
+    pinned=False,
+):
     """A :class:`CorridorCandidate` for a datum-referenced hole/pattern location dim.
     Location dims outrank a coincident slot-position line in dedup (#345) and form the
     outer, datum-distance-ordered run of the ladder (#346). Force-kept (policy B): a plan-X
     / side-Y location has no alternate view, so a corridor block keeps it rather than drops
     it; only a physically full strip drops (``location_ref_dropped`` → hole-table escalate)."""
 
+    def _placed(nm):
+        dwg._cover_scattered_hole_doc(nm)
+        if pinned:
+            dwg.pin(nm)
+
     def _drop(nm):
         edge = "plan view" if view == "plan" else "side view"
         dwg._record_build_issue(
@@ -382,16 +399,17 @@ def _location_candidate(dwg, name, *, view, span_key, distance, build, feature=N
         build=build,
         order=(_LOC_SUBCHAIN, distance, name),
         # A placed location may later be replaced by the scattered-hole table (#351 PR-4c).
-        on_place=lambda nm: dwg._cover_scattered_hole_doc(nm),
+        on_place=_placed,
         on_drop=_drop,
         dedup=(view, span_key[0], span_key[1]),
-        precedence=2,
+        precedence=3 if pinned else 2,
+        priority=100.0 if pinned else 0.0,
         force=True,
         feature=feature,  # provenance (ADR 0010): the located hole/pattern
     )
 
 
-def render_locations(dwg, model, a, *, only=None) -> int:
+def render_locations(dwg, model, a, *, only=None, pinned=None) -> int:
     """Baseline X/Y hole-location dims from the IR (#238). The planner decides the
     intent (`plan_locations`: which refs, from which datum); this renderer owns the
     layout (Amendment 4) — X dims tier above the plan view, Y dims above the side
@@ -402,7 +420,11 @@ def render_locations(dwg, model, a, *, only=None) -> int:
     *only*, when given, restricts placement to refs whose source feature is in the set —
     the #426 finalize() path passes the recorded ``locate`` intents' features so the
     corridor solve runs over the user's edited subset. ``None`` (the auto-pass) places
-    every ref, byte-identically."""
+    every ref, byte-identically.
+
+    *pinned* carries the #511 first slice: deferred user ``locate(..., pin=True)`` calls
+    remain first-class corridor candidates, but get higher survival/dedup priority and
+    pin their placed names instead of being hand-added after the solve."""
     planned = plan_locations(model)
     if not planned:
         return 0
@@ -430,6 +452,7 @@ def render_locations(dwg, model, a, *, only=None) -> int:
         refs.append((rx, ry, pd.feature))  # carry the source feature for provenance (ADR 0010)
     if not refs:
         return 0
+    pinned_set = set(pinned or ())
     tier = draft.font_size + 2 * draft.pad_around_text
     n = 0
 
@@ -452,8 +475,12 @@ def render_locations(dwg, model, a, *, only=None) -> int:
     PX, PY = a.proj.plan_x, a.proj.plan_y
     x_refs: list = []
     for r in refs:
-        if not any(abs(r[0] - u[0]) < 0.5 for u in x_refs):
-            x_refs.append(r)
+        for u in x_refs:
+            if abs(r[0] - u[0]) < 0.5:
+                u[3] = u[3] or r[2] in pinned_set
+                break
+        else:
+            x_refs.append([r[0], r[1], r[2], r[2] in pinned_set])
     _x_drawable = {r[0] for r in x_refs if abs(r[0] - datum_x) * a.SCALE >= 1.0}
     _kept_x, _n_x_close = _legible_locations(_x_drawable, a.SCALE)
     if _n_x_close:
@@ -472,7 +499,7 @@ def render_locations(dwg, model, a, *, only=None) -> int:
     # pass carving around the other and interleaving. No alternate view for a plan-X
     # location, so a corridor-blocked dim is force-kept (policy B), not relocated; only a
     # physically full strip drops (→ location_ref_dropped, escalates the hole table).
-    for i, (rx, ry, feat) in enumerate(sorted(x_refs, key=lambda r: abs(r[0] - datum_x))):
+    for i, (rx, ry, feat, pin_ref) in enumerate(sorted(x_refs, key=lambda r: abs(r[0] - datum_x))):
         if abs(rx - datum_x) * a.SCALE < 1.0:
             continue  # on the datum edge — nothing to dimension
         n += 1
@@ -502,6 +529,7 @@ def render_locations(dwg, model, a, *, only=None) -> int:
                     label=_fmt(_rx - datum_x),
                 ),
                 feature=_xfeat,
+                pinned=pin_ref,
             ),
         )
 
@@ -511,8 +539,12 @@ def render_locations(dwg, model, a, *, only=None) -> int:
     iso_x0, iso_y0, _, _ = _iso_bbox(dwg)
     y_refs: list = []
     for r in refs:
-        if not any(abs(r[1] - u[1]) < 0.5 for u in y_refs):
-            y_refs.append(r)
+        for u in y_refs:
+            if abs(r[1] - u[1]) < 0.5:
+                u[3] = u[3] or r[2] in pinned_set
+                break
+        else:
+            y_refs.append([r[0], r[1], r[2], r[2] in pinned_set])
     _y_drawable = {r[1] for r in y_refs if abs(r[1] - datum_y) * a.SCALE >= 1.0}
     _kept_y, _n_y_close = _legible_locations(_y_drawable, a.SCALE)
     if _n_y_close:
@@ -528,9 +560,9 @@ def render_locations(dwg, model, a, *, only=None) -> int:
     # Cap the side-above strip below the iso view so Y-location dims never run under it
     # (the carve respects outer_limit); the dim_pitch_side dims are obstacles the carve
     # avoids structurally, retiring the old manual allocate(10.0) reservation + cursor.
-    if y_refs and any(SX(ry) + 10 > iso_x0 - 4 for _, ry, _ in y_refs):
+    if y_refs and any(SX(ry) + 10 > iso_x0 - 4 for _, ry, _feat, _pin in y_refs):
         a.sv_zones.above.outer_limit = min(a.sv_zones.above.outer_limit, iso_y0 - 4)
-    for i, (rx, ry, feat) in enumerate(sorted(y_refs, key=lambda r: abs(r[1] - datum_y))):
+    for i, (rx, ry, feat, pin_ref) in enumerate(sorted(y_refs, key=lambda r: abs(r[1] - datum_y))):
         if abs(ry - datum_y) * a.SCALE < 1.0:
             continue
         n += 1
@@ -558,6 +590,7 @@ def render_locations(dwg, model, a, *, only=None) -> int:
                     label=_fmt(_ry - datum_y),
                 ),
                 feature=_yfeat,
+                pinned=pin_ref,
             ),
         )
     return n
@@ -802,8 +835,8 @@ def _envelope_tier(dwg, strip, view, size):
     ``allocate`` gave the right order only because an earlier pass had advanced a
     shared cursor; that coupling inverted the moment the location pass moved to
     ``plan_strip`` (#321), which never advances the cursor. Reading obstacle boxes
-    decouples the two passes. #133 mandatory-dim starvation is still guarded upstream
-    by the orchestrator's tier reservation.
+    decouples the two passes. The current renderer queues envelope dims into the shared
+    corridor instead; #133 mandatory-dim starvation is guarded by envelope priority.
 
     Assumes a below/above strip (Y stacking axis) — the only strips ``render_envelope``
     uses; a left/right strip would need the X interval of each obstacle box."""
@@ -822,55 +855,78 @@ def _envelope_tier(dwg, strip, view, size):
 
 def render_envelope(dwg, groups, a) -> int:
     """Overall width (plan, below) + depth (side, below) envelope dims via the IR,
-    placed by carving each below-strip around the feature/location dims already on it
-    (ADR 0009) — so the overall dim stacks outermost by construction, no longer via a
-    shared strip cursor an earlier pass had to advance. The **planner** decides
-    suppression (square footprint / X-turned; #250); this renderer just skips
-    suppressed dims and places the rest. Returns the count placed."""
+    registered into the same below-strip corridor as feature/location/GD&T/PMI candidates.
+    The overall dims use the last ladder subchain so they stack outermost by construction,
+    while their mandatory priority prevents best-effort below-strip occupants from starving
+    principal dimensions. The **planner** decides suppression (square footprint / X-turned;
+    #250); this renderer just skips suppressed dims and queues the rest. Returns the count
+    queued."""
     env = envelope_group(groups)
     if env is None:
         return 0
     n = 0
+
+    def _queue(name, strip, view, tier, distance, build):
+        register_corridor(
+            dwg,
+            (view, "below"),
+            strip,
+            view,
+            "y",
+            tier,
+            CorridorCandidate(
+                name=name,
+                build=build,
+                order=(_OVERALL_SUBCHAIN, distance, name),
+                on_place=lambda _nm: None,
+                on_drop=lambda _nm: None,
+                priority=_MANDATORY_OVERALL_PRIORITY,
+                force=True,
+            ),
+        )
+
     width = _env_pd(env, "width")
     if env_dim_placed(width):
         (x0, y0, z0), (x1, _, _) = width.param.span
         p1, p2 = dwg.at("plan", x0, y0, z0), dwg.at("plan", x1, y0, z0)
         witness = p1[1] - 2
-        py = _envelope_tier(dwg, a.pv_zones.below, "plan", _SLOT_DIM_WIDTH)
-        if py is not None:
-            dwg.add(
-                _dim(
-                    (p1[0], witness, 0),
-                    (p2[0], witness, 0),
-                    "below",
-                    witness - py,
-                    dwg.draft,
-                    label=_fmt(width.param.value),
-                ),
-                "m_env_width",
-                view="plan",
-            )
-            n += 1
+        _queue(
+            "m_env_width",
+            a.pv_zones.below,
+            "plan",
+            _SLOT_DIM_WIDTH,
+            abs(x1 - x0),
+            lambda pos, _p1=p1, _p2=p2, _w=witness, _v=width.param.value: _dim(
+                (_p1[0], _w, 0),
+                (_p2[0], _w, 0),
+                "below",
+                _w - pos,
+                dwg.draft,
+                label=_fmt(_v),
+            ),
+        )
+        n += 1
     depth = _env_pd(env, "depth")
     if env_dim_placed(depth):
         (x0, y0, z0), (_, y1, _) = depth.param.span
         p1, p2 = dwg.at("side", x0, y0, z0), dwg.at("side", x0, y1, z0)
         witness = p1[1] - 2
-        pd = _envelope_tier(dwg, a.sv_zones.below, "side", _SLOT_DIM_DEPTH)
-        if pd is not None:
-            dwg.add(
-                _dim(
-                    (p1[0], witness, 0),
-                    (p2[0], witness, 0),
-                    "below",
-                    witness - pd,
-                    dwg.draft,
-                    label=_fmt(depth.param.value),
-                ),
-                "m_env_depth",
-                view="side",
-            )
-            n += 1
+        _queue(
+            "m_env_depth",
+            a.sv_zones.below,
+            "side",
+            _SLOT_DIM_DEPTH,
+            abs(y1 - y0),
+            lambda pos, _p1=p1, _p2=p2, _w=witness, _v=depth.param.value: _dim(
+                (_p1[0], _w, 0),
+                (_p2[0], _w, 0),
+                "below",
+                _w - pos,
+                dwg.draft,
+                label=_fmt(_v),
+            ),
+        )
+        n += 1
     return n
 
 
@@ -1122,7 +1178,7 @@ def _detect_step_repeat(step_zs, bb_min_z, bb_max_z, tol_frac=0.10):
     return n, mean_rise
 
 
-def render_height_ladder(dwg, model, a) -> int:
+def render_height_ladder(dwg, model, a, *, 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
@@ -1214,7 +1270,7 @@ def render_height_ladder(dwg, model, a) -> int:
     # — #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 = model.orientation == "z" or od_is_height
+    suppress_height = (not include_overall) or model.orientation == "z" or od_is_height
     px = (
         None
         if suppress_height
@@ -1434,9 +1490,9 @@ def _bore_half_span(pmi_kind: str, value: float) -> float:
     """Half the perpendicular span of a bore-size dim from the bore centroid — the
     distance to each witness base point. A ``"diameter"`` record stores the full
     diameter (so half = radius = value/2); a ``"radius"`` record already stores the
-    radius (half = value). Keyed on ``PmiFeature.pmi_kind`` (the PMI category), NOT
-    ``.kind`` (the feature kind, always ``"pmi"``) — the #360 bug used the latter, so
-    the diameter branch was dead and every diameter dim spanned ±diameter (2× wide)."""
+    radius (half = value). Keyed on the drafting dimension category, NOT ``.kind`` (the
+    IR feature kind) — the #360 bug used the latter, so the diameter branch was dead and
+    every diameter dim spanned ±diameter (2× wide)."""
     return value / 2 if pmi_kind == "diameter" else value
 
 
@@ -1447,10 +1503,26 @@ _PMI_SUBCHAIN = 3
 _PMI_CORRIDOR_PRIORITY = 1.0
 
 
+def _renderable_pmi_records(records):
+    """PMI records the dimension renderer may place.
+
+    Raw ``PmiFeature`` fallbacks can preserve unsupported AP242 records. Do not render those
+    just because they happen to carry a numeric value and references; only drafting dimension
+    categories belong in this placement path.
+    """
+    return [
+        r
+        for r in records
+        if r.pmi_kind in AUTHORED_DIMENSION_KINDS and r.value > 0 and len(r.ref_pts) >= 2
+    ]
+
+
 def render_pmi(dwg, model, a) -> int:
-    """Render pre-authored PMI annotations (STEP AP242) from the IR `PmiFeature`s
-    as first-class corridor candidates (#208/#393). Replaces the engine's
-    `_annotate_pmi`.
+    """Render imported authored dimensions from concept IR as first-class candidates.
+
+    AP242 dimensional PMI lowers to ``AuthoredDimension``; unsupported raw PMI fallback
+    records still ride as ``PmiFeature`` so they remain visible to diagnostics (#208/#393).
+    Replaces the engine's ``_annotate_pmi``.
 
     Called from ``_auto_annotate`` before ``drain_corridors`` so authored PMI
     co-solves with automatic strip candidates. Skips records whose page
@@ -1464,26 +1536,9 @@ def render_pmi(dwg, model, a) -> int:
                     too compressed in the side view)
     """
     draft = dwg.draft
-    pmi = [f for f in model.features if f.kind == "pmi"]
-    usable = [r for r in pmi if r.value > 0 and len(r.ref_pts) >= 2]
-    n_gtol = sum(
-        1
-        for r in pmi
-        if r.pmi_kind
-        not in (
-            "linear",
-            "diameter",
-            "radius",
-            "angular",
-            "curved_dist",
-            "oriented",
-            "curve_length",
-            "thickness",
-            "label",
-            "presentation",
-        )
-        and r.value > 0
-    )
+    pmi = [f for f in model.features if f.kind in ("authored_dimension", "pmi")]
+    usable = _renderable_pmi_records(pmi)
+    n_gtol = sum(1 for r in pmi if r.pmi_kind not in AUTHORED_DIMENSION_KINDS and r.value > 0)
     if n_gtol:
         _log.debug("PMI annotate: %d gtol/datum record(s) not yet annotatable (Phase 4)", n_gtol)
     if not usable:
@@ -1920,10 +1975,11 @@ def render_pmi(dwg, model, a) -> int:
 # 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
+# Authored-intent run of the shared corridor ladder: GD&T frames tier BEYOND the
+# feature-size (_SIZE_SUBCHAIN=0), datum-location (_LOC_SUBCHAIN=1), and overall
+# envelope (_OVERALL_SUBCHAIN=2) dim runs, so a frame never lands mid-ladder among
+# the dimensions it annotates.
+_GDT_SUBCHAIN = 3
 # 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.