draftwright 0.2.4__tar.gz → 0.2.5__tar.gz

{draftwright-0.2.4 → draftwright-0.2.5}/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+### Changed
+
+- **Dimension-line spacing now follows ISO 129-1 / ASME Y14.5 convention** (#347).
+  The first dimension line sits further from the view outline (first-line gap
+  8 → 10 mm) and successive parallel lines stack tighter and uniform (between-line
+  clear gap 4 → 2.5 mm). The inter-view corridor widens in step (`_DIM_PAD`
+  18 → 20 mm) so the wider first-line gap does not crowd the between-view
+  dimensions. Re-drifts the layout of every drawing.
+
 ## v0.2.4 — 2026-07-03
 
 A follow-up patch on the ADR 0009 placement rebuild in 0.2.3: it finishes unifying

{draftwright-0.2.4 → draftwright-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.4
+Version: 0.2.5
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.2.4 → draftwright-0.2.5}/pyproject.toml

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

{draftwright-0.2.4 → draftwright-0.2.5}/src/draftwright/_core.py

@@ -162,6 +162,15 @@ def _dim(p1, p2, side, distance, draft, **kwargs):
     return d
 
 
+# Dimension-line spacing (page-mm, scale-independent), the single source of truth for
+# BOTH the ADR 0009 strip carve (via the `Strip` dataclass defaults below) and the
+# sheet.py halo/depth estimates that must reserve the same space. Per ISO 129-1 / ASME
+# Y14.5, the FIRST dimension line sits furthest from the outline (clears the outline +
+# extension-line origins) and subsequent parallel lines stack tighter and uniform (#347).
+_STRIP_GAP = 10.0  # clearance between the view outline and the first dimension line
+_STRIP_SPACING = 2.5  # clear gap between successive parallel dimension lines (beyond the label)
+
+
 @dataclass
 class Strip:
     """A one-dimensional annotation band adjacent to an orthographic view.
@@ -184,8 +193,8 @@ class Strip:
     anchor: float
     outer_limit: float
     direction: float = 1.0
-    gap: float = 8.0
-    spacing: float = 4.0
+    gap: float = _STRIP_GAP
+    spacing: float = _STRIP_SPACING
 
     @property
     def available(self) -> float:
@@ -220,7 +229,6 @@ _SLOT_DIM_DEPTH = 2 * _FONT_SIZE + _PAD  # sv_zones.below: overall depth dimensi
 _SLOT_DIM_HEIGHT = 2 * _FONT_SIZE + 2 * _PAD  # fv_zones.right: overall height dim
 
 
-_STRIP_SPACING = 4.0  # page-mm between successive annotations in a strip
 _MIN_VIEW_MM = (
     10.0  # min projected view dimension; below it annotation geometry degenerates (#129)
 )
@@ -572,8 +580,11 @@ def _iso_bbox(dwg):
 # Relocated from make_drawing for the sheet.py split (#162). Shared by sheet.py
 # (choose_scale/_layout_geometry) and make_drawing's repack pass, so they live
 # here in the shared base to keep the DAG acyclic.
-_DIM_PAD = 18.0
-_STRIP_GAP = 8.0
+# The base inter-view corridor: one first-line gap + one dimension tier. Tracks
+# _STRIP_GAP so widening the first-line gap (#347) keeps the below-plan / between-view
+# corridors from razor-fitting the first dim line (the #130 slack guarantee): 10 + 10.
+_DIM_PAD = _STRIP_GAP + _SLOT_DIM_HEIGHT  # 20.0
+# _STRIP_GAP / _STRIP_SPACING are defined above (beside the `Strip` dataclass they seed).
 
 _PAGE_SIZES = {
     "A4": (297.0, 210.0),

{draftwright-0.2.4 → draftwright-0.2.5}/src/draftwright/annotate.py

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

{draftwright-0.2.4 → draftwright-0.2.5}/src/draftwright/annotations/_common.py

@@ -302,6 +302,9 @@ class CorridorCandidate:
     dedup: tuple | None = None
     precedence: int = 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
 
 
 def solve_corridor(dwg, strip, view, axis, cands, tier):
@@ -353,13 +356,16 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
                 _promote_losers(c)
         return
     pairs = [(c.name, c.build) for c in kept]
-    left = {n for n, _ in place_strip_candidates(dwg, strip, view, axis, pairs, tier)}
+    feats = {c.name: c.feature for c in kept if c.feature is not None}  # provenance (ADR 0010)
+    left = {
+        n for n, _ in place_strip_candidates(dwg, strip, view, axis, pairs, tier, features=feats)
+    }
     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
+                dwg, strip, view, axis, force_pairs, tier, force=True, features=feats
             )
         }
         if force_pairs
@@ -393,7 +399,7 @@ def drain_corridors(dwg):
     dwg._corridor_batch = {}
 
 
-def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False):
+def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False, features=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
@@ -481,7 +487,9 @@ 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
-            dwg.add(dim, name, view=view)
+            # 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))
     return todo
 
 

{draftwright-0.2.4 → draftwright-0.2.5}/src/draftwright/annotations/from_model.py

@@ -151,13 +151,19 @@ def _record_slot_drop(dwg, kind, idx, view, feat):
     )
 
 
-def render_slots(dwg, model, a) -> int:
+def render_slots(dwg, model, a, *, only=None) -> int:
     """Dimension milled slots from the IR — width (the defining size, across
     ``width_axis``) + length (along ``long_axis``) + a position dim from the part
     datum, in the view the two axes span. Places through the engine's zone strips
     (shared infra, ADR 0008 Amend. 4); a dim with no clear room is dropped and
     recorded at info severity (place-what-fits). Sources `SlotFeature`s from the
-    model; replaces the engine's `_annotate_slots`. Returns the count placed."""
+    model; replaces the engine's `_annotate_slots`. Returns the count placed.
+
+    ``only`` (a set of `SlotFeature`s, #426 Phase 2b) restricts placement to a recorded
+    subset for ``finalize()``; ``only=None`` (the auto-pass) places all slots, byte-
+    identically. Skips filtered slots **in place** so ``i`` stays the slot's model index
+    (the ``m_slot{i}_*`` names must match the auto-pass — never re-enumerate a compacted
+    list)."""
     slots = [f for f in model.features if f.kind == "slot"]
     if not slots:
         return 0
@@ -174,6 +180,8 @@ def render_slots(dwg, model, a) -> int:
 
     count = 0
     for i, s in enumerate(slots):
+        if only is not None and s not in only:
+            continue  # #426 Ph2b: skip in place — i must stay the model index
         view = views[frozenset((s.width_axis, s.long_axis))]
         name, zones, h_axis, h_proj, _v_axis, v_proj = view
 
@@ -244,7 +252,13 @@ def render_slots(dwg, model, a) -> int:
 
                 def _below_or_drop(nm, _bs=below_strip, _bh=below_hi, _feat=s, _dw=drop_word):
                     if _bs is not None and not place_strip_candidates(
-                        dwg, _bs, vw[0], "y", [_cand_for("below", _bh)], tier
+                        dwg,
+                        _bs,
+                        vw[0],
+                        "y",
+                        [_cand_for("below", _bh)],
+                        tier,
+                        features={cname: _feat},
                     ):
                         return  # placed on the below strip
                     _record_slot_drop(dwg, _dw, idx, vw[0], _feat)
@@ -275,6 +289,7 @@ def render_slots(dwg, model, a) -> int:
                         ),
                         precedence=1 if is_pos else 0,
                         force=False,
+                        feature=s,  # provenance (ADR 0010): this dim belongs to the slot
                     ),
                 )
                 return True  # deferred — the callback owns the drop; caller's else must not fire
@@ -286,7 +301,7 @@ def render_slots(dwg, model, a) -> int:
                     continue
                 axis = "y" if side in ("above", "below") else "x"
                 if not place_strip_candidates(
-                    dwg, strip, vw[0], axis, [_cand_for(side, hi)], tier
+                    dwg, strip, vw[0], axis, [_cand_for(side, hi)], tier, features={cname: s}
                 ):
                     return True
             return False
@@ -329,7 +344,7 @@ _SIZE_SUBCHAIN = 0
 _LOC_SUBCHAIN = 1
 
 
-def _location_candidate(dwg, name, *, view, span_key, distance, build):
+def _location_candidate(dwg, name, *, view, span_key, distance, build, feature=None):
     """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
@@ -353,16 +368,22 @@ def _location_candidate(dwg, name, *, view, span_key, distance, build):
         dedup=(view, span_key[0], span_key[1]),
         precedence=2,
         force=True,
+        feature=feature,  # provenance (ADR 0010): the located hole/pattern
     )
 
 
-def render_locations(dwg, model, a) -> int:
+def render_locations(dwg, model, a, *, only=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
     view, nearest-datum-first, legibility-gated, allocated from the existing strips;
     a ref with no room is dropped as `location_ref_dropped`. Replaces the engine's
-    `_add_location_dims`. Returns the count placed."""
+    `_add_location_dims`. Returns the count placed.
+
+    *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."""
     planned = plan_locations(model)
     if not planned:
         return 0
@@ -372,6 +393,8 @@ def render_locations(dwg, model, a) -> int:
     datum_x, datum_y = datum.at[0], datum.at[1]
     refs = []
     for pd in planned:
+        if only is not None and pd.feature not in only:  # #426: recorded subset only
+            continue
         if pd.param.span is None:
             continue
         rx, ry = pd.param.span[1][0], pd.param.span[1][1]
@@ -385,12 +408,27 @@ def render_locations(dwg, model, a) -> int:
             and math.hypot(rx - a.cx, ry - a.cy) <= _CONCENTRIC_TOL_MM
         ):
             continue
-        refs.append((rx, ry))
+        refs.append((rx, ry, pd.feature))  # carry the source feature for provenance (ADR 0010)
     if not refs:
         return 0
     tier = draft.font_size + 2 * draft.pad_around_text
     n = 0
 
+    # Location-dim names. The auto-pass (only is None) numbers them positionally —
+    # m_locx{i}, the historical byte-identical scheme. The finalize() path (only set) may
+    # run AFTER live-replayed locate() dims already hold m_loc names, so there it allocates
+    # the first FREE index to avoid Drawing.add silently replacing one (#429 review).
+    _loc_used = set(dwg._named) if only is not None else None
+
+    def _loc_name(prefix: str, i: int) -> str:
+        if _loc_used is None:
+            return f"{prefix}{i}"  # auto-pass: unchanged, byte-identical
+        j = 0
+        while f"{prefix}{j}" in _loc_used:
+            j += 1
+        _loc_used.add(f"{prefix}{j}")
+        return f"{prefix}{j}"
+
     # --- X locations: tier above the plan view ---
     PX, PY = a.proj.plan_x, a.proj.plan_y
     x_refs: list = []
@@ -415,10 +453,14 @@ def render_locations(dwg, model, a) -> 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) in enumerate(sorted(x_refs, key=lambda r: abs(r[0] - datum_x))):
+    for i, (rx, ry, feat) 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
+        # A single X-location dim shared by two *distinct* features at this X belongs to
+        # neither exclusively — leave it unowned so drop() cannot over-strip a sibling's
+        # dimension and annotations_of never over-claims it (review #406, ADR 0010).
+        _xfeat = None if any(abs(o[0] - rx) < 0.5 and o[2] != feat for o in refs) else feat
         register_corridor(
             dwg,
             ("plan", "above"),
@@ -428,7 +470,7 @@ def render_locations(dwg, model, a) -> int:
             tier,
             _location_candidate(
                 dwg,
-                f"m_locx{i}",
+                _loc_name("m_locx", i),
                 view="plan",
                 span_key=(round(PX(datum_x), 1), round(PX(rx), 1)),
                 distance=abs(rx - datum_x),
@@ -440,6 +482,7 @@ def render_locations(dwg, model, a) -> int:
                     draft,
                     label=_fmt(_rx - datum_x),
                 ),
+                feature=_xfeat,
             ),
         )
 
@@ -466,12 +509,14 @@ def render_locations(dwg, model, a) -> 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, _ in y_refs):
         a.sv_zones.above.outer_limit = min(a.sv_zones.above.outer_limit, iso_y0 - 4)
-    for i, (rx, ry) in enumerate(sorted(y_refs, key=lambda r: abs(r[1] - datum_y))):
+    for i, (rx, ry, feat) 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
+        # Shared-Y location dim → unowned (see the X loop; review #406).
+        _yfeat = None if any(abs(o[1] - ry) < 0.5 and o[2] != feat for o in refs) else feat
         register_corridor(
             dwg,
             ("side", "above"),
@@ -481,7 +526,7 @@ def render_locations(dwg, model, a) -> int:
             tier,
             _location_candidate(
                 dwg,
-                f"m_locy{i}",
+                _loc_name("m_locy", i),
                 view="side",
                 span_key=(round(SX(datum_y), 1), round(SX(ry), 1)),
                 distance=abs(ry - datum_y),
@@ -493,6 +538,7 @@ def render_locations(dwg, model, a) -> int:
                     draft,
                     label=_fmt(_ry - datum_y),
                 ),
+                feature=_yfeat,
             ),
         )
     return n
@@ -513,7 +559,7 @@ def render_centermarks(dwg, groups) -> int:
         members = feat.members or (g.anchor,)
         for loc in members:
             px, py, *_ = dwg.at(view, *loc)
-            dwg.add(CenterMark((px, py, 0), size, dwg.draft), f"m_cm{n}", view=view)
+            dwg.add(CenterMark((px, py, 0), size, dwg.draft), f"m_cm{n}", view=view, feature=feat)
             n += 1
     return n
 
@@ -532,7 +578,7 @@ def _mentioned_diameters(dwg) -> set[float]:
     return diams
 
 
-def _diameter_row_below(dwg, items) -> int:
+def _diameter_row_below(dwg, items, start: int = 0) -> int:
     """ø-callout row BELOW the front view for X-turned step/boss diameters (#77).
     *items* is ``[(anchor, diameter), ...]``. The row is dropped clear of anything
     already below the profile; labels spread along page-x by the ADR-0003 strip
@@ -553,30 +599,31 @@ def _diameter_row_below(dwg, items) -> int:
     label_y = obstacle_bottom - (draft.font_size + 4 * draft.pad_around_text)
     if label_y < _MARGIN + draft.font_size:
         return 0
-    specs = []  # (tip_page, label), tip on the step's bottom silhouette
-    for anchor, dia in items:
+    specs = []  # (tip_page, label, feature), tip on the step's bottom silhouette
+    for anchor, dia, feat in items:
         ax, ay, az = anchor
         tip = dwg.at("front", ax, ay, az - dia / 2)
-        specs.append((tip, f"ø{_fmt(dia)}"))
+        specs.append((tip, f"ø{_fmt(dia)}", feat))
     specs.sort(key=lambda s: s[0][0])
-    half_w = max(len(label) for _, label in specs) * draft.font_size * 0.62 / 2
+    half_w = max(len(label) for _, label, _ in specs) * draft.font_size * 0.62 / 2
     min_gap = 2 * half_w + 2 * draft.pad_around_text
-    naturals = [tip[0] for tip, _ in specs]
+    naturals = [tip[0] for tip, _, _ in specs]
     xs = _solve_strip_ys(naturals, min_gap, fx0 + half_w, fx1 - half_w) or _greedy_strip_ys(
         naturals, min_gap, fx0 + half_w, fx1 - half_w
     )
     if xs is None:
         return 0
-    for i, ((tip, label), lx) in enumerate(zip(specs, xs, strict=True)):
+    for i, ((tip, label, feat), lx) in enumerate(zip(specs, xs, strict=True)):
         dwg.add(
             Leader(tip=(tip[0], tip[1], 0), elbow=(lx, label_y, 0), label=label, draft=draft),
-            f"m_dia_x{i}",
+            f"m_dia_x{start + i}",
             view="front",
+            feature=feat,
         )
     return len(specs)
 
 
-def _diameter_column_left(dwg, items) -> int:
+def _diameter_column_left(dwg, items, start: int = 0) -> int:
     """ø-callout column to the LEFT of the front view for Z-turned step/boss
     diameters (#131) — the page-Y mirror of the row-below. A per-label occupancy
     gate drops only a label that would overprint a bore leader / existing callout
@@ -585,19 +632,19 @@ def _diameter_column_left(dwg, items) -> int:
         return 0
     draft = dwg.draft
     fx0, fy0, _, fy1 = dwg.view_bounds("front")
-    label_w = max(len(f"ø{_fmt(dia)}") for _, dia in items) * draft.font_size * 0.62
+    label_w = max(len(f"ø{_fmt(dia)}") for _, dia, _ in items) * draft.font_size * 0.62
     elbow_x = fx0 - (draft.font_size + 2 * draft.pad_around_text)
     if elbow_x - label_w < _MARGIN:
         return 0
-    specs = []  # (tip_page, label), tip on the step's left silhouette
-    for anchor, dia in items:
+    specs = []  # (tip_page, label, feature), tip on the step's left silhouette
+    for anchor, dia, feat in items:
         ax, ay, az = anchor
         tip = dwg.at("front", ax - dia / 2, ay, az)
-        specs.append((tip, f"ø{_fmt(dia)}"))
+        specs.append((tip, f"ø{_fmt(dia)}", feat))
     specs.sort(key=lambda s: s[0][1])
     half_h = draft.font_size / 2 + draft.pad_around_text
     min_gap = 2 * half_h
-    naturals = [tip[1] for tip, _ in specs]
+    naturals = [tip[1] for tip, _, _ in specs]
     ys = _solve_strip_ys(naturals, min_gap, fy0 + half_h, fy1 - half_h) or _greedy_strip_ys(
         naturals, min_gap, fy0 + half_h, fy1 - half_h
     )
@@ -609,42 +656,70 @@ def _diameter_column_left(dwg, items) -> int:
     # occupant class, #358). Centre lines stay crossable (a diameter dim may cross one).
     occupied = strip_obstacles(dwg, view="front", crossable=CROSSABLE_TYPES)
     placed = 0
-    for i, ((tip, label), ly) in enumerate(zip(specs, ys, strict=True)):
+    for i, ((tip, label, feat), ly) in enumerate(zip(specs, ys, strict=True)):
         ldr = Leader(tip=(tip[0], tip[1], 0), elbow=(elbow_x, ly, 0), label=label, draft=draft)
         if _box_hits(_anno_box(ldr), occupied):
             continue  # would overprint a bore leader / existing callout — drop just this one
-        dwg.add(ldr, f"m_dia_z{i}", view="front")
+        dwg.add(ldr, f"m_dia_z{start + i}", view="front", feature=feat)
         occupied.append(_anno_box(ldr))
         placed += 1
     return placed
 
 
-def render_diameters(dwg, groups, tol: float = 0.15) -> int:
+def render_diameters(dwg, groups, tol: float = 0.15, *, only=None) -> int:
     """ø leaders for a turned part's external step/boss diameters, from the IR —
     one distinct callout per diameter, in a tidy row below the front view
     (X-turning) or a column to its left (Z-turning). Orientation is the feature
     frame's axis, not two passes. Replaces the engine's ``_annotate_turned_diameters``
-    (ADR 0008 convergence). Diameters another annotation already covers are skipped."""
+    (ADR 0008 convergence). Diameters another annotation already covers are skipped.
+
+    *only*, when given, restricts placement to step/boss features in the set — the #426
+    finalize() path passes the recorded step/boss ``callout`` intents' features. ``None``
+    (the auto-pass) places every diameter with the historical 0-based ``m_dia_{x,z}``
+    naming, byte-identically."""
     mentioned = _mentioned_diameters(dwg)
-    seen: set[tuple[str, float]] = set()
-    rows: list = []  # X-turned (anchor, dia)
-    cols: list = []  # Z-turned (anchor, dia)
+    # One distinct callout per (axis, diameter). Accumulate EVERY feature that shares a
+    # diameter (insertion-ordered), so provenance (#412) can tag the callout with its
+    # single owner — or leave it unowned when two distinct features share the diameter
+    # (the #398c/#406 shared-value rule, so drop can't over-strip a sibling).
+    row_buckets: dict = {}  # round(dia,2) -> [anchor, dia, {features}]  (X-turned)
+    col_buckets: dict = {}  # Z-turned
     for g in groups:
         if g.feature_kind not in ("step", "boss"):
             continue
+        if only is not None and g.feature not in only:  # #426 finalize: recorded subset
+            continue
         dia = next((pd.param.value for pd in g.dims if pd.param.kind == "diameter"), None)
         if dia is None or any(abs(dia - m) <= tol for m in mentioned):
             continue
-        axis = g.feature.frame.axis
-        key = (axis, round(dia, 2))
-        if key in seen:  # one distinct callout per diameter
+        bucket = {"x": row_buckets, "z": col_buckets}.get(g.feature.frame.axis)
+        if bucket is None:
             continue
-        seen.add(key)
-        if axis == "x":
-            rows.append((g.anchor, dia))
-        elif axis == "z":
-            cols.append((g.anchor, dia))
-    return _diameter_row_below(dwg, rows) + _diameter_column_left(dwg, cols)
+        dkey = round(dia, 2)
+        bucket.setdefault(dkey, [g.anchor, dia, set()])[2].add(g.feature)
+
+    def _items(buckets):
+        return [(a, d, next(iter(fs)) if len(fs) == 1 else None) for a, d, fs in buckets.values()]
+
+    # The placers name leaders m_dia_{x,z}{start+i} CONTIGUOUSLY from one start. The auto-pass
+    # (only None) uses start=0 — byte-identical. The finalize path (only set) may run after
+    # existing m_dia names (a prior batch), so it starts past the MAX existing index — NOT the
+    # first-free (which is unsound for a multi-item run when the names are non-contiguous, e.g.
+    # after drop(): a gap below an occupied index would let the run wrap onto it and silently
+    # overwrite an earlier leader — #432 review). Starting past the max keeps the whole run free.
+    def _next_start(prefix):
+        idxs = [
+            int(n[len(prefix) :])
+            for n in dwg._named
+            if n.startswith(prefix) and n[len(prefix) :].isdigit()
+        ]
+        return max(idxs) + 1 if idxs else 0
+
+    start_x = _next_start("m_dia_x") if only is not None else 0
+    start_z = _next_start("m_dia_z") if only is not None else 0
+    return _diameter_row_below(dwg, _items(row_buckets), start=start_x) + _diameter_column_left(
+        dwg, _items(col_buckets), start=start_z
+    )
 
 
 def _env_pd(group, role):
@@ -769,7 +844,9 @@ def _record_step_chain_drop(dwg, why: str) -> None:
     )
 
 
-def _draw_step_chain(dwg, view, segs, name_prefix, detail_scale=None, allow_collapse=True) -> int:
+def _draw_step_chain(
+    dwg, view, segs, name_prefix, detail_scale=None, allow_collapse=True, *, start=0
+) -> int:
     """Place a turned step-length chain in *view* from *segs* — each ``(pa, pb,
     value)`` already projected to *view*'s page coords, in axis order. Orientation is
     data (the projected span direction): horizontal → chain above the view, vertical
@@ -800,7 +877,8 @@ def _draw_step_chain(dwg, view, segs, name_prefix, detail_scale=None, allow_coll
             dim = _dim((min(xs), y1, 0), (max(xs), y1, 0), "above", gap, draft, label=label)
         else:
             dim = _dim((x1, min(ys), 0), (x1, max(ys), 0), "right", gap, draft, label=label)
-        candidates = [(f"{name_prefix}_typ", dim)]
+        typ_name = f"{name_prefix}_typ" if start == 0 else f"{name_prefix}_typ{start}"
+        candidates = [(typ_name, dim)]
     else:
         tier_step = draft.font_size + 2 * draft.pad_around_text
         tiers = [0] * len(segs)
@@ -841,7 +919,7 @@ def _draw_step_chain(dwg, view, segs, name_prefix, detail_scale=None, allow_coll
                 p1, p2, side = (x1, pa[1], 0), (x1, pb[1], 0), "right"
                 dist = gap
             candidates.append(
-                (f"{name_prefix}{i}", _dim(p1, p2, side, dist, draft, label=_fmt(value)))
+                (f"{name_prefix}{start + i}", _dim(p1, p2, side, dist, draft, label=_fmt(value)))
             )
 
     # Room guard: if any dim would fall off the drawable page, place NONE.
@@ -860,7 +938,24 @@ def _draw_step_chain(dwg, view, segs, name_prefix, detail_scale=None, allow_coll
     return len(candidates)
 
 
-def render_step_lengths(dwg, groups) -> int:
+def _next_steplen_start(dwg, prefix: str = "m_steplen") -> int:
+    """First free m_steplen index past the MAX existing one — the #426 finalize path names
+    the chain as a contiguous run from one start, so it must clear every existing name (max+1,
+    not first-free: a gap below an occupied index would let the run wrap onto it, #432)."""
+    idxs: list[int] = []
+    for n in dwg._named:
+        if not n.startswith(prefix):
+            continue
+        rest = n[len(prefix) :]
+        if rest.isdigit():
+            idxs.append(int(rest))
+        elif rest.startswith("_typ"):  # the N× collapse name m_steplen_typ{start}
+            tail = rest[4:]
+            idxs.append(int(tail) if tail.isdigit() else 0)
+    return max(idxs) + 1 if idxs else 0
+
+
+def render_step_lengths(dwg, groups, *, only=None) -> int:
     """Unified turned step-length chain (ADR 0008 #223): each `StepFeature`'s length
     span projects into the front view and joins the chain that tiles the turning axis
     so every shoulder is located. X-turned → horizontal chain above the view;
@@ -877,6 +972,8 @@ def render_step_lengths(dwg, groups) -> int:
     for g in groups:
         if g.feature_kind != "step":
             continue
+        if only is not None and g.feature not in only:  # #426 finalize: recorded subset
+            continue
         length = next(
             (pd.param for pd in g.dims if pd.param.kind == "length" and pd.param.span is not None),
             None,
@@ -887,6 +984,9 @@ def render_step_lengths(dwg, groups) -> int:
     if not rows:
         return 0
     draft = dwg.draft
+    # only=None (auto-pass) → start=0, historical m_steplen naming, byte-identical. The
+    # finalize path (only set) starts past existing m_steplen names (#426 naming seam).
+    start = _next_steplen_start(dwg) if only is not None else 0
     fsegs = [(dwg.at("front", *a), dwg.at("front", *b), v) for a, b, v in rows]
     horizontal = abs(fsegs[0][1][0] - fsegs[0][0][0]) >= abs(fsegs[0][1][1] - fsegs[0][0][1])
 
@@ -936,9 +1036,11 @@ def render_step_lengths(dwg, groups) -> int:
             main.sort(key=lambda s: s[0][0])
             # The chain now mixes head-block(s) with real steps — never collapse it to a
             # uniform "N× v" representative (a block is not a repeated step, #307 review).
-            return _draw_step_chain(dwg, "front", main, "m_steplen", allow_collapse=False)
+            return _draw_step_chain(
+                dwg, "front", main, "m_steplen", allow_collapse=False, start=start
+            )
 
-    return _draw_step_chain(dwg, "front", fsegs, "m_steplen")
+    return _draw_step_chain(dwg, "front", fsegs, "m_steplen", start=start)
 
 
 def _detect_step_repeat(step_zs, bb_min_z, bb_max_z, tol_frac=0.10):