draftwright 0.4.6__tar.gz → 0.4.8__tar.gz

{draftwright-0.4.6 → draftwright-0.4.8}/CHANGELOG.md

@@ -1,5 +1,92 @@
 # Changelog
 
+## Unreleased
+
+### Added
+
+- Recogniser co-development now has a one-command, wheel-based two-checkout check; an exact
+  registry-release evidence record; automated dependency PR preparation; and documented landing,
+  compatibility, deprecation, rollback, ownership, and CI-budget rules. Dependency PRs retain the
+  canonical coverage/Codecov gate while avoiding four duplicate platform suites and the slow tier
+  (#1170).
+- A versioned, independently authored STEP-analysis corpus and evaluator now report detection
+  recall/false positives, parameter fidelity, and downstream usefulness as separate evidence
+  layers. Hash-pinned positive, negative, ambiguous, compound, and topology-order-variant fixtures,
+  per-layer diagnostics, and an anti-self-validation mutation prevent recogniser output from
+  defining its own denominator (#1169).
+- Draftwright now validates the released `b123d-recognisers` 0.2.0 capability manifest against
+  an exhaustive consumer-owned declaration of IR, DSL, generated-code, drawing, completeness,
+  and documentation states. Unknown families, stale implementations, record-schema drift, and
+  unevidenced state transitions fail closed; intentionally geometry-only repeating-profile
+  evidence remains usable without acquiring invented drafting semantics.
+
+### Changed
+
+- Updated the exact `b123d-recognisers` production lock from 0.2.0 to 0.2.1.
+  The immutable PyPI wheel/sdist hashes and capability-manifest digest
+  `383a196329ed6a3d1bf88f18ae4ff75613c032f35d40f2b53302b6744da4d19e` are
+  recorded in `.github/recogniser-release.json`; focused compatibility evidence and the
+  normal consumer gates run on the generated PR.
+
+### Fixed
+
+- Stable release and TestPyPI snapshot builds now update package metadata and the independently
+  validated Draftwright consumer-contract identity atomically. This prevents stripped `.dev0`
+  and numbered development artifacts from failing their own capability-contract validation.
+- Installed wheels validate every portable recogniser-contract property without requiring the
+  repository-only behavior-test files whose existence remains a strict source/CI gate. This keeps
+  the packaged STEP-analysis evaluator usable without weakening evidence checks in development.
+- Post-release development-version bumps now update the consumer-contract identity on a branch,
+  open a protected PR, and dispatch the narrow maintenance gate instead of attempting a rejected
+  direct push to protected `main` (#1170).
+- Machined-feature leader callouts now collect all clear alternatives within each
+  post-drain pass and use a bounded maximum-cardinality, minimum-leader-length
+  assignment instead of taking corners greedily in feature order (#740). If a
+  deterministic alternative-count, pass-size, candidate-pair, or search budget is
+  reached, placement retains the legacy greedy result or a result no worse than it
+  rather than losing additional callouts. Pre-drain diameter clearance ranking and
+  its Policy-B fallback remain unchanged.
+- Compatible automatic/deferred sparse ordinary side/plan hole and post-drain
+  machined-feature callouts now share one bounded same-view leader inventory
+  (#1166). Pattern, profiled-bore, and dense table-eligible hole queues retain
+  their specialised established paths because their winners affect downstream
+  furniture/table semantics or await #798 silhouette-aware routing. The solve
+  preserves required/priority-ranked evidence, rejects new-leader crossings,
+  checks complete leader ink against actual-width fixed dimension/witness,
+  arrow, label, and centre-furniture components (including rendered arrows on
+  shifted dimensions and component-local dashed circular centre furniture);
+  fixed residual faces and the selected survivor both require each tessellation
+  triangle to fit one same analytical component rather than merely the union,
+  plus exact continuous OCC containment for curved faces; residual lowering
+  also retains filled datum/GD&T faces absent from segment metadata; if candidate
+  or selected-survivor construction raises, or a survivor fails validation, the
+  bad alternative fails closed and the canonical lazy producer tail is replayed
+  instead of falsely dropping an otherwise valid callout; an all-invalid tail is
+  reported as validation-stage geometry failure rather than no clear room (so
+  scale fallback does not retry a non-spatial helper defect), while compiler
+  invariant violations such as a missing semantic callout label remain loud;
+  only explicitly marked global turning axes permit an arrow-local leader-tip
+  attachment; near-collinear shaft travel and ownerless section/cutting lines
+  remain fixed ink. The solve prefers
+  clear routes over explicit Policy-B fallbacks, and then minimises real leader
+  length. Provisional sections cannot veto that primary result: one separately
+  bounded refinement may choose an equally complete leader inventory that clears
+  their exact components, after which the final section performs one bounded
+  end-symbol repair and yields if exact ink still conflicts. The selected OCC survivor is validated against the same analytical
+  ink contract. A retained fixed-ink crossing now emits the machine-readable
+  `feature_leader_crossing` info finding instead of appearing lint-clean. Candidate,
+  fixed-component lowering, fixed-obstacle-probe, pair, and exact-search work is
+  bounded; the fixed inventory is lowered once and reused with the producer's
+  legacy lazy result as the floor, including state-cap exhaustion; page,
+  own-silhouette, and title-reservation constraints remain hard in every fallback.
+  A replay that exhausts exact fixed-probe classification is retained visibly as
+  `feature_leader_fixed_ink_unverified` rather than rescanning past the cap, and
+  that uncertainty participates in the legibility quality inventory.
+  Trace output preserves an abandoned fully admitted inventory when state search
+  exhausts, records the producer-floor replay separately, and names exact committed/provisional components,
+  refinement status, and competing blockers; live
+  single-callout edits remain immediate.
+
 ## v0.4.6 — 2026-08-15
 
 ### Changed

{draftwright-0.4.6 → draftwright-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.6
+Version: 0.4.8
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,7 +684,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: antlr4-python3-runtime<4.10
-Requires-Dist: b123d-recognisers==0.1.0
+Requires-Dist: b123d-recognisers==0.2.1
 Requires-Dist: build123d-drafting-helpers>=0.14.1
 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'

{draftwright-0.4.6 → draftwright-0.4.8}/docs/adr/README.md

@@ -30,7 +30,7 @@ architecture** table; open retired or superseded records only for design history
 | [0011](0011-ir-as-public-input.md) | The IR as a public input: declare features, don't only detect them | Accept the feature IR as public input through declarations and the `Sheet` façade. | Accepted; core landed; #62/#462/#495 remain | `test_declare.py`, `test_object_aspects.py`, `test_sheet_gdt.py` |
 | [0012](0012-edits-as-pinned-priority-candidates-in-the-global-solve.md) | User annotation edits are pinned, priority-ranked corridor candidates | Drain recorded semantic edits through corridor placement with pin and priority. | Accepted; partially landed; full recomposition/parity remains #426/#707 (#661 detail views landed) | `test_make_drawing.py`, `test_sheet_emit.py` |
 | [0013](0013-uniform-recognition-and-shared-package.md) | A uniform recogniser/feature contract and shared `b123d-recognisers` deployment | Enforce the geometry-only contract in the shared package and consume it through Draftwright's record→IR boundary. | Accepted; Phases 1–2 deployed | `test_external_recognition_boundary.py`, `test_detect_registry.py`, package semantic goldens |
-| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering. | Accepted; supersedes 0009 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_import_boundaries.py` |
+| [0014](0014-collect-then-solve-annotation-placement.md) | Collect-then-solve annotation placement (as built) | Collect, select, assign, and deterministically solve annotations per corridor before rendering; compatible sparse ordinary side/plan hole and post-drain machined leaders share one bounded late inventory. | Accepted; supersedes 0009; #740 Amendment 1; #1166 Amendment 2 | `test_carve_free_position_callers.py`, `test_strip_layout.py`, `test_layout_property.py`, `test_issue_740_leader_assignment.py`, `test_issue_1166_cross_pass_feature_leaders.py`, `test_import_boundaries.py` |
 | [0015](0015-part-drawing-compiler-as-built.md) | The part-drawing compiler, as built | Use one detected-or-declared feature IR and planner-fed dimension groups as the compiler waist. | Accepted; supersedes 0008 | `test_part_model.py`, `test_detect_once.py`, `test_import_boundaries.py` |
 | [0016](0016-declared-dimensioning-intent.md) | Declared dimensioning intent: capture what to measure, let the engine place it | Declare which measurements matter as scale-independent intent routed through the planner and corridor solve; never hardcode dimension geometry. | Accepted; epic #867 complete; phase 6 landed (#940) | `test_compiled_plan_boundary.py`, `test_label_provenance.py`, `test_sheet_emit.py`, `test_add_dimension.py` |
 | [0017](0017-recognition-inventory-correspondence-and-measurement-provenance.md) | One recognition result per run; correspondence is evidence-gated | Produce one external immutable recognition result held by Draftwright's per-run cache; require vertical-slice evidence before generalising correspondence, identity, requirements, outcomes, or reconciliation. | Accepted; external cache ownership clarified, extensions gated by #1018 | `test_external_recognition_boundary.py`, `test_recognition_manifest.py`, `test_declared_recognition_gate.py` |

draftwright-0.4.8/docs/reference/recogniser-capabilities.md

@@ -0,0 +1,52 @@
+# Recogniser capability contract
+
+Draftwright consumes the public capability manifest installed with `b123d-recognisers`; it never
+reads a sibling checkout or a package-private file. The matching Draftwright-owned declaration is
+implemented in `draftwright.recogniser_contract` and validated in CI.
+
+The package manifest describes geometry evidence. Draftwright separately declares, for every
+package family, its IR adapter, fluent `Sheet` surface, generated-Sheet behavior, drawing consumer,
+completeness treatment, and documentation. A stage is either `supported`, `deferred`,
+`not-applicable`, or `unsupported`, with the evidence required by that state. This separation lets
+other CAD consumers apply different policy without making Draftwright policy part of the geometry
+library.
+
+## What failures mean
+
+Validation fails closed and names the family and boundary whenever possible:
+
+- **family inventory mismatch** — the installed package added, removed, or renamed a family.
+  Update the package pin deliberately, add or remove the Draftwright declaration, and provide the
+  downstream behavior or an explicit non-supported state.
+- **record schema mismatch** — a consumed record schema changed. Review the record fields and
+  compatibility notes, update the relevant adapter and tests, then pin the accepted schema version.
+- **stale implementation** — a declared adapter, `Sheet` method, emitter, renderer, or completeness
+  function no longer resolves. Repair the implementation reference and its independent behavior
+  evidence; do not merely rename the string.
+- **evidence is missing** — a supported claim points at a deleted test or document. Restore or
+  replace the behavior evidence before changing the path.
+- **unknown state or unsupported format** — the installed contract uses semantics this Draftwright
+  version does not understand. Upgrade the validator before accepting the package version.
+- **geometry-only family invents semantics** — geometry used for critique was incorrectly given an
+  inferred IR/DSL/code-generation/drawing path. Keep it geometry-only unless a separately reviewed
+  Draftwright feature introduces authored semantics and compatibility evidence.
+- **reserved family claims supported downstream semantics** — a family-level `deferred` or
+  `unsupported` disposition still advertises an implemented downstream stage. Either make the
+  family disposition supported with behavior evidence, or defer/disable every semantic stage and
+  retain its tracking issue.
+- **state transition lacks evidence** — a capability was strengthened or weakened without a named
+  Draftwright version, release notes, and compatibility tests. Supply all three as one reviewed
+  transition.
+
+## Adding or changing a recogniser
+
+Land the package record, independent geometry evidence, manifest update, and compatible package
+release first. Then update Draftwright against that immutable release. For each applicable stage,
+add the adapter, declaration, emitted-Sheet round trip, drawing behavior, and completeness evidence;
+for an inapplicable or deferred stage, state why and link its tracking issue. The contract test
+derives package record outputs, converter registries, live `Sheet` methods, and emitter branches
+independently, so copying a new name into the declaration alone cannot make CI pass.
+
+`bosses` is the fully consumed reference family. `repeating-radial-profiles` is the opposite
+reference: it remains geometry-only critique evidence for a separately authored gear declaration,
+with no inferred gear feature added to fill the table.

draftwright-0.4.8/docs/reference/sheet.md

@@ -0,0 +1,35 @@
+# Sheet and fluent handles
+
+`Sheet` is the declared authoring façade. Feature verbs return fluent handles; those handles
+are documented here because they are part of normal use even though their Python names begin
+with an underscore.
+
+## Sheet
+
+::: draftwright.sheet.Sheet
+    options:
+      filters: public
+
+## Hole handle
+
+::: draftwright.sheet._Hole
+    options:
+      filters: public
+
+## Diameter and step handle
+
+::: draftwright.sheet._Dim
+    options:
+      filters: public
+
+## Multi-parameter handle
+
+::: draftwright.sheet._Params
+    options:
+      filters: public
+
+## GD&T control builder
+
+::: draftwright.sheet._Control
+    options:
+      filters: public

draftwright-0.4.8/docs/research/1062-repeating-radial-profile-evidence.md

@@ -0,0 +1,102 @@
+# Repeating Radial Profile Evidence (#1062)
+
+> **Status:** productionised by #1087, 2026-08-09. The executable mutations remain in
+> `tests/test_issue_1058_wheel_profile.py`; the reusable evidence is owned by
+> `recognition/repeating_profiles.py`. No automatic gear semantics are approved by this note.
+
+## Decision
+
+The wheel fixture proves a **closed 13-fold repeating radial outer profile** about its Z
+axis. It does not prove that the profile is a gear, nor does it establish module, pressure
+angle, helix angle, backlash, tooth thickness, quality grade, or manufacturing process.
+
+Keep `unrecognised_defining_geometry` for this part. Do not add an automatic `GearFeature`,
+emit a gear callout, or treat outside/root diameters and repeat count as a complete
+manufacturing definition. The useful next boundary is:
+
+1. reusable geometry-only correspondence for a repeating radial profile; and
+2. a separately designed, explicit declaration of gear requirements and their drawing
+   presentation.
+
+The second may consume the first to check that declared tooth count and axis correspond to
+the solid. Recognition must not manufacture the declaration.
+
+## Pinned Evidence
+
+| Item | Observed fact |
+|---|---|
+| Fixture | `tests/fixtures/issue_1058_wheel_rh.step` |
+| SHA-256 | `4911c06426f0ceeedc198416e058aabc1c1a6a65e9e766eca7efed5484a27cda` |
+| STEP form | AP214, one solid, generic product name `SOLID` |
+| Overall bounds | X -3.8000001..3.7733322; Y -3.8000001..3.8000001; Z -3.8500001..3.8500001 mm |
+| Principal outer boundaries | two, at the opposed Z limits |
+| Boundary topology | one closed 52-edge outer wire on each end face |
+| Edge inventory | 13 circular edges and 39 B-splines |
+| Circular edges | radius 3.8 mm, common XY centre (0, 0) |
+| Rotational correspondence | four complete 13-edge orbits under `2*pi/13` rotation |
+| Orbit roles | one circular-tip orbit and three B-spline orbits |
+
+Both end faces prove the same correspondence despite different edge start and traversal.
+The STEP header and entities contain no gear name, PMI, standard, or parameter metadata.
+
+## What The Proof Establishes
+
+The test samples every curve in each outer wire, then requires a one-to-one mapping of every
+curve under one sector rotation. Curve type, length, and sampled geometry must agree within
+the fixed tolerance. The mapping must be bijective, each orbit must contain exactly 13
+curves, and every endpoint must belong to one connected degree-two cycle.
+
+This is stronger than the existing lint hint. `_radial_outer_arc_count` reports 13 equal,
+equally spaced arcs on a common circle, but explicitly does not claim that the 39 intervening
+B-splines repeat. The complete-wire proof closes that geometric gap without widening the
+semantic claim.
+
+The following mutations fail:
+
+- retaining only the 13 common-circle arcs;
+- altering one intervening B-spline sample while leaving all arcs unchanged;
+- breaking one endpoint so the outer wire is open;
+- changing one sector boundary while preserving a closed cycle; and
+- relying on the wire's original start edge or traversal direction.
+
+The changed-intervening-curve mutation is the decisive guard: an arc-count implementation
+would still pass it.
+
+## Why This Is Not Gear Recognition
+
+Many manufactured profiles can be cyclic without being gears. Even if a human recognises
+the fixture's purpose, the B-rep alone does not uniquely identify the generating standard or
+the requirements needed to reproduce and inspect it. Fitting a plausible standard from 13
+tips and a diameter would turn a guess into normative drawing output.
+
+A truthful technical drawing therefore needs explicit requirements supplied by the author,
+usually including at least the gear system/type, tooth count, module or diametral pitch,
+pressure angle, reference geometry, and the applicable accuracy or inspection requirement.
+The exact public surface and table/callout form need a standards-backed design slice; this
+discovery does not invent them.
+
+## ADR Fit
+
+- **ADR 0013:** the proven repeat is lower-tier, geometry-only evidence. `gear` is an
+  application semantic and must not be smuggled into the recognition record.
+- **ADR 0015:** any future automatic record must enter through the compiler's existing
+  recognition waist. A declared gear requirement belongs on the declared path.
+- **ADR 0017:** if productionised, one orchestration owns the correspondence evidence and
+  consumers project from it. The mutation precedes trust in the guard, and a new identity
+  scheme is not justified by this single case.
+- **ADR 0011:** explicit author intent is the appropriate source for requirements that the
+  B-rep cannot establish.
+
+No ADR amendment is required. No placement decision is made, so ADR 0014 is unaffected.
+
+## Follow-up Slices
+
+1. **Productionised in #1087.** The pure full-wire correspondence is owned by the one
+   recognition orchestration and consumed by physical critique for declared-profile
+   correspondence. It does not clear completeness merely because the repeat exists.
+2. **Design declared gear requirements.** Start from the applicable drawing/gear standards
+   and define the minimum honest declaration, validation, IR, and table/callout output. Include
+   a mismatch diagnostic when declared count or axis disagrees with geometric evidence.
+3. **Only then assess automatic assistance.** Recognition may prefill proven geometric facts
+   such as axis and repeat count for user confirmation. It may not infer the normative gear
+   specification.

{draftwright-0.4.6 → draftwright-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.6"
+version = "0.4.8"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,7 @@ dependencies = [
     "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.14.1",
-    "b123d-recognisers==0.1.0",
+    "b123d-recognisers==0.2.1",
     "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
@@ -69,6 +69,9 @@ include = [
     "src/draftwright",
     "tests",
     "skills",
+    "docs/reference/recogniser-capabilities.md",
+    "docs/reference/sheet.md",
+    "docs/research/1062-repeating-radial-profile-evidence.md",
     "README.md",
     "LICENSE",
     "CHANGELOG.md",

{draftwright-0.4.6 → draftwright-0.4.8}/src/draftwright/_geometry.py

@@ -327,6 +327,33 @@ def _segment_clips_box(p, q, box, pad=0.0) -> bool:
     return _segment_clip_extent(p, q, box, pad=pad) is not None
 
 
+def _convex_polygons_overlap(left, right) -> bool:
+    """Whether two convex page-plane polygons have positive-area overlap.
+
+    The separating-axis test is strict: touching edges/vertices are clear, the
+    same placement convention as :func:`_boxes_overlap`.
+    """
+
+    if len(left) < 3 or len(right) < 3:
+        return False
+    axes: list[tuple[float, float]] = []
+    for points in (left, right):
+        axes.extend(
+            (-(second[1] - first[1]), second[0] - first[0])
+            for first, second in zip(points, (*points[1:], points[0]), strict=True)
+        )
+    for ax, ay in axes:
+        if abs(ax) + abs(ay) <= 1e-12:
+            continue
+        left_projection = [x * ax + y * ay for x, y in left]
+        right_projection = [x * ax + y * ay for x, y in right]
+        if max(left_projection) <= min(right_projection) or max(right_projection) <= min(
+            left_projection
+        ):
+            return False
+    return True
+
+
 def _convex_polygon_overlaps_box(points, box) -> bool:
     """Whether a convex page-plane polygon has positive-area overlap with an AABB.
 
@@ -341,21 +368,63 @@ def _convex_polygon_overlaps_box(points, box) -> bool:
         (box[2], box[3]),
         (box[0], box[3]),
     )
-    axes = [(1.0, 0.0), (0.0, 1.0)]
-    axes.extend(
-        (-(second[1] - first[1]), second[0] - first[0])
-        for first, second in zip(points, (*points[1:], points[0]), strict=True)
+    return _convex_polygons_overlap(points, corners)
+
+
+def _stroke_polygon(first, second, width: float):
+    """The exact swept rectangle for one rendered straight stroke, or ``None``."""
+
+    dx, dy = float(second[0]) - float(first[0]), float(second[1]) - float(first[1])
+    length = math.hypot(dx, dy)
+    half = max(0.0, float(width)) / 2.0
+    if length <= 1e-12 or half <= 0.0:
+        return None
+    vx, vy = -dy / length * half, dx / length * half
+    return (
+        (float(first[0]) + vx, float(first[1]) + vy),
+        (float(second[0]) + vx, float(second[1]) + vy),
+        (float(second[0]) - vx, float(second[1]) - vy),
+        (float(first[0]) - vx, float(first[1]) - vy),
     )
-    for ax, ay in axes:
-        if abs(ax) + abs(ay) <= 1e-12:
-            continue
-        polygon_projection = [x * ax + y * ay for x, y in points]
-        box_projection = [x * ax + y * ay for x, y in corners]
-        if max(polygon_projection) <= min(box_projection) or max(box_projection) <= min(
-            polygon_projection
-        ):
-            return False
-    return True
+
+
+def _leader_ink_polygons(tip, elbow, *, arrow_length: float, line_width: float):
+    """Convex components of a leader's rendered tip→elbow shaft and arrow."""
+
+    dx, dy = float(elbow[0]) - float(tip[0]), float(elbow[1]) - float(tip[1])
+    length = math.hypot(dx, dy)
+    half_line = max(0.0, float(line_width)) / 2.0
+    head_length = max(0.0, float(arrow_length))
+    if length <= 1e-12:
+        half = max(half_line, head_length / 3.0)
+        if half <= 0.0:
+            return ()
+        return (
+            (
+                (float(tip[0]) - half, float(tip[1]) - half),
+                (float(tip[0]) + half, float(tip[1]) - half),
+                (float(tip[0]) + half, float(tip[1]) + half),
+                (float(tip[0]) - half, float(tip[1]) + half),
+            ),
+        )
+
+    ux, uy = dx / length, dy / length
+    vx, vy = -uy, ux
+    polygons = []
+    shaft = _stroke_polygon(tip, elbow, line_width)
+    if shaft is not None:
+        polygons.append(shaft)
+    if head_length > 0.0:
+        half_head = head_length / 3.0
+        base_x, base_y = tip[0] + ux * head_length, tip[1] + uy * head_length
+        polygons.append(
+            (
+                (float(tip[0]), float(tip[1])),
+                (base_x + vx * half_head, base_y + vy * half_head),
+                (base_x - vx * half_head, base_y - vy * half_head),
+            )
+        )
+    return tuple(polygons)
 
 
 def _leader_ink_crosses_box(
@@ -378,41 +447,15 @@ def _leader_ink_crosses_box(
     Touching boundaries are clear, matching :func:`_boxes_overlap` and the placement-side
     semantics of :func:`_segment_crosses_box`.
     """
-    dx, dy = float(elbow[0]) - float(tip[0]), float(elbow[1]) - float(tip[1])
-    length = math.hypot(dx, dy)
-    half_line = max(0.0, float(line_width)) / 2.0
-    head_length = max(0.0, float(arrow_length))
-
-    if length <= 1e-12:
-        half = max(half_line, head_length / 3.0)
-        point_box = (tip[0] - half, tip[1] - half, tip[0] + half, tip[1] + half)
-        return _boxes_overlap(point_box, box)
-
-    ux, uy = dx / length, dy / length
-    vx, vy = -uy, ux
-
-    if half_line > 0.0:
-        shaft = (
-            (tip[0] + vx * half_line, tip[1] + vy * half_line),
-            (elbow[0] + vx * half_line, elbow[1] + vy * half_line),
-            (elbow[0] - vx * half_line, elbow[1] - vy * half_line),
-            (tip[0] - vx * half_line, tip[1] - vy * half_line),
+    return any(
+        _convex_polygon_overlaps_box(polygon, box)
+        for polygon in _leader_ink_polygons(
+            tip,
+            elbow,
+            arrow_length=arrow_length,
+            line_width=line_width,
         )
-        if _convex_polygon_overlaps_box(shaft, box):
-            return True
-
-    if head_length > 0.0:
-        half_head = head_length / 3.0
-        base_x, base_y = tip[0] + ux * head_length, tip[1] + uy * head_length
-        arrow = (
-            (tip[0], tip[1]),
-            (base_x + vx * half_head, base_y + vy * half_head),
-            (base_x - vx * half_head, base_y - vy * half_head),
-        )
-        if _convex_polygon_overlaps_box(arrow, box):
-            return True
-
-    return False
+    )
 
 
 def _segments_cross_or_overlap(a1, a2, b1, b2) -> bool:

{draftwright-0.4.6 → draftwright-0.4.8}/src/draftwright/analysis.py

@@ -630,7 +630,7 @@ def _analyse(
         # by #1025). Both callers deriving this separately let lint project over a different
         # ladder than the model was sized from — which is exactly the divergence one waist is
         # supposed to prevent.
-        step_zs = recognition.step_ladder(bb)
+        step_zs = recognition.step_ladder_for_z_span(bb.min.Z, bb.max.Z)
     # The aggregate owns the shared substrate from here on.  Rebind the local projection so
     # model construction, Analysis and the finished BuildState all consume the same inventory
     # object rather than parallel list/tuple wrappers that merely happen to contain equal data.

{draftwright-0.4.6 → draftwright-0.4.8}/src/draftwright/annotations/_common.py

@@ -786,6 +786,43 @@ def dim_footprint(p1, p2, side, distance, draft, label):
     return (min(xs) - pad, min(ys) - pad, max(xs) + pad, max(ys) + pad)
 
 
+def leader_callout_geometry(tip, elbow, draft, *, text_side="auto", callout_box=None):
+    """Exact cheap label box and line segments for a callout-bearing ``Leader``.
+
+    This is the position-dependent subset of :func:`leader_footprint` needed by
+    the shared feature-leader solve.  It mirrors the helper's two input edges and
+    the translation of the already-measured callout sketch, without constructing
+    the arrow/shelf OCC faces.  ``None`` matches the helper's forced-side guard.
+    """
+
+    gap = draft.pad_around_text
+    if text_side == "auto":
+        shelf_dir = 1.0 if elbow[0] >= tip[0] else -1.0
+    else:
+        shelf_dir = 1.0 if text_side == "right" else -1.0
+    shelf_end = (elbow[0] + shelf_dir * gap, elbow[1])
+    segments = (
+        ((float(tip[0]), float(tip[1])), (float(elbow[0]), float(elbow[1]))),
+        ((float(elbow[0]), float(elbow[1])), (float(shelf_end[0]), float(shelf_end[1]))),
+    )
+
+    label_box = None
+    if callout_box is not None:
+        cw = callout_box[2] - callout_box[0]
+        ch = callout_box[3] - callout_box[1]
+        if shelf_dir > 0:
+            cx0, cx1 = shelf_end[0], shelf_end[0] + cw
+        else:
+            cx0, cx1 = shelf_end[0] - cw, shelf_end[0]
+        cy0, cy1 = elbow[1] - ch / 2.0, elbow[1] + ch / 2.0
+        label_box = (cx0, cy0, cx1, cy1)
+        if text_side != "auto" and _segment_crosses_box(
+            (tip[0], tip[1]), (elbow[0], elbow[1]), label_box
+        ):
+            return None
+    return label_box, segments
+
+
 def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     """Analytical page-mm AABB ``(x0, y0, x1, y1)`` of the :class:`Leader` that
     ``Leader(tip, elbow, label="", draft, text_side=…, callout=…)`` would build —
@@ -811,12 +848,17 @@ def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     that runs the shaft through the label — so callers omit the candidate exactly
     as the built-geometry probe's except-handler did.
     """
-    gap = draft.pad_around_text
-    if text_side == "auto":
-        shelf_dir = 1.0 if elbow[0] >= tip[0] else -1.0
-    else:
-        shelf_dir = 1.0 if text_side == "right" else -1.0
-    shelf_end_x = elbow[0] + shelf_dir * gap
+    geometry = leader_callout_geometry(
+        tip,
+        elbow,
+        draft,
+        text_side=text_side,
+        callout_box=callout_box,
+    )
+    if geometry is None:
+        return None
+    label_box, segments = geometry
+    shelf_end_x = segments[1][1][0]
 
     # The arrowhead bounds the shaft only while it is the wider of the two; a style with a
     # heavy line and a small arrow inverts that, and a diagonal shaft then pushes its stroke
@@ -829,22 +871,9 @@ def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     xs += [min(elbow[0], shelf_end_x) - half_line, max(elbow[0], shelf_end_x) + half_line]
     ys += [elbow[1] - half_line, elbow[1] + half_line]
 
-    if callout_box is not None:
-        cw = callout_box[2] - callout_box[0]
-        ch = callout_box[3] - callout_box[1]
-        if shelf_dir > 0:
-            cx0, cx1 = shelf_end_x, shelf_end_x + cw
-        else:
-            cx0, cx1 = shelf_end_x - cw, shelf_end_x
-        cy0, cy1 = elbow[1] - ch / 2.0, elbow[1] + ch / 2.0
-        # Leader raises rather than draw a shaft through its own label; a forced side
-        # is the only way to get there, matching helpers' own guard condition.
-        if text_side != "auto" and _segment_crosses_box(
-            (tip[0], tip[1]), (elbow[0], elbow[1]), (cx0, cy0, cx1, cy1)
-        ):
-            return None
-        xs += [cx0, cx1]
-        ys += [cy0, cy1]
+    if label_box is not None:
+        xs += [label_box[0], label_box[2]]
+        ys += [label_box[1], label_box[3]]
 
     return (min(xs), min(ys), max(xs), max(ys))
 
@@ -970,6 +999,19 @@ def occupancy_boxes(o, stroke_pad=None):
 _STROKE_PAD = 1.2
 
 
+def annotation_obstacle_boxes(dwg, annotation):
+    """One annotation's obstacle boxes under the shared strip-occupancy policy.
+
+    Candidate-based placers use this before an annotation is registered; factoring
+    the preset-aware stroke pad here keeps those candidate conflicts identical to
+    the boxes :func:`strip_obstacles` will expose after placement (#740).
+    """
+
+    arrow_length = getattr(getattr(dwg, "draft", None), "arrow_length", None)
+    pad = max(_STROKE_PAD, arrow_length / 2) if arrow_length else _STROKE_PAD
+    return occupancy_boxes(annotation, stroke_pad=pad)
+
+
 def strip_obstacles(dwg, view=None, *, crossable=(), named=False):
     """The COMPLETE occupancy for strip placement (ADR 0009): every placed
     annotation's full rendered footprint, optionally restricted to *view*, minus
@@ -1005,9 +1047,6 @@ def strip_obstacles(dwg, view=None, *, crossable=(), named=False):
 
     The occupancy source for the collect-then-solve carve — every migrated renderer's
     ``place_strip_candidates`` call wires this in (#321/#150/P3)."""
-    # Preset-aware stroke pad (#688 review): arrowheads scale with font_size.
-    al = getattr(getattr(dwg, "draft", None), "arrow_length", None)
-    pad = max(_STROKE_PAD, al / 2) if al else _STROKE_PAD
     boxes: list = []
     for name, o in dwg.iter_annotations():
         if view is not None:
@@ -1016,7 +1055,7 @@ def strip_obstacles(dwg, view=None, *, crossable=(), named=False):
                 continue  # owned by a different ortho view → its own (disjoint) block
         if type(o).__name__ in crossable:
             continue  # this consumer may cross it (centre lines/marks for a dim)
-        occ = occupancy_boxes(o, stroke_pad=pad)  # decomposed, not one hull (#685)
+        occ = annotation_obstacle_boxes(dwg, o)  # decomposed, not one hull (#685/#740)
         boxes.extend(((name, b) for b in occ) if named else occ)
     return boxes
 
@@ -1485,6 +1524,11 @@ class PlacementContext:
     # 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)
+    # Compatible automatic/deferred feature-callout jobs collected across the
+    # hole + post-drain machined passes (#1166). ``None`` is intentional: direct
+    # renderer calls and finished-sheet live verbs keep their immediate behavior;
+    # the orchestrator/finalize paths opt in with ``[]`` and drain once.
+    feature_leaders: list | None = None
     # The opt-in solve-trace recorder (#736) — a :class:`SolveTrace` threaded off the
     # drawing's build state by both entry paths, or ``None`` (the default: tracing off,
     # every hook a bare None check). Ctx state, not a module global, so the finalize