draftwright 0.3.1__tar.gz → 0.3.2__tar.gz

{draftwright-0.3.1 → draftwright-0.3.2}/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## v0.3.2 — 2026-07-18
+
+The **performance release**: the #602 perf loop (six PRs) plus the
+build123d-drafting-helpers 0.14 upgrade. A dimension-dense drawing now builds
+roughly **14× faster** than v0.3.1 (grid-plate benchmark 40 s → 2.8 s; NIST
+CTC-02 ~107 s → well under half); the full test tier dropped ~14 min → ~3.5 min.
+
+### Performance
+
+- **Placement measures, then builds** (#678, #679): corridor/strip candidates are
+  evaluated on analytical footprints (`dim_footprint`) or a single probe box; an
+  accepted candidate builds its OCC geometry exactly once and re-validates the
+  real box. Dimension constructions on the scattered-plate benchmark: 59 → 21
+  (= the placed count).
+- **Detect once** (#682): the sizing model `_analyse` builds pre-scale is stored
+  on `Analysis.model` and reused as the render model — restoring ADR 0008
+  Amendment 5 ("one inventory, detected once"). ~13 s off CTC-02.
+- **Fillet recognition de-quadratised** (#683): edge→faces adjacency map replaces
+  the O(faces²×edges²) `IsSame` sweep (3.7 M calls on CTC-02); 10.8 s → 4.6 s,
+  byte-identical records.
+- **Lint bounding boxes memoised** (#681): `Drawing.lint()` 0.88 s → 0.07 s per
+  call (identity+location-token-checked cache beside the #143 view-edge cache).
+- **DXF viewport from the known page window** (#680): skips `ezdxf.zoom.extents`'
+  per-entity walk; ~2.4 s per DXF export.
+- **helpers 0.14** (#684): boolean-free dimension ink (upstream #177, filed and
+  fixed same-day) — ~25 ms per `Dimension`, was ~234 ms.
+
+### Changed
+
+- **Tight-span dimensions now render honestly** (helpers 0.14): ISO outside
+  arrows where 0.13 silently degraded to a bare line. Ink extents grow on such
+  dims; placement models the flip analytically. Two placement-golden fixtures
+  re-blessed (ink extent only).
+- Diameter-row leader labels space by **measured text width** and repair
+  helpers' shelf-flip collisions (crowded rows only; ordinary rows unchanged).
+- A plate-thickness dim whose home strip corner is structurally contested falls
+  through to the opposite strip / side view instead of dropping (#684; the
+  underlying one-box-occupancy artifact is tracked as #685).
+
+### Fixed
+
+- `recognise_fillets` neighbour tie-break is order-independent (#683 review).
+- Lint's annotation-box cache prunes departed objects and detects in-place
+  relocation (#681 review).
+
 ## v0.3.1 — 2026-07-17
 
 Also lands the **#635 consolidation epic** (P1–P6, all six children closed): the render

{draftwright-0.3.1 → draftwright-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.1
+Version: 0.3.2
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -682,7 +682,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
-Requires-Dist: build123d-drafting-helpers>=0.13.1
+Requires-Dist: build123d-drafting-helpers>=0.14.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: numpy>=1.24

{draftwright-0.3.1 → draftwright-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.1"
+version = "0.3.2"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,7 +17,7 @@ dependencies = [
     # 3.13+. Mirrors pzfreo/build123d-mcp's dependency handling.
     "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.1",
+    "build123d-drafting-helpers>=0.14.0",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2
     # Apache-2.0 wrapping Google PDFium BSD-3) and ship pre-built wheels with NO native system

{draftwright-0.3.1 → draftwright-0.3.2}/src/draftwright/_core.py

@@ -107,8 +107,10 @@ _QUOTED_RE = re.compile(r"'([^']*)'")
 
 
 @functools.lru_cache(maxsize=512)
-def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> float:
-    """Measured rendered width (page-mm) of *text* at *font_size*.
+def _text_size(
+    text: str, font_size: float, font_path: str | None = PLEX_MONO, font: str = "Arial"
+) -> tuple[float, float]:
+    """Measured rendered (width, height) (page-mm) of *text* at *font_size*.
 
     Uses build123d's ``Text`` — the same primitive ``Dimension``/``HoleCallout``
     stroke their labels with — so callout-width estimates use real glyph metrics
@@ -116,22 +118,27 @@ def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> floa
     (``font_path``), not a system font *name*: name resolution substitutes a
     different font on Linux, which makes this estimate — and the layout it feeds —
     platform-variant (#149). The default is the same face the annotations render
-    with, so estimate and render agree.  Cached because the same numeric labels
-    recur across holes and the rasterisation is the costly part.
+    with, so estimate and render agree.  *font* only matters when a caller opts out
+    of path-pinning (``font_path=None``) — then the *name* resolves through the OS
+    font stack, exactly as the renderer would.  Cached because the same numeric
+    labels recur across holes and the rasterisation is the costly part.
     """
     if not text:
-        return 0.0
-    return (
-        Text(
-            txt=text,
-            font_size=font_size,
-            font_path=font_path,
-            align=(Align.CENTER, Align.CENTER),
-            mode=Mode.PRIVATE,
-        )
-        .bounding_box()
-        .size.X
-    )
+        return (0.0, 0.0)
+    bb = Text(
+        txt=text,
+        font_size=font_size,
+        font=font,
+        font_path=font_path,
+        align=(Align.CENTER, Align.CENTER),
+        mode=Mode.PRIVATE,
+    ).bounding_box()
+    return (bb.size.X, bb.size.Y)
+
+
+def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> float:
+    """Measured rendered width (page-mm) of *text* — see :func:`_text_size`."""
+    return _text_size(text, font_size, font_path)[0]
 
 
 # Cheap mean glyph advance as a fraction of the em (font size), for label-width ESTIMATES in
@@ -556,6 +563,12 @@ class Analysis:
     out: str
     pmi: list
     pmi_mode: str
+    # The PartModel built by _analyse's pre-scale sizing pass (#584 WP1 A) — stored so
+    # the render path reuses it instead of re-running the detectors (ADR 0008 Amdt 5:
+    # one inventory, detected once; #602). Typed `object` because model/ sits above
+    # _core in the DAG. None when the caller declared a model (ADR 0011) or on a
+    # manually-built Analysis — consumers fall back to build_model(a).
+    model: object | None = None
 
 
 _greedy_strip_ys = _greedy_strip_1d

{draftwright-0.3.1 → draftwright-0.3.2}/src/draftwright/analysis.py

@@ -772,4 +772,9 @@ def _analyse(
         out=out,
         pmi=pmi_records,
         pmi_mode=pmi,
+        # The sizing model IS the render model when detection ran (identical inputs by
+        # construction — #584 WP1 A); store it so the pipeline never detects twice
+        # (ADR 0008 Amdt 5, #602). A declared model (layout_model) is NOT stored: the
+        # builder coerces + decorates the caller's model itself.
+        model=sizing_model if layout_model is None else None,
     )

{draftwright-0.3.1 → draftwright-0.3.2}/src/draftwright/annotations/_common.py

@@ -8,11 +8,13 @@ and an AABB overlap test (`_box_hits`). Bottom of the annotations DAG.
 from __future__ import annotations
 
 import logging
+import math
 from dataclasses import dataclass, field
 from typing import Any
 
-from build123d_drafting.helpers import Dimension, SafeDimension
+from build123d_drafting.helpers import DEFAULT_FONT_PATH, Dimension, SafeDimension
 
+from draftwright._core import _text_size
 from draftwright.layout import StripCandidate, plan_strip
 from draftwright.linting.issues import LintIssue
 from draftwright.linting.structural import _centerline_extent
@@ -100,6 +102,84 @@ def _geom_box(o):
         return None
 
 
+def dim_footprint(p1, p2, side, distance, draft, label):
+    """Analytical page-mm AABB ``(x0, y0, x1, y1)`` of the :class:`Dimension` that
+    ``_dim(p1, p2, side, distance, draft, label=label)`` would build — WITHOUT
+    constructing any OCC geometry (#602: a rejected candidate must not pay the
+    rendering cost).
+
+    Mirrors ``helpers.Dimension`` / build123d ``ExtensionLine``: each extension line
+    is the object→dimension-line segment *translated* ``extension_gap`` along itself,
+    so it spans ``p + side·gap`` → ``p + side·(distance + gap)`` — starting ``gap``
+    clear of the object and overshooting the dimension line by the same ``gap``. The
+    measured label is centred on the line's midpoint with its extents swapped for a
+    vertical measured segment (the label is rotated); everything strokes at
+    ``line_width``. With inside arrows the heads lie within the extension-line
+    overshoot (at preset sizes), so they add nothing to the hull.
+
+    Tight spans mirror helpers ≥0.14's outside-arrows flip (``_dim_line_ink``):
+    when the label and both heads don't fit — ``w + 2·al ≥ length`` or the shaft
+    piece beside a head would vanish — the ink extends ``2·arrow_length`` past
+    each end along the line. The label itself stays centred regardless of width
+    (``Dimension`` always passes an explicit ``label_t``, so the hang branch
+    never runs), and when its keep-clear reaches a witness end the witness's
+    overshoot past the dimension line is cut away with it. Without this model
+    the estimate under-covers exactly the dims v0.14 widens, and the
+    accept-time rebuild fails validation until the candidate is dropped (the
+    declared-plate 8 mm thickness dim was the first casualty). Assumes the
+    centred label (``label_offset_x=0``), like the rest of the estimate.
+    Callers accepting a candidate off this footprint must still build the real
+    geometry once and re-validate its box (the #602 validation fallback) so any
+    residual mismatch degrades to a wasted probe, never a collision.
+    """
+    if isinstance(side, str):  # mirror helpers._SIDE_VECTORS ("above"/"below"/"left"/"right")
+        side = {
+            "above": (0.0, 1.0, 0.0),
+            "below": (0.0, -1.0, 0.0),
+            "left": (-1.0, 0.0, 0.0),
+            "right": (1.0, 0.0, 0.0),
+        }[side]
+    sx, sy = side[0], side[1]
+    off = abs(distance)
+    gap = draft.extension_gap
+    dxp, dyp = p2[0] - p1[0], p2[1] - p1[1]
+    # Mirror the renderer's font resolution exactly (helpers._font_path): the pinned
+    # font *file* when set, else the helpers default; an explicit font_path=None means
+    # name-based resolution of draft.font — so pass the name through too.
+    w, h = _text_size(
+        label,
+        draft.font_size,
+        getattr(draft, "font_path", DEFAULT_FONT_PATH),
+        getattr(draft, "font", "Arial"),
+    )
+    hx, hy = (h / 2.0, w / 2.0) if abs(dyp) > abs(dxp) else (w / 2.0, h / 2.0)
+    lcx = (p1[0] + p2[0]) / 2.0 + sx * off
+    lcy = (p1[1] + p2[1]) / 2.0 + sy * off
+    far = off + gap
+    xs = [p1[0] + sx * gap, p2[0] + sx * gap, lcx - hx, lcx + hx]
+    ys = [p1[1] + sy * gap, p2[1] + sy * gap, lcy - hy, lcy + hy]
+    # Helpers ≥0.14 tight-span behaviour. Along the line: the label's half-extent
+    # is w/2 regardless of orientation (the text rotates with the line); outside
+    # arrows extend the ink 2·al past each end when label+heads don't fit. Along
+    # the witness: the label keep-clear (h/2 + pad either side of the line) is
+    # cut out of a witness the centred label reaches, removing its overshoot
+    # unless a stub past the keep-clear survives (gap > h/2 + pad).
+    length = math.hypot(dxp, dyp)
+    al = getattr(draft, "arrow_length", 0.9 * draft.font_size)
+    tpad = getattr(draft, "pad_around_text", 0.0)
+    fits = length > 0 and (w + 2.0 * al < length) and (length / 2.0 - w / 2.0 - tpad > al / 2.0)
+    if not fits and length > 0:
+        ux, uy = dxp / length, dyp / length
+        xs += [p1[0] + sx * off - ux * 2.0 * al, p2[0] + sx * off + ux * 2.0 * al]
+        ys += [p1[1] + sy * off - uy * 2.0 * al, p2[1] + sy * off + uy * 2.0 * al]
+    label_covers_witness = length > 0 and length / 2.0 < w / 2.0 + tpad
+    if not label_covers_witness or gap > h / 2.0 + tpad:
+        xs += [p1[0] + sx * far, p2[0] + sx * far]
+        ys += [p1[1] + sy * far, p2[1] + sy * far]
+    pad = draft.line_width / 2.0
+    return (min(xs) - pad, min(ys) - pad, max(xs) + pad, max(ys) + pad)
+
+
 CROSSABLE_TYPES = frozenset({"Centerline", "CenterlineCircle", "CenterMark"})
 """Annotation types a *dimension* may legitimately cross (ISO 128): centre lines
 and centre marks. A **leader**, by contrast, must avoid them (#305) — so this is a
@@ -415,9 +495,20 @@ class CorridorCandidate:
     # the title block, which is placed after the corridor drain so the strip carve can't see
     # it (#481). ``None`` (every dim) skips the check → byte-identical.
     forbid: object | None = None
-
-
-def solve_corridor(dwg, strip, view, axis, cands, tier):
+    # Analytical ``pos -> (x0, y0, x1, y1)`` footprint of the geometry ``build(pos)``
+    # would produce (#602): lets the strip solve measure and evaluate this candidate
+    # without constructing OCC geometry at all (see :func:`dim_footprint`). ``None``
+    # falls back to one probe build at the strip edge + the box-shift model. CONTRACT:
+    # the footprint must be accurate — its PERPENDICULAR extent feeds the obstacle
+    # band filter, so an underestimate hides obstacles from the carve. The solve
+    # re-validates each built survivor against the blockers, the forbid box and the
+    # band-filtered-out obstacles, so a miss costs a wasted build and a retry, but
+    # keeping footprints truthful (``dim_footprint``, ±0.05 mm) is what keeps that
+    # fallback rare and the placement identical to the probe path.
+    footprint: object | None = None
+
+
+def solve_corridor(dwg, strip, view, axis, cands, tier, corner_reserves=()):
     """One collect-then-solve over every :class:`CorridorCandidate` a shared strip
     accumulated across passes (ADR 0009 end state). Dedup → order → one non-force
     :func:`place_strip_candidates` pass → a force pass for the force-eligible leftovers →
@@ -472,6 +563,7 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
     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}
+    foots = {c.name: c.footprint for c in kept if c.footprint is not None}  # analytical (#602)
     left = {
         n
         for n, _ in place_strip_candidates(
@@ -487,6 +579,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
             priorities=prio,
             anchored=anchored,
             naturals=naturals,
+            footprints=foots,
+            corner_reserves=corner_reserves,
         )
     }
     force_pairs = [(c.name, c.build) for c in kept if c.name in left and c.force]
@@ -501,6 +595,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
                 force_pairs,
                 tier,
                 force=True,
+                footprints=foots,
+                corner_reserves=corner_reserves,
                 features=feats,
                 sizes=sizes,
                 forbid=forbid,
@@ -540,6 +636,10 @@ class PlacementContext:
     corridor_batch: dict = field(default_factory=dict)
     escalations: list = field(default_factory=list)
     detail_requests: list = field(default_factory=list)
+    # Fallthrough callbacks a pass's on_drop queues to run AFTER every corridor has
+    # drained (#684 review): a mid-drain carve could occupy space a later sibling
+    # corridor's force candidate needs; deferral makes "post-drain" literally true.
+    post_drain: list = field(default_factory=list)
     # The drawing's build-state stores, referenced (not owned) by the run's passes (#639).
     # Duck-typed as ``Any`` — matching the untyped ``Drawing._record_build_issue`` they replace —
     # so mypy does not reject the delegating calls below.
@@ -601,10 +701,43 @@ def register_corridor(ctx, key, strip, view, axis, tier, cand):
 def drain_corridors(ctx, dwg):
     """Solve every registered corridor (one :func:`solve_corridor` per strip), then clear
     the batch. Called once, after all corridor-feeding passes have registered. Takes both the
-    scratch *ctx* (the batch) and *dwg* (the drawing :func:`solve_corridor` places onto)."""
-    for b in ctx.corridor_batch.values():
-        solve_corridor(dwg, b["strip"], b["view"], b["axis"], b["cands"], b["tier"])
+    scratch *ctx* (the batch) and *dwg* (the drawing :func:`solve_corridor` places onto).
+
+    Corner coordination (helpers ≥0.14): perpendicular strips of one view contest the
+    view corners — a tight-span dim's outside-arrow tails overhang past the view edge
+    into the sibling strip's band (an 8 mm plate-thickness dim on the left strip dips
+    below the view bottom; the below strip's own tight dim pokes left of the view edge).
+    Solved sequentially and blind, the first drain fills the corner and the second's
+    force-kept candidate hard-drops. So each solve receives the *innermost-tier
+    footprint boxes* of every not-yet-drained same-view sibling's **force** candidates
+    as extra obstacles: the earlier drain places clear of the corner the later one
+    provably needs. Reservation is exact (the candidate's own analytical footprint, at
+    the innermost position it would take), restricted to force candidates — principal
+    dims that would otherwise drop rather than relocate — so best-effort occupants
+    never lose capacity to it. Already-drained siblings need nothing: their dims are
+    real obstacles via :func:`strip_obstacles`."""
+    batches = list(ctx.corridor_batch.values())
+    for i, b in enumerate(batches):
+        reserves = []
+        for sib in batches[i + 1 :]:
+            if sib["view"] != b["view"] or sib["strip"] is None:
+                continue
+            s = sib["strip"]
+            inner_pos = s.anchor + s.direction * s.gap
+            for c in sib["cands"]:
+                if c.force and c.footprint is not None:
+                    box = c.footprint(inner_pos)
+                    if box is not None:
+                        reserves.append(box)
+        solve_corridor(
+            dwg, b["strip"], b["view"], b["axis"], b["cands"], b["tier"], corner_reserves=reserves
+        )
     ctx.corridor_batch = {}
+    # Deferred fallthroughs (opposite-strip retries) run once every strip has drained,
+    # so a retry can never preempt a corner a later sibling's force candidate needs.
+    pending, ctx.post_drain = ctx.post_drain, []
+    for cb in pending:
+        cb()
 
 
 def place_strip_candidates(
@@ -622,6 +755,8 @@ def place_strip_candidates(
     priorities=None,
     anchored=None,
     naturals=None,
+    footprints=None,
+    corner_reserves=(),
 ):
     """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,
@@ -699,13 +834,59 @@ def place_strip_candidates(
     # obstacles out first. The perpendicular extent is independent of the tier position,
     # so a single probe build per candidate suffices; the corridor check below already
     # uses the full 2-D box, so it needs no such filter.
-    pbands = [
-        (b[perp], b[perp + 2]) for _n, build in cands if (b := _geom_box(build(lo))) is not None
-    ]
+    #
+    # That one probe build is also this call's entire MEASUREMENT step (#602): every
+    # candidate is a fixed feature-side anchor (witness origin / leader shaft end)
+    # plus a dim line that translates with the tier position, so its box at position
+    # ``pos`` is the probe box with the OUTWARD stacking-axis edge shifted by
+    # ``pos - lo`` — no further geometry is built to evaluate a position. The
+    # segment loop below re-solves and re-checks on these predicted boxes only;
+    # each finally-accepted candidate is built once and its real box re-validated
+    # (a prediction miss degrades to a later-segment retry, never a collision).
+    # A candidate with an analytical *footprints* entry (#602) needs no probe build at
+    # all — its box at any position is computed, not measured.
+    probe_boxes = {
+        name: (footprints[name](lo) if name in (footprints or {}) else _geom_box(build(lo)))
+        for name, build in cands
+    }
+    pbands = [(b[perp], b[perp + 2]) for b in probe_boxes.values() if b is not None]
+
+    def _predicted_box(name, pos):
+        fp = (footprints or {}).get(name)
+        if fp is not None:
+            return fp(pos)
+        pb = probe_boxes.get(name)
+        if pb is None:
+            return None
+        box = list(pb)
+        # The moving edge is the one AWAY from the view (`inner`); the feature-side
+        # edge is anchored geometry and stays put.
+        box[idx + 2 if inner == lo else idx] += pos - lo
+        return tuple(box)
+
     occupied = strip_obstacles(dwg, view=view, crossable=CROSSABLE_TYPES)
+    # Obstacles OUTSIDE the batch's predicted perpendicular band are invisible to the
+    # carve below by design — but that makes the band prediction itself load-bearing: a
+    # candidate whose real geometry exceeds its predicted band could land on one with no
+    # check ever seeing it (review #679). Keep the filtered-out set: the post-build
+    # validation re-checks each survivor's REAL box against it. In-band overlaps are NOT
+    # validated — witness lines legitimately cross the boxes of dims stacked further in
+    # (ISO 129-1), which is exactly why the carve projects onto the stacking axis only.
+    out_of_band: list = []
     if pbands:
         band_lo, band_hi = min(p[0] for p in pbands), max(p[1] for p in pbands)
-        occupied = [b for b in occupied if b[perp] < band_hi and b[perp + 2] > band_lo]
+        in_band = [b for b in occupied if b[perp] < band_hi and b[perp + 2] > band_lo]
+        out_of_band = [b for b in occupied if not (b[perp] < band_hi and b[perp + 2] > band_lo)]
+        occupied = in_band
+        # Corner reserves (drain_corridors): projected boxes of not-yet-drained sibling
+        # corridors' force candidates. Same band relevance filter as real obstacles, but
+        # NEVER in out_of_band — a reserve is a projection, not geometry, so a survivor's
+        # real box must not be failed against it.
+        occupied += [
+            r
+            for r in corner_reserves
+            if r is not None and r[perp] < band_hi and r[perp + 2] > band_lo
+        ]
     blockers = () if force else corridor_blockers(dwg, view)
     segs = carve_free_segments(lo, hi, [(b[idx], b[idx + 2]) for b in occupied], pad)
     # Fill innermost-first (nearest the view), matching the old cursor's stack order.
@@ -764,8 +945,15 @@ def place_strip_candidates(
             if pos is None:  # segment over its estimated capacity (shouldn't occur)
                 rejected.append((name, build))
                 continue
-            dim = build(pos)
-            if not force and _box_hits(_geom_box(dim), blockers):  # corridor crosses a leader
+            # Predicted box, not built geometry (#602): the refill loop re-evaluates
+            # every already-accepted candidate each iteration, so building here made
+            # the drain quadratic in OCC builds.
+            box = _predicted_box(name, pos)
+            if box is None:  # probe didn't bbox — measure the old way, once per check
+                box = _geom_box(build(pos))
+            if (
+                not force and box is not None and _box_hits(box, blockers)
+            ):  # corridor crosses a leader
                 rejected.append((name, build))
                 continue
             # A forbidden box (the title block, #481) is rejected even under force — it is
@@ -773,10 +961,10 @@ def place_strip_candidates(
             # must still not stack onto it. `forbid` maps names to their box (only GD&T sets it,
             # so dims are byte-identical). Returned unplaced → the caller's on_drop fallthrough.
             fb = (forbid or {}).get(name)
-            if fb is not None and _box_hits(_geom_box(dim), (fb,)):
+            if fb is not None and box is not None and _box_hits(box, (fb,)):
                 rejected.append((name, build))
                 continue
-            accepted.append(((name, build), dim))
+            accepted.append(((name, build), pos))
         return accepted, rejected
 
     for seg_lo, seg_hi in segs:
@@ -792,9 +980,32 @@ def place_strip_candidates(
             if vacancies <= 0 or not todo:
                 break
             fill, todo = _take_for_segment(todo, vacancies)
-            take = [nb for nb, _dim in accepted] + fill
+            take = [nb for nb, _pos in accepted] + fill
+        # Build each survivor ONCE at its solved position and re-validate the real box
+        # (the #602 validation fallback): a prediction miss is returned to the pool for
+        # the next segment — exactly where a same-segment rejection would have sent it.
+        placed = []
+        for (name, build), pos in accepted:
+            dim = build(pos)
+            real = _geom_box(dim)
+            if real is not None:
+                if not force and _box_hits(real, blockers):
+                    rejected_total.append((name, build))
+                    continue
+                fb = (forbid or {}).get(name)
+                if fb is not None and _box_hits(real, (fb,)):
+                    rejected_total.append((name, build))
+                    continue
+                # A survivor whose real geometry escaped the batch's predicted
+                # perpendicular band could overlap an obstacle the carve was never
+                # shown (review #679) — the one collision class the stacking-axis
+                # model cannot tolerate. Never fires while predictions are accurate.
+                if _box_hits(real, out_of_band):
+                    rejected_total.append((name, build))
+                    continue
+            placed.append((name, dim))
         todo = todo + rejected_total
-        for (name, _build), dim in accepted:
+        for name, dim in placed:
             # 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))