draftwright 0.2.3__tar.gz → 0.2.5__tar.gz

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

@@ -2,6 +2,46 @@
 
 ## 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
+the shared "above-view" dimension corridor, adds a layout-overflow safety net, and
+makes two more drop paths non-silent.
+
+### Changed
+
+- **Plan-view X location dimensions, side-view Y location dimensions, and a
+  coincident slot-position dimension now share one collect-then-solve pass** (ADR
+  0009 Amendment 6, #345/#346). Previously each pass carved the strip independently,
+  so a hole location and a slot position measuring the same datum span could both be
+  drawn, and the location ladder could come out non-monotonic. One solve now dedups
+  the coincident span (keeping the higher-priority location dimension) and orders the
+  whole ladder as segregated, monotonic runs — feature-size dimensions nearest the
+  view, datum locations nesting outward by distance.
+
+### Fixed
+
+- **`choose_scale` never returns an overflowing layout** (#350). Scale selection
+  could pick a scale whose composed block layout exceeded the drawable area; it now
+  rejects any overflowing candidate.
+- **A hole location and a coincident slot position are no longer drawn twice** (#345),
+  including at fractional datum distances where a display-value snap gap previously let
+  the duplicate escape deduplication.
+- **The plan-view location ladder is monotonic** (#346) — running dimensions off a
+  shared datum stack outward in ascending order instead of interleaving.
+- **A dropped balloon is non-silent** (#387). A balloon that cannot be placed now
+  reports the drop and clears its `callout_dropped` state precisely, instead of
+  vanishing with no on-sheet signal.
+
 ## v0.2.3 — 2026-07-03
 
 A large patch release: the **annotation-placement engine was rebuilt** as a

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.3
+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
@@ -700,24 +700,70 @@ Description-Content-Type: text/markdown
 Automated technical-drawing generation for [build123d](https://github.com/gumyr/build123d).
 Point it at a solid (or a STEP file) and get a fully-annotated multi-view engineering
 drawing — orthographic views, dimensions, section A–A, ISO hatching, title block — ready
-to export as SVG and DXF.
+to export as PDF, SVG, and DXF.
+
+![Example engineering drawing generated by draftwright](docs/images/example.png)
+
+*A mounting plate, generated automatically: three dimensioned orthographic views, a
+counterbored bore callout (`⌀18 THRU ⊔ ⌀30 ↓14`), a `4× ⌀8 THRU` hole-pattern callout,
+Section A–A with ISO hatching, an isometric, and an ISO 7200 title block — every
+annotation placed by the engine.*
+
+## Quick start
+
+```
+pip install draftwright
+```
+
+### Command line
+
+Point it at a STEP file — that's the whole workflow:
+
+```
+draftwright my_part.step --title "Mounting Plate" --number DWG-001
+# writes my_part.pdf (the default)
+```
+
+Choose formats, scale, and page; or emit an editable drawing script:
+
+```
+draftwright my_part.step --format pdf,dxf     # also: svg, all
+draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
+draftwright my_part.step --script             # write an editable .py drawing script
+```
+
+`draftwright --help` lists every flag; `--version` prints the version.
+
+### Python
+
+One call turns a build123d solid (or a STEP file) into a drawing. This is the exact
+part in the image above:
 
 ```python
 from build123d import Box, Cylinder, Pos
 from draftwright import make_drawing
 
-part = Box(80, 60, 20) - Pos(0, 0, 5) * Cylinder(8, 20)
-make_drawing(part, out="my_part", title="Mounting Block", number="DWG-001")
-# writes my_part.svg and my_part.dxf
+part = (
+    Box(100, 70, 24)
+    - Pos(0, 0, 0) * Cylinder(9, 40)     # central bore, counterbored below
+    - Pos(0, 0, 8) * Cylinder(15, 20)    # counterbore → triggers Section A–A
+    - Pos(-38, 24, 0) * Cylinder(4, 40)  # 4× corner holes (recognised as a pattern)
+    - Pos(38, 24, 0) * Cylinder(4, 40)
+    - Pos(-38, -24, 0) * Cylinder(4, 40)
+    - Pos(38, -24, 0) * Cylinder(4, 40)
+)
+make_drawing(part, out="my_part", title="Mounting Plate", number="DWG-001")
+# writes my_part.svg and my_part.dxf   (or from a STEP file: make_drawing(step_file="p.step", out="my_part"))
 ```
 
-Or from the command line:
+For inspection and editing, get a composable `Drawing`:
 
-```
-draftwright my_part.step --title "Mounting Block" --number DWG-001
-# writes my_part.pdf (the default); add --format to choose:
-draftwright my_part.step --format pdf,dxf    # PDF + DXF
-draftwright my_part.step --format all        # PDF + SVG + DXF
+```python
+from draftwright import build_drawing
+
+dwg = build_drawing(part, title="Mounting Plate")
+issues = dwg.lint()                       # list[LintIssue] — coverage, page bounds, ISO
+svg_path, dxf_path = dwg.export("my_part")
 ```
 
 ## What it produces
@@ -734,48 +780,14 @@ draftwright my_part.step --format all        # PDF + SVG + DXF
 - **Lint** — `Drawing.lint()` checks annotation coverage, page bounds, and ISO compliance
   and returns structured `LintIssue` objects
 
-All output is real build123d geometry, so SVG and DXF export come from the same source
-and dimensions are live on the DXF layer.
-
-## Installation
-
-```
-pip install draftwright
-```
+All output is real build123d geometry, so PDF, SVG, and DXF all come from the same
+source and dimensions are live on the DXF layer.
 
 Requires Python ≥ 3.10 and build123d ≥ 0.9.0. Annotation primitives are provided by
 [`build123d-drafting-helpers`](https://github.com/pzfreo/build123d-drafting-helpers),
-which is installed automatically as a dependency.
-
-## Usage
+installed automatically as a dependency.
 
-### From a build123d solid
-
-```python
-from draftwright import make_drawing, build_drawing, Drawing
-
-# One-shot: write SVG + DXF
-make_drawing(part, out="drawing", title="My Part", number="DWG-001")
-
-# Composable: get a Drawing object to inspect or extend
-dwg = build_drawing(part, title="My Part")
-issues = dwg.lint()          # list[LintIssue]
-svg_path, dxf_path = dwg.export("drawing")
-```
-
-### From a STEP file
-
-```python
-from draftwright import make_drawing
-make_drawing(step_file="part.step", out="drawing")
-```
-
-Or via the CLI:
-
-```
-draftwright part.step --out drawing --scale 2 --page A3
-draftwright part.step --script   # write an editable .py drawing script instead
-```
+## Going further
 
 ### Scale and page control
 
@@ -833,3 +845,5 @@ build → plan → render). See
 [`docs/target-architecture.md`](docs/target-architecture.md) and
 [`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
 selection, annotation placement, and section rendering.
+
+The codebase has been entirely written by LLM (Claude Code) under detailed guidance from a person.

{draftwright-0.2.3 → draftwright-0.2.5}/README.md

@@ -9,24 +9,70 @@
 Automated technical-drawing generation for [build123d](https://github.com/gumyr/build123d).
 Point it at a solid (or a STEP file) and get a fully-annotated multi-view engineering
 drawing — orthographic views, dimensions, section A–A, ISO hatching, title block — ready
-to export as SVG and DXF.
+to export as PDF, SVG, and DXF.
+
+![Example engineering drawing generated by draftwright](docs/images/example.png)
+
+*A mounting plate, generated automatically: three dimensioned orthographic views, a
+counterbored bore callout (`⌀18 THRU ⊔ ⌀30 ↓14`), a `4× ⌀8 THRU` hole-pattern callout,
+Section A–A with ISO hatching, an isometric, and an ISO 7200 title block — every
+annotation placed by the engine.*
+
+## Quick start
+
+```
+pip install draftwright
+```
+
+### Command line
+
+Point it at a STEP file — that's the whole workflow:
+
+```
+draftwright my_part.step --title "Mounting Plate" --number DWG-001
+# writes my_part.pdf (the default)
+```
+
+Choose formats, scale, and page; or emit an editable drawing script:
+
+```
+draftwright my_part.step --format pdf,dxf     # also: svg, all
+draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
+draftwright my_part.step --script             # write an editable .py drawing script
+```
+
+`draftwright --help` lists every flag; `--version` prints the version.
+
+### Python
+
+One call turns a build123d solid (or a STEP file) into a drawing. This is the exact
+part in the image above:
 
 ```python
 from build123d import Box, Cylinder, Pos
 from draftwright import make_drawing
 
-part = Box(80, 60, 20) - Pos(0, 0, 5) * Cylinder(8, 20)
-make_drawing(part, out="my_part", title="Mounting Block", number="DWG-001")
-# writes my_part.svg and my_part.dxf
+part = (
+    Box(100, 70, 24)
+    - Pos(0, 0, 0) * Cylinder(9, 40)     # central bore, counterbored below
+    - Pos(0, 0, 8) * Cylinder(15, 20)    # counterbore → triggers Section A–A
+    - Pos(-38, 24, 0) * Cylinder(4, 40)  # 4× corner holes (recognised as a pattern)
+    - Pos(38, 24, 0) * Cylinder(4, 40)
+    - Pos(-38, -24, 0) * Cylinder(4, 40)
+    - Pos(38, -24, 0) * Cylinder(4, 40)
+)
+make_drawing(part, out="my_part", title="Mounting Plate", number="DWG-001")
+# writes my_part.svg and my_part.dxf   (or from a STEP file: make_drawing(step_file="p.step", out="my_part"))
 ```
 
-Or from the command line:
+For inspection and editing, get a composable `Drawing`:
 
-```
-draftwright my_part.step --title "Mounting Block" --number DWG-001
-# writes my_part.pdf (the default); add --format to choose:
-draftwright my_part.step --format pdf,dxf    # PDF + DXF
-draftwright my_part.step --format all        # PDF + SVG + DXF
+```python
+from draftwright import build_drawing
+
+dwg = build_drawing(part, title="Mounting Plate")
+issues = dwg.lint()                       # list[LintIssue] — coverage, page bounds, ISO
+svg_path, dxf_path = dwg.export("my_part")
 ```
 
 ## What it produces
@@ -43,48 +89,14 @@ draftwright my_part.step --format all        # PDF + SVG + DXF
 - **Lint** — `Drawing.lint()` checks annotation coverage, page bounds, and ISO compliance
   and returns structured `LintIssue` objects
 
-All output is real build123d geometry, so SVG and DXF export come from the same source
-and dimensions are live on the DXF layer.
-
-## Installation
-
-```
-pip install draftwright
-```
+All output is real build123d geometry, so PDF, SVG, and DXF all come from the same
+source and dimensions are live on the DXF layer.
 
 Requires Python ≥ 3.10 and build123d ≥ 0.9.0. Annotation primitives are provided by
 [`build123d-drafting-helpers`](https://github.com/pzfreo/build123d-drafting-helpers),
-which is installed automatically as a dependency.
-
-## Usage
+installed automatically as a dependency.
 
-### From a build123d solid
-
-```python
-from draftwright import make_drawing, build_drawing, Drawing
-
-# One-shot: write SVG + DXF
-make_drawing(part, out="drawing", title="My Part", number="DWG-001")
-
-# Composable: get a Drawing object to inspect or extend
-dwg = build_drawing(part, title="My Part")
-issues = dwg.lint()          # list[LintIssue]
-svg_path, dxf_path = dwg.export("drawing")
-```
-
-### From a STEP file
-
-```python
-from draftwright import make_drawing
-make_drawing(step_file="part.step", out="drawing")
-```
-
-Or via the CLI:
-
-```
-draftwright part.step --out drawing --scale 2 --page A3
-draftwright part.step --script   # write an editable .py drawing script instead
-```
+## Going further
 
 ### Scale and page control
 
@@ -142,3 +154,5 @@ build → plan → render). See
 [`docs/target-architecture.md`](docs/target-architecture.md) and
 [`docs/adr/`](docs/adr/). The engine handles view layout (strip/zone model), scale
 selection, annotation placement, and section rendering.
+
+The codebase has been entirely written by LLM (Claude Code) under detailed guidance from a person.

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

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

{draftwright-0.2.3 → 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),
@@ -583,7 +594,11 @@ _PAGE_SIZES = {
     "A0": (1189.0, 841.0),
 }
 
-_SCALES = [10.0, 5.0, 2.0, 1.0, 0.5, 0.2]
+# ISO 5455 scale series (1-2-5 decades). Enlargements + 1:1 first, then reductions
+# down to 1:10000 so a very large part still gets a scale that FITS rather than an
+# overflowing layout (#350). Ordered largest-scale-first for "least reduction first".
+_SCALES = [10.0, 5.0, 2.0, 1.0]
+_SCALES += [0.5, 0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, 0.0002, 0.0001]
 
 # Horizontal page budget to reserve for the isometric view during scale
 # selection and view placement, as a fraction of bbox_max * scale.  This is a
@@ -634,6 +649,19 @@ _LADDER = [
     (0.2, 841.0, 594.0, 150.0),  # A1 1:5
     (0.5, 1189.0, 841.0, 150.0),  # A0 1:2
     (0.2, 1189.0, 841.0, 150.0),  # A0 1:5
+    # Past 1:5 keep reducing on A0 (the largest sheet) through the rest of the ISO 5455
+    # series, so a part too big for A0 1:5 still gets a scale that FITS rather than an
+    # overflowing layout (#350). A0 1:10000 holds anything up to ~8.4 m of drawn height.
+    (0.1, 1189.0, 841.0, 150.0),  # A0 1:10
+    (0.05, 1189.0, 841.0, 150.0),  # A0 1:20
+    (0.02, 1189.0, 841.0, 150.0),  # A0 1:50
+    (0.01, 1189.0, 841.0, 150.0),  # A0 1:100
+    (0.005, 1189.0, 841.0, 150.0),  # A0 1:200
+    (0.002, 1189.0, 841.0, 150.0),  # A0 1:500
+    (0.001, 1189.0, 841.0, 150.0),  # A0 1:1000
+    (0.0005, 1189.0, 841.0, 150.0),  # A0 1:2000
+    (0.0002, 1189.0, 841.0, 150.0),  # A0 1:5000
+    (0.0001, 1189.0, 841.0, 150.0),  # A0 1:10000
 ]
 
 

{draftwright-0.2.3 → 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.3 → draftwright-0.2.5}/src/draftwright/annotations/_common.py

@@ -269,7 +269,137 @@ def _segment_hits_box(p1, p2, box) -> bool:
     return any(_seg_seg(p1, p2, corners[i], corners[(i + 1) % 4]) for i in range(4))
 
 
-def place_strip_candidates(dwg, strip, view, axis, cands, tier, *, force=False):
+@dataclass
+class CorridorCandidate:
+    """One datum-referenced linear dim collected for a shared corridor's single solve
+    (ADR 0009 end state, #345/#346). Multiple render passes (`render_locations`,
+    `render_slots`) feed the SAME above-view strip; committing per-pass interleaves the
+    dims and cannot dedup coincident spans. Each pass instead registers a candidate here;
+    one :func:`solve_corridor` per strip dedups, orders, and places the whole set.
+
+    Attributes:
+        name/build: the ``(name, pos->Dimension)`` pair :func:`place_strip_candidates`
+            consumes — unchanged.
+        order:      sort key placing the candidate in the corridor ladder. Location dims
+            key on datum distance (the monotonic ISO ladder); size dims form a separate
+            contiguous run so a slot length never lands mid-ladder (#346).
+        dedup:      coincidence key ``(view, meas-origin, meas-endpoint)`` on the MEASURED
+            axis, or ``None`` to never dedup (size dims). Two candidates with equal keys are
+            the same physical dimension; the higher-``precedence`` one survives (#345).
+        precedence: dedup survivor rank — a hole *location* dim (feeds coverage/table
+            escalation) outranks a coincident slot *position* line.
+        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
+            no alternate view); size/position slot dims fall through instead (``on_drop``).
+    """
+
+    name: str
+    build: object
+    order: tuple
+    on_place: object
+    on_drop: object
+    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):
+    """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 →
+    dispatch each candidate's ``on_place``/``on_drop``. This is what removes the duplicate
+    span (#345) and the interleaved ladder (#346) by construction: a single solve sees the
+    full set, so coincident spans collapse and the order is one monotonic chain."""
+    if not cands:
+        return
+    # Dedup: keep the highest-precedence candidate per coincidence key (tie-break on name,
+    # deterministic — ADR 0001). A displaced duplicate is a *loser*: while its winner is
+    # drawn it is silently dropped (never starved, so firing its pass's drop lint would be a
+    # false report) — but if the winner itself fails to place, the top loser is promoted so
+    # the measurement still gets its pass's fallthrough/drop handling (no silent vanish).
+    winners: dict = {}
+    for c in cands:
+        if c.dedup is None:
+            continue
+        prev = winners.get(c.dedup)
+        # Winner: highest precedence, ties broken by the lexicographically smaller name.
+        if (
+            prev is None
+            or c.precedence > prev.precedence
+            or (c.precedence == prev.precedence and c.name < prev.name)
+        ):
+            winners[c.dedup] = c
+    kept = [c for c in cands if c.dedup is None or winners.get(c.dedup) is c]
+    losers: dict = {}  # dedup key → its displaced candidates (highest precedence first)
+    for c in cands:
+        if c.dedup is not None and winners.get(c.dedup) is not c:
+            losers.setdefault(c.dedup, []).append(c)
+    for group in losers.values():
+        group.sort(key=lambda c: (-c.precedence, c.name))
+    kept.sort(key=lambda c: c.order)
+
+    def _promote_losers(dropped_winner):
+        # The winner did not place → hand its measurement to the best surviving loser
+        # (e.g. the slot position's below-strip fallthrough), then stop.
+        for loser in losers.get(dropped_winner.dedup, ()):
+            loser.on_drop(loser.name)
+            break
+
+    if strip is None:  # no such strip on this drawing — every candidate drops
+        for c in kept:
+            c.on_drop(c.name)
+            if c.dedup is not None:
+                _promote_losers(c)
+        return
+    pairs = [(c.name, c.build) for c in kept]
+    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, features=feats
+            )
+        }
+        if force_pairs
+        else set()
+    )
+    for c in kept:
+        placed = c.name not in left or (c.force and c.name not in still)
+        if placed:
+            c.on_place(c.name)  # placed in the corridor-respecting pass or the force pass
+        else:
+            c.on_drop(c.name)  # dropped / not force-kept — the pass's drop handler runs
+            if c.dedup is not None:  # a deduped winner failed → promote its top loser
+                _promote_losers(c)
+
+
+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)``."""
+    b = dwg._corridor_batch.setdefault(
+        key, {"strip": strip, "view": view, "axis": axis, "tier": tier, "cands": []}
+    )
+    b["cands"].append(cand)
+
+
+def drain_corridors(dwg):
+    """Solve every registered corridor (one :func:`solve_corridor` per strip), then clear
+    the batch. Called once, after all corridor-feeding passes have registered."""
+    for b in dwg._corridor_batch.values():
+        solve_corridor(dwg, b["strip"], b["view"], b["axis"], b["cands"], b["tier"])
+    dwg._corridor_batch = {}
+
+
+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
@@ -357,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
 
 
@@ -372,8 +504,23 @@ def carve_free_position(dwg, strip, view, axis, tier, perp_span, *, outermost=Fa
     next — the height-ladder leapfrog chain, where each step dim's witness base is the
     previous dim's line — uses this. Same carve: outer-label tier reservation, the
     perpendicular-band filter (*perp_span* drops obstacles disjoint from this dim's own
-    perpendicular extent), and innermost-first fill. No corridor check (a single-strip
-    ladder has no alternate view to route to; obstacle tiers are still avoided)."""
+    perpendicular extent), and innermost-first fill.
+
+    **No corridor check, by construction — not just omission.** This avoids obstacle
+    *tiers* on the strip but does not reject a position whose witness *corridor* (feature
+    → dim line, across *perp_span*) crosses a leader/callout. Crucially, a single-position
+    return *cannot* fix a corridor crossing by choosing a different tier: every tier on
+    one side shares that corridor, and a farther tier's corridor is a **superset** of a
+    nearer one's, so the innermost free tier this already returns has the shortest
+    corridor and the fewest crossings — moving outward only adds crossings. Corridor
+    avoidance is therefore inherently a **relocation** problem (reject this position →
+    place on another view/side), which is :func:`place_strip_candidates`' job and out of
+    scope for a position return. Per caller: the height-ladder chain has no alternate
+    view (correct to omit); public ``Drawing.place_dim`` takes the view AND side from the
+    caller, so it cannot relocate; the PMI dim helpers already fall through sides
+    (``_try_above(...) or _try_below(...)``) and are where a corridor-reject would go if
+    ever wanted. Left as a documented known-limitation — the crossing is unobserved on
+    the corpus (the cleanliness ratchet would catch it)."""
     if strip is None:
         return None
     lo, hi, inner = strip_free_span(strip)