draftwright 0.2.10__tar.gz → 0.2.12__tar.gz

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

@@ -1,5 +1,69 @@
 # 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,
+furniture footprints, and table/balloon escalation now negotiate through the same layout
+fitness model instead of using separate fixed offsets or first-fit policies after the main
+solve.
+
+### Fixed
+
+- **Solver placement paths are more consistent.** STEP PMI dimensions now queue into
+  the shared ADR 0009 corridor solve instead of carving after the drain; front-view
+  hole callouts use the strip solver instead of fixed row stepping; pitch-dimension
+  fallback searches bounded, obstacle-aware positions; repair no longer hides
+  `annotation_overlap` with a fixed-step nudge; and step-count sizing now handles
+  non-convergence conservatively. (#524)
+- **Page/scale fitness is shared across initial selection and repack.** Later layout
+  passes now compare candidates with the same model as the page chooser, preventing a
+  nominally "better" repack from invalidating the original layout decision. (#519)
+- **Section A-A participates in layout selection.** Section placement is measured as
+  part of page/scale fitness, so a section view is no longer a fixed-offset afterthought
+  that can disappear on dense sheets. (#515)
+- **Furniture placement reserves full rendered footprints.** Section arrows, detail
+  views, balloons, hole/data tables, and other furniture now reserve/check their true
+  rendered footprint instead of just their labels. (#518)
+- **Hole/data tables and balloon rings escalate through the layout model.** Dense table
+  and balloon outputs can move or negotiate for available room rather than dropping from
+  greedy first-fit placement when a small adjustment would fit. (#516, #517)
+
 ## v0.2.10 — 2026-07-07
 
 **Declarative-surface fidelity and layout-engine unification.** Editing and re-running a

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.10
+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.10 → 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.10 → draftwright-0.2.12}/pyproject.toml

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

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

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from draftwright.recognition import TurnedProfile
+    from draftwright.sheet import StripDepths
 
 from build123d import Align, BoundBox, Location, Mode, Shape, Text
 from build123d_drafting.helpers import (
@@ -338,7 +339,7 @@ def _legible_locations(positions, scale):
     return kept, n_too_close
 
 
-def _largest_empty_rect(drawable, obstacles):
+def _largest_empty_rect(drawable, obstacles, *, warn: bool = True):
     """Largest axis-aligned empty rectangle in *drawable* avoiding *obstacles*.
 
     *drawable* and each obstacle are ``(x0, y0, x1, y1)`` page-mm boxes.  Returns
@@ -376,10 +377,11 @@ def _largest_empty_rect(drawable, obstacles):
         # is unreachable in practice — choose_scale always leaves a gap — but
         # if it ever happens the iso would render over the other views, so flag
         # it rather than fail silently.
-        _log.warning(
-            "No empty rectangle found for the iso view; obstacles fill the "
-            "drawable area — iso may overlap other views"
-        )
+        if warn:
+            _log.warning(
+                "No empty rectangle found for the iso view; obstacles fill the "
+                "drawable area — iso may overlap other views"
+            )
         return drawable
     return best
 
@@ -514,6 +516,10 @@ class Analysis:
     is_rotational: bool
     od_axis: str  # rotation/turning axis of a rotational part ("z" default; "x"/"y" #222)
     step_zs: list[float]
+    layout_strips: StripDepths
+    layout_n_steps: int
+    layout_section: bool
+    layout_table_sizes: tuple[tuple[float, float], ...]
     sv_right: float
     iso_right_limit: float
     SCALE: float

{draftwright-0.2.10 → draftwright-0.2.12}/src/draftwright/analysis.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import logging
 import math
 import warnings
+from collections.abc import Callable
 
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
@@ -20,6 +21,7 @@ from OCP.IFSelect import IFSelect_ReturnStatus
 from OCP.STEPControl import STEPControl_Reader
 
 from draftwright._core import (
+    _CONCENTRIC_TOL_MM,
     _DIM_PAD,
     _FONT_SIZE,
     _MARGIN,
@@ -40,9 +42,12 @@ from draftwright.recognition import (
     full_cylinders,
 )
 from draftwright.sheet import (
+    StripDepths,
     _build_zones,
+    _est_hole_table_sizes,
     _layout_geometry,
     _measure_strips,
+    _will_section,
     choose_scale,
 )
 
@@ -54,6 +59,41 @@ _log = logging.getLogger(__name__)
 _SQUARENESS_TOL = 0.05
 _OD_FILL_MIN = 0.8
 _OD_AXIS_TOL = 0.05
+_ScalePick = tuple[float, float, float, float]
+
+
+def _declared_will_section(model, *, is_rotational=False, cx=0.0, cy=0.0) -> bool:
+    """True when a caller-supplied IR model contains a section-driving Z hole.
+
+    Detection-based layout uses recogniser holes; declared-model builds may
+    intentionally supply features detection missed. Inspect the public IR shape
+    duck-typed here so declared sections get the same page/scale reservation.
+    """
+
+    if model is None:
+        return False
+    features = getattr(model, "features", model)
+
+    def feature_member(pt) -> bool:
+        return not (is_rotational and math.hypot(pt[0] - cx, pt[1] - cy) <= _CONCENTRIC_TOL_MM)
+
+    for feat in features:
+        if getattr(feat, "kind", None) not in ("hole", "pattern"):
+            continue
+        frame = getattr(feat, "frame", None)
+        if frame is None or frame.axis != "z":
+            continue
+        members = getattr(feat, "members", ()) or (frame.origin,)
+        if not any(feature_member(m) for m in members):
+            continue
+        bore = getattr(feat, "member", feat)
+        if (
+            getattr(bore, "cbore", None) is not None
+            or getattr(bore, "spotface", None) is not None
+            or not getattr(bore, "through", True)
+        ):
+            return True
+    return False
 
 
 def _import_step(path) -> Compound:
@@ -106,6 +146,53 @@ def _is_rotational(x_size, y_size, od_diam, od_axis_offset) -> bool:
     )
 
 
+def _converge_step_sizing(
+    initial_steps: int,
+    measure_strips: Callable[[int], StripDepths],
+    pick_scale: Callable[[int, StripDepths], _ScalePick],
+    count_legible: Callable[[float], int],
+) -> tuple[_ScalePick, StripDepths, int]:
+    """Choose scale/page with a step-corridor count that matches legibility.
+
+    The right-side step ladder is reserved before the scale is known, but the
+    actual step list is filtered by the chosen scale. Iterate that dependency
+    until it reaches a fixed point; if it cycles, reserve the largest count seen
+    so the sheet is sized conservatively instead of silently accepting whichever
+    value happened to appear on a fixed iteration budget (#520).
+    """
+    n_for_sizing = initial_steps
+    seen: set[int] = set()
+    attempted: list[int] = []
+    max_iter = max(4, initial_steps + 2)
+
+    for _ in range(max_iter):
+        if n_for_sizing in seen:
+            break
+        seen.add(n_for_sizing)
+        attempted.append(n_for_sizing)
+
+        strips = measure_strips(n_for_sizing)
+        scale_pick = pick_scale(n_for_sizing, strips)
+        n_next = count_legible(scale_pick[0])
+        if n_next == n_for_sizing:
+            return scale_pick, strips, n_for_sizing
+        if n_next in seen:
+            n_for_sizing = n_next
+            break
+        n_for_sizing = n_next
+
+    conservative_n = max(attempted + [n_for_sizing], default=initial_steps)
+    strips = measure_strips(conservative_n)
+    scale_pick = pick_scale(conservative_n, strips)
+    _log.warning(
+        "Step-corridor sizing did not converge from %d steps (tried %s); reserving %d steps",
+        initial_steps,
+        attempted,
+        conservative_n,
+    )
+    return scale_pick, strips, conservative_n
+
+
 # A hole is "concentric" with a turned part's rotation axis when its drilling
 # axis is the Z (OD) axis and its opening sits on the part centreline.  Such
 # bores are already dimensioned by the ldr_z bore leaders, so they must not
@@ -202,7 +289,16 @@ def _solids_body(part, src: str = "part"):
 
 
 def _analyse(
-    step_file, title, number, tolerance, drawn_by, out, scale=None, page=None, pmi="off"
+    step_file,
+    title,
+    number,
+    tolerance,
+    drawn_by,
+    out,
+    scale=None,
+    page=None,
+    pmi="off",
+    model=None,
 ) -> Analysis:
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
@@ -317,6 +413,20 @@ def _analyse(
     patterns = find_hole_patterns(holes)
     bosses = find_bosses(part, cyls=(z_cyls, cross_cyls))  # detect once — the one inventory (#264)
     slots = find_slots(part)
+    layout_section = _will_section(
+        holes,
+        patterns,
+        is_rotational=is_rotational,
+        cx=cx,
+        cy=cy,
+    ) or _declared_will_section(model, is_rotational=is_rotational, cx=cx, cy=cy)
+    layout_table_sizes = _est_hole_table_sizes(
+        holes,
+        patterns,
+        bb,
+        font_size=_FONT_SIZE,
+        pad_around_text=_pad_around_text,
+    )
 
     # Choose scale/page, iterating so the reserved step corridor matches the
     # number of steps the legibility gate will actually place (#1) — not the raw
@@ -324,24 +434,35 @@ def _analyse(
     # with 15 tiny treads) reserves a phantom step ladder that blocks a larger
     # scale. Seed conservatively (all faces), then re-gate at the chosen scale;
     # converges in a couple of rounds.
-    n_for_sizing = len(step_zs)
-    strips_i = None
-    for _ in range(3):
-        strips_i = _measure_strips(
+    def _measure_for_step_count(n_steps_i: int) -> StripDepths:
+        return _measure_strips(
             holes,
             patterns,
-            n_for_sizing,
+            n_steps_i,
             bb,
             arrow_length=_arrow_length,
             pad_around_text=_pad_around_text,
         )
-        SCALE, PAGE_W, PAGE_H, TB_W = choose_scale(
-            x_size, y_size, z_size, n_steps=n_for_sizing, scale=scale, page=page, strips=strips_i
+
+    def _pick_for_step_count(n_steps_i: int, strips_i: StripDepths) -> _ScalePick:
+        return choose_scale(
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_steps_i,
+            scale=scale,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
-        n_next = len(_legible_steps(step_zs, bb.min.Z, SCALE)[0])
-        if n_next == n_for_sizing:
-            break
-        n_for_sizing = n_next
+
+    (SCALE, PAGE_W, PAGE_H, TB_W), strips_i, n_for_sizing = _converge_step_sizing(
+        len(step_zs),
+        _measure_for_step_count,
+        _pick_for_step_count,
+        lambda scale_i: len(_legible_steps(step_zs, bb.min.Z, scale_i)[0]),
+    )
     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
@@ -362,7 +483,15 @@ def _analyse(
                 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
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_for_sizing,
+            scale=None,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
         # 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
@@ -393,7 +522,19 @@ def _analyse(
     # View positions + iso empty-rectangle, shared with scale selection (_fits)
     # via _layout_geometry so placement and fit never diverge (#11).  _fit_iso_view
     # later scales the iso to fill its rectangle.
-    _g = _layout_geometry(x_size, y_size, z_size, SCALE, PAGE_W, PAGE_H, TB_W, strips, n_steps)
+    _g = _layout_geometry(
+        x_size,
+        y_size,
+        z_size,
+        SCALE,
+        PAGE_W,
+        PAGE_H,
+        TB_W,
+        strips,
+        n_steps,
+        section=layout_section,
+        table_sizes=layout_table_sizes,
+    )
     fv_hw = _g.fv_hw
     fv_hh = _g.fv_hh
     pv_hh = _g.pv_hh
@@ -461,6 +602,10 @@ def _analyse(
         is_rotational=is_rotational,
         od_axis=od_axis,
         step_zs=step_zs,
+        layout_strips=strips,
+        layout_n_steps=n_steps,
+        layout_section=layout_section,
+        layout_table_sizes=layout_table_sizes,
         sv_right=sv_right,
         iso_right_limit=iso_right_limit,
         SCALE=SCALE,

{draftwright-0.2.10 → 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
@@ -537,13 +559,31 @@ def place_strip_candidates(
     # Fill innermost-first (nearest the view), matching the old cursor's stack order.
     segs.sort(key=lambda s: abs((s[0] if inner == lo else s[1]) - inner))
     todo = list(cands)
-    for seg_lo, seg_hi in segs:
-        if not todo:
-            break
-        cap = int((seg_hi - seg_lo) / pad) + 1
-        take, todo = todo[:cap], todo[cap:]
+
+    def _take_for_segment(items, n):
+        if len(items) <= n:
+            return items, []
+        # Do not let segment-cap slicing preempt the ranked selection step (#357/#393).
+        # `plan_strip` drops the lowest (priority, generated-key), but a narrow segment
+        # can only see the candidates we hand it. Preselect the highest-priority members
+        # for this segment, preserving their original order for crossing-free placement;
+        # ties mirror the generated key below (inner=lo keeps later candidates, inner=hi
+        # keeps earlier candidates).
+        ranked = sorted(
+            enumerate(items),
+            key=lambda item: (
+                (priorities or {}).get(item[1][0], 0.0),
+                item[0] if inner == lo else -item[0],
+            ),
+            reverse=True,
+        )
+        chosen = {i for i, _ in ranked[:n]}
+        take = [nb for i, nb in enumerate(items) if i in chosen]
+        rest = [nb for i, nb in enumerate(items) if i not in chosen]
+        return take, rest
+
+    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.
@@ -551,23 +591,30 @@ 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,
             )
             for k, nb in enumerate(take)
         ]
         res = plan_strip([sc for sc, _ in triples], seg_lo, seg_hi, pad, axis=axis)
+        accepted = []
+        rejected = []
         for sc, (name, build) in triples:
             pos = res.placed.get(sc.key)
             if pos is None:  # segment over its estimated capacity (shouldn't occur)
-                todo.append((name, build))
+                rejected.append((name, build))
                 continue
             dim = build(pos)
             if not force and _box_hits(_geom_box(dim), blockers):  # corridor crosses a leader
-                todo.append((name, build))
+                rejected.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
@@ -575,8 +622,27 @@ def place_strip_candidates(
             # 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))
+                rejected.append((name, build))
                 continue
+            accepted.append(((name, build), dim))
+        return accepted, rejected
+
+    for seg_lo, seg_hi in segs:
+        if not todo:
+            break
+        cap = int((seg_hi - seg_lo) / pad) + 1
+        take, todo = _take_for_segment(todo, cap)
+        rejected_total = []
+        while take:
+            accepted, rejected = _evaluate_segment(take, seg_lo, seg_hi)
+            rejected_total.extend(rejected)
+            vacancies = cap - len(accepted)
+            if vacancies <= 0 or not todo:
+                break
+            fill, todo = _take_for_segment(todo, vacancies)
+            take = [nb for nb, _dim in accepted] + fill
+        todo = todo + rejected_total
+        for (name, _build), dim in accepted:
             # 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))